650efff WIP · gordon · git.bnema.dev

M internal/http/handlers/htmx-installer.go +11 -4

@@ -1,6 +1,8 @@
1	1		package handlers
2	2
3	3		import (
	4	+	"errors"
	5	+
4	6		"github.com/labstack/echo/v4"
5	7		"gogs.bnema.dev/gordon-echo/pkg/scripts"
6	8		"gogs.bnema.dev/gordon-echo/pkg/utils"

@@ -29,13 +31,18 @@ func TraefikInstallerHandler(c echo.Context) error {
29	31		}
30	32
31	33		// Call to create the YAML files
32		-	err = scripts.CreateYAMLFiles(topDomain, adminEmail, logger)
	34	+	success, err := scripts.InstallTraefik(topDomain, adminEmail, logger)
33	35		if err != nil {
34		-	logger.Error().Err(err).Msg("Failed to create YAML files")
	36	+	logger.Error().Err(err).Msg("Failed to install Traefik")
35	37		return err
	38	+	} else if !success {
	39	+	logger.Error().Msg("Failed to install Traefik")
	40	+	return errors.New("failed to install Traefik")
	41	+	} else {
	42	+	logger.Info().Msg("Traefik installed successfully")
36	43		}
37		-	return nil
38		-
	44	+	// Return success message to the user wih htmx
	45	+	return c.HTML(200, "Traefik installed successfully")
39	46		}
40	47
41	48		// use the handler at the route /admin/install/traefik

@@ -1,6 +1,8 @@
1		package handlers	1		package handlers
2			2
3		import (	3		import (
			4	+	"errors"
			5	+
4		"github.com/labstack/echo/v4"	6		"github.com/labstack/echo/v4"
5		"gogs.bnema.dev/gordon-echo/pkg/scripts"	7		"gogs.bnema.dev/gordon-echo/pkg/scripts"
6		"gogs.bnema.dev/gordon-echo/pkg/utils"	8		"gogs.bnema.dev/gordon-echo/pkg/utils"

@@ -29,13 +31,18 @@ func TraefikInstallerHandler(c echo.Context) error {
29		}	31		}
30			32
31		// Call to create the YAML files	33		// Call to create the YAML files
32	-	err = scripts.CreateYAMLFiles(topDomain, adminEmail, logger)	34	+	success, err := scripts.InstallTraefik(topDomain, adminEmail, logger)
33		if err != nil {	35		if err != nil {
34	-	logger.Error().Err(err).Msg("Failed to create YAML files")	36	+	logger.Error().Err(err).Msg("Failed to install Traefik")
35		return err	37		return err
			38	+	} else if !success {
			39	+	logger.Error().Msg("Failed to install Traefik")
			40	+	return errors.New("failed to install Traefik")
			41	+	} else {
			42	+	logger.Info().Msg("Traefik installed successfully")
36		}	43		}
37	-	return nil	44	+	// Return success message to the user wih htmx
38	-		45	+	return c.HTML(200, "Traefik installed successfully")
39		}	46		}
40			47
41		// use the handler at the route /admin/install/traefik	48		// use the handler at the route /admin/install/traefik

M pkg/docker/commands.go +43 -8


