feat: add alias command

cmd/cmd.go

@@ -0,0 +1,484 @@
+package cmd
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+
+	"gitea.antoine-langlois.net/datahearth/doggo-fetcher/pkg"
+	"github.com/sirupsen/logrus"
+	"github.com/urfave/cli/v2"
+)
+
+var (
+	dgfFolder = strings.ReplaceAll("~/.local/doggofetcher", "~", os.Getenv("HOME"))
+	hashFile  = filepath.Join(dgfFolder, "hash.txt")
+	aliasFile = filepath.Join(dgfFolder, "alias.txt")
+	re        = regexp.MustCompile(`\d*\.?\d*\.?\d(rc|beta)?\d*?`)
+	Logger    = &logrus.Logger{
+		Out:       os.Stdout,
+		Formatter: new(pkg.LoggerFormatter),
+		Hooks:     make(logrus.LevelHooks),
+		Level:     logrus.InfoLevel,
+	}
+	app = &cli.App{
+		Name:  "doggo-fetcher",
+		Usage: "I bring you your latest GoLang release with ease and efficiency (like a stick) !",
+		Description: `Doggo-fetcher is a utility tool that manage for you your installed GoLang releases.
+You can select a specific GoLang release or even set a specific one for directories.`,
+		EnableBashCompletion: true,
+		Authors: []*cli.Author{
+			{
+				Name:  "Antoine <DataHearth> Langlois",
+				Email: "antoine.l@antoine-langlois.net",
+			},
+		},
+		Suggest: true,
+		Version: "0.1.0",
+		Commands: []*cli.Command{
+			{
+				Name:  "use",
+				Usage: "Set a specific golang version",
+				Description: `Use a specific golang version as primary golang binary for the user.
+If the version is not already downloaded, it'll downloaded and installed automatically.`,
+				Flags: []cli.Flag{
+					&cli.BoolFlag{
+						Name:    "latest",
+						Aliases: []string{"lts"},
+						Usage:   "Use latest release",
+					},
+					&cli.BoolFlag{
+						Name:  "rc",
+						Usage: "Allow \"rc\" version to be fetched",
+					},
+					&cli.BoolFlag{
+						Name:  "beta",
+						Usage: "Allow \"beta\" version to be fetched",
+					},
+				},
+				Action: use,
+			},
+			{
+				Name:  "init",
+				Usage: "Initialize doggofetcher",
+				Description: `Initialize doggofetcher by adding a custom path inside your sheel configuration file.
+It also creates a folder at "~/.local/doggofetcher" to store your custom golang binaries.`,
+				Action: initFunc,
+			},
+			{
+				Name:  "uninstall",
+				Usage: "Uninstall golang release",
+				Description: `Uninstall current golang release.
+It will remove the folder at "~/.local/doggofetcher/go"`,
+				Action: uninstall,
+			},
+			{
+				Name:  "ls",
+				Usage: "List available releases",
+				Description: `List available releases.
+It will list all available releases in the "~/.local/doggofetcher/go*" folder.`,
+				Action: ls,
+			},
+			{
+				Name:  "remove",
+				Usage: "Remove one or more releases",
+				Description: `Remove one or more releases.
+Release(s) folder will be removed from "~/.local/doggofetcher" and thus not available.`,
+				Action: remove,
+				Flags: []cli.Flag{
+					&cli.BoolFlag{
+						Name:    "all",
+						Aliases: []string{"a"},
+						Usage:   "Remove all releases",
+					},
+				},
+			},
+			{
+				Name:   "exec",
+				Usage:  "Execute a go command",
+				Action: execCommand,
+			},
+			{
+				Name:  "ls-remote",
+				Usage: "List all remote references",
+				Flags: []cli.Flag{
+					&cli.BoolFlag{
+						Name:  "rc",
+						Usage: "Allow \"rc\" version to be fetched",
+					},
+					&cli.BoolFlag{
+						Name:  "beta",
+						Usage: "Allow \"beta\" version to be fetched",
+					},
+				},
+				Action: lsRemote,
+			},
+			{
+				Name:   "alias",
+				Usage:  "Set an alias for a GoLang version",
+				Action: alias,
+				Flags: []cli.Flag{
+					&cli.BoolFlag{
+						Name:    "list",
+						Aliases: []string{"l"},
+						Usage:   "List all set alias and their version",
+					},
+					&cli.StringFlag{
+						Name:  "get",
+						Usage: "Get a version for a given alias",
+					},
+					&cli.StringSliceFlag{
+						Name:  "rename",
+						Usage: "Rename an already existing alias",
+						Value: nil,
+					},
+				},
+			},
+		},
+		Flags: []cli.Flag{
+			&cli.BoolFlag{Name: "verbose", Aliases: []string{"v"}, Usage: "Enable verbose mode"},
+		},
+	}
+)
+
+// todo: alias (set alias for a release)
+
+func Execute() error {
+	cli.VersionFlag = &cli.BoolFlag{
+		Name:    "version",
+		Aliases: []string{"V"},
+		Usage:   "print the version",
+	}
+
+	return app.Run(os.Args)
+}
+
+func use(ctx *cli.Context) error {
+	if err := checkInitialized(); err != nil {
+		return err
+	}
+
+	if ctx.Bool("verbose") {
+		Logger.Level = logrus.DebugLevel
+	}
+
+	alias, err := pkg.NewAlias(aliasFile)
+	if err != nil {
+		return err
+	}
+
+	var release string
+	if ctx.NArg() == 0 {
+		if !ctx.Bool("latest") {
+			return errors.New("a release is required if \"--latest|--lts\" is not passed")
+		}
+		release = pkg.LTS
+	} else {
+		release = ctx.Args().First()
+		if !re.Match([]byte(release)) {
+			release = alias.GetAliasVersion(release)
+			if release == "" {
+				return fmt.Errorf("release doesn't match \"%s\" format nor is an existing alias", re.String())
+			}
+		}
+	}
+
+	release, err = pkg.NewTags(release, ctx.Context).GetRelease(ctx.Bool("beta"), ctx.Bool("rc"))
+	if err != nil {
+		return err
+	}
+
+	hash, err := pkg.NewHash(hashFile)
+	if err != nil {
+		return err
+	}
+	r := pkg.NewRelease(release, filepath.Join(dgfFolder, release))
+
+	if err := r.CheckReleaseExists(); err != nil {
+		if err != pkg.ErrReleaseNotFound {
+			return err
+		}
+
+		Logger.Info("Release not found, downloading...")
+		if err := r.DownloadRelease(); err != nil {
+			return err
+		}
+
+		Logger.Info("Release downloaded, installing...")
+		if err := r.ExtractRelease(); err != nil {
+			return err
+		}
+
+		Logger.Debug("Release installed, generating hash...")
+		h, err := hash.GetFolderHash(r.GetReleaseFolder())
+		if err != nil {
+			return err
+		}
+		if err := hash.AddHash(r.GetReleaseFolder(), h); err != nil {
+			return err
+		}
+	} else {
+		Logger.Debug("Release found, checking hash...")
+		h, err := hash.GetFolderHash(r.GetReleaseFolder())
+		if err != nil {
+			return err
+		}
+
+		if err := hash.CompareReleaseHash(r.GetReleaseFolder(), h); err != nil {
+			if err == pkg.ErrHashNotFound {
+				Logger.Warnln("Hash not found in hash table, adding...")
+				if err := hash.AddHash(r.GetReleaseFolder(), h); err != nil {
+					return err
+				}
+			} else if err == pkg.ErrHashInvalid {
+				Logger.Warnln("Hash invalid, replacing...")
+				if err := hash.ReplaceHash(r.GetReleaseFolder(), h); err != nil {
+					return err
+				}
+			} else {
+				return err
+			}
+		}
+	}
+
+	Logger.Info("Setting golang binary")
+	if err := pkg.UpdateRelease(filepath.Join(dgfFolder, "go"), r.GetReleaseFolder()); err != nil {
+		return err
+	}
+
+	Logger.Info("Everything done!")
+	return nil
+}
+
+func initFunc(ctx *cli.Context) error {
+	if ctx.Bool("verbose") {
+		Logger.Level = logrus.DebugLevel
+	}
+
+	Logger.WithField("folder", dgfFolder).Infoln("Initializing doggofetcher folder")
+
+	if err := os.MkdirAll(dgfFolder, 0755); err != nil {
+		return err
+	}
+	f, err := os.Create(hashFile)
+	if err != nil {
+		return err
+	}
+	f.Close()
+
+	f, err = os.Create(aliasFile)
+	if err != nil {
+		return err
+	}
+	f.Close()
+
+	Logger.Infoln("Add doggofetcher to your shell configuration file with the following command:")
+	fmt.Fprintln(os.Stdout, "\n# doggofetcher section")
+	fmt.Fprintf(os.Stdout, "export PATH=%s:$PATH\n", filepath.Join(dgfFolder, "go", "bin"))
+
+	return nil
+}
+
+// todo:
+func uninstall(ctx *cli.Context) error {
+	return os.RemoveAll(filepath.Join(dgfFolder, "go"))
+}
+
+func ls(ctx *cli.Context) error {
+	if err := checkInitialized(); err != nil {
+		return err
+	}
+
+	if ctx.Bool("verbose") {
+		Logger.Level = logrus.DebugLevel
+	}
+
+	items, err := os.ReadDir(dgfFolder)
+	if err != nil {
+		return err
+	}
+
+	for _, i := range items {
+		if i.IsDir() && i.Name() != "go" {
+			fmt.Println(i.Name())
+		}
+	}
+
+	return nil
+}
+
+func remove(ctx *cli.Context) error {
+	if err := checkInitialized(); err != nil {
+		return err
+	}
+
+	if ctx.Bool("verbose") {
+		Logger.Level = logrus.DebugLevel
+	}
+
+	if !ctx.Bool("all") {
+		if ctx.NArg() == 0 {
+			return errors.New("a release is required")
+		}
+		release := ctx.Args().First()
+		if !re.Match([]byte(release)) {
+			return errors.New("release doesn't match \"\\d*\\.?\\d*\\.?\\d(rc|beta)?\\d*?\" format")
+		}
+		hash, err := pkg.NewHash(dgfFolder)
+		if err != nil {
+			return err
+		}
+
+		if err := os.RemoveAll(filepath.Join(dgfFolder, fmt.Sprintf("go%s", release))); err != nil {
+			return fmt.Errorf("could not remove release %s: %s", release, err)
+		}
+
+		if err := hash.RemoveHash(fmt.Sprintf("%s/go%s", dgfFolder, release)); err != nil {
+			return err
+		}
+
+		if strings.Contains(runtime.Version(), ctx.Args().First()) {
+			Logger.Infoln("Removing installed version...")
+			if err := os.RemoveAll(filepath.Join(dgfFolder, "go")); err != nil {
+				return fmt.Errorf("could not remove installed release %s: %s", release, err)
+			}
+		}
+
+		Logger.Info("Release removed")
+		return nil
+	}
+
+	entries, err := os.ReadDir(dgfFolder)
+	if err != nil {
+		return fmt.Errorf("could not read local folder: %s", err)
+	}
+
+	hash, err := pkg.NewHash(dgfFolder)
+	if err != nil {
+		return err
+	}
+
+	for _, f := range entries {
+		if !f.IsDir() {
+			continue
+		}
+
+		if strings.Contains(f.Name(), "go") && f.Name() != "go" {
+			folderPath := filepath.Join(dgfFolder, f.Name())
+			if err := os.RemoveAll(folderPath); err != nil {
+				return fmt.Errorf("could not remove %s: %s", folderPath, err)
+			}
+			if err := hash.RemoveHash(folderPath); err != nil {
+				return err
+			}
+		}
+	}
+
+	Logger.Infoln("Removing installed version...")
+	if err := os.RemoveAll(filepath.Join(dgfFolder, "go")); err != nil {
+		return fmt.Errorf("could not remove installed release: %s", err)
+	}
+
+	Logger.Info("All releases removed")
+	return nil
+}
+
+func execCommand(ctx *cli.Context) error {
+	if err := checkInitialized(); err != nil {
+		return err
+	}
+
+	if ctx.Bool("verbose") {
+		Logger.Level = logrus.DebugLevel
+	}
+
+	if ctx.NArg() == 0 {
+		return errors.New("a release is required")
+	}
+
+	release := ctx.Args().First()
+	if !re.Match([]byte(release)) {
+		return errors.New("release doesn't match \"\\d*\\.?\\d*\\.?\\d(rc|beta)?\\d*?\" format")
+	}
+
+	cmd := exec.Command(filepath.Join(dgfFolder, fmt.Sprintf("go%s", release), "bin", "go"), ctx.Args().Tail()...)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+
+	return cmd.Run()
+}
+
+func lsRemote(ctx *cli.Context) error {
+	refs, err := pkg.NewTags("", ctx.Context).GetTagsRef()
+	if err != nil {
+		return err
+	}
+
+	for _, r := range refs {
+		ref := r.GetRef()
+		if (!ctx.Bool("rc") && strings.Contains(ref, "rc")) || (!ctx.Bool("beta") && strings.Contains(ref, "beta")) {
+			continue
+		}
+
+		fmt.Println(strings.ReplaceAll(strings.Split(ref, "/")[2], "go", ""))
+	}
+
+	return nil
+}
+
+func alias(ctx *cli.Context) error {
+	if err := checkInitialized(); err != nil {
+		return err
+	}
+
+	alias, err := pkg.NewAlias(aliasFile)
+	if err != nil {
+		return err
+	}
+	if ctx.Bool("list") {
+		for a, v := range alias.GetAllAlias() {
+			fmt.Printf("alias: %s | version: %s\n", a, v)
+		}
+		return nil
+	} else if a := ctx.String("get"); a != "" {
+		fmt.Printf("alias: %s | version: %s\n", a, alias.GetAliasVersion(a))
+		return nil
+	} else if values := ctx.StringSlice("rename"); len(values) != 0 {
+		if len(values) != 2 {
+			return errors.New("rename takes 2 parameters")
+		}
+
+		if err := alias.RenameAlias(ctx.Args().Get(0), ctx.Args().Get(1)); err != nil {
+			return err
+		}
+	} else {
+		if ctx.NArg() != 2 {
+			return errors.New("an alias needs an alias name and a golang version")
+		}
+
+		alias.SetAlias(ctx.Args().Get(0), ctx.Args().Get(1))
+	}
+
+	return alias.WriteAliasFile()
+}
+
+func checkInitialized() error {
+	fi, err := os.Stat(dgfFolder)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return fmt.Errorf("\"%s\" not initialized. Initialize it with \"doggo-fetcher init\"", dgfFolder)
+		}
+
+		return err
+	}
+	if !fi.IsDir() {
+		return fmt.Errorf("\"%s\" is not a directory", dgfFolder)
+	}
+
+	return nil
+}

