shoopea/backup
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

v2 #2

Merged
shoopea merged 29 commits from v2 into master 2023-08-21 20:03:11 +02:00
Conversation 0 Commits 29 Files Changed 65 +130 -10
7 changed files with 130 additions and 10 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit b4d27e0867 - Show all commits

61
addr.go
View File

@ -2,6 +2,7 @@ package main
import (
"errors"
"fmt"
"regexp"
"strings"
@ -50,7 +51,7 @@ func (a Addr) BoxExec(cmd string) (string, error) {
if b, ok := cfg.box[a.Box()]; !ok {
err := errors.New("box doesn't exist")
log.WithFields(log.Fields{"addr": a, "box": a.Box()}).Errorf("")
log.WithFields(log.Fields{"addr": a, "box": a.Box(), "error": err}).Errorf("")
return "", err
} else {
return b.Exec(cmd)
@ -70,26 +71,78 @@ func (a Addr) ValidSnapshots() ([]*ZfsSnapshot, error) {
if b, ok := cfg.box[a.Box()]; !ok {
err := errors.New("box doesn't exist")
log.WithFields(log.Fields{"addr": a, "box": a.Box()}).Errorf("")
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}).Errorf("")
log.WithFields(log.Fields{"addr": a, "error": err}).Errorf("")
return nil, err
}
}
}
func (a Addr) SetManaged(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.mx.Lock()
defer fs.mx.Unlock()
if fs.managed != val {
var cmd string
if val {
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 = val
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.mx.Lock()
defer fs.mx.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()}).Errorf("")
log.WithFields(log.Fields{"addr": a, "box": a.Box(), "error": err}).Errorf("")
return err
} else {
return b.zfs.Mkdir(a.Path())

16
app.go
View File

@ -302,6 +302,13 @@ func (a *App) Run(now time.Time) error {
}
}
for _, src := range a.sources {
if err := src.SetManaged(true); err != nil {
log.WithFields(log.Fields{"app": a.name, "call": "src.SetManaged", "error": err}).Errorf("")
return err
}
}
if err := a.Transfer(); err != nil {
log.WithFields(log.Fields{"app": a.name, "call": "Transfer", "error": err}).Errorf("")
return err
@ -481,8 +488,17 @@ func (a *App) Transfer() error {
log.WithFields(log.Fields{"app": a.name, "call": "TransferZfs", "src": src, "dest": dest, "error": err}).Errorf("")
return err
}
if err := dest.SetManaged(true); err != nil {
log.WithFields(log.Fields{"app": a.name, "call": "SetManaged", "src": src, "dest": dest, "error": err}).Errorf("")
return err
}
}
}
if err := src.SetBackedUp(true); err != nil {
log.WithFields(log.Fields{"app": a.name, "call": "SetBackedUp", "src": src, "error": err}).Errorf("")
return err
}
}
return nil

6
backup.go
View File

@ -61,6 +61,12 @@ func main() {
cfg.Run(e)
cfg.Cleanup(e)
if err := e.Send(); err != nil {
log.Printf("Cannot send email (%s)", err)
}
os.Exit(0)
}

38
config.go
View File

@ -202,6 +202,44 @@ func (c *Config) Run(e *Email) {
return
}
func (c *Config) Cleanup(e *Email) {
log.WithFields(log.Fields{}).Debugf("starting")
defer log.WithFields(log.Fields{}).Debugf("done")
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[src.Box()]; ok {
if fs, ok := b.zfs.filesystems[dest.Append("/"+src.Box()+"/"+src.Path()).Path()]; ok {
fs.destApps = append(fs.destApps, a)
}
}
}
}
}
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))
}
}
}
}
}
func (c *Config) Stop(e *Email) {
log.WithFields(log.Fields{}).Debugf("starting")
defer log.WithFields(log.Fields{}).Debugf("done")

4
email.go
View File

@ -41,6 +41,10 @@ func (e *Email) Send() error {
log.WithFields(log.Fields{}).Debugf("starting")
defer log.WithFields(log.Fields{}).Debugf("done")
if len(e.items) == 0 {
return nil
}
body := " - " + e.items[0]
for _, item := range e.items[1:] {
body = body + "\r\n" + item

8
version.go
View File

@ -1,7 +1,7 @@
// Code generated by version.sh (@generated) DO NOT EDIT.
package main
var githash = "e07c1c4"
var githash = "24a5e66"
var branch = "v2"
var buildstamp = "2023-07-01_20:33:58"
var commits = "65"
var version = "e07c1c4-b65 - 2023-07-01_20:33:58"
var buildstamp = "2023-07-31_08:12:46"
var commits = "66"
var version = "24a5e66-b66 - 2023-07-31_08:12:46"

7
zfs.go
View File

@ -23,9 +23,11 @@ type BoxZfs struct {
type ZfsFs struct {
path string
managed bool
backedUp bool
zfs *BoxZfs
snapshots map[string]*ZfsSnapshot
apps []*App
srcApps []*App
destApps []*App
mx sync.Mutex
}
@ -200,7 +202,8 @@ func (z *BoxZfs) Mkdir(path string) error {
managed: false,
zfs: z,
snapshots: make(map[string]*ZfsSnapshot),
apps: make([]*App, 0),
srcApps: make([]*App, 0),
destApps: make([]*App, 0),
}
z.filesystems[newPath] = fs
}