reorganize error code (#1133)

[bytom/bytom.git] / blockchain / pseudohsm / watch.go

diff --git a/blockchain/pseudohsm/watch.go b/blockchain/pseudohsm/watch.go
index 8dd5f40..32c1159 100644 (file)
--- a/blockchain/pseudohsm/watch.go
+++ b/blockchain/pseudohsm/watch.go
@@ -18,94 +18,94 @@
 
 package pseudohsm
 
-import (
-    "time"
-    "fmt"
-    "github.com/rjeczalik/notify"
-)
+//"fmt"
+//"github.com/rjeczalik/notify"
+//"time"
 
 type watcher struct {
-    ac       *addrCache
-    starting bool
-    running  bool
-    ev       chan notify.EventInfo
-    quit     chan struct{}
+       kc       *keyCache
+       starting bool
+       running  bool
+       //ev       chan notify.EventInfo
+       quit chan struct{}
 }
 
-func newWatcher(ac *addrCache) *watcher {
-    return &watcher{
-        ac:   ac,
-        ev:   make(chan notify.EventInfo, 10),
-        quit: make(chan struct{}),
-    }
+func newWatcher(kc *keyCache) *watcher {
+       return &watcher{
+               kc: kc,
+               //ev:   make(chan notify.EventInfo, 10),
+               quit: make(chan struct{}),
+       }
 }
 
 // starts the watcher loop in the background.
 // Start a watcher in the background if that's not already in progress.
-// The caller must hold w.ac.mu.
+// The caller must hold w.kc.mu.
 func (w *watcher) start() {
-    if w.starting || w.running {
-        return
-    }
-    w.starting = true
-    go w.loop()
+       if w.starting || w.running {
+               return
+       }
+       w.starting = true
+       go w.loop()
 }
 
 func (w *watcher) close() {
-    close(w.quit)
+       close(w.quit)
 }
 
 func (w *watcher) loop() {
-    defer func() {
-        w.ac.mu.Lock()
-        w.running = false
-        w.starting = false
-        w.ac.mu.Unlock()
-    }()
+       defer func() {
+               w.kc.mu.Lock()
+               w.running = false
+               w.starting = false
+               w.kc.mu.Unlock()
+       }()
 
-    err := notify.Watch(w.ac.keydir, w.ev, notify.All)
-    if err != nil {
-        fmt.Printf("can't watch %s: %v", w.ac.keydir, err)
-        return
-    }
-    defer notify.Stop(w.ev)
-    fmt.Printf("now watching %s", w.ac.keydir)
-    defer fmt.Printf("no longer watching %s", w.ac.keydir)
+       /*
+               err := notify.Watch(w.kc.keydir, w.ev, notify.All)
+               if err != nil {
+                       fmt.Printf("can't watch %s: %v", w.kc.keydir, err)
+                       return
+               }
+               defer notify.Stop(w.ev)
+               fmt.Printf("now watching %s", w.kc.keydir)
+               defer fmt.Printf("no longer watching %s", w.kc.keydir)
 
-    w.ac.mu.Lock()
-    w.running = true
-    w.ac.mu.Unlock()
+               w.kc.mu.Lock()
+               w.running = true
+               w.kc.mu.Unlock()
 
-    // Wait for file system events and reload.
-    // When an event occurs, the reload call is delayed a bit so that
-    // multiple events arriving quickly only cause a single reload.
-    var (
-        debounce          = time.NewTimer(0)
-        debounceDuration  = 500 * time.Millisecond
-        inCycle, hadEvent bool
-    )
-    defer debounce.Stop()
-    for {
-        select {
-        case <-w.quit:
-            return
-        case <-w.ev:
-            if !inCycle {
-                debounce.Reset(debounceDuration)
-                inCycle = true
-            } else {
-                hadEvent = true
-            }
-        case <-debounce.C:
-            w.ac.mu.Lock()
-            w.ac.reload()
-            w.ac.mu.Unlock()
-            if hadEvent {
-                debounce.Reset(debounceDuration)
-                inCycle, hadEvent = true, false
-            } else {
-                inCycle, hadEvent = false, false
-            }
-        }
-    }
+               // Wait for file system events and reload.
+               // When an event occurs, the reload call is delayed a bit so that
+               // multiple events arriving quickly only cause a single reload.
+               var (
+                       debounce          = time.NewTimer(0)
+                       debounceDuration  = 500 * time.Millisecond
+                       inCycle, hadEvent bool
+               )
+               defer debounce.Stop()
+               for {
+                       select {
+                       case <-w.quit:
+                               return
+                       case <-w.ev:
+                               if !inCycle {
+                                       debounce.Reset(debounceDuration)
+                                       inCycle = true
+                               } else {
+                                       hadEvent = true
+                               }
+                       case <-debounce.C:
+                               w.kc.mu.Lock()
+                               w.kc.reload()
+                               w.kc.mu.Unlock()
+                               if hadEvent {
+                                       debounce.Reset(debounceDuration)
+                                       inCycle, hadEvent = true, false
+                               } else {
+                                       inCycle, hadEvent = false, false
+                               }
+                       }
+               }
+       */
 }