-
Notifications
You must be signed in to change notification settings - Fork 875
/
keys.go
118 lines (94 loc) · 3.05 KB
/
keys.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
package keys
import (
"fmt"
"k8s.io/apimachinery/pkg/api/meta"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/apimachinery/pkg/runtime/schema"
"k8s.io/klog/v2"
)
// ClusterWideKey is the object key which is a unique identifier under a cluster, across all resources.
type ClusterWideKey struct {
// Group is the API Group of resource being referenced.
Group string
// Version is the API Version of the resource being referenced.
Version string
// Kind is the type of resource being referenced.
Kind string
// Namespace is the name of a namespace.
Namespace string
// Name is the name of resource being referenced.
Name string
}
// String returns the key's printable info with format:
// "<GroupVersion>, kind=<Kind>, <NamespaceKey>"
func (k ClusterWideKey) String() string {
return fmt.Sprintf("%s, kind=%s, %s", k.GroupVersion().String(), k.Kind, k.NamespaceKey())
}
// NamespaceKey returns the traditional key of a object.
func (k *ClusterWideKey) NamespaceKey() string {
if len(k.Namespace) > 0 {
return k.Namespace + "/" + k.Name
}
return k.Name
}
// GroupVersionKind returns the group, version, and kind of resource being referenced.
func (k *ClusterWideKey) GroupVersionKind() schema.GroupVersionKind {
return schema.GroupVersionKind{
Group: k.Group,
Version: k.Version,
Kind: k.Kind,
}
}
// GroupVersion returns the group and version of resource being referenced.
func (k *ClusterWideKey) GroupVersion() schema.GroupVersion {
return schema.GroupVersion{
Group: k.Group,
Version: k.Version,
}
}
// ClusterWideKeyFunc generates a ClusterWideKey for object.
func ClusterWideKeyFunc(obj interface{}) (ClusterWideKey, error) {
key := ClusterWideKey{}
runtimeObject, ok := obj.(runtime.Object)
if !ok {
klog.Errorf("Invalid object")
return key, fmt.Errorf("not runtime object")
}
metaInfo, err := meta.Accessor(obj)
if err != nil { // should not happen
return key, fmt.Errorf("object has no meta: %v", err)
}
gvk := runtimeObject.GetObjectKind().GroupVersionKind()
key.Group = gvk.Group
key.Version = gvk.Version
key.Kind = gvk.Kind
key.Namespace = metaInfo.GetNamespace()
key.Name = metaInfo.GetName()
return key, nil
}
// FederatedKey is the object key which is a unique identifier across all clusters in federation.
type FederatedKey struct {
// Cluster is the cluster name of the referencing object.
Cluster string
ClusterWideKey
}
// String returns the key's printable info with format:
// "cluster=<Cluster>, <GroupVersion>, kind=<Kind>, <NamespaceKey>"
func (f FederatedKey) String() string {
return fmt.Sprintf("cluster=%s, %s, kind=%s, %s", f.Cluster, f.GroupVersion().String(), f.Kind, f.NamespaceKey())
}
// FederatedKeyFunc generates a FederatedKey for object.
func FederatedKeyFunc(cluster string, obj interface{}) (FederatedKey, error) {
key := FederatedKey{}
if len(cluster) == 0 {
return key, fmt.Errorf("empty cluster name is not allowed")
}
cwk, err := ClusterWideKeyFunc(obj)
if err != nil {
klog.Errorf("Invalid object")
return key, err
}
key.Cluster = cluster
key.ClusterWideKey = cwk
return key, nil
}