add snapshots list api

Reviewed-on: #2

.gitignore

@@ -1,2 +1,3 @@
 config.json
 backup
+backup.json

addr.go

@@ -0,0 +1,165 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+	"regexp"
+	"strings"
+
+	log "github.com/sirupsen/logrus"
+)
+
+type Addr string
+
+var (
+	reBox  = regexp.MustCompile(`^[a-zA-Z0-9\-_\.]+$`)
+	rePath = regexp.MustCompile(`^(/){0,1}[a-zA-Z0-9\-_\.]+(/[a-zA-Z0-9\-_\.]+)+$`)
+)
+
+func (a Addr) Box() string {
+	s := strings.Split(string(a), `:`)
+	box := s[0]
+	if reBox.MatchString(box) {
+		return box
+	} else {
+		return ""
+	}
+}
+
+func (a Addr) Path() string {
+	s := strings.Split(string(a), `:`)
+	path := s[1]
+	if rePath.MatchString(path) {
+		return path
+	} else {
+		return ""
+	}
+}
+
+func (a Addr) Append(path string) Addr {
+	newPath := a.Path() + path
+	if rePath.MatchString(newPath) {
+		return Addr(a.Box() + ":" + newPath)
+	} else {
+		return ""
+	}
+}
+
+func (a Addr) BoxExec(cmd string) (string, error) {
+	log.WithFields(log.Fields{"addr": a}).Debugf("starting")
+	defer log.WithFields(log.Fields{"addr": a}).Debugf("done")
+
+	if b, ok := cfg.box[a.Box()]; !ok {
+		err := errors.New("box doesn't exist")
+		log.WithFields(log.Fields{"addr": a, "box": a.Box(), "error": err}).Errorf("")
+		return "", err
+	} else {
+		return b.Exec(cmd)
+	}
+}
+
+func (a Addr) Exec() (string, error) {
+	log.WithFields(log.Fields{"addr": a}).Debugf("starting")
+	defer log.WithFields(log.Fields{"addr": a}).Debugf("done")
+
+	return a.BoxExec(a.Path())
+}
+
+func (a Addr) ValidSnapshots() ([]*ZfsSnapshot, error) {
+	log.WithFields(log.Fields{"addr": a}).Debugf("starting")
+	defer log.WithFields(log.Fields{"addr": a}).Debugf("done")
+
+	if b, ok := cfg.box[a.Box()]; !ok {
+		err := errors.New("box doesn't exist")
+		log.WithFields(log.Fields{"addr": a, "box": a.Box(), "error": err}).Errorf("")
+		return nil, err
+	} else {
+		if fs, ok := b.zfs.filesystems[a.Path()]; ok {
+			return fs.ValidSnapshots(), nil
+		} else {
+			err := errors.New("path doesn't exist")
+			log.WithFields(log.Fields{"addr": a, "error": err}).Errorf("")
+			return nil, err
+		}
+	}
+}
+
+func (a Addr) SetManaged(managed bool) error {
+	log.WithFields(log.Fields{"addr": a}).Debugf("starting")
+	defer log.WithFields(log.Fields{"addr": a}).Debugf("done")
+
+	if b, ok := cfg.box[a.Box()]; !ok {
+		err := errors.New("box doesn't exist")
+		log.WithFields(log.Fields{"addr": a, "box": a.Box(), "error": err}).Errorf("")
+		return err
+	} else if fs, ok := b.zfs.filesystems[a.Path()]; !ok {
+		err := errors.New("path doesn't exist")
+		log.WithFields(log.Fields{"addr": a, "path": a.Path(), "error": err}).Errorf("")
+		return err
+	} else {
+		fs.Lock()
+		defer fs.Unlock()
+		if fs.managed != managed {
+			var cmd string
+			if managed {
+				cmd = fmt.Sprintf("zfs set %s=+ %s", zfsManagedPropertyName, a.Path())
+			} else {
+				cmd = fmt.Sprintf("zfs set %s=- %s", zfsManagedPropertyName, a.Path())
+			}
+			if _, err := b.Exec(cmd); err != nil {
+				log.WithFields(log.Fields{"addr": a, "call": "Exec", "attr": cmd, "error": err}).Errorf("")
+				return err
+			}
+		}
+		fs.managed = managed
+		return nil
+	}
+}
+
+func (a Addr) SetBackedUp(val bool) error {
+	log.WithFields(log.Fields{"addr": a}).Debugf("starting")
+	defer log.WithFields(log.Fields{"addr": a}).Debugf("done")
+
+	if b, ok := cfg.box[a.Box()]; !ok {
+		err := errors.New("box doesn't exist")
+		log.WithFields(log.Fields{"addr": a, "box": a.Box(), "error": err}).Errorf("")
+		return err
+	} else if fs, ok := b.zfs.filesystems[a.Path()]; !ok {
+		err := errors.New("path doesn't exist")
+		log.WithFields(log.Fields{"addr": a, "path": a.Path(), "error": err}).Errorf("")
+		return err
+	} else {
+		fs.Lock()
+		defer fs.Unlock()
+		fs.backedUp = val
+		return nil
+	}
+}
+
+func (a Addr) Mkdir() error {
+	log.WithFields(log.Fields{"addr": a}).Debugf("starting")
+	defer log.WithFields(log.Fields{"addr": a}).Debugf("done")
+
+	if b, ok := cfg.box[a.Box()]; !ok {
+		err := errors.New("box doesn't exist")
+		log.WithFields(log.Fields{"addr": a, "box": a.Box(), "error": err}).Errorf("")
+		return err
+	} else {
+		return b.zfs.Mkdir(a.Path())
+	}
+}
+
+func (a Addr) String() string {
+	return string(a)
+}
+
+func (a Addr) Online() bool {
+	log.WithFields(log.Fields{"addr": a}).Debugf("starting")
+	defer log.WithFields(log.Fields{"addr": a}).Debugf("done")
+
+	if b, ok := cfg.box[a.Box()]; !ok {
+		return false
+	} else {
+		return b.online
+	}
+}

admin.go

@@ -0,0 +1,97 @@
+package main
+
+import (
+	"context"
+	"embed"
+	"net/http"
+	"os/signal"
+	"syscall"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"github.com/robfig/cron/v3"
+	log "github.com/sirupsen/logrus"
+)
+
+type AdminConfig struct {
+	Addr string `json:"addr"`
+}
+
+//go:embed assets
+var assets embed.FS
+
+func NewAdmin() *AdminConfig {
+	log.WithFields(log.Fields{}).Debugf("starting")
+	defer log.WithFields(log.Fields{}).Debugf("done")
+
+	a := &AdminConfig{
+		Addr: "0.0.0.0:8080",
+	}
+
+	return a
+}
+
+func (a *AdminConfig) Run() {
+	log.WithFields(log.Fields{}).Debugf("starting")
+	defer log.WithFields(log.Fields{}).Debugf("done")
+
+	// Create context that listens for the interrupt signal from the OS.
+	ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
+	defer stop()
+
+	if !*debug {
+		gin.SetMode(gin.ReleaseMode)
+	}
+
+	r := gin.Default()
+
+	r.GET("/run", ApiRun)
+	r.GET("/run/:app", ApiRunApp)
+
+	r.GET("/snapshot/add/:app/:schedule", ApiSnapshotAdd)
+	r.GET("/snapshot/del/:app/:name", ApiSnapshotDel)
+	r.GET("/snapshot/list/:app", ApiSnapshotList)
+
+	r.GET("/schedule/list", ApiScheduleList)
+	r.GET("/schedule/add/:name/:duration", ApiScheduleAdd)
+	r.GET("/schedule/del/:name", ApiScheduleDel)
+
+	r.GET("/save", ApiSave)
+
+	r.GET("/config", ApiConfig)
+	r.GET("/config/:app", ApiConfigApp)
+
+	srv := &http.Server{
+		Addr:    a.Addr,
+		Handler: r,
+	}
+
+	go func() {
+		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+			log.WithFields(log.Fields{"call": "http.ListenAndServe", "attr": a.Addr, "error": err}).Errorf("")
+		}
+	}()
+
+	c := cron.New(cron.WithLocation(time.UTC))
+	if _, err := c.AddFunc("0 * * * *", func() { cfg.Run() }); err != nil {
+		log.WithFields(log.Fields{"call": "cron.AddFunc", "error": err}).Errorf("")
+	}
+	c.Start()
+	log.WithFields(log.Fields{"call": "cron.Start"}).Debugf("cron started")
+
+	// Listen for the interrupt signal.
+	<-ctx.Done()
+
+	// Restore default behavior on the interrupt signal and notify user of shutdown.
+	stop()
+	log.WithFields(log.Fields{"call": "stop"}).Warnf("shutting down")
+
+	// The context is used to inform the server it has 5 seconds to finish
+	// the request it is currently handling
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	if err := srv.Shutdown(ctx); err != nil {
+		log.WithFields(log.Fields{"call": "http.Shutdown", "error": err}).Errorf("shutting down")
+	}
+
+}

api.go

@@ -0,0 +1,164 @@
+package main
+
+import (
+	"net/http"
+	"time"
+
+	"github.com/gin-gonic/gin"
+)
+
+func ApiRun(c *gin.Context) {
+	cfg.Run()
+	c.JSON(http.StatusOK, gin.H{
+		"message": "done",
+	})
+}
+
+func ApiSnapshotAdd(c *gin.Context) {
+	if app, ok := cfg.apps[c.Param("app")]; ok {
+		schedule := c.Param("schedule")
+		if _, ok := app.schedule[schedule]; ok {
+			if err := app.RunStandaloneSchedule(schedule); err != nil {
+				c.JSON(http.StatusInternalServerError, gin.H{
+					"message": "error",
+					"error":   err,
+				})
+			} else {
+				c.JSON(http.StatusOK, gin.H{
+					"message": "done",
+				})
+			}
+		} else {
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"message": "error",
+				"error":   "no schedule found",
+			})
+		}
+	} else {
+		c.JSON(http.StatusInternalServerError, gin.H{
+			"message": "error",
+			"error":   "no app found",
+		})
+	}
+}
+
+func ApiSnapshotDel(c *gin.Context) {
+	c.JSON(http.StatusInternalServerError, gin.H{
+		"message": "error",
+		"error":   "not implemented",
+	})
+}
+
+func ApiSnapshotList(c *gin.Context) {
+	if app, ok := cfg.apps[c.Param("app")]; ok {
+		if snapshots, err := app.Snapshots(); err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"message": "error",
+				"error":   err,
+			})
+		} else {
+			c.JSON(http.StatusOK, gin.H{
+				"message":   "done",
+				"snapshots": snapshots,
+			})
+		}
+	} else {
+		c.JSON(http.StatusInternalServerError, gin.H{
+			"message": "error",
+			"error":   "no app found",
+		})
+	}
+	c.JSON(http.StatusInternalServerError, gin.H{
+		"message": "error",
+		"error":   "not implemented",
+	})
+}
+
+func ApiScheduleAdd(c *gin.Context) {
+	c.JSON(http.StatusInternalServerError, gin.H{
+		"message": "error",
+		"error":   "not implemented",
+	})
+}
+
+func ApiScheduleDel(c *gin.Context) {
+	c.JSON(http.StatusInternalServerError, gin.H{
+		"message": "error",
+		"error":   "not implemented",
+	})
+}
+
+func ApiScheduleList(c *gin.Context) {
+	c.JSON(http.StatusInternalServerError, gin.H{
+		"message": "error",
+		"error":   "not implemented",
+	})
+}
+
+func ApiRunApp(c *gin.Context) {
+	if app, ok := cfg.apps[c.Param("app")]; ok {
+		if err := app.RunStandaloneTime(time.Now()); err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{
+				"message": "error",
+				"error":   err,
+			})
+		} else {
+			c.JSON(http.StatusOK, gin.H{
+				"message": "done",
+			})
+		}
+	} else {
+		c.JSON(http.StatusInternalServerError, gin.H{
+			"message": "error",
+			"error":   "no app found",
+		})
+	}
+}
+
+func ApiSave(c *gin.Context) {
+	if err := cfg.Save(); err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{
+			"message": "error",
+			"error":   err,
+		})
+	} else {
+		c.JSON(http.StatusOK, gin.H{
+			"message": "done",
+		})
+	}
+}
+
+func ApiConfig(c *gin.Context) {
+	if b, err := cfg.Pretty(); err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{
+			"message": "error",
+			"error":   err,
+		})
+	} else {
+		c.Data(http.StatusOK, "application/json", b)
+	}
+}
+
+func ApiConfigApp(c *gin.Context) {
+	name := c.Param("app")
+	found := false
+	for _, app := range cfg.Apps {
+		if app.Name == name {
+			found = true
+			if b, err := app.Pretty(); err != nil {
+				c.JSON(http.StatusInternalServerError, gin.H{
+					"message": "error",
+					"error":   err,
+				})
+			} else {
+				c.Data(http.StatusOK, "application/json", b)
+			}
+		}
+	}
+	if !found {
+		c.JSON(http.StatusInternalServerError, gin.H{
+			"message": "error",
+			"error":   "no app found",
+		})
+	}
+}

