GUI implementation of notifications

.github/workflows/go-release.yml

@@ -1,6 +1,6 @@
 name: Go
 
-on: 
+on:
   release
 
 jobs:
@@ -13,7 +13,7 @@ jobs:
     - name: Set up Go
       uses: actions/setup-go@v2
       with:
-        go-version: 1.17
+        go-version: 1.19
     - name: Install GoReleaser
       uses: goreleaser/goreleaser-action@v2.7.0
       with:

.github/workflows/go.yml

@@ -12,11 +12,15 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v2
+    - name: setup runner
+      run: |
+        # sudo apt search xorg
+        sudo apt-get install -y xserver-xorg libxcursor-dev libxrandr-dev libxinerama-dev libxi-dev libglvnd-dev libxxf86vm-dev
 
     - name: Set up Go
       uses: actions/setup-go@v2
       with:
-        go-version: 1.17
+        go-version: 1.19
     - name: Install GoReleaser
       uses: goreleaser/goreleaser-action@v2.7.0
       with:

.goreleaser.yml

@@ -33,7 +33,8 @@ builds:
     id: "backive_ui"
     binary: backive_ui
     env:
-      - CGO_ENABLED=0
+      - CGO_ENABLED=1
+      - GOOS=linux
     goarch:
       - amd64
     goos:

backive-example.yml

@@ -40,6 +40,7 @@ backups:
 settings:
   systemMountPoint: /mnt/backups
   unixSocketLocation: /var/local/backive/backive.sock
+  uiUnixSocketLocation: /var/local/backive/ui.sock
   logLocation: /var/log/backive
   dbLocation: /var/lib/backive
 

backive.puml

@@ -0,0 +1,121 @@
+@startuml
+namespace backive {
+    class Backup << (S,Aquamarine) >> {
+        - logger *log.Logger
+
+        + Name string
+        + TargetDevice string
+        + TargetPath string
+        + SourcePath string
+        + ScriptPath <font color=blue>interface</font>{}
+        + Frequency int
+        + ExeUser string
+        + Label string
+
+        + CanRun() error
+        + PrepareRun() error
+        + Run() error
+        + ShouldRun() bool
+
+    }
+    class Backups << (S,Aquamarine) >> {
+        + FindBackupsForDevice(d Device) ([]*Backup, bool)
+
+    }
+    class Configuration << (S,Aquamarine) >> {
+        + Settings Settings
+        + Devices Devices
+        + Backups Backups
+        + Vconfig *viper.Viper
+
+        + CreateViper() 
+        + Load() 
+
+    }
+    class Database << (S,Aquamarine) >> {
+        - data <font color=blue>map</font>[string]<font color=blue>interface</font>{}
+
+        + Save() 
+        + Load() 
+
+    }
+    class Device << (S,Aquamarine) >> {
+        - isMounted bool
+
+        + Name string
+        + UUID string
+        + OwnerUser string
+
+        + Mount() error
+        + Unmount() error
+        + IsMounted() bool
+
+    }
+    class EventHandler << (S,Aquamarine) >> {
+        - ls net.Listener
+        - callbacks []<font color=blue>func</font>(<font color=blue>map</font>[string]string) 
+
+        - process() 
+
+        + Init(socketPath string) error
+        + Listen() 
+        + RegisterCallback(cb <font color=blue>func</font>(<font color=blue>map</font>[string]string) ) 
+
+    }
+    class MsgLvls << (S,Aquamarine) >> {
+        + Error MsgLevel
+        + Finish MsgLevel
+        + Remind MsgLevel
+        + Info MsgLevel
+        + Debug MsgLevel
+
+    }
+    class Runs << (S,Aquamarine) >> {
+        - data <font color=blue>map</font>[string][]time.Time
+
+        + Load(db Database) 
+        + Save(db Database) 
+        + RegisterRun(b *Backup) 
+        + LastRun(b *Backup) (time.Time, error)
+
+    }
+    class Settings << (S,Aquamarine) >> {
+        + SystemMountPoint string
+        + UserMountPoint string
+        + UnixSocketLocation string
+        + UIUnixSocketLocation string
+        + LogLocation string
+        + DbLocation string
+
+    }
+    class UIHandler << (S,Aquamarine) >> {
+        - ls net.Listener
+        - client net.Conn
+
+        + Init(socketPath string) error
+        + Listen() 
+        + DisplayMessage(header string, message string, level MsgLevel) error
+
+    }
+    class backive.Backups << (T, #FF7700) >>  {
+    }
+    class backive.Devices << (T, #FF7700) >>  {
+    }
+    class backive.MsgLevel << (T, #FF7700) >>  {
+    }
+}
+
+
+namespace ui {
+    class uiSettings << (S,Aquamarine) >> {
+        - hideUntil time.Time
+        - globalLevel int
+
+    }
+}
+
+
+"__builtin__.int" #.. "backive.MsgLevel"
+"backive.<font color=blue>map</font>[string]*Backup" #.. "backive.Backups"
+"backive.<font color=blue>map</font>[string]*Device" #.. "backive.Devices"
+@enduml

