Skip to content

Modern Docker Management, Designed for Everyone

fix: allow use of the local templates directory (#462)

Kyle Mendellcae0df4fd3a2
diff --git a/backend/internal/bootstrap/jobs_bootstrap.go b/backend/internal/bootstrap/jobs_bootstrap.go
index 8f3b3d1dc..c888a938d 100644
--- a/backend/internal/bootstrap/jobs_bootstrap.go
+++ b/backend/internal/bootstrap/jobs_bootstrap.go
@@ -25,7 +25,7 @@ func registerJobs(appCtx context.Context, scheduler *job.Scheduler, appServices
slog.ErrorContext(appCtx, "Failed to register event cleanup job", slog.Any("error", err))
}
- if err := job.RegisterFilesystemWatcherJob(appCtx, scheduler, appServices.Stack, appServices.Settings); err != nil {
+ if err := job.RegisterFilesystemWatcherJob(appCtx, scheduler, appServices.Stack, appServices.Template, appServices.Settings); err != nil {
slog.ErrorContext(appCtx, "Failed to register filesystem watcher job", slog.Any("error", err))
}
diff --git a/backend/internal/job/filesystem_watcher_job.go b/backend/internal/job/filesystem_watcher_job.go
index a362109fa..9168df5be 100644
--- a/backend/internal/job/filesystem_watcher_job.go
+++ b/backend/internal/job/filesystem_watcher_job.go
@@ -3,33 +3,36 @@ package job
import (
"context"
"log/slog"
- "os"
"time"
"github.com/ofkm/arcane-backend/internal/services"
"github.com/ofkm/arcane-backend/internal/utils"
+ "github.com/ofkm/arcane-backend/internal/utils/fs"
)
type FilesystemWatcherJob struct {
- stackService *services.StackService
- settingsService *services.SettingsService
- watcher *utils.FilesystemWatcher
+ stackService *services.StackService
+ templateService *services.TemplateService
+ settingsService *services.SettingsService
+ projectsWatcher *utils.FilesystemWatcher
+ templatesWatcher *utils.FilesystemWatcher
}
func NewFilesystemWatcherJob(
stackService *services.StackService,
+ templateService *services.TemplateService,
settingsService *services.SettingsService,
) *FilesystemWatcherJob {
return &FilesystemWatcherJob{
stackService: stackService,
+ templateService: templateService,
settingsService: settingsService,
}
}
-func RegisterFilesystemWatcherJob(ctx context.Context, scheduler *Scheduler, stackService *services.StackService, settingsService *services.SettingsService) error {
- job := NewFilesystemWatcherJob(stackService, settingsService)
+func RegisterFilesystemWatcherJob(ctx context.Context, scheduler *Scheduler, stackService *services.StackService, templateService *services.TemplateService, settingsService *services.SettingsService) error {
+ job := NewFilesystemWatcherJob(stackService, templateService, settingsService)
- // Start the filesystem watcher as a background task
go func() {
if err := job.Start(ctx); err != nil {
slog.ErrorContext(ctx, "Filesystem watcher failed", "error", err)
@@ -41,22 +44,17 @@ func RegisterFilesystemWatcherJob(ctx context.Context, scheduler *Scheduler, sta
}
func (j *FilesystemWatcherJob) Start(ctx context.Context) error {
- // Get stacks directory from settings
- stacksDir, err := j.getStacksDirectory(ctx)
+
+ settings, err := j.settingsService.GetSettings(ctx)
if err != nil {
return err
}
-
- // Ensure directory exists
- if _, err := os.Stat(stacksDir); os.IsNotExist(err) {
- if err := os.MkdirAll(stacksDir, 0755); err != nil {
- return err
- }
- slog.InfoContext(ctx, "Created stacks directory", "path", stacksDir)
+ projectsDirectory, err := fs.GetProjectsDirectory(ctx, settings.StacksDirectory.Value)
+ if err != nil {
+ return err
}
- // Create filesystem watcher
- watcher, err := utils.NewFilesystemWatcher(stacksDir, utils.WatcherOptions{
+ sw, err := utils.NewFilesystemWatcher(projectsDirectory, utils.WatcherOptions{
Debounce: 3 * time.Second, // Wait 3 seconds after last change before syncing
OnChange: j.handleFilesystemChange,
})
@@ -64,27 +62,71 @@ func (j *FilesystemWatcherJob) Start(ctx context.Context) error {
return err
}
- j.watcher = watcher
+ j.projectsWatcher = sw
+
+ templatesDir, err := fs.GetTemplatesDirectory(ctx)
+ if err != nil {
+ return err
+ }
+
+ if j.templateService != nil {
+ tw, err := utils.NewFilesystemWatcher(templatesDir, utils.WatcherOptions{
+ Debounce: 3 * time.Second,
+ OnChange: j.handleTemplatesChange,
+ })
+ if err != nil {
+ return err
+ }
+ j.templatesWatcher = tw
+ }
- // Start watching
- if err := j.watcher.Start(ctx); err != nil {
+ if err := j.projectsWatcher.Start(ctx); err != nil {
return err
}
+ if j.templatesWatcher != nil {
+ if err := j.templatesWatcher.Start(ctx); err != nil {
+ if stopErr := j.projectsWatcher.Stop(); stopErr != nil {
+ slog.ErrorContext(ctx, "Failed to stop projects watcher after templates watcher start error", "error", stopErr)
+ }
+ return err
+ }
+ }
+
+ slog.InfoContext(ctx, "Filesystem watcher started for projects directory",
+ "path", projectsDirectory)
+ if j.templatesWatcher != nil {
+ slog.InfoContext(ctx, "Filesystem watcher started for templates directory",
+ "path", templatesDir)
+ }
- slog.InfoContext(ctx, "Filesystem watcher started for stacks directory",
- "path", stacksDir)
+ // Initial sync to surface pre-existing resources
+ if err := j.stackService.SyncAllStacksFromFilesystem(ctx); err != nil {
+ slog.ErrorContext(ctx, "Initial stack sync failed", "error", err)
+ }
+ if j.templateService != nil {
+ if err := j.templateService.SyncLocalTemplatesFromFilesystem(ctx); err != nil {
+ slog.ErrorContext(ctx, "Initial template sync failed", "error", err)
+ }
+ }
- // Keep the watcher running until context is cancelled
<-ctx.Done()
return j.Stop()
}
func (j *FilesystemWatcherJob) Stop() error {
- if j.watcher != nil {
- return j.watcher.Stop()
+ var firstErr error
+ if j.projectsWatcher != nil {
+ if err := j.projectsWatcher.Stop(); err != nil {
+ firstErr = err
+ }
}
- return nil
+ if j.templatesWatcher != nil {
+ if err := j.templatesWatcher.Stop(); err != nil && firstErr == nil {
+ firstErr = err
+ }
+ }
+ return firstErr
}
func (j *FilesystemWatcherJob) handleFilesystemChange(ctx context.Context) {
@@ -98,10 +140,14 @@ func (j *FilesystemWatcherJob) handleFilesystemChange(ctx context.Context) {
}
}
-func (j *FilesystemWatcherJob) getStacksDirectory(ctx context.Context) (string, error) {
- settings, err := j.settingsService.GetSettings(ctx)
- if err != nil {
- return "data/projects", err
+func (j *FilesystemWatcherJob) handleTemplatesChange(ctx context.Context) {
+ slog.InfoContext(ctx, "Template directory change detected, syncing templates")
+ if j.templateService == nil {
+ return
+ }
+ if err := j.templateService.SyncLocalTemplatesFromFilesystem(ctx); err != nil {
+ slog.ErrorContext(ctx, "Failed to sync templates after filesystem change", "error", err)
+ } else {
+ slog.InfoContext(ctx, "Template sync completed after filesystem change")
}
- return settings.StacksDirectory.Value, nil
}
diff --git a/backend/internal/models/template.go b/backend/internal/models/template.go
index cbb52b83d..39c0f6a56 100644
--- a/backend/internal/models/template.go
+++ b/backend/internal/models/template.go
@@ -22,19 +22,14 @@ type ComposeTemplate struct {
}
type ComposeTemplateMetadata struct {
- Version *string `json:"version,omitempty" gorm:"column:meta_version"`
- Author *string `json:"author,omitempty" gorm:"column:meta_author"`
- Tags *string `json:"tags,omitempty" gorm:"column:meta_tags"`
- RemoteURL *string `json:"remoteUrl,omitempty" gorm:"column:meta_remote_url"`
- EnvURL *string `json:"envUrl,omitempty" gorm:"column:meta_env_url"`
- DocumentationURL *string `json:"documentationUrl,omitempty" gorm:"column:meta_documentation_url"`
- IconURL *string `json:"iconUrl,omitempty" gorm:"column:meta_icon_url"`
+ Version *string `json:"version,omitempty"`
+ Author *string `json:"author,omitempty"`
+ Tags *string `json:"tags,omitempty"`
+ RemoteURL *string `json:"remoteUrl,omitempty"`
+ EnvURL *string `json:"envUrl,omitempty"`
+ DocumentationURL *string `json:"documentationUrl,omitempty"`
+ IconURL *string `json:"iconUrl,omitempty"`
}
-func (TemplateRegistry) TableName() string {
- return "template_registries"
-}
-
-func (ComposeTemplate) TableName() string {
- return "compose_templates"
-}
+func (TemplateRegistry) TableName() string { return "template_registries" }
+func (ComposeTemplate) TableName() string { return "compose_templates" }
diff --git a/backend/internal/services/template_service.go b/backend/internal/services/template_service.go
index 754ebd0f8..a944ffa77 100644
--- a/backend/internal/services/template_service.go
+++ b/backend/internal/services/template_service.go
@@ -14,9 +14,11 @@ import (
"sync/atomic"
"time"
+ "github.com/google/uuid"
"github.com/ofkm/arcane-backend/internal/database"
"github.com/ofkm/arcane-backend/internal/dto"
"github.com/ofkm/arcane-backend/internal/models"
+ appfs "github.com/ofkm/arcane-backend/internal/utils/fs"
"gorm.io/gorm"
)
@@ -113,15 +115,22 @@ func (s *TemplateService) ensureRemoteTemplatesLoaded(ctx context.Context) error
}
func (s *TemplateService) GetAllTemplates(ctx context.Context) ([]models.ComposeTemplate, error) {
- var templates []models.ComposeTemplate
+ if err := s.syncFilesystemTemplatesInternal(ctx); err != nil {
+ fmt.Printf("Warning: failed to sync filesystem templates: %v\n", err)
+ }
- err := s.db.WithContext(ctx).Preload("Registry").Find(&templates).Error
- if err != nil {
+ var templates []models.ComposeTemplate
+ if err := s.db.WithContext(ctx).Preload("Registry").Find(&templates).Error; err != nil {
return nil, fmt.Errorf("failed to get local templates: %w", err)
}
- err = s.ensureRemoteTemplatesLoaded(ctx)
- if err != nil {
+ // Trim heavy fields in list responses
+ for i := range templates {
+ templates[i].Content = ""
+ templates[i].EnvContent = nil
+ }
+
+ if err := s.ensureRemoteTemplatesLoaded(ctx); err != nil {
fmt.Printf("Warning: failed to load remote templates for GetAllTemplates: %v\n", err)
} else {
rc := s.getRemoteCache()
@@ -134,27 +143,25 @@ func (s *TemplateService) GetAllTemplates(ctx context.Context) ([]models.Compose
}
func (s *TemplateService) GetTemplate(ctx context.Context, id string) (*models.ComposeTemplate, error) {
- var template models.ComposeTemplate
+ if err := s.syncFilesystemTemplatesInternal(ctx); err != nil {
+ fmt.Printf("Warning: failed to sync filesystem templates: %v\n", err)
+ }
- // Local DB by ID (keeps DB concerns in models)
- err := s.db.WithContext(ctx).Preload("Registry").Where("id = ?", id).First(&template).Error
- if err == nil {
+ var template models.ComposeTemplate
+ if err := s.db.WithContext(ctx).Preload("Registry").Where("id = ?", id).First(&template).Error; err == nil {
return &template, nil
- }
- if !errors.Is(err, gorm.ErrRecordNotFound) {
+ } else if !errors.Is(err, gorm.ErrRecordNotFound) {
return nil, fmt.Errorf("failed to query local template: %w", err)
}
- // Remote cache by public ID
if err := s.ensureRemoteTemplatesLoaded(ctx); err != nil {
return nil, fmt.Errorf("template not found (failed to load remote templates): %w", err)
}
rc := s.getRemoteCache()
for _, remoteTemplate := range rc.templates {
- // Compare against public ID (supports both new composite IDs and legacy slug IDs if present)
if remoteTemplate.ID == id {
- foundTemplate := remoteTemplate
- return &foundTemplate, nil
+ t := remoteTemplate
+ return &t, nil
}
}
@@ -162,19 +169,14 @@ func (s *TemplateService) GetTemplate(ctx context.Context, id string) (*models.C
}
func (s *TemplateService) CreateTemplate(ctx context.Context, template *models.ComposeTemplate) error {
- // Ensure ID is set if not provided (for custom templates)
if template.ID == "" {
- template.ID = s.generateTemplateID(template.Name)
+ template.ID = uuid.NewString()
}
-
template.IsCustom = true
template.IsRemote = false
-
- err := s.db.WithContext(ctx).Create(template).Error
- if err != nil {
+ if err := s.db.WithContext(ctx).Create(template).Error; err != nil {
return fmt.Errorf("failed to create template: %w", err)
}
-
return nil
}
@@ -226,7 +228,6 @@ func (s *TemplateService) DeleteTemplate(ctx context.Context, id string) error {
return fmt.Errorf("failed to delete template: %w", result.Error)
}
if result.RowsAffected == 0 {
- // This case should ideally not be reached if First() succeeded, but as a safeguard
return fmt.Errorf("template not found after finding it")
}
return nil
@@ -265,6 +266,7 @@ func (s *TemplateService) GetRegistries(ctx context.Context) ([]models.TemplateR
}
func (s *TemplateService) CreateRegistry(ctx context.Context, registry *models.TemplateRegistry) error {
+ // Hydrate metadata if needed
if registry.Name == "" || registry.Description == "" {
if registry.URL == "" {
return fmt.Errorf("registry URL is required")
@@ -281,6 +283,10 @@ func (s *TemplateService) CreateRegistry(ctx context.Context, registry *models.T
}
}
+ if registry.ID == "" {
+ registry.ID = uuid.NewString()
+ }
+
if err := s.db.WithContext(ctx).Create(registry).Error; err != nil {
return fmt.Errorf("failed to create registry: %w", err)
}
@@ -454,21 +460,6 @@ func (s *TemplateService) convertRemoteToLocal(remote dto.RemoteTemplate, regist
}
}
-func (s *TemplateService) generateTemplateID(name string) string {
- id := strings.ToLower(name)
- id = regexp.MustCompile(`[^a-z0-9]+`).ReplaceAllString(id, "-")
- id = strings.Trim(id, "-")
-
- if id == "" {
- id = "template"
- }
-
- // Ensure uniqueness for local templates if needed, e.g., append a short hash or timestamp
- // For now, relying on DB primary key constraint for uniqueness on save.
-
- return id
-}
-
func (s *TemplateService) getDefaultEnvTemplate() string {
return `# Environment Variables
# These variables will be available to your stack services
@@ -526,11 +517,73 @@ func (s *TemplateService) DownloadTemplate(ctx context.Context, remoteTemplate *
return nil, fmt.Errorf("template is not remote")
}
- // Check if a local version with the same remote ID already exists
- // This prevents duplicate downloads of the same remote template
- existingLocalTemplate, err := s.GetTemplate(ctx, s.generateTemplateID(remoteTemplate.Name))
- if err == nil && !existingLocalTemplate.IsRemote {
- return existingLocalTemplate, fmt.Errorf("template '%s' is already downloaded", remoteTemplate.Name)
+ // Determine safe folder name from template name or public ID
+ base := s.slugify(remoteTemplate.Name)
+ if base == "" {
+ parts := strings.Split(remoteTemplate.ID, ":")
+ if len(parts) > 0 {
+ base = s.slugify(parts[len(parts)-1])
+ }
+ if base == "" {
+ base = "template-" + uuid.NewString()
+ }
+ }
+
+ // Ensure directory: data/templates/<base>
+ tplDir := filepath.Join("data", "templates", base)
+ if err := os.MkdirAll(tplDir, 0755); err != nil {
+ return nil, fmt.Errorf("failed to create template directory: %w", err)
+ }
+ composePath := filepath.Join(tplDir, "compose.yaml")
+ envPath := filepath.Join(tplDir, ".env.example")
+ srcDesc := fmt.Sprintf("Imported from data/templates/%s/compose.yaml", base)
+
+ var existing models.ComposeTemplate
+ if err := s.db.WithContext(ctx).
+ Where("is_remote = ? AND registry_id IS NULL AND (description = ? OR name = ?)", false, srcDesc, base).
+ First(&existing).Error; err == nil {
+ composeContent, envContent, err := s.FetchTemplateContent(ctx, remoteTemplate)
+ if err != nil {
+ return nil, fmt.Errorf("failed to fetch template content for existing local template: %w", err)
+ }
+
+ // Write compose file and handle errors
+ if err := os.WriteFile(composePath, []byte(composeContent), 0600); err != nil {
+ return nil, fmt.Errorf("failed to write compose file: %w", err)
+ }
+
+ // Write env file if present and handle errors
+ hasEnv := strings.TrimSpace(envContent) != ""
+ if hasEnv {
+ if err := os.WriteFile(envPath, []byte(envContent), 0600); err != nil {
+ return nil, fmt.Errorf("failed to write env file: %w", err)
+ }
+ }
+
+ // Only set fields after successful writes
+ existing.Content = composeContent
+ if hasEnv {
+ existing.EnvContent = &envContent
+ }
+
+ if remoteTemplate.Metadata != nil {
+ existing.Metadata = &models.ComposeTemplateMetadata{
+ Version: remoteTemplate.Metadata.Version,
+ Author: remoteTemplate.Metadata.Author,
+ Tags: remoteTemplate.Metadata.Tags,
+ RemoteURL: remoteTemplate.Metadata.RemoteURL,
+ EnvURL: remoteTemplate.Metadata.EnvURL,
+ DocumentationURL: remoteTemplate.Metadata.DocumentationURL,
+ IconURL: remoteTemplate.Metadata.IconURL,
+ }
+ }
+
+ if err := s.db.WithContext(ctx).Save(&existing).Error; err != nil {
+ return nil, fmt.Errorf("failed to update existing local template: %w", err)
+ }
+ return &existing, nil
+ } else if !errors.Is(err, gorm.ErrRecordNotFound) {
+ return nil, fmt.Errorf("failed to check existing template: %w", err)
}
composeContent, envContent, err := s.FetchTemplateContent(ctx, remoteTemplate)
@@ -538,42 +591,153 @@ func (s *TemplateService) DownloadTemplate(ctx context.Context, remoteTemplate *
return nil, fmt.Errorf("failed to fetch template content for download: %w", err)
}
+ if err := os.WriteFile(composePath, []byte(composeContent), 0600); err != nil {
+ return nil, fmt.Errorf("failed to write compose file: %w", err)
+ }
+ var envPtr *string
+ if strings.TrimSpace(envContent) != "" {
+ if err := os.WriteFile(envPath, []byte(envContent), 0600); err != nil {
+ return nil, fmt.Errorf("failed to write env file: %w", err)
+ }
+ envPtr = &envContent
+ }
+
localTemplate := &models.ComposeTemplate{
- Name: remoteTemplate.Name,
- Description: fmt.Sprintf("%s (Downloaded from %s)", remoteTemplate.Description, remoteTemplate.Registry.Name),
+ BaseModel: models.BaseModel{ID: uuid.NewString()},
+ Name: base,
+ Description: srcDesc,
Content: composeContent,
+ EnvContent: envPtr,
IsCustom: true,
IsRemote: false,
RegistryID: nil,
Registry: nil,
}
- if envContent != "" {
- localTemplate.EnvContent = &envContent
- }
-
if remoteTemplate.Metadata != nil {
localTemplate.Metadata = &models.ComposeTemplateMetadata{
Version: remoteTemplate.Metadata.Version,
Author: remoteTemplate.Metadata.Author,
Tags: remoteTemplate.Metadata.Tags,
+ RemoteURL: remoteTemplate.Metadata.RemoteURL,
+ EnvURL: remoteTemplate.Metadata.EnvURL,
DocumentationURL: remoteTemplate.Metadata.DocumentationURL,
IconURL: remoteTemplate.Metadata.IconURL,
}
}
- err = s.db.WithContext(ctx).Create(localTemplate).Error
- if err != nil {
+ if err := s.db.WithContext(ctx).Create(localTemplate).Error; err != nil {
return nil, fmt.Errorf("failed to save local template: %w", err)
}
- // After successful download and save, remove the remote template from the cache
- // This is optional but can help keep the list clean if you only want to see local after download
- // s.removeRemoteTemplateFromCache(remoteTemplate.ID) // Need to implement this helper if desired
-
return localTemplate, nil
}
+// slugify produces a filesystem-safe name.
+func (s *TemplateService) slugify(in string) string {
+ in = strings.TrimSpace(strings.ToLower(in))
+ if in == "" {
+ return ""
+ }
+ in = strings.ReplaceAll(in, " ", "-")
+ re := regexp.MustCompile(`[^a-z0-9\-_]+`)
+ in = re.ReplaceAllString(in, "-")
+ in = regexp.MustCompile(`-+`).ReplaceAllString(in, "-")
+ return strings.Trim(in, "-")
+}
+
func (s *TemplateService) invalidateRemoteCache() {
s.setRemoteCache(remoteCache{})
}
+
+func (s *TemplateService) SyncLocalTemplatesFromFilesystem(ctx context.Context) error {
+ return s.syncFilesystemTemplatesInternal(ctx)
+}
+
+// upsertFilesystemTemplate centralizes insert/update logic for filesystem templates.
+func (s *TemplateService) upsertFilesystemTemplate(ctx context.Context, name, desc, compose string, envPtr *string) error {
+ var existing models.ComposeTemplate
+ q := s.db.WithContext(ctx).
+ Where("is_remote = ? AND registry_id IS NULL AND description = ?", false, desc).
+ First(&existing)
+
+ if q.Error == nil {
+ existing.Name = name
+ existing.Content = compose
+ existing.EnvContent = envPtr
+ existing.IsCustom = true
+ existing.IsRemote = false
+ if err := s.db.WithContext(ctx).Save(&existing).Error; err != nil {
+ return fmt.Errorf("update template %s: %w", existing.ID, err)
+ }
+ return nil
+ }
+ if !errors.Is(q.Error, gorm.ErrRecordNotFound) {
+ return fmt.Errorf("query existing template: %w", q.Error)
+ }
+
+ tpl := &models.ComposeTemplate{
+ BaseModel: models.BaseModel{ID: uuid.NewString()},
+ Name: name,
+ Description: desc,
+ Content: compose,
+ EnvContent: envPtr,
+ IsCustom: true,
+ IsRemote: false,
+ RegistryID: nil,
+ Registry: nil,
+ Metadata: nil,
+ }
+ if err := s.db.WithContext(ctx).Create(tpl).Error; err != nil {
+ return fmt.Errorf("insert template %s: %w", name, err)
+ }
+ return nil
+}
+
+func (s *TemplateService) processFolderEntry(ctx context.Context, baseDir, folder string) error {
+ compose, envPtr, desc, found, err := appfs.ReadFolderComposeTemplate(baseDir, folder)
+ if err != nil || !found {
+ return err
+ }
+ return s.upsertFilesystemTemplate(ctx, folder, desc, compose, envPtr)
+}
+
+func (s *TemplateService) processRootFile(ctx context.Context, baseDir, file string) error {
+ base, compose, envPtr, desc, err := appfs.ReadRootComposeTemplate(baseDir, file)
+ if err != nil {
+ return err
+ }
+ return s.upsertFilesystemTemplate(ctx, base, desc, compose, envPtr)
+}
+
+func (s *TemplateService) syncFilesystemTemplatesInternal(ctx context.Context) error {
+ dir, err := appfs.GetTemplatesDirectory(ctx)
+ if err != nil {
+ return fmt.Errorf("ensure templates dir: %w", err)
+ }
+
+ entries, err := os.ReadDir(dir)
+ if err != nil {
+ if os.IsNotExist(err) {
+ return nil
+ }
+ return fmt.Errorf("read dir %s: %w", dir, err)
+ }
+
+ for _, ent := range entries {
+ if ent.IsDir() {
+ if err := s.processFolderEntry(ctx, dir, ent.Name()); err != nil {
+ fmt.Printf("Warning: failed to read folder template %s: %v\n", ent.Name(), err)
+ }
+ continue
+ }
+ ext := strings.ToLower(filepath.Ext(ent.Name()))
+ if ext != ".yml" && ext != ".yaml" {
+ continue
+ }
+ if err := s.processRootFile(ctx, dir, ent.Name()); err != nil {
+ fmt.Printf("Warning: failed to read file template %s: %v\n", ent.Name(), err)
+ }
+ }
+ return nil
+}
diff --git a/backend/internal/utils/fs/fs_templates.go b/backend/internal/utils/fs/fs_templates.go
new file mode 100644
index 000000000..43dab88dd
--- /dev/null
+++ b/backend/internal/utils/fs/fs_templates.go
@@ -0,0 +1,60 @@
+package fs
+
+import (
+ "fmt"
+ "os"
+ "path/filepath"
+ "strings"
+)
+
+func ReadFolderComposeTemplate(baseDir, folder string) (string, *string, string, bool, error) {
+ composePath := filepath.Join(baseDir, folder, "compose.yaml")
+ if _, err := os.Stat(composePath); err != nil {
+ if os.IsNotExist(err) {
+ return "", nil, "", false, nil
+ }
+ return "", nil, "", false, fmt.Errorf("stat compose: %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(baseDir, folder, envName)
+ if eb, err := os.ReadFile(envPath); err == nil {
+ env := string(eb)
+ envPtr = &env
+ break
+ }
+ }
+
+ desc := fmt.Sprintf("Imported from %s/%s/compose.yaml", baseDir, folder)
+ return string(b), envPtr, desc, true, nil
+}
+
+func ReadRootComposeTemplate(baseDir, fileName string) (string, string, *string, string, error) {
+ ext := strings.ToLower(filepath.Ext(fileName))
+ base := strings.TrimSuffix(fileName, ext)
+ composePath := filepath.Join(baseDir, fileName)
+
+ b, err := os.ReadFile(composePath)
+ if err != nil {
+ return "", "", nil, "", fmt.Errorf("read compose %s: %w", composePath, err)
+ }
+
+ var envPtr *string
+ for _, envExt := range []string{".env.example", ".env"} {
+ envPath := filepath.Join(baseDir, base+envExt)
+ if eb, err := os.ReadFile(envPath); err == nil {
+ env := string(eb)
+ envPtr = &env
+ break
+ }
+ }
+
+ desc := fmt.Sprintf("Imported from %s/%s", baseDir, fileName)
+ return base, string(b), envPtr, desc, nil
+}
diff --git a/backend/internal/utils/fs/fs_util.go b/backend/internal/utils/fs/fs_util.go
index 830952113..3decd4a00 100644
--- a/backend/internal/utils/fs/fs_util.go
+++ b/backend/internal/utils/fs/fs_util.go
@@ -1,8 +1,11 @@
package fs
import (
+ "context"
"fmt"
+ "log/slog"
"os"
+ "path/filepath"
)
func CountSubdirectories(path string) (int, error) {
@@ -19,3 +22,30 @@ func CountSubdirectories(path string) (int, error) {
}
return count, nil
}
+
+func GetProjectsDirectory(ctx context.Context, stacksDir string) (string, error) {
+ projectsDirectory := stacksDir
+ if projectsDirectory == "" {
+ projectsDirectory = "data/projects"
+ }
+
+ if _, err := os.Stat(projectsDirectory); os.IsNotExist(err) {
+ if err := os.MkdirAll(projectsDirectory, 0755); err != nil {
+ return "", err
+ }
+ slog.InfoContext(ctx, "Created projects directory", "path", projectsDirectory)
+ }
+
+ return projectsDirectory, nil
+}
+
+func GetTemplatesDirectory(ctx context.Context) (string, error) {
+ templatesDir := filepath.Join("data", "templates")
+ if _, err := os.Stat(templatesDir); os.IsNotExist(err) {
+ if err := os.MkdirAll(templatesDir, 0755); err != nil {
+ return "", err
+ }
+ slog.InfoContext(ctx, "Created templates directory", "path", templatesDir)
+ }
+ return templatesDir, nil
+}