add latest docker compose improvements for services support

Signed-off-by: Vasek - Tom C <tom@quartz.technology>

Author: TomChv

docker_sdk/src/codebase/dockercompose/docker_compose.go

@@ -46,6 +46,16 @@ func (d *DockerCompose) Services() []*Service {
 	return services
 }
 
+func (d *DockerCompose) GetService(name string) (*Service, error) {
+	for _, service := range d.Services() {
+		if service.Name() == name {
+			return service, nil
+		}
+	}
+
+	return nil, fmt.Errorf("no such service: %s", name)
+}
+
 func (d *DockerCompose) String() string {
 	yaml, err := d.project.MarshalYAML()
 	if err != nil {

docker_sdk/src/codebase/dockercompose/service.go

@@ -107,6 +107,15 @@ func (s *Service) Ports() []int {
 		ports = append(ports, published)
 	}
 
+	for _, port := range s.s.Expose {
+		published, err := strconv.Atoi(port)
+		if err != nil {
+			fmt.Println(fmt.Errorf("failed to parse port published: %w, ignoring it", err))
+		}
+
+		ports = append(ports, published)
+	}
+
 	return ports
 }
 
@@ -144,9 +153,19 @@ func (s *Service) Volumes() ([]*Volume, []*Cache) {
 		case "volume":
 			caches = append(caches, &Cache{name: v.Source, path: v.Target})
 		case "bind":
-			volumes = append(volumes, &Volume{origin: v.Source, target: v.Target})
+			volumes = append(volumes, &Volume{origin: trimHostPath(v.Source), target: v.Target})
 		}
 	}
 
 	return volumes, caches
 }
+
+func (s *Service) DependsOn() []string{
+	dependentServices := []string{}
+
+	for key := range s.s.DependsOn {
+		dependentServices = append(dependentServices, key)
+	}
+
+	return dependentServices
+}

docker_sdk/src/codebase/to_module.go

@@ -13,10 +13,7 @@ func (c *Codebase) ToModule(name string) *module.Module {
 	}
 
 	if c.dockercompose != nil {
-
-		for _, service := range c.dockercompose.Services() {
-			dockerModule = dockerModule.WithService(service)
-		}
+		dockerModule = dockerModule.WithDockerCompose(c.dockercompose)
 	}
 
 	return module.Build(name, dockerModule)

docker_sdk/src/module/compose/all.go

@@ -0,0 +1,97 @@
+package compose
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"dagger.io/dagger"
+	"dagger.io/dagger/dag"
+	"dagger.io/dockersdk/module/object"
+	"dagger.io/dockersdk/module/proxy"
+)
+
+// allFunc is a function that starts all services using
+// a proxy module to group them together.
+//
+// It MUST be registered AFTER all services have been registered.
+// The proxy is a simple duplication of: github.com/kpenfound/dagger-modules/proxy@v0.2.5 module.
+type allFunc struct {
+	c *Compose
+}
+
+func (u *allFunc) up(services []*proxy.Service) *dagger.Container {
+	proxy := proxy.New()
+
+	for _, service := range services {
+		proxy = proxy.WithService(service)
+	}
+
+	return proxy.Service()
+}
+
+func (u *allFunc) Invoke(ctx context.Context, state object.State, input object.InputArgs) (object.Result, error) {
+	compose, err := u.c.load(state)
+	if err != nil {
+		return nil, fmt.Errorf("failed to load object state: %w", err)
+	}
+
+	services := []*proxy.Service{}
+	for _, service := range u.c.dockercompose.Services() {
+		service := &serviceFunc{c: compose, service: service}
+		servicePrefix := fmt.Sprintf("%s_", service.service.Name())
+
+		serviceInput := input
+		for argName, argValue := range input {
+			if strings.HasPrefix(argName, servicePrefix) {
+				serviceInput[strings.TrimPrefix(argName, servicePrefix)] = argValue
+			}
+		}
+
+		serviceCtr, err := service.ToService(ctx, state, serviceInput)
+		if err != nil {
+			return nil, fmt.Errorf("failed to get service %s: %w", service.service.Name(), err)
+		}
+
+		services = append(services, serviceCtr)
+	}
+
+	return (*allFunc).up(
+		&allFunc{c: compose},
+		services,
+	), nil
+}
+
+func (u *allFunc) Arguments() []*object.FunctionArg {
+	// This method should not be called for this function
+	return nil
+}
+
+func (u *allFunc) AddTypeDefToObject(ctx context.Context, mod *dagger.Module, obj *dagger.TypeDef) (*dagger.Module, *dagger.TypeDef) {
+	args := []*object.FunctionArg{}
+
+	serviceNames := []string{}
+	for name, service := range u.c.funcMap {
+		serviceNames = append(serviceNames, name)
+
+		serviceArgs := service.Arguments()
+		for _, arg := range serviceArgs {
+			args = append(args, &object.FunctionArg{
+				// Prefix the argument name with the service name to avoid colission
+				Name: fmt.Sprintf("%s_%s", name, arg.Name),
+				Type: arg.Type,
+				Opts: arg.Opts,
+			})
+		}
+	}
+
+	typedef := dag.Function("All", dag.TypeDef().WithObject("Container")).
+		WithDescription(fmt.Sprintf("Start all service containers (%s)", strings.Join(serviceNames, ", ")))
+
+	for _, arg := range args {
+		typedef = typedef.WithArg(arg.Name, arg.Type, arg.Opts)
+	}
+
+	return mod, obj.
+		WithFunction(typedef)
+}

