services/magefiles/prepare.go

//go:build mage

package main

import (
	"fmt"
	"io"
	"io/fs"
	"log"
	"os"
	"path/filepath"
	"strings"
	"text/template"

	"github.com/magefile/mage/mg"
)

// Prepare prepares the service's build directory.
func Prepare(service string) error {
	cfg, err := newConfig(configFile)
	if err != nil {
		return fmt.Errorf("unable to load the configuration; %v", err)
	}

	if service == "all" {
		objects, err := os.ReadDir(rootTemplatesDir)
		if err != nil {
			return fmt.Errorf("unable to read the templates directory; %w", err)
		}

		for _, o := range objects {
			if !o.IsDir() {
				continue
			}

			service := o.Name()

			buildDir := filepath.Join(rootBuildDir, service)

			if _, err := os.Stat(buildDir); err != nil {
				if err := os.Mkdir(buildDir, 0o700); err != nil {
					return fmt.Errorf("unable to make %s; %w", buildDir, err)
				}
			}

			if service != "compose" {
				mg.Deps(
					mg.F(Download, service),
				)

				log.Printf("Copying assets for %s.\n", service)
				if err := copyAssets(service); err != nil {
					return fmt.Errorf("unable to copy the assets for %s; %w", service, err)
				}
			}

			log.Printf("Rendering templates for %s.\n", service)
			if err := render(cfg, service); err != nil {
				return fmt.Errorf("unable to render templates for %s; %w", service, err)
			}

		}
	} else {
		buildDir := filepath.Join(rootBuildDir, service)

		if _, err := os.Stat(buildDir); err != nil {
			if err := os.Mkdir(buildDir, 0o700); err != nil {
				return fmt.Errorf("unable to make %s; %w", buildDir, err)
			}
		}

		if service != "compose" {
			mg.Deps(
				mg.F(Download, service),
				mg.F(Prepare, "compose"),
			)

			log.Printf("Copying assets for %s.\n", service)
			if err := copyAssets(service); err != nil {
				return fmt.Errorf("unable to copy the assets for %s; %w", service, err)
			}
		}

		if err := render(cfg, service); err != nil {
			return fmt.Errorf("an error occurred whilst rendering the templates; %w", err)
		}

	}

	return nil
}

func render(cfg config, component string) error {
	buildDirName := filepath.Join(rootBuildDir, component)

	templateDirName := filepath.Join(rootTemplatesDir, component)

	files, err := os.ReadDir(templateDirName)
	if err != nil {
		return fmt.Errorf("unable to read files from %s; %w ", templateDirName, err)
	}

	for _, f := range files {
		err := func() error {
			templateFilename := f.Name()

			if f.IsDir() || !strings.HasSuffix(templateFilename, templateExtension) {
				return nil
			}

			outputFilename := strings.TrimSuffix(templateFilename, templateExtension)
			outputPath := filepath.Join(buildDirName, outputFilename)

			file, err := os.Create(outputPath)
			if err != nil {
				return fmt.Errorf("unable to create the file '%s'; %w", outputPath, err)
			}
			defer file.Close()

			templatePath := filepath.Join(templateDirName, templateFilename)
			tmpl, err := template.New(templateFilename).ParseFiles(templatePath)
			if err != nil {
				return fmt.Errorf("unable to create a new template value from '%s'; %w", templateFilename, err)
			}

			if err = tmpl.Execute(file, cfg); err != nil {
				return fmt.Errorf("unable to render the template to '%s'; %w", outputPath, err)
			}

			return nil
		}()
		if err != nil {
			return fmt.Errorf("an error occurred whilst rendering the templates for '%s'; %w", component, err)
		}
	}

	return nil
}

func copyAssets(service string) error {
	assetsDirName := filepath.Join(rootAssetsDir, service)
	if _, err := os.Stat(assetsDirName); err != nil {
		log.Printf("There's no assets directory for %s.\n", service)
		return nil
	}

	buildDirName := filepath.Join(rootBuildDir, service, "assets")

	walkDirFunc := func(path string, d fs.DirEntry, err error) error {
		if err != nil {
			return err
		}

		if path == assetsDirName {
			return nil
		}

		buildAssetPath := filepath.Join(buildDirName, strings.TrimPrefix(path, assetsDirName))

		if d.IsDir() {
			if err := os.MkdirAll(buildAssetPath, 0o750); err != nil {
				return fmt.Errorf("unable to make %s; %w", path, err)
			}

			return nil
		}

		source, err := os.Open(path)
		if err != nil {
			return err
		}
		defer source.Close()

		dest, err := os.Create(buildAssetPath)
		if err != nil {
			return err
		}
		defer dest.Close()

		if _, err := io.Copy(dest, source); err != nil {
			return err
		}

		return nil
	}

	err := filepath.WalkDir(assetsDirName, walkDirFunc)
	if err != nil {
		return fmt.Errorf("error walking the path '%s'; %w", assetsDirName, err)
	}

	return nil
}