github.com/benoitkugler/goacve@v0.0.0-20201217100549-151ce6e55dc8/client/controllers/main_update.go

package controllers

import (
	"archive/tar"
	"bytes"
	"compress/gzip"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"io/ioutil"
	"log"
	"net/http"
	"os"
	"os/exec"
	"path"
	"path/filepath"
	"runtime"

	"github.com/benoitkugler/goACVE/client/version"

	"github.com/benoitkugler/goACVE/server/core/apiserver"
	"github.com/benoitkugler/goACVE/server/core/utils"
)

const pathClientVersions = "local/versions.json"

type monFunc = func(string, uint8)

type clientInfo struct {
	// `true` si première utilisation depuis la mise à jour
	IsNew bool
}

func isNewlyUpdated() bool {
	var out clientInfo
	b, err := ioutil.ReadFile(pathClientVersions)
	if err != nil {
		return false
	}
	if err := json.Unmarshal(b, &out); err != nil {
		log.Println(err)
	}
	return out.IsNew
}

func setNewlyUpdated(new bool) {
	f, err := os.Create(pathClientVersions)
	if err != nil {
		log.Println(err)
		return
	}
	defer f.Close()
	err = json.NewEncoder(f).Encode(clientInfo{IsNew: new})
	if err != nil {
		log.Println(err)
	}
}

func verifyChecksum(archiveContent []byte, reference []byte) error {
	checksum, err := utils.HashBytes(archiveContent)
	if err != nil {
		return err
	}
	if !bytes.Equal(reference, checksum) {
		return fmt.Errorf("updated file has wrong checksum. Expected: %x, got: %x", reference, checksum)
	}
	return nil
}

// buf est un tar.gz contenant un ou plusieurs dossiers / fichiers
func applyUpdate(archive *bytes.Buffer, version apiserver.VersionInfos, monitor monFunc) error {
	if err := verifyChecksum(archive.Bytes(), version.Hash); err != nil {
		return fmt.Errorf("Somme de contrôle invalide : %s", err)
	}
	if version.NbFiles == 0 {
		return errors.New("La mise à jour semble ne contenir aucun fichier.")
	}

	gz, err := gzip.NewReader(archive)
	if err != nil {
		return err
	}
	defer gz.Close()
	innerTr := tar.NewReader(gz)
	current, step := 0, version.NbFiles/100
	for {
		current += 1
		hdr, err := innerTr.Next()
		if err == io.EOF {
			break // End of archive
		}
		if err != nil {
			return fmt.Errorf("Archive illisible : %s", err)
		}
		if hdr.FileInfo().Mode().IsDir() {
			continue
		}

		targetPath := hdr.Name

		dirPath := filepath.Dir(targetPath)
		if _, err := os.Stat(dirPath); err != nil {
			if err := os.MkdirAll(dirPath, os.ModePerm); err != nil {
				return err
			}
		}

		if hdr.Typeflag == tar.TypeSymlink {
			if _, err := os.Lstat(targetPath); err == nil {
				if err := os.Remove(targetPath); err != nil {
					return fmt.Errorf("Impossible de supprimer le lien symolique : %+v", err)
				}
			} else if os.IsNotExist(err) {
				return fmt.Errorf("Impossible de vérifier le lien symbolique: %+v", err)
			}

			if err := os.Symlink(hdr.Linkname, targetPath); err != nil {
				return err
			}
			continue
		}

		// pour éviter les problèmes de fichier en cours d'utilisation
		// on utilise un fichier temporaire
		newPath := targetPath + ".new"
		f, err := os.OpenFile(newPath, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0755)
		if err != nil {
			return fmt.Errorf("Impossible de créer le fichier : %s", err)
		}

		// copy over contents
		if _, err := io.Copy(f, innerTr); err != nil {
			return fmt.Errorf("Impossible d'enregistrer la mise à jour : %s", err)
		}

		// manually close here after each file operation; defering would cause each file close
		// to wait until all operations have completed.
		if err = f.Close(); err != nil {
			return err
		}

		// this is where we'll move the existing file to so that we can swap in the updated replacement
		oldPath := filepath.Join(targetPath + ".old")

		// delete any existing old exec file - this is necessary on Windows for two reasons:
		// 1. after a successful update, Windows can't remove the .old file because the process is still running
		// 2. windows rename operations fail if the destination file already exists
		_ = os.Remove(oldPath)

		if _, err := os.Lstat(targetPath); err == nil { // le fichier existe
			// move the existing file to a new file in the same directory
			// freeing targetPath
			err = os.Rename(targetPath, oldPath)
			if err != nil {
				return err
			}
		}

		// move the new exectuable in to become the new program
		if err = os.Rename(newPath, targetPath); err != nil {
			return err
		}

		// we try to cleanup, may fail on windows
		_ = os.Remove(oldPath)

		if current%step == 0 {
			monitor("Copie des fichiers", uint8(100*current/version.NbFiles))
		}
	}
	return nil
}

// CheckUpdate implémente un système d'auto-update
func (c *MainController) CheckUpdate(monitor monFunc) (restartNeeded bool, err error) {
	goos := runtime.GOOS

	monitor("Lecture des versions...", 0)
	news := &apiserver.VersionInfos{}

	url := path.Join(apiserver.UrlUpdate, goos)

	err = requete(url, http.MethodGet, nil, news)
	fmt.Printf("version infos : %v \n", *news)
	if err != nil { // Impossible de vérifier les MAJ -> mode offline
		Server.actif = false
		return false, err
	}
	monitor("Comparaison...", 50)
	needed := utils.IsNewer(version.VERSION, news.Version)
	if !needed {
		return false, nil // pas de mise à jour à télécharger
	}

	monitor(fmt.Sprintf("Une <b>mise à jour</b> a été trouvée (<i>%s</i>).", news.Version), 0)
	downloadCb := func(percent uint8) { monitor("Téléchargement de la mise à jour...", percent) }
	buf := new(bytes.Buffer)
	err = requestDownload(url, http.MethodPost, nil, downloadCb, buf)
	if err != nil {
		return false, err
	}
	monitor("Dépaquettage et redémarrage...", 0)

	if goos == "darwin" { // executable is not in root folder
		if err := os.Chdir("../.."); err != nil {
			return false, err
		} // now in "ACVE-Gestion.app"
	}

	if err = applyUpdate(buf, *news, monitor); err != nil {
		return false, err
	}

	if goos == "darwin" { // executable is not in root folder
		if err := os.Chdir("Contents/MacOS/"); err != nil {
			return false, err
		} // back next to client
	}

	// mise à jour de la version
	setNewlyUpdated(true)
	monitor("Mise à jour réussie.", 100)
	return true, nil
}

// Restart start a new program. The main function should be quit as soon as possible.
// An error is returned if the launch wasn't successful
func (c MainController) Restart() error {
	exePath, err := os.Executable()
	if err != nil {
		return err
	}
	log.Println("restarting with :", exePath, os.Args[1:])
	cmd := exec.Command(exePath, os.Args[1:]...)
	err = cmd.Start()
	if err != nil {
		return err
	}
	os.Exit(0)
	return nil
}