436 lines
16 KiB
Go
436 lines
16 KiB
Go
// 2026-03-07
|
|
// function_resource.go — Terraform ресурс sless_function.
|
|
//
|
|
// Lifecycle:
|
|
//
|
|
// Create: POST /functions → если code_path задан: upload zip → WaitReady (5 мин)
|
|
// Read: GET /functions/{name} → sync state
|
|
// Update: PUT /functions/{name} → если code_hash изменился: upload zip → WaitReady
|
|
// Delete: DELETE /functions/{name}
|
|
//
|
|
// code_hash — пользователь задаёт сам (например filemd5("./handler.zip")).
|
|
// Изменение hash → провайдер перезагружает zip и ждёт новой сборки.
|
|
// Это стандартный паттерн для file-based ресурсов в terraform-plugin-framework.
|
|
//
|
|
// При переносе в nubes: файл кладётся в internal/resources_gen/ без изменений,
|
|
// client.Client заменяется на *core.UniversalClient или аналогичный.
|
|
package resources
|
|
|
|
import (
|
|
"archive/zip"
|
|
"bytes"
|
|
"context"
|
|
"crypto/sha256"
|
|
"encoding/hex"
|
|
"fmt"
|
|
"io/fs"
|
|
"os"
|
|
"path/filepath"
|
|
"sort"
|
|
"time"
|
|
|
|
"terraform-provider-sless/internal/client"
|
|
|
|
"github.com/hashicorp/terraform-plugin-framework-validators/int64validator"
|
|
"github.com/hashicorp/terraform-plugin-framework-validators/stringvalidator"
|
|
"github.com/hashicorp/terraform-plugin-framework/diag"
|
|
"github.com/hashicorp/terraform-plugin-framework/resource"
|
|
"github.com/hashicorp/terraform-plugin-framework/resource/schema"
|
|
"github.com/hashicorp/terraform-plugin-framework/resource/schema/planmodifier"
|
|
"github.com/hashicorp/terraform-plugin-framework/resource/schema/stringplanmodifier"
|
|
"github.com/hashicorp/terraform-plugin-framework/schema/validator"
|
|
"github.com/hashicorp/terraform-plugin-framework/types"
|
|
)
|
|
|
|
// defaultBuildTimeoutSec — дефолтный таймаут ожидания kaniko-сборки (300 сек = 5 мин).
|
|
// Пользователь может переопределить через build_timeout_sec.
|
|
const defaultBuildTimeoutSec = 300
|
|
|
|
var _ resource.Resource = &FunctionResource{}
|
|
|
|
type FunctionResource struct {
|
|
client *client.Client
|
|
}
|
|
|
|
func NewFunctionResource() resource.Resource {
|
|
return &FunctionResource{}
|
|
}
|
|
|
|
// FunctionModel — модель состояния terraform для sless_function.
|
|
type FunctionModel struct {
|
|
Name types.String `tfsdk:"name"`
|
|
Runtime types.String `tfsdk:"runtime"`
|
|
Entrypoint types.String `tfsdk:"entrypoint"`
|
|
MemoryMB types.Int64 `tfsdk:"memory_mb"`
|
|
TimeoutSec types.Int64 `tfsdk:"timeout_sec"`
|
|
EnvVars types.Map `tfsdk:"env_vars"`
|
|
CodePath types.String `tfsdk:"code_path"`
|
|
// source_dir — директория с исходниками. Провайдер сам упакует в zip и загрузит.
|
|
// Взаимоисключающе с code_path. Не требует hashicorp/archive.
|
|
SourceDir types.String `tfsdk:"source_dir"`
|
|
// code_hash — sha256 содержимого. При code_path: задаётся вручную.
|
|
// При source_dir: провайдер вычисляет сам и хранит в state для детекции изменений.
|
|
CodeHash types.String `tfsdk:"code_hash"`
|
|
// build_timeout_sec — максимальное ожидание kaniko-сборки. Дефолт 300 сек.
|
|
BuildTimeoutSec types.Int64 `tfsdk:"build_timeout_sec"`
|
|
Phase types.String `tfsdk:"phase"`
|
|
ImageRef types.String `tfsdk:"image_ref"`
|
|
}
|
|
|
|
func (r *FunctionResource) Metadata(_ context.Context, req resource.MetadataRequest, resp *resource.MetadataResponse) {
|
|
resp.TypeName = req.ProviderTypeName + "_function"
|
|
}
|
|
|
|
func (r *FunctionResource) Schema(_ context.Context, _ resource.SchemaRequest, resp *resource.SchemaResponse) {
|
|
resp.Schema = schema.Schema{
|
|
Attributes: map[string]schema.Attribute{
|
|
// name — immutable, смена требует пересоздания ресурса
|
|
"name": schema.StringAttribute{
|
|
Required: true,
|
|
PlanModifiers: []planmodifier.String{
|
|
stringplanmodifier.RequiresReplace(),
|
|
},
|
|
},
|
|
"runtime": schema.StringAttribute{
|
|
Required: true,
|
|
PlanModifiers: []planmodifier.String{
|
|
stringplanmodifier.RequiresReplace(),
|
|
},
|
|
Validators: []validator.String{
|
|
stringvalidator.OneOf("nodejs20", "python3.11", "go1.21"),
|
|
},
|
|
},
|
|
"entrypoint": schema.StringAttribute{
|
|
Optional: true,
|
|
Computed: true,
|
|
PlanModifiers: []planmodifier.String{
|
|
stringplanmodifier.UseStateForUnknown(),
|
|
},
|
|
},
|
|
"memory_mb": schema.Int64Attribute{
|
|
Optional: true,
|
|
Computed: true,
|
|
Validators: []validator.Int64{
|
|
int64validator.Between(1, 4096),
|
|
},
|
|
},
|
|
"timeout_sec": schema.Int64Attribute{
|
|
Optional: true,
|
|
Computed: true,
|
|
Validators: []validator.Int64{
|
|
int64validator.Between(1, 900),
|
|
},
|
|
},
|
|
"env_vars": schema.MapAttribute{
|
|
ElementType: types.StringType,
|
|
Optional: true,
|
|
},
|
|
"code_path": schema.StringAttribute{
|
|
Optional: true,
|
|
},
|
|
// source_dir — путь к директории с исходниками. Провайдер сам соберёт zip без archive provider.
|
|
"source_dir": schema.StringAttribute{
|
|
Optional: true,
|
|
MarkdownDescription: "Путь к директории с исходным кодом. Провайдер сам упакует в zip. Не нужен archive provider.",
|
|
},
|
|
// code_hash — при code_path: задаётся вручную; при source_dir: вычисляется автоматически.
|
|
"code_hash": schema.StringAttribute{
|
|
Optional: true,
|
|
Computed: true,
|
|
},
|
|
// build_timeout_sec — таймаут ожидания kaniko-сборки. Дефолт 300 сек (5 мин).
|
|
// Увеличь если функция с тяжёлыми зависимостями (например torch).
|
|
"build_timeout_sec": schema.Int64Attribute{
|
|
Optional: true,
|
|
Computed: true,
|
|
MarkdownDescription: "Таймаут ожидания сборки образа в секундах. По умолчанию 300 (5 мин).",
|
|
},
|
|
// phase, image_ref — только для чтения, вычисляются оператором
|
|
"phase": schema.StringAttribute{
|
|
Computed: true,
|
|
PlanModifiers: []planmodifier.String{
|
|
stringplanmodifier.UseStateForUnknown(),
|
|
},
|
|
},
|
|
// image_ref — только для чтения, вычисляется оператором после сборки образа.
|
|
// Намеренно без UseStateForUnknown: при пересборке (смена code_hash) image_ref
|
|
// может измениться (например смена registry), поэтому всегда (known after apply).
|
|
"image_ref": schema.StringAttribute{
|
|
Computed: true,
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
func (r *FunctionResource) Configure(_ context.Context, req resource.ConfigureRequest, resp *resource.ConfigureResponse) {
|
|
if req.ProviderData == nil {
|
|
return
|
|
}
|
|
c, ok := req.ProviderData.(*client.Client)
|
|
if !ok {
|
|
resp.Diagnostics.AddError(
|
|
"unexpected provider data",
|
|
fmt.Sprintf("expected *client.Client, got: %T", req.ProviderData),
|
|
)
|
|
return
|
|
}
|
|
r.client = c
|
|
}
|
|
|
|
func (r *FunctionResource) Create(ctx context.Context, req resource.CreateRequest, resp *resource.CreateResponse) {
|
|
var plan FunctionModel
|
|
resp.Diagnostics.Append(req.Plan.Get(ctx, &plan)...)
|
|
if resp.Diagnostics.HasError() {
|
|
return
|
|
}
|
|
|
|
ns := r.client.Namespace
|
|
envVars, d := mapToStringMap(ctx, plan.EnvVars)
|
|
resp.Diagnostics.Append(d...)
|
|
if resp.Diagnostics.HasError() {
|
|
return
|
|
}
|
|
|
|
fn, err := r.client.CreateFunction(ctx, ns, client.FunctionRequest{
|
|
Name: plan.Name.ValueString(),
|
|
Runtime: plan.Runtime.ValueString(),
|
|
Entrypoint: plan.Entrypoint.ValueString(),
|
|
MemoryMB: int32(plan.MemoryMB.ValueInt64()),
|
|
TimeoutSec: int32(plan.TimeoutSec.ValueInt64()),
|
|
Env: envVars,
|
|
})
|
|
if err != nil {
|
|
resp.Diagnostics.AddError("create function", err.Error())
|
|
return
|
|
}
|
|
|
|
var codeUploaded bool
|
|
if !plan.SourceDir.IsNull() && plan.SourceDir.ValueString() != "" {
|
|
// source_dir: провайдер сам собирает zip и вычисляет hash
|
|
zipData, hash, err := zipDir(plan.SourceDir.ValueString())
|
|
if err != nil {
|
|
resp.Diagnostics.AddError("zip source_dir", err.Error())
|
|
return
|
|
}
|
|
if err := r.client.UploadCodeReader(ctx, ns, fn.Name, "code.zip", bytes.NewReader(zipData)); err != nil {
|
|
resp.Diagnostics.AddError("upload code", err.Error())
|
|
return
|
|
}
|
|
plan.CodeHash = types.StringValue(hash)
|
|
codeUploaded = true
|
|
} else if !plan.CodePath.IsNull() && plan.CodePath.ValueString() != "" {
|
|
// code_path: старый путь, для обратной совместимости
|
|
if err := r.client.UploadCode(ctx, ns, fn.Name, plan.CodePath.ValueString()); err != nil {
|
|
resp.Diagnostics.AddError("upload code", err.Error())
|
|
return
|
|
}
|
|
codeUploaded = true
|
|
}
|
|
if codeUploaded {
|
|
buildSec := plan.BuildTimeoutSec.ValueInt64()
|
|
if buildSec <= 0 {
|
|
buildSec = defaultBuildTimeoutSec
|
|
}
|
|
fn, err = r.client.WaitReady(ctx, ns, fn.Name, time.Duration(buildSec)*time.Second)
|
|
if err != nil {
|
|
resp.Diagnostics.AddError("waiting for function ready", err.Error())
|
|
return
|
|
}
|
|
}
|
|
|
|
resp.Diagnostics.Append(resp.State.Set(ctx, fnToModel(plan, fn))...)
|
|
}
|
|
|
|
func (r *FunctionResource) Read(ctx context.Context, req resource.ReadRequest, resp *resource.ReadResponse) {
|
|
var state FunctionModel
|
|
resp.Diagnostics.Append(req.State.Get(ctx, &state)...)
|
|
if resp.Diagnostics.HasError() {
|
|
return
|
|
}
|
|
|
|
fn, err := r.client.GetFunction(ctx, r.client.Namespace, state.Name.ValueString())
|
|
if err != nil {
|
|
resp.Diagnostics.AddError("read function", err.Error())
|
|
return
|
|
}
|
|
if fn == nil {
|
|
// Ресурс удалён вне terraform — убираем из state
|
|
resp.State.RemoveResource(ctx)
|
|
return
|
|
}
|
|
|
|
resp.Diagnostics.Append(resp.State.Set(ctx, fnToModel(state, fn))...)
|
|
}
|
|
|
|
func (r *FunctionResource) Update(ctx context.Context, req resource.UpdateRequest, resp *resource.UpdateResponse) {
|
|
var plan, state FunctionModel
|
|
resp.Diagnostics.Append(req.Plan.Get(ctx, &plan)...)
|
|
resp.Diagnostics.Append(req.State.Get(ctx, &state)...)
|
|
if resp.Diagnostics.HasError() {
|
|
return
|
|
}
|
|
|
|
ns := r.client.Namespace
|
|
name := plan.Name.ValueString()
|
|
|
|
envVars, d := mapToStringMap(ctx, plan.EnvVars)
|
|
resp.Diagnostics.Append(d...)
|
|
if resp.Diagnostics.HasError() {
|
|
return
|
|
}
|
|
|
|
fn, err := r.client.UpdateFunction(ctx, ns, name, client.FunctionRequest{
|
|
Name: name,
|
|
Runtime: plan.Runtime.ValueString(),
|
|
Entrypoint: plan.Entrypoint.ValueString(),
|
|
MemoryMB: int32(plan.MemoryMB.ValueInt64()),
|
|
TimeoutSec: int32(plan.TimeoutSec.ValueInt64()),
|
|
Env: envVars,
|
|
})
|
|
if err != nil {
|
|
resp.Diagnostics.AddError("update function", err.Error())
|
|
return
|
|
}
|
|
|
|
var codeUploaded bool
|
|
if !plan.SourceDir.IsNull() && plan.SourceDir.ValueString() != "" {
|
|
// source_dir: пересчитываем hash и загружаем только если изменился
|
|
zipData, hash, err := zipDir(plan.SourceDir.ValueString())
|
|
if err != nil {
|
|
resp.Diagnostics.AddError("zip source_dir", err.Error())
|
|
return
|
|
}
|
|
newHash := types.StringValue(hash)
|
|
if !newHash.Equal(state.CodeHash) {
|
|
if err := r.client.UploadCodeReader(ctx, ns, name, "code.zip", bytes.NewReader(zipData)); err != nil {
|
|
resp.Diagnostics.AddError("upload code", err.Error())
|
|
return
|
|
}
|
|
codeUploaded = true
|
|
}
|
|
plan.CodeHash = newHash
|
|
} else if !plan.CodeHash.Equal(state.CodeHash) && !plan.CodePath.IsNull() && plan.CodePath.ValueString() != "" {
|
|
// code_path: загружаем только если code_hash изменился вручную
|
|
if err := r.client.UploadCode(ctx, ns, name, plan.CodePath.ValueString()); err != nil {
|
|
resp.Diagnostics.AddError("upload code", err.Error())
|
|
return
|
|
}
|
|
codeUploaded = true
|
|
}
|
|
if codeUploaded {
|
|
buildSec := plan.BuildTimeoutSec.ValueInt64()
|
|
if buildSec <= 0 {
|
|
buildSec = defaultBuildTimeoutSec
|
|
}
|
|
fn, err = r.client.WaitReady(ctx, ns, name, time.Duration(buildSec)*time.Second)
|
|
if err != nil {
|
|
resp.Diagnostics.AddError("waiting for function ready", err.Error())
|
|
return
|
|
}
|
|
}
|
|
|
|
resp.Diagnostics.Append(resp.State.Set(ctx, fnToModel(plan, fn))...)
|
|
}
|
|
|
|
func (r *FunctionResource) Delete(ctx context.Context, req resource.DeleteRequest, resp *resource.DeleteResponse) {
|
|
var state FunctionModel
|
|
resp.Diagnostics.Append(req.State.Get(ctx, &state)...)
|
|
if resp.Diagnostics.HasError() {
|
|
return
|
|
}
|
|
|
|
if err := r.client.DeleteFunction(ctx, r.client.Namespace, state.Name.ValueString()); err != nil {
|
|
resp.Diagnostics.AddError("delete function", err.Error())
|
|
}
|
|
}
|
|
|
|
// fnToModel конвертирует API-ответ + plan (для локальных полей) → state модель.
|
|
// plan используется для code_path, code_hash, build_timeout_sec — API их не хранит.
|
|
func fnToModel(plan FunctionModel, fn *client.FunctionResponse) FunctionModel {
|
|
buildTimeoutSec := plan.BuildTimeoutSec
|
|
// Если не задан пользователем — записываем дефолт чтобы не было null в state
|
|
if buildTimeoutSec.IsNull() || buildTimeoutSec.IsUnknown() || buildTimeoutSec.ValueInt64() <= 0 {
|
|
buildTimeoutSec = types.Int64Value(defaultBuildTimeoutSec)
|
|
}
|
|
return FunctionModel{
|
|
Name: types.StringValue(fn.Name),
|
|
Runtime: types.StringValue(fn.Runtime),
|
|
Entrypoint: types.StringValue(fn.Entrypoint),
|
|
MemoryMB: types.Int64Value(int64(fn.MemoryMB)),
|
|
TimeoutSec: types.Int64Value(int64(fn.TimeoutSec)),
|
|
EnvVars: plan.EnvVars, // API возвращает null для пустого map — берём из plan
|
|
CodePath: plan.CodePath,
|
|
SourceDir: plan.SourceDir,
|
|
CodeHash: plan.CodeHash,
|
|
BuildTimeoutSec: buildTimeoutSec,
|
|
Phase: types.StringValue(fn.Phase),
|
|
ImageRef: types.StringValue(fn.ImageRef),
|
|
}
|
|
}
|
|
|
|
// zipDir упаковывает директорию dir в zip-архив (in-memory) и возвращает байты + SHA256 содержимого.
|
|
// Сортирует файлы по пути для детерминированного хеша — одинаковый код даёт одинаковый hash.
|
|
func zipDir(dir string) ([]byte, string, error) {
|
|
var paths []string
|
|
err := filepath.WalkDir(dir, func(path string, d fs.DirEntry, err error) error {
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if !d.IsDir() {
|
|
paths = append(paths, path)
|
|
}
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
return nil, "", fmt.Errorf("walk dir %q: %w", dir, err)
|
|
}
|
|
sort.Strings(paths)
|
|
|
|
var buf bytes.Buffer
|
|
zw := zip.NewWriter(&buf)
|
|
h := sha256.New()
|
|
for _, path := range paths {
|
|
rel, err := filepath.Rel(dir, path)
|
|
if err != nil {
|
|
return nil, "", err
|
|
}
|
|
data, err := os.ReadFile(path)
|
|
if err != nil {
|
|
return nil, "", fmt.Errorf("read %q: %w", path, err)
|
|
}
|
|
fw, err := zw.Create(rel)
|
|
if err != nil {
|
|
return nil, "", fmt.Errorf("zip create %q: %w", rel, err)
|
|
}
|
|
if _, err := fw.Write(data); err != nil {
|
|
return nil, "", fmt.Errorf("zip write %q: %w", rel, err)
|
|
}
|
|
// хешируем путь + содержимое для надёжной детекции изменений
|
|
h.Write([]byte(rel))
|
|
h.Write(data)
|
|
}
|
|
if err := zw.Close(); err != nil {
|
|
return nil, "", fmt.Errorf("zip close: %w", err)
|
|
}
|
|
return buf.Bytes(), hex.EncodeToString(h.Sum(nil)), nil
|
|
}
|
|
|
|
// mapToStringMap конвертирует types.Map → map[string]string.
|
|
func mapToStringMap(ctx context.Context, m types.Map) (map[string]string, diag.Diagnostics) {
|
|
if m.IsNull() || m.IsUnknown() {
|
|
return nil, nil
|
|
}
|
|
elements := m.Elements()
|
|
result := make(map[string]string, len(elements))
|
|
var diags diag.Diagnostics
|
|
for k, v := range elements {
|
|
strVal, ok := v.(types.String)
|
|
if !ok {
|
|
diags.AddError("env_vars conversion", fmt.Sprintf("value for key %q is not a string", k))
|
|
continue
|
|
}
|
|
result[k] = strVal.ValueString()
|
|
}
|
|
return result, diags
|
|
}
|