cmd/main.go

@@ -1,81 +0,0 @@
-package main
-
-import (
-	"errors"
-	"fmt"
-	"os"
-
-	"github.com/datahearth/doggo-fetcher/pkg"
-	"github.com/urfave/cli/v2"
-)
-
-var app = &cli.App{
-	Name:  "dg",
-	Usage: "I bring you your latest Golang version with ease and efficiency (like a stick) !",
-	Description: `Doggo-fetcher is a utility tool that manage for you your Golang version.
-You can select a specific go version or even set version for directories.`,
-	EnableBashCompletion: true,
-	Authors: []*cli.Author{{
-		Name:  "Antoine <DataHearth> Langlois",
-		Email: "antoine.l@antoine-langlois.net",
-	}},
-	Suggest: true,
-	Version: "0.1.0",
-	Commands: []*cli.Command{
-		{
-			Name:        "install",
-			Usage:       "Download a given release",
-			Description: "Download a given release and set it as first release to be use",
-			Flags: []cli.Flag{
-				&cli.BoolFlag{
-					Name:  "keep-release",
-					Usage: "Downloaded release archive will be stored",
-				},
-				&cli.BoolFlag{
-					Name:    "latest",
-					Aliases: []string{"lts"},
-					Usage:   "Download and install the latest release",
-				},
-				&cli.BoolFlag{
-					Name:  "rc",
-					Usage: "Allow \"rc\" version to be fetched",
-				},
-				&cli.BoolFlag{
-					Name:  "beta",
-					Usage: "Allow \"beta\" version to be fetched",
-				},
-			},
-			Action: func(ctx *cli.Context) error {
-				var release string
-				if ctx.NArg() == 0 {
-					if !ctx.Bool("latest") {
-						return errors.New("a release is required if \"--latest\" is not passed")
-					}
-					release = "lts"
-				} else {
-					release = ctx.Args().First()
-				}
-
-				ghTags := pkg.NewTags(release, ctx.Context)
-				release, err := ghTags.CheckReleaseExists(ctx.Bool("beta"), ctx.Bool("rc"))
-				if err != nil {
-					return err
-				}
-
-				fmt.Printf("release: %v\n", release)
-
-				return nil
-			},
-		},
-	},
-	Action: func(c *cli.Context) error {
-		fmt.Println("Hello friend!")
-		return nil
-	},
-}
-
-func main() {
-	if err := app.Run(os.Args); err != nil {
-		fmt.Println(err)
-	}
-}

