Merge pull request #7 from flatrun/feat/improve-autodeployments

feat: improve deployment automation and file management

Author: nfebe

config.example.yml

@@ -25,6 +25,9 @@ certbot:
   container_name: certbot
   email: your-email@example.com
   staging: true
+  # Optional: Override default paths (relative to deployments_path)
+  # certs_path: /deployments/nginx/certs/live
+  # webroot_path: /deployments/nginx/html
 
 logging:
   level: info

internal/api/server.go

@@ -3,7 +3,6 @@ package api
 import (
 	"context"
 	"fmt"
-	"io"
 	"net/http"
 	"os"
 	"path/filepath"
@@ -1270,17 +1269,8 @@ func corsMiddleware(allowedOrigins []string) gin.HandlerFunc {
 func (s *Server) listDeploymentFiles(c *gin.Context) {
 	name := c.Param("name")
 	path := c.DefaultQuery("path", "/")
-	root := c.Query("root") == "true"
-
-	var filesList []files.FileInfo
-	var err error
-
-	if root {
-		filesList, err = s.filesManager.ListAllFiles(name, path)
-	} else {
-		filesList, err = s.filesManager.ListFiles(name, path)
-	}
 
+	filesList, err := s.filesManager.ListFiles(name, path)
 	if err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{
 			"error": err.Error(),
@@ -1291,14 +1281,12 @@ func (s *Server) listDeploymentFiles(c *gin.Context) {
 	c.JSON(http.StatusOK, gin.H{
 		"files": filesList,
 		"path":  path,
-		"root":  root,
 	})
 }
 
 func (s *Server) getDeploymentFile(c *gin.Context) {
 	name := c.Param("name")
 	path := c.Param("path")
-	root := c.Query("root") == "true"
 
 	if c.Query("info") == "true" {
 		info, err := s.filesManager.GetFileInfo(name, path)
@@ -1313,13 +1301,7 @@ func (s *Server) getDeploymentFile(c *gin.Context) {
 	}
 
 	if c.Query("list") == "true" {
-		var filesList []files.FileInfo
-		var err error
-		if root {
-			filesList, err = s.filesManager.ListAllFiles(name, path)
-		} else {
-			filesList, err = s.filesManager.ListFiles(name, path)
-		}
+		filesList, err := s.filesManager.ListFiles(name, path)
 		if err != nil {
 			c.JSON(http.StatusInternalServerError, gin.H{
 				"error": err.Error(),
@@ -1329,21 +1311,11 @@ func (s *Server) getDeploymentFile(c *gin.Context) {
 		c.JSON(http.StatusOK, gin.H{
 			"files": filesList,
 			"path":  path,
-			"root":  root,
 		})
 		return
 	}
 
-	var file io.ReadCloser
-	var info *files.FileInfo
-	var err error
-
-	if root {
-		file, info, err = s.filesManager.ReadAllFile(name, path)
-	} else {
-		file, info, err = s.filesManager.ReadFile(name, path)
-	}
-
+	file, info, err := s.filesManager.ReadFile(name, path)
 	if err != nil {
 		c.JSON(http.StatusNotFound, gin.H{
 			"error": err.Error(),

internal/docker/compose.go

@@ -3,8 +3,11 @@ package docker
 import (
 	"bytes"
 	"fmt"
+	"os"
 	"os/exec"
 	"strings"
+
+	"gopkg.in/yaml.v3"
 )
 
 type ComposeExecutor struct {
@@ -58,10 +61,66 @@ func (c *ComposeExecutor) Pull(deploymentPath string) (string, error) {
 
 func (c *ComposeExecutor) getProjectName(deploymentPath string) string {
 	parts := strings.Split(strings.TrimSuffix(deploymentPath, "/"), "/")
-	if len(parts) > 0 {
-		return "flatrun-" + parts[len(parts)-1]
+	if len(parts) == 0 {
+		return "flatrun"
+	}
+	dirName := parts[len(parts)-1]
+
+	// First, try to read name from compose file
+	if name := c.readComposeProjectName(deploymentPath); name != "" {
+		return name
+	}
+
+	// Fallback: detect existing project from running containers
+	if name := c.detectExistingProject(dirName); name != "" {
+		return name
+	}
+
+	// Default to directory name for compatibility
+	return dirName
+}
+
+// readComposeProjectName reads the 'name:' attribute from the compose file
+func (c *ComposeExecutor) readComposeProjectName(deploymentPath string) string {
+	composeFiles := []string{
+		"docker-compose.yml",
+		"docker-compose.yaml",
+		"compose.yml",
+		"compose.yaml",
 	}
-	return "flatrun"
+
+	for _, filename := range composeFiles {
+		path := deploymentPath + "/" + filename
+		data, err := os.ReadFile(path)
+		if err != nil {
+			continue
+		}
+
+		var compose struct {
+			Name string `yaml:"name"`
+		}
+		if err := yaml.Unmarshal(data, &compose); err == nil && compose.Name != "" {
+			return compose.Name
+		}
+	}
+	return ""
+}
+
+// detectExistingProject checks if containers exist with common project name patterns
+func (c *ComposeExecutor) detectExistingProject(dirName string) string {
+	candidates := []string{
+		dirName,
+		"flatrun-" + dirName,
+	}
+
+	for _, candidate := range candidates {
+		cmd := exec.Command("docker", "compose", "-p", candidate, "ps", "-q")
+		output, err := cmd.Output()
+		if err == nil && len(strings.TrimSpace(string(output))) > 0 {
+			return candidate
+		}
+	}
+	return ""
 }
 
 func (c *ComposeExecutor) runCompose(deploymentPath string, args ...string) (string, error) {

internal/docker/discovery.go

@@ -4,6 +4,8 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"strconv"
+	"strings"
 	"time"
 
 	"github.com/flatrun/agent/pkg/models"
@@ -102,9 +104,14 @@ func (d *Discovery) GetDeployment(name string) (*models.Deployment, error) {
 	}
 
 	metadataPath := filepath.Join(dirPath, "service.yml")
-	if metadata, err := d.loadMetadata(metadataPath); err == nil {
-		deployment.Metadata = metadata
+	metadata, err := d.loadMetadata(metadataPath)
+	if err != nil {
+		metadata = d.generateMetadataFromCompose(composePath, name)
+		if metadata != nil {
+			_ = d.SaveMetadata(name, metadata)
+		}
 	}
+	deployment.Metadata = metadata
 
 	if services, err := d.parseComposeServices(composePath); err == nil {
 		deployment.Services = services
@@ -203,10 +210,38 @@ func (d *Discovery) CreateDeployment(name string, composeContent string) error {
 		return err
 	}
 
+	// Ensure compose file has a name attribute for project identification
+	composeContent = d.ensureComposeName(name, composeContent)
+
 	composePath := filepath.Join(dirPath, "docker-compose.yml")
 	return os.WriteFile(composePath, []byte(composeContent), 0644)
 }
 
+// ensureComposeName adds or updates the name attribute in a compose file
+func (d *Discovery) ensureComposeName(name string, content string) string {
+	var compose map[string]interface{}
+	if err := yaml.Unmarshal([]byte(content), &compose); err != nil {
+		// If parsing fails, prepend name manually
+		return fmt.Sprintf("name: %s\n%s", name, content)
+	}
+
+	// Check if name already exists
+	if _, exists := compose["name"]; exists {
+		return content
+	}
+
+	// Add name attribute
+	compose["name"] = name
+
+	// Re-marshal with name included
+	data, err := yaml.Marshal(compose)
+	if err != nil {
+		return fmt.Sprintf("name: %s\n%s", name, content)
+	}
+
+	return string(data)
+}
+
 func (d *Discovery) DeleteDeployment(name string) error {
 	dirPath := filepath.Join(d.basePath, name)
 	return os.RemoveAll(dirPath)
@@ -266,3 +301,68 @@ func (d *Discovery) DeleteMetadata(name string) error {
 
 	return os.Remove(metadataPath)
 }
+
+func (d *Discovery) generateMetadataFromCompose(composePath, name string) *models.ServiceMetadata {
+	data, err := os.ReadFile(composePath)
+	if err != nil {
+		return nil
+	}
+
+	var compose composeFile
+	if err := yaml.Unmarshal(data, &compose); err != nil {
+		return nil
+	}
+
+	metadata := &models.ServiceMetadata{
+		Name: name,
+		Type: "",
+		Networking: models.NetworkingConfig{
+			Expose:    false,
+			Protocol:  "http",
+			ProxyType: "http",
+		},
+		SSL: models.SSLConfig{
+			Enabled:  false,
+			AutoCert: false,
+		},
+		HealthCheck: models.HealthCheckConfig{
+			Path:     "/",
+			Interval: "30s",
+		},
+	}
+
+	for _, svc := range compose.Services {
+		if len(svc.Ports) > 0 {
+			portStr := d.parsePort(svc.Ports[0])
+			if portStr != "" {
+				port := d.extractContainerPort(portStr)
+				if port > 0 {
+					metadata.Networking.ContainerPort = port
+				}
+			}
+			break
+		}
+	}
+
+	return metadata
+}
+
+func (d *Discovery) extractContainerPort(portStr string) int {
+	parts := strings.Split(portStr, ":")
+	var portPart string
+	if len(parts) == 2 {
+		portPart = parts[1]
+	} else if len(parts) == 1 {
+		portPart = parts[0]
+	} else {
+		return 0
+	}
+
+	portPart = strings.Split(portPart, "/")[0]
+
+	port, err := strconv.Atoi(portPart)
+	if err != nil {
+		return 0
+	}
+	return port
+}