wip: add entrypoints to services and targets

.dockerignore

@@ -1,4 +1,5 @@
 examples
+Makefile
 Dockerfile
 compose.yml
 docs

cmd/config/configuration.go

@@ -29,7 +29,7 @@ var (
 )
 
 const (
-	databaseFilename              = "seelf.db?_foreign_keys=yes&_txlock=immediate"
+	databaseConnectionString      = "seelf.db?_journal=WAL&_timeout=5000&_foreign_keys=yes&_txlock=immediate"
 	defaultConfigFilename         = "conf.yml"
 	defaultPort                   = 8080
 	defaultHost                   = ""
@@ -189,7 +189,7 @@ func (c *configuration) IsSecure() bool {
 
 // Gets the connection string to be used.
 func (c *configuration) ConnectionString() string {
-	return "file:" + path.Join(c.Data.Path, databaseFilename)
+	return "file:" + path.Join(c.Data.Path, databaseConnectionString)
 }
 
 // Returns the address to bind the HTTP server to.

examples/multiple-ports/.dockerignore

@@ -1,2 +1,3 @@
+Makefile
 Dockerfile
 compose.yml

examples/multiple-ports/Makefile

@@ -0,0 +1,3 @@
+archive:
+	rm -rf multiple-ports.tar.gz
+	tar czf multiple-ports.tar.gz *

examples/multiple-ports/compose.yml

@@ -1,11 +1,11 @@
 services:
   app:
     build: .
-    command: -web 8080,8081 -tcp 8082,8083 -udp 8084,8085
+    command: -web 8080,8081,8082 -tcp 8083,8084,8085 -udp 8086,8087,8088
     ports:
       - "8080:8080"
-      - "8081:8081"
-      - "8082:8082/tcp"
+      - "8081-8082:8081-8082"
       - "8083:8083/tcp"
-      - "8084:8084/udp"
-      - "8085:8085/udp"
+      - "8084-8085:8084-8085/tcp"
+      - "8086:8086/udp"
+      - "8087-8088:8087-8088/udp"

examples/sveltekit-hello/.dockerignore

@@ -1,3 +1,4 @@
+Makefile
 Dockerfile
 compose.yml
 node_modules

internal/deployment/app/cleanup_app/cleanup_app_test.go

@@ -71,7 +71,7 @@ func Test_CleanupApp(t *testing.T) {
 		target := must.Panic(domain.NewTarget("my-target",
 			domain.NewTargetUrlRequirement(must.Panic(domain.UrlFrom("http://localhost")), true),
 			domain.NewProviderConfigRequirement(nil, true), "uid"))
-		target.Configured(target.CurrentVersion(), nil)
+		target.Configured(target.CurrentVersion(), nil, nil)
 		target.RequestCleanup(false, "uid")
 
 		uc, provider := sut(initialData{
@@ -90,7 +90,7 @@ func Test_CleanupApp(t *testing.T) {
 		target := must.Panic(domain.NewTarget("my-target",
 			domain.NewTargetUrlRequirement(must.Panic(domain.UrlFrom("http://localhost")), true),
 			domain.NewProviderConfigRequirement(nil, true), "uid"))
-		target.Configured(target.CurrentVersion(), nil)
+		target.Configured(target.CurrentVersion(), nil, nil)
 
 		uc, provider := sut(initialData{
 			targets: []*domain.Target{&target},
@@ -108,7 +108,7 @@ func Test_CleanupApp(t *testing.T) {
 		target := must.Panic(domain.NewTarget("my-target",
 			domain.NewTargetUrlRequirement(must.Panic(domain.UrlFrom("http://localhost")), true),
 			domain.NewProviderConfigRequirement(nil, true), "uid"))
-		target.Configured(target.CurrentVersion(), nil)
+		target.Configured(target.CurrentVersion(), nil, nil)
 		app := must.Panic(domain.NewApp("my-app",
 			domain.NewEnvironmentConfigRequirement(domain.NewEnvironmentConfig(target.ID()), true, true),
 			domain.NewEnvironmentConfigRequirement(domain.NewEnvironmentConfig(target.ID()), true, true), "uid"))

internal/deployment/app/cleanup_target/cleanup_target_test.go

@@ -34,7 +34,7 @@ func Test_CleanupTarget(t *testing.T) {
 		target := must.Panic(domain.NewTarget("my-target",
 			domain.NewTargetUrlRequirement(must.Panic(domain.UrlFrom("http://localhost")), true),
 			domain.NewProviderConfigRequirement(nil, true), "uid"))
-		target.Configured(target.CurrentVersion(), errors.New("some error"))
+		target.Configured(target.CurrentVersion(), nil, errors.New("some error"))
 
 		uc, provider := sut(&target)
 
@@ -50,7 +50,7 @@ func Test_CleanupTarget(t *testing.T) {
 		target := must.Panic(domain.NewTarget("my-target",
 			domain.NewTargetUrlRequirement(must.Panic(domain.UrlFrom("http://localhost")), true),
 			domain.NewProviderConfigRequirement(nil, true), "uid"))
-		target.Configured(target.CurrentVersion(), nil)
+		target.Configured(target.CurrentVersion(), nil, nil)
 
 		uc, provider := sut(&target)
 

internal/deployment/app/configure_target/configure_target.go

@@ -41,6 +41,8 @@ func Handler(
 			return bus.Unit, nil
 		}
 
+		var assigned domain.TargetEntrypointsAssigned
+
 		// Same as for the deployment, since the configuration can take some time, retrieve the latest
 		// target version before updating its state.
 		defer func() {
@@ -56,12 +58,12 @@ func Handler(
 				return
 			}
 
-			target.Configured(cmd.Version, finalErr)
+			target.Configured(cmd.Version, assigned, finalErr)
 
 			finalErr = writer.Write(ctx, &target)
 		}()
 
-		finalErr = provider.Setup(ctx, target)
+		assigned, finalErr = provider.Setup(ctx, target)
 
 		return
 	}

internal/deployment/app/configure_target/configure_target_test.go

@@ -92,7 +92,7 @@ type dummyProvider struct {
 	called bool
 }
 
-func (d *dummyProvider) Setup(context.Context, domain.Target) error {
+func (d *dummyProvider) Setup(context.Context, domain.Target) (domain.TargetEntrypointsAssigned, error) {
 	d.called = true
-	return d.err
+	return nil, d.err
 }

internal/deployment/app/configure_target/on_deployment_state_changed.go

@@ -0,0 +1,29 @@
+package configure_target
+
+import (
+	"context"
+
+	"github.com/YuukanOO/seelf/internal/deployment/domain"
+	"github.com/YuukanOO/seelf/pkg/bus"
+)
+
+func OnDeploymentStateChangedHandler(
+	reader domain.TargetsReader,
+	writer domain.TargetsWriter,
+) bus.SignalHandler[domain.DeploymentStateChanged] {
+	return func(ctx context.Context, evt domain.DeploymentStateChanged) error {
+		if evt.State.Status() != domain.DeploymentStatusSucceeded {
+			return nil
+		}
+
+		target, err := reader.GetByID(ctx, evt.Config.Target())
+
+		if err != nil {
+			return err
+		}
+
+		target.MustExpose(evt.ID.AppID(), evt.Config.Environment(), evt.State.Services().Get(domain.Services{}))
+
+		return writer.Write(ctx, &target)
+	}
+}

internal/deployment/app/create_target/create_target_test.go

@@ -116,7 +116,8 @@ func (*dummyProvider) Prepare(ctx context.Context, payload any, existing ...doma
 	return dummyConfig{}, nil
 }
 
-func (dummyConfig) Fingerprint() string                   { return "dummy" }
-func (c dummyConfig) Equals(o domain.ProviderConfig) bool { return c == o }
-func (dummyConfig) Kind() string                          { return "dummy" }
-func (dummyConfig) String() string                        { return "dummy" }
+func (dummyConfig) Fingerprint() string                                         { return "dummy" }
+func (c dummyConfig) Equals(o domain.ProviderConfig) bool                       { return c == o }
+func (dummyConfig) Kind() string                                                { return "dummy" }
+func (dummyConfig) String() string                                              { return "dummy" }
+func (dummyConfig) FilterEntrypoints(e []domain.Entrypoint) []domain.Entrypoint { return e }

internal/deployment/app/delete_target/delete_target_test.go

@@ -49,7 +49,7 @@ func Test_DeleteTarget(t *testing.T) {
 		target := must.Panic(domain.NewTarget("my-target",
 			domain.NewTargetUrlRequirement(must.Panic(domain.UrlFrom("http://localhost")), true),
 			domain.NewProviderConfigRequirement(nil, true), "uid"))
-		target.Configured(target.CurrentVersion(), nil)
+		target.Configured(target.CurrentVersion(), nil, nil)
 		testutil.IsNil(t, target.RequestCleanup(false, "uid"))
 
 		uc, provider := sut(&target)

internal/deployment/app/deploy/deploy_test.go

@@ -80,7 +80,7 @@ func Test_Deploy(t *testing.T) {
 		target := must.Panic(domain.NewTarget("my-target",
 			domain.NewTargetUrlRequirement(must.Panic(domain.UrlFrom("http://localhost")), true),
 			domain.NewProviderConfigRequirement(nil, true), "some-uid"))
-		target.Configured(target.CurrentVersion(), nil)
+		target.Configured(target.CurrentVersion(), nil, nil)
 
 		app := must.Panic(domain.NewApp("my-app",
 			domain.NewEnvironmentConfigRequirement(domain.NewEnvironmentConfig(target.ID()), true, true),
@@ -113,7 +113,7 @@ func Test_Deploy(t *testing.T) {
 		target := must.Panic(domain.NewTarget("my-target",
 			domain.NewTargetUrlRequirement(must.Panic(domain.UrlFrom("http://localhost")), true),
 			domain.NewProviderConfigRequirement(nil, true), "some-uid"))
-		target.Configured(target.CurrentVersion(), nil)
+		target.Configured(target.CurrentVersion(), nil, nil)
 
 		app := must.Panic(domain.NewApp("my-app",
 			domain.NewEnvironmentConfigRequirement(domain.NewEnvironmentConfig(target.ID()), true, true),
@@ -146,7 +146,7 @@ func Test_Deploy(t *testing.T) {
 		target := must.Panic(domain.NewTarget("my-target",
 			domain.NewTargetUrlRequirement(must.Panic(domain.UrlFrom("http://localhost")), true),
 			domain.NewProviderConfigRequirement(nil, true), "some-uid"))
-		target.Configured(target.CurrentVersion(), nil)
+		target.Configured(target.CurrentVersion(), nil, nil)
 
 		app := must.Panic(domain.NewApp("my-app",
 			domain.NewEnvironmentConfigRequirement(domain.NewEnvironmentConfig(target.ID()), true, true),

internal/deployment/app/expose_seelf_container/expose_seelf_container.go

@@ -87,7 +87,9 @@ func Handler(
 			return bus.Unit, err
 		}
 
-		target.Configured(target.CurrentVersion(), provider.Setup(ctx, target))
+		assigned, err := provider.Setup(ctx, target)
+
+		target.Configured(target.CurrentVersion(), assigned, err)
 
 		if err := writer.Write(ctx, &target); err != nil {
 			return bus.Unit, err

internal/deployment/app/get_deployment/get_deployment.go

@@ -1,6 +1,7 @@
 package get_deployment
 
 import (
+	"fmt"
 	"time"
 
 	"github.com/YuukanOO/seelf/internal/deployment/app"
@@ -56,16 +57,25 @@ type (
 
 	Services []Service
 
+	Entrypoint struct {
+		Name          string              `json:"name"`
+		Router        string              `json:"router"`
+		Subdomain     monad.Maybe[string] `json:"subdomain"`
+		Port          uint                `json:"port"`
+		Url           monad.Maybe[string] `json:"url"`
+		PublishedPort monad.Maybe[uint]   `json:"published_port"`
+	}
+
 	Service struct {
-		Name      string              `json:"name"`
-		Image     string              `json:"image"`
-		Subdomain monad.Maybe[string] `json:"subdomain"`
-		Url       monad.Maybe[string] `json:"url"`
+		Name        string       `json:"name"`
+		Image       string       `json:"image"`
+		Entrypoints []Entrypoint `json:"entrypoints"`
 	}
 )
 
 func (Query) Name_() string { return "deployment.query.get_deployment" }
 
 func (s *Services) Scan(value any) error {
+	fmt.Println("TODO: implement a compatility layer to extract the root subdomain into a new entrypoint HTTP")
 	return storage.ScanJSON(value, s)
 }

internal/deployment/app/reconfigure_target/reconfigure_target_test.go

@@ -31,7 +31,7 @@ func Test_ReconfigureTarget(t *testing.T) {
 		target := must.Panic(domain.NewTarget("my-target",
 			domain.NewTargetUrlRequirement(must.Panic(domain.UrlFrom("http://localhost")), true),
 			domain.NewProviderConfigRequirement(nil, true), "uid"))
-		target.Configured(target.CurrentVersion(), nil)
+		target.Configured(target.CurrentVersion(), nil, nil)
 
 		uc := sut(&target)
 

internal/deployment/app/request_target_cleanup/request_target_cleanup_test.go

@@ -42,7 +42,7 @@ func Test_RequestTargetCleanup(t *testing.T) {
 		target := must.Panic(domain.NewTarget("my-target",
 			domain.NewTargetUrlRequirement(must.Panic(domain.UrlFrom("http://docker.localhost")), true),
 			domain.NewProviderConfigRequirement(dummyProviderConfig{}, true), "uid"))
-		target.Configured(target.CurrentVersion(), nil)
+		target.Configured(target.CurrentVersion(), nil, nil)
 		app := must.Panic(domain.NewApp("my-app",
 			domain.NewEnvironmentConfigRequirement(domain.NewEnvironmentConfig(target.ID()), true, true),
 			domain.NewEnvironmentConfigRequirement(domain.NewEnvironmentConfig(target.ID()), true, true), "uid"))
@@ -63,7 +63,7 @@ func Test_RequestTargetCleanup(t *testing.T) {
 		target := must.Panic(domain.NewTarget("my-target",
 			domain.NewTargetUrlRequirement(must.Panic(domain.UrlFrom("http://docker.localhost")), true),
 			domain.NewProviderConfigRequirement(dummyProviderConfig{}, true), "uid"))
-		target.Configured(target.CurrentVersion(), nil)
+		target.Configured(target.CurrentVersion(), nil, nil)
 
 		uc := sut(initialData{
 			targets: []*domain.Target{&target},

internal/deployment/app/update_target/update_target_test.go

@@ -92,7 +92,8 @@ func (*dummyProvider) Prepare(ctx context.Context, payload any, existing ...doma
 	return dummyConfig{payload.(string)}, nil
 }
 
-func (dummyConfig) Kind() string                              { return "dummy" }
-func (c dummyConfig) Fingerprint() string                     { return c.data }
-func (c dummyConfig) Equals(other domain.ProviderConfig) bool { return false }
-func (c dummyConfig) String() string                          { return c.data }
+func (dummyConfig) Kind() string                                                { return "dummy" }
+func (c dummyConfig) Fingerprint() string                                       { return c.data }
+func (c dummyConfig) Equals(other domain.ProviderConfig) bool                   { return false }
+func (c dummyConfig) String() string                                            { return c.data }
+func (dummyConfig) FilterEntrypoints(e []domain.Entrypoint) []domain.Entrypoint { return e }

internal/deployment/domain/deployment.go

@@ -69,8 +69,9 @@ type (
 	DeploymentStateChanged struct {
 		bus.Notification
 
-		ID    DeploymentID
-		State DeploymentState
+		ID     DeploymentID
+		Config DeploymentConfig
+		State  DeploymentState
 	}
 )
 
@@ -221,8 +222,9 @@ func (d *Deployment) HasEnded(services Services, deploymentErr error) error {
 
 func (d *Deployment) stateChanged() {
 	d.apply(DeploymentStateChanged{
-		ID:    d.id,
-		State: d.state,
+		ID:     d.id,
+		Config: d.config,
+		State:  d.state,
 	})
 }
 

internal/deployment/domain/deployment_config.go

@@ -69,7 +69,7 @@ func (c DeploymentConfig) EnvironmentVariablesFor(service string) (m monad.Maybe
 }
 
 // Returns the subdomain that will be used to expose a specific service.
-func (c DeploymentConfig) SubDomain(service string, hasExposedServices bool) string {
+func (c DeploymentConfig) SubDomain(service string, isDefault bool) string {
 	subdomain := string(c.appname)
 
 	if !c.environment.IsProduction() {
@@ -78,7 +78,7 @@ func (c DeploymentConfig) SubDomain(service string, hasExposedServices bool) str
 
 	// If the default domain has already been taken by another service, build a
 	// unique subdomain with the service name being exposed.
-	if hasExposedServices {
+	if !isDefault {
 		subdomain = service + "." + subdomain
 	}
 

internal/deployment/domain/deployment_config_test.go

@@ -59,15 +59,15 @@ func Test_Config(t *testing.T) {
 	t.Run("should generate a subdomain equals to app name if env is production", func(t *testing.T) {
 		conf, _ := app.ConfigSnapshotFor(domain.Production)
 
-		testutil.Equals(t, "my-app", conf.SubDomain("app", false))
-		testutil.Equals(t, "db.my-app", conf.SubDomain("db", true))
+		testutil.Equals(t, "my-app", conf.SubDomain("app", true))
+		testutil.Equals(t, "db.my-app", conf.SubDomain("db", false))
 	})
 
 	t.Run("should generate a subdomain suffixed by the env if not production", func(t *testing.T) {
 		conf, _ := app.ConfigSnapshotFor(domain.Staging)
 
-		testutil.Equals(t, "my-app-staging", conf.SubDomain("app", false))
-		testutil.Equals(t, "db.my-app-staging", conf.SubDomain("db", true))
+		testutil.Equals(t, "my-app-staging", conf.SubDomain("app", true))
+		testutil.Equals(t, "db.my-app-staging", conf.SubDomain("db", false))
 	})
 
 	t.Run("should expose a unique project name", func(t *testing.T) {

internal/deployment/domain/deployment_test.go

@@ -86,13 +86,13 @@ func Test_Deployment(t *testing.T) {
 	})
 
 	t.Run("could be marked has ended with services", func(t *testing.T) {
-		var (
-			err      error
-			services domain.Services
-		)
+		var err error
 
 		dpl := must.Panic(app.NewDeployment(number, nonVcsMeta, domain.Production, uid))
-		services, _ = services.Append(dpl.Config(), "aservice", "an/image", false)
+		services := domain.Services{
+			dpl.Config().NewService("aservice", "an/image"),
+		}
+
 		dpl.HasStarted()
 
 		err = dpl.HasEnded(services, nil)