Switch to go mod

vendor/github.com/hpcloud/tail/.travis.yml

@@ -4,10 +4,9 @@ script:
   - go test -race -v ./...
 
 go:
+  - 1.4
   - 1.5
   - 1.6
-  - 1.7
-  - 1.8
   - tip
 
 matrix:
@@ -15,5 +14,5 @@ matrix:
     - go: tip
 
 install:
-  - go get gopkg.in/fsnotify/fsnotify.v1
+  - go get gopkg.in/fsnotify.v1
   - go get gopkg.in/tomb.v1

vendor/github.com/hpcloud/tail/README.md

@@ -1,5 +1,5 @@
 [![Build Status](https://travis-ci.org/hpcloud/tail.svg)](https://travis-ci.org/hpcloud/tail)
-[![Build status](https://ci.appveyor.com/api/projects/status/vrl3paf9md0a7bgk/branch/master?svg=true)](https://ci.appveyor.com/project/Nino-K/tail/branch/master)
+[![Build status](https://ci.appveyor.com/api/projects/status/kohpsf3rvhjhrox6?svg=true)](https://ci.appveyor.com/project/HelionCloudFoundry/tail) 
 
 # Go package for tail-ing files
 

vendor/github.com/hpcloud/tail/ratelimiter/memory.go

@@ -5,10 +5,7 @@ import (
 	"time"
 )
 
-const (
-	GC_SIZE   int           = 100
-	GC_PERIOD time.Duration = 60 * time.Second
-)
+const GC_SIZE int = 100
 
 type Memory struct {
 	store           map[string]LeakyBucket
@@ -47,10 +44,11 @@ func (m *Memory) GarbageCollect() {
 	now := time.Now()
 
 	// rate limit GC to once per minute
-	if now.Unix() >= m.lastGCCollected.Add(GC_PERIOD).Unix() {
+	if now.Add(60*time.Second).Unix() > m.lastGCCollected.Unix() {
+
 		for key, bucket := range m.store {
 			// if the bucket is drained, then GC
-			if bucket.DrainedAt().Unix() < now.Unix() {
+			if bucket.DrainedAt().Unix() > now.Unix() {
 				delete(m.store, key)
 			}
 		}

vendor/github.com/hpcloud/tail/tail.go

@@ -22,7 +22,7 @@ import (
 )
 
 var (
-	ErrStop = errors.New("tail should now stop")
+	ErrStop = fmt.Errorf("tail should now stop")
 )
 
 type Line struct {
@@ -250,7 +250,7 @@ func (tail *Tail) tailFileSync() {
 
 	tail.openReader()
 
-	var offset int64
+	var offset int64 = 0
 	var err error
 
 	// Read line by line.
@@ -273,9 +273,10 @@ func (tail *Tail) tailFileSync() {
 			if cooloff {
 				// Wait a second before seeking till the end of
 				// file when rate limit is reached.
-				msg := ("Too much log activity; waiting a second " +
-					"before resuming tailing")
-				tail.Lines <- &Line{msg, time.Now(), errors.New(msg)}
+				msg := fmt.Sprintf(
+					"Too much log activity; waiting a second " +
+						"before resuming tailing")
+				tail.Lines <- &Line{msg, time.Now(), fmt.Errorf(msg)}
 				select {
 				case <-time.After(time.Second):
 				case <-tail.Dying():

vendor/github.com/hpcloud/tail/watch/filechanges.go

@@ -8,7 +8,7 @@ type FileChanges struct {
 
 func NewFileChanges() *FileChanges {
 	return &FileChanges{
-		make(chan bool, 1), make(chan bool, 1), make(chan bool, 1)}
+		make(chan bool), make(chan bool), make(chan bool)}
 }
 
 func (fc *FileChanges) NotifyModified() {

vendor/github.com/hpcloud/tail/watch/inotify.go

@@ -10,7 +10,7 @@ import (
 
 	"github.com/hpcloud/tail/util"
 
-	"gopkg.in/fsnotify/fsnotify.v1"
+	"gopkg.in/fsnotify.v1"
 	"gopkg.in/tomb.v1"
 )
 
@@ -75,6 +75,7 @@ func (fw *InotifyFileWatcher) ChangeEvents(t *tomb.Tomb, pos int64) (*FileChange
 	fw.Size = pos
 
 	go func() {
+		defer RemoveWatch(fw.Filename)
 
 		events := Events(fw.Filename)
 
@@ -87,11 +88,9 @@ func (fw *InotifyFileWatcher) ChangeEvents(t *tomb.Tomb, pos int64) (*FileChange
 			select {
 			case evt, ok = <-events:
 				if !ok {
-					RemoveWatch(fw.Filename)
 					return
 				}
 			case <-t.Dying():
-				RemoveWatch(fw.Filename)
 				return
 			}
 
@@ -100,19 +99,13 @@ func (fw *InotifyFileWatcher) ChangeEvents(t *tomb.Tomb, pos int64) (*FileChange
 				fallthrough
 
 			case evt.Op&fsnotify.Rename == fsnotify.Rename:
-				RemoveWatch(fw.Filename)
 				changes.NotifyDeleted()
 				return
 
-			//With an open fd, unlink(fd) - inotify returns IN_ATTRIB (==fsnotify.Chmod)
-			case evt.Op&fsnotify.Chmod == fsnotify.Chmod:
-				fallthrough
-
 			case evt.Op&fsnotify.Write == fsnotify.Write:
 				fi, err := os.Stat(fw.Filename)
 				if err != nil {
 					if os.IsNotExist(err) {
-						RemoveWatch(fw.Filename)
 						changes.NotifyDeleted()
 						return
 					}

vendor/github.com/hpcloud/tail/watch/inotify_tracker.go

@@ -12,7 +12,7 @@ import (
 
 	"github.com/hpcloud/tail/util"
 
-	"gopkg.in/fsnotify/fsnotify.v1"
+	"gopkg.in/fsnotify.v1"
 )
 
 type InotifyTracker struct {
@@ -83,21 +83,21 @@ func watch(winfo *watchInfo) error {
 }
 
 // RemoveWatch signals the run goroutine to remove the watch for the input filename
-func RemoveWatch(fname string) error {
-	return remove(&watchInfo{
+func RemoveWatch(fname string) {
+	remove(&watchInfo{
 		fname: fname,
 	})
 }
 
 // RemoveWatch create signals the run goroutine to remove the watch for the input filename
-func RemoveWatchCreate(fname string) error {
-	return remove(&watchInfo{
+func RemoveWatchCreate(fname string) {
+	remove(&watchInfo{
 		op:    fsnotify.Create,
 		fname: fname,
 	})
 }
 
-func remove(winfo *watchInfo) error {
+func remove(winfo *watchInfo) {
 	// start running the shared InotifyTracker if not already running
 	once.Do(goRun)
 
@@ -108,67 +108,6 @@ func remove(winfo *watchInfo) error {
 		delete(shared.done, winfo.fname)
 		close(done)
 	}
-	shared.mux.Unlock()
-
-	shared.remove <- winfo
-	return <-shared.error
-}
-
-// Events returns a channel to which FileEvents corresponding to the input filename
-// will be sent. This channel will be closed when removeWatch is called on this
-// filename.
-func Events(fname string) <-chan fsnotify.Event {
-	shared.mux.Lock()
-	defer shared.mux.Unlock()
-
-	return shared.chans[fname]
-}
-
-// Cleanup removes the watch for the input filename if necessary.
-func Cleanup(fname string) error {
-	return RemoveWatch(fname)
-}
-
-// watchFlags calls fsnotify.WatchFlags for the input filename and flags, creating
-// a new Watcher if the previous Watcher was closed.
-func (shared *InotifyTracker) addWatch(winfo *watchInfo) error {
-	shared.mux.Lock()
-	defer shared.mux.Unlock()
-
-	if shared.chans[winfo.fname] == nil {
-		shared.chans[winfo.fname] = make(chan fsnotify.Event)
-	}
-	if shared.done[winfo.fname] == nil {
-		shared.done[winfo.fname] = make(chan bool)
-	}
-
-	fname := winfo.fname
-	if winfo.isCreate() {
-		// Watch for new files to be created in the parent directory.
-		fname = filepath.Dir(fname)
-	}
-
-	var err error
-	// already in inotify watch
-	if shared.watchNums[fname] == 0 {
-		err = shared.watcher.Add(fname)
-	}
-	if err == nil {
-		shared.watchNums[fname]++
-	}
-	return err
-}
-
-// removeWatch calls fsnotify.RemoveWatch for the input filename and closes the
-// corresponding events channel.
-func (shared *InotifyTracker) removeWatch(winfo *watchInfo) error {
-	shared.mux.Lock()
-
-	ch := shared.chans[winfo.fname]
-	if ch != nil {
-		delete(shared.chans, winfo.fname)
-		close(ch)
-	}
 
 	fname := winfo.fname
 	if winfo.isCreate() {
@@ -182,18 +121,91 @@ func (shared *InotifyTracker) removeWatch(winfo *watchInfo) error {
 	}
 	shared.mux.Unlock()
 
-	var err error
 	// If we were the last ones to watch this file, unsubscribe from inotify.
 	// This needs to happen after releasing the lock because fsnotify waits
 	// synchronously for the kernel to acknowledge the removal of the watch
 	// for this file, which causes us to deadlock if we still held the lock.
 	if watchNum == 0 {
-		err = shared.watcher.Remove(fname)
+		shared.watcher.Remove(fname)
+	}
+	shared.remove <- winfo
+}
+
+// Events returns a channel to which FileEvents corresponding to the input filename
+// will be sent. This channel will be closed when removeWatch is called on this
+// filename.
+func Events(fname string) <-chan fsnotify.Event {
+	shared.mux.Lock()
+	defer shared.mux.Unlock()
+
+	return shared.chans[fname]
+}
+
+// Cleanup removes the watch for the input filename if necessary.
+func Cleanup(fname string) {
+	RemoveWatch(fname)
+}
+
+// watchFlags calls fsnotify.WatchFlags for the input filename and flags, creating
+// a new Watcher if the previous Watcher was closed.
+func (shared *InotifyTracker) addWatch(winfo *watchInfo) error {
+	shared.mux.Lock()
+	defer shared.mux.Unlock()
+
+	if shared.chans[winfo.fname] == nil {
+		shared.chans[winfo.fname] = make(chan fsnotify.Event)
+		shared.done[winfo.fname] = make(chan bool)
 	}
 
+	fname := winfo.fname
+	if winfo.isCreate() {
+		// Watch for new files to be created in the parent directory.
+		fname = filepath.Dir(fname)
+	}
+
+	// already in inotify watch
+	if shared.watchNums[fname] > 0 {
+		shared.watchNums[fname]++
+		if winfo.isCreate() {
+			shared.watchNums[winfo.fname]++
+		}
+		return nil
+	}
+
+	err := shared.watcher.Add(fname)
+	if err == nil {
+		shared.watchNums[fname]++
+		if winfo.isCreate() {
+			shared.watchNums[winfo.fname]++
+		}
+	}
 	return err
 }
 
+// removeWatch calls fsnotify.RemoveWatch for the input filename and closes the
+// corresponding events channel.
+func (shared *InotifyTracker) removeWatch(winfo *watchInfo) {
+	shared.mux.Lock()
+	defer shared.mux.Unlock()
+
+	ch := shared.chans[winfo.fname]
+	if ch == nil {
+		return
+	}
+
+	delete(shared.chans, winfo.fname)
+	close(ch)
+
+	if !winfo.isCreate() {
+		return
+	}
+
+	shared.watchNums[winfo.fname]--
+	if shared.watchNums[winfo.fname] == 0 {
+		delete(shared.watchNums, winfo.fname)
+	}
+}
+
 // sendEvent sends the input event to the appropriate Tail.
 func (shared *InotifyTracker) sendEvent(event fsnotify.Event) {
 	name := filepath.Clean(event.Name)
@@ -226,7 +238,7 @@ func (shared *InotifyTracker) run() {
 			shared.error <- shared.addWatch(winfo)
 
 		case winfo := <-shared.remove:
-			shared.error <- shared.removeWatch(winfo)
+			shared.removeWatch(winfo)
 
 		case event, open := <-shared.watcher.Events:
 			if !open {