From 3877268508e5bb3f5aa93af5e5fd9b6f7bc1636a Mon Sep 17 00:00:00 2001 From: Chakib Ben Ziane Date: Sun, 28 Oct 2018 20:19:12 +0100 Subject: [PATCH] Cleaner error handling --- api.go | 8 ++++-- bookmarks.go | 8 ++++-- browsers.go | 34 +++++++++++++++++------- chrome.go | 24 ++++++++++------- db.go | 74 +++++++++++++++++++++++++++++++++++++++------------- firefox.go | 44 +++++++++++++++++++++---------- main.go | 17 +++++++----- mode.go | 2 +- watcher.go | 2 +- 9 files changed, 150 insertions(+), 63 deletions(-) diff --git a/api.go b/api.go index cfcdd13..143d00c 100644 --- a/api.go +++ b/api.go @@ -10,7 +10,9 @@ import ( func getBookmarks(c *gin.Context) { rows, err := CacheDB.Handle.QueryContext(c, "SELECT URL, metadata, tags FROM bookmarks") - logPanic(err) + if err != nil { + log.Error(err) + } var bookmarks []Bookmark @@ -18,7 +20,9 @@ func getBookmarks(c *gin.Context) { for rows.Next() { bookmark := Bookmark{} err = rows.Scan(&bookmark.URL, &bookmark.Metadata, &tags) - logPanic(err) + if err != nil { + log.Error(err) + } bookmark.Tags = strings.Split(tags, TagJoinSep) diff --git a/bookmarks.go b/bookmarks.go index fd8e7dd..b8fe6bf 100644 --- a/bookmarks.go +++ b/bookmarks.go @@ -24,7 +24,9 @@ func (bk *Bookmark) InsertInDB(db *DB) { _db := db.Handle tx, err := _db.Begin() - logPanic(err) + if err != nil { + log.Error(err) + } stmt, err := tx.Prepare(`INSERT INTO bookmarks(URL, metadata, tags, desc, flags) VALUES (?, ?, ?, ?, ?)`) logError(err) @@ -75,7 +77,9 @@ func (bk *Bookmark) InsertOrUpdateInDB(db *DB) { // Begin transaction tx, err := _db.Begin() - logPanic(err) + if err != nil { + log.Error(err) + } // First try to insert the bookmark (assume it's new) _, err = tx.Stmt(tryInsertBk).Exec( diff --git a/browsers.go b/browsers.go index 650775d..dec95da 100644 --- a/browsers.go +++ b/browsers.go @@ -36,12 +36,12 @@ type BrowserPaths struct { type IBrowser interface { IWatchable - InitBuffer() // init buffer db, should be defered to close after call + InitBuffer() // init buffer db, TODO: defer closings and shutdown InitIndex() // Creates in memory Index (RB-Tree) RegisterHooks(...ParseHook) Load() // Loads bookmarks to db without watching //Parse(...ParseHook) // Main parsing method with different parsing hooks - Close() // Gracefully finish work and stop watching + Shutdown() // Graceful shutdown, it should call the BaseBrowser.Close() } // Base browser class serves as reference for implmented browser types @@ -92,8 +92,7 @@ func (bw *BaseBrowser) Load() { // Check if cache is initialized if CacheDB == nil || CacheDB.Handle == nil { - log.Critical("cache is not yet initialized !") - panic("cache is not yet initialized !") + log.Criticalf("<%s> Loading bookmarks while cache not yet initialized !", bw.name) } if bw.watcher == nil { @@ -118,21 +117,36 @@ func (bw *BaseBrowser) GetDir() string { func (bw *BaseBrowser) SetupWatcher() { var err error bw.watcher, err = fsnotify.NewWatcher() - logPanic(err) + if err != nil { + log.Critical(err) + } err = bw.watcher.Add(bw.GetDir()) - logPanic(err) + if err != nil { + log.Critical(err) + } + } func (bw *BaseBrowser) ResetWatcher() { err := bw.watcher.Close() - logPanic(err) + if err != nil { + log.Critical(err) + } bw.SetupWatcher() } -func (bw *BaseBrowser) Close() { +func (bw *BaseBrowser) Close() error { err := bw.watcher.Close() - bw.BufferDB.Close() - logPanic(err) + if err != nil { + return err + } + + err = bw.BufferDB.Close() + if err != nil { + return err + } + + return nil } func (b *BaseBrowser) InitIndex() { diff --git a/chrome.go b/chrome.go index 95ed22e..9a0f5bf 100644 --- a/chrome.go +++ b/chrome.go @@ -91,6 +91,14 @@ func NewChromeBrowser() IBrowser { return browser } +func (bw ChromeBrowser) Shutdown() { + log.Debugf("<%s> shutting down ... ", bw.name) + err := bw.BaseBrowser.Close() + if err != nil { + log.Error(err) + } +} + func (bw *ChromeBrowser) Watch() bool { if !bw.isWatching { go WatcherThread(bw) @@ -117,7 +125,9 @@ func (bw *ChromeBrowser) Run() { // Load bookmark file bookmarkPath := path.Join(bw.baseDir, bw.bkFile) f, err := ioutil.ReadFile(bookmarkPath) - logPanic(err) + if err != nil { + log.Critical(err) + } var parseChildren ParseChildFunc var jsonParseRecursive RecursiveParseFunc @@ -322,8 +332,10 @@ func (bw *ChromeBrowser) Run() { // until local db is already populated and preloaded //debugPrint("%d", BufferDB.Count()) if empty, err := CacheDB.isEmpty(); empty { - logPanic(err) - log.Debug("cache empty: loading buffer to Cachedb") + if err != nil { + log.Error(err) + } + log.Info("cache empty: loading buffer to Cachedb") //start := time.Now() bw.BufferDB.CopyTo(CacheDB) @@ -335,12 +347,6 @@ func (bw *ChromeBrowser) Run() { CacheDB.SyncToDisk(getDBFullPath()) } - // TODO: Implement incremental sync by doing INSERTS - // to avoid overwriting the original cache bw.BufferDB.SyncTo(CacheDB) - // TODO: Check if new/modified bookmarks in buffer compared to cache - // This should be fixed with an InsertOrUp sync to cache db - log.Debugf("DOING: check if new/modified bookmarks in %s compared to %s", bw.BufferDB.Name, CacheDB.Name) - } diff --git a/db.go b/db.go index 9cd41bd..0bf1a44 100644 --- a/db.go +++ b/db.go @@ -79,7 +79,10 @@ func (db *DB) InitRO() { // Create the sqlite connection db.Handle, err = sql.Open("sqlite3", db.Path) log.Debugf("<%s> opened at <%s>", db.Name, db.Path) - logPanic(err) + if err != nil { + log.Critical(err) + } + } // Initialize a sqlite database with Gomark Schema @@ -99,20 +102,30 @@ func (db *DB) Init() { db.Handle, err = sql.Open("sqlite3", db.Path) //log.Debugf("db <%s> opend at at <%s>", db.name, db.path) log.Debugf("<%s> opened at <%s>", db.Name, db.Path) - logPanic(err) + if err != nil { + log.Critical(err) + } // Populate db schema tx, err := db.Handle.Begin() - logPanic(err) + if err != nil { + log.Error(err) + } stmt, err := tx.Prepare(QCreateMemDbSchema) - logPanic(err) + if err != nil { + log.Error(err) + } _, err = stmt.Exec() - logPanic(err) + if err != nil { + log.Error(err) + } err = tx.Commit() - logPanic(err) + if err != nil { + log.Error(err) + } if !backupHookRegistered { //log.Debugf("backup_hook: registering driver %s", DB_BACKUP_HOOK) @@ -136,7 +149,9 @@ func (db *DB) Attach(attached *DB) { stmtStr := fmt.Sprintf("ATTACH DATABASE '%s' AS '%s'", attached.Path, attached.Name) _, err := db.Handle.Exec(stmtStr) - logPanic(err) + if err != nil { + log.Error(err) + } ///////////////// // For debug only @@ -154,9 +169,13 @@ func (db *DB) Attach(attached *DB) { //} } -func (db *DB) Close() { +func (db *DB) Close() error { log.Debugf("Closing DB <%s>", db.Name) - db.Handle.Close() + err := db.Handle.Close() + if err != nil { + return err + } + return nil } func (db *DB) Count() int { @@ -164,7 +183,9 @@ func (db *DB) Count() int { row := db.Handle.QueryRow("select count(*) from bookmarks") err := row.Scan(&count) - logPanic(err) + if err != nil { + log.Error(err) + } return count } @@ -373,7 +394,9 @@ func (src *DB) CopyTo(dst *DB) { srcDb.Close() _sql3conns = _sql3conns[:len(_sql3conns)-1] }() - logPanic(err) + if err != nil { + log.Error(err) + } srcDb.Ping() @@ -382,14 +405,20 @@ func (src *DB) CopyTo(dst *DB) { dstDb.Close() _sql3conns = _sql3conns[:len(_sql3conns)-1] }() - logPanic(err) + if err != nil { + log.Error(err) + } dstDb.Ping() bk, err := _sql3conns[1].Backup("main", _sql3conns[0], "main") - logPanic(err) + if err != nil { + log.Error(err) + } _, err = bk.Step(-1) - logPanic(err) + if err != nil { + log.Error(err) + } bk.Finish() } @@ -523,17 +552,24 @@ func initDB() { // Verifiy that local db directory path is writeable err := checkWriteable(dbdir) - logPanic(err) + if err != nil { + log.Critical(err) + } // If local db exists load it to cacheDB var exists bool if exists, err = checkFileExists(dbpath); exists { - logPanic(err) + if err != nil { + log.Warning(err) + } log.Debugf("localdb exists, preloading to cache") CacheDB.SyncFromDisk(dbpath) //CacheDB.Print() } else { - logPanic(err) + if err != nil { + log.Error(err) + } + // Else initialize it initLocalDB(CacheDB, dbpath) } @@ -546,7 +582,9 @@ func initLocalDB(db *DB, dbpath string) { log.Infof("Initializing local db at '%s'", dbpath) log.Debugf("%s flushing to disk", db.Name) err := db.SyncToDisk(dbpath) - logPanic(err) + if err != nil { + log.Critical(err) + } } diff --git a/firefox.go b/firefox.go index 3fa6090..e3f5372 100644 --- a/firefox.go +++ b/firefox.go @@ -18,7 +18,7 @@ const ( type FFBrowser struct { BaseBrowser //embedding - _places *DB + places *DB } type FFTag struct { @@ -35,6 +35,11 @@ func NewFFBrowser() IBrowser { browser.Stats = &ParserStats{} browser.NodeTree = &Node{Name: "root", Parent: nil, Type: "root"} + // Initialize `places.sqlite` + bookmarkPath := path.Join(browser.baseDir, browser.bkFile) + browser.places = DB{}.New("Places", bookmarkPath) + browser.places.InitRO() + // Across jobs buffer browser.InitBuffer() @@ -51,9 +56,25 @@ func NewFFBrowser() IBrowser { return browser } +func (bw *FFBrowser) Shutdown() { + + log.Debugf("<%s> shutting down ... ", bw.name) + + err := bw.BaseBrowser.Close() + if err != nil { + log.Critical(err) + } + + err = bw.places.Close() + if err != nil { + log.Critical(err) + } +} + func (bw *FFBrowser) Watch() bool { - log.Debugf("<%s> NOT IMPLEMENTED! ", bw.name) + log.Debugf("<%s> TODO ... ", bw.name) + //if !bw.isWatching { //go WatcherThread(bw) //bw.isWatching = true @@ -91,8 +112,10 @@ func getFFBookmarks(bw *FFBrowser) { //QGetTags := "SELECT id,title from moz_bookmarks WHERE parent = %d" - rows, err := bw._places.Handle.Query(QGetBookmarks, MozPlacesTagsRootID) - logPanic(err) + rows, err := bw.places.Handle.Query(QGetBookmarks, MozPlacesTagsRootID) + if err != nil { + log.Error(err) + } tagMap := make(map[int]*Node) urlMap := make(map[string]*Node) @@ -109,7 +132,9 @@ func getFFBookmarks(bw *FFBrowser) { var tagId int err = rows.Scan(&url, &title, &desc, &tagId, &tagTitle) //log.Debugf("%s|%s|%s|%d|%s", url, title, desc, tagId, tagTitle) - logPanic(err) + if err != nil { + log.Error(err) + } /* * If this is the first time we see this tag @@ -177,14 +202,6 @@ func (bw *FFBrowser) Run() { // TODO: Handle folders - // Open firefox sqlite db - bookmarkPath := path.Join(bw.baseDir, bw.bkFile) - placesDB := DB{}.New("Places", bookmarkPath) - placesDB.InitRO() - defer placesDB.Close() - - bw._places = placesDB - // Parse bookmarks to a flat tree (for compatibility with tree system) start := time.Now() getFFBookmarks(bw) @@ -201,5 +218,4 @@ func (bw *FFBrowser) Run() { // Implement incremental sync by doing INSERTs bw.BufferDB.SyncTo(CacheDB) - CacheDB.SyncToDisk(getDBFullPath()) } diff --git a/main.go b/main.go index b9927ea..413957c 100644 --- a/main.go +++ b/main.go @@ -7,9 +7,7 @@ package main import "github.com/gin-gonic/gin" -func main() { - // Block the main function - //block := make(chan bool) +func mainLoop() { r := gin.Default() @@ -23,6 +21,8 @@ func main() { cb := NewChromeBrowser() ff := NewFFBrowser() + defer cb.Shutdown() + defer ff.Shutdown() cb.RegisterHooks(ParseTags) ff.RegisterHooks(ParseTags) @@ -33,7 +33,12 @@ func main() { _ = cb.Watch() _ = ff.Watch() - r.Run("127.0.0.1:4242") - - //<-block + err := r.Run("127.0.0.1:4242") + if err != nil { + log.Panic(err) + } +} + +func main() { + mainLoop() } diff --git a/mode.go b/mode.go index 78c8513..f743128 100644 --- a/mode.go +++ b/mode.go @@ -39,7 +39,7 @@ func SetMode(value string) { case TestMode: gomarkMode = testCode default: - panic("go-bookmark mode unknown: " + value) + log.Panic("go-bookmark mode unknown: " + value) } modeName = value } diff --git a/watcher.go b/watcher.go index 29aa5d2..c16c7f3 100644 --- a/watcher.go +++ b/watcher.go @@ -64,7 +64,7 @@ func WatcherThread(w IWatchable) { //w.Run() } case err := <-watcher.Errors: - log.Errorf("error: %s", err) + log.Error(err) } } }