github.com/benoitkugler/goacve@v0.0.0-20201217100549-151ce6e55dc8/deploy/main.go

package main

import (
	"archive/tar"
	"archive/zip"
	"bytes"
	"compress/gzip"
	"encoding/json"
	"flag"
	"io"
	"io/ioutil"
	"log"
	"os"
	"path/filepath"
	"runtime"
	"strings"

	"github.com/benoitkugler/goACVE/deploy/upload"

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

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

type fullArchive interface {
	addFile(info os.FileInfo, sourcePath string)
	close() []byte
}

type zipArchive struct {
	buffer  *bytes.Buffer
	archive *zip.Writer
}

func (z zipArchive) addFile(info os.FileInfo, sourcePath string) {
	if info.IsDir() {
		return
	}
	wr, err := z.archive.Create(sourcePath)
	if err != nil {
		log.Fatal(err)
	}
	f, err := os.Open(sourcePath)
	defer f.Close()
	if err != nil {
		log.Fatal(err)
	}
	if _, err := io.Copy(wr, f); err != nil {
		log.Fatal(err)
	}
}

func (z zipArchive) close() []byte {
	if err := z.archive.Close(); err != nil {
		log.Fatal(err)
	}
	return z.buffer.Bytes()
}

type tarArchive struct {
	buffer     *bytes.Buffer
	compressed *gzip.Writer
	archive    *tar.Writer
	full       bool // for full logiciel
}

func newTarArchive() tarArchive {
	buf := new(bytes.Buffer)
	compressed, err := gzip.NewWriterLevel(buf, gzip.BestCompression)
	if err != nil {
		log.Fatal(err)
	}
	tw := tar.NewWriter(compressed)
	return tarArchive{buffer: buf, archive: tw, compressed: compressed}
}

func (t tarArchive) addFile(info os.FileInfo, sourcePath string) {
	archive := t.archive

	var (
		link string
		err  error
	)
	if info.Mode()&os.ModeSymlink == os.ModeSymlink {
		if link, err = os.Readlink(sourcePath); err != nil {
			log.Fatal(err)
		}
	}

	hdr, err := tar.FileInfoHeader(info, link)
	if err != nil {
		log.Fatal(err)
	}

	if t.full {
		hdr.Name = sourcePath // pack complet
	} else {
		if hdr.Name+"/" == store.DarwinApp {
			return
		}
		hdr.Name = strings.TrimPrefix(sourcePath, store.DarwinApp) // pour darwin, on se place à l'intérieur de l'app..
	}

	if err := archive.WriteHeader(hdr); err != nil {
		log.Fatal(err)
	}

	if !info.Mode().IsRegular() { //nothing more to do for non-regular
		return
	}

	f, err := os.Open(sourcePath)
	defer f.Close()
	if err != nil {
		log.Fatal(err)
	}
	if _, err := io.Copy(archive, f); err != nil {
		log.Fatal(err)
	}
}

func (t tarArchive) close() []byte {
	if err := t.archive.Close(); err != nil {
		log.Fatal(err)
	}
	if err := t.compressed.Close(); err != nil {
		log.Fatal(err)
	}
	return t.buffer.Bytes()
}

// On suppose qu'on a déjà build avec qt deploy
// et copié les ressources.
func main() {
	noUpload := flag.Bool("noup", false, "disable uploading to the server")
	noPack := flag.Bool("nopack", false, "disable packing")
	flag.Parse()

	if !*noPack {
		Pack()
	}

	if !*noUpload {
		Upload()
	}
}

func Pack() {
	newVersion := version.VERSION
	log.Printf("Utilitaire de déployement pour la version %s", newVersion)
	storePaths := store.GetPaths(runtime.GOOS)

	checkLogicielDir()
	oldVersion := readVersion(storePaths.Versions)

	currentDir, err := os.Getwd()
	if err != nil {
		log.Fatal(err)
	}
	root := "client/deploy/" + runtime.GOOS
	log.Println("Moving to", root)
	if err := os.Chdir(root); err != nil {
		log.Fatal(err)
	}

	log.Println("Packing datas...")
	client, fullArch, nbFiles := parcourtFolder()

	log.Println("Going back to", currentDir)
	if err := os.Chdir(currentDir); err != nil {
		log.Fatal(err)
	}

	log.Println("Saving full archive...")
	if err = ioutil.WriteFile(storePaths.Full, fullArch, 0666); err != nil {
		log.Fatal(err)
	}
	log.Println("UP -> Logiciel copié dans", storePaths.Full)

	if newVersion == oldVersion.Version {
		log.Fatal("La version du client n'a pas été mise à jour !")
	}
	log.Println("Mise à jour du client...")

	oldVersion.Version = newVersion
	hash, err := utils.HashBytes(client)
	if err != nil {
		log.Fatal(err)
	}
	oldVersion.Hash = hash
	oldVersion.NbFiles = nbFiles
	if err = ioutil.WriteFile(storePaths.Client, client, 0666); err != nil {
		log.Fatal(err)
	}
	log.Println("UP -> Client copié dans", storePaths.Client)

	b, err := json.MarshalIndent(oldVersion, " ", " ")
	if err != nil {
		log.Fatal(err)
	}
	if err := ioutil.WriteFile(storePaths.Versions, b, 0666); err != nil {
		log.Fatal(err)
	}
	log.Println("UP -> Versions copiées dans", storePaths.Versions)
}

func Upload() {
	storePaths := store.GetPaths(runtime.GOOS)
	toUpload := []upload.Up{
		upload.NewUp(storePaths.Full),
		upload.NewUp(storePaths.Client),
		upload.NewUp(storePaths.Versions),
	}
	s := upload.OpenFTP()
	if err := upload.Upload(s, toUpload); err != nil {
		log.Fatal(err)
	}
	log.Println("Upload done.")
}

func readVersion(path string) apiserver.VersionInfos {
	b, _ := ioutil.ReadFile(path)
	var v apiserver.VersionInfos
	err := json.Unmarshal(b, &v)
	if err != nil {
		v.Version = "0.0.0"
		log.Println("Fichier de version introuvable (ancienne version => 0.0.0)")
	}
	return v
}

func checkLogicielDir() {
	path := filepath.Join(store.BasePathExport, runtime.GOOS)
	_, err := os.Stat(path)
	if err == nil {
		return
	}
	if err = os.Mkdir(path, 0777); err != nil {
		log.Fatalf("Impossible de créer le dossier d'export : %s", err)
	}
}

func initFullArchive() fullArchive {
	var fullArch fullArchive
	buf := new(bytes.Buffer)
	if runtime.GOOS == "windows" {
		fullArch = zipArchive{buffer: buf, archive: zip.NewWriter(buf)}
	} else {
		t := newTarArchive()
		t.full = true
		fullArch = t
	}
	return fullArch
}

func parcourtFolder() ([]byte, []byte, int) {
	nbFiles := 0
	client := newTarArchive()
	fullArch := initFullArchive()
	walkF := func(filePath string, info os.FileInfo, err error) error {
		if filePath == "." {
			return nil
		}
		if err != nil {
			log.Fatal(err)
		}
		nbFiles += 1
		client.addFile(info, filePath)
		fullArch.addFile(info, filePath)
		return nil
	}
	err := filepath.Walk(".", walkF)
	if err != nil {
		log.Fatal(err)
	}
	return client.close(), fullArch.close(), nbFiles
}