go-serviceman/vendor/github.com/UnnoTed/fileb0x/main.go

384 lines
8.1 KiB
Go
Raw Normal View History

2019-07-01 08:44:54 +00:00
package main
import (
"bufio"
"bytes"
"crypto/md5"
"flag"
"fmt"
"go/format"
"io/ioutil"
"log"
"os"
"path"
"path/filepath"
"runtime"
"sort"
"strconv"
"strings"
"time"
"github.com/UnnoTed/fileb0x/compression"
"github.com/UnnoTed/fileb0x/config"
"github.com/UnnoTed/fileb0x/custom"
"github.com/UnnoTed/fileb0x/dir"
"github.com/UnnoTed/fileb0x/file"
"github.com/UnnoTed/fileb0x/template"
"github.com/UnnoTed/fileb0x/updater"
"github.com/UnnoTed/fileb0x/utils"
// just to install automatically
_ "github.com/labstack/echo"
_ "golang.org/x/net/webdav"
)
var (
err error
cfg *config.Config
files = make(map[string]*file.File)
dirs = new(dir.Dir)
cfgPath string
fUpdate string
startTime = time.Now()
hashStart = []byte("// modification hash(")
hashEnd = []byte(")")
modTimeStart = []byte("// modified(")
modTimeEnd = []byte(")")
)
func main() {
runtime.GOMAXPROCS(runtime.NumCPU())
// check for updates
flag.StringVar(&fUpdate, "update", "", "-update=http(s)://host:port - default port: 8041")
flag.Parse()
var (
update = fUpdate != ""
up *updater.Updater
)
// create config and try to get b0x file from args
f := new(config.File)
err = f.FromArg(true)
if err != nil {
panic(err)
}
// load b0x file's config
cfg, err = f.Load()
if err != nil {
panic(err)
}
err = cfg.Defaults()
if err != nil {
panic(err)
}
cfgPath = f.FilePath
if err := cfg.Updater.CheckInfo(); err != nil {
panic(err)
}
cfg.Updater.IsUpdating = update
// creates a config that can be inserTed into custom
// without causing a import cycle
sharedConfig := new(custom.SharedConfig)
sharedConfig.Output = cfg.Output
sharedConfig.Updater = cfg.Updater
sharedConfig.Compression = compression.NewGzip()
sharedConfig.Compression.Options = cfg.Compression
// loop through b0x's [custom] objects
for _, c := range cfg.Custom {
err = c.Parse(&files, &dirs, sharedConfig)
if err != nil {
panic(err)
}
}
// builds remap's list
var (
remap string
modHash string
mods []string
lastHash string
)
for _, f := range files {
remap += f.GetRemap()
mods = append(mods, f.Modified)
}
// sorts modification time list and create a md5 of it
sort.Strings(mods)
modHash = stringMD5Hex(strings.Join(mods, "")) + "." + stringMD5Hex(string(f.Data))
exists := fileExists(cfg.Dest + cfg.Output)
if exists {
// gets the modification hash from the main b0x file
lastHash, err = getModification(cfg.Dest+cfg.Output, hashStart, hashEnd)
if err != nil {
panic(err)
}
}
if !exists || lastHash != modHash {
// create files template and exec it
t := new(template.Template)
t.Set("files")
t.Variables = struct {
ConfigFile string
Now string
Pkg string
Files map[string]*file.File
Tags string
Spread bool
Remap string
DirList []string
Compression *compression.Options
Debug bool
Updater updater.Config
ModificationHash string
}{
ConfigFile: filepath.Base(cfgPath),
Now: time.Now().String(),
Pkg: cfg.Pkg,
Files: files,
Tags: cfg.Tags,
Remap: remap,
Spread: cfg.Spread,
DirList: dirs.Clean(),
Compression: cfg.Compression,
Debug: cfg.Debug,
Updater: cfg.Updater,
ModificationHash: modHash,
}
tmpl, err := t.Exec()
if err != nil {
panic(err)
}
if err := os.MkdirAll(cfg.Dest, 0770); err != nil {
panic(err)
}
// gofmt
if cfg.Fmt {
tmpl, err = format.Source(tmpl)
if err != nil {
panic(err)
}
}
// write final execuTed template into the destination file
err = ioutil.WriteFile(cfg.Dest+cfg.Output, tmpl, 0640)
if err != nil {
panic(err)
}
}
// write spread files
var (
finalList []string
changedList []string
)
if cfg.Spread {
a := strings.Split(path.Dir(cfg.Dest), "/")
dirName := a[len(a)-1:][0]
for _, f := range files {
a := strings.Split(path.Dir(f.Path), "/")
fileDirName := a[len(a)-1:][0]
if dirName == fileDirName {
continue
}
// transform / to _ and some other chars...
customName := "b0xfile_" + utils.FixName(f.Path) + ".go"
finalList = append(finalList, customName)
exists := fileExists(cfg.Dest + customName)
var mth string
if exists {
mth, err = getModification(cfg.Dest+customName, modTimeStart, modTimeEnd)
if err != nil {
panic(err)
}
}
changed := mth != f.Modified
if changed {
changedList = append(changedList, f.OriginalPath)
}
if !exists || changed {
// creates file template and exec it
t := new(template.Template)
t.Set("file")
t.Variables = struct {
ConfigFile string
Now string
Pkg string
Path string
Name string
Dir [][]string
Tags string
Data string
Compression *compression.Options
Modified string
OriginalPath string
}{
ConfigFile: filepath.Base(cfgPath),
Now: time.Now().String(),
Pkg: cfg.Pkg,
Path: f.Path,
Name: f.Name,
Dir: dirs.List,
Tags: f.Tags,
Data: f.Data,
Compression: cfg.Compression,
Modified: f.Modified,
OriginalPath: f.OriginalPath,
}
tmpl, err := t.Exec()
if err != nil {
panic(err)
}
// gofmt
if cfg.Fmt {
tmpl, err = format.Source(tmpl)
if err != nil {
panic(err)
}
}
// write final execuTed template into the destination file
if err := ioutil.WriteFile(cfg.Dest+customName, tmpl, 0640); err != nil {
panic(err)
}
}
}
}
// remove b0xfiles when [clean] is true
// it doesn't clean destination's folders
if cfg.Clean {
matches, err := filepath.Glob(cfg.Dest + "b0xfile_*.go")
if err != nil {
panic(err)
}
// remove matched file if they aren't in the finalList
// which contains the list of all files written by the
// spread option
for _, f := range matches {
var found bool
for _, name := range finalList {
if strings.HasSuffix(f, name) {
found = true
}
}
if !found {
err = os.Remove(f)
if err != nil {
panic(err)
}
}
}
}
// main b0x
if lastHash != modHash {
log.Printf("fileb0x: took [%dms] to write [%s] from config file [%s] at [%s]",
time.Since(startTime).Nanoseconds()/1e6, cfg.Dest+cfg.Output,
filepath.Base(cfgPath), time.Now().String())
} else {
log.Printf("fileb0x: no changes detected")
}
// log changed files
if cfg.Lcf && len(changedList) > 0 {
log.Printf("fileb0x: list of changed files [%s]", strings.Join(changedList, " | "))
}
if update {
if !cfg.Updater.Enabled {
panic("fileb0x: The updater is disabled, enable it in your config file!")
}
// includes port when not present
if !strings.HasSuffix(fUpdate, ":"+strconv.Itoa(cfg.Updater.Port)) {
fUpdate += ":" + strconv.Itoa(cfg.Updater.Port)
}
up = &updater.Updater{
Server: fUpdate,
Auth: updater.Auth{
Username: cfg.Updater.Username,
Password: cfg.Updater.Password,
},
Workers: cfg.Updater.Workers,
}
// get file hashes from server
if err := up.Init(); err != nil {
panic(err)
}
// check if an update is available, then updates...
if err := up.UpdateFiles(files); err != nil {
panic(err)
}
}
}
func getModification(path string, start []byte, end []byte) (string, error) {
file, err := os.Open(path)
if err != nil {
return "", err
}
defer file.Close()
reader := bufio.NewReader(file)
var data []byte
for {
line, _, err := reader.ReadLine()
if err != nil {
return "", err
}
if !bytes.HasPrefix(line, start) || !bytes.HasSuffix(line, end) {
continue
}
data = line
break
}
hash := bytes.TrimPrefix(data, start)
hash = bytes.TrimSuffix(hash, end)
return string(hash), nil
}
func fileExists(filename string) bool {
_, err := os.Stat(filename)
return err == nil
}
func stringMD5Hex(data string) string {
hash := md5.New()
hash.Write([]byte(data))
return fmt.Sprintf("%x", hash.Sum(nil))
}