doggo-fetcher.go

@@ -1 +0,0 @@
-package doggofetcher

go.mod

@@ -1,14 +1,22 @@
-module github.com/datahearth/doggo-fetcher
+module gitea.antoine-langlois.net/datahearth/doggo-fetcher
 
 go 1.18
 
-require github.com/urfave/cli/v2 v2.8.1
+require (
+	github.com/briandowns/spinner v1.18.1
+	github.com/google/go-github/v45 v45.1.0
+	github.com/sirupsen/logrus v1.9.0
+	github.com/urfave/cli/v2 v2.8.1
+)
 
 require (
 	github.com/cpuguy83/go-md2man/v2 v2.0.1 // indirect
-	github.com/google/go-github/v45 v45.1.0 // indirect
+	github.com/fatih/color v1.7.0 // indirect
 	github.com/google/go-querystring v1.1.0 // indirect
+	github.com/mattn/go-colorable v0.1.2 // indirect
+	github.com/mattn/go-isatty v0.0.8 // indirect
 	github.com/russross/blackfriday/v2 v2.1.0 // indirect
 	github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 // indirect
 	golang.org/x/crypto v0.0.0-20210817164053-32db794688a5 // indirect
+	golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8 // indirect
 )

go.sum

@@ -1,16 +1,41 @@
+github.com/briandowns/spinner v1.18.1 h1:yhQmQtM1zsqFsouh09Bk/jCjd50pC3EOGsh28gLVvwY=
+github.com/briandowns/spinner v1.18.1/go.mod h1:mQak9GHqbspjC/5iUx3qMlIho8xBS/ppAL/hX5SmPJU=
 github.com/cpuguy83/go-md2man/v2 v2.0.1 h1:r/myEWzV9lfsM1tFLgDyu0atFtJ1fXn261LKYj/3DxU=
 github.com/cpuguy83/go-md2man/v2 v2.0.1/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/fatih/color v1.7.0 h1:DkWD4oS2D8LGGgTQ6IvwJJXSL5Vp2ffcQg58nFV38Ys=