assets/backup.sample.json

@@ -0,0 +1,18 @@
+{
+    "schedule":{
+        "hourly":"25h",
+        "daily":"1m",
+        "weekly":"3m",
+        "monthly":"13m"
+    },
+	"box":{},
+	"email":{
+        "active":false
+    },
+	"apps":[],
+	"timezone":"Etc/UTC",
+	"admin":{
+        "addr":":8080"
+    },
+	"debug":true
+}

backup.go

@@ -3,22 +3,18 @@ package main
 import (
 	"flag"
 	"fmt"
-	"log"
 	"os"
-	"time"
+
+	log "github.com/sirupsen/logrus"
 )
 
 var (
-	appFlag         = flag.String("app", "", "run specific app")
+	cfgFile  = flag.String("config", "", "config file")
-	cfgFile         = flag.String("config", "config.json", "config file")
+	isDaemon = flag.Bool("daemon", false, "run as daemon")
-	schedFlag       = flag.String("schedule", "", "specific schedule")
+	debug    = flag.Bool("debug", false, "log debug messages")
-	slowFlag        = flag.Bool("slow", false, "slow process")
+	quiet    = flag.Bool("quiet", false, "remove most log messages")
-	testFlag        = flag.Bool("test", false, "test run")
+	logFile  = flag.String("logfile", "", "log file")
-	debugFlag       = flag.Bool("debug", false, "debug")
+	cfg      *Config
-	testMailFlag    = flag.Bool("test-mail", false, "test email setup")
-	stopOnErrorFlag = flag.Bool("stop-on-error", false, "stop processing on error")
-	cfg             Config
-	email           *Email
 )
 
 func main() {
@@ -26,70 +22,45 @@ func main() {
 
 	fmt.Printf("backup (%s)\n", version)
 
-	email = new(Email)
+	if *debug {
-	email.startTime = time.Now()
+		log.SetLevel(log.DebugLevel)
-	email.items = make([]string, 0)
+	}
+	if *quiet {
+		log.SetLevel(log.WarnLevel)
+	}
+	if *logFile != "" {
+		if f, err := os.OpenFile(*logFile, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0644); err != nil {
+			log.Printf("Cannot open logfile (%s)", err)
+		} else {
+			log.SetOutput(f)
+			defer f.Close()
+		}
 
-	err := cfg.Load()
+	}
-	if err != nil {
+	log.SetReportCaller(true)
-		log.Printf("Cannot load config (%s)", err)
+
-		os.Exit(1)
+	if *cfgFile != "" {
+		if c, err := LoadConfigFile(*cfgFile); err != nil {
+			log.Printf("Cannot load config (%s)", err)
+			os.Exit(1)
+		} else {
+			cfg = c
+		}
+	} else if c, err := LoadConfigFile("backup.json"); err == nil {
+		cfg = c
+	} else {
+		log.Debugf("loading default config")
+		cfg, _ = LoadConfigByte(sampleCfg)
 	}
 
-	if *testMailFlag {
+	if *isDaemon {
-		SendMail(cfg.Email.SmtpHost, cfg.Email.FromEmail, "test backup email topic", "test backup email body", cfg.Email.ToEmail)
+		if cfg.Admin == nil {
+			cfg.Admin = NewAdmin()
+		}
+		cfg.Admin.Run()
+	} else {
+		cfg.Run()
 		os.Exit(0)
 	}
 
-	err = RunBackup(*appFlag, *stopOnErrorFlag)
-	if err != nil {
-		log.Printf("Cannot run schedule (%s)", err)
-		os.Exit(1)
-	}
-
-	if len(email.items) > 0 {
-		body := " - " + email.items[0]
-		for _, v := range email.items[1:] {
-			body = body + "\r\n" + " - " + v
-		}
-		SendMail(cfg.Email.SmtpHost, cfg.Email.FromEmail, "Autobackup report", body, cfg.Email.ToEmail)
-		log.Printf("Sending summary email\r\n%v", email.items)
-	}
-}
-
-//RunBackup run all backup targets where schedule is registered
-func RunBackup(app string, stopOnError bool) error {
-	if app == "" {
-		if *debugFlag {
-			log.Printf("RunBackup() : Start")
-		}
-		for _, a := range cfg.Apps {
-			err := a.RunAppBackup()
-			if err != nil {
-				if *debugFlag {
-					log.Printf("RunBackup() : Error running %s", a.Name)
-				}
-				if stopOnError {
-					return err
-				}
-			}
-		}
-	} else {
-		if *debugFlag {
-			log.Printf("RunBackup() : Start %s", app)
-		}
-		for _, a := range cfg.Apps {
-			if a.Name == app {
-				err := a.RunAppBackup()
-				if err != nil {
-					if *debugFlag {
-						log.Printf("RunBackup() : Error running %s", a.Name)
-					}
-					return err
-				}
-			}
-		}
-	}
-
-	return nil
 }

box.go

@@ -1,423 +1,230 @@
 package main
 
 import (
-	"bytes"
+	"errors"
-	"encoding/csv"
+	"regexp"
-	"fmt"
+	"sync"
-	"log"
+
-	"strings"
+	"github.com/silenceper/pool"
+	log "github.com/sirupsen/logrus"
 )
 
 type Box struct {
-	Addr   string `json:"addr"`
+	name    string
-	User   string `json:"user"`
+	addr    string
-	Key    string `json:"key"`
+	user    string
-	Name   string `json:"-"`
+	key     string
-	ssh    *SSHConfig
+	zfs     *BoxZfs
-	zfs    *ZFSConfig
+	sshPool pool.Pool
-	online bool
+	created bool
+	online  bool
+	mx      sync.Mutex
 }
 
-func (b *Box) ZFSTakeSnapshot(schedule, path string) (err error) {
+func (b *Box) Lock() {
-	if *debugFlag {
+	log.WithFields(log.Fields{"name": b.name}).Debugf("starting")
-		log.Printf("Box.ZFSTakeSnapshot : %s : Taking snapshot on %s for %s", b.Name, path, schedule)
+	b.mx.Lock()
-	}
-
-	if !b.online {
-		err = fmt.Errorf("box offline")
-		return
-	}
-
-	err = b.SnapshotInitialize()
-	if err != nil {
-		return
-	}
-
-	b.zfs.M.Lock()
-	defer b.zfs.M.Unlock()
-
-	timestamp := cfg.Now.Format("2006-01-02_15.04.05")
-	name := fmt.Sprintf("%s-%s--%s", schedule, timestamp, cfg.Zfsnap[schedule])
-	_, err = b.ssh.exec("zfs snapshot " + path + "@" + name)
-
-	if err != nil {
-		return
-	}
-
-	b.zfs.SnapshotAdded = true
-	b.zfs.SnapshotList = append(b.zfs.SnapshotList, Snapshot(path+"@"+name))
-
-	return
 }
 
-func (b *Box) ZFSGetLastSnapshot(path string) (last Snapshot, err error) {
+func (b *Box) Unlock() {
-	if *debugFlag {
+	log.WithFields(log.Fields{"name": b.name}).Debugf("starting")
-		log.Printf("Box.ZFSGetLastSnapshot : %s : Start %s (%d snapshots)", b.Name, path, len(b.zfs.SnapshotList))
+	b.mx.Unlock()
-	}
-
-	if !b.online {
-		err = fmt.Errorf("box offline")
-		return
-	}
-
-	err = b.SnapshotInitialize()
-	if err != nil {
-		return last, err
-	}
-
-	b.zfs.M.Lock()
-	defer b.zfs.M.Unlock()
-
-	for _, v := range b.zfs.SnapshotList {
-		if v.Path() == path {
-			last = v
-		}
-	}
-	if len(string(last)) == 0 {
-		err = fmt.Errorf("no snapshot")
-	}
-	return
 }
 
-func (b *Box) ZFSIsLastSnapshot(src Snapshot) (is bool, err error) {
+func (c *Config) NewBox(name, addr, user, key string) (b *Box, err error) {
-	if *debugFlag {
+	log.WithFields(log.Fields{"name": name, "addr": addr, "user": user, "key": key}).Debugf("starting")
-		log.Printf("Box.ZFSIsLastSnapshot : %s : Start %s", b.Name, string(src))
+	defer log.WithFields(log.Fields{"name": name, "addr": addr, "user": user, "key": key}).Debugf("done")
+
+	re := regexp.MustCompile(boxNamePattern)
+	if !re.MatchString(name) {
+		err := errors.New("invalid name")
+		log.WithFields(log.Fields{"name": b.name, "error": err}).Errorf("")
+		return nil, err
 	}
 
-	if !b.online {
+	p, err := NewSshPool(name, addr, user, key)
-		err = fmt.Errorf("box offline")
-		return
-	}
-
-	err = b.SnapshotInitialize()
 	if err != nil {
-		return
+		log.WithFields(log.Fields{"name": b.name, "call": "NewSshPool", "error": err}).Errorf("")
+		return nil, err
 	}
 
-	_, err = b.ZFSGetNextSnapshot(src)
+	b = &Box{
-	if err != nil {
+		name: name,
-		if err.Error() == "no snapshot" {
+		addr: addr,
-			is = true
+		user: user,
-			err = nil
+		key:  key,
-		}
+		zfs: &BoxZfs{
-	} else {
+			online: false,
-		is = false
+		},
+		sshPool: p,
+		online:  false,
+		created: true,
 	}
-	return
+
+	b.zfs.box = b
+
+	return b, nil
 }
 
-func (b *Box) ZFSGetFirstSnapshot(path string) (first Snapshot, err error) {
+func (b *Box) Open() error {
-	if *debugFlag {
+	log.WithFields(log.Fields{"name": b.name}).Debugf("starting")
-		log.Printf("Box.ZFSGetFirstSnapshot : %s : Start %s", b.Name, path)
+	defer log.WithFields(log.Fields{"name": b.name}).Debugf("done")
-	}
 
-	if !b.online {
+	b.Lock()
-		err = fmt.Errorf("box offline")
+	defer b.Unlock()
-		return
-	}
 
-	err = b.SnapshotInitialize()
+	if b.online {
-	if err != nil {
-		return
-	}
-
-	b.zfs.M.Lock()
-	defer b.zfs.M.Unlock()
-
-	for _, v := range b.zfs.SnapshotList {
-		if v.Path() == path {
-			first = v
-			return
-		}
-	}
-	err = fmt.Errorf("no snapshot")
-	return
-}
-
-func (b *Box) ZFSGetNextSnapshot(src Snapshot) (next Snapshot, err error) {
-	if *debugFlag {
-		log.Printf("Box.ZFSGetNextSnapshot : %s : Start %s", b.Name, string(src))
-	}
-
-	if !b.online {
-		err = fmt.Errorf("box offline")
-		return
-	}
-
-	err = b.SnapshotInitialize()
-	if err != nil {
-		return
-	}
-
-	b.zfs.M.Lock()
-	defer b.zfs.M.Unlock()
-
-	for id, v := range b.zfs.SnapshotList {
-		if v == src {
-			if len(b.zfs.SnapshotList) > id+1 {
-				next = b.zfs.SnapshotList[id+1]
-				if next.Path() == src.Path() {
-					return
-				} else {
-					err = fmt.Errorf("no snapshot")
-					return
-				}
-			} else {
-				err = fmt.Errorf("no snapshot")
-				return
-			}
-		}
-	}
-	err = fmt.Errorf("no snapshot")
-	return
-}
-
-func (b *Box) ZFSUpdateSnapshotList() (err error) {
-	if *debugFlag {
-		log.Printf("Box.ZFSUpdateSnapshotList : %s : Start", b.Name)
-	}
-
-	if !b.online {
-		err = fmt.Errorf("box offline")
-		return
-	}
-
-	b.zfs.M.Lock()
-	if b.zfs.SnapshotDeleted || b.zfs.SnapshotAdded {
-		b.zfs.SnapshotInitialized = false
-	}
-	b.zfs.M.Unlock()
-
-	err = b.SnapshotInitialize()
-	return
-}
-
-func (b *Box) ZFSGetSnapshotList() (snaps []Snapshot, err error) {
-	if *debugFlag {
-		log.Printf("Box.ZFSGetSnapshotList : %s : Start", b.Name)
-	}
-
-	if !b.online {
-		err = fmt.Errorf("box offline")
-		return
-	}
-
-	err = b.SnapshotInitialize()
-	if err != nil {
-		return
-	}
-
-	b.zfs.M.Lock()
-	defer b.zfs.M.Unlock()
-
-	snaps = b.zfs.SnapshotList
-	return
-}
-
-func (b *Box) SnapshotInitialize() (err error) {
-	if *debugFlag {
-		log.Printf("Box.SnapshotInitialize : %s : Start", b.Name)
-	}
-
-	if !b.online {
-		err = fmt.Errorf("box offline")
-		return
-	}
-
-	b.zfs.M.Lock()
-	defer b.zfs.M.Unlock()
-
-	if b.zfs.SnapshotInitialized {
 		return nil
 	}
 
-	if *debugFlag {
+	hostname, err := b.Exec("hostname")
-		log.Printf("Box.SnapshotInitialize : %s : Start", b.Name)
-	}
-
-	b.zfs.SnapshotList = make([]Snapshot, 0)
-
-	var buf *bytes.Buffer
-	buf, err = b.SSHExec("zfs list -H -t snapshot -o name")
-
-	csvReader := csv.NewReader(buf)
-	csvReader.Comma = '\t'
-	csvReader.FieldsPerRecord = 1
-
-	csvData, err := csvReader.ReadAll()
 	if err != nil {
-		if *debugFlag {
+		log.WithFields(log.Fields{"name": b.name, "call": "Exec", "attr": "hostname", "error": err}).Errorf("")
-			log.Printf("Box.SnapshotInitialize : %s : csvReader.ReadAll() : %s", b.Name, err)
-		}
 		return err
 	}
 
-	for _, rec := range csvData {
+	log.WithFields(log.Fields{"name": b.name}).Debugf("hostname : %s", hostname)
-		b.zfs.SnapshotList = append(b.zfs.SnapshotList, Snapshot(rec[0]))
-	}
 
-	if *debugFlag {
+	b.online = true
-		log.Printf("Box.SnapshotInitialize : %s : read %d zfs snapshots", b.Name, len(b.zfs.SnapshotList))
-	}
 
-	b.zfs.SnapshotInitialized = true
+	if err := b.zfs.Open(); err != nil {
-	b.zfs.SnapshotAdded = false
+		log.WithFields(log.Fields{"name": b.name, "call": "zfs.Open", "error": err}).Errorf("")
-	b.zfs.SnapshotDeleted = false
+		return err
+	}
 
 	return nil
 }
 
-func (b *Box) ZFSUpdateList() (err error) {
+func (b *Box) Close() error {
-	if *debugFlag {
+	log.WithFields(log.Fields{"name": b.name}).Debugf("starting")
-		log.Printf("Box.ZFSUpdateList : %s : Start", b.Name)
+	defer log.WithFields(log.Fields{"name": b.name}).Debugf("done")
-	}
+
+	b.Lock()
+	defer b.Unlock()
 
 	if !b.online {
-		err = fmt.Errorf("box offline")
+		return nil
-		return
 	}
 
-	b.zfs.M.Lock()
+	if err := b.zfs.Close(); err != nil {
-	if b.zfs.ZFSDeleted || b.zfs.ZFSAdded {
+		log.WithFields(log.Fields{"name": b.name, "call": "zfs.Close", "error": err}).Errorf("")
-		b.zfs.ZFSInitialized = false
+		return err
 	}
-	b.zfs.M.Unlock()
 
-	err = b.ZFSInitialize()
+	b.online = false
-	return
+
+	return nil
 }
 
-func (b *Box) ZFSIsZFS(path string) bool {
+func (b *Box) Exec(cmd string) (r string, err error) {
-	if *debugFlag {
+	log.WithFields(log.Fields{"name": b.name, "cmd": cmd}).Debugf("starting")
-		log.Printf("Box.ZFSIsZFS : %s : Start %s", b.Name, path)
+	defer log.WithFields(log.Fields{"name": b.name, "cmd": cmd}).Debugf("done")
+
+	if !b.created {
+		err := errors.New("box not initialized")
+		log.WithFields(log.Fields{"name": b.name, "error": err}).Errorf("")
+		return "", err
 	}
 
-	if !b.online {
+	v, err := b.sshPool.Get()
-		return false
-	}
-
-	err := b.ZFSInitialize()
 	if err != nil {
-		return false
+		log.WithFields(log.Fields{"name": b.name, "error": err, "call": "SshPool.Get"}).Errorf("")
+		return "", err
 	}
 
-	b.zfs.M.Lock()
+	defer b.sshPool.Put(v)
-	defer b.zfs.M.Unlock()
+	s := v.(*Ssh)
-
-	if _, ok := b.zfs.ZFSMap[path]; ok {
-		return true
-	}
-	return false
 
+	return s.Exec(cmd)
 }
 
-func (b *Box) ZFSCreateZFS(path string) (err error) {
+func TransferZfs(from Addr, to []Addr) (int, error) {
-	if *debugFlag {
+	log.WithFields(log.Fields{"from": from, "to": to}).Debugf("starting")
-		log.Printf("Box.ZFSCreateZFS : %s : Start %s", b.Name, path)
+	defer log.WithFields(log.Fields{"from": from, "to": to}).Debugf("done")
-	}
 
-	if !b.online {
+	count := 0
-		err = fmt.Errorf("box offline")
-		return
-	}
 
-	err = b.ZFSInitialize()
+	for _, dest := range to {
-	if err != nil {
+		if err := TransferDirectZfs(from, dest); err != nil {
-		return
+			log.WithFields(log.Fields{"from": from, "to": to, "call": "TransferDirectZfs", "attr": dest, "error": err}).Errorf("")
-	}
+			return count, err
-
-	b.zfs.M.Lock()
-	defer b.zfs.M.Unlock()
-
-	p := strings.Split(path, `/`)
-	var base string
-	for _, d := range p {
-		if base == "" {
-			base = d
 		} else {
-			base = base + `/` + d
+			count++
-		}
-		if _, ok := b.zfs.ZFSMap[base]; !ok {
-
-			if *debugFlag {
-				log.Printf("Box.ZFSCreateZFS : Creating %s:%s", b.Name, base)
-			}
-
-			_, err = b.SSHExec("zfs create -o mountpoint=none " + base)
-			if err != nil {
-				if *debugFlag {
-					log.Printf("Box.ZFSCreateZFS : %s : SSHExec : %s", b.Name, err)
-				}
-				return
-			}
-
-			b.zfs.ZFSMap[base] = "none"
-			b.zfs.ZFSAdded = true
 		}
 	}
 
-	return
+	return count, nil
+
 }
 
-func (b *Box) ZFSInitialize() (err error) {
+func TransferDirectZfs(from, to Addr) error {
-	b.zfs.M.Lock()
+	log.WithFields(log.Fields{"from": from, "to": to}).Debugf("starting")
-	defer b.zfs.M.Unlock()
+	defer log.WithFields(log.Fields{"from": from, "to": to}).Debugf("done")
-	if *debugFlag {
-		log.Printf("Box.ZFSInitialize : %s : Start", b.Name)
-	}
 
-	if !b.online {
+	var (
-		err = fmt.Errorf("box offline")
+		err                        error
-		return
+		fromSnapshots, toSnapshots []*ZfsSnapshot
-	}
+	)
 
-	if b.zfs.ZFSInitialized {
+	if fromSnapshots, err = from.ValidSnapshots(); err != nil {
-		return nil
+		log.WithFields(log.Fields{"from": from, "to": to, "call": "ValidSnapshots", "attr": from, "error": err}).Errorf("")
-	}
-
-	if *debugFlag {
-		log.Printf("Box.ZFSInitialize : %s : Start", b.Name)
-	}
-
-	b.zfs.ZFSMap = make(map[string]string)
-
-	var buf *bytes.Buffer
-	buf, err = b.SSHExec("zfs list -H -o name,mountpoint")
-
-	csvReader := csv.NewReader(buf)
-	csvReader.Comma = '\t'
-	csvReader.FieldsPerRecord = 2
-
-	csvData, err := csvReader.ReadAll()
-	if err != nil {
-		if *debugFlag {
-			log.Printf("Box.ZFSInitialize : %s : csvReader.ReadAll() : %s", b.Name, err)
-		}
 		return err
 	}
 
-	for _, rec := range csvData {
+	if len(fromSnapshots) == 0 {
-		b.zfs.ZFSMap[rec[0]] = rec[1]
+		return nil
 	}
 
-	b.zfs.ZFSInitialized = true
+	if toSnapshots, err = to.ValidSnapshots(); err != nil {
-	b.zfs.ZFSAdded = false
+		log.WithFields(log.Fields{"from": from, "to": to, "call": "ValidSnapshots", "attr": to, "error": err}).Errorf("")
-	b.zfs.ZFSDeleted = false
+		return err
+	}
+
+	if len(toSnapshots) == 0 {
+		log.WithFields(log.Fields{"from": from, "to": to}).Debugf("initiating destination")
+		if _, err := to.BoxExec("ssh " + from.Box() + " zfs send " + fromSnapshots[0].String() + " | zfs recv -F " + to.Path()); err != nil {
+			log.WithFields(log.Fields{"from": from, "to": to, "call": "BoxExec", "error": err}).Errorf("")
+			return err
+		}
+		newToSnapshot := &ZfsSnapshot{name: fromSnapshots[0].name, fs: cfg.box[to.Box()].zfs.filesystems[to.Path()]}
+		toSnapshots = append(toSnapshots, newToSnapshot)
+		cfg.box[to.Box()].zfs.filesystems[to.Path()].AddSnapshot(newToSnapshot)
+
+	}
+
+	fromFromSnapshotId := len(fromSnapshots) - 1
+	fromToSnapshotId := -1
+	for fromFromSnapshotId >= 0 {
+		fromToSnapshotId = len(toSnapshots) - 1
+		for fromToSnapshotId >= 0 {
+			if fromSnapshots[fromFromSnapshotId].name == toSnapshots[fromToSnapshotId].name {
+				break
+			}
+			fromToSnapshotId = fromToSnapshotId - 1
+		}
+		if fromToSnapshotId >= 0 {
+			break
+		}
+		fromFromSnapshotId = fromFromSnapshotId - 1
+	}
+
+	if fromFromSnapshotId == -1 {
+		err := errors.New("zfs snapshot unsync")
+		log.WithFields(log.Fields{"from": from, "to": to, "error": err}).Errorf("")
+		return err
+	}
+
+	if fromFromSnapshotId < len(fromSnapshots)-1 {
+		log.WithFields(log.Fields{"from": from, "to": to}).Debugf("transfering from %s to %s", fromSnapshots[fromFromSnapshotId].name, fromSnapshots[len(fromSnapshots)-1].name)
+		if _, err := to.BoxExec("ssh " + from.Box() + " zfs send -I " + fromSnapshots[fromFromSnapshotId].String() + " " + fromSnapshots[len(fromSnapshots)-1].String() + " | zfs recv -F " + to.Path()); err != nil {
+			log.WithFields(log.Fields{"from": from, "to": to, "call": "BoxExec", "error": err}).Errorf("")
+			return err
+		}
+
+		for _, v := range fromSnapshots[fromFromSnapshotId+1:] {
+			cfg.box[to.Box()].zfs.filesystems[to.Path()].AddSnapshot(&ZfsSnapshot{name: v.name, fs: cfg.box[to.Box()].zfs.filesystems[to.Path()]})
+		}
+	}
 
 	return nil
 }
-
-func (b *Box) SSHExec(cmd string) (buf *bytes.Buffer, err error) {
-	if !b.online {
-		err = fmt.Errorf("box offline")
-		return
-	}
-
-	buf, err = b.ssh.exec(cmd)
-	return
-}
-
-func (b *Box) Host() string {
-	s := strings.Split(string(b.Addr), `:`)
-	return s[0]
-}

config.go

@@ -1,227 +1,364 @@
 package main
 
 import (
-	"bytes"
+	_ "embed"
+
 	"encoding/json"
+	"errors"
 	"fmt"
-	"io/ioutil"
+	"os"
-	"log"
 	"regexp"
+	"sync"
 	"time"
 
-	"golang.org/x/crypto/ssh"
+	log "github.com/sirupsen/logrus"
+	"github.com/tailscale/hujson"
+	"github.com/tidwall/pretty"
 )
 
 type Config struct {
-	Zfsnap   map[string]string `json:"zfsnap"`
+	ScheduleDuration map[string]string     `json:"schedule,omitempty"`
-	Box      map[string]*Box   `json:"box"`
+	Box              map[string]*BoxConfig `json:"box,omitempty"`
-	Email    EmailConfig       `json:"email"`
+	Email            *EmailConfig          `json:"email,omitempty"`
-	Apps     []AppConfig       `json:"apps"`
+	Apps             []*AppConfig          `json:"apps,omitempty"`
-	Timezone string            `json:"timezone"`
+	Timezone         string                `json:"timezone,omitempty"`
-	Now      time.Time         `json:"-"`
+	Admin            *AdminConfig          `json:"admin,omitempty"`
+	box              map[string]*Box       `json:"-"`
+	apps             map[string]*App       `json:"-"`
+	timezone         *time.Location        `json:"-"`
 }
 
-//Load config from file
+var (
-func (c *Config) Load() error {
+	cfgMx  sync.Mutex
-	if *debugFlag {
+	cfgRun bool
-		log.Printf("SSHConfig.Load : Start")
+)
-	}
+
-	b, err := ioutil.ReadFile(*cfgFile)
+//go:embed assets/backup.sample.json
+var sampleCfg []byte
+
+type BoxConfig struct {
+	Addr string `json:"addr"`
+	User string `json:"user"`
+	Key  string `json:"key"`
+}
+
+type AppConfig struct {
+	Name         string            `json:"name"`
+	Schedule     []string          `json:"schedule"`
+	Sources      []string          `json:"src"`
+	Destinations []string          `json:"dest"`
+	Before       map[string]string `json:"before,omitempty"`
+	After        map[string]string `json:"after,omitempty"`
+	Active       bool              `json:"active,omitempty"`
+}
+
+type EmailConfig struct {
+	Active    bool     `json:"active"`
+	SmtpHost  string   `json:"smtp,omitempty"`
+	FromEmail string   `json:"email_from,omitempty"`
+	ToEmail   []string `json:"email_to,omitempty"`
+}
+
+func CfgLock() {
+	log.WithFields(log.Fields{}).Debugf("starting")
+	cfgMx.Lock()
+}
+
+func CfgUnlock() {
+	log.WithFields(log.Fields{}).Debugf("starting")
+	cfgMx.Unlock()
+
+}
+
+// Load config from file
+func LoadConfigFile(path string) (*Config, error) {
+	log.WithFields(log.Fields{"path": path}).Debugf("starting")
+	defer log.WithFields(log.Fields{"path": path}).Debugf("done")
+
+	b, err := os.ReadFile(path)
 	if err != nil {
-		if *debugFlag {
+		log.WithFields(log.Fields{"path": path, "error": err, "call": "os.ReadFile"}).Errorf("")
-			log.Printf("Config.Load : ioutil.ReadFile(%s) : %s", *cfgFile, err)
+		return nil, err
-		}
-		return err
 	}
 
-	err = json.Unmarshal(b, &c)
+	return LoadConfigByte(b)
+
+}
+
+// Load config from string
+func LoadConfigByte(conf []byte) (*Config, error) {
+	log.WithFields(log.Fields{}).Debugf("starting")
+	defer log.WithFields(log.Fields{}).Debugf("done")
+
+	c := &Config{}
+	if err := json.Unmarshal(sampleCfg, c); err != nil {
+		log.WithFields(log.Fields{"error": err, "call": "json.Unmarshal", "attr": "sampleCfg"}).Errorf("")
+		return nil, err
+	}
+
+	b, err := hujson.Standardize(conf)
 	if err != nil {
-		if *debugFlag {
+		log.WithFields(log.Fields{"error": err, "call": "hujson.Standardize"}).Errorf("")
-			log.Printf("Config.Load : json.Unmarshal : %s", err)
+		return nil, err
-		}
-		return err
 	}
 
-	if *debugFlag {
+	if err := json.Unmarshal(b, c); err != nil {
-		log.Printf("Config.Load :\r\n%v", cfg)
+		log.WithFields(log.Fields{"error": err, "call": "json.Unmarshal"}).Errorf("")
+		return nil, err
 	}
 
-	l, err := time.LoadLocation(cfg.Timezone)
+	c.timezone, err = time.LoadLocation(c.Timezone)
 	if err != nil {
-		if *debugFlag {
+		log.WithFields(log.Fields{"error": err, "call": "time.LoadLocation", "attr": cfg.Timezone}).Errorf("")
-			log.Printf("Config.Load : time.LoadLocation : %s", err)
+		return nil, err
-		}
-		return err
 	}
 
-	if len(cfg.Email.SmtpHost) == 0 {
+	if c.Email != nil {
-		if *debugFlag {
+		if c.Email.Active {
-			log.Printf("Config.Load : no smtp")
+			if len(c.Email.SmtpHost) == 0 {
+				err := fmt.Errorf("no smtp")
+				log.WithFields(log.Fields{"error": err}).Errorf("")
+				return nil, err
+			}
+
+			if len(c.Email.FromEmail) == 0 {
+				err := fmt.Errorf("no email from")
+				log.WithFields(log.Fields{"error": err}).Errorf("")
+				return nil, err
+			}
+
+			if len(c.Email.ToEmail) == 0 {
+				err := fmt.Errorf("no email to")
+				log.WithFields(log.Fields{"error": err}).Errorf("")
+				return nil, err
+			}
 		}
-		return fmt.Errorf("no smtp")
 	}
 
-	if len(cfg.Email.FromEmail) == 0 {
+	for k, v := range c.ScheduleDuration {
-		if *debugFlag {
+		switch k {
-			log.Printf("Config.Load : no email from")
+		case "hourly":
+		case "daily":
+		case "weekly":
+		case "monthly":
+		case "yearly":
+			if _, err := Expiration(time.Now(), v); err != nil {
+				log.WithFields(log.Fields{"schedule": k, "deadline": v, "error": err}).Errorf("")
+				return nil, err
+			}
+		default:
+			err := errors.New("invalid schedule")
+			log.WithFields(log.Fields{"schedule": k, "deadline": v, "error": err}).Errorf("")
+			return nil, err
 		}
-		return fmt.Errorf("no email from")
 	}
 
-	if len(cfg.Email.ToEmail) == 0 {
+	c.box = make(map[string]*Box)
-		if *debugFlag {
-			log.Printf("Config.Load : no email to")
-		}
-		return fmt.Errorf("no email to")
-	}
-
-	c.Now = time.Now().In(l)
-
 	for k, v := range c.Box {
-		v.Name = k
+		if b, err := c.NewBox(k, v.Addr, v.User, v.Key); err != nil {
-		v.online = false
+			log.WithFields(log.Fields{"call": "NewBox", "attr": k, "error": err}).Errorf("")
-		v.zfs = NewZFSConfig()
+			return nil, err
-		s := &SSHConfig{
-			logged: false,
-			name:   k,
-		}
-		v.ssh = s
-		keyRaw, err := ioutil.ReadFile(v.Key)
-		if err != nil {
-			if *debugFlag {
-				log.Printf("Config.Load : ioutil.ReadFile(%s) : %s", k, err)
-			}
-			return err
-		}
-
-		key, err := ssh.ParseRawPrivateKey(keyRaw)
-		if err != nil {
-			if *debugFlag {
-				log.Printf("Config.Load : ssh.ParseRawPrivateKey(%s) : %s", k, err)
-			}
-			return err
-		}
-
-		s.signer, err = ssh.NewSignerFromKey(key)
-		if err != nil {
-			if *debugFlag {
-				log.Printf("Config.Load : ssh.NewSignerFromKey(%s) : %s", k, err)
-			}
-			return err
-		}
-
-		s.config = &ssh.ClientConfig{
-			User: v.User,
-			Auth: []ssh.AuthMethod{
-				ssh.PublicKeys(s.signer),
-			},
-			HostKeyCallback: ssh.InsecureIgnoreHostKey(),
-			Timeout:         5 * time.Second,
-		}
-
-		s.client, err = ssh.Dial("tcp", v.Addr, s.config)
-		if err != nil {
-			if *debugFlag {
-				log.Printf("Config.Load : ssh.Dial(%s) : %s", k, err)
-			}
 		} else {
-			v.online = true
+			if _, ok := c.box[k]; ok {
-			session, err := s.client.NewSession()
+				err := errors.New("already exists")
-			if err != nil {
+				log.WithFields(log.Fields{"attr": k, "error": err}).Errorf("")
-				if *debugFlag {
+				return nil, err
-					log.Printf("Config.Load : client.NewSession(%s) : %s", k, err)
-				}
-				return err
 			}
-
+			c.box[k] = b
-			var b bytes.Buffer
-			session.Stdout = &b
-
-			err = session.Run("TZ=\"" + cfg.Timezone + "\" zfsnap --version")
-			if err != nil {
-				if *debugFlag {
-					log.Printf("Config.Load : client.NewSession(%s) : %s", k, err)
-				}
-				return err
-			}
-			if *debugFlag {
-				log.Printf("Config.Load : logged into %s : %s", k, b.String())
-			}
-			session.Close()
-			s.logged = true
 		}
 	}
 
-	for _, app := range c.Apps {
+	c.apps = make(map[string]*App)
-		for _, src := range app.Sources {
+	for _, v := range c.Apps {
-			if !src.Valid() {
+		if a, err := c.NewApp(v.Name, v.Sources, v.Destinations, v.Schedule, v.Before, v.After); err != nil {
-				return fmt.Errorf("Source not valid : %s", string(src))
+			log.WithFields(log.Fields{"call": "NewApp", "attr": v.Name, "error": err}).Errorf("")
+			return nil, err
+		} else {
+			if _, ok := c.apps[v.Name]; ok {
+				err := errors.New("app already exists")
+				log.WithFields(log.Fields{"app": v.Name, "error": err}).Errorf("")
+				return nil, err
 			}
-			if _, ok := cfg.Box[src.Box()]; !ok {
+			c.apps[v.Name] = a
-				return fmt.Errorf("No box defined for source : %s", string(src))
+			for k := range a.schedule {
-			}
+				if dur, ok := c.ScheduleDuration[k]; ok {
-			if !cfg.Box[src.Box()].online {
+					re := regexp.MustCompile(`^forever|([0-9]+(h|d|m|y))+$`)
-				email.items = append(email.items, fmt.Sprintf("Source box offline for app : %s", app.Name))
+					if !re.MatchString(dur) {
-			}
+						err := errors.New("incorrect schedule duration")
-		}
+						log.WithFields(log.Fields{"app": v.Name, "schedule": k, "error": err}).Errorf("")
-		var allOffline bool = true
+						return nil, err
-		for _, dest := range app.Destinations {
+					}
-			if !dest.Valid() {
+				} else {
-				return fmt.Errorf("Destination not valid : %s", string(dest))
+					err := errors.New("undefined schedule duration")
-			}
+					log.WithFields(log.Fields{"app": v.Name, "schedule": k, "error": err}).Errorf("")
-			if _, ok := cfg.Box[dest.Box()]; !ok {
+					return nil, err
-				return fmt.Errorf("No box defined for destination : %s", string(dest))
-			}
-			if cfg.Box[dest.Box()].online {
-				allOffline = false
-			}
-		}
-		if allOffline {
-			email.items = append(email.items, fmt.Sprintf("No online destination box for app : %s", app.Name))
-		}
-
-		for val, before := range app.Before {
-			_, err = regexp.Compile(val)
-			if err != nil {
-				if *debugFlag {
-					log.Printf("Config.Load : invalid regex : %s", val)
 				}
-				return err
-			}
-			if !before.Valid() {
-				return fmt.Errorf("Before not valid : %s", string(before))
-			}
-			if _, ok := cfg.Box[before.Box()]; !ok {
-				return fmt.Errorf("No box defined for before : %s", string(before))
-			}
-			if !cfg.Box[before.Box()].online {
-				email.items = append(email.items, fmt.Sprintf("Before box offline for app : %s", app.Name))
-			}
-		}
-		for val, after := range app.After {
-			_, err = regexp.Compile(val)
-			if err != nil {
-				if *debugFlag {
-					log.Printf("Config.Load : invalid regex : %s", val)
-				}
-				return err
-			}
-			if !after.Valid() {
-				return fmt.Errorf("After not valid : %s", string(after))
-			}
-			if _, ok := cfg.Box[after.Box()]; !ok {
-				return fmt.Errorf("No box defined for after : %s", string(after))
-			}
-			if !cfg.Box[after.Box()].online {
-				email.items = append(email.items, fmt.Sprintf("After box offline for app : %s", app.Name))
 			}
 		}
 	}
 
-	return nil
+	return c, nil
 }
 
-//Close config
+// Pretty config
-func (c *Config) Close() error {
+func (c *Config) Pretty() ([]byte, error) {
-	return nil
+	log.WithFields(log.Fields{}).Debugf("starting")
+	defer log.WithFields(log.Fields{}).Debugf("done")
+
+	CfgLock()
+	defer CfgUnlock()
+
+	b, err := json.Marshal(cfg)
+	if err != nil {
+		log.WithFields(log.Fields{"error": err, "call": "json.Marshal"}).Errorf("")
+		return nil, err
+	}
+
+	return pretty.PrettyOptions(b, &pretty.Options{Indent: "        "}), nil
+}
+
+// Pretty App Config
+func (a *AppConfig) Pretty() ([]byte, error) {
+	log.WithFields(log.Fields{}).Debugf("starting")
+	defer log.WithFields(log.Fields{}).Debugf("done")
+
+	CfgLock()
+	defer CfgUnlock()
+
+	b, err := json.Marshal(a)
+	if err != nil {
+		log.WithFields(log.Fields{"error": err, "call": "json.Marshal"}).Errorf("")
+		return nil, err
+	}
+
+	return pretty.PrettyOptions(b, &pretty.Options{Indent: "        "}), nil
+}
+
+// Save config
+func (c *Config) Save() error {
+	log.WithFields(log.Fields{}).Debugf("starting")
+	defer log.WithFields(log.Fields{}).Debugf("done")
+
+	r, err := cfg.Pretty()
+	if err != nil {
+		log.WithFields(log.Fields{"error": err, "call": "cfg.Pretty"}).Errorf("")
+		return err
+	}
+
+	f, err := os.Create(*cfgFile)
+	if err != nil {
+		log.WithFields(log.Fields{"error": err, "call": "os.Open"}).Errorf("")
+		return err
+	}
+
+	if _, err := f.Write(r); err != nil {
+		log.WithFields(log.Fields{"error": err, "call": "File.Write"}).Errorf("")
+		return err
+	}
+
+	return nil
+
+}
+
+// Run config
+func (c *Config) Run() {
+	log.WithFields(log.Fields{}).Debugf("starting")
+	defer log.WithFields(log.Fields{}).Debugf("done")
+
+	if cfgRun {
+		return
+	}
+
+	CfgLock()
+	defer CfgUnlock()
+
+	cfgRun = true
+	defer func() { cfgRun = false }()
+
+	e := NewEmail(time.Now())
+
+	var wg sync.WaitGroup
+
+	// Setup boxes
+	for _, b := range c.box {
+		wg.Add(1)
+		go func(box *Box) {
+			defer wg.Done()
+			if err := box.Open(); err != nil {
+				log.WithFields(log.Fields{"name": box.name, "call": "Open", "error": err}).Errorf("")
+				e.AddItem(fmt.Sprintf(" - Box : %s is down", box.name))
+				return
+			}
+		}(b)
+	}
+
+	wg.Wait()
+
+	// Run each app
+	for _, a := range cfg.apps {
+		wg.Add(1)
+		go func(app *App) {
+			if sched, err := app.RunTime(e.startTime); err != nil {
+				e.AddItem(fmt.Sprintf(" - App : Error running %s (%s)", app.name, err))
+			} else if *debug {
+				if sched != "" {
+					e.AddItem(fmt.Sprintf(" - App : Success backing up %s (%s)", app.name, sched))
+				} else {
+					e.AddItem(fmt.Sprintf(" - App : No backup for %s", app.name))
+				}
+			}
+			wg.Done()
+		}(a)
+	}
+
+	wg.Wait()
+
+	// Cleanup
+	for _, a := range cfg.apps {
+		for _, src := range a.sources {
+			if b, ok := c.box[src.Box()]; ok {
+				if fs, ok := b.zfs.filesystems[src.Path()]; ok {
+					fs.srcApps = append(fs.srcApps, a)
+				}
+			}
+			for _, dest := range a.destinations {
+				if b, ok := c.box[dest.Box()]; ok {
+					dest2 := dest.Append("/" + src.Box() + "/" + src.Path())
+					if fs, ok := b.zfs.filesystems[dest2.Path()]; ok {
+						fs.destApps = append(fs.destApps, a)
+					} else {
+						e.AddItem(fmt.Sprintf(" - Dest : No folder (%s)", dest2.String()))
+					}
+				}
+			}
+		}
+	}
+
+	for _, b := range cfg.box {
+		if b.online {
+			for _, fs := range b.zfs.filesystems {
+				if len(fs.srcApps) > 0 && !fs.backedUp {
+					log.WithFields(log.Fields{"box": b.name, "fs": fs.path}).Warnf("not backed up")
+					e.AddItem(fmt.Sprintf(" - Src : Folder not backed up (%s)", b.name+":"+fs.path))
+				}
+				if len(fs.destApps) == 0 && !fs.backedUp && fs.managed {
+					log.WithFields(log.Fields{"box": b.name, "fs": fs.path}).Warnf("managed")
+					e.AddItem(fmt.Sprintf(" - Dest : Folder managed (%s)", b.name+":"+fs.path))
+				}
+			}
+		}
+	}
+
+	// Stop
+	for _, b := range c.box {
+		if err := b.Close(); err != nil {
+			log.WithFields(log.Fields{"name": b.name, "call": "Close", "error": err}).Errorf("")
+		}
+	}
+
+	if len(e.items) > 0 {
+		if err := e.Send(cfg.Email.SmtpHost, cfg.Email.FromEmail, cfg.Email.ToEmail); err != nil {
+			log.WithFields(log.Fields{"call": "email.Send", "error": err}).Errorf("")
+		}
+	}
 }

const.go

@@ -0,0 +1,13 @@
+package main
+
+const (
+	boxNamePattern = `[a-zA-Z0-9\-_\.]`
+
+	zfsManagedPropertyName = "biz.siteop:managed"
+	zfsSnapshotPattern     = `^(?P<Schedule>hourly|daily|weekly|monthly|yearly|adhoc)\-(?P<Timestamp>[0-9]{4}-[0-9]{2}-[0-9]{2}_[0-9]{2}.[0-9]{2}.[0-9]{2})\-\-(?P<Expiration>forever|([0-9]+(h|d|m|y))+)$`
+	zfsSnapshotDatePattern = "2006-01-02_15.04.05"
+
+	serverAddr     = ":8080"
+	serverUsername = "admin"
+	serverPassword = "8c6976e5b5410415bde908bd4dee15dfb167a9c873fc4bb8a81f6f2ab448a918" //admin
+)

email.go

@@ -2,10 +2,13 @@ package main
 
 import (
 	"encoding/base64"
-	"log"
+	"fmt"
 	"net/smtp"
+	"sort"
 	"strings"
 	"time"
+
+	log "github.com/sirupsen/logrus"
 )
 
 type Email struct {
@@ -13,50 +16,79 @@ type Email struct {
 	items     []string
 }
 
-type EmailConfig struct {
+func NewEmail(now time.Time) *Email {
-	SmtpHost  string   `json:"smtp"`
+	log.WithFields(log.Fields{"now": now}).Debugf("starting")
-	FromEmail string   `json:"email_from"`
+	defer log.WithFields(log.Fields{"now": now}).Debugf("done")
-	ToEmail   []string `json:"email_to"`
+
+	return &Email{startTime: now, items: make([]string, 0)}
+}
+
+func (e *Email) AddItem(item string) {
+	log.WithFields(log.Fields{"item": item}).Debugf("starting")
+	defer log.WithFields(log.Fields{"item": item}).Debugf("done")
+	if cfg.Email.Active {
+		e.items = append(e.items, item)
+	}
+}
+
+func (e *Email) Send(addr, from string, to []string) error {
+	log.WithFields(log.Fields{}).Debugf("starting")
+	defer log.WithFields(log.Fields{}).Debugf("done")
+
+	if len(e.items) == 0 {
+		return nil
+	}
+
+	sort.Slice(e.items, func(i, j int) bool {
+		return e.items[i] < e.items[j]
+	})
+
+	body := e.items[0]
+	for _, item := range e.items[1:] {
+		body = body + "\r\n" + item
+	}
+
+	subject := fmt.Sprintf("Autobackup report (%s)", e.startTime)
+
+	if err := SendMail(addr, from, subject, body, to); err != nil {
+		log.WithFields(log.Fields{"addr": addr, "from": from, "subject": subject, "call": "SendMail", "error": err}).Errorf("")
+		return err
+	}
+
+	return nil
+
 }
 
 func SendMail(addr, from, subject, body string, to []string) error {
-	if *debugFlag {
+	log.WithFields(log.Fields{"addr": addr, "from": from, "subject": subject}).Debugf("starting")
-		log.Printf("SendMail : Start")
+	defer log.WithFields(log.Fields{"addr": addr, "from": from, "subject": subject}).Debugf("done")
-	}
+
 	r := strings.NewReplacer("\r\n", "", "\r", "", "\n", "", "%0a", "", "%0d", "")
 
 	c, err := smtp.Dial(addr)
 	if err != nil {
-		if *debugFlag {
+		log.WithFields(log.Fields{"addr": addr, "from": from, "subject": subject, "call": "smtp.Dial", "error": err}).Errorf("")
-			log.Printf("SendMail : %s : smtp.Dial (%s)", addr, err)
-		}
 		return err
 	}
 
 	defer c.Close()
 
 	if err = c.Mail(r.Replace(from)); err != nil {
-		if *debugFlag {
+		log.WithFields(log.Fields{"addr": addr, "from": from, "subject": subject, "call": "client.Mail", "error": err}).Errorf("")
-			log.Printf("SendMail : %s : client.Mail (%s)", from, err)
-		}
 		return err
 	}
 
 	for i := range to {
 		to[i] = r.Replace(to[i])
 		if err = c.Rcpt(to[i]); err != nil {
-			if *debugFlag {
+			log.WithFields(log.Fields{"addr": addr, "from": from, "subject": subject, "call": "client.Rcpt", "attr": to[i], "error": err}).Errorf("")
-				log.Printf("SendMail : %s : client.Rcpt (%s)", to[i], err)
-			}
 			return err
 		}
 	}
 
 	w, err := c.Data()
 	if err != nil {
-		if *debugFlag {
+		log.WithFields(log.Fields{"addr": addr, "from": from, "subject": subject, "call": "client.Date", "error": err}).Errorf("")
-			log.Printf("SendMail : client.Data (%s)", err)
-		}
 		return err
 	}
 
@@ -68,29 +100,21 @@ func SendMail(addr, from, subject, body string, to []string) error {
 		"Content-Transfer-Encoding: base64\r\n" +
 		"\r\n" + base64.StdEncoding.EncodeToString([]byte(body))
 
-	if *debugFlag {
-		log.Printf("SendMail :\r\n%s", msg)
-	}
-
 	_, err = w.Write([]byte(msg))
 	if err != nil {
-		if *debugFlag {
+		log.WithFields(log.Fields{"addr": addr, "from": from, "subject": subject, "call": "writer.Write", "error": err}).Errorf("")
-			log.Printf("SendMail : writer.Write (%s)", err)
-		}
 		return err
 	}
 
 	err = w.Close()
 	if err != nil {
-		if *debugFlag {
+		log.WithFields(log.Fields{"addr": addr, "from": from, "subject": subject, "call": "writer.Close", "error": err}).Errorf("")
-			log.Printf("SendMail : writer.Close (%s)", err)
-		}
 		return err
 	}
 
-	err = c.Quit()
+	if err = c.Quit(); err != nil {
-	if *debugFlag {
+		log.WithFields(log.Fields{"addr": addr, "from": from, "subject": subject, "call": "client.Quit", "error": err}).Errorf("")
-		log.Printf("SendMail : client.Quit (%s)", err)
+		return err
 	}
-	return err
+	return nil
 }

go.mod

@@ -1,8 +1,40 @@
 module git.siteop.biz/shoopea/backup
 
-go 1.16
+go 1.21
 
 require (
-	golang.org/x/crypto v0.0.0-20221005025214-4161e89ecf1b
+	github.com/gin-gonic/gin v1.9.1
-	golang.org/x/sys v0.0.0-20221006211917-84dc82d7e875 // indirect
+	github.com/robfig/cron/v3 v3.0.1
+	github.com/sethvargo/go-password v0.2.0
+	github.com/silenceper/pool v1.0.0
+	github.com/sirupsen/logrus v1.9.3
+	github.com/tailscale/hujson v0.0.0-20221223112325-20486734a56a
+	github.com/tidwall/pretty v1.2.1
+	golang.org/x/crypto v0.29.0
+)
+
+require (
+	github.com/bytedance/sonic v1.9.1 // indirect
+	github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311 // indirect
+	github.com/gabriel-vasile/mimetype v1.4.2 // indirect
+	github.com/gin-contrib/sse v0.1.0 // indirect
+	github.com/go-playground/locales v0.14.1 // indirect
+	github.com/go-playground/universal-translator v0.18.1 // indirect
+	github.com/go-playground/validator/v10 v10.14.0 // indirect
+	github.com/goccy/go-json v0.10.2 // indirect
+	github.com/json-iterator/go v1.1.12 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.4 // indirect
+	github.com/leodido/go-urn v1.2.4 // indirect
+	github.com/mattn/go-isatty v0.0.19 // indirect
+	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
+	github.com/modern-go/reflect2 v1.0.2 // indirect
+	github.com/pelletier/go-toml/v2 v2.0.8 // indirect
+	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
+	github.com/ugorji/go/codec v1.2.11 // indirect
+	golang.org/x/arch v0.3.0 // indirect
+	golang.org/x/net v0.21.0 // indirect
+	golang.org/x/sys v0.27.0 // indirect
+	golang.org/x/text v0.20.0 // indirect
+	google.golang.org/protobuf v1.30.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -1,12 +1,106 @@
-golang.org/x/crypto v0.0.0-20221005025214-4161e89ecf1b h1:huxqepDufQpLLIRXiVkTvnxrzJlpwmIWAObmcCcUFr0=
+github.com/bytedance/sonic v1.5.0/go.mod h1:ED5hyg4y6t3/9Ku1R6dU/4KyJ48DZ4jPhfY1O2AihPM=
-golang.org/x/crypto v0.0.0-20221005025214-4161e89ecf1b/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
+github.com/bytedance/sonic v1.9.1 h1:6iJ6NqdoxCDr6mbY8h18oSO+cShGSMRGCEo7F2h0x8s=
-golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+github.com/bytedance/sonic v1.9.1/go.mod h1:i736AoUSYt75HyZLoJW9ERYxcy6eaN6h4BZXU064P/U=
-golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+github.com/chenzhuoyu/base64x v0.0.0-20211019084208-fb5309c8db06/go.mod h1:DH46F32mSOjUmXrMHnKwZdA8wcEefY7UVqBKYGjpdQY=
-golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311 h1:qSGYFH7+jGhDF8vLC+iwCD4WpbV1EBDSzWkJODFLams=
-golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311/go.mod h1:b583jCggY9gE99b6G5LEC39OIiVsWj+R97kbl5odCEk=
-golang.org/x/sys v0.0.0-20221006211917-84dc82d7e875 h1:AzgQNqF+FKwyQ5LbVrVqOcuuFB67N47F9+htZYH0wFM=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-golang.org/x/sys v0.0.0-20221006211917-84dc82d7e875/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
-golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1 h1:v+OssWQX+hTHEmOBgwxdZxK4zHq3yOs8F9J7mk0PY8E=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+github.com/gabriel-vasile/mimetype v1.4.2 h1:w5qFW6JKBz9Y393Y4q372O9A7cUSequkh1Q7OhCmWKU=
-golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+github.com/gabriel-vasile/mimetype v1.4.2/go.mod h1:zApsH/mKG4w07erKIaJPFiX0Tsq9BFQgN3qGY5GnNgA=
-golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE=
+github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI=
+github.com/gin-gonic/gin v1.9.1 h1:4idEAncQnU5cB7BeOkPtxjfCSye0AAm1R0RVIqJ+Jmg=
+github.com/gin-gonic/gin v1.9.1/go.mod h1:hPrL7YrpYKXt5YId3A/Tnip5kqbEAP+KLuI3SUcPTeU=
+github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=
+github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
+github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA=
+github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY=
+github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY=
+github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
+github.com/go-playground/validator/v10 v10.14.0 h1:vgvQWe3XCz3gIeFDm/HnTIbj6UGmg/+t63MyGU2n5js=
+github.com/go-playground/validator/v10 v10.14.0/go.mod h1:9iXMNT7sEkjXb0I+enO7QXmzG6QCsPWY4zveKFVRSyU=
+github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU=
+github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
+github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
+github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.8 h1:e6P7q2lk1O+qJJb4BtCQXlK8vWEO8V1ZeuEdJNOqZyg=
+github.com/google/go-cmp v0.5.8/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
+github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
+github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
+github.com/klauspost/cpuid/v2 v2.2.4 h1:acbojRNwl3o09bUq+yDCtZFc1aiwaAAxtcn8YkZXnvk=
+github.com/klauspost/cpuid/v2 v2.2.4/go.mod h1:RVVoqg1df56z8g3pUjL/3lE5UfnlrJX8tyFgg4nqhuY=
+github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
+github.com/leodido/go-urn v1.2.4 h1:XlAE/cm/ms7TE/VMVoduSpNBoyc2dOxHs5MZSwAN63Q=
+github.com/leodido/go-urn v1.2.4/go.mod h1:7ZrI8mTSeBSHl/UaRyKQW1qZeMgak41ANeCNaVckg+4=
+github.com/mattn/go-isatty v0.0.19 h1:JITubQf0MOLdlGRuRq+jtsDlekdYPia9ZFsB8h/APPA=
+github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
+github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
+github.com/pelletier/go-toml/v2 v2.0.8 h1:0ctb6s9mE31h0/lhu+J6OPmVeDxJn+kYnJc2jZR9tGQ=
+github.com/pelletier/go-toml/v2 v2.0.8/go.mod h1:vuYfssBdrU2XDZ9bYydBu6t+6a6PYNcZljzZR9VXg+4=
+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/robfig/cron/v3 v3.0.1 h1:WdRxkvbJztn8LMz/QEvLN5sBU+xKpSqwwUO1Pjr4qDs=
+github.com/robfig/cron/v3 v3.0.1/go.mod h1:eQICP3HwyT7UooqI/z+Ov+PtYAWygg1TEWWzGIFLtro=
+github.com/sethvargo/go-password v0.2.0 h1:BTDl4CC/gjf/axHMaDQtw507ogrXLci6XRiLc7i/UHI=
+github.com/sethvargo/go-password v0.2.0/go.mod h1:Ym4Mr9JXLBycr02MFuVQ/0JHidNetSgbzutTr3zsYXE=
+github.com/silenceper/pool v1.0.0 h1:JTCaA+U6hJAA0P8nCx+JfsRCHMwLTfatsm5QXelffmU=
+github.com/silenceper/pool v1.0.0/go.mod h1:3DN13bqAbq86Lmzf6iUXWEPIWFPOSYVfaoceFvilKKI=
+github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
+github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=
+github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
+github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+github.com/stretchr/testify v1.8.3 h1:RP3t2pwF7cMEbC1dqtB6poj3niw/9gnV4Cjg5oW5gtY=
+github.com/stretchr/testify v1.8.3/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/tailscale/hujson v0.0.0-20221223112325-20486734a56a h1:SJy1Pu0eH1C29XwJucQo73FrleVK6t4kYz4NVhp34Yw=
+github.com/tailscale/hujson v0.0.0-20221223112325-20486734a56a/go.mod h1:DFSS3NAGHthKo1gTlmEcSBiZrRJXi28rLNd/1udP1c8=
+github.com/tidwall/pretty v1.2.1 h1:qjsOFOWWQl+N3RsoF5/ssm1pHmJJwhjlSbZ51I6wMl4=
+github.com/tidwall/pretty v1.2.1/go.mod h1:ITEVvHYasfjBbM0u2Pg8T2nJnzm8xPwvNhhsoaGGjNU=
+github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI=
+github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
+github.com/ugorji/go/codec v1.2.11 h1:BMaWp1Bb6fHwEtbplGBGJ498wD+LKlNSl25MjdZY4dU=
+github.com/ugorji/go/codec v1.2.11/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg=
+golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
+golang.org/x/arch v0.3.0 h1:02VY4/ZcO/gBOH6PUaoiptASxtXU10jazRCP865E97k=
+golang.org/x/arch v0.3.0/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
+golang.org/x/crypto v0.29.0 h1:L5SG1JTTXupVV3n6sUqMTeWbjAyfPwoda2DLX8J8FrQ=
+golang.org/x/crypto v0.29.0/go.mod h1:+F4F4N5hv6v38hfeYwTdx20oUvLLc+QfrE9Ax9HtgRg=
+golang.org/x/net v0.21.0 h1:AQyQV4dYCvJ7vGmJyKki9+PBdyvhkSd8EIx/qb0AYv4=
+golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44=
+golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20220704084225-05e143d24a9e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.27.0 h1:wBqf8DvsY9Y/2P8gAfPDEYNuS30J4lPHJxXSb/nJZ+s=
+golang.org/x/sys v0.27.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/term v0.26.0 h1:WEQa6V3Gja/BhNxg540hBip/kkaYtRg3cxg4oXSw4AU=
+golang.org/x/term v0.26.0/go.mod h1:Si5m1o57C5nBNQo5z1iq+XDijt21BDBDp2bK0QI8e3E=
+golang.org/x/text v0.20.0 h1:gK/Kv2otX8gz+wn7Rmb3vT96ZwuoxnQlY+HlJVj7Qug=
+golang.org/x/text v0.20.0/go.mod h1:D4IsuqiFMhST5bX19pQ9ikHC2GsaKyk/oF+pn3ducp4=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
+google.golang.org/protobuf v1.30.0 h1:kPPoIgf3TsEvrm0PFe15JQ+570QVxYzEvvHqChK+cng=
+google.golang.org/protobuf v1.30.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4=

location.go

@@ -1,20 +1 @@
 package main
-
-import "strings"
-
-type Location string
-
-func (l Location) Box() string {
-	s := strings.Split(string(l), `:`)
-	return s[0]
-}
-
-func (l Location) Path() string {
-	s := strings.Split(string(l), `:`)
-	return s[1]
-}
-
-func (l Location) Valid() bool {
-	s := strings.Split(string(l), `:`)
-	return len(s) == 2
-}

snapshot.go

@@ -1,20 +1,123 @@
 package main
 
-import "strings"
+import (
+	"errors"
+	"regexp"
+	"time"
 
-type Snapshot string
+	log "github.com/sirupsen/logrus"
+)
 
-func (s Snapshot) Path() string {
+func SnapshotName(schedule string, now time.Time) string {
-	s2 := strings.Split(string(s), `@`)
+	log.WithFields(log.Fields{"schedule": schedule, "now": now}).Debugf("starting")
-	return s2[0]
+	log.WithFields(log.Fields{"schedule": schedule, "now": now}).Debugf("done")
+
+	return schedule + "-" + now.Format(zfsSnapshotDatePattern) + "--" + cfg.ScheduleDuration[schedule]
 }
 
-func (s Snapshot) Name() string {
+func (s *ZfsSnapshot) Valid() bool {
-	s2 := strings.Split(string(s), `@`)
+	log.WithFields(log.Fields{"box": s.fs.zfs.box.name, "fs": s.fs.path, "name": s.name}).Debugf("starting")
-	return s2[1]
+	defer log.WithFields(log.Fields{"box": s.fs.zfs.box.name, "fs": s.fs.path, "name": s.name}).Debugf("done")
+
+	re := regexp.MustCompile(zfsSnapshotPattern)
+	return re.MatchString(s.name)
 }
 
-func (s Snapshot) Append(path string) Snapshot {
+func (s *ZfsSnapshot) Schedule() (string, error) {
-	s2 := strings.Split(string(s), `@`)
+	log.WithFields(log.Fields{"box": s.fs.zfs.box.name, "fs": s.fs.path, "name": s.name}).Debugf("starting")
-	return Snapshot(s2[0] + "/" + path + "@" + s2[1])
+	defer log.WithFields(log.Fields{"box": s.fs.zfs.box.name, "fs": s.fs.path, "name": s.name}).Debugf("done")
+
+	if !s.Valid() {
+		err := errors.New("invalid name")
+		log.WithFields(log.Fields{"box": s.fs.zfs.box.name, "fs": s.fs.path, "name": s.name, "call": "Valid", "error": err}).Errorf("")
+		return "", err
+	}
+
+	re := regexp.MustCompile(zfsSnapshotPattern)
+
+	return re.ReplaceAllString(s.name, "${Schedule}"), nil
+
+}
+
+func (s *ZfsSnapshot) Expiration() (time.Time, error) {
+	log.WithFields(log.Fields{"box": s.fs.zfs.box.name, "fs": s.fs.path, "name": s.name}).Debugf("starting")
+	defer log.WithFields(log.Fields{"box": s.fs.zfs.box.name, "fs": s.fs.path, "name": s.name}).Debugf("done")
+
+	if !s.Valid() {
+		err := errors.New("invalid name")
+		log.WithFields(log.Fields{"box": s.fs.zfs.box.name, "fs": s.fs.path, "name": s.name, "call": "Valid", "error": err}).Errorf("")
+		return time.Now(), err
+	}
+
+	re := regexp.MustCompile(zfsSnapshotPattern)
+
+	expirationString := re.ReplaceAllString(s.name, "${Expiration}")
+
+	timestampTime, err := s.Timestamp()
+	if err != nil {
+		log.WithFields(log.Fields{"box": s.fs.zfs.box.name, "fs": s.fs.path, "name": s.name, "call": "Timestamp", "error": err}).Errorf("")
+		return time.Now(), err
+	}
+
+	return Expiration(timestampTime, expirationString)
+
+}
+
+func (s *ZfsSnapshot) Timestamp() (time.Time, error) {
+	log.WithFields(log.Fields{"box": s.fs.zfs.box.name, "fs": s.fs.path, "name": s.name}).Debugf("starting")
+	defer log.WithFields(log.Fields{"box": s.fs.zfs.box.name, "fs": s.fs.path, "name": s.name}).Debugf("done")
+
+	t := time.Now()
+
+	if !s.Valid() {
+		err := errors.New("invalid name")
+		log.WithFields(log.Fields{"box": s.fs.zfs.box.name, "fs": s.fs.path, "name": s.name, "call": "Valid", "error": err}).Errorf("")
+		return t, err
+	}
+
+	re := regexp.MustCompile(zfsSnapshotPattern)
+
+	timestampString := re.ReplaceAllString(s.name, "${Timestamp}")
+	timestampTime, err := time.ParseInLocation(zfsSnapshotDatePattern, timestampString, cfg.timezone)
+	if err != nil {
+		log.WithFields(log.Fields{"box": s.fs.zfs.box.name, "fs": s.fs.path, "name": s.name, "call": "time.Parse", "attr": timestampString, "error": err}).Errorf("")
+		return t, err
+	}
+
+	return timestampTime, nil
+}
+
+func (s *ZfsSnapshot) Expired(now time.Time) (bool, error) {
+	log.WithFields(log.Fields{"box": s.fs.zfs.box.name, "fs": s.fs.path, "name": s.name}).Debugf("starting")
+	defer log.WithFields(log.Fields{"box": s.fs.zfs.box.name, "fs": s.fs.path, "name": s.name}).Debugf("done")
+
+	if !s.Valid() {
+		err := errors.New("invalid name")
+		log.WithFields(log.Fields{"box": s.fs.zfs.box.name, "fs": s.fs.path, "name": s.name, "call": "Valid", "error": err}).Errorf("")
+		return false, err
+	}
+
+	expirationTime, err := s.Expiration()
+	if err != nil {
+		log.WithFields(log.Fields{"box": s.fs.zfs.box.name, "fs": s.fs.path, "name": s.name, "call": "Timestamp", "error": err}).Errorf("")
+		return false, err
+	}
+
+	if now.After(expirationTime) {
+		return true, nil
+	} else {
+		return false, nil
+	}
+
+}
+
+func (s *ZfsSnapshot) String() string {
+	return s.fs.path + "@" + s.name
+}
+
+func (s *ZfsSnapshot) Delete() error {
+	log.WithFields(log.Fields{"box": s.fs.zfs.box.name, "fs": s.fs.path, "name": s.name}).Debugf("starting")
+	defer log.WithFields(log.Fields{"box": s.fs.zfs.box.name, "fs": s.fs.path, "name": s.name}).Debugf("done")
+
+	return s.fs.DelSnapshot(s.name)
 }

ssh.go

@@ -1,47 +1,170 @@
 package main
 
 import (
-	"bytes"
+	"io"
-	"log"
+	"os"
+	"time"
 
+	"github.com/silenceper/pool"
+	log "github.com/sirupsen/logrus"
 	"golang.org/x/crypto/ssh"
 )
 
-type SSHConfig struct {
+const SshDialTimeout = time.Duration(10 * time.Second)
-	signer   ssh.Signer
+const SshInactivityTimeout = time.Duration(time.Minute)
-	config   *ssh.ClientConfig
+
-	client   *ssh.Client
+type Ssh struct {
-	logged   bool
+	name    string
-	name     string
+	signer  ssh.Signer
-	snapshot []Snapshot
+	config  *ssh.ClientConfig
+	client  *ssh.Client
+	session *ssh.Session
+	in      io.WriteCloser
+	out     io.Reader
+	err     io.Reader
 }
 
-func (s *SSHConfig) exec(cmd string) (b *bytes.Buffer, err error) {
+func NewSsh(name, addr, user, key string) (*Ssh, error) {
-	if *debugFlag {
+	log.WithFields(log.Fields{"name": name, "addr": addr, "user": user, "key": key}).Debugf("starting")
-		log.Printf("SSHConfig.exec : %s : Start %s", s.name, cmd)
+	defer log.WithFields(log.Fields{"name": name, "addr": addr, "user": user, "key": key}).Debugf("done")
+
+	s := &Ssh{
+		name: name,
 	}
 
+	k, err := os.ReadFile(key)
+	if err != nil {
+		log.WithFields(log.Fields{"name": name, "addr": addr, "user": user, "key": key, "call": "os.ReadFile", "error": err}).Errorf("")
+		return s, err
+	}
+
+	parsedKey, err := ssh.ParseRawPrivateKey(k)
+	if err != nil {
+		log.WithFields(log.Fields{"name": name, "addr": addr, "user": user, "key": key, "call": "ssh.ParseRawPrivateKey", "error": err}).Errorf("")
+		return s, err
+	}
+
+	s.signer, err = ssh.NewSignerFromKey(parsedKey)
+	if err != nil {
+		log.WithFields(log.Fields{"name": name, "addr": addr, "user": user, "key": key, "call": "ssh.NewSignerFromKey", "error": err}).Errorf("")
+		return s, err
+	}
+
+	s.config = &ssh.ClientConfig{
+		User: user,
+		Auth: []ssh.AuthMethod{
+			ssh.PublicKeys(s.signer),
+		},
+		HostKeyCallback: ssh.InsecureIgnoreHostKey(),
+		Timeout:         SshDialTimeout,
+	}
+
+	s.client, err = ssh.Dial("tcp", addr, s.config)
+	if err != nil {
+		log.WithFields(log.Fields{"name": name, "addr": addr, "user": user, "key": key, "call": "ssh.Dial", "error": err}).Errorf("")
+		return s, err
+	}
+
+	return s, nil
+
+}
+
+func (s *Ssh) Close() error {
+	log.WithFields(log.Fields{"name": s.name}).Debugf("starting")
+	defer log.WithFields(log.Fields{"name": s.name}).Debugf("done")
+
+	return s.client.Close()
+}
+
+func NewSshPool(name, addr, user, key string) (pool.Pool, error) {
+	log.WithFields(log.Fields{"name": name, "addr": addr, "user": user, "key": key}).Debugf("starting")
+	defer log.WithFields(log.Fields{"name": name, "addr": addr, "user": user, "key": key}).Debugf("done")
+
+	//factory Specify the method to create the connection
+	factory := func() (interface{}, error) { return NewSsh(name, addr, user, key) }
+
+	// close Specify the method to close the connection
+	close := func(v interface{}) error { return v.(*Ssh).Close() }
+
+	// Create a connection pool: Initialize the number of connections to 0, the maximum idle connection is 2, and the maximum concurrent connection is 25
+	poolConfig := &pool.Config{
+		InitialCap: 0,
+		MaxIdle:    2,
+		MaxCap:     25,
+		Factory:    factory,
+		Close:      close,
+		//Ping:       ping,
+		//The maximum idle time of the connection, the connection exceeding this time will be closed, which can avoid the problem of automatic failure when connecting to EOF when idle
+		IdleTimeout: SshInactivityTimeout,
+	}
+
+	return pool.NewChannelPool(poolConfig)
+}
+
+func (s *Ssh) Exec(cmd string) (string, error) {
+	log.WithFields(log.Fields{"name": s.name, "cmd": cmd}).Debugf("starting")
+	defer log.WithFields(log.Fields{"name": s.name, "cmd": cmd}).Debugf("done")
+
+	if err := s.ExecPipe(cmd); err != nil {
+		log.WithFields(log.Fields{"name": s.name, "cmd": cmd, "call": "ssh.ExecPipe", "error": err}).Errorf("")
+		return "", err
+	}
+	defer s.session.Close()
+
+	if err := s.session.Wait(); err != nil {
+		log.WithFields(log.Fields{"name": s.name, "cmd": cmd, "call": "session.Setenv", "error": err}).Errorf("")
+		return "", err
+	}
+
+	buf, err := io.ReadAll(s.out)
+	if err != nil {
+		log.WithFields(log.Fields{"name": s.name, "cmd": cmd, "call": "io.ReadAll", "error": err}).Errorf("")
+		return "", err
+	}
+
+	return string(buf), nil
+
+}
+
+func (s *Ssh) ExecPipe(cmd string) error {
+	log.WithFields(log.Fields{"name": s.name, "cmd": cmd}).Debugf("starting")
+	defer log.WithFields(log.Fields{"name": s.name, "cmd": cmd}).Debugf("done")
+
 	session, err := s.client.NewSession()
 	if err != nil {
-		if *debugFlag {
+		log.WithFields(log.Fields{"name": s.name, "cmd": cmd, "call": "client.NewSession", "error": err}).Errorf("")
-			log.Printf("SSHConfig.exec : %s : client().NewSession(%s) : %s", s.name, cmd, err)
+		return err
-		}
+	}
-		return
+	s.session = session
+
+	if err = s.session.Setenv("TZ", cfg.Timezone); err != nil {
+		log.WithFields(log.Fields{"name": s.name, "cmd": cmd, "call": "session.Setenv", "attr": cfg.Timezone, "error": err}).Errorf("")
+		return err
 	}
 
-	var buf bytes.Buffer
+	if s.in, err = s.session.StdinPipe(); err != nil {
-	b = &buf
+		log.WithFields(log.Fields{"name": s.name, "cmd": cmd, "call": "session.StdinPipe", "error": err}).Errorf("")
-	session.Stdout = b
+		s.session.Close()
-
+		return err
-	err = session.Run("TZ=\"" + cfg.Timezone + "\" " + cmd)
-	if err != nil {
-		if *debugFlag {
-			log.Printf("SSHConfig.exec : session(%s).Run(%s) : %s", s.name, cmd, err)
-		}
-		return
 	}
 
-	session.Close()
+	if s.out, err = s.session.StdoutPipe(); err != nil {
+		log.WithFields(log.Fields{"name": s.name, "cmd": cmd, "call": "session.StdoutPipe", "error": err}).Errorf("")
+		s.session.Close()
+		return err
+	}
 
-	return
+	if s.err, err = s.session.StderrPipe(); err != nil {
+		log.WithFields(log.Fields{"name": s.name, "cmd": cmd, "call": "session.StderrPipe", "error": err}).Errorf("")
+		s.session.Close()
+		return err
+	}
+
+	if err = s.session.Start(cmd); err != nil {
+		log.WithFields(log.Fields{"name": s.name, "cmd": cmd, "call": "session.Start", "attr": cmd, "error": err}).Errorf("")
+		s.session.Close()
+		return err
+	}
+
+	return nil
 }

utils.go

@@ -0,0 +1,41 @@
+package main
+
+import (
+	"errors"
+	"regexp"
+	"strconv"
+	"time"
+
+	log "github.com/sirupsen/logrus"
+)
+
+func Expiration(now time.Time, deadline string) (time.Time, error) {
+	log.WithFields(log.Fields{"now": now, "deadline": deadline}).Debugf("starting")
+	defer log.WithFields(log.Fields{"now": now, "deadline": deadline}).Debugf("done")
+
+	if deadline == "forever" {
+		return time.Unix(1<<63-1, 0), nil
+	}
+
+	reExpiration := regexp.MustCompile(`([0-9]+)([a-z]+)`)
+	for _, v := range reExpiration.FindAllStringSubmatch(deadline, -1) {
+		log.WithFields(log.Fields{"now": now, "deadline": deadline}).Debugf("duration[%d] : %v", len(v), v)
+		count, _ := strconv.Atoi(v[1])
+		switch v[2] {
+		case "y":
+			now = now.AddDate(count, 0, 0)
+		case "m":
+			now = now.AddDate(0, count, 0)
+		case "d":
+			now = now.AddDate(0, 0, count)
+		case "h":
+			now = now.Add(time.Duration(time.Duration(count) * time.Hour))
+		default:
+			err := errors.New("invalid duration")
+			log.WithFields(log.Fields{"now": now, "deadline": deadline, "attr": v[2], "error": err}).Errorf("")
+			return time.Now(), err
+		}
+	}
+
+	return now, nil
+}

version.go

@@ -1,6 +1,7 @@
 // Code generated by version.sh (@generated) DO NOT EDIT.
 package main
-var githash = "7f9cf49"
+var githash = "05054be"
-var buildstamp = "2022-10-08_03:14:52"
+var branch = "master"
-var commits = "54"
+var buildstamp = "2025-10-26_09:32:26"
-var version = "7f9cf49-b54 - 2022-10-08_03:14:52"
+var commits = "116"
+var version = "05054be-b116 - 2025-10-26_09:32:26"

version.sh

@@ -1,12 +1,14 @@
 # Get the version.
 githash=`git rev-parse --short HEAD`
+branch=`git rev-parse --abbrev-ref HEAD`
 buildstamp=`date -u '+%Y-%m-%d_%H:%M:%S'`
-commits=`git rev-list --count master`
+commits=`git rev-list --count $branch`
 # Write out the package.
 cat << EOF > version.go
 // Code generated by version.sh (@generated) DO NOT EDIT.
 package main
 var githash = "$githash"
+var branch = "$branch"
 var buildstamp = "$buildstamp"
 var commits = "$commits"
 var version = "$githash-b$commits - $buildstamp"

zfs.go

@@ -1,27 +1,352 @@
 package main
 
-import "sync"
+import (
+	"bytes"
+	"encoding/csv"
+	"errors"
+	"fmt"
+	"regexp"
+	"sort"
+	"strings"
+	"sync"
 
-type ZFSConfig struct {
+	log "github.com/sirupsen/logrus"
-	SnapshotAdded       bool
+)
-	SnapshotDeleted     bool
+
-	SnapshotInitialized bool
+type BoxZfs struct {
-	SnapshotList        []Snapshot
+	filesystems map[string]*ZfsFs
-	ZFSAdded            bool
+	box         *Box
-	ZFSDeleted          bool
+	online      bool
-	ZFSInitialized      bool
+	mx          sync.Mutex
-	ZFSMap              map[string]string
-	M                   sync.Mutex
 }
 
-func NewZFSConfig() (z *ZFSConfig) {
+type ZfsFs struct {
-	z = &ZFSConfig{
+	path      string
-		SnapshotAdded:       false,
+	managed   bool
-		SnapshotDeleted:     false,
+	backedUp  bool
-		SnapshotInitialized: false,
+	zfs       *BoxZfs
-		ZFSAdded:            false,
+	snapshots map[string]*ZfsSnapshot
-		ZFSDeleted:          false,
+	srcApps   []*App
-		ZFSInitialized:      false,
+	destApps  []*App
+	mx        sync.Mutex
+}
+
+type ZfsSnapshot struct {
+	name string
+	fs   *ZfsFs
+}
+
+func (z *BoxZfs) Lock() {
+	log.WithFields(log.Fields{"name": z.box.name}).Debugf("starting")
+	z.mx.Lock()
+}
+
+func (z *BoxZfs) Unlock() {
+	log.WithFields(log.Fields{"name": z.box.name}).Debugf("starting")
+	z.mx.Unlock()
+}
+
+func (fs *ZfsFs) Lock() {
+	log.WithFields(log.Fields{"box": fs.zfs.box.name, "fs": fs.path}).Debugf("starting")
+	fs.mx.Lock()
+}
+
+func (fs *ZfsFs) Unlock() {
+	log.WithFields(log.Fields{"box": fs.zfs.box.name, "fs": fs.path}).Debugf("starting")
+	fs.mx.Unlock()
+}
+
+func (z *BoxZfs) Open() error {
+	log.WithFields(log.Fields{"name": z.box.name}).Debugf("starting")
+	defer log.WithFields(log.Fields{"name": z.box.name}).Debugf("done")
+
+	z.Lock()
+	defer z.Unlock()
+
+	if z.online {
+		return nil
 	}
-	return
+
+	z.filesystems = make(map[string]*ZfsFs)
+
+	zfsList, err := z.box.Exec("zfs list -H -t filesystem -o name,mountpoint")
+	if err != nil {
+		log.WithFields(log.Fields{"name": z.box.name, "call": "Exec", "attr": "zfs list -H -t filesystem -o name,mountpoint", "error": err}).Errorf("")
+		return err
+	}
+
+	csvReader := csv.NewReader(bytes.NewBufferString(zfsList))
+	csvReader.Comma = '\t'
+	csvReader.FieldsPerRecord = 2
+
+	csvData, err := csvReader.ReadAll()
+	if err != nil {
+		log.WithFields(log.Fields{"name": z.box.name, "call": "csvReader.ReadAll", "error": err}).Errorf("")
+		return err
+	}
+
+	for _, rec := range csvData {
+		log.WithFields(log.Fields{"name": z.box.name, "zfs-name": rec[0], "zfs-mount": rec[1]}).Debugf("zfs list -t filesystem")
+		if rec[1] != "legacy" {
+			fs := &ZfsFs{
+				path:      rec[0],
+				zfs:       z,
+				snapshots: make(map[string]*ZfsSnapshot),
+			}
+			z.filesystems[rec[0]] = fs
+			log.WithFields(log.Fields{"name": z.box.name, "fs": rec[0]}).Infof("new filesystem")
+		}
+	}
+
+	log.WithFields(log.Fields{"name": z.box.name, "call": "csvReader.ReadAll"}).Infof("")
+
+	zfsList, err = z.box.Exec("zfs list -H -t snapshot -o name")
+	if err != nil {
+		log.WithFields(log.Fields{"name": z.box.name, "call": "Exec", "attr": "zfs list -H -t snapshot -o name", "error": err}).Errorf("")
+		return err
+	}
+
+	csvReader = csv.NewReader(bytes.NewBufferString(zfsList))
+	csvReader.Comma = '\t'
+	csvReader.FieldsPerRecord = 1
+
+	csvData, err = csvReader.ReadAll()
+	if err != nil {
+		log.WithFields(log.Fields{"name": z.box.name, "call": "csvReader.ReadAll", "error": err}).Errorf("")
+		return err
+	}
+
+	for _, rec := range csvData {
+		log.WithFields(log.Fields{"name": z.box.name, "zfs-snapshot": rec[0]}).Debugf("zfs list -t snapshot")
+
+		s := strings.Split(rec[0], `@`)
+		if fs, ok := z.filesystems[s[0]]; ok {
+			snap := &ZfsSnapshot{
+				name: s[1],
+				fs:   fs,
+			}
+			fs.snapshots[s[1]] = snap
+			log.WithFields(log.Fields{"name": z.box.name, "fs": s[0], "snapshot": s[1]}).Infof("new snapshot")
+		}
+	}
+
+	zfsList, err = z.box.Exec("zfs get -H -o name,value " + zfsManagedPropertyName)
+	if err != nil {
+		log.WithFields(log.Fields{"name": z.box.name, "call": "Exec", "attr": "zfs get -H -o name,value,source " + zfsManagedPropertyName, "error": err}).Errorf("")
+		return err
+	}
+
+	csvReader = csv.NewReader(bytes.NewBufferString(zfsList))
+	csvReader.Comma = '\t'
+	csvReader.FieldsPerRecord = 2
+
+	csvData, err = csvReader.ReadAll()
+	if err != nil {
+		log.WithFields(log.Fields{"name": z.box.name, "call": "csvReader.ReadAll", "error": err}).Errorf("")
+		return err
+	}
+
+	for _, rec := range csvData {
+		log.WithFields(log.Fields{"name": z.box.name, "zfs-fs": rec[0], "zfs-value": rec[1]}).Debugf("zfs get " + zfsManagedPropertyName)
+
+		if fs, ok := z.filesystems[rec[0]]; ok {
+			if rec[1] == "+" {
+				fs.managed = true
+				log.WithFields(log.Fields{"name": z.box.name, "zfs-fs": rec[0], "zfs-value": rec[1]}).Infof("managed fs")
+			}
+		}
+	}
+
+	z.online = true
+
+	return nil
+}
+
+func (z *BoxZfs) Close() error {
+	log.WithFields(log.Fields{"name": z.box.name}).Debugf("starting")
+	defer log.WithFields(log.Fields{"name": z.box.name}).Debugf("done")
+
+	z.Lock()
+	defer z.Unlock()
+
+	for _, fs := range z.filesystems {
+		fs.Lock()
+		defer fs.Unlock()
+	}
+
+	z.online = false
+
+	return nil
+}
+
+func (z *BoxZfs) Mkdir(path string) error {
+	log.WithFields(log.Fields{"name": z.box.name}).Debugf("starting")
+	defer log.WithFields(log.Fields{"name": z.box.name}).Debugf("done")
+
+	if !z.online {
+		err := errors.New("zfs offline")
+		log.WithFields(log.Fields{"name": z.box.name, "error": err}).Errorf("")
+		return err
+	}
+
+	z.Lock()
+	defer z.Unlock()
+
+	b := z.box
+	if !b.online {
+		err := errors.New("box offline")
+		log.WithFields(log.Fields{"name": z.box.name, "error": err}).Errorf("")
+		return err
+	}
+
+	if _, ok := z.filesystems[path]; ok {
+		return nil
+	}
+
+	if _, err := b.Exec(fmt.Sprintf("zfs create -p %s", path)); err != nil {
+		log.WithFields(log.Fields{"name": z.box.name, "call": "Exec", "error": err}).Errorf("")
+		return err
+	}
+
+	newPath := ""
+	for _, p := range strings.Split(path, "/") {
+		if newPath == "" {
+			newPath = p
+		} else {
+			newPath = newPath + "/" + p
+		}
+
+		if _, ok := z.filesystems[newPath]; !ok {
+			fs := &ZfsFs{
+				path:      newPath,
+				managed:   false,
+				zfs:       z,
+				snapshots: make(map[string]*ZfsSnapshot),
+				srcApps:   make([]*App, 0),
+				destApps:  make([]*App, 0),
+			}
+			z.filesystems[newPath] = fs
+		}
+
+	}
+
+	return nil
+}
+
+func (fs *ZfsFs) TakeSnapshot(name string) (*ZfsSnapshot, error) {
+	log.WithFields(log.Fields{"box": fs.zfs.box.name, "fs": fs.path, "name": name}).Debugf("starting")
+	defer log.WithFields(log.Fields{"box": fs.zfs.box.name, "fs": fs.path, "name": name}).Debugf("done")
+
+	if !fs.zfs.online {
+		err := errors.New("zfs offline")
+		log.WithFields(log.Fields{"box": fs.zfs.box.name, "fs": fs.path, "name": name, "error": err}).Errorf("")
+		return nil, err
+	}
+
+	re := regexp.MustCompile(`^[a-zA-Z0-9\-\._]{1,255}$`)
+	if !re.MatchString(name) {
+		err := errors.New("unsupported name")
+		log.WithFields(log.Fields{"box": fs.zfs.box.name, "fs": fs.path, "name": name, "error": err}).Errorf("")
+		return nil, err
+	}
+
+	fs.Lock()
+	defer fs.Unlock()
+
+	if _, ok := fs.snapshots[name]; ok {
+		err := errors.New("already exists")
+		log.WithFields(log.Fields{"box": fs.zfs.box.name, "fs": fs.path, "name": name, "error": err}).Errorf("")
+		return nil, err
+	}
+
+	if _, err := fs.zfs.box.Exec("zfs snapshot " + fs.path + "@" + name); err != nil {
+		log.WithFields(log.Fields{"box": fs.zfs.box.name, "fs": fs.path, "name": name, "error": err}).Errorf("")
+		return nil, err
+	}
+
+	s := &ZfsSnapshot{
+		name: name,
+		fs:   fs,
+	}
+
+	fs.snapshots[name] = s
+
+	return s, nil
+}
+
+func (fs *ZfsFs) DelSnapshot(name string) error {
+	log.WithFields(log.Fields{"box": fs.zfs.box.name, "fs": fs.path, "name": name}).Debugf("starting")
+	defer log.WithFields(log.Fields{"box": fs.zfs.box.name, "fs": fs.path, "name": name}).Debugf("done")
+
+	if !fs.zfs.online {
+		err := errors.New("zfs offline")
+		log.WithFields(log.Fields{"box": fs.zfs.box.name, "fs": fs.path, "name": name, "error": err}).Errorf("")
+		return err
+	}
+
+	fs.Lock()
+	defer fs.Unlock()
+
+	if _, ok := fs.snapshots[name]; !ok {
+		err := errors.New("doesn't exist")
+		log.WithFields(log.Fields{"box": fs.zfs.box.name, "fs": fs.path, "name": name, "error": err}).Errorf("")
+		return err
+	}
+
+	log.WithFields(log.Fields{"box": fs.zfs.box.name, "fs": fs.path, "name": name}).Debugf("zfs destroy " + fs.path + "@" + name)
+
+	if _, err := fs.zfs.box.Exec("zfs destroy " + fs.path + "@" + name); err != nil {
+		log.WithFields(log.Fields{"box": fs.zfs.box.name, "fs": fs.path, "name": name, "error": err}).Errorf("")
+		return err
+	}
+
+	delete(fs.snapshots, name)
+
+	return nil
+
+}
+
+func (fs *ZfsFs) AddSnapshot(s *ZfsSnapshot) error {
+	log.WithFields(log.Fields{"box": fs.zfs.box.name, "fs": fs.path, "name": s.name}).Debugf("starting")
+	defer log.WithFields(log.Fields{"box": fs.zfs.box.name, "fs": fs.path, "name": s.name}).Debugf("done")
+
+	if !fs.zfs.online {
+		err := errors.New("zfs offline")
+		log.WithFields(log.Fields{"box": fs.zfs.box.name, "fs": fs.path, "name": s.name, "error": err}).Errorf("")
+		return err
+	}
+
+	fs.Lock()
+	defer fs.Unlock()
+
+	if _, ok := fs.snapshots[s.name]; ok {
+		err := errors.New("already exist")
+		log.WithFields(log.Fields{"box": fs.zfs.box.name, "fs": fs.path, "name": s.name, "error": err}).Errorf("")
+		return err
+	}
+
+	fs.snapshots[s.name] = s
+
+	return nil
+}
+
+func (fs *ZfsFs) ValidSnapshots() []*ZfsSnapshot {
+	log.WithFields(log.Fields{"box": fs.zfs.box.name, "fs": fs.path}).Debugf("starting")
+	defer log.WithFields(log.Fields{"box": fs.zfs.box.name, "fs": fs.path}).Debugf("done")
+
+	tab := make([]*ZfsSnapshot, 0)
+
+	for _, s := range fs.snapshots {
+		if s.Valid() {
+			tab = append(tab, s)
+		}
+	}
+
+	sort.Slice(tab, func(i, j int) bool {
+		ti, _ := tab[i].Timestamp()
+		tj, _ := tab[j].Timestamp()
+		return ti.Before(tj)
+	})
+
+	return tab
 }