From f9c4b52af2a53bc0182ecde4380976df0f1e92cf Mon Sep 17 00:00:00 2001 From: Karol Wychowaniec Date: Thu, 22 Feb 2018 15:14:36 +0100 Subject: [PATCH 1/2] Introduce External Metrics API --- staging/BUILD | 1 + .../metrics/pkg/apis/external_metrics/BUILD | 40 +++++++++++++ .../metrics/pkg/apis/external_metrics/doc.go | 19 ++++++ .../pkg/apis/external_metrics/install/BUILD | 32 ++++++++++ .../apis/external_metrics/install/install.go | 43 +++++++++++++ .../pkg/apis/external_metrics/register.go | 51 ++++++++++++++++ .../pkg/apis/external_metrics/types.go | 60 +++++++++++++++++++ .../pkg/apis/external_metrics/v1beta1/BUILD | 39 ++++++++++++ .../pkg/apis/external_metrics/v1beta1/doc.go | 21 +++++++ .../apis/external_metrics/v1beta1/register.go | 49 +++++++++++++++ .../apis/external_metrics/v1beta1/types.go | 60 +++++++++++++++++++ 11 files changed, 415 insertions(+) create mode 100644 staging/src/k8s.io/metrics/pkg/apis/external_metrics/BUILD create mode 100644 staging/src/k8s.io/metrics/pkg/apis/external_metrics/doc.go create mode 100644 staging/src/k8s.io/metrics/pkg/apis/external_metrics/install/BUILD create mode 100644 staging/src/k8s.io/metrics/pkg/apis/external_metrics/install/install.go create mode 100644 staging/src/k8s.io/metrics/pkg/apis/external_metrics/register.go create mode 100644 staging/src/k8s.io/metrics/pkg/apis/external_metrics/types.go create mode 100644 staging/src/k8s.io/metrics/pkg/apis/external_metrics/v1beta1/BUILD create mode 100644 staging/src/k8s.io/metrics/pkg/apis/external_metrics/v1beta1/doc.go create mode 100644 staging/src/k8s.io/metrics/pkg/apis/external_metrics/v1beta1/register.go create mode 100644 staging/src/k8s.io/metrics/pkg/apis/external_metrics/v1beta1/types.go diff --git a/staging/BUILD b/staging/BUILD index ed1965fc2bb..b64dc4676ee 100644 --- a/staging/BUILD +++ b/staging/BUILD @@ -217,6 +217,7 @@ filegroup( "//staging/src/k8s.io/code-generator/third_party/forked/golang/reflect:all-srcs", "//staging/src/k8s.io/kube-aggregator:all-srcs", "//staging/src/k8s.io/metrics/pkg/apis/custom_metrics:all-srcs", + "//staging/src/k8s.io/metrics/pkg/apis/external_metrics:all-srcs", "//staging/src/k8s.io/metrics/pkg/apis/metrics:all-srcs", "//staging/src/k8s.io/metrics/pkg/client/clientset_generated/clientset:all-srcs", "//staging/src/k8s.io/metrics/pkg/client/custom_metrics:all-srcs", diff --git a/staging/src/k8s.io/metrics/pkg/apis/external_metrics/BUILD b/staging/src/k8s.io/metrics/pkg/apis/external_metrics/BUILD new file mode 100644 index 00000000000..e728e0c7c0b --- /dev/null +++ b/staging/src/k8s.io/metrics/pkg/apis/external_metrics/BUILD @@ -0,0 +1,40 @@ +package(default_visibility = ["//visibility:public"]) + +load( + "@io_bazel_rules_go//go:def.bzl", + "go_library", +) + +go_library( + name = "go_default_library", + srcs = [ + "doc.go", + "register.go", + "types.go", + "zz_generated.deepcopy.go", + ], + importpath = "k8s.io/metrics/pkg/apis/external_metrics", + deps = [ + "//vendor/k8s.io/apimachinery/pkg/api/resource:go_default_library", + "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library", + "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library", + "//vendor/k8s.io/apimachinery/pkg/runtime/schema:go_default_library", + ], +) + +filegroup( + name = "package-srcs", + srcs = glob(["**"]), + tags = ["automanaged"], + visibility = ["//visibility:private"], +) + +filegroup( + name = "all-srcs", + srcs = [ + ":package-srcs", + "//staging/src/k8s.io/metrics/pkg/apis/external_metrics/install:all-srcs", + "//staging/src/k8s.io/metrics/pkg/apis/external_metrics/v1beta1:all-srcs", + ], + tags = ["automanaged"], +) diff --git a/staging/src/k8s.io/metrics/pkg/apis/external_metrics/doc.go b/staging/src/k8s.io/metrics/pkg/apis/external_metrics/doc.go new file mode 100644 index 00000000000..c450a1e3b64 --- /dev/null +++ b/staging/src/k8s.io/metrics/pkg/apis/external_metrics/doc.go @@ -0,0 +1,19 @@ +/* +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. +*/ + +// +k8s:deepcopy-gen=package +// +groupName=external.metrics.k8s.io +package external_metrics diff --git a/staging/src/k8s.io/metrics/pkg/apis/external_metrics/install/BUILD b/staging/src/k8s.io/metrics/pkg/apis/external_metrics/install/BUILD new file mode 100644 index 00000000000..df63ba222fb --- /dev/null +++ b/staging/src/k8s.io/metrics/pkg/apis/external_metrics/install/BUILD @@ -0,0 +1,32 @@ +package(default_visibility = ["//visibility:public"]) + +load( + "@io_bazel_rules_go//go:def.bzl", + "go_library", +) + +go_library( + name = "go_default_library", + srcs = ["install.go"], + importpath = "k8s.io/metrics/pkg/apis/external_metrics/install", + deps = [ + "//vendor/k8s.io/apimachinery/pkg/apimachinery/announced:go_default_library", + "//vendor/k8s.io/apimachinery/pkg/apimachinery/registered:go_default_library", + "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library", + "//vendor/k8s.io/metrics/pkg/apis/external_metrics:go_default_library", + "//vendor/k8s.io/metrics/pkg/apis/external_metrics/v1beta1:go_default_library", + ], +) + +filegroup( + name = "package-srcs", + srcs = glob(["**"]), + tags = ["automanaged"], + visibility = ["//visibility:private"], +) + +filegroup( + name = "all-srcs", + srcs = [":package-srcs"], + tags = ["automanaged"], +) diff --git a/staging/src/k8s.io/metrics/pkg/apis/external_metrics/install/install.go b/staging/src/k8s.io/metrics/pkg/apis/external_metrics/install/install.go new file mode 100644 index 00000000000..6effb7f3e3e --- /dev/null +++ b/staging/src/k8s.io/metrics/pkg/apis/external_metrics/install/install.go @@ -0,0 +1,43 @@ +/* +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 install installs the experimental API group, making it available as +// an option to all of the API encoding/decoding machinery. +package install + +import ( + "k8s.io/apimachinery/pkg/apimachinery/announced" + "k8s.io/apimachinery/pkg/apimachinery/registered" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/metrics/pkg/apis/external_metrics" + "k8s.io/metrics/pkg/apis/external_metrics/v1beta1" +) + +// Install registers the API group and adds types to a scheme +func Install(groupFactoryRegistry announced.APIGroupFactoryRegistry, registry *registered.APIRegistrationManager, scheme *runtime.Scheme) { + if err := announced.NewGroupMetaFactory( + &announced.GroupMetaFactoryArgs{ + GroupName: external_metrics.GroupName, + VersionPreferenceOrder: []string{v1beta1.SchemeGroupVersion.Version}, + AddInternalObjectsToScheme: external_metrics.AddToScheme, + }, + announced.VersionToSchemeFunc{ + v1beta1.SchemeGroupVersion.Version: v1beta1.AddToScheme, + }, + ).Announce(groupFactoryRegistry).RegisterAndEnable(registry, scheme); err != nil { + panic(err) + } +} diff --git a/staging/src/k8s.io/metrics/pkg/apis/external_metrics/register.go b/staging/src/k8s.io/metrics/pkg/apis/external_metrics/register.go new file mode 100644 index 00000000000..33dca86c9ae --- /dev/null +++ b/staging/src/k8s.io/metrics/pkg/apis/external_metrics/register.go @@ -0,0 +1,51 @@ +/* +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 external_metrics + +import ( + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" +) + +// GroupName is the group name use in this package +const GroupName = "external.metrics.k8s.io" + +// SchemeGroupVersion is group version used to register these objects +var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: runtime.APIVersionInternal} + +// Kind takes an unqualified kind and returns back a Group qualified GroupKind +func Kind(kind string) schema.GroupKind { + return SchemeGroupVersion.WithKind(kind).GroupKind() +} + +// Resource takes an unqualified resource and returns back a Group qualified GroupResource +func Resource(resource string) schema.GroupResource { + return SchemeGroupVersion.WithResource(resource).GroupResource() +} + +var ( + SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes) + AddToScheme = SchemeBuilder.AddToScheme +) + +func addKnownTypes(scheme *runtime.Scheme) error { + scheme.AddKnownTypes(SchemeGroupVersion, + &ExternalMetricValue{}, + &ExternalMetricValueList{}, + ) + return nil +} diff --git a/staging/src/k8s.io/metrics/pkg/apis/external_metrics/types.go b/staging/src/k8s.io/metrics/pkg/apis/external_metrics/types.go new file mode 100644 index 00000000000..2a9c6e3923d --- /dev/null +++ b/staging/src/k8s.io/metrics/pkg/apis/external_metrics/types.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 external_metrics + +import ( + "k8s.io/apimachinery/pkg/api/resource" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" +) + +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + +// a list of values for a given metric for some set labels +type ExternalMetricValueList struct { + metav1.TypeMeta `json:",inline"` + metav1.ListMeta `json:"metadata,omitempty"` + + // value of the metric matching a given set of labels + Items []ExternalMetricValue `json:"items"` +} + +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + +// a metric value for external metric +// A single metric value is identified by metric name and a set of string labels. +// For one metric there can be multiple values with different sets of labels. +type ExternalMetricValue struct { + metav1.TypeMeta `json:",inline"` + + // the name of the metric + MetricName string `json:"metricName"` + + // a set of labels that identify a single time series for the metric + MetricLabels map[string]string `json:"metricLabels"` + + // indicates the time at which the metrics were produced + Timestamp metav1.Time `json:"timestamp"` + + // indicates the window ([Timestamp-Window, Timestamp]) from + // which these metrics were calculated, when returning rate + // metrics calculated from cumulative metrics (or zero for + // non-calculated instantaneous metrics). + WindowSeconds *int64 `json:"window,omitempty"` + + // the value of the metric + Value resource.Quantity `json:"value"` +} diff --git a/staging/src/k8s.io/metrics/pkg/apis/external_metrics/v1beta1/BUILD b/staging/src/k8s.io/metrics/pkg/apis/external_metrics/v1beta1/BUILD new file mode 100644 index 00000000000..888f2610f0d --- /dev/null +++ b/staging/src/k8s.io/metrics/pkg/apis/external_metrics/v1beta1/BUILD @@ -0,0 +1,39 @@ +package(default_visibility = ["//visibility:public"]) + +load( + "@io_bazel_rules_go//go:def.bzl", + "go_library", +) + +go_library( + name = "go_default_library", + srcs = [ + "doc.go", + "register.go", + "types.go", + "zz_generated.conversion.go", + "zz_generated.deepcopy.go", + ], + importpath = "k8s.io/metrics/pkg/apis/external_metrics/v1beta1", + deps = [ + "//vendor/k8s.io/apimachinery/pkg/api/resource:go_default_library", + "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library", + "//vendor/k8s.io/apimachinery/pkg/conversion:go_default_library", + "//vendor/k8s.io/apimachinery/pkg/runtime:go_default_library", + "//vendor/k8s.io/apimachinery/pkg/runtime/schema:go_default_library", + "//vendor/k8s.io/metrics/pkg/apis/external_metrics:go_default_library", + ], +) + +filegroup( + name = "package-srcs", + srcs = glob(["**"]), + tags = ["automanaged"], + visibility = ["//visibility:private"], +) + +filegroup( + name = "all-srcs", + srcs = [":package-srcs"], + tags = ["automanaged"], +) diff --git a/staging/src/k8s.io/metrics/pkg/apis/external_metrics/v1beta1/doc.go b/staging/src/k8s.io/metrics/pkg/apis/external_metrics/v1beta1/doc.go new file mode 100644 index 00000000000..70acd67cd69 --- /dev/null +++ b/staging/src/k8s.io/metrics/pkg/apis/external_metrics/v1beta1/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. +*/ + +// +k8s:deepcopy-gen=package +// +k8s:conversion-gen=k8s.io/metrics/pkg/apis/external_metrics +// +k8s:openapi-gen=true + +package v1beta1 diff --git a/staging/src/k8s.io/metrics/pkg/apis/external_metrics/v1beta1/register.go b/staging/src/k8s.io/metrics/pkg/apis/external_metrics/v1beta1/register.go new file mode 100644 index 00000000000..83f1e9e6121 --- /dev/null +++ b/staging/src/k8s.io/metrics/pkg/apis/external_metrics/v1beta1/register.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 v1beta1 + +import ( + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/runtime" + "k8s.io/apimachinery/pkg/runtime/schema" +) + +// GroupName is the group name use in this package +const GroupName = "external.metrics.k8s.io" + +// SchemeGroupVersion is group version used to register these objects +var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1beta1"} + +// Resource takes an unqualified resource and returns a Group qualified GroupResource +func Resource(resource string) schema.GroupResource { + return SchemeGroupVersion.WithResource(resource).GroupResource() +} + +var ( + SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes) + localSchemeBuilder = &SchemeBuilder + AddToScheme = localSchemeBuilder.AddToScheme +) + +func addKnownTypes(scheme *runtime.Scheme) error { + scheme.AddKnownTypes(SchemeGroupVersion, + &ExternalMetricValue{}, + &ExternalMetricValueList{}, + ) + metav1.AddToGroupVersion(scheme, SchemeGroupVersion) + return nil +} diff --git a/staging/src/k8s.io/metrics/pkg/apis/external_metrics/v1beta1/types.go b/staging/src/k8s.io/metrics/pkg/apis/external_metrics/v1beta1/types.go new file mode 100644 index 00000000000..edf78ed43d2 --- /dev/null +++ b/staging/src/k8s.io/metrics/pkg/apis/external_metrics/v1beta1/types.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 v1beta1 + +import ( + "k8s.io/apimachinery/pkg/api/resource" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" +) + +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + +// a list of values for a given metric for some set labels +type ExternalMetricValueList struct { + metav1.TypeMeta `json:",inline"` + metav1.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"` + + // value of the metric matching a given set of labels + Items []ExternalMetricValue `json:"items" protobuf:"bytes,2,rep,name=items"` +} + +// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object + +// a metric value for external metric +// A single metric value is identified by metric name and a set of string labels. +// For one metric there can be multiple values with different sets of labels. +type ExternalMetricValue struct { + metav1.TypeMeta `json:",inline"` + + // the name of the metric + MetricName string `json:"metricName" protobuf:"bytes,1,name=metricName"` + + // a set of labels that identify a single time series for the metric + MetricLabels map[string]string `json:"metricLabels" protobuf:"bytes,2,rep,name=metricLabels"` + + // indicates the time at which the metrics were produced + Timestamp metav1.Time `json:"timestamp" protobuf:"bytes,3,name=timestamp"` + + // indicates the window ([Timestamp-Window, Timestamp]) from + // which these metrics were calculated, when returning rate + // metrics calculated from cumulative metrics (or zero for + // non-calculated instantaneous metrics). + WindowSeconds *int64 `json:"window,omitempty" protobuf:"bytes,4,opt,name=window"` + + // the value of the metric + Value resource.Quantity `json:"value" protobuf:"bytes,5,name=value"` +} From e375f3607ddb0b74f23aa0cc30f9fa19e270baeb Mon Sep 17 00:00:00 2001 From: Karol Wychowaniec Date: Thu, 22 Feb 2018 15:16:15 +0100 Subject: [PATCH 2/2] Include generated files --- hack/.golint_failures | 2 + hack/update-generated-protobuf-dockerized.sh | 1 + pkg/generated/openapi/BUILD | 1 + .../pkg/apis/external_metrics/v1beta1/BUILD | 8 + .../external_metrics/v1beta1/generated.pb.go | 823 ++++++++++++++++++ .../external_metrics/v1beta1/generated.proto | 63 ++ .../v1beta1/zz_generated.conversion.go | 94 ++ .../v1beta1/zz_generated.deepcopy.go | 103 +++ .../external_metrics/zz_generated.deepcopy.go | 103 +++ 9 files changed, 1198 insertions(+) create mode 100644 staging/src/k8s.io/metrics/pkg/apis/external_metrics/v1beta1/generated.pb.go create mode 100644 staging/src/k8s.io/metrics/pkg/apis/external_metrics/v1beta1/generated.proto create mode 100644 staging/src/k8s.io/metrics/pkg/apis/external_metrics/v1beta1/zz_generated.conversion.go create mode 100644 staging/src/k8s.io/metrics/pkg/apis/external_metrics/v1beta1/zz_generated.deepcopy.go create mode 100644 staging/src/k8s.io/metrics/pkg/apis/external_metrics/zz_generated.deepcopy.go diff --git a/hack/.golint_failures b/hack/.golint_failures index c977aaf6a5d..cc8d8024f56 100644 --- a/hack/.golint_failures +++ b/hack/.golint_failures @@ -728,6 +728,8 @@ staging/src/k8s.io/kube-aggregator/pkg/registry/apiservice staging/src/k8s.io/kube-aggregator/pkg/registry/apiservice/etcd staging/src/k8s.io/metrics/pkg/apis/custom_metrics staging/src/k8s.io/metrics/pkg/apis/custom_metrics/v1beta1 +staging/src/k8s.io/metrics/pkg/apis/external_metrics +staging/src/k8s.io/metrics/pkg/apis/external_metrics/v1beta1 staging/src/k8s.io/metrics/pkg/apis/metrics staging/src/k8s.io/metrics/pkg/apis/metrics/v1alpha1 staging/src/k8s.io/metrics/pkg/apis/metrics/v1beta1 diff --git a/hack/update-generated-protobuf-dockerized.sh b/hack/update-generated-protobuf-dockerized.sh index cb1839dd23c..658a82942f0 100755 --- a/hack/update-generated-protobuf-dockerized.sh +++ b/hack/update-generated-protobuf-dockerized.sh @@ -79,6 +79,7 @@ PACKAGES=( k8s.io/metrics/pkg/apis/metrics/v1alpha1 k8s.io/metrics/pkg/apis/metrics/v1beta1 k8s.io/metrics/pkg/apis/custom_metrics/v1beta1 + k8s.io/metrics/pkg/apis/external_metrics/v1beta1 k8s.io/apiserver/pkg/apis/audit/v1alpha1 k8s.io/apiserver/pkg/apis/audit/v1beta1 k8s.io/apiserver/pkg/apis/example2/v1 diff --git a/pkg/generated/openapi/BUILD b/pkg/generated/openapi/BUILD index 18f3b653917..c6bcf302eed 100644 --- a/pkg/generated/openapi/BUILD +++ b/pkg/generated/openapi/BUILD @@ -67,6 +67,7 @@ openapi_library( "k8s.io/kube-aggregator/pkg/apis/apiregistration/v1", "k8s.io/kube-aggregator/pkg/apis/apiregistration/v1beta1", "k8s.io/metrics/pkg/apis/custom_metrics/v1beta1", + "k8s.io/metrics/pkg/apis/external_metrics/v1beta1", "k8s.io/metrics/pkg/apis/metrics/v1alpha1", "k8s.io/metrics/pkg/apis/metrics/v1beta1", ], diff --git a/staging/src/k8s.io/metrics/pkg/apis/external_metrics/v1beta1/BUILD b/staging/src/k8s.io/metrics/pkg/apis/external_metrics/v1beta1/BUILD index 888f2610f0d..ea25f623932 100644 --- a/staging/src/k8s.io/metrics/pkg/apis/external_metrics/v1beta1/BUILD +++ b/staging/src/k8s.io/metrics/pkg/apis/external_metrics/v1beta1/BUILD @@ -9,6 +9,7 @@ go_library( name = "go_default_library", srcs = [ "doc.go", + "generated.pb.go", "register.go", "types.go", "zz_generated.conversion.go", @@ -16,6 +17,8 @@ go_library( ], importpath = "k8s.io/metrics/pkg/apis/external_metrics/v1beta1", deps = [ + "//vendor/github.com/gogo/protobuf/proto:go_default_library", + "//vendor/github.com/gogo/protobuf/sortkeys:go_default_library", "//vendor/k8s.io/apimachinery/pkg/api/resource:go_default_library", "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library", "//vendor/k8s.io/apimachinery/pkg/conversion:go_default_library", @@ -37,3 +40,8 @@ filegroup( srcs = [":package-srcs"], tags = ["automanaged"], ) + +filegroup( + name = "go_default_library_protos", + srcs = ["generated.proto"], +) diff --git a/staging/src/k8s.io/metrics/pkg/apis/external_metrics/v1beta1/generated.pb.go b/staging/src/k8s.io/metrics/pkg/apis/external_metrics/v1beta1/generated.pb.go new file mode 100644 index 00000000000..71b70dc9615 --- /dev/null +++ b/staging/src/k8s.io/metrics/pkg/apis/external_metrics/v1beta1/generated.pb.go @@ -0,0 +1,823 @@ +/* +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. +*/ + +// Code generated by protoc-gen-gogo. +// source: k8s.io/kubernetes/vendor/k8s.io/metrics/pkg/apis/external_metrics/v1beta1/generated.proto +// DO NOT EDIT! + +/* + Package v1beta1 is a generated protocol buffer package. + + It is generated from these files: + k8s.io/kubernetes/vendor/k8s.io/metrics/pkg/apis/external_metrics/v1beta1/generated.proto + + It has these top-level messages: + ExternalMetricValue + ExternalMetricValueList +*/ +package v1beta1 + +import proto "github.com/gogo/protobuf/proto" +import fmt "fmt" +import math "math" + +import github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys" + +import strings "strings" +import reflect "reflect" + +import io "io" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package + +func (m *ExternalMetricValue) Reset() { *m = ExternalMetricValue{} } +func (*ExternalMetricValue) ProtoMessage() {} +func (*ExternalMetricValue) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{0} } + +func (m *ExternalMetricValueList) Reset() { *m = ExternalMetricValueList{} } +func (*ExternalMetricValueList) ProtoMessage() {} +func (*ExternalMetricValueList) Descriptor() ([]byte, []int) { return fileDescriptorGenerated, []int{1} } + +func init() { + proto.RegisterType((*ExternalMetricValue)(nil), "k8s.io.metrics.pkg.apis.external_metrics.v1beta1.ExternalMetricValue") + proto.RegisterType((*ExternalMetricValueList)(nil), "k8s.io.metrics.pkg.apis.external_metrics.v1beta1.ExternalMetricValueList") +} +func (m *ExternalMetricValue) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ExternalMetricValue) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + dAtA[i] = 0xa + i++ + i = encodeVarintGenerated(dAtA, i, uint64(len(m.MetricName))) + i += copy(dAtA[i:], m.MetricName) + if len(m.MetricLabels) > 0 { + keysForMetricLabels := make([]string, 0, len(m.MetricLabels)) + for k := range m.MetricLabels { + keysForMetricLabels = append(keysForMetricLabels, string(k)) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForMetricLabels) + for _, k := range keysForMetricLabels { + dAtA[i] = 0x12 + i++ + v := m.MetricLabels[string(k)] + mapSize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v))) + i = encodeVarintGenerated(dAtA, i, uint64(mapSize)) + dAtA[i] = 0xa + i++ + i = encodeVarintGenerated(dAtA, i, uint64(len(k))) + i += copy(dAtA[i:], k) + dAtA[i] = 0x12 + i++ + i = encodeVarintGenerated(dAtA, i, uint64(len(v))) + i += copy(dAtA[i:], v) + } + } + dAtA[i] = 0x1a + i++ + i = encodeVarintGenerated(dAtA, i, uint64(m.Timestamp.Size())) + n1, err := m.Timestamp.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n1 + if m.WindowSeconds != nil { + dAtA[i] = 0x20 + i++ + i = encodeVarintGenerated(dAtA, i, uint64(*m.WindowSeconds)) + } + dAtA[i] = 0x2a + i++ + i = encodeVarintGenerated(dAtA, i, uint64(m.Value.Size())) + n2, err := m.Value.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n2 + return i, nil +} + +func (m *ExternalMetricValueList) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ExternalMetricValueList) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + dAtA[i] = 0xa + i++ + i = encodeVarintGenerated(dAtA, i, uint64(m.ListMeta.Size())) + n3, err := m.ListMeta.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n3 + if len(m.Items) > 0 { + for _, msg := range m.Items { + dAtA[i] = 0x12 + i++ + i = encodeVarintGenerated(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n + } + } + return i, nil +} + +func encodeFixed64Generated(dAtA []byte, offset int, v uint64) int { + dAtA[offset] = uint8(v) + dAtA[offset+1] = uint8(v >> 8) + dAtA[offset+2] = uint8(v >> 16) + dAtA[offset+3] = uint8(v >> 24) + dAtA[offset+4] = uint8(v >> 32) + dAtA[offset+5] = uint8(v >> 40) + dAtA[offset+6] = uint8(v >> 48) + dAtA[offset+7] = uint8(v >> 56) + return offset + 8 +} +func encodeFixed32Generated(dAtA []byte, offset int, v uint32) int { + dAtA[offset] = uint8(v) + dAtA[offset+1] = uint8(v >> 8) + dAtA[offset+2] = uint8(v >> 16) + dAtA[offset+3] = uint8(v >> 24) + return offset + 4 +} +func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int { + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return offset + 1 +} +func (m *ExternalMetricValue) Size() (n int) { + var l int + _ = l + l = len(m.MetricName) + n += 1 + l + sovGenerated(uint64(l)) + if len(m.MetricLabels) > 0 { + for k, v := range m.MetricLabels { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + len(v) + sovGenerated(uint64(len(v))) + n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize)) + } + } + l = m.Timestamp.Size() + n += 1 + l + sovGenerated(uint64(l)) + if m.WindowSeconds != nil { + n += 1 + sovGenerated(uint64(*m.WindowSeconds)) + } + l = m.Value.Size() + n += 1 + l + sovGenerated(uint64(l)) + return n +} + +func (m *ExternalMetricValueList) Size() (n int) { + var l int + _ = l + l = m.ListMeta.Size() + n += 1 + l + sovGenerated(uint64(l)) + if len(m.Items) > 0 { + for _, e := range m.Items { + l = e.Size() + n += 1 + l + sovGenerated(uint64(l)) + } + } + return n +} + +func sovGenerated(x uint64) (n int) { + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n +} +func sozGenerated(x uint64) (n int) { + return sovGenerated(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (this *ExternalMetricValue) String() string { + if this == nil { + return "nil" + } + keysForMetricLabels := make([]string, 0, len(this.MetricLabels)) + for k := range this.MetricLabels { + keysForMetricLabels = append(keysForMetricLabels, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForMetricLabels) + mapStringForMetricLabels := "map[string]string{" + for _, k := range keysForMetricLabels { + mapStringForMetricLabels += fmt.Sprintf("%v: %v,", k, this.MetricLabels[k]) + } + mapStringForMetricLabels += "}" + s := strings.Join([]string{`&ExternalMetricValue{`, + `MetricName:` + fmt.Sprintf("%v", this.MetricName) + `,`, + `MetricLabels:` + mapStringForMetricLabels + `,`, + `Timestamp:` + strings.Replace(strings.Replace(this.Timestamp.String(), "Time", "k8s_io_apimachinery_pkg_apis_meta_v1.Time", 1), `&`, ``, 1) + `,`, + `WindowSeconds:` + valueToStringGenerated(this.WindowSeconds) + `,`, + `Value:` + strings.Replace(strings.Replace(this.Value.String(), "Quantity", "k8s_io_apimachinery_pkg_api_resource.Quantity", 1), `&`, ``, 1) + `,`, + `}`, + }, "") + return s +} +func (this *ExternalMetricValueList) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ExternalMetricValueList{`, + `ListMeta:` + strings.Replace(strings.Replace(this.ListMeta.String(), "ListMeta", "k8s_io_apimachinery_pkg_apis_meta_v1.ListMeta", 1), `&`, ``, 1) + `,`, + `Items:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Items), "ExternalMetricValue", "ExternalMetricValue", 1), `&`, ``, 1) + `,`, + `}`, + }, "") + return s +} +func valueToStringGenerated(v interface{}) string { + rv := reflect.ValueOf(v) + if rv.IsNil() { + return "nil" + } + pv := reflect.Indirect(rv).Interface() + return fmt.Sprintf("*%v", pv) +} +func (m *ExternalMetricValue) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ExternalMetricValue: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ExternalMetricValue: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MetricName", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + intStringLen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.MetricName = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MetricLabels", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + var keykey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + keykey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapkey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthGenerated + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey := string(dAtA[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + if m.MetricLabels == nil { + m.MetricLabels = make(map[string]string) + } + if iNdEx < postIndex { + var valuekey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + valuekey |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + var stringLenmapvalue uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapvalue |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapvalue := int(stringLenmapvalue) + if intStringLenmapvalue < 0 { + return ErrInvalidLengthGenerated + } + postStringIndexmapvalue := iNdEx + intStringLenmapvalue + if postStringIndexmapvalue > l { + return io.ErrUnexpectedEOF + } + mapvalue := string(dAtA[iNdEx:postStringIndexmapvalue]) + iNdEx = postStringIndexmapvalue + m.MetricLabels[mapkey] = mapvalue + } else { + var mapvalue string + m.MetricLabels[mapkey] = mapvalue + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Timestamp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field WindowSeconds", wireType) + } + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= (int64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + m.WindowSeconds = &v + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.Value.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ExternalMetricValueList) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ExternalMetricValueList: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ExternalMetricValueList: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ListMeta", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.ListMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Items = append(m.Items, ExternalMetricValue{}) + if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func skipGenerated(dAtA []byte) (n int, err error) { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGenerated + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGenerated + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + return iNdEx, nil + case 1: + iNdEx += 8 + return iNdEx, nil + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGenerated + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + iNdEx += length + if length < 0 { + return 0, ErrInvalidLengthGenerated + } + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowGenerated + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + innerWire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + innerWireType := int(innerWire & 0x7) + if innerWireType == 4 { + break + } + next, err := skipGenerated(dAtA[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + } + return iNdEx, nil + case 4: + return iNdEx, nil + case 5: + iNdEx += 4 + return iNdEx, nil + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + } + panic("unreachable") +} + +var ( + ErrInvalidLengthGenerated = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowGenerated = fmt.Errorf("proto: integer overflow") +) + +func init() { + proto.RegisterFile("k8s.io/kubernetes/vendor/k8s.io/metrics/pkg/apis/external_metrics/v1beta1/generated.proto", fileDescriptorGenerated) +} + +var fileDescriptorGenerated = []byte{ + // 564 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x92, 0x4d, 0x6b, 0x13, 0x41, + 0x18, 0xc7, 0x33, 0x8d, 0xd1, 0x66, 0xda, 0x42, 0xb3, 0x16, 0x0c, 0x39, 0x6c, 0x42, 0x4f, 0x51, + 0xe8, 0x8c, 0x89, 0x22, 0xc5, 0x8b, 0xb0, 0x90, 0x83, 0xd0, 0x08, 0x6e, 0x8b, 0xc5, 0x17, 0x90, + 0xc9, 0xe6, 0x71, 0x33, 0x26, 0xfb, 0xc2, 0xcc, 0x6c, 0x6a, 0x6e, 0x7e, 0x04, 0xfd, 0x56, 0x39, + 0xf6, 0xd8, 0x53, 0x30, 0xdb, 0x8f, 0xe1, 0x45, 0x76, 0x77, 0xb6, 0x89, 0x49, 0x5f, 0x10, 0xbc, + 0xcd, 0x33, 0xcf, 0xfc, 0xff, 0xcf, 0x6f, 0xfe, 0x33, 0xf8, 0xfd, 0xf0, 0x50, 0x12, 0x1e, 0xd0, + 0x61, 0xd4, 0x03, 0xe1, 0x83, 0x02, 0x49, 0xc7, 0xe0, 0xf7, 0x03, 0x41, 0x75, 0xc3, 0x03, 0x25, + 0xb8, 0x23, 0x69, 0x38, 0x74, 0x29, 0x0b, 0xb9, 0xa4, 0xf0, 0x4d, 0x81, 0xf0, 0xd9, 0xe8, 0x73, + 0xde, 0x19, 0xb7, 0x7a, 0xa0, 0x58, 0x8b, 0xba, 0xe0, 0x83, 0x60, 0x0a, 0xfa, 0x24, 0x14, 0x81, + 0x0a, 0x8c, 0xa7, 0x99, 0x03, 0xd1, 0xe7, 0x48, 0x38, 0x74, 0x49, 0xe2, 0x40, 0x56, 0x1d, 0x88, + 0x76, 0xa8, 0x1d, 0xb8, 0x5c, 0x0d, 0xa2, 0x1e, 0x71, 0x02, 0x8f, 0xba, 0x81, 0x1b, 0xd0, 0xd4, + 0xa8, 0x17, 0x7d, 0x49, 0xab, 0xb4, 0x48, 0x57, 0xd9, 0x80, 0xda, 0x73, 0x8d, 0xc8, 0x42, 0xee, + 0x31, 0x67, 0xc0, 0x7d, 0x10, 0x93, 0x9c, 0x93, 0x0a, 0x90, 0x41, 0x24, 0x1c, 0x58, 0xc5, 0xba, + 0x55, 0x25, 0x93, 0xeb, 0x32, 0x3a, 0x5e, 0xbb, 0x4c, 0x8d, 0xde, 0xa4, 0x12, 0x91, 0xaf, 0xb8, + 0xb7, 0x3e, 0xe6, 0xc5, 0x5d, 0x02, 0xe9, 0x0c, 0xc0, 0x63, 0x6b, 0xba, 0x67, 0x37, 0xe9, 0x22, + 0xc5, 0x47, 0x94, 0xfb, 0x4a, 0x2a, 0xb1, 0x2a, 0xda, 0xff, 0x5d, 0xc4, 0x0f, 0x3b, 0x3a, 0xd5, + 0x6e, 0x1a, 0xea, 0x3b, 0x36, 0x8a, 0xc0, 0x68, 0x63, 0x9c, 0x65, 0xfc, 0x86, 0x79, 0x50, 0x45, + 0x0d, 0xd4, 0x2c, 0x5b, 0xc6, 0x74, 0x56, 0x2f, 0xc4, 0xb3, 0x3a, 0xee, 0x5e, 0x75, 0xec, 0xa5, + 0x53, 0xc6, 0x4f, 0x84, 0xb7, 0xb3, 0xf2, 0x88, 0xf5, 0x60, 0x24, 0xab, 0x1b, 0x8d, 0x62, 0x73, + 0xab, 0x7d, 0x4a, 0xfe, 0xf5, 0x39, 0xc9, 0x35, 0x44, 0xa4, 0xbb, 0xe4, 0xdc, 0xf1, 0x95, 0x98, + 0x58, 0x7b, 0x9a, 0x67, 0x7b, 0xb9, 0x65, 0xff, 0x85, 0x60, 0x7c, 0xc4, 0xe5, 0x24, 0x33, 0xa9, + 0x98, 0x17, 0x56, 0x8b, 0x0d, 0xd4, 0xdc, 0x6a, 0x3f, 0xc9, 0x79, 0x96, 0x83, 0x5a, 0x40, 0x25, + 0xef, 0x48, 0xc6, 0x2d, 0x72, 0xc2, 0x3d, 0xb0, 0x2a, 0x7a, 0x44, 0xf9, 0x24, 0x37, 0xb1, 0x17, + 0x7e, 0xc6, 0x63, 0x7c, 0xff, 0x8c, 0xfb, 0xfd, 0xe0, 0xac, 0x7a, 0xaf, 0x81, 0x9a, 0x45, 0xab, + 0x12, 0xcf, 0xea, 0x3b, 0xa7, 0xe9, 0xce, 0x31, 0x38, 0x81, 0xdf, 0x97, 0xb6, 0x3e, 0x60, 0x1c, + 0xe3, 0xd2, 0x38, 0xb9, 0x46, 0xb5, 0x94, 0x32, 0x90, 0xdb, 0x18, 0x48, 0xfe, 0x03, 0xc9, 0xdb, + 0x88, 0xf9, 0x8a, 0xab, 0x89, 0xb5, 0xa3, 0x39, 0x4a, 0x69, 0x16, 0x76, 0xe6, 0x55, 0x7b, 0x85, + 0x2b, 0x6b, 0xa9, 0x18, 0xbb, 0xb8, 0x38, 0x84, 0x49, 0xf6, 0x64, 0x76, 0xb2, 0x34, 0xf6, 0xf2, + 0xd9, 0x1b, 0xe9, 0x5e, 0x56, 0xbc, 0xdc, 0x38, 0x44, 0xfb, 0x97, 0x08, 0x3f, 0xba, 0x26, 0xeb, + 0x23, 0x2e, 0x95, 0xf1, 0x09, 0x6f, 0x26, 0x51, 0xf4, 0x99, 0x62, 0xa9, 0xd9, 0x1d, 0xd0, 0x8b, + 0xe0, 0x12, 0x75, 0x17, 0x14, 0xb3, 0x76, 0x35, 0xf4, 0x66, 0xbe, 0x63, 0x5f, 0x39, 0x1a, 0x5f, + 0x71, 0x89, 0x2b, 0xf0, 0xf2, 0x3f, 0xd2, 0xf9, 0x2f, 0x7f, 0x64, 0x11, 0xd3, 0xeb, 0xc4, 0xdb, + 0xce, 0x46, 0x58, 0x07, 0xd3, 0xb9, 0x59, 0x38, 0x9f, 0x9b, 0x85, 0x8b, 0xb9, 0x59, 0xf8, 0x1e, + 0x9b, 0x68, 0x1a, 0x9b, 0xe8, 0x3c, 0x36, 0xd1, 0x45, 0x6c, 0xa2, 0x5f, 0xb1, 0x89, 0x7e, 0x5c, + 0x9a, 0x85, 0x0f, 0x0f, 0xb4, 0xf1, 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xf5, 0x48, 0x2f, 0x06, + 0xd9, 0x04, 0x00, 0x00, +} diff --git a/staging/src/k8s.io/metrics/pkg/apis/external_metrics/v1beta1/generated.proto b/staging/src/k8s.io/metrics/pkg/apis/external_metrics/v1beta1/generated.proto new file mode 100644 index 00000000000..2fb3f56378b --- /dev/null +++ b/staging/src/k8s.io/metrics/pkg/apis/external_metrics/v1beta1/generated.proto @@ -0,0 +1,63 @@ +/* +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. +*/ + + +// This file was autogenerated by go-to-protobuf. Do not edit it manually! + +syntax = 'proto2'; + +package k8s.io.metrics.pkg.apis.external_metrics.v1beta1; + +import "k8s.io/apimachinery/pkg/api/resource/generated.proto"; +import "k8s.io/apimachinery/pkg/apis/meta/v1/generated.proto"; +import "k8s.io/apimachinery/pkg/runtime/generated.proto"; +import "k8s.io/apimachinery/pkg/runtime/schema/generated.proto"; +import "k8s.io/apimachinery/pkg/util/intstr/generated.proto"; + +// Package-wide variables from generator "generated". +option go_package = "v1beta1"; + +// a metric value for external metric +// A single metric value is identified by metric name and a set of string labels. +// For one metric there can be multiple values with different sets of labels. +message ExternalMetricValue { + // the name of the metric + optional string metricName = 1; + + // a set of labels that identify a single time series for the metric + map metricLabels = 2; + + // indicates the time at which the metrics were produced + optional k8s.io.apimachinery.pkg.apis.meta.v1.Time timestamp = 3; + + // indicates the window ([Timestamp-Window, Timestamp]) from + // which these metrics were calculated, when returning rate + // metrics calculated from cumulative metrics (or zero for + // non-calculated instantaneous metrics). + optional int64 window = 4; + + // the value of the metric + optional k8s.io.apimachinery.pkg.api.resource.Quantity value = 5; +} + +// a list of values for a given metric for some set labels +message ExternalMetricValueList { + optional k8s.io.apimachinery.pkg.apis.meta.v1.ListMeta metadata = 1; + + // value of the metric matching a given set of labels + repeated ExternalMetricValue items = 2; +} + diff --git a/staging/src/k8s.io/metrics/pkg/apis/external_metrics/v1beta1/zz_generated.conversion.go b/staging/src/k8s.io/metrics/pkg/apis/external_metrics/v1beta1/zz_generated.conversion.go new file mode 100644 index 00000000000..35155293c9a --- /dev/null +++ b/staging/src/k8s.io/metrics/pkg/apis/external_metrics/v1beta1/zz_generated.conversion.go @@ -0,0 +1,94 @@ +// +build !ignore_autogenerated + +/* +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. +*/ + +// This file was autogenerated by conversion-gen. Do not edit it manually! + +package v1beta1 + +import ( + unsafe "unsafe" + + conversion "k8s.io/apimachinery/pkg/conversion" + runtime "k8s.io/apimachinery/pkg/runtime" + external_metrics "k8s.io/metrics/pkg/apis/external_metrics" +) + +func init() { + localSchemeBuilder.Register(RegisterConversions) +} + +// RegisterConversions adds conversion functions to the given scheme. +// Public to allow building arbitrary schemes. +func RegisterConversions(scheme *runtime.Scheme) error { + return scheme.AddGeneratedConversionFuncs( + Convert_v1beta1_ExternalMetricValue_To_external_metrics_ExternalMetricValue, + Convert_external_metrics_ExternalMetricValue_To_v1beta1_ExternalMetricValue, + Convert_v1beta1_ExternalMetricValueList_To_external_metrics_ExternalMetricValueList, + Convert_external_metrics_ExternalMetricValueList_To_v1beta1_ExternalMetricValueList, + ) +} + +func autoConvert_v1beta1_ExternalMetricValue_To_external_metrics_ExternalMetricValue(in *ExternalMetricValue, out *external_metrics.ExternalMetricValue, s conversion.Scope) error { + out.MetricName = in.MetricName + out.MetricLabels = *(*map[string]string)(unsafe.Pointer(&in.MetricLabels)) + out.Timestamp = in.Timestamp + out.WindowSeconds = (*int64)(unsafe.Pointer(in.WindowSeconds)) + out.Value = in.Value + return nil +} + +// Convert_v1beta1_ExternalMetricValue_To_external_metrics_ExternalMetricValue is an autogenerated conversion function. +func Convert_v1beta1_ExternalMetricValue_To_external_metrics_ExternalMetricValue(in *ExternalMetricValue, out *external_metrics.ExternalMetricValue, s conversion.Scope) error { + return autoConvert_v1beta1_ExternalMetricValue_To_external_metrics_ExternalMetricValue(in, out, s) +} + +func autoConvert_external_metrics_ExternalMetricValue_To_v1beta1_ExternalMetricValue(in *external_metrics.ExternalMetricValue, out *ExternalMetricValue, s conversion.Scope) error { + out.MetricName = in.MetricName + out.MetricLabels = *(*map[string]string)(unsafe.Pointer(&in.MetricLabels)) + out.Timestamp = in.Timestamp + out.WindowSeconds = (*int64)(unsafe.Pointer(in.WindowSeconds)) + out.Value = in.Value + return nil +} + +// Convert_external_metrics_ExternalMetricValue_To_v1beta1_ExternalMetricValue is an autogenerated conversion function. +func Convert_external_metrics_ExternalMetricValue_To_v1beta1_ExternalMetricValue(in *external_metrics.ExternalMetricValue, out *ExternalMetricValue, s conversion.Scope) error { + return autoConvert_external_metrics_ExternalMetricValue_To_v1beta1_ExternalMetricValue(in, out, s) +} + +func autoConvert_v1beta1_ExternalMetricValueList_To_external_metrics_ExternalMetricValueList(in *ExternalMetricValueList, out *external_metrics.ExternalMetricValueList, s conversion.Scope) error { + out.ListMeta = in.ListMeta + out.Items = *(*[]external_metrics.ExternalMetricValue)(unsafe.Pointer(&in.Items)) + return nil +} + +// Convert_v1beta1_ExternalMetricValueList_To_external_metrics_ExternalMetricValueList is an autogenerated conversion function. +func Convert_v1beta1_ExternalMetricValueList_To_external_metrics_ExternalMetricValueList(in *ExternalMetricValueList, out *external_metrics.ExternalMetricValueList, s conversion.Scope) error { + return autoConvert_v1beta1_ExternalMetricValueList_To_external_metrics_ExternalMetricValueList(in, out, s) +} + +func autoConvert_external_metrics_ExternalMetricValueList_To_v1beta1_ExternalMetricValueList(in *external_metrics.ExternalMetricValueList, out *ExternalMetricValueList, s conversion.Scope) error { + out.ListMeta = in.ListMeta + out.Items = *(*[]ExternalMetricValue)(unsafe.Pointer(&in.Items)) + return nil +} + +// Convert_external_metrics_ExternalMetricValueList_To_v1beta1_ExternalMetricValueList is an autogenerated conversion function. +func Convert_external_metrics_ExternalMetricValueList_To_v1beta1_ExternalMetricValueList(in *external_metrics.ExternalMetricValueList, out *ExternalMetricValueList, s conversion.Scope) error { + return autoConvert_external_metrics_ExternalMetricValueList_To_v1beta1_ExternalMetricValueList(in, out, s) +} diff --git a/staging/src/k8s.io/metrics/pkg/apis/external_metrics/v1beta1/zz_generated.deepcopy.go b/staging/src/k8s.io/metrics/pkg/apis/external_metrics/v1beta1/zz_generated.deepcopy.go new file mode 100644 index 00000000000..3df3549edf9 --- /dev/null +++ b/staging/src/k8s.io/metrics/pkg/apis/external_metrics/v1beta1/zz_generated.deepcopy.go @@ -0,0 +1,103 @@ +// +build !ignore_autogenerated + +/* +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. +*/ + +// This file was autogenerated by deepcopy-gen. Do not edit it manually! + +package v1beta1 + +import ( + runtime "k8s.io/apimachinery/pkg/runtime" +) + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ExternalMetricValue) DeepCopyInto(out *ExternalMetricValue) { + *out = *in + out.TypeMeta = in.TypeMeta + if in.MetricLabels != nil { + in, out := &in.MetricLabels, &out.MetricLabels + *out = make(map[string]string, len(*in)) + for key, val := range *in { + (*out)[key] = val + } + } + in.Timestamp.DeepCopyInto(&out.Timestamp) + if in.WindowSeconds != nil { + in, out := &in.WindowSeconds, &out.WindowSeconds + if *in == nil { + *out = nil + } else { + *out = new(int64) + **out = **in + } + } + out.Value = in.Value.DeepCopy() + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ExternalMetricValue. +func (in *ExternalMetricValue) DeepCopy() *ExternalMetricValue { + if in == nil { + return nil + } + out := new(ExternalMetricValue) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *ExternalMetricValue) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } else { + return nil + } +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ExternalMetricValueList) DeepCopyInto(out *ExternalMetricValueList) { + *out = *in + out.TypeMeta = in.TypeMeta + out.ListMeta = in.ListMeta + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]ExternalMetricValue, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ExternalMetricValueList. +func (in *ExternalMetricValueList) DeepCopy() *ExternalMetricValueList { + if in == nil { + return nil + } + out := new(ExternalMetricValueList) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *ExternalMetricValueList) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } else { + return nil + } +} diff --git a/staging/src/k8s.io/metrics/pkg/apis/external_metrics/zz_generated.deepcopy.go b/staging/src/k8s.io/metrics/pkg/apis/external_metrics/zz_generated.deepcopy.go new file mode 100644 index 00000000000..96daead3fd6 --- /dev/null +++ b/staging/src/k8s.io/metrics/pkg/apis/external_metrics/zz_generated.deepcopy.go @@ -0,0 +1,103 @@ +// +build !ignore_autogenerated + +/* +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. +*/ + +// This file was autogenerated by deepcopy-gen. Do not edit it manually! + +package external_metrics + +import ( + runtime "k8s.io/apimachinery/pkg/runtime" +) + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ExternalMetricValue) DeepCopyInto(out *ExternalMetricValue) { + *out = *in + out.TypeMeta = in.TypeMeta + if in.MetricLabels != nil { + in, out := &in.MetricLabels, &out.MetricLabels + *out = make(map[string]string, len(*in)) + for key, val := range *in { + (*out)[key] = val + } + } + in.Timestamp.DeepCopyInto(&out.Timestamp) + if in.WindowSeconds != nil { + in, out := &in.WindowSeconds, &out.WindowSeconds + if *in == nil { + *out = nil + } else { + *out = new(int64) + **out = **in + } + } + out.Value = in.Value.DeepCopy() + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ExternalMetricValue. +func (in *ExternalMetricValue) DeepCopy() *ExternalMetricValue { + if in == nil { + return nil + } + out := new(ExternalMetricValue) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *ExternalMetricValue) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } else { + return nil + } +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ExternalMetricValueList) DeepCopyInto(out *ExternalMetricValueList) { + *out = *in + out.TypeMeta = in.TypeMeta + out.ListMeta = in.ListMeta + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]ExternalMetricValue, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ExternalMetricValueList. +func (in *ExternalMetricValueList) DeepCopy() *ExternalMetricValueList { + if in == nil { + return nil + } + out := new(ExternalMetricValueList) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *ExternalMetricValueList) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } else { + return nil + } +}