+github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
 github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.8 h1:e6P7q2lk1O+qJJb4BtCQXlK8vWEO8V1ZeuEdJNOqZyg=
 github.com/google/go-github/v45 v45.1.0 h1:SbUjHMRiCe9cHfu6Me4idWxLQEV8ZW9DLPz69zopyWo=
 github.com/google/go-github/v45 v45.1.0/go.mod h1:FObaZJEDSTa/WGCzZ2Z3eoCDXWJKMenWWTrd8jrta28=
 github.com/google/go-querystring v1.1.0 h1:AnCroh3fv4ZBgVIf1Iwtovgjaw/GiKJo8M8yD/fhyJ8=
 github.com/google/go-querystring v1.1.0/go.mod h1:Kcdr2DB4koayq7X8pmAG4sNG59So17icRSOU623lUBU=
+github.com/mattn/go-colorable v0.1.2 h1:/bC9yWikZXAL9uJdulbSfyVNIR3n3trXl+v8+1sx8mU=
+github.com/mattn/go-colorable v0.1.2/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
+github.com/mattn/go-isatty v0.0.8 h1:HLtExJ+uU2HOZ+wI0Tt5DtUDrx8yhUqDcp7fYERX4CE=
+github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
+github.com/sirupsen/logrus v1.9.0 h1:trlNQbNUG3OdDrDil03MCb1H2o9nJ1x4/5LYw7byDE0=
+github.com/sirupsen/logrus v1.9.0/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/urfave/cli/v2 v2.8.1 h1:CGuYNZF9IKZY/rfBe3lJpccSoIY1ytfvmgQT90cNOl4=
 github.com/urfave/cli/v2 v2.8.1/go.mod h1:Z41J9TPoffeoqP0Iza0YbAhGvymRdZAd2uPmZ5JxRdY=
 github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 h1:bAn7/zixMGCfxrRTfdpNzjtPYqr8smhKouy9mxVdGPU=
 github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673/go.mod h1:N3UwUGtsrSj3ccvlPHLoLsHnpR27oXr4ZE984MbSER8=
 golang.org/x/crypto v0.0.0-20210817164053-32db794688a5 h1:HWj/xjIHfjYU5nVXpTM0s39J9CbLn7Cc5a7IC5rwsMQ=
 golang.org/x/crypto v0.0.0-20210817164053-32db794688a5/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
+golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8 h1:0A+M6Uqn+Eje4kHMK80dtF3JCXC4ykBgQG4Fe06QRhQ=
+golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

main.go

@@ -0,0 +1,9 @@
+package main
+
+import "gitea.antoine-langlois.net/datahearth/doggo-fetcher/cmd"
+
+func main() {
+	if err := cmd.Execute(); err != nil {
+		cmd.Logger.Errorln(err)
+	}
+}

pkg/alias.go

@@ -0,0 +1,96 @@
+package pkg
+
+import (
+	"bufio"
+	"errors"
+	"fmt"
+	"os"
+	"strings"
+)
+
+type Alias struct {
+	file    string
+	aliases map[string]string
+}
+
+type Aliaser interface {
+	GetAliasVersion(alias string) string
+	GetAllAlias() map[string]string
+	SetAlias(alias, version string)
+	RenameAlias(old, new string) error
+	WriteAliasFile() error
+}
+
+func NewAlias(path string) (Aliaser, error) {
+	f, err := os.Open(path)
+	if err != nil {
+		return nil, err
+	}
+
+	alias := make(map[string]string)
+	sc := bufio.NewScanner(f)
+	for sc.Scan() {
+		splittedLine := strings.Split(sc.Text(), " ")
+		if len(splittedLine) != 2 {
+			return nil, errors.New("alias file malformatted")
+		}
+		if splittedLine[1] == "" {
+			continue
+		}
+
+		alias[splittedLine[0]] = splittedLine[1]
+	}
+
+	return &Alias{
+		file:    path,
+		aliases: alias,
+	}, nil
+}
+
+func (a *Alias) GetAliasVersion(alias string) string {
+	if v, ok := a.aliases[alias]; !ok {
+		return ""
+	} else {
+		return v
+	}
+}
+
+func (a *Alias) GetAllAlias() map[string]string {
+	return a.aliases
+}
+
+func (a *Alias) SetAlias(alias, version string) {
+	a.aliases[alias] = strings.ReplaceAll(version, "go", "")
+}
+
+func (a *Alias) WriteAliasFile() error {
+	f, err := os.OpenFile(a.file, os.O_WRONLY|os.O_TRUNC, 06664)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	d := []byte{}
+	for k, v := range a.aliases {
+		d = append(d, []byte(fmt.Sprintf("%s %s", k, v))...)
+	}
+
+	if _, err := f.Write(d); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (a *Alias) RenameAlias(old, new string) error {
+	if _, ok := a.aliases[old]; !ok {
+		return fmt.Errorf("\"%s\" isn't an alias", old)
+	}
+
+	version := a.aliases[old]
+	a.aliases[new] = version
+
+	delete(a.aliases, old)
+
+	return nil
+}

pkg/download.go

@@ -1,4 +0,0 @@
-package pkg
-
-const GO_DL_SERVER = "https://dl.google.com/go"
-

pkg/hash.go

@@ -0,0 +1,156 @@
+package pkg
+
+import (
+	"bufio"
+	"crypto/sha256"
+	"encoding/hex"
+	"fmt"
+	"io"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+type HashActions interface {
+	GetFolderHash(path string) (string, error)
+	CompareReleaseHash(path string, hash string) error
+	AddHash(path, hash string) error
+	ReplaceHash(path, hash string) error
+	RemoveHash(path string) error
+	writeHashTable() error
+}
+
+type Hash struct {
+	hashTable map[string]string
+	hashFile  string
+}
+
+// NewHash returns a new Hash object. It reads the hashes from the ~/.local/doggofetcher/hashes.txt file then loads
+// them into the hash table.
+func NewHash(hashFile string) (HashActions, error) {
+	f, err := os.Open(hashFile)
+	if err != nil {
+		return &Hash{}, err
+	}
+	defer f.Close()
+
+	hashTable := make(map[string]string)
+	sc := bufio.NewScanner(f)
+	for sc.Scan() {
+		l := strings.Split(sc.Text(), " ")
+		hashTable[l[0]] = l[1]
+	}
+
+	return &Hash{
+		hashTable: hashTable,
+		hashFile:  hashFile,
+	}, nil
+}
+
+// GetFolderHash returns the hash of the folder by using the Merkle tree.
+func (h *Hash) GetFolderHash(path string) (string, error) {
+	hashes := [][]byte{}
+	err := filepath.WalkDir(path, func(path string, d fs.DirEntry, err error) error {
+		if err != nil {
+			return err
+		}
+
+		if !d.Type().IsRegular() {
+			return nil
+		}
+		if d.IsDir() {
+			hash, err := h.GetFolderHash(path)
+			if err != nil {
+				return err
+			}
+
+			hashes = append(hashes, []byte(hash))
+			return nil
+		}
+
+		f, err := os.Open(path)
+		if err != nil {
+			return err
+		}
+		defer f.Close()
+
+		sha := sha256.New()
+		buf := make([]byte, 10*1024)
+		for {
+			n, err := f.Read(buf)
+			if err != nil {
+				if err == io.EOF {
+					break
+				}
+				return err
+			}
+
+			sha.Write(buf[:n])
+		}
+
+		hashes = append(hashes, sha.Sum(nil))
+		return nil
+	})
+	if err != nil {
+		return "", err
+	}
+
+	sha := sha256.New()
+	for _, h := range hashes {
+		if _, err := sha.Write(h); err != nil {
+			return "", err
+		}
+	}
+
+	return hex.EncodeToString(sha.Sum(nil)), nil
+}
+
+// CompareReleaseHash compares the hash of the release with the hash in the hash table.
+func (h *Hash) CompareReleaseHash(path, hash string) error {
+	if h, ok := h.hashTable[path]; !ok {
+		return ErrHashNotFound
+	} else if h != hash {
+		return ErrHashInvalid
+	} else {
+		return nil
+	}
+}
+
+// AddHash adds a hash to the hash table by writing the "hashTable" property and the file.
+func (h *Hash) AddHash(path, hash string) error {
+	h.hashTable[path] = hash
+
+	return h.writeHashTable()
+}
+
+// ReplaceHash replaces the hash in the hash table with the new hash.
+func (h *Hash) ReplaceHash(path, hash string) error {
+	h.hashTable[path] = hash
+
+	return h.writeHashTable()
+}
+
+// RemoveHash removes a hash from the hash table.
+func (h *Hash) RemoveHash(path string) error {
+	delete(h.hashTable, path)
+
+	return h.writeHashTable()
+}
+
+// writeHashTable writes the hash table to the file with the given data.
+func (h *Hash) writeHashTable() error {
+	start := true
+	var data []byte
+	for path, hash := range h.hashTable {
+		if start {
+			start = false
+		} else {
+			data = append(data, []byte("\n")...)
+		}
+
+		data = append(data, []byte(fmt.Sprintf("%s %s", path, hash))...)
+	}
+
+	return os.WriteFile(h.hashFile, data, 0644)
+}

pkg/logger.go

@@ -0,0 +1,74 @@
+package pkg
+
+import (
+	"fmt"
+
+	"github.com/sirupsen/logrus"
+)
+
+const (
+	red    = 31
+	yellow = 33
+	blue   = 36
+	gray   = 37
+)
+
+const (
+	PanicLevel logrus.Level = iota
+	FatalLevel
+	ErrorLevel
+	WarnLevel
+	InfoLevel
+	DebugLevel
+	TraceLevel
+)
+
+type LoggerFormatter struct{}
+
+func (f *LoggerFormatter) Format(e *logrus.Entry) ([]byte, error) {
+	msg := f.printColored(e)
+
+	if len(e.Data) != 0 {
+		for k, v := range e.Data {
+			msg = fmt.Sprintf("%s %s=%v", msg, k, v)
+		}
+
+		msg = fmt.Sprintf("%s message='%s'\n", msg, e.Message)
+	} else {
+		msg = fmt.Sprintf("%s %s\n", msg, e.Message)
+	}
+
+	return []byte(msg), nil
+}
+
+func (f *LoggerFormatter) printColored(e *logrus.Entry) string {
+	var levelColor int
+	var levelText string
+	switch e.Level {
+	case TraceLevel:
+		levelText = "trace:"
+		levelColor = gray
+	case DebugLevel:
+		levelText = "debug:"
+		levelColor = gray
+	case InfoLevel:
+		levelText = "info:"
+		levelColor = blue
+	case WarnLevel:
+		levelText = "warn:"
+		levelColor = yellow
+	case ErrorLevel:
+		levelText = "error:"
+		levelColor = red
+	case FatalLevel:
+		levelText = "fatal:"
+		levelColor = red
+	case PanicLevel:
+		levelText = "panic:"
+		levelColor = red
+	default:
+		levelColor = blue
+	}
+
+	return fmt.Sprintf("\x1b[%dm%s\x1b[0m", levelColor, levelText)
+}

pkg/release.go

@@ -0,0 +1,161 @@
+package pkg
+
+import (
+	"archive/tar"
+	"compress/gzip"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"time"
+
+	"github.com/briandowns/spinner"
+)
+
+type ReleaseActions interface {
+	DownloadRelease() error
+	ExtractRelease() error
+	CheckReleaseExists() error
+	GetReleaseFolder() string
+	downloadFile(*os.File) error
+}
+
+type Release struct {
+	release       string
+	releaseFolder string
+	client        *http.Client
+	archivePath   string
+}
+
+// NewRelease returns a Release object
+func NewRelease(release, releaseFolder string) ReleaseActions {
+	return &Release{
+		release:       release,
+		releaseFolder: releaseFolder,
+		client:        http.DefaultClient,
+	}
+}
+
+// DownloadRelease downloads the golang release
+func (d *Release) DownloadRelease() error {
+	d.archivePath = fmt.Sprintf("%s/%s.tar.gz", os.TempDir(), d.release)
+	f, err := os.Create(d.archivePath)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	return d.downloadFile(f)
+}
+
+// downloadFile downloads the file to the given writer
+func (d *Release) downloadFile(f *os.File) error {
+	s := spinner.New(spinner.CharSets[35], 100*time.Millisecond)
+	s.Suffix = " Downloading release..."
+	s.Start()
+	defer s.Stop()
+
+	rsp, err := d.client.Get(fmt.Sprintf("%s/%s.%s-amd64.tar.gz", GO_DL_SERVER, d.release, runtime.GOOS))
+	if err != nil {
+		return err
+	}
+	defer rsp.Body.Close()
+
+	if rsp.StatusCode != 200 {
+		return errors.New("golang download server return a non success status code")
+	}
+
+	if _, err := io.Copy(f, rsp.Body); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// ExtractRelease extracts the golang release
+func (d *Release) ExtractRelease() error {
+	f, err := os.Open(d.archivePath)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	gzipReader, err := gzip.NewReader(f)
+	if err != nil {
+		return err
+	}
+	defer gzipReader.Close()
+
+	tarReader := tar.NewReader(gzipReader)
+
+	if err := os.MkdirAll(d.releaseFolder, 0755); err != nil {
+		return err
+	}
+
+	var rootFolder string
+	start := true
+	for {
+		h, err := tarReader.Next()
+		if err != nil {
+			if err == io.EOF {
+				return os.Remove(d.archivePath)
+			}
+
+			return err
+		}
+
+		// skip first folder
+		if start {
+			rootFolder = h.Name
+			start = false
+			continue
+		}
+
+		target := filepath.Join(d.releaseFolder, strings.Replace(h.Name, rootFolder, "", 1))
+		switch h.Typeflag {
+		case tar.TypeDir:
+			if err = os.MkdirAll(target, h.FileInfo().Mode()); err != nil {
+				return err
+			}
+		case tar.TypeReg:
+			file, err := os.OpenFile(target, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, h.FileInfo().Mode())
+			if err != nil {
+				return err
+			}
+
+			if _, err = io.Copy(file, tarReader); err != nil {
+				file.Close()
+				return err
+			}
+
+			file.Close()
+		}
+	}
+}
+
+// CheckReleaseExists checks if the release exists in doggofetcher folder
+func (d *Release) CheckReleaseExists() error {
+	fi, err := os.Stat(d.releaseFolder)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return ErrReleaseNotFound
+		}
+
+		return err
+	}
+
+	if !fi.IsDir() {
+		return ErrReleaseNotFound
+	}
+
+	return nil
+}
+
+// GetReleaseFolder returns the release folder
+func (d *Release) GetReleaseFolder() string {
+	return d.releaseFolder
+}

pkg/tags.go

@@ -2,18 +2,19 @@ package pkg
 
 import (
 	"context"
-	"errors"
 	"fmt"
 	"net/http"
+	"os"
 	"strings"
 
 	"github.com/google/go-github/v45/github"
 )
 
-var (
-	ErrBadResponse = errors.New("github API responde with a non success code")
-	ErrEmptyTags   = errors.New("no tags found")
-)
+type TagsAction interface {
+	GetRelease(beta, rc bool) (string, error)
+	GetTagsRef() ([]*github.Reference, error)
+	getLatestTag(beta, rc bool) (string, error)
+}
 
 type Tags struct {
 	release string
@@ -21,7 +22,7 @@ type Tags struct {
 	ctx     context.Context
 }
 
-func NewTags(release string, ctx context.Context) Tags {
+func NewTags(release string, ctx context.Context) TagsAction {
 	return Tags{
 		release: release,
 		client:  *github.NewClient(nil),
@@ -29,41 +30,114 @@ func NewTags(release string, ctx context.Context) Tags {
 	}
 }
 
-// checkReleaseExists retrieves tags from "golang/go" and check whether
+// GetRelease retrieves tags from "golang/go" and check whether
 // the given release exists in it
-func (t Tags) CheckReleaseExists(beta, rc bool) (string, error) {
-	var tags []*github.RepositoryTag
-	var response *github.Response
-	var err error
+//
+// Returns the found release or an error
+func (t Tags) GetRelease(beta, rc bool) (string, error) {
+	if t.release == LTS {
+		return t.getLatestTag(beta, rc)
+	}
 
-	tags, response, err = t.client.Repositories.ListTags(t.ctx, "golang", "go", nil)
+	refs, err := t.GetTagsRef()
 	if err != nil {
+		if err == ErrEmptyTags {
+			return "", nil
+		}
 		return "", err
 	}
-	if response.StatusCode != http.StatusOK {
-		return "", ErrBadResponse
-	}
-	if len(tags) == 0 {
-		return "", ErrEmptyTags
-	}
 
-	if t.release == "lts" {
-		return *tags[len(tags)-1].Name, nil
-	}
-
-	for i, tag := range tags {
+	for i, ref := range refs {
 		userRelease := fmt.Sprintf("go%s", t.release)
-		if strings.Contains(*tag.Name, userRelease) {
-			if (!beta && strings.Contains(*tag.Name, "beta")) || (!rc && strings.Contains(*tag.Name, "rc")) {
+		tag := strings.Split(*ref.Ref, "/")[2]
+
+		if strings.Contains(tag, userRelease) {
+			if (!beta && strings.Contains(tag, "beta")) || (!rc && strings.Contains(tag, "rc")) {
 				continue
 			}
 
-			if strings.Contains(*tags[i+1].Name, userRelease) {
+			if len(refs) == i+1 {
+				return tag, nil
+			}
+
+			if beta && strings.Contains(tag, "beta") {
+				if strings.Contains(*refs[i+1].Ref, userRelease) && strings.Contains(*refs[i+1].Ref, "beta") {
+					continue
+				} else {
+					return tag, nil
+				}
+			}
+
+			if rc && strings.Contains(tag, "rc") {
+				if strings.Contains(*refs[i+1].Ref, userRelease) && strings.Contains(*refs[i+1].Ref, "rc") {
+					continue
+				} else {
+					return tag, nil
+				}
+			}
+
+			if strings.Contains(*refs[i+1].Ref, userRelease) {
 				continue
 			}
 
+			return tag, nil
+		}
+	}
+
+	return "", ErrEmptyTags
+}
+
+// GetTagsRef retrieves all tags from golang/go
+//
+// Returns a list of tags reference if there is as least one
+// or an error otherwise.
+func (t Tags) GetTagsRef() ([]*github.Reference, error) {
+	refs, response, err := t.client.Git.ListMatchingRefs(t.ctx, "golang", "go", &github.ReferenceListOptions{
+		Ref: "tags/go",
+	})
+	if err != nil {
+		return nil, err
+	}
+	if response.StatusCode != http.StatusOK {
+		fmt.Fprintf(os.Stderr, "%s: %d\n", ErrBadResponse.Error(), response.StatusCode)
+		return nil, ErrBadResponse
+	}
+	if len(refs) == 0 {
+		return nil, ErrEmptyTags
+	}
+
+	return refs, nil
+}
+
+// getLatestTag gather find the latest version of golang.
+// beta and rc version can be specified.
+//
+// Returns the latest release or an error
+func (t Tags) getLatestTag(beta, rc bool) (string, error) {
+	refs, err := t.GetTagsRef()
+	if err != nil {
+		if err == ErrEmptyTags {
 			return "", nil
 		}
+		return "", err
+	}
+
+	for i := len(refs) - 1; i >= 0; i-- {
+		if (!beta && strings.Contains(*refs[i].Ref, "beta")) || (!rc && strings.Contains(*refs[i].Ref, "rc")) {
+			continue
+		}
+
+		if beta && strings.Contains(*refs[i].Ref, "beta") {
+			return strings.Split(*refs[i].Ref, "/")[2], nil
+		}
+
+		if rc && strings.Contains(*refs[i].Ref, "rc") {
+			return strings.Split(*refs[i].Ref, "/")[2], nil
+		}
+
+		if !strings.Contains(*refs[i].Ref, "beta") && !strings.Contains(*refs[i].Ref, "rc") {
+			return strings.Split(*refs[i].Ref, "/")[2], nil
+		}
 	}
 
 	return "", nil

pkg/utils.go

@@ -0,0 +1,65 @@
+package pkg
+
+import (
+	"io"
+	"os"
+	"path/filepath"
+)
+
+func UpdateRelease(activeRelease, releaseFolder string) error {
+	if err := os.RemoveAll(activeRelease); err != nil {
+		return err
+	}
+	if err := os.MkdirAll(activeRelease, 0755); err != nil {
+		return err
+	}
+
+	return CopyFolder(releaseFolder, activeRelease, true)
+}
+
+func CopyFolder(src, dst string, init bool) error {
+	items, err := os.ReadDir(src)
+	if err != nil {
+		return err
+	}
+
+	for _, i := range items {
+		info, err := i.Info()
+		if err != nil {
+			return err
+		}
+
+		src := filepath.Join(src, i.Name())
+		dst := filepath.Join(dst, i.Name())
+		if i.IsDir() {
+			if err := os.MkdirAll(dst, info.Mode()); err != nil {
+				return err
+			}
+
+			CopyFolder(src, dst, false)
+			continue
+		}
+
+		f, err := os.Open(src)
+		if err != nil {
+			return err
+		}
+
+		dstFile, err := os.OpenFile(dst, os.O_WRONLY|os.O_CREATE, info.Mode())
+		if err != nil {
+			f.Close()
+			return err
+		}
+
+		if _, err := io.Copy(dstFile, f); err != nil {
+			f.Close()
+			dstFile.Close()
+			return err
+		}
+
+		f.Close()
+		dstFile.Close()
+	}
+
+	return nil
+}

pkg/variables.go

@@ -0,0 +1,14 @@
+package pkg
+
+import "errors"
+
+const GO_DL_SERVER = "https://go.dev/dl"
+const LTS = "lts"
+
+var (
+	ErrReleaseNotFound = errors.New("release not found")
+	ErrBadResponse     = errors.New("github API responde with a non success code")
+	ErrEmptyTags       = errors.New("no tags found")
+	ErrHashNotFound    = errors.New("release hash not found")
+	ErrHashInvalid     = errors.New("release hash doesn't match")
+)