epochcli/main.go

package main

import (
	"crypto/md5"
	"encoding/hex"
	"flag"
	"fmt"
	"io"
	"io/fs"
	"log"
	"net/http"
	"os"
	"os/exec"
	"path/filepath"
	"regexp"
	"strings"
)

const (
	manifestUrl      = "https://updater.project-epoch.net/api/v2/manifest"
	defaultWowPath   = "/path/to/wow"
	defaultLaunchCmd = "not configured"
)

func main() {
	outOfDate, err := needUpdate()
	if err != nil {
		log.Fatal(err)
	}

	if outOfDate {
		fmt.Println("There is a new version of epochcli, you must update before running")
		os.Exit(1)
	}

	var (
		helpFlag       bool
		updateOnlyFlag bool
		forceFlag      bool
		rerunConfig    bool
	)
	flag.BoolVar(&helpFlag, "h", false, "Print help")
	flag.BoolVar(&forceFlag, "f", false, "Forces epochcli to update files even if they match the current version")
	flag.BoolVar(&updateOnlyFlag, "u", false, "Ignore EnableLauncher setting in config and only runs an update. Does nothing if EnableLauncher is false")
	flag.BoolVar(&rerunConfig, "c", false, "Runs config configuration step. Overrides the config file")
	flag.Parse()

	if helpFlag {
		flag.CommandLine.SetOutput(os.Stdout)
		fmt.Println("Epochcli Help:")
		flag.PrintDefaults()
		os.Exit(0)
	}

	config, err := setupConfig(rerunConfig)
	if err != nil {
		log.Fatal(err)
	}

	if config.WowDir == defaultWowPath {
		log.Fatalf("WowDir in %s is still the default setting, exiting", cfgPath)
	}

	stats, err := downloadUpdate(config, forceFlag)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Printf("%d files updated\n\n", stats.updated)
	if stats.current > 0 {
		fmt.Printf("%d files are already up to date\n\n", stats.current)
	}

	if configRun {
		fmt.Println("Configuration complete!")
		os.Exit(0)
	}

	if updateOnlyFlag {
		os.Exit(0)
	}

	if config.EnableLauncher {
		if config.LaunchCmd == defaultLaunchCmd {
			log.Fatalf("LaunchCmd in %s is still the default setting, exiting\n", cfgPath)
		}

		fmt.Println("Starting Epoch...")
		var cmd = strings.Split(config.LaunchCmd, " ")
		ex := exec.Command(cmd[0], cmd[1:]...)
		cmdStr := strings.Join(cmd, " ")
		if config.WinePrefix != "" {
			prefix := fmt.Sprintf("WINEPREFIX=%s", config.WinePrefix)
			newEnv := append(os.Environ(), prefix)
			ex.Env = newEnv
			cmdStr = prefix + " " + cmdStr
		}
		fmt.Println("Running command:", cmdStr)
		err = ex.Run()
		if err != nil {
			log.Fatal(err)
		}
	}
}

type DownloadStats struct {
	updated int
	current int
}

func downloadUpdate(config *Config, force bool) (DownloadStats, error) {
	var stats DownloadStats

	manifest, err := getManifest()
	if err != nil {
		log.Fatalf("Failed to get manifest: %v\n", err)
	}

	for _, file := range manifest.Files {
		path := strings.ReplaceAll(file.Path, `\`, `/`)
		path = strings.TrimLeft(path, `\`)

		localPath := filepath.Join(config.WowDir, path)
		localDir := filepath.Dir(localPath)
		if _, err = os.Stat(localDir); os.IsNotExist(err) {
			err = os.MkdirAll(localDir, 0755)
			if err != nil {
				return stats, fmt.Errorf("failed to create directory %s: %v", localDir, err)
			}
		}

		if !force {
			if _, err = os.Stat(localPath); err == nil {
				data, err := os.ReadFile(localPath)
				if err != nil {
					return stats, err
				}
				hashBytes := md5.Sum(data)
				hash := hex.EncodeToString(hashBytes[:])
				if hash == file.Hash {
					fmt.Printf("File %s is up to date\n", localPath)
					stats.current += 1
					continue
				}
			}
		}

		fmt.Printf("Updating %s...\n", localPath)

		outFile, err := os.Create(localPath)
		if err != nil {
			return stats, err
		}

		for _, url := range []string{file.Urls.Cloudflare, file.Urls.Digitalocean, file.Urls.None} {
			resp, err := http.Get(url)
			if err != nil {
				outFile.Close()
				return stats, err
			}
			defer resp.Body.Close()
			if resp.StatusCode != http.StatusOK {
				outFile.Close()
				return stats, fmt.Errorf("failed to download update from %s, status code: %d", url, resp.StatusCode)
			}

			_, err = io.Copy(outFile, resp.Body)
			if err != nil {
				outFile.Close()
				return stats, err
			}

			break
		}

		outFile.Close()
		stats.updated += 1
	}

	if config.RemoveUnknownPatches {
		patches := make([]string, 0)
		patchreg := regexp.MustCompile(`patch-[A-Za-z].MPQ`)

		for _, file := range manifest.Files {
			if patchreg.MatchString(file.Path) {
				patches = append(patches, strings.Split(file.Path, "Data\\")[1])
			}
		}

		err = filepath.WalkDir(filepath.Join(config.WowDir, "Data"), func(path string, d fs.DirEntry, err error) error {
			if !d.IsDir() && patchreg.MatchString(d.Name()) {
				del := true
				for _, patch := range patches {
					if patch == d.Name() {
						del = false
						break
					}
				}
				if del {
					err = os.Remove(path)
					if err != nil {
						return err
					}
					fmt.Println("Removed unknown patch", d.Name())
				}
			}
			return nil
		})

		if err != nil {
			log.Fatalf("failed to delete unknown patches: %s", err)
		}
	}

	return stats, nil
}