new driver: kubernetes

Tested with `kind` and GKE.

Note: "nodes" shown in `docker buildx ls` are unrelated to Kubernetes "nodes".
Probably buildx should come up with an alternative term.

Usage:

  $ kind create cluster
  $ export KUBECONFIG="$(kind get kubeconfig-path --name="kind")"

  $ docker buildx create --driver kubernetes --driver-opt replicas=3 --use
  $ docker buildx build -t foo --load .

`--load` loads the image into the local Docker.

Driver opts:

  - `image=IMAGE` - Sets the container image to be used for running buildkit.
  - `namespace=NS` - Sets the Kubernetes namespace. Defaults to the current namespace.
  - `replicas=N` - Sets the number of `Pod` replicas. Defaults to 1.
  - `rootless=(true|false)` - Run the container as a non-root user without `securityContext.privileged`. Defaults to false.
  - `loadbalance=(sticky|random)` - Load-balancing strategy. If set to "sticky", the pod is chosen using the hash of the context path. Defaults to "sticky"

Signed-off-by: Akihiro Suda <akihiro.suda.cz@hco.ntt.co.jp>

vendor/github.com/serialx/hashring/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Sung-jin Hong
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vendor/github.com/serialx/hashring/README.md

@@ -0,0 +1,70 @@
+hashring
+============================
+
+Implements consistent hashing that can be used when
+the number of server nodes can increase or decrease (like in memcached).
+The hashing ring is built using the same algorithm as libketama.
+
+This is a port of Python hash_ring library <https://pypi.python.org/pypi/hash_ring/>
+in Go with the extra methods to add and remove nodes.
+
+
+Using
+============================
+
+Importing ::
+
+```go
+import "github.com/serialx/hashring"
+```
+
+Basic example usage ::
+
+```go
+memcacheServers := []string{"192.168.0.246:11212",
+                            "192.168.0.247:11212",
+                            "192.168.0.249:11212"}
+
+ring := hashring.New(memcacheServers)
+server, _ := ring.GetNode("my_key")
+```
+
+To fulfill replication requirements, you can also get a list of servers that should store your key.
+```go
+serversInRing := []string{"192.168.0.246:11212",
+                          "192.168.0.247:11212",
+                          "192.168.0.248:11212",
+                          "192.168.0.249:11212",
+                          "192.168.0.250:11212",
+                          "192.168.0.251:11212",
+                          "192.168.0.252:11212"}
+
+replicaCount := 3
+ring := hashring.New(serversInRing)
+server, _ := ring.GetNodes("my_key", replicaCount)
+```
+
+Using weights example ::
+
+```go
+weights := make(map[string]int)
+weights["192.168.0.246:11212"] = 1
+weights["192.168.0.247:11212"] = 2
+weights["192.168.0.249:11212"] = 1
+
+ring := hashring.NewWithWeights(weights)
+server, _ := ring.GetNode("my_key")
+```
+
+Adding and removing nodes example ::
+
+```go
+memcacheServers := []string{"192.168.0.246:11212",
+                            "192.168.0.247:11212",
+                            "192.168.0.249:11212"}
+
+ring := hashring.New(memcacheServers)
+ring = ring.RemoveNode("192.168.0.246:11212")
+ring = ring.AddNode("192.168.0.250:11212")
+server, _ := ring.GetNode("my_key")
+```

vendor/github.com/serialx/hashring/hashring.go

