Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
package projects
import (
"context"
"errors"
"fmt"
"log/slog"
"os"
"path/filepath"
"regexp"
"strings"
composeloader "github.com/compose-spec/compose-go/v2/loader"
composetypes "github.com/compose-spec/compose-go/v2/types"
"github.com/samber/mo"
"go.getarcane.app/acfs"
"github.com/getarcaneapp/arcane/backend/v2/internal/common"
"github.com/getarcaneapp/arcane/backend/v2/pkg/utils"
)
// ReadFolderComposeTemplate stays on os.* for its reads: template folders are
// user-managed on disk, so compose/env files may be symlinks resolving outside
// any confinement root, which acfs cannot follow.
func ReadFolderComposeTemplate(ctx context.Context, baseDir, folder string) (string, *string, string, bool, error) {
folderPath := filepath.Join(baseDir, folder)
composePath, err := DetectComposeFile(ctx, "", folderPath)
if err != nil {
if errors.Is(err, common.ErrComposeFileNotFound) {
return "", nil, "", false, nil
}
return "", nil, "", false, fmt.Errorf("detect compose file: %w", err)
}
b, err := os.ReadFile(composePath)
if err != nil {
return "", nil, "", false, fmt.Errorf("read compose %s: %w", composePath, err)
}
var envPtr *string
for _, envName := range []string{".env.example", ".env"} {
envPath := filepath.Join(folderPath, envName)
if eb, rerr := os.ReadFile(envPath); rerr == nil {
envPtr = new(string(eb))
break
}
}
desc := "Imported from " + composePath
return string(b), envPtr, desc, true, nil
}
var (
slugInvalidCharsPattern = regexp.MustCompile(`[^a-z0-9\-_]+`)
slugDashRunPattern = regexp.MustCompile(`-+`)
)
func Slugify(in string) string {
in = strings.TrimSpace(strings.ToLower(in))
if in == "" {
return ""
}
in = strings.ReplaceAll(in, " ", "-")
in = slugInvalidCharsPattern.ReplaceAllString(in, "-")
in = slugDashRunPattern.ReplaceAllString(in, "-")
return strings.Trim(in, "-")
}
func EnsureTemplateDir(ctx context.Context, templatesDir, base string) (dir, composePath, envPath string, err error) {
baseDir, derr := GetTemplatesDirectory(ctx, templatesDir)
if derr != nil {
return "", "", "", fmt.Errorf("ensure templates dir: %w", derr)
}
dir = filepath.Join(baseDir, base)
dirLogical, err := acfs.LogicalPath(baseDir, dir)
if err != nil {
return "", "", "", fmt.Errorf("template directory is outside the templates root: %w", err)
}
if mkdirAllErr := acfs.MkdirAll(ctx, baseDir, dirLogical, utils.DirPerm); mkdirAllErr != nil {
return "", "", "", fmt.Errorf("failed to create template directory: %w", mkdirAllErr)
}
composePath = filepath.Join(dir, "compose.yaml")
envPath = filepath.Join(dir, ".env.example")
return dir, composePath, envPath, nil
}
func WriteTemplateFiles(composePath, envPath, composeContent, envContent string) (*string, error) {
if err := WriteTemplateFile(composePath, composeContent); err != nil {
return nil, err
}
envTrim := strings.TrimSpace(envContent)
if envTrim == "" {
return nil, nil
}
if err := WriteTemplateFile(envPath, envContent); err != nil {
return nil, err
}
return &envContent, nil
}
// Previous built-in templates; unedited on-disk copies are upgraded to the current defaults.
const (
retiredDefaultComposeTemplate = `services:
nginx:
image: nginx:alpine
container_name: nginx_service
env_file:
- .env
ports:
- "8080:80"
volumes:
- nginx_data:/usr/share/nginx/html
restart: unless-stopped
volumes:
nginx_data:
driver: local
`
retiredDefaultEnvTemplate = `# Environment Variables
# These variables will be available to your project services
# Format: VARIABLE_NAME=value
# Web Server Configuration
NGINX_HOST=localhost
NGINX_PORT=80
# Database Configuration
POSTGRES_DB=myapp
POSTGRES_USER=myuser
POSTGRES_PASSWORD=mypassword
POSTGRES_PORT=5432
# Example Additional Variables
# API_KEY=your_api_key_here
# SECRET_KEY=your_secret_key_here
# DEBUG=false
`
)
// EnsureDefaultTemplates writes missing default templates and upgrades unedited retired defaults.
func EnsureDefaultTemplates(ctx context.Context, configuredTemplatesDir string) error {
templatesDir, err := GetTemplatesDirectory(ctx, configuredTemplatesDir)
if err != nil {
return fmt.Errorf("get templates directory: %w", err)
}
defaults := []struct {
path, name, content, retired string
}{
{"/.compose.template", "compose", getDefaultComposeTemplate(), retiredDefaultComposeTemplate},
{"/.swarm-stack.template", "swarm stack", DefaultSwarmStackTemplate(), ""},
{"/.swarm-stack.env.template", "swarm stack env", DefaultSwarmStackEnvTemplate(), ""},
{"/.env.template", "env", getDefaultEnvTemplate(), retiredDefaultEnvTemplate},
}
for _, tmpl := range defaults {
exists, existsErr := acfs.Exists(ctx, templatesDir, tmpl.path)
if existsErr != nil {
return fmt.Errorf("write default %s template: %w", tmpl.name, existsErr)
}
if exists {
if tmpl.retired == "" {
continue
}
current, readFileErr := acfs.ReadFile(ctx, templatesDir, tmpl.path)
if readFileErr != nil {
return fmt.Errorf("read default %s template: %w", tmpl.name, readFileErr)
}
if string(current) != tmpl.retired {
continue
}
}
if writeErr := acfs.Write(ctx, templatesDir, tmpl.path, []byte(tmpl.content), acfs.WriteOptions{Mode: utils.FilePerm}); writeErr != nil {
return fmt.Errorf("write default %s template: %w", tmpl.name, writeErr)
}
}
return nil
}
func getDefaultComposeTemplate() string {
return `services:
nginx:
image: nginx:alpine
container_name: nginx_service
env_file:
- .env
ports:
- "${NGINX_HOST_PORT:-8080}:80"
volumes:
- nginx_data:/usr/share/nginx/html
restart: unless-stopped
volumes:
nginx_data:
driver: local
`
}
func DefaultSwarmStackTemplate() string {
return `services:
web:
image: ${STACK_WEB_IMAGE:-nginx}:${STACK_WEB_TAG:-alpine}
ports:
- target: 80
published: ${STACK_WEB_PUBLISHED_PORT:-8080}
protocol: tcp
mode: ingress
deploy:
mode: replicated
replicas: ${STACK_WEB_REPLICAS:-2}
update_config:
parallelism: ${STACK_UPDATE_PARALLELISM:-1}
delay: ${STACK_UPDATE_DELAY:-10s}
order: start-first
rollback_config:
parallelism: ${STACK_ROLLBACK_PARALLELISM:-1}
delay: ${STACK_ROLLBACK_DELAY:-5s}
order: stop-first
restart_policy:
condition: on-failure
delay: ${STACK_RESTART_DELAY:-5s}
networks:
- web
networks:
web:
driver: overlay
name: ${STACK_OVERLAY_NETWORK:-web}
`
}
func DefaultSwarmStackEnvTemplate() string {
return `# Docker Swarm stack variables
# These values are interpolated into the stack file before deployment.
# Example syntax in compose.yaml:
# image: ${STACK_WEB_IMAGE:-nginx}:${STACK_WEB_TAG:-alpine}
# replicas: ${STACK_WEB_REPLICAS:-2}
# Service image
STACK_WEB_IMAGE=nginx
STACK_WEB_TAG=alpine
# Published ingress port for the web service
STACK_WEB_PUBLISHED_PORT=8080
# Replica count for deploy.mode=replicated
STACK_WEB_REPLICAS=2
# Actual Docker overlay network name created for the stack
STACK_OVERLAY_NETWORK=web
# Rolling update behavior
STACK_UPDATE_PARALLELISM=1
STACK_UPDATE_DELAY=10s
# Rollback behavior
STACK_ROLLBACK_PARALLELISM=1
STACK_ROLLBACK_DELAY=5s
# Restart policy
STACK_RESTART_DELAY=5s
`
}
func getDefaultEnvTemplate() string {
return `# Project variables
# These values are interpolated into compose.yaml and passed to services via env_file.
# Example syntax in compose.yaml:
# ports:
# - "${NGINX_HOST_PORT:-8080}:80"
# Host port that serves the nginx container
NGINX_HOST_PORT=8080
`
}
// ParseComposeServices extracts service names from a compose file content using compose-go
func ParseComposeServices(ctx context.Context, composeContent string) []string {
if composeContent == "" {
return []string{}
}
// Create a temp directory with dummy .env file to satisfy env_file references
// System temp scratch: no acfs root exists for it.
tmpDir, err := os.MkdirTemp("", "arcane-compose-parse-*")
if err != nil {
slog.WarnContext(ctx, "Failed to create temp dir for compose parsing", "error", err)
return []string{}
}
defer func() { _ = os.RemoveAll(tmpDir) }()
// Create a dummy .env file to prevent env file errors
envPath := filepath.Join(tmpDir, ".env")
if writeFileWithPermErr := WriteFileWithPerm(envPath, "", utils.FilePerm); writeFileWithPermErr != nil {
slog.WarnContext(ctx, "Failed to create dummy env file", "error", writeFileWithPermErr)
}
// Parse using compose-go
configDetails := composetypes.ConfigDetails{
ConfigFiles: []composetypes.ConfigFile{
{
Content: []byte(composeContent),
},
},
WorkingDir: tmpDir,
Environment: composetypes.Mapping{},
}
project, err := composeloader.LoadWithContext(ctx, configDetails, composeloader.WithSkipValidation)
if err != nil {
slog.WarnContext(ctx, "Failed to parse compose services", "error", err)
return []string{}
}
serviceNames := make([]string, 0, len(project.Services))
for _, service := range project.Services {
serviceNames = append(serviceNames, service.Name)
}
return serviceNames
}
// ResolveTemplateIconURL reads Arcane icon metadata from template Compose content.
func ResolveTemplateIconURL(ctx context.Context, composeContent, envContent string) *string {
if strings.TrimSpace(composeContent) == "" {
return nil
}
// System temp scratch: no acfs root exists for it.
tmpDir, err := os.MkdirTemp("", "arcane-template-icon-*")
if err != nil {
slog.WarnContext(ctx, "failed to create temp dir for template icon parsing", "error", err)
return nil
}
defer func() { _ = os.RemoveAll(tmpDir) }()
envPath := filepath.Join(tmpDir, ".env")
if writeFileWithPermErr := WriteFileWithPerm(envPath, envContent, utils.FilePerm); writeFileWithPermErr != nil {
slog.WarnContext(ctx, "failed to create temp env file for template icon parsing", "error", writeFileWithPermErr)
}
envMap := make(composetypes.Mapping)
for _, variable := range ParseEnvContent(envContent) {
if key := strings.TrimSpace(variable.Key); key != "" {
envMap[key] = variable.Value
}
}
envMap["PWD"] = tmpDir
configDetails := composetypes.ConfigDetails{
ConfigFiles: []composetypes.ConfigFile{
{
Content: []byte(composeContent),
},
},
WorkingDir: tmpDir,
Environment: envMap,
}
project, err := composeloader.LoadWithContext(ctx, configDetails, composeloader.WithSkipValidation, func(opts *composeloader.Options) {
opts.SkipConsistencyCheck = true
})
if err != nil {
slog.WarnContext(ctx, "failed to parse compose for template icon metadata", "error", err)
return nil
}
if project == nil {
return nil
}
icon, _, _, _ := parseArcaneBlockInternal(ctx, project.Extensions[arcaneBlockKey])
return mo.EmptyableToOption(strings.TrimSpace(icon.Icon)).ToPointer()
}