@@ -3,6 +3,7 @@ package docker
3	3		import (
4	4		"bufio"
5	5		"context"
	6	+	"errors"
6	7		"fmt"
7	8		"io"
8	9		"os"

@@ -174,26 +175,61 @@ func CreateNetwork(name string) error {
174	175		return nil
175	176		}
176	177
	178	+	// Check if a container exists
	179	+	func ContainerExists(name string) (bool, error) {
	180	+	ctx := context.Background()
	181	+	cli, err := client.NewClientWithOpts(client.FromEnv, client.WithAPIVersionNegotiation())
	182	+	if err != nil {
	183	+	return false, errors.New("failed to initialize Docker client")
	184	+	}
	185	+	defer cli.Close()
	186	+
	187	+	fmt.Println("Checking if container exists...")
	188	+	containers, err := cli.ContainerList(ctx, types.ContainerListOptions{})
	189	+	if err != nil {
	190	+	return false, errors.New("failed to list containers")
	191	+	}
	192	+
	193	+	for _, container := range containers {
	194	+	for _, containerName := range container.Names {
	195	+	if containerName == "/"+name {
	196	+	return true, nil
	197	+	}
	198	+	}
	199	+	}
	200	+
	201	+	return false, nil
	202	+	}
	203	+
	204	+	func CheckDockerRunning() (bool, error) {
	205	+	fmt.Println("Checking if Docker is running...")
	206	+	cmd := exec.Command("docker", "info")
	207	+	if err := cmd.Run(); err != nil {
	208	+	return true, errors.New("docker is not running")
	209	+	}
	210	+	return false, nil
	211	+	}
	212	+
177	213		// CreateContainerFromComposeFile creates containers using docker compose based on the provided compose file.
178		-	func CreateContainerFromComposeFile(composeFilePath string, logger *utils.Logger) error {
	214	+	func CreateContainerFromComposeFile(composeFilePath string, logger *utils.Logger) (bool, error) {
179	215		fmt.Println("Executing CreateContainerFromComposeFile()")
180	216
181	217		// Create and start containers using docker compose in the foreground
182		-	cmd := exec.Command("docker", "compose", "-f", composeFilePath, "up")
	218	+	cmd := exec.Command("docker", "compose", "-f", composeFilePath, "up", "-d")
183	219
184	220		// Get stdout and stderr pipes
185	221		stdout, err := cmd.StdoutPipe()
186	222		if err != nil {
187		-	return fmt.Errorf("failed to get stdout pipe: %v", err)
	223	+	return false, fmt.Errorf("failed to get stdout pipe: %v", err)
188	224		}
189	225		stderr, err := cmd.StderrPipe()
190	226		if err != nil {
191		-	return fmt.Errorf("failed to get stderr pipe: %v", err)
	227	+	return false, fmt.Errorf("failed to get stderr pipe: %v", err)
192	228		}
193	229
194	230		// Start the command
195	231		if err := cmd.Start(); err != nil {
196		-	return fmt.Errorf("failed to start docker compose: %v", err)
	232	+	return false, fmt.Errorf("failed to start docker compose: %v", err)
197	233		}
198	234
199	235		// Stream stdout to logger with INFO level

@@ -203,11 +239,10 @@ func CreateContainerFromComposeFile(composeFilePath string, logger *utils.Logger
203	239
204	240		// Wait for the command to finish
205	241		if err := cmd.Wait(); err != nil {
206		-	return fmt.Errorf("docker compose command finished with error: %v", err)
	242	+	return false, fmt.Errorf("docker compose command finished with error: %v", err)
207	243		}
208	244
209		-	fmt.Println("Containers started successfully using docker compose")
210		-	return nil
	245	+	return true, nil
211	246		}
212	247
213	248		func streamToLogger(r io.Reader, logger *utils.Logger, level utils.LogLevel) {

 import (
 	"bufio"
 	"context"
+	"errors"
 	"fmt"
 	"io"
 	"os"
 	return nil
 }
+// Check if a container exists
+func ContainerExists(name string) (bool, error) {
+	ctx := context.Background()
+	cli, err := client.NewClientWithOpts(client.FromEnv, client.WithAPIVersionNegotiation())
+	if err != nil {
+		return false, errors.New("failed to initialize Docker client")
+	}
+	defer cli.Close()
+	fmt.Println("Checking if container exists...")
+	containers, err := cli.ContainerList(ctx, types.ContainerListOptions{})
+	if err != nil {
+		return false, errors.New("failed to list containers")
+	}
+	for _, container := range containers {
+		for _, containerName := range container.Names {
+			if containerName == "/"+name {
+				return true, nil
+			}
+		}
+	}
+	return false, nil
+}
+func CheckDockerRunning() (bool, error) {
+	fmt.Println("Checking if Docker is running...")
+	cmd := exec.Command("docker", "info")
+	if err := cmd.Run(); err != nil {
+		return true, errors.New("docker is not running")
+	}
+	return false, nil
+}
 // CreateContainerFromComposeFile creates containers using docker compose based on the provided compose file.
-func CreateContainerFromComposeFile(composeFilePath string, logger *utils.Logger) error {
+func CreateContainerFromComposeFile(composeFilePath string, logger *utils.Logger) (bool, error) {
 	fmt.Println("Executing CreateContainerFromComposeFile()")
 	// Create and start containers using docker compose in the foreground
-	cmd := exec.Command("docker", "compose", "-f", composeFilePath, "up")
+	cmd := exec.Command("docker", "compose", "-f", composeFilePath, "up", "-d")
 	// Get stdout and stderr pipes
 	stdout, err := cmd.StdoutPipe()
 	if err != nil {
-		return fmt.Errorf("failed to get stdout pipe: %v", err)
+		return false, fmt.Errorf("failed to get stdout pipe: %v", err)
 	}
 	stderr, err := cmd.StderrPipe()
 	if err != nil {
-		return fmt.Errorf("failed to get stderr pipe: %v", err)
+		return false, fmt.Errorf("failed to get stderr pipe: %v", err)
 	}
 	// Start the command
 	if err := cmd.Start(); err != nil {
-		return fmt.Errorf("failed to start docker compose: %v", err)
+		return false, fmt.Errorf("failed to start docker compose: %v", err)
 	}
 	// Stream stdout to logger with INFO level
 	// Wait for the command to finish
 	if err := cmd.Wait(); err != nil {
-		return fmt.Errorf("docker compose command finished with error: %v", err)
+		return false, fmt.Errorf("docker compose command finished with error: %v", err)
 	}
-	fmt.Println("Containers started successfully using docker compose")
+	return true, nil
-	return nil
 }
 func streamToLogger(r io.Reader, logger *utils.Logger, level utils.LogLevel) {

M pkg/scripts/install-traefik.go +82 -22


@@ -12,32 +12,56 @@ import (
12	12		"gogs.bnema.dev/gordon-echo/pkg/utils"
13	13		)
14	14
	15	+	var path string
	16	+
	17	+	func init() {
	18	+	path = app.GetBuildDir() + "/"
	19	+	}
	20	+
	21	+	func InstallTraefik(topDomain, adminEmail string, logger *utils.Logger) (bool, error) {
	22	+	// Create the YAML files
	23	+	if success, err := createYAMLFiles(topDomain, adminEmail, logger); err != nil {
	24	+	return false, err
	25	+	} else if !success {
	26	+	return false, errors.New("failed to create YAML files")
	27	+	}
	28	+
	29	+	// Deploy the containers
	30	+	if success, err := deployTraefik(topDomain, adminEmail, logger); err != nil {
	31	+	return false, err
	32	+	} else if !success {
	33	+	return false, errors.New("failed to deploy Traefik")
	34	+	}
	35	+
	36	+	return true, nil
	37	+	}
	38	+
15	39		func ensureDirExists(dir string) error {
16	40		if _, err := os.Stat(dir); os.IsNotExist(err) {
17	41		return os.Mkdir(dir, 0755)
18	42		}
19	43		return nil
20	44		}
21		-	func CreateYAMLFiles(topDomain, adminEmail string, logger *utils.Logger) error {
22		-	path := app.GetBuildDir() + "/"
	45	+
	46	+	func createYAMLFiles(topDomain, adminEmail string, logger *utils.Logger) (bool, error) {
23	47		modelFS := root.ModelFS
24	48		if modelFS == nil {
25		-	return errors.New("modelFS is nil")
	49	+	return false, errors.New("modelFS is nil")
26	50		}
27	51
28	52		// Check if directory traefik exists, if not create it
29	53		if err := ensureDirExists(path + "traefik"); err != nil {
30		-	return err
	54	+	return false, err
31	55		}
32	56		// Check if directory traefik/volume exists, if not create it
33	57		if err := ensureDirExists(path + "traefik/volume"); err != nil {
34		-	return err
	58	+	return false, err
35	59		}
36	60
37	61		// Setup the TXT renderer for traefik-compose.goyml
38	62		rendererCompose, err := templating.GetTXTRenderer("traefik-compose.goyml", modelFS, logger)
39	63		if err != nil {
40		-	return err
	64	+	return false, err
41	65		}
42	66
43	67		// Render the traefik-compose.goyml with payload data

@@ -45,18 +69,18 @@ func CreateYAMLFiles(topDomain, adminEmail string, logger *utils.Logger) error {
45	69		"topdomain": topDomain,
46	70		})
47	71		if err != nil {
48		-	return err
	72	+	return false, err
49	73		}
50	74		// Save the rendered content to a file at the env path
51	75		err = os.WriteFile(path+"traefik/docker-compose.yml", []byte(composeContent), 0644)
52	76		if err != nil {
53		-	return err
	77	+	return false, err
54	78		}
55	79
56	80		// Setup the TXT renderer for traefik.goyml
57	81		rendererTraefik, err := templating.GetTXTRenderer("traefik.goyml", modelFS, logger)
58	82		if err != nil {
59		-	return err
	83	+	return false, err
60	84		}
61	85
62	86		// Render the traefik.goyml with payload

@@ -64,49 +88,85 @@ func CreateYAMLFiles(topDomain, adminEmail string, logger *utils.Logger) error {
64	88		"admin.email": adminEmail,
65	89		})
66	90		if err != nil {
67		-	return err
	91	+	return false, err
68	92		}
69	93
70	94		// Save the rendered content to a file at the env path
71	95		err = os.WriteFile(path+"traefik/traefik.yml", []byte(traefikContent), 0644)
72	96		if err != nil {
73		-	return err
	97	+	return false, err
74	98		}
75	99
	100	+	return true, nil
	101	+
	102	+	}
	103	+
	104	+	func deployTraefik(topDomain, adminEmail string, logger *utils.Logger) (bool, error) {
76	105		// Now that we have the YAML files, we can launch the containers
77	106		// Create acme.json with permissions 600
78	107		if f, err := os.Create(path + "traefik/volume/acme.json"); err != nil {
79		-	return err
	108	+	return false, err
	109	+	} else if err = f.Chmod(0600); err != nil {
	110	+	return false, err
	111	+	} else {
	112	+	f.Close() // Schedule closing of the file when function exits
	113	+	}
	114	+
	115	+	// traefik.log
	116	+	if f, err := os.Create(path + "traefik/traefik.log"); err != nil {
	117	+	return false, err
80	118		} else if err = f.Chmod(0600); err != nil {
81		-	return err
	119	+	return false, err
82	120		} else {
83	121		f.Close() // Schedule closing of the file when function exits
84	122		}
85	123
	124	+	// check if docker is running
	125	+	if s, err := docker.CheckDockerRunning(); err != nil {
	126	+	return false, err
	127	+	} else if s {
	128	+	fmt.Println("Docker is running")
	129	+	} else {
	130	+	fmt.Println("Docker is not running")
	131	+	}
	132	+
	133	+	// check if a container named traefik already exists
	134	+	if exists, err := docker.ContainerExists("traefik"); err != nil {
	135	+	return false, err
	136	+	} else if exists {
	137	+	return false, errors.New("container traefik already exists")
	138	+	} else {
	139	+	fmt.Println("Container Traefik not found, creating it")
	140	+	}
	141	+
	142	+	// check if there is already a container named traefik
	143	+
86	144		// Create the network "exposed" if it doesn't exist
87	145		// Ensure that the network "exposed" exists if not create it
88	146		exists, err := docker.NetworkExists("exposed")
89	147		if err != nil {
90		-	return err
	148	+	return false, err
91	149		}
92	150		if exists {
93	151		fmt.Println("Network Exposed found")
94	152		} else {
95	153		fmt.Println("Network Exposed not found, creating it")
96	154		if err := docker.CreateNetwork("exposed"); err != nil {
97		-	return err
	155	+	return false, err
98	156		}
99	157		}
100	158
101	159		fmt.Println("Network created successfully")
102	160
103		-	// Create the containers with CreateContainerFromComposeFile
104		-	if err := docker.CreateContainerFromComposeFile(path+"traefik/docker-compose.yml", logger); err != nil {
105		-	return err
	161	+	// Create the containers with CreateContainerFromComposeFile (bool, error)
	162	+	succes, err := docker.CreateContainerFromComposeFile(path+"traefik/docker-compose.yml", logger)
	163	+	if err != nil {
	164	+	return false, err
	165	+	}
	166	+	if succes {
	167	+	fmt.Println("Containers created successfully")
	168	+	return true, nil
106	169		}
107	170
108		-	fmt.Println("Containers created successfully")
109		-
110		-	return nil
111		-
	171	+	return false, errors.New("failed to create containers")
112	172		}


@@ -12,32 +12,56 @@ import (
12		"gogs.bnema.dev/gordon-echo/pkg/utils"	12		"gogs.bnema.dev/gordon-echo/pkg/utils"
13		)	13		)
14			14
			15	+	var path string
			16	+
			17	+	func init() {
			18	+	path = app.GetBuildDir() + "/"
			19	+	}
			20	+
			21	+	func InstallTraefik(topDomain, adminEmail string, logger *utils.Logger) (bool, error) {
			22	+	// Create the YAML files
			23	+	if success, err := createYAMLFiles(topDomain, adminEmail, logger); err != nil {
			24	+	return false, err
			25	+	} else if !success {
			26	+	return false, errors.New("failed to create YAML files")
			27	+	}
			28	+
			29	+	// Deploy the containers
			30	+	if success, err := deployTraefik(topDomain, adminEmail, logger); err != nil {
			31	+	return false, err
			32	+	} else if !success {
			33	+	return false, errors.New("failed to deploy Traefik")
			34	+	}
			35	+
			36	+	return true, nil
			37	+	}
			38	+
15		func ensureDirExists(dir string) error {	39		func ensureDirExists(dir string) error {
16		if _, err := os.Stat(dir); os.IsNotExist(err) {	40		if _, err := os.Stat(dir); os.IsNotExist(err) {
17		return os.Mkdir(dir, 0755)	41		return os.Mkdir(dir, 0755)
18		}	42		}
19		return nil	43		return nil
20		}	44		}
21	-	func CreateYAMLFiles(topDomain, adminEmail string, logger *utils.Logger) error {	45	+
22	-	path := app.GetBuildDir() + "/"	46	+	func createYAMLFiles(topDomain, adminEmail string, logger *utils.Logger) (bool, error) {
23		modelFS := root.ModelFS	47		modelFS := root.ModelFS
24		if modelFS == nil {	48		if modelFS == nil {
25	-	return errors.New("modelFS is nil")	49	+	return false, errors.New("modelFS is nil")
26		}	50		}
27			51
28		// Check if directory traefik exists, if not create it	52		// Check if directory traefik exists, if not create it
29		if err := ensureDirExists(path + "traefik"); err != nil {	53		if err := ensureDirExists(path + "traefik"); err != nil {
30	-	return err	54	+	return false, err
31		}	55		}
32		// Check if directory traefik/volume exists, if not create it	56		// Check if directory traefik/volume exists, if not create it
33		if err := ensureDirExists(path + "traefik/volume"); err != nil {	57		if err := ensureDirExists(path + "traefik/volume"); err != nil {
34	-	return err	58	+	return false, err
35		}	59		}
36			60
37		// Setup the TXT renderer for traefik-compose.goyml	61		// Setup the TXT renderer for traefik-compose.goyml
38		rendererCompose, err := templating.GetTXTRenderer("traefik-compose.goyml", modelFS, logger)	62		rendererCompose, err := templating.GetTXTRenderer("traefik-compose.goyml", modelFS, logger)
39		if err != nil {	63		if err != nil {
40	-	return err	64	+	return false, err
41		}	65		}
42			66
43		// Render the traefik-compose.goyml with payload data	67		// Render the traefik-compose.goyml with payload data

@@ -45,18 +69,18 @@ func CreateYAMLFiles(topDomain, adminEmail string, logger *utils.Logger) error {
45		"topdomain": topDomain,	69		"topdomain": topDomain,
46		})	70		})
47		if err != nil {	71		if err != nil {
48	-	return err	72	+	return false, err
49		}	73		}
50		// Save the rendered content to a file at the env path	74		// Save the rendered content to a file at the env path
51		err = os.WriteFile(path+"traefik/docker-compose.yml", []byte(composeContent), 0644)	75		err = os.WriteFile(path+"traefik/docker-compose.yml", []byte(composeContent), 0644)
52		if err != nil {	76		if err != nil {
53	-	return err	77	+	return false, err
54		}	78		}
55			79
56		// Setup the TXT renderer for traefik.goyml	80		// Setup the TXT renderer for traefik.goyml
57		rendererTraefik, err := templating.GetTXTRenderer("traefik.goyml", modelFS, logger)	81		rendererTraefik, err := templating.GetTXTRenderer("traefik.goyml", modelFS, logger)
58		if err != nil {	82		if err != nil {
59	-	return err	83	+	return false, err
60		}	84		}
61			85
62		// Render the traefik.goyml with payload	86		// Render the traefik.goyml with payload

@@ -64,49 +88,85 @@ func CreateYAMLFiles(topDomain, adminEmail string, logger *utils.Logger) error {
64		"admin.email": adminEmail,	88		"admin.email": adminEmail,
65		})	89		})
66		if err != nil {	90		if err != nil {
67	-	return err	91	+	return false, err
68		}	92		}
69			93
70		// Save the rendered content to a file at the env path	94		// Save the rendered content to a file at the env path
71		err = os.WriteFile(path+"traefik/traefik.yml", []byte(traefikContent), 0644)	95		err = os.WriteFile(path+"traefik/traefik.yml", []byte(traefikContent), 0644)
72		if err != nil {	96		if err != nil {
73	-	return err	97	+	return false, err
74		}	98		}
75			99
			100	+	return true, nil
			101	+
			102	+	}
			103	+
			104	+	func deployTraefik(topDomain, adminEmail string, logger *utils.Logger) (bool, error) {
76		// Now that we have the YAML files, we can launch the containers	105		// Now that we have the YAML files, we can launch the containers
77		// Create acme.json with permissions 600	106		// Create acme.json with permissions 600
78		if f, err := os.Create(path + "traefik/volume/acme.json"); err != nil {	107		if f, err := os.Create(path + "traefik/volume/acme.json"); err != nil {
79	-	return err	108	+	return false, err
			109	+	} else if err = f.Chmod(0600); err != nil {
			110	+	return false, err
			111	+	} else {
			112	+	f.Close() // Schedule closing of the file when function exits
			113	+	}
			114	+
			115	+	// traefik.log
			116	+	if f, err := os.Create(path + "traefik/traefik.log"); err != nil {
			117	+	return false, err
80		} else if err = f.Chmod(0600); err != nil {	118		} else if err = f.Chmod(0600); err != nil {
81	-	return err	119	+	return false, err
82		} else {	120		} else {
83		f.Close() // Schedule closing of the file when function exits	121		f.Close() // Schedule closing of the file when function exits
84		}	122		}
85			123
			124	+	// check if docker is running
			125	+	if s, err := docker.CheckDockerRunning(); err != nil {
			126	+	return false, err
			127	+	} else if s {
			128	+	fmt.Println("Docker is running")
			129	+	} else {
			130	+	fmt.Println("Docker is not running")
			131	+	}
			132	+
			133	+	// check if a container named traefik already exists
			134	+	if exists, err := docker.ContainerExists("traefik"); err != nil {
			135	+	return false, err
			136	+	} else if exists {
			137	+	return false, errors.New("container traefik already exists")
			138	+	} else {
			139	+	fmt.Println("Container Traefik not found, creating it")
			140	+	}
			141	+
			142	+	// check if there is already a container named traefik
			143	+
86		// Create the network "exposed" if it doesn't exist	144		// Create the network "exposed" if it doesn't exist
87		// Ensure that the network "exposed" exists if not create it	145		// Ensure that the network "exposed" exists if not create it
88		exists, err := docker.NetworkExists("exposed")	146		exists, err := docker.NetworkExists("exposed")
89		if err != nil {	147		if err != nil {
90	-	return err	148	+	return false, err
91		}	149		}
92		if exists {	150		if exists {
93		fmt.Println("Network Exposed found")	151		fmt.Println("Network Exposed found")
94		} else {	152		} else {
95		fmt.Println("Network Exposed not found, creating it")	153		fmt.Println("Network Exposed not found, creating it")
96		if err := docker.CreateNetwork("exposed"); err != nil {	154		if err := docker.CreateNetwork("exposed"); err != nil {
97	-	return err	155	+	return false, err
98		}	156		}
99		}	157		}
100			158
101		fmt.Println("Network created successfully")	159		fmt.Println("Network created successfully")
102			160
103	-	// Create the containers with CreateContainerFromComposeFile	161	+	// Create the containers with CreateContainerFromComposeFile (bool, error)
104	-	if err := docker.CreateContainerFromComposeFile(path+"traefik/docker-compose.yml", logger); err != nil {	162	+	succes, err := docker.CreateContainerFromComposeFile(path+"traefik/docker-compose.yml", logger)
105	-	return err	163	+	if err != nil {
			164	+	return false, err
			165	+	}
			166	+	if succes {
			167	+	fmt.Println("Containers created successfully")
			168	+	return true, nil
106		}	169		}
107			170
108	-	fmt.Println("Containers created successfully")	171	+	return false, errors.New("failed to create containers")
109	-
110	-	return nil
111	-
112		}	172		}

M pkg/templating/models/traefik-compose.goyml +1 -1


@@ -11,7 +11,7 @@ services:
11	11		volumes:
12	12		- /var/run/docker.sock:/var/run/docker.sock:ro
13	13		- ./traefik.yml:/etc/traefik/traefik.yml
14		-	- ./traefik/volume/acme.json:/acme.json
	14	+	- ./volume/acme.json:/acme.json
15	15		- ./traefik.log:/var/log/traefik/traefik.log
16	16		labels:
17	17		- "traefik.enable=true"


@@ -11,7 +11,7 @@ services:
11		volumes:	11		volumes:
12		- /var/run/docker.sock:/var/run/docker.sock:ro	12		- /var/run/docker.sock:/var/run/docker.sock:ro
13		- ./traefik.yml:/etc/traefik/traefik.yml	13		- ./traefik.yml:/etc/traefik/traefik.yml
14	-	- ./traefik/volume/acme.json:/acme.json	14	+	- ./volume/acme.json:/acme.json
15		- ./traefik.log:/var/log/traefik/traefik.log	15		- ./traefik.log:/var/log/traefik/traefik.log
16		labels:	16		labels:
17		- "traefik.enable=true"	17		- "traefik.enable=true"