clickhouse-operator/pkg/chop/configmaps_secret.go at 56a3c8842b630a34779abf0b4c7b1b7167dfe4e6 · Altinity/clickhouse-operator · GitHub

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
package chop

import (
	"context"
	"log"
	"os"

	corev1 "k8s.io/api/core/v1"
	apiErrors "k8s.io/apimachinery/pkg/api/errors"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	kube "k8s.io/client-go/kubernetes"
)

var cmNamePaths = map[string]string{
	"etc-clickhouse-operator-files":            "/etc/clickhouse-operator/",
	"etc-clickhouse-operator-confd-files":      "/etc/clickhouse-operator/conf.d/",
	"etc-clickhouse-operator-configd-files":    "/etc/clickhouse-operator/config.d/",
	"etc-clickhouse-operator-templatesd-files": "/etc/clickhouse-operator/templates.d/",
	"etc-clickhouse-operator-usersd-files":     "/etc/clickhouse-operator/users.d/",
}

func HandleConfigmapsCreation(kubeClient *kube.Clientset) error {
	var cm_namespace = os.Getenv("POD_NAMESPACE")

	for name, path := range cmNamePaths {
		_, err := kubeClient.CoreV1().ConfigMaps(cm_namespace).Get(context.TODO(), name, metav1.GetOptions{})

		if apiErrors.IsNotFound(err) {
			cm := makeConfigmap(name, path)
			_, err := kubeClient.CoreV1().ConfigMaps(cm.Namespace).Create(context.TODO(), cm, metav1.CreateOptions{})
			if err != nil {
				log.Printf("Creating ConfigMap %s/%s failed with error %v", cm.Namespace, cm.Name, err)
				return err
			}
		} else if err != nil {
			log.Printf("Error probing ConfigMap %s/%s with error %v", cm_namespace, name, err)
		} else {
			log.Printf("ConfigMap %s/%s already exists", cm_namespace, name)
		}
	}
	return nil
}

func makeConfigmap(name string, path string) *corev1.ConfigMap {
	configs := getConfigsFrom(path)

	cm := &corev1.ConfigMap{
		ObjectMeta: metav1.ObjectMeta{
			Name:      name,
			Namespace: os.Getenv("POD_NAMESPACE"),
		},
		Data: configs,
	}
	return cm
}

func getConfigsFrom(path string) map[string]string {
	configs := map[string]string{}

	files, err := os.ReadDir(path)
	if err != nil {
		log.Fatal(err)
	}

	for _, f := range files {
		if !f.IsDir() && f.Name() != ".gitkeep.xml" {
			dat, err := os.ReadFile(path + f.Name())
			if err != nil {
				log.Fatal(err.Error())
			}
			configs[f.Name()] = string(dat)
		}
	}

	return configs
}

func HandleSecretCreation(kubeClient *kube.Clientset) error {
	const secret_name = "clickhouse-operator"
	var secret_namespace = os.Getenv("POD_NAMESPACE")

	_, err := kubeClient.CoreV1().Secrets(secret_namespace).Get(context.TODO(), secret_name, metav1.GetOptions{})

	if apiErrors.IsNotFound(err) {
		secret := &corev1.Secret{
			ObjectMeta: metav1.ObjectMeta{
				Namespace: secret_namespace,
				Name:      secret_name,
			},
			StringData: map[string]string{
				"username": "clickhouse_operator",
				"password": "clickhouse_operator_password",
			},
			Type: corev1.SecretTypeOpaque,
		}

		_, err := kubeClient.CoreV1().Secrets(secret_namespace).Create(context.TODO(), secret, metav1.CreateOptions{})
		if err != nil {
			log.Printf("Creating Secret %s/%s failed with error %v", secret.Namespace, secret.Name, err)
			return err
		}
	} else if err != nil {
		log.Printf("Error probing Secret %s/%s with error %v", secret_namespace, secret_name, err)
		return err
	} else {
		log.Printf("Secret %s/%s already exists", secret_namespace, secret_name)
	}
	return nil
}