forked from kubernetes/kops
/
tagbuilder.go
140 lines (116 loc) · 3.48 KB
/
tagbuilder.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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
package cloudup
import (
"fmt"
"github.com/golang/glog"
"k8s.io/kops/upup/pkg/api"
"k8s.io/kops/upup/pkg/fi"
)
func buildCloudupTags(cluster *api.Cluster) (map[string]struct{}, error) {
// TODO: Make these configurable?
useMasterASG := true
useMasterLB := false
tags := make(map[string]struct{})
networking := cluster.Spec.Networking
if networking == nil || networking.Classic != nil {
tags["_networking_classic"] = struct{}{}
} else if networking.Kubenet != nil {
tags["_networking_kubenet"] = struct{}{}
} else if networking.External != nil {
// external is based on kubenet
tags["_networking_kubenet"] = struct{}{}
tags["_networking_external"] = struct{}{}
} else {
return nil, fmt.Errorf("No networking mode set")
}
if useMasterASG {
tags["_master_asg"] = struct{}{}
} else {
tags["_master_single"] = struct{}{}
}
if useMasterLB {
tags["_master_lb"] = struct{}{}
} else {
tags["_not_master_lb"] = struct{}{}
}
if cluster.Spec.MasterPublicName != "" {
tags["_master_dns"] = struct{}{}
}
if fi.BoolValue(cluster.Spec.IsolateMasters) {
tags["_isolate_masters"] = struct{}{}
}
switch cluster.Spec.CloudProvider {
case "gce":
{
glog.Fatalf("GCE is (probably) not working currently - please ping @justinsb for cleanup")
tags["_gce"] = struct{}{}
}
case "aws":
{
tags["_aws"] = struct{}{}
}
default:
return nil, fmt.Errorf("unknown CloudProvider %q", cluster.Spec.CloudProvider)
}
versionTag := ""
if cluster.Spec.KubernetesVersion != "" {
sv, err := api.ParseKubernetesVersion(cluster.Spec.KubernetesVersion)
if err != nil {
return nil, fmt.Errorf("unable to determine kubernetes version from %q", cluster.Spec.KubernetesVersion)
}
if sv.Major == 1 && sv.Minor >= 5 {
versionTag = "_k8s_1_5"
} else if sv.Major == 1 && sv.Minor == 4 {
versionTag = "_k8s_1_4"
} else {
// We don't differentiate between these older versions
versionTag = "_k8s_1_3"
}
}
if versionTag == "" {
return nil, fmt.Errorf("unable to determine kubernetes version from %q", cluster.Spec.KubernetesVersion)
} else {
tags[versionTag] = struct{}{}
}
return tags, nil
}
func buildNodeupTags(role api.InstanceGroupRole, cluster *api.Cluster, clusterTags map[string]struct{}) ([]string, error) {
var tags []string
switch role {
case api.InstanceGroupRoleNode:
tags = append(tags, "_kubernetes_pool")
// TODO: Should we run _protokube on the nodes?
tags = append(tags, "_protokube")
case api.InstanceGroupRoleMaster:
tags = append(tags, "_kubernetes_master")
if !fi.BoolValue(cluster.Spec.IsolateMasters) {
// Run this master as a pool node also (start kube-proxy etc)
tags = append(tags, "_kubernetes_pool")
}
tags = append(tags, "_protokube")
default:
return nil, fmt.Errorf("Unrecognized role: %v", role)
}
// TODO: Replace with list of CNI plugins ?
if usesCNI(cluster) {
tags = append(tags, "_cni_bridge")
tags = append(tags, "_cni_host_local")
tags = append(tags, "_cni_loopback")
tags = append(tags, "_cni_ptp")
//tags = append(tags, "_cni_tuning")
}
switch fi.StringValue(cluster.Spec.UpdatePolicy) {
case "": // default
tags = append(tags, "_automatic_upgrades")
case api.UpdatePolicyExternal:
// Skip applying the tag
default:
glog.Warningf("Unrecognized value for UpdatePolicy: %v", fi.StringValue(cluster.Spec.UpdatePolicy))
}
if _, found := clusterTags["_gce"]; found {
tags = append(tags, "_gce")
}
if _, found := clusterTags["_aws"]; found {
tags = append(tags, "_aws")
}
return tags, nil
}