knowledge-governance/cmd/release-worker/config.go

package main

import (
	"bytes"
	"encoding/json"
	"errors"
	"io"
	"net/url"
	"os"
	"path/filepath"
	"strings"
	"syscall"
)

const maxReleaseConfigBytes = 1024 * 1024

type releaseRuntimeConfig struct {
	ArchiveRoot string               `json:"archive_root"`
	Routes      []releaseRouteConfig `json:"routes"`
}

type releaseRouteConfig struct {
	TenantID        uint64                `json:"tenant_id"`
	KnowledgeBaseID string                `json:"knowledge_base_id"`
	EmbeddingModel  string                `json:"embedding_model"`
	Source          releaseEndpointConfig `json:"source"`
	Target          releaseEndpointConfig `json:"target"`
}

type releaseEndpointConfig struct {
	DatabaseURLFile string                     `json:"database_url_file"`
	Elasticsearch   releaseElasticsearchConfig `json:"elasticsearch"`
	Object          releaseObjectConfig        `json:"object"`
	WeKnora         releaseWeKnoraConfig       `json:"weknora"`
}

type releaseElasticsearchConfig struct {
	BaseURL   string `json:"base_url"`
	Index     string `json:"index"`
	TokenFile string `json:"token_file"`
}

type releaseObjectConfig struct {
	Provider         string `json:"provider"`
	Endpoint         string `json:"endpoint"`
	Region           string `json:"region"`
	Bucket           string `json:"bucket"`
	StorageBackendID string `json:"storage_backend_id"`
	AccessKeyFile    string `json:"access_key_file"`
	SecretKeyFile    string `json:"secret_key_file"`
}

type releaseWeKnoraConfig struct {
	BaseURL         string `json:"base_url"`
	APIKeyFile      string `json:"api_key_file"`
	AllowDockerHTTP bool   `json:"allow_docker_http"`
}

func loadReleaseRuntimeConfig(path string) (releaseRuntimeConfig, error) {
	if !filepath.IsAbs(path) {
		return releaseRuntimeConfig{}, errors.New("release config path must be absolute")
	}
	fd, err := syscall.Open(path, syscall.O_RDONLY|syscall.O_NOFOLLOW, 0)
	if err != nil {
		return releaseRuntimeConfig{}, errors.New("open release config")
	}
	file := os.NewFile(uintptr(fd), "release-config")
	if file == nil {
		syscall.Close(fd)
		return releaseRuntimeConfig{}, errors.New("open release config")
	}
	defer file.Close()
	info, err := file.Stat()
	if err != nil || !info.Mode().IsRegular() || info.Mode().Perm() != 0o600 || info.Size() <= 0 || info.Size() > maxReleaseConfigBytes {
		return releaseRuntimeConfig{}, errors.New("release config must be a non-empty regular 0600 file")
	}
	payload, err := io.ReadAll(io.LimitReader(file, maxReleaseConfigBytes+1))
	if err != nil || len(payload) > maxReleaseConfigBytes {
		return releaseRuntimeConfig{}, errors.New("read release config")
	}
	decoder := json.NewDecoder(bytes.NewReader(payload))
	decoder.DisallowUnknownFields()
	var config releaseRuntimeConfig
	if err := decoder.Decode(&config); err != nil {
		return releaseRuntimeConfig{}, errors.New("decode release config")
	}
	var trailing any
	if err := decoder.Decode(&trailing); !errors.Is(err, io.EOF) {
		return releaseRuntimeConfig{}, errors.New("release config contains trailing data")
	}
	if err := validateReleaseRuntimeConfig(config); err != nil {
		return releaseRuntimeConfig{}, err
	}
	return config, nil
}

func validateReleaseRuntimeConfig(config releaseRuntimeConfig) error {
	if !filepath.IsAbs(config.ArchiveRoot) || len(config.Routes) == 0 {
		return errors.New("release archive root and routes are required")
	}
	seen := map[string]bool{}
	for _, route := range config.Routes {
		if route.TenantID == 0 || !validConfigIdentifier(route.KnowledgeBaseID) || !validConfigIdentifier(route.EmbeddingModel) || seen[route.KnowledgeBaseID] {
			return errors.New("invalid or duplicate release route")
		}
		seen[route.KnowledgeBaseID] = true
		if !validReleaseEndpoint(route.Source, false) || !validReleaseEndpoint(route.Target, true) {
			return errors.New("invalid release route endpoint")
		}
		if route.Source.DatabaseURLFile == route.Target.DatabaseURLFile ||
			route.Source.Elasticsearch.BaseURL == route.Target.Elasticsearch.BaseURL ||
			(route.Source.Object.Endpoint == route.Target.Object.Endpoint && route.Source.Object.Bucket == route.Target.Object.Bucket) {
			return errors.New("release source and target must be distinct")
		}
	}
	return nil
}

func validReleaseEndpoint(endpoint releaseEndpointConfig, target bool) bool {
	if !absoluteFile(endpoint.DatabaseURLFile) || !validHTTPURL(endpoint.Elasticsearch.BaseURL) || !validConfigIdentifier(endpoint.Elasticsearch.Index) ||
		(endpoint.Elasticsearch.TokenFile != "" && !absoluteFile(endpoint.Elasticsearch.TokenFile)) ||
		!validObjectEndpoint(endpoint.Object) {
		return false
	}
	if target {
		return validConfigIdentifier(endpoint.Object.StorageBackendID) && validHTTPURL(endpoint.WeKnora.BaseURL) && absoluteFile(endpoint.WeKnora.APIKeyFile)
	}
	return endpoint.WeKnora.BaseURL == "" && endpoint.WeKnora.APIKeyFile == ""
}

func validObjectEndpoint(object releaseObjectConfig) bool {
	return (object.Provider == "minio" || object.Provider == "s3" || object.Provider == "oss") && validHTTPURL(object.Endpoint) &&
		validConfigIdentifier(object.Bucket) && absoluteFile(object.AccessKeyFile) && absoluteFile(object.SecretKeyFile)
}

func absoluteFile(path string) bool { return filepath.IsAbs(path) && filepath.Clean(path) == path }

func validHTTPURL(value string) bool {
	parsed, err := url.Parse(value)
	return err == nil && (parsed.Scheme == "http" || parsed.Scheme == "https") && parsed.Host != "" && parsed.User == nil && parsed.RawQuery == "" && parsed.Fragment == ""
}

func validConfigIdentifier(value string) bool {
	value = strings.TrimSpace(value)
	if value == "" || len(value) > 128 {
		return false
	}
	for _, char := range value {
		if (char >= 'a' && char <= 'z') || (char >= 'A' && char <= 'Z') || (char >= '0' && char <= '9') || char == '-' || char == '_' || char == '.' {
			continue
		}
		return false
	}
	return true
}