259 lines
9.3 KiB
Go
259 lines
9.3 KiB
Go
package fission
|
|
|
|
import (
|
|
"context"
|
|
"encoding/base64"
|
|
"fmt"
|
|
"strconv"
|
|
"time"
|
|
|
|
"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"
|
|
"k8s.io/client-go/dynamic"
|
|
)
|
|
|
|
const (
|
|
functionCreatedAtAnnotation = "fission-console/createdAt"
|
|
functionUpdatedAtAnnotation = "fission-console/updatedAt"
|
|
)
|
|
|
|
// CreateFunctionResult holds the result of a CreateFunction call.
|
|
type CreateFunctionResult struct {
|
|
Name string `json:"name"`
|
|
Package string `json:"package"`
|
|
HTTPTrigger string `json:"httptrigger"`
|
|
Route string `json:"route"`
|
|
ExpiresAt string `json:"expires_at,omitempty"`
|
|
}
|
|
|
|
// UpdateFunctionResult holds the result of an UpdateFunctionCode call.
|
|
type UpdateFunctionResult struct {
|
|
Updated bool `json:"updated"`
|
|
Package string `json:"package"`
|
|
}
|
|
|
|
// CreateFunction orchestrates the creation of a complete Fission function set: Package, Function, and HTTPTrigger.
|
|
func CreateFunction(ctx context.Context, dyn dynamic.Interface, ns string, req model.CreateFunctionRequest) (*CreateFunctionResult, error) {
|
|
pkgName := req.Name + "-pkg"
|
|
triggerName := req.Name + "-route"
|
|
|
|
methodValues := make([]any, 0, len(req.Methods))
|
|
for _, method := range req.Methods {
|
|
methodValues = append(methodValues, method)
|
|
}
|
|
|
|
var pkgSpec map[string]any
|
|
if req.Language == "go" {
|
|
srcZip, err := runtime.BuildGoSourceZip(req.Code)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("build go source archive: %w", err)
|
|
}
|
|
literal := base64.StdEncoding.EncodeToString(srcZip)
|
|
pkgSpec = map[string]any{
|
|
"source": map[string]any{
|
|
"type": "literal",
|
|
"literal": literal,
|
|
},
|
|
"deployment": map[string]any{},
|
|
"environment": map[string]any{"name": req.Environment, "namespace": ns},
|
|
"buildcommand": "build",
|
|
}
|
|
} else {
|
|
deployBytes, archiveErr := runtime.BuildDeployArchive(req.Language, req.Code)
|
|
if archiveErr != nil {
|
|
return nil, fmt.Errorf("build %s archive: %w", req.Language, archiveErr)
|
|
}
|
|
pkgSpec = map[string]any{
|
|
"deployment": map[string]any{"type": "literal", "literal": base64.StdEncoding.EncodeToString(deployBytes)},
|
|
"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,
|
|
}}
|
|
|
|
fnAnnotations := map[string]any{
|
|
"fission-console/language": req.Language,
|
|
}
|
|
now := time.Now().UTC()
|
|
fnAnnotations[functionCreatedAtAnnotation] = now.Format(time.RFC3339)
|
|
fnAnnotations[functionUpdatedAtAnnotation] = now.Format(time.RFC3339)
|
|
var expiresAtStr string
|
|
if req.TTL != "" {
|
|
expiresAt, ttlErr := parseTTL(req.TTL)
|
|
if ttlErr != nil {
|
|
return nil, fmt.Errorf("invalid ttl %q: %w", req.TTL, ttlErr)
|
|
}
|
|
expiresAtStr = expiresAt.UTC().Format(time.RFC3339)
|
|
fnAnnotations["fission-console/expires-at"] = expiresAtStr
|
|
}
|
|
|
|
if _, err := dyn.Resource(PackageGVR).Namespace(ns).Create(ctx, pkg, metav1.CreateOptions{}); err != nil {
|
|
return nil, fmt.Errorf("create package: %w", err)
|
|
}
|
|
|
|
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 := dyn.Resource(FunctionGVR).Namespace(ns).Create(ctx, fn, metav1.CreateOptions{}); err != nil {
|
|
_ = dyn.Resource(PackageGVR).Namespace(ns).Delete(context.Background(), pkgName, metav1.DeleteOptions{})
|
|
return nil, fmt.Errorf("create function: %w", err)
|
|
}
|
|
|
|
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 := dyn.Resource(HTTPTrigGVR).Namespace(ns).Create(ctx, httpTrigger, metav1.CreateOptions{}); err != nil {
|
|
_ = dyn.Resource(FunctionGVR).Namespace(ns).Delete(context.Background(), req.Name, metav1.DeleteOptions{})
|
|
_ = dyn.Resource(PackageGVR).Namespace(ns).Delete(context.Background(), pkgName, metav1.DeleteOptions{})
|
|
return nil, fmt.Errorf("create httptrigger: %w", err)
|
|
}
|
|
|
|
return &CreateFunctionResult{
|
|
Name: req.Name,
|
|
Package: pkgName,
|
|
HTTPTrigger: triggerName,
|
|
Route: req.Route,
|
|
ExpiresAt: expiresAtStr,
|
|
}, nil
|
|
}
|
|
|
|
// UpdateFunctionCode orchestrates updating the code of an existing function.
|
|
func UpdateFunctionCode(ctx context.Context, dyn dynamic.Interface, ns, name string, req model.UpdateCodeRequest) (*UpdateFunctionResult, error) {
|
|
fn, err := dyn.Resource(FunctionGVR).Namespace(ns).Get(ctx, name, metav1.GetOptions{})
|
|
if err != nil {
|
|
return nil, fmt.Errorf("get function %q: %w", name, err)
|
|
}
|
|
|
|
oldPkgName, _, _ := unstructured.NestedString(fn.Object, "spec", "package", "packageref", "name")
|
|
lang, _, _ := unstructured.NestedString(fn.Object, "metadata", "annotations", "fission-console/language")
|
|
|
|
deployBytes, archiveErr := runtime.BuildDeployArchive(lang, req.Code)
|
|
if archiveErr != nil {
|
|
return nil, fmt.Errorf("build %s archive: %w", lang, archiveErr)
|
|
}
|
|
|
|
envName, _, _ := unstructured.NestedString(fn.Object, "spec", "environment", "name")
|
|
newPkgName := name + "-pkg-" + strconv.FormatInt(time.Now().UnixMilli(), 36)
|
|
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": map[string]any{"type": "literal", "literal": base64.StdEncoding.EncodeToString(deployBytes)},
|
|
"environment": map[string]any{"name": envName, "namespace": ns},
|
|
"source": map[string]any{},
|
|
},
|
|
}}
|
|
|
|
createdPkg, err := dyn.Resource(PackageGVR).Namespace(ns).Create(ctx, newPkg, metav1.CreateOptions{})
|
|
if err != nil {
|
|
return nil, fmt.Errorf("create new package: %w", err)
|
|
}
|
|
|
|
if err := unstructured.SetNestedField(fn.Object, req.Timeout, "spec", "functionTimeout"); err != nil {
|
|
_ = dyn.Resource(PackageGVR).Namespace(ns).Delete(context.Background(), newPkgName, metav1.DeleteOptions{})
|
|
return nil, fmt.Errorf("set function timeout: %w", err)
|
|
}
|
|
|
|
annotations := fn.GetAnnotations()
|
|
if annotations == nil {
|
|
annotations = make(map[string]string)
|
|
}
|
|
annotations[functionUpdatedAtAnnotation] = time.Now().UTC().Format(time.RFC3339)
|
|
fn.SetAnnotations(annotations)
|
|
|
|
if err := unstructured.SetNestedField(fn.Object, map[string]any{
|
|
"name": newPkgName,
|
|
"namespace": ns,
|
|
"resourceversion": createdPkg.GetResourceVersion(),
|
|
}, "spec", "package", "packageref"); err != nil {
|
|
_ = dyn.Resource(PackageGVR).Namespace(ns).Delete(context.Background(), newPkgName, metav1.DeleteOptions{})
|
|
return nil, fmt.Errorf("set function packageref: %w", err)
|
|
}
|
|
|
|
if _, err := dyn.Resource(FunctionGVR).Namespace(ns).Update(ctx, fn, metav1.UpdateOptions{}); err != nil {
|
|
_ = dyn.Resource(PackageGVR).Namespace(ns).Delete(context.Background(), newPkgName, metav1.DeleteOptions{})
|
|
return nil, fmt.Errorf("update function %q: %w", name, err)
|
|
}
|
|
|
|
if oldPkgName != "" && oldPkgName != newPkgName {
|
|
_ = dyn.Resource(PackageGVR).Namespace(ns).Delete(context.Background(), oldPkgName, metav1.DeleteOptions{})
|
|
}
|
|
|
|
return &UpdateFunctionResult{
|
|
Updated: true,
|
|
Package: newPkgName,
|
|
}, nil
|
|
}
|
|
|
|
// DeleteFunction orchestrates the deletion of a function and its related resources.
|
|
func DeleteFunction(ctx context.Context, dyn dynamic.Interface, ns, name string) error {
|
|
// Best-effort deletion of related resources.
|
|
_ = dyn.Resource(HTTPTrigGVR).Namespace(ns).Delete(ctx, name+"-route", metav1.DeleteOptions{})
|
|
|
|
fn, err := dyn.Resource(FunctionGVR).Namespace(ns).Get(ctx, name, metav1.GetOptions{})
|
|
if err != nil && !apierrors.IsNotFound(err) {
|
|
return fmt.Errorf("get function for deletion: %w", err)
|
|
}
|
|
|
|
if err == nil {
|
|
if pkgName, found, _ := unstructured.NestedString(fn.Object, "spec", "package", "packageref", "name"); found && pkgName != "" {
|
|
_ = dyn.Resource(PackageGVR).Namespace(ns).Delete(ctx, pkgName, metav1.DeleteOptions{})
|
|
}
|
|
}
|
|
|
|
if err := dyn.Resource(FunctionGVR).Namespace(ns).Delete(ctx, name, metav1.DeleteOptions{}); err != nil && !apierrors.IsNotFound(err) {
|
|
return fmt.Errorf("delete function: %w", err)
|
|
}
|
|
|
|
if fn != nil {
|
|
if envName, found, _ := unstructured.NestedString(fn.Object, "spec", "environment", "name"); found && envName != "" {
|
|
CleanupEnvironmentIfUnused(context.Background(), dyn, ns, envName)
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func parseTTL(ttl string) (time.Time, error) {
|
|
duration, err := time.ParseDuration(ttl)
|
|
if err != nil {
|
|
return time.Time{}, err
|
|
}
|
|
return time.Now().UTC().Add(duration), nil
|
|
}
|