WIP Try to use composer-go

- there are problems to resolve with health check
- compose/parser.go and compose/types.go should be recheck
- need to recheck writers

compose/parser.go

@@ -1,13 +1,12 @@
 package compose
 
 import (
-	"fmt"
-	"katenary/helm"
 	"log"
 	"os"
 	"strings"
 
-	"github.com/google/shlex"
+	"github.com/compose-spec/compose-go/cli"
+	"github.com/compose-spec/compose-go/types"
 	"gopkg.in/yaml.v3"
 )
 
@@ -17,7 +16,7 @@ const (
 
 // Parser is a docker-compose parser.
 type Parser struct {
-	Data *Compose
+	Data *types.Project
 }
 
 var Appname = ""
@@ -44,205 +43,34 @@ func NewParser(filename string, content ...string) *Parser {
 		}
 	}
 
-	p := &Parser{Data: c}
+	p := &Parser{}
 
 	return p
 }
 
 func (p *Parser) Parse(appname string) {
-	Appname = appname
 
-	services := make(map[string][]string)
-	// get the service list, to be sure that everything is ok
+	// Reminder:
+	// - set Appname
+	// - loas services
 
-	// fix ugly types
-	for _, s := range p.Data.Services {
-		parseEnv(s)
-		parseCommand(s)
-		parseEnvFiles(s)
-		parseHealthCheck(s)
+	options, err := cli.NewProjectOptions(nil,
+		cli.WithDefaultConfigPath,
+		cli.WithNormalization(true),
+		cli.WithInterpolation(true),
+		cli.WithResolvedPaths(true),
+	)
+	if err != nil {
+		log.Fatal(err)
 	}
 
-	c := p.Data
-	for name, s := range c.Services {
-		if portlabel, ok := s.Labels[helm.LABEL_PORT]; ok {
-			services := strings.Split(portlabel, ",")
-			for _, serviceport := range services {
-				portexists := false
-				for _, found := range s.Ports {
-					if found == serviceport {
-						portexists = true
-					}
-				}
-				if !portexists {
-					s.Ports = append(s.Ports, serviceport)
-				}
-			}
-		}
-		if len(s.Ports) > 0 {
-			services[name] = s.Ports
-		}
+	proj, err := cli.ProjectFromOptions(options)
+	if err != nil {
+		log.Fatal(err)
 	}
 
-	// check if dependencies are resolved
-	missing := []string{}
-	for name, s := range c.Services {
-		for _, dep := range s.DependsOn {
-			if _, ok := services[dep]; !ok {
-				missing = append(missing, fmt.Sprintf(
-					"The service \"%s\" hasn't got "+
-						"declared port for dependency from \"%s\" - please "+
-						"append a %s label or a \"ports\" section in the docker-compose file",
-					dep, name, helm.LABEL_PORT),
-				)
-			}
-		}
-	}
+	Appname = proj.Name
 
-	if len(missing) > 0 {
-		log.Fatal(strings.Join(missing, "\n"))
-	}
-
-	// check if all "image" properties are set
-	missing = []string{}
-	for name, s := range c.Services {
-		if s.Image == "" {
-			missing = append(missing, fmt.Sprintf(
-				"The service \"%s\" hasn't got "+
-					"an image property - please "+
-					"append an image property in the docker-compose file",
-				name,
-			))
-		}
-	}
-	if len(missing) > 0 {
-		log.Fatal(strings.Join(missing, "\n"))
-	}
-
-	// check the build element
-	for name, s := range c.Services {
-		if s.RawBuild == nil {
-			continue
-		}
-
-		fmt.Println(ICON_EXCLAMATION +
-			" \x1b[33myou will need to build and push your image named \"" + s.Image + "\"" +
-			" for the \"" + name + "\" service \x1b[0m")
-
-	}
+	p.Data = proj
 
 }
-
-// manage environment variables, if the type is map[string]string so we can use it, else we need to split "=" sign
-// and apply this in env variable
-func parseEnv(s *Service) {
-	env := make(map[string]string)
-	if s.RawEnvironment == nil {
-		return
-	}
-	switch s.RawEnvironment.(type) {
-	case map[string]string:
-		env = s.RawEnvironment.(map[string]string)
-	case map[string]interface{}:
-		for k, v := range s.RawEnvironment.(map[string]interface{}) {
-			// force to string
-			env[k] = fmt.Sprintf("%v", v)
-		}
-	case []interface{}:
-		for _, v := range s.RawEnvironment.([]interface{}) {
-			// Splot the value of the env variable with "="
-			parts := strings.Split(v.(string), "=")
-			env[parts[0]] = parts[1]
-		}
-	case string:
-		parts := strings.Split(s.RawEnvironment.(string), "=")
-		env[parts[0]] = parts[1]
-	default:
-		log.Printf("%+v, %T", s.RawEnvironment, s.RawEnvironment)
-		log.Fatal("Environment type not supported")
-	}
-	s.Environment = env
-}
-
-func parseCommand(s *Service) {
-
-	if s.RawCommand == nil {
-		return
-	}
-
-	// following the command type, it can be a "slice" or a simple sting, so we need to check it
-	switch v := s.RawCommand.(type) {
-	case string:
-		// use shlex to parse the command
-		command, err := shlex.Split(v)
-		if err != nil {
-			log.Fatal(err)
-		}
-		s.Command = command
-	case []string:
-		s.Command = v
-	case []interface{}:
-		for _, v := range v {
-			s.Command = append(s.Command, v.(string))
-		}
-	default:
-		log.Printf("%+v %T", s.RawCommand, s.RawCommand)
-		log.Fatal("Command type not supported")
-	}
-}
-
-func parseEnvFiles(s *Service) {
-	// Same than parseEnv, but for env files
-	if s.RawEnvFiles == nil {
-		return
-	}
-	envfiles := make([]string, 0)
-	switch v := s.RawEnvFiles.(type) {
-	case []string:
-		envfiles = v
-	case []interface{}:
-		for _, v := range v {
-			envfiles = append(envfiles, v.(string))
-		}
-	case string:
-		envfiles = append(envfiles, v)
-	default:
-		log.Printf("%+v %T", s.RawEnvFiles, s.RawEnvFiles)
-		log.Fatal("EnvFile type not supported")
-	}
-	s.EnvFiles = envfiles
-}
-
-func parseHealthCheck(s *Service) {
-	// HealthCheck command can be a string or slice of strings
-	if s.HealthCheck == nil {
-		return
-	}
-	if s.HealthCheck.RawTest == nil {
-		return
-	}
-
-	switch v := s.HealthCheck.RawTest.(type) {
-	case string:
-		c, err := shlex.Split(v)
-		if err != nil {
-			log.Fatal(err)
-		}
-		s.HealthCheck = &HealthCheck{
-			Test: c,
-		}
-
-	case []string:
-		s.HealthCheck = &HealthCheck{
-			Test: v,
-		}
-
-	case []interface{}:
-		for _, v := range v {
-			s.HealthCheck.Test = append(s.HealthCheck.Test, v.(string))
-		}
-	default:
-		log.Printf("%+v %T", s.HealthCheck.RawTest, s.HealthCheck.RawTest)
-		log.Fatal("HealthCheck type not supported")
-	}
-}

compose/parser_test.go

@@ -1,199 +0,0 @@
-package compose
-
-import (
-	"katenary/logger"
-	"testing"
-)
-
-const DOCKER_COMPOSE_YML1 = `
-version: "3"
-
-services:
-    # first service, very basic
-    web:
-        image: nginx
-        ports:
-            - "80:80"
-        environment:
-            FOO: bar
-            BAZ: qux
-        networks:
-            - frontend
-
-
-    database:
-        image: postgres
-        networks:
-            - frontend
-        environment:
-          POSTGRES_USER: postgres
-          POSTGRES_PASSWORD: mysecretpassword
-          POSTGRES_DB: mydb
-        labels:
-            katenary.io/ports: "5432"
-
-    commander1:
-        image: foo
-        command: ["/bin/sh", "-c", "echo 'hello world'"]
-
-    commander2:
-        image: foo
-        command: echo "hello world"
-
-    hc1:
-        image: foo
-        healthcheck:
-            test: ["CMD-SHELL", "echo 'hello world1'"]
-
-    hc2:
-        image: foo
-        healthcheck:
-            test: echo "hello world2"
-
-    hc3:
-        image: foo
-        healthcheck:
-            test: ["CMD", "echo 'hello world3'"]
-
-
-`
-
-func init() {
-	logger.NOLOG = true
-}
-
-func TestParser(t *testing.T) {
-	p := NewParser("", DOCKER_COMPOSE_YML1)
-	p.Parse("test")
-
-	// check if the "web" and "database" service is parsed correctly
-	// by checking if the "ports" and "environment"
-	for name, service := range p.Data.Services {
-		if name == "web" {
-			if len(service.Ports) != 1 {
-				t.Errorf("Expected 1 port, got %d", len(service.Ports))
-			}
-			if service.Ports[0] != "80:80" {
-				t.Errorf("Expected port 80:80, got %s", service.Ports[0])
-			}
-			if len(service.Environment) != 2 {
-				t.Errorf("Expected 2 environment variables, got %d", len(service.Environment))
-			}
-			if service.Environment["FOO"] != "bar" {
-				t.Errorf("Expected FOO=bar, got %s", service.Environment["FOO"])
-			}
-			if service.Environment["BAZ"] != "qux" {
-				t.Errorf("Expected BAZ=qux, got %s", service.Environment["BAZ"])
-			}
-		}
-		// same for the "database" service
-		if name == "database" {
-			if len(service.Ports) != 1 {
-				t.Errorf("Expected 1 port, got %d", len(service.Ports))
-			}
-			if service.Ports[0] != "5432" {
-				t.Errorf("Expected port 5432, got %s", service.Ports[0])
-			}
-			if len(service.Environment) != 3 {
-				t.Errorf("Expected 3 environment variables, got %d", len(service.Environment))
-			}
-			if service.Environment["POSTGRES_USER"] != "postgres" {
-				t.Errorf("Expected POSTGRES_USER=postgres, got %s", service.Environment["POSTGRES_USER"])
-			}
-			if service.Environment["POSTGRES_PASSWORD"] != "mysecretpassword" {
-				t.Errorf("Expected POSTGRES_PASSWORD=mysecretpassword, got %s", service.Environment["POSTGRES_PASSWORD"])
-			}
-			if service.Environment["POSTGRES_DB"] != "mydb" {
-				t.Errorf("Expected POSTGRES_DB=mydb, got %s", service.Environment["POSTGRES_DB"])
-			}
-			// check labels
-			if len(service.Labels) != 1 {
-				t.Errorf("Expected 1 label, got %d", len(service.Labels))
-			}
-			// is label katenary.io/ports correct?
-			if service.Labels["katenary.io/ports"] != "5432" {
-				t.Errorf("Expected katenary.io/ports=5432, got %s", service.Labels["katenary.io/ports"])
-			}
-		}
-	}
-}
-
-func TestParseCommand(t *testing.T) {
-	p := NewParser("", DOCKER_COMPOSE_YML1)
-	p.Parse("test")
-
-	for name, s := range p.Data.Services {
-		if name == "commander1" {
-			t.Log(s.Command)
-			if len(s.Command) != 3 {
-				t.Errorf("Expected 3 command, got %d", len(s.Command))
-			}
-			if s.Command[0] != "/bin/sh" {
-				t.Errorf("Expected /bin/sh, got %s", s.Command[0])
-			}
-			if s.Command[1] != "-c" {
-				t.Errorf("Expected -c, got %s", s.Command[1])
-			}
-			if s.Command[2] != "echo 'hello world'" {
-				t.Errorf("Expected echo 'hello world', got %s", s.Command[2])
-			}
-		}
-		if name == "commander2" {
-			t.Log(s.Command)
-			if len(s.Command) != 2 {
-				t.Errorf("Expected 1 command, got %d", len(s.Command))
-			}
-			if s.Command[0] != "echo" {
-				t.Errorf("Expected echo, got %s", s.Command[0])
-			}
-			if s.Command[1] != "hello world" {
-				t.Errorf("Expected hello world, got %s", s.Command[1])
-			}
-		}
-	}
-}
-
-func TestHealthChecks(t *testing.T) {
-	p := NewParser("", DOCKER_COMPOSE_YML1)
-	p.Parse("test")
-
-	for name, s := range p.Data.Services {
-		if name != "hc1" && name != "hc2" && name != "hc3" {
-			continue
-		}
-
-		if name == "hc1" {
-			if len(s.HealthCheck.Test) != 2 {
-				t.Errorf("Expected 2 healthcheck tests, got %d", len(s.HealthCheck.Test))
-			}
-			if s.HealthCheck.Test[0] != "CMD-SHELL" {
-				t.Errorf("Expected CMD-SHELL, got %s", s.HealthCheck.Test[0])
-			}
-			if s.HealthCheck.Test[1] != "echo 'hello world1'" {
-				t.Errorf("Expected echo 'hello world1', got %s", s.HealthCheck.Test[1])
-			}
-		}
-		if name == "hc2" {
-			if len(s.HealthCheck.Test) != 2 {
-				t.Errorf("Expected 2 healthcheck tests, got %d", len(s.HealthCheck.Test))
-			}
-			if s.HealthCheck.Test[0] != "echo" {
-				t.Errorf("Expected echo, got %s", s.HealthCheck.Test[1])
-			}
-			if s.HealthCheck.Test[1] != "hello world2" {
-				t.Errorf("Expected echo 'hello world2', got %s", s.HealthCheck.Test[1])
-			}
-		}
-		if name == "hc3" {
-			if len(s.HealthCheck.Test) != 2 {
-				t.Errorf("Expected 2 healthcheck tests, got %d", len(s.HealthCheck.Test))
-			}
-			if s.HealthCheck.Test[0] != "CMD" {
-				t.Errorf("Expected CMD, got %s", s.HealthCheck.Test[0])
-			}
-			if s.HealthCheck.Test[1] != "echo 'hello world3'" {
-				t.Errorf("Expected echo 'hello world3', got %s", s.HealthCheck.Test[1])
-			}
-		}
-	}
-}