Refactoring

Can run as daemon

doc.go

@@ -1,6 +0,0 @@
-// hipa project doc.go
-
-/*
-hipa document
-*/
-package main

e-hipa.service

@@ -0,0 +1,9 @@
+[Unit]
+Description=e-hipa - bash history packer
+Wants=syncthing-inotify.service
+
+[Service]
+ExecStart=/usr/bin/e-hipa
+
+[Install]
+WantedBy=default.target

e-hipa.timer

@@ -0,0 +1,6 @@
+[Unit]
+Description=Hourly e-hipa timer
+
+[Timer]
+OnBootSec=1min
+OnUnitActiveSec=1h

main.go

@@ -1,70 +1,16 @@
 package main
 
-import (
-	"bufio"
-	"fmt"
-	"os"
-	"strings"
-)
-
-// map for old history records
-var history = make(map[string]int)
-
-// path ${HOME}/.bash_history
-var h Hfile
-
-// path /tmp/.bash_history******/.bash_history
-var t Tmpfile
-
-func init() {
-	h.name = ".bash_history"
-	h.init()
-	h.Open()
-
-	t.name = h.name
-	t.init()
-	t.Open()
-}
+import "log"
 
 func main() {
-	//read old history
-	scanner := bufio.NewScanner(h.handle)
-	var i = 0
-	for scanner.Scan() {
-		line := strings.TrimSpace(scanner.Text())
-		history[line] = i
-		i++
-	}
-	delete(history, "")
-	h.handle.Close()
-
-	// push history to temp slice
-	// and sort by last entry position number
-	var ah = make([]string, i)
-	for key, val := range history {
-		ah[val] = key
-	}
-
-	// write not empty lines to temp file
-	i = 0
-	for _, key := range ah {
-		if len(key) > 0 {
-			t.handle.WriteString(key + "\n")
-			i++
-		}
-	}
-	t.handle.Close()
+	old := NewBashHistoryFile()
+	defer old.FileHandle.Close()
+	old.ReadHistory()
+	name := old.FileHandle.Name()
 
-	//copy from temp file to home
-	_, err := CopyFile(t.path, h.path)
-	if err != nil {
-		fmt.Println(err)
-	}
+	tmp := NewBashHistoryTmpFile()
+	wrote := tmp.SaveTmp(old.History)
+	tmp.WriteFresh(old, true)
 
-	//finnaly remove temp folder
-	err = os.RemoveAll(t.dir)
-	if err != nil {
-		fmt.Print(err)
-	}
-	fmt.Printf("wrote %d lines to %s\n", i, h.path)
+	log.Printf("wrote %d lines to %s\n", wrote, name)
 }

utils.go

@@ -1,76 +1,136 @@
-// utils
 package main
 
 import (
-	"fmt"
+	"bufio"
 	"io"
 	"io/ioutil"
+	"log"
 	"os"
 	"os/user"
 	"path"
+	"strings"
 )
 