docker_sdk/src/module/compose/object.go

@@ -0,0 +1,104 @@
+package compose
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+
+	"dagger.io/dagger"
+	"dagger.io/dagger/dag"
+	"dagger.io/dockersdk/codebase/dockercompose"
+	"dagger.io/dockersdk/module/object"
+	"dagger.io/dockersdk/utils"
+)
+
+type Compose struct {
+	Dir *dagger.Directory
+
+	dockercompose *dockercompose.DockerCompose
+	funcMap       map[string]object.Function
+}
+
+func New(
+	dir *dagger.Directory,
+	dockercomposeFile *dockercompose.DockerCompose,
+) *Compose {
+	c := &Compose{
+		Dir:           dir,
+		dockercompose: dockercomposeFile,
+		funcMap:       make(map[string]object.Function),
+	}
+
+	for _, service := range dockercomposeFile.Services() {
+		c.funcMap[service.Name()] = &serviceFunc{c: c, service: service}
+	}
+
+	// Add up for all services
+	c.funcMap["All"] = &allFunc{c: c}
+
+	return c
+}
+
+func (c *Compose) Name() string {
+	return "Compose"
+}
+
+func (c *Compose) Description() string {
+	return "Manage compos services"
+}
+
+func (c *Compose) New(input object.InputArgs) object.Object {
+	var dir *dagger.Directory
+
+	if input["dir"] != nil {
+		dir = utils.LoadDirectoryFromID([]byte(input["dir"]))
+	}
+
+	return &Compose{
+		Dir:           dir,
+		dockercompose: c.dockercompose,
+	}
+}
+
+func (c *Compose) AddTypeDef(ctx context.Context) dagger.WithModuleFunc {
+	return func(mod *dagger.Module) *dagger.Module {
+		object := dag.TypeDef().WithObject(c.Name())
+
+		for _, fct := range c.funcMap {
+			mod, object = fct.AddTypeDefToObject(ctx, mod, object)
+		}
+
+		return mod.WithObject(object)
+	}
+}
+
+func (c *Compose) Load(state object.State) (object.Object, error) {
+	return c.load(state)
+}
+
+func (c *Compose) load(state object.State) (*Compose, error) {
+	parentMap := make(map[string]interface{})
+	err := json.Unmarshal(state, &parentMap)
+	if err != nil {
+		return nil, fmt.Errorf("failed to unmarshal parent object: %w", err)
+	}
+
+	cpyCompose := &Compose{
+		dockercompose: c.dockercompose,
+		funcMap:       c.funcMap,
+	}
+
+	if parentMap["Dir"] != nil {
+		cpyCompose.Dir = dag.LoadDirectoryFromID(dagger.DirectoryID(parentMap["Dir"].(string)))
+	}
+
+	return cpyCompose, nil
+}
+
+func (c *Compose) Invoke(ctx context.Context, state object.State, fnName string, input object.InputArgs) (object.Result, error) {
+	if c.funcMap[fnName] == nil {
+		return nil, fmt.Errorf("unknown function %s", fnName)
+	}
+
+	return c.funcMap[fnName].Invoke(ctx, state, input)
+}