514 lines
20 KiB
Go
514 lines
20 KiB
Go
// Package api — CRUD операции с функциями: чтение, удаление, обновление таймаута, логи, env vars.
|
||
//
|
||
// Этот файл содержит операции, не связанные с заменой кода/архива:
|
||
// - handleGetFunction — GET /functions/:name (детали: код, route, environment, source_type)
|
||
// - handleDeleteFunction — DELETE /functions/:name (каскадное удаление: триггеры, Package, S3)
|
||
// - handleUpdateFunctionTimeout — PUT /functions/:name/timeout (только таймаут, без замены кода)
|
||
// - handleGetFunctionLogs — GET /functions/:name/logs (логи пода через Kubernetes API)
|
||
// - handleGetFunctionEnvVars — GET /functions/:name/envvars (переменные окружения из CRD)
|
||
// - handlePutFunctionEnvVars — PUT /functions/:name/envvars (обновить env vars в CRD)
|
||
//
|
||
// Операции с кодом и архивом — в function_code.go и function_archive.go соответственно.
|
||
// Вызов функции — в function_invoke.go.
|
||
package api
|
||
|
||
import (
|
||
"context"
|
||
"encoding/json"
|
||
"fmt"
|
||
"io"
|
||
"net/http"
|
||
"strings"
|
||
"time"
|
||
|
||
"fission-console/internal/fission"
|
||
|
||
corev1 "k8s.io/api/core/v1"
|
||
apierrors "k8s.io/apimachinery/pkg/api/errors"
|
||
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
|
||
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
|
||
k8stypes "k8s.io/apimachinery/pkg/types"
|
||
)
|
||
|
||
// handleGetFunction возвращает детали функции: код, environment, route, methods.
|
||
func (s *Server) handleGetFunction(w http.ResponseWriter, r *http.Request, name string) {
|
||
ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
|
||
defer cancel()
|
||
ns := s.userNS(r)
|
||
|
||
fn, err := s.dyn.Resource(fission.FunctionGVR).Namespace(ns).Get(ctx, name, metav1.GetOptions{})
|
||
if err != nil {
|
||
status := http.StatusBadGateway
|
||
if apierrors.IsNotFound(err) {
|
||
status = http.StatusNotFound
|
||
}
|
||
writeJSONError(w, status, fmt.Sprintf("get function %q: %v", name, err))
|
||
return
|
||
}
|
||
|
||
packageName, _, _ := unstructured.NestedString(fn.Object, "spec", "package", "packageref", "name")
|
||
environment, _, _ := unstructured.NestedString(fn.Object, "spec", "environment", "name")
|
||
entrypoint, _, _ := unstructured.NestedString(fn.Object, "spec", "package", "functionName")
|
||
functionTimeout, foundTimeout, _ := unstructured.NestedInt64(fn.Object, "spec", "functionTimeout")
|
||
if !foundTimeout || functionTimeout <= 0 {
|
||
functionTimeout = int64(defaultFunctionInvokeTimeout / time.Second)
|
||
}
|
||
|
||
// Извлекаем исходный код из Package (пробуем source.literal, потом deployment.literal, потом url)
|
||
code := ""
|
||
if packageName != "" {
|
||
pkg, pkgErr := s.dyn.Resource(fission.PackageGVR).Namespace(ns).Get(ctx, packageName, metav1.GetOptions{})
|
||
if pkgErr == nil {
|
||
code = extractPackageSourceCode(ctx, s, pkg)
|
||
}
|
||
}
|
||
|
||
// Ищем HTTPTrigger для получения route и methods
|
||
route := ""
|
||
methods := []string{}
|
||
triggers, trigErr := s.dyn.Resource(fission.HTTPTrigGVR).Namespace(ns).List(ctx, metav1.ListOptions{})
|
||
if trigErr == nil {
|
||
for _, trig := range triggers.Items {
|
||
refName, _, _ := unstructured.NestedString(trig.Object, "spec", "functionref", "name")
|
||
if refName != name {
|
||
continue
|
||
}
|
||
route, _, _ = unstructured.NestedString(trig.Object, "spec", "relativeurl")
|
||
methods, _, _ = unstructured.NestedStringSlice(trig.Object, "spec", "methods")
|
||
break
|
||
}
|
||
}
|
||
|
||
// Читаем source-type аннотацию (code / archive)
|
||
sourceType := "code"
|
||
archiveFilename := ""
|
||
if ann := fn.GetAnnotations(); ann != nil {
|
||
if v := ann[fissionSourceTypeAnnotation]; v != "" {
|
||
sourceType = v
|
||
}
|
||
if v := ann["fission-console/archive-filename"]; v != "" {
|
||
archiveFilename = v
|
||
}
|
||
}
|
||
|
||
writeAnyJSON(w, http.StatusOK, map[string]any{
|
||
"name": name,
|
||
"namespace": ns,
|
||
"environment": environment,
|
||
"package": packageName,
|
||
"entrypoint": entrypoint,
|
||
"timeout": functionTimeout,
|
||
"created_at": functionTimestampResponse(fn)["created_at"],
|
||
"updated_at": functionTimestampResponse(fn)["updated_at"],
|
||
"code": code,
|
||
"source_type": sourceType,
|
||
"archive_filename": archiveFilename,
|
||
"route": route,
|
||
"methods": methods,
|
||
"env_vars": extractEnvVars(fn),
|
||
"raw": fn.Object,
|
||
})
|
||
}
|
||
|
||
// handleUpdateFunctionTimeout обновляет только spec.functionTimeout функции (без замены кода/архива).
|
||
func (s *Server) handleUpdateFunctionTimeout(w http.ResponseWriter, r *http.Request, name string) {
|
||
ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
|
||
defer cancel()
|
||
ns := s.userNS(r)
|
||
|
||
var req struct {
|
||
Timeout int64 `json:"timeout"`
|
||
Entrypoint string `json:"entrypoint"`
|
||
}
|
||
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
||
writeJSONError(w, http.StatusBadRequest, fmt.Sprintf("decode request: %v", err))
|
||
return
|
||
}
|
||
timeout := normalizeFunctionTimeout(req.Timeout)
|
||
|
||
fn, err := s.dyn.Resource(fission.FunctionGVR).Namespace(ns).Get(ctx, name, metav1.GetOptions{})
|
||
if err != nil {
|
||
writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("get function %q: %v", name, err))
|
||
return
|
||
}
|
||
if err := unstructured.SetNestedField(fn.Object, timeout, "spec", "functionTimeout"); err != nil {
|
||
writeJSONError(w, http.StatusInternalServerError, fmt.Sprintf("set timeout: %v", err))
|
||
return
|
||
}
|
||
if req.Entrypoint != "" {
|
||
_ = unstructured.SetNestedField(fn.Object, req.Entrypoint, "spec", "package", "functionName")
|
||
}
|
||
now := time.Now().UTC().Format(time.RFC3339)
|
||
ann := fn.GetAnnotations()
|
||
if ann == nil {
|
||
ann = map[string]string{}
|
||
}
|
||
ann[functionUpdatedAtAnnotation] = now
|
||
fn.SetAnnotations(ann)
|
||
|
||
if _, err := s.dyn.Resource(fission.FunctionGVR).Namespace(ns).Update(ctx, fn, metav1.UpdateOptions{}); err != nil {
|
||
writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("update function %q: %v", name, err))
|
||
return
|
||
}
|
||
writeAnyJSON(w, http.StatusOK, map[string]any{"updated": true, "timeout": timeout})
|
||
}
|
||
|
||
// handleDeleteFunction удаляет функцию и связанные объекты: HTTPTrigger, TimeTrigger, Package.
|
||
// После удаления вызывает CleanupEnvironmentIfUnused — убирает environment если язык больше не используется.
|
||
func (s *Server) handleDeleteFunction(w http.ResponseWriter, r *http.Request, name string) {
|
||
ctx, cancel := context.WithTimeout(r.Context(), 20*time.Second)
|
||
defer cancel()
|
||
ns := s.userNS(r)
|
||
|
||
// Получаем Function чтобы знать pkgName и envName для cleanup
|
||
var pkgName, envName string
|
||
fn, err := s.dyn.Resource(fission.FunctionGVR).Namespace(ns).Get(ctx, name, metav1.GetOptions{})
|
||
if err != nil {
|
||
if apierrors.IsNotFound(err) {
|
||
writeJSONError(w, http.StatusNotFound, fmt.Sprintf("function %q not found", name))
|
||
return
|
||
}
|
||
writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("get function %q: %v", name, err))
|
||
return
|
||
}
|
||
pkgName, _, _ = unstructured.NestedString(fn.Object, "spec", "package", "packageref", "name")
|
||
envName, _, _ = unstructured.NestedString(fn.Object, "spec", "environment", "name")
|
||
|
||
// Удаляем связанные HTTPTrigger-ы
|
||
triggers, err := s.dyn.Resource(fission.HTTPTrigGVR).Namespace(ns).List(ctx, metav1.ListOptions{})
|
||
if err == nil {
|
||
for _, trig := range triggers.Items {
|
||
refName, _, _ := unstructured.NestedString(trig.Object, "spec", "functionref", "name")
|
||
if refName == name {
|
||
_ = s.dyn.Resource(fission.HTTPTrigGVR).Namespace(ns).Delete(ctx, trig.GetName(), metav1.DeleteOptions{})
|
||
}
|
||
}
|
||
}
|
||
|
||
// Удаляем связанные TimeTrigger-ы
|
||
if triggers, err := s.dyn.Resource(fission.TimeTrigGVR).Namespace(ns).List(ctx, metav1.ListOptions{}); err == nil {
|
||
for _, trig := range triggers.Items {
|
||
refName, _, _ := unstructured.NestedString(trig.Object, "spec", "functionref", "name")
|
||
if refName == name {
|
||
_ = s.dyn.Resource(fission.TimeTrigGVR).Namespace(ns).Delete(ctx, trig.GetName(), metav1.DeleteOptions{})
|
||
}
|
||
}
|
||
}
|
||
|
||
if err := s.dyn.Resource(fission.FunctionGVR).Namespace(ns).Delete(ctx, name, metav1.DeleteOptions{}); err != nil && !apierrors.IsNotFound(err) {
|
||
writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("delete function %q: %v", name, err))
|
||
return
|
||
}
|
||
|
||
if pkgName != "" {
|
||
// Получаем URL архива из Package spec.deployment перед удалением, чтобы потом очистить S3
|
||
var archiveURL string
|
||
if pkg, pkgErr := s.dyn.Resource(fission.PackageGVR).Namespace(ns).Get(ctx, pkgName, metav1.GetOptions{}); pkgErr == nil {
|
||
deployType, _, _ := unstructured.NestedString(pkg.Object, "spec", "deployment", "type")
|
||
if deployType == "url" {
|
||
archiveURL, _, _ = unstructured.NestedString(pkg.Object, "spec", "deployment", "url")
|
||
}
|
||
}
|
||
if err := s.dyn.Resource(fission.PackageGVR).Namespace(ns).Delete(ctx, pkgName, metav1.DeleteOptions{}); err != nil && !apierrors.IsNotFound(err) {
|
||
writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("delete package %q: %v", pkgName, err))
|
||
return
|
||
}
|
||
// Удаляем архив из S3 после успешного удаления Package (best-effort)
|
||
if archiveURL != "" {
|
||
go s.deleteFromStoragesvc(context.Background(), archiveURL)
|
||
}
|
||
}
|
||
|
||
// Убираем environment pool pods если язык больше не используется (best-effort)
|
||
if envName != "" {
|
||
cleanupCtx, cleanupCancel := context.WithTimeout(context.Background(), 15*time.Second)
|
||
defer cleanupCancel()
|
||
fission.CleanupEnvironmentIfUnused(cleanupCtx, s.dyn, ns, envName)
|
||
}
|
||
|
||
// (reconciler NS удалён — за FISSION_RESOURCE_NAMESPACES теперь отвечает Layer 1 NSWatcher)
|
||
|
||
writeAnyJSON(w, http.StatusOK, map[string]any{"deleted": true, "name": name, "package": pkgName})
|
||
}
|
||
|
||
// handleGetFunctionLogs возвращает логи пода функции (последние 100 строк).
|
||
// Ищет под по лейблу functionName=<name> в namespace пользователя.
|
||
func (s *Server) handleGetFunctionLogs(w http.ResponseWriter, r *http.Request, name string) {
|
||
ns := s.userNS(r)
|
||
ctx := r.Context()
|
||
|
||
if s.kube == nil {
|
||
writeJSONError(w, http.StatusServiceUnavailable, "kubernetes client not available")
|
||
return
|
||
}
|
||
|
||
labelSelector := "functionName=" + name
|
||
pods, err := s.kube.CoreV1().Pods(ns).List(ctx, metav1.ListOptions{
|
||
LabelSelector: labelSelector,
|
||
})
|
||
if err != nil {
|
||
writeJSONError(w, http.StatusInternalServerError, "list pods: "+err.Error())
|
||
return
|
||
}
|
||
|
||
if len(pods.Items) == 0 {
|
||
writeAnyJSON(w, http.StatusOK, map[string]any{
|
||
"logs": "(нет запущенных подов для функции " + name + ")",
|
||
})
|
||
return
|
||
}
|
||
|
||
var allLogs strings.Builder
|
||
tailLines := int64(100)
|
||
for _, pod := range pods.Items {
|
||
containerName := ""
|
||
if len(pod.Spec.Containers) > 0 {
|
||
containerName = pod.Spec.Containers[0].Name
|
||
}
|
||
req := s.kube.CoreV1().Pods(ns).GetLogs(pod.Name, &corev1.PodLogOptions{
|
||
Container: containerName,
|
||
TailLines: &tailLines,
|
||
})
|
||
rc, err := req.Stream(ctx)
|
||
if err != nil {
|
||
allLogs.WriteString("[" + pod.Name + ": ошибка чтения логов: " + err.Error() + "]\n")
|
||
continue
|
||
}
|
||
data, _ := io.ReadAll(rc)
|
||
rc.Close()
|
||
if allLogs.Len() > 0 {
|
||
allLogs.WriteString("\n--- " + pod.Name + " ---\n")
|
||
} else {
|
||
allLogs.WriteString("--- " + pod.Name + " ---\n")
|
||
}
|
||
allLogs.Write(data)
|
||
}
|
||
|
||
writeAnyJSON(w, http.StatusOK, map[string]any{
|
||
"logs": allLogs.String(),
|
||
})
|
||
}
|
||
|
||
// handleGetFunctionEnvVars возвращает переменные окружения функции из .spec.runtime.container.env
|
||
func (s *Server) handleGetFunctionEnvVars(w http.ResponseWriter, r *http.Request, name string) {
|
||
ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
|
||
defer cancel()
|
||
ns := s.userNS(r)
|
||
|
||
fn, err := s.dyn.Resource(fission.FunctionGVR).Namespace(ns).Get(ctx, name, metav1.GetOptions{})
|
||
if err != nil {
|
||
status := http.StatusBadGateway
|
||
if apierrors.IsNotFound(err) {
|
||
status = http.StatusNotFound
|
||
}
|
||
writeJSONError(w, status, fmt.Sprintf("get function %q: %v", name, err))
|
||
return
|
||
}
|
||
|
||
envVars := extractEnvVars(fn)
|
||
writeAnyJSON(w, http.StatusOK, map[string]any{"env_vars": envVars})
|
||
}
|
||
|
||
// handlePutFunctionEnvVars обновляет переменные окружения функции.
|
||
//
|
||
// Логика переключения ExecutorType:
|
||
// - Если env vars непустые → ExecutorType: newdeploy + spec.podspec.containers[0].env
|
||
// (newdeploy создаёт dedicated Deployment, Kubernetes ставит env vars на уровне ОС)
|
||
// - Если env vars пустые → ExecutorType: poolmgr, podspec удаляется
|
||
// (poolmgr использует warm pool, быстрый cold start)
|
||
//
|
||
// Это единственный универсальный способ передать env vars в pod для всех языков
|
||
// (Python, Go, Ruby, PHP, Node.js) без изменений в env-серверах.
|
||
func (s *Server) handlePutFunctionEnvVars(w http.ResponseWriter, r *http.Request, name string) {
|
||
ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
|
||
defer cancel()
|
||
ns := s.userNS(r)
|
||
|
||
var req struct {
|
||
EnvVars []map[string]string `json:"env_vars"` // [{name: "KEY", value: "VAL"}, ...]
|
||
}
|
||
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
||
writeJSONError(w, http.StatusBadRequest, fmt.Sprintf("decode request: %v", err))
|
||
return
|
||
}
|
||
|
||
// Валидация: имена переменных
|
||
for _, ev := range req.EnvVars {
|
||
k := ev["name"]
|
||
if k == "" {
|
||
writeJSONError(w, http.StatusBadRequest, "env var name cannot be empty")
|
||
return
|
||
}
|
||
}
|
||
|
||
fn, err := s.dyn.Resource(fission.FunctionGVR).Namespace(ns).Get(ctx, name, metav1.GetOptions{})
|
||
if err != nil {
|
||
status := http.StatusBadGateway
|
||
if apierrors.IsNotFound(err) {
|
||
status = http.StatusNotFound
|
||
}
|
||
writeJSONError(w, status, fmt.Sprintf("get function %q: %v", name, err))
|
||
return
|
||
}
|
||
|
||
// Сериализуем в JSON для аннотации (для UI)
|
||
envJSON, err := json.Marshal(req.EnvVars)
|
||
if err != nil {
|
||
writeJSONError(w, http.StatusInternalServerError, fmt.Sprintf("marshal env vars: %v", err))
|
||
return
|
||
}
|
||
|
||
// Обновляем аннотации
|
||
now := time.Now().UTC().Format(time.RFC3339)
|
||
ann := fn.GetAnnotations()
|
||
if ann == nil {
|
||
ann = map[string]string{}
|
||
}
|
||
ann[functionUpdatedAtAnnotation] = now
|
||
ann["fission-console/env-vars"] = string(envJSON)
|
||
fn.SetAnnotations(ann)
|
||
|
||
if len(req.EnvVars) > 0 {
|
||
// Есть env vars → newdeploy + podspec с env vars
|
||
envName, _, _ := unstructured.NestedString(fn.Object, "spec", "environment", "name")
|
||
|
||
// Строим список env vars для Kubernetes
|
||
envList := make([]any, 0, len(req.EnvVars))
|
||
for _, ev := range req.EnvVars {
|
||
envList = append(envList, map[string]any{
|
||
"name": ev["name"],
|
||
"value": ev["value"],
|
||
})
|
||
}
|
||
|
||
// Устанавливаем podspec.containers[0] с env vars
|
||
// Имя контейнера = имя environment (стандарт Fission)
|
||
if err := unstructured.SetNestedSlice(fn.Object, []any{
|
||
map[string]any{
|
||
"name": envName,
|
||
"env": envList,
|
||
},
|
||
}, "spec", "podspec", "containers"); err != nil {
|
||
writeJSONError(w, http.StatusInternalServerError, fmt.Sprintf("set podspec: %v", err))
|
||
return
|
||
}
|
||
|
||
// Переключаем на newdeploy (только он поддерживает podspec env)
|
||
if err := unstructured.SetNestedField(fn.Object, map[string]any{
|
||
"ExecutionStrategy": map[string]any{
|
||
"ExecutorType": "newdeploy",
|
||
"MinScale": int64(0),
|
||
"MaxScale": int64(1),
|
||
"SpecializationTimeout": int64(120),
|
||
},
|
||
"StrategyType": "execution",
|
||
}, "spec", "InvokeStrategy"); err != nil {
|
||
writeJSONError(w, http.StatusInternalServerError, fmt.Sprintf("set invoke strategy: %v", err))
|
||
return
|
||
}
|
||
} else {
|
||
// Нет env vars → poolmgr, убираем podspec
|
||
unstructured.RemoveNestedField(fn.Object, "spec", "podspec")
|
||
|
||
if err := unstructured.SetNestedField(fn.Object, map[string]any{
|
||
"ExecutionStrategy": map[string]any{
|
||
"ExecutorType": "poolmgr",
|
||
"SpecializationTimeout": int64(120),
|
||
},
|
||
"StrategyType": "execution",
|
||
}, "spec", "InvokeStrategy"); err != nil {
|
||
writeJSONError(w, http.StatusInternalServerError, fmt.Sprintf("set invoke strategy: %v", err))
|
||
return
|
||
}
|
||
}
|
||
|
||
if _, err := s.dyn.Resource(fission.FunctionGVR).Namespace(ns).Update(ctx, fn, metav1.UpdateOptions{}); err != nil {
|
||
writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("update function %q: %v", name, err))
|
||
return
|
||
}
|
||
|
||
// Fission newdeploy НЕ применяет fn.Spec.PodSpec при построении Deployment.
|
||
// Поэтому напрямую патчим существующий Deployment через Kubernetes API.
|
||
if len(req.EnvVars) > 0 && s.kube != nil {
|
||
envName, _, _ := unstructured.NestedString(fn.Object, "spec", "environment", "name")
|
||
if envName != "" {
|
||
if err := s.patchDeploymentEnvVars(ctx, ns, name, envName, req.EnvVars); err != nil {
|
||
// Не фатальная ошибка — CRD обновлён, Deployment будет обновлён позже
|
||
_ = err // warn only
|
||
}
|
||
}
|
||
}
|
||
|
||
executor := "poolmgr"
|
||
if len(req.EnvVars) > 0 {
|
||
executor = "newdeploy"
|
||
}
|
||
writeAnyJSON(w, http.StatusOK, map[string]any{"updated": true, "count": len(req.EnvVars), "executor": executor})
|
||
}
|
||
|
||
// extractEnvVars читает аннотацию fission-console/env-vars (JSON) из Function CRD
|
||
// Возвращает [{name, value}, ...]
|
||
func extractEnvVars(fn *unstructured.Unstructured) []map[string]string {
|
||
ann := fn.GetAnnotations()
|
||
if ann == nil {
|
||
return []map[string]string{}
|
||
}
|
||
raw := ann["fission-console/env-vars"]
|
||
if raw == "" {
|
||
return []map[string]string{}
|
||
}
|
||
var result []map[string]string
|
||
if err := json.Unmarshal([]byte(raw), &result); err != nil {
|
||
return []map[string]string{}
|
||
}
|
||
return result
|
||
}
|
||
|
||
// patchDeploymentEnvVars находит Deployment newdeploy для функции и патчит его env vars.
|
||
// Fission не применяет fn.Spec.PodSpec при построении Deployment, поэтому патчим напрямую.
|
||
// Поиск по labels: functionName=<name>, functionNamespace=<ns>, executorType=newdeploy
|
||
func (s *Server) patchDeploymentEnvVars(ctx context.Context, ns, fnName, envContainerName string, envVars []map[string]string) error {
|
||
selector := fmt.Sprintf("functionName=%s,functionNamespace=%s,executorType=newdeploy", fnName, ns)
|
||
deplList, err := s.kube.AppsV1().Deployments(ns).List(ctx, metav1.ListOptions{LabelSelector: selector})
|
||
if err != nil {
|
||
return fmt.Errorf("list deployments: %w", err)
|
||
}
|
||
if len(deplList.Items) == 0 {
|
||
return nil // Deployment ещё не создан Fission — ничего страшного
|
||
}
|
||
|
||
// Строим env vars для patch (StrategicMergePatch мержит по "name")
|
||
envItems := make([]map[string]string, 0, len(envVars))
|
||
for _, ev := range envVars {
|
||
envItems = append(envItems, map[string]string{"name": ev["name"], "value": ev["value"]})
|
||
}
|
||
|
||
patch := map[string]any{
|
||
"spec": map[string]any{
|
||
"template": map[string]any{
|
||
"spec": map[string]any{
|
||
"containers": []any{
|
||
map[string]any{
|
||
"name": envContainerName,
|
||
"env": envItems,
|
||
},
|
||
},
|
||
},
|
||
},
|
||
},
|
||
}
|
||
patchBytes, err := json.Marshal(patch)
|
||
if err != nil {
|
||
return fmt.Errorf("marshal patch: %w", err)
|
||
}
|
||
|
||
for _, depl := range deplList.Items {
|
||
if _, err := s.kube.AppsV1().Deployments(ns).Patch(
|
||
ctx, depl.Name, k8stypes.StrategicMergePatchType, patchBytes, metav1.PatchOptions{},
|
||
); err != nil {
|
||
return fmt.Errorf("patch deployment %s: %w", depl.Name, err)
|
||
}
|
||
}
|
||
return nil
|
||
}
|