generate-scrolls.go

package main

import (
	"encoding/json"
	"fmt"
	"io/ioutil"
	"log"
	"os"
	"path/filepath"
	"strings"
	"text/template"
	"unicode"

	cp "github.com/otiai10/copy"

	"github.com/blang/semver"
)

type TemplateVars struct {
	Artifact           string
	Version            string
	VersionEscaped     string
	ColdstarterImage   string
	SteamImage         string
	Artifacts          map[string]string
	ArtifactsUnescaped map[string]string
	Vars               map[string]string
	Ports              []PortSpec
	ChunksYaml         string
}

type PortSpec struct {
	Name        string
	Port        string
	Protocol    string
	Description string
}

func main() {

	if len(os.Args) < 2 {
		fmt.Println("Please enter a path.")
		return
	}

	basepath := os.Args[1]
	buildPath := basepath + "/.build"
	artifactsPath := buildPath + "/artifacts.json"
	switchScrollDir := buildPath + "/scroll-switch"
	scrollYamlTemplate := buildPath + "/scroll.yaml.tmpl"
	varsFile := buildPath + "/vars.json"
	println("Path: " + buildPath)
	println("Artifacts Path: " + artifactsPath)
	println("Switch Scroll Dir: " + switchScrollDir)
	println("Scroll Yaml Template: " + scrollYamlTemplate)
	println("Vars File: " + varsFile)

	//parse vars json file, if exists
	vars := make(map[string]map[string]string)
	varsBytes, err := ioutil.ReadFile(varsFile)
	if err != nil {
		fmt.Printf("Error reading vars.json file. %s", err.Error())
	}

	if varsBytes != nil {
		json.Unmarshal(varsBytes, &vars)
	}

	//parse artifacs json file
	artifacts := make(map[string]string)
	artifactBytes, err := ioutil.ReadFile(artifactsPath)
	if err != nil {
		fmt.Printf("Error reading artifacts.json file. %s", err.Error())
		return
	}
	json.Unmarshal(artifactBytes, &artifacts)

	// Create template with custom functions
	funcMap := template.FuncMap{
		"split": func(sep, s string) []string {
			return strings.Split(s, sep)
		},
		"upper": strings.ToUpper,
		"env": func(value string) string {
			var out strings.Builder
			for i, r := range value {
				if i > 0 && unicode.IsUpper(r) {
					out.WriteByte('_')
				}
				if r == '-' || r == ' ' {
					out.WriteByte('_')
					continue
				}
				out.WriteRune(unicode.ToUpper(r))
			}
			return out.String()
		},
	}
	scollYamltemplate, err := template.New(filepath.Base(scrollYamlTemplate)).Funcs(funcMap).ParseFiles(scrollYamlTemplate)
	// Capture any error
	if err != nil {
		log.Fatalln(err)
	}
	coldstarterImage := os.Getenv("DRUID_COLDSTARTER_IMAGE")
	if coldstarterImage == "" {
		coldstarterImage = "artifacts.druid.gg/druid-team/druid:v0.1.249"
	}
	steamImage := os.Getenv("DRUID_STEAM_RUNTIME_IMAGE")
	if steamImage == "" {
		steamImage = "artifacts.druid.gg/druid-team/druid:v0.1.249-steamcmd"
	}

	//iterate through artifacts and generate scroll.yaml files
	for version, artifact := range artifacts {
		println("Generating scroll.yaml for " + artifact + " version " + version)
		var templateVars TemplateVars
		templateVars.Artifact = artifact
		templateVars.Version = version
		templateVars.VersionEscaped = strings.Replace(version, ".", "-", -1)
		templateVars.ColdstarterImage = coldstarterImage
		templateVars.SteamImage = steamImage
		templateVars.Artifacts = GetArtifactsAbove(version, artifacts, true)
		templateVars.ArtifactsUnescaped = GetArtifactsAbove(version, artifacts, false)
		if varsBytes != nil && vars[version] == nil {
			log.Println("No vars found for version " + version + " in vars.json file. Please add vars for this version.")
		} else {
			templateVars.Vars = vars[version]
		}
		templateVars.Ports = ParsePorts(templateVars.Vars["port"])

		chunksYaml, err := ioutil.ReadFile(filepath.Join(buildPath, "versions", version, "chunks.yaml"))
		if err == nil {
			templateVars.ChunksYaml = string(chunksYaml)
		} else if !os.IsNotExist(err) {
			log.Println("read chunks.yaml: ", err)
			return
		}

		//create scroll dir
		dir := filepath.Join(basepath, version)
		os.MkdirAll(dir, os.ModePerm)

		// Create a new file for the rendered output
		outputFile, err := os.Create(filepath.Join(dir, "scroll.yaml"))
		if err != nil {
			log.Println("create file: ", err)
			return
		}
		defer outputFile.Close()

		// Print out the template to std
		scollYamltemplate.Execute(outputFile, templateVars)

		cp.Copy(buildPath+"/data", dir+"/data")
		cp.Copy(buildPath+"/packet_handler", dir+"/packet_handler")

		cp.Copy(buildPath+"/update", dir+"/update")
		//copy metadata, this might copy nothing
		cp.Copy(buildPath+"/meta/"+version, dir+"/.meta")
		//copy version specific files
		cp.Copy(buildPath+"/versions/"+version, dir, cp.Options{
			OnDirExists: func(src, dest string) cp.DirExistsAction {
				return cp.Merge
			},
			Skip: func(info os.FileInfo, src, dest string) (bool, error) {
				return info.Name() == "chunks.yaml", nil
			},
		})

		//copy shell scripts
		cp.Copy(buildPath, dir, cp.Options{
			Skip: func(info os.FileInfo, src, dest string) (bool, error) {
				return !strings.HasSuffix(src, ".sh") || strings.HasPrefix(info.Name(), "_"), nil
			},
		})

		//render and copy switch scroll
		subitems, _ := ioutil.ReadDir(switchScrollDir)
		for _, subitem := range subitems {
			if !subitem.IsDir() {
				//just copy the files instead
				cp.Copy(filepath.Join(switchScrollDir, subitem.Name()), filepath.Join(dir, "scroll-switch", subitem.Name()))
				continue
			}
			filename := subitem.Name()
			switchSrollYaml := filepath.Join(switchScrollDir, filename, "scroll-switch.sh.tmpl")

			drdScrollName := strings.TrimSuffix(filename, "@version")
			println("Generating switch scroll for " + drdScrollName + " version " + version)

			filecontent, err := ioutil.ReadFile(switchSrollYaml)
			if err != nil {
				log.Fatalln(err)
			}

			for version, artifact := range GetArtifactsAbove(version, artifacts, false) {

				escapedVersion := strings.Replace(version, ".", "-", -1)

				switchScrollDir := filepath.Join(dir, "scroll-switch", drdScrollName+"@"+escapedVersion)

				os.MkdirAll(switchScrollDir, os.ModePerm)

				RenderScrollSwitch(switchScrollDir, "scroll-switch.sh", string(filecontent), artifact, version)
			}

		}

	}

}