-type Hfile struct {
-	name   string
-	dir    string
-	path   string
-	handle *os.File
+type HistoryFile struct {
+	Dir        string
+	History    *BashHistory
+	FileHandle *os.File
 }
 
 type Tmpfile struct {
-	path   string
-	dir    string
-	name   string
-	handle *os.File
+	Dir        string
+	FileHandle *os.File
 }
 
-func (f *Hfile) init() {
-	u, err := user.Current()
-	if err != nil {
-		fmt.Println("Panicking!")
-		panic(fmt.Sprintf("%v", err))
+type BashHistory struct {
+	Old map[string]int
+	Tmp []string
+}
+
+func (tempfile *Tmpfile) WriteFresh(historyfile *HistoryFile, makebackup bool) {
+
+	defer os.RemoveAll(tempfile.Dir)
+	defer tempfile.FileHandle.Close()
+
+	if makebackup {
+		historyfile.Makebackup()
+	}
+
+	if err := historyfile.FileHandle.Truncate(0); err != nil {
+		log.Fatalf("h.trunc: %s\n", err)
+	}
+
+	if _, err := historyfile.FileHandle.Seek(0, 0); err != nil {
+		log.Fatalf("writefresh h.Seek(): %s\n", err)
+	}
+
+	if _, err := tempfile.FileHandle.Seek(0, 0); err != nil {
+		log.Fatalf("t.Seek(): %s\n", err)
+	}
+
+	if _, err := io.Copy(historyfile.FileHandle, tempfile.FileHandle); err != nil {
+		log.Fatalf("tmp io.copy: %s\n", err)
 	}
-	f.dir = u.HomeDir
-	f.path = path.Join(f.dir, f.name)
 }
 
-func (f *Tmpfile) init() {
-	tmpdir, err := ioutil.TempDir(os.TempDir(), f.name)
-	if err != nil {
-		fmt.Println("Panicking!")
-		panic(fmt.Sprintf("%v", err))
+func (tempfile *Tmpfile) SaveTmp(h *BashHistory) (wrote int) {
+	for key, val := range h.Old {
+		h.Tmp[val] = key
 	}
-	f.dir = tmpdir
-	f.path = path.Join(f.dir, f.name)
+	wrote = 0
+	for _, key := range h.Tmp {
+		if len(key) > 0 {
+			if _, err := tempfile.FileHandle.WriteString(key + "\n"); err != nil {
+				log.Fatalf("Error writing line %d value %s : %s \n", wrote, key, err)
+			}
+			wrote++
+		}
+	}
+	return wrote
 }
 
-func (h *Hfile) Open() {
-	fh, err := os.Open(h.path)
+func (historyfile *HistoryFile) Makebackup() {
+	if _, err := historyfile.FileHandle.Seek(0, 0); err != nil {
+		log.Fatalf("makebackup Seek(): %s\n", err)
+	}
+	backup, err := os.Create(historyfile.FileHandle.Name() + ".old")
 	if err != nil {
-		fmt.Print(err)
+		log.Fatalf("makebackup os.Create() .old: %s\n", err)
+	}
+	if _, err := io.Copy(backup, historyfile.FileHandle); err != nil {
+		log.Fatalf("makebackup io.Copy(): %s\n", err)
+	}
+	backup.Close()
+}
+
+func (historyfile *HistoryFile) ReadHistory() {
+	if historyfile.FileHandle == nil {
+		historyfile.Open()
+	}
+	historyfile.History = new(BashHistory)
+	historyfile.History.Old = make(map[string]int)
+
+	scanner := bufio.NewScanner(historyfile.FileHandle)
+	var nr = 0
+	for scanner.Scan() {
+		line := strings.TrimSpace(scanner.Text())
+		historyfile.History.Old[line] = nr
+		nr++
 	}
-	h.handle = fh
+	historyfile.History.Tmp = make([]string, nr)
+	delete(historyfile.History.Old, "")
 }
 
-func (h *Tmpfile) Open() {
-	fh, err := os.OpenFile(h.path, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0600)
+func (historyfile *HistoryFile) Open() {
+	h, err := os.OpenFile(path.Join(historyfile.Dir, ".bash_history"), os.O_RDWR, 0600)
 	if err != nil {
-		fmt.Print(err)
+		log.Fatalf("historyfile Open(): %s\n", err)
 	}
-	h.handle = fh
+	historyfile.FileHandle = h
+
+}
+func NewBashHistoryFile() *HistoryFile {
+	u, err := user.Current()
+	if err != nil {
+		log.Fatalf("NewBashHistoryFile() user.Current():  %s\n ", err)
+	}
+	historyfile := new(HistoryFile)
+	historyfile.Dir = u.HomeDir
+	return historyfile
 }
 
-func CopyFile(src, dst string) (int64, error) {
-	sf, err := os.Open(src)
+func NewBashHistoryTmpFile() *Tmpfile {
+	tmpdir, err := ioutil.TempDir(os.TempDir(), "hipa")
 	if err != nil {
-		return 0, err
+		log.Fatalf("NewBashHistoryTmpFile() TempDir():  %s\n ", err)
 	}
-	defer sf.Close()
-	df, err := os.Create(dst)
+	tmpfile, err := ioutil.TempFile(tmpdir, "hipa")
 	if err != nil {
-		return 0, err
+		log.Fatalf("NewBashHistoryTmpFile() TempDir():  %s\n ", err)
 	}
-	df.Chmod(0600)
-	defer df.Close()
-	return io.Copy(df, sf)
+
+	tempfile := new(Tmpfile)
+	tempfile.Dir = tmpdir
+	tempfile.FileHandle = tmpfile
+	return tempfile
 }