summaryrefslogtreecommitdiffstats
path: root/peer-finder
diff options
context:
space:
mode:
Diffstat (limited to 'peer-finder')
-rw-r--r--peer-finder/Dockerfile23
-rw-r--r--peer-finder/Makefile33
-rw-r--r--peer-finder/peer-finder.go152
-rw-r--r--peer-finder/sets/BUILD71
-rw-r--r--peer-finder/sets/byte.go203
-rw-r--r--peer-finder/sets/doc.go20
-rw-r--r--peer-finder/sets/empty.go23
-rw-r--r--peer-finder/sets/int.go203
-rw-r--r--peer-finder/sets/int64.go203
-rw-r--r--peer-finder/sets/set_test.go270
-rw-r--r--peer-finder/sets/string.go203
-rw-r--r--peer-finder/sets/types/BUILD25
-rw-r--r--peer-finder/sets/types/types.go32
13 files changed, 1461 insertions, 0 deletions
diff --git a/peer-finder/Dockerfile b/peer-finder/Dockerfile
new file mode 100644
index 0000000..137d2b4
--- /dev/null
+++ b/peer-finder/Dockerfile
@@ -0,0 +1,23 @@
+# Copyright 2016 The Kubernetes Authors All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+FROM gcr.io/google_containers/ubuntu-slim:0.2
+MAINTAINER Prashanth.B <beeps@google.com>
+
+RUN apt-get update && apt-get install -y wget bash dnsutils
+ADD peer-finder /peer-finder
+ADD peer-finder.go /peer-finder.go
+
+EXPOSE 9376
+ENTRYPOINT ["/peer-finder"]
diff --git a/peer-finder/Makefile b/peer-finder/Makefile
new file mode 100644
index 0000000..6e9a2cf
--- /dev/null
+++ b/peer-finder/Makefile
@@ -0,0 +1,33 @@
+# Copyright 2016 The Kubernetes Authors All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+all: server
+
+TAG = 0.1
+PREFIX = gcr.io/google_containers/peer-finder
+
+server: peer-finder.go
+ CGO_ENABLED=0 go build -a -installsuffix cgo --ldflags '-w' ./peer-finder.go
+
+release: server
+ gsutil cp peer-finder gs://kubernetes-release/pets/peer-finder
+
+container: server
+ docker build -t $(PREFIX):$(TAG) .
+
+push: container
+ gcloud docker push $(PREFIX):$(TAG)
+
+clean:
+ rm -f peer-finder
diff --git a/peer-finder/peer-finder.go b/peer-finder/peer-finder.go
new file mode 100644
index 0000000..5b48c1c
--- /dev/null
+++ b/peer-finder/peer-finder.go
@@ -0,0 +1,152 @@
+/*
+Copyright 2014 The Kubernetes Authors All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// A small utility program to lookup hostnames of endpoints in a service.
+package main
+
+import (
+ "flag"
+ "fmt"
+ "log"
+ "net"
+ "os"
+ "os/exec"
+ "sort"
+ "strings"
+ "time"
+
+ "./sets"
+// "k8s.io/apimachinery/pkg/util/sets"
+)
+
+const (
+ svcLocalSuffix = "svc.cluster.local"
+ pollPeriod = 1 * time.Second
+)
+
+var (
+ onChange = flag.String("on-change", "", "Script to run on change, must accept a new line separated list of peers via stdin.")
+ onStart = flag.String("on-start", "", "Script to run on start, must accept a new line separated list of peers via stdin.")
+ svc = flag.String("service", "", "Governing service responsible for the DNS records of the domain this pod is in.")
+ namespace = flag.String("ns", "", "The namespace this pod is running in. If unspecified, the POD_NAMESPACE env var is used.")
+)
+
+func lookup(svcName string) (sets.String, error) {
+ endpoints := sets.NewString()
+ _, srvRecords, err := net.LookupSRV("", "", svcName)
+ if err != nil {
+ return endpoints, err
+ }
+ for _, srvRecord := range srvRecords {
+ // The SRV records ends in a "." for the root domain
+ ep := fmt.Sprintf("%v", srvRecord.Target[:len(srvRecord.Target)-1])
+ endpoints.Insert(ep)
+ }
+ return endpoints, nil
+}
+
+func resolve(s *sets.String, dnsName string) (error) {
+ ips, err := net.LookupIP(dnsName)
+ if (err == nil) {
+ for _, ip := range ips {
+ s.Insert(ip.String())
+ }
+ }
+ return err
+}
+
+
+func shellOut(sendStdin, script string) {
+ log.Printf("execing: %v with stdin: %v", script, sendStdin)
+ // TODO: Switch to sending stdin from go
+ out, err := exec.Command("bash", "-c", fmt.Sprintf("echo -e '%v' | %v", sendStdin, script)).CombinedOutput()
+ if err != nil {
+ log.Fatalf("Failed to execute %v: %v, err: %v", script, string(out), err)
+ }
+ log.Print(string(out))
+}
+
+func main() {
+ flag.Parse()
+
+ ns := *namespace
+ if ns == "" {
+ ns = os.Getenv("POD_NAMESPACE")
+ }
+ if *svc == "" || ns == "" || (*onChange == "" && *onStart == "") {
+ log.Fatalf("Incomplete args, require -on-change and/or -on-start, -service and -ns or an env var for POD_NAMESPACE.")
+ }
+
+ hostname, err := os.Hostname()
+ if err != nil {
+ log.Fatalf("Failed to get hostname: %s", err)
+ }
+
+ matchIP := false
+ myName := strings.Join([]string{hostname, *svc, ns, svcLocalSuffix}, ".")
+ myIP := sets.NewString()
+ if (resolve(&myIP, myName) != nil) {
+ if (resolve(&myIP, hostname) != nil) {
+ log.Fatalf("Failed to resolve IP: %s", err)
+ } else {
+ myName = hostname
+ matchIP = true
+ }
+ }
+ log.Printf("MyName is: %v, MyIP is: %v, Match IP: %v.", myName, myIP.List(), matchIP)
+
+ script := *onStart
+ if script == "" {
+ script = *onChange
+ log.Printf("No on-start supplied, on-change %v will be applied on start.", script)
+ }
+ for newPeers, peers := sets.NewString(), sets.NewString(); script != ""; time.Sleep(pollPeriod) {
+ newPeers, err = lookup(*svc)
+ if err != nil {
+ log.Printf("%v", err)
+ continue
+ }
+ log.Printf("Peers is: %v.", newPeers.List())
+ if (newPeers.Equal(peers)) {
+ continue
+ }
+
+ if (!newPeers.Has(myName)) {
+ if (matchIP) {
+ peersIP := sets.NewString()
+ for _, peer := range(newPeers.List()) {
+ _ = resolve(&peersIP, peer)
+ }
+
+ newIP := peersIP.Intersection(myIP)
+ if (newIP.Len() == 0) {
+ continue
+ }
+ } else {
+ continue
+ }
+ }
+ peerList := newPeers.List()
+ sort.Strings(peerList)
+ log.Printf("Peer list updated\nwas %v\nnow %v", peers.List(), newPeers.List())
+ shellOut(strings.Join(peerList, "\n"), script)
+ peers = newPeers
+ script = *onChange
+ }
+ // TODO: Exit if there's no on-change?
+ log.Printf("Peer finder exiting")
+}
+
diff --git a/peer-finder/sets/BUILD b/peer-finder/sets/BUILD
new file mode 100644
index 0000000..ec2f234
--- /dev/null
+++ b/peer-finder/sets/BUILD
@@ -0,0 +1,71 @@
+package(default_visibility = ["//visibility:public"])
+
+load("@io_kubernetes_build//defs:go.bzl", "go_genrule")
+load(
+ "@io_bazel_rules_go//go:def.bzl",
+ "go_library",
+ "go_test",
+)
+
+go_library(
+ name = "go_default_library",
+ srcs = [
+ "byte.go",
+ "doc.go",
+ "empty.go",
+ "int.go",
+ "int64.go",
+ "string.go",
+ ],
+ importpath = "k8s.io/apimachinery/pkg/util/sets",
+)
+
+go_genrule(
+ name = "set-gen",
+ srcs = [
+ "//hack/boilerplate:boilerplate.go.txt",
+ ],
+ outs = [
+ "byte.go",
+ "doc.go",
+ "empty.go",
+ "int.go",
+ "int64.go",
+ "string.go",
+ ],
+ cmd = """
+$(location //vendor/k8s.io/code-generator/cmd/set-gen) \
+ --input-dirs ./vendor/k8s.io/apimachinery/pkg/util/sets/types \
+ --output-base $$(dirname $$(dirname $(location :byte.go))) \
+ --go-header-file $(location //hack/boilerplate:boilerplate.go.txt) \
+ --output-package sets
+ """,
+ go_deps = [
+ "//vendor/k8s.io/apimachinery/pkg/util/sets/types:go_default_library",
+ ],
+ tools = [
+ "//vendor/k8s.io/code-generator/cmd/set-gen",
+ ],
+)
+
+go_test(
+ name = "go_default_test",
+ srcs = ["set_test.go"],
+ embed = [":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/apimachinery/pkg/util/sets/types:all-srcs",
+ ],
+ tags = ["automanaged"],
+)
diff --git a/peer-finder/sets/byte.go b/peer-finder/sets/byte.go
new file mode 100644
index 0000000..a460e4b
--- /dev/null
+++ b/peer-finder/sets/byte.go
@@ -0,0 +1,203 @@
+/*
+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.
+*/
+
+// This file was autogenerated by set-gen. Do not edit it manually!
+
+package sets
+
+import (
+ "reflect"
+ "sort"
+)
+
+// sets.Byte is a set of bytes, implemented via map[byte]struct{} for minimal memory consumption.
+type Byte map[byte]Empty
+
+// New creates a Byte from a list of values.
+func NewByte(items ...byte) Byte {
+ ss := Byte{}
+ ss.Insert(items...)
+ return ss
+}
+
+// ByteKeySet creates a Byte from a keys of a map[byte](? extends interface{}).
+// If the value passed in is not actually a map, this will panic.
+func ByteKeySet(theMap interface{}) Byte {
+ v := reflect.ValueOf(theMap)
+ ret := Byte{}
+
+ for _, keyValue := range v.MapKeys() {
+ ret.Insert(keyValue.Interface().(byte))
+ }
+ return ret
+}
+
+// Insert adds items to the set.
+func (s Byte) Insert(items ...byte) {
+ for _, item := range items {
+ s[item] = Empty{}
+ }
+}
+
+// Delete removes all items from the set.
+func (s Byte) Delete(items ...byte) {
+ for _, item := range items {
+ delete(s, item)
+ }
+}
+
+// Has returns true if and only if item is contained in the set.
+func (s Byte) Has(item byte) bool {
+ _, contained := s[item]
+ return contained
+}
+
+// HasAll returns true if and only if all items are contained in the set.
+func (s Byte) HasAll(items ...byte) bool {
+ for _, item := range items {
+ if !s.Has(item) {
+ return false
+ }
+ }
+ return true
+}
+
+// HasAny returns true if any items are contained in the set.
+func (s Byte) HasAny(items ...byte) bool {
+ for _, item := range items {
+ if s.Has(item) {
+ return true
+ }
+ }
+ return false
+}
+
+// Difference returns a set of objects that are not in s2
+// For example:
+// s1 = {a1, a2, a3}
+// s2 = {a1, a2, a4, a5}
+// s1.Difference(s2) = {a3}
+// s2.Difference(s1) = {a4, a5}
+func (s Byte) Difference(s2 Byte) Byte {
+ result := NewByte()
+ for key := range s {
+ if !s2.Has(key) {
+ result.Insert(key)
+ }
+ }
+ return result
+}
+
+// Union returns a new set which includes items in either s1 or s2.
+// For example:
+// s1 = {a1, a2}
+// s2 = {a3, a4}
+// s1.Union(s2) = {a1, a2, a3, a4}
+// s2.Union(s1) = {a1, a2, a3, a4}
+func (s1 Byte) Union(s2 Byte) Byte {
+ result := NewByte()
+ for key := range s1 {
+ result.Insert(key)
+ }
+ for key := range s2 {
+ result.Insert(key)
+ }
+ return result
+}
+
+// Intersection returns a new set which includes the item in BOTH s1 and s2
+// For example:
+// s1 = {a1, a2}
+// s2 = {a2, a3}
+// s1.Intersection(s2) = {a2}
+func (s1 Byte) Intersection(s2 Byte) Byte {
+ var walk, other Byte
+ result := NewByte()
+ if s1.Len() < s2.Len() {
+ walk = s1
+ other = s2
+ } else {
+ walk = s2
+ other = s1
+ }
+ for key := range walk {
+ if other.Has(key) {
+ result.Insert(key)
+ }
+ }
+ return result
+}
+
+// IsSuperset returns true if and only if s1 is a superset of s2.
+func (s1 Byte) IsSuperset(s2 Byte) bool {
+ for item := range s2 {
+ if !s1.Has(item) {
+ return false
+ }
+ }
+ return true
+}
+
+// Equal returns true if and only if s1 is equal (as a set) to s2.
+// Two sets are equal if their membership is identical.
+// (In practice, this means same elements, order doesn't matter)
+func (s1 Byte) Equal(s2 Byte) bool {
+ return len(s1) == len(s2) && s1.IsSuperset(s2)
+}
+
+type sortableSliceOfByte []byte
+
+func (s sortableSliceOfByte) Len() int { return len(s) }
+func (s sortableSliceOfByte) Less(i, j int) bool { return lessByte(s[i], s[j]) }
+func (s sortableSliceOfByte) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
+
+// List returns the contents as a sorted byte slice.
+func (s Byte) List() []byte {
+ res := make(sortableSliceOfByte, 0, len(s))
+ for key := range s {
+ res = append(res, key)
+ }
+ sort.Sort(res)
+ return []byte(res)
+}
+
+// UnsortedList returns the slice with contents in random order.
+func (s Byte) UnsortedList() []byte {
+ res := make([]byte, 0, len(s))
+ for key := range s {
+ res = append(res, key)
+ }
+ return res
+}
+
+// Returns a single element from the set.
+func (s Byte) PopAny() (byte, bool) {
+ for key := range s {
+ s.Delete(key)
+ return key, true
+ }
+ var zeroValue byte
+ return zeroValue, false
+}
+
+// Len returns the size of the set.
+func (s Byte) Len() int {
+ return len(s)
+}
+
+func lessByte(lhs, rhs byte) bool {
+ return lhs < rhs
+}
diff --git a/peer-finder/sets/doc.go b/peer-finder/sets/doc.go
new file mode 100644
index 0000000..28a6a7d
--- /dev/null
+++ b/peer-finder/sets/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.
+*/
+
+// This file was autogenerated by set-gen. Do not edit it manually!
+
+// Package sets has auto-generated set types.
+package sets
diff --git a/peer-finder/sets/empty.go b/peer-finder/sets/empty.go
new file mode 100644
index 0000000..cd22b95
--- /dev/null
+++ b/peer-finder/sets/empty.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.
+*/
+
+// This file was autogenerated by set-gen. Do not edit it manually!
+
+package sets
+
+// Empty is public since it is used by some internal API objects for conversions between external
+// string arrays and internal sets, and conversion logic requires public types today.
+type Empty struct{}
diff --git a/peer-finder/sets/int.go b/peer-finder/sets/int.go
new file mode 100644
index 0000000..0614e9f
--- /dev/null
+++ b/peer-finder/sets/int.go
@@ -0,0 +1,203 @@
+/*
+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.
+*/
+
+// This file was autogenerated by set-gen. Do not edit it manually!
+
+package sets
+
+import (
+ "reflect"
+ "sort"
+)
+
+// sets.Int is a set of ints, implemented via map[int]struct{} for minimal memory consumption.
+type Int map[int]Empty
+
+// New creates a Int from a list of values.
+func NewInt(items ...int) Int {
+ ss := Int{}
+ ss.Insert(items...)
+ return ss
+}
+
+// IntKeySet creates a Int from a keys of a map[int](? extends interface{}).
+// If the value passed in is not actually a map, this will panic.
+func IntKeySet(theMap interface{}) Int {
+ v := reflect.ValueOf(theMap)
+ ret := Int{}
+
+ for _, keyValue := range v.MapKeys() {
+ ret.Insert(keyValue.Interface().(int))
+ }
+ return ret
+}
+
+// Insert adds items to the set.
+func (s Int) Insert(items ...int) {
+ for _, item := range items {
+ s[item] = Empty{}
+ }
+}
+
+// Delete removes all items from the set.
+func (s Int) Delete(items ...int) {
+ for _, item := range items {
+ delete(s, item)
+ }
+}
+
+// Has returns true if and only if item is contained in the set.
+func (s Int) Has(item int) bool {
+ _, contained := s[item]
+ return contained
+}
+
+// HasAll returns true if and only if all items are contained in the set.
+func (s Int) HasAll(items ...int) bool {
+ for _, item := range items {
+ if !s.Has(item) {
+ return false
+ }
+ }
+ return true
+}
+
+// HasAny returns true if any items are contained in the set.
+func (s Int) HasAny(items ...int) bool {
+ for _, item := range items {
+ if s.Has(item) {
+ return true
+ }
+ }
+ return false
+}
+
+// Difference returns a set of objects that are not in s2
+// For example:
+// s1 = {a1, a2, a3}
+// s2 = {a1, a2, a4, a5}
+// s1.Difference(s2) = {a3}
+// s2.Difference(s1) = {a4, a5}
+func (s Int) Difference(s2 Int) Int {
+ result := NewInt()
+ for key := range s {
+ if !s2.Has(key) {
+ result.Insert(key)
+ }
+ }
+ return result
+}
+
+// Union returns a new set which includes items in either s1 or s2.
+// For example:
+// s1 = {a1, a2}
+// s2 = {a3, a4}
+// s1.Union(s2) = {a1, a2, a3, a4}
+// s2.Union(s1) = {a1, a2, a3, a4}
+func (s1 Int) Union(s2 Int) Int {
+ result := NewInt()
+ for key := range s1 {
+ result.Insert(key)
+ }
+ for key := range s2 {
+ result.Insert(key)
+ }
+ return result
+}
+
+// Intersection returns a new set which includes the item in BOTH s1 and s2
+// For example:
+// s1 = {a1, a2}
+// s2 = {a2, a3}
+// s1.Intersection(s2) = {a2}
+func (s1 Int) Intersection(s2 Int) Int {
+ var walk, other Int
+ result := NewInt()
+ if s1.Len() < s2.Len() {
+ walk = s1
+ other = s2
+ } else {
+ walk = s2
+ other = s1
+ }
+ for key := range walk {
+ if other.Has(key) {
+ result.Insert(key)
+ }
+ }
+ return result
+}
+
+// IsSuperset returns true if and only if s1 is a superset of s2.
+func (s1 Int) IsSuperset(s2 Int) bool {
+ for item := range s2 {
+ if !s1.Has(item) {
+ return false
+ }
+ }
+ return true
+}
+
+// Equal returns true if and only if s1 is equal (as a set) to s2.
+// Two sets are equal if their membership is identical.
+// (In practice, this means same elements, order doesn't matter)
+func (s1 Int) Equal(s2 Int) bool {
+ return len(s1) == len(s2) && s1.IsSuperset(s2)
+}
+
+type sortableSliceOfInt []int
+
+func (s sortableSliceOfInt) Len() int { return len(s) }
+func (s sortableSliceOfInt) Less(i, j int) bool { return lessInt(s[i], s[j]) }
+func (s sortableSliceOfInt) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
+
+// List returns the contents as a sorted int slice.
+func (s Int) List() []int {
+ res := make(sortableSliceOfInt, 0, len(s))
+ for key := range s {
+ res = append(res, key)
+ }
+ sort.Sort(res)
+ return []int(res)
+}
+
+// UnsortedList returns the slice with contents in random order.
+func (s Int) UnsortedList() []int {
+ res := make([]int, 0, len(s))
+ for key := range s {
+ res = append(res, key)
+ }
+ return res
+}
+
+// Returns a single element from the set.
+func (s Int) PopAny() (int, bool) {
+ for key := range s {
+ s.Delete(key)
+ return key, true
+ }
+ var zeroValue int
+ return zeroValue, false
+}
+
+// Len returns the size of the set.
+func (s Int) Len() int {
+ return len(s)
+}
+
+func lessInt(lhs, rhs int) bool {
+ return lhs < rhs
+}
diff --git a/peer-finder/sets/int64.go b/peer-finder/sets/int64.go
new file mode 100644
index 0000000..82e1ba7
--- /dev/null
+++ b/peer-finder/sets/int64.go
@@ -0,0 +1,203 @@
+/*
+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.
+*/
+
+// This file was autogenerated by set-gen. Do not edit it manually!
+
+package sets
+
+import (
+ "reflect"
+ "sort"
+)
+
+// sets.Int64 is a set of int64s, implemented via map[int64]struct{} for minimal memory consumption.
+type Int64 map[int64]Empty
+
+// New creates a Int64 from a list of values.
+func NewInt64(items ...int64) Int64 {
+ ss := Int64{}
+ ss.Insert(items...)
+ return ss
+}
+
+// Int64KeySet creates a Int64 from a keys of a map[int64](? extends interface{}).
+// If the value passed in is not actually a map, this will panic.
+func Int64KeySet(theMap interface{}) Int64 {
+ v := reflect.ValueOf(theMap)
+ ret := Int64{}
+
+ for _, keyValue := range v.MapKeys() {
+ ret.Insert(keyValue.Interface().(int64))
+ }
+ return ret
+}
+
+// Insert adds items to the set.
+func (s Int64) Insert(items ...int64) {
+ for _, item := range items {
+ s[item] = Empty{}
+ }
+}
+
+// Delete removes all items from the set.
+func (s Int64) Delete(items ...int64) {
+ for _, item := range items {
+ delete(s, item)
+ }
+}
+
+// Has returns true if and only if item is contained in the set.
+func (s Int64) Has(item int64) bool {
+ _, contained := s[item]
+ return contained
+}
+
+// HasAll returns true if and only if all items are contained in the set.
+func (s Int64) HasAll(items ...int64) bool {
+ for _, item := range items {
+ if !s.Has(item) {
+ return false
+ }
+ }
+ return true
+}
+
+// HasAny returns true if any items are contained in the set.
+func (s Int64) HasAny(items ...int64) bool {
+ for _, item := range items {
+ if s.Has(item) {
+ return true
+ }
+ }
+ return false
+}
+
+// Difference returns a set of objects that are not in s2
+// For example:
+// s1 = {a1, a2, a3}
+// s2 = {a1, a2, a4, a5}
+// s1.Difference(s2) = {a3}
+// s2.Difference(s1) = {a4, a5}
+func (s Int64) Difference(s2 Int64) Int64 {
+ result := NewInt64()
+ for key := range s {
+ if !s2.Has(key) {
+ result.Insert(key)
+ }
+ }
+ return result
+}
+
+// Union returns a new set which includes items in either s1 or s2.
+// For example:
+// s1 = {a1, a2}
+// s2 = {a3, a4}
+// s1.Union(s2) = {a1, a2, a3, a4}
+// s2.Union(s1) = {a1, a2, a3, a4}
+func (s1 Int64) Union(s2 Int64) Int64 {
+ result := NewInt64()
+ for key := range s1 {
+ result.Insert(key)
+ }
+ for key := range s2 {
+ result.Insert(key)
+ }
+ return result
+}
+
+// Intersection returns a new set which includes the item in BOTH s1 and s2
+// For example:
+// s1 = {a1, a2}
+// s2 = {a2, a3}
+// s1.Intersection(s2) = {a2}
+func (s1 Int64) Intersection(s2 Int64) Int64 {
+ var walk, other Int64
+ result := NewInt64()
+ if s1.Len() < s2.Len() {
+ walk = s1
+ other = s2
+ } else {
+ walk = s2
+ other = s1
+ }
+ for key := range walk {
+ if other.Has(key) {
+ result.Insert(key)
+ }
+ }
+ return result
+}
+
+// IsSuperset returns true if and only if s1 is a superset of s2.
+func (s1 Int64) IsSuperset(s2 Int64) bool {
+ for item := range s2 {
+ if !s1.Has(item) {
+ return false
+ }
+ }
+ return true
+}
+
+// Equal returns true if and only if s1 is equal (as a set) to s2.
+// Two sets are equal if their membership is identical.
+// (In practice, this means same elements, order doesn't matter)
+func (s1 Int64) Equal(s2 Int64) bool {
+ return len(s1) == len(s2) && s1.IsSuperset(s2)
+}
+
+type sortableSliceOfInt64 []int64
+
+func (s sortableSliceOfInt64) Len() int { return len(s) }
+func (s sortableSliceOfInt64) Less(i, j int) bool { return lessInt64(s[i], s[j]) }
+func (s sortableSliceOfInt64) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
+
+// List returns the contents as a sorted int64 slice.
+func (s Int64) List() []int64 {
+ res := make(sortableSliceOfInt64, 0, len(s))
+ for key := range s {
+ res = append(res, key)
+ }
+ sort.Sort(res)
+ return []int64(res)
+}
+
+// UnsortedList returns the slice with contents in random order.
+func (s Int64) UnsortedList() []int64 {
+ res := make([]int64, 0, len(s))
+ for key := range s {
+ res = append(res, key)
+ }
+ return res
+}
+
+// Returns a single element from the set.
+func (s Int64) PopAny() (int64, bool) {
+ for key := range s {
+ s.Delete(key)
+ return key, true
+ }
+ var zeroValue int64
+ return zeroValue, false
+}
+
+// Len returns the size of the set.
+func (s Int64) Len() int {
+ return len(s)
+}
+
+func lessInt64(lhs, rhs int64) bool {
+ return lhs < rhs
+}
diff --git a/peer-finder/sets/set_test.go b/peer-finder/sets/set_test.go
new file mode 100644
index 0000000..df722ec
--- /dev/null
+++ b/peer-finder/sets/set_test.go
@@ -0,0 +1,270 @@
+/*
+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 sets
+
+import (
+ "reflect"
+ "testing"
+)
+
+func TestStringSet(t *testing.T) {
+ s := String{}
+ s2 := String{}
+ if len(s) != 0 {
+ t.Errorf("Expected len=0: %d", len(s))
+ }
+ s.Insert("a", "b")
+ if len(s) != 2 {
+ t.Errorf("Expected len=2: %d", len(s))
+ }
+ s.Insert("c")
+ if s.Has("d") {
+ t.Errorf("Unexpected contents: %#v", s)
+ }
+ if !s.Has("a") {
+ t.Errorf("Missing contents: %#v", s)
+ }
+ s.Delete("a")
+ if s.Has("a") {
+ t.Errorf("Unexpected contents: %#v", s)
+ }
+ s.Insert("a")
+ if s.HasAll("a", "b", "d") {
+ t.Errorf("Unexpected contents: %#v", s)
+ }
+ if !s.HasAll("a", "b") {
+ t.Errorf("Missing contents: %#v", s)
+ }
+ s2.Insert("a", "b", "d")
+ if s.IsSuperset(s2) {
+ t.Errorf("Unexpected contents: %#v", s)
+ }
+ s2.Delete("d")
+ if !s.IsSuperset(s2) {
+ t.Errorf("Missing contents: %#v", s)
+ }
+}
+
+func TestStringSetDeleteMultiples(t *testing.T) {
+ s := String{}
+ s.Insert("a", "b", "c")
+ if len(s) != 3 {
+ t.Errorf("Expected len=3: %d", len(s))
+ }
+
+ s.Delete("a", "c")
+ if len(s) != 1 {
+ t.Errorf("Expected len=1: %d", len(s))
+ }
+ if s.Has("a") {
+ t.Errorf("Unexpected contents: %#v", s)
+ }
+ if s.Has("c") {
+ t.Errorf("Unexpected contents: %#v", s)
+ }
+ if !s.Has("b") {
+ t.Errorf("Missing contents: %#v", s)
+ }
+
+}
+
+func TestNewStringSet(t *testing.T) {
+ s := NewString("a", "b", "c")
+ if len(s) != 3 {
+ t.Errorf("Expected len=3: %d", len(s))
+ }
+ if !s.Has("a") || !s.Has("b") || !s.Has("c") {
+ t.Errorf("Unexpected contents: %#v", s)
+ }
+}
+
+func TestStringSetList(t *testing.T) {
+ s := NewString("z", "y", "x", "a")
+ if !reflect.DeepEqual(s.List(), []string{"a", "x", "y", "z"}) {
+ t.Errorf("List gave unexpected result: %#v", s.List())
+ }
+}
+
+func TestStringSetDifference(t *testing.T) {
+ a := NewString("1", "2", "3")
+ b := NewString("1", "2", "4", "5")
+ c := a.Difference(b)
+ d := b.Difference(a)
+ if len(c) != 1 {
+ t.Errorf("Expected len=1: %d", len(c))
+ }
+ if !c.Has("3") {
+ t.Errorf("Unexpected contents: %#v", c.List())
+ }
+ if len(d) != 2 {
+ t.Errorf("Expected len=2: %d", len(d))
+ }
+ if !d.Has("4") || !d.Has("5") {
+ t.Errorf("Unexpected contents: %#v", d.List())
+ }
+}
+
+func TestStringSetHasAny(t *testing.T) {
+ a := NewString("1", "2", "3")
+
+ if !a.HasAny("1", "4") {
+ t.Errorf("expected true, got false")
+ }
+
+ if a.HasAny("0", "4") {
+ t.Errorf("expected false, got true")
+ }
+}
+
+func TestStringSetEquals(t *testing.T) {
+ // Simple case (order doesn't matter)
+ a := NewString("1", "2")
+ b := NewString("2", "1")
+ if !a.Equal(b) {
+ t.Errorf("Expected to be equal: %v vs %v", a, b)
+ }
+
+ // It is a set; duplicates are ignored
+ b = NewString("2", "2", "1")
+ if !a.Equal(b) {
+ t.Errorf("Expected to be equal: %v vs %v", a, b)
+ }
+
+ // Edge cases around empty sets / empty strings
+ a = NewString()
+ b = NewString()
+ if !a.Equal(b) {
+ t.Errorf("Expected to be equal: %v vs %v", a, b)
+ }
+
+ b = NewString("1", "2", "3")
+ if a.Equal(b) {
+ t.Errorf("Expected to be not-equal: %v vs %v", a, b)
+ }
+
+ b = NewString("1", "2", "")
+ if a.Equal(b) {
+ t.Errorf("Expected to be not-equal: %v vs %v", a, b)
+ }
+
+ // Check for equality after mutation
+ a = NewString()
+ a.Insert("1")
+ if a.Equal(b) {
+ t.Errorf("Expected to be not-equal: %v vs %v", a, b)
+ }
+
+ a.Insert("2")
+ if a.Equal(b) {
+ t.Errorf("Expected to be not-equal: %v vs %v", a, b)
+ }
+
+ a.Insert("")
+ if !a.Equal(b) {
+ t.Errorf("Expected to be equal: %v vs %v", a, b)
+ }
+
+ a.Delete("")
+ if a.Equal(b) {
+ t.Errorf("Expected to be not-equal: %v vs %v", a, b)
+ }
+}
+
+func TestStringUnion(t *testing.T) {
+ tests := []struct {
+ s1 String
+ s2 String
+ expected String
+ }{
+ {
+ NewString("1", "2", "3", "4"),
+ NewString("3", "4", "5", "6"),
+ NewString("1", "2", "3", "4", "5", "6"),
+ },
+ {
+ NewString("1", "2", "3", "4"),
+ NewString(),
+ NewString("1", "2", "3", "4"),
+ },
+ {
+ NewString(),
+ NewString("1", "2", "3", "4"),
+ NewString("1", "2", "3", "4"),
+ },
+ {
+ NewString(),
+ NewString(),
+ NewString(),
+ },
+ }
+
+ for _, test := range tests {
+ union := test.s1.Union(test.s2)
+ if union.Len() != test.expected.Len() {
+ t.Errorf("Expected union.Len()=%d but got %d", test.expected.Len(), union.Len())
+ }
+
+ if !union.Equal(test.expected) {
+ t.Errorf("Expected union.Equal(expected) but not true. union:%v expected:%v", union.List(), test.expected.List())
+ }
+ }
+}
+
+func TestStringIntersection(t *testing.T) {
+ tests := []struct {
+ s1 String
+ s2 String
+ expected String
+ }{
+ {
+ NewString("1", "2", "3", "4"),
+ NewString("3", "4", "5", "6"),
+ NewString("3", "4"),
+ },
+ {
+ NewString("1", "2", "3", "4"),
+ NewString("1", "2", "3", "4"),
+ NewString("1", "2", "3", "4"),
+ },
+ {
+ NewString("1", "2", "3", "4"),
+ NewString(),
+ NewString(),
+ },
+ {
+ NewString(),
+ NewString("1", "2", "3", "4"),
+ NewString(),
+ },
+ {
+ NewString(),
+ NewString(),
+ NewString(),
+ },
+ }
+
+ for _, test := range tests {
+ intersection := test.s1.Intersection(test.s2)
+ if intersection.Len() != test.expected.Len() {
+ t.Errorf("Expected intersection.Len()=%d but got %d", test.expected.Len(), intersection.Len())
+ }
+
+ if !intersection.Equal(test.expected) {
+ t.Errorf("Expected intersection.Equal(expected) but not true. intersection:%v expected:%v", intersection.List(), test.expected.List())
+ }
+ }
+}
diff --git a/peer-finder/sets/string.go b/peer-finder/sets/string.go
new file mode 100644
index 0000000..baef7a6
--- /dev/null
+++ b/peer-finder/sets/string.go
@@ -0,0 +1,203 @@
+/*
+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.
+*/
+
+// This file was autogenerated by set-gen. Do not edit it manually!
+
+package sets
+
+import (
+ "reflect"
+ "sort"
+)
+
+// sets.String is a set of strings, implemented via map[string]struct{} for minimal memory consumption.
+type String map[string]Empty
+
+// New creates a String from a list of values.
+func NewString(items ...string) String {
+ ss := String{}
+ ss.Insert(items...)
+ return ss
+}
+
+// StringKeySet creates a String from a keys of a map[string](? extends interface{}).
+// If the value passed in is not actually a map, this will panic.
+func StringKeySet(theMap interface{}) String {
+ v := reflect.ValueOf(theMap)
+ ret := String{}
+
+ for _, keyValue := range v.MapKeys() {
+ ret.Insert(keyValue.Interface().(string))
+ }
+ return ret
+}
+
+// Insert adds items to the set.
+func (s String) Insert(items ...string) {
+ for _, item := range items {
+ s[item] = Empty{}
+ }
+}
+
+// Delete removes all items from the set.
+func (s String) Delete(items ...string) {
+ for _, item := range items {
+ delete(s, item)
+ }
+}
+
+// Has returns true if and only if item is contained in the set.
+func (s String) Has(item string) bool {
+ _, contained := s[item]
+ return contained
+}
+
+// HasAll returns true if and only if all items are contained in the set.
+func (s String) HasAll(items ...string) bool {
+ for _, item := range items {
+ if !s.Has(item) {
+ return false
+ }
+ }
+ return true
+}
+
+// HasAny returns true if any items are contained in the set.
+func (s String) HasAny(items ...string) bool {
+ for _, item := range items {
+ if s.Has(item) {
+ return true
+ }
+ }
+ return false
+}
+
+// Difference returns a set of objects that are not in s2
+// For example:
+// s1 = {a1, a2, a3}
+// s2 = {a1, a2, a4, a5}
+// s1.Difference(s2) = {a3}
+// s2.Difference(s1) = {a4, a5}
+func (s String) Difference(s2 String) String {
+ result := NewString()
+ for key := range s {
+ if !s2.Has(key) {
+ result.Insert(key)
+ }
+ }
+ return result
+}
+
+// Union returns a new set which includes items in either s1 or s2.
+// For example:
+// s1 = {a1, a2}
+// s2 = {a3, a4}
+// s1.Union(s2) = {a1, a2, a3, a4}
+// s2.Union(s1) = {a1, a2, a3, a4}
+func (s1 String) Union(s2 String) String {
+ result := NewString()
+ for key := range s1 {
+ result.Insert(key)
+ }
+ for key := range s2 {
+ result.Insert(key)
+ }
+ return result
+}
+
+// Intersection returns a new set which includes the item in BOTH s1 and s2
+// For example:
+// s1 = {a1, a2}
+// s2 = {a2, a3}
+// s1.Intersection(s2) = {a2}
+func (s1 String) Intersection(s2 String) String {
+ var walk, other String
+ result := NewString()
+ if s1.Len() < s2.Len() {
+ walk = s1
+ other = s2
+ } else {
+ walk = s2
+ other = s1
+ }
+ for key := range walk {
+ if other.Has(key) {
+ result.Insert(key)
+ }
+ }
+ return result
+}
+
+// IsSuperset returns true if and only if s1 is a superset of s2.
+func (s1 String) IsSuperset(s2 String) bool {
+ for item := range s2 {
+ if !s1.Has(item) {
+ return false
+ }
+ }
+ return true
+}
+
+// Equal returns true if and only if s1 is equal (as a set) to s2.
+// Two sets are equal if their membership is identical.
+// (In practice, this means same elements, order doesn't matter)
+func (s1 String) Equal(s2 String) bool {
+ return len(s1) == len(s2) && s1.IsSuperset(s2)
+}
+
+type sortableSliceOfString []string
+
+func (s sortableSliceOfString) Len() int { return len(s) }
+func (s sortableSliceOfString) Less(i, j int) bool { return lessString(s[i], s[j]) }
+func (s sortableSliceOfString) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
+
+// List returns the contents as a sorted string slice.
+func (s String) List() []string {
+ res := make(sortableSliceOfString, 0, len(s))
+ for key := range s {
+ res = append(res, key)
+ }
+ sort.Sort(res)
+ return []string(res)
+}
+
+// UnsortedList returns the slice with contents in random order.
+func (s String) UnsortedList() []string {
+ res := make([]string, 0, len(s))
+ for key := range s {
+ res = append(res, key)
+ }
+ return res
+}
+
+// Returns a single element from the set.
+func (s String) PopAny() (string, bool) {
+ for key := range s {
+ s.Delete(key)
+ return key, true
+ }
+ var zeroValue string
+ return zeroValue, false
+}
+
+// Len returns the size of the set.
+func (s String) Len() int {
+ return len(s)
+}
+
+func lessString(lhs, rhs string) bool {
+ return lhs < rhs
+}
diff --git a/peer-finder/sets/types/BUILD b/peer-finder/sets/types/BUILD
new file mode 100644
index 0000000..50f7528
--- /dev/null
+++ b/peer-finder/sets/types/BUILD
@@ -0,0 +1,25 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+ "@io_bazel_rules_go//go:def.bzl",
+ "go_library",
+)
+
+go_library(
+ name = "go_default_library",
+ srcs = ["types.go"],
+ importpath = "k8s.io/apimachinery/pkg/util/sets/types",
+)
+
+filegroup(
+ name = "package-srcs",
+ srcs = glob(["**"]),
+ tags = ["automanaged"],
+ visibility = ["//visibility:private"],
+)
+
+filegroup(
+ name = "all-srcs",
+ srcs = [":package-srcs"],
+ tags = ["automanaged"],
+)
diff --git a/peer-finder/sets/types/types.go b/peer-finder/sets/types/types.go
new file mode 100644
index 0000000..4197356
--- /dev/null
+++ b/peer-finder/sets/types/types.go
@@ -0,0 +1,32 @@
+/*
+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 types just provides input types to the set generator. It also
+// contains a "go generate" block.
+// (You must first `go install k8s.io/code-generator/cmd/set-gen`)
+package types
+
+//go:generate set-gen -i k8s.io/kubernetes/pkg/util/sets/types
+
+type ReferenceSetTypes struct {
+ // These types all cause files to be generated.
+ // These types should be reflected in the output of
+ // the "//pkg/util/sets:set-gen" genrule.
+ a int64
+ b int
+ c byte
+ d string
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-08 12:41:43 +0000