func ParsePorts(spec string) []PortSpec {
	var ports []PortSpec
	for _, part := range strings.Split(spec, ";") {
		part = strings.TrimSpace(part)
		if part == "" {
			continue
		}
		name := part
		value := ""
		if strings.Contains(part, "=") {
			pieces := strings.SplitN(part, "=", 2)
			name = strings.TrimSpace(pieces[0])
			value = strings.TrimSpace(pieces[1])
		}
		if name == "" {
			continue
		}
		port := value
		protocol := "tcp"
		if strings.Contains(value, "/") {
			pieces := strings.SplitN(value, "/", 2)
			port = strings.TrimSpace(pieces[0])
			protocol = strings.TrimSpace(pieces[1])
		}
		if protocol == "" {
			protocol = "tcp"
		}
		ports = append(ports, PortSpec{
			Name:        name,
			Port:        port,
			Protocol:    protocol,
			Description: PortDescription(name),
		})
	}
	return ports
}

func PortDescription(name string) string {
	switch name {
	case "query":
		return "Steam Query Port. Use this to connect via the Steam client."
	case "main":
		return "Main game port. Use this port inside of your game client to connect to the server. Depending on the game you might need the query port to connect."
	default:
		return ""
	}
}

func RenderScrollSwitch(dir string, filename string, filecontent string, artifact string, version string) {

	escapedVersion := strings.Replace(version, ".", "-", -1)
	templateVars := TemplateVars{Artifact: artifact, Version: version, VersionEscaped: escapedVersion}
	RenderFile(dir, filename, filecontent, templateVars)
}

func RenderFolder(dir string, targetFolder string, data any) {
	// Create a new file for the rendered output
	outputFile, err := os.Create(filepath.Join(dir, targetFolder))
	if err != nil {
		log.Println("create file: ", err)
		return
	}
	defer outputFile.Close()

	templ, err := template.New(dir).Parse(string(targetFolder))
	// Capture any error
	if err != nil {
		log.Fatalln(err)
	}
	// Print out scroll switch template
	templ.Execute(outputFile, data)
}

func RenderFile(dir string, filename string, filecontent string, data any) {

	// Create a new file for the rendered output
	outputFile, err := os.Create(filepath.Join(dir, filename))
	if err != nil {
		log.Println("create file: ", err)
		return
	}
	defer outputFile.Close()

	templ, err := template.New(dir).Parse(string(filecontent))
	// Capture any error
	if err != nil {
		log.Fatalln(err)
	}
	// Print out scroll switch template
	templ.Execute(outputFile, data)
}

func GetArtifactsAbove(version string, artifacts map[string]string, escaped bool) map[string]string {

	artifactsAbove := make(map[string]string)
	for artifactVersion, artifact := range artifacts {

		aV := SafeParseVersion(artifactVersion)
		v := SafeParseVersion(version)
		fmt.Printf("aV %v v: %v \n", aV, v)

		if escaped {
			artifactVersion = strings.Replace(artifactVersion, ".", "-", -1)
		}

		if aV.GT(v) {
			artifactsAbove[artifactVersion] = artifact
		}
	}
	return artifactsAbove
}

func SafeParseVersion(version string) semver.Version {
	parts := strings.Split(version, ".")
	if len(parts) < 1 {
		log.Fatalln("Invalid version format " + version)
	}
	if len(parts) == 2 {
		version = version + ".0"
	}

	v, _ := semver.Parse(version)
	return v

}