mirror of
https://github.com/stakater/Reloader.git
synced 2026-05-17 06:06:39 +00:00
341 lines
11 KiB
Go
341 lines
11 KiB
Go
package utils
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"strings"
|
|
"time"
|
|
|
|
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
|
|
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
|
|
"k8s.io/apimachinery/pkg/util/wait"
|
|
"k8s.io/client-go/dynamic"
|
|
)
|
|
|
|
// DeploymentConfigAdapter implements WorkloadAdapter for OpenShift DeploymentConfigs.
|
|
type DeploymentConfigAdapter struct {
|
|
dynamicClient dynamic.Interface
|
|
}
|
|
|
|
// NewDeploymentConfigAdapter creates a new DeploymentConfigAdapter.
|
|
func NewDeploymentConfigAdapter(dynamicClient dynamic.Interface) *DeploymentConfigAdapter {
|
|
return &DeploymentConfigAdapter{dynamicClient: dynamicClient}
|
|
}
|
|
|
|
// Type returns the workload type.
|
|
func (a *DeploymentConfigAdapter) Type() WorkloadType {
|
|
return WorkloadDeploymentConfig
|
|
}
|
|
|
|
// Create creates a DeploymentConfig with the given config.
|
|
func (a *DeploymentConfigAdapter) Create(ctx context.Context, namespace, name string, cfg WorkloadConfig) error {
|
|
opts := buildDCOptions(cfg)
|
|
return CreateDeploymentConfig(ctx, a.dynamicClient, namespace, name, opts...)
|
|
}
|
|
|
|
// Delete removes the DeploymentConfig.
|
|
func (a *DeploymentConfigAdapter) Delete(ctx context.Context, namespace, name string) error {
|
|
return DeleteDeploymentConfig(ctx, a.dynamicClient, namespace, name)
|
|
}
|
|
|
|
// WaitReady waits for the DeploymentConfig to be ready.
|
|
func (a *DeploymentConfigAdapter) WaitReady(ctx context.Context, namespace, name string, timeout time.Duration) error {
|
|
return WaitForDeploymentConfigReady(ctx, a.dynamicClient, namespace, name, timeout)
|
|
}
|
|
|
|
// WaitReloaded waits for the DeploymentConfig to have the reload annotation.
|
|
func (a *DeploymentConfigAdapter) WaitReloaded(ctx context.Context, namespace, name, annotationKey string, timeout time.Duration) (bool, error) {
|
|
return WaitForDeploymentConfigReloaded(ctx, a.dynamicClient, namespace, name, annotationKey, timeout)
|
|
}
|
|
|
|
// WaitEnvVar waits for the DeploymentConfig to have a STAKATER_ env var.
|
|
func (a *DeploymentConfigAdapter) WaitEnvVar(ctx context.Context, namespace, name, prefix string, timeout time.Duration) (bool, error) {
|
|
return WaitForDeploymentConfigEnvVar(ctx, a.dynamicClient, namespace, name, prefix, timeout)
|
|
}
|
|
|
|
// SupportsEnvVarStrategy returns true as DeploymentConfigs support env var reload strategy.
|
|
func (a *DeploymentConfigAdapter) SupportsEnvVarStrategy() bool {
|
|
return true
|
|
}
|
|
|
|
// RequiresSpecialHandling returns false as DeploymentConfigs use standard rolling restart.
|
|
func (a *DeploymentConfigAdapter) RequiresSpecialHandling() bool {
|
|
return false
|
|
}
|
|
|
|
// buildDCOptions converts WorkloadConfig to DCOption slice.
|
|
func buildDCOptions(cfg WorkloadConfig) []DCOption {
|
|
var opts []DCOption
|
|
|
|
// Add annotations (to pod template)
|
|
if len(cfg.Annotations) > 0 {
|
|
opts = append(opts, WithDCAnnotations(cfg.Annotations))
|
|
}
|
|
|
|
// Add envFrom references
|
|
if cfg.UseConfigMapEnvFrom && cfg.ConfigMapName != "" {
|
|
opts = append(opts, WithDCConfigMapEnvFrom(cfg.ConfigMapName))
|
|
}
|
|
if cfg.UseSecretEnvFrom && cfg.SecretName != "" {
|
|
opts = append(opts, WithDCSecretEnvFrom(cfg.SecretName))
|
|
}
|
|
|
|
// Add volume mounts
|
|
if cfg.UseConfigMapVolume && cfg.ConfigMapName != "" {
|
|
opts = append(opts, WithDCConfigMapVolume(cfg.ConfigMapName))
|
|
}
|
|
if cfg.UseSecretVolume && cfg.SecretName != "" {
|
|
opts = append(opts, WithDCSecretVolume(cfg.SecretName))
|
|
}
|
|
|
|
// Add projected volume
|
|
if cfg.UseProjectedVolume {
|
|
opts = append(opts, WithDCProjectedVolume(cfg.ConfigMapName, cfg.SecretName))
|
|
}
|
|
|
|
// Add valueFrom references
|
|
if cfg.UseConfigMapKeyRef && cfg.ConfigMapName != "" {
|
|
key := cfg.ConfigMapKey
|
|
if key == "" {
|
|
key = "key"
|
|
}
|
|
envVar := cfg.EnvVarName
|
|
if envVar == "" {
|
|
envVar = "CONFIG_VAR"
|
|
}
|
|
opts = append(opts, WithDCConfigMapKeyRef(cfg.ConfigMapName, key, envVar))
|
|
}
|
|
if cfg.UseSecretKeyRef && cfg.SecretName != "" {
|
|
key := cfg.SecretKey
|
|
if key == "" {
|
|
key = "key"
|
|
}
|
|
envVar := cfg.EnvVarName
|
|
if envVar == "" {
|
|
envVar = "SECRET_VAR"
|
|
}
|
|
opts = append(opts, WithDCSecretKeyRef(cfg.SecretName, key, envVar))
|
|
}
|
|
|
|
// Add init container with envFrom
|
|
if cfg.UseInitContainer {
|
|
opts = append(opts, WithDCInitContainer(cfg.ConfigMapName, cfg.SecretName))
|
|
}
|
|
|
|
// Add init container with volume mount
|
|
if cfg.UseInitContainerVolume {
|
|
opts = append(opts, WithDCInitContainerVolume(cfg.ConfigMapName, cfg.SecretName))
|
|
}
|
|
|
|
return opts
|
|
}
|
|
|
|
// WithDCProjectedVolume adds a projected volume with ConfigMap and/or Secret sources to a DeploymentConfig.
|
|
func WithDCProjectedVolume(cmName, secretName string) DCOption {
|
|
return func(dc *unstructured.Unstructured) {
|
|
volumeName := "projected-config"
|
|
sources := []interface{}{}
|
|
|
|
if cmName != "" {
|
|
sources = append(sources, map[string]interface{}{
|
|
"configMap": map[string]interface{}{
|
|
"name": cmName,
|
|
},
|
|
})
|
|
}
|
|
if secretName != "" {
|
|
sources = append(sources, map[string]interface{}{
|
|
"secret": map[string]interface{}{
|
|
"name": secretName,
|
|
},
|
|
})
|
|
}
|
|
|
|
// Add volume
|
|
volumes, _, _ := unstructured.NestedSlice(dc.Object, "spec", "template", "spec", "volumes")
|
|
volumes = append(volumes, map[string]interface{}{
|
|
"name": volumeName,
|
|
"projected": map[string]interface{}{
|
|
"sources": sources,
|
|
},
|
|
})
|
|
_ = unstructured.SetNestedSlice(dc.Object, volumes, "spec", "template", "spec", "volumes")
|
|
|
|
// Add volumeMount
|
|
containers, _, _ := unstructured.NestedSlice(dc.Object, "spec", "template", "spec", "containers")
|
|
if len(containers) > 0 {
|
|
container := containers[0].(map[string]interface{})
|
|
volumeMounts, _, _ := unstructured.NestedSlice(container, "volumeMounts")
|
|
volumeMounts = append(volumeMounts, map[string]interface{}{
|
|
"name": volumeName,
|
|
"mountPath": "/etc/projected",
|
|
})
|
|
container["volumeMounts"] = volumeMounts
|
|
containers[0] = container
|
|
_ = unstructured.SetNestedSlice(dc.Object, containers, "spec", "template", "spec", "containers")
|
|
}
|
|
}
|
|
}
|
|
|
|
// WithDCConfigMapKeyRef adds an env var with valueFrom.configMapKeyRef to a DeploymentConfig.
|
|
func WithDCConfigMapKeyRef(cmName, key, envVarName string) DCOption {
|
|
return func(dc *unstructured.Unstructured) {
|
|
containers, _, _ := unstructured.NestedSlice(dc.Object, "spec", "template", "spec", "containers")
|
|
if len(containers) > 0 {
|
|
container := containers[0].(map[string]interface{})
|
|
env, _, _ := unstructured.NestedSlice(container, "env")
|
|
env = append(env, map[string]interface{}{
|
|
"name": envVarName,
|
|
"valueFrom": map[string]interface{}{
|
|
"configMapKeyRef": map[string]interface{}{
|
|
"name": cmName,
|
|
"key": key,
|
|
},
|
|
},
|
|
})
|
|
container["env"] = env
|
|
containers[0] = container
|
|
_ = unstructured.SetNestedSlice(dc.Object, containers, "spec", "template", "spec", "containers")
|
|
}
|
|
}
|
|
}
|
|
|
|
// WithDCSecretKeyRef adds an env var with valueFrom.secretKeyRef to a DeploymentConfig.
|
|
func WithDCSecretKeyRef(secretName, key, envVarName string) DCOption {
|
|
return func(dc *unstructured.Unstructured) {
|
|
containers, _, _ := unstructured.NestedSlice(dc.Object, "spec", "template", "spec", "containers")
|
|
if len(containers) > 0 {
|
|
container := containers[0].(map[string]interface{})
|
|
env, _, _ := unstructured.NestedSlice(container, "env")
|
|
env = append(env, map[string]interface{}{
|
|
"name": envVarName,
|
|
"valueFrom": map[string]interface{}{
|
|
"secretKeyRef": map[string]interface{}{
|
|
"name": secretName,
|
|
"key": key,
|
|
},
|
|
},
|
|
})
|
|
container["env"] = env
|
|
containers[0] = container
|
|
_ = unstructured.SetNestedSlice(dc.Object, containers, "spec", "template", "spec", "containers")
|
|
}
|
|
}
|
|
}
|
|
|
|
// WithDCInitContainer adds an init container that references ConfigMap and/or Secret via envFrom.
|
|
func WithDCInitContainer(cmName, secretName string) DCOption {
|
|
return func(dc *unstructured.Unstructured) {
|
|
initContainer := map[string]interface{}{
|
|
"name": "init",
|
|
"image": DefaultImage,
|
|
"command": []interface{}{"sh", "-c", "echo init done"},
|
|
}
|
|
|
|
envFrom := []interface{}{}
|
|
if cmName != "" {
|
|
envFrom = append(envFrom, map[string]interface{}{
|
|
"configMapRef": map[string]interface{}{
|
|
"name": cmName,
|
|
},
|
|
})
|
|
}
|
|
if secretName != "" {
|
|
envFrom = append(envFrom, map[string]interface{}{
|
|
"secretRef": map[string]interface{}{
|
|
"name": secretName,
|
|
},
|
|
})
|
|
}
|
|
if len(envFrom) > 0 {
|
|
initContainer["envFrom"] = envFrom
|
|
}
|
|
|
|
initContainers, _, _ := unstructured.NestedSlice(dc.Object, "spec", "template", "spec", "initContainers")
|
|
initContainers = append(initContainers, initContainer)
|
|
_ = unstructured.SetNestedSlice(dc.Object, initContainers, "spec", "template", "spec", "initContainers")
|
|
}
|
|
}
|
|
|
|
// WithDCInitContainerVolume adds an init container with ConfigMap/Secret volume mounts to a DeploymentConfig.
|
|
func WithDCInitContainerVolume(cmName, secretName string) DCOption {
|
|
return func(dc *unstructured.Unstructured) {
|
|
initContainer := map[string]interface{}{
|
|
"name": "init",
|
|
"image": DefaultImage,
|
|
"command": []interface{}{"sh", "-c", "echo init done"},
|
|
}
|
|
|
|
volumeMounts := []interface{}{}
|
|
volumes, _, _ := unstructured.NestedSlice(dc.Object, "spec", "template", "spec", "volumes")
|
|
|
|
if cmName != "" {
|
|
volumeName := fmt.Sprintf("init-cm-%s", cmName)
|
|
volumes = append(volumes, map[string]interface{}{
|
|
"name": volumeName,
|
|
"configMap": map[string]interface{}{
|
|
"name": cmName,
|
|
},
|
|
})
|
|
volumeMounts = append(volumeMounts, map[string]interface{}{
|
|
"name": volumeName,
|
|
"mountPath": fmt.Sprintf("/etc/init-config/%s", cmName),
|
|
})
|
|
}
|
|
if secretName != "" {
|
|
volumeName := fmt.Sprintf("init-secret-%s", secretName)
|
|
volumes = append(volumes, map[string]interface{}{
|
|
"name": volumeName,
|
|
"secret": map[string]interface{}{
|
|
"secretName": secretName,
|
|
},
|
|
})
|
|
volumeMounts = append(volumeMounts, map[string]interface{}{
|
|
"name": volumeName,
|
|
"mountPath": fmt.Sprintf("/etc/init-secrets/%s", secretName),
|
|
})
|
|
}
|
|
|
|
if len(volumeMounts) > 0 {
|
|
initContainer["volumeMounts"] = volumeMounts
|
|
}
|
|
|
|
_ = unstructured.SetNestedSlice(dc.Object, volumes, "spec", "template", "spec", "volumes")
|
|
|
|
initContainers, _, _ := unstructured.NestedSlice(dc.Object, "spec", "template", "spec", "initContainers")
|
|
initContainers = append(initContainers, initContainer)
|
|
_ = unstructured.SetNestedSlice(dc.Object, initContainers, "spec", "template", "spec", "initContainers")
|
|
}
|
|
}
|
|
|
|
// WaitForDeploymentConfigEnvVar waits for a DeploymentConfig's container to have an env var with the given prefix.
|
|
func WaitForDeploymentConfigEnvVar(ctx context.Context, dynamicClient dynamic.Interface, namespace, name, prefix string, timeout time.Duration) (bool, error) {
|
|
var found bool
|
|
err := wait.PollUntilContextTimeout(ctx, DefaultInterval, timeout, true, func(ctx context.Context) (bool, error) {
|
|
dc, err := dynamicClient.Resource(DeploymentConfigGVR).Namespace(namespace).Get(ctx, name, metav1.GetOptions{})
|
|
if err != nil {
|
|
return false, nil
|
|
}
|
|
|
|
containers, _, _ := unstructured.NestedSlice(dc.Object, "spec", "template", "spec", "containers")
|
|
for _, c := range containers {
|
|
container := c.(map[string]interface{})
|
|
env, _, _ := unstructured.NestedSlice(container, "env")
|
|
for _, e := range env {
|
|
envVar := e.(map[string]interface{})
|
|
if envName, ok := envVar["name"].(string); ok && strings.HasPrefix(envName, prefix) {
|
|
found = true
|
|
return true, nil
|
|
}
|
|
}
|
|
}
|
|
|
|
return false, nil
|
|
})
|
|
|
|
if err != nil && err != context.DeadlineExceeded {
|
|
return false, err
|
|
}
|
|
return found, nil
|
|
}
|