/
k8sconfig.go
237 lines (193 loc) · 5.96 KB
/
k8sconfig.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
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
package k8sinterface
import (
"context"
"fmt"
"strings"
logger "github.com/kubescape/go-logger"
"github.com/kubescape/go-logger/helpers"
"k8s.io/client-go/discovery"
"k8s.io/client-go/dynamic"
"k8s.io/client-go/kubernetes"
restclient "k8s.io/client-go/rest"
"k8s.io/client-go/tools/clientcmd"
clientcmdapi "k8s.io/client-go/tools/clientcmd/api"
// DO NOT REMOVE - load cloud providers auth
_ "k8s.io/client-go/plugin/pkg/client/auth"
"sigs.k8s.io/controller-runtime/pkg/client/config"
)
var connectedToCluster = true
var clusterContextName = ""
var ConfigClusterServerName = ""
var K8SGitServerVersion = ""
// K8SConfig pointer to k8s config
var K8SConfig *restclient.Config
var clientConfigAPI *clientcmdapi.Config
// KubernetesApi -
type KubernetesApi struct {
KubernetesClient kubernetes.Interface
DynamicClient dynamic.Interface
DiscoveryClient discovery.DiscoveryInterface
Context context.Context
K8SConfig *restclient.Config
}
// NewKubernetesApi -
func NewKubernetesApi() *KubernetesApi {
var kubernetesClient *kubernetes.Clientset
var err error
if !IsConnectedToCluster() {
logger.L().Fatal("failed to load kubernetes config: no configuration has been provided, try setting KUBECONFIG environment variable")
}
k8sConfig := GetK8sConfig()
kubernetesClient, err = kubernetes.NewForConfig(k8sConfig)
if err != nil {
logger.L().Fatal("failed to initialize a new kubernetes client", helpers.Error(err))
}
dynamicClient, err := dynamic.NewForConfig(k8sConfig)
if err != nil {
logger.L().Fatal("failed to initialize a new dynamic client", helpers.Error(err))
}
discoveryClient, err := discovery.NewDiscoveryClientForConfig(k8sConfig)
if err != nil {
logger.L().Fatal("failed to initialize a new discovery client", helpers.Error(err))
}
restclient.SetDefaultWarningHandler(restclient.NoWarnings{})
InitializeMapResources(discoveryClient)
return &KubernetesApi{
KubernetesClient: kubernetesClient,
DynamicClient: dynamicClient,
DiscoveryClient: discoveryClient,
Context: context.Background(),
K8SConfig: k8sConfig,
}
}
func (k8sAPI *KubernetesApi) GetKubernetesClient() kubernetes.Interface {
return k8sAPI.KubernetesClient
}
func (k8sAPI *KubernetesApi) GetDynamicClient() dynamic.Interface {
return k8sAPI.DynamicClient
}
func (k8sAPI *KubernetesApi) GetDiscoveryClient() discovery.DiscoveryInterface {
return k8sAPI.DiscoveryClient
}
// RunningIncluster whether running in cluster
var RunningIncluster bool
// LoadK8sConfig load config from local file or from cluster
func LoadK8sConfig() error {
kubeconfig, err := config.GetConfigWithContext(clusterContextName)
if err != nil {
return fmt.Errorf("failed to load kubernetes config: %s", strings.ReplaceAll(err.Error(), "KUBERNETES_MASTER", "KUBECONFIG"))
}
if _, err := restclient.InClusterConfig(); err == nil {
RunningIncluster = true
} else {
RunningIncluster = false
}
K8SConfig = kubeconfig
return nil
}
// GetK8sConfig get config. load if not loaded yet
func GetK8sConfig() *restclient.Config {
if !IsConnectedToCluster() {
return nil
}
return K8SConfig
}
func GetContext() *clientcmdapi.Context {
kubeConfig := GetConfig()
if kubeConfig == nil {
return nil
}
contextName := clusterContextName
if contextName == "" {
// if context name is not set, use the current context
contextName = kubeConfig.CurrentContext
}
if context, exist := kubeConfig.Contexts[contextName]; exist && context != nil {
// return the context
return context
}
return nil
}
func SetClientConfigAPI(conf *clientcmdapi.Config) {
clientConfigAPI = conf
}
func IsConnectedToCluster() bool {
if K8SConfig == nil {
if err := LoadK8sConfig(); err != nil {
SetConnectedToCluster(false)
}
}
return connectedToCluster
}
func GetContextName() string {
if clusterContextName != "" {
return clusterContextName
}
if config := GetConfig(); config != nil {
return config.CurrentContext
}
return ""
}
// get config from ~/.kube/config
func GetConfig() *clientcmdapi.Config {
if !connectedToCluster {
return nil
}
if clientConfigAPI != nil {
return clientConfigAPI
}
kubeConfig := clientcmd.NewNonInteractiveDeferredLoadingClientConfig(clientcmd.NewDefaultClientConfigLoadingRules(), &clientcmd.ConfigOverrides{CurrentContext: clusterContextName})
config, err := kubeConfig.RawConfig()
if err != nil {
return nil
}
// set the config to the global variable
SetClientConfigAPI(&config)
return &config
}
// GetDefaultNamespace returns the default namespace for the current context
func GetDefaultNamespace() string {
if context := GetContext(); context != nil {
return context.Namespace
}
// return default namespace in case the context is not available
return "default"
}
// GetCluster returns a pointer to the clientcmdapi Cluster object of the current context
func GetCluster() *clientcmdapi.Cluster {
config := GetConfig()
if config == nil {
return nil
}
if context, exist := config.Clusters[GetContextName()]; exist && context != nil {
// return the cluster as based on the context
return context
}
return nil
}
// SetClusterContextName set the name of desired cluster context. The package will use this name when loading the context
func SetClusterContextName(contextName string) {
clusterContextName = contextName
}
func SetK8SGitServerVersion(K8SGitServerVersionInput string) {
K8SGitServerVersion = K8SGitServerVersionInput
}
func SetConfigClusterServerName(contextName string) {
ConfigClusterServerName = contextName
}
// GetK8sConfigClusterServerName get the server name of desired cluster context
func GetK8sConfigClusterServerName() string {
config := GetConfig()
if config == nil {
return ""
}
if context, exist := config.Clusters[GetContextName()]; exist && context != nil {
// return the server name of the context
return context.Server
}
// return current context in case the server name is not available
return ConfigClusterServerName
}
func SetConnectedToCluster(isConnected bool) {
connectedToCluster = isConnected
}