@@ -0,0 +1,268 @@
+package hashring
+
+import (
+	"crypto/md5"
+	"math"
+	"sort"
+	"strconv"
+)
+
+type HashKey uint32
+type HashKeyOrder []HashKey
+
+func (h HashKeyOrder) Len() int           { return len(h) }
+func (h HashKeyOrder) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }
+func (h HashKeyOrder) Less(i, j int) bool { return h[i] < h[j] }
+
+type HashRing struct {
+	ring       map[HashKey]string
+	sortedKeys []HashKey
+	nodes      []string
+	weights    map[string]int
+}
+
+func New(nodes []string) *HashRing {
+	hashRing := &HashRing{
+		ring:       make(map[HashKey]string),
+		sortedKeys: make([]HashKey, 0),
+		nodes:      nodes,
+		weights:    make(map[string]int),
+	}
+	hashRing.generateCircle()
+	return hashRing
+}
+
+func NewWithWeights(weights map[string]int) *HashRing {
+	nodes := make([]string, 0, len(weights))
+	for node, _ := range weights {
+		nodes = append(nodes, node)
+	}
+	hashRing := &HashRing{
+		ring:       make(map[HashKey]string),
+		sortedKeys: make([]HashKey, 0),
+		nodes:      nodes,
+		weights:    weights,
+	}
+	hashRing.generateCircle()
+	return hashRing
+}
+
+func (h *HashRing) Size() int {
+	return len(h.nodes)
+}
+
+func (h *HashRing) UpdateWithWeights(weights map[string]int) {
+	nodesChgFlg := false
+	if len(weights) != len(h.weights) {
+		nodesChgFlg = true
+	} else {
+		for node, newWeight := range weights {
+			oldWeight, ok := h.weights[node]
+			if !ok || oldWeight != newWeight {
+				nodesChgFlg = true
+				break
+			}
+		}
+	}
+
+	if nodesChgFlg {
+		newhring := NewWithWeights(weights)
+		h.weights = newhring.weights
+		h.nodes = newhring.nodes
+		h.ring = newhring.ring
+		h.sortedKeys = newhring.sortedKeys
+	}
+}
+
+func (h *HashRing) generateCircle() {
+	totalWeight := 0
+	for _, node := range h.nodes {
+		if weight, ok := h.weights[node]; ok {
+			totalWeight += weight
+		} else {
+			totalWeight += 1
+			h.weights[node] = 1
+		}
+	}
+
+	for _, node := range h.nodes {
+		weight := h.weights[node]
+
+		factor := math.Floor(float64(40*len(h.nodes)*weight) / float64(totalWeight))
+
+		for j := 0; j < int(factor); j++ {
+			nodeKey := node + "-" + strconv.FormatInt(int64(j), 10)
+			bKey := hashDigest(nodeKey)
+
+			for i := 0; i < 3; i++ {
+				key := hashVal(bKey[i*4 : i*4+4])
+				h.ring[key] = node
+				h.sortedKeys = append(h.sortedKeys, key)
+			}
+		}
+	}
+
+	sort.Sort(HashKeyOrder(h.sortedKeys))
+}
+
+func (h *HashRing) GetNode(stringKey string) (node string, ok bool) {
+	pos, ok := h.GetNodePos(stringKey)
+	if !ok {
+		return "", false
+	}
+	return h.ring[h.sortedKeys[pos]], true
+}
+
+func (h *HashRing) GetNodePos(stringKey string) (pos int, ok bool) {
+	if len(h.ring) == 0 {
+		return 0, false
+	}
+
+	key := h.GenKey(stringKey)
+
+	nodes := h.sortedKeys
+	pos = sort.Search(len(nodes), func(i int) bool { return nodes[i] > key })
+
+	if pos == len(nodes) {
+		// Wrap the search, should return first node
+		return 0, true
+	} else {
+		return pos, true
+	}
+}
+
+func (h *HashRing) GenKey(key string) HashKey {
+	bKey := hashDigest(key)
+	return hashVal(bKey[0:4])
+}
+
+func (h *HashRing) GetNodes(stringKey string, size int) (nodes []string, ok bool) {
+	pos, ok := h.GetNodePos(stringKey)
+	if !ok {
+		return nil, false
+	}
+
+	if size > len(h.nodes) {
+		return nil, false
+	}
+
+	returnedValues := make(map[string]bool, size)
+	//mergedSortedKeys := append(h.sortedKeys[pos:], h.sortedKeys[:pos]...)
+	resultSlice := make([]string, 0, size)
+
+	for i := pos; i < pos+len(h.sortedKeys); i++ {
+		key := h.sortedKeys[i%len(h.sortedKeys)]
+		val := h.ring[key]
+		if !returnedValues[val] {
+			returnedValues[val] = true
+			resultSlice = append(resultSlice, val)
+		}
+		if len(returnedValues) == size {
+			break
+		}
+	}
+
+	return resultSlice, len(resultSlice) == size
+}
+
+func (h *HashRing) AddNode(node string) *HashRing {
+	return h.AddWeightedNode(node, 1)
+}
+
+func (h *HashRing) AddWeightedNode(node string, weight int) *HashRing {
+	if weight <= 0 {
+		return h
+	}
+
+	if _, ok := h.weights[node]; ok {
+		return h
+	}
+
+	nodes := make([]string, len(h.nodes), len(h.nodes)+1)
+	copy(nodes, h.nodes)
+	nodes = append(nodes, node)
+
+	weights := make(map[string]int)
+	for eNode, eWeight := range h.weights {
+		weights[eNode] = eWeight
+	}
+	weights[node] = weight
+
+	hashRing := &HashRing{
+		ring:       make(map[HashKey]string),
+		sortedKeys: make([]HashKey, 0),
+		nodes:      nodes,
+		weights:    weights,
+	}
+	hashRing.generateCircle()
+	return hashRing
+}
+
+func (h *HashRing) UpdateWeightedNode(node string, weight int) *HashRing {
+	if weight <= 0 {
+		return h
+	}
+
+	/* node is not need to update for node is not existed or weight is not changed */
+	if oldWeight, ok := h.weights[node]; (!ok) || (ok && oldWeight == weight) {
+		return h
+	}
+
+	nodes := make([]string, len(h.nodes), len(h.nodes))
+	copy(nodes, h.nodes)
+
+	weights := make(map[string]int)
+	for eNode, eWeight := range h.weights {
+		weights[eNode] = eWeight
+	}
+	weights[node] = weight
+
+	hashRing := &HashRing{
+		ring:       make(map[HashKey]string),
+		sortedKeys: make([]HashKey, 0),
+		nodes:      nodes,
+		weights:    weights,
+	}
+	hashRing.generateCircle()
+	return hashRing
+}
+func (h *HashRing) RemoveNode(node string) *HashRing {
+	/* if node isn't exist in hashring, don't refresh hashring */
+	if _, ok := h.weights[node]; !ok {
+		return h
+	}
+
+	nodes := make([]string, 0)
+	for _, eNode := range h.nodes {
+		if eNode != node {
+			nodes = append(nodes, eNode)
+		}
+	}
+
+	weights := make(map[string]int)
+	for eNode, eWeight := range h.weights {
+		if eNode != node {
+			weights[eNode] = eWeight
+		}
+	}
+
+	hashRing := &HashRing{
+		ring:       make(map[HashKey]string),
+		sortedKeys: make([]HashKey, 0),
+		nodes:      nodes,
+		weights:    weights,
+	}
+	hashRing.generateCircle()
+	return hashRing
+}
+
+func hashVal(bKey []byte) HashKey {
+	return ((HashKey(bKey[3]) << 24) |
+		(HashKey(bKey[2]) << 16) |
+		(HashKey(bKey[1]) << 8) |
+		(HashKey(bKey[0])))
+}
+
+func hashDigest(key string) [md5.Size]byte {
+	return md5.Sum([]byte(key))
+}