reorganize error code (#1133)

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

diff --git a/blockchain/pseudohsm/watch.go b/blockchain/pseudohsm/watch.go
index 0f8bd57..32c1159 100644 (file)
--- a/blockchain/pseudohsm/watch.go
+++ b/blockchain/pseudohsm/watch.go
@@ -18,24 +18,22 @@
 
 package pseudohsm
 
-import (
-       "fmt"
-       "github.com/rjeczalik/notify"
-       "time"
-)
+//"fmt"
+//"github.com/rjeczalik/notify"
+//"time"
 
 type watcher struct {
        kc       *keyCache
        starting bool
        running  bool
-       ev       chan notify.EventInfo
-       quit     chan struct{}
+       //ev       chan notify.EventInfo
+       quit chan struct{}
 }
 
 func newWatcher(kc *keyCache) *watcher {
        return &watcher{
-               kc:   kc,
-               ev:   make(chan notify.EventInfo, 10),
+               kc: kc,
+               //ev:   make(chan notify.EventInfo, 10),
                quit: make(chan struct{}),
        }
 }
@@ -63,49 +61,51 @@ func (w *watcher) loop() {
                w.kc.mu.Unlock()
        }()
 
-       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)
+       /*
+               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.kc.mu.Lock()
-       w.running = true
-       w.kc.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.kc.mu.Lock()
-                       w.kc.reload()
-                       w.kc.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
+                               }
                        }
                }
-       }
+       */
 }