backup.go

@@ -93,6 +93,7 @@ func (b *Backup) PrepareRun() error {
 // Run runs the backup script with appropriate rights.
 func (b *Backup) Run() error {
 	log.Printf("Running backup '%s'.", b.Name)
+	UiHdl.DisplayMessage("Backive backup", fmt.Sprintf("Running backup '%s'...", b.Name), MsgLevels.Info)
 	dev, ok := config.Devices[b.TargetDevice]
 	if ok {
 		log.Printf("Device found: %s (%s).", dev.Name, dev.UUID)
@@ -102,15 +103,14 @@ func (b *Backup) Run() error {
 	}
 	if ok && dev.IsMounted() {
 		var scriptWArgs []string
+		// ScriptPath may be an slice/array of a script path with parameters or just a string with a script path
 		switch slice := b.ScriptPath.(type) {
 		case []interface{}:
 			for _, v := range slice {
 				scriptWArgs = append(scriptWArgs, v.(string))
 			}
 		case []string:
-			for _, v := range slice {
-				scriptWArgs = append(scriptWArgs, v)
-			}
+			scriptWArgs = append(scriptWArgs, slice...)
 		case string:
 			scriptWArgs = append(scriptWArgs, slice)
 		default:
@@ -156,6 +156,7 @@ func (b *Backup) Run() error {
 			return err
 		}
 		runs.RegisterRun(b)
+		UiHdl.DisplayMessage("Backive backup", fmt.Sprintf("Finished backup '%s'", b.Name), MsgLevels.Info)
 		return nil
 	}
 	// quit with error that the device is not available.
@@ -170,24 +171,53 @@ type Runs struct {
 // Load loads the data from the json database
 func (r *Runs) Load(db Database) {
 	data := db.data["runs"]
-	if data != "" {
-		runerr := json.Unmarshal([]byte(db.data["runs"]), &r.data)
-		if runerr != nil {
-			panic(runerr)
+	if data != nil {
+		log.Println("Loading runs db")
+		switch d := data.(type) {
+		case string:
+			// be able to read the old version
+			log.Println("Loading legacy data")
+			runerr := json.Unmarshal([]byte(data.(string)), &r.data)
+			if runerr != nil {
+				panic(runerr)
+			}
+		case map[string]interface{}:
+			log.Println("Loading data")
+			if r.data == nil {
+				r.data = make(map[string][]time.Time)
+			}
+			raw := data.(map[string]interface{})
+			for k, v := range raw {
+				r.data[k] = make([]time.Time, 0)
+				for _, i := range v.([]interface{}) {
+					t, _ := time.Parse(time.RFC3339Nano, i.(string))
+					r.data[k] = append(r.data[k], t)
+				}
+			}
+			LogToJson(data)
+		default:
+			log.Printf("got data type: %s", d)
 		}
 	}
+	log.Println("Data loaded:")
+	LogToJson(r.data)
 }
 
 // Save saves the data into the json database
 func (r *Runs) Save(db Database) {
 	if db.data == nil {
-		db.data = map[string]string{}
+		db.data = map[string]interface{}{}
 	}
-	str, err := json.Marshal(r.data)
+	db.data["runs"] = r.data
+	LogToJson(db.data)
+}
+
+func LogToJson(data interface{}) {
+	str, err := json.Marshal(data)
 	if err != nil {
 		panic(err)
 	}
-	db.data["runs"] = string(str)
+	log.Printf("Data: %s", str)
 }
 
 // ShouldRun Takes a backup key and returns a bool if a backup should run now.
@@ -205,17 +235,21 @@ func (b *Backup) ShouldRun() bool {
 	if freq == 0 {
 		return true
 	}
+	if ok != nil && lr.Equal(time.Unix(0, 0)) {
+		return true
+	}
 	return false
 }
 
 // RegisterRun saves a date of a backup run into the internal storage
 func (r *Runs) RegisterRun(b *Backup) {
 	if r.data == nil {
-		r.data = map[string][]time.Time{}
+		x := map[string][]time.Time{}
+		r.data = x
 	}
 	nbl, ok := r.data[b.Name]
 	if !ok {
-		nbl = make([]time.Time, 1)
+		nbl = make([]time.Time, 0)
 	}
 	nbl = append([]time.Time{time.Now()}, nbl...)
 	r.data[b.Name] = nbl

backup_test.go

@@ -170,3 +170,5 @@ func TestRun(t *testing.T) {
 		return nil
 	}
 }
+
+// TODO: write a test for the lastRun method!

cmd/backive/main.go

@@ -55,14 +55,19 @@ func defaultCallback(envMap map[string]string) {
 			log.Printf("Device: Name: %s, UUID: %s", dev.Name, dev.UUID)
 			backups, found := config.Backups.FindBackupsForDevice(*dev)
 			log.Println("Searching configured backups...")
+			bnames := make([]string, 0)
+			for _, v := range backups {
+				bnames = append(bnames, v.Name)
+			}
+			log.Printf("Found backups: %s", bnames)
 			if found {
+				// only mount device if we really have to do a backup!
+				dev.Mount()
+				log.Println("Device mounted.")
 				for _, backup := range backups {
-					log.Printf("Backup found: %s", backup.Name)
+					log.Printf("Backup running: %s", backup.Name)
 					err := backup.CanRun()
 					if err == nil {
-						// only mount device if we really have to do a backup!
-						dev.Mount()
-						log.Println("Device mounted.")
 						log.Println("Backup is able to run (config check passed).")
 						prepErr := backup.PrepareRun()
 						log.Println("Prepared run.")
@@ -74,11 +79,15 @@ func defaultCallback(envMap map[string]string) {
 						if rerr != nil {
 							log.Printf("Error running the backup routine: %v", err)
 						}
-						dev.Unmount()
 					} else {
-						log.Printf("Backup '%s' can not run (error or frequency not reached): %s", backup.Name, err)
+						msg := fmt.Sprintf("Backup '%s' can not run (error or frequency not reached): %s", backup.Name, err)
+						log.Printf(msg)
+						backive.UiHdl.DisplayMessage("Backive backup", msg, backive.MsgLevels.Info)
 					}
 				}
+				if dev.IsMounted() {
+					dev.Unmount()
+				}
 			} else {
 				log.Println("No backup found.")
 			}
@@ -127,17 +136,22 @@ func main() {
 		if err != nil {
 			log.Printf("Removal of %s failed.", config.Settings.UnixSocketLocation)
 		}
+		err = os.Remove(config.Settings.UIUnixSocketLocation)
+		if err != nil {
+			log.Printf("Removal of %s failed.", config.Settings.UIUnixSocketLocation)
+		}
 		os.Exit(code)
 	}()
 
-	// TODO: do proper signal handling!
 	log.Println("backive starting up...")
 	// find and load config
 	database.Load()
 	config.Load()
 	setupLogging()
 	backive.Init(config, database)
-
+	backive.UiHdl.Init(config.Settings.UIUnixSocketLocation)
+	// Start UIHandler to be able to inform users through notifications
+	go backive.UiHdl.Listen()
 	// init scheduler and check for next needed runs?
 	// start event loop
 	events.Init(config.Settings.UnixSocketLocation)