“Naeel”
6a8c3a27e2
- handleCreateFunction: deps → аннотация fission-console/deps - handleUpdateFunctionCode: deps → аннотация fission-console/deps (или удаление если пусто) - GET /functions/:name: возвращает deps из аннотации - openEdit: заполняет e-deps.value = fn.deps (вместо пустого поля)
439 lines
17 KiB
Go
439 lines
17 KiB
Go
// Package api — создание и обновление функций из исходного кода (inline code).
|
||
//
|
||
// Этот файл отвечает за два сценария:
|
||
// 1. handleCreateFunction — создание новой функции из кода (JSON body).
|
||
// 2. handleUpdateFunctionCode — обновление существующей функции: новый код → новый Package.
|
||
//
|
||
// Поддерживаемые языки: python, nodejs, php, ruby, go.
|
||
// Для Go создаётся source package (builder компилирует .so плагин).
|
||
// Для остальных языков — deployment archive (zip загружается в storagesvc или как literal).
|
||
//
|
||
// Почему новый Package при обновлении:
|
||
// Fission executor кэширует function service по functionUid и не видит изменений
|
||
// в существующем Package. Новое имя пакета гарантирует cache miss в executor.
|
||
package api
|
||
|
||
import (
|
||
"context"
|
||
"encoding/json"
|
||
"fmt"
|
||
"net/http"
|
||
"strconv"
|
||
"strings"
|
||
"time"
|
||
|
||
"fission-console/internal/billing"
|
||
"fission-console/internal/fission"
|
||
"fission-console/internal/model"
|
||
"fission-console/internal/runtime"
|
||
|
||
apierrors "k8s.io/apimachinery/pkg/api/errors"
|
||
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
|
||
"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
|
||
)
|
||
|
||
// buildDeployArchive упаковывает исходный код в байты для deployment Package.
|
||
// Для nodejs — ESM-обёртка (package.json + main.js).
|
||
// Для php/ruby — zip с одним файлом скрипта.
|
||
// Для остальных (python) — raw bytes кода (или zip если есть deps).
|
||
// deps — содержимое файла зависимостей (requirements.txt, Gemfile, composer.json).
|
||
// Если deps пустой — поведение как раньше.
|
||
func buildDeployArchive(lang, code, deps string) ([]byte, error) {
|
||
switch lang {
|
||
case "nodejs":
|
||
// TODO: поддержка package.json с deps для nodejs — пока игнорируем deps
|
||
return runtime.BuildJSDeployZip(code)
|
||
case "php":
|
||
if deps != "" {
|
||
return runtime.BuildScriptZipWithDeps(code, "main.php", deps, "composer.json")
|
||
}
|
||
return runtime.BuildScriptZip(code, "main.php")
|
||
case "ruby":
|
||
if deps != "" {
|
||
return runtime.BuildScriptZipWithDeps(code, "handler.rb", deps, "Gemfile")
|
||
}
|
||
return runtime.BuildScriptZip(code, "handler.rb")
|
||
default: // python
|
||
return runtime.BuildPythonZip(code, deps)
|
||
}
|
||
}
|
||
|
||
// handleCreateFunction создаёт новую функцию: Package + Function + HTTPTrigger.
|
||
//
|
||
// Порядок создания: Package → Function → HTTPTrigger.
|
||
// При ошибке на любом шаге откатываем уже созданные объекты (best-effort).
|
||
// TTL парсится ДО создания объектов — невалидный TTL не оставляет мусор.
|
||
func (s *Server) handleCreateFunction(w http.ResponseWriter, r *http.Request) {
|
||
ns := s.userNS(r)
|
||
|
||
// Поддерживаем два формата: JSON (код) и multipart/form-data (архив).
|
||
isArchiveUpload := strings.HasPrefix(r.Header.Get("Content-Type"), "multipart/form-data")
|
||
if isArchiveUpload {
|
||
s.handleCreateFunctionFromArchive(w, r, ns)
|
||
return
|
||
}
|
||
|
||
var req model.CreateFunctionRequest
|
||
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
||
writeJSONError(w, http.StatusBadRequest, fmt.Sprintf("decode request: %v", err))
|
||
return
|
||
}
|
||
|
||
// Гарантируем namespace — на случай прямого вызова API без handleAuth
|
||
nsCtx, nsCancel := context.WithTimeout(r.Context(), 60*time.Second)
|
||
defer nsCancel()
|
||
if err := s.nsManager.EnsureUserNS(nsCtx, ns); err != nil {
|
||
writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("ensure namespace: %v", err))
|
||
return
|
||
}
|
||
|
||
req.Name = strings.TrimSpace(req.Name)
|
||
req.Language = strings.TrimSpace(req.Language)
|
||
req.Environment = strings.TrimSpace(req.Environment)
|
||
req.Code = strings.TrimSpace(req.Code)
|
||
req.Entrypoint = strings.TrimSpace(req.Entrypoint)
|
||
req.Route = strings.TrimSpace(req.Route)
|
||
|
||
// Валидация имени
|
||
if req.Name != "" && (!validFuncName.MatchString(req.Name) || len(req.Name) > 57) {
|
||
writeJSONError(w, http.StatusBadRequest, "invalid function name: must match ^[a-z0-9]([a-z0-9-]*[a-z0-9])?$ and be <= 57 chars")
|
||
return
|
||
}
|
||
if len(req.Code) > maxCodeSize {
|
||
writeJSONError(w, http.StatusBadRequest, "code exceeds 1MB limit")
|
||
return
|
||
}
|
||
|
||
// Lazy создание Environment по языку (если язык указан явно)
|
||
if req.Language != "" {
|
||
envCtx, envCancel := context.WithTimeout(r.Context(), 15*time.Second)
|
||
defer envCancel()
|
||
envName, err := fission.EnsureEnvironment(envCtx, s.dyn, ns, req.Language)
|
||
if err != nil {
|
||
if strings.Contains(err.Error(), "unsupported language") {
|
||
writeJSONError(w, http.StatusBadRequest, err.Error())
|
||
} else {
|
||
writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("ensure environment: %v", err))
|
||
}
|
||
return
|
||
}
|
||
req.Environment = envName
|
||
}
|
||
|
||
if req.Name == "" || req.Environment == "" || req.Code == "" {
|
||
writeJSONError(w, http.StatusBadRequest, "name, environment/language and code are required")
|
||
return
|
||
}
|
||
if req.Entrypoint == "" {
|
||
req.Entrypoint = runtime.DefaultEntrypoint(req.Language)
|
||
}
|
||
if req.Route == "" {
|
||
// Namespace-prefix route: избегаем коллизий между пользователями
|
||
// (разные пользователи могут создать функцию с одинаковым именем)
|
||
nsShort := ns
|
||
if len(nsShort) > 12 {
|
||
nsShort = nsShort[len(nsShort)-12:]
|
||
}
|
||
req.Route = "/" + nsShort + "/" + req.Name
|
||
}
|
||
if !strings.HasPrefix(req.Route, "/") {
|
||
req.Route = "/" + req.Route
|
||
}
|
||
req.Methods = normalizeMethods(req.Methods)
|
||
req.Timeout = normalizeFunctionTimeout(req.Timeout)
|
||
|
||
ctx, cancel := context.WithTimeout(r.Context(), 20*time.Second)
|
||
defer cancel()
|
||
|
||
// Проверяем что environment существует (мог быть задан явно без language)
|
||
if _, err := s.dyn.Resource(fission.EnvironmentGVR).Namespace(ns).Get(ctx, req.Environment, metav1.GetOptions{}); err != nil {
|
||
writeJSONError(w, http.StatusBadRequest, fmt.Sprintf("environment %q not found: %v", req.Environment, err))
|
||
return
|
||
}
|
||
|
||
pkgName := req.Name + "-pkg"
|
||
triggerName := req.Name + "-route"
|
||
|
||
methodValues := make([]any, 0, len(req.Methods))
|
||
for _, method := range req.Methods {
|
||
methodValues = append(methodValues, method)
|
||
}
|
||
|
||
// Строим Package spec в зависимости от языка:
|
||
// - Go: source package → builder job компилирует в .so плагин
|
||
// - Node.js: deployment zip с ESM wrapper (package.json + main.js)
|
||
// - Остальные: deployment archive с кодом (S3 или literal fallback)
|
||
var pkgSpec map[string]any
|
||
if req.Language == "go" {
|
||
srcZip, err := runtime.BuildGoSourceZip(req.Code)
|
||
if err != nil {
|
||
writeJSONError(w, http.StatusBadRequest, fmt.Sprintf("build go source archive: %v", err))
|
||
return
|
||
}
|
||
srcSpec, srcErr := s.buildDeploySpec(ctx, srcZip)
|
||
if srcErr != nil {
|
||
writeJSONError(w, http.StatusInternalServerError, fmt.Sprintf("upload go source: %v", srcErr))
|
||
return
|
||
}
|
||
pkgSpec = map[string]any{
|
||
"source": srcSpec,
|
||
"deployment": map[string]any{},
|
||
"environment": map[string]any{"name": req.Environment, "namespace": ns},
|
||
"buildcommand": "build",
|
||
}
|
||
} else {
|
||
deployBytes, archiveErr := buildDeployArchive(req.Language, req.Code, req.Deps)
|
||
if archiveErr != nil {
|
||
writeJSONError(w, http.StatusInternalServerError, fmt.Sprintf("build %s archive: %v", req.Language, archiveErr))
|
||
return
|
||
}
|
||
deploySpec, uploadErr := s.buildDeploySpec(ctx, deployBytes)
|
||
if uploadErr != nil {
|
||
writeJSONError(w, http.StatusInternalServerError, fmt.Sprintf("upload %s archive: %v", req.Language, uploadErr))
|
||
return
|
||
}
|
||
pkgSpec = map[string]any{
|
||
"deployment": deploySpec,
|
||
"environment": map[string]any{"name": req.Environment, "namespace": ns},
|
||
"source": map[string]any{},
|
||
}
|
||
}
|
||
|
||
pkg := &unstructured.Unstructured{Object: map[string]any{
|
||
"apiVersion": "fission.io/v1",
|
||
"kind": "Package",
|
||
"metadata": map[string]any{"name": pkgName, "namespace": ns},
|
||
"spec": pkgSpec,
|
||
}}
|
||
|
||
// Парсим TTL ДО создания K8s ресурсов — невалидный TTL не оставляет мусор
|
||
fnAnnotations := map[string]any{
|
||
"fission-console/language": req.Language,
|
||
fissionSourceTypeAnnotation: "code",
|
||
}
|
||
now := time.Now().UTC()
|
||
fnAnnotations[functionCreatedAtAnnotation] = now.Format(time.RFC3339)
|
||
fnAnnotations[functionUpdatedAtAnnotation] = now.Format(time.RFC3339)
|
||
if req.Deps != "" {
|
||
fnAnnotations["fission-console/deps"] = req.Deps
|
||
}
|
||
if req.TTL != "" {
|
||
expiresAt, ttlErr := parseTTL(req.TTL)
|
||
if ttlErr != nil {
|
||
writeJSONError(w, http.StatusBadRequest, fmt.Sprintf("invalid ttl %q: %v", req.TTL, ttlErr))
|
||
return
|
||
}
|
||
fnAnnotations["fission-console/expires-at"] = expiresAt.UTC().Format(time.RFC3339)
|
||
}
|
||
|
||
if _, err := s.dyn.Resource(fission.PackageGVR).Namespace(ns).Create(ctx, pkg, metav1.CreateOptions{}); err != nil {
|
||
if apierrors.IsAlreadyExists(err) {
|
||
writeJSONError(w, http.StatusConflict, fmt.Sprintf("function %q already exists", req.Name))
|
||
return
|
||
}
|
||
if apierrors.IsInvalid(err) {
|
||
writeJSONError(w, http.StatusBadRequest, fmt.Sprintf("invalid function spec: %v", err))
|
||
return
|
||
}
|
||
writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("create package: %v", err))
|
||
return
|
||
}
|
||
|
||
fn := &unstructured.Unstructured{Object: map[string]any{
|
||
"apiVersion": "fission.io/v1",
|
||
"kind": "Function",
|
||
"metadata": map[string]any{"name": req.Name, "namespace": ns, "annotations": fnAnnotations},
|
||
"spec": map[string]any{
|
||
"environment": map[string]any{"name": req.Environment, "namespace": ns},
|
||
"functionTimeout": req.Timeout,
|
||
"InvokeStrategy": map[string]any{
|
||
"ExecutionStrategy": map[string]any{"ExecutorType": "poolmgr"},
|
||
"StrategyType": "execution",
|
||
},
|
||
"package": map[string]any{
|
||
"packageref": map[string]any{"name": pkgName, "namespace": ns},
|
||
"functionName": req.Entrypoint,
|
||
},
|
||
},
|
||
}}
|
||
|
||
if _, err := s.dyn.Resource(fission.FunctionGVR).Namespace(ns).Create(ctx, fn, metav1.CreateOptions{}); err != nil {
|
||
// Откатываем Package если Function не создалась
|
||
_ = s.dyn.Resource(fission.PackageGVR).Namespace(ns).Delete(ctx, pkgName, metav1.DeleteOptions{})
|
||
if apierrors.IsAlreadyExists(err) {
|
||
writeJSONError(w, http.StatusConflict, fmt.Sprintf("function %q already exists", req.Name))
|
||
return
|
||
}
|
||
writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("create function: %v", err))
|
||
return
|
||
}
|
||
|
||
httpTrigger := &unstructured.Unstructured{Object: map[string]any{
|
||
"apiVersion": "fission.io/v1",
|
||
"kind": "HTTPTrigger",
|
||
"metadata": map[string]any{"name": triggerName, "namespace": ns},
|
||
"spec": map[string]any{
|
||
"relativeurl": req.Route,
|
||
"methods": methodValues,
|
||
"createingress": true,
|
||
"functionref": map[string]any{"type": "name", "name": req.Name},
|
||
},
|
||
}}
|
||
|
||
if _, err := s.dyn.Resource(fission.HTTPTrigGVR).Namespace(ns).Create(ctx, httpTrigger, metav1.CreateOptions{}); err != nil {
|
||
// Откатываем Function и Package
|
||
_ = s.dyn.Resource(fission.FunctionGVR).Namespace(ns).Delete(ctx, req.Name, metav1.DeleteOptions{})
|
||
_ = s.dyn.Resource(fission.PackageGVR).Namespace(ns).Delete(ctx, pkgName, metav1.DeleteOptions{})
|
||
writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("create httptrigger: %v", err))
|
||
return
|
||
}
|
||
|
||
s.billing.RecordInvocation(billing.Invocation{
|
||
Namespace: ns,
|
||
FunctionName: req.Name,
|
||
TriggerType: billing.TriggerEvent,
|
||
StartedAt: now,
|
||
StatusCode: http.StatusCreated,
|
||
RecordedBy: "console",
|
||
EventType: "create",
|
||
})
|
||
|
||
writeAnyJSON(w, http.StatusCreated, map[string]any{
|
||
"name": req.Name,
|
||
"package": pkgName,
|
||
"httptrigger": triggerName,
|
||
"route": req.Route,
|
||
"expires_at": fnAnnotations["fission-console/expires-at"],
|
||
})
|
||
}
|
||
|
||
// handleUpdateFunctionCode обновляет код уже существующей функции.
|
||
// Создаёт НОВЫЙ Package (вместо обновления старого) чтобы executor сбросил кэш:
|
||
// executor кэширует function service по functionUid и не видит изменений в том же Package.
|
||
// Новое имя пакета гарантирует cache miss в executor.
|
||
func (s *Server) handleUpdateFunctionCode(w http.ResponseWriter, r *http.Request, name string) {
|
||
var req model.UpdateCodeRequest
|
||
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
|
||
writeJSONError(w, http.StatusBadRequest, fmt.Sprintf("decode request: %v", err))
|
||
return
|
||
}
|
||
req.Code = strings.TrimSpace(req.Code)
|
||
if req.Code == "" {
|
||
writeJSONError(w, http.StatusBadRequest, "code is required")
|
||
return
|
||
}
|
||
|
||
ctx, cancel := context.WithTimeout(r.Context(), 20*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
|
||
}
|
||
|
||
oldPkgName, _, _ := unstructured.NestedString(fn.Object, "spec", "package", "packageref", "name")
|
||
|
||
// Определяем язык из аннотации — нужен для правильной упаковки
|
||
lang, _, _ := unstructured.NestedString(fn.Object, "metadata", "annotations", "fission-console/language")
|
||
deployBytes, archiveErr := buildDeployArchive(lang, req.Code, req.Deps)
|
||
if archiveErr != nil {
|
||
writeJSONError(w, http.StatusInternalServerError, fmt.Sprintf("build %s archive: %v", lang, archiveErr))
|
||
return
|
||
}
|
||
|
||
// Создаём новый Package с уникальным именем.
|
||
// Это единственный способ сбросить кэш executor: он кэширует по functionUid и
|
||
// не замечает изменений в существующем Package.
|
||
envName, _, _ := unstructured.NestedString(fn.Object, "spec", "environment", "name")
|
||
createdAt := func() time.Time {
|
||
ann := fn.GetAnnotations()
|
||
if ann != nil {
|
||
if v := strings.TrimSpace(ann[functionCreatedAtAnnotation]); v != "" {
|
||
if ts, err := parseRFC3339(v); err == nil {
|
||
return ts.UTC()
|
||
}
|
||
}
|
||
}
|
||
if ts := fn.GetCreationTimestamp(); !ts.IsZero() {
|
||
return ts.UTC()
|
||
}
|
||
return time.Time{}
|
||
}()
|
||
now := time.Now().UTC()
|
||
newPkgName := name + "-pkg-" + strconv.FormatInt(time.Now().UnixMilli(), 36)
|
||
deploySpec, uploadErr := s.buildDeploySpec(ctx, deployBytes)
|
||
if uploadErr != nil {
|
||
writeJSONError(w, http.StatusInternalServerError, fmt.Sprintf("upload %s archive: %v", lang, uploadErr))
|
||
return
|
||
}
|
||
newPkg := &unstructured.Unstructured{Object: map[string]any{
|
||
"apiVersion": "fission.io/v1",
|
||
"kind": "Package",
|
||
"metadata": map[string]any{"name": newPkgName, "namespace": ns},
|
||
"spec": map[string]any{
|
||
"deployment": deploySpec,
|
||
"environment": map[string]any{"name": envName, "namespace": ns},
|
||
"source": map[string]any{},
|
||
},
|
||
}}
|
||
|
||
createdPkg, err := s.dyn.Resource(fission.PackageGVR).Namespace(ns).Create(ctx, newPkg, metav1.CreateOptions{})
|
||
if err != nil {
|
||
writeJSONError(w, http.StatusBadGateway, fmt.Sprintf("create new package: %v", err))
|
||
return
|
||
}
|
||
|
||
// Обновляем Function на новый Package
|
||
if err := unstructured.SetNestedField(fn.Object, normalizeFunctionTimeout(req.Timeout), "spec", "functionTimeout"); err != nil {
|
||
writeJSONError(w, http.StatusInternalServerError, fmt.Sprintf("set function timeout: %v", err))
|
||
_ = s.dyn.Resource(fission.PackageGVR).Namespace(ns).Delete(ctx, newPkgName, metav1.DeleteOptions{})
|
||
return
|
||
}
|
||
ensureFunctionTimestamps(fn, now)
|
||
if createdAt.IsZero() {
|
||
createdAt = now
|
||
}
|
||
fnAnnotations := fn.GetAnnotations()
|
||
if fnAnnotations == nil {
|
||
fnAnnotations = map[string]string{}
|
||
}
|
||
fnAnnotations[functionCreatedAtAnnotation] = createdAt.UTC().Format(time.RFC3339)
|
||
fnAnnotations[functionUpdatedAtAnnotation] = now.Format(time.RFC3339)
|
||
if req.Deps != "" {
|
||
fnAnnotations["fission-console/deps"] = req.Deps
|
||
} else {
|
||
delete(fnAnnotations, "fission-console/deps")
|
||
}
|
||
fn.SetAnnotations(fnAnnotations)
|
||
if err := unstructured.SetNestedField(fn.Object, map[string]any{
|
||
"name": newPkgName,
|
||
"namespace": ns,
|
||
"resourceversion": createdPkg.GetResourceVersion(),
|
||
}, "spec", "package", "packageref"); err != nil {
|
||
writeJSONError(w, http.StatusInternalServerError, fmt.Sprintf("set function packageref: %v", err))
|
||
_ = s.dyn.Resource(fission.PackageGVR).Namespace(ns).Delete(ctx, newPkgName, metav1.DeleteOptions{})
|
||
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))
|
||
_ = s.dyn.Resource(fission.PackageGVR).Namespace(ns).Delete(ctx, newPkgName, metav1.DeleteOptions{})
|
||
return
|
||
}
|
||
|
||
// Удаляем старый Package (best effort)
|
||
if oldPkgName != "" && oldPkgName != newPkgName {
|
||
_ = s.dyn.Resource(fission.PackageGVR).Namespace(ns).Delete(ctx, oldPkgName, metav1.DeleteOptions{})
|
||
}
|
||
|
||
writeAnyJSON(w, http.StatusOK, map[string]any{
|
||
"updated": true,
|
||
"package": newPkgName,
|
||
})
|
||
}
|