feat: project deployment versions

saitho · saitho · commit 36849519b4aa · 2023-05-27T21:18:08.000+02:00
diff --git a/commands/project/deploy.go b/commands/project/deploy.go
@@ -54,7 +54,7 @@ var DeployApplication = func() *cobra.Command {
 			} else {
 				// Confirm resource creation
 				fmt.Println("\nStackHead will try to create or update the following resources:")
-				for _, resourceGroup := range system.Context.Resources {
+				for _, resourceGroup := range system.Context.CurrentDeployment.ResourceGroups {
 					for _, resource := range resourceGroup.Resources {
 						fmt.Println(fmt.Sprintf("- %s", resource.ToString(false)))
 					}
diff --git a/modules/container/docker/definitions/volume.go b/modules/container/docker/definitions/volume.go
@@ -3,24 +3,27 @@ package container_docker_definitions
 import (
 	"github.com/getstackhead/stackhead/project"
 	"github.com/getstackhead/stackhead/system"
+	"path"
 )
 
 type DockerPaths struct {
-	BaseDir string
+	DataDir       string
+	DeploymentDir string
 }
 
 func GetDockerPaths() DockerPaths {
 	return DockerPaths{
-		BaseDir: system.Context.Project.GetRuntimeDataDirectoryPath() + "/container",
+		DataDir:       path.Join(system.Context.Project.GetRuntimeDataDirectoryPath(), "container"),
+		DeploymentDir: path.Join(system.Context.CurrentDeployment.GetPath(), "container"),
 	}
 }
 
 func (p DockerPaths) GetHooksDir() string {
-	return p.BaseDir + "/hooks"
+	return path.Join(p.DeploymentDir, "hooks")
 }
 
 func (p DockerPaths) getDataDir() string {
-	return p.BaseDir + "/data"
+	return path.Join(p.DataDir, "data")
 }
 
 func (p DockerPaths) GetServiceDataDir(service project.ContainerService, volume project.ContainerServiceVolume) string {
diff --git a/modules/container/docker/deploy.go b/modules/container/docker/deploy.go
@@ -138,25 +138,36 @@ func (m Module) Deploy(modulesSettings interface{}) error {
 		return err
 	}
 
-	composeFileRemotePath := system.Context.Project.GetDirectoryPath() + "/docker-compose.yaml"
-
-	hasRemoteFile, err := xfs.HasFile("ssh://" + composeFileRemotePath)
-	if err != nil && err.Error() == "file does not exist" {
-		hasRemoteFile = false
-	} else if err != nil {
-		return fmt.Errorf("Unable to check state of remote docker-compose.yaml from previous deployment: " + err.Error())
+	dockerComposeResource := system.Resource{
+		Type:      system.TypeFile,
+		Operation: system.OperationCreate,
+		Name:      "docker-compose.yaml",
 	}
 
+	oldComposeFilePath := ""
 	var remoteComposeObjMap map[string]interface{}
-	if hasRemoteFile {
-		remoteComposeObj := docker_compose.DockerCompose{}
-		remoteComposeContent, err := xfs.ReadFile("ssh://" + composeFileRemotePath)
-		if err := yaml.Unmarshal([]byte(remoteComposeContent), &remoteComposeObj); err != nil {
-			return fmt.Errorf("unable to read remote docker-compose.yaml file from previous deployment: " + err.Error())
-		}
-		remoteComposeObjMap, err = remoteComposeObj.Map()
+	if system.Context.LatestDeployment != nil {
+		dockerComposeFilePathOld, err := system.Context.LatestDeployment.GetResourcePath(dockerComposeResource)
 		if err != nil {
-			return fmt.Errorf("unable to process remote docker-compose.yaml file from previous deployment: " + err.Error())
+			return err
+		}
+		oldComposeFilePath = dockerComposeFilePathOld
+		hasRemoteFile, err := xfs.HasFile("ssh://" + oldComposeFilePath)
+		if err != nil && hasRemoteFile {
+			remoteComposeContent, err := xfs.ReadFile("ssh://" + oldComposeFilePath)
+			if err != nil {
+				return fmt.Errorf("unable to read remote docker-compose.yaml file from previous deployment: " + err.Error())
+			}
+			remoteComposeObj := docker_compose.DockerCompose{}
+			if err := yaml.Unmarshal([]byte(remoteComposeContent), &remoteComposeObj); err != nil {
+				return fmt.Errorf("unable to read remote docker-compose.yaml file from previous deployment: " + err.Error())
+			}
+			remoteComposeObjMap, err = remoteComposeObj.Map()
+			if err != nil {
+				return fmt.Errorf("unable to process remote docker-compose.yaml file from previous deployment: " + err.Error())
+			}
+		} else if err != nil && err.Error() != "file does not exist" {
+			return fmt.Errorf("Unable to check state of remote docker-compose.yaml from previous deployment: " + err.Error())
 		}
 	}
 
@@ -177,17 +188,13 @@ func (m Module) Deploy(modulesSettings interface{}) error {
 	if err != nil {
 		return err
 	}
+	dockerComposeResource.Content = composeFileContent
 
-	system.Context.Resources = append(system.Context.Resources, system.ResourceGroup{
-		Name: "container-docker-" + system.Context.Project.Name + "-composefile",
-		Resources: []system.Resource{
-			{
-				Type:      system.TypeFile,
-				Operation: system.OperationCreate,
-				Name:      composeFileRemotePath,
-				Content:   composeFileContent,
-			},
-		},
+	dockerComposeFilePathNew, _ := system.Context.CurrentDeployment.GetResourcePath(dockerComposeResource)
+
+	system.Context.CurrentDeployment.ResourceGroups = append(system.Context.CurrentDeployment.ResourceGroups, system.ResourceGroup{
+		Name:      "container-docker-" + system.Context.Project.Name + "-composefile",
+		Resources: []system.Resource{dockerComposeResource},
 	})
 
 	var containerResources []system.Resource
@@ -202,14 +209,22 @@ func (m Module) Deploy(modulesSettings interface{}) error {
 		})
 	}
 
-	system.Context.Resources = append(system.Context.Resources, system.ResourceGroup{
+	system.Context.CurrentDeployment.ResourceGroups = append(system.Context.CurrentDeployment.ResourceGroups, system.ResourceGroup{
 		Name:      "container-docker-" + system.Context.Project.Name + "-containers",
 		Resources: containerResources,
 		ApplyResourceFunc: func() error {
+			// Stop old Docker Compose containers
+			// todo: allow using either docker-compose or "docker compose" whichever is available (prefer "docker compose")
+			if _, stderr, err := system.RemoteRun("docker compose", system.RemoteRunOpts{Args: []string{"down"}, WorkingDir: path.Dir(oldComposeFilePath)}); err != nil {
+				if stderr.Len() > 0 {
+					return fmt.Errorf("Unable to stop old Docker containers: " + stderr.String())
+				}
+				return fmt.Errorf("Unable to stop old Docker containers: " + err.Error())
+			}
+
 			// Start Docker Compose
 			// todo: allow using either docker-compose or "docker compose" whichever is available (prefer "docker compose")
-			_, stderr, err := system.RemoteRun("docker compose", system.RemoteRunOpts{Args: []string{"up", "-d"}, WorkingDir: system.Context.Project.GetDirectoryPath()})
-			if err != nil {
+			if _, stderr, err := system.RemoteRun("docker compose", system.RemoteRunOpts{Args: []string{"up", "-d"}, WorkingDir: path.Dir(dockerComposeFilePathNew)}); err != nil {
 				if stderr.Len() > 0 {
 					return fmt.Errorf("Unable to start Docker containers: " + stderr.String())
 				}
@@ -223,10 +238,18 @@ func (m Module) Deploy(modulesSettings interface{}) error {
 			return nil
 		},
 		RollbackResourceFunc: func() error {
+			// Start old containers again
+			// todo: allow using either docker-compose or "docker compose" whichever is available (prefer "docker compose")
+			if _, stderr, err := system.RemoteRun("docker compose", system.RemoteRunOpts{Args: []string{"up", "-d"}, WorkingDir: path.Dir(oldComposeFilePath)}); err != nil {
+				if stderr.Len() > 0 {
+					return fmt.Errorf("Unable to stop Docker containers: " + stderr.String())
+				}
+				return fmt.Errorf("Unable to stop Docker containers: " + err.Error())
+			}
+
 			// Stop Docker Compose
 			// todo: allow using either docker-compose or "docker compose" whichever is available (prefer "docker compose")
-			_, stderr, err := system.RemoteRun("docker compose", system.RemoteRunOpts{Args: []string{"down"}, WorkingDir: system.Context.Project.GetDirectoryPath()})
-			if err != nil {
+			if _, stderr, err := system.RemoteRun("docker compose", system.RemoteRunOpts{Args: []string{"down"}, WorkingDir: path.Dir(dockerComposeFilePathNew)}); err != nil {
 				if stderr.Len() > 0 {
 					return fmt.Errorf("Unable to stop Docker containers: " + stderr.String())
 				}
diff --git a/modules/container/docker/destroy.go b/modules/container/docker/destroy.go
@@ -15,7 +15,7 @@ func (m Module) Destroy(modulesSettings interface{}) error {
 
 	// Stop and remove containers
 	// todo: allow using either docker-compose or "docker compose" whichever is available (prefer "docker compose")
-	_, stderr, err := system.RemoteRun("docker compose", system.RemoteRunOpts{Args: []string{"down"}, WorkingDir: system.Context.Project.GetDirectoryPath()})
+	_, stderr, err := system.RemoteRun("docker compose", system.RemoteRunOpts{Args: []string{"down"}, WorkingDir: system.Context.CurrentDeployment.GetPath()})
 	if err != nil {
 		if stderr.Len() > 0 {
 			return fmt.Errorf("Unable to stop Docker containers: " + stderr.String())
diff --git a/modules/container/docker/docker-compose/yaml.go b/modules/container/docker/docker-compose/yaml.go
@@ -17,7 +17,7 @@ func BuildDockerCompose(project *project.Project) (DockerCompose, error) {
 	dockerPaths := container_docker_definitions.GetDockerPaths()
 	compose := DockerCompose{
 		Version:  "2.4",
-		Networks: map[string]Network{"stackhead-network-" + project.Name: {}},
+		Networks: map[string]Network{docker_system.NetworkName(project.Name, system.Context.CurrentDeployment): {}},
 		Services: map[string]Services{},
 		Volumes:  map[string]Volume{},
 	}
@@ -36,7 +36,6 @@ func BuildDockerCompose(project *project.Project) (DockerCompose, error) {
 				continue
 			}
 			vol := Volume{}
-			serviceName := service.Name
 			vol.DriverOpts.Type = "none"
 			vol.DriverOpts.O = "bind"
 			if volume.Type == "local" {
@@ -46,7 +45,7 @@ func BuildDockerCompose(project *project.Project) (DockerCompose, error) {
 			} else if volume.Type == "custom" {
 				vol.DriverOpts.Device = volume.Src
 			}
-			compose.Volumes[GetVolumeSrcKey(project.Name, serviceName, volume)] = vol
+			compose.Volumes[GetVolumeSrcKey(project.Name, service.Name, volume)] = vol
 		}
 	}
 
@@ -89,12 +88,12 @@ func addService(compose *DockerCompose, project *project.Project, service projec
 	}
 
 	compose.Services[service.Name] = Services{
-		ContainerName: docker_system.ContainerName(project.Name, service.Name),
+		ContainerName: docker_system.ContainerName(project.Name, service.Name, system.Context.CurrentDeployment),
 		Image:         service.Image,
 		Restart:       "unless-stopped",
 		Labels:        map[string]string{"stackhead.project": project.Name},
 		User:          service.User,
-		Networks:      map[string]ServiceNetwork{"stackhead-network-" + project.Name: {Aliases: []string{service.Name}}},
+		Networks:      map[string]ServiceNetwork{docker_system.NetworkName(project.Name, system.Context.CurrentDeployment): {Aliases: []string{service.Name}}},
 		Volumes:       volumes,
 		Ports:         ports,
 		Environment:   service.Environment,
diff --git a/modules/container/docker/system/hooks.go b/modules/container/docker/system/hooks.go
@@ -45,14 +45,14 @@ func ExecuteHook(hookName string) error {
 
 		// copy file onto container and run it.....
 		containerLocation := path.Join("/", file.File)
-		containerName := ContainerName(system.Context.Project.Name, file.Service)
+		containerName := ContainerName(system.Context.Project.Name, file.Service, system.Context.CurrentDeployment)
 		_, err := system.SimpleRemoteRun("docker", system.RemoteRunOpts{
 			Args: []string{
 				"cp",
 				filePath,
 				containerName + ":" + containerLocation,
 			},
-			WorkingDir: system.Context.Project.GetDirectoryPath(),
+			WorkingDir: system.Context.CurrentDeployment.GetPath(),
 		})
 		if err != nil {
 			return fmt.Errorf("Unable to copy file %s to container %s: \"%s\"", file.File, containerName, err.Error())
@@ -64,7 +64,7 @@ func ExecuteHook(hookName string) error {
 				containerName,
 				"chmod +x " + containerLocation,
 			},
-			WorkingDir: system.Context.Project.GetDirectoryPath(),
+			WorkingDir: system.Context.CurrentDeployment.GetPath(),
 		})
 		if err != nil {
 			return fmt.Errorf("Unable to copy file %s to container %s: \"%s\"", file.File, containerName, err.Error())
@@ -76,7 +76,7 @@ func ExecuteHook(hookName string) error {
 				containerName,
 				containerLocation,
 			},
-			WorkingDir: system.Context.Project.GetDirectoryPath(),
+			WorkingDir: system.Context.CurrentDeployment.GetPath(),
 		})
 		if err != nil {
 			return fmt.Errorf("Unable to run %s on container %s: \"%s\"", file, containerName, err.Error())
diff --git a/modules/container/docker/system/naming.go b/modules/container/docker/system/naming.go
@@ -1,7 +1,14 @@
 package docker_system
 
-import "fmt"
+import (
+	"fmt"
+	"github.com/getstackhead/stackhead/system"
+)
 
-func ContainerName(projectName string, serviceName string) string {
-	return fmt.Sprintf("stackhead-%s-%s", projectName, serviceName)
+func ContainerName(projectName string, serviceName string, deployment system.Deployment) string {
+	return fmt.Sprintf("stackhead-%s-%s-v%d", projectName, serviceName, deployment.Version)
+}
+
+func NetworkName(projectName string, deployment system.Deployment) string {
+	return fmt.Sprintf("stackhead-network-%s-v%d", projectName, deployment.Version)
 }
diff --git a/modules/container/docker/system/ports.go b/modules/container/docker/system/ports.go
@@ -16,7 +16,7 @@ func GetPortMap(project *project.Project) (map[string]int, error) {
 
 	// find ports for running containers
 	for _, service := range project.Container.Services {
-		res, _, err := system.RemoteRun("docker", system.RemoteRunOpts{Args: []string{"port", "stackhead-" + project.Name + "-" + service.Name}})
+		res, _, err := system.RemoteRun("docker", system.RemoteRunOpts{Args: []string{"port", ContainerName(project.Name, service.Name, system.Context.CurrentDeployment)}})
 		if err == nil { // ignore error (container not running)
 			// e.g. 80/tcp -> 0.0.0.0:49155
 			re := regexp.MustCompile(`(?P<Internal>\d+)\/tcp -> 0\.0\.0\.0:(?P<External>\d+)`)
diff --git a/modules/container/docker/templates/project.tf.tmpl b/modules/container/docker/templates/project.tf.tmpl
diff --git a/modules/proxy/caddy/deploy.go b/modules/proxy/caddy/deploy.go
@@ -17,20 +17,23 @@ func (Module) Deploy(modulesSettings interface{}) error {
 		return err
 	}
 
-	projectCaddyLocation := system.Context.Project.GetDirectoryPath() + "/Caddyfile"
+	caddyFileResource := system.Resource{
+		Type:      system.TypeFile,
+		Operation: system.OperationCreate,
+		Name:      "Caddyfile",
+		Content:   caddyDirectives,
+	}
 
-	system.Context.Resources = append(system.Context.Resources, system.ResourceGroup{
-		Name: "proxy-caddy-" + system.Context.Project.Name + "-caddyfile",
-		Resources: []system.Resource{
-			{
-				Type:      system.TypeFile,
-				Operation: system.OperationCreate,
-				Name:      projectCaddyLocation,
-				Content:   caddyDirectives,
-			},
-		},
+	caddyFilePath, err := system.Context.CurrentDeployment.GetResourcePath(caddyFileResource)
+	if err != nil {
+		return err
+	}
+
+	system.Context.CurrentDeployment.ResourceGroups = append(system.Context.CurrentDeployment.ResourceGroups, system.ResourceGroup{
+		Name:      "proxy-caddy-" + system.Context.Project.Name + "-caddyfile",
+		Resources: []system.Resource{caddyFileResource},
 		ApplyResourceFunc: func() error {
-			if _, err := system.SimpleRemoteRun("ln", system.RemoteRunOpts{Args: []string{"-sf " + projectCaddyLocation + " /etc/caddy/conf.d/stackhead_" + system.Context.Project.Name + ".conf"}}); err != nil {
+			if _, err := system.SimpleRemoteRun("ln", system.RemoteRunOpts{Args: []string{"-sf " + caddyFilePath + " /etc/caddy/conf.d/stackhead_" + system.Context.Project.Name + ".conf"}}); err != nil {
 				return fmt.Errorf("Unable to symlink project Caddyfile: " + err.Error())
 			}
 			if _, err := system.SimpleRemoteRun("systemctl", system.RemoteRunOpts{Args: []string{"reload", "caddy"}, Sudo: true}); err != nil {
diff --git a/modules/proxy/rendering.go b/modules/proxy/rendering.go
@@ -38,7 +38,7 @@ var FuncMap = template.FuncMap{
 		return auths
 	},
 	"getExternalPort": func(service string, internalPort int) string {
-		for _, resourceGroup := range system.Context.Resources {
+		for _, resourceGroup := range system.Context.CurrentDeployment.ResourceGroups {
 			for _, resource := range resourceGroup.Resources {
 				if resource.Type != system.TypeContainer {
 					continue
diff --git a/project/funcs.go b/project/funcs.go
@@ -10,6 +10,10 @@ func (project *Project) GetDirectoryPath() string {
 	return path.Join(config.ProjectsRootDirectory, project.Name)
 }
 
+func (project *Project) GetDeploymentsPath() string {
+	return path.Join(config.ProjectsRootDirectory, project.Name, "deployments")
+}
+
 func (project *Project) GetRuntimeDataDirectoryPath() string {
-	return path.Join(config.ProjectsRootDirectory, project.Name, "runtime")
+	return path.Join(config.ProjectsRootDirectory, project.Name, "data")
 }
diff --git a/routines/implementations.go b/routines/implementations.go
diff --git a/system/context.go b/system/context.go
diff --git a/system/deployments.go b/system/deployments.go
diff --git a/system/resource_manager.go b/system/resource_manager.go

Original file line number	Diff line number	Diff line change
`@@ -54,7 +54,7 @@ var DeployApplication = func() *cobra.Command {`
`54`	`54`	`} else {`
`55`	`55`	`// Confirm resource creation`
`56`	`56`	`fmt.Println("\nStackHead will try to create or update the following resources:")`
`57`		`- for _, resourceGroup := range system.Context.Resources {`
	`57`	`+ for _, resourceGroup := range system.Context.CurrentDeployment.ResourceGroups {`
`58`	`58`	`for _, resource := range resourceGroup.Resources {`
`59`	`59`	`fmt.Println(fmt.Sprintf("- %s", resource.ToString(false)))`
`60`	`60`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3,24 +3,27 @@ package container_docker_definitions`
`3`	`3`	`import (`
`4`	`4`	`"github.com/getstackhead/stackhead/project"`
`5`	`5`	`"github.com/getstackhead/stackhead/system"`
	`6`	`+ "path"`
`6`	`7`	`)`
`7`	`8`
`8`	`9`	`type DockerPaths struct {`
`9`		`- BaseDir string`
	`10`	`+ DataDir string`
	`11`	`+ DeploymentDir string`
`10`	`12`	`}`
`11`	`13`
`12`	`14`	`func GetDockerPaths() DockerPaths {`
`13`	`15`	`return DockerPaths{`
`14`		`- BaseDir: system.Context.Project.GetRuntimeDataDirectoryPath() + "/container",`
	`16`	`+ DataDir: path.Join(system.Context.Project.GetRuntimeDataDirectoryPath(), "container"),`
	`17`	`+ DeploymentDir: path.Join(system.Context.CurrentDeployment.GetPath(), "container"),`
`15`	`18`	`}`
`16`	`19`	`}`
`17`	`20`
`18`	`21`	`func (p DockerPaths) GetHooksDir() string {`
`19`		`- return p.BaseDir + "/hooks"`
	`22`	`+ return path.Join(p.DeploymentDir, "hooks")`
`20`	`23`	`}`
`21`	`24`
`22`	`25`	`func (p DockerPaths) getDataDir() string {`
`23`		`- return p.BaseDir + "/data"`
	`26`	`+ return path.Join(p.DataDir, "data")`
`24`	`27`	`}`
`25`	`28`
`26`	`29`	`func (p DockerPaths) GetServiceDataDir(service project.ContainerService, volume project.ContainerServiceVolume) string {`