Initial 1Password Operator commit

vendor/k8s.io/kube-state-metrics/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.

vendor/k8s.io/kube-state-metrics/pkg/metric/family.go

@@ -0,0 +1,38 @@
+/*
+Copyright 2019 The Kubernetes Authors All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package metric
+
+import (
+	"strings"
+)
+
+// Family represents a set of metrics with the same name and help text.
+type Family struct {
+	Name    string
+	Metrics []*Metric
+}
+
+// ByteSlice returns the given Family in its string representation.
+func (f Family) ByteSlice() []byte {
+	b := strings.Builder{}
+	for _, m := range f.Metrics {
+		b.WriteString(f.Name)
+		m.Write(&b)
+	}
+
+	return []byte(b.String())
+}

vendor/k8s.io/kube-state-metrics/pkg/metric/generator.go

@@ -0,0 +1,102 @@
+/*
+Copyright 2019 The Kubernetes Authors All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package metric
+
+import (
+	"strings"
+
+	metricsstore "k8s.io/kube-state-metrics/pkg/metrics_store"
+)
+
+// FamilyGenerator provides everything needed to generate a metric family with a
+// Kubernetes object.
+type FamilyGenerator struct {
+	Name         string
+	Help         string
+	Type         Type
+	GenerateFunc func(obj interface{}) *Family
+}
+
+// Generate calls the FamilyGenerator.GenerateFunc and gives the family its
+// name. The reasoning behind injecting the name at such a late point in time is
+// deduplication in the code, preventing typos made by developers as
+// well as saving memory.
+func (g *FamilyGenerator) Generate(obj interface{}) *Family {
+	family := g.GenerateFunc(obj)
+	family.Name = g.Name
+	return family
+}
+
+func (g *FamilyGenerator) generateHeader() string {
+	header := strings.Builder{}
+	header.WriteString("# HELP ")
+	header.WriteString(g.Name)
+	header.WriteByte(' ')
+	header.WriteString(g.Help)
+	header.WriteByte('\n')
+	header.WriteString("# TYPE ")
+	header.WriteString(g.Name)
+	header.WriteByte(' ')
+	header.WriteString(string(g.Type))
+
+	return header.String()
+}
+
+// ExtractMetricFamilyHeaders takes in a slice of FamilyGenerator metrics and
+// returns the extracted headers.
+func ExtractMetricFamilyHeaders(families []FamilyGenerator) []string {
+	headers := make([]string, len(families))
+
+	for i, f := range families {
+		headers[i] = f.generateHeader()
+	}
+
+	return headers
+}
+
+// ComposeMetricGenFuncs takes a slice of metric families and returns a function
+// that composes their metric generation functions into a single one.
+func ComposeMetricGenFuncs(familyGens []FamilyGenerator) func(obj interface{}) []metricsstore.FamilyByteSlicer {
+	return func(obj interface{}) []metricsstore.FamilyByteSlicer {
+		families := make([]metricsstore.FamilyByteSlicer, len(familyGens))
+
+		for i, gen := range familyGens {
+			families[i] = gen.Generate(obj)
+		}
+
+		return families
+	}
+}
+
+type whiteBlackLister interface {
+	IsIncluded(string) bool
+	IsExcluded(string) bool
+}
+
+// FilterMetricFamilies takes a white- and a blacklist and a slice of metric
+// families and returns a filtered slice.
+func FilterMetricFamilies(l whiteBlackLister, families []FamilyGenerator) []FamilyGenerator {
+	filtered := []FamilyGenerator{}
+
+	for _, f := range families {
+		if l.IsIncluded(f.Name) {
+			filtered = append(filtered, f)
+		}
+	}
+
+	return filtered
+}

vendor/k8s.io/kube-state-metrics/pkg/metric/metric.go

@@ -0,0 +1,124 @@
+/*
+Copyright 2018 The Kubernetes Authors All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package metric
+
+import (
+	"fmt"
+	"math"
+	"strconv"
+	"strings"
+	"sync"
+)
+
+const (
+	initialNumBufSize = 24
+)
+
+var (
+	numBufPool = sync.Pool{
+		New: func() interface{} {
+			b := make([]byte, 0, initialNumBufSize)
+			return &b
+		},
+	}
+)
+
+// Type represents the type of a metric e.g. a counter. See
+// https://prometheus.io/docs/concepts/metric_types/.
+type Type string
+
+// Gauge defines a Prometheus gauge.
+var Gauge Type = "gauge"
+
+// Counter defines a Prometheus counter.
+var Counter Type = "counter"
+
+// Metric represents a single time series.
+type Metric struct {
+	// The name of a metric is injected by its family to reduce duplication.
+	LabelKeys   []string
+	LabelValues []string
+	Value       float64
+}
+
+func (m *Metric) Write(s *strings.Builder) {
+	if len(m.LabelKeys) != len(m.LabelValues) {
+		panic(fmt.Sprintf(
+			"expected labelKeys %q to be of same length as labelValues %q",
+			m.LabelKeys, m.LabelValues,
+		))
+	}
+
+	labelsToString(s, m.LabelKeys, m.LabelValues)
+	s.WriteByte(' ')
+	writeFloat(s, m.Value)
+	s.WriteByte('\n')
+}
+
+func labelsToString(m *strings.Builder, keys, values []string) {
+	if len(keys) > 0 {
+		var separator byte = '{'
+
+		for i := 0; i < len(keys); i++ {
+			m.WriteByte(separator)
+			m.WriteString(keys[i])
+			m.WriteString("=\"")
+			escapeString(m, values[i])
+			m.WriteByte('"')
+			separator = ','
+		}
+
+		m.WriteByte('}')
+	}
+}
+
+var (
+	escapeWithDoubleQuote = strings.NewReplacer("\\", `\\`, "\n", `\n`, "\"", `\"`)
+)
+
+// escapeString replaces '\' by '\\', new line character by '\n', and '"' by
+// '\"'.
+// Taken from github.com/prometheus/common/expfmt/text_create.go.
+func escapeString(m *strings.Builder, v string) {
+	escapeWithDoubleQuote.WriteString(m, v)
+}
+
+// writeFloat is equivalent to fmt.Fprint with a float64 argument but hardcodes
+// a few common cases for increased efficiency. For non-hardcoded cases, it uses
+// strconv.AppendFloat to avoid allocations, similar to writeInt.
+// Taken from github.com/prometheus/common/expfmt/text_create.go.
+func writeFloat(w *strings.Builder, f float64) {
+	switch {
+	case f == 1:
+		w.WriteByte('1')
+	case f == 0:
+		w.WriteByte('0')
+	case f == -1:
+		w.WriteString("-1")
+	case math.IsNaN(f):
+		w.WriteString("NaN")
+	case math.IsInf(f, +1):
+		w.WriteString("+Inf")
+	case math.IsInf(f, -1):
+		w.WriteString("-Inf")
+	default:
+		bp := numBufPool.Get().(*[]byte)
+		*bp = strconv.AppendFloat((*bp)[:0], f, 'g', -1, 64)
+		w.Write(*bp)
+		numBufPool.Put(bp)
+	}
+}

vendor/k8s.io/kube-state-metrics/pkg/metrics_store/metrics_store.go

@@ -0,0 +1,165 @@
+/*
+Copyright 2018 The Kubernetes Authors All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package metricsstore
+
+import (
+	"io"
+	"sync"
+
+	"k8s.io/apimachinery/pkg/api/meta"
+	"k8s.io/apimachinery/pkg/types"
+)
+
+// FamilyByteSlicer represents a metric family that can be converted to its string
+// representation.
+type FamilyByteSlicer interface {
+	ByteSlice() []byte
+}
+
+// MetricsStore implements the k8s.io/client-go/tools/cache.Store
+// interface. Instead of storing entire Kubernetes objects, it stores metrics
+// generated based on those objects.
+type MetricsStore struct {
+	// Protects metrics
+	mutex sync.RWMutex
+	// metrics is a map indexed by Kubernetes object id, containing a slice of
+	// metric families, containing a slice of metrics. We need to keep metrics
+	// grouped by metric families in order to zip families with their help text in
+	// MetricsStore.WriteAll().
+	metrics map[types.UID][][]byte
+	// headers contains the header (TYPE and HELP) of each metric family. It is
+	// later on zipped with with their corresponding metric families in
+	// MetricStore.WriteAll().
+	headers []string
+
+	// generateMetricsFunc generates metrics based on a given Kubernetes object
+	// and returns them grouped by metric family.
+	generateMetricsFunc func(interface{}) []FamilyByteSlicer
+}
+
+// NewMetricsStore returns a new MetricsStore
+func NewMetricsStore(headers []string, generateFunc func(interface{}) []FamilyByteSlicer) *MetricsStore {
+	return &MetricsStore{
+		generateMetricsFunc: generateFunc,
+		headers:             headers,
+		metrics:             map[types.UID][][]byte{},
+	}
+}
+
+// Implementing k8s.io/client-go/tools/cache.Store interface
+
+// Add inserts adds to the MetricsStore by calling the metrics generator functions and
+// adding the generated metrics to the metrics map that underlies the MetricStore.
+func (s *MetricsStore) Add(obj interface{}) error {
+	o, err := meta.Accessor(obj)
+	if err != nil {
+		return err
+	}
+
+	s.mutex.Lock()
+	defer s.mutex.Unlock()
+
+	families := s.generateMetricsFunc(obj)
+	familyStrings := make([][]byte, len(families))
+
+	for i, f := range families {
+		familyStrings[i] = f.ByteSlice()
+	}
+
+	s.metrics[o.GetUID()] = familyStrings
+
+	return nil
+}
+
+// Update updates the existing entry in the MetricsStore.
+func (s *MetricsStore) Update(obj interface{}) error {
+	// TODO: For now, just call Add, in the future one could check if the resource version changed?
+	return s.Add(obj)
+}
+
+// Delete deletes an existing entry in the MetricsStore.
+func (s *MetricsStore) Delete(obj interface{}) error {
+
+	o, err := meta.Accessor(obj)
+	if err != nil {
+		return err
+	}
+
+	s.mutex.Lock()
+	defer s.mutex.Unlock()
+
+	delete(s.metrics, o.GetUID())
+
+	return nil
+}
+
+// List implements the List method of the store interface.
+func (s *MetricsStore) List() []interface{} {
+	return nil
+}
+
+// ListKeys implements the ListKeys method of the store interface.
+func (s *MetricsStore) ListKeys() []string {
+	return nil
+}
+
+// Get implements the Get method of the store interface.
+func (s *MetricsStore) Get(obj interface{}) (item interface{}, exists bool, err error) {
+	return nil, false, nil
+}
+
+// GetByKey implements the GetByKey method of the store interface.
+func (s *MetricsStore) GetByKey(key string) (item interface{}, exists bool, err error) {
+	return nil, false, nil
+}
+
+// Replace will delete the contents of the store, using instead the
+// given list.
+func (s *MetricsStore) Replace(list []interface{}, _ string) error {
+	s.mutex.Lock()
+	s.metrics = map[types.UID][][]byte{}
+	s.mutex.Unlock()
+
+	for _, o := range list {
+		err := s.Add(o)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// Resync implements the Resync method of the store interface.
+func (s *MetricsStore) Resync() error {
+	return nil
+}
+
+// WriteAll writes all metrics of the store into the given writer, zipped with the
+// help text of each metric family.
+func (s *MetricsStore) WriteAll(w io.Writer) {
+	s.mutex.RLock()
+	defer s.mutex.RUnlock()
+
+	for i, help := range s.headers {
+		w.Write([]byte(help))
+		w.Write([]byte{'\n'})
+		for _, metricFamilies := range s.metrics {
+			w.Write([]byte(metricFamilies[i]))
+		}
+	}
+}