rebase: add controller runtime dependency

this commits add the controller runtime and its dependency to the vendor. Signed-off-by: Madhu Rajanna <madhupr007@gmail.com>
2024-12-18 02:50:30 +00:00 · 2020-10-21 11:19:41 +05:30 · 2020-10-21 11:19:41 +05:30 · 5af3fe5deb
commit 5af3fe5deb
parent 14700b89d1
101 changed files with 11946 additions and 230 deletions
--- a/go.mod
+++ b/go.mod
@ -6,9 +6,10 @@ require (
 	github.com/ceph/go-ceph v0.6.0
 	github.com/container-storage-interface/spec v1.3.0
 	github.com/docker/spdystream v0.0.0-20181023171402-6480d4af844c // indirect
 	github.com/go-logr/logr v0.2.1 // indirect
 	github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e // indirect
 	github.com/golang/protobuf v1.3.5
-	github.com/googleapis/gnostic v0.3.1 // indirect
+	github.com/googleapis/gnostic v0.4.0 // indirect
 	github.com/grpc-ecosystem/go-grpc-middleware v1.2.0
 	github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0
 	github.com/hashicorp/golang-lru v0.5.4 // indirect
@ -39,6 +40,7 @@ require (
 	k8s.io/kubectl v0.18.6 // indirect
 	k8s.io/kubernetes v1.18.6
 	k8s.io/utils v0.0.0-20200324210504-a9aa75ae1b89
 	sigs.k8s.io/controller-runtime v0.6.0
 )
 replace (
--- a/go.sum
+++ b/go.sum
@ -1,5 +1,6 @@
 bitbucket.org/bertimus9/systemstat v0.0.0-20180207000608-0eeff89b0690/go.mod h1:Ulb78X89vxKYgdL24HMTiXYHlyHEvruOj1ZPlqeNEZM=
 cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
 cloud.google.com/go v0.38.0 h1:ROfEUZz+Gh5pa62DJWXSaonyu3StP6EA6lPEXPI6mCo=
 cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU=
 github.com/Azure/azure-sdk-for-go v35.0.0+incompatible/go.mod h1:9XXNKU+eRnpl9moKnB4QOLf1HestfXbmab5FXxiDBjc=
 github.com/Azure/go-ansiterm v0.0.0-20170929234023-d6e3b3328b78/go.mod h1:LmzpDX56iTiv29bbRTIsUNlaFfuhWRQBWjQdVyAevI8=
@ -128,7 +129,9 @@ github.com/elazarl/goproxy v0.0.0-20180725130230-947c36da3153/go.mod h1:/Zj4wYkg
 github.com/emicklei/go-restful v0.0.0-20170410110728-ff4f55a20633/go.mod h1:otzb+WCGbkyDHkqmQmT5YD2WR4BBwUdeQoFo8l/7tVs=
 github.com/emicklei/go-restful v2.9.5+incompatible h1:spTtZBk5DYEvbxMVutUuTyh1Ao2r4iyvLdACqsl/Ljk=
 github.com/emicklei/go-restful v2.9.5+incompatible/go.mod h1:otzb+WCGbkyDHkqmQmT5YD2WR4BBwUdeQoFo8l/7tVs=
 github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473 h1:4cmBvAEBNJaGARUEs3/suWRyfyBfhf7I60WBZq+bv2w=
 github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
 github.com/envoyproxy/protoc-gen-validate v0.1.0 h1:EQciDnbrYxy13PgWoY8AqoxGiPrpgBZ1R8UNe3ddc+A=
 github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
 github.com/euank/go-kmsg-parser v2.0.0+incompatible/go.mod h1:MhmAMZ8V4CYH4ybgdRwPr2TU5ThnS43puaKEMpja1uw=
 github.com/evanphx/json-patch v4.2.0+incompatible h1:fUDGZCv/7iAN7u0puUVhvKCcsR6vRfwrJatElLBEf0I=
@ -160,6 +163,10 @@ github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V
 github.com/go-logr/logr v0.1.0/go.mod h1:ixOQHD9gLJUVQQ2ZOR7zLEifBX6tGkNJF4QyIY7sIas=
 github.com/go-logr/logr v0.2.0 h1:QvGt2nLcHH0WK9orKa+ppBPAxREcH364nPUedEpK0TY=
 github.com/go-logr/logr v0.2.0/go.mod h1:z6/tIYblkpsD+a4lm/fGIIU9mZ+XfAiaFtq7xTgseGU=
 github.com/go-logr/logr v0.2.1 h1:fV3MLmabKIZ383XifUjFSwcoGee0v9qgPp8wy5svibE=
 github.com/go-logr/logr v0.2.1/go.mod h1:z6/tIYblkpsD+a4lm/fGIIU9mZ+XfAiaFtq7xTgseGU=
 github.com/go-logr/zapr v0.1.0 h1:h+WVe9j6HAA01niTJPA/kKH0i7e0rLZBCwauQFcRE54=
 github.com/go-logr/zapr v0.1.0/go.mod h1:tabnROwaDl0UNxkVeFRbY8bwB37GwRv0P8lg6aAiEnk=
 github.com/go-ole/go-ole v1.2.1/go.mod h1:7FAglXiTm7HKlQRDeOQ6ZNUHidzCWXuZWq/1dTyBNF8=
 github.com/go-openapi/analysis v0.0.0-20180825180245-b006789cd277/go.mod h1:k70tL6pCuVxPJOHXQ+wIac1FUrvNkHolPie/cLEU6hI=
 github.com/go-openapi/analysis v0.17.0/go.mod h1:IowGgpVeD0vNm45So8nr+IcQ3pxVtpRoBWb8PVZO0ik=
@ -297,6 +304,8 @@ github.com/googleapis/gnostic v0.1.0/go.mod h1:sJBsCZ4ayReDTBIg8b9dl28c5xFWyhBTV
 github.com/googleapis/gnostic v0.2.0/go.mod h1:sJBsCZ4ayReDTBIg8b9dl28c5xFWyhBTVRp3pOg5EKY=
 github.com/googleapis/gnostic v0.3.1 h1:WeAefnSUHlBb0iJKwxFDZdbfGwkd7xRNuV+IpXMJhYk=
 github.com/googleapis/gnostic v0.3.1/go.mod h1:on+2t9HRStVgn95RSsFWFz+6Q0Snyqv1awfrALZdbtU=
 github.com/googleapis/gnostic v0.4.0 h1:BXDUo8p/DaxC+4FJY/SSx3gvnx9C1VdHNgaUkiEL5mk=
 github.com/googleapis/gnostic v0.4.0/go.mod h1:on+2t9HRStVgn95RSsFWFz+6Q0Snyqv1awfrALZdbtU=
 github.com/gophercloud/gophercloud v0.1.0/go.mod h1:vxM41WHh5uqHVBMZHzuwNOHh8XEoIEcSTewFxm1c5g8=
 github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
 github.com/gorilla/context v1.1.1/go.mod h1:kBGZzfjB9CEq2AlWe17Uuf7NDRt0dE0s8S51q0aT7Yg=
@ -327,6 +336,7 @@ github.com/heketi/tests v0.0.0-20151005000721-f3775cbcefd6/go.mod h1:xGMAM8JLi7U
 github.com/hpcloud/tail v1.0.0 h1:nfCOvKYfkgYP8hkirhJocXT2+zOD8yUNjXaWfTlyFKI=
 github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
 github.com/imdario/mergo v0.3.5/go.mod h1:2EnlNZ0deacrJVfApfmtdGgDfMuh/nq6Ok1EcJh5FfA=
 github.com/imdario/mergo v0.3.6/go.mod h1:2EnlNZ0deacrJVfApfmtdGgDfMuh/nq6Ok1EcJh5FfA=
 github.com/imdario/mergo v0.3.9 h1:UauaLniWCFHWd+Jp9oCEkTBj8VO/9DKg3PV3VCNMDIg=
 github.com/imdario/mergo v0.3.9/go.mod h1:2EnlNZ0deacrJVfApfmtdGgDfMuh/nq6Ok1EcJh5FfA=
 github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
@ -443,6 +453,7 @@ github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1Cpa
 github.com/onsi/gomega v1.5.0/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
 github.com/onsi/gomega v1.7.0/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
 github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY=
 github.com/onsi/gomega v1.8.1/go.mod h1:Ho0h+IUsWyvy1OpqCwxlQ/21gkhVunqlU8fDGcoTdcA=
 github.com/onsi/gomega v1.9.0 h1:R1uwffexN6Pr340GtYRIdZmAiN4J+iw6WG4wog1DUXg=
 github.com/onsi/gomega v1.9.0/go.mod h1:Ho0h+IUsWyvy1OpqCwxlQ/21gkhVunqlU8fDGcoTdcA=
 github.com/opencontainers/go-digest v1.0.0-rc1 h1:WzifXhOVOEOuFYOJAW6aQqW0TooG2iki3E3Ii+WN7gQ=
@ -739,6 +750,8 @@ golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8T
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 gomodules.xyz/jsonpatch/v2 v2.0.1 h1:xyiBuvkD2g5n7cYzx6u2sxQvsAy4QJsZFCzGVdzOXZ0=
 gomodules.xyz/jsonpatch/v2 v2.0.1/go.mod h1:IhYNNY4jnS53ZnfE4PAmpKtDpTCj1JFXc+3mwe7XcUU=
 gonum.org/v1/gonum v0.0.0-20180816165407-929014505bf4/go.mod h1:Y+Yx5eoAFn32cQvJDxZx5Dpnq+c3wtXuadVZAcxbbBo=
 gonum.org/v1/gonum v0.0.0-20190331200053-3d26580ed485/go.mod h1:2ltnJ7xHfj0zHS40VVPYEAAMTa3ZGguvHGBSJeRWqE0=
 gonum.org/v1/gonum v0.6.2/go.mod h1:9mxDZsDKxgMAuccQkewq682L+0eCu4dCN2yonUJTCLU=
@ -805,6 +818,7 @@ honnef.co/go/tools v0.0.1-2019.2.3 h1:3JgtbtFHMiCmsznwGVTUWbgGov+pVqnlf1dEJTNAXe
 honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg=
 k8s.io/api v0.18.6 h1:osqrAXbOQjkKIWDTjrqxWQ3w0GkKb1KA1XkUGHHYpeE=
 k8s.io/api v0.18.6/go.mod h1:eeyxr+cwCjMdLAmr2W3RyDI0VvTawSg/3RFFBEnmZGI=
 k8s.io/apiextensions-apiserver v0.18.6 h1:vDlk7cyFsDyfwn2rNAO2DbmUbvXy5yT5GE3rrqOzaMo=
 k8s.io/apiextensions-apiserver v0.18.6/go.mod h1:lv89S7fUysXjLZO7ke783xOwVTm6lKizADfvUM/SS/M=
 k8s.io/apimachinery v0.18.6 h1:RtFHnfGNfd1N0LeSrKCUznz5xtUP1elRGvHJbL3Ntag=
 k8s.io/apimachinery v0.18.6/go.mod h1:OaXp26zu/5J7p0f92ASynJa1pZo06YlV9fG7BoWbCko=
@ -868,6 +882,8 @@ rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0=
 rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA=
 sigs.k8s.io/apiserver-network-proxy/konnectivity-client v0.0.7 h1:uuHDyjllyzRyCIvvn0OBjiRB0SgBZGqHNYAmjR7fO50=
 sigs.k8s.io/apiserver-network-proxy/konnectivity-client v0.0.7/go.mod h1:PHgbrJT7lCHcxMU+mDHEm+nx46H4zuuHZkDP6icnhu0=
 sigs.k8s.io/controller-runtime v0.6.0 h1:Fzna3DY7c4BIP6KwfSlrfnj20DJ+SeMBK8HSFvOk9NM=
 sigs.k8s.io/controller-runtime v0.6.0/go.mod h1:CpYf5pdNY/B352A1TFLAS2JVSlnGQ5O2cftPHndTroo=
 sigs.k8s.io/kustomize v2.0.3+incompatible/go.mod h1:MkjgH3RdOWrievjo6c9T245dYlB5QeXV4WCbnt/PEpU=
 sigs.k8s.io/structured-merge-diff/v3 v3.0.0-20200116222232-67a7b8c61874/go.mod h1:PlARxl6Hbt/+BC80dRLi1qAmnMqwqDg62YvvVkZjemw=
 sigs.k8s.io/structured-merge-diff/v3 v3.0.0 h1:dOmIZBMfhcHS09XZkMyUgkq5trg3/jRyJYFZUiaOp8E=
--- a/vendor/github.com/go-logr/logr/README.md
+++ b/vendor/github.com/go-logr/logr/README.md
@ -41,6 +41,7 @@ There are implementations for the following logging libraries:
 - **log** (the Go standard library logger):
  [stdr](https://github.com/go-logr/stdr)
 - **github.com/sirupsen/logrus**: [logrusr](https://github.com/bombsimon/logrusr)
 - **github.com/wojas/genericr**: [genericr](https://github.com/wojas/genericr) (makes it easy to implement your own backend)
 # FAQ
--- a/vendor/github.com/go-logr/logr/logr.go
+++ b/vendor/github.com/go-logr/logr/logr.go
@ -78,9 +78,9 @@ limitations under the License.
 // Each log message from a Logger has four types of context:
 // logger name, log verbosity, log message, and the named values.
 //
-// The Logger name constists of a series of name "segments" added by successive
+// The Logger name consists of a series of name "segments" added by successive
 // calls to WithName.  These name segments will be joined in some way by the
-// underlying implementation.  It is strongly reccomended that name segements
+// underlying implementation.  It is strongly recommended that name segments
 // contain simple identifiers (letters, digits, and hyphen), and do not contain
 // characters that could muddle the log output or confuse the joining operation
 // (e.g.  whitespace, commas, periods, slashes, brackets, quotes, etc).
@ -91,8 +91,8 @@ limitations under the License.
 // and log messages for users to filter on.  It's illegal to pass a log level
 // below zero.
 //
-// The log message consists of a constant message attached to the the log line.
+// The log message consists of a constant message attached to the log line.
-// This should generally be a simple description of what's occuring, and should
+// This should generally be a simple description of what's occurring, and should
 // never be a format string.
 //
 // Variable information can then be attached using named values (key/value
@ -125,7 +125,7 @@ limitations under the License.
 // - `"ts"`: the timestamp for a log line.
 //
 // Implementations are encouraged to make use of these keys to represent the
-// above concepts, when neccessary (for example, in a pure-JSON output form, it
+// above concepts, when necessary (for example, in a pure-JSON output form, it
 // would be necessary to represent at least message and timestamp as ordinary
 // named values).
 package logr
@ -171,8 +171,12 @@ type Logger interface {
 	// WithName adds a new element to the logger's name.
 	// Successive calls with WithName continue to append
-	// suffixes to the logger's name.  It's strongly reccomended
+	// suffixes to the logger's name.  It's strongly recommended
 	// that name segments contain only letters, digits, and hyphens
 	// (see the package documentation for more information).
 	WithName(name string) Logger
 }
 // InfoLogger provides compatibility with code that relies on the v0.1.0 interface
 // Deprecated: use Logger instead. This will be removed in a future release.
 type InfoLogger = Logger
--- a/vendor/github.com/googleapis/gnostic/OpenAPIv2/OpenAPIv2.pb.go
+++ b/vendor/github.com/googleapis/gnostic/OpenAPIv2/OpenAPIv2.pb.go
@ -5026,201 +5026,200 @@ func init() {
 func init() { proto.RegisterFile("OpenAPIv2/OpenAPIv2.proto", fileDescriptor_336adc04ae589d92) }
 var fileDescriptor_336adc04ae589d92 = []byte{
-	// 3129 bytes of a gzipped FileDescriptorProto
+	// 3108 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x3b, 0x4b, 0x73, 0x1c, 0x57,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xec, 0x1b, 0x4d, 0x73, 0x1c, 0x57,
-	0xd5, 0xf3, 0x7e, 0x1c, 0x69, 0x46, 0xa3, 0x96, 0x2c, 0xb7, 0x24, 0xc7, 0x71, 0xe4, 0x3c, 0x6c,
+	0x31, 0xab, 0xfd, 0xee, 0xd5, 0xae, 0x56, 0x23, 0x59, 0x5e, 0x49, 0x8e, 0xe3, 0x28, 0x5f, 0x8e,
-	0xe7, 0xb3, 0x9c, 0x4f, 0x29, 0x48, 0x05, 0x2a, 0x05, 0xf2, 0xab, 0xc6, 0xc4, 0x44, 0x4a, 0xcb,
+	0x43, 0xe4, 0xa0, 0x14, 0xa4, 0x02, 0x45, 0x81, 0x1c, 0xdb, 0x15, 0x13, 0x13, 0x29, 0x23, 0x27,
-	0x0e, 0x09, 0x04, 0xba, 0xae, 0x66, 0xee, 0x48, 0x9d, 0x74, 0xf7, 0x6d, 0x77, 0xf7, 0xc8, 0x1a,
+	0x10, 0x08, 0x4c, 0x8d, 0x76, 0xdf, 0x4a, 0x93, 0xec, 0xce, 0xac, 0x67, 0x66, 0x65, 0x89, 0x03,
-	0x16, 0x2c, 0xa0, 0x8a, 0x35, 0x50, 0x59, 0x53, 0x15, 0x16, 0x14, 0x55, 0x59, 0xb0, 0x62, 0xc5,
+	0x07, 0xa8, 0xe2, 0x0c, 0x54, 0xce, 0x54, 0xc1, 0x81, 0xa2, 0x2a, 0x07, 0x4e, 0x9c, 0xf8, 0x03,
-	0x1f, 0x60, 0xc7, 0x3f, 0x60, 0x0d, 0x5b, 0xaa, 0x58, 0x51, 0x3c, 0xea, 0xbe, 0xfa, 0x31, 0x7d,
+	0xdc, 0xf8, 0x07, 0x9c, 0xe1, 0x4a, 0x15, 0x27, 0x8a, 0x8f, 0x7e, 0x5f, 0xf3, 0xf9, 0x66, 0x76,
-	0x7b, 0x1e, 0x96, 0x0b, 0x28, 0xd0, 0x6a, 0xe6, 0xde, 0x73, 0xee, 0xb9, 0xa7, 0x4f, 0x9f, 0xd7,
+	0xc7, 0x72, 0x01, 0x05, 0x3a, 0xed, 0xce, 0xeb, 0x7e, 0xfd, 0xfa, 0xf5, 0x74, 0xf7, 0xeb, 0x8f,
-	0x3d, 0xe7, 0x36, 0xac, 0xef, 0x79, 0xd8, 0xdd, 0xdd, 0x7f, 0x70, 0xb2, 0x73, 0x2b, 0xfa, 0xb7,
+	0x37, 0xb0, 0xbe, 0x37, 0x21, 0xf6, 0xee, 0xfe, 0xbd, 0x93, 0x9d, 0x9b, 0xc1, 0xbf, 0xed, 0x89,
-	0xed, 0xf9, 0x24, 0x24, 0x1a, 0x10, 0x0f, 0xbb, 0xc8, 0xb3, 0xb6, 0x4f, 0x76, 0x36, 0xd6, 0x8f,
+	0xeb, 0xf8, 0x8e, 0x06, 0x0e, 0x0e, 0x98, 0x13, 0x6b, 0xfb, 0x64, 0x67, 0x63, 0xfd, 0xc8, 0x71,
-	0x08, 0x39, 0xb2, 0xf1, 0x2d, 0x06, 0x39, 0x1c, 0x0e, 0x6e, 0x21, 0x77, 0xc4, 0xd1, 0xb6, 0x1c,
+	0x8e, 0x46, 0xe4, 0x26, 0x83, 0x1c, 0x4e, 0x87, 0x37, 0x4d, 0xfb, 0x8c, 0xa3, 0x6d, 0x8d, 0xa1,
-	0xd0, 0x77, 0xfb, 0x7d, 0x2b, 0xb4, 0x88, 0x8b, 0xec, 0x7d, 0x9f, 0x78, 0xd8, 0x0f, 0x2d, 0x1c,
+	0xb7, 0x3b, 0x18, 0x58, 0xbe, 0xe5, 0xd8, 0xe6, 0x68, 0xdf, 0xc5, 0x49, 0xae, 0x6f, 0x11, 0xef,
-	0x3c, 0x08, 0xb1, 0xa3, 0xfd, 0x1f, 0xd4, 0x82, 0xde, 0x31, 0x76, 0x90, 0x5e, 0xbc, 0x52, 0xbc,
+	0x9e, 0x4f, 0xc6, 0xda, 0xe7, 0xa0, 0xe6, 0xf5, 0x8f, 0xc9, 0xd8, 0xec, 0x95, 0xae, 0x95, 0xae,
-	0xb6, 0xb0, 0xa3, 0x6d, 0xc7, 0x34, 0xb7, 0x0f, 0x18, 0xa4, 0x5b, 0x30, 0x04, 0x8e, 0xb6, 0x01,
+	0xb7, 0x76, 0xb4, 0xed, 0x90, 0xe6, 0xf6, 0x01, 0x83, 0xbc, 0xfd, 0x94, 0x2e, 0x70, 0xb4, 0x0d,
-	0xf5, 0x43, 0x42, 0x6c, 0x8c, 0x5c, 0xbd, 0x74, 0xa5, 0x78, 0xad, 0xd1, 0x2d, 0x18, 0x72, 0xe2,
+	0xa8, 0x1f, 0x3a, 0xce, 0x88, 0x98, 0x76, 0x6f, 0x01, 0xd1, 0x1b, 0x08, 0x92, 0x03, 0xb7, 0xea,
-	0x76, 0x1d, 0xaa, 0xc4, 0xc5, 0x64, 0xb0, 0x75, 0x0f, 0xca, 0xbb, 0xee, 0x48, 0xbb, 0x01, 0xd5,
+	0x50, 0x75, 0x6c, 0xe2, 0x0c, 0xb7, 0xee, 0x40, 0x79, 0xd7, 0x3e, 0xd3, 0x6e, 0x40, 0xf5, 0xc4,
-	0x13, 0x64, 0x0f, 0xb1, 0x20, 0xbc, 0xba, 0xcd, 0x19, 0xdc, 0x96, 0x0c, 0x6e, 0xef, 0xba, 0x23,
+	0x1c, 0x4d, 0x89, 0x20, 0xbc, 0xba, 0xcd, 0x19, 0xdc, 0x96, 0x0c, 0x6e, 0x23, 0x92, 0xce, 0x51,
-	0x83, 0xa3, 0x68, 0x1a, 0x54, 0x46, 0xc8, 0xb1, 0x19, 0xd1, 0xa6, 0xc1, 0xfe, 0x6f, 0x7d, 0x51,
+	0x34, 0x0d, 0x2a, 0x67, 0xe6, 0x78, 0xc4, 0x88, 0x36, 0x75, 0xf6, 0x7f, 0xeb, 0xb3, 0x12, 0x74,
-	0x84, 0xf6, 0xae, 0x67, 0xbd, 0x8b, 0x47, 0x07, 0xb8, 0x37, 0xf4, 0xad, 0x70, 0x44, 0xd1, 0xc2,
+	0x76, 0x27, 0xd6, 0x3b, 0xe4, 0xec, 0x80, 0xf4, 0xa7, 0xae, 0xe5, 0x9f, 0x51, 0x34, 0xff, 0x6c,
-	0x91, 0xc7, 0x29, 0x36, 0x0d, 0xf6, 0x9f, 0xce, 0xb9, 0xc8, 0xc1, 0x72, 0x29, 0xfd, 0xaf, 0xb5,
+	0xc2, 0x29, 0x22, 0x1a, 0xfd, 0x4f, 0xc7, 0x6c, 0x73, 0x4c, 0xe4, 0x54, 0xfa, 0x5f, 0xeb, 0xc0,
-	0xa1, 0x64, 0xb9, 0x7a, 0x99, 0xcd, 0x94, 0x2c, 0x57, 0xbb, 0x02, 0x0b, 0x7d, 0x1c, 0xf4, 0x7c,
+	0x82, 0x65, 0xf7, 0xca, 0x6c, 0x04, 0xff, 0x69, 0xd7, 0xa0, 0x35, 0x20, 0x5e, 0xdf, 0xb5, 0x26,
-	0xcb, 0xa3, 0x32, 0xd0, 0x2b, 0x0c, 0x90, 0x9c, 0xd2, 0xbe, 0x06, 0x9d, 0x13, 0xec, 0xf6, 0x89,
+	0x54, 0x06, 0xbd, 0x0a, 0x03, 0x44, 0x87, 0xb4, 0xaf, 0x42, 0xf7, 0x84, 0xd8, 0x03, 0xc7, 0x35,
-	0x6f, 0xe2, 0xd3, 0x10, 0xbb, 0x01, 0x45, 0xab, 0x5e, 0x29, 0x33, 0xbe, 0x13, 0x02, 0x79, 0x0f,
+	0xc8, 0xa9, 0x4f, 0x6c, 0x8f, 0xa2, 0x55, 0xaf, 0x95, 0x19, 0xdf, 0x11, 0x81, 0xbc, 0x8b, 0xd4,
-	0x39, 0xb8, 0x4f, 0xf9, 0x5e, 0xe2, 0xd8, 0xf7, 0x24, 0xf2, 0xd6, 0x67, 0x45, 0xd8, 0xbc, 0x8d,
+	0x07, 0x94, 0xef, 0x25, 0x8e, 0x7d, 0x47, 0x22, 0x6f, 0x7d, 0x5a, 0x82, 0xcd, 0x5b, 0xa6, 0x67,
-	0x02, 0xab, 0xb7, 0x3b, 0x0c, 0x8f, 0xb1, 0x1b, 0x5a, 0x3d, 0x44, 0x09, 0x4f, 0x64, 0x7d, 0x8c,
+	0xf5, 0x77, 0xa7, 0xfe, 0x31, 0xb1, 0x7d, 0xab, 0x6f, 0x52, 0xc2, 0xb9, 0xac, 0x27, 0xd8, 0x5a,
-	0xad, 0xd2, 0x6c, 0x6c, 0x95, 0xe7, 0x61, 0xeb, 0x0f, 0x45, 0x68, 0xdd, 0x26, 0xfd, 0xd1, 0x3e,
+	0x98, 0x8f, 0xad, 0x72, 0x11, 0xb6, 0xfe, 0x58, 0x82, 0xf6, 0x2d, 0x67, 0x70, 0xb6, 0x6f, 0xba,
-	0xf2, 0x91, 0x83, 0x43, 0xec, 0x8f, 0x6f, 0x5a, 0xcc, 0x6e, 0x3a, 0x8b, 0x44, 0x37, 0xa0, 0xe1,
+	0x88, 0xe3, 0x13, 0x37, 0xb9, 0x68, 0x29, 0xbd, 0xe8, 0x3c, 0x12, 0xdd, 0x80, 0x86, 0x4b, 0x1e,
-	0xe3, 0x27, 0x43, 0xcb, 0xc7, 0x7d, 0x26, 0xce, 0x86, 0x11, 0x8d, 0xb5, 0x1b, 0x91, 0x4a, 0x55,
+	0x4e, 0x2d, 0x97, 0x0c, 0x98, 0x38, 0x1b, 0x7a, 0xf0, 0x8c, 0x2f, 0x5e, 0xaa, 0x54, 0x35, 0x4b,
-	0xf3, 0x54, 0x2a, 0x52, 0x28, 0xd5, 0x03, 0xd6, 0xe6, 0x79, 0xc0, 0x1f, 0x17, 0xa1, 0x7e, 0x87,
+	0xa5, 0x02, 0x85, 0x52, 0x6d, 0xb0, 0x56, 0x64, 0x83, 0x3f, 0x2e, 0x41, 0xfd, 0x2d, 0xc7, 0xf6,
-	0xb8, 0x21, 0xea, 0x85, 0x11, 0xe3, 0xc5, 0x04, 0xe3, 0x1d, 0x28, 0x0f, 0x7d, 0xa9, 0x58, 0xf4,
+	0xcd, 0xbe, 0x1f, 0x30, 0x5e, 0x8a, 0x30, 0xde, 0x85, 0xf2, 0xd4, 0x95, 0x8a, 0x45, 0xff, 0x6a,
-	0xaf, 0xb6, 0x0a, 0x55, 0xec, 0x20, 0xcb, 0x16, 0x4f, 0xc3, 0x07, 0x4a, 0x46, 0x2a, 0xf3, 0x30,
+	0xab, 0x50, 0xc5, 0x95, 0xad, 0x91, 0xd8, 0x0d, 0x7f, 0x50, 0x32, 0x52, 0x29, 0xc2, 0xc8, 0x03,
-	0xf2, 0x08, 0xea, 0x77, 0xf1, 0x00, 0x0d, 0xed, 0x50, 0x7b, 0x00, 0x17, 0x50, 0x64, 0x6f, 0xa6,
+	0xa8, 0xdf, 0x26, 0x43, 0x73, 0x3a, 0xf2, 0xb5, 0x7b, 0x70, 0xc9, 0x0c, 0xec, 0xcd, 0x98, 0x04,
-	0x17, 0x19, 0x9c, 0x5e, 0x9c, 0x40, 0x70, 0x15, 0x29, 0x4c, 0x74, 0xeb, 0x3b, 0xb0, 0x70, 0x17,
+	0x06, 0x87, 0x8c, 0x65, 0x13, 0x5c, 0x35, 0x15, 0x26, 0xba, 0xf5, 0x1d, 0x68, 0x21, 0x55, 0xcb,
-	0x0f, 0x2c, 0x97, 0x41, 0x02, 0xed, 0xe1, 0x64, 0xca, 0x17, 0x33, 0x94, 0x85, 0xb8, 0xd5, 0xc4,
+	0x66, 0x10, 0x4f, 0xbb, 0x9f, 0x4f, 0xf9, 0x72, 0x8a, 0xb2, 0x10, 0xb7, 0x9a, 0xf8, 0x9f, 0xaa,
-	0xff, 0x58, 0x85, 0xc6, 0x5d, 0xd2, 0x1b, 0x3a, 0xd8, 0x0d, 0x35, 0x1d, 0xea, 0xc1, 0x53, 0x74,
+	0xd0, 0xb8, 0xed, 0xf4, 0xa7, 0x63, 0xd4, 0x57, 0xad, 0x07, 0x75, 0xef, 0x91, 0x79, 0x74, 0x44,
-	0x74, 0x84, 0x7d, 0x21, 0x3f, 0x39, 0xd4, 0x5e, 0x86, 0x8a, 0xe5, 0x0e, 0x08, 0x93, 0xe1, 0xc2,
+	0x5c, 0x21, 0x3f, 0xf9, 0xa8, 0x3d, 0x0f, 0x15, 0xcb, 0x1e, 0x3a, 0x4c, 0x86, 0xad, 0x9d, 0x6e,
-	0x4e, 0x27, 0xb9, 0xc7, 0x03, 0x77, 0x40, 0x0c, 0x06, 0xa5, 0xc2, 0x3f, 0x26, 0x41, 0x28, 0xa4,
+	0x74, 0x8d, 0x7b, 0x38, 0xae, 0x33, 0x28, 0x15, 0xfe, 0xb1, 0xe3, 0xf9, 0x42, 0xaa, 0xec, 0xbf,
-	0xca, 0xfe, 0x6b, 0x9b, 0xd0, 0x3c, 0x44, 0x01, 0x36, 0x3d, 0x14, 0x1e, 0x0b, 0xab, 0x6b, 0xd0,
+	0xb6, 0x09, 0xcd, 0x43, 0xd3, 0x23, 0xc6, 0xc4, 0xf4, 0x8f, 0x85, 0xd5, 0x35, 0xe8, 0xc0, 0x3e,
-	0x89, 0x7d, 0x14, 0x1e, 0xb3, 0x0d, 0x29, 0x77, 0x38, 0x60, 0x96, 0x46, 0x37, 0xe4, 0x43, 0xaa,
+	0x3e, 0xb3, 0x05, 0x29, 0x77, 0xc8, 0x3d, 0xb5, 0x34, 0xba, 0x20, 0x7f, 0xa4, 0xca, 0xd5, 0xc7,
-	0x5c, 0x3d, 0xe2, 0x06, 0x43, 0x0a, 0xaa, 0x31, 0x50, 0x34, 0xa6, 0x30, 0xcf, 0x27, 0xfd, 0x61,
+	0xdd, 0x4e, 0x29, 0xa8, 0xc6, 0x40, 0xc1, 0x33, 0x85, 0xe1, 0xb6, 0x07, 0xd3, 0x3e, 0xc2, 0xea,
-	0x0f, 0x07, 0x7a, 0x9d, 0xc3, 0xe4, 0x58, 0x7b, 0x0d, 0xaa, 0x74, 0xa7, 0x40, 0x6f, 0x30, 0x4e,
+	0x1c, 0x26, 0x9f, 0xb5, 0x97, 0xa0, 0x4a, 0x57, 0xf2, 0x7a, 0x0d, 0xc6, 0xe9, 0x72, 0x94, 0x53,
-	0x97, 0x93, 0x9c, 0xd2, 0x2d, 0x03, 0x83, 0xc3, 0xb5, 0xb7, 0xa9, 0x0d, 0x44, 0x52, 0xd5, 0x9b,
+	0xba, 0xa4, 0xa7, 0x73, 0xb8, 0xf6, 0x26, 0xb5, 0x81, 0x40, 0xaa, 0xbd, 0x26, 0x43, 0x8f, 0x09,
-	0x0c, 0x3d, 0x25, 0xbc, 0x84, 0xd0, 0x8d, 0x24, 0xae, 0xf6, 0x75, 0x00, 0x4f, 0xda, 0x52, 0xa0,
+	0x2f, 0x22, 0x74, 0x3d, 0x8a, 0xab, 0x7d, 0x0d, 0x60, 0x22, 0x6d, 0xc9, 0xeb, 0x01, 0x9b, 0x79,
-	0x03, 0x5b, 0x79, 0x25, 0xbd, 0x91, 0x80, 0x26, 0x49, 0x24, 0xd6, 0x68, 0xef, 0x40, 0xd3, 0xc7,
+	0x2d, 0xbe, 0x90, 0x80, 0x46, 0x49, 0x44, 0xe6, 0x68, 0x5f, 0x81, 0xa6, 0x4b, 0xbc, 0x09, 0x0e,
-	0x81, 0x47, 0xdc, 0x00, 0x07, 0xfa, 0x02, 0x23, 0xf0, 0x62, 0x92, 0x80, 0x21, 0x80, 0xc9, 0xf5,
+	0xe3, 0x16, 0x5a, 0x8c, 0xc0, 0x33, 0x51, 0x02, 0xba, 0x00, 0x46, 0xe7, 0x87, 0x33, 0xb4, 0x2f,
-	0xf1, 0x0a, 0xed, 0xab, 0xd0, 0x08, 0x84, 0x53, 0xd1, 0x17, 0xd9, 0x5b, 0x4f, 0xad, 0x96, 0x0e,
+	0x43, 0xc3, 0x13, 0x4e, 0xa5, 0xb7, 0xc8, 0xde, 0x7a, 0x6c, 0xb6, 0x74, 0x38, 0x3a, 0xb7, 0x46,
-	0xc7, 0xe0, 0xd6, 0x48, 0x5f, 0xad, 0x11, 0x2d, 0xd0, 0x0c, 0x58, 0x95, 0xff, 0xcd, 0xa4, 0x04,
+	0xfa, 0x6a, 0xf5, 0x60, 0x82, 0xa6, 0xc3, 0xaa, 0xfc, 0x6f, 0x44, 0x25, 0xd0, 0x4e, 0xb3, 0x21,
-	0x5a, 0x59, 0x36, 0x24, 0xa1, 0x24, 0x1b, 0x2b, 0x41, 0x76, 0x52, 0xbb, 0x0a, 0x95, 0x10, 0x1d,
+	0x09, 0x45, 0xd9, 0x58, 0xf1, 0xd2, 0x83, 0xda, 0x73, 0xe8, 0xd9, 0xcc, 0x23, 0xaf, 0xd7, 0x61,
-	0x05, 0x7a, 0x9b, 0x31, 0xb3, 0x94, 0xa4, 0xf1, 0x08, 0x1d, 0x19, 0x0c, 0xa8, 0xbd, 0x03, 0x2d,
+	0xcc, 0x2c, 0x45, 0x69, 0x3c, 0x30, 0x8f, 0x74, 0x06, 0xc4, 0x4d, 0xb7, 0xa9, 0x5d, 0xb9, 0x54,
-	0x6a, 0x57, 0x3e, 0x55, 0xdb, 0x3e, 0xe9, 0x05, 0xfa, 0x12, 0xdb, 0x51, 0x4f, 0x62, 0xdf, 0x13,
+	0x6d, 0x07, 0x4e, 0xdf, 0xeb, 0x2d, 0xb1, 0x15, 0x7b, 0x51, 0xec, 0x3b, 0x02, 0x01, 0x55, 0xd2,
-	0x08, 0x77, 0x49, 0x2f, 0x30, 0x16, 0x71, 0x62, 0xa4, 0xb4, 0xce, 0xce, 0x3c, 0xd6, 0xf9, 0x18,
+	0xd3, 0x17, 0x49, 0xe4, 0x49, 0x69, 0x9d, 0xdd, 0x22, 0xd6, 0xf9, 0x3e, 0x34, 0xee, 0x9c, 0x9a,
-	0x1a, 0xf7, 0x4e, 0x91, 0xe3, 0xd9, 0x38, 0x78, 0x9e, 0xe6, 0xf9, 0xa3, 0x22, 0x2c, 0x26, 0xd9,
+	0xe3, 0xc9, 0x08, 0x25, 0xf8, 0x04, 0xcd, 0xf3, 0x47, 0x25, 0x58, 0x8c, 0xb2, 0x3d, 0x87, 0x77,
-	0x9e, 0xc1, 0xbb, 0x66, 0x1d, 0xd2, 0x99, 0x9d, 0xfc, 0x3f, 0x4a, 0x00, 0xf7, 0x2d, 0x1b, 0x73,
+	0x4d, 0x3b, 0xa4, 0x73, 0x3b, 0xf9, 0x7f, 0x2e, 0x00, 0xdc, 0xb5, 0x46, 0x84, 0x1b, 0xbb, 0xb6,
-	0x63, 0xd7, 0xd6, 0xa0, 0x36, 0x20, 0xbe, 0x83, 0x42, 0xb1, 0xbd, 0x18, 0x51, 0xc7, 0x17, 0x5a,
+	0x06, 0xb5, 0xa1, 0xe3, 0x8e, 0x4d, 0x5f, 0x2c, 0x2f, 0x9e, 0xa8, 0xe3, 0xf3, 0x2d, 0x7f, 0x24,
-	0xa1, 0x2d, 0x1d, 0x3b, 0x1f, 0x8c, 0x73, 0x5c, 0xce, 0x72, 0x7c, 0x1d, 0xea, 0x7d, 0xee, 0xd9,
+	0x1d, 0x3b, 0x7f, 0x48, 0x72, 0x5c, 0x4e, 0x73, 0xfc, 0x32, 0xd4, 0x07, 0xdc, 0xb3, 0x31, 0x1b,
-	0x98, 0x0d, 0x8f, 0xbd, 0x63, 0xca, 0x91, 0x84, 0xa7, 0xc2, 0x02, 0x37, 0xea, 0x38, 0x2c, 0xc8,
+	0x4e, 0xbc, 0x63, 0xca, 0x91, 0x84, 0xc7, 0x8e, 0x05, 0x6e, 0xd4, 0xe1, 0xb1, 0x20, 0x4f, 0xc0,
-	0x08, 0x58, 0x4b, 0x44, 0xc0, 0x4d, 0x6a, 0x0b, 0xa8, 0x6f, 0x12, 0xd7, 0x1e, 0xe9, 0x75, 0x19,
+	0x5a, 0xe4, 0x04, 0xdc, 0xa4, 0xb6, 0x60, 0x0e, 0x0c, 0xc7, 0x1e, 0x9d, 0xa1, 0x39, 0x8b, 0x73,
-	0x47, 0x50, 0x7f, 0xcf, 0xb5, 0x47, 0x59, 0x9d, 0x69, 0xcc, 0xa5, 0x33, 0xd7, 0xa1, 0x8e, 0xf9,
+	0xc4, 0x1c, 0xec, 0xe1, 0x73, 0x5a, 0x67, 0x1a, 0x85, 0x74, 0x06, 0xd9, 0x26, 0xfc, 0x95, 0x0b,
-	0x2b, 0x17, 0x06, 0x9e, 0x65, 0x5b, 0xc0, 0x95, 0x6f, 0x00, 0xe6, 0x79, 0x03, 0x5f, 0xd4, 0x60,
+	0x03, 0x4f, 0xb3, 0x2d, 0xe0, 0xca, 0x37, 0x00, 0x45, 0xde, 0xc0, 0x67, 0x35, 0xd8, 0xb8, 0x8b,
-	0xe3, 0x3e, 0xf1, 0x9d, 0xbb, 0x28, 0x44, 0x91, 0x03, 0x38, 0x18, 0x1e, 0x1e, 0xc8, 0xb4, 0x29,
+	0x52, 0xbe, 0x6d, 0xfa, 0x66, 0xe0, 0x00, 0x0e, 0xa6, 0x87, 0x07, 0x32, 0x6c, 0x0a, 0xc5, 0x52,
-	0x16, 0x4b, 0x71, 0x2c, 0x5a, 0xf2, 0xc8, 0x5a, 0xca, 0xcb, 0x55, 0xca, 0xf9, 0xf1, 0xb9, 0x92,
+	0x4a, 0x9c, 0x96, 0xfc, 0x64, 0x5d, 0xc8, 0x8a, 0x55, 0xca, 0xd9, 0xe7, 0x73, 0x25, 0x72, 0xcc,
-	0x08, 0x73, 0x37, 0x60, 0x19, 0xd9, 0x36, 0x79, 0x6a, 0x62, 0xc7, 0x0b, 0x47, 0x26, 0x4f, 0xbc,
+	0xdd, 0x80, 0x65, 0x73, 0x34, 0x72, 0x1e, 0x19, 0x64, 0x3c, 0x41, 0xdb, 0xe6, 0x81, 0x57, 0x95,
-	0xaa, 0x6c, 0xab, 0x25, 0x06, 0xb8, 0x47, 0xe7, 0x3f, 0x90, 0xc9, 0x56, 0xe6, 0x45, 0xc4, 0x3a,
+	0x2d, 0xb5, 0xc4, 0x00, 0x77, 0xe8, 0xf8, 0x07, 0x32, 0xd8, 0x4a, 0xbd, 0x88, 0x50, 0x67, 0xea,
-	0x53, 0x4f, 0xe9, 0xcc, 0xff, 0x43, 0xd5, 0x0a, 0xb1, 0x23, 0x65, 0xbf, 0x99, 0xf2, 0x74, 0xbe,
+	0x31, 0x9d, 0xf9, 0x3c, 0x54, 0x2d, 0x0c, 0x13, 0xa5, 0xec, 0x37, 0x63, 0x9e, 0xce, 0xb5, 0xc6,
-	0xe5, 0x58, 0xa1, 0x75, 0xc2, 0x33, 0xc9, 0xc0, 0xe0, 0x98, 0xda, 0xeb, 0xb0, 0xdc, 0x23, 0xb6,
+	0x68, 0x12, 0x27, 0x3c, 0x92, 0x44, 0xe7, 0xca, 0x30, 0xb5, 0x57, 0x60, 0xb9, 0xef, 0x8c, 0x46,
-	0x8d, 0x7b, 0x94, 0x59, 0x53, 0x50, 0x6d, 0x32, 0xaa, 0x9d, 0x18, 0x70, 0x9f, 0xd3, 0x4f, 0xe8,
+	0xa4, 0x4f, 0x99, 0x35, 0x04, 0xd5, 0x26, 0xa3, 0xda, 0x0d, 0x01, 0x77, 0x39, 0xfd, 0x88, 0x6e,
-	0x16, 0x4c, 0xd1, 0x2d, 0x1d, 0xea, 0x0e, 0x3a, 0xb5, 0x9c, 0xa1, 0xc3, 0xbc, 0x66, 0xd1, 0x90,
+	0xc1, 0x0c, 0xdd, 0xc2, 0xf3, 0x62, 0x6c, 0x9e, 0x5a, 0xe3, 0xe9, 0x98, 0x79, 0xcd, 0x92, 0x2e,
-	0x43, 0xba, 0x23, 0x3e, 0xed, 0xd9, 0xc3, 0xc0, 0x3a, 0xc1, 0xa6, 0xc4, 0x59, 0x64, 0x0f, 0xdf,
+	0x1f, 0xe9, 0x8a, 0xe4, 0xb4, 0x3f, 0x9a, 0x7a, 0xc8, 0x8b, 0x21, 0x71, 0x16, 0xd9, 0xe6, 0xbb,
-	0x89, 0x00, 0xdf, 0x14, 0xc8, 0x94, 0x8c, 0xe5, 0x32, 0x94, 0x96, 0x20, 0xc3, 0x87, 0x63, 0x64,
+	0x01, 0xe0, 0x1b, 0x02, 0x99, 0x92, 0x41, 0xdf, 0x45, 0x51, 0xda, 0x82, 0x0c, 0x7f, 0x4c, 0x90,
-	0x04, 0x4e, 0x7b, 0x9c, 0x8c, 0x40, 0x7e, 0x01, 0xc0, 0x41, 0xa7, 0xa6, 0x8d, 0xdd, 0xa3, 0xf0,
+	0x11, 0x38, 0x9d, 0x24, 0x19, 0x81, 0xfc, 0x34, 0x00, 0xae, 0x64, 0x8c, 0x88, 0x7d, 0x84, 0x67,
-	0x98, 0x79, 0xb3, 0xb2, 0xd1, 0x74, 0xd0, 0xe9, 0x43, 0x36, 0xc1, 0xc0, 0x96, 0x2b, 0xc1, 0x1d,
+	0x1b, 0xf5, 0x66, 0x65, 0xbd, 0x89, 0x23, 0xf7, 0xd9, 0x00, 0x03, 0x5b, 0xb6, 0x04, 0x77, 0x05,
-	0x01, 0xb6, 0x5c, 0x01, 0xd6, 0xa1, 0xee, 0xa1, 0x90, 0x2a, 0xab, 0xbe, 0xcc, 0x83, 0xad, 0x18,
+	0xd8, 0xb2, 0x05, 0x18, 0x99, 0xc0, 0x93, 0x88, 0x2a, 0x6b, 0x6f, 0x99, 0x1f, 0xb6, 0xe2, 0x91,
-	0x52, 0x8b, 0xa0, 0x74, 0xb9, 0xd0, 0x35, 0xb6, 0xae, 0xe1, 0xa0, 0x53, 0x26, 0x61, 0x06, 0xb4,
+	0x5a, 0x04, 0xa5, 0xcb, 0x85, 0xae, 0xb1, 0x79, 0x0d, 0x1c, 0x60, 0x12, 0x66, 0x40, 0xa4, 0xca,
-	0x5c, 0x01, 0x5c, 0x11, 0x40, 0xcb, 0xe5, 0xc0, 0x97, 0x60, 0x71, 0xe8, 0x5a, 0x4f, 0x86, 0x58,
+	0x81, 0x2b, 0x02, 0x68, 0xd9, 0x1c, 0xf8, 0x2c, 0x2c, 0x4e, 0x6d, 0xeb, 0xe1, 0x94, 0x08, 0xf8,
-	0xc0, 0x57, 0x19, 0xe7, 0x0b, 0x7c, 0x8e, 0xa3, 0x5c, 0x85, 0x0a, 0x76, 0x87, 0x8e, 0x7e, 0x21,
+	0x2a, 0xe3, 0xbc, 0xc5, 0xc7, 0x38, 0x0a, 0xba, 0x6a, 0x62, 0xe3, 0xa6, 0x2e, 0xa5, 0x5d, 0x35,
-	0xeb, 0xaa, 0xa9, 0xa8, 0x19, 0x50, 0x7b, 0x11, 0x16, 0x9c, 0xa1, 0x1d, 0x5a, 0x9e, 0x8d, 0x4d,
+	0x15, 0x35, 0x03, 0x6a, 0xcf, 0x40, 0x6b, 0x8c, 0xf2, 0xb6, 0xd0, 0x30, 0x0c, 0x67, 0xd8, 0x5b,
-	0x32, 0xd0, 0xd7, 0x98, 0x90, 0x40, 0x4e, 0xed, 0x0d, 0x94, 0xd6, 0x72, 0x71, 0x2e, 0x6b, 0xa9,
+	0x63, 0x42, 0x02, 0x39, 0xb4, 0x37, 0x54, 0x5a, 0xcb, 0xe5, 0x42, 0xd6, 0x52, 0x85, 0xda, 0xdb,
-	0x42, 0xad, 0x8b, 0x51, 0x1f, 0xfb, 0xca, 0xb4, 0x38, 0xd6, 0xc5, 0x92, 0x5a, 0x17, 0xcb, 0x67,
+	0x68, 0xe5, 0x18, 0x5b, 0xa8, 0xc2, 0xe2, 0x50, 0x17, 0x17, 0xd4, 0xba, 0x58, 0x3e, 0x9f, 0x2e,
-	0xd3, 0xc5, 0xca, 0x74, 0x5d, 0xac, 0xce, 0xae, 0x8b, 0xb5, 0x19, 0x74, 0xb1, 0x3e, 0x5d, 0x17,
+	0x56, 0x66, 0xeb, 0x62, 0x75, 0x7e, 0x5d, 0xac, 0xcd, 0xa1, 0x8b, 0xf5, 0xd9, 0xba, 0xd8, 0x98,
-	0x1b, 0x33, 0xe8, 0x62, 0x73, 0x26, 0x5d, 0x84, 0xc9, 0xba, 0xb8, 0x30, 0x41, 0x17, 0x17, 0x27,
+	0x43, 0x17, 0x9b, 0x73, 0xe9, 0x22, 0xe4, 0xeb, 0x62, 0x2b, 0x47, 0x17, 0x17, 0x73, 0x74, 0xb1,
-	0xe8, 0x62, 0x6b, 0x92, 0x2e, 0xb6, 0xa7, 0xe8, 0xe2, 0x52, 0xbe, 0x2e, 0x76, 0xe6, 0xd0, 0xc5,
+	0x9d, 0xa7, 0x8b, 0x9d, 0x19, 0xba, 0xb8, 0x94, 0xad, 0x8b, 0xdd, 0x02, 0xba, 0xb8, 0x9c, 0xd2,
-	0xe5, 0x8c, 0x2e, 0x8e, 0x79, 0x4b, 0x6d, 0xb6, 0x23, 0xd4, 0xca, 0x3c, 0xda, 0xfa, 0xb7, 0x2a,
+	0xc5, 0x84, 0xb7, 0xd4, 0xe6, 0x4b, 0xa1, 0x56, 0x8a, 0x68, 0xeb, 0xdf, 0xab, 0xd0, 0xe3, 0xda,
-	0xe8, 0x5c, 0x5b, 0xff, 0x2d, 0x9e, 0x5d, 0x5a, 0x48, 0x55, 0x69, 0x21, 0x35, 0xb5, 0x85, 0xd4,
+	0xfa, 0x1f, 0xf1, 0xec, 0xd2, 0x42, 0xaa, 0x4a, 0x0b, 0xa9, 0xa9, 0x2d, 0xa4, 0x7e, 0x3e, 0x0b,
-	0xcf, 0x66, 0x21, 0x8d, 0xe9, 0x16, 0xd2, 0x9c, 0xdd, 0x42, 0x60, 0x06, 0x0b, 0x59, 0x98, 0x6e,
+	0x69, 0xcc, 0xb6, 0x90, 0xe6, 0xfc, 0x16, 0x02, 0x73, 0x58, 0x48, 0x6b, 0xb6, 0x85, 0x2c, 0xce,
-	0x21, 0x8b, 0x33, 0x58, 0x48, 0x6b, 0x26, 0x0b, 0x69, 0x4f, 0xb6, 0x90, 0xa5, 0x09, 0x16, 0xd2,
+	0x61, 0x21, 0xed, 0xb9, 0x2c, 0xa4, 0x93, 0x6f, 0x21, 0x4b, 0x39, 0x16, 0xd2, 0xcd, 0xb1, 0x90,
-	0x99, 0x60, 0x21, 0xcb, 0x93, 0x2c, 0x44, 0x9b, 0x62, 0x21, 0x2b, 0xf9, 0x16, 0xb2, 0x3a, 0x87,
+	0xe5, 0x3c, 0x0b, 0xd1, 0x66, 0x58, 0xc8, 0x4a, 0xb6, 0x85, 0xac, 0x16, 0xb0, 0x90, 0x4b, 0x73,
-	0x85, 0x5c, 0x98, 0xc9, 0x5b, 0xaf, 0xcd, 0xa3, 0xff, 0xdf, 0x82, 0x3a, 0x57, 0xff, 0x67, 0x38,
+	0x79, 0xeb, 0xb5, 0x22, 0xfa, 0xff, 0x4d, 0xa8, 0x73, 0xf5, 0x7f, 0x8c, 0xf4, 0x93, 0x4f, 0xcc,
-	0x7e, 0xf2, 0x85, 0x39, 0xc9, 0xf3, 0xe7, 0x25, 0xa8, 0xd0, 0x03, 0x64, 0x9c, 0x98, 0x16, 0x93,
+	0x08, 0x9e, 0x7f, 0xb1, 0x00, 0x15, 0x9a, 0x40, 0x86, 0x81, 0x69, 0x29, 0x1a, 0x98, 0xa2, 0xd4,
-	0x89, 0xa9, 0x0e, 0xf5, 0x13, 0xec, 0x07, 0x71, 0x65, 0x44, 0x0e, 0x67, 0x30, 0xa4, 0x6b, 0xd0,
+	0x4f, 0x70, 0xd1, 0xb0, 0x32, 0x22, 0x1f, 0xe7, 0x30, 0xa4, 0xeb, 0xd0, 0xc5, 0xf7, 0x33, 0xf6,
-	0x09, 0xb1, 0xef, 0x04, 0x26, 0x19, 0x98, 0x01, 0xf6, 0x4f, 0xac, 0x9e, 0x34, 0xaa, 0x36, 0x9b,
+	0x50, 0x24, 0x86, 0x47, 0xdc, 0x13, 0xab, 0x2f, 0x8d, 0xaa, 0xc3, 0xc6, 0xf7, 0x86, 0x07, 0x7c,
-	0xdf, 0x1b, 0x1c, 0xf0, 0x59, 0xed, 0x26, 0xd4, 0x7b, 0xbc, 0x7c, 0x20, 0x9c, 0xfe, 0x4a, 0xf2,
+	0x54, 0x7b, 0x15, 0xea, 0x7d, 0x5e, 0x3e, 0x10, 0x4e, 0x7f, 0x25, 0xba, 0x09, 0x51, 0x59, 0xd0,
-	0x21, 0x44, 0x65, 0xc1, 0x90, 0x38, 0x14, 0xdd, 0xb6, 0x7a, 0xd8, 0x0d, 0x78, 0xfa, 0x34, 0x86,
+	0x25, 0x0e, 0x45, 0x1f, 0xe1, 0x34, 0xcc, 0xc4, 0x98, 0xe9, 0x25, 0xd0, 0xef, 0x73, 0x90, 0x2e,
-	0xfe, 0x90, 0x83, 0x0c, 0x89, 0xa3, 0x14, 0x7e, 0x7d, 0x1e, 0xe1, 0xbf, 0x05, 0x4d, 0xa6, 0x0c,
+	0x71, 0x94, 0xc2, 0xaf, 0x17, 0x11, 0xfe, 0x1b, 0xd0, 0x64, 0xca, 0xc0, 0x6a, 0x75, 0x37, 0x22,
-	0xac, 0x56, 0x77, 0x23, 0x51, 0xab, 0x2b, 0x4f, 0x2e, 0xac, 0x6c, 0xdd, 0x85, 0xd6, 0x37, 0x02,
+	0xb5, 0xba, 0x72, 0x7e, 0x61, 0x65, 0xeb, 0x36, 0xb4, 0xbf, 0xee, 0x39, 0xb6, 0x4e, 0x86, 0xc4,
-	0xe2, 0x1a, 0x78, 0x80, 0x7d, 0xec, 0xf6, 0xb0, 0xb6, 0x0c, 0x15, 0xd3, 0xc7, 0x03, 0x21, 0xe3,
+	0x25, 0x36, 0x6e, 0x74, 0x19, 0x2a, 0x86, 0x4b, 0x86, 0x42, 0xc6, 0x65, 0x04, 0xcc, 0xae, 0x3f,
-	0xb2, 0x81, 0x07, 0xd3, 0xeb, 0x4f, 0x5b, 0x1e, 0xd4, 0xc5, 0x33, 0xcd, 0x58, 0x5c, 0x39, 0xf3,
+	0x6d, 0x4d, 0xa0, 0x2e, 0xf6, 0x34, 0x67, 0x71, 0xe5, 0xdc, 0xb9, 0xcc, 0x1d, 0x68, 0x48, 0xa0,
-	0x59, 0xe6, 0x1e, 0x34, 0x24, 0x50, 0xb9, 0xe5, 0x2b, 0xb2, 0xaa, 0x58, 0x52, 0x3b, 0x20, 0x0e,
+	0x72, 0xc9, 0x17, 0x64, 0x55, 0x71, 0x41, 0xed, 0x80, 0x38, 0x74, 0xeb, 0x1d, 0x68, 0x45, 0x14,
-	0xdd, 0x7a, 0x17, 0x16, 0x12, 0x0a, 0xa8, 0xa4, 0x74, 0x2d, 0x4d, 0x29, 0x25, 0x4c, 0xa1, 0xb7,
+	0x50, 0x49, 0xe9, 0x7a, 0x9c, 0x52, 0x4c, 0x98, 0x42, 0x6f, 0x05, 0xb1, 0xf7, 0xa0, 0xc3, 0x88,
-	0x82, 0xd8, 0xfb, 0xd0, 0x66, 0xc4, 0xe2, 0x22, 0x9a, 0x8a, 0xde, 0xeb, 0x69, 0x7a, 0x17, 0x94,
+	0x85, 0x45, 0x34, 0x15, 0xbd, 0x57, 0xe2, 0xf4, 0x2e, 0x29, 0x8b, 0x02, 0x92, 0xe4, 0x1e, 0xb4,
-	0x45, 0x01, 0x49, 0x72, 0x0f, 0x5a, 0x82, 0x64, 0x78, 0xcc, 0xde, 0xad, 0x8a, 0xe2, 0x8d, 0x34,
+	0x05, 0x49, 0xff, 0x98, 0xbd, 0x5b, 0x15, 0xc5, 0x1b, 0x71, 0x8a, 0xab, 0xc9, 0x7a, 0x06, 0x9d,
-	0xc5, 0xd5, 0xf1, 0x7a, 0x06, 0x5d, 0x38, 0x4e, 0x50, 0x56, 0x0f, 0xe6, 0x26, 0x28, 0x17, 0x4a,
+	0x98, 0x24, 0x28, 0xab, 0x07, 0x85, 0x09, 0xca, 0x89, 0x92, 0xe0, 0x87, 0xa0, 0xc5, 0x08, 0x06,
-	0x82, 0x1f, 0x81, 0x96, 0x22, 0x18, 0x9d, 0x1d, 0x32, 0x54, 0x6f, 0xa5, 0xa9, 0xae, 0xab, 0xa8,
+	0xb9, 0x43, 0x8a, 0xea, 0xcd, 0x38, 0xd5, 0x75, 0x15, 0x55, 0x36, 0x3b, 0xf9, 0x72, 0xc4, 0x19,
-	0xb2, 0xd5, 0xe3, 0x2f, 0x47, 0xc4, 0xd0, 0x79, 0x5f, 0x8e, 0xd0, 0x74, 0x41, 0xcc, 0x81, 0x4b,
+	0x5a, 0xf4, 0xe5, 0x08, 0x4d, 0x17, 0xc4, 0xc6, 0x70, 0x85, 0x13, 0x4b, 0x97, 0x26, 0x32, 0x05,
-	0x9c, 0x58, 0xb6, 0x34, 0x91, 0x2b, 0xd8, 0xb7, 0xd3, 0xd4, 0xaf, 0x4e, 0xa9, 0x7b, 0x24, 0xe5,
+	0xfb, 0x66, 0x9c, 0xfa, 0x73, 0x33, 0xea, 0x1e, 0x51, 0x39, 0xbf, 0x21, 0x79, 0xf7, 0x5d, 0xcb,
-	0xfc, 0x96, 0xe4, 0x3d, 0xf4, 0x2d, 0xf7, 0x48, 0x49, 0x7d, 0x35, 0x49, 0xbd, 0x29, 0x17, 0x3e,
+	0x3e, 0x52, 0x52, 0x5f, 0x8d, 0x52, 0x6f, 0xca, 0x89, 0xef, 0x43, 0x37, 0x32, 0x71, 0xd7, 0x75,
-	0x86, 0x4e, 0x62, 0xe1, 0xae, 0xef, 0x23, 0xb5, 0x82, 0xdf, 0x4c, 0xf3, 0x96, 0xf2, 0xa9, 0x89,
+	0x4d, 0xb5, 0x82, 0xbf, 0x1a, 0xe7, 0x2d, 0xe6, 0x53, 0x23, 0x73, 0x25, 0xd9, 0xdf, 0x96, 0x91,
-	0xb5, 0x92, 0xec, 0x6f, 0xca, 0xd0, 0x79, 0x8f, 0xb8, 0xe9, 0x1a, 0x2f, 0x86, 0xcd, 0x63, 0xa6,
+	0xae, 0x63, 0xc7, 0x6b, 0xbc, 0x04, 0x36, 0x8f, 0x99, 0x06, 0x1b, 0x41, 0xdd, 0xc9, 0xf0, 0xa6,
-	0xc1, 0x66, 0x54, 0x77, 0x32, 0x83, 0xe1, 0xa1, 0x99, 0xaa, 0xf4, 0xbf, 0x9c, 0x55, 0xf8, 0x6c,
+	0x87, 0x46, 0xac, 0xd2, 0xff, 0x7c, 0x5a, 0xe1, 0xd3, 0x01, 0xce, 0xdb, 0x4f, 0xe9, 0xbd, 0xe3,
-	0x82, 0xd3, 0x2d, 0x18, 0xfa, 0x71, 0x5e, 0xf2, 0x63, 0xc3, 0x65, 0x9a, 0x30, 0x98, 0x7d, 0x14,
+	0xac, 0xe0, 0x67, 0x04, 0x57, 0x69, 0xc0, 0x60, 0x0c, 0x30, 0xeb, 0x55, 0xaf, 0xc4, 0xf7, 0xf0,
-	0x22, 0xf5, 0x4e, 0xfc, 0x19, 0x5e, 0x4d, 0xee, 0x94, 0x7f, 0x4c, 0xee, 0x16, 0x8c, 0x8d, 0x41,
+	0x62, 0x74, 0xa5, 0xec, 0x34, 0x19, 0xd7, 0xda, 0x18, 0x66, 0x27, 0xd1, 0x87, 0xb0, 0x81, 0x47,
-	0xfe, 0x21, 0xfa, 0x10, 0x36, 0x9e, 0x0c, 0xb1, 0x3f, 0x52, 0xef, 0x54, 0xce, 0xbe, 0xc9, 0xf7,
+	0xa3, 0x7b, 0xa6, 0x5e, 0xa9, 0x9c, 0x7e, 0x93, 0xef, 0x51, 0x6c, 0xe5, 0x32, 0x97, 0x1f, 0xaa,
-	0x29, 0xb6, 0x72, 0x9b, 0x8b, 0x4f, 0xd4, 0x20, 0xcd, 0x84, 0x75, 0x0f, 0x85, 0xc7, 0xea, 0x2d,
+	0x41, 0x9a, 0x01, 0xeb, 0xb4, 0x42, 0xa8, 0x5e, 0x82, 0x17, 0x3f, 0xb6, 0x92, 0x56, 0xa8, 0x5c,
-	0x78, 0xf1, 0x63, 0x6b, 0xdc, 0x0a, 0x95, 0x3b, 0xac, 0x79, 0x4a, 0x48, 0xdc, 0x24, 0xf9, 0xbc,
+	0x61, 0x6d, 0xa2, 0x84, 0x84, 0x4d, 0x12, 0x3c, 0xfc, 0x7a, 0x7b, 0xe6, 0xd4, 0x3f, 0xde, 0xd9,
-	0x04, 0xfa, 0x1e, 0x1a, 0x86, 0xc7, 0x3b, 0xbb, 0xbd, 0x1e, 0x0e, 0x82, 0x3b, 0xa4, 0x8f, 0xa7,
+	0xed, 0xf7, 0x89, 0xe7, 0xbd, 0xe5, 0x0c, 0xc8, 0xac, 0x3e, 0xc7, 0x10, 0xf3, 0x78, 0x59, 0x95,
-	0xf5, 0x39, 0x06, 0x36, 0x79, 0x2a, 0xab, 0xf2, 0xf4, 0xbf, 0xf6, 0x06, 0x0d, 0x08, 0xc4, 0xc3,
+	0xa7, 0xff, 0xb5, 0xd7, 0xe8, 0x81, 0x80, 0xec, 0xc8, 0x94, 0x28, 0x56, 0x1a, 0xe1, 0xd4, 0x0f,
-	0xf2, 0x48, 0x94, 0x2a, 0x8d, 0x70, 0xea, 0x07, 0x0c, 0x6e, 0x08, 0x3c, 0x9a, 0x35, 0xd1, 0x69,
+	0x18, 0x5c, 0x17, 0x78, 0x34, 0x6a, 0xa2, 0xc3, 0x8e, 0x6b, 0x7d, 0x9f, 0xf5, 0x27, 0x0c, 0xea,
-	0xe2, 0x5b, 0xdf, 0x67, 0xfd, 0x09, 0x93, 0xfa, 0x6f, 0x71, 0x20, 0x4a, 0x01, 0x1e, 0xfb, 0x36,
+	0xbf, 0x45, 0x42, 0x14, 0x03, 0xbc, 0x8f, 0xce, 0x1c, 0x03, 0x18, 0xdf, 0xf9, 0x84, 0x70, 0x24,
-	0x4d, 0x60, 0x42, 0xf2, 0x29, 0xe6, 0x48, 0x3c, 0xff, 0x6c, 0xb0, 0x09, 0x0a, 0x1c, 0x0b, 0x1e,
+	0x1e, 0x7f, 0x36, 0xd8, 0x00, 0x05, 0x26, 0x0e, 0x8f, 0xda, 0x7c, 0x91, 0x77, 0xa1, 0xc3, 0xef,
-	0xb5, 0xd9, 0x32, 0xef, 0xb9, 0x82, 0xdf, 0x5f, 0x8a, 0xb0, 0x2e, 0x64, 0xe4, 0x79, 0xf6, 0x2c,
+	0xaf, 0x25, 0x58, 0x17, 0x32, 0x9a, 0x4c, 0x46, 0xf3, 0x74, 0x54, 0x9e, 0x8c, 0x90, 0x62, 0xfb,
-	0x1d, 0x95, 0xe7, 0x23, 0xa4, 0xd4, 0x73, 0x57, 0x26, 0x3f, 0x77, 0x75, 0xb6, 0xe7, 0x9e, 0xab,
+	0xae, 0xe4, 0xef, 0xbb, 0x3a, 0xdf, 0xbe, 0x0b, 0xf5, 0x34, 0x7e, 0xb8, 0x00, 0x6b, 0x9c, 0xb1,
-	0xa7, 0xf1, 0xc3, 0x12, 0xac, 0x71, 0xc6, 0x1e, 0x38, 0xf4, 0xb9, 0xad, 0xf0, 0x3f, 0x4d, 0x33,
+	0x7b, 0x63, 0xba, 0x6f, 0xcb, 0xff, 0x6f, 0xd3, 0x8c, 0x7f, 0x83, 0x10, 0xfe, 0x52, 0x92, 0x42,
-	0xfe, 0x05, 0x42, 0xf8, 0x73, 0x51, 0x0a, 0x61, 0x1f, 0x05, 0xc1, 0x53, 0xe2, 0xf7, 0xff, 0x07,
+	0xd8, 0x37, 0x3d, 0xef, 0x91, 0xe3, 0x0e, 0xfe, 0x0f, 0xde, 0xfc, 0x47, 0xb0, 0x18, 0xe5, 0xeb,
-	0xde, 0xfc, 0xc7, 0xb0, 0x98, 0xe4, 0xeb, 0x19, 0xfa, 0x3d, 0x2c, 0x42, 0xe4, 0x24, 0xdc, 0x3f,
+	0x31, 0xfa, 0x3d, 0xec, 0x84, 0xc8, 0x08, 0xb8, 0x7f, 0x5e, 0x81, 0xe6, 0x1e, 0x3e, 0x98, 0x32,
-	0xaf, 0x40, 0x73, 0xcf, 0xc3, 0x3e, 0x92, 0x87, 0x4d, 0x56, 0xb7, 0x2f, 0xb2, 0x3a, 0x2d, 0x2f,
+	0xd9, 0x64, 0x75, 0xfb, 0x12, 0xab, 0xd3, 0xf2, 0x32, 0x3d, 0xed, 0xc9, 0x4c, 0xc7, 0x63, 0xd3,
-	0xd3, 0xeb, 0x50, 0x0f, 0x86, 0x8e, 0x83, 0xfc, 0x91, 0xcc, 0xb9, 0xc5, 0x70, 0x86, 0x9c, 0x3b,
+	0x3d, 0x93, 0x31, 0xb7, 0x78, 0x9c, 0x23, 0xe6, 0x4e, 0x95, 0x6b, 0x2b, 0x85, 0xca, 0xb5, 0x98,
-	0x53, 0xae, 0xad, 0xcc, 0x55, 0xae, 0x7d, 0x09, 0x16, 0x89, 0xe4, 0xcd, 0xb4, 0xfa, 0x52, 0xbc,
+	0x10, 0x39, 0x92, 0x37, 0xc3, 0x1a, 0x48, 0xf1, 0x06, 0x63, 0xf7, 0x06, 0xb1, 0xde, 0x4f, 0x2d,
-	0xd1, 0xdc, 0x83, 0x7e, 0xaa, 0xf7, 0x53, 0x1b, 0xeb, 0xfd, 0x24, 0x7b, 0x46, 0xf5, 0xb1, 0x9e,
+	0xd1, 0xfb, 0x89, 0xf6, 0x8c, 0xea, 0x89, 0x9e, 0xd1, 0x97, 0x62, 0x3d, 0x9b, 0x06, 0x13, 0xdd,
-	0xd1, 0x57, 0x52, 0x3d, 0x9b, 0x06, 0x13, 0xdd, 0x86, 0x32, 0x3d, 0xe3, 0xa1, 0x3e, 0xd9, 0xad,
+	0x86, 0x32, 0x3c, 0xe3, 0x47, 0x7d, 0xb4, 0x5b, 0xf3, 0x7a, 0xb4, 0x5b, 0xd3, 0x4c, 0x47, 0x76,
-	0x79, 0x33, 0xd9, 0xad, 0x69, 0x66, 0x33, 0x3b, 0x99, 0xe0, 0xa4, 0x7a, 0x34, 0x89, 0xd6, 0x16,
+	0x32, 0xc0, 0x89, 0xf5, 0x68, 0x22, 0xad, 0x2d, 0x88, 0xb7, 0xb6, 0xae, 0x02, 0x0c, 0xc8, 0xc4,
-	0xa4, 0x5b, 0x5b, 0x97, 0x01, 0xfa, 0xd8, 0xf3, 0x71, 0x0f, 0x85, 0xb8, 0x2f, 0x4e, 0xbd, 0x89,
+	0x25, 0xe8, 0xcb, 0xc8, 0x40, 0x64, 0xbd, 0x91, 0x91, 0xf3, 0x75, 0x77, 0x54, 0xea, 0xd7, 0x2e,
-	0x99, 0xb3, 0x75, 0x77, 0x54, 0xea, 0xd7, 0x9a, 0x47, 0xfd, 0x7e, 0x59, 0x84, 0x66, 0x9c, 0x45,
+	0xa2, 0x7e, 0xbf, 0x2a, 0x41, 0x33, 0x8c, 0x22, 0x6e, 0x41, 0xe7, 0x10, 0xc3, 0x8a, 0xf0, 0x30,
-	0xdc, 0x86, 0xf6, 0x21, 0xe9, 0x27, 0xe2, 0xad, 0x48, 0x1c, 0x52, 0x09, 0x5e, 0x2a, 0xf1, 0xe8,
+	0x14, 0x81, 0x43, 0x2c, 0xc0, 0x8b, 0x05, 0x1e, 0x78, 0xf0, 0xb5, 0x0f, 0x63, 0x91, 0xc8, 0x7d,
-	0x16, 0x8c, 0xd6, 0x61, 0x2a, 0x13, 0x79, 0x08, 0x9a, 0x4b, 0x5c, 0x73, 0x8c, 0x0e, 0x4f, 0x0b,
+	0xd0, 0x6c, 0x7c, 0x9f, 0x09, 0x3a, 0x3c, 0x2c, 0xb8, 0x12, 0x63, 0x2a, 0x11, 0xc3, 0x20, 0xa9,
-	0x2e, 0xa5, 0x98, 0x1a, 0xcb, 0x61, 0xba, 0x05, 0xa3, 0xe3, 0x8e, 0xcd, 0xc5, 0xd1, 0xf3, 0x08,
+	0xae, 0x9d, 0x18, 0x0b, 0x4f, 0xcf, 0x23, 0x58, 0x55, 0xf5, 0xd9, 0xb4, 0xbd, 0x7c, 0x7b, 0xd9,
-	0x56, 0x55, 0x7d, 0x36, 0x6d, 0x6f, 0xb2, 0xbd, 0x6c, 0x64, 0xc4, 0x10, 0x27, 0xe6, 0x6a, 0x93,
+	0x48, 0x89, 0x21, 0x0c, 0xcc, 0xd5, 0x26, 0xf3, 0x69, 0x09, 0x3a, 0x71, 0xed, 0xd0, 0xbe, 0x00,
-	0xf9, 0xac, 0x08, 0xed, 0xb4, 0x76, 0x68, 0x5f, 0x82, 0xe6, 0xb8, 0x44, 0xd4, 0xb9, 0x7e, 0xb7,
+	0xcd, 0xa4, 0x44, 0xd4, 0xb1, 0x3e, 0x6e, 0x21, 0xc4, 0xa4, 0xd2, 0xfc, 0x18, 0x13, 0x32, 0x9a,
-	0x60, 0xc4, 0x98, 0x54, 0x9a, 0x9f, 0x04, 0xc4, 0xa5, 0x67, 0x30, 0x7e, 0x22, 0x53, 0xa5, 0xcb,
+	0x83, 0xf1, 0x8c, 0x4c, 0x15, 0x2e, 0xc7, 0x52, 0x36, 0x2a, 0xcd, 0x8f, 0xa3, 0x03, 0xe1, 0xfe,
-	0xa9, 0x23, 0x1b, 0x95, 0xe6, 0x27, 0xc9, 0x89, 0xf8, 0xf9, 0x7f, 0x5f, 0x86, 0x46, 0x74, 0x74,
+	0xff, 0x50, 0x86, 0x46, 0x90, 0x3a, 0x28, 0x32, 0xbb, 0x97, 0xa0, 0x7c, 0x44, 0x7c, 0x55, 0x26,
-	0x50, 0x9c, 0xec, 0x5e, 0x83, 0xf2, 0x11, 0x0e, 0x55, 0x27, 0x91, 0xc8, 0xfe, 0x0d, 0x8a, 0x41,
+	0x12, 0xd8, 0xbf, 0x4e, 0x31, 0x28, 0xe2, 0x64, 0xea, 0x0b, 0xff, 0x98, 0x85, 0x88, 0x18, 0xda,
-	0x11, 0xbd, 0x61, 0x28, 0xfc, 0x63, 0x1e, 0xa2, 0x37, 0x0c, 0xb5, 0xeb, 0x50, 0xf1, 0x48, 0x20,
+	0xcb, 0x50, 0x99, 0xd0, 0xf6, 0x6e, 0x25, 0x0f, 0x93, 0xa1, 0x60, 0x04, 0x5b, 0x1b, 0x90, 0x11,
-	0x3b, 0x40, 0x39, 0x98, 0x0c, 0x45, 0xbb, 0x09, 0xb5, 0x3e, 0xb6, 0x71, 0x88, 0xc5, 0x89, 0x3a,
+	0x6e, 0x5a, 0x64, 0xd4, 0x19, 0xc8, 0x02, 0x09, 0xd3, 0x87, 0xba, 0x33, 0xe1, 0x6d, 0xc8, 0x5a,
-	0x07, 0x59, 0x20, 0x69, 0xb7, 0xa0, 0x4e, 0x3c, 0xde, 0x86, 0xac, 0x4d, 0xc2, 0x97, 0x58, 0x94,
+	0x1e, 0xbe, 0xc4, 0xa2, 0xac, 0xd0, 0x90, 0x54, 0x14, 0xb9, 0xb2, 0x58, 0xa1, 0x28, 0x34, 0x27,
-	0x15, 0x9a, 0x92, 0x8a, 0x22, 0x57, 0x1e, 0x2b, 0x14, 0x85, 0x9e, 0xc9, 0x3c, 0x14, 0xf6, 0x8e,
+	0xc3, 0x40, 0xac, 0x7f, 0x2c, 0xda, 0x17, 0x19, 0xb8, 0x1c, 0x27, 0xe1, 0x26, 0x9a, 0x85, 0xdc,
-	0x45, 0xfb, 0x22, 0x07, 0x97, 0xe3, 0x8c, 0xb9, 0x89, 0xe6, 0x5c, 0x6e, 0xe2, 0xcc, 0x1d, 0xa4,
+	0xc4, 0xb9, 0x3b, 0x48, 0x7f, 0xab, 0xc2, 0x9a, 0x3a, 0x9a, 0xbc, 0xa8, 0x31, 0x5e, 0xd4, 0x18,
-	0xbf, 0x56, 0x61, 0x4d, 0x9d, 0x4d, 0x9e, 0xd7, 0x18, 0xcf, 0x6b, 0x8c, 0xff, 0xed, 0x35, 0xc6,
+	0xff, 0xd7, 0x6b, 0x8c, 0x8f, 0xa0, 0xca, 0x2e, 0x68, 0x28, 0x29, 0x95, 0x0a, 0x50, 0x42, 0xe7,
-	0xa7, 0x50, 0x65, 0x17, 0x34, 0x94, 0x94, 0x8a, 0x73, 0x50, 0xd2, 0x6e, 0x42, 0x85, 0xdd, 0x36,
+	0x53, 0x61, 0xb7, 0x4d, 0x16, 0xd8, 0xa4, 0x75, 0x85, 0xc3, 0x17, 0x75, 0x13, 0x86, 0xb6, 0xf5,
-	0x29, 0xb1, 0x45, 0xeb, 0x0a, 0x87, 0x2f, 0xea, 0x26, 0x0c, 0x6d, 0xeb, 0x67, 0x55, 0x58, 0x1a,
+	0xb3, 0x2a, 0x2c, 0x25, 0xb4, 0xf6, 0xa2, 0x27, 0x75, 0xd1, 0x93, 0x3a, 0x57, 0x4f, 0x4a, 0xa5,
-	0xd3, 0xda, 0xf3, 0x9e, 0xd4, 0x79, 0x4f, 0xea, 0x4c, 0x3d, 0x29, 0x95, 0x0e, 0x6b, 0xf3, 0x58,
+	0xc3, 0x5a, 0x11, 0x6b, 0xf8, 0x36, 0x40, 0x18, 0x82, 0x3c, 0xe1, 0x3b, 0x5f, 0xbf, 0xae, 0xc1,
-	0xc3, 0xb7, 0x01, 0xe2, 0x14, 0xe4, 0x39, 0xdf, 0xf9, 0xfa, 0x55, 0x0d, 0x2e, 0xe6, 0x14, 0x46,
+	0xe5, 0x8c, 0xc2, 0xc8, 0xc5, 0x35, 0x85, 0x8b, 0x6b, 0x0a, 0x17, 0xd7, 0x14, 0x42, 0x33, 0xfc,
-	0xce, 0xaf, 0x29, 0x9c, 0x5f, 0x53, 0x38, 0xbf, 0xa6, 0x10, 0x9b, 0xe1, 0xdf, 0x8b, 0xd0, 0x88,
+	0x47, 0x09, 0x1a, 0x41, 0x39, 0x7d, 0xf6, 0xc5, 0xae, 0xed, 0xa0, 0x3b, 0xc3, 0xc3, 0xee, 0xb5,
-	0xca, 0xe9, 0xd3, 0x2f, 0x76, 0x6d, 0x47, 0xdd, 0x19, 0x9e, 0x76, 0xaf, 0x65, 0x6b, 0xd6, 0x2c,
+	0x74, 0xcd, 0x9a, 0x1d, 0x3c, 0xf2, 0xea, 0xeb, 0xab, 0x50, 0xe7, 0x95, 0x55, 0x79, 0x78, 0xac,
-	0xf0, 0xc8, 0xab, 0xaf, 0x37, 0xa1, 0xce, 0x2b, 0xab, 0x32, 0x78, 0xac, 0x64, 0x0b, 0xb2, 0x81,
+	0xa4, 0x0b, 0xb2, 0x9e, 0x2e, 0x71, 0xb4, 0xd7, 0xa0, 0x21, 0xae, 0x2b, 0xc9, 0xcc, 0x7a, 0x35,
-	0x21, 0x71, 0xb4, 0x37, 0xa0, 0x21, 0xae, 0x2b, 0xc9, 0x93, 0xf5, 0x6a, 0xfa, 0x64, 0xcd, 0x61,
+	0x9e, 0x59, 0x73, 0x98, 0x1e, 0x60, 0x9d, 0xff, 0x4e, 0x33, 0x81, 0x15, 0xc5, 0x65, 0x44, 0xed,
-	0x46, 0x84, 0x75, 0xf6, 0x3b, 0xcd, 0x18, 0x56, 0x14, 0x97, 0x11, 0xb5, 0xf7, 0x26, 0x3b, 0xa4,
+	0xdd, 0x7c, 0x87, 0x94, 0x3e, 0x73, 0x83, 0xd6, 0x82, 0xda, 0x25, 0xfd, 0xa4, 0x04, 0xed, 0x78,
-	0x6c, 0xcc, 0x8d, 0x5a, 0x0b, 0x6a, 0x97, 0xf4, 0x93, 0x22, 0xb4, 0xd2, 0x5d, 0x86, 0x1d, 0xea,
+	0x97, 0x61, 0x87, 0x3a, 0x22, 0x3e, 0x10, 0xdc, 0x1e, 0x57, 0xe4, 0xdc, 0x98, 0x20, 0x05, 0x78,
-	0x88, 0xf8, 0x44, 0x74, 0x7b, 0x5c, 0x71, 0xe6, 0xee, 0x16, 0x8c, 0x08, 0xef, 0xf9, 0x9e, 0xaf,
+	0x4f, 0x36, 0xbf, 0xfa, 0x29, 0x26, 0xc2, 0x41, 0x66, 0xaf, 0xbd, 0x05, 0x6d, 0xb9, 0x8c, 0xd1,
-	0x7e, 0x5a, 0x84, 0x66, 0x74, 0xb2, 0xd7, 0xee, 0x40, 0x4b, 0x6e, 0x63, 0xf6, 0x48, 0x1f, 0x8b,
+	0x77, 0x06, 0x44, 0x6c, 0xf4, 0x6a, 0xe6, 0x46, 0x79, 0xb7, 0x63, 0x51, 0x4e, 0xa2, 0xb5, 0x5d,
-	0x07, 0xbd, 0x9c, 0xfb, 0xa0, 0xbc, 0xdb, 0xb1, 0x28, 0x17, 0xdd, 0x21, 0x7d, 0x75, 0x2b, 0xb0,
+	0xe5, 0xdb, 0x58, 0x28, 0xf2, 0x36, 0x7e, 0xd3, 0x84, 0x9a, 0x70, 0xd4, 0x8a, 0x8c, 0x2f, 0x2b,
-	0x34, 0xcf, 0xdb, 0xf8, 0x75, 0x13, 0x6a, 0xc2, 0x51, 0x2b, 0x4e, 0x7c, 0x79, 0x09, 0x4a, 0xd4,
+	0x40, 0x09, 0x7a, 0xab, 0xe5, 0x9c, 0x4b, 0x7f, 0x95, 0xdc, 0x4b, 0x7f, 0xb3, 0x02, 0x8f, 0x84,
-	0x5b, 0x2d, 0x4f, 0xb8, 0xf4, 0x57, 0x99, 0x78, 0xe9, 0x6f, 0x5a, 0xe2, 0x31, 0x66, 0x89, 0xb5,
+	0x25, 0xd6, 0x52, 0x96, 0x18, 0x71, 0x89, 0xf5, 0x39, 0x5c, 0x62, 0x63, 0xb6, 0x4b, 0x6c, 0xce,
-	0x8c, 0x25, 0x26, 0x5c, 0x62, 0x7d, 0x06, 0x97, 0xd8, 0x98, 0xee, 0x12, 0x9b, 0x33, 0xb8, 0x44,
+	0xe1, 0x12, 0x61, 0x2e, 0x97, 0xd8, 0xca, 0x77, 0x89, 0x8b, 0x39, 0x2e, 0xb1, 0x9d, 0xe3, 0x12,
-	0x98, 0xc9, 0x25, 0x2e, 0x4c, 0x76, 0x89, 0x8b, 0x13, 0x5c, 0x62, 0x6b, 0x82, 0x4b, 0x6c, 0x4f,
+	0x3b, 0x79, 0x2e, 0x71, 0x69, 0x86, 0x4b, 0xec, 0xa6, 0x5d, 0xe2, 0x0b, 0xd0, 0xa1, 0xc4, 0x23,
-	0x72, 0x89, 0x4b, 0x53, 0x5c, 0x62, 0x27, 0xeb, 0x12, 0x5f, 0x81, 0x36, 0x25, 0x9e, 0x30, 0x36,
+	0xc6, 0xc6, 0x33, 0x81, 0x36, 0x8e, 0x46, 0x62, 0x05, 0x8a, 0x86, 0xcb, 0x44, 0xd0, 0x34, 0x81,
-	0x7e, 0x12, 0x68, 0x39, 0xe8, 0x34, 0x91, 0x2b, 0x50, 0x34, 0xcb, 0x4d, 0xa2, 0x69, 0x02, 0xcd,
+	0x66, 0xd9, 0x11, 0xb4, 0xe8, 0x41, 0xbf, 0x92, 0xb8, 0xa6, 0x39, 0x57, 0x46, 0xf0, 0x61, 0x96,
-	0x72, 0x13, 0x68, 0xc9, 0x40, 0xbf, 0x32, 0x76, 0x4d, 0x73, 0xa6, 0x13, 0xc1, 0x47, 0x79, 0x2e,
+	0x0b, 0xb8, 0x94, 0x6e, 0x2d, 0x65, 0x7d, 0x7a, 0xa2, 0xf6, 0x06, 0xda, 0x75, 0x71, 0xec, 0xaf,
-	0xe0, 0x42, 0xb6, 0xb5, 0x94, 0xf7, 0xe9, 0x89, 0xda, 0x1b, 0x68, 0xd7, 0x44, 0xd8, 0x5f, 0xcb,
+	0xa5, 0xed, 0xfe, 0x01, 0x8e, 0xf3, 0xd8, 0x9d, 0x05, 0x03, 0xaf, 0xc8, 0x43, 0xff, 0x72, 0x3a,
-	0xda, 0xfd, 0xa3, 0x91, 0x87, 0x79, 0xee, 0xce, 0x92, 0x81, 0xd7, 0x65, 0xd0, 0xbf, 0x98, 0x3d,
+	0xb9, 0x0f, 0x9a, 0xe6, 0xf2, 0xb8, 0x7f, 0x19, 0x6a, 0x18, 0x60, 0x50, 0xfd, 0xec, 0x65, 0xf6,
-	0xdc, 0x47, 0x4d, 0x73, 0x19, 0xee, 0xaf, 0x43, 0x0d, 0xd9, 0x36, 0xd5, 0x4f, 0x3d, 0xb7, 0x77,
+	0xce, 0xab, 0x88, 0x81, 0xea, 0xfa, 0x45, 0x80, 0xc8, 0x8e, 0xd6, 0xd3, 0xce, 0x3c, 0xe4, 0x56,
-	0x5e, 0x45, 0xb6, 0xbd, 0x37, 0xd0, 0xbe, 0x0c, 0x90, 0x78, 0xa2, 0xf5, 0xac, 0x33, 0x8f, 0xb9,
+	0x8f, 0x60, 0x6a, 0xcf, 0x43, 0x7b, 0x60, 0x51, 0x0b, 0x42, 0x61, 0x9b, 0xbe, 0xe3, 0xf6, 0x36,
-	0x35, 0x12, 0x98, 0xda, 0xcb, 0xd0, 0xea, 0x5b, 0xd4, 0x82, 0x1c, 0xcb, 0x45, 0x21, 0xf1, 0xf5,
+	0x98, 0x82, 0xc4, 0x07, 0xe3, 0x57, 0x5e, 0x37, 0x13, 0x57, 0x5e, 0x9f, 0x85, 0xf2, 0xe9, 0x78,
-	0x0d, 0xa6, 0x20, 0xe9, 0xc9, 0xf4, 0x95, 0xd7, 0xcd, 0xb1, 0x2b, 0xaf, 0x2f, 0x41, 0xf9, 0xd4,
+	0xd4, 0xbb, 0x92, 0xb6, 0xb8, 0x6f, 0x8d, 0x47, 0x3a, 0x85, 0xa5, 0xcb, 0xac, 0x4f, 0x3f, 0xee,
-	0xb1, 0xf5, 0x4b, 0x59, 0x8b, 0xfb, 0xd0, 0xb1, 0x0d, 0x0a, 0xcb, 0x96, 0x59, 0x5f, 0x78, 0xd6,
+	0xad, 0xd8, 0xab, 0x8f, 0x71, 0x2b, 0xf6, 0x99, 0x22, 0x1e, 0xeb, 0x07, 0x00, 0xe1, 0xb9, 0x57,
-	0x5b, 0xb1, 0x97, 0x9f, 0xe1, 0x56, 0xec, 0x8b, 0xf3, 0x78, 0xac, 0x1f, 0x00, 0xc4, 0x71, 0x6f,
+	0xf0, 0x4b, 0xa3, 0x37, 0xa1, 0x35, 0xb4, 0xd0, 0xa1, 0x64, 0x1f, 0xa9, 0xe1, 0x8d, 0x67, 0x9c,
-	0xce, 0x2f, 0x8d, 0xde, 0x86, 0x85, 0x81, 0x65, 0x63, 0x33, 0x3f, 0xa4, 0xc6, 0x37, 0x9e, 0xbb,
+	0x06, 0xc3, 0xe0, 0x29, 0xf4, 0xe2, 0x3e, 0xac, 0x28, 0xba, 0xb9, 0xda, 0x77, 0xf3, 0xcf, 0xaf,
-	0x05, 0x03, 0x06, 0xd1, 0x28, 0xf6, 0xe2, 0x21, 0xac, 0x28, 0xba, 0xb9, 0xda, 0x77, 0x27, 0xc7,
+	0xeb, 0xe9, 0x80, 0x3a, 0xa3, 0x25, 0xac, 0x3e, 0xce, 0xfe, 0x5c, 0x81, 0xcb, 0x59, 0xcd, 0xe8,
-	0xaf, 0x6b, 0xd9, 0x84, 0x3a, 0xa7, 0x25, 0xac, 0x0e, 0x67, 0x7f, 0xaa, 0xc0, 0xc5, 0xbc, 0x66,
+	0x31, 0x3c, 0x7d, 0x48, 0x3f, 0x12, 0x32, 0xcc, 0xd8, 0x57, 0x42, 0x46, 0x50, 0xf3, 0xe5, 0xa2,
-	0xb4, 0x03, 0x2f, 0x1c, 0xa2, 0xc0, 0xea, 0x99, 0x28, 0xf5, 0x95, 0x90, 0x19, 0xd5, 0x7c, 0xb9,
+	0x79, 0x29, 0x56, 0x61, 0xcd, 0xfe, 0xaa, 0x08, 0x37, 0xbe, 0x79, 0x98, 0xf3, 0xd1, 0xd1, 0x5d,
-	0x68, 0x5e, 0x4b, 0x55, 0x58, 0xf3, 0xbf, 0x2a, 0xea, 0x16, 0x8c, 0xcd, 0xc3, 0x09, 0x1f, 0x1d,
+	0xe8, 0x22, 0x11, 0xe3, 0x13, 0x72, 0x16, 0xae, 0xc0, 0x25, 0x19, 0xab, 0x6b, 0xc5, 0xbf, 0xb2,
-	0xdd, 0x87, 0x0e, 0xf2, 0x2c, 0xf3, 0x53, 0x3c, 0x8a, 0x77, 0xe0, 0x92, 0x4c, 0xd5, 0xb5, 0xd2,
+	0x42, 0xa2, 0x1d, 0x33, 0xfe, 0xdd, 0xd5, 0xf7, 0xa0, 0xe7, 0xb0, 0xb6, 0x84, 0x61, 0x89, 0x86,
-	0x5f, 0x59, 0x75, 0x0b, 0x46, 0x1b, 0xa5, 0xbf, 0xbb, 0xfa, 0x1e, 0xe8, 0x84, 0xb5, 0x25, 0x4c,
+	0x54, 0x48, 0xaf, 0x9c, 0xee, 0x8a, 0xaa, 0x7b, 0x57, 0xb4, 0x2b, 0xea, 0xa8, 0xbb, 0x5a, 0x21,
-	0x4b, 0x34, 0xa4, 0x62, 0x7a, 0xe5, 0x6c, 0x57, 0x54, 0xdd, 0xbb, 0xea, 0x16, 0x8c, 0x35, 0xa2,
+	0xfd, 0x89, 0xe8, 0xf5, 0x84, 0xf4, 0x2b, 0x59, 0xf4, 0x93, 0x6d, 0xa1, 0x90, 0x7e, 0xaa, 0x61,
-	0xee, 0x6a, 0xc5, 0xf4, 0x3d, 0xd1, 0xeb, 0x89, 0xe9, 0x57, 0xf2, 0xe8, 0x8f, 0xb7, 0x85, 0x62,
+	0x74, 0x04, 0x9b, 0x82, 0xbe, 0x19, 0x36, 0x12, 0xc3, 0x25, 0xf8, 0x01, 0xf7, 0x42, 0x7a, 0x09,
-	0xfa, 0x99, 0x86, 0xd1, 0x11, 0x6c, 0x0a, 0xfa, 0x28, 0x6e, 0x24, 0xc6, 0x5b, 0xf0, 0x00, 0xf7,
+	0x45, 0xdb, 0x11, 0x57, 0x59, 0x77, 0x32, 0x7b, 0x92, 0x24, 0x5c, 0x88, 0x75, 0x75, 0x59, 0xb8,
-	0x4a, 0x76, 0x0b, 0x45, 0xdb, 0xb1, 0x5b, 0x30, 0xd6, 0x49, 0x6e, 0x4f, 0x12, 0xc7, 0x1b, 0xb1,
+	0x10, 0x2e, 0x54, 0x4b, 0x7b, 0xc7, 0xac, 0x1e, 0x30, 0x6d, 0xbc, 0x3b, 0x19, 0xb0, 0x50, 0xc3,
-	0xae, 0x2e, 0x4b, 0x17, 0xe2, 0x8d, 0x6a, 0x59, 0xef, 0x98, 0xd7, 0x03, 0xee, 0x16, 0x0c, 0x21,
+	0x8f, 0x43, 0x0d, 0x8f, 0xb4, 0x04, 0xb4, 0xf7, 0xf2, 0x35, 0xfc, 0x4a, 0x46, 0xdb, 0x88, 0x5f,
-	0x93, 0x2c, 0x2c, 0xd6, 0xf0, 0xe3, 0x58, 0xc3, 0x13, 0x2d, 0x01, 0xed, 0xfd, 0xc9, 0x1a, 0x7e,
+	0x2c, 0x50, 0x6b, 0xf5, 0x73, 0xd0, 0x8a, 0xde, 0x5c, 0x58, 0x0d, 0x3f, 0xee, 0x2b, 0x87, 0x77,
-	0x29, 0xa7, 0x6d, 0xc4, 0x2f, 0x16, 0xa8, 0xb5, 0xfa, 0x2a, 0x2c, 0x24, 0x6f, 0x2e, 0xac, 0xc6,
+	0x1c, 0x7e, 0x57, 0x82, 0xf2, 0x03, 0x53, 0x7d, 0x2b, 0x62, 0xf6, 0xc7, 0x6e, 0x29, 0xcf, 0x56,
-	0x1f, 0xf7, 0x95, 0xe3, 0x3b, 0x0e, 0xbf, 0x2d, 0x42, 0xf9, 0x11, 0x52, 0xdf, 0x8a, 0x98, 0xfe,
+	0x3e, 0xf7, 0x37, 0x22, 0x85, 0xbe, 0xe0, 0xba, 0x06, 0x0d, 0x79, 0xc2, 0x64, 0xec, 0xef, 0x23,
-	0xb1, 0x5b, 0xc6, 0xb3, 0x95, 0xcf, 0xfc, 0x8d, 0xc8, 0x5c, 0x5f, 0x70, 0x5d, 0x81, 0x86, 0x8c,
+	0x58, 0xfa, 0x20, 0x51, 0x6f, 0x7a, 0x82, 0x1f, 0x93, 0xfc, 0x1e, 0xa5, 0x87, 0x6e, 0x5e, 0x29,
-	0x30, 0x39, 0xcf, 0xf7, 0x31, 0x2c, 0x7d, 0x30, 0x56, 0x6f, 0x7a, 0x8e, 0x1f, 0x93, 0xfc, 0xae,
+	0xbd, 0x2b, 0xd0, 0xa4, 0xbf, 0xde, 0xc4, 0xec, 0xcb, 0x7b, 0x25, 0xe1, 0x00, 0x0d, 0xfe, 0x26,
-	0x08, 0xe5, 0x0f, 0x1d, 0x5b, 0x29, 0xbd, 0x4b, 0xd0, 0xa4, 0xbf, 0x81, 0x87, 0x7a, 0xf2, 0x5e,
+	0x18, 0x0f, 0x5a, 0xa7, 0x22, 0xca, 0x13, 0x4f, 0x74, 0x16, 0x06, 0x27, 0xae, 0x75, 0x38, 0xf5,
-	0x49, 0x3c, 0x41, 0x93, 0x3f, 0xcf, 0xc7, 0x03, 0xeb, 0x54, 0x64, 0x79, 0x62, 0x44, 0x57, 0xa1,
+	0x89, 0xf8, 0x4c, 0x2f, 0x1c, 0xa0, 0xa1, 0xcc, 0x23, 0x17, 0x0d, 0x82, 0x0c, 0x44, 0x0a, 0x2e,
-	0x30, 0xf4, 0xad, 0xc3, 0x61, 0x88, 0xc5, 0x67, 0x7a, 0xf1, 0x04, 0x4d, 0x65, 0x9e, 0xfa, 0xc8,
+	0x1f, 0xcf, 0xdd, 0xc7, 0xbc, 0xf5, 0x22, 0x74, 0x1c, 0xf7, 0x48, 0xe2, 0x1a, 0x27, 0x3b, 0xb7,
-	0xf3, 0x70, 0x5f, 0x1c, 0xc1, 0xe5, 0xf0, 0xcc, 0x7d, 0xcc, 0xdb, 0xaf, 0x42, 0x9b, 0xf8, 0x47,
+	0x16, 0xc5, 0xb7, 0xab, 0xfb, 0xf4, 0xeb, 0xcf, 0xfd, 0xd2, 0x2f, 0x17, 0xca, 0x7b, 0xbb, 0x07,
-	0x12, 0xd7, 0x3c, 0xd9, 0xb9, 0xbd, 0x28, 0xbe, 0x5d, 0xdd, 0xf7, 0x49, 0x48, 0xf6, 0x8b, 0xbf,
+	0x87, 0x35, 0xf6, 0x31, 0xe8, 0xeb, 0xff, 0x0a, 0x00, 0x00, 0xff, 0xff, 0xd4, 0x0a, 0xef, 0xca,
-	0x28, 0x95, 0xf7, 0x76, 0x0f, 0x0e, 0x6b, 0xec, 0x63, 0xd0, 0x37, 0xff, 0x19, 0x00, 0x00, 0xff,
+	0xe4, 0x3a, 0x00, 0x00,
 	0xff, 0xd4, 0x0a, 0xef, 0xca, 0xe4, 0x3a, 0x00, 0x00,
 }
--- a/vendor/github.com/googleapis/gnostic/extensions/extension.pb.go
+++ b/vendor/github.com/googleapis/gnostic/extensions/extension.pb.go
@ -273,28 +273,28 @@ func init() {
 func init() { proto.RegisterFile("extensions/extension.proto", fileDescriptor_661e47e790f76671) }
 var fileDescriptor_661e47e790f76671 = []byte{
-	// 362 bytes of a gzipped FileDescriptorProto
+	// 360 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x91, 0x4d, 0x4b, 0xeb, 0x40,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x74, 0x91, 0xdf, 0x4b, 0xeb, 0x30,
-	0x18, 0x85, 0x49, 0xbf, 0x72, 0x33, 0x97, 0xdb, 0x2b, 0x63, 0xd1, 0x58, 0x5c, 0x94, 0x80, 0x50,
+	0x1c, 0xc5, 0xe9, 0x7e, 0xf5, 0xee, 0x7b, 0xb9, 0xbb, 0x12, 0x87, 0xd6, 0xe1, 0x83, 0x14, 0x04,
-	0x44, 0xa6, 0x54, 0xc1, 0x7d, 0x0b, 0x45, 0xdd, 0xd8, 0x32, 0x8b, 0xba, 0xb3, 0x4c, 0xd3, 0xb7,
+	0x11, 0xe9, 0x98, 0x82, 0xef, 0x1b, 0x0c, 0xf5, 0xc5, 0x8d, 0x3c, 0xcc, 0x37, 0x47, 0xd6, 0x65,
-	0x69, 0x24, 0x99, 0x19, 0x27, 0x1f, 0xb6, 0x7f, 0xc5, 0xa5, 0xbf, 0x54, 0x32, 0x93, 0xc4, 0x85,
+	0x5d, 0xa5, 0x4d, 0x62, 0xfa, 0xc3, 0xed, 0x5f, 0xf1, 0xd1, 0xbf, 0xd4, 0x34, 0x69, 0xeb, 0x83,
-	0xba, 0x9b, 0xf3, 0x70, 0xda, 0xf7, 0x9c, 0x13, 0xd4, 0x87, 0x7d, 0x0a, 0x3c, 0x09, 0x05, 0x4f,
+	0xfa, 0x96, 0xf3, 0xe1, 0x34, 0x39, 0xe7, 0x14, 0x06, 0x74, 0x97, 0x52, 0x96, 0x84, 0x9c, 0x25,
-	0x46, 0xf5, 0x93, 0x48, 0x25, 0x52, 0x81, 0x8f, 0x85, 0x04, 0xce, 0x64, 0xf8, 0xc5, 0xf3, 0x71,
+	0xc3, 0xfa, 0xe8, 0x09, 0xc9, 0x53, 0x8e, 0x0e, 0xb9, 0xa0, 0x8c, 0x88, 0xf0, 0x8b, 0xe7, 0xa3,
-	0xff, 0x2c, 0x10, 0x22, 0x88, 0x60, 0xa4, 0x2d, 0xeb, 0x6c, 0x3b, 0x62, 0xfc, 0x60, 0xfc, 0x9e,
+	0xc1, 0x49, 0xc0, 0x79, 0x10, 0xd1, 0xa1, 0xb6, 0xac, 0xb2, 0xcd, 0x90, 0xb0, 0xbd, 0xf1, 0xbb,
-	0x8f, 0xec, 0x25, 0xa8, 0xc2, 0x88, 0x7b, 0xa8, 0x1d, 0xb3, 0x17, 0xa1, 0x5c, 0x6b, 0x60, 0x0d,
+	0x3e, 0xd8, 0x0b, 0x2a, 0x0b, 0x23, 0xea, 0x43, 0x3b, 0x26, 0x2f, 0x5c, 0x3a, 0xd6, 0x99, 0x75,
-	0xdb, 0xd4, 0x08, 0x4d, 0x43, 0x2e, 0x94, 0xdb, 0x28, 0x69, 0x21, 0x0a, 0x2a, 0x59, 0xea, 0xef,
+	0xd1, 0xc6, 0x46, 0x68, 0x1a, 0x32, 0x45, 0x1b, 0x25, 0x2d, 0x44, 0x41, 0x05, 0x49, 0xfd, 0xad,
-	0xdc, 0xa6, 0xa1, 0x5a, 0xe0, 0x13, 0xd4, 0x49, 0xb2, 0xed, 0x36, 0xdc, 0xbb, 0xad, 0x81, 0x35,
+	0xd3, 0x34, 0x54, 0x0b, 0x74, 0x04, 0x9d, 0x24, 0xdb, 0x6c, 0xc2, 0x9d, 0xd3, 0x52, 0xb8, 0x8b,
-	0x74, 0x68, 0xa9, 0xbc, 0x77, 0x0b, 0x9d, 0xce, 0xaa, 0x40, 0xf7, 0x8c, 0x6f, 0x22, 0x50, 0x14,
+	0x4b, 0xe5, 0xbe, 0x5b, 0x70, 0x3c, 0xad, 0x02, 0xdd, 0x13, 0xb6, 0x8e, 0xa8, 0xc4, 0xf4, 0x35,
-	0x5e, 0x33, 0x48, 0x52, 0x7c, 0x8b, 0xec, 0x37, 0xc5, 0xa4, 0x04, 0x73, 0xf7, 0xef, 0xf5, 0x39,
+	0xa3, 0x49, 0x8a, 0x6e, 0xc1, 0x7e, 0x93, 0x44, 0x08, 0x6a, 0xde, 0xfd, 0x7b, 0x7d, 0xea, 0xfd,
-	0xf9, 0xa1, 0x02, 0x79, 0x32, 0x1e, 0x5a, 0x99, 0xf1, 0x1d, 0x3a, 0xf2, 0x45, 0x2c, 0xc3, 0x08,
+	0x50, 0xc1, 0x7b, 0x32, 0x1e, 0x5c, 0x99, 0xd1, 0x1d, 0x1c, 0xf8, 0x3c, 0x16, 0xa1, 0xba, 0x6a,
-	0xd4, 0x2a, 0x37, 0x0d, 0x74, 0x98, 0xdf, 0xfe, 0xa0, 0x6c, 0x49, 0xff, 0x57, 0xbf, 0x2a, 0x81,
+	0x99, 0x9b, 0x06, 0x3a, 0xcc, 0x6f, 0x17, 0x94, 0x2d, 0xf1, 0xff, 0xea, 0xab, 0x12, 0xb8, 0x39,
-	0x97, 0x23, 0xf7, 0x7b, 0xb6, 0x44, 0x0a, 0x9e, 0x00, 0x76, 0x91, 0xbd, 0xd3, 0x68, 0xa3, 0xc3,
+	0x38, 0xdf, 0xb3, 0x25, 0x42, 0x8d, 0x4b, 0x91, 0x03, 0xf6, 0x56, 0xa3, 0xb5, 0x0e, 0xf7, 0x07,
-	0xfd, 0xa1, 0x95, 0x2c, 0x06, 0x00, 0xa5, 0xf4, 0x2c, 0xcd, 0xa1, 0x43, 0x8d, 0xc0, 0x97, 0xa8,
+	0x57, 0xb2, 0x18, 0x80, 0x4a, 0xa9, 0x67, 0x69, 0xaa, 0xa6, 0x46, 0xa0, 0x4b, 0x68, 0xe7, 0x24,
-	0x9d, 0xb3, 0x28, 0x83, 0x32, 0x49, 0x8f, 0x98, 0xe1, 0x49, 0x35, 0x3c, 0x99, 0xf0, 0x03, 0x35,
+	0xca, 0x68, 0x99, 0xa4, 0xef, 0x99, 0xe1, 0xbd, 0x6a, 0x78, 0x6f, 0xcc, 0xf6, 0xd8, 0x58, 0xdc,
-	0x16, 0xef, 0x19, 0xd9, 0x65, 0xa9, 0xe2, 0x4c, 0x55, 0xc1, 0xd2, 0xc3, 0x55, 0x12, 0x5f, 0xa0,
+	0x67, 0xb0, 0xcb, 0x52, 0xc5, 0x33, 0x55, 0x05, 0x4b, 0x0f, 0x57, 0x49, 0x74, 0x0e, 0xbd, 0xba,
-	0x6e, 0xdd, 0x62, 0xc5, 0x59, 0x0c, 0xfa, 0x33, 0x38, 0xf4, 0x5f, 0x4d, 0x1f, 0x59, 0x0c, 0x18,
+	0xc5, 0x92, 0x91, 0x98, 0xea, 0xdf, 0xd0, 0xc5, 0xff, 0x6a, 0xfa, 0xa8, 0x20, 0x42, 0xd0, 0xda,
-	0xa3, 0xd6, 0x81, 0xc5, 0x91, 0x3e, 0xeb, 0x50, 0xfd, 0x9e, 0x5e, 0xa1, 0xae, 0x50, 0x01, 0x09,
+	0x93, 0x38, 0xd2, 0xcf, 0x76, 0xb1, 0x3e, 0x4f, 0xae, 0xa0, 0xc7, 0x65, 0xe0, 0x05, 0x8c, 0x27,
-	0xb8, 0x48, 0xd2, 0xd0, 0x27, 0xf9, 0x78, 0x8a, 0xe7, 0x12, 0xf8, 0x64, 0xf1, 0x50, 0xd7, 0x5d,
+	0x69, 0xe8, 0xab, 0x09, 0x26, 0x68, 0xa6, 0x76, 0x19, 0xcf, 0x1f, 0xea, 0xba, 0x8b, 0xd1, 0xdc,
-	0x8e, 0x17, 0xd6, 0x47, 0xa3, 0x39, 0x9f, 0xcc, 0xd6, 0x1d, 0x1d, 0xf1, 0xe6, 0x33, 0x00, 0x00,
+	0xfa, 0x68, 0x34, 0x67, 0xe3, 0xe9, 0xaa, 0xa3, 0x23, 0xde, 0x7c, 0x06, 0x00, 0x00, 0xff, 0xff,
-	0xff, 0xff, 0xeb, 0xf3, 0xfa, 0x65, 0x5c, 0x02, 0x00, 0x00,
+	0xeb, 0xf3, 0xfa, 0x65, 0x5c, 0x02, 0x00, 0x00,
 }
--- a/vendor/gomodules.xyz/jsonpatch/v2/LICENSE
+++ b/vendor/gomodules.xyz/jsonpatch/v2/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.
--- a/vendor/gomodules.xyz/jsonpatch/v2/go.mod
+++ b/vendor/gomodules.xyz/jsonpatch/v2/go.mod
@ -0,0 +1,9 @@
 module gomodules.xyz/jsonpatch/v2
 go 1.12
 require (
 	github.com/evanphx/json-patch v4.5.0+incompatible
 	github.com/pkg/errors v0.8.1 // indirect
 	github.com/stretchr/testify v1.3.0
 )
--- a/vendor/gomodules.xyz/jsonpatch/v2/go.sum
+++ b/vendor/gomodules.xyz/jsonpatch/v2/go.sum
@ -0,0 +1,11 @@
 github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/evanphx/json-patch v4.5.0+incompatible h1:ouOWdg56aJriqS0huScTkVXPC5IcNrDCXZ6OoTAWu7M=
 github.com/evanphx/json-patch v4.5.0+incompatible/go.mod h1:50XU6AFN0ol/bzJsmQLiYLvXMP4fmwYFNcr97nuDLSk=
 github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I=
 github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
--- a/vendor/gomodules.xyz/jsonpatch/v2/jsonpatch.go
+++ b/vendor/gomodules.xyz/jsonpatch/v2/jsonpatch.go
@ -0,0 +1,336 @@
 package jsonpatch
 import (
 	"bytes"
 	"encoding/json"
 	"fmt"
 	"reflect"
 	"strings"
 )
 var errBadJSONDoc = fmt.Errorf("invalid JSON Document")
 type JsonPatchOperation = Operation
 type Operation struct {
 	Operation string      `json:"op"`
 	Path      string      `json:"path"`
 	Value     interface{} `json:"value,omitempty"`
 }
 func (j *Operation) Json() string {
 	b, _ := json.Marshal(j)
 	return string(b)
 }
 func (j *Operation) MarshalJSON() ([]byte, error) {
 	var b bytes.Buffer
 	b.WriteString("{")
 	b.WriteString(fmt.Sprintf(`"op":"%s"`, j.Operation))
 	b.WriteString(fmt.Sprintf(`,"path":"%s"`, j.Path))
 	// Consider omitting Value for non-nullable operations.
 	if j.Value != nil || j.Operation == "replace" || j.Operation == "add" {
 		v, err := json.Marshal(j.Value)
 		if err != nil {
 			return nil, err
 		}
 		b.WriteString(`,"value":`)
 		b.Write(v)
 	}
 	b.WriteString("}")
 	return b.Bytes(), nil
 }
 type ByPath []Operation
 func (a ByPath) Len() int           { return len(a) }
 func (a ByPath) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
 func (a ByPath) Less(i, j int) bool { return a[i].Path < a[j].Path }
 func NewPatch(operation, path string, value interface{}) Operation {
 	return Operation{Operation: operation, Path: path, Value: value}
 }
 // CreatePatch creates a patch as specified in http://jsonpatch.com/
 //
 // 'a' is original, 'b' is the modified document. Both are to be given as json encoded content.
 // The function will return an array of JsonPatchOperations
 //
 // An error will be returned if any of the two documents are invalid.
 func CreatePatch(a, b []byte) ([]Operation, error) {
 	var aI interface{}
 	var bI interface{}
 	err := json.Unmarshal(a, &aI)
 	if err != nil {
 		return nil, errBadJSONDoc
 	}
 	err = json.Unmarshal(b, &bI)
 	if err != nil {
 		return nil, errBadJSONDoc
 	}
 	return handleValues(aI, bI, "", []Operation{})
 }
 // Returns true if the values matches (must be json types)
 // The types of the values must match, otherwise it will always return false
 // If two map[string]interface{} are given, all elements must match.
 func matchesValue(av, bv interface{}) bool {
 	if reflect.TypeOf(av) != reflect.TypeOf(bv) {
 		return false
 	}
 	switch at := av.(type) {
 	case string:
 		bt, ok := bv.(string)
 		if ok && bt == at {
 			return true
 		}
 	case float64:
 		bt, ok := bv.(float64)
 		if ok && bt == at {
 			return true
 		}
 	case bool:
 		bt, ok := bv.(bool)
 		if ok && bt == at {
 			return true
 		}
 	case map[string]interface{}:
 		bt, ok := bv.(map[string]interface{})
 		if !ok {
 			return false
 		}
 		for key := range at {
 			if !matchesValue(at[key], bt[key]) {
 				return false
 			}
 		}
 		for key := range bt {
 			if !matchesValue(at[key], bt[key]) {
 				return false
 			}
 		}
 		return true
 	case []interface{}:
 		bt, ok := bv.([]interface{})
 		if !ok {
 			return false
 		}
 		if len(bt) != len(at) {
 			return false
 		}
 		for key := range at {
 			if !matchesValue(at[key], bt[key]) {
 				return false
 			}
 		}
 		for key := range bt {
 			if !matchesValue(at[key], bt[key]) {
 				return false
 			}
 		}
 		return true
 	}
 	return false
 }
 // From http://tools.ietf.org/html/rfc6901#section-4 :
 //
 // Evaluation of each reference token begins by decoding any escaped
 // character sequence.  This is performed by first transforming any
 // occurrence of the sequence '~1' to '/', and then transforming any
 // occurrence of the sequence '~0' to '~'.
 //   TODO decode support:
 //   var rfc6901Decoder = strings.NewReplacer("~1", "/", "~0", "~")
 var rfc6901Encoder = strings.NewReplacer("~", "~0", "/", "~1")
 func makePath(path string, newPart interface{}) string {
 	key := rfc6901Encoder.Replace(fmt.Sprintf("%v", newPart))
 	if path == "" {
 		return "/" + key
 	}
 	if strings.HasSuffix(path, "/") {
 		return path + key
 	}
 	return path + "/" + key
 }
 // diff returns the (recursive) difference between a and b as an array of JsonPatchOperations.
 func diff(a, b map[string]interface{}, path string, patch []Operation) ([]Operation, error) {
 	for key, bv := range b {
 		p := makePath(path, key)
 		av, ok := a[key]
 		// value was added
 		if !ok {
 			patch = append(patch, NewPatch("add", p, bv))
 			continue
 		}
 		// Types are the same, compare values
 		var err error
 		patch, err = handleValues(av, bv, p, patch)
 		if err != nil {
 			return nil, err
 		}
 	}
 	// Now add all deleted values as nil
 	for key := range a {
 		_, found := b[key]
 		if !found {
 			p := makePath(path, key)
 			patch = append(patch, NewPatch("remove", p, nil))
 		}
 	}
 	return patch, nil
 }
 func handleValues(av, bv interface{}, p string, patch []Operation) ([]Operation, error) {
 	{
 		at := reflect.TypeOf(av)
 		bt := reflect.TypeOf(bv)
 		if at == nil && bt == nil {
 			// do nothing
 			return patch, nil
 		} else if at == nil && bt != nil {
 			return append(patch, NewPatch("add", p, bv)), nil
 		} else if at != bt {
 			// If types have changed, replace completely (preserves null in destination)
 			return append(patch, NewPatch("replace", p, bv)), nil
 		}
 	}
 	var err error
 	switch at := av.(type) {
 	case map[string]interface{}:
 		bt := bv.(map[string]interface{})
 		patch, err = diff(at, bt, p, patch)
 		if err != nil {
 			return nil, err
 		}
 	case string, float64, bool:
 		if !matchesValue(av, bv) {
 			patch = append(patch, NewPatch("replace", p, bv))
 		}
 	case []interface{}:
 		bt := bv.([]interface{})
 		if isSimpleArray(at) && isSimpleArray(bt) {
 			patch = append(patch, compareEditDistance(at, bt, p)...)
 		} else {
 			n := min(len(at), len(bt))
 			for i := len(at) - 1; i >= n; i-- {
 				patch = append(patch, NewPatch("remove", makePath(p, i), nil))
 			}
 			for i := n; i < len(bt); i++ {
 				patch = append(patch, NewPatch("add", makePath(p, i), bt[i]))
 			}
 			for i := 0; i < n; i++ {
 				var err error
 				patch, err = handleValues(at[i], bt[i], makePath(p, i), patch)
 				if err != nil {
 					return nil, err
 				}
 			}
 		}
 	default:
 		panic(fmt.Sprintf("Unknown type:%T ", av))
 	}
 	return patch, nil
 }
 func isBasicType(a interface{}) bool {
 	switch a.(type) {
 	case string, float64, bool:
 	default:
 		return false
 	}
 	return true
 }
 func isSimpleArray(a []interface{}) bool {
 	for i := range a {
 		switch a[i].(type) {
 		case string, float64, bool:
 		default:
 			val := reflect.ValueOf(a[i])
 			if val.Kind() == reflect.Map {
 				for _, k := range val.MapKeys() {
 					av := val.MapIndex(k)
 					if av.Kind() == reflect.Ptr || av.Kind() == reflect.Interface {
 						if av.IsNil() {
 							continue
 						}
 						av = av.Elem()
 					}
 					if av.Kind() != reflect.String && av.Kind() != reflect.Float64 && av.Kind() != reflect.Bool {
 						return false
 					}
 				}
 				return true
 			}
 			return false
 		}
 	}
 	return true
 }
 // https://en.wikipedia.org/wiki/Wagner%E2%80%93Fischer_algorithm
 // Adapted from https://github.com/texttheater/golang-levenshtein
 func compareEditDistance(s, t []interface{}, p string) []Operation {
 	m := len(s)
 	n := len(t)
 	d := make([][]int, m+1)
 	for i := 0; i <= m; i++ {
 		d[i] = make([]int, n+1)
 		d[i][0] = i
 	}
 	for j := 0; j <= n; j++ {
 		d[0][j] = j
 	}
 	for j := 1; j <= n; j++ {
 		for i := 1; i <= m; i++ {
 			if reflect.DeepEqual(s[i-1], t[j-1]) {
 				d[i][j] = d[i-1][j-1] // no op required
 			} else {
 				del := d[i-1][j] + 1
 				add := d[i][j-1] + 1
 				rep := d[i-1][j-1] + 1
 				d[i][j] = min(rep, min(add, del))
 			}
 		}
 	}
 	return backtrace(s, t, p, m, n, d)
 }
 func min(x int, y int) int {
 	if y < x {
 		return y
 	}
 	return x
 }
 func backtrace(s, t []interface{}, p string, i int, j int, matrix [][]int) []Operation {
 	if i > 0 && matrix[i-1][j]+1 == matrix[i][j] {
 		op := NewPatch("remove", makePath(p, i-1), nil)
 		return append([]Operation{op}, backtrace(s, t, p, i-1, j, matrix)...)
 	}
 	if j > 0 && matrix[i][j-1]+1 == matrix[i][j] {
 		op := NewPatch("add", makePath(p, i), t[j-1])
 		return append([]Operation{op}, backtrace(s, t, p, i, j-1, matrix)...)
 	}
 	if i > 0 && j > 0 && matrix[i-1][j-1]+1 == matrix[i][j] {
 		if isBasicType(s[0]) {
 			op := NewPatch("replace", makePath(p, i-1), t[j-1])
 			return append([]Operation{op}, backtrace(s, t, p, i-1, j-1, matrix)...)
 		}
 		p2, _ := handleValues(s[i-1], t[j-1], makePath(p, i-1), []Operation{})
 		return append(p2, backtrace(s, t, p, i-1, j-1, matrix)...)
 	}
 	if i > 0 && j > 0 && matrix[i-1][j-1] == matrix[i][j] {
 		return backtrace(s, t, p, i-1, j-1, matrix)
 	}
 	return []Operation{}
 }
--- a/vendor/k8s.io/client-go/tools/leaderelection/OWNERS
+++ b/vendor/k8s.io/client-go/tools/leaderelection/OWNERS
@ -0,0 +1,14 @@
 # See the OWNERS docs at https://go.k8s.io/owners
 approvers:
 - mikedanese
 - timothysc
 reviewers:
 - wojtek-t
 - deads2k
 - mikedanese
 - gmarek
 - eparis
 - timothysc
 - ingvagabund
 - resouer
--- a/vendor/k8s.io/client-go/tools/leaderelection/healthzadaptor.go
+++ b/vendor/k8s.io/client-go/tools/leaderelection/healthzadaptor.go
@ -0,0 +1,69 @@
 /*
 Copyright 2015 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package leaderelection
 import (
 	"net/http"
 	"sync"
 	"time"
 )
 // HealthzAdaptor associates the /healthz endpoint with the LeaderElection object.
 // It helps deal with the /healthz endpoint being set up prior to the LeaderElection.
 // This contains the code needed to act as an adaptor between the leader
 // election code the health check code. It allows us to provide health
 // status about the leader election. Most specifically about if the leader
 // has failed to renew without exiting the process. In that case we should
 // report not healthy and rely on the kubelet to take down the process.
 type HealthzAdaptor struct {
 	pointerLock sync.Mutex
 	le          *LeaderElector
 	timeout     time.Duration
 }
 // Name returns the name of the health check we are implementing.
 func (l *HealthzAdaptor) Name() string {
 	return "leaderElection"
 }
 // Check is called by the healthz endpoint handler.
 // It fails (returns an error) if we own the lease but had not been able to renew it.
 func (l *HealthzAdaptor) Check(req *http.Request) error {
 	l.pointerLock.Lock()
 	defer l.pointerLock.Unlock()
 	if l.le == nil {
 		return nil
 	}
 	return l.le.Check(l.timeout)
 }
 // SetLeaderElection ties a leader election object to a HealthzAdaptor
 func (l *HealthzAdaptor) SetLeaderElection(le *LeaderElector) {
 	l.pointerLock.Lock()
 	defer l.pointerLock.Unlock()
 	l.le = le
 }
 // NewLeaderHealthzAdaptor creates a basic healthz adaptor to monitor a leader election.
 // timeout determines the time beyond the lease expiry to be allowed for timeout.
 // checks within the timeout period after the lease expires will still return healthy.
 func NewLeaderHealthzAdaptor(timeout time.Duration) *HealthzAdaptor {
 	result := &HealthzAdaptor{
 		timeout: timeout,
 	}
 	return result
 }
--- a/vendor/k8s.io/client-go/tools/leaderelection/leaderelection.go
+++ b/vendor/k8s.io/client-go/tools/leaderelection/leaderelection.go
@ -0,0 +1,389 @@
 /*
 Copyright 2015 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 // Package leaderelection implements leader election of a set of endpoints.
 // It uses an annotation in the endpoints object to store the record of the
 // election state. This implementation does not guarantee that only one
 // client is acting as a leader (a.k.a. fencing).
 //
 // A client only acts on timestamps captured locally to infer the state of the
 // leader election. The client does not consider timestamps in the leader
 // election record to be accurate because these timestamps may not have been
 // produced by a local clock. The implemention does not depend on their
 // accuracy and only uses their change to indicate that another client has
 // renewed the leader lease. Thus the implementation is tolerant to arbitrary
 // clock skew, but is not tolerant to arbitrary clock skew rate.
 //
 // However the level of tolerance to skew rate can be configured by setting
 // RenewDeadline and LeaseDuration appropriately. The tolerance expressed as a
 // maximum tolerated ratio of time passed on the fastest node to time passed on
 // the slowest node can be approximately achieved with a configuration that sets
 // the same ratio of LeaseDuration to RenewDeadline. For example if a user wanted
 // to tolerate some nodes progressing forward in time twice as fast as other nodes,
 // the user could set LeaseDuration to 60 seconds and RenewDeadline to 30 seconds.
 //
 // While not required, some method of clock synchronization between nodes in the
 // cluster is highly recommended. It's important to keep in mind when configuring
 // this client that the tolerance to skew rate varies inversely to master
 // availability.
 //
 // Larger clusters often have a more lenient SLA for API latency. This should be
 // taken into account when configuring the client. The rate of leader transitions
 // should be monitored and RetryPeriod and LeaseDuration should be increased
 // until the rate is stable and acceptably low. It's important to keep in mind
 // when configuring this client that the tolerance to API latency varies inversely
 // to master availability.
 //
 // DISCLAIMER: this is an alpha API. This library will likely change significantly
 // or even be removed entirely in subsequent releases. Depend on this API at
 // your own risk.
 package leaderelection
 import (
 	"bytes"
 	"context"
 	"fmt"
 	"time"
 	"k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/util/clock"
 	"k8s.io/apimachinery/pkg/util/runtime"
 	"k8s.io/apimachinery/pkg/util/wait"
 	rl "k8s.io/client-go/tools/leaderelection/resourcelock"
 	"k8s.io/klog"
 )
 const (
 	JitterFactor = 1.2
 )
 // NewLeaderElector creates a LeaderElector from a LeaderElectionConfig
 func NewLeaderElector(lec LeaderElectionConfig) (*LeaderElector, error) {
 	if lec.LeaseDuration <= lec.RenewDeadline {
 		return nil, fmt.Errorf("leaseDuration must be greater than renewDeadline")
 	}
 	if lec.RenewDeadline <= time.Duration(JitterFactor*float64(lec.RetryPeriod)) {
 		return nil, fmt.Errorf("renewDeadline must be greater than retryPeriod*JitterFactor")
 	}
 	if lec.LeaseDuration < 1 {
 		return nil, fmt.Errorf("leaseDuration must be greater than zero")
 	}
 	if lec.RenewDeadline < 1 {
 		return nil, fmt.Errorf("renewDeadline must be greater than zero")
 	}
 	if lec.RetryPeriod < 1 {
 		return nil, fmt.Errorf("retryPeriod must be greater than zero")
 	}
 	if lec.Callbacks.OnStartedLeading == nil {
 		return nil, fmt.Errorf("OnStartedLeading callback must not be nil")
 	}
 	if lec.Callbacks.OnStoppedLeading == nil {
 		return nil, fmt.Errorf("OnStoppedLeading callback must not be nil")
 	}
 	if lec.Lock == nil {
 		return nil, fmt.Errorf("Lock must not be nil.")
 	}
 	le := LeaderElector{
 		config:  lec,
 		clock:   clock.RealClock{},
 		metrics: globalMetricsFactory.newLeaderMetrics(),
 	}
 	le.metrics.leaderOff(le.config.Name)
 	return &le, nil
 }
 type LeaderElectionConfig struct {
 	// Lock is the resource that will be used for locking
 	Lock rl.Interface
 	// LeaseDuration is the duration that non-leader candidates will
 	// wait to force acquire leadership. This is measured against time of
 	// last observed ack.
 	//
 	// A client needs to wait a full LeaseDuration without observing a change to
 	// the record before it can attempt to take over. When all clients are
 	// shutdown and a new set of clients are started with different names against
 	// the same leader record, they must wait the full LeaseDuration before
 	// attempting to acquire the lease. Thus LeaseDuration should be as short as
 	// possible (within your tolerance for clock skew rate) to avoid a possible
 	// long waits in the scenario.
 	//
 	// Core clients default this value to 15 seconds.
 	LeaseDuration time.Duration
 	// RenewDeadline is the duration that the acting master will retry
 	// refreshing leadership before giving up.
 	//
 	// Core clients default this value to 10 seconds.
 	RenewDeadline time.Duration
 	// RetryPeriod is the duration the LeaderElector clients should wait
 	// between tries of actions.
 	//
 	// Core clients default this value to 2 seconds.
 	RetryPeriod time.Duration
 	// Callbacks are callbacks that are triggered during certain lifecycle
 	// events of the LeaderElector
 	Callbacks LeaderCallbacks
 	// WatchDog is the associated health checker
 	// WatchDog may be null if its not needed/configured.
 	WatchDog *HealthzAdaptor
 	// ReleaseOnCancel should be set true if the lock should be released
 	// when the run context is cancelled. If you set this to true, you must
 	// ensure all code guarded by this lease has successfully completed
 	// prior to cancelling the context, or you may have two processes
 	// simultaneously acting on the critical path.
 	ReleaseOnCancel bool
 	// Name is the name of the resource lock for debugging
 	Name string
 }
 // LeaderCallbacks are callbacks that are triggered during certain
 // lifecycle events of the LeaderElector. These are invoked asynchronously.
 //
 // possible future callbacks:
 //  * OnChallenge()
 type LeaderCallbacks struct {
 	// OnStartedLeading is called when a LeaderElector client starts leading
 	OnStartedLeading func(context.Context)
 	// OnStoppedLeading is called when a LeaderElector client stops leading
 	OnStoppedLeading func()
 	// OnNewLeader is called when the client observes a leader that is
 	// not the previously observed leader. This includes the first observed
 	// leader when the client starts.
 	OnNewLeader func(identity string)
 }
 // LeaderElector is a leader election client.
 type LeaderElector struct {
 	config LeaderElectionConfig
 	// internal bookkeeping
 	observedRecord    rl.LeaderElectionRecord
 	observedRawRecord []byte
 	observedTime      time.Time
 	// used to implement OnNewLeader(), may lag slightly from the
 	// value observedRecord.HolderIdentity if the transition has
 	// not yet been reported.
 	reportedLeader string
 	// clock is wrapper around time to allow for less flaky testing
 	clock clock.Clock
 	metrics leaderMetricsAdapter
 	// name is the name of the resource lock for debugging
 	name string
 }
 // Run starts the leader election loop
 func (le *LeaderElector) Run(ctx context.Context) {
 	defer func() {
 		runtime.HandleCrash()
 		le.config.Callbacks.OnStoppedLeading()
 	}()
 	if !le.acquire(ctx) {
 		return // ctx signalled done
 	}
 	ctx, cancel := context.WithCancel(ctx)
 	defer cancel()
 	go le.config.Callbacks.OnStartedLeading(ctx)
 	le.renew(ctx)
 }
 // RunOrDie starts a client with the provided config or panics if the config
 // fails to validate.
 func RunOrDie(ctx context.Context, lec LeaderElectionConfig) {
 	le, err := NewLeaderElector(lec)
 	if err != nil {
 		panic(err)
 	}
 	if lec.WatchDog != nil {
 		lec.WatchDog.SetLeaderElection(le)
 	}
 	le.Run(ctx)
 }
 // GetLeader returns the identity of the last observed leader or returns the empty string if
 // no leader has yet been observed.
 func (le *LeaderElector) GetLeader() string {
 	return le.observedRecord.HolderIdentity
 }
 // IsLeader returns true if the last observed leader was this client else returns false.
 func (le *LeaderElector) IsLeader() bool {
 	return le.observedRecord.HolderIdentity == le.config.Lock.Identity()
 }
 // acquire loops calling tryAcquireOrRenew and returns true immediately when tryAcquireOrRenew succeeds.
 // Returns false if ctx signals done.
 func (le *LeaderElector) acquire(ctx context.Context) bool {
 	ctx, cancel := context.WithCancel(ctx)
 	defer cancel()
 	succeeded := false
 	desc := le.config.Lock.Describe()
 	klog.Infof("attempting to acquire leader lease  %v...", desc)
 	wait.JitterUntil(func() {
 		succeeded = le.tryAcquireOrRenew(ctx)
 		le.maybeReportTransition()
 		if !succeeded {
 			klog.V(4).Infof("failed to acquire lease %v", desc)
 			return
 		}
 		le.config.Lock.RecordEvent("became leader")
 		le.metrics.leaderOn(le.config.Name)
 		klog.Infof("successfully acquired lease %v", desc)
 		cancel()
 	}, le.config.RetryPeriod, JitterFactor, true, ctx.Done())
 	return succeeded
 }
 // renew loops calling tryAcquireOrRenew and returns immediately when tryAcquireOrRenew fails or ctx signals done.
 func (le *LeaderElector) renew(ctx context.Context) {
 	ctx, cancel := context.WithCancel(ctx)
 	defer cancel()
 	wait.Until(func() {
 		timeoutCtx, timeoutCancel := context.WithTimeout(ctx, le.config.RenewDeadline)
 		defer timeoutCancel()
 		err := wait.PollImmediateUntil(le.config.RetryPeriod, func() (bool, error) {
 			return le.tryAcquireOrRenew(timeoutCtx), nil
 		}, timeoutCtx.Done())
 		le.maybeReportTransition()
 		desc := le.config.Lock.Describe()
 		if err == nil {
 			klog.V(5).Infof("successfully renewed lease %v", desc)
 			return
 		}
 		le.config.Lock.RecordEvent("stopped leading")
 		le.metrics.leaderOff(le.config.Name)
 		klog.Infof("failed to renew lease %v: %v", desc, err)
 		cancel()
 	}, le.config.RetryPeriod, ctx.Done())
 	// if we hold the lease, give it up
 	if le.config.ReleaseOnCancel {
 		le.release()
 	}
 }
 // release attempts to release the leader lease if we have acquired it.
 func (le *LeaderElector) release() bool {
 	if !le.IsLeader() {
 		return true
 	}
 	leaderElectionRecord := rl.LeaderElectionRecord{
 		LeaderTransitions: le.observedRecord.LeaderTransitions,
 	}
 	if err := le.config.Lock.Update(context.TODO(), leaderElectionRecord); err != nil {
 		klog.Errorf("Failed to release lock: %v", err)
 		return false
 	}
 	le.observedRecord = leaderElectionRecord
 	le.observedTime = le.clock.Now()
 	return true
 }
 // tryAcquireOrRenew tries to acquire a leader lease if it is not already acquired,
 // else it tries to renew the lease if it has already been acquired. Returns true
 // on success else returns false.
 func (le *LeaderElector) tryAcquireOrRenew(ctx context.Context) bool {
 	now := metav1.Now()
 	leaderElectionRecord := rl.LeaderElectionRecord{
 		HolderIdentity:       le.config.Lock.Identity(),
 		LeaseDurationSeconds: int(le.config.LeaseDuration / time.Second),
 		RenewTime:            now,
 		AcquireTime:          now,
 	}
 	// 1. obtain or create the ElectionRecord
 	oldLeaderElectionRecord, oldLeaderElectionRawRecord, err := le.config.Lock.Get(ctx)
 	if err != nil {
 		if !errors.IsNotFound(err) {
 			klog.Errorf("error retrieving resource lock %v: %v", le.config.Lock.Describe(), err)
 			return false
 		}
 		if err = le.config.Lock.Create(ctx, leaderElectionRecord); err != nil {
 			klog.Errorf("error initially creating leader election record: %v", err)
 			return false
 		}
 		le.observedRecord = leaderElectionRecord
 		le.observedTime = le.clock.Now()
 		return true
 	}
 	// 2. Record obtained, check the Identity & Time
 	if !bytes.Equal(le.observedRawRecord, oldLeaderElectionRawRecord) {
 		le.observedRecord = *oldLeaderElectionRecord
 		le.observedRawRecord = oldLeaderElectionRawRecord
 		le.observedTime = le.clock.Now()
 	}
 	if len(oldLeaderElectionRecord.HolderIdentity) > 0 &&
 		le.observedTime.Add(le.config.LeaseDuration).After(now.Time) &&
 		!le.IsLeader() {
 		klog.V(4).Infof("lock is held by %v and has not yet expired", oldLeaderElectionRecord.HolderIdentity)
 		return false
 	}
 	// 3. We're going to try to update. The leaderElectionRecord is set to it's default
 	// here. Let's correct it before updating.
 	if le.IsLeader() {
 		leaderElectionRecord.AcquireTime = oldLeaderElectionRecord.AcquireTime
 		leaderElectionRecord.LeaderTransitions = oldLeaderElectionRecord.LeaderTransitions
 	} else {
 		leaderElectionRecord.LeaderTransitions = oldLeaderElectionRecord.LeaderTransitions + 1
 	}
 	// update the lock itself
 	if err = le.config.Lock.Update(ctx, leaderElectionRecord); err != nil {
 		klog.Errorf("Failed to update lock: %v", err)
 		return false
 	}
 	le.observedRecord = leaderElectionRecord
 	le.observedTime = le.clock.Now()
 	return true
 }
 func (le *LeaderElector) maybeReportTransition() {
 	if le.observedRecord.HolderIdentity == le.reportedLeader {
 		return
 	}
 	le.reportedLeader = le.observedRecord.HolderIdentity
 	if le.config.Callbacks.OnNewLeader != nil {
 		go le.config.Callbacks.OnNewLeader(le.reportedLeader)
 	}
 }
 // Check will determine if the current lease is expired by more than timeout.
 func (le *LeaderElector) Check(maxTolerableExpiredLease time.Duration) error {
 	if !le.IsLeader() {
 		// Currently not concerned with the case that we are hot standby
 		return nil
 	}
 	// If we are more than timeout seconds after the lease duration that is past the timeout
 	// on the lease renew. Time to start reporting ourselves as unhealthy. We should have
 	// died but conditions like deadlock can prevent this. (See #70819)
 	if le.clock.Since(le.observedTime) > le.config.LeaseDuration+maxTolerableExpiredLease {
 		return fmt.Errorf("failed election to renew leadership on lease %s", le.config.Name)
 	}
 	return nil
 }
--- a/vendor/k8s.io/client-go/tools/leaderelection/metrics.go
+++ b/vendor/k8s.io/client-go/tools/leaderelection/metrics.go
@ -0,0 +1,109 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package leaderelection
 import (
 	"sync"
 )
 // This file provides abstractions for setting the provider (e.g., prometheus)
 // of metrics.
 type leaderMetricsAdapter interface {
 	leaderOn(name string)
 	leaderOff(name string)
 }
 // GaugeMetric represents a single numerical value that can arbitrarily go up
 // and down.
 type SwitchMetric interface {
 	On(name string)
 	Off(name string)
 }
 type noopMetric struct{}
 func (noopMetric) On(name string)  {}
 func (noopMetric) Off(name string) {}
 // defaultLeaderMetrics expects the caller to lock before setting any metrics.
 type defaultLeaderMetrics struct {
 	// leader's value indicates if the current process is the owner of name lease
 	leader SwitchMetric
 }
 func (m *defaultLeaderMetrics) leaderOn(name string) {
 	if m == nil {
 		return
 	}
 	m.leader.On(name)
 }
 func (m *defaultLeaderMetrics) leaderOff(name string) {
 	if m == nil {
 		return
 	}
 	m.leader.Off(name)
 }
 type noMetrics struct{}
 func (noMetrics) leaderOn(name string)  {}
 func (noMetrics) leaderOff(name string) {}
 // MetricsProvider generates various metrics used by the leader election.
 type MetricsProvider interface {
 	NewLeaderMetric() SwitchMetric
 }
 type noopMetricsProvider struct{}
 func (_ noopMetricsProvider) NewLeaderMetric() SwitchMetric {
 	return noopMetric{}
 }
 var globalMetricsFactory = leaderMetricsFactory{
 	metricsProvider: noopMetricsProvider{},
 }
 type leaderMetricsFactory struct {
 	metricsProvider MetricsProvider
 	onlyOnce sync.Once
 }
 func (f *leaderMetricsFactory) setProvider(mp MetricsProvider) {
 	f.onlyOnce.Do(func() {
 		f.metricsProvider = mp
 	})
 }
 func (f *leaderMetricsFactory) newLeaderMetrics() leaderMetricsAdapter {
 	mp := f.metricsProvider
 	if mp == (noopMetricsProvider{}) {
 		return noMetrics{}
 	}
 	return &defaultLeaderMetrics{
 		leader: mp.NewLeaderMetric(),
 	}
 }
 // SetProvider sets the metrics provider for all subsequently created work
 // queues. Only the first call has an effect.
 func SetProvider(metricsProvider MetricsProvider) {
 	globalMetricsFactory.setProvider(metricsProvider)
 }
--- a/vendor/k8s.io/client-go/tools/leaderelection/resourcelock/configmaplock.go
+++ b/vendor/k8s.io/client-go/tools/leaderelection/resourcelock/configmaplock.go
@ -0,0 +1,117 @@
 /*
 Copyright 2017 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package resourcelock
 import (
 	"context"
 	"encoding/json"
 	"errors"
 	"fmt"
 	"k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	corev1client "k8s.io/client-go/kubernetes/typed/core/v1"
 )
 // TODO: This is almost a exact replica of Endpoints lock.
 // going forwards as we self host more and more components
 // and use ConfigMaps as the means to pass that configuration
 // data we will likely move to deprecate the Endpoints lock.
 type ConfigMapLock struct {
 	// ConfigMapMeta should contain a Name and a Namespace of a
 	// ConfigMapMeta object that the LeaderElector will attempt to lead.
 	ConfigMapMeta metav1.ObjectMeta
 	Client        corev1client.ConfigMapsGetter
 	LockConfig    ResourceLockConfig
 	cm            *v1.ConfigMap
 }
 // Get returns the election record from a ConfigMap Annotation
 func (cml *ConfigMapLock) Get(ctx context.Context) (*LeaderElectionRecord, []byte, error) {
 	var record LeaderElectionRecord
 	var err error
 	cml.cm, err = cml.Client.ConfigMaps(cml.ConfigMapMeta.Namespace).Get(ctx, cml.ConfigMapMeta.Name, metav1.GetOptions{})
 	if err != nil {
 		return nil, nil, err
 	}
 	if cml.cm.Annotations == nil {
 		cml.cm.Annotations = make(map[string]string)
 	}
 	recordBytes, found := cml.cm.Annotations[LeaderElectionRecordAnnotationKey]
 	if found {
 		if err := json.Unmarshal([]byte(recordBytes), &record); err != nil {
 			return nil, nil, err
 		}
 	}
 	return &record, []byte(recordBytes), nil
 }
 // Create attempts to create a LeaderElectionRecord annotation
 func (cml *ConfigMapLock) Create(ctx context.Context, ler LeaderElectionRecord) error {
 	recordBytes, err := json.Marshal(ler)
 	if err != nil {
 		return err
 	}
 	cml.cm, err = cml.Client.ConfigMaps(cml.ConfigMapMeta.Namespace).Create(ctx, &v1.ConfigMap{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:      cml.ConfigMapMeta.Name,
 			Namespace: cml.ConfigMapMeta.Namespace,
 			Annotations: map[string]string{
 				LeaderElectionRecordAnnotationKey: string(recordBytes),
 			},
 		},
 	}, metav1.CreateOptions{})
 	return err
 }
 // Update will update an existing annotation on a given resource.
 func (cml *ConfigMapLock) Update(ctx context.Context, ler LeaderElectionRecord) error {
 	if cml.cm == nil {
 		return errors.New("configmap not initialized, call get or create first")
 	}
 	recordBytes, err := json.Marshal(ler)
 	if err != nil {
 		return err
 	}
 	if cml.cm.Annotations == nil {
 		cml.cm.Annotations = make(map[string]string)
 	}
 	cml.cm.Annotations[LeaderElectionRecordAnnotationKey] = string(recordBytes)
 	cml.cm, err = cml.Client.ConfigMaps(cml.ConfigMapMeta.Namespace).Update(ctx, cml.cm, metav1.UpdateOptions{})
 	return err
 }
 // RecordEvent in leader election while adding meta-data
 func (cml *ConfigMapLock) RecordEvent(s string) {
 	if cml.LockConfig.EventRecorder == nil {
 		return
 	}
 	events := fmt.Sprintf("%v %v", cml.LockConfig.Identity, s)
 	cml.LockConfig.EventRecorder.Eventf(&v1.ConfigMap{ObjectMeta: cml.cm.ObjectMeta}, v1.EventTypeNormal, "LeaderElection", events)
 }
 // Describe is used to convert details on current resource lock
 // into a string
 func (cml *ConfigMapLock) Describe() string {
 	return fmt.Sprintf("%v/%v", cml.ConfigMapMeta.Namespace, cml.ConfigMapMeta.Name)
 }
 // Identity returns the Identity of the lock
 func (cml *ConfigMapLock) Identity() string {
 	return cml.LockConfig.Identity
 }
--- a/vendor/k8s.io/client-go/tools/leaderelection/resourcelock/endpointslock.go
+++ b/vendor/k8s.io/client-go/tools/leaderelection/resourcelock/endpointslock.go
@ -0,0 +1,112 @@
 /*
 Copyright 2016 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package resourcelock
 import (
 	"context"
 	"encoding/json"
 	"errors"
 	"fmt"
 	"k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	corev1client "k8s.io/client-go/kubernetes/typed/core/v1"
 )
 type EndpointsLock struct {
 	// EndpointsMeta should contain a Name and a Namespace of an
 	// Endpoints object that the LeaderElector will attempt to lead.
 	EndpointsMeta metav1.ObjectMeta
 	Client        corev1client.EndpointsGetter
 	LockConfig    ResourceLockConfig
 	e             *v1.Endpoints
 }
 // Get returns the election record from a Endpoints Annotation
 func (el *EndpointsLock) Get(ctx context.Context) (*LeaderElectionRecord, []byte, error) {
 	var record LeaderElectionRecord
 	var err error
 	el.e, err = el.Client.Endpoints(el.EndpointsMeta.Namespace).Get(ctx, el.EndpointsMeta.Name, metav1.GetOptions{})
 	if err != nil {
 		return nil, nil, err
 	}
 	if el.e.Annotations == nil {
 		el.e.Annotations = make(map[string]string)
 	}
 	recordBytes, found := el.e.Annotations[LeaderElectionRecordAnnotationKey]
 	if found {
 		if err := json.Unmarshal([]byte(recordBytes), &record); err != nil {
 			return nil, nil, err
 		}
 	}
 	return &record, []byte(recordBytes), nil
 }
 // Create attempts to create a LeaderElectionRecord annotation
 func (el *EndpointsLock) Create(ctx context.Context, ler LeaderElectionRecord) error {
 	recordBytes, err := json.Marshal(ler)
 	if err != nil {
 		return err
 	}
 	el.e, err = el.Client.Endpoints(el.EndpointsMeta.Namespace).Create(ctx, &v1.Endpoints{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:      el.EndpointsMeta.Name,
 			Namespace: el.EndpointsMeta.Namespace,
 			Annotations: map[string]string{
 				LeaderElectionRecordAnnotationKey: string(recordBytes),
 			},
 		},
 	}, metav1.CreateOptions{})
 	return err
 }
 // Update will update and existing annotation on a given resource.
 func (el *EndpointsLock) Update(ctx context.Context, ler LeaderElectionRecord) error {
 	if el.e == nil {
 		return errors.New("endpoint not initialized, call get or create first")
 	}
 	recordBytes, err := json.Marshal(ler)
 	if err != nil {
 		return err
 	}
 	if el.e.Annotations == nil {
 		el.e.Annotations = make(map[string]string)
 	}
 	el.e.Annotations[LeaderElectionRecordAnnotationKey] = string(recordBytes)
 	el.e, err = el.Client.Endpoints(el.EndpointsMeta.Namespace).Update(ctx, el.e, metav1.UpdateOptions{})
 	return err
 }
 // RecordEvent in leader election while adding meta-data
 func (el *EndpointsLock) RecordEvent(s string) {
 	if el.LockConfig.EventRecorder == nil {
 		return
 	}
 	events := fmt.Sprintf("%v %v", el.LockConfig.Identity, s)
 	el.LockConfig.EventRecorder.Eventf(&v1.Endpoints{ObjectMeta: el.e.ObjectMeta}, v1.EventTypeNormal, "LeaderElection", events)
 }
 // Describe is used to convert details on current resource lock
 // into a string
 func (el *EndpointsLock) Describe() string {
 	return fmt.Sprintf("%v/%v", el.EndpointsMeta.Namespace, el.EndpointsMeta.Name)
 }
 // Identity returns the Identity of the lock
 func (el *EndpointsLock) Identity() string {
 	return el.LockConfig.Identity
 }
--- a/vendor/k8s.io/client-go/tools/leaderelection/resourcelock/interface.go
+++ b/vendor/k8s.io/client-go/tools/leaderelection/resourcelock/interface.go
@ -0,0 +1,142 @@
 /*
 Copyright 2016 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package resourcelock
 import (
 	"context"
 	"fmt"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	coordinationv1 "k8s.io/client-go/kubernetes/typed/coordination/v1"
 	corev1 "k8s.io/client-go/kubernetes/typed/core/v1"
 )
 const (
 	LeaderElectionRecordAnnotationKey = "control-plane.alpha.kubernetes.io/leader"
 	EndpointsResourceLock             = "endpoints"
 	ConfigMapsResourceLock            = "configmaps"
 	LeasesResourceLock                = "leases"
 	EndpointsLeasesResourceLock       = "endpointsleases"
 	ConfigMapsLeasesResourceLock      = "configmapsleases"
 )
 // LeaderElectionRecord is the record that is stored in the leader election annotation.
 // This information should be used for observational purposes only and could be replaced
 // with a random string (e.g. UUID) with only slight modification of this code.
 // TODO(mikedanese): this should potentially be versioned
 type LeaderElectionRecord struct {
 	// HolderIdentity is the ID that owns the lease. If empty, no one owns this lease and
 	// all callers may acquire. Versions of this library prior to Kubernetes 1.14 will not
 	// attempt to acquire leases with empty identities and will wait for the full lease
 	// interval to expire before attempting to reacquire. This value is set to empty when
 	// a client voluntarily steps down.
 	HolderIdentity       string      `json:"holderIdentity"`
 	LeaseDurationSeconds int         `json:"leaseDurationSeconds"`
 	AcquireTime          metav1.Time `json:"acquireTime"`
 	RenewTime            metav1.Time `json:"renewTime"`
 	LeaderTransitions    int         `json:"leaderTransitions"`
 }
 // EventRecorder records a change in the ResourceLock.
 type EventRecorder interface {
 	Eventf(obj runtime.Object, eventType, reason, message string, args ...interface{})
 }
 // ResourceLockConfig common data that exists across different
 // resource locks
 type ResourceLockConfig struct {
 	// Identity is the unique string identifying a lease holder across
 	// all participants in an election.
 	Identity string
 	// EventRecorder is optional.
 	EventRecorder EventRecorder
 }
 // Interface offers a common interface for locking on arbitrary
 // resources used in leader election.  The Interface is used
 // to hide the details on specific implementations in order to allow
 // them to change over time.  This interface is strictly for use
 // by the leaderelection code.
 type Interface interface {
 	// Get returns the LeaderElectionRecord
 	Get(ctx context.Context) (*LeaderElectionRecord, []byte, error)
 	// Create attempts to create a LeaderElectionRecord
 	Create(ctx context.Context, ler LeaderElectionRecord) error
 	// Update will update and existing LeaderElectionRecord
 	Update(ctx context.Context, ler LeaderElectionRecord) error
 	// RecordEvent is used to record events
 	RecordEvent(string)
 	// Identity will return the locks Identity
 	Identity() string
 	// Describe is used to convert details on current resource lock
 	// into a string
 	Describe() string
 }
 // Manufacture will create a lock of a given type according to the input parameters
 func New(lockType string, ns string, name string, coreClient corev1.CoreV1Interface, coordinationClient coordinationv1.CoordinationV1Interface, rlc ResourceLockConfig) (Interface, error) {
 	endpointsLock := &EndpointsLock{
 		EndpointsMeta: metav1.ObjectMeta{
 			Namespace: ns,
 			Name:      name,
 		},
 		Client:     coreClient,
 		LockConfig: rlc,
 	}
 	configmapLock := &ConfigMapLock{
 		ConfigMapMeta: metav1.ObjectMeta{
 			Namespace: ns,
 			Name:      name,
 		},
 		Client:     coreClient,
 		LockConfig: rlc,
 	}
 	leaseLock := &LeaseLock{
 		LeaseMeta: metav1.ObjectMeta{
 			Namespace: ns,
 			Name:      name,
 		},
 		Client:     coordinationClient,
 		LockConfig: rlc,
 	}
 	switch lockType {
 	case EndpointsResourceLock:
 		return endpointsLock, nil
 	case ConfigMapsResourceLock:
 		return configmapLock, nil
 	case LeasesResourceLock:
 		return leaseLock, nil
 	case EndpointsLeasesResourceLock:
 		return &MultiLock{
 			Primary:   endpointsLock,
 			Secondary: leaseLock,
 		}, nil
 	case ConfigMapsLeasesResourceLock:
 		return &MultiLock{
 			Primary:   configmapLock,
 			Secondary: leaseLock,
 		}, nil
 	default:
 		return nil, fmt.Errorf("Invalid lock-type %s", lockType)
 	}
 }
--- a/vendor/k8s.io/client-go/tools/leaderelection/resourcelock/leaselock.go
+++ b/vendor/k8s.io/client-go/tools/leaderelection/resourcelock/leaselock.go
@ -0,0 +1,130 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package resourcelock
 import (
 	"context"
 	"encoding/json"
 	"errors"
 	"fmt"
 	coordinationv1 "k8s.io/api/coordination/v1"
 	corev1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	coordinationv1client "k8s.io/client-go/kubernetes/typed/coordination/v1"
 )
 type LeaseLock struct {
 	// LeaseMeta should contain a Name and a Namespace of a
 	// LeaseMeta object that the LeaderElector will attempt to lead.
 	LeaseMeta  metav1.ObjectMeta
 	Client     coordinationv1client.LeasesGetter
 	LockConfig ResourceLockConfig
 	lease      *coordinationv1.Lease
 }
 // Get returns the election record from a Lease spec
 func (ll *LeaseLock) Get(ctx context.Context) (*LeaderElectionRecord, []byte, error) {
 	var err error
 	ll.lease, err = ll.Client.Leases(ll.LeaseMeta.Namespace).Get(ctx, ll.LeaseMeta.Name, metav1.GetOptions{})
 	if err != nil {
 		return nil, nil, err
 	}
 	record := LeaseSpecToLeaderElectionRecord(&ll.lease.Spec)
 	recordByte, err := json.Marshal(*record)
 	if err != nil {
 		return nil, nil, err
 	}
 	return record, recordByte, nil
 }
 // Create attempts to create a Lease
 func (ll *LeaseLock) Create(ctx context.Context, ler LeaderElectionRecord) error {
 	var err error
 	ll.lease, err = ll.Client.Leases(ll.LeaseMeta.Namespace).Create(ctx, &coordinationv1.Lease{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:      ll.LeaseMeta.Name,
 			Namespace: ll.LeaseMeta.Namespace,
 		},
 		Spec: LeaderElectionRecordToLeaseSpec(&ler),
 	}, metav1.CreateOptions{})
 	return err
 }
 // Update will update an existing Lease spec.
 func (ll *LeaseLock) Update(ctx context.Context, ler LeaderElectionRecord) error {
 	if ll.lease == nil {
 		return errors.New("lease not initialized, call get or create first")
 	}
 	ll.lease.Spec = LeaderElectionRecordToLeaseSpec(&ler)
 	var err error
 	ll.lease, err = ll.Client.Leases(ll.LeaseMeta.Namespace).Update(ctx, ll.lease, metav1.UpdateOptions{})
 	return err
 }
 // RecordEvent in leader election while adding meta-data
 func (ll *LeaseLock) RecordEvent(s string) {
 	if ll.LockConfig.EventRecorder == nil {
 		return
 	}
 	events := fmt.Sprintf("%v %v", ll.LockConfig.Identity, s)
 	ll.LockConfig.EventRecorder.Eventf(&coordinationv1.Lease{ObjectMeta: ll.lease.ObjectMeta}, corev1.EventTypeNormal, "LeaderElection", events)
 }
 // Describe is used to convert details on current resource lock
 // into a string
 func (ll *LeaseLock) Describe() string {
 	return fmt.Sprintf("%v/%v", ll.LeaseMeta.Namespace, ll.LeaseMeta.Name)
 }
 // Identity returns the Identity of the lock
 func (ll *LeaseLock) Identity() string {
 	return ll.LockConfig.Identity
 }
 func LeaseSpecToLeaderElectionRecord(spec *coordinationv1.LeaseSpec) *LeaderElectionRecord {
 	var r LeaderElectionRecord
 	if spec.HolderIdentity != nil {
 		r.HolderIdentity = *spec.HolderIdentity
 	}
 	if spec.LeaseDurationSeconds != nil {
 		r.LeaseDurationSeconds = int(*spec.LeaseDurationSeconds)
 	}
 	if spec.LeaseTransitions != nil {
 		r.LeaderTransitions = int(*spec.LeaseTransitions)
 	}
 	if spec.AcquireTime != nil {
 		r.AcquireTime = metav1.Time{spec.AcquireTime.Time}
 	}
 	if spec.RenewTime != nil {
 		r.RenewTime = metav1.Time{spec.RenewTime.Time}
 	}
 	return &r
 }
 func LeaderElectionRecordToLeaseSpec(ler *LeaderElectionRecord) coordinationv1.LeaseSpec {
 	leaseDurationSeconds := int32(ler.LeaseDurationSeconds)
 	leaseTransitions := int32(ler.LeaderTransitions)
 	return coordinationv1.LeaseSpec{
 		HolderIdentity:       &ler.HolderIdentity,
 		LeaseDurationSeconds: &leaseDurationSeconds,
 		AcquireTime:          &metav1.MicroTime{ler.AcquireTime.Time},
 		RenewTime:            &metav1.MicroTime{ler.RenewTime.Time},
 		LeaseTransitions:     &leaseTransitions,
 	}
 }
--- a/vendor/k8s.io/client-go/tools/leaderelection/resourcelock/multilock.go
+++ b/vendor/k8s.io/client-go/tools/leaderelection/resourcelock/multilock.go
@ -0,0 +1,104 @@
 /*
 Copyright 2019 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package resourcelock
 import (
 	"bytes"
 	"context"
 	"encoding/json"
 	apierrors "k8s.io/apimachinery/pkg/api/errors"
 )
 const (
 	UnknownLeader = "leaderelection.k8s.io/unknown"
 )
 // MultiLock is used for lock's migration
 type MultiLock struct {
 	Primary   Interface
 	Secondary Interface
 }
 // Get returns the older election record of the lock
 func (ml *MultiLock) Get(ctx context.Context) (*LeaderElectionRecord, []byte, error) {
 	primary, primaryRaw, err := ml.Primary.Get(ctx)
 	if err != nil {
 		return nil, nil, err
 	}
 	secondary, secondaryRaw, err := ml.Secondary.Get(ctx)
 	if err != nil {
 		// Lock is held by old client
 		if apierrors.IsNotFound(err) && primary.HolderIdentity != ml.Identity() {
 			return primary, primaryRaw, nil
 		}
 		return nil, nil, err
 	}
 	if primary.HolderIdentity != secondary.HolderIdentity {
 		primary.HolderIdentity = UnknownLeader
 		primaryRaw, err = json.Marshal(primary)
 		if err != nil {
 			return nil, nil, err
 		}
 	}
 	return primary, ConcatRawRecord(primaryRaw, secondaryRaw), nil
 }
 // Create attempts to create both primary lock and secondary lock
 func (ml *MultiLock) Create(ctx context.Context, ler LeaderElectionRecord) error {
 	err := ml.Primary.Create(ctx, ler)
 	if err != nil && !apierrors.IsAlreadyExists(err) {
 		return err
 	}
 	return ml.Secondary.Create(ctx, ler)
 }
 // Update will update and existing annotation on both two resources.
 func (ml *MultiLock) Update(ctx context.Context, ler LeaderElectionRecord) error {
 	err := ml.Primary.Update(ctx, ler)
 	if err != nil {
 		return err
 	}
 	_, _, err = ml.Secondary.Get(ctx)
 	if err != nil && apierrors.IsNotFound(err) {
 		return ml.Secondary.Create(ctx, ler)
 	}
 	return ml.Secondary.Update(ctx, ler)
 }
 // RecordEvent in leader election while adding meta-data
 func (ml *MultiLock) RecordEvent(s string) {
 	ml.Primary.RecordEvent(s)
 	ml.Secondary.RecordEvent(s)
 }
 // Describe is used to convert details on current resource lock
 // into a string
 func (ml *MultiLock) Describe() string {
 	return ml.Primary.Describe()
 }
 // Identity returns the Identity of the lock
 func (ml *MultiLock) Identity() string {
 	return ml.Primary.Identity()
 }
 func ConcatRawRecord(primaryRaw, secondaryRaw []byte) []byte {
 	return bytes.Join([][]byte{primaryRaw, secondaryRaw}, []byte(","))
 }
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@ -29,7 +29,7 @@ github.com/docker/spdystream
 github.com/docker/spdystream/spdy
 # github.com/evanphx/json-patch v4.5.0+incompatible
 github.com/evanphx/json-patch
-# github.com/go-logr/logr v0.2.0
+# github.com/go-logr/logr v0.2.1
 github.com/go-logr/logr
 # github.com/gogo/protobuf v1.3.1
 github.com/gogo/protobuf/gogoproto
@ -57,7 +57,7 @@ github.com/google/go-cmp/cmp/internal/value
 github.com/google/gofuzz
 # github.com/google/uuid v1.1.1
 github.com/google/uuid
-# github.com/googleapis/gnostic v0.3.1
+# github.com/googleapis/gnostic v0.4.0
 github.com/googleapis/gnostic/OpenAPIv2
 github.com/googleapis/gnostic/compiler
 github.com/googleapis/gnostic/extensions
@ -243,6 +243,8 @@ golang.org/x/time/rate
 # golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543
 golang.org/x/xerrors
 golang.org/x/xerrors/internal
 # gomodules.xyz/jsonpatch/v2 v2.0.1
 gomodules.xyz/jsonpatch/v2
 # google.golang.org/appengine v1.6.5
 google.golang.org/appengine/internal
 google.golang.org/appengine/internal/base
@ -607,6 +609,8 @@ k8s.io/client-go/tools/clientcmd
 k8s.io/client-go/tools/clientcmd/api
 k8s.io/client-go/tools/clientcmd/api/latest
 k8s.io/client-go/tools/clientcmd/api/v1
 k8s.io/client-go/tools/leaderelection
 k8s.io/client-go/tools/leaderelection/resourcelock
 k8s.io/client-go/tools/metrics
 k8s.io/client-go/tools/pager
 k8s.io/client-go/tools/record
@ -763,6 +767,36 @@ k8s.io/utils/trace
 # sigs.k8s.io/apiserver-network-proxy/konnectivity-client v0.0.7
 sigs.k8s.io/apiserver-network-proxy/konnectivity-client/pkg/client
 sigs.k8s.io/apiserver-network-proxy/konnectivity-client/proto/client
 # sigs.k8s.io/controller-runtime v0.6.0
 sigs.k8s.io/controller-runtime/pkg/cache
 sigs.k8s.io/controller-runtime/pkg/cache/internal
 sigs.k8s.io/controller-runtime/pkg/client
 sigs.k8s.io/controller-runtime/pkg/client/apiutil
 sigs.k8s.io/controller-runtime/pkg/client/config
 sigs.k8s.io/controller-runtime/pkg/controller
 sigs.k8s.io/controller-runtime/pkg/event
 sigs.k8s.io/controller-runtime/pkg/handler
 sigs.k8s.io/controller-runtime/pkg/healthz
 sigs.k8s.io/controller-runtime/pkg/internal/controller
 sigs.k8s.io/controller-runtime/pkg/internal/controller/metrics
 sigs.k8s.io/controller-runtime/pkg/internal/log
 sigs.k8s.io/controller-runtime/pkg/internal/recorder
 sigs.k8s.io/controller-runtime/pkg/leaderelection
 sigs.k8s.io/controller-runtime/pkg/log
 sigs.k8s.io/controller-runtime/pkg/manager
 sigs.k8s.io/controller-runtime/pkg/manager/signals
 sigs.k8s.io/controller-runtime/pkg/metrics
 sigs.k8s.io/controller-runtime/pkg/predicate
 sigs.k8s.io/controller-runtime/pkg/ratelimiter
 sigs.k8s.io/controller-runtime/pkg/reconcile
 sigs.k8s.io/controller-runtime/pkg/recorder
 sigs.k8s.io/controller-runtime/pkg/runtime/inject
 sigs.k8s.io/controller-runtime/pkg/source
 sigs.k8s.io/controller-runtime/pkg/source/internal
 sigs.k8s.io/controller-runtime/pkg/webhook
 sigs.k8s.io/controller-runtime/pkg/webhook/admission
 sigs.k8s.io/controller-runtime/pkg/webhook/internal/certwatcher
 sigs.k8s.io/controller-runtime/pkg/webhook/internal/metrics
 # sigs.k8s.io/structured-merge-diff/v3 v3.0.0
 sigs.k8s.io/structured-merge-diff/v3/value
 # sigs.k8s.io/yaml v1.2.0
--- a/vendor/sigs.k8s.io/controller-runtime/LICENSE
+++ b/vendor/sigs.k8s.io/controller-runtime/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.
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/cache/cache.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/cache/cache.go
@ -0,0 +1,141 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package cache
 import (
 	"context"
 	"fmt"
 	"time"
 	"k8s.io/apimachinery/pkg/api/meta"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/client-go/kubernetes/scheme"
 	"k8s.io/client-go/rest"
 	toolscache "k8s.io/client-go/tools/cache"
 	"sigs.k8s.io/controller-runtime/pkg/cache/internal"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/client/apiutil"
 	logf "sigs.k8s.io/controller-runtime/pkg/internal/log"
 )
 var log = logf.RuntimeLog.WithName("object-cache")
 // Cache knows how to load Kubernetes objects, fetch informers to request
 // to receive events for Kubernetes objects (at a low-level),
 // and add indices to fields on the objects stored in the cache.
 type Cache interface {
 	// Cache acts as a client to objects stored in the cache.
 	client.Reader
 	// Cache loads informers and adds field indices.
 	Informers
 }
 // Informers knows how to create or fetch informers for different
 // group-version-kinds, and add indices to those informers.  It's safe to call
 // GetInformer from multiple threads.
 type Informers interface {
 	// GetInformer fetches or constructs an informer for the given object that corresponds to a single
 	// API kind and resource.
 	GetInformer(ctx context.Context, obj runtime.Object) (Informer, error)
 	// GetInformerForKind is similar to GetInformer, except that it takes a group-version-kind, instead
 	// of the underlying object.
 	GetInformerForKind(ctx context.Context, gvk schema.GroupVersionKind) (Informer, error)
 	// Start runs all the informers known to this cache until the given channel is closed.
 	// It blocks.
 	Start(stopCh <-chan struct{}) error
 	// WaitForCacheSync waits for all the caches to sync.  Returns false if it could not sync a cache.
 	WaitForCacheSync(stop <-chan struct{}) bool
 	// Informers knows how to add indices to the caches (informers) that it manages.
 	client.FieldIndexer
 }
 // Informer - informer allows you interact with the underlying informer
 type Informer interface {
 	// AddEventHandler adds an event handler to the shared informer using the shared informer's resync
 	// period.  Events to a single handler are delivered sequentially, but there is no coordination
 	// between different handlers.
 	AddEventHandler(handler toolscache.ResourceEventHandler)
 	// AddEventHandlerWithResyncPeriod adds an event handler to the shared informer using the
 	// specified resync period.  Events to a single handler are delivered sequentially, but there is
 	// no coordination between different handlers.
 	AddEventHandlerWithResyncPeriod(handler toolscache.ResourceEventHandler, resyncPeriod time.Duration)
 	// AddIndexers adds more indexers to this store.  If you call this after you already have data
 	// in the store, the results are undefined.
 	AddIndexers(indexers toolscache.Indexers) error
 	//HasSynced return true if the informers underlying store has synced
 	HasSynced() bool
 }
 // Options are the optional arguments for creating a new InformersMap object
 type Options struct {
 	// Scheme is the scheme to use for mapping objects to GroupVersionKinds
 	Scheme *runtime.Scheme
 	// Mapper is the RESTMapper to use for mapping GroupVersionKinds to Resources
 	Mapper meta.RESTMapper
 	// Resync is the base frequency the informers are resynced.
 	// Defaults to defaultResyncTime.
 	// A 10 percent jitter will be added to the Resync period between informers
 	// So that all informers will not send list requests simultaneously.
 	Resync *time.Duration
 	// Namespace restricts the cache's ListWatch to the desired namespace
 	// Default watches all namespaces
 	Namespace string
 }
 var defaultResyncTime = 10 * time.Hour
 // New initializes and returns a new Cache.
 func New(config *rest.Config, opts Options) (Cache, error) {
 	opts, err := defaultOpts(config, opts)
 	if err != nil {
 		return nil, err
 	}
 	im := internal.NewInformersMap(config, opts.Scheme, opts.Mapper, *opts.Resync, opts.Namespace)
 	return &informerCache{InformersMap: im}, nil
 }
 func defaultOpts(config *rest.Config, opts Options) (Options, error) {
 	// Use the default Kubernetes Scheme if unset
 	if opts.Scheme == nil {
 		opts.Scheme = scheme.Scheme
 	}
 	// Construct a new Mapper if unset
 	if opts.Mapper == nil {
 		var err error
 		opts.Mapper, err = apiutil.NewDiscoveryRESTMapper(config)
 		if err != nil {
 			log.WithName("setup").Error(err, "Failed to get API Group-Resources")
 			return opts, fmt.Errorf("could not create RESTMapper from config")
 		}
 	}
 	// Default the resync period to 10 hours if unset
 	if opts.Resync == nil {
 		opts.Resync = &defaultResyncTime
 	}
 	return opts, nil
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/cache/doc.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/cache/doc.go
@ -0,0 +1,19 @@
 /*
 Copyright 2019 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 // Package cache provides object caches that act as caching client.Reader
 // instances and help drive Kubernetes-object-based event handlers.
 package cache
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/cache/informer_cache.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/cache/informer_cache.go
@ -0,0 +1,218 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package cache
 import (
 	"context"
 	"fmt"
 	"reflect"
 	"strings"
 	apimeta "k8s.io/apimachinery/pkg/api/meta"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/client-go/tools/cache"
 	"sigs.k8s.io/controller-runtime/pkg/cache/internal"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/client/apiutil"
 )
 var (
 	_ Informers     = &informerCache{}
 	_ client.Reader = &informerCache{}
 	_ Cache         = &informerCache{}
 )
 // ErrCacheNotStarted is returned when trying to read from the cache that wasn't started.
 type ErrCacheNotStarted struct{}
 func (*ErrCacheNotStarted) Error() string {
 	return "the cache is not started, can not read objects"
 }
 // informerCache is a Kubernetes Object cache populated from InformersMap.  informerCache wraps an InformersMap.
 type informerCache struct {
 	*internal.InformersMap
 }
 // Get implements Reader
 func (ip *informerCache) Get(ctx context.Context, key client.ObjectKey, out runtime.Object) error {
 	gvk, err := apiutil.GVKForObject(out, ip.Scheme)
 	if err != nil {
 		return err
 	}
 	started, cache, err := ip.InformersMap.Get(ctx, gvk, out)
 	if err != nil {
 		return err
 	}
 	if !started {
 		return &ErrCacheNotStarted{}
 	}
 	return cache.Reader.Get(ctx, key, out)
 }
 // List implements Reader
 func (ip *informerCache) List(ctx context.Context, out runtime.Object, opts ...client.ListOption) error {
 	gvk, cacheTypeObj, err := ip.objectTypeForListObject(out)
 	if err != nil {
 		return err
 	}
 	started, cache, err := ip.InformersMap.Get(ctx, *gvk, cacheTypeObj)
 	if err != nil {
 		return err
 	}
 	if !started {
 		return &ErrCacheNotStarted{}
 	}
 	return cache.Reader.List(ctx, out, opts...)
 }
 // objectTypeForListObject tries to find the runtime.Object and associated GVK
 // for a single object corresponding to the passed-in list type. We need them
 // because they are used as cache map key.
 func (ip *informerCache) objectTypeForListObject(list runtime.Object) (*schema.GroupVersionKind, runtime.Object, error) {
 	gvk, err := apiutil.GVKForObject(list, ip.Scheme)
 	if err != nil {
 		return nil, nil, err
 	}
 	if !strings.HasSuffix(gvk.Kind, "List") {
 		return nil, nil, fmt.Errorf("non-list type %T (kind %q) passed as output", list, gvk)
 	}
 	// we need the non-list GVK, so chop off the "List" from the end of the kind
 	gvk.Kind = gvk.Kind[:len(gvk.Kind)-4]
 	_, isUnstructured := list.(*unstructured.UnstructuredList)
 	var cacheTypeObj runtime.Object
 	if isUnstructured {
 		u := &unstructured.Unstructured{}
 		u.SetGroupVersionKind(gvk)
 		cacheTypeObj = u
 	} else {
 		itemsPtr, err := apimeta.GetItemsPtr(list)
 		if err != nil {
 			return nil, nil, err
 		}
 		// http://knowyourmeme.com/memes/this-is-fine
 		elemType := reflect.Indirect(reflect.ValueOf(itemsPtr)).Type().Elem()
 		if elemType.Kind() != reflect.Ptr {
 			elemType = reflect.PtrTo(elemType)
 		}
 		cacheTypeValue := reflect.Zero(elemType)
 		var ok bool
 		cacheTypeObj, ok = cacheTypeValue.Interface().(runtime.Object)
 		if !ok {
 			return nil, nil, fmt.Errorf("cannot get cache for %T, its element %T is not a runtime.Object", list, cacheTypeValue.Interface())
 		}
 	}
 	return &gvk, cacheTypeObj, nil
 }
 // GetInformerForKind returns the informer for the GroupVersionKind
 func (ip *informerCache) GetInformerForKind(ctx context.Context, gvk schema.GroupVersionKind) (Informer, error) {
 	// Map the gvk to an object
 	obj, err := ip.Scheme.New(gvk)
 	if err != nil {
 		return nil, err
 	}
 	_, i, err := ip.InformersMap.Get(ctx, gvk, obj)
 	if err != nil {
 		return nil, err
 	}
 	return i.Informer, err
 }
 // GetInformer returns the informer for the obj
 func (ip *informerCache) GetInformer(ctx context.Context, obj runtime.Object) (Informer, error) {
 	gvk, err := apiutil.GVKForObject(obj, ip.Scheme)
 	if err != nil {
 		return nil, err
 	}
 	_, i, err := ip.InformersMap.Get(ctx, gvk, obj)
 	if err != nil {
 		return nil, err
 	}
 	return i.Informer, err
 }
 // NeedLeaderElection implements the LeaderElectionRunnable interface
 // to indicate that this can be started without requiring the leader lock
 func (ip *informerCache) NeedLeaderElection() bool {
 	return false
 }
 // IndexField adds an indexer to the underlying cache, using extraction function to get
 // value(s) from the given field.  This index can then be used by passing a field selector
 // to List. For one-to-one compatibility with "normal" field selectors, only return one value.
 // The values may be anything.  They will automatically be prefixed with the namespace of the
 // given object, if present.  The objects passed are guaranteed to be objects of the correct type.
 func (ip *informerCache) IndexField(ctx context.Context, obj runtime.Object, field string, extractValue client.IndexerFunc) error {
 	informer, err := ip.GetInformer(ctx, obj)
 	if err != nil {
 		return err
 	}
 	return indexByField(informer, field, extractValue)
 }
 func indexByField(indexer Informer, field string, extractor client.IndexerFunc) error {
 	indexFunc := func(objRaw interface{}) ([]string, error) {
 		// TODO(directxman12): check if this is the correct type?
 		obj, isObj := objRaw.(runtime.Object)
 		if !isObj {
 			return nil, fmt.Errorf("object of type %T is not an Object", objRaw)
 		}
 		meta, err := apimeta.Accessor(obj)
 		if err != nil {
 			return nil, err
 		}
 		ns := meta.GetNamespace()
 		rawVals := extractor(obj)
 		var vals []string
 		if ns == "" {
 			// if we're not doubling the keys for the namespaced case, just re-use what was returned to us
 			vals = rawVals
 		} else {
 			// if we need to add non-namespaced versions too, double the length
 			vals = make([]string, len(rawVals)*2)
 		}
 		for i, rawVal := range rawVals {
 			// save a namespaced variant, so that we can ask
 			// "what are all the object matching a given index *in a given namespace*"
 			vals[i] = internal.KeyToNamespacedKey(ns, rawVal)
 			if ns != "" {
 				// if we have a namespace, also inject a special index key for listing
 				// regardless of the object namespace
 				vals[i+len(rawVals)] = internal.KeyToNamespacedKey("", rawVal)
 			}
 		}
 		return vals, nil
 	}
 	return indexer.AddIndexers(cache.Indexers{internal.FieldIndexName(field): indexFunc})
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/cache/internal/cache_reader.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/cache/internal/cache_reader.go
@ -0,0 +1,185 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package internal
 import (
 	"context"
 	"fmt"
 	"reflect"
 	"k8s.io/apimachinery/pkg/api/errors"
 	apimeta "k8s.io/apimachinery/pkg/api/meta"
 	"k8s.io/apimachinery/pkg/fields"
 	"k8s.io/apimachinery/pkg/labels"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apimachinery/pkg/selection"
 	"k8s.io/client-go/tools/cache"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 )
 // CacheReader is a client.Reader
 var _ client.Reader = &CacheReader{}
 // CacheReader wraps a cache.Index to implement the client.CacheReader interface for a single type
 type CacheReader struct {
 	// indexer is the underlying indexer wrapped by this cache.
 	indexer cache.Indexer
 	// groupVersionKind is the group-version-kind of the resource.
 	groupVersionKind schema.GroupVersionKind
 }
 // Get checks the indexer for the object and writes a copy of it if found
 func (c *CacheReader) Get(_ context.Context, key client.ObjectKey, out runtime.Object) error {
 	storeKey := objectKeyToStoreKey(key)
 	// Lookup the object from the indexer cache
 	obj, exists, err := c.indexer.GetByKey(storeKey)
 	if err != nil {
 		return err
 	}
 	// Not found, return an error
 	if !exists {
 		// Resource gets transformed into Kind in the error anyway, so this is fine
 		return errors.NewNotFound(schema.GroupResource{
 			Group:    c.groupVersionKind.Group,
 			Resource: c.groupVersionKind.Kind,
 		}, key.Name)
 	}
 	// Verify the result is a runtime.Object
 	if _, isObj := obj.(runtime.Object); !isObj {
 		// This should never happen
 		return fmt.Errorf("cache contained %T, which is not an Object", obj)
 	}
 	// deep copy to avoid mutating cache
 	// TODO(directxman12): revisit the decision to always deepcopy
 	obj = obj.(runtime.Object).DeepCopyObject()
 	// Copy the value of the item in the cache to the returned value
 	// TODO(directxman12): this is a terrible hack, pls fix (we should have deepcopyinto)
 	outVal := reflect.ValueOf(out)
 	objVal := reflect.ValueOf(obj)
 	if !objVal.Type().AssignableTo(outVal.Type()) {
 		return fmt.Errorf("cache had type %s, but %s was asked for", objVal.Type(), outVal.Type())
 	}
 	reflect.Indirect(outVal).Set(reflect.Indirect(objVal))
 	out.GetObjectKind().SetGroupVersionKind(c.groupVersionKind)
 	return nil
 }
 // List lists items out of the indexer and writes them to out
 func (c *CacheReader) List(_ context.Context, out runtime.Object, opts ...client.ListOption) error {
 	var objs []interface{}
 	var err error
 	listOpts := client.ListOptions{}
 	listOpts.ApplyOptions(opts)
 	if listOpts.FieldSelector != nil {
 		// TODO(directxman12): support more complicated field selectors by
 		// combining multiple indices, GetIndexers, etc
 		field, val, requiresExact := requiresExactMatch(listOpts.FieldSelector)
 		if !requiresExact {
 			return fmt.Errorf("non-exact field matches are not supported by the cache")
 		}
 		// list all objects by the field selector.  If this is namespaced and we have one, ask for the
 		// namespaced index key.  Otherwise, ask for the non-namespaced variant by using the fake "all namespaces"
 		// namespace.
 		objs, err = c.indexer.ByIndex(FieldIndexName(field), KeyToNamespacedKey(listOpts.Namespace, val))
 	} else if listOpts.Namespace != "" {
 		objs, err = c.indexer.ByIndex(cache.NamespaceIndex, listOpts.Namespace)
 	} else {
 		objs = c.indexer.List()
 	}
 	if err != nil {
 		return err
 	}
 	var labelSel labels.Selector
 	if listOpts.LabelSelector != nil {
 		labelSel = listOpts.LabelSelector
 	}
 	runtimeObjs := make([]runtime.Object, 0, len(objs))
 	for _, item := range objs {
 		obj, isObj := item.(runtime.Object)
 		if !isObj {
 			return fmt.Errorf("cache contained %T, which is not an Object", obj)
 		}
 		meta, err := apimeta.Accessor(obj)
 		if err != nil {
 			return err
 		}
 		if labelSel != nil {
 			lbls := labels.Set(meta.GetLabels())
 			if !labelSel.Matches(lbls) {
 				continue
 			}
 		}
 		outObj := obj.DeepCopyObject()
 		outObj.GetObjectKind().SetGroupVersionKind(c.groupVersionKind)
 		runtimeObjs = append(runtimeObjs, outObj)
 	}
 	return apimeta.SetList(out, runtimeObjs)
 }
 // objectKeyToStorageKey converts an object key to store key.
 // It's akin to MetaNamespaceKeyFunc.  It's separate from
 // String to allow keeping the key format easily in sync with
 // MetaNamespaceKeyFunc.
 func objectKeyToStoreKey(k client.ObjectKey) string {
 	if k.Namespace == "" {
 		return k.Name
 	}
 	return k.Namespace + "/" + k.Name
 }
 // requiresExactMatch checks if the given field selector is of the form `k=v` or `k==v`.
 func requiresExactMatch(sel fields.Selector) (field, val string, required bool) {
 	reqs := sel.Requirements()
 	if len(reqs) != 1 {
 		return "", "", false
 	}
 	req := reqs[0]
 	if req.Operator != selection.Equals && req.Operator != selection.DoubleEquals {
 		return "", "", false
 	}
 	return req.Field, req.Value, true
 }
 // FieldIndexName constructs the name of the index over the given field,
 // for use with an indexer.
 func FieldIndexName(field string) string {
 	return "field:" + field
 }
 // noNamespaceNamespace is used as the "namespace" when we want to list across all namespaces
 const allNamespacesNamespace = "__all_namespaces"
 // KeyToNamespacedKey prefixes the given index key with a namespace
 // for use in field selector indexes.
 func KeyToNamespacedKey(ns string, baseKey string) string {
 	if ns != "" {
 		return ns + "/" + baseKey
 	}
 	return allNamespacesNamespace + "/" + baseKey
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/cache/internal/deleg_map.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/cache/internal/deleg_map.go
@ -0,0 +1,103 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package internal
 import (
 	"context"
 	"time"
 	"k8s.io/apimachinery/pkg/api/meta"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/client-go/rest"
 	"k8s.io/client-go/tools/cache"
 )
 // InformersMap create and caches Informers for (runtime.Object, schema.GroupVersionKind) pairs.
 // It uses a standard parameter codec constructed based on the given generated Scheme.
 type InformersMap struct {
 	// we abstract over the details of structured vs unstructured with the specificInformerMaps
 	structured   *specificInformersMap
 	unstructured *specificInformersMap
 	// Scheme maps runtime.Objects to GroupVersionKinds
 	Scheme *runtime.Scheme
 }
 // NewInformersMap creates a new InformersMap that can create informers for
 // both structured and unstructured objects.
 func NewInformersMap(config *rest.Config,
 	scheme *runtime.Scheme,
 	mapper meta.RESTMapper,
 	resync time.Duration,
 	namespace string) *InformersMap {
 	return &InformersMap{
 		structured:   newStructuredInformersMap(config, scheme, mapper, resync, namespace),
 		unstructured: newUnstructuredInformersMap(config, scheme, mapper, resync, namespace),
 		Scheme: scheme,
 	}
 }
 // Start calls Run on each of the informers and sets started to true.  Blocks on the stop channel.
 func (m *InformersMap) Start(stop <-chan struct{}) error {
 	go m.structured.Start(stop)
 	go m.unstructured.Start(stop)
 	<-stop
 	return nil
 }
 // WaitForCacheSync waits until all the caches have been started and synced.
 func (m *InformersMap) WaitForCacheSync(stop <-chan struct{}) bool {
 	syncedFuncs := append([]cache.InformerSynced(nil), m.structured.HasSyncedFuncs()...)
 	syncedFuncs = append(syncedFuncs, m.unstructured.HasSyncedFuncs()...)
 	if !m.structured.waitForStarted(stop) {
 		return false
 	}
 	if !m.unstructured.waitForStarted(stop) {
 		return false
 	}
 	return cache.WaitForCacheSync(stop, syncedFuncs...)
 }
 // Get will create a new Informer and add it to the map of InformersMap if none exists.  Returns
 // the Informer from the map.
 func (m *InformersMap) Get(ctx context.Context, gvk schema.GroupVersionKind, obj runtime.Object) (bool, *MapEntry, error) {
 	_, isUnstructured := obj.(*unstructured.Unstructured)
 	_, isUnstructuredList := obj.(*unstructured.UnstructuredList)
 	isUnstructured = isUnstructured || isUnstructuredList
 	if isUnstructured {
 		return m.unstructured.Get(ctx, gvk, obj)
 	}
 	return m.structured.Get(ctx, gvk, obj)
 }
 // newStructuredInformersMap creates a new InformersMap for structured objects.
 func newStructuredInformersMap(config *rest.Config, scheme *runtime.Scheme, mapper meta.RESTMapper, resync time.Duration, namespace string) *specificInformersMap {
 	return newSpecificInformersMap(config, scheme, mapper, resync, namespace, createStructuredListWatch)
 }
 // newUnstructuredInformersMap creates a new InformersMap for unstructured objects.
 func newUnstructuredInformersMap(config *rest.Config, scheme *runtime.Scheme, mapper meta.RESTMapper, resync time.Duration, namespace string) *specificInformersMap {
 	return newSpecificInformersMap(config, scheme, mapper, resync, namespace, createUnstructuredListWatch)
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/cache/internal/informers_map.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/cache/internal/informers_map.go
@ -0,0 +1,313 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package internal
 import (
 	"context"
 	"fmt"
 	"math/rand"
 	"sync"
 	"time"
 	apierrors "k8s.io/apimachinery/pkg/api/errors"
 	"k8s.io/apimachinery/pkg/api/meta"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/apimachinery/pkg/watch"
 	"k8s.io/client-go/dynamic"
 	"k8s.io/client-go/rest"
 	"k8s.io/client-go/tools/cache"
 	"sigs.k8s.io/controller-runtime/pkg/client/apiutil"
 )
 // clientListWatcherFunc knows how to create a ListWatcher
 type createListWatcherFunc func(gvk schema.GroupVersionKind, ip *specificInformersMap) (*cache.ListWatch, error)
 // newSpecificInformersMap returns a new specificInformersMap (like
 // the generical InformersMap, except that it doesn't implement WaitForCacheSync).
 func newSpecificInformersMap(config *rest.Config,
 	scheme *runtime.Scheme,
 	mapper meta.RESTMapper,
 	resync time.Duration,
 	namespace string,
 	createListWatcher createListWatcherFunc) *specificInformersMap {
 	ip := &specificInformersMap{
 		config:            config,
 		Scheme:            scheme,
 		mapper:            mapper,
 		informersByGVK:    make(map[schema.GroupVersionKind]*MapEntry),
 		codecs:            serializer.NewCodecFactory(scheme),
 		paramCodec:        runtime.NewParameterCodec(scheme),
 		resync:            resync,
 		startWait:         make(chan struct{}),
 		createListWatcher: createListWatcher,
 		namespace:         namespace,
 	}
 	return ip
 }
 // MapEntry contains the cached data for an Informer
 type MapEntry struct {
 	// Informer is the cached informer
 	Informer cache.SharedIndexInformer
 	// CacheReader wraps Informer and implements the CacheReader interface for a single type
 	Reader CacheReader
 }
 // specificInformersMap create and caches Informers for (runtime.Object, schema.GroupVersionKind) pairs.
 // It uses a standard parameter codec constructed based on the given generated Scheme.
 type specificInformersMap struct {
 	// Scheme maps runtime.Objects to GroupVersionKinds
 	Scheme *runtime.Scheme
 	// config is used to talk to the apiserver
 	config *rest.Config
 	// mapper maps GroupVersionKinds to Resources
 	mapper meta.RESTMapper
 	// informersByGVK is the cache of informers keyed by groupVersionKind
 	informersByGVK map[schema.GroupVersionKind]*MapEntry
 	// codecs is used to create a new REST client
 	codecs serializer.CodecFactory
 	// paramCodec is used by list and watch
 	paramCodec runtime.ParameterCodec
 	// stop is the stop channel to stop informers
 	stop <-chan struct{}
 	// resync is the base frequency the informers are resynced
 	// a 10 percent jitter will be added to the resync period between informers
 	// so that all informers will not send list requests simultaneously.
 	resync time.Duration
 	// mu guards access to the map
 	mu sync.RWMutex
 	// start is true if the informers have been started
 	started bool
 	// startWait is a channel that is closed after the
 	// informer has been started.
 	startWait chan struct{}
 	// createClient knows how to create a client and a list object,
 	// and allows for abstracting over the particulars of structured vs
 	// unstructured objects.
 	createListWatcher createListWatcherFunc
 	// namespace is the namespace that all ListWatches are restricted to
 	// default or empty string means all namespaces
 	namespace string
 }
 // Start calls Run on each of the informers and sets started to true.  Blocks on the stop channel.
 // It doesn't return start because it can't return an error, and it's not a runnable directly.
 func (ip *specificInformersMap) Start(stop <-chan struct{}) {
 	func() {
 		ip.mu.Lock()
 		defer ip.mu.Unlock()
 		// Set the stop channel so it can be passed to informers that are added later
 		ip.stop = stop
 		// Start each informer
 		for _, informer := range ip.informersByGVK {
 			go informer.Informer.Run(stop)
 		}
 		// Set started to true so we immediately start any informers added later.
 		ip.started = true
 		close(ip.startWait)
 	}()
 	<-stop
 }
 func (ip *specificInformersMap) waitForStarted(stop <-chan struct{}) bool {
 	select {
 	case <-ip.startWait:
 		return true
 	case <-stop:
 		return false
 	}
 }
 // HasSyncedFuncs returns all the HasSynced functions for the informers in this map.
 func (ip *specificInformersMap) HasSyncedFuncs() []cache.InformerSynced {
 	ip.mu.RLock()
 	defer ip.mu.RUnlock()
 	syncedFuncs := make([]cache.InformerSynced, 0, len(ip.informersByGVK))
 	for _, informer := range ip.informersByGVK {
 		syncedFuncs = append(syncedFuncs, informer.Informer.HasSynced)
 	}
 	return syncedFuncs
 }
 // Get will create a new Informer and add it to the map of specificInformersMap if none exists.  Returns
 // the Informer from the map.
 func (ip *specificInformersMap) Get(ctx context.Context, gvk schema.GroupVersionKind, obj runtime.Object) (bool, *MapEntry, error) {
 	// Return the informer if it is found
 	i, started, ok := func() (*MapEntry, bool, bool) {
 		ip.mu.RLock()
 		defer ip.mu.RUnlock()
 		i, ok := ip.informersByGVK[gvk]
 		return i, ip.started, ok
 	}()
 	if !ok {
 		var err error
 		if i, started, err = ip.addInformerToMap(gvk, obj); err != nil {
 			return started, nil, err
 		}
 	}
 	if started && !i.Informer.HasSynced() {
 		// Wait for it to sync before returning the Informer so that folks don't read from a stale cache.
 		if !cache.WaitForCacheSync(ctx.Done(), i.Informer.HasSynced) {
 			return started, nil, apierrors.NewTimeoutError(fmt.Sprintf("failed waiting for %T Informer to sync", obj), 0)
 		}
 	}
 	return started, i, nil
 }
 func (ip *specificInformersMap) addInformerToMap(gvk schema.GroupVersionKind, obj runtime.Object) (*MapEntry, bool, error) {
 	ip.mu.Lock()
 	defer ip.mu.Unlock()
 	// Check the cache to see if we already have an Informer.  If we do, return the Informer.
 	// This is for the case where 2 routines tried to get the informer when it wasn't in the map
 	// so neither returned early, but the first one created it.
 	if i, ok := ip.informersByGVK[gvk]; ok {
 		return i, ip.started, nil
 	}
 	// Create a NewSharedIndexInformer and add it to the map.
 	var lw *cache.ListWatch
 	lw, err := ip.createListWatcher(gvk, ip)
 	if err != nil {
 		return nil, false, err
 	}
 	ni := cache.NewSharedIndexInformer(lw, obj, resyncPeriod(ip.resync)(), cache.Indexers{
 		cache.NamespaceIndex: cache.MetaNamespaceIndexFunc,
 	})
 	i := &MapEntry{
 		Informer: ni,
 		Reader:   CacheReader{indexer: ni.GetIndexer(), groupVersionKind: gvk},
 	}
 	ip.informersByGVK[gvk] = i
 	// Start the Informer if need by
 	// TODO(seans): write thorough tests and document what happens here - can you add indexers?
 	// can you add eventhandlers?
 	if ip.started {
 		go i.Informer.Run(ip.stop)
 	}
 	return i, ip.started, nil
 }
 // newListWatch returns a new ListWatch object that can be used to create a SharedIndexInformer.
 func createStructuredListWatch(gvk schema.GroupVersionKind, ip *specificInformersMap) (*cache.ListWatch, error) {
 	// Kubernetes APIs work against Resources, not GroupVersionKinds.  Map the
 	// groupVersionKind to the Resource API we will use.
 	mapping, err := ip.mapper.RESTMapping(gvk.GroupKind(), gvk.Version)
 	if err != nil {
 		return nil, err
 	}
 	client, err := apiutil.RESTClientForGVK(gvk, ip.config, ip.codecs)
 	if err != nil {
 		return nil, err
 	}
 	listGVK := gvk.GroupVersion().WithKind(gvk.Kind + "List")
 	listObj, err := ip.Scheme.New(listGVK)
 	if err != nil {
 		return nil, err
 	}
 	// TODO: the functions that make use of this ListWatch should be adapted to
 	//  pass in their own contexts instead of relying on this fixed one here.
 	ctx := context.TODO()
 	// Create a new ListWatch for the obj
 	return &cache.ListWatch{
 		ListFunc: func(opts metav1.ListOptions) (runtime.Object, error) {
 			res := listObj.DeepCopyObject()
 			isNamespaceScoped := ip.namespace != "" && mapping.Scope.Name() != meta.RESTScopeNameRoot
 			err := client.Get().NamespaceIfScoped(ip.namespace, isNamespaceScoped).Resource(mapping.Resource.Resource).VersionedParams(&opts, ip.paramCodec).Do(ctx).Into(res)
 			return res, err
 		},
 		// Setup the watch function
 		WatchFunc: func(opts metav1.ListOptions) (watch.Interface, error) {
 			// Watch needs to be set to true separately
 			opts.Watch = true
 			isNamespaceScoped := ip.namespace != "" && mapping.Scope.Name() != meta.RESTScopeNameRoot
 			return client.Get().NamespaceIfScoped(ip.namespace, isNamespaceScoped).Resource(mapping.Resource.Resource).VersionedParams(&opts, ip.paramCodec).Watch(ctx)
 		},
 	}, nil
 }
 func createUnstructuredListWatch(gvk schema.GroupVersionKind, ip *specificInformersMap) (*cache.ListWatch, error) {
 	// Kubernetes APIs work against Resources, not GroupVersionKinds.  Map the
 	// groupVersionKind to the Resource API we will use.
 	mapping, err := ip.mapper.RESTMapping(gvk.GroupKind(), gvk.Version)
 	if err != nil {
 		return nil, err
 	}
 	dynamicClient, err := dynamic.NewForConfig(ip.config)
 	if err != nil {
 		return nil, err
 	}
 	// TODO: the functions that make use of this ListWatch should be adapted to
 	//  pass in their own contexts instead of relying on this fixed one here.
 	ctx := context.TODO()
 	// Create a new ListWatch for the obj
 	return &cache.ListWatch{
 		ListFunc: func(opts metav1.ListOptions) (runtime.Object, error) {
 			if ip.namespace != "" && mapping.Scope.Name() != meta.RESTScopeNameRoot {
 				return dynamicClient.Resource(mapping.Resource).Namespace(ip.namespace).List(ctx, opts)
 			}
 			return dynamicClient.Resource(mapping.Resource).List(ctx, opts)
 		},
 		// Setup the watch function
 		WatchFunc: func(opts metav1.ListOptions) (watch.Interface, error) {
 			// Watch needs to be set to true separately
 			opts.Watch = true
 			if ip.namespace != "" && mapping.Scope.Name() != meta.RESTScopeNameRoot {
 				return dynamicClient.Resource(mapping.Resource).Namespace(ip.namespace).Watch(ctx, opts)
 			}
 			return dynamicClient.Resource(mapping.Resource).Watch(ctx, opts)
 		},
 	}, nil
 }
 // resyncPeriod returns a function which generates a duration each time it is
 // invoked; this is so that multiple controllers don't get into lock-step and all
 // hammer the apiserver with list requests simultaneously.
 func resyncPeriod(resync time.Duration) func() time.Duration {
 	return func() time.Duration {
 		// the factor will fall into [0.9, 1.1)
 		factor := rand.Float64()/5.0 + 0.9
 		return time.Duration(float64(resync.Nanoseconds()) * factor)
 	}
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/cache/multi_namespace_cache.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/cache/multi_namespace_cache.go
@ -0,0 +1,222 @@
 /*
 Copyright 2019 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package cache
 import (
 	"context"
 	"fmt"
 	"time"
 	corev1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/meta"
 	apimeta "k8s.io/apimachinery/pkg/api/meta"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/client-go/rest"
 	toolscache "k8s.io/client-go/tools/cache"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 )
 // NewCacheFunc - Function for creating a new cache from the options and a rest config
 type NewCacheFunc func(config *rest.Config, opts Options) (Cache, error)
 // MultiNamespacedCacheBuilder - Builder function to create a new multi-namespaced cache.
 // This will scope the cache to a list of namespaces. Listing for all namespaces
 // will list for all the namespaces that this knows about. Note that this is not intended
 // to be used for excluding namespaces, this is better done via a Predicate. Also note that
 // you may face performance issues when using this with a high number of namespaces.
 func MultiNamespacedCacheBuilder(namespaces []string) NewCacheFunc {
 	return func(config *rest.Config, opts Options) (Cache, error) {
 		opts, err := defaultOpts(config, opts)
 		if err != nil {
 			return nil, err
 		}
 		caches := map[string]Cache{}
 		for _, ns := range namespaces {
 			opts.Namespace = ns
 			c, err := New(config, opts)
 			if err != nil {
 				return nil, err
 			}
 			caches[ns] = c
 		}
 		return &multiNamespaceCache{namespaceToCache: caches, Scheme: opts.Scheme}, nil
 	}
 }
 // multiNamespaceCache knows how to handle multiple namespaced caches
 // Use this feature when scoping permissions for your
 // operator to a list of namespaces instead of watching every namespace
 // in the cluster.
 type multiNamespaceCache struct {
 	namespaceToCache map[string]Cache
 	Scheme           *runtime.Scheme
 }
 var _ Cache = &multiNamespaceCache{}
 // Methods for multiNamespaceCache to conform to the Informers interface
 func (c *multiNamespaceCache) GetInformer(ctx context.Context, obj runtime.Object) (Informer, error) {
 	informers := map[string]Informer{}
 	for ns, cache := range c.namespaceToCache {
 		informer, err := cache.GetInformer(ctx, obj)
 		if err != nil {
 			return nil, err
 		}
 		informers[ns] = informer
 	}
 	return &multiNamespaceInformer{namespaceToInformer: informers}, nil
 }
 func (c *multiNamespaceCache) GetInformerForKind(ctx context.Context, gvk schema.GroupVersionKind) (Informer, error) {
 	informers := map[string]Informer{}
 	for ns, cache := range c.namespaceToCache {
 		informer, err := cache.GetInformerForKind(ctx, gvk)
 		if err != nil {
 			return nil, err
 		}
 		informers[ns] = informer
 	}
 	return &multiNamespaceInformer{namespaceToInformer: informers}, nil
 }
 func (c *multiNamespaceCache) Start(stopCh <-chan struct{}) error {
 	for ns, cache := range c.namespaceToCache {
 		go func(ns string, cache Cache) {
 			err := cache.Start(stopCh)
 			if err != nil {
 				log.Error(err, "multinamespace cache failed to start namespaced informer", "namespace", ns)
 			}
 		}(ns, cache)
 	}
 	<-stopCh
 	return nil
 }
 func (c *multiNamespaceCache) WaitForCacheSync(stop <-chan struct{}) bool {
 	synced := true
 	for _, cache := range c.namespaceToCache {
 		if s := cache.WaitForCacheSync(stop); !s {
 			synced = s
 		}
 	}
 	return synced
 }
 func (c *multiNamespaceCache) IndexField(ctx context.Context, obj runtime.Object, field string, extractValue client.IndexerFunc) error {
 	for _, cache := range c.namespaceToCache {
 		if err := cache.IndexField(ctx, obj, field, extractValue); err != nil {
 			return err
 		}
 	}
 	return nil
 }
 func (c *multiNamespaceCache) Get(ctx context.Context, key client.ObjectKey, obj runtime.Object) error {
 	cache, ok := c.namespaceToCache[key.Namespace]
 	if !ok {
 		return fmt.Errorf("unable to get: %v because of unknown namespace for the cache", key)
 	}
 	return cache.Get(ctx, key, obj)
 }
 // List multi namespace cache will get all the objects in the namespaces that the cache is watching if asked for all namespaces.
 func (c *multiNamespaceCache) List(ctx context.Context, list runtime.Object, opts ...client.ListOption) error {
 	listOpts := client.ListOptions{}
 	listOpts.ApplyOptions(opts)
 	if listOpts.Namespace != corev1.NamespaceAll {
 		cache, ok := c.namespaceToCache[listOpts.Namespace]
 		if !ok {
 			return fmt.Errorf("unable to get: %v because of unknown namespace for the cache", listOpts.Namespace)
 		}
 		return cache.List(ctx, list, opts...)
 	}
 	listAccessor, err := meta.ListAccessor(list)
 	if err != nil {
 		return err
 	}
 	allItems, err := apimeta.ExtractList(list)
 	if err != nil {
 		return err
 	}
 	var resourceVersion string
 	for _, cache := range c.namespaceToCache {
 		listObj := list.DeepCopyObject()
 		err = cache.List(ctx, listObj, opts...)
 		if err != nil {
 			return err
 		}
 		items, err := apimeta.ExtractList(listObj)
 		if err != nil {
 			return err
 		}
 		accessor, err := meta.ListAccessor(listObj)
 		if err != nil {
 			return fmt.Errorf("object: %T must be a list type", list)
 		}
 		allItems = append(allItems, items...)
 		// The last list call should have the most correct resource version.
 		resourceVersion = accessor.GetResourceVersion()
 	}
 	listAccessor.SetResourceVersion(resourceVersion)
 	return apimeta.SetList(list, allItems)
 }
 // multiNamespaceInformer knows how to handle interacting with the underlying informer across multiple namespaces
 type multiNamespaceInformer struct {
 	namespaceToInformer map[string]Informer
 }
 var _ Informer = &multiNamespaceInformer{}
 // AddEventHandler adds the handler to each namespaced informer
 func (i *multiNamespaceInformer) AddEventHandler(handler toolscache.ResourceEventHandler) {
 	for _, informer := range i.namespaceToInformer {
 		informer.AddEventHandler(handler)
 	}
 }
 // AddEventHandlerWithResyncPeriod adds the handler with a resync period to each namespaced informer
 func (i *multiNamespaceInformer) AddEventHandlerWithResyncPeriod(handler toolscache.ResourceEventHandler, resyncPeriod time.Duration) {
 	for _, informer := range i.namespaceToInformer {
 		informer.AddEventHandlerWithResyncPeriod(handler, resyncPeriod)
 	}
 }
 // AddIndexers adds the indexer for each namespaced informer
 func (i *multiNamespaceInformer) AddIndexers(indexers toolscache.Indexers) error {
 	for _, informer := range i.namespaceToInformer {
 		err := informer.AddIndexers(indexers)
 		if err != nil {
 			return err
 		}
 	}
 	return nil
 }
 // HasSynced checks if each namespaced informer has synced
 func (i *multiNamespaceInformer) HasSynced() bool {
 	for _, informer := range i.namespaceToInformer {
 		if ok := informer.HasSynced(); !ok {
 			return ok
 		}
 	}
 	return true
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/client/apiutil/apimachinery.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/client/apiutil/apimachinery.go
@ -0,0 +1,97 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 // Package apiutil contains utilities for working with raw Kubernetes
 // API machinery, such as creating RESTMappers and raw REST clients,
 // and extracting the GVK of an object.
 package apiutil
 import (
 	"fmt"
 	"k8s.io/apimachinery/pkg/api/meta"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/client-go/discovery"
 	"k8s.io/client-go/rest"
 	"k8s.io/client-go/restmapper"
 )
 // NewDiscoveryRESTMapper constructs a new RESTMapper based on discovery
 // information fetched by a new client with the given config.
 func NewDiscoveryRESTMapper(c *rest.Config) (meta.RESTMapper, error) {
 	// Get a mapper
 	dc, err := discovery.NewDiscoveryClientForConfig(c)
 	if err != nil {
 		return nil, err
 	}
 	gr, err := restmapper.GetAPIGroupResources(dc)
 	if err != nil {
 		return nil, err
 	}
 	return restmapper.NewDiscoveryRESTMapper(gr), nil
 }
 // GVKForObject finds the GroupVersionKind associated with the given object, if there is only a single such GVK.
 func GVKForObject(obj runtime.Object, scheme *runtime.Scheme) (schema.GroupVersionKind, error) {
 	gvks, isUnversioned, err := scheme.ObjectKinds(obj)
 	if err != nil {
 		return schema.GroupVersionKind{}, err
 	}
 	if isUnversioned {
 		return schema.GroupVersionKind{}, fmt.Errorf("cannot create a new informer for the unversioned type %T", obj)
 	}
 	if len(gvks) < 1 {
 		return schema.GroupVersionKind{}, fmt.Errorf("no group-version-kinds associated with type %T", obj)
 	}
 	if len(gvks) > 1 {
 		// this should only trigger for things like metav1.XYZ --
 		// normal versioned types should be fine
 		return schema.GroupVersionKind{}, fmt.Errorf(
 			"multiple group-version-kinds associated with type %T, refusing to guess at one", obj)
 	}
 	return gvks[0], nil
 }
 // RESTClientForGVK constructs a new rest.Interface capable of accessing the resource associated
 // with the given GroupVersionKind. The REST client will be configured to use the negotiated serializer from
 // baseConfig, if set, otherwise a default serializer will be set.
 func RESTClientForGVK(gvk schema.GroupVersionKind, baseConfig *rest.Config, codecs serializer.CodecFactory) (rest.Interface, error) {
 	cfg := createRestConfig(gvk, baseConfig)
 	if cfg.NegotiatedSerializer == nil {
 		cfg.NegotiatedSerializer = serializer.WithoutConversionCodecFactory{CodecFactory: codecs}
 	}
 	return rest.RESTClientFor(cfg)
 }
 //createRestConfig copies the base config and updates needed fields for a new rest config
 func createRestConfig(gvk schema.GroupVersionKind, baseConfig *rest.Config) *rest.Config {
 	gv := gvk.GroupVersion()
 	cfg := rest.CopyConfig(baseConfig)
 	cfg.GroupVersion = &gv
 	if gvk.Group == "" {
 		cfg.APIPath = "/api"
 	} else {
 		cfg.APIPath = "/apis"
 	}
 	if cfg.UserAgent == "" {
 		cfg.UserAgent = rest.DefaultKubernetesUserAgent()
 	}
 	return cfg
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/client/apiutil/dynamicrestmapper.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/client/apiutil/dynamicrestmapper.go
@ -0,0 +1,323 @@
 /*
 Copyright 2019 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package apiutil
 import (
 	"errors"
 	"sync"
 	"time"
 	"golang.org/x/time/rate"
 	"k8s.io/apimachinery/pkg/api/meta"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/client-go/discovery"
 	"k8s.io/client-go/rest"
 	"k8s.io/client-go/restmapper"
 )
 // ErrRateLimited is returned by a RESTMapper method if the number of API
 // calls has exceeded a limit within a certain time period.
 type ErrRateLimited struct {
 	// Duration to wait until the next API call can be made.
 	Delay time.Duration
 }
 func (e ErrRateLimited) Error() string {
 	return "too many API calls to the RESTMapper within a timeframe"
 }
 // DelayIfRateLimited returns the delay time until the next API call is
 // allowed and true if err is of type ErrRateLimited. The zero
 // time.Duration value and false are returned if err is not a ErrRateLimited.
 func DelayIfRateLimited(err error) (time.Duration, bool) {
 	var rlerr ErrRateLimited
 	if errors.As(err, &rlerr) {
 		return rlerr.Delay, true
 	}
 	return 0, false
 }
 // dynamicRESTMapper is a RESTMapper that dynamically discovers resource
 // types at runtime.
 type dynamicRESTMapper struct {
 	mu           sync.RWMutex // protects the following fields
 	staticMapper meta.RESTMapper
 	limiter      *dynamicLimiter
 	newMapper    func() (meta.RESTMapper, error)
 	lazy bool
 	// Used for lazy init.
 	initOnce sync.Once
 }
 // DynamicRESTMapperOption is a functional option on the dynamicRESTMapper
 type DynamicRESTMapperOption func(*dynamicRESTMapper) error
 // WithLimiter sets the RESTMapper's underlying limiter to lim.
 func WithLimiter(lim *rate.Limiter) DynamicRESTMapperOption {
 	return func(drm *dynamicRESTMapper) error {
 		drm.limiter = &dynamicLimiter{lim}
 		return nil
 	}
 }
 // WithLazyDiscovery prevents the RESTMapper from discovering REST mappings
 // until an API call is made.
 var WithLazyDiscovery DynamicRESTMapperOption = func(drm *dynamicRESTMapper) error {
 	drm.lazy = true
 	return nil
 }
 // WithCustomMapper supports setting a custom RESTMapper refresher instead of
 // the default method, which uses a discovery client.
 //
 // This exists mainly for testing, but can be useful if you need tighter control
 // over how discovery is performed, which discovery endpoints are queried, etc.
 func WithCustomMapper(newMapper func() (meta.RESTMapper, error)) DynamicRESTMapperOption {
 	return func(drm *dynamicRESTMapper) error {
 		drm.newMapper = newMapper
 		return nil
 	}
 }
 // NewDynamicRESTMapper returns a dynamic RESTMapper for cfg. The dynamic
 // RESTMapper dynamically discovers resource types at runtime. opts
 // configure the RESTMapper.
 func NewDynamicRESTMapper(cfg *rest.Config, opts ...DynamicRESTMapperOption) (meta.RESTMapper, error) {
 	client, err := discovery.NewDiscoveryClientForConfig(cfg)
 	if err != nil {
 		return nil, err
 	}
 	drm := &dynamicRESTMapper{
 		limiter: &dynamicLimiter{
 			rate.NewLimiter(rate.Limit(defaultRefillRate), defaultLimitSize),
 		},
 		newMapper: func() (meta.RESTMapper, error) {
 			groupResources, err := restmapper.GetAPIGroupResources(client)
 			if err != nil {
 				return nil, err
 			}
 			return restmapper.NewDiscoveryRESTMapper(groupResources), nil
 		},
 	}
 	for _, opt := range opts {
 		if err = opt(drm); err != nil {
 			return nil, err
 		}
 	}
 	if !drm.lazy {
 		if err := drm.setStaticMapper(); err != nil {
 			return nil, err
 		}
 	}
 	return drm, nil
 }
 var (
 	// defaultRefilRate is the default rate at which potential calls are
 	// added back to the "bucket" of allowed calls.
 	defaultRefillRate = 5
 	// defaultLimitSize is the default starting/max number of potential calls
 	// per second.  Once a call is used, it's added back to the bucket at a rate
 	// of defaultRefillRate per second.
 	defaultLimitSize = 5
 )
 // setStaticMapper sets drm's staticMapper by querying its client, regardless
 // of reload backoff.
 func (drm *dynamicRESTMapper) setStaticMapper() error {
 	newMapper, err := drm.newMapper()
 	if err != nil {
 		return err
 	}
 	drm.staticMapper = newMapper
 	return nil
 }
 // init initializes drm only once if drm is lazy.
 func (drm *dynamicRESTMapper) init() (err error) {
 	drm.initOnce.Do(func() {
 		if drm.lazy {
 			err = drm.setStaticMapper()
 		}
 	})
 	return err
 }
 // checkAndReload attempts to call the given callback, which is assumed to be dependent
 // on the data in the restmapper.
 //
 // If the callback returns a NoKindMatchError, it will attempt to reload
 // the RESTMapper's data and re-call the callback once that's occurred.
 // If the callback returns any other error, the function will return immediately regardless.
 //
 // It will take care
 // ensuring that reloads are rate-limitted and that extraneous calls aren't made.
 // It's thread-safe, and worries about thread-safety for the callback (so the callback does
 // not need to attempt to lock the restmapper).
 func (drm *dynamicRESTMapper) checkAndReload(needsReloadErr error, checkNeedsReload func() error) error {
 	// first, check the common path -- data is fresh enough
 	// (use an IIFE for the lock's defer)
 	err := func() error {
 		drm.mu.RLock()
 		defer drm.mu.RUnlock()
 		return checkNeedsReload()
 	}()
 	// NB(directxman12): `Is` and `As` have a confusing relationship --
 	// `Is` is like `== or does this implement .Is`, whereas `As` says
 	// `can I type-assert into`
 	needsReload := errors.As(err, &needsReloadErr)
 	if !needsReload {
 		return err
 	}
 	// if the data wasn't fresh, we'll need to try and update it, so grab the lock...
 	drm.mu.Lock()
 	defer drm.mu.Unlock()
 	// ... and double-check that we didn't reload in the meantime
 	err = checkNeedsReload()
 	needsReload = errors.As(err, &needsReloadErr)
 	if !needsReload {
 		return err
 	}
 	// we're still stale, so grab a rate-limit token if we can...
 	if err := drm.limiter.checkRate(); err != nil {
 		return err
 	}
 	// ...reload...
 	if err := drm.setStaticMapper(); err != nil {
 		return err
 	}
 	// ...and return the results of the closure regardless
 	return checkNeedsReload()
 }
 // TODO: wrap reload errors on NoKindMatchError with go 1.13 errors.
 func (drm *dynamicRESTMapper) KindFor(resource schema.GroupVersionResource) (schema.GroupVersionKind, error) {
 	if err := drm.init(); err != nil {
 		return schema.GroupVersionKind{}, err
 	}
 	var gvk schema.GroupVersionKind
 	err := drm.checkAndReload(&meta.NoResourceMatchError{}, func() error {
 		var err error
 		gvk, err = drm.staticMapper.KindFor(resource)
 		return err
 	})
 	return gvk, err
 }
 func (drm *dynamicRESTMapper) KindsFor(resource schema.GroupVersionResource) ([]schema.GroupVersionKind, error) {
 	if err := drm.init(); err != nil {
 		return nil, err
 	}
 	var gvks []schema.GroupVersionKind
 	err := drm.checkAndReload(&meta.NoResourceMatchError{}, func() error {
 		var err error
 		gvks, err = drm.staticMapper.KindsFor(resource)
 		return err
 	})
 	return gvks, err
 }
 func (drm *dynamicRESTMapper) ResourceFor(input schema.GroupVersionResource) (schema.GroupVersionResource, error) {
 	if err := drm.init(); err != nil {
 		return schema.GroupVersionResource{}, err
 	}
 	var gvr schema.GroupVersionResource
 	err := drm.checkAndReload(&meta.NoResourceMatchError{}, func() error {
 		var err error
 		gvr, err = drm.staticMapper.ResourceFor(input)
 		return err
 	})
 	return gvr, err
 }
 func (drm *dynamicRESTMapper) ResourcesFor(input schema.GroupVersionResource) ([]schema.GroupVersionResource, error) {
 	if err := drm.init(); err != nil {
 		return nil, err
 	}
 	var gvrs []schema.GroupVersionResource
 	err := drm.checkAndReload(&meta.NoResourceMatchError{}, func() error {
 		var err error
 		gvrs, err = drm.staticMapper.ResourcesFor(input)
 		return err
 	})
 	return gvrs, err
 }
 func (drm *dynamicRESTMapper) RESTMapping(gk schema.GroupKind, versions ...string) (*meta.RESTMapping, error) {
 	if err := drm.init(); err != nil {
 		return nil, err
 	}
 	var mapping *meta.RESTMapping
 	err := drm.checkAndReload(&meta.NoKindMatchError{}, func() error {
 		var err error
 		mapping, err = drm.staticMapper.RESTMapping(gk, versions...)
 		return err
 	})
 	return mapping, err
 }
 func (drm *dynamicRESTMapper) RESTMappings(gk schema.GroupKind, versions ...string) ([]*meta.RESTMapping, error) {
 	if err := drm.init(); err != nil {
 		return nil, err
 	}
 	var mappings []*meta.RESTMapping
 	err := drm.checkAndReload(&meta.NoKindMatchError{}, func() error {
 		var err error
 		mappings, err = drm.staticMapper.RESTMappings(gk, versions...)
 		return err
 	})
 	return mappings, err
 }
 func (drm *dynamicRESTMapper) ResourceSingularizer(resource string) (string, error) {
 	if err := drm.init(); err != nil {
 		return "", err
 	}
 	var singular string
 	err := drm.checkAndReload(&meta.NoResourceMatchError{}, func() error {
 		var err error
 		singular, err = drm.staticMapper.ResourceSingularizer(resource)
 		return err
 	})
 	return singular, err
 }
 // dynamicLimiter holds a rate limiter used to throttle chatty RESTMapper users.
 type dynamicLimiter struct {
 	*rate.Limiter
 }
 // checkRate returns an ErrRateLimited if too many API calls have been made
 // within the set limit.
 func (b *dynamicLimiter) checkRate() error {
 	res := b.Reserve()
 	if res.Delay() == 0 {
 		return nil
 	}
 	res.Cancel()
 	return ErrRateLimited{res.Delay()}
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/client/client.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/client/client.go
@ -0,0 +1,208 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package client
 import (
 	"context"
 	"fmt"
 	"k8s.io/apimachinery/pkg/api/meta"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/client-go/kubernetes/scheme"
 	"k8s.io/client-go/rest"
 	"sigs.k8s.io/controller-runtime/pkg/client/apiutil"
 )
 // Options are creation options for a Client
 type Options struct {
 	// Scheme, if provided, will be used to map go structs to GroupVersionKinds
 	Scheme *runtime.Scheme
 	// Mapper, if provided, will be used to map GroupVersionKinds to Resources
 	Mapper meta.RESTMapper
 }
 // New returns a new Client using the provided config and Options.
 // The returned client reads *and* writes directly from the server
 // (it doesn't use object caches).  It understands how to work with
 // normal types (both custom resources and aggregated/built-in resources),
 // as well as unstructured types.
 //
 // In the case of normal types, the scheme will be used to look up the
 // corresponding group, version, and kind for the given type.  In the
 // case of unstructured types, the group, version, and kind will be extracted
 // from the corresponding fields on the object.
 func New(config *rest.Config, options Options) (Client, error) {
 	if config == nil {
 		return nil, fmt.Errorf("must provide non-nil rest.Config to client.New")
 	}
 	// Init a scheme if none provided
 	if options.Scheme == nil {
 		options.Scheme = scheme.Scheme
 	}
 	// Init a Mapper if none provided
 	if options.Mapper == nil {
 		var err error
 		options.Mapper, err = apiutil.NewDynamicRESTMapper(config)
 		if err != nil {
 			return nil, err
 		}
 	}
 	clientcache := &clientCache{
 		config:         config,
 		scheme:         options.Scheme,
 		mapper:         options.Mapper,
 		codecs:         serializer.NewCodecFactory(options.Scheme),
 		resourceByType: make(map[schema.GroupVersionKind]*resourceMeta),
 	}
 	c := &client{
 		typedClient: typedClient{
 			cache:      clientcache,
 			paramCodec: runtime.NewParameterCodec(options.Scheme),
 		},
 		unstructuredClient: unstructuredClient{
 			cache:      clientcache,
 			paramCodec: noConversionParamCodec{},
 		},
 	}
 	return c, nil
 }
 var _ Client = &client{}
 // client is a client.Client that reads and writes directly from/to an API server.  It lazily initializes
 // new clients at the time they are used, and caches the client.
 type client struct {
 	typedClient        typedClient
 	unstructuredClient unstructuredClient
 }
 // resetGroupVersionKind is a helper function to restore and preserve GroupVersionKind on an object.
 // TODO(vincepri): Remove this function and its calls once controller-runtime dependencies are upgraded to 1.16?
 func (c *client) resetGroupVersionKind(obj runtime.Object, gvk schema.GroupVersionKind) {
 	if gvk != schema.EmptyObjectKind.GroupVersionKind() {
 		if v, ok := obj.(schema.ObjectKind); ok {
 			v.SetGroupVersionKind(gvk)
 		}
 	}
 }
 // Create implements client.Client
 func (c *client) Create(ctx context.Context, obj runtime.Object, opts ...CreateOption) error {
 	_, ok := obj.(*unstructured.Unstructured)
 	if ok {
 		return c.unstructuredClient.Create(ctx, obj, opts...)
 	}
 	return c.typedClient.Create(ctx, obj, opts...)
 }
 // Update implements client.Client
 func (c *client) Update(ctx context.Context, obj runtime.Object, opts ...UpdateOption) error {
 	defer c.resetGroupVersionKind(obj, obj.GetObjectKind().GroupVersionKind())
 	_, ok := obj.(*unstructured.Unstructured)
 	if ok {
 		return c.unstructuredClient.Update(ctx, obj, opts...)
 	}
 	return c.typedClient.Update(ctx, obj, opts...)
 }
 // Delete implements client.Client
 func (c *client) Delete(ctx context.Context, obj runtime.Object, opts ...DeleteOption) error {
 	_, ok := obj.(*unstructured.Unstructured)
 	if ok {
 		return c.unstructuredClient.Delete(ctx, obj, opts...)
 	}
 	return c.typedClient.Delete(ctx, obj, opts...)
 }
 // DeleteAllOf implements client.Client
 func (c *client) DeleteAllOf(ctx context.Context, obj runtime.Object, opts ...DeleteAllOfOption) error {
 	_, ok := obj.(*unstructured.Unstructured)
 	if ok {
 		return c.unstructuredClient.DeleteAllOf(ctx, obj, opts...)
 	}
 	return c.typedClient.DeleteAllOf(ctx, obj, opts...)
 }
 // Patch implements client.Client
 func (c *client) Patch(ctx context.Context, obj runtime.Object, patch Patch, opts ...PatchOption) error {
 	defer c.resetGroupVersionKind(obj, obj.GetObjectKind().GroupVersionKind())
 	_, ok := obj.(*unstructured.Unstructured)
 	if ok {
 		return c.unstructuredClient.Patch(ctx, obj, patch, opts...)
 	}
 	return c.typedClient.Patch(ctx, obj, patch, opts...)
 }
 // Get implements client.Client
 func (c *client) Get(ctx context.Context, key ObjectKey, obj runtime.Object) error {
 	_, ok := obj.(*unstructured.Unstructured)
 	if ok {
 		return c.unstructuredClient.Get(ctx, key, obj)
 	}
 	return c.typedClient.Get(ctx, key, obj)
 }
 // List implements client.Client
 func (c *client) List(ctx context.Context, obj runtime.Object, opts ...ListOption) error {
 	_, ok := obj.(*unstructured.UnstructuredList)
 	if ok {
 		return c.unstructuredClient.List(ctx, obj, opts...)
 	}
 	return c.typedClient.List(ctx, obj, opts...)
 }
 // Status implements client.StatusClient
 func (c *client) Status() StatusWriter {
 	return &statusWriter{client: c}
 }
 // statusWriter is client.StatusWriter that writes status subresource
 type statusWriter struct {
 	client *client
 }
 // ensure statusWriter implements client.StatusWriter
 var _ StatusWriter = &statusWriter{}
 // Update implements client.StatusWriter
 func (sw *statusWriter) Update(ctx context.Context, obj runtime.Object, opts ...UpdateOption) error {
 	defer sw.client.resetGroupVersionKind(obj, obj.GetObjectKind().GroupVersionKind())
 	_, ok := obj.(*unstructured.Unstructured)
 	if ok {
 		return sw.client.unstructuredClient.UpdateStatus(ctx, obj, opts...)
 	}
 	return sw.client.typedClient.UpdateStatus(ctx, obj, opts...)
 }
 // Patch implements client.Client
 func (sw *statusWriter) Patch(ctx context.Context, obj runtime.Object, patch Patch, opts ...PatchOption) error {
 	defer sw.client.resetGroupVersionKind(obj, obj.GetObjectKind().GroupVersionKind())
 	_, ok := obj.(*unstructured.Unstructured)
 	if ok {
 		return sw.client.unstructuredClient.PatchStatus(ctx, obj, patch, opts...)
 	}
 	return sw.client.typedClient.PatchStatus(ctx, obj, patch, opts...)
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/client/client_cache.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/client/client_cache.go
@ -0,0 +1,140 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package client
 import (
 	"strings"
 	"sync"
 	"k8s.io/apimachinery/pkg/api/meta"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/client-go/rest"
 	"sigs.k8s.io/controller-runtime/pkg/client/apiutil"
 )
 // clientCache creates and caches rest clients and metadata for Kubernetes types
 type clientCache struct {
 	// config is the rest.Config to talk to an apiserver
 	config *rest.Config
 	// scheme maps go structs to GroupVersionKinds
 	scheme *runtime.Scheme
 	// mapper maps GroupVersionKinds to Resources
 	mapper meta.RESTMapper
 	// codecs are used to create a REST client for a gvk
 	codecs serializer.CodecFactory
 	// resourceByType caches type metadata
 	resourceByType map[schema.GroupVersionKind]*resourceMeta
 	mu             sync.RWMutex
 }
 // newResource maps obj to a Kubernetes Resource and constructs a client for that Resource.
 // If the object is a list, the resource represents the item's type instead.
 func (c *clientCache) newResource(gvk schema.GroupVersionKind, isList bool) (*resourceMeta, error) {
 	if strings.HasSuffix(gvk.Kind, "List") && isList {
 		// if this was a list, treat it as a request for the item's resource
 		gvk.Kind = gvk.Kind[:len(gvk.Kind)-4]
 	}
 	client, err := apiutil.RESTClientForGVK(gvk, c.config, c.codecs)
 	if err != nil {
 		return nil, err
 	}
 	mapping, err := c.mapper.RESTMapping(gvk.GroupKind(), gvk.Version)
 	if err != nil {
 		return nil, err
 	}
 	return &resourceMeta{Interface: client, mapping: mapping, gvk: gvk}, nil
 }
 // getResource returns the resource meta information for the given type of object.
 // If the object is a list, the resource represents the item's type instead.
 func (c *clientCache) getResource(obj runtime.Object) (*resourceMeta, error) {
 	gvk, err := apiutil.GVKForObject(obj, c.scheme)
 	if err != nil {
 		return nil, err
 	}
 	// It's better to do creation work twice than to not let multiple
 	// people make requests at once
 	c.mu.RLock()
 	r, known := c.resourceByType[gvk]
 	c.mu.RUnlock()
 	if known {
 		return r, nil
 	}
 	// Initialize a new Client
 	c.mu.Lock()
 	defer c.mu.Unlock()
 	r, err = c.newResource(gvk, meta.IsListType(obj))
 	if err != nil {
 		return nil, err
 	}
 	c.resourceByType[gvk] = r
 	return r, err
 }
 // getObjMeta returns objMeta containing both type and object metadata and state
 func (c *clientCache) getObjMeta(obj runtime.Object) (*objMeta, error) {
 	r, err := c.getResource(obj)
 	if err != nil {
 		return nil, err
 	}
 	m, err := meta.Accessor(obj)
 	if err != nil {
 		return nil, err
 	}
 	return &objMeta{resourceMeta: r, Object: m}, err
 }
 // resourceMeta caches state for a Kubernetes type.
 type resourceMeta struct {
 	// client is the rest client used to talk to the apiserver
 	rest.Interface
 	// gvk is the GroupVersionKind of the resourceMeta
 	gvk schema.GroupVersionKind
 	// mapping is the rest mapping
 	mapping *meta.RESTMapping
 }
 // isNamespaced returns true if the type is namespaced
 func (r *resourceMeta) isNamespaced() bool {
 	return r.mapping.Scope.Name() != meta.RESTScopeNameRoot
 }
 // resource returns the resource name of the type
 func (r *resourceMeta) resource() string {
 	return r.mapping.Resource.Resource
 }
 // objMeta stores type and object information about a Kubernetes type
 type objMeta struct {
 	// resourceMeta contains type information for the object
 	*resourceMeta
 	// Object contains meta data for the object instance
 	metav1.Object
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/client/codec.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/client/codec.go
@ -0,0 +1,24 @@
 package client
 import (
 	"errors"
 	"net/url"
 	"k8s.io/apimachinery/pkg/conversion/queryparams"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 )
 var _ runtime.ParameterCodec = noConversionParamCodec{}
 // noConversionParamCodec is a no-conversion codec for serializing parameters into URL query strings.
 // it's useful in scenarios with the unstructured client and arbitrary resouces.
 type noConversionParamCodec struct{}
 func (noConversionParamCodec) EncodeParameters(obj runtime.Object, to schema.GroupVersion) (url.Values, error) {
 	return queryparams.Convert(obj)
 }
 func (noConversionParamCodec) DecodeParameters(parameters url.Values, from schema.GroupVersion, into runtime.Object) error {
 	return errors.New("DecodeParameters not implemented on noConversionParamCodec")
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/client/config/config.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/client/config/config.go
@ -0,0 +1,163 @@
 /*
 Copyright 2017 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package config
 import (
 	"flag"
 	"fmt"
 	"os"
 	"os/user"
 	"path"
 	"k8s.io/client-go/rest"
 	"k8s.io/client-go/tools/clientcmd"
 	clientcmdapi "k8s.io/client-go/tools/clientcmd/api"
 	logf "sigs.k8s.io/controller-runtime/pkg/internal/log"
 )
 var (
 	kubeconfig, apiServerURL string
 	log                      = logf.RuntimeLog.WithName("client").WithName("config")
 )
 func init() {
 	// TODO: Fix this to allow double vendoring this library but still register flags on behalf of users
 	flag.StringVar(&kubeconfig, "kubeconfig", "",
 		"Paths to a kubeconfig. Only required if out-of-cluster.")
 	// This flag is deprecated, it'll be removed in a future iteration, please switch to --kubeconfig.
 	flag.StringVar(&apiServerURL, "master", "",
 		"(Deprecated: switch to `--kubeconfig`) The address of the Kubernetes API server. Overrides any value in kubeconfig. "+
 			"Only required if out-of-cluster.")
 }
 // GetConfig creates a *rest.Config for talking to a Kubernetes API server.
 // If --kubeconfig is set, will use the kubeconfig file at that location.  Otherwise will assume running
 // in cluster and use the cluster provided kubeconfig.
 //
 // It also applies saner defaults for QPS and burst based on the Kubernetes
 // controller manager defaults (20 QPS, 30 burst)
 //
 // Config precedence
 //
 // * --kubeconfig flag pointing at a file
 //
 // * KUBECONFIG environment variable pointing at a file
 //
 // * In-cluster config if running in cluster
 //
 // * $HOME/.kube/config if exists
 func GetConfig() (*rest.Config, error) {
 	return GetConfigWithContext("")
 }
 // GetConfigWithContext creates a *rest.Config for talking to a Kubernetes API server with a specific context.
 // If --kubeconfig is set, will use the kubeconfig file at that location.  Otherwise will assume running
 // in cluster and use the cluster provided kubeconfig.
 //
 // It also applies saner defaults for QPS and burst based on the Kubernetes
 // controller manager defaults (20 QPS, 30 burst)
 //
 // Config precedence
 //
 // * --kubeconfig flag pointing at a file
 //
 // * KUBECONFIG environment variable pointing at a file
 //
 // * In-cluster config if running in cluster
 //
 // * $HOME/.kube/config if exists
 func GetConfigWithContext(context string) (*rest.Config, error) {
 	cfg, err := loadConfig(context)
 	if err != nil {
 		return nil, err
 	}
 	if cfg.QPS == 0.0 {
 		cfg.QPS = 20.0
 		cfg.Burst = 30.0
 	}
 	return cfg, nil
 }
 // loadInClusterConfig is a function used to load the in-cluster
 // Kubernetes client config. This variable makes is possible to
 // test the precedence of loading the config.
 var loadInClusterConfig = rest.InClusterConfig
 // loadConfig loads a REST Config as per the rules specified in GetConfig
 func loadConfig(context string) (*rest.Config, error) {
 	// If a flag is specified with the config location, use that
 	if len(kubeconfig) > 0 {
 		return loadConfigWithContext(apiServerURL, &clientcmd.ClientConfigLoadingRules{ExplicitPath: kubeconfig}, context)
 	}
 	// If the recommended kubeconfig env variable is not specified,
 	// try the in-cluster config.
 	kubeconfigPath := os.Getenv(clientcmd.RecommendedConfigPathEnvVar)
 	if len(kubeconfigPath) == 0 {
 		if c, err := loadInClusterConfig(); err == nil {
 			return c, nil
 		}
 	}
 	// If the recommended kubeconfig env variable is set, or there
 	// is no in-cluster config, try the default recommended locations.
 	//
 	// NOTE: For default config file locations, upstream only checks
 	// $HOME for the user's home directory, but we can also try
 	// os/user.HomeDir when $HOME is unset.
 	//
 	// TODO(jlanford): could this be done upstream?
 	loadingRules := clientcmd.NewDefaultClientConfigLoadingRules()
 	if _, ok := os.LookupEnv("HOME"); !ok {
 		u, err := user.Current()
 		if err != nil {
 			return nil, fmt.Errorf("could not get current user: %v", err)
 		}
 		loadingRules.Precedence = append(loadingRules.Precedence, path.Join(u.HomeDir, clientcmd.RecommendedHomeDir, clientcmd.RecommendedFileName))
 	}
 	return loadConfigWithContext(apiServerURL, loadingRules, context)
 }
 func loadConfigWithContext(apiServerURL string, loader clientcmd.ClientConfigLoader, context string) (*rest.Config, error) {
 	return clientcmd.NewNonInteractiveDeferredLoadingClientConfig(
 		loader,
 		&clientcmd.ConfigOverrides{
 			ClusterInfo: clientcmdapi.Cluster{
 				Server: apiServerURL,
 			},
 			CurrentContext: context,
 		}).ClientConfig()
 }
 // GetConfigOrDie creates a *rest.Config for talking to a Kubernetes apiserver.
 // If --kubeconfig is set, will use the kubeconfig file at that location.  Otherwise will assume running
 // in cluster and use the cluster provided kubeconfig.
 //
 // Will log an error and exit if there is an error creating the rest.Config.
 func GetConfigOrDie() *rest.Config {
 	config, err := GetConfig()
 	if err != nil {
 		log.Error(err, "unable to get kubeconfig")
 		os.Exit(1)
 	}
 	return config
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/client/config/doc.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/client/config/doc.go
@ -0,0 +1,18 @@
 /*
 Copyright 2017 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 // Package config contains libraries for initializing REST configs for talking to the Kubernetes API
 package config
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/client/doc.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/client/doc.go
@ -0,0 +1,49 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 // Package client contains functionality for interacting with Kubernetes API
 // servers.
 //
 // Clients
 //
 // Clients are split into two interfaces -- Readers and Writers.   Readers
 // get and list, while writers create, update, and delete.
 //
 // The New function can be used to create a new client that talks directly
 // to the API server.
 //
 // A common pattern in Kubernetes to read from a cache and write to the API
 // server.  This pattern is covered by the DelegatingClient type, which can
 // be used to have a client whose Reader is different from the Writer.
 //
 // Options
 //
 // Many client operations in Kubernetes support options.  These options are
 // represented as variadic arguments at the end of a given method call.
 // For instance, to use a label selector on list, you can call
 //  err := someReader.List(context.Background(), &podList, client.MatchingLabels{"somelabel": "someval"})
 //
 // Indexing
 //
 // Indexes may be added to caches using a FieldIndexer.  This allows you to easily
 // and efficiently look up objects with certain properties.  You can then make
 // use of the index by specifying a field selector on calls to List on the Reader
 // corresponding to the given Cache.
 //
 // For instance, a Secret controller might have an index on the
 // `.spec.volumes.secret.secretName` field in Pod objects, so that it could
 // easily look up all pods that reference a given secret.
 package client
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/client/dryrun.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/client/dryrun.go
@ -0,0 +1,95 @@
 /*
 Copyright 2020 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package client
 import (
 	"context"
 	"k8s.io/apimachinery/pkg/runtime"
 )
 // NewDryRunClient wraps an existing client and enforces DryRun mode
 // on all mutating api calls.
 func NewDryRunClient(c Client) Client {
 	return &dryRunClient{client: c}
 }
 var _ Client = &dryRunClient{}
 // dryRunClient is a Client that wraps another Client in order to enforce DryRun mode.
 type dryRunClient struct {
 	client Client
 }
 // Create implements client.Client
 func (c *dryRunClient) Create(ctx context.Context, obj runtime.Object, opts ...CreateOption) error {
 	return c.client.Create(ctx, obj, append(opts, DryRunAll)...)
 }
 // Update implements client.Client
 func (c *dryRunClient) Update(ctx context.Context, obj runtime.Object, opts ...UpdateOption) error {
 	return c.client.Update(ctx, obj, append(opts, DryRunAll)...)
 }
 // Delete implements client.Client
 func (c *dryRunClient) Delete(ctx context.Context, obj runtime.Object, opts ...DeleteOption) error {
 	return c.client.Delete(ctx, obj, append(opts, DryRunAll)...)
 }
 // DeleteAllOf implements client.Client
 func (c *dryRunClient) DeleteAllOf(ctx context.Context, obj runtime.Object, opts ...DeleteAllOfOption) error {
 	return c.client.DeleteAllOf(ctx, obj, append(opts, DryRunAll)...)
 }
 // Patch implements client.Client
 func (c *dryRunClient) Patch(ctx context.Context, obj runtime.Object, patch Patch, opts ...PatchOption) error {
 	return c.client.Patch(ctx, obj, patch, append(opts, DryRunAll)...)
 }
 // Get implements client.Client
 func (c *dryRunClient) Get(ctx context.Context, key ObjectKey, obj runtime.Object) error {
 	return c.client.Get(ctx, key, obj)
 }
 // List implements client.Client
 func (c *dryRunClient) List(ctx context.Context, obj runtime.Object, opts ...ListOption) error {
 	return c.client.List(ctx, obj, opts...)
 }
 // Status implements client.StatusClient
 func (c *dryRunClient) Status() StatusWriter {
 	return &dryRunStatusWriter{client: c.client.Status()}
 }
 // ensure dryRunStatusWriter implements client.StatusWriter
 var _ StatusWriter = &dryRunStatusWriter{}
 // dryRunStatusWriter is client.StatusWriter that writes status subresource with dryRun mode
 // enforced.
 type dryRunStatusWriter struct {
 	client StatusWriter
 }
 // Update implements client.StatusWriter
 func (sw *dryRunStatusWriter) Update(ctx context.Context, obj runtime.Object, opts ...UpdateOption) error {
 	return sw.client.Update(ctx, obj, append(opts, DryRunAll)...)
 }
 // Patch implements client.StatusWriter
 func (sw *dryRunStatusWriter) Patch(ctx context.Context, obj runtime.Object, patch Patch, opts ...PatchOption) error {
 	return sw.client.Patch(ctx, obj, patch, append(opts, DryRunAll)...)
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/client/interfaces.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/client/interfaces.go
@ -0,0 +1,135 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package client
 import (
 	"context"
 	apierrors "k8s.io/apimachinery/pkg/api/errors"
 	"k8s.io/apimachinery/pkg/api/meta"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/types"
 )
 // ObjectKey identifies a Kubernetes Object.
 type ObjectKey = types.NamespacedName
 // ObjectKeyFromObject returns the ObjectKey given a runtime.Object
 func ObjectKeyFromObject(obj runtime.Object) (ObjectKey, error) {
 	accessor, err := meta.Accessor(obj)
 	if err != nil {
 		return ObjectKey{}, err
 	}
 	return ObjectKey{Namespace: accessor.GetNamespace(), Name: accessor.GetName()}, nil
 }
 // Patch is a patch that can be applied to a Kubernetes object.
 type Patch interface {
 	// Type is the PatchType of the patch.
 	Type() types.PatchType
 	// Data is the raw data representing the patch.
 	Data(obj runtime.Object) ([]byte, error)
 }
 // TODO(directxman12): is there a sane way to deal with get/delete options?
 // Reader knows how to read and list Kubernetes objects.
 type Reader interface {
 	// Get retrieves an obj for the given object key from the Kubernetes Cluster.
 	// obj must be a struct pointer so that obj can be updated with the response
 	// returned by the Server.
 	Get(ctx context.Context, key ObjectKey, obj runtime.Object) error
 	// List retrieves list of objects for a given namespace and list options. On a
 	// successful call, Items field in the list will be populated with the
 	// result returned from the server.
 	List(ctx context.Context, list runtime.Object, opts ...ListOption) error
 }
 // Writer knows how to create, delete, and update Kubernetes objects.
 type Writer interface {
 	// Create saves the object obj in the Kubernetes cluster.
 	Create(ctx context.Context, obj runtime.Object, opts ...CreateOption) error
 	// Delete deletes the given obj from Kubernetes cluster.
 	Delete(ctx context.Context, obj runtime.Object, opts ...DeleteOption) error
 	// Update updates the given obj in the Kubernetes cluster. obj must be a
 	// struct pointer so that obj can be updated with the content returned by the Server.
 	Update(ctx context.Context, obj runtime.Object, opts ...UpdateOption) error
 	// Patch patches the given obj in the Kubernetes cluster. obj must be a
 	// struct pointer so that obj can be updated with the content returned by the Server.
 	Patch(ctx context.Context, obj runtime.Object, patch Patch, opts ...PatchOption) error
 	// DeleteAllOf deletes all objects of the given type matching the given options.
 	DeleteAllOf(ctx context.Context, obj runtime.Object, opts ...DeleteAllOfOption) error
 }
 // StatusClient knows how to create a client which can update status subresource
 // for kubernetes objects.
 type StatusClient interface {
 	Status() StatusWriter
 }
 // StatusWriter knows how to update status subresource of a Kubernetes object.
 type StatusWriter interface {
 	// Update updates the fields corresponding to the status subresource for the
 	// given obj. obj must be a struct pointer so that obj can be updated
 	// with the content returned by the Server.
 	Update(ctx context.Context, obj runtime.Object, opts ...UpdateOption) error
 	// Patch patches the given object's subresource. obj must be a struct
 	// pointer so that obj can be updated with the content returned by the
 	// Server.
 	Patch(ctx context.Context, obj runtime.Object, patch Patch, opts ...PatchOption) error
 }
 // Client knows how to perform CRUD operations on Kubernetes objects.
 type Client interface {
 	Reader
 	Writer
 	StatusClient
 }
 // IndexerFunc knows how to take an object and turn it into a series
 // of non-namespaced keys. Namespaced objects are automatically given
 // namespaced and non-spaced variants, so keys do not need to include namespace.
 type IndexerFunc func(runtime.Object) []string
 // FieldIndexer knows how to index over a particular "field" such that it
 // can later be used by a field selector.
 type FieldIndexer interface {
 	// IndexFields adds an index with the given field name on the given object type
 	// by using the given function to extract the value for that field.  If you want
 	// compatibility with the Kubernetes API server, only return one key, and only use
 	// fields that the API server supports.  Otherwise, you can return multiple keys,
 	// and "equality" in the field selector means that at least one key matches the value.
 	// The FieldIndexer will automatically take care of indexing over namespace
 	// and supporting efficient all-namespace queries.
 	IndexField(ctx context.Context, obj runtime.Object, field string, extractValue IndexerFunc) error
 }
 // IgnoreNotFound returns nil on NotFound errors.
 // All other values that are not NotFound errors or nil are returned unmodified.
 func IgnoreNotFound(err error) error {
 	if apierrors.IsNotFound(err) {
 		return nil
 	}
 	return err
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/client/options.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/client/options.go
@ -0,0 +1,720 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package client
 import (
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/fields"
 	"k8s.io/apimachinery/pkg/labels"
 	"k8s.io/apimachinery/pkg/selection"
 )
 // {{{ "Functional" Option Interfaces
 // CreateOption is some configuration that modifies options for a create request.
 type CreateOption interface {
 	// ApplyToCreate applies this configuration to the given create options.
 	ApplyToCreate(*CreateOptions)
 }
 // DeleteOption is some configuration that modifies options for a delete request.
 type DeleteOption interface {
 	// ApplyToDelete applies this configuration to the given delete options.
 	ApplyToDelete(*DeleteOptions)
 }
 // ListOption is some configuration that modifies options for a list request.
 type ListOption interface {
 	// ApplyToList applies this configuration to the given list options.
 	ApplyToList(*ListOptions)
 }
 // UpdateOption is some configuration that modifies options for a update request.
 type UpdateOption interface {
 	// ApplyToUpdate applies this configuration to the given update options.
 	ApplyToUpdate(*UpdateOptions)
 }
 // PatchOption is some configuration that modifies options for a patch request.
 type PatchOption interface {
 	// ApplyToPatch applies this configuration to the given patch options.
 	ApplyToPatch(*PatchOptions)
 }
 // DeleteAllOfOption is some configuration that modifies options for a delete request.
 type DeleteAllOfOption interface {
 	// ApplyToDeleteAllOf applies this configuration to the given deletecollection options.
 	ApplyToDeleteAllOf(*DeleteAllOfOptions)
 }
 // }}}
 // {{{ Multi-Type Options
 // DryRunAll sets the "dry run" option to "all", executing all
 // validation, etc without persisting the change to storage.
 var DryRunAll = dryRunAll{}
 type dryRunAll struct{}
 // ApplyToCreate applies this configuration to the given create options.
 func (dryRunAll) ApplyToCreate(opts *CreateOptions) {
 	opts.DryRun = []string{metav1.DryRunAll}
 }
 // ApplyToUpdate applies this configuration to the given update options.
 func (dryRunAll) ApplyToUpdate(opts *UpdateOptions) {
 	opts.DryRun = []string{metav1.DryRunAll}
 }
 // ApplyToPatch applies this configuration to the given patch options.
 func (dryRunAll) ApplyToPatch(opts *PatchOptions) {
 	opts.DryRun = []string{metav1.DryRunAll}
 }
 // ApplyToPatch applies this configuration to the given delete options.
 func (dryRunAll) ApplyToDelete(opts *DeleteOptions) {
 	opts.DryRun = []string{metav1.DryRunAll}
 }
 func (dryRunAll) ApplyToDeleteAllOf(opts *DeleteAllOfOptions) {
 	opts.DryRun = []string{metav1.DryRunAll}
 }
 // FieldOwner set the field manager name for the given server-side apply patch.
 type FieldOwner string
 // ApplyToPatch applies this configuration to the given patch options.
 func (f FieldOwner) ApplyToPatch(opts *PatchOptions) {
 	opts.FieldManager = string(f)
 }
 // ApplyToCreate applies this configuration to the given create options.
 func (f FieldOwner) ApplyToCreate(opts *CreateOptions) {
 	opts.FieldManager = string(f)
 }
 // ApplyToUpdate applies this configuration to the given update options.
 func (f FieldOwner) ApplyToUpdate(opts *UpdateOptions) {
 	opts.FieldManager = string(f)
 }
 // }}}
 // {{{ Create Options
 // CreateOptions contains options for create requests. It's generally a subset
 // of metav1.CreateOptions.
 type CreateOptions struct {
 	// When present, indicates that modifications should not be
 	// persisted. An invalid or unrecognized dryRun directive will
 	// result in an error response and no further processing of the
 	// request. Valid values are:
 	// - All: all dry run stages will be processed
 	DryRun []string
 	// FieldManager is the name of the user or component submitting
 	// this request.  It must be set with server-side apply.
 	FieldManager string
 	// Raw represents raw CreateOptions, as passed to the API server.
 	Raw *metav1.CreateOptions
 }
 // AsCreateOptions returns these options as a metav1.CreateOptions.
 // This may mutate the Raw field.
 func (o *CreateOptions) AsCreateOptions() *metav1.CreateOptions {
 	if o == nil {
 		return &metav1.CreateOptions{}
 	}
 	if o.Raw == nil {
 		o.Raw = &metav1.CreateOptions{}
 	}
 	o.Raw.DryRun = o.DryRun
 	o.Raw.FieldManager = o.FieldManager
 	return o.Raw
 }
 // ApplyOptions applies the given create options on these options,
 // and then returns itself (for convenient chaining).
 func (o *CreateOptions) ApplyOptions(opts []CreateOption) *CreateOptions {
 	for _, opt := range opts {
 		opt.ApplyToCreate(o)
 	}
 	return o
 }
 // ApplyToCreate implements CreateOption
 func (o *CreateOptions) ApplyToCreate(co *CreateOptions) {
 	if o.DryRun != nil {
 		co.DryRun = o.DryRun
 	}
 	if o.FieldManager != "" {
 		co.FieldManager = o.FieldManager
 	}
 	if o.Raw != nil {
 		co.Raw = o.Raw
 	}
 }
 var _ CreateOption = &CreateOptions{}
 // CreateDryRunAll sets the "dry run" option to "all".
 //
 // Deprecated: Use DryRunAll
 var CreateDryRunAll = DryRunAll
 // }}}
 // {{{ Delete Options
 // DeleteOptions contains options for delete requests. It's generally a subset
 // of metav1.DeleteOptions.
 type DeleteOptions struct {
 	// GracePeriodSeconds is 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.
 	GracePeriodSeconds *int64
 	// Preconditions must be fulfilled before a deletion is carried out. If not
 	// possible, a 409 Conflict status will be returned.
 	Preconditions *metav1.Preconditions
 	// PropagationPolicy determined whether and how garbage collection will be
 	// performed. Either this field or OrphanDependents may be set, but not both.
 	// The default policy is decided by the existing finalizer set in the
 	// metadata.finalizers and the resource-specific default policy.
 	// Acceptable values are: 'Orphan' - orphan the dependents; 'Background' -
 	// allow the garbage collector to delete the dependents in the background;
 	// 'Foreground' - a cascading policy that deletes all dependents in the
 	// foreground.
 	PropagationPolicy *metav1.DeletionPropagation
 	// Raw represents raw DeleteOptions, as passed to the API server.
 	Raw *metav1.DeleteOptions
 	// When present, indicates that modifications should not be
 	// persisted. An invalid or unrecognized dryRun directive will
 	// result in an error response and no further processing of the
 	// request. Valid values are:
 	// - All: all dry run stages will be processed
 	DryRun []string
 }
 // AsDeleteOptions returns these options as a metav1.DeleteOptions.
 // This may mutate the Raw field.
 func (o *DeleteOptions) AsDeleteOptions() *metav1.DeleteOptions {
 	if o == nil {
 		return &metav1.DeleteOptions{}
 	}
 	if o.Raw == nil {
 		o.Raw = &metav1.DeleteOptions{}
 	}
 	o.Raw.GracePeriodSeconds = o.GracePeriodSeconds
 	o.Raw.Preconditions = o.Preconditions
 	o.Raw.PropagationPolicy = o.PropagationPolicy
 	o.Raw.DryRun = o.DryRun
 	return o.Raw
 }
 // ApplyOptions applies the given delete options on these options,
 // and then returns itself (for convenient chaining).
 func (o *DeleteOptions) ApplyOptions(opts []DeleteOption) *DeleteOptions {
 	for _, opt := range opts {
 		opt.ApplyToDelete(o)
 	}
 	return o
 }
 var _ DeleteOption = &DeleteOptions{}
 // ApplyToDelete implements DeleteOption
 func (o *DeleteOptions) ApplyToDelete(do *DeleteOptions) {
 	if o.GracePeriodSeconds != nil {
 		do.GracePeriodSeconds = o.GracePeriodSeconds
 	}
 	if o.Preconditions != nil {
 		do.Preconditions = o.Preconditions
 	}
 	if o.PropagationPolicy != nil {
 		do.PropagationPolicy = o.PropagationPolicy
 	}
 	if o.Raw != nil {
 		do.Raw = o.Raw
 	}
 	if o.DryRun != nil {
 		do.DryRun = o.DryRun
 	}
 }
 // GracePeriodSeconds sets the grace period for the deletion
 // to the given number of seconds.
 type GracePeriodSeconds int64
 // ApplyToDelete applies this configuration to the given delete options.
 func (s GracePeriodSeconds) ApplyToDelete(opts *DeleteOptions) {
 	secs := int64(s)
 	opts.GracePeriodSeconds = &secs
 }
 // ApplyToDeleteAllOf applies this configuration to the given an List options.
 func (s GracePeriodSeconds) ApplyToDeleteAllOf(opts *DeleteAllOfOptions) {
 	s.ApplyToDelete(&opts.DeleteOptions)
 }
 // Preconditions must be fulfilled before an operation (update, delete, etc.) is carried out.
 type Preconditions metav1.Preconditions
 // ApplyToDelete applies this configuration to the given delete options.
 func (p Preconditions) ApplyToDelete(opts *DeleteOptions) {
 	preconds := metav1.Preconditions(p)
 	opts.Preconditions = &preconds
 }
 // ApplyToDeleteAllOf applies this configuration to the given an List options.
 func (p Preconditions) ApplyToDeleteAllOf(opts *DeleteAllOfOptions) {
 	p.ApplyToDelete(&opts.DeleteOptions)
 }
 // PropagationPolicy determined whether and how garbage collection will be
 // performed. Either this field or OrphanDependents may be set, but not both.
 // The default policy is decided by the existing finalizer set in the
 // metadata.finalizers and the resource-specific default policy.
 // Acceptable values are: 'Orphan' - orphan the dependents; 'Background' -
 // allow the garbage collector to delete the dependents in the background;
 // 'Foreground' - a cascading policy that deletes all dependents in the
 // foreground.
 type PropagationPolicy metav1.DeletionPropagation
 // ApplyToDelete applies the given delete options on these options.
 // It will propagate to the dependents of the object to let the garbage collector handle it.
 func (p PropagationPolicy) ApplyToDelete(opts *DeleteOptions) {
 	policy := metav1.DeletionPropagation(p)
 	opts.PropagationPolicy = &policy
 }
 // ApplyToDeleteAllOf applies this configuration to the given an List options.
 func (p PropagationPolicy) ApplyToDeleteAllOf(opts *DeleteAllOfOptions) {
 	p.ApplyToDelete(&opts.DeleteOptions)
 }
 // }}}
 // {{{ List Options
 // ListOptions contains options for limiting or filtering results.
 // It's generally a subset of metav1.ListOptions, with support for
 // pre-parsed selectors (since generally, selectors will be executed
 // against the cache).
 type ListOptions struct {
 	// LabelSelector filters results by label.  Use SetLabelSelector to
 	// set from raw string form.
 	LabelSelector labels.Selector
 	// FieldSelector filters results by a particular field.  In order
 	// to use this with cache-based implementations, restrict usage to
 	// a single field-value pair that's been added to the indexers.
 	FieldSelector fields.Selector
 	// Namespace represents the namespace to list for, or empty for
 	// non-namespaced objects, or to list across all namespaces.
 	Namespace string
 	// Limit specifies the maximum number of results to return from the server. The server may
 	// not support this field on all resource types, but if it does and more results remain it
 	// will set the continue field on the returned list object. This field is not supported if watch
 	// is true in the Raw ListOptions.
 	Limit int64
 	// Continue is a token returned by the server that lets a client retrieve chunks of results
 	// from the server by specifying limit. The server may reject requests for continuation tokens
 	// it does not recognize and will return a 410 error if the token can no longer be used because
 	// it has expired. This field is not supported if watch is true in the Raw ListOptions.
 	Continue string
 	// Raw represents raw ListOptions, as passed to the API server.  Note
 	// that these may not be respected by all implementations of interface,
 	// and the LabelSelector, FieldSelector, Limit and Continue fields are ignored.
 	Raw *metav1.ListOptions
 }
 var _ ListOption = &ListOptions{}
 // ApplyToList implements ListOption for ListOptions
 func (o *ListOptions) ApplyToList(lo *ListOptions) {
 	if o.LabelSelector != nil {
 		lo.LabelSelector = o.LabelSelector
 	}
 	if o.FieldSelector != nil {
 		lo.FieldSelector = o.FieldSelector
 	}
 	if o.Namespace != "" {
 		lo.Namespace = o.Namespace
 	}
 	if o.Raw != nil {
 		lo.Raw = o.Raw
 	}
 	if o.Limit > 0 {
 		lo.Limit = o.Limit
 	}
 	if o.Continue != "" {
 		lo.Continue = o.Continue
 	}
 }
 // AsListOptions returns these options as a flattened metav1.ListOptions.
 // This may mutate the Raw field.
 func (o *ListOptions) AsListOptions() *metav1.ListOptions {
 	if o == nil {
 		return &metav1.ListOptions{}
 	}
 	if o.Raw == nil {
 		o.Raw = &metav1.ListOptions{}
 	}
 	if o.LabelSelector != nil {
 		o.Raw.LabelSelector = o.LabelSelector.String()
 	}
 	if o.FieldSelector != nil {
 		o.Raw.FieldSelector = o.FieldSelector.String()
 	}
 	if !o.Raw.Watch {
 		o.Raw.Limit = o.Limit
 		o.Raw.Continue = o.Continue
 	}
 	return o.Raw
 }
 // ApplyOptions applies the given list options on these options,
 // and then returns itself (for convenient chaining).
 func (o *ListOptions) ApplyOptions(opts []ListOption) *ListOptions {
 	for _, opt := range opts {
 		opt.ApplyToList(o)
 	}
 	return o
 }
 // MatchingLabels filters the list/delete operation on the given set of labels.
 type MatchingLabels map[string]string
 // ApplyToList applies this configuration to the given list options.
 func (m MatchingLabels) ApplyToList(opts *ListOptions) {
 	// TODO(directxman12): can we avoid reserializing this over and over?
 	sel := labels.SelectorFromValidatedSet(map[string]string(m))
 	opts.LabelSelector = sel
 }
 // ApplyToDeleteAllOf applies this configuration to the given an List options.
 func (m MatchingLabels) ApplyToDeleteAllOf(opts *DeleteAllOfOptions) {
 	m.ApplyToList(&opts.ListOptions)
 }
 // HasLabels filters the list/delete operation checking if the set of labels exists
 // without checking their values.
 type HasLabels []string
 // ApplyToList applies this configuration to the given list options.
 func (m HasLabels) ApplyToList(opts *ListOptions) {
 	sel := labels.NewSelector()
 	for _, label := range m {
 		r, err := labels.NewRequirement(label, selection.Exists, nil)
 		if err == nil {
 			sel = sel.Add(*r)
 		}
 	}
 	opts.LabelSelector = sel
 }
 // ApplyToDeleteAllOf applies this configuration to the given an List options.
 func (m HasLabels) ApplyToDeleteAllOf(opts *DeleteAllOfOptions) {
 	m.ApplyToList(&opts.ListOptions)
 }
 // MatchingLabelsSelector filters the list/delete operation on the given label
 // selector (or index in the case of cached lists). A struct is used because
 // labels.Selector is an interface, which cannot be aliased.
 type MatchingLabelsSelector struct {
 	labels.Selector
 }
 // ApplyToList applies this configuration to the given list options.
 func (m MatchingLabelsSelector) ApplyToList(opts *ListOptions) {
 	opts.LabelSelector = m
 }
 // ApplyToDeleteAllOf applies this configuration to the given an List options.
 func (m MatchingLabelsSelector) ApplyToDeleteAllOf(opts *DeleteAllOfOptions) {
 	m.ApplyToList(&opts.ListOptions)
 }
 // MatchingField filters the list operation on the given field selector
 // (or index in the case of cached lists).
 //
 // Deprecated: Use MatchingFields
 func MatchingField(name, val string) MatchingFields {
 	return MatchingFields{name: val}
 }
 // MatchingFields filters the list/delete operation on the given field Set
 // (or index in the case of cached lists).
 type MatchingFields fields.Set
 // ApplyToList applies this configuration to the given list options.
 func (m MatchingFields) ApplyToList(opts *ListOptions) {
 	// TODO(directxman12): can we avoid re-serializing this?
 	sel := fields.Set(m).AsSelector()
 	opts.FieldSelector = sel
 }
 // ApplyToDeleteAllOf applies this configuration to the given an List options.
 func (m MatchingFields) ApplyToDeleteAllOf(opts *DeleteAllOfOptions) {
 	m.ApplyToList(&opts.ListOptions)
 }
 // MatchingFieldsSelector filters the list/delete operation on the given field
 // selector (or index in the case of cached lists). A struct is used because
 // fields.Selector is an interface, which cannot be aliased.
 type MatchingFieldsSelector struct {
 	fields.Selector
 }
 // ApplyToList applies this configuration to the given list options.
 func (m MatchingFieldsSelector) ApplyToList(opts *ListOptions) {
 	opts.FieldSelector = m
 }
 // ApplyToDeleteAllOf applies this configuration to the given an List options.
 func (m MatchingFieldsSelector) ApplyToDeleteAllOf(opts *DeleteAllOfOptions) {
 	m.ApplyToList(&opts.ListOptions)
 }
 // InNamespace restricts the list/delete operation to the given namespace.
 type InNamespace string
 // ApplyToList applies this configuration to the given list options.
 func (n InNamespace) ApplyToList(opts *ListOptions) {
 	opts.Namespace = string(n)
 }
 // ApplyToDeleteAllOf applies this configuration to the given an List options.
 func (n InNamespace) ApplyToDeleteAllOf(opts *DeleteAllOfOptions) {
 	n.ApplyToList(&opts.ListOptions)
 }
 // Limit specifies the maximum number of results to return from the server.
 // Limit does not implement DeleteAllOfOption interface because the server
 // does not support setting it for deletecollection operations.
 type Limit int64
 // ApplyToList applies this configuration to the given an list options.
 func (l Limit) ApplyToList(opts *ListOptions) {
 	opts.Limit = int64(l)
 }
 // Continue sets a continuation token to retrieve chunks of results when using limit.
 // Continue does not implement DeleteAllOfOption interface because the server
 // does not support setting it for deletecollection operations.
 type Continue string
 // ApplyToList applies this configuration to the given an List options.
 func (c Continue) ApplyToList(opts *ListOptions) {
 	opts.Continue = string(c)
 }
 // }}}
 // {{{ Update Options
 // UpdateOptions contains options for create requests. It's generally a subset
 // of metav1.UpdateOptions.
 type UpdateOptions struct {
 	// When present, indicates that modifications should not be
 	// persisted. An invalid or unrecognized dryRun directive will
 	// result in an error response and no further processing of the
 	// request. Valid values are:
 	// - All: all dry run stages will be processed
 	DryRun []string
 	// FieldManager is the name of the user or component submitting
 	// this request.  It must be set with server-side apply.
 	FieldManager string
 	// Raw represents raw UpdateOptions, as passed to the API server.
 	Raw *metav1.UpdateOptions
 }
 // AsUpdateOptions returns these options as a metav1.UpdateOptions.
 // This may mutate the Raw field.
 func (o *UpdateOptions) AsUpdateOptions() *metav1.UpdateOptions {
 	if o == nil {
 		return &metav1.UpdateOptions{}
 	}
 	if o.Raw == nil {
 		o.Raw = &metav1.UpdateOptions{}
 	}
 	o.Raw.DryRun = o.DryRun
 	o.Raw.FieldManager = o.FieldManager
 	return o.Raw
 }
 // ApplyOptions applies the given update options on these options,
 // and then returns itself (for convenient chaining).
 func (o *UpdateOptions) ApplyOptions(opts []UpdateOption) *UpdateOptions {
 	for _, opt := range opts {
 		opt.ApplyToUpdate(o)
 	}
 	return o
 }
 var _ UpdateOption = &UpdateOptions{}
 // ApplyToUpdate implements UpdateOption
 func (o *UpdateOptions) ApplyToUpdate(uo *UpdateOptions) {
 	if o.DryRun != nil {
 		uo.DryRun = o.DryRun
 	}
 	if o.FieldManager != "" {
 		uo.FieldManager = o.FieldManager
 	}
 	if o.Raw != nil {
 		uo.Raw = o.Raw
 	}
 }
 // UpdateDryRunAll sets the "dry run" option to "all".
 //
 // Deprecated: Use DryRunAll
 var UpdateDryRunAll = DryRunAll
 // }}}
 // {{{ Patch Options
 // PatchOptions contains options for patch requests.
 type PatchOptions struct {
 	// When present, indicates that modifications should not be
 	// persisted. An invalid or unrecognized dryRun directive will
 	// result in an error response and no further processing of the
 	// request. Valid values are:
 	// - All: all dry run stages will be processed
 	DryRun []string
 	// Force is going to "force" Apply requests. It means user will
 	// re-acquire conflicting fields owned by other people. Force
 	// flag must be unset for non-apply patch requests.
 	// +optional
 	Force *bool
 	// FieldManager is the name of the user or component submitting
 	// this request.  It must be set with server-side apply.
 	FieldManager string
 	// Raw represents raw PatchOptions, as passed to the API server.
 	Raw *metav1.PatchOptions
 }
 // ApplyOptions applies the given patch options on these options,
 // and then returns itself (for convenient chaining).
 func (o *PatchOptions) ApplyOptions(opts []PatchOption) *PatchOptions {
 	for _, opt := range opts {
 		opt.ApplyToPatch(o)
 	}
 	return o
 }
 // AsPatchOptions returns these options as a metav1.PatchOptions.
 // This may mutate the Raw field.
 func (o *PatchOptions) AsPatchOptions() *metav1.PatchOptions {
 	if o == nil {
 		return &metav1.PatchOptions{}
 	}
 	if o.Raw == nil {
 		o.Raw = &metav1.PatchOptions{}
 	}
 	o.Raw.DryRun = o.DryRun
 	o.Raw.Force = o.Force
 	o.Raw.FieldManager = o.FieldManager
 	return o.Raw
 }
 var _ PatchOption = &PatchOptions{}
 // ApplyToPatch implements PatchOptions
 func (o *PatchOptions) ApplyToPatch(po *PatchOptions) {
 	if o.DryRun != nil {
 		po.DryRun = o.DryRun
 	}
 	if o.Force != nil {
 		po.Force = o.Force
 	}
 	if o.FieldManager != "" {
 		po.FieldManager = o.FieldManager
 	}
 	if o.Raw != nil {
 		po.Raw = o.Raw
 	}
 }
 // ForceOwnership indicates that in case of conflicts with server-side apply,
 // the client should acquire ownership of the conflicting field.  Most
 // controllers should use this.
 var ForceOwnership = forceOwnership{}
 type forceOwnership struct{}
 func (forceOwnership) ApplyToPatch(opts *PatchOptions) {
 	definitelyTrue := true
 	opts.Force = &definitelyTrue
 }
 // PatchDryRunAll sets the "dry run" option to "all".
 //
 // Deprecated: Use DryRunAll
 var PatchDryRunAll = DryRunAll
 // }}}
 // {{{ DeleteAllOf Options
 // these are all just delete options and list options
 // DeleteAllOfOptions contains options for deletecollection (deleteallof) requests.
 // It's just list and delete options smooshed together.
 type DeleteAllOfOptions struct {
 	ListOptions
 	DeleteOptions
 }
 // ApplyOptions applies the given deleteallof options on these options,
 // and then returns itself (for convenient chaining).
 func (o *DeleteAllOfOptions) ApplyOptions(opts []DeleteAllOfOption) *DeleteAllOfOptions {
 	for _, opt := range opts {
 		opt.ApplyToDeleteAllOf(o)
 	}
 	return o
 }
 var _ DeleteAllOfOption = &DeleteAllOfOptions{}
 // ApplyToDeleteAllOf implements DeleteAllOfOption
 func (o *DeleteAllOfOptions) ApplyToDeleteAllOf(do *DeleteAllOfOptions) {
 	o.ApplyToList(&do.ListOptions)
 	o.ApplyToDelete(&do.DeleteOptions)
 }
 // }}}
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/client/patch.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/client/patch.go
@ -0,0 +1,123 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package client
 import (
 	jsonpatch "github.com/evanphx/json-patch"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/apimachinery/pkg/util/json"
 )
 var (
 	// Apply uses server-side apply to patch the given object.
 	Apply = applyPatch{}
 	// Merge uses the raw object as a merge patch, without modifications.
 	// Use MergeFrom if you wish to compute a diff instead.
 	Merge = mergePatch{}
 )
 type patch struct {
 	patchType types.PatchType
 	data      []byte
 }
 // Type implements Patch.
 func (s *patch) Type() types.PatchType {
 	return s.patchType
 }
 // Data implements Patch.
 func (s *patch) Data(obj runtime.Object) ([]byte, error) {
 	return s.data, nil
 }
 // RawPatch constructs a new Patch with the given PatchType and data.
 func RawPatch(patchType types.PatchType, data []byte) Patch {
 	return &patch{patchType, data}
 }
 // ConstantPatch constructs a new Patch with the given PatchType and data.
 //
 // Deprecated: use RawPatch instead
 func ConstantPatch(patchType types.PatchType, data []byte) Patch {
 	return RawPatch(patchType, data)
 }
 type mergeFromPatch struct {
 	from runtime.Object
 }
 // Type implements patch.
 func (s *mergeFromPatch) Type() types.PatchType {
 	return types.MergePatchType
 }
 // Data implements Patch.
 func (s *mergeFromPatch) Data(obj runtime.Object) ([]byte, error) {
 	originalJSON, err := json.Marshal(s.from)
 	if err != nil {
 		return nil, err
 	}
 	modifiedJSON, err := json.Marshal(obj)
 	if err != nil {
 		return nil, err
 	}
 	return jsonpatch.CreateMergePatch(originalJSON, modifiedJSON)
 }
 // MergeFrom creates a Patch that patches using the merge-patch strategy with the given object as base.
 func MergeFrom(obj runtime.Object) Patch {
 	return &mergeFromPatch{obj}
 }
 // mergePatch uses a raw merge strategy to patch the object.
 type mergePatch struct{}
 // Type implements Patch.
 func (p mergePatch) Type() types.PatchType {
 	return types.MergePatchType
 }
 // Data implements Patch.
 func (p mergePatch) Data(obj runtime.Object) ([]byte, error) {
 	// NB(directxman12): we might technically want to be using an actual encoder
 	// here (in case some more performant encoder is introduced) but this is
 	// correct and sufficient for our uses (it's what the JSON serializer in
 	// client-go does, more-or-less).
 	return json.Marshal(obj)
 }
 // applyPatch uses server-side apply to patch the object.
 type applyPatch struct{}
 // Type implements Patch.
 func (p applyPatch) Type() types.PatchType {
 	return types.ApplyPatchType
 }
 // Data implements Patch.
 func (p applyPatch) Data(obj runtime.Object) ([]byte, error) {
 	// NB(directxman12): we might technically want to be using an actual encoder
 	// here (in case some more performant encoder is introduced) but this is
 	// correct and sufficient for our uses (it's what the JSON serializer in
 	// client-go does, more-or-less).
 	return json.Marshal(obj)
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/client/split.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/client/split.go
@ -0,0 +1,61 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package client
 import (
 	"context"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"k8s.io/apimachinery/pkg/runtime"
 )
 // DelegatingClient forms a Client by composing separate reader, writer and
 // statusclient interfaces.  This way, you can have an Client that reads from a
 // cache and writes to the API server.
 type DelegatingClient struct {
 	Reader
 	Writer
 	StatusClient
 }
 // DelegatingReader forms a Reader that will cause Get and List requests for
 // unstructured types to use the ClientReader while requests for any other type
 // of object with use the CacheReader.  This avoids accidentally caching the
 // entire cluster in the common case of loading arbitrary unstructured objects
 // (e.g. from OwnerReferences).
 type DelegatingReader struct {
 	CacheReader  Reader
 	ClientReader Reader
 }
 // Get retrieves an obj for a given object key from the Kubernetes Cluster.
 func (d *DelegatingReader) Get(ctx context.Context, key ObjectKey, obj runtime.Object) error {
 	_, isUnstructured := obj.(*unstructured.Unstructured)
 	if isUnstructured {
 		return d.ClientReader.Get(ctx, key, obj)
 	}
 	return d.CacheReader.Get(ctx, key, obj)
 }
 // List retrieves list of objects for a given namespace and list options.
 func (d *DelegatingReader) List(ctx context.Context, list runtime.Object, opts ...ListOption) error {
 	_, isUnstructured := list.(*unstructured.UnstructuredList)
 	if isUnstructured {
 		return d.ClientReader.List(ctx, list, opts...)
 	}
 	return d.CacheReader.List(ctx, list, opts...)
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/client/typed_client.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/client/typed_client.go
@ -0,0 +1,201 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package client
 import (
 	"context"
 	"k8s.io/apimachinery/pkg/runtime"
 )
 // client is a client.Client that reads and writes directly from/to an API server.  It lazily initializes
 // new clients at the time they are used, and caches the client.
 type typedClient struct {
 	cache      *clientCache
 	paramCodec runtime.ParameterCodec
 }
 // Create implements client.Client
 func (c *typedClient) Create(ctx context.Context, obj runtime.Object, opts ...CreateOption) error {
 	o, err := c.cache.getObjMeta(obj)
 	if err != nil {
 		return err
 	}
 	createOpts := &CreateOptions{}
 	createOpts.ApplyOptions(opts)
 	return o.Post().
 		NamespaceIfScoped(o.GetNamespace(), o.isNamespaced()).
 		Resource(o.resource()).
 		Body(obj).
 		VersionedParams(createOpts.AsCreateOptions(), c.paramCodec).
 		Do(ctx).
 		Into(obj)
 }
 // Update implements client.Client
 func (c *typedClient) Update(ctx context.Context, obj runtime.Object, opts ...UpdateOption) error {
 	o, err := c.cache.getObjMeta(obj)
 	if err != nil {
 		return err
 	}
 	updateOpts := &UpdateOptions{}
 	updateOpts.ApplyOptions(opts)
 	return o.Put().
 		NamespaceIfScoped(o.GetNamespace(), o.isNamespaced()).
 		Resource(o.resource()).
 		Name(o.GetName()).
 		Body(obj).
 		VersionedParams(updateOpts.AsUpdateOptions(), c.paramCodec).
 		Do(ctx).
 		Into(obj)
 }
 // Delete implements client.Client
 func (c *typedClient) Delete(ctx context.Context, obj runtime.Object, opts ...DeleteOption) error {
 	o, err := c.cache.getObjMeta(obj)
 	if err != nil {
 		return err
 	}
 	deleteOpts := DeleteOptions{}
 	deleteOpts.ApplyOptions(opts)
 	return o.Delete().
 		NamespaceIfScoped(o.GetNamespace(), o.isNamespaced()).
 		Resource(o.resource()).
 		Name(o.GetName()).
 		Body(deleteOpts.AsDeleteOptions()).
 		Do(ctx).
 		Error()
 }
 // DeleteAllOf implements client.Client
 func (c *typedClient) DeleteAllOf(ctx context.Context, obj runtime.Object, opts ...DeleteAllOfOption) error {
 	o, err := c.cache.getObjMeta(obj)
 	if err != nil {
 		return err
 	}
 	deleteAllOfOpts := DeleteAllOfOptions{}
 	deleteAllOfOpts.ApplyOptions(opts)
 	return o.Delete().
 		NamespaceIfScoped(deleteAllOfOpts.ListOptions.Namespace, o.isNamespaced()).
 		Resource(o.resource()).
 		VersionedParams(deleteAllOfOpts.AsListOptions(), c.paramCodec).
 		Body(deleteAllOfOpts.AsDeleteOptions()).
 		Do(ctx).
 		Error()
 }
 // Patch implements client.Client
 func (c *typedClient) Patch(ctx context.Context, obj runtime.Object, patch Patch, opts ...PatchOption) error {
 	o, err := c.cache.getObjMeta(obj)
 	if err != nil {
 		return err
 	}
 	data, err := patch.Data(obj)
 	if err != nil {
 		return err
 	}
 	patchOpts := &PatchOptions{}
 	return o.Patch(patch.Type()).
 		NamespaceIfScoped(o.GetNamespace(), o.isNamespaced()).
 		Resource(o.resource()).
 		Name(o.GetName()).
 		VersionedParams(patchOpts.ApplyOptions(opts).AsPatchOptions(), c.paramCodec).
 		Body(data).
 		Do(ctx).
 		Into(obj)
 }
 // Get implements client.Client
 func (c *typedClient) Get(ctx context.Context, key ObjectKey, obj runtime.Object) error {
 	r, err := c.cache.getResource(obj)
 	if err != nil {
 		return err
 	}
 	return r.Get().
 		NamespaceIfScoped(key.Namespace, r.isNamespaced()).
 		Resource(r.resource()).
 		Name(key.Name).Do(ctx).Into(obj)
 }
 // List implements client.Client
 func (c *typedClient) List(ctx context.Context, obj runtime.Object, opts ...ListOption) error {
 	r, err := c.cache.getResource(obj)
 	if err != nil {
 		return err
 	}
 	listOpts := ListOptions{}
 	listOpts.ApplyOptions(opts)
 	return r.Get().
 		NamespaceIfScoped(listOpts.Namespace, r.isNamespaced()).
 		Resource(r.resource()).
 		VersionedParams(listOpts.AsListOptions(), c.paramCodec).
 		Do(ctx).
 		Into(obj)
 }
 // UpdateStatus used by StatusWriter to write status.
 func (c *typedClient) UpdateStatus(ctx context.Context, obj runtime.Object, opts ...UpdateOption) error {
 	o, err := c.cache.getObjMeta(obj)
 	if err != nil {
 		return err
 	}
 	// TODO(droot): examine the returned error and check if it error needs to be
 	// wrapped to improve the UX ?
 	// It will be nice to receive an error saying the object doesn't implement
 	// status subresource and check CRD definition
 	return o.Put().
 		NamespaceIfScoped(o.GetNamespace(), o.isNamespaced()).
 		Resource(o.resource()).
 		Name(o.GetName()).
 		SubResource("status").
 		Body(obj).
 		VersionedParams((&UpdateOptions{}).ApplyOptions(opts).AsUpdateOptions(), c.paramCodec).
 		Do(ctx).
 		Into(obj)
 }
 // PatchStatus used by StatusWriter to write status.
 func (c *typedClient) PatchStatus(ctx context.Context, obj runtime.Object, patch Patch, opts ...PatchOption) error {
 	o, err := c.cache.getObjMeta(obj)
 	if err != nil {
 		return err
 	}
 	data, err := patch.Data(obj)
 	if err != nil {
 		return err
 	}
 	patchOpts := &PatchOptions{}
 	return o.Patch(patch.Type()).
 		NamespaceIfScoped(o.GetNamespace(), o.isNamespaced()).
 		Resource(o.resource()).
 		Name(o.GetName()).
 		SubResource("status").
 		Body(data).
 		VersionedParams(patchOpts.ApplyOptions(opts).AsPatchOptions(), c.paramCodec).
 		Do(ctx).
 		Into(obj)
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/client/unstructured_client.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/client/unstructured_client.go
@ -0,0 +1,273 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package client
 import (
 	"context"
 	"fmt"
 	"strings"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"k8s.io/apimachinery/pkg/runtime"
 )
 // client is a client.Client that reads and writes directly from/to an API server.  It lazily initializes
 // new clients at the time they are used, and caches the client.
 type unstructuredClient struct {
 	cache      *clientCache
 	paramCodec runtime.ParameterCodec
 }
 // Create implements client.Client
 func (uc *unstructuredClient) Create(ctx context.Context, obj runtime.Object, opts ...CreateOption) error {
 	u, ok := obj.(*unstructured.Unstructured)
 	if !ok {
 		return fmt.Errorf("unstructured client did not understand object: %T", obj)
 	}
 	gvk := u.GroupVersionKind()
 	o, err := uc.cache.getObjMeta(obj)
 	if err != nil {
 		return err
 	}
 	createOpts := &CreateOptions{}
 	createOpts.ApplyOptions(opts)
 	result := o.Post().
 		NamespaceIfScoped(o.GetNamespace(), o.isNamespaced()).
 		Resource(o.resource()).
 		Body(obj).
 		VersionedParams(createOpts.AsCreateOptions(), uc.paramCodec).
 		Do(ctx).
 		Into(obj)
 	u.SetGroupVersionKind(gvk)
 	return result
 }
 // Update implements client.Client
 func (uc *unstructuredClient) Update(ctx context.Context, obj runtime.Object, opts ...UpdateOption) error {
 	u, ok := obj.(*unstructured.Unstructured)
 	if !ok {
 		return fmt.Errorf("unstructured client did not understand object: %T", obj)
 	}
 	gvk := u.GroupVersionKind()
 	o, err := uc.cache.getObjMeta(obj)
 	if err != nil {
 		return err
 	}
 	updateOpts := UpdateOptions{}
 	updateOpts.ApplyOptions(opts)
 	result := o.Put().
 		NamespaceIfScoped(o.GetNamespace(), o.isNamespaced()).
 		Resource(o.resource()).
 		Name(o.GetName()).
 		Body(obj).
 		VersionedParams(updateOpts.AsUpdateOptions(), uc.paramCodec).
 		Do(ctx).
 		Into(obj)
 	u.SetGroupVersionKind(gvk)
 	return result
 }
 // Delete implements client.Client
 func (uc *unstructuredClient) Delete(ctx context.Context, obj runtime.Object, opts ...DeleteOption) error {
 	_, ok := obj.(*unstructured.Unstructured)
 	if !ok {
 		return fmt.Errorf("unstructured client did not understand object: %T", obj)
 	}
 	o, err := uc.cache.getObjMeta(obj)
 	if err != nil {
 		return err
 	}
 	deleteOpts := DeleteOptions{}
 	deleteOpts.ApplyOptions(opts)
 	return o.Delete().
 		NamespaceIfScoped(o.GetNamespace(), o.isNamespaced()).
 		Resource(o.resource()).
 		Name(o.GetName()).
 		Body(deleteOpts.AsDeleteOptions()).
 		Do(ctx).
 		Error()
 }
 // DeleteAllOf implements client.Client
 func (uc *unstructuredClient) DeleteAllOf(ctx context.Context, obj runtime.Object, opts ...DeleteAllOfOption) error {
 	_, ok := obj.(*unstructured.Unstructured)
 	if !ok {
 		return fmt.Errorf("unstructured client did not understand object: %T", obj)
 	}
 	o, err := uc.cache.getObjMeta(obj)
 	if err != nil {
 		return err
 	}
 	deleteAllOfOpts := DeleteAllOfOptions{}
 	deleteAllOfOpts.ApplyOptions(opts)
 	return o.Delete().
 		NamespaceIfScoped(deleteAllOfOpts.ListOptions.Namespace, o.isNamespaced()).
 		Resource(o.resource()).
 		VersionedParams(deleteAllOfOpts.AsListOptions(), uc.paramCodec).
 		Body(deleteAllOfOpts.AsDeleteOptions()).
 		Do(ctx).
 		Error()
 }
 // Patch implements client.Client
 func (uc *unstructuredClient) Patch(ctx context.Context, obj runtime.Object, patch Patch, opts ...PatchOption) error {
 	_, ok := obj.(*unstructured.Unstructured)
 	if !ok {
 		return fmt.Errorf("unstructured client did not understand object: %T", obj)
 	}
 	o, err := uc.cache.getObjMeta(obj)
 	if err != nil {
 		return err
 	}
 	data, err := patch.Data(obj)
 	if err != nil {
 		return err
 	}
 	patchOpts := &PatchOptions{}
 	return o.Patch(patch.Type()).
 		NamespaceIfScoped(o.GetNamespace(), o.isNamespaced()).
 		Resource(o.resource()).
 		Name(o.GetName()).
 		VersionedParams(patchOpts.ApplyOptions(opts).AsPatchOptions(), uc.paramCodec).
 		Body(data).
 		Do(ctx).
 		Into(obj)
 }
 // Get implements client.Client
 func (uc *unstructuredClient) Get(ctx context.Context, key ObjectKey, obj runtime.Object) error {
 	u, ok := obj.(*unstructured.Unstructured)
 	if !ok {
 		return fmt.Errorf("unstructured client did not understand object: %T", obj)
 	}
 	gvk := u.GroupVersionKind()
 	r, err := uc.cache.getResource(obj)
 	if err != nil {
 		return err
 	}
 	result := r.Get().
 		NamespaceIfScoped(key.Namespace, r.isNamespaced()).
 		Resource(r.resource()).
 		Name(key.Name).
 		Do(ctx).
 		Into(obj)
 	u.SetGroupVersionKind(gvk)
 	return result
 }
 // List implements client.Client
 func (uc *unstructuredClient) List(ctx context.Context, obj runtime.Object, opts ...ListOption) error {
 	u, ok := obj.(*unstructured.UnstructuredList)
 	if !ok {
 		return fmt.Errorf("unstructured client did not understand object: %T", obj)
 	}
 	gvk := u.GroupVersionKind()
 	if strings.HasSuffix(gvk.Kind, "List") {
 		gvk.Kind = gvk.Kind[:len(gvk.Kind)-4]
 	}
 	listOpts := ListOptions{}
 	listOpts.ApplyOptions(opts)
 	r, err := uc.cache.getResource(obj)
 	if err != nil {
 		return err
 	}
 	return r.Get().
 		NamespaceIfScoped(listOpts.Namespace, r.isNamespaced()).
 		Resource(r.resource()).
 		VersionedParams(listOpts.AsListOptions(), uc.paramCodec).
 		Do(ctx).
 		Into(obj)
 }
 func (uc *unstructuredClient) UpdateStatus(ctx context.Context, obj runtime.Object, opts ...UpdateOption) error {
 	_, ok := obj.(*unstructured.Unstructured)
 	if !ok {
 		return fmt.Errorf("unstructured client did not understand object: %T", obj)
 	}
 	o, err := uc.cache.getObjMeta(obj)
 	if err != nil {
 		return err
 	}
 	return o.Put().
 		NamespaceIfScoped(o.GetNamespace(), o.isNamespaced()).
 		Resource(o.resource()).
 		Name(o.GetName()).
 		SubResource("status").
 		Body(obj).
 		VersionedParams((&UpdateOptions{}).ApplyOptions(opts).AsUpdateOptions(), uc.paramCodec).
 		Do(ctx).
 		Into(obj)
 }
 func (uc *unstructuredClient) PatchStatus(ctx context.Context, obj runtime.Object, patch Patch, opts ...PatchOption) error {
 	u, ok := obj.(*unstructured.Unstructured)
 	if !ok {
 		return fmt.Errorf("unstructured client did not understand object: %T", obj)
 	}
 	gvk := u.GroupVersionKind()
 	o, err := uc.cache.getObjMeta(obj)
 	if err != nil {
 		return err
 	}
 	data, err := patch.Data(obj)
 	if err != nil {
 		return err
 	}
 	patchOpts := &PatchOptions{}
 	result := o.Patch(patch.Type()).
 		NamespaceIfScoped(o.GetNamespace(), o.isNamespaced()).
 		Resource(o.resource()).
 		Name(o.GetName()).
 		SubResource("status").
 		Body(data).
 		VersionedParams(patchOpts.ApplyOptions(opts).AsPatchOptions(), uc.paramCodec).
 		Do(ctx).
 		Into(u)
 	u.SetGroupVersionKind(gvk)
 	return result
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/controller/controller.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/controller/controller.go
@ -0,0 +1,120 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package controller
 import (
 	"fmt"
 	"k8s.io/client-go/util/workqueue"
 	"sigs.k8s.io/controller-runtime/pkg/handler"
 	"sigs.k8s.io/controller-runtime/pkg/internal/controller"
 	"sigs.k8s.io/controller-runtime/pkg/manager"
 	"sigs.k8s.io/controller-runtime/pkg/predicate"
 	"sigs.k8s.io/controller-runtime/pkg/ratelimiter"
 	"sigs.k8s.io/controller-runtime/pkg/reconcile"
 	"sigs.k8s.io/controller-runtime/pkg/source"
 )
 // Options are the arguments for creating a new Controller
 type Options struct {
 	// MaxConcurrentReconciles is the maximum number of concurrent Reconciles which can be run. Defaults to 1.
 	MaxConcurrentReconciles int
 	// Reconciler reconciles an object
 	Reconciler reconcile.Reconciler
 	// RateLimiter is used to limit how frequently requests may be queued.
 	// Defaults to MaxOfRateLimiter which has both overall and per-item rate limiting.
 	// The overall is a token bucket and the per-item is exponential.
 	RateLimiter ratelimiter.RateLimiter
 }
 // Controller implements a Kubernetes API.  A Controller manages a work queue fed reconcile.Requests
 // from source.Sources.  Work is performed through the reconcile.Reconciler for each enqueued item.
 // Work typically is reads and writes Kubernetes objects to make the system state match the state specified
 // in the object Spec.
 type Controller interface {
 	// Reconciler is called to reconcile an object by Namespace/Name
 	reconcile.Reconciler
 	// Watch takes events provided by a Source and uses the EventHandler to
 	// enqueue reconcile.Requests in response to the events.
 	//
 	// Watch may be provided one or more Predicates to filter events before
 	// they are given to the EventHandler.  Events will be passed to the
 	// EventHandler if all provided Predicates evaluate to true.
 	Watch(src source.Source, eventhandler handler.EventHandler, predicates ...predicate.Predicate) error
 	// Start starts the controller.  Start blocks until stop is closed or a
 	// controller has an error starting.
 	Start(stop <-chan struct{}) error
 }
 // New returns a new Controller registered with the Manager.  The Manager will ensure that shared Caches have
 // been synced before the Controller is Started.
 func New(name string, mgr manager.Manager, options Options) (Controller, error) {
 	c, err := NewUnmanaged(name, mgr, options)
 	if err != nil {
 		return nil, err
 	}
 	// Add the controller as a Manager components
 	return c, mgr.Add(c)
 }
 // NewUnmanaged returns a new controller without adding it to the manager. The
 // caller is responsible for starting the returned controller.
 func NewUnmanaged(name string, mgr manager.Manager, options Options) (Controller, error) {
 	if options.Reconciler == nil {
 		return nil, fmt.Errorf("must specify Reconciler")
 	}
 	if len(name) == 0 {
 		return nil, fmt.Errorf("must specify Name for Controller")
 	}
 	if options.MaxConcurrentReconciles <= 0 {
 		options.MaxConcurrentReconciles = 1
 	}
 	if options.RateLimiter == nil {
 		options.RateLimiter = workqueue.DefaultControllerRateLimiter()
 	}
 	// Inject dependencies into Reconciler
 	if err := mgr.SetFields(options.Reconciler); err != nil {
 		return nil, err
 	}
 	// Create controller with dependencies set
 	c := &controller.Controller{
 		Do:       options.Reconciler,
 		Cache:    mgr.GetCache(),
 		Config:   mgr.GetConfig(),
 		Scheme:   mgr.GetScheme(),
 		Client:   mgr.GetClient(),
 		Recorder: mgr.GetEventRecorderFor(name),
 		MakeQueue: func() workqueue.RateLimitingInterface {
 			return workqueue.NewNamedRateLimitingQueue(options.RateLimiter, name)
 		},
 		MaxConcurrentReconciles: options.MaxConcurrentReconciles,
 		SetFields:               mgr.SetFields,
 		Name:                    name,
 	}
 	return c, nil
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/controller/doc.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/controller/doc.go
@ -0,0 +1,25 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 /*
 Package controller provides types and functions for building Controllers.  Controllers implement Kubernetes APIs.
 Creation
 To create a new Controller, first create a manager.Manager and pass it to the controller.New function.
 The Controller MUST be started by calling Manager.Start.
 */
 package controller
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/event/doc.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/event/doc.go
@ -0,0 +1,28 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 /*
 Package event contains the definitions for the Event types produced by source.Sources and transformed into
 reconcile.Requests by handler.EventHandler.
 You should rarely need to work with these directly -- instead, use Controller.Watch with
 source.Sources and handler.EventHandlers.
 Events generally contain both a full runtime.Object that caused the event, as well
 as a direct handle to that object's metadata.  This saves a lot of typecasting in
 code that works with Events.
 */
 package event
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/event/event.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/event/event.go
@ -0,0 +1,73 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package event
 import (
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 )
 // CreateEvent is an event where a Kubernetes object was created.  CreateEvent should be generated
 // by a source.Source and transformed into a reconcile.Request by an handler.EventHandler.
 type CreateEvent struct {
 	// Meta is the ObjectMeta of the Kubernetes Type that was created
 	Meta metav1.Object
 	// Object is the object from the event
 	Object runtime.Object
 }
 // UpdateEvent is an event where a Kubernetes object was updated.  UpdateEvent should be generated
 // by a source.Source and transformed into a reconcile.Request by an handler.EventHandler.
 type UpdateEvent struct {
 	// MetaOld is the ObjectMeta of the Kubernetes Type that was updated (before the update)
 	MetaOld metav1.Object
 	// ObjectOld is the object from the event
 	ObjectOld runtime.Object
 	// MetaNew is the ObjectMeta of the Kubernetes Type that was updated (after the update)
 	MetaNew metav1.Object
 	// ObjectNew is the object from the event
 	ObjectNew runtime.Object
 }
 // DeleteEvent is an event where a Kubernetes object was deleted.  DeleteEvent should be generated
 // by a source.Source and transformed into a reconcile.Request by an handler.EventHandler.
 type DeleteEvent struct {
 	// Meta is the ObjectMeta of the Kubernetes Type that was deleted
 	Meta metav1.Object
 	// Object is the object from the event
 	Object runtime.Object
 	// DeleteStateUnknown is true if the Delete event was missed but we identified the object
 	// as having been deleted.
 	DeleteStateUnknown bool
 }
 // GenericEvent is an event where the operation type is unknown (e.g. polling or event originating outside the cluster).
 // GenericEvent should be generated by a source.Source and transformed into a reconcile.Request by an
 // handler.EventHandler.
 type GenericEvent struct {
 	// Meta is the ObjectMeta of a Kubernetes Type this event is for
 	Meta metav1.Object
 	// Object is the object from the event
 	Object runtime.Object
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/handler/doc.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/handler/doc.go
@ -0,0 +1,38 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 /*
 Package handler defines EventHandlers that enqueue reconcile.Requests in response to Create, Update, Deletion Events
 observed from Watching Kubernetes APIs.  Users should provide a source.Source and handler.EventHandler to
 Controller.Watch in order to generate and enqueue reconcile.Request work items.
 Generally, following premade event handlers should be sufficient for most use cases:
 EventHandlers
 EnqueueRequestForObject - Enqueues a reconcile.Request containing the Name and Namespace of the object in the Event.  This will
 cause the object that was the source of the Event (e.g. the created / deleted / updated object) to be
 reconciled.
 EnqueueRequestForOwner - Enqueues a reconcile.Request containing the Name and Namespace of the Owner of the object in the Event.
 This will cause owner of the object that was the source of the Event (e.g. the owner object that created the object)
 to be reconciled.
 EnqueueRequestsFromMapFunc - Enqueues reconcile.Requests resulting from a user provided transformation function run against the
 object in the Event.  This will cause an arbitrary collection of objects (defined from a transformation of the
 source object) to be reconciled.
 */
 package handler
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/handler/enqueue.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/handler/enqueue.go
@ -0,0 +1,91 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package handler
 import (
 	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/client-go/util/workqueue"
 	"sigs.k8s.io/controller-runtime/pkg/event"
 	logf "sigs.k8s.io/controller-runtime/pkg/internal/log"
 	"sigs.k8s.io/controller-runtime/pkg/reconcile"
 )
 var enqueueLog = logf.RuntimeLog.WithName("eventhandler").WithName("EnqueueRequestForObject")
 var _ EventHandler = &EnqueueRequestForObject{}
 // EnqueueRequestForObject enqueues a Request containing the Name and Namespace of the object that is the source of the Event.
 // (e.g. the created / deleted / updated objects Name and Namespace).  handler.EnqueueRequestForObject is used by almost all
 // Controllers that have associated Resources (e.g. CRDs) to reconcile the associated Resource.
 type EnqueueRequestForObject struct{}
 // Create implements EventHandler
 func (e *EnqueueRequestForObject) Create(evt event.CreateEvent, q workqueue.RateLimitingInterface) {
 	if evt.Meta == nil {
 		enqueueLog.Error(nil, "CreateEvent received with no metadata", "event", evt)
 		return
 	}
 	q.Add(reconcile.Request{NamespacedName: types.NamespacedName{
 		Name:      evt.Meta.GetName(),
 		Namespace: evt.Meta.GetNamespace(),
 	}})
 }
 // Update implements EventHandler
 func (e *EnqueueRequestForObject) Update(evt event.UpdateEvent, q workqueue.RateLimitingInterface) {
 	if evt.MetaOld != nil {
 		q.Add(reconcile.Request{NamespacedName: types.NamespacedName{
 			Name:      evt.MetaOld.GetName(),
 			Namespace: evt.MetaOld.GetNamespace(),
 		}})
 	} else {
 		enqueueLog.Error(nil, "UpdateEvent received with no old metadata", "event", evt)
 	}
 	if evt.MetaNew != nil {
 		q.Add(reconcile.Request{NamespacedName: types.NamespacedName{
 			Name:      evt.MetaNew.GetName(),
 			Namespace: evt.MetaNew.GetNamespace(),
 		}})
 	} else {
 		enqueueLog.Error(nil, "UpdateEvent received with no new metadata", "event", evt)
 	}
 }
 // Delete implements EventHandler
 func (e *EnqueueRequestForObject) Delete(evt event.DeleteEvent, q workqueue.RateLimitingInterface) {
 	if evt.Meta == nil {
 		enqueueLog.Error(nil, "DeleteEvent received with no metadata", "event", evt)
 		return
 	}
 	q.Add(reconcile.Request{NamespacedName: types.NamespacedName{
 		Name:      evt.Meta.GetName(),
 		Namespace: evt.Meta.GetNamespace(),
 	}})
 }
 // Generic implements EventHandler
 func (e *EnqueueRequestForObject) Generic(evt event.GenericEvent, q workqueue.RateLimitingInterface) {
 	if evt.Meta == nil {
 		enqueueLog.Error(nil, "GenericEvent received with no metadata", "event", evt)
 		return
 	}
 	q.Add(reconcile.Request{NamespacedName: types.NamespacedName{
 		Name:      evt.Meta.GetName(),
 		Namespace: evt.Meta.GetNamespace(),
 	}})
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/handler/enqueue_mapped.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/handler/enqueue_mapped.go
@ -0,0 +1,105 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package handler
 import (
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/client-go/util/workqueue"
 	"sigs.k8s.io/controller-runtime/pkg/event"
 	"sigs.k8s.io/controller-runtime/pkg/reconcile"
 	"sigs.k8s.io/controller-runtime/pkg/runtime/inject"
 )
 var _ EventHandler = &EnqueueRequestsFromMapFunc{}
 // EnqueueRequestsFromMapFunc enqueues Requests by running a transformation function that outputs a collection
 // of reconcile.Requests on each Event.  The reconcile.Requests may be for an arbitrary set of objects
 // defined by some user specified transformation of the source Event.  (e.g. trigger Reconciler for a set of objects
 // in response to a cluster resize event caused by adding or deleting a Node)
 //
 // EnqueueRequestsFromMapFunc is frequently used to fan-out updates from one object to one or more other
 // objects of a differing type.
 //
 // For UpdateEvents which contain both a new and old object, the transformation function is run on both
 // objects and both sets of Requests are enqueue.
 type EnqueueRequestsFromMapFunc struct {
 	// Mapper transforms the argument into a slice of keys to be reconciled
 	ToRequests Mapper
 }
 // Create implements EventHandler
 func (e *EnqueueRequestsFromMapFunc) Create(evt event.CreateEvent, q workqueue.RateLimitingInterface) {
 	e.mapAndEnqueue(q, MapObject{Meta: evt.Meta, Object: evt.Object})
 }
 // Update implements EventHandler
 func (e *EnqueueRequestsFromMapFunc) Update(evt event.UpdateEvent, q workqueue.RateLimitingInterface) {
 	e.mapAndEnqueue(q, MapObject{Meta: evt.MetaOld, Object: evt.ObjectOld})
 	e.mapAndEnqueue(q, MapObject{Meta: evt.MetaNew, Object: evt.ObjectNew})
 }
 // Delete implements EventHandler
 func (e *EnqueueRequestsFromMapFunc) Delete(evt event.DeleteEvent, q workqueue.RateLimitingInterface) {
 	e.mapAndEnqueue(q, MapObject{Meta: evt.Meta, Object: evt.Object})
 }
 // Generic implements EventHandler
 func (e *EnqueueRequestsFromMapFunc) Generic(evt event.GenericEvent, q workqueue.RateLimitingInterface) {
 	e.mapAndEnqueue(q, MapObject{Meta: evt.Meta, Object: evt.Object})
 }
 func (e *EnqueueRequestsFromMapFunc) mapAndEnqueue(q workqueue.RateLimitingInterface, object MapObject) {
 	for _, req := range e.ToRequests.Map(object) {
 		q.Add(req)
 	}
 }
 // EnqueueRequestsFromMapFunc can inject fields into the mapper.
 // InjectFunc implements inject.Injector.
 func (e *EnqueueRequestsFromMapFunc) InjectFunc(f inject.Func) error {
 	if f == nil {
 		return nil
 	}
 	return f(e.ToRequests)
 }
 // Mapper maps an object to a collection of keys to be enqueued
 type Mapper interface {
 	// Map maps an object
 	Map(MapObject) []reconcile.Request
 }
 // MapObject contains information from an event to be transformed into a Request.
 type MapObject struct {
 	// Meta is the meta data for an object from an event.
 	Meta metav1.Object
 	// Object is the object from an event.
 	Object runtime.Object
 }
 var _ Mapper = ToRequestsFunc(nil)
 // ToRequestsFunc implements Mapper using a function.
 type ToRequestsFunc func(MapObject) []reconcile.Request
 // Map implements Mapper
 func (m ToRequestsFunc) Map(i MapObject) []reconcile.Request {
 	return m(i)
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/handler/enqueue_owner.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/handler/enqueue_owner.go
@ -0,0 +1,188 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package handler
 import (
 	"fmt"
 	"k8s.io/apimachinery/pkg/api/meta"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/client-go/util/workqueue"
 	"sigs.k8s.io/controller-runtime/pkg/event"
 	logf "sigs.k8s.io/controller-runtime/pkg/internal/log"
 	"sigs.k8s.io/controller-runtime/pkg/reconcile"
 	"sigs.k8s.io/controller-runtime/pkg/runtime/inject"
 )
 var _ EventHandler = &EnqueueRequestForOwner{}
 var log = logf.RuntimeLog.WithName("eventhandler").WithName("EnqueueRequestForOwner")
 // EnqueueRequestForOwner enqueues Requests for the Owners of an object.  E.g. the object that created
 // the object that was the source of the Event.
 //
 // If a ReplicaSet creates Pods, users may reconcile the ReplicaSet in response to Pod Events using:
 //
 // - a source.Kind Source with Type of Pod.
 //
 // - a handler.EnqueueRequestForOwner EventHandler with an OwnerType of ReplicaSet and IsController set to true.
 type EnqueueRequestForOwner struct {
 	// OwnerType is the type of the Owner object to look for in OwnerReferences.  Only Group and Kind are compared.
 	OwnerType runtime.Object
 	// IsController if set will only look at the first OwnerReference with Controller: true.
 	IsController bool
 	// groupKind is the cached Group and Kind from OwnerType
 	groupKind schema.GroupKind
 	// mapper maps GroupVersionKinds to Resources
 	mapper meta.RESTMapper
 }
 // Create implements EventHandler
 func (e *EnqueueRequestForOwner) Create(evt event.CreateEvent, q workqueue.RateLimitingInterface) {
 	for _, req := range e.getOwnerReconcileRequest(evt.Meta) {
 		q.Add(req)
 	}
 }
 // Update implements EventHandler
 func (e *EnqueueRequestForOwner) Update(evt event.UpdateEvent, q workqueue.RateLimitingInterface) {
 	for _, req := range e.getOwnerReconcileRequest(evt.MetaOld) {
 		q.Add(req)
 	}
 	for _, req := range e.getOwnerReconcileRequest(evt.MetaNew) {
 		q.Add(req)
 	}
 }
 // Delete implements EventHandler
 func (e *EnqueueRequestForOwner) Delete(evt event.DeleteEvent, q workqueue.RateLimitingInterface) {
 	for _, req := range e.getOwnerReconcileRequest(evt.Meta) {
 		q.Add(req)
 	}
 }
 // Generic implements EventHandler
 func (e *EnqueueRequestForOwner) Generic(evt event.GenericEvent, q workqueue.RateLimitingInterface) {
 	for _, req := range e.getOwnerReconcileRequest(evt.Meta) {
 		q.Add(req)
 	}
 }
 // parseOwnerTypeGroupKind parses the OwnerType into a Group and Kind and caches the result.  Returns false
 // if the OwnerType could not be parsed using the scheme.
 func (e *EnqueueRequestForOwner) parseOwnerTypeGroupKind(scheme *runtime.Scheme) error {
 	// Get the kinds of the type
 	kinds, _, err := scheme.ObjectKinds(e.OwnerType)
 	if err != nil {
 		log.Error(err, "Could not get ObjectKinds for OwnerType", "owner type", fmt.Sprintf("%T", e.OwnerType))
 		return err
 	}
 	// Expect only 1 kind.  If there is more than one kind this is probably an edge case such as ListOptions.
 	if len(kinds) != 1 {
 		err := fmt.Errorf("Expected exactly 1 kind for OwnerType %T, but found %s kinds", e.OwnerType, kinds)
 		log.Error(nil, "Expected exactly 1 kind for OwnerType", "owner type", fmt.Sprintf("%T", e.OwnerType), "kinds", kinds)
 		return err
 	}
 	// Cache the Group and Kind for the OwnerType
 	e.groupKind = schema.GroupKind{Group: kinds[0].Group, Kind: kinds[0].Kind}
 	return nil
 }
 // getOwnerReconcileRequest looks at object and returns a slice of reconcile.Request to reconcile
 // owners of object that match e.OwnerType.
 func (e *EnqueueRequestForOwner) getOwnerReconcileRequest(object metav1.Object) []reconcile.Request {
 	// Iterate through the OwnerReferences looking for a match on Group and Kind against what was requested
 	// by the user
 	var result []reconcile.Request
 	for _, ref := range e.getOwnersReferences(object) {
 		// Parse the Group out of the OwnerReference to compare it to what was parsed out of the requested OwnerType
 		refGV, err := schema.ParseGroupVersion(ref.APIVersion)
 		if err != nil {
 			log.Error(err, "Could not parse OwnerReference APIVersion",
 				"api version", ref.APIVersion)
 			return nil
 		}
 		// Compare the OwnerReference Group and Kind against the OwnerType Group and Kind specified by the user.
 		// If the two match, create a Request for the objected referred to by
 		// the OwnerReference.  Use the Name from the OwnerReference and the Namespace from the
 		// object in the event.
 		if ref.Kind == e.groupKind.Kind && refGV.Group == e.groupKind.Group {
 			// Match found - add a Request for the object referred to in the OwnerReference
 			request := reconcile.Request{NamespacedName: types.NamespacedName{
 				Name: ref.Name,
 			}}
 			// if owner is not namespaced then we should set the namespace to the empty
 			mapping, err := e.mapper.RESTMapping(e.groupKind, refGV.Version)
 			if err != nil {
 				log.Error(err, "Could not retrieve rest mapping", "kind", e.groupKind)
 				return nil
 			}
 			if mapping.Scope.Name() != meta.RESTScopeNameRoot {
 				request.Namespace = object.GetNamespace()
 			}
 			result = append(result, request)
 		}
 	}
 	// Return the matches
 	return result
 }
 // getOwnersReferences returns the OwnerReferences for an object as specified by the EnqueueRequestForOwner
 // - if IsController is true: only take the Controller OwnerReference (if found)
 // - if IsController is false: take all OwnerReferences
 func (e *EnqueueRequestForOwner) getOwnersReferences(object metav1.Object) []metav1.OwnerReference {
 	if object == nil {
 		return nil
 	}
 	// If not filtered as Controller only, then use all the OwnerReferences
 	if !e.IsController {
 		return object.GetOwnerReferences()
 	}
 	// If filtered to a Controller, only take the Controller OwnerReference
 	if ownerRef := metav1.GetControllerOf(object); ownerRef != nil {
 		return []metav1.OwnerReference{*ownerRef}
 	}
 	// No Controller OwnerReference found
 	return nil
 }
 var _ inject.Scheme = &EnqueueRequestForOwner{}
 // InjectScheme is called by the Controller to provide a singleton scheme to the EnqueueRequestForOwner.
 func (e *EnqueueRequestForOwner) InjectScheme(s *runtime.Scheme) error {
 	return e.parseOwnerTypeGroupKind(s)
 }
 var _ inject.Mapper = &EnqueueRequestForOwner{}
 // InjectMapper  is called by the Controller to provide the rest mapper used by the manager.
 func (e *EnqueueRequestForOwner) InjectMapper(m meta.RESTMapper) error {
 	e.mapper = m
 	return nil
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/handler/eventhandler.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/handler/eventhandler.go
@ -0,0 +1,104 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package handler
 import (
 	"k8s.io/client-go/util/workqueue"
 	"sigs.k8s.io/controller-runtime/pkg/event"
 )
 // EventHandler enqueues reconcile.Requests in response to events (e.g. Pod Create).  EventHandlers map an Event
 // for one object to trigger Reconciles for either the same object or different objects - e.g. if there is an
 // Event for object with type Foo (using source.KindSource) then reconcile one or more object(s) with type Bar.
 //
 // Identical reconcile.Requests will be batched together through the queuing mechanism before reconcile is called.
 //
 // * Use EnqueueRequestForObject to reconcile the object the event is for
 // - do this for events for the type the Controller Reconciles. (e.g. Deployment for a Deployment Controller)
 //
 // * Use EnqueueRequestForOwner to reconcile the owner of the object the event is for
 // - do this for events for the types the Controller creates.  (e.g. ReplicaSets created by a Deployment Controller)
 //
 // * Use EnqueueRequestsFromMapFunc to transform an event for an object to a reconcile of an object
 // of a different type - do this for events for types the Controller may be interested in, but doesn't create.
 // (e.g. If Foo responds to cluster size events, map Node events to Foo objects.)
 //
 // Unless you are implementing your own EventHandler, you can ignore the functions on the EventHandler interface.
 // Most users shouldn't need to implement their own EventHandler.
 type EventHandler interface {
 	// Create is called in response to an create event - e.g. Pod Creation.
 	Create(event.CreateEvent, workqueue.RateLimitingInterface)
 	// Update is called in response to an update event -  e.g. Pod Updated.
 	Update(event.UpdateEvent, workqueue.RateLimitingInterface)
 	// Delete is called in response to a delete event - e.g. Pod Deleted.
 	Delete(event.DeleteEvent, workqueue.RateLimitingInterface)
 	// Generic is called in response to an event of an unknown type or a synthetic event triggered as a cron or
 	// external trigger request - e.g. reconcile Autoscaling, or a Webhook.
 	Generic(event.GenericEvent, workqueue.RateLimitingInterface)
 }
 var _ EventHandler = Funcs{}
 // Funcs implements EventHandler.
 type Funcs struct {
 	// Create is called in response to an add event.  Defaults to no-op.
 	// RateLimitingInterface is used to enqueue reconcile.Requests.
 	CreateFunc func(event.CreateEvent, workqueue.RateLimitingInterface)
 	// Update is called in response to an update event.  Defaults to no-op.
 	// RateLimitingInterface is used to enqueue reconcile.Requests.
 	UpdateFunc func(event.UpdateEvent, workqueue.RateLimitingInterface)
 	// Delete is called in response to a delete event.  Defaults to no-op.
 	// RateLimitingInterface is used to enqueue reconcile.Requests.
 	DeleteFunc func(event.DeleteEvent, workqueue.RateLimitingInterface)
 	// GenericFunc is called in response to a generic event.  Defaults to no-op.
 	// RateLimitingInterface is used to enqueue reconcile.Requests.
 	GenericFunc func(event.GenericEvent, workqueue.RateLimitingInterface)
 }
 // Create implements EventHandler
 func (h Funcs) Create(e event.CreateEvent, q workqueue.RateLimitingInterface) {
 	if h.CreateFunc != nil {
 		h.CreateFunc(e, q)
 	}
 }
 // Delete implements EventHandler
 func (h Funcs) Delete(e event.DeleteEvent, q workqueue.RateLimitingInterface) {
 	if h.DeleteFunc != nil {
 		h.DeleteFunc(e, q)
 	}
 }
 // Update implements EventHandler
 func (h Funcs) Update(e event.UpdateEvent, q workqueue.RateLimitingInterface) {
 	if h.UpdateFunc != nil {
 		h.UpdateFunc(e, q)
 	}
 }
 // Generic implements EventHandler
 func (h Funcs) Generic(e event.GenericEvent, q workqueue.RateLimitingInterface) {
 	if h.GenericFunc != nil {
 		h.GenericFunc(e, q)
 	}
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/healthz/doc.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/healthz/doc.go
@ -0,0 +1,32 @@
 /*
 Copyright 2014 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 // Package healthz contains helpers from supporting liveness and readiness endpoints.
 // (often referred to as healthz and readyz, respectively).
 //
 // This package draws heavily from the apiserver's healthz package
 // ( https://github.com/kubernetes/apiserver/tree/master/pkg/server/healthz )
 // but has some changes to bring it in line with controller-runtime's style.
 //
 // The main entrypoint is the Handler -- this serves both aggregated health status
 // and individual health check endpoints.
 package healthz
 import (
 	logf "sigs.k8s.io/controller-runtime/pkg/internal/log"
 )
 var log = logf.RuntimeLog.WithName("healthz")
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/healthz/healthz.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/healthz/healthz.go
@ -0,0 +1,207 @@
 /*
 Copyright 2014 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package healthz
 import (
 	"fmt"
 	"net/http"
 	"path"
 	"sort"
 	"strings"
 	"k8s.io/apimachinery/pkg/util/sets"
 )
 // Handler is an http.Handler that aggregates the results of the given
 // checkers to the root path, and supports calling individual checkers on
 // subpaths of the name of the checker.
 //
 // Adding checks on the fly is *not* threadsafe -- use a wrapper.
 type Handler struct {
 	Checks map[string]Checker
 }
 // checkStatus holds the output of a particular check
 type checkStatus struct {
 	name     string
 	healthy  bool
 	excluded bool
 }
 func (h *Handler) serveAggregated(resp http.ResponseWriter, req *http.Request) {
 	failed := false
 	excluded := getExcludedChecks(req)
 	parts := make([]checkStatus, 0, len(h.Checks))
 	// calculate the results...
 	for checkName, check := range h.Checks {
 		// no-op the check if we've specified we want to exclude the check
 		if excluded.Has(checkName) {
 			excluded.Delete(checkName)
 			parts = append(parts, checkStatus{name: checkName, healthy: true, excluded: true})
 			continue
 		}
 		if err := check(req); err != nil {
 			log.V(1).Info("healthz check failed", "checker", checkName, "error", err)
 			parts = append(parts, checkStatus{name: checkName, healthy: false})
 			failed = true
 		} else {
 			parts = append(parts, checkStatus{name: checkName, healthy: true})
 		}
 	}
 	// ...default a check if none is present...
 	if len(h.Checks) == 0 {
 		parts = append(parts, checkStatus{name: "ping", healthy: true})
 	}
 	for _, c := range excluded.List() {
 		log.V(1).Info("cannot exclude health check, no matches for it", "checker", c)
 	}
 	// ...sort to be consistent...
 	sort.Slice(parts, func(i, j int) bool { return parts[i].name < parts[j].name })
 	// ...and write out the result
 	// TODO(directxman12): this should also accept a request for JSON content (via a accept header)
 	_, forceVerbose := req.URL.Query()["verbose"]
 	writeStatusesAsText(resp, parts, excluded, failed, forceVerbose)
 }
 // writeStatusAsText writes out the given check statuses in some semi-arbitrary
 // bespoke text format that we copied from Kubernetes.  unknownExcludes lists
 // any checks that the user requested to have excluded, but weren't actually
 // known checks.  writeStatusAsText is always verbose on failure, and can be
 // forced to be verbose on success using the given argument.
 func writeStatusesAsText(resp http.ResponseWriter, parts []checkStatus, unknownExcludes sets.String, failed, forceVerbose bool) {
 	resp.Header().Set("Content-Type", "text/plain; charset=utf-8")
 	resp.Header().Set("X-Content-Type-Options", "nosniff")
 	// always write status code first
 	if failed {
 		resp.WriteHeader(http.StatusInternalServerError)
 	} else {
 		resp.WriteHeader(http.StatusOK)
 	}
 	// shortcut for easy non-verbose success
 	if !failed && !forceVerbose {
 		fmt.Fprint(resp, "ok")
 		return
 	}
 	// we're always verbose on failure, so from this point on we're guaranteed to be verbose
 	for _, checkOut := range parts {
 		switch {
 		case checkOut.excluded:
 			fmt.Fprintf(resp, "[+]%s excluded: ok\n", checkOut.name)
 		case checkOut.healthy:
 			fmt.Fprintf(resp, "[+]%s ok\n", checkOut.name)
 		default:
 			// don't include the error since this endpoint is public.  If someone wants more detail
 			// they should have explicit permission to the detailed checks.
 			fmt.Fprintf(resp, "[-]%s failed: reason withheld\n", checkOut.name)
 		}
 	}
 	if unknownExcludes.Len() > 0 {
 		fmt.Fprintf(resp, "warn: some health checks cannot be excluded: no matches for %s\n", formatQuoted(unknownExcludes.List()...))
 	}
 	if failed {
 		log.Info("healthz check failed", "statuses", parts)
 		fmt.Fprintf(resp, "healthz check failed\n")
 	} else {
 		fmt.Fprint(resp, "healthz check passed\n")
 	}
 }
 func (h *Handler) ServeHTTP(resp http.ResponseWriter, req *http.Request) {
 	// clean up the request (duplicating the internal logic of http.ServeMux a bit)
 	// clean up the path a bit
 	reqPath := req.URL.Path
 	if reqPath == "" || reqPath[0] != '/' {
 		reqPath = "/" + reqPath
 	}
 	// path.Clean removes the trailing slash except for root for us
 	// (which is fine, since we're only serving one layer of sub-paths)
 	reqPath = path.Clean(reqPath)
 	// either serve the root endpoint...
 	if reqPath == "/" {
 		h.serveAggregated(resp, req)
 		return
 	}
 	// ...the default check (if nothing else is present)...
 	if len(h.Checks) == 0 && reqPath[1:] == "ping" {
 		CheckHandler{Checker: Ping}.ServeHTTP(resp, req)
 		return
 	}
 	// ...or an individual checker
 	checkName := reqPath[1:] // ignore the leading slash
 	checker, known := h.Checks[checkName]
 	if !known {
 		http.NotFoundHandler().ServeHTTP(resp, req)
 		return
 	}
 	CheckHandler{Checker: checker}.ServeHTTP(resp, req)
 }
 // CheckHandler is an http.Handler that serves a health check endpoint at the root path,
 // based on its checker.
 type CheckHandler struct {
 	Checker
 }
 func (h CheckHandler) ServeHTTP(resp http.ResponseWriter, req *http.Request) {
 	err := h.Checker(req)
 	if err != nil {
 		http.Error(resp, fmt.Sprintf("internal server error: %v", err), http.StatusInternalServerError)
 	} else {
 		fmt.Fprint(resp, "ok")
 	}
 }
 // Checker knows how to perform a health check.
 type Checker func(req *http.Request) error
 // Ping returns true automatically when checked
 var Ping Checker = func(_ *http.Request) error { return nil }
 // getExcludedChecks extracts the health check names to be excluded from the query param
 func getExcludedChecks(r *http.Request) sets.String {
 	checks, found := r.URL.Query()["exclude"]
 	if found {
 		return sets.NewString(checks...)
 	}
 	return sets.NewString()
 }
 // formatQuoted returns a formatted string of the health check names,
 // preserving the order passed in.
 func formatQuoted(names ...string) string {
 	quoted := make([]string, 0, len(names))
 	for _, name := range names {
 		quoted = append(quoted, fmt.Sprintf("%q", name))
 	}
 	return strings.Join(quoted, ",")
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/internal/controller/controller.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/internal/controller/controller.go
@ -0,0 +1,298 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package controller
 import (
 	"fmt"
 	"sync"
 	"time"
 	"k8s.io/apimachinery/pkg/runtime"
 	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
 	"k8s.io/apimachinery/pkg/util/wait"
 	"k8s.io/client-go/rest"
 	"k8s.io/client-go/tools/record"
 	"k8s.io/client-go/util/workqueue"
 	"sigs.k8s.io/controller-runtime/pkg/cache"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/handler"
 	ctrlmetrics "sigs.k8s.io/controller-runtime/pkg/internal/controller/metrics"
 	logf "sigs.k8s.io/controller-runtime/pkg/internal/log"
 	"sigs.k8s.io/controller-runtime/pkg/predicate"
 	"sigs.k8s.io/controller-runtime/pkg/reconcile"
 	"sigs.k8s.io/controller-runtime/pkg/runtime/inject"
 	"sigs.k8s.io/controller-runtime/pkg/source"
 )
 var log = logf.RuntimeLog.WithName("controller")
 var _ inject.Injector = &Controller{}
 // Controller implements controller.Controller
 type Controller struct {
 	// Name is used to uniquely identify a Controller in tracing, logging and monitoring.  Name is required.
 	Name string
 	// MaxConcurrentReconciles is the maximum number of concurrent Reconciles which can be run. Defaults to 1.
 	MaxConcurrentReconciles int
 	// Reconciler is a function that can be called at any time with the Name / Namespace of an object and
 	// ensures that the state of the system matches the state specified in the object.
 	// Defaults to the DefaultReconcileFunc.
 	Do reconcile.Reconciler
 	// Client is a lazily initialized Client.  The controllerManager will initialize this when Start is called.
 	Client client.Client
 	// Scheme is injected by the controllerManager when controllerManager.Start is called
 	Scheme *runtime.Scheme
 	// informers are injected by the controllerManager when controllerManager.Start is called
 	Cache cache.Cache
 	// Config is the rest.Config used to talk to the apiserver.  Defaults to one of in-cluster, environment variable
 	// specified, or the ~/.kube/Config.
 	Config *rest.Config
 	// MakeQueue constructs the queue for this controller once the controller is ready to start.
 	// This exists because the standard Kubernetes workqueues start themselves immediately, which
 	// leads to goroutine leaks if something calls controller.New repeatedly.
 	MakeQueue func() workqueue.RateLimitingInterface
 	// Queue is an listeningQueue that listens for events from Informers and adds object keys to
 	// the Queue for processing
 	Queue workqueue.RateLimitingInterface
 	// SetFields is used to inject dependencies into other objects such as Sources, EventHandlers and Predicates
 	SetFields func(i interface{}) error
 	// mu is used to synchronize Controller setup
 	mu sync.Mutex
 	// JitterPeriod allows tests to reduce the JitterPeriod so they complete faster
 	JitterPeriod time.Duration
 	// WaitForCacheSync allows tests to mock out the WaitForCacheSync function to return an error
 	// defaults to Cache.WaitForCacheSync
 	WaitForCacheSync func(stopCh <-chan struct{}) bool
 	// Started is true if the Controller has been Started
 	Started bool
 	// Recorder is an event recorder for recording Event resources to the
 	// Kubernetes API.
 	Recorder record.EventRecorder
 	// TODO(community): Consider initializing a logger with the Controller Name as the tag
 	// watches maintains a list of sources, handlers, and predicates to start when the controller is started.
 	watches []watchDescription
 }
 // watchDescription contains all the information necessary to start a watch.
 type watchDescription struct {
 	src        source.Source
 	handler    handler.EventHandler
 	predicates []predicate.Predicate
 }
 // Reconcile implements reconcile.Reconciler
 func (c *Controller) Reconcile(r reconcile.Request) (reconcile.Result, error) {
 	return c.Do.Reconcile(r)
 }
 // Watch implements controller.Controller
 func (c *Controller) Watch(src source.Source, evthdler handler.EventHandler, prct ...predicate.Predicate) error {
 	c.mu.Lock()
 	defer c.mu.Unlock()
 	// Inject Cache into arguments
 	if err := c.SetFields(src); err != nil {
 		return err
 	}
 	if err := c.SetFields(evthdler); err != nil {
 		return err
 	}
 	for _, pr := range prct {
 		if err := c.SetFields(pr); err != nil {
 			return err
 		}
 	}
 	c.watches = append(c.watches, watchDescription{src: src, handler: evthdler, predicates: prct})
 	if c.Started {
 		log.Info("Starting EventSource", "controller", c.Name, "source", src)
 		return src.Start(evthdler, c.Queue, prct...)
 	}
 	return nil
 }
 // Start implements controller.Controller
 func (c *Controller) Start(stop <-chan struct{}) error {
 	// use an IIFE to get proper lock handling
 	// but lock outside to get proper handling of the queue shutdown
 	c.mu.Lock()
 	c.Queue = c.MakeQueue()
 	defer c.Queue.ShutDown() // needs to be outside the iife so that we shutdown after the stop channel is closed
 	err := func() error {
 		defer c.mu.Unlock()
 		// TODO(pwittrock): Reconsider HandleCrash
 		defer utilruntime.HandleCrash()
 		// NB(directxman12): launch the sources *before* trying to wait for the
 		// caches to sync so that they have a chance to register their intendeded
 		// caches.
 		for _, watch := range c.watches {
 			log.Info("Starting EventSource", "controller", c.Name, "source", watch.src)
 			if err := watch.src.Start(watch.handler, c.Queue, watch.predicates...); err != nil {
 				return err
 			}
 		}
 		// Start the SharedIndexInformer factories to begin populating the SharedIndexInformer caches
 		log.Info("Starting Controller", "controller", c.Name)
 		// Wait for the caches to be synced before starting workers
 		if c.WaitForCacheSync == nil {
 			c.WaitForCacheSync = c.Cache.WaitForCacheSync
 		}
 		if ok := c.WaitForCacheSync(stop); !ok {
 			// This code is unreachable right now since WaitForCacheSync will never return an error
 			// Leaving it here because that could happen in the future
 			err := fmt.Errorf("failed to wait for %s caches to sync", c.Name)
 			log.Error(err, "Could not wait for Cache to sync", "controller", c.Name)
 			return err
 		}
 		if c.JitterPeriod == 0 {
 			c.JitterPeriod = 1 * time.Second
 		}
 		// Launch workers to process resources
 		log.Info("Starting workers", "controller", c.Name, "worker count", c.MaxConcurrentReconciles)
 		for i := 0; i < c.MaxConcurrentReconciles; i++ {
 			// Process work items
 			go wait.Until(c.worker, c.JitterPeriod, stop)
 		}
 		c.Started = true
 		return nil
 	}()
 	if err != nil {
 		return err
 	}
 	<-stop
 	log.Info("Stopping workers", "controller", c.Name)
 	return nil
 }
 // worker runs a worker thread that just dequeues items, processes them, and marks them done.
 // It enforces that the reconcileHandler is never invoked concurrently with the same object.
 func (c *Controller) worker() {
 	for c.processNextWorkItem() {
 	}
 }
 // processNextWorkItem will read a single work item off the workqueue and
 // attempt to process it, by calling the reconcileHandler.
 func (c *Controller) processNextWorkItem() bool {
 	obj, shutdown := c.Queue.Get()
 	if shutdown {
 		// Stop working
 		return false
 	}
 	// We call Done here so the workqueue knows we have finished
 	// processing this item. We also must remember to call Forget if we
 	// do not want this work item being re-queued. For example, we do
 	// not call Forget if a transient error occurs, instead the item is
 	// put back on the workqueue and attempted again after a back-off
 	// period.
 	defer c.Queue.Done(obj)
 	return c.reconcileHandler(obj)
 }
 func (c *Controller) reconcileHandler(obj interface{}) bool {
 	// Update metrics after processing each item
 	reconcileStartTS := time.Now()
 	defer func() {
 		c.updateMetrics(time.Since(reconcileStartTS))
 	}()
 	var req reconcile.Request
 	var ok bool
 	if req, ok = obj.(reconcile.Request); !ok {
 		// As the item in the workqueue is actually invalid, we call
 		// Forget here else we'd go into a loop of attempting to
 		// process a work item that is invalid.
 		c.Queue.Forget(obj)
 		log.Error(nil, "Queue item was not a Request",
 			"controller", c.Name, "type", fmt.Sprintf("%T", obj), "value", obj)
 		// Return true, don't take a break
 		return true
 	}
 	// RunInformersAndControllers the syncHandler, passing it the namespace/Name string of the
 	// resource to be synced.
 	if result, err := c.Do.Reconcile(req); err != nil {
 		c.Queue.AddRateLimited(req)
 		log.Error(err, "Reconciler error", "controller", c.Name, "request", req)
 		ctrlmetrics.ReconcileErrors.WithLabelValues(c.Name).Inc()
 		ctrlmetrics.ReconcileTotal.WithLabelValues(c.Name, "error").Inc()
 		return false
 	} else if result.RequeueAfter > 0 {
 		// The result.RequeueAfter request will be lost, if it is returned
 		// along with a non-nil error. But this is intended as
 		// We need to drive to stable reconcile loops before queuing due
 		// to result.RequestAfter
 		c.Queue.Forget(obj)
 		c.Queue.AddAfter(req, result.RequeueAfter)
 		ctrlmetrics.ReconcileTotal.WithLabelValues(c.Name, "requeue_after").Inc()
 		return true
 	} else if result.Requeue {
 		c.Queue.AddRateLimited(req)
 		ctrlmetrics.ReconcileTotal.WithLabelValues(c.Name, "requeue").Inc()
 		return true
 	}
 	// Finally, if no error occurs we Forget this item so it does not
 	// get queued again until another change happens.
 	c.Queue.Forget(obj)
 	// TODO(directxman12): What does 1 mean?  Do we want level constants?  Do we want levels at all?
 	log.V(1).Info("Successfully Reconciled", "controller", c.Name, "request", req)
 	ctrlmetrics.ReconcileTotal.WithLabelValues(c.Name, "success").Inc()
 	// Return true, don't take a break
 	return true
 }
 // InjectFunc implement SetFields.Injector
 func (c *Controller) InjectFunc(f inject.Func) error {
 	c.SetFields = f
 	return nil
 }
 // updateMetrics updates prometheus metrics within the controller
 func (c *Controller) updateMetrics(reconcileTime time.Duration) {
 	ctrlmetrics.ReconcileTime.WithLabelValues(c.Name).Observe(reconcileTime.Seconds())
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/internal/controller/metrics/metrics.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/internal/controller/metrics/metrics.go
@ -0,0 +1,59 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package metrics
 import (
 	"github.com/prometheus/client_golang/prometheus"
 	"sigs.k8s.io/controller-runtime/pkg/metrics"
 )
 var (
 	// ReconcileTotal is a prometheus counter metrics which holds the total
 	// number of reconciliations per controller. It has two labels. controller label refers
 	// to the controller name and result label refers to the reconcile result i.e
 	// success, error, requeue, requeue_after
 	ReconcileTotal = prometheus.NewCounterVec(prometheus.CounterOpts{
 		Name: "controller_runtime_reconcile_total",
 		Help: "Total number of reconciliations per controller",
 	}, []string{"controller", "result"})
 	// ReconcileErrors is a prometheus counter metrics which holds the total
 	// number of errors from the Reconciler
 	ReconcileErrors = prometheus.NewCounterVec(prometheus.CounterOpts{
 		Name: "controller_runtime_reconcile_errors_total",
 		Help: "Total number of reconciliation errors per controller",
 	}, []string{"controller"})
 	// ReconcileTime is a prometheus metric which keeps track of the duration
 	// of reconciliations
 	ReconcileTime = prometheus.NewHistogramVec(prometheus.HistogramOpts{
 		Name: "controller_runtime_reconcile_time_seconds",
 		Help: "Length of time per reconciliation per controller",
 	}, []string{"controller"})
 )
 func init() {
 	metrics.Registry.MustRegister(
 		ReconcileTotal,
 		ReconcileErrors,
 		ReconcileTime,
 		// expose process metrics like CPU, Memory, file descriptor usage etc.
 		prometheus.NewProcessCollector(prometheus.ProcessCollectorOpts{}),
 		// expose Go runtime metrics like GC stats, memory stats etc.
 		prometheus.NewGoCollector(),
 	)
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/internal/log/log.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/internal/log/log.go
@ -0,0 +1,35 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 // Package log contains utilities for fetching a new logger
 // when one is not already available.
 // Deprecated: use pkg/log
 package log
 import (
 	"github.com/go-logr/logr"
 	"sigs.k8s.io/controller-runtime/pkg/log"
 )
 var (
 	// RuntimeLog is a base parent logger for use inside controller-runtime.
 	RuntimeLog logr.Logger
 )
 func init() {
 	RuntimeLog = log.Log.WithName("controller-runtime")
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/internal/recorder/recorder.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/internal/recorder/recorder.go
@ -0,0 +1,60 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package recorder
 import (
 	"fmt"
 	"github.com/go-logr/logr"
 	corev1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/client-go/kubernetes"
 	typedcorev1 "k8s.io/client-go/kubernetes/typed/core/v1"
 	"k8s.io/client-go/rest"
 	"k8s.io/client-go/tools/record"
 	"sigs.k8s.io/controller-runtime/pkg/recorder"
 )
 type provider struct {
 	// scheme to specify when creating a recorder
 	scheme *runtime.Scheme
 	// eventBroadcaster to create new recorder instance
 	eventBroadcaster record.EventBroadcaster
 	// logger is the logger to use when logging diagnostic event info
 	logger logr.Logger
 }
 // NewProvider create a new Provider instance.
 func NewProvider(config *rest.Config, scheme *runtime.Scheme, logger logr.Logger, broadcaster record.EventBroadcaster) (recorder.Provider, error) {
 	clientSet, err := kubernetes.NewForConfig(config)
 	if err != nil {
 		return nil, fmt.Errorf("failed to init clientSet: %w", err)
 	}
 	p := &provider{scheme: scheme, logger: logger, eventBroadcaster: broadcaster}
 	p.eventBroadcaster.StartRecordingToSink(&typedcorev1.EventSinkImpl{Interface: clientSet.CoreV1().Events("")})
 	p.eventBroadcaster.StartEventWatcher(
 		func(e *corev1.Event) {
 			p.logger.V(1).Info(e.Type, "object", e.InvolvedObject, "reason", e.Reason, "message", e.Message)
 		})
 	return p, nil
 }
 func (p *provider) GetEventRecorderFor(name string) record.EventRecorder {
 	return p.eventBroadcaster.NewRecorder(p.scheme, corev1.EventSource{Component: name})
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/leaderelection/doc.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/leaderelection/doc.go
@ -0,0 +1,24 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 /*
 Package leaderelection contains a constructors for a leader election resource lock.
 This is used to ensure that multiple copies of a controller manager can be run with
 only one active set of controllers, for active-passive HA.
 It uses built-in Kubernetes leader election APIs.
 */
 package leaderelection
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/leaderelection/leader_election.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/leaderelection/leader_election.go
@ -0,0 +1,111 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package leaderelection
 import (
 	"errors"
 	"fmt"
 	"io/ioutil"
 	"os"
 	"k8s.io/apimachinery/pkg/util/uuid"
 	"k8s.io/client-go/kubernetes"
 	"k8s.io/client-go/rest"
 	"k8s.io/client-go/tools/leaderelection/resourcelock"
 	"sigs.k8s.io/controller-runtime/pkg/recorder"
 )
 const inClusterNamespacePath = "/var/run/secrets/kubernetes.io/serviceaccount/namespace"
 // Options provides the required configuration to create a new resource lock
 type Options struct {
 	// LeaderElection determines whether or not to use leader election when
 	// starting the manager.
 	LeaderElection bool
 	// LeaderElectionNamespace determines the namespace in which the leader
 	// election configmap will be created.
 	LeaderElectionNamespace string
 	// LeaderElectionID determines the name of the configmap that leader election
 	// will use for holding the leader lock.
 	LeaderElectionID string
 }
 // NewResourceLock creates a new config map resource lock for use in a leader
 // election loop
 func NewResourceLock(config *rest.Config, recorderProvider recorder.Provider, options Options) (resourcelock.Interface, error) {
 	if !options.LeaderElection {
 		return nil, nil
 	}
 	// LeaderElectionID must be provided to prevent clashes
 	if options.LeaderElectionID == "" {
 		return nil, errors.New("LeaderElectionID must be configured")
 	}
 	// Default the namespace (if running in cluster)
 	if options.LeaderElectionNamespace == "" {
 		var err error
 		options.LeaderElectionNamespace, err = getInClusterNamespace()
 		if err != nil {
 			return nil, fmt.Errorf("unable to find leader election namespace: %w", err)
 		}
 	}
 	// Leader id, needs to be unique
 	id, err := os.Hostname()
 	if err != nil {
 		return nil, err
 	}
 	id = id + "_" + string(uuid.NewUUID())
 	// Construct client for leader election
 	client, err := kubernetes.NewForConfig(config)
 	if err != nil {
 		return nil, err
 	}
 	// TODO(JoelSpeed): switch to leaderelection object in 1.12
 	return resourcelock.New(resourcelock.ConfigMapsResourceLock,
 		options.LeaderElectionNamespace,
 		options.LeaderElectionID,
 		client.CoreV1(),
 		client.CoordinationV1(),
 		resourcelock.ResourceLockConfig{
 			Identity:      id,
 			EventRecorder: recorderProvider.GetEventRecorderFor(id),
 		})
 }
 func getInClusterNamespace() (string, error) {
 	// Check whether the namespace file exists.
 	// If not, we are not running in cluster so can't guess the namespace.
 	_, err := os.Stat(inClusterNamespacePath)
 	if os.IsNotExist(err) {
 		return "", fmt.Errorf("not running in-cluster, please specify LeaderElectionNamespace")
 	} else if err != nil {
 		return "", fmt.Errorf("error checking namespace file: %w", err)
 	}
 	// Load the namespace file and return its content
 	namespace, err := ioutil.ReadFile(inClusterNamespacePath)
 	if err != nil {
 		return "", fmt.Errorf("error reading namespace file: %w", err)
 	}
 	return string(namespace), nil
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/log/deleg.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/log/deleg.go
@ -0,0 +1,137 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package log
 import (
 	"sync"
 	"github.com/go-logr/logr"
 )
 // loggerPromise knows how to populate a concrete logr.Logger
 // with options, given an actual base logger later on down the line.
 type loggerPromise struct {
 	logger        *DelegatingLogger
 	childPromises []*loggerPromise
 	promisesLock  sync.Mutex
 	name *string
 	tags []interface{}
 }
 // WithName provides a new Logger with the name appended
 func (p *loggerPromise) WithName(l *DelegatingLogger, name string) *loggerPromise {
 	res := &loggerPromise{
 		logger:       l,
 		name:         &name,
 		promisesLock: sync.Mutex{},
 	}
 	p.promisesLock.Lock()
 	defer p.promisesLock.Unlock()
 	p.childPromises = append(p.childPromises, res)
 	return res
 }
 // WithValues provides a new Logger with the tags appended
 func (p *loggerPromise) WithValues(l *DelegatingLogger, tags ...interface{}) *loggerPromise {
 	res := &loggerPromise{
 		logger:       l,
 		tags:         tags,
 		promisesLock: sync.Mutex{},
 	}
 	p.promisesLock.Lock()
 	defer p.promisesLock.Unlock()
 	p.childPromises = append(p.childPromises, res)
 	return res
 }
 // Fulfill instantiates the Logger with the provided logger
 func (p *loggerPromise) Fulfill(parentLogger logr.Logger) {
 	var logger = parentLogger
 	if p.name != nil {
 		logger = logger.WithName(*p.name)
 	}
 	if p.tags != nil {
 		logger = logger.WithValues(p.tags...)
 	}
 	p.logger.Logger = logger
 	p.logger.promise = nil
 	for _, childPromise := range p.childPromises {
 		childPromise.Fulfill(logger)
 	}
 }
 // DelegatingLogger is a logr.Logger that delegates to another logr.Logger.
 // If the underlying promise is not nil, it registers calls to sub-loggers with
 // the logging factory to be populated later, and returns a new delegating
 // logger.  It expects to have *some* logr.Logger set at all times (generally
 // a no-op logger before the promises are fulfilled).
 type DelegatingLogger struct {
 	logr.Logger
 	promise *loggerPromise
 }
 // WithName provides a new Logger with the name appended
 func (l *DelegatingLogger) WithName(name string) logr.Logger {
 	if l.promise == nil {
 		return l.Logger.WithName(name)
 	}
 	res := &DelegatingLogger{Logger: l.Logger}
 	promise := l.promise.WithName(res, name)
 	res.promise = promise
 	return res
 }
 // WithValues provides a new Logger with the tags appended
 func (l *DelegatingLogger) WithValues(tags ...interface{}) logr.Logger {
 	if l.promise == nil {
 		return l.Logger.WithValues(tags...)
 	}
 	res := &DelegatingLogger{Logger: l.Logger}
 	promise := l.promise.WithValues(res, tags...)
 	res.promise = promise
 	return res
 }
 // Fulfill switches the logger over to use the actual logger
 // provided, instead of the temporary initial one, if this method
 // has not been previously called.
 func (l *DelegatingLogger) Fulfill(actual logr.Logger) {
 	if l.promise != nil {
 		l.promise.Fulfill(actual)
 	}
 }
 // NewDelegatingLogger constructs a new DelegatingLogger which uses
 // the given logger before it's promise is fulfilled.
 func NewDelegatingLogger(initial logr.Logger) *DelegatingLogger {
 	l := &DelegatingLogger{
 		Logger:  initial,
 		promise: &loggerPromise{promisesLock: sync.Mutex{}},
 	}
 	l.promise.logger = l
 	return l
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/log/log.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/log/log.go
@ -0,0 +1,48 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 // Package log contains utilities for fetching a new logger
 // when one is not already available.
 //
 // The Log Handle
 //
 // This package contains a root logr.Logger Log.  It may be used to
 // get a handle to whatever the root logging implementation is.  By
 // default, no implementation exists, and the handle returns "promises"
 // to loggers.  When the implementation is set using SetLogger, these
 // "promises" will be converted over to real loggers.
 //
 // Logr
 //
 // All logging in controller-runtime is structured, using a set of interfaces
 // defined by a package called logr
 // (https://godoc.org/github.com/go-logr/logr).  The sub-package zap provides
 // helpers for setting up logr backed by Zap (go.uber.org/zap).
 package log
 import (
 	"github.com/go-logr/logr"
 )
 // SetLogger sets a concrete logging implementation for all deferred Loggers.
 func SetLogger(l logr.Logger) {
 	Log.Fulfill(l)
 }
 // Log is the base logger used by kubebuilder.  It delegates
 // to another logr.Logger.  You *must* call SetLogger to
 // get any actual logging.
 var Log = NewDelegatingLogger(NullLogger{})
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/log/null.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/log/null.go
@ -0,0 +1,60 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package log
 import (
 	"github.com/go-logr/logr"
 )
 // NB: this is the same as the null logger logr/testing,
 // but avoids accidentally adding the testing flags to
 // all binaries.
 // NullLogger is a logr.Logger that does nothing.
 type NullLogger struct{}
 var _ logr.Logger = NullLogger{}
 // Info implements logr.InfoLogger
 func (NullLogger) Info(_ string, _ ...interface{}) {
 	// Do nothing.
 }
 // Enabled implements logr.InfoLogger
 func (NullLogger) Enabled() bool {
 	return false
 }
 // Error implements logr.Logger
 func (NullLogger) Error(_ error, _ string, _ ...interface{}) {
 	// Do nothing.
 }
 // V implements logr.Logger
 func (log NullLogger) V(_ int) logr.InfoLogger {
 	return log
 }
 // WithName implements logr.Logger
 func (log NullLogger) WithName(_ string) logr.Logger {
 	return log
 }
 // WithValues implements logr.Logger
 func (log NullLogger) WithValues(_ ...interface{}) logr.Logger {
 	return log
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/manager/doc.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/manager/doc.go
@ -0,0 +1,21 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 /*
 Package manager is required to create Controllers and provides shared dependencies such as clients, caches, schemes,
 etc.  Controllers must be started by calling Manager.Start.
 */
 package manager
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/manager/internal.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/manager/internal.go
@ -0,0 +1,586 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package manager
 import (
 	"context"
 	"fmt"
 	"net"
 	"net/http"
 	"sync"
 	"time"
 	"github.com/prometheus/client_golang/prometheus/promhttp"
 	"k8s.io/apimachinery/pkg/api/meta"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/client-go/rest"
 	"k8s.io/client-go/tools/leaderelection"
 	"k8s.io/client-go/tools/leaderelection/resourcelock"
 	"k8s.io/client-go/tools/record"
 	"sigs.k8s.io/controller-runtime/pkg/cache"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/healthz"
 	logf "sigs.k8s.io/controller-runtime/pkg/internal/log"
 	"sigs.k8s.io/controller-runtime/pkg/metrics"
 	"sigs.k8s.io/controller-runtime/pkg/recorder"
 	"sigs.k8s.io/controller-runtime/pkg/runtime/inject"
 	"sigs.k8s.io/controller-runtime/pkg/webhook"
 )
 const (
 	// Values taken from: https://github.com/kubernetes/apiserver/blob/master/pkg/apis/config/v1alpha1/defaults.go
 	defaultLeaseDuration = 15 * time.Second
 	defaultRenewDeadline = 10 * time.Second
 	defaultRetryPeriod   = 2 * time.Second
 	defaultReadinessEndpoint = "/readyz"
 	defaultLivenessEndpoint  = "/healthz"
 	defaultMetricsEndpoint   = "/metrics"
 )
 var log = logf.RuntimeLog.WithName("manager")
 type controllerManager struct {
 	// config is the rest.config used to talk to the apiserver.  Required.
 	config *rest.Config
 	// scheme is the scheme injected into Controllers, EventHandlers, Sources and Predicates.  Defaults
 	// to scheme.scheme.
 	scheme *runtime.Scheme
 	// leaderElectionRunnables is the set of Controllers that the controllerManager injects deps into and Starts.
 	// These Runnables are managed by lead election.
 	leaderElectionRunnables []Runnable
 	// nonLeaderElectionRunnables is the set of webhook servers that the controllerManager injects deps into and Starts.
 	// These Runnables will not be blocked by lead election.
 	nonLeaderElectionRunnables []Runnable
 	cache cache.Cache
 	// TODO(directxman12): Provide an escape hatch to get individual indexers
 	// client is the client injected into Controllers (and EventHandlers, Sources and Predicates).
 	client client.Client
 	// apiReader is the reader that will make requests to the api server and not the cache.
 	apiReader client.Reader
 	// fieldIndexes knows how to add field indexes over the Cache used by this controller,
 	// which can later be consumed via field selectors from the injected client.
 	fieldIndexes client.FieldIndexer
 	// recorderProvider is used to generate event recorders that will be injected into Controllers
 	// (and EventHandlers, Sources and Predicates).
 	recorderProvider recorder.Provider
 	// resourceLock forms the basis for leader election
 	resourceLock resourcelock.Interface
 	// mapper is used to map resources to kind, and map kind and version.
 	mapper meta.RESTMapper
 	// metricsListener is used to serve prometheus metrics
 	metricsListener net.Listener
 	// metricsExtraHandlers contains extra handlers to register on http server that serves metrics.
 	metricsExtraHandlers map[string]http.Handler
 	// healthProbeListener is used to serve liveness probe
 	healthProbeListener net.Listener
 	// Readiness probe endpoint name
 	readinessEndpointName string
 	// Liveness probe endpoint name
 	livenessEndpointName string
 	// Readyz probe handler
 	readyzHandler *healthz.Handler
 	// Healthz probe handler
 	healthzHandler *healthz.Handler
 	mu             sync.Mutex
 	started        bool
 	startedLeader  bool
 	healthzStarted bool
 	// NB(directxman12): we don't just use an error channel here to avoid the situation where the
 	// error channel is too small and we end up blocking some goroutines waiting to report their errors.
 	// errSignal lets us track when we should stop because an error occurred
 	errSignal *errSignaler
 	// internalStop is the stop channel *actually* used by everything involved
 	// with the manager as a stop channel, so that we can pass a stop channel
 	// to things that need it off the bat (like the Channel source).  It can
 	// be closed via `internalStopper` (by being the same underlying channel).
 	internalStop <-chan struct{}
 	// internalStopper is the write side of the internal stop channel, allowing us to close it.
 	// It and `internalStop` should point to the same channel.
 	internalStopper chan<- struct{}
 	// elected is closed when this manager becomes the leader of a group of
 	// managers, either because it won a leader election or because no leader
 	// election was configured.
 	elected chan struct{}
 	startCache func(stop <-chan struct{}) error
 	// port is the port that the webhook server serves at.
 	port int
 	// host is the hostname that the webhook server binds to.
 	host string
 	// CertDir is the directory that contains the server key and certificate.
 	// if not set, webhook server would look up the server key and certificate in
 	// {TempDir}/k8s-webhook-server/serving-certs
 	certDir string
 	webhookServer *webhook.Server
 	// leaseDuration is the duration that non-leader candidates will
 	// wait to force acquire leadership.
 	leaseDuration time.Duration
 	// renewDeadline is the duration that the acting master will retry
 	// refreshing leadership before giving up.
 	renewDeadline time.Duration
 	// retryPeriod is the duration the LeaderElector clients should wait
 	// between tries of actions.
 	retryPeriod time.Duration
 }
 type errSignaler struct {
 	// errSignal indicates that an error occurred, when closed.  It shouldn't
 	// be written to.
 	errSignal chan struct{}
 	// err is the received error
 	err error
 	mu sync.Mutex
 }
 func (r *errSignaler) SignalError(err error) {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 	if err == nil {
 		// non-error, ignore
 		log.Error(nil, "SignalError called without an (with a nil) error, which should never happen, ignoring")
 		return
 	}
 	if r.err != nil {
 		// we already have an error, don't try again
 		return
 	}
 	// save the error and report it
 	r.err = err
 	close(r.errSignal)
 }
 func (r *errSignaler) Error() error {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 	return r.err
 }
 func (r *errSignaler) GotError() chan struct{} {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 	return r.errSignal
 }
 // Add sets dependencies on i, and adds it to the list of Runnables to start.
 func (cm *controllerManager) Add(r Runnable) error {
 	cm.mu.Lock()
 	defer cm.mu.Unlock()
 	// Set dependencies on the object
 	if err := cm.SetFields(r); err != nil {
 		return err
 	}
 	var shouldStart bool
 	// Add the runnable to the leader election or the non-leaderelection list
 	if leRunnable, ok := r.(LeaderElectionRunnable); ok && !leRunnable.NeedLeaderElection() {
 		shouldStart = cm.started
 		cm.nonLeaderElectionRunnables = append(cm.nonLeaderElectionRunnables, r)
 	} else {
 		shouldStart = cm.startedLeader
 		cm.leaderElectionRunnables = append(cm.leaderElectionRunnables, r)
 	}
 	if shouldStart {
 		// If already started, start the controller
 		go func() {
 			if err := r.Start(cm.internalStop); err != nil {
 				cm.errSignal.SignalError(err)
 			}
 		}()
 	}
 	return nil
 }
 func (cm *controllerManager) SetFields(i interface{}) error {
 	if _, err := inject.ConfigInto(cm.config, i); err != nil {
 		return err
 	}
 	if _, err := inject.ClientInto(cm.client, i); err != nil {
 		return err
 	}
 	if _, err := inject.APIReaderInto(cm.apiReader, i); err != nil {
 		return err
 	}
 	if _, err := inject.SchemeInto(cm.scheme, i); err != nil {
 		return err
 	}
 	if _, err := inject.CacheInto(cm.cache, i); err != nil {
 		return err
 	}
 	if _, err := inject.InjectorInto(cm.SetFields, i); err != nil {
 		return err
 	}
 	if _, err := inject.StopChannelInto(cm.internalStop, i); err != nil {
 		return err
 	}
 	if _, err := inject.MapperInto(cm.mapper, i); err != nil {
 		return err
 	}
 	return nil
 }
 // AddMetricsExtraHandler adds extra handler served on path to the http server that serves metrics.
 func (cm *controllerManager) AddMetricsExtraHandler(path string, handler http.Handler) error {
 	if path == defaultMetricsEndpoint {
 		return fmt.Errorf("overriding builtin %s endpoint is not allowed", defaultMetricsEndpoint)
 	}
 	cm.mu.Lock()
 	defer cm.mu.Unlock()
 	_, found := cm.metricsExtraHandlers[path]
 	if found {
 		return fmt.Errorf("can't register extra handler by duplicate path %q on metrics http server", path)
 	}
 	cm.metricsExtraHandlers[path] = handler
 	log.V(2).Info("Registering metrics http server extra handler", "path", path)
 	return nil
 }
 // AddHealthzCheck allows you to add Healthz checker
 func (cm *controllerManager) AddHealthzCheck(name string, check healthz.Checker) error {
 	cm.mu.Lock()
 	defer cm.mu.Unlock()
 	if cm.healthzStarted {
 		return fmt.Errorf("unable to add new checker because healthz endpoint has already been created")
 	}
 	if cm.healthzHandler == nil {
 		cm.healthzHandler = &healthz.Handler{Checks: map[string]healthz.Checker{}}
 	}
 	cm.healthzHandler.Checks[name] = check
 	return nil
 }
 // AddReadyzCheck allows you to add Readyz checker
 func (cm *controllerManager) AddReadyzCheck(name string, check healthz.Checker) error {
 	cm.mu.Lock()
 	defer cm.mu.Unlock()
 	if cm.healthzStarted {
 		return fmt.Errorf("unable to add new checker because readyz endpoint has already been created")
 	}
 	if cm.readyzHandler == nil {
 		cm.readyzHandler = &healthz.Handler{Checks: map[string]healthz.Checker{}}
 	}
 	cm.readyzHandler.Checks[name] = check
 	return nil
 }
 func (cm *controllerManager) GetConfig() *rest.Config {
 	return cm.config
 }
 func (cm *controllerManager) GetClient() client.Client {
 	return cm.client
 }
 func (cm *controllerManager) GetScheme() *runtime.Scheme {
 	return cm.scheme
 }
 func (cm *controllerManager) GetFieldIndexer() client.FieldIndexer {
 	return cm.fieldIndexes
 }
 func (cm *controllerManager) GetCache() cache.Cache {
 	return cm.cache
 }
 func (cm *controllerManager) GetEventRecorderFor(name string) record.EventRecorder {
 	return cm.recorderProvider.GetEventRecorderFor(name)
 }
 func (cm *controllerManager) GetRESTMapper() meta.RESTMapper {
 	return cm.mapper
 }
 func (cm *controllerManager) GetAPIReader() client.Reader {
 	return cm.apiReader
 }
 func (cm *controllerManager) GetWebhookServer() *webhook.Server {
 	if cm.webhookServer == nil {
 		cm.webhookServer = &webhook.Server{
 			Port:    cm.port,
 			Host:    cm.host,
 			CertDir: cm.certDir,
 		}
 		if err := cm.Add(cm.webhookServer); err != nil {
 			panic("unable to add webhookServer to the controller manager")
 		}
 	}
 	return cm.webhookServer
 }
 func (cm *controllerManager) serveMetrics(stop <-chan struct{}) {
 	handler := promhttp.HandlerFor(metrics.Registry, promhttp.HandlerOpts{
 		ErrorHandling: promhttp.HTTPErrorOnError,
 	})
 	// TODO(JoelSpeed): Use existing Kubernetes machinery for serving metrics
 	mux := http.NewServeMux()
 	mux.Handle(defaultMetricsEndpoint, handler)
 	func() {
 		cm.mu.Lock()
 		defer cm.mu.Unlock()
 		for path, extraHandler := range cm.metricsExtraHandlers {
 			mux.Handle(path, extraHandler)
 		}
 	}()
 	server := http.Server{
 		Handler: mux,
 	}
 	// Run the server
 	go func() {
 		log.Info("starting metrics server", "path", defaultMetricsEndpoint)
 		if err := server.Serve(cm.metricsListener); err != nil && err != http.ErrServerClosed {
 			cm.errSignal.SignalError(err)
 		}
 	}()
 	// Shutdown the server when stop is closed
 	<-stop
 	if err := server.Shutdown(context.Background()); err != nil {
 		cm.errSignal.SignalError(err)
 	}
 }
 func (cm *controllerManager) serveHealthProbes(stop <-chan struct{}) {
 	// TODO(hypnoglow): refactor locking to use anonymous func in the similar way
 	// it's done in serveMetrics.
 	cm.mu.Lock()
 	mux := http.NewServeMux()
 	if cm.readyzHandler != nil {
 		mux.Handle(cm.readinessEndpointName, http.StripPrefix(cm.readinessEndpointName, cm.readyzHandler))
 	}
 	if cm.healthzHandler != nil {
 		mux.Handle(cm.livenessEndpointName, http.StripPrefix(cm.livenessEndpointName, cm.healthzHandler))
 	}
 	server := http.Server{
 		Handler: mux,
 	}
 	// Run server
 	go func() {
 		if err := server.Serve(cm.healthProbeListener); err != nil && err != http.ErrServerClosed {
 			cm.errSignal.SignalError(err)
 		}
 	}()
 	cm.healthzStarted = true
 	cm.mu.Unlock()
 	// Shutdown the server when stop is closed
 	<-stop
 	if err := server.Shutdown(context.Background()); err != nil {
 		cm.errSignal.SignalError(err)
 	}
 }
 func (cm *controllerManager) Start(stop <-chan struct{}) error {
 	// join the passed-in stop channel as an upstream feeding into cm.internalStopper
 	defer close(cm.internalStopper)
 	// initialize this here so that we reset the signal channel state on every start
 	cm.errSignal = &errSignaler{errSignal: make(chan struct{})}
 	// Metrics should be served whether the controller is leader or not.
 	// (If we don't serve metrics for non-leaders, prometheus will still scrape
 	// the pod but will get a connection refused)
 	if cm.metricsListener != nil {
 		go cm.serveMetrics(cm.internalStop)
 	}
 	// Serve health probes
 	if cm.healthProbeListener != nil {
 		go cm.serveHealthProbes(cm.internalStop)
 	}
 	go cm.startNonLeaderElectionRunnables()
 	if cm.resourceLock != nil {
 		err := cm.startLeaderElection()
 		if err != nil {
 			return err
 		}
 	} else {
 		// Treat not having leader election enabled the same as being elected.
 		close(cm.elected)
 		go cm.startLeaderElectionRunnables()
 	}
 	select {
 	case <-stop:
 		// We are done
 		return nil
 	case <-cm.errSignal.GotError():
 		// Error starting a controller
 		return cm.errSignal.Error()
 	}
 }
 func (cm *controllerManager) startNonLeaderElectionRunnables() {
 	cm.mu.Lock()
 	defer cm.mu.Unlock()
 	cm.waitForCache()
 	// Start the non-leaderelection Runnables after the cache has synced
 	for _, c := range cm.nonLeaderElectionRunnables {
 		// Controllers block, but we want to return an error if any have an error starting.
 		// Write any Start errors to a channel so we can return them
 		ctrl := c
 		go func() {
 			if err := ctrl.Start(cm.internalStop); err != nil {
 				cm.errSignal.SignalError(err)
 			}
 			// we use %T here because we don't have a good stand-in for "name",
 			// and the full runnable might not serialize (mutexes, etc)
 			log.V(1).Info("non-leader-election runnable finished", "runnable type", fmt.Sprintf("%T", ctrl))
 		}()
 	}
 }
 func (cm *controllerManager) startLeaderElectionRunnables() {
 	cm.mu.Lock()
 	defer cm.mu.Unlock()
 	cm.waitForCache()
 	// Start the leader election Runnables after the cache has synced
 	for _, c := range cm.leaderElectionRunnables {
 		// Controllers block, but we want to return an error if any have an error starting.
 		// Write any Start errors to a channel so we can return them
 		ctrl := c
 		go func() {
 			if err := ctrl.Start(cm.internalStop); err != nil {
 				cm.errSignal.SignalError(err)
 			}
 			// we use %T here because we don't have a good stand-in for "name",
 			// and the full runnable might not serialize (mutexes, etc)
 			log.V(1).Info("leader-election runnable finished", "runnable type", fmt.Sprintf("%T", ctrl))
 		}()
 	}
 	cm.startedLeader = true
 }
 func (cm *controllerManager) waitForCache() {
 	if cm.started {
 		return
 	}
 	// Start the Cache. Allow the function to start the cache to be mocked out for testing
 	if cm.startCache == nil {
 		cm.startCache = cm.cache.Start
 	}
 	go func() {
 		if err := cm.startCache(cm.internalStop); err != nil {
 			cm.errSignal.SignalError(err)
 		}
 	}()
 	// Wait for the caches to sync.
 	// TODO(community): Check the return value and write a test
 	cm.cache.WaitForCacheSync(cm.internalStop)
 	cm.started = true
 }
 func (cm *controllerManager) startLeaderElection() (err error) {
 	l, err := leaderelection.NewLeaderElector(leaderelection.LeaderElectionConfig{
 		Lock:          cm.resourceLock,
 		LeaseDuration: cm.leaseDuration,
 		RenewDeadline: cm.renewDeadline,
 		RetryPeriod:   cm.retryPeriod,
 		Callbacks: leaderelection.LeaderCallbacks{
 			OnStartedLeading: func(_ context.Context) {
 				close(cm.elected)
 				cm.startLeaderElectionRunnables()
 			},
 			OnStoppedLeading: func() {
 				// Most implementations of leader election log.Fatal() here.
 				// Since Start is wrapped in log.Fatal when called, we can just return
 				// an error here which will cause the program to exit.
 				cm.errSignal.SignalError(fmt.Errorf("leader election lost"))
 			},
 		},
 	})
 	if err != nil {
 		return err
 	}
 	ctx, cancel := context.WithCancel(context.Background())
 	go func() {
 		select {
 		case <-cm.internalStop:
 			cancel()
 		case <-ctx.Done():
 		}
 	}()
 	// Start the leader elector process
 	go l.Run(ctx)
 	return nil
 }
 func (cm *controllerManager) Elected() <-chan struct{} {
 	return cm.elected
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/manager/manager.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/manager/manager.go
@ -0,0 +1,443 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package manager
 import (
 	"fmt"
 	"net"
 	"net/http"
 	"time"
 	"github.com/go-logr/logr"
 	"k8s.io/apimachinery/pkg/api/meta"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/client-go/kubernetes/scheme"
 	"k8s.io/client-go/rest"
 	"k8s.io/client-go/tools/leaderelection/resourcelock"
 	"k8s.io/client-go/tools/record"
 	"sigs.k8s.io/controller-runtime/pkg/cache"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/client/apiutil"
 	"sigs.k8s.io/controller-runtime/pkg/healthz"
 	internalrecorder "sigs.k8s.io/controller-runtime/pkg/internal/recorder"
 	"sigs.k8s.io/controller-runtime/pkg/leaderelection"
 	"sigs.k8s.io/controller-runtime/pkg/metrics"
 	"sigs.k8s.io/controller-runtime/pkg/recorder"
 	"sigs.k8s.io/controller-runtime/pkg/webhook"
 )
 // Manager initializes shared dependencies such as Caches and Clients, and provides them to Runnables.
 // A Manager is required to create Controllers.
 type Manager interface {
 	// Add will set requested dependencies on the component, and cause the component to be
 	// started when Start is called.  Add will inject any dependencies for which the argument
 	// implements the inject interface - e.g. inject.Client.
 	// Depending on if a Runnable implements LeaderElectionRunnable interface, a Runnable can be run in either
 	// non-leaderelection mode (always running) or leader election mode (managed by leader election if enabled).
 	Add(Runnable) error
 	// Elected is closed when this manager is elected leader of a group of
 	// managers, either because it won a leader election or because no leader
 	// election was configured.
 	Elected() <-chan struct{}
 	// SetFields will set any dependencies on an object for which the object has implemented the inject
 	// interface - e.g. inject.Client.
 	SetFields(interface{}) error
 	// AddMetricsExtraHandler adds an extra handler served on path to the http server that serves metrics.
 	// Might be useful to register some diagnostic endpoints e.g. pprof. Note that these endpoints meant to be
 	// sensitive and shouldn't be exposed publicly.
 	// If the simple path -> handler mapping offered here is not enough, a new http server/listener should be added as
 	// Runnable to the manager via Add method.
 	AddMetricsExtraHandler(path string, handler http.Handler) error
 	// AddHealthzCheck allows you to add Healthz checker
 	AddHealthzCheck(name string, check healthz.Checker) error
 	// AddReadyzCheck allows you to add Readyz checker
 	AddReadyzCheck(name string, check healthz.Checker) error
 	// Start starts all registered Controllers and blocks until the Stop channel is closed.
 	// Returns an error if there is an error starting any controller.
 	Start(<-chan struct{}) error
 	// GetConfig returns an initialized Config
 	GetConfig() *rest.Config
 	// GetScheme returns an initialized Scheme
 	GetScheme() *runtime.Scheme
 	// GetClient returns a client configured with the Config. This client may
 	// not be a fully "direct" client -- it may read from a cache, for
 	// instance.  See Options.NewClient for more information on how the default
 	// implementation works.
 	GetClient() client.Client
 	// GetFieldIndexer returns a client.FieldIndexer configured with the client
 	GetFieldIndexer() client.FieldIndexer
 	// GetCache returns a cache.Cache
 	GetCache() cache.Cache
 	// GetEventRecorderFor returns a new EventRecorder for the provided name
 	GetEventRecorderFor(name string) record.EventRecorder
 	// GetRESTMapper returns a RESTMapper
 	GetRESTMapper() meta.RESTMapper
 	// GetAPIReader returns a reader that will be configured to use the API server.
 	// This should be used sparingly and only when the client does not fit your
 	// use case.
 	GetAPIReader() client.Reader
 	// GetWebhookServer returns a webhook.Server
 	GetWebhookServer() *webhook.Server
 }
 // Options are the arguments for creating a new Manager
 type Options struct {
 	// Scheme is the scheme used to resolve runtime.Objects to GroupVersionKinds / Resources
 	// Defaults to the kubernetes/client-go scheme.Scheme, but it's almost always better
 	// idea to pass your own scheme in.  See the documentation in pkg/scheme for more information.
 	Scheme *runtime.Scheme
 	// MapperProvider provides the rest mapper used to map go types to Kubernetes APIs
 	MapperProvider func(c *rest.Config) (meta.RESTMapper, error)
 	// SyncPeriod determines the minimum frequency at which watched resources are
 	// reconciled. A lower period will correct entropy more quickly, but reduce
 	// responsiveness to change if there are many watched resources. Change this
 	// value only if you know what you are doing. Defaults to 10 hours if unset.
 	// there will a 10 percent jitter between the SyncPeriod of all controllers
 	// so that all controllers will not send list requests simultaneously.
 	SyncPeriod *time.Duration
 	// LeaderElection determines whether or not to use leader election when
 	// starting the manager.
 	LeaderElection bool
 	// LeaderElectionNamespace determines the namespace in which the leader
 	// election configmap will be created.
 	LeaderElectionNamespace string
 	// LeaderElectionID determines the name of the configmap that leader election
 	// will use for holding the leader lock.
 	LeaderElectionID string
 	// LeaseDuration is the duration that non-leader candidates will
 	// wait to force acquire leadership. This is measured against time of
 	// last observed ack. Default is 15 seconds.
 	LeaseDuration *time.Duration
 	// RenewDeadline is the duration that the acting master will retry
 	// refreshing leadership before giving up. Default is 10 seconds.
 	RenewDeadline *time.Duration
 	// RetryPeriod is the duration the LeaderElector clients should wait
 	// between tries of actions. Default is 2 seconds.
 	RetryPeriod *time.Duration
 	// Namespace if specified restricts the manager's cache to watch objects in
 	// the desired namespace Defaults to all namespaces
 	//
 	// Note: If a namespace is specified, controllers can still Watch for a
 	// cluster-scoped resource (e.g Node).  For namespaced resources the cache
 	// will only hold objects from the desired namespace.
 	Namespace string
 	// MetricsBindAddress is the TCP address that the controller should bind to
 	// for serving prometheus metrics.
 	// It can be set to "0" to disable the metrics serving.
 	MetricsBindAddress string
 	// HealthProbeBindAddress is the TCP address that the controller should bind to
 	// for serving health probes
 	HealthProbeBindAddress string
 	// Readiness probe endpoint name, defaults to "readyz"
 	ReadinessEndpointName string
 	// Liveness probe endpoint name, defaults to "healthz"
 	LivenessEndpointName string
 	// Port is the port that the webhook server serves at.
 	// It is used to set webhook.Server.Port.
 	Port int
 	// Host is the hostname that the webhook server binds to.
 	// It is used to set webhook.Server.Host.
 	Host string
 	// CertDir is the directory that contains the server key and certificate.
 	// if not set, webhook server would look up the server key and certificate in
 	// {TempDir}/k8s-webhook-server/serving-certs. The server key and certificate
 	// must be named tls.key and tls.crt, respectively.
 	CertDir string
 	// Functions to all for a user to customize the values that will be injected.
 	// NewCache is the function that will create the cache to be used
 	// by the manager. If not set this will use the default new cache function.
 	NewCache cache.NewCacheFunc
 	// NewClient will create the client to be used by the manager.
 	// If not set this will create the default DelegatingClient that will
 	// use the cache for reads and the client for writes.
 	NewClient NewClientFunc
 	// DryRunClient specifies whether the client should be configured to enforce
 	// dryRun mode.
 	DryRunClient bool
 	// EventBroadcaster records Events emitted by the manager and sends them to the Kubernetes API
 	// Use this to customize the event correlator and spam filter
 	EventBroadcaster record.EventBroadcaster
 	// Dependency injection for testing
 	newRecorderProvider    func(config *rest.Config, scheme *runtime.Scheme, logger logr.Logger, broadcaster record.EventBroadcaster) (recorder.Provider, error)
 	newResourceLock        func(config *rest.Config, recorderProvider recorder.Provider, options leaderelection.Options) (resourcelock.Interface, error)
 	newMetricsListener     func(addr string) (net.Listener, error)
 	newHealthProbeListener func(addr string) (net.Listener, error)
 }
 // NewClientFunc allows a user to define how to create a client
 type NewClientFunc func(cache cache.Cache, config *rest.Config, options client.Options) (client.Client, error)
 // Runnable allows a component to be started.
 // It's very important that Start blocks until
 // it's done running.
 type Runnable interface {
 	// Start starts running the component.  The component will stop running
 	// when the channel is closed.  Start blocks until the channel is closed or
 	// an error occurs.
 	Start(<-chan struct{}) error
 }
 // RunnableFunc implements Runnable using a function.
 // It's very important that the given function block
 // until it's done running.
 type RunnableFunc func(<-chan struct{}) error
 // Start implements Runnable
 func (r RunnableFunc) Start(s <-chan struct{}) error {
 	return r(s)
 }
 // LeaderElectionRunnable knows if a Runnable needs to be run in the leader election mode.
 type LeaderElectionRunnable interface {
 	// NeedLeaderElection returns true if the Runnable needs to be run in the leader election mode.
 	// e.g. controllers need to be run in leader election mode, while webhook server doesn't.
 	NeedLeaderElection() bool
 }
 // New returns a new Manager for creating Controllers.
 func New(config *rest.Config, options Options) (Manager, error) {
 	// Initialize a rest.config if none was specified
 	if config == nil {
 		return nil, fmt.Errorf("must specify Config")
 	}
 	// Set default values for options fields
 	options = setOptionsDefaults(options)
 	// Create the mapper provider
 	mapper, err := options.MapperProvider(config)
 	if err != nil {
 		log.Error(err, "Failed to get API Group-Resources")
 		return nil, err
 	}
 	// Create the cache for the cached read client and registering informers
 	cache, err := options.NewCache(config, cache.Options{Scheme: options.Scheme, Mapper: mapper, Resync: options.SyncPeriod, Namespace: options.Namespace})
 	if err != nil {
 		return nil, err
 	}
 	apiReader, err := client.New(config, client.Options{Scheme: options.Scheme, Mapper: mapper})
 	if err != nil {
 		return nil, err
 	}
 	writeObj, err := options.NewClient(cache, config, client.Options{Scheme: options.Scheme, Mapper: mapper})
 	if err != nil {
 		return nil, err
 	}
 	if options.DryRunClient {
 		writeObj = client.NewDryRunClient(writeObj)
 	}
 	// Create the recorder provider to inject event recorders for the components.
 	// TODO(directxman12): the log for the event provider should have a context (name, tags, etc) specific
 	// to the particular controller that it's being injected into, rather than a generic one like is here.
 	recorderProvider, err := options.newRecorderProvider(config, options.Scheme, log.WithName("events"), options.EventBroadcaster)
 	if err != nil {
 		return nil, err
 	}
 	// Create the resource lock to enable leader election)
 	resourceLock, err := options.newResourceLock(config, recorderProvider, leaderelection.Options{
 		LeaderElection:          options.LeaderElection,
 		LeaderElectionID:        options.LeaderElectionID,
 		LeaderElectionNamespace: options.LeaderElectionNamespace,
 	})
 	if err != nil {
 		return nil, err
 	}
 	// Create the metrics listener. This will throw an error if the metrics bind
 	// address is invalid or already in use.
 	metricsListener, err := options.newMetricsListener(options.MetricsBindAddress)
 	if err != nil {
 		return nil, err
 	}
 	// By default we have no extra endpoints to expose on metrics http server.
 	metricsExtraHandlers := make(map[string]http.Handler)
 	// Create health probes listener. This will throw an error if the bind
 	// address is invalid or already in use.
 	healthProbeListener, err := options.newHealthProbeListener(options.HealthProbeBindAddress)
 	if err != nil {
 		return nil, err
 	}
 	stop := make(chan struct{})
 	return &controllerManager{
 		config:                config,
 		scheme:                options.Scheme,
 		cache:                 cache,
 		fieldIndexes:          cache,
 		client:                writeObj,
 		apiReader:             apiReader,
 		recorderProvider:      recorderProvider,
 		resourceLock:          resourceLock,
 		mapper:                mapper,
 		metricsListener:       metricsListener,
 		metricsExtraHandlers:  metricsExtraHandlers,
 		internalStop:          stop,
 		internalStopper:       stop,
 		elected:               make(chan struct{}),
 		port:                  options.Port,
 		host:                  options.Host,
 		certDir:               options.CertDir,
 		leaseDuration:         *options.LeaseDuration,
 		renewDeadline:         *options.RenewDeadline,
 		retryPeriod:           *options.RetryPeriod,
 		healthProbeListener:   healthProbeListener,
 		readinessEndpointName: options.ReadinessEndpointName,
 		livenessEndpointName:  options.LivenessEndpointName,
 	}, nil
 }
 // defaultNewClient creates the default caching client
 func defaultNewClient(cache cache.Cache, config *rest.Config, options client.Options) (client.Client, error) {
 	// Create the Client for Write operations.
 	c, err := client.New(config, options)
 	if err != nil {
 		return nil, err
 	}
 	return &client.DelegatingClient{
 		Reader: &client.DelegatingReader{
 			CacheReader:  cache,
 			ClientReader: c,
 		},
 		Writer:       c,
 		StatusClient: c,
 	}, nil
 }
 // defaultHealthProbeListener creates the default health probes listener bound to the given address
 func defaultHealthProbeListener(addr string) (net.Listener, error) {
 	if addr == "" || addr == "0" {
 		return nil, nil
 	}
 	ln, err := net.Listen("tcp", addr)
 	if err != nil {
 		return nil, fmt.Errorf("error listening on %s: %v", addr, err)
 	}
 	return ln, nil
 }
 // setOptionsDefaults set default values for Options fields
 func setOptionsDefaults(options Options) Options {
 	// Use the Kubernetes client-go scheme if none is specified
 	if options.Scheme == nil {
 		options.Scheme = scheme.Scheme
 	}
 	if options.MapperProvider == nil {
 		options.MapperProvider = func(c *rest.Config) (meta.RESTMapper, error) {
 			return apiutil.NewDynamicRESTMapper(c)
 		}
 	}
 	// Allow newClient to be mocked
 	if options.NewClient == nil {
 		options.NewClient = defaultNewClient
 	}
 	// Allow newCache to be mocked
 	if options.NewCache == nil {
 		options.NewCache = cache.New
 	}
 	// Allow newRecorderProvider to be mocked
 	if options.newRecorderProvider == nil {
 		options.newRecorderProvider = internalrecorder.NewProvider
 	}
 	// Allow newResourceLock to be mocked
 	if options.newResourceLock == nil {
 		options.newResourceLock = leaderelection.NewResourceLock
 	}
 	if options.newMetricsListener == nil {
 		options.newMetricsListener = metrics.NewListener
 	}
 	leaseDuration, renewDeadline, retryPeriod := defaultLeaseDuration, defaultRenewDeadline, defaultRetryPeriod
 	if options.LeaseDuration == nil {
 		options.LeaseDuration = &leaseDuration
 	}
 	if options.RenewDeadline == nil {
 		options.RenewDeadline = &renewDeadline
 	}
 	if options.RetryPeriod == nil {
 		options.RetryPeriod = &retryPeriod
 	}
 	if options.EventBroadcaster == nil {
 		options.EventBroadcaster = record.NewBroadcaster()
 	}
 	if options.ReadinessEndpointName == "" {
 		options.ReadinessEndpointName = defaultReadinessEndpoint
 	}
 	if options.LivenessEndpointName == "" {
 		options.LivenessEndpointName = defaultLivenessEndpoint
 	}
 	if options.newHealthProbeListener == nil {
 		options.newHealthProbeListener = defaultHealthProbeListener
 	}
 	return options
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/manager/signals/doc.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/manager/signals/doc.go
@ -0,0 +1,20 @@
 /*
 Copyright 2017 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 // Package signals contains libraries for handling signals to gracefully
 // shutdown the manager in combination with Kubernetes pod graceful termination
 // policy.
 package signals
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/manager/signals/signal.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/manager/signals/signal.go
@ -0,0 +1,43 @@
 /*
 Copyright 2017 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package signals
 import (
 	"os"
 	"os/signal"
 )
 var onlyOneSignalHandler = make(chan struct{})
 // SetupSignalHandler registers for SIGTERM and SIGINT. A stop channel is returned
 // which is closed on one of these signals. If a second signal is caught, the program
 // is terminated with exit code 1.
 func SetupSignalHandler() (stopCh <-chan struct{}) {
 	close(onlyOneSignalHandler) // panics when called twice
 	stop := make(chan struct{})
 	c := make(chan os.Signal, 2)
 	signal.Notify(c, shutdownSignals...)
 	go func() {
 		<-c
 		close(stop)
 		<-c
 		os.Exit(1) // second signal. Exit directly.
 	}()
 	return stop
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/manager/signals/signal_posix.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/manager/signals/signal_posix.go
@ -0,0 +1,26 @@
 // +build !windows
 /*
 Copyright 2017 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package signals
 import (
 	"os"
 	"syscall"
 )
 var shutdownSignals = []os.Signal{os.Interrupt, syscall.SIGTERM}
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/manager/signals/signal_windows.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/manager/signals/signal_windows.go
@ -0,0 +1,23 @@
 /*
 Copyright 2017 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package signals
 import (
 	"os"
 )
 var shutdownSignals = []os.Signal{os.Interrupt}
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/metrics/client_go_adapter.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/metrics/client_go_adapter.go
@ -0,0 +1,213 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package metrics
 import (
 	"net/url"
 	"time"
 	"github.com/prometheus/client_golang/prometheus"
 	reflectormetrics "k8s.io/client-go/tools/cache"
 	clientmetrics "k8s.io/client-go/tools/metrics"
 )
 // this file contains setup logic to initialize the myriad of places
 // that client-go registers metrics.  We copy the names and formats
 // from Kubernetes so that we match the core controllers.
 // Metrics subsystem and all of the keys used by the rest client.
 const (
 	RestClientSubsystem = "rest_client"
 	LatencyKey          = "request_latency_seconds"
 	ResultKey           = "requests_total"
 )
 // Metrics subsystem and all keys used by the reflectors.
 const (
 	ReflectorSubsystem     = "reflector"
 	ListsTotalKey          = "lists_total"
 	ListsDurationKey       = "list_duration_seconds"
 	ItemsPerListKey        = "items_per_list"
 	WatchesTotalKey        = "watches_total"
 	ShortWatchesTotalKey   = "short_watches_total"
 	WatchDurationKey       = "watch_duration_seconds"
 	ItemsPerWatchKey       = "items_per_watch"
 	LastResourceVersionKey = "last_resource_version"
 )
 var (
 	// client metrics
 	requestLatency = prometheus.NewHistogramVec(prometheus.HistogramOpts{
 		Subsystem: RestClientSubsystem,
 		Name:      LatencyKey,
 		Help:      "Request latency in seconds. Broken down by verb and URL.",
 		Buckets:   prometheus.ExponentialBuckets(0.001, 2, 10),
 	}, []string{"verb", "url"})
 	requestResult = prometheus.NewCounterVec(prometheus.CounterOpts{
 		Subsystem: RestClientSubsystem,
 		Name:      ResultKey,
 		Help:      "Number of HTTP requests, partitioned by status code, method, and host.",
 	}, []string{"code", "method", "host"})
 	// reflector metrics
 	// TODO(directxman12): update these to be histograms once the metrics overhaul KEP
 	// PRs start landing.
 	listsTotal = prometheus.NewCounterVec(prometheus.CounterOpts{
 		Subsystem: ReflectorSubsystem,
 		Name:      ListsTotalKey,
 		Help:      "Total number of API lists done by the reflectors",
 	}, []string{"name"})
 	listsDuration = prometheus.NewSummaryVec(prometheus.SummaryOpts{
 		Subsystem: ReflectorSubsystem,
 		Name:      ListsDurationKey,
 		Help:      "How long an API list takes to return and decode for the reflectors",
 	}, []string{"name"})
 	itemsPerList = prometheus.NewSummaryVec(prometheus.SummaryOpts{
 		Subsystem: ReflectorSubsystem,
 		Name:      ItemsPerListKey,
 		Help:      "How many items an API list returns to the reflectors",
 	}, []string{"name"})
 	watchesTotal = prometheus.NewCounterVec(prometheus.CounterOpts{
 		Subsystem: ReflectorSubsystem,
 		Name:      WatchesTotalKey,
 		Help:      "Total number of API watches done by the reflectors",
 	}, []string{"name"})
 	shortWatchesTotal = prometheus.NewCounterVec(prometheus.CounterOpts{
 		Subsystem: ReflectorSubsystem,
 		Name:      ShortWatchesTotalKey,
 		Help:      "Total number of short API watches done by the reflectors",
 	}, []string{"name"})
 	watchDuration = prometheus.NewSummaryVec(prometheus.SummaryOpts{
 		Subsystem: ReflectorSubsystem,
 		Name:      WatchDurationKey,
 		Help:      "How long an API watch takes to return and decode for the reflectors",
 	}, []string{"name"})
 	itemsPerWatch = prometheus.NewSummaryVec(prometheus.SummaryOpts{
 		Subsystem: ReflectorSubsystem,
 		Name:      ItemsPerWatchKey,
 		Help:      "How many items an API watch returns to the reflectors",
 	}, []string{"name"})
 	lastResourceVersion = prometheus.NewGaugeVec(prometheus.GaugeOpts{
 		Subsystem: ReflectorSubsystem,
 		Name:      LastResourceVersionKey,
 		Help:      "Last resource version seen for the reflectors",
 	}, []string{"name"})
 )
 func init() {
 	registerClientMetrics()
 	registerReflectorMetrics()
 }
 // registerClientMetrics sets up the client latency metrics from client-go
 func registerClientMetrics() {
 	// register the metrics with our registry
 	Registry.MustRegister(requestLatency)
 	Registry.MustRegister(requestResult)
 	// register the metrics with client-go
 	clientmetrics.Register(clientmetrics.RegisterOpts{
 		RequestLatency: &latencyAdapter{metric: requestLatency},
 		RequestResult:  &resultAdapter{metric: requestResult},
 	})
 }
 // registerReflectorMetrics sets up reflector (reconcile) loop metrics
 func registerReflectorMetrics() {
 	Registry.MustRegister(listsTotal)
 	Registry.MustRegister(listsDuration)
 	Registry.MustRegister(itemsPerList)
 	Registry.MustRegister(watchesTotal)
 	Registry.MustRegister(shortWatchesTotal)
 	Registry.MustRegister(watchDuration)
 	Registry.MustRegister(itemsPerWatch)
 	Registry.MustRegister(lastResourceVersion)
 	reflectormetrics.SetReflectorMetricsProvider(reflectorMetricsProvider{})
 }
 // this section contains adapters, implementations, and other sundry organic, artisanally
 // hand-crafted syntax trees required to convince client-go that it actually wants to let
 // someone use its metrics.
 // Client metrics adapters (method #1 for client-go metrics),
 // copied (more-or-less directly) from k8s.io/kubernetes setup code
 // (which isn't anywhere in an easily-importable place).
 type latencyAdapter struct {
 	metric *prometheus.HistogramVec
 }
 func (l *latencyAdapter) Observe(verb string, u url.URL, latency time.Duration) {
 	l.metric.WithLabelValues(verb, u.String()).Observe(latency.Seconds())
 }
 type resultAdapter struct {
 	metric *prometheus.CounterVec
 }
 func (r *resultAdapter) Increment(code, method, host string) {
 	r.metric.WithLabelValues(code, method, host).Inc()
 }
 // Reflector metrics provider (method #2 for client-go metrics),
 // copied (more-or-less directly) from k8s.io/kubernetes setup code
 // (which isn't anywhere in an easily-importable place).
 type reflectorMetricsProvider struct{}
 func (reflectorMetricsProvider) NewListsMetric(name string) reflectormetrics.CounterMetric {
 	return listsTotal.WithLabelValues(name)
 }
 func (reflectorMetricsProvider) NewListDurationMetric(name string) reflectormetrics.SummaryMetric {
 	return listsDuration.WithLabelValues(name)
 }
 func (reflectorMetricsProvider) NewItemsInListMetric(name string) reflectormetrics.SummaryMetric {
 	return itemsPerList.WithLabelValues(name)
 }
 func (reflectorMetricsProvider) NewWatchesMetric(name string) reflectormetrics.CounterMetric {
 	return watchesTotal.WithLabelValues(name)
 }
 func (reflectorMetricsProvider) NewShortWatchesMetric(name string) reflectormetrics.CounterMetric {
 	return shortWatchesTotal.WithLabelValues(name)
 }
 func (reflectorMetricsProvider) NewWatchDurationMetric(name string) reflectormetrics.SummaryMetric {
 	return watchDuration.WithLabelValues(name)
 }
 func (reflectorMetricsProvider) NewItemsInWatchMetric(name string) reflectormetrics.SummaryMetric {
 	return itemsPerWatch.WithLabelValues(name)
 }
 func (reflectorMetricsProvider) NewLastResourceVersionMetric(name string) reflectormetrics.GaugeMetric {
 	return lastResourceVersion.WithLabelValues(name)
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/metrics/doc.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/metrics/doc.go
@ -0,0 +1,20 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 /*
 Package metrics contains controller related metrics utilities
 */
 package metrics
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/metrics/listener.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/metrics/listener.go
@ -0,0 +1,52 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package metrics
 import (
 	"fmt"
 	"net"
 	logf "sigs.k8s.io/controller-runtime/pkg/internal/log"
 )
 var log = logf.RuntimeLog.WithName("metrics")
 // DefaultBindAddress sets the default bind address for the metrics listener
 // The metrics is on by default.
 var DefaultBindAddress = ":8080"
 // NewListener creates a new TCP listener bound to the given address.
 func NewListener(addr string) (net.Listener, error) {
 	if addr == "" {
 		// If the metrics bind address is empty, default to ":8080"
 		addr = DefaultBindAddress
 	}
 	// Add a case to disable metrics altogether
 	if addr == "0" {
 		return nil, nil
 	}
 	log.Info("metrics server is starting to listen", "addr", addr)
 	ln, err := net.Listen("tcp", addr)
 	if err != nil {
 		er := fmt.Errorf("error listening on %s: %w", addr, err)
 		log.Error(er, "metrics server failed to listen. You may want to disable the metrics server or use another port if it is due to conflicts")
 		return nil, er
 	}
 	return ln, nil
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/metrics/registry.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/metrics/registry.go
@ -0,0 +1,30 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package metrics
 import "github.com/prometheus/client_golang/prometheus"
 // RegistererGatherer combines both parts of the API of a Prometheus
 // registry, both the Registerer and the Gatherer interfaces.
 type RegistererGatherer interface {
 	prometheus.Registerer
 	prometheus.Gatherer
 }
 // Registry is a prometheus registry for storing metrics within the
 // controller-runtime
 var Registry RegistererGatherer = prometheus.NewRegistry()
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/metrics/workqueue.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/metrics/workqueue.go
@ -0,0 +1,130 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package metrics
 import (
 	"github.com/prometheus/client_golang/prometheus"
 	"k8s.io/client-go/util/workqueue"
 )
 // This file is copied and adapted from k8s.io/kubernetes/pkg/util/workqueue/prometheus
 // which registers metrics to the default prometheus Registry. We require very
 // similar functionality, but must register metrics to a different Registry.
 // Metrics subsystem and all keys used by the workqueue.
 const (
 	WorkQueueSubsystem         = "workqueue"
 	DepthKey                   = "depth"
 	AddsKey                    = "adds_total"
 	QueueLatencyKey            = "queue_duration_seconds"
 	WorkDurationKey            = "work_duration_seconds"
 	UnfinishedWorkKey          = "unfinished_work_seconds"
 	LongestRunningProcessorKey = "longest_running_processor_seconds"
 	RetriesKey                 = "retries_total"
 )
 var (
 	depth = prometheus.NewGaugeVec(prometheus.GaugeOpts{
 		Subsystem: WorkQueueSubsystem,
 		Name:      DepthKey,
 		Help:      "Current depth of workqueue",
 	}, []string{"name"})
 	adds = prometheus.NewCounterVec(prometheus.CounterOpts{
 		Subsystem: WorkQueueSubsystem,
 		Name:      AddsKey,
 		Help:      "Total number of adds handled by workqueue",
 	}, []string{"name"})
 	latency = prometheus.NewHistogramVec(prometheus.HistogramOpts{
 		Subsystem: WorkQueueSubsystem,
 		Name:      QueueLatencyKey,
 		Help:      "How long in seconds an item stays in workqueue before being requested",
 		Buckets:   prometheus.ExponentialBuckets(10e-9, 10, 10),
 	}, []string{"name"})
 	workDuration = prometheus.NewHistogramVec(prometheus.HistogramOpts{
 		Subsystem: WorkQueueSubsystem,
 		Name:      WorkDurationKey,
 		Help:      "How long in seconds processing an item from workqueue takes.",
 		Buckets:   prometheus.ExponentialBuckets(10e-9, 10, 10),
 	}, []string{"name"})
 	unfinished = prometheus.NewGaugeVec(prometheus.GaugeOpts{
 		Subsystem: WorkQueueSubsystem,
 		Name:      UnfinishedWorkKey,
 		Help: "How many seconds of work has been done that " +
 			"is in progress and hasn't been observed by work_duration. Large " +
 			"values indicate stuck threads. One can deduce the number of stuck " +
 			"threads by observing the rate at which this increases.",
 	}, []string{"name"})
 	longestRunningProcessor = prometheus.NewGaugeVec(prometheus.GaugeOpts{
 		Subsystem: WorkQueueSubsystem,
 		Name:      LongestRunningProcessorKey,
 		Help: "How many seconds has the longest running " +
 			"processor for workqueue been running.",
 	}, []string{"name"})
 	retries = prometheus.NewCounterVec(prometheus.CounterOpts{
 		Subsystem: WorkQueueSubsystem,
 		Name:      RetriesKey,
 		Help:      "Total number of retries handled by workqueue",
 	}, []string{"name"})
 )
 func init() {
 	Registry.MustRegister(depth)
 	Registry.MustRegister(adds)
 	Registry.MustRegister(latency)
 	Registry.MustRegister(workDuration)
 	Registry.MustRegister(unfinished)
 	Registry.MustRegister(longestRunningProcessor)
 	Registry.MustRegister(retries)
 	workqueue.SetProvider(workqueueMetricsProvider{})
 }
 type workqueueMetricsProvider struct{}
 func (workqueueMetricsProvider) NewDepthMetric(name string) workqueue.GaugeMetric {
 	return depth.WithLabelValues(name)
 }
 func (workqueueMetricsProvider) NewAddsMetric(name string) workqueue.CounterMetric {
 	return adds.WithLabelValues(name)
 }
 func (workqueueMetricsProvider) NewLatencyMetric(name string) workqueue.HistogramMetric {
 	return latency.WithLabelValues(name)
 }
 func (workqueueMetricsProvider) NewWorkDurationMetric(name string) workqueue.HistogramMetric {
 	return workDuration.WithLabelValues(name)
 }
 func (workqueueMetricsProvider) NewUnfinishedWorkSecondsMetric(name string) workqueue.SettableGaugeMetric {
 	return unfinished.WithLabelValues(name)
 }
 func (workqueueMetricsProvider) NewLongestRunningProcessorSecondsMetric(name string) workqueue.SettableGaugeMetric {
 	return longestRunningProcessor.WithLabelValues(name)
 }
 func (workqueueMetricsProvider) NewRetriesMetric(name string) workqueue.CounterMetric {
 	return retries.WithLabelValues(name)
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/predicate/doc.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/predicate/doc.go
@ -0,0 +1,20 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 /*
 Package predicate defines Predicates used by Controllers to filter Events before they are provided to EventHandlers.
 */
 package predicate
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/predicate/predicate.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/predicate/predicate.go
@ -0,0 +1,157 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package predicate
 import (
 	"sigs.k8s.io/controller-runtime/pkg/event"
 	logf "sigs.k8s.io/controller-runtime/pkg/internal/log"
 )
 var log = logf.RuntimeLog.WithName("predicate").WithName("eventFilters")
 // Predicate filters events before enqueuing the keys.
 type Predicate interface {
 	// Create returns true if the Create event should be processed
 	Create(event.CreateEvent) bool
 	// Delete returns true if the Delete event should be processed
 	Delete(event.DeleteEvent) bool
 	// Update returns true if the Update event should be processed
 	Update(event.UpdateEvent) bool
 	// Generic returns true if the Generic event should be processed
 	Generic(event.GenericEvent) bool
 }
 var _ Predicate = Funcs{}
 var _ Predicate = ResourceVersionChangedPredicate{}
 var _ Predicate = GenerationChangedPredicate{}
 // Funcs is a function that implements Predicate.
 type Funcs struct {
 	// Create returns true if the Create event should be processed
 	CreateFunc func(event.CreateEvent) bool
 	// Delete returns true if the Delete event should be processed
 	DeleteFunc func(event.DeleteEvent) bool
 	// Update returns true if the Update event should be processed
 	UpdateFunc func(event.UpdateEvent) bool
 	// Generic returns true if the Generic event should be processed
 	GenericFunc func(event.GenericEvent) bool
 }
 // Create implements Predicate
 func (p Funcs) Create(e event.CreateEvent) bool {
 	if p.CreateFunc != nil {
 		return p.CreateFunc(e)
 	}
 	return true
 }
 // Delete implements Predicate
 func (p Funcs) Delete(e event.DeleteEvent) bool {
 	if p.DeleteFunc != nil {
 		return p.DeleteFunc(e)
 	}
 	return true
 }
 // Update implements Predicate
 func (p Funcs) Update(e event.UpdateEvent) bool {
 	if p.UpdateFunc != nil {
 		return p.UpdateFunc(e)
 	}
 	return true
 }
 // Generic implements Predicate
 func (p Funcs) Generic(e event.GenericEvent) bool {
 	if p.GenericFunc != nil {
 		return p.GenericFunc(e)
 	}
 	return true
 }
 // ResourceVersionChangedPredicate implements a default update predicate function on resource version change
 type ResourceVersionChangedPredicate struct {
 	Funcs
 }
 // Update implements default UpdateEvent filter for validating resource version change
 func (ResourceVersionChangedPredicate) Update(e event.UpdateEvent) bool {
 	if e.MetaOld == nil {
 		log.Error(nil, "UpdateEvent has no old metadata", "event", e)
 		return false
 	}
 	if e.ObjectOld == nil {
 		log.Error(nil, "GenericEvent has no old runtime object to update", "event", e)
 		return false
 	}
 	if e.ObjectNew == nil {
 		log.Error(nil, "GenericEvent has no new runtime object for update", "event", e)
 		return false
 	}
 	if e.MetaNew == nil {
 		log.Error(nil, "UpdateEvent has no new metadata", "event", e)
 		return false
 	}
 	return e.MetaNew.GetResourceVersion() != e.MetaOld.GetResourceVersion()
 }
 // GenerationChangedPredicate implements a default update predicate function on Generation change.
 //
 // This predicate will skip update events that have no change in the object's metadata.generation field.
 // The metadata.generation field of an object is incremented by the API server when writes are made to the spec field of an object.
 // This allows a controller to ignore update events where the spec is unchanged, and only the metadata and/or status fields are changed.
 //
 // For CustomResource objects the Generation is only incremented when the status subresource is enabled.
 //
 // Caveats:
 //
 // * The assumption that the Generation is incremented only on writing to the spec does not hold for all APIs.
 // E.g For Deployment objects the Generation is also incremented on writes to the metadata.annotations field.
 // For object types other than CustomResources be sure to verify which fields will trigger a Generation increment when they are written to.
 //
 // * With this predicate, any update events with writes only to the status field will not be reconciled.
 // So in the event that the status block is overwritten or wiped by someone else the controller will not self-correct to restore the correct status.
 type GenerationChangedPredicate struct {
 	Funcs
 }
 // Update implements default UpdateEvent filter for validating generation change
 func (GenerationChangedPredicate) Update(e event.UpdateEvent) bool {
 	if e.MetaOld == nil {
 		log.Error(nil, "Update event has no old metadata", "event", e)
 		return false
 	}
 	if e.ObjectOld == nil {
 		log.Error(nil, "Update event has no old runtime object to update", "event", e)
 		return false
 	}
 	if e.ObjectNew == nil {
 		log.Error(nil, "Update event has no new runtime object for update", "event", e)
 		return false
 	}
 	if e.MetaNew == nil {
 		log.Error(nil, "Update event has no new metadata", "event", e)
 		return false
 	}
 	return e.MetaNew.GetGeneration() != e.MetaOld.GetGeneration()
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/ratelimiter/doc.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/ratelimiter/doc.go
@ -0,0 +1,22 @@
 /*
 Copyright 2020 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 /*
 Package ratelimiter defines rate limiters used by Controllers to limit how frequently requests may be queued.
 Typical rate limiters that can be used are implemented in client-go's workqueue package.
 */
 package ratelimiter
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/ratelimiter/ratelimiter.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/ratelimiter/ratelimiter.go
@ -0,0 +1,30 @@
 /*
 Copyright 2020 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package ratelimiter
 import "time"
 // RateLimiter is an identical interface of client-go workqueue RateLimiter.
 type RateLimiter interface {
 	// When gets an item and gets to decide how long that item should wait
 	When(item interface{}) time.Duration
 	// Forget indicates that an item is finished being retried.  Doesn't matter whether its for perm failing
 	// or for success, we'll stop tracking it
 	Forget(item interface{})
 	// NumRequeues returns back how many failures the item has had
 	NumRequeues(item interface{}) int
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/reconcile/doc.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/reconcile/doc.go
@ -0,0 +1,21 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 /*
 Package reconcile defines the Reconciler interface  to implement Kubernetes APIs.  Reconciler is provided
 to Controllers at creation time as the API implementation.
 */
 package reconcile
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/reconcile/reconcile.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/reconcile/reconcile.go
@ -0,0 +1,93 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package reconcile
 import (
 	"time"
 	"k8s.io/apimachinery/pkg/types"
 )
 // Result contains the result of a Reconciler invocation.
 type Result struct {
 	// Requeue tells the Controller to requeue the reconcile key.  Defaults to false.
 	Requeue bool
 	// RequeueAfter if greater than 0, tells the Controller to requeue the reconcile key after the Duration.
 	// Implies that Requeue is true, there is no need to set Requeue to true at the same time as RequeueAfter.
 	RequeueAfter time.Duration
 }
 // Request contains the information necessary to reconcile a Kubernetes object.  This includes the
 // information to uniquely identify the object - its Name and Namespace.  It does NOT contain information about
 // any specific Event or the object contents itself.
 type Request struct {
 	// NamespacedName is the name and namespace of the object to reconcile.
 	types.NamespacedName
 }
 /*
 Reconciler implements a Kubernetes API for a specific Resource by Creating, Updating or Deleting Kubernetes
 objects, or by making changes to systems external to the cluster (e.g. cloudproviders, github, etc).
 reconcile implementations compare the state specified in an object by a user against the actual cluster state,
 and then perform operations to make the actual cluster state reflect the state specified by the user.
 Typically, reconcile is triggered by a Controller in response to cluster Events (e.g. Creating, Updating,
 Deleting Kubernetes objects) or external Events (GitHub Webhooks, polling external sources, etc).
 Example reconcile Logic:
 	* Read an object and all the Pods it owns.
 	* Observe that the object spec specifies 5 replicas but actual cluster contains only 1 Pod replica.
 	* Create 4 Pods and set their OwnerReferences to the object.
 reconcile may be implemented as either a type:
 	type reconcile struct {}
 	func (reconcile) reconcile(controller.Request) (controller.Result, error) {
 		// Implement business logic of reading and writing objects here
 		return controller.Result{}, nil
 	}
 Or as a function:
 	controller.Func(func(o controller.Request) (controller.Result, error) {
 		// Implement business logic of reading and writing objects here
 		return controller.Result{}, nil
 	})
 Reconciliation is level-based, meaning action isn't driven off changes in individual Events, but instead is
 driven by actual cluster state read from the apiserver or a local cache.
 For example if responding to a Pod Delete Event, the Request won't contain that a Pod was deleted,
 instead the reconcile function observes this when reading the cluster state and seeing the Pod as missing.
 */
 type Reconciler interface {
 	// Reconciler performs a full reconciliation for the object referred to by the Request.
 	// The Controller will requeue the Request to be processed again if an error is non-nil or
 	// Result.Requeue is true, otherwise upon completion it will remove the work from the queue.
 	Reconcile(Request) (Result, error)
 }
 // Func is a function that implements the reconcile interface.
 type Func func(Request) (Result, error)
 var _ Reconciler = Func(nil)
 // Reconcile implements Reconciler.
 func (r Func) Reconcile(o Request) (Result, error) { return r(o) }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/recorder/recorder.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/recorder/recorder.go
@ -0,0 +1,31 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 // Package recorder defines interfaces for working with Kubernetes event recorders.
 //
 // You can use these to emit Kubernetes events associated with a particular Kubernetes
 // object.
 package recorder
 import (
 	"k8s.io/client-go/tools/record"
 )
 // Provider knows how to generate new event recorders with given name.
 type Provider interface {
 	// NewRecorder returns an EventRecorder with given name.
 	GetEventRecorderFor(name string) record.EventRecorder
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/runtime/inject/doc.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/runtime/inject/doc.go
@ -0,0 +1,22 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 /*
 Package inject defines interfaces and functions for propagating dependencies from a ControllerManager to
 the components registered with it.  Dependencies are propagated to Reconciler, Source, EventHandler and Predicate
 objects which implement the Injectable interfaces.
 */
 package inject
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/runtime/inject/inject.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/runtime/inject/inject.go
@ -0,0 +1,162 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package inject
 import (
 	"github.com/go-logr/logr"
 	"k8s.io/apimachinery/pkg/api/meta"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/client-go/rest"
 	"sigs.k8s.io/controller-runtime/pkg/cache"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 )
 // Cache is used by the ControllerManager to inject Cache into Sources, EventHandlers, Predicates, and
 // Reconciles
 type Cache interface {
 	InjectCache(cache cache.Cache) error
 }
 // CacheInto will set informers on i and return the result if it implements Cache.  Returns
 //// false if i does not implement Cache.
 func CacheInto(c cache.Cache, i interface{}) (bool, error) {
 	if s, ok := i.(Cache); ok {
 		return true, s.InjectCache(c)
 	}
 	return false, nil
 }
 // APIReader is used by the Manager to inject the APIReader into necessary types.
 type APIReader interface {
 	InjectAPIReader(client.Reader) error
 }
 // APIReaderInto will set APIReader on i and return the result if it implements APIReaderInto.
 // Returns false if i does not implement APIReader
 func APIReaderInto(reader client.Reader, i interface{}) (bool, error) {
 	if s, ok := i.(APIReader); ok {
 		return true, s.InjectAPIReader(reader)
 	}
 	return false, nil
 }
 // Config is used by the ControllerManager to inject Config into Sources, EventHandlers, Predicates, and
 // Reconciles
 type Config interface {
 	InjectConfig(*rest.Config) error
 }
 // ConfigInto will set config on i and return the result if it implements Config.  Returns
 //// false if i does not implement Config.
 func ConfigInto(config *rest.Config, i interface{}) (bool, error) {
 	if s, ok := i.(Config); ok {
 		return true, s.InjectConfig(config)
 	}
 	return false, nil
 }
 // Client is used by the ControllerManager to inject client into Sources, EventHandlers, Predicates, and
 // Reconciles
 type Client interface {
 	InjectClient(client.Client) error
 }
 // ClientInto will set client on i and return the result if it implements Client. Returns
 // false if i does not implement Client.
 func ClientInto(client client.Client, i interface{}) (bool, error) {
 	if s, ok := i.(Client); ok {
 		return true, s.InjectClient(client)
 	}
 	return false, nil
 }
 // Scheme is used by the ControllerManager to inject Scheme into Sources, EventHandlers, Predicates, and
 // Reconciles
 type Scheme interface {
 	InjectScheme(scheme *runtime.Scheme) error
 }
 // SchemeInto will set scheme and return the result on i if it implements Scheme.  Returns
 // false if i does not implement Scheme.
 func SchemeInto(scheme *runtime.Scheme, i interface{}) (bool, error) {
 	if is, ok := i.(Scheme); ok {
 		return true, is.InjectScheme(scheme)
 	}
 	return false, nil
 }
 // Stoppable is used by the ControllerManager to inject stop channel into Sources,
 // EventHandlers, Predicates, and Reconciles.
 type Stoppable interface {
 	InjectStopChannel(<-chan struct{}) error
 }
 // StopChannelInto will set stop channel on i and return the result if it implements Stoppable.
 // Returns false if i does not implement Stoppable.
 func StopChannelInto(stop <-chan struct{}, i interface{}) (bool, error) {
 	if s, ok := i.(Stoppable); ok {
 		return true, s.InjectStopChannel(stop)
 	}
 	return false, nil
 }
 // Mapper is used to inject the rest mapper to components that may need it
 type Mapper interface {
 	InjectMapper(meta.RESTMapper) error
 }
 // MapperInto will set the rest mapper on i and return the result if it implements Mapper.
 // Returns false if i does not implement Mapper.
 func MapperInto(mapper meta.RESTMapper, i interface{}) (bool, error) {
 	if m, ok := i.(Mapper); ok {
 		return true, m.InjectMapper(mapper)
 	}
 	return false, nil
 }
 // Func injects dependencies into i.
 type Func func(i interface{}) error
 // Injector is used by the ControllerManager to inject Func into Controllers
 type Injector interface {
 	InjectFunc(f Func) error
 }
 // InjectorInto will set f and return the result on i if it implements Injector.  Returns
 // false if i does not implement Injector.
 func InjectorInto(f Func, i interface{}) (bool, error) {
 	if ii, ok := i.(Injector); ok {
 		return true, ii.InjectFunc(f)
 	}
 	return false, nil
 }
 // Logger is used to inject Loggers into components that need them
 // and don't otherwise have opinions.
 type Logger interface {
 	InjectLogger(l logr.Logger) error
 }
 // LoggerInto will set the logger on the given object if it implements inject.Logger,
 // returning true if a InjectLogger was called, and false otherwise.
 func LoggerInto(l logr.Logger, i interface{}) (bool, error) {
 	if injectable, wantsLogger := i.(Logger); wantsLogger {
 		return true, injectable.InjectLogger(l)
 	}
 	return false, nil
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/source/doc.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/source/doc.go
@ -0,0 +1,22 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 /*
 Package source provides event streams to hook up to Controllers with Controller.Watch.  Events are
 used with handler.EventHandlers to enqueue reconcile.Requests and trigger Reconciles for Kubernetes
 objects.
 */
 package source
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/source/internal/eventsource.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/source/internal/eventsource.go
@ -0,0 +1,177 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package internal
 import (
 	"fmt"
 	"k8s.io/apimachinery/pkg/api/meta"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/client-go/tools/cache"
 	"k8s.io/client-go/util/workqueue"
 	"sigs.k8s.io/controller-runtime/pkg/event"
 	"sigs.k8s.io/controller-runtime/pkg/handler"
 	logf "sigs.k8s.io/controller-runtime/pkg/internal/log"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"sigs.k8s.io/controller-runtime/pkg/predicate"
 )
 var log = logf.RuntimeLog.WithName("source").WithName("EventHandler")
 var _ cache.ResourceEventHandler = EventHandler{}
 // EventHandler adapts a handler.EventHandler interface to a cache.ResourceEventHandler interface
 type EventHandler struct {
 	EventHandler handler.EventHandler
 	Queue        workqueue.RateLimitingInterface
 	Predicates   []predicate.Predicate
 }
 // OnAdd creates CreateEvent and calls Create on EventHandler
 func (e EventHandler) OnAdd(obj interface{}) {
 	c := event.CreateEvent{}
 	// Pull metav1.Object out of the object
 	if o, err := meta.Accessor(obj); err == nil {
 		c.Meta = o
 	} else {
 		log.Error(err, "OnAdd missing Meta",
 			"object", obj, "type", fmt.Sprintf("%T", obj))
 		return
 	}
 	// Pull the runtime.Object out of the object
 	if o, ok := obj.(runtime.Object); ok {
 		c.Object = o
 	} else {
 		log.Error(nil, "OnAdd missing runtime.Object",
 			"object", obj, "type", fmt.Sprintf("%T", obj))
 		return
 	}
 	for _, p := range e.Predicates {
 		if !p.Create(c) {
 			return
 		}
 	}
 	// Invoke create handler
 	e.EventHandler.Create(c, e.Queue)
 }
 // OnUpdate creates UpdateEvent and calls Update on EventHandler
 func (e EventHandler) OnUpdate(oldObj, newObj interface{}) {
 	u := event.UpdateEvent{}
 	// Pull metav1.Object out of the object
 	if o, err := meta.Accessor(oldObj); err == nil {
 		u.MetaOld = o
 	} else {
 		log.Error(err, "OnUpdate missing MetaOld",
 			"object", oldObj, "type", fmt.Sprintf("%T", oldObj))
 		return
 	}
 	// Pull the runtime.Object out of the object
 	if o, ok := oldObj.(runtime.Object); ok {
 		u.ObjectOld = o
 	} else {
 		log.Error(nil, "OnUpdate missing ObjectOld",
 			"object", oldObj, "type", fmt.Sprintf("%T", oldObj))
 		return
 	}
 	// Pull metav1.Object out of the object
 	if o, err := meta.Accessor(newObj); err == nil {
 		u.MetaNew = o
 	} else {
 		log.Error(err, "OnUpdate missing MetaNew",
 			"object", newObj, "type", fmt.Sprintf("%T", newObj))
 		return
 	}
 	// Pull the runtime.Object out of the object
 	if o, ok := newObj.(runtime.Object); ok {
 		u.ObjectNew = o
 	} else {
 		log.Error(nil, "OnUpdate missing ObjectNew",
 			"object", oldObj, "type", fmt.Sprintf("%T", oldObj))
 		return
 	}
 	for _, p := range e.Predicates {
 		if !p.Update(u) {
 			return
 		}
 	}
 	// Invoke update handler
 	e.EventHandler.Update(u, e.Queue)
 }
 // OnDelete creates DeleteEvent and calls Delete on EventHandler
 func (e EventHandler) OnDelete(obj interface{}) {
 	d := event.DeleteEvent{}
 	// Deal with tombstone events by pulling the object out.  Tombstone events wrap the object in a
 	// DeleteFinalStateUnknown struct, so the object needs to be pulled out.
 	// Copied from sample-controller
 	// This should never happen if we aren't missing events, which we have concluded that we are not
 	// and made decisions off of this belief.  Maybe this shouldn't be here?
 	var ok bool
 	if _, ok = obj.(metav1.Object); !ok {
 		// If the object doesn't have Metadata, assume it is a tombstone object of type DeletedFinalStateUnknown
 		tombstone, ok := obj.(cache.DeletedFinalStateUnknown)
 		if !ok {
 			log.Error(nil, "Error decoding objects.  Expected cache.DeletedFinalStateUnknown",
 				"type", fmt.Sprintf("%T", obj),
 				"object", obj)
 			return
 		}
 		// Set obj to the tombstone obj
 		obj = tombstone.Obj
 	}
 	// Pull metav1.Object out of the object
 	if o, err := meta.Accessor(obj); err == nil {
 		d.Meta = o
 	} else {
 		log.Error(err, "OnDelete missing Meta",
 			"object", obj, "type", fmt.Sprintf("%T", obj))
 		return
 	}
 	// Pull the runtime.Object out of the object
 	if o, ok := obj.(runtime.Object); ok {
 		d.Object = o
 	} else {
 		log.Error(nil, "OnDelete missing runtime.Object",
 			"object", obj, "type", fmt.Sprintf("%T", obj))
 		return
 	}
 	for _, p := range e.Predicates {
 		if !p.Delete(d) {
 			return
 		}
 	}
 	// Invoke delete handler
 	e.EventHandler.Delete(d, e.Queue)
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/source/source.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/source/source.go
@ -0,0 +1,297 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package source
 import (
 	"context"
 	"fmt"
 	"sync"
 	"k8s.io/apimachinery/pkg/api/meta"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/client-go/util/workqueue"
 	"sigs.k8s.io/controller-runtime/pkg/event"
 	"sigs.k8s.io/controller-runtime/pkg/handler"
 	logf "sigs.k8s.io/controller-runtime/pkg/internal/log"
 	"sigs.k8s.io/controller-runtime/pkg/runtime/inject"
 	"sigs.k8s.io/controller-runtime/pkg/source/internal"
 	"sigs.k8s.io/controller-runtime/pkg/cache"
 	"sigs.k8s.io/controller-runtime/pkg/predicate"
 )
 var log = logf.RuntimeLog.WithName("source")
 const (
 	// defaultBufferSize is the default number of event notifications that can be buffered.
 	defaultBufferSize = 1024
 )
 // Source is a source of events (eh.g. Create, Update, Delete operations on Kubernetes Objects, Webhook callbacks, etc)
 // which should be processed by event.EventHandlers to enqueue reconcile.Requests.
 //
 // * Use Kind for events originating in the cluster (e.g. Pod Create, Pod Update, Deployment Update).
 //
 // * Use Channel for events originating outside the cluster (eh.g. GitHub Webhook callback, Polling external urls).
 //
 // Users may build their own Source implementations.  If their implementations implement any of the inject package
 // interfaces, the dependencies will be injected by the Controller when Watch is called.
 type Source interface {
 	// Start is internal and should be called only by the Controller to register an EventHandler with the Informer
 	// to enqueue reconcile.Requests.
 	Start(handler.EventHandler, workqueue.RateLimitingInterface, ...predicate.Predicate) error
 }
 // NewKindWithCache creates a Source without InjectCache, so that it is assured that the given cache is used
 // and not overwritten. It can be used to watch objects in a different cluster by passing the cache
 // from that other cluster
 func NewKindWithCache(object runtime.Object, cache cache.Cache) Source {
 	return &kindWithCache{kind: Kind{Type: object, cache: cache}}
 }
 type kindWithCache struct {
 	kind Kind
 }
 func (ks *kindWithCache) Start(handler handler.EventHandler, queue workqueue.RateLimitingInterface,
 	prct ...predicate.Predicate) error {
 	return ks.kind.Start(handler, queue, prct...)
 }
 // Kind is used to provide a source of events originating inside the cluster from Watches (e.g. Pod Create)
 type Kind struct {
 	// Type is the type of object to watch.  e.g. &v1.Pod{}
 	Type runtime.Object
 	// cache used to watch APIs
 	cache cache.Cache
 }
 var _ Source = &Kind{}
 // Start is internal and should be called only by the Controller to register an EventHandler with the Informer
 // to enqueue reconcile.Requests.
 func (ks *Kind) Start(handler handler.EventHandler, queue workqueue.RateLimitingInterface,
 	prct ...predicate.Predicate) error {
 	// Type should have been specified by the user.
 	if ks.Type == nil {
 		return fmt.Errorf("must specify Kind.Type")
 	}
 	// cache should have been injected before Start was called
 	if ks.cache == nil {
 		return fmt.Errorf("must call CacheInto on Kind before calling Start")
 	}
 	// Lookup the Informer from the Cache and add an EventHandler which populates the Queue
 	i, err := ks.cache.GetInformer(context.TODO(), ks.Type)
 	if err != nil {
 		if kindMatchErr, ok := err.(*meta.NoKindMatchError); ok {
 			log.Error(err, "if kind is a CRD, it should be installed before calling Start",
 				"kind", kindMatchErr.GroupKind)
 		}
 		return err
 	}
 	i.AddEventHandler(internal.EventHandler{Queue: queue, EventHandler: handler, Predicates: prct})
 	return nil
 }
 func (ks *Kind) String() string {
 	if ks.Type != nil && ks.Type.GetObjectKind() != nil {
 		return fmt.Sprintf("kind source: %v", ks.Type.GetObjectKind().GroupVersionKind().String())
 	}
 	return fmt.Sprintf("kind source: unknown GVK")
 }
 var _ inject.Cache = &Kind{}
 // InjectCache is internal should be called only by the Controller.  InjectCache is used to inject
 // the Cache dependency initialized by the ControllerManager.
 func (ks *Kind) InjectCache(c cache.Cache) error {
 	if ks.cache == nil {
 		ks.cache = c
 	}
 	return nil
 }
 var _ Source = &Channel{}
 // Channel is used to provide a source of events originating outside the cluster
 // (e.g. GitHub Webhook callback).  Channel requires the user to wire the external
 // source (eh.g. http handler) to write GenericEvents to the underlying channel.
 type Channel struct {
 	// once ensures the event distribution goroutine will be performed only once
 	once sync.Once
 	// Source is the source channel to fetch GenericEvents
 	Source <-chan event.GenericEvent
 	// stop is to end ongoing goroutine, and close the channels
 	stop <-chan struct{}
 	// dest is the destination channels of the added event handlers
 	dest []chan event.GenericEvent
 	// DestBufferSize is the specified buffer size of dest channels.
 	// Default to 1024 if not specified.
 	DestBufferSize int
 	// destLock is to ensure the destination channels are safely added/removed
 	destLock sync.Mutex
 }
 func (cs *Channel) String() string {
 	return fmt.Sprintf("channel source: %p", cs)
 }
 var _ inject.Stoppable = &Channel{}
 // InjectStopChannel is internal should be called only by the Controller.
 // It is used to inject the stop channel initialized by the ControllerManager.
 func (cs *Channel) InjectStopChannel(stop <-chan struct{}) error {
 	if cs.stop == nil {
 		cs.stop = stop
 	}
 	return nil
 }
 // Start implements Source and should only be called by the Controller.
 func (cs *Channel) Start(
 	handler handler.EventHandler,
 	queue workqueue.RateLimitingInterface,
 	prct ...predicate.Predicate) error {
 	// Source should have been specified by the user.
 	if cs.Source == nil {
 		return fmt.Errorf("must specify Channel.Source")
 	}
 	// stop should have been injected before Start was called
 	if cs.stop == nil {
 		return fmt.Errorf("must call InjectStop on Channel before calling Start")
 	}
 	// use default value if DestBufferSize not specified
 	if cs.DestBufferSize == 0 {
 		cs.DestBufferSize = defaultBufferSize
 	}
 	cs.once.Do(func() {
 		// Distribute GenericEvents to all EventHandler / Queue pairs Watching this source
 		go cs.syncLoop()
 	})
 	dst := make(chan event.GenericEvent, cs.DestBufferSize)
 	go func() {
 		for evt := range dst {
 			shouldHandle := true
 			for _, p := range prct {
 				if !p.Generic(evt) {
 					shouldHandle = false
 					break
 				}
 			}
 			if shouldHandle {
 				handler.Generic(evt, queue)
 			}
 		}
 	}()
 	cs.destLock.Lock()
 	defer cs.destLock.Unlock()
 	cs.dest = append(cs.dest, dst)
 	return nil
 }
 func (cs *Channel) doStop() {
 	cs.destLock.Lock()
 	defer cs.destLock.Unlock()
 	for _, dst := range cs.dest {
 		close(dst)
 	}
 }
 func (cs *Channel) distribute(evt event.GenericEvent) {
 	cs.destLock.Lock()
 	defer cs.destLock.Unlock()
 	for _, dst := range cs.dest {
 		// We cannot make it under goroutine here, or we'll meet the
 		// race condition of writing message to closed channels.
 		// To avoid blocking, the dest channels are expected to be of
 		// proper buffer size. If we still see it blocked, then
 		// the controller is thought to be in an abnormal state.
 		dst <- evt
 	}
 }
 func (cs *Channel) syncLoop() {
 	for {
 		select {
 		case <-cs.stop:
 			// Close destination channels
 			cs.doStop()
 			return
 		case evt := <-cs.Source:
 			cs.distribute(evt)
 		}
 	}
 }
 // Informer is used to provide a source of events originating inside the cluster from Watches (e.g. Pod Create)
 type Informer struct {
 	// Informer is the controller-runtime Informer
 	Informer cache.Informer
 }
 var _ Source = &Informer{}
 // Start is internal and should be called only by the Controller to register an EventHandler with the Informer
 // to enqueue reconcile.Requests.
 func (is *Informer) Start(handler handler.EventHandler, queue workqueue.RateLimitingInterface,
 	prct ...predicate.Predicate) error {
 	// Informer should have been specified by the user.
 	if is.Informer == nil {
 		return fmt.Errorf("must specify Informer.Informer")
 	}
 	is.Informer.AddEventHandler(internal.EventHandler{Queue: queue, EventHandler: handler, Predicates: prct})
 	return nil
 }
 func (is *Informer) String() string {
 	return fmt.Sprintf("informer source: %p", is.Informer)
 }
 // Func is a function that implements Source
 type Func func(handler.EventHandler, workqueue.RateLimitingInterface, ...predicate.Predicate) error
 // Start implements Source
 func (f Func) Start(evt handler.EventHandler, queue workqueue.RateLimitingInterface,
 	pr ...predicate.Predicate) error {
 	return f(evt, queue, pr...)
 }
 func (f Func) String() string {
 	return fmt.Sprintf("func source: %p", f)
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/webhook/admission/decode.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/webhook/admission/decode.go
@ -0,0 +1,76 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
   http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package admission
 import (
 	"fmt"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/apimachinery/pkg/util/json"
 )
 // Decoder knows how to decode the contents of an admission
 // request into a concrete object.
 type Decoder struct {
 	codecs serializer.CodecFactory
 }
 // NewDecoder creates a Decoder given the runtime.Scheme
 func NewDecoder(scheme *runtime.Scheme) (*Decoder, error) {
 	return &Decoder{codecs: serializer.NewCodecFactory(scheme)}, nil
 }
 // Decode decodes the inlined object in the AdmissionRequest into the passed-in runtime.Object.
 // If you want decode the OldObject in the AdmissionRequest, use DecodeRaw.
 // It errors out if req.Object.Raw is empty i.e. containing 0 raw bytes.
 func (d *Decoder) Decode(req Request, into runtime.Object) error {
 	// we error out if rawObj is an empty object.
 	if len(req.Object.Raw) == 0 {
 		return fmt.Errorf("there is no content to decode")
 	}
 	return d.DecodeRaw(req.Object, into)
 }
 // DecodeRaw decodes a RawExtension object into the passed-in runtime.Object.
 // It errors out if rawObj is empty i.e. containing 0 raw bytes.
 func (d *Decoder) DecodeRaw(rawObj runtime.RawExtension, into runtime.Object) error {
 	// NB(directxman12): there's a bug/weird interaction between decoders and
 	// the API server where the API server doesn't send a GVK on the embedded
 	// objects, which means the unstructured decoder refuses to decode.  It
 	// also means we can't pass the unstructured directly in, since it'll try
 	// and call unstructured's special Unmarshal implementation, which calls
 	// back into that same decoder :-/
 	// See kubernetes/kubernetes#74373.
 	// we error out if rawObj is an empty object.
 	if len(rawObj.Raw) == 0 {
 		return fmt.Errorf("there is no content to decode")
 	}
 	if unstructuredInto, isUnstructured := into.(*unstructured.Unstructured); isUnstructured {
 		// unmarshal into unstructured's underlying object to avoid calling the decoder
 		if err := json.Unmarshal(rawObj.Raw, &unstructuredInto.Object); err != nil {
 			return err
 		}
 		return nil
 	}
 	deserializer := d.codecs.UniversalDeserializer()
 	return runtime.DecodeInto(deserializer, rawObj.Raw, into)
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/webhook/admission/defaulter.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/webhook/admission/defaulter.go
@ -0,0 +1,75 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package admission
 import (
 	"context"
 	"encoding/json"
 	"net/http"
 	"k8s.io/apimachinery/pkg/runtime"
 )
 // Defaulter defines functions for setting defaults on resources
 type Defaulter interface {
 	runtime.Object
 	Default()
 }
 // DefaultingWebhookFor creates a new Webhook for Defaulting the provided type.
 func DefaultingWebhookFor(defaulter Defaulter) *Webhook {
 	return &Webhook{
 		Handler: &mutatingHandler{defaulter: defaulter},
 	}
 }
 type mutatingHandler struct {
 	defaulter Defaulter
 	decoder   *Decoder
 }
 var _ DecoderInjector = &mutatingHandler{}
 // InjectDecoder injects the decoder into a mutatingHandler.
 func (h *mutatingHandler) InjectDecoder(d *Decoder) error {
 	h.decoder = d
 	return nil
 }
 // Handle handles admission requests.
 func (h *mutatingHandler) Handle(ctx context.Context, req Request) Response {
 	if h.defaulter == nil {
 		panic("defaulter should never be nil")
 	}
 	// Get the object in the request
 	obj := h.defaulter.DeepCopyObject().(Defaulter)
 	err := h.decoder.Decode(req, obj)
 	if err != nil {
 		return Errored(http.StatusBadRequest, err)
 	}
 	// Default the object
 	obj.Default()
 	marshalled, err := json.Marshal(obj)
 	if err != nil {
 		return Errored(http.StatusInternalServerError, err)
 	}
 	// Create the patch
 	return PatchResponseFromRaw(req.Object.Raw, marshalled)
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/webhook/admission/doc.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/webhook/admission/doc.go
@ -0,0 +1,28 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 /*
 Package admission provides implementation for admission webhook and methods to implement admission webhook handlers.
 See examples/mutatingwebhook.go and examples/validatingwebhook.go for examples of admission webhooks.
 */
 package admission
 import (
 	logf "sigs.k8s.io/controller-runtime/pkg/internal/log"
 )
 var log = logf.RuntimeLog.WithName("admission")
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/webhook/admission/http.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/webhook/admission/http.go
@ -0,0 +1,104 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package admission
 import (
 	"encoding/json"
 	"errors"
 	"fmt"
 	"io"
 	"io/ioutil"
 	"net/http"
 	"k8s.io/api/admission/v1beta1"
 	admissionv1beta1 "k8s.io/api/admission/v1beta1"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/serializer"
 	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
 )
 var admissionScheme = runtime.NewScheme()
 var admissionCodecs = serializer.NewCodecFactory(admissionScheme)
 func init() {
 	utilruntime.Must(admissionv1beta1.AddToScheme(admissionScheme))
 }
 var _ http.Handler = &Webhook{}
 func (wh *Webhook) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	var body []byte
 	var err error
 	var reviewResponse Response
 	if r.Body != nil {
 		if body, err = ioutil.ReadAll(r.Body); err != nil {
 			wh.log.Error(err, "unable to read the body from the incoming request")
 			reviewResponse = Errored(http.StatusBadRequest, err)
 			wh.writeResponse(w, reviewResponse)
 			return
 		}
 	} else {
 		err = errors.New("request body is empty")
 		wh.log.Error(err, "bad request")
 		reviewResponse = Errored(http.StatusBadRequest, err)
 		wh.writeResponse(w, reviewResponse)
 		return
 	}
 	// verify the content type is accurate
 	contentType := r.Header.Get("Content-Type")
 	if contentType != "application/json" {
 		err = fmt.Errorf("contentType=%s, expected application/json", contentType)
 		wh.log.Error(err, "unable to process a request with an unknown content type", "content type", contentType)
 		reviewResponse = Errored(http.StatusBadRequest, err)
 		wh.writeResponse(w, reviewResponse)
 		return
 	}
 	req := Request{}
 	ar := v1beta1.AdmissionReview{
 		// avoid an extra copy
 		Request: &req.AdmissionRequest,
 	}
 	if _, _, err := admissionCodecs.UniversalDeserializer().Decode(body, nil, &ar); err != nil {
 		wh.log.Error(err, "unable to decode the request")
 		reviewResponse = Errored(http.StatusBadRequest, err)
 		wh.writeResponse(w, reviewResponse)
 		return
 	}
 	wh.log.V(1).Info("received request", "UID", req.UID, "kind", req.Kind, "resource", req.Resource)
 	// TODO: add panic-recovery for Handle
 	reviewResponse = wh.Handle(r.Context(), req)
 	wh.writeResponse(w, reviewResponse)
 }
 func (wh *Webhook) writeResponse(w io.Writer, response Response) {
 	encoder := json.NewEncoder(w)
 	responseAdmissionReview := v1beta1.AdmissionReview{
 		Response: &response.AdmissionResponse,
 	}
 	err := encoder.Encode(responseAdmissionReview)
 	if err != nil {
 		wh.log.Error(err, "unable to encode the response")
 		wh.writeResponse(w, Errored(http.StatusInternalServerError, err))
 	} else {
 		res := responseAdmissionReview.Response
 		wh.log.V(1).Info("wrote response", "UID", res.UID, "allowed", res.Allowed, "result", res.Result)
 	}
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/webhook/admission/inject.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/webhook/admission/inject.go
@ -0,0 +1,31 @@
 /*
 Copyright 2019 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package admission
 // DecoderInjector is used by the ControllerManager to inject decoder into webhook handlers.
 type DecoderInjector interface {
 	InjectDecoder(*Decoder) error
 }
 // InjectDecoderInto will set decoder on i and return the result if it implements Decoder.  Returns
 // false if i does not implement Decoder.
 func InjectDecoderInto(decoder *Decoder, i interface{}) (bool, error) {
 	if s, ok := i.(DecoderInjector); ok {
 		return true, s.InjectDecoder(decoder)
 	}
 	return false, nil
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/webhook/admission/multi.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/webhook/admission/multi.go
@ -0,0 +1,126 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
   http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package admission
 import (
 	"context"
 	"encoding/json"
 	"fmt"
 	"net/http"
 	"gomodules.xyz/jsonpatch/v2"
 	admissionv1beta1 "k8s.io/api/admission/v1beta1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"sigs.k8s.io/controller-runtime/pkg/runtime/inject"
 )
 type multiMutating []Handler
 func (hs multiMutating) Handle(ctx context.Context, req Request) Response {
 	patches := []jsonpatch.JsonPatchOperation{}
 	for _, handler := range hs {
 		resp := handler.Handle(ctx, req)
 		if !resp.Allowed {
 			return resp
 		}
 		if resp.PatchType != nil && *resp.PatchType != admissionv1beta1.PatchTypeJSONPatch {
 			return Errored(http.StatusInternalServerError,
 				fmt.Errorf("unexpected patch type returned by the handler: %v, only allow: %v",
 					resp.PatchType, admissionv1beta1.PatchTypeJSONPatch))
 		}
 		patches = append(patches, resp.Patches...)
 	}
 	var err error
 	marshaledPatch, err := json.Marshal(patches)
 	if err != nil {
 		return Errored(http.StatusBadRequest, fmt.Errorf("error when marshaling the patch: %w", err))
 	}
 	return Response{
 		AdmissionResponse: admissionv1beta1.AdmissionResponse{
 			Allowed: true,
 			Result: &metav1.Status{
 				Code: http.StatusOK,
 			},
 			Patch:     marshaledPatch,
 			PatchType: func() *admissionv1beta1.PatchType { pt := admissionv1beta1.PatchTypeJSONPatch; return &pt }(),
 		},
 	}
 }
 // InjectFunc injects the field setter into the handlers.
 func (hs multiMutating) InjectFunc(f inject.Func) error {
 	// inject directly into the handlers.  It would be more correct
 	// to do this in a sync.Once in Handle (since we don't have some
 	// other start/finalize-type method), but it's more efficient to
 	// do it here, presumably.
 	for _, handler := range hs {
 		if err := f(handler); err != nil {
 			return err
 		}
 	}
 	return nil
 }
 // MultiMutatingHandler combines multiple mutating webhook handlers into a single
 // mutating webhook handler.  Handlers are called in sequential order, and the first
 // `allowed: false`	response may short-circuit the rest.  Users must take care to
 // ensure patches are disjoint.
 func MultiMutatingHandler(handlers ...Handler) Handler {
 	return multiMutating(handlers)
 }
 type multiValidating []Handler
 func (hs multiValidating) Handle(ctx context.Context, req Request) Response {
 	for _, handler := range hs {
 		resp := handler.Handle(ctx, req)
 		if !resp.Allowed {
 			return resp
 		}
 	}
 	return Response{
 		AdmissionResponse: admissionv1beta1.AdmissionResponse{
 			Allowed: true,
 			Result: &metav1.Status{
 				Code: http.StatusOK,
 			},
 		},
 	}
 }
 // MultiValidatingHandler combines multiple validating webhook handlers into a single
 // validating webhook handler.  Handlers are called in sequential order, and the first
 // `allowed: false`	response may short-circuit the rest.
 func MultiValidatingHandler(handlers ...Handler) Handler {
 	return multiValidating(handlers)
 }
 // InjectFunc injects the field setter into the handlers.
 func (hs multiValidating) InjectFunc(f inject.Func) error {
 	// inject directly into the handlers.  It would be more correct
 	// to do this in a sync.Once in Handle (since we don't have some
 	// other start/finalize-type method), but it's more efficient to
 	// do it here, presumably.
 	for _, handler := range hs {
 		if err := f(handler); err != nil {
 			return err
 		}
 	}
 	return nil
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/webhook/admission/response.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/webhook/admission/response.go
@ -0,0 +1,98 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
   http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package admission
 import (
 	"net/http"
 	"gomodules.xyz/jsonpatch/v2"
 	admissionv1beta1 "k8s.io/api/admission/v1beta1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )
 // Allowed constructs a response indicating that the given operation
 // is allowed (without any patches).
 func Allowed(reason string) Response {
 	return ValidationResponse(true, reason)
 }
 // Denied constructs a response indicating that the given operation
 // is not allowed.
 func Denied(reason string) Response {
 	return ValidationResponse(false, reason)
 }
 // Patched constructs a response indicating that the given operation is
 // allowed, and that the target object should be modified by the given
 // JSONPatch operations.
 func Patched(reason string, patches ...jsonpatch.JsonPatchOperation) Response {
 	resp := Allowed(reason)
 	resp.Patches = patches
 	return resp
 }
 // Errored creates a new Response for error-handling a request.
 func Errored(code int32, err error) Response {
 	return Response{
 		AdmissionResponse: admissionv1beta1.AdmissionResponse{
 			Allowed: false,
 			Result: &metav1.Status{
 				Code:    code,
 				Message: err.Error(),
 			},
 		},
 	}
 }
 // ValidationResponse returns a response for admitting a request.
 func ValidationResponse(allowed bool, reason string) Response {
 	code := http.StatusForbidden
 	if allowed {
 		code = http.StatusOK
 	}
 	resp := Response{
 		AdmissionResponse: admissionv1beta1.AdmissionResponse{
 			Allowed: allowed,
 			Result: &metav1.Status{
 				Code: int32(code),
 			},
 		},
 	}
 	if len(reason) > 0 {
 		resp.Result.Reason = metav1.StatusReason(reason)
 	}
 	return resp
 }
 // PatchResponseFromRaw takes 2 byte arrays and returns a new response with json patch.
 // The original object should be passed in as raw bytes to avoid the roundtripping problem
 // described in https://github.com/kubernetes-sigs/kubebuilder/issues/510.
 func PatchResponseFromRaw(original, current []byte) Response {
 	patches, err := jsonpatch.CreatePatch(original, current)
 	if err != nil {
 		return Errored(http.StatusInternalServerError, err)
 	}
 	return Response{
 		Patches: patches,
 		AdmissionResponse: admissionv1beta1.AdmissionResponse{
 			Allowed:   true,
 			PatchType: func() *admissionv1beta1.PatchType { pt := admissionv1beta1.PatchTypeJSONPatch; return &pt }(),
 		},
 	}
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/webhook/admission/validator.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/webhook/admission/validator.go
@ -0,0 +1,108 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package admission
 import (
 	"context"
 	"net/http"
 	"k8s.io/api/admission/v1beta1"
 	"k8s.io/apimachinery/pkg/runtime"
 )
 // Validator defines functions for validating an operation
 type Validator interface {
 	runtime.Object
 	ValidateCreate() error
 	ValidateUpdate(old runtime.Object) error
 	ValidateDelete() error
 }
 // ValidatingWebhookFor creates a new Webhook for validating the provided type.
 func ValidatingWebhookFor(validator Validator) *Webhook {
 	return &Webhook{
 		Handler: &validatingHandler{validator: validator},
 	}
 }
 type validatingHandler struct {
 	validator Validator
 	decoder   *Decoder
 }
 var _ DecoderInjector = &validatingHandler{}
 // InjectDecoder injects the decoder into a validatingHandler.
 func (h *validatingHandler) InjectDecoder(d *Decoder) error {
 	h.decoder = d
 	return nil
 }
 // Handle handles admission requests.
 func (h *validatingHandler) Handle(ctx context.Context, req Request) Response {
 	if h.validator == nil {
 		panic("validator should never be nil")
 	}
 	// Get the object in the request
 	obj := h.validator.DeepCopyObject().(Validator)
 	if req.Operation == v1beta1.Create {
 		err := h.decoder.Decode(req, obj)
 		if err != nil {
 			return Errored(http.StatusBadRequest, err)
 		}
 		err = obj.ValidateCreate()
 		if err != nil {
 			return Denied(err.Error())
 		}
 	}
 	if req.Operation == v1beta1.Update {
 		oldObj := obj.DeepCopyObject()
 		err := h.decoder.DecodeRaw(req.Object, obj)
 		if err != nil {
 			return Errored(http.StatusBadRequest, err)
 		}
 		err = h.decoder.DecodeRaw(req.OldObject, oldObj)
 		if err != nil {
 			return Errored(http.StatusBadRequest, err)
 		}
 		err = obj.ValidateUpdate(oldObj)
 		if err != nil {
 			return Denied(err.Error())
 		}
 	}
 	if req.Operation == v1beta1.Delete {
 		// In reference to PR: https://github.com/kubernetes/kubernetes/pull/76346
 		// OldObject contains the object being deleted
 		err := h.decoder.DecodeRaw(req.OldObject, obj)
 		if err != nil {
 			return Errored(http.StatusBadRequest, err)
 		}
 		err = obj.ValidateDelete()
 		if err != nil {
 			return Denied(err.Error())
 		}
 	}
 	return Allowed("")
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/webhook/admission/webhook.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/webhook/admission/webhook.go
@ -0,0 +1,200 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
   http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package admission
 import (
 	"context"
 	"errors"
 	"net/http"
 	"github.com/go-logr/logr"
 	"gomodules.xyz/jsonpatch/v2"
 	admissionv1beta1 "k8s.io/api/admission/v1beta1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/util/json"
 	"sigs.k8s.io/controller-runtime/pkg/runtime/inject"
 )
 var (
 	errUnableToEncodeResponse = errors.New("unable to encode response")
 )
 // Request defines the input for an admission handler.
 // It contains information to identify the object in
 // question (group, version, kind, resource, subresource,
 // name, namespace), as well as the operation in question
 // (e.g. Get, Create, etc), and the object itself.
 type Request struct {
 	admissionv1beta1.AdmissionRequest
 }
 // Response is the output of an admission handler.
 // It contains a response indicating if a given
 // operation is allowed, as well as a set of patches
 // to mutate the object in the case of a mutating admission handler.
 type Response struct {
 	// Patches are the JSON patches for mutating webhooks.
 	// Using this instead of setting Response.Patch to minimize
 	// overhead of serialization and deserialization.
 	// Patches set here will override any patches in the response,
 	// so leave this empty if you want to set the patch response directly.
 	Patches []jsonpatch.JsonPatchOperation
 	// AdmissionResponse is the raw admission response.
 	// The Patch field in it will be overwritten by the listed patches.
 	admissionv1beta1.AdmissionResponse
 }
 // Complete populates any fields that are yet to be set in
 // the underlying AdmissionResponse, It mutates the response.
 func (r *Response) Complete(req Request) error {
 	r.UID = req.UID
 	// ensure that we have a valid status code
 	if r.Result == nil {
 		r.Result = &metav1.Status{}
 	}
 	if r.Result.Code == 0 {
 		r.Result.Code = http.StatusOK
 	}
 	// TODO(directxman12): do we need to populate this further, and/or
 	// is code actually necessary (the same webhook doesn't use it)
 	if len(r.Patches) == 0 {
 		return nil
 	}
 	var err error
 	r.Patch, err = json.Marshal(r.Patches)
 	if err != nil {
 		return err
 	}
 	patchType := admissionv1beta1.PatchTypeJSONPatch
 	r.PatchType = &patchType
 	return nil
 }
 // Handler can handle an AdmissionRequest.
 type Handler interface {
 	// Handle yields a response to an AdmissionRequest.
 	//
 	// The supplied context is extracted from the received http.Request, allowing wrapping
 	// http.Handlers to inject values into and control cancelation of downstream request processing.
 	Handle(context.Context, Request) Response
 }
 // HandlerFunc implements Handler interface using a single function.
 type HandlerFunc func(context.Context, Request) Response
 var _ Handler = HandlerFunc(nil)
 // Handle process the AdmissionRequest by invoking the underlying function.
 func (f HandlerFunc) Handle(ctx context.Context, req Request) Response {
 	return f(ctx, req)
 }
 // Webhook represents each individual webhook.
 type Webhook struct {
 	// Handler actually processes an admission request returning whether it was allowed or denied,
 	// and potentially patches to apply to the handler.
 	Handler Handler
 	// decoder is constructed on receiving a scheme and passed down to then handler
 	decoder *Decoder
 	log logr.Logger
 }
 // InjectLogger gets a handle to a logging instance, hopefully with more info about this particular webhook.
 func (w *Webhook) InjectLogger(l logr.Logger) error {
 	w.log = l
 	return nil
 }
 // Handle processes AdmissionRequest.
 // If the webhook is mutating type, it delegates the AdmissionRequest to each handler and merge the patches.
 // If the webhook is validating type, it delegates the AdmissionRequest to each handler and
 // deny the request if anyone denies.
 func (w *Webhook) Handle(ctx context.Context, req Request) Response {
 	resp := w.Handler.Handle(ctx, req)
 	if err := resp.Complete(req); err != nil {
 		w.log.Error(err, "unable to encode response")
 		return Errored(http.StatusInternalServerError, errUnableToEncodeResponse)
 	}
 	return resp
 }
 // InjectScheme injects a scheme into the webhook, in order to construct a Decoder.
 func (w *Webhook) InjectScheme(s *runtime.Scheme) error {
 	// TODO(directxman12): we should have a better way to pass this down
 	var err error
 	w.decoder, err = NewDecoder(s)
 	if err != nil {
 		return err
 	}
 	// inject the decoder here too, just in case the order of calling this is not
 	// scheme first, then inject func
 	if w.Handler != nil {
 		if _, err := InjectDecoderInto(w.GetDecoder(), w.Handler); err != nil {
 			return err
 		}
 	}
 	return nil
 }
 // GetDecoder returns a decoder to decode the objects embedded in admission requests.
 // It may be nil if we haven't received a scheme to use to determine object types yet.
 func (w *Webhook) GetDecoder() *Decoder {
 	return w.decoder
 }
 // InjectFunc injects the field setter into the webhook.
 func (w *Webhook) InjectFunc(f inject.Func) error {
 	// inject directly into the handlers.  It would be more correct
 	// to do this in a sync.Once in Handle (since we don't have some
 	// other start/finalize-type method), but it's more efficient to
 	// do it here, presumably.
 	// also inject a decoder, and wrap this so that we get a setFields
 	// that injects a decoder (hopefully things don't ignore the duplicate
 	// InjectorInto call).
 	var setFields inject.Func
 	setFields = func(target interface{}) error {
 		if err := f(target); err != nil {
 			return err
 		}
 		if _, err := inject.InjectorInto(setFields, target); err != nil {
 			return err
 		}
 		if _, err := InjectDecoderInto(w.GetDecoder(), target); err != nil {
 			return err
 		}
 		return nil
 	}
 	return setFields(w.Handler)
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/webhook/alias.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/webhook/alias.go
@ -0,0 +1,73 @@
 /*
 Copyright 2019 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package webhook
 import (
 	"gomodules.xyz/jsonpatch/v2"
 	"sigs.k8s.io/controller-runtime/pkg/webhook/admission"
 )
 // define some aliases for common bits of the webhook functionality
 // Defaulter defines functions for setting defaults on resources
 type Defaulter = admission.Defaulter
 // Validator defines functions for validating an operation
 type Validator = admission.Validator
 // AdmissionRequest defines the input for an admission handler.
 // It contains information to identify the object in
 // question (group, version, kind, resource, subresource,
 // name, namespace), as well as the operation in question
 // (e.g. Get, Create, etc), and the object itself.
 type AdmissionRequest = admission.Request
 // AdmissionResponse is the output of an admission handler.
 // It contains a response indicating if a given
 // operation is allowed, as well as a set of patches
 // to mutate the object in the case of a mutating admission handler.
 type AdmissionResponse = admission.Response
 // Admission is webhook suitable for registration with the server
 // an admission webhook that validates API operations and potentially
 // mutates their contents.
 type Admission = admission.Webhook
 // AdmissionHandler knows how to process admission requests, validating them,
 // and potentially mutating the objects they contain.
 type AdmissionHandler = admission.Handler
 // AdmissionDecoder knows how to decode objects from admission requests.
 type AdmissionDecoder = admission.Decoder
 // JSONPatchOp represents a single JSONPatch patch operation.
 type JSONPatchOp = jsonpatch.Operation
 var (
 	// Allowed indicates that the admission request should be allowed for the given reason.
 	Allowed = admission.Allowed
 	// Denied indicates that the admission request should be denied for the given reason.
 	Denied = admission.Denied
 	// Patched indicates that the admission request should be allowed for the given reason,
 	// and that the contained object should be mutated using the given patches.
 	Patched = admission.Patched
 	// Errored indicates that an error occurred in the admission request.
 	Errored = admission.Errored
 )
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/webhook/doc.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/webhook/doc.go
@ -0,0 +1,28 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 /*
 Package webhook provides methods to build and bootstrap a webhook server.
 Currently, it only supports admission webhooks. It will support CRD conversion webhooks in the near future.
 */
 package webhook
 import (
 	logf "sigs.k8s.io/controller-runtime/pkg/internal/log"
 )
 var log = logf.RuntimeLog.WithName("webhook")
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/webhook/internal/certwatcher/certwatcher.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/webhook/internal/certwatcher/certwatcher.go
@ -0,0 +1,162 @@
 /*
 Copyright 2019 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package certwatcher
 import (
 	"crypto/tls"
 	"sync"
 	"gopkg.in/fsnotify.v1"
 	logf "sigs.k8s.io/controller-runtime/pkg/internal/log"
 )
 var log = logf.RuntimeLog.WithName("certwatcher")
 // CertWatcher watches certificate and key files for changes.  When either file
 // changes, it reads and parses both and calls an optional callback with the new
 // certificate.
 type CertWatcher struct {
 	sync.Mutex
 	currentCert *tls.Certificate
 	watcher     *fsnotify.Watcher
 	certPath string
 	keyPath  string
 }
 // New returns a new CertWatcher watching the given certificate and key.
 func New(certPath, keyPath string) (*CertWatcher, error) {
 	var err error
 	cw := &CertWatcher{
 		certPath: certPath,
 		keyPath:  keyPath,
 	}
 	// Initial read of certificate and key.
 	if err := cw.ReadCertificate(); err != nil {
 		return nil, err
 	}
 	cw.watcher, err = fsnotify.NewWatcher()
 	if err != nil {
 		return nil, err
 	}
 	return cw, nil
 }
 // GetCertificate fetches the currently loaded certificate, which may be nil.
 func (cw *CertWatcher) GetCertificate(_ *tls.ClientHelloInfo) (*tls.Certificate, error) {
 	cw.Lock()
 	defer cw.Unlock()
 	return cw.currentCert, nil
 }
 // Start starts the watch on the certificate and key files.
 func (cw *CertWatcher) Start(stopCh <-chan struct{}) error {
 	files := []string{cw.certPath, cw.keyPath}
 	for _, f := range files {
 		if err := cw.watcher.Add(f); err != nil {
 			return err
 		}
 	}
 	go cw.Watch()
 	log.Info("Starting certificate watcher")
 	// Block until the stop channel is closed.
 	<-stopCh
 	return cw.watcher.Close()
 }
 // Watch reads events from the watcher's channel and reacts to changes.
 func (cw *CertWatcher) Watch() {
 	for {
 		select {
 		case event, ok := <-cw.watcher.Events:
 			// Channel is closed.
 			if !ok {
 				return
 			}
 			cw.handleEvent(event)
 		case err, ok := <-cw.watcher.Errors:
 			// Channel is closed.
 			if !ok {
 				return
 			}
 			log.Error(err, "certificate watch error")
 		}
 	}
 }
 // ReadCertificate reads the certificate and key files from disk, parses them,
 // and updates the current certificate on the watcher.  If a callback is set, it
 // is invoked with the new certificate.
 func (cw *CertWatcher) ReadCertificate() error {
 	cert, err := tls.LoadX509KeyPair(cw.certPath, cw.keyPath)
 	if err != nil {
 		return err
 	}
 	cw.Lock()
 	cw.currentCert = &cert
 	cw.Unlock()
 	log.Info("Updated current TLS certificate")
 	return nil
 }
 func (cw *CertWatcher) handleEvent(event fsnotify.Event) {
 	// Only care about events which may modify the contents of the file.
 	if !(isWrite(event) || isRemove(event) || isCreate(event)) {
 		return
 	}
 	log.V(1).Info("certificate event", "event", event)
 	// If the file was removed, re-add the watch.
 	if isRemove(event) {
 		if err := cw.watcher.Add(event.Name); err != nil {
 			log.Error(err, "error re-watching file")
 		}
 	}
 	if err := cw.ReadCertificate(); err != nil {
 		log.Error(err, "error re-reading certificate")
 	}
 }
 func isWrite(event fsnotify.Event) bool {
 	return event.Op&fsnotify.Write == fsnotify.Write
 }
 func isCreate(event fsnotify.Event) bool {
 	return event.Op&fsnotify.Create == fsnotify.Create
 }
 func isRemove(event fsnotify.Event) bool {
 	return event.Op&fsnotify.Remove == fsnotify.Remove
 }
--- a/vendor/sigs.k8s.io/controller-runtime/pkg/webhook/internal/metrics/metrics.go
+++ b/vendor/sigs.k8s.io/controller-runtime/pkg/webhook/internal/metrics/metrics.go
@ -0,0 +1,40 @@
 /*
 Copyright 2018 The Kubernetes Authors.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
 package metrics
 import (
 	"github.com/prometheus/client_golang/prometheus"
 	"sigs.k8s.io/controller-runtime/pkg/metrics"
 )
 var (
 	// RequestLatency is a prometheus metric which is a histogram of the latency
 	// of processing admission requests.
 	RequestLatency = prometheus.NewHistogramVec(
 		prometheus.HistogramOpts{
 			Name: "controller_runtime_webhook_latency_seconds",
 			Help: "Histogram of the latency of processing admission requests",
 		},
 		[]string{"webhook"},
 	)
 )
 func init() {
 	metrics.Registry.MustRegister(
 		RequestLatency)
 }
--- a/Show More
+++ b/Show More