nutomic/syncthing-android
1
0
Fork 0
mirror of https://github.com/syncthing/syncthing-android.git synced 2024-12-02 17:21:17 +00:00
Code Releases Activity
syncthing-android/ext/patches/syncthing-inotify/godeps/0001-add-godeps.patch

9174 lines
258 KiB
Diff
Raw Normal View History

Use CGO to build Syncthing with support for DNS (fixes #57)
2015-11-13 22:38:17 +00:00
From cf0c69c5bc84cdcefe887245d4a093f41999caf2 Mon Sep 17 00:00:00 2001
From: Andrew Sutherland <dr3wsuth3rland@gmail.com>
Date: Sat, 10 Oct 2015 15:59:08 -0500
Subject: [PATCH] add godeps
---
Godeps/Godeps.json | 14 +
Godeps/Readme | 5 +
Godeps/_workspace/.gitignore | 2 +
.../src/github.com/cenkalti/backoff/.gitignore | 22 +
.../src/github.com/cenkalti/backoff/.travis.yml | 2 +
.../src/github.com/cenkalti/backoff/LICENSE | 20 +
.../src/github.com/cenkalti/backoff/README.md | 116 +++
.../cenkalti/backoff/adv_example_test.go | 117 +++
.../src/github.com/cenkalti/backoff/backoff.go | 59 ++
.../github.com/cenkalti/backoff/backoff_test.go | 27 +
.../github.com/cenkalti/backoff/example_test.go | 51 ++
.../src/github.com/cenkalti/backoff/exponential.go | 151 ++++
.../cenkalti/backoff/exponential_test.go | 108 +++
.../src/github.com/cenkalti/backoff/retry.go | 46 ++
.../src/github.com/cenkalti/backoff/retry_test.go | 34 +
.../src/github.com/cenkalti/backoff/ticker.go | 79 ++
.../src/github.com/cenkalti/backoff/ticker_test.go | 45 ++
.../src/github.com/zillode/notify/.gitignore | 88 ++
.../src/github.com/zillode/notify/.travis.yml | 35 +
.../src/github.com/zillode/notify/AUTHORS | 10 +
.../src/github.com/zillode/notify/LICENSE | 21 +
.../src/github.com/zillode/notify/README.md | 18 +
.../src/github.com/zillode/notify/appveyor.yml | 24 +
.../src/github.com/zillode/notify/debug.go | 11 +
.../src/github.com/zillode/notify/debug_debug.go | 43 +
.../src/github.com/zillode/notify/doc.go | 39 +
.../src/github.com/zillode/notify/event.go | 143 ++++
.../github.com/zillode/notify/event_fsevents.go | 71 ++
.../src/github.com/zillode/notify/event_inotify.go | 75 ++
.../src/github.com/zillode/notify/event_kqueue.go | 89 ++
.../src/github.com/zillode/notify/event_readdcw.go | 108 +++
.../src/github.com/zillode/notify/event_stub.go | 31 +
.../src/github.com/zillode/notify/event_test.go | 33 +
.../zillode/notify/example_fsevents_test.go | 128 +++
.../zillode/notify/example_inotify_test.go | 83 ++
.../zillode/notify/example_readdcw_test.go | 40 +
.../src/github.com/zillode/notify/example_test.go | 87 ++
.../src/github.com/zillode/notify/node.go | 271 +++++++
.../src/github.com/zillode/notify/notify.go | 70 ++
.../zillode/notify/notify_inotify_test.go | 37 +
.../zillode/notify/notify_readdcw_test.go | 60 ++
.../src/github.com/zillode/notify/notify_test.go | 103 +++
.../github.com/zillode/notify/sync_readdcw_test.go | 33 +
.../github.com/zillode/notify/sync_unix_test.go | 18 +
.../src/github.com/zillode/notify/testdata/vfs.txt | 56 ++
.../src/github.com/zillode/notify/testing_test.go | 895 +++++++++++++++++++++
.../src/github.com/zillode/notify/tree.go | 22 +
.../github.com/zillode/notify/tree_nonrecursive.go | 292 +++++++
.../zillode/notify/tree_nonrecursive_test.go | 543 +++++++++++++
.../github.com/zillode/notify/tree_recursive.go | 354 ++++++++
.../zillode/notify/tree_recursive_test.go | 524 ++++++++++++
.../src/github.com/zillode/notify/util.go | 146 ++++
.../github.com/zillode/notify/util_darwin_test.go | 41 +
.../src/github.com/zillode/notify/util_test.go | 147 ++++
.../github.com/zillode/notify/util_unix_test.go | 94 +++
.../src/github.com/zillode/notify/watcher.go | 85 ++
.../github.com/zillode/notify/watcher_fsevents.go | 319 ++++++++
.../zillode/notify/watcher_fsevents_cgo.go | 156 ++++
.../zillode/notify/watcher_fsevents_test.go | 111 +++
.../github.com/zillode/notify/watcher_inotify.go | 396 +++++++++
.../zillode/notify/watcher_inotify_test.go | 132 +++
.../github.com/zillode/notify/watcher_kqueue.go | 413 ++++++++++
.../zillode/notify/watcher_kqueue_test.go | 72 ++
.../github.com/zillode/notify/watcher_readdcw.go | 574 +++++++++++++
.../zillode/notify/watcher_readdcw_test.go | 67 ++
.../zillode/notify/watcher_recursive_test.go | 102 +++
.../src/github.com/zillode/notify/watcher_stub.go | 21 +
.../src/github.com/zillode/notify/watcher_test.go | 32 +
.../src/github.com/zillode/notify/watchpoint.go | 102 +++
.../github.com/zillode/notify/watchpoint_other.go | 23 +
.../zillode/notify/watchpoint_readdcw.go | 38 +
.../github.com/zillode/notify/watchpoint_test.go | 162 ++++
72 files changed, 8586 insertions(+)
create mode 100644 Godeps/Godeps.json
create mode 100644 Godeps/Readme
create mode 100644 Godeps/_workspace/.gitignore
create mode 100644 Godeps/_workspace/src/github.com/cenkalti/backoff/.gitignore
create mode 100644 Godeps/_workspace/src/github.com/cenkalti/backoff/.travis.yml
create mode 100644 Godeps/_workspace/src/github.com/cenkalti/backoff/LICENSE
create mode 100644 Godeps/_workspace/src/github.com/cenkalti/backoff/README.md
create mode 100644 Godeps/_workspace/src/github.com/cenkalti/backoff/adv_example_test.go
create mode 100644 Godeps/_workspace/src/github.com/cenkalti/backoff/backoff.go
create mode 100644 Godeps/_workspace/src/github.com/cenkalti/backoff/backoff_test.go
create mode 100644 Godeps/_workspace/src/github.com/cenkalti/backoff/example_test.go
create mode 100644 Godeps/_workspace/src/github.com/cenkalti/backoff/exponential.go
create mode 100644 Godeps/_workspace/src/github.com/cenkalti/backoff/exponential_test.go
create mode 100644 Godeps/_workspace/src/github.com/cenkalti/backoff/retry.go
create mode 100644 Godeps/_workspace/src/github.com/cenkalti/backoff/retry_test.go
create mode 100644 Godeps/_workspace/src/github.com/cenkalti/backoff/ticker.go
create mode 100644 Godeps/_workspace/src/github.com/cenkalti/backoff/ticker_test.go
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/.gitignore
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/.travis.yml
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/AUTHORS
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/LICENSE
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/README.md
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/appveyor.yml
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/debug.go
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/debug_debug.go
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/doc.go
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/event.go
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/event_fsevents.go
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/event_inotify.go
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/event_kqueue.go
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/event_readdcw.go
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/event_stub.go
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/event_test.go
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/example_fsevents_test.go
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/example_inotify_test.go
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/example_readdcw_test.go
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/example_test.go
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/node.go
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/notify.go
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/notify_inotify_test.go
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/notify_readdcw_test.go
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/notify_test.go
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/sync_readdcw_test.go
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/sync_unix_test.go
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/testdata/vfs.txt
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/testing_test.go
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/tree.go
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/tree_nonrecursive.go
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/tree_nonrecursive_test.go
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/tree_recursive.go
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/tree_recursive_test.go
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/util.go
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/util_darwin_test.go
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/util_test.go
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/util_unix_test.go
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/watcher.go
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/watcher_fsevents.go
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/watcher_fsevents_cgo.go
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/watcher_fsevents_test.go
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/watcher_inotify.go
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/watcher_inotify_test.go
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/watcher_kqueue.go
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/watcher_kqueue_test.go
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/watcher_readdcw.go
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/watcher_readdcw_test.go
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/watcher_recursive_test.go
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/watcher_stub.go
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/watcher_test.go
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/watchpoint.go
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/watchpoint_other.go
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/watchpoint_readdcw.go
create mode 100644 Godeps/_workspace/src/github.com/zillode/notify/watchpoint_test.go
diff --git a/Godeps/Godeps.json b/Godeps/Godeps.json
new file mode 100644
index 0000000..79c42a5
--- /dev/null
+++ b/Godeps/Godeps.json
@@ -0,0 +1,14 @@
+{
+ "ImportPath": "github.com/syncthing/syncthing-inotify",
+ "GoVersion": "go1.5.1",
+ "Deps": [
+ {
+ "ImportPath": "github.com/cenkalti/backoff",
+ "Rev": "4dc77674aceaabba2c7e3da25d4c823edfb73f99"
+ },
+ {
+ "ImportPath": "github.com/zillode/notify",
+ "Rev": "f06b1e3b795091f2e1414067b08e5f07332cdb05"
+ }
+ ]
+}
diff --git a/Godeps/Readme b/Godeps/Readme
new file mode 100644
index 0000000..4cdaa53
--- /dev/null
+++ b/Godeps/Readme
@@ -0,0 +1,5 @@
+This directory tree is generated automatically by godep.
+
+Please do not edit.
+
+See https://github.com/tools/godep for more information.
diff --git a/Godeps/_workspace/.gitignore b/Godeps/_workspace/.gitignore
new file mode 100644
index 0000000..f037d68
--- /dev/null
+++ b/Godeps/_workspace/.gitignore
@@ -0,0 +1,2 @@
+/pkg
+/bin
diff --git a/Godeps/_workspace/src/github.com/cenkalti/backoff/.gitignore b/Godeps/_workspace/src/github.com/cenkalti/backoff/.gitignore
new file mode 100644
index 0000000..0026861
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/cenkalti/backoff/.gitignore
@@ -0,0 +1,22 @@
+# Compiled Object files, Static and Dynamic libs (Shared Objects)
+*.o
+*.a
+*.so
+
+# Folders
+_obj
+_test
+
+# Architecture specific extensions/prefixes
+*.[568vq]
+[568vq].out
+
+*.cgo1.go
+*.cgo2.c
+_cgo_defun.c
+_cgo_gotypes.go
+_cgo_export.*
+
+_testmain.go
+
+*.exe
diff --git a/Godeps/_workspace/src/github.com/cenkalti/backoff/.travis.yml b/Godeps/_workspace/src/github.com/cenkalti/backoff/.travis.yml
new file mode 100644
index 0000000..ce9cb62
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/cenkalti/backoff/.travis.yml
@@ -0,0 +1,2 @@
+language: go
+go: 1.3.3
diff --git a/Godeps/_workspace/src/github.com/cenkalti/backoff/LICENSE b/Godeps/_workspace/src/github.com/cenkalti/backoff/LICENSE
new file mode 100644
index 0000000..89b8179
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/cenkalti/backoff/LICENSE
@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Cenk Altı
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/Godeps/_workspace/src/github.com/cenkalti/backoff/README.md b/Godeps/_workspace/src/github.com/cenkalti/backoff/README.md
new file mode 100644
index 0000000..020b8fb
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/cenkalti/backoff/README.md
@@ -0,0 +1,116 @@
+# Exponential Backoff [![GoDoc][godoc image]][godoc] [![Build Status][travis image]][travis]
+
+This is a Go port of the exponential backoff algorithm from [Google's HTTP Client Library for Java][google-http-java-client].
+
+[Exponential backoff][exponential backoff wiki]
+is an algorithm that uses feedback to multiplicatively decrease the rate of some process,
+in order to gradually find an acceptable rate.
+The retries exponentially increase and stop increasing when a certain threshold is met.
+
+## How To
+
+We define two functions, `Retry()` and `RetryNotify()`.
+They receive an `Operation` to execute, a `BackOff` algorithm,
+and an optional `Notify` error handler.
+
+The operation will be executed, and will be retried on failure with delay
+as given by the backoff algorithm. The backoff algorithm can also decide when to stop
+retrying.
+In addition, the notify error handler will be called after each failed attempt,
+except for the last time, whose error should be handled by the caller.
+
+```go
+// An Operation is executing by Retry() or RetryNotify().
+// The operation will be retried using a backoff policy if it returns an error.
+type Operation func() error
+
+// Notify is a notify-on-error function. It receives an operation error and
+// backoff delay if the operation failed (with an error).
+//
+// NOTE that if the backoff policy stated to stop retrying,
+// the notify function isn't called.
+type Notify func(error, time.Duration)
+
+func Retry(Operation, BackOff) error
+func RetryNotify(Operation, BackOff, Notify)
+```
+
+## Examples
+
+See more advanced examples in the [godoc][advanced example].
+
+### Retry
+
+Simple retry helper that uses the default exponential backoff algorithm:
+
+```go
+operation := func() error {
+ // An operation that might fail.
+ return nil // or return errors.New("some error")
+}
+
+err := Retry(operation, NewExponentialBackOff())
+if err != nil {
+ // Handle error.
+ return err
+}
+
+// Operation is successful.
+return nil
+```
+
+### Ticker
+
+```go
+operation := func() error {
+ // An operation that might fail
+ return nil // or return errors.New("some error")
+}
+
+b := NewExponentialBackOff()
+ticker := NewTicker(b)
+
+var err error
+
+// Ticks will continue to arrive when the previous operation is still running,
+// so operations that take a while to fail could run in quick succession.
+for range ticker.C {
+ if err = operation(); err != nil {
+ log.Println(err, "will retry...")
+ continue
+ }
+
+ ticker.Stop()
+ break
+}
+
+if err != nil {
+ // Operation has failed.
+ return err
+}
+
+// Operation is successful.
+return nil
+```
+
+## Getting Started
+
+```bash
+# install
+$ go get github.com/cenkalti/backoff
+
+# test
+$ cd $GOPATH/src/github.com/cenkalti/backoff
+$ go get -t ./...
+$ go test -v -cover
+```
+
+[godoc]: https://godoc.org/github.com/cenkalti/backoff
+[godoc image]: https://godoc.org/github.com/cenkalti/backoff?status.png
+[travis]: https://travis-ci.org/cenkalti/backoff
+[travis image]: https://travis-ci.org/cenkalti/backoff.png
+
+[google-http-java-client]: https://github.com/google/google-http-java-client
+[exponential backoff wiki]: http://en.wikipedia.org/wiki/Exponential_backoff
+
+[advanced example]: https://godoc.org/github.com/cenkalti/backoff#example_
diff --git a/Godeps/_workspace/src/github.com/cenkalti/backoff/adv_example_test.go b/Godeps/_workspace/src/github.com/cenkalti/backoff/adv_example_test.go
new file mode 100644
index 0000000..3fe6783
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/cenkalti/backoff/adv_example_test.go
@@ -0,0 +1,117 @@
+package backoff
+
+import (
+ "io/ioutil"
+ "log"
+ "net/http"
+ "time"
+)
+
+// This is an example that demonstrates how this package could be used
+// to perform various advanced operations.
+//
+// It executes an HTTP GET request with exponential backoff,
+// while errors are logged and failed responses are closed, as required by net/http package.
+//
+// Note we define a condition function which is used inside the operation to
+// determine whether the operation succeeded or failed.
+func Example() error {
+ res, err := GetWithRetry(
+ "http://localhost:9999",
+ ErrorIfStatusCodeIsNot(http.StatusOK),
+ NewExponentialBackOff())
+
+ if err != nil {
+ // Close response body of last (failed) attempt.
+ // The Last attempt isn't handled by the notify-on-error function,
+ // which closes the body of all the previous attempts.
+ if e := res.Body.Close(); e != nil {
+ log.Printf("error closing last attempt's response body: %s", e)
+ }
+ log.Printf("too many failed request attempts: %s", err)
+ return err
+ }
+ defer res.Body.Close() // The response's Body must be closed.
+
+ // Read body
+ _, _ = ioutil.ReadAll(res.Body)
+
+ // Do more stuff
+ return nil
+}
+
+// GetWithRetry is a helper function that performs an HTTP GET request
+// to the given URL, and retries with the given backoff using the given condition function.
+//
+// It also uses a notify-on-error function which logs
+// and closes the response body of the failed request.
+func GetWithRetry(url string, condition Condition, bck BackOff) (*http.Response, error) {
+ var res *http.Response
+ err := RetryNotify(
+ func() error {
+ var err error
+ res, err = http.Get(url)
+ if err != nil {
+ return err
+ }
+ return condition(res)
+ },
+ bck,
+ LogAndClose())
+
+ return res, err
+}
+
+// Condition is a retry condition function.
+// It receives a response, and returns an error
+// if the response failed the condition.
+type Condition func(*http.Response) error
+
+// ErrorIfStatusCodeIsNot returns a retry condition function.
+// The condition returns an error
+// if the given response's status code is not the given HTTP status code.
+func ErrorIfStatusCodeIsNot(status int) Condition {
+ return func(res *http.Response) error {
+ if res.StatusCode != status {
+ return NewError(res)
+ }
+ return nil
+ }
+}
+
+// Error is returned on ErrorIfX() condition functions throughout this package.
+type Error struct {
+ Response *http.Response
+}
+
+func NewError(res *http.Response) *Error {
+ // Sanity check
+ if res == nil {
+ panic("response object is nil")
+ }
+ return &Error{Response: res}
+}
+func (err *Error) Error() string { return "request failed" }
+
+// LogAndClose is a notify-on-error function.
+// It logs the error and closes the response body.
+func LogAndClose() Notify {
+ return func(err error, wait time.Duration) {
+ switch e := err.(type) {
+ case *Error:
+ defer e.Response.Body.Close()
+
+ b, err := ioutil.ReadAll(e.Response.Body)
+ var body string
+ if err != nil {
+ body = "can't read body"
+ } else {
+ body = string(b)
+ }
+
+ log.Printf("%s: %s", e.Response.Status, body)
+ default:
+ log.Println(err)
+ }
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/cenkalti/backoff/backoff.go b/Godeps/_workspace/src/github.com/cenkalti/backoff/backoff.go
new file mode 100644
index 0000000..61bd6df
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/cenkalti/backoff/backoff.go
@@ -0,0 +1,59 @@
+// Package backoff implements backoff algorithms for retrying operations.
+//
+// Also has a Retry() helper for retrying operations that may fail.
+package backoff
+
+import "time"
+
+// BackOff is a backoff policy for retrying an operation.
+type BackOff interface {
+ // NextBackOff returns the duration to wait before retrying the operation,
+ // or backoff.Stop to indicate that no more retries should be made.
+ //
+ // Example usage:
+ //
+ // duration := backoff.NextBackOff();
+ // if (duration == backoff.Stop) {
+ // // Do not retry operation.
+ // } else {
+ // // Sleep for duration and retry operation.
+ // }
+ //
+ NextBackOff() time.Duration
+
+ // Reset to initial state.
+ Reset()
+}
+
+// Indicates that no more retries should be made for use in NextBackOff().
+const Stop time.Duration = -1
+
+// ZeroBackOff is a fixed backoff policy whose backoff time is always zero,
+// meaning that the operation is retried immediately without waiting, indefinitely.
+type ZeroBackOff struct{}
+
+func (b *ZeroBackOff) Reset() {}
+
+func (b *ZeroBackOff) NextBackOff() time.Duration { return 0 }
+
+// StopBackOff is a fixed backoff policy that always returns backoff.Stop for
+// NextBackOff(), meaning that the operation should never be retried.
+type StopBackOff struct{}
+
+func (b *StopBackOff) Reset() {}
+
+func (b *StopBackOff) NextBackOff() time.Duration { return Stop }
+
+// ConstantBackOff is a backoff policy that always returns the same backoff delay.
+// This is in contrast to an exponential backoff policy,
+// which returns a delay that grows longer as you call NextBackOff() over and over again.
+type ConstantBackOff struct {
+ Interval time.Duration
+}
+
+func (b *ConstantBackOff) Reset() {}
+func (b *ConstantBackOff) NextBackOff() time.Duration { return b.Interval }
+
+func NewConstantBackOff(d time.Duration) *ConstantBackOff {
+ return &ConstantBackOff{Interval: d}
+}
diff --git a/Godeps/_workspace/src/github.com/cenkalti/backoff/backoff_test.go b/Godeps/_workspace/src/github.com/cenkalti/backoff/backoff_test.go
new file mode 100644
index 0000000..91f27c4
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/cenkalti/backoff/backoff_test.go
@@ -0,0 +1,27 @@
+package backoff
+
+import (
+ "testing"
+ "time"
+)
+
+func TestNextBackOffMillis(t *testing.T) {
+ subtestNextBackOff(t, 0, new(ZeroBackOff))
+ subtestNextBackOff(t, Stop, new(StopBackOff))
+}
+
+func subtestNextBackOff(t *testing.T, expectedValue time.Duration, backOffPolicy BackOff) {
+ for i := 0; i < 10; i++ {
+ next := backOffPolicy.NextBackOff()
+ if next != expectedValue {
+ t.Errorf("got: %d expected: %d", next, expectedValue)
+ }
+ }
+}
+
+func TestConstantBackOff(t *testing.T) {
+ backoff := NewConstantBackOff(time.Second)
+ if backoff.NextBackOff() != time.Second {
+ t.Error("invalid interval")
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/cenkalti/backoff/example_test.go b/Godeps/_workspace/src/github.com/cenkalti/backoff/example_test.go
new file mode 100644
index 0000000..0d1852e
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/cenkalti/backoff/example_test.go
@@ -0,0 +1,51 @@
+package backoff
+
+import "log"
+
+func ExampleRetry() error {
+ operation := func() error {
+ // An operation that might fail.
+ return nil // or return errors.New("some error")
+ }
+
+ err := Retry(operation, NewExponentialBackOff())
+ if err != nil {
+ // Handle error.
+ return err
+ }
+
+ // Operation is successful.
+ return nil
+}
+
+func ExampleTicker() error {
+ operation := func() error {
+ // An operation that might fail
+ return nil // or return errors.New("some error")
+ }
+
+ b := NewExponentialBackOff()
+ ticker := NewTicker(b)
+
+ var err error
+
+ // Ticks will continue to arrive when the previous operation is still running,
+ // so operations that take a while to fail could run in quick succession.
+ for _ = range ticker.C {
+ if err = operation(); err != nil {
+ log.Println(err, "will retry...")
+ continue
+ }
+
+ ticker.Stop()
+ break
+ }
+
+ if err != nil {
+ // Operation has failed.
+ return err
+ }
+
+ // Operation is successful.
+ return nil
+}
diff --git a/Godeps/_workspace/src/github.com/cenkalti/backoff/exponential.go b/Godeps/_workspace/src/github.com/cenkalti/backoff/exponential.go
new file mode 100644
index 0000000..cc2a164
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/cenkalti/backoff/exponential.go
@@ -0,0 +1,151 @@
+package backoff
+
+import (
+ "math/rand"
+ "time"
+)
+
+/*
+ExponentialBackOff is a backoff implementation that increases the backoff
+period for each retry attempt using a randomization function that grows exponentially.
+
+NextBackOff() is calculated using the following formula:
+
+ randomized interval =
+ RetryInterval * (random value in range [1 - RandomizationFactor, 1 + RandomizationFactor])
+
+In other words NextBackOff() will range between the randomization factor
+percentage below and above the retry interval.
+
+For example, given the following parameters:
+
+ RetryInterval = 2
+ RandomizationFactor = 0.5
+ Multiplier = 2
+
+the actual backoff period used in the next retry attempt will range between 1 and 3 seconds,
+multiplied by the exponential, that is, between 2 and 6 seconds.
+
+Note: MaxInterval caps the RetryInterval and not the randomized interval.
+
+If the time elapsed since an ExponentialBackOff instance is created goes past the
+MaxElapsedTime, then the method NextBackOff() starts returning backoff.Stop.
+
+The elapsed time can be reset by calling Reset().
+
+Example: Given the following default arguments, for 10 tries the sequence will be,
+and assuming we go over the MaxElapsedTime on the 10th try:
+
+ Request # RetryInterval (seconds) Randomized Interval (seconds)
+
+ 1 0.5 [0.25, 0.75]
+ 2 0.75 [0.375, 1.125]
+ 3 1.125 [0.562, 1.687]
+ 4 1.687 [0.8435, 2.53]
+ 5 2.53 [1.265, 3.795]
+ 6 3.795 [1.897, 5.692]
+ 7 5.692 [2.846, 8.538]
+ 8 8.538 [4.269, 12.807]
+ 9 12.807 [6.403, 19.210]
+ 10 19.210 backoff.Stop
+
+Note: Implementation is not thread-safe.
+*/
+type ExponentialBackOff struct {
+ InitialInterval time.Duration
+ RandomizationFactor float64
+ Multiplier float64
+ MaxInterval time.Duration
+ // After MaxElapsedTime the ExponentialBackOff stops.
+ // It never stops if MaxElapsedTime == 0.
+ MaxElapsedTime time.Duration
+ Clock Clock
+
+ currentInterval time.Duration
+ startTime time.Time
+}
+
+// Clock is an interface that returns current time for BackOff.
+type Clock interface {
+ Now() time.Time
+}
+
+// Default values for ExponentialBackOff.
+const (
+ DefaultInitialInterval = 500 * time.Millisecond
+ DefaultRandomizationFactor = 0.5
+ DefaultMultiplier = 1.5
+ DefaultMaxInterval = 60 * time.Second
+ DefaultMaxElapsedTime = 15 * time.Minute
+)
+
+// NewExponentialBackOff creates an instance of ExponentialBackOff using default values.
+func NewExponentialBackOff() *ExponentialBackOff {
+ b := &ExponentialBackOff{
+ InitialInterval: DefaultInitialInterval,
+ RandomizationFactor: DefaultRandomizationFactor,
+ Multiplier: DefaultMultiplier,
+ MaxInterval: DefaultMaxInterval,
+ MaxElapsedTime: DefaultMaxElapsedTime,
+ Clock: SystemClock,
+ }
+ b.Reset()
+ return b
+}
+
+type systemClock struct{}
+
+func (t systemClock) Now() time.Time {
+ return time.Now()
+}
+
+// SystemClock implements Clock interface that uses time.Now().
+var SystemClock = systemClock{}
+
+// Reset the interval back to the initial retry interval and restarts the timer.
+func (b *ExponentialBackOff) Reset() {
+ b.currentInterval = b.InitialInterval
+ b.startTime = b.Clock.Now()
+}
+
+// NextBackOff calculates the next backoff interval using the formula:
+// Randomized interval = RetryInterval +/- (RandomizationFactor * RetryInterval)
+func (b *ExponentialBackOff) NextBackOff() time.Duration {
+ // Make sure we have not gone over the maximum elapsed time.
+ if b.MaxElapsedTime != 0 && b.GetElapsedTime() > b.MaxElapsedTime {
+ return Stop
+ }
+ defer b.incrementCurrentInterval()
+ return getRandomValueFromInterval(b.RandomizationFactor, rand.Float64(), b.currentInterval)
+}
+
+// GetElapsedTime returns the elapsed time since an ExponentialBackOff instance
+// is created and is reset when Reset() is called.
+//
+// The elapsed time is computed using time.Now().UnixNano().
+func (b *ExponentialBackOff) GetElapsedTime() time.Duration {
+ return b.Clock.Now().Sub(b.startTime)
+}
+
+// Increments the current interval by multiplying it with the multiplier.
+func (b *ExponentialBackOff) incrementCurrentInterval() {
+ // Check for overflow, if overflow is detected set the current interval to the max interval.
+ if float64(b.currentInterval) >= float64(b.MaxInterval)/b.Multiplier {
+ b.currentInterval = b.MaxInterval
+ } else {
+ b.currentInterval = time.Duration(float64(b.currentInterval) * b.Multiplier)
+ }
+}
+
+// Returns a random value from the following interval:
+// [randomizationFactor * currentInterval, randomizationFactor * currentInterval].
+func getRandomValueFromInterval(randomizationFactor, random float64, currentInterval time.Duration) time.Duration {
+ var delta = randomizationFactor * float64(currentInterval)
+ var minInterval = float64(currentInterval) - delta
+ var maxInterval = float64(currentInterval) + delta
+
+ // Get a random value from the range [minInterval, maxInterval].
+ // The formula used below has a +1 because if the minInterval is 1 and the maxInterval is 3 then
+ // we want a 33% chance for selecting either 1, 2 or 3.
+ return time.Duration(minInterval + (random * (maxInterval - minInterval + 1)))
+}
diff --git a/Godeps/_workspace/src/github.com/cenkalti/backoff/exponential_test.go b/Godeps/_workspace/src/github.com/cenkalti/backoff/exponential_test.go
new file mode 100644
index 0000000..11b95e4
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/cenkalti/backoff/exponential_test.go
@@ -0,0 +1,108 @@
+package backoff
+
+import (
+ "math"
+ "testing"
+ "time"
+)
+
+func TestBackOff(t *testing.T) {
+ var (
+ testInitialInterval = 500 * time.Millisecond
+ testRandomizationFactor = 0.1
+ testMultiplier = 2.0
+ testMaxInterval = 5 * time.Second
+ testMaxElapsedTime = 15 * time.Minute
+ )
+
+ exp := NewExponentialBackOff()
+ exp.InitialInterval = testInitialInterval
+ exp.RandomizationFactor = testRandomizationFactor
+ exp.Multiplier = testMultiplier
+ exp.MaxInterval = testMaxInterval
+ exp.MaxElapsedTime = testMaxElapsedTime
+ exp.Reset()
+
+ var expectedResults = []time.Duration{500, 1000, 2000, 4000, 5000, 5000, 5000, 5000, 5000, 5000}
+ for i, d := range expectedResults {
+ expectedResults[i] = d * time.Millisecond
+ }
+
+ for _, expected := range expectedResults {
+ assertEquals(t, expected, exp.currentInterval)
+ // Assert that the next backoff falls in the expected range.
+ var minInterval = expected - time.Duration(testRandomizationFactor*float64(expected))
+ var maxInterval = expected + time.Duration(testRandomizationFactor*float64(expected))
+ var actualInterval = exp.NextBackOff()
+ if !(minInterval <= actualInterval && actualInterval <= maxInterval) {
+ t.Error("error")
+ }
+ }
+}
+
+func TestGetRandomizedInterval(t *testing.T) {
+ // 33% chance of being 1.
+ assertEquals(t, 1, getRandomValueFromInterval(0.5, 0, 2))
+ assertEquals(t, 1, getRandomValueFromInterval(0.5, 0.33, 2))
+ // 33% chance of being 2.
+ assertEquals(t, 2, getRandomValueFromInterval(0.5, 0.34, 2))
+ assertEquals(t, 2, getRandomValueFromInterval(0.5, 0.66, 2))
+ // 33% chance of being 3.
+ assertEquals(t, 3, getRandomValueFromInterval(0.5, 0.67, 2))
+ assertEquals(t, 3, getRandomValueFromInterval(0.5, 0.99, 2))
+}
+
+type TestClock struct {
+ i time.Duration
+ start time.Time
+}
+
+func (c *TestClock) Now() time.Time {
+ t := c.start.Add(c.i)
+ c.i += time.Second
+ return t
+}
+
+func TestGetElapsedTime(t *testing.T) {
+ var exp = NewExponentialBackOff()
+ exp.Clock = &TestClock{}
+ exp.Reset()
+
+ var elapsedTime = exp.GetElapsedTime()
+ if elapsedTime != time.Second {
+ t.Errorf("elapsedTime=%d", elapsedTime)
+ }
+}
+
+func TestMaxElapsedTime(t *testing.T) {
+ var exp = NewExponentialBackOff()
+ exp.Clock = &TestClock{start: time.Time{}.Add(10000 * time.Second)}
+ // Change the currentElapsedTime to be 0 ensuring that the elapsed time will be greater
+ // than the max elapsed time.
+ exp.startTime = time.Time{}
+ assertEquals(t, Stop, exp.NextBackOff())
+}
+
+func TestBackOffOverflow(t *testing.T) {
+ var (
+ testInitialInterval time.Duration = math.MaxInt64 / 2
+ testMaxInterval time.Duration = math.MaxInt64
+ testMultiplier = 2.1
+ )
+
+ exp := NewExponentialBackOff()
+ exp.InitialInterval = testInitialInterval
+ exp.Multiplier = testMultiplier
+ exp.MaxInterval = testMaxInterval
+ exp.Reset()
+
+ exp.NextBackOff()
+ // Assert that when an overflow is possible the current varerval time.Duration is set to the max varerval time.Duration .
+ assertEquals(t, testMaxInterval, exp.currentInterval)
+}
+
+func assertEquals(t *testing.T, expected, value time.Duration) {
+ if expected != value {
+ t.Errorf("got: %d, expected: %d", value, expected)
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/cenkalti/backoff/retry.go b/Godeps/_workspace/src/github.com/cenkalti/backoff/retry.go
new file mode 100644
index 0000000..f01f2bb
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/cenkalti/backoff/retry.go
@@ -0,0 +1,46 @@
+package backoff
+
+import "time"
+
+// An Operation is executing by Retry() or RetryNotify().
+// The operation will be retried using a backoff policy if it returns an error.
+type Operation func() error
+
+// Notify is a notify-on-error function. It receives an operation error and
+// backoff delay if the operation failed (with an error).
+//
+// NOTE that if the backoff policy stated to stop retrying,
+// the notify function isn't called.
+type Notify func(error, time.Duration)
+
+// Retry the function f until it does not return error or BackOff stops.
+// f is guaranteed to be run at least once.
+// It is the caller's responsibility to reset b after Retry returns.
+//
+// Retry sleeps the goroutine for the duration returned by BackOff after a
+// failed operation returns.
+func Retry(o Operation, b BackOff) error { return RetryNotify(o, b, nil) }
+
+// RetryNotify calls notify function with the error and wait duration
+// for each failed attempt before sleep.
+func RetryNotify(operation Operation, b BackOff, notify Notify) error {
+ var err error
+ var next time.Duration
+
+ b.Reset()
+ for {
+ if err = operation(); err == nil {
+ return nil
+ }
+
+ if next = b.NextBackOff(); next == Stop {
+ return err
+ }
+
+ if notify != nil {
+ notify(err, next)
+ }
+
+ time.Sleep(next)
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/cenkalti/backoff/retry_test.go b/Godeps/_workspace/src/github.com/cenkalti/backoff/retry_test.go
new file mode 100644
index 0000000..c0d25ab
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/cenkalti/backoff/retry_test.go
@@ -0,0 +1,34 @@
+package backoff
+
+import (
+ "errors"
+ "log"
+ "testing"
+)
+
+func TestRetry(t *testing.T) {
+ const successOn = 3
+ var i = 0
+
+ // This function is successfull on "successOn" calls.
+ f := func() error {
+ i++
+ log.Printf("function is called %d. time\n", i)
+
+ if i == successOn {
+ log.Println("OK")
+ return nil
+ }
+
+ log.Println("error")
+ return errors.New("error")
+ }
+
+ err := Retry(f, NewExponentialBackOff())
+ if err != nil {
+ t.Errorf("unexpected error: %s", err.Error())
+ }
+ if i != successOn {
+ t.Errorf("invalid number of retries: %d", i)
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/cenkalti/backoff/ticker.go b/Godeps/_workspace/src/github.com/cenkalti/backoff/ticker.go
new file mode 100644
index 0000000..7a5ff4e
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/cenkalti/backoff/ticker.go
@@ -0,0 +1,79 @@
+package backoff
+
+import (
+ "runtime"
+ "sync"
+ "time"
+)
+
+// Ticker holds a channel that delivers `ticks' of a clock at times reported by a BackOff.
+//
+// Ticks will continue to arrive when the previous operation is still running,
+// so operations that take a while to fail could run in quick succession.
+type Ticker struct {
+ C <-chan time.Time
+ c chan time.Time
+ b BackOff
+ stop chan struct{}
+ stopOnce sync.Once
+}
+
+// NewTicker returns a new Ticker containing a channel that will send the time at times
+// specified by the BackOff argument. Ticker is guaranteed to tick at least once.
+// The channel is closed when Stop method is called or BackOff stops.
+func NewTicker(b BackOff) *Ticker {
+ c := make(chan time.Time)
+ t := &Ticker{
+ C: c,
+ c: c,
+ b: b,
+ stop: make(chan struct{}),
+ }
+ go t.run()
+ runtime.SetFinalizer(t, (*Ticker).Stop)
+ return t
+}
+
+// Stop turns off a ticker. After Stop, no more ticks will be sent.
+func (t *Ticker) Stop() {
+ t.stopOnce.Do(func() { close(t.stop) })
+}
+
+func (t *Ticker) run() {
+ c := t.c
+ defer close(c)
+ t.b.Reset()
+
+ // Ticker is guaranteed to tick at least once.
+ afterC := t.send(time.Now())
+
+ for {
+ if afterC == nil {
+ return
+ }
+
+ select {
+ case tick := <-afterC:
+ afterC = t.send(tick)
+ case <-t.stop:
+ t.c = nil // Prevent future ticks from being sent to the channel.
+ return
+ }
+ }
+}
+
+func (t *Ticker) send(tick time.Time) <-chan time.Time {
+ select {
+ case t.c <- tick:
+ case <-t.stop:
+ return nil
+ }
+
+ next := t.b.NextBackOff()
+ if next == Stop {
+ t.Stop()
+ return nil
+ }
+
+ return time.After(next)
+}
diff --git a/Godeps/_workspace/src/github.com/cenkalti/backoff/ticker_test.go b/Godeps/_workspace/src/github.com/cenkalti/backoff/ticker_test.go
new file mode 100644
index 0000000..7c392df
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/cenkalti/backoff/ticker_test.go
@@ -0,0 +1,45 @@
+package backoff
+
+import (
+ "errors"
+ "log"
+ "testing"
+)
+
+func TestTicker(t *testing.T) {
+ const successOn = 3
+ var i = 0
+
+ // This function is successfull on "successOn" calls.
+ f := func() error {
+ i++
+ log.Printf("function is called %d. time\n", i)
+
+ if i == successOn {
+ log.Println("OK")
+ return nil
+ }
+
+ log.Println("error")
+ return errors.New("error")
+ }
+
+ b := NewExponentialBackOff()
+ ticker := NewTicker(b)
+
+ var err error
+ for _ = range ticker.C {
+ if err = f(); err != nil {
+ t.Log(err)
+ continue
+ }
+
+ break
+ }
+ if err != nil {
+ t.Errorf("unexpected error: %s", err.Error())
+ }
+ if i != successOn {
+ t.Errorf("invalid number of retries: %d", i)
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/.gitignore b/Godeps/_workspace/src/github.com/zillode/notify/.gitignore
new file mode 100644
index 0000000..86d4fa8
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/.gitignore
@@ -0,0 +1,88 @@
+# Created by https://www.gitignore.io
+
+### OSX ###
+.DS_Store
+.AppleDouble
+.LSOverride
+
+# Icon must end with two \r
+Icon
+
+# Thumbnails
+._*
+
+# Files that might appear on external disk
+.Spotlight-V100
+.Trashes
+
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+
+### Windows ###
+# Windows image file caches
+Thumbs.db
+ehthumbs.db
+
+# Folder config file
+Desktop.ini
+
+# Recycle Bin used on file shares
+$RECYCLE.BIN/
+
+# Windows Installer files
+*.cab
+*.msi
+*.msm
+*.msp
+
+# Windows shortcuts
+*.lnk
+
+
+### Linux ###
+*~
+
+# KDE directory preferences
+.directory
+
+
+### Go ###
+# Compiled Object files, Static and Dynamic libs (Shared Objects)
+*.o
+*.a
+*.so
+
+# Folders
+_obj
+_test
+
+# Architecture specific extensions/prefixes
+*.[568vq]
+[568vq].out
+
+*.cgo1.go
+*.cgo2.c
+_cgo_defun.c
+_cgo_gotypes.go
+_cgo_export.*
+
+_testmain.go
+
+*.exe
+*.test
+*.prof
+
+
+### vim ###
+[._]*.s[a-w][a-z]
+[._]s[a-w][a-z]
+*.un~
+Session.vim
+.netrwhist
+*~
+
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/.travis.yml b/Godeps/_workspace/src/github.com/zillode/notify/.travis.yml
new file mode 100644
index 0000000..f287755
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/.travis.yml
@@ -0,0 +1,35 @@
+language: go
+
+go:
+ - 1.4.2
+
+os:
+ - linux
+ - osx
+
+matrix:
+ include:
+ - os: osx
+ go: 1.4.2
+ env:
+ - GOFLAGS="-tags kqueue"
+
+env:
+ global:
+ - secure: JfdLa3hcnvIwT13kbH2fr4c+4V9H4yO4GZsqDckODmxILlEtKcCLM5eCi09D21uTuaMUfZDIFNPN4mpDhbeEoM6Aoro4Ht+mX0vlpFUOS5bRqhP0l59PKEXqKFfh2IIlqEOmQ9XU6XvqWezTirN1OFUPMIMO9qSM/HuKhbX5wJQ=
+ - GOBIN=$HOME/bin
+ - PATH=$HOME/bin:$PATH
+
+install:
+ - if [ "$(curl -LIsS -w %{http_code} coveralls.io | tail -1)" = "200" ] && [ "$TRAVIS_OS_NAME" = "linux" ]; then export COVERALLS=1; fi
+ - go get golang.org/x/tools/cmd/vet
+ - if [ "$COVERALLS" = "1" ]; then go get golang.org/x/tools/cmd/cover github.com/mattn/goveralls github.com/modocache/gover; fi
+ - go get -t -v ./...
+
+script:
+ - go tool vet -all .
+ - go install $GOFLAGS ./...
+ - go test -v -race $GOFLAGS ./...
+ - if [ "$COVERALLS" = "1" ]; then go list -f '{{if len .TestGoFiles}}go test -coverprofile={{.Dir}}/.coverprofile {{.ImportPath}}{{end}}' ./... | xargs -i sh -c {}; fi
+ - if [ "$COVERALLS" = "1" ]; then gover; fi
+ - if [ "$COVERALLS" = "1" ]; then goveralls -coverprofile=gover.coverprofile -service=travis-ci -repotoken $COVERALLS_TOKEN; fi
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/AUTHORS b/Godeps/_workspace/src/github.com/zillode/notify/AUTHORS
new file mode 100644
index 0000000..9262eae
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/AUTHORS
@@ -0,0 +1,10 @@
+# List of individuals who contributed to the Notify package.
+#
+# The up-to-date list of the authors one may obtain with:
+#
+# ~ $ git shortlog -es | cut -f2 | rev | uniq -f1 | rev
+#
+
+Pawel Blaszczyk <blaszczykpb@gmail.com>
+Pawel Knap <pawelknap88@gmail.com>
+Rafal Jeczalik <rjeczalik@gmail.com>
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/LICENSE b/Godeps/_workspace/src/github.com/zillode/notify/LICENSE
new file mode 100644
index 0000000..3e67881
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014-2015 The Notify Authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/README.md b/Godeps/_workspace/src/github.com/zillode/notify/README.md
new file mode 100644
index 0000000..adbeb3f
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/README.md
@@ -0,0 +1,18 @@
+notify [![GoDoc](https://godoc.org/github.com/rjeczalik/notify?status.svg)](https://godoc.org/github.com/rjeczalik/notify) [![Build Status](https://img.shields.io/travis/rjeczalik/notify/master.svg)](https://travis-ci.org/rjeczalik/notify "inotify + FSEvents + kqueue") [![Build status](https://img.shields.io/appveyor/ci/rjeczalik/notify-246.svg)](https://ci.appveyor.com/project/rjeczalik/notify-246 "ReadDirectoryChangesW") [![Coverage Status](https://img.shields.io/coveralls/rjeczalik/notify/master.svg)](https://coveralls.io/r/rjeczalik/notify?branch=master)
+======
+
+Filesystem event notification library on steroids. (under active development)
+
+*Documentation*
+
+[godoc.org/github.com/rjeczalik/notify](https://godoc.org/github.com/rjeczalik/notify)
+
+*Installation*
+
+```
+~ $ go get -u github.com/rjeczalik/notify
+```
+
+*Projects using notify*
+
+- [github.com/rjeczalik/cmd/notify](https://godoc.org/github.com/rjeczalik/cmd/notify)
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/appveyor.yml b/Godeps/_workspace/src/github.com/zillode/notify/appveyor.yml
new file mode 100644
index 0000000..16d09ac
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/appveyor.yml
@@ -0,0 +1,24 @@
+version: "{build}"
+
+os: Windows Server 2012 R2
+
+clone_folder: c:\projects\src\github.com\rjeczalik\notify
+
+environment:
+ PATH: c:\projects\bin;%PATH%
+ GOPATH: c:\projects
+ NOTIFY_TIMEOUT: 5s
+
+install:
+ - go version
+ - go get golang.org/x/tools/cmd/vet
+ - go get -v -t ./...
+
+build_script:
+ - go tool vet -all .
+ - go build ./...
+ - go test -v -race ./...
+
+test: off
+
+deploy: off
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/debug.go b/Godeps/_workspace/src/github.com/zillode/notify/debug.go
new file mode 100644
index 0000000..bd9bc46
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/debug.go
@@ -0,0 +1,11 @@
+// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+// +build !debug
+
+package notify
+
+func dbgprint(...interface{}) {}
+
+func dbgprintf(string, ...interface{}) {}
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/debug_debug.go b/Godeps/_workspace/src/github.com/zillode/notify/debug_debug.go
new file mode 100644
index 0000000..f062291
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/debug_debug.go
@@ -0,0 +1,43 @@
+// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+// +build debug
+
+package notify
+
+import (
+ "fmt"
+ "os"
+ "runtime"
+ "strings"
+)
+
+func dbgprint(v ...interface{}) {
+ fmt.Printf("[D] ")
+ fmt.Print(v...)
+ fmt.Printf("\n\n")
+}
+
+func dbgprintf(format string, v ...interface{}) {
+ fmt.Printf("[D] ")
+ fmt.Printf(format, v...)
+ fmt.Printf("\n\n")
+}
+
+func dbgcallstack(max int) []string {
+ pc, stack := make([]uintptr, max), make([]string, 0, max)
+ runtime.Callers(2, pc)
+ for _, pc := range pc {
+ if f := runtime.FuncForPC(pc); f != nil {
+ fname := f.Name()
+ idx := strings.LastIndex(fname, string(os.PathSeparator))
+ if idx != -1 {
+ stack = append(stack, fname[idx+1:])
+ } else {
+ stack = append(stack, fname)
+ }
+ }
+ }
+ return stack
+}
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/doc.go b/Godeps/_workspace/src/github.com/zillode/notify/doc.go
new file mode 100644
index 0000000..e26014e
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/doc.go
@@ -0,0 +1,39 @@
+// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+// Package notify implements access to filesystem events.
+//
+// Notify is a high-level abstraction over filesystem watchers like inotify,
+// kqueue, FSEvents or ReadDirectoryChangesW. Watcher implementations are
+// split into two groups: ones that natively support recursive notifications
+// (FSEvents and ReadDirectoryChangesW) and ones that do not (inotify and kqueue).
+// For more details see watcher and recursiveWatcher interfaces in watcher.go
+// source file.
+//
+// On top of filesystem watchers notify maintains a watchpoint tree, which provides
+// strategy for creating and closing filesystem watches and dispatching filesystem
+// events to user channels.
+//
+// An event set is just an event list joint using bitwise OR operator
+// into a single event value.
+//
+// A filesystem watch or just a watch is platform-specific entity which represents
+// a single path registered for notifications for specific event set. Setting a watch
+// means using platform-specific API calls for creating / initializing said watch.
+// For each watcher the API call is:
+//
+// - FSEvents: FSEventStreamCreate
+// - inotify: notify_add_watch
+// - kqueue: kevent
+// - ReadDirectoryChangesW: CreateFile+ReadDirectoryChangesW
+//
+// To rewatch means to either shrink or expand an event set that was previously
+// registered during watch operation for particular filesystem watch.
+//
+// A watchpoint is a list of user channel and event set pairs for particular
+// path (watchpoint tree's node). A single watchpoint can contain multiple
+// different user channels registered to listen for one or more events. A single
+// user channel can be registered in one or more watchpoints, recurisve and
+// non-recursive ones as well.
+package notify
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/event.go b/Godeps/_workspace/src/github.com/zillode/notify/event.go
new file mode 100644
index 0000000..e045edc
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/event.go
@@ -0,0 +1,143 @@
+// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+package notify
+
+import (
+ "fmt"
+ "strings"
+)
+
+// Event represents the type of filesystem action.
+//
+// Number of available event values is dependent on the target system or the
+// watcher implmenetation used (e.g. it's possible to use either kqueue or
+// FSEvents on Darwin).
+//
+// Please consult documentation for your target platform to see list of all
+// available events.
+type Event uint32
+
+// Create, Remove, Write and Rename are the only event values guaranteed to be
+// present on all platforms.
+const (
+ Create = osSpecificCreate
+ Remove = osSpecificRemove
+ Write = osSpecificWrite
+ Rename = osSpecificRename
+
+ // All is handful alias for all platform-independent event values.
+ All = Create | Remove | Write | Rename
+)
+
+const internal = recursive | omit
+
+// String implements fmt.Stringer interface.
+func (e Event) String() string {
+ var s []string
+ for _, strmap := range []map[Event]string{estr, osestr} {
+ for ev, str := range strmap {
+ if e&ev == ev {
+ s = append(s, str)
+ }
+ }
+ }
+ return strings.Join(s, "|")
+}
+
+// EventInfo describes an event reported by the underlying filesystem notification
+// subsystem.
+//
+// It always describes single event, even if the OS reported a coalesced action.
+// Reported path is absolute and clean.
+//
+// For non-recursive watchpoints its base is always equal to the path passed
+// to corresponding Watch call.
+//
+// The value of Sys if system-dependent and can be nil.
+//
+// Sys
+//
+// Under Darwin (FSEvents) Sys() always returns a non-nil *notify.FSEvent value,
+// which is defined as:
+//
+// type FSEvent struct {
+// Path string // real path of the file or directory
+// ID uint64 // ID of the event (FSEventStreamEventId)
+// Flags uint32 // joint FSEvents* flags (FSEventStreamEventFlags)
+// }
+//
+// For possible values of Flags see Darwin godoc for notify or FSEvents
+// documentation for FSEventStreamEventFlags constants:
+//
+// https://developer.apple.com/library/mac/documentation/Darwin/Reference/FSEvents_Ref/index.html#//apple_ref/doc/constant_group/FSEventStreamEventFlags
+//
+// Under Linux (inotify) Sys() always returns a non-nil *syscall.InotifyEvent
+// value, defined as:
+//
+// type InotifyEvent struct {
+// Wd int32 // Watch descriptor
+// Mask uint32 // Mask describing event
+// Cookie uint32 // Unique cookie associating related events (for rename(2))
+// Len uint32 // Size of name field
+// Name [0]uint8 // Optional null-terminated name
+// }
+//
+// More information about inotify masks and the usage of inotify_event structure
+// can be found at:
+//
+// http://man7.org/linux/man-pages/man7/inotify.7.html
+//
+// Under Darwin, DragonFlyBSD, FreeBSD, NetBSD, OpenBSD (kqueue) Sys() always
+// returns a non-nil *notify.Kevent value, which is defined as:
+//
+// type Kevent struct {
+// Kevent *syscall.Kevent_t // Kevent is a kqueue specific structure
+// FI os.FileInfo // FI describes file/dir
+// }
+//
+// More information about syscall.Kevent_t can be found at:
+//
+// https://www.freebsd.org/cgi/man.cgi?query=kqueue
+//
+// Under Windows (ReadDirectoryChangesW) Sys() always returns nil. The documentation
+// of watcher's WinAPI function can be found at:
+//
+// https://msdn.microsoft.com/en-us/library/windows/desktop/aa365465%28v=vs.85%29.aspx
+type EventInfo interface {
+ Event() Event // event value for the filesystem action
+ Path() string // real path of the file or directory
+ Sys() interface{} // underlying data source (can return nil)
+}
+
+type isDirer interface {
+ isDir() (bool, error)
+}
+
+var _ fmt.Stringer = (*event)(nil)
+var _ isDirer = (*event)(nil)
+
+// String implements fmt.Stringer interface.
+func (e *event) String() string {
+ return e.Event().String() + `: "` + e.Path() + `"`
+}
+
+var estr = map[Event]string{
+ Create: "notify.Create",
+ Remove: "notify.Remove",
+ Write: "notify.Write",
+ Rename: "notify.Rename",
+ // Display name for recursive event is added only for debugging
+ // purposes. It's an internal event after all and won't be exposed to the
+ // user. Having Recursive event printable is helpful, e.g. for reading
+ // testing failure messages:
+ //
+ // --- FAIL: TestWatchpoint (0.00 seconds)
+ // watchpoint_test.go:64: want diff=[notify.Remove notify.Create|notify.Remove];
+ // got [notify.Remove notify.Remove|notify.Create] (i=1)
+ //
+ // Yup, here the diff have Recursive event inside. Go figure.
+ recursive: "recursive",
+ omit: "omit",
+}
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/event_fsevents.go b/Godeps/_workspace/src/github.com/zillode/notify/event_fsevents.go
new file mode 100644
index 0000000..6ded80b
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/event_fsevents.go
@@ -0,0 +1,71 @@
+// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+// +build darwin,!kqueue
+
+package notify
+
+const (
+ osSpecificCreate = Event(FSEventsCreated)
+ osSpecificRemove = Event(FSEventsRemoved)
+ osSpecificWrite = Event(FSEventsModified)
+ osSpecificRename = Event(FSEventsRenamed)
+ // internal = Event(0x100000)
+ // recursive is used to distinguish recursive eventsets from non-recursive ones
+ recursive = Event(0x200000)
+ // omit is used for dispatching internal events; only those events are sent
+ // for which both the event and the watchpoint has omit in theirs event sets.
+ omit = Event(0x400000)
+)
+
+// FSEvents specific event values.
+const (
+ FSEventsMustScanSubDirs Event = 0x00001
+ FSEventsUserDropped = 0x00002
+ FSEventsKernelDropped = 0x00004
+ FSEventsEventIdsWrapped = 0x00008
+ FSEventsHistoryDone = 0x00010
+ FSEventsRootChanged = 0x00020
+ FSEventsMount = 0x00040
+ FSEventsUnmount = 0x00080
+ FSEventsCreated = 0x00100
+ FSEventsRemoved = 0x00200
+ FSEventsInodeMetaMod = 0x00400
+ FSEventsRenamed = 0x00800
+ FSEventsModified = 0x01000
+ FSEventsFinderInfoMod = 0x02000
+ FSEventsChangeOwner = 0x04000
+ FSEventsXattrMod = 0x08000
+ FSEventsIsFile = 0x10000
+ FSEventsIsDir = 0x20000
+ FSEventsIsSymlink = 0x40000
+)
+
+var osestr = map[Event]string{
+ FSEventsMustScanSubDirs: "notify.FSEventsMustScanSubDirs",
+ FSEventsUserDropped: "notify.FSEventsUserDropped",
+ FSEventsKernelDropped: "notify.FSEventsKernelDropped",
+ FSEventsEventIdsWrapped: "notify.FSEventsEventIdsWrapped",
+ FSEventsHistoryDone: "notify.FSEventsHistoryDone",
+ FSEventsRootChanged: "notify.FSEventsRootChanged",
+ FSEventsMount: "notify.FSEventsMount",
+ FSEventsUnmount: "notify.FSEventsUnmount",
+ FSEventsInodeMetaMod: "notify.FSEventsInodeMetaMod",
+ FSEventsFinderInfoMod: "notify.FSEventsFinderInfoMod",
+ FSEventsChangeOwner: "notify.FSEventsChangeOwner",
+ FSEventsXattrMod: "notify.FSEventsXattrMod",
+ FSEventsIsFile: "notify.FSEventsIsFile",
+ FSEventsIsDir: "notify.FSEventsIsDir",
+ FSEventsIsSymlink: "notify.FSEventsIsSymlink",
+}
+
+type event struct {
+ fse FSEvent
+ event Event
+}
+
+func (ei *event) Event() Event { return ei.event }
+func (ei *event) Path() string { return ei.fse.Path }
+func (ei *event) Sys() interface{} { return &ei.fse }
+func (ei *event) isDir() (bool, error) { return ei.fse.Flags&FSEventsIsDir != 0, nil }
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/event_inotify.go b/Godeps/_workspace/src/github.com/zillode/notify/event_inotify.go
new file mode 100644
index 0000000..82954a9
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/event_inotify.go
@@ -0,0 +1,75 @@
+// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+// +build linux
+
+package notify
+
+import "syscall"
+
+// Platform independent event values.
+const (
+ osSpecificCreate Event = 0x100000 << iota
+ osSpecificRemove
+ osSpecificWrite
+ osSpecificRename
+ // internal
+ // recursive is used to distinguish recursive eventsets from non-recursive ones
+ recursive
+ // omit is used for dispatching internal events; only those events are sent
+ // for which both the event and the watchpoint has omit in theirs event sets.
+ omit
+)
+
+// Inotify specific masks are legal, implemented events that are guaranteed to
+// work with notify package on linux-based systems.
+const (
+ InAccess = Event(syscall.IN_ACCESS) // File was accessed
+ InModify = Event(syscall.IN_MODIFY) // File was modified
+ InAttrib = Event(syscall.IN_ATTRIB) // Metadata changed
+ InCloseWrite = Event(syscall.IN_CLOSE_WRITE) // Writtable file was closed
+ InCloseNowrite = Event(syscall.IN_CLOSE_NOWRITE) // Unwrittable file closed
+ InOpen = Event(syscall.IN_OPEN) // File was opened
+ InMovedFrom = Event(syscall.IN_MOVED_FROM) // File was moved from X
+ InMovedTo = Event(syscall.IN_MOVED_TO) // File was moved to Y
+ InCreate = Event(syscall.IN_CREATE) // Subfile was created
+ InDelete = Event(syscall.IN_DELETE) // Subfile was deleted
+ InDeleteSelf = Event(syscall.IN_DELETE_SELF) // Self was deleted
+ InMoveSelf = Event(syscall.IN_MOVE_SELF) // Self was moved
+)
+
+var osestr = map[Event]string{
+ InAccess: "notify.InAccess",
+ InModify: "notify.InModify",
+ InAttrib: "notify.InAttrib",
+ InCloseWrite: "notify.InCloseWrite",
+ InCloseNowrite: "notify.InCloseNowrite",
+ InOpen: "notify.InOpen",
+ InMovedFrom: "notify.InMovedFrom",
+ InMovedTo: "notify.InMovedTo",
+ InCreate: "notify.InCreate",
+ InDelete: "notify.InDelete",
+ InDeleteSelf: "notify.InDeleteSelf",
+ InMoveSelf: "notify.InMoveSelf",
+}
+
+// Inotify behavior events are not **currently** supported by notify package.
+const (
+ inDontFollow = Event(syscall.IN_DONT_FOLLOW)
+ inExclUnlink = Event(syscall.IN_EXCL_UNLINK)
+ inMaskAdd = Event(syscall.IN_MASK_ADD)
+ inOneshot = Event(syscall.IN_ONESHOT)
+ inOnlydir = Event(syscall.IN_ONLYDIR)
+)
+
+type event struct {
+ sys syscall.InotifyEvent
+ path string
+ event Event
+}
+
+func (e *event) Event() Event { return e.event }
+func (e *event) Path() string { return e.path }
+func (e *event) Sys() interface{} { return &e.sys }
+func (e *event) isDir() (bool, error) { return e.sys.Mask&syscall.IN_ISDIR != 0, nil }
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/event_kqueue.go b/Godeps/_workspace/src/github.com/zillode/notify/event_kqueue.go
new file mode 100644
index 0000000..b5fee08
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/event_kqueue.go
@@ -0,0 +1,89 @@
+// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+// +build darwin,kqueue dragonfly freebsd netbsd openbsd
+
+package notify
+
+import (
+ "os"
+ "syscall"
+)
+
+// TODO(pblaszczyk): ensure in runtime notify built-in event values do not
+// overlap with platform-defined ones.
+
+// Platform independent event values.
+const (
+ osSpecificCreate Event = 0x0100 << iota
+ osSpecificRemove
+ osSpecificWrite
+ osSpecificRename
+ // internal
+ // recursive is used to distinguish recursive eventsets from non-recursive ones
+ recursive
+ // omit is used for dispatching internal events; only those events are sent
+ // for which both the event and the watchpoint has omit in theirs event sets.
+ omit
+)
+
+const (
+ // NoteDelete is an even reported when the unlink() system call was called
+ // on the file referenced by the descriptor.
+ NoteDelete = Event(syscall.NOTE_DELETE)
+ // NoteWrite is an event reported when a write occurred on the file
+ // referenced by the descriptor.
+ NoteWrite = Event(syscall.NOTE_WRITE)
+ // NoteExtend is an event reported when the file referenced by the
+ // descriptor was extended.
+ NoteExtend = Event(syscall.NOTE_EXTEND)
+ // NoteAttrib is an event reported when the file referenced
+ // by the descriptor had its attributes changed.
+ NoteAttrib = Event(syscall.NOTE_ATTRIB)
+ // NoteLink is an event reported when the link count on the file changed.
+ NoteLink = Event(syscall.NOTE_LINK)
+ // NoteRename is an event reported when the file referenced
+ // by the descriptor was renamed.
+ NoteRename = Event(syscall.NOTE_RENAME)
+ // NoteRevoke is an event reported when access to the file was revoked via
+ // revoke(2) or the underlying file system was unmounted.
+ NoteRevoke = Event(syscall.NOTE_REVOKE)
+)
+
+var osestr = map[Event]string{
+ NoteDelete: "notify.NoteDelete",
+ NoteWrite: "notify.NoteWrite",
+ NoteExtend: "notify.NoteExtend",
+ NoteAttrib: "notify.NoteAttrib",
+ NoteLink: "notify.NoteLink",
+ NoteRename: "notify.NoteRename",
+ NoteRevoke: "notify.NoteRevoke",
+}
+
+// event is a struct storing reported event's data.
+type event struct {
+ // p is an absolute path to file for which event is reported.
+ p string
+ // e specifies type of a reported event.
+ e Event
+ // kq specifies event's additional information.
+ kq Kevent
+}
+
+// Event returns type of a reported event.
+func (e *event) Event() Event { return e.e }
+
+// Path returns path to file/directory for which event is reported.
+func (e *event) Path() string { return e.p }
+
+// Sys returns platform specific object describing reported event.
+func (e *event) Sys() interface{} { return &e.kq }
+
+func (e *event) isDir() (bool, error) { return e.kq.FI.IsDir(), nil }
+
+// Kevent represents a single event.
+type Kevent struct {
+ Kevent *syscall.Kevent_t // Kevent is a kqueue specific structure.
+ FI os.FileInfo // FI describes file/dir.
+}
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/event_readdcw.go b/Godeps/_workspace/src/github.com/zillode/notify/event_readdcw.go
new file mode 100644
index 0000000..11ead9e
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/event_readdcw.go
@@ -0,0 +1,108 @@
+// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+// +build windows
+
+package notify
+
+import (
+ "os"
+ "path/filepath"
+ "syscall"
+)
+
+// Platform independent event values.
+const (
+ osSpecificCreate Event = 1 << (20 + iota)
+ osSpecificRemove
+ osSpecificWrite
+ osSpecificRename
+ // recursive is used to distinguish recursive eventsets from non-recursive ones
+ recursive
+ // omit is used for dispatching internal events; only those events are sent
+ // for which both the event and the watchpoint has omit in theirs event sets.
+ omit
+ // dirmarker TODO(pknap)
+ dirmarker
+)
+
+// ReadDirectoryChangesW filters.
+const (
+ FileNotifyChangeFileName = Event(syscall.FILE_NOTIFY_CHANGE_FILE_NAME)
+ FileNotifyChangeDirName = Event(syscall.FILE_NOTIFY_CHANGE_DIR_NAME)
+ FileNotifyChangeAttributes = Event(syscall.FILE_NOTIFY_CHANGE_ATTRIBUTES)
+ FileNotifyChangeSize = Event(syscall.FILE_NOTIFY_CHANGE_SIZE)
+ FileNotifyChangeLastWrite = Event(syscall.FILE_NOTIFY_CHANGE_LAST_WRITE)
+ FileNotifyChangeLastAccess = Event(syscall.FILE_NOTIFY_CHANGE_LAST_ACCESS)
+ FileNotifyChangeCreation = Event(syscall.FILE_NOTIFY_CHANGE_CREATION)
+ FileNotifyChangeSecurity = Event(syscallFileNotifyChangeSecurity)
+)
+
+const (
+ fileNotifyChangeAll = 0x17f // logical sum of all FileNotifyChange* events.
+ fileNotifyChangeModified = fileNotifyChangeAll &^ (FileNotifyChangeFileName | FileNotifyChangeDirName)
+)
+
+// according to: http://msdn.microsoft.com/en-us/library/windows/desktop/aa365465(v=vs.85).aspx
+// this flag should be declared in: http://golang.org/src/pkg/syscall/ztypes_windows.go
+const syscallFileNotifyChangeSecurity = 0x00000100
+
+// ReadDirectoryChangesW actions.
+const (
+ FileActionAdded = Event(syscall.FILE_ACTION_ADDED) << 12
+ FileActionRemoved = Event(syscall.FILE_ACTION_REMOVED) << 12
+ FileActionModified = Event(syscall.FILE_ACTION_MODIFIED) << 14
+ FileActionRenamedOldName = Event(syscall.FILE_ACTION_RENAMED_OLD_NAME) << 15
+ FileActionRenamedNewName = Event(syscall.FILE_ACTION_RENAMED_NEW_NAME) << 16
+)
+
+const fileActionAll = 0x7f000 // logical sum of all FileAction* events.
+
+var osestr = map[Event]string{
+ FileNotifyChangeFileName: "notify.FileNotifyChangeFileName",
+ FileNotifyChangeDirName: "notify.FileNotifyChangeDirName",
+ FileNotifyChangeAttributes: "notify.FileNotifyChangeAttributes",
+ FileNotifyChangeSize: "notify.FileNotifyChangeSize",
+ FileNotifyChangeLastWrite: "notify.FileNotifyChangeLastWrite",
+ FileNotifyChangeLastAccess: "notify.FileNotifyChangeLastAccess",
+ FileNotifyChangeCreation: "notify.FileNotifyChangeCreation",
+ FileNotifyChangeSecurity: "notify.FileNotifyChangeSecurity",
+
+ FileActionAdded: "notify.FileActionAdded",
+ FileActionRemoved: "notify.FileActionRemoved",
+ FileActionModified: "notify.FileActionModified",
+ FileActionRenamedOldName: "notify.FileActionRenamedOldName",
+ FileActionRenamedNewName: "notify.FileActionRenamedNewName",
+}
+
+const (
+ fTypeUnknown uint8 = iota
+ fTypeFile
+ fTypeDirectory
+)
+
+// TODO(ppknap) : doc.
+type event struct {
+ pathw []uint16
+ name string
+ ftype uint8
+ action uint32
+ filter uint32
+ e Event
+}
+
+func (e *event) Event() Event { return e.e }
+func (e *event) Path() string { return filepath.Join(syscall.UTF16ToString(e.pathw), e.name) }
+func (e *event) Sys() interface{} { return e.ftype }
+
+func (e *event) isDir() (bool, error) {
+ if e.ftype != fTypeUnknown {
+ return e.ftype == fTypeDirectory, nil
+ }
+ fi, err := os.Stat(e.Path())
+ if err != nil {
+ return false, err
+ }
+ return fi.IsDir(), nil
+}
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/event_stub.go b/Godeps/_workspace/src/github.com/zillode/notify/event_stub.go
new file mode 100644
index 0000000..919bce2
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/event_stub.go
@@ -0,0 +1,31 @@
+// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+// +build !darwin,!linux,!freebsd,!dragonfly,!netbsd,!openbsd,!windows
+// +build !kqueue
+
+package notify
+
+// Platform independent event values.
+const (
+ osSpecificCreate Event = 1 << iota
+ osSpecificRemove
+ osSpecificWrite
+ osSpecificRename
+ // internal
+ // recursive is used to distinguish recursive eventsets from non-recursive ones
+ recursive
+ // omit is used for dispatching internal events; only those events are sent
+ // for which both the event and the watchpoint has omit in theirs event sets.
+ omit
+)
+
+var osestr = map[Event]string{}
+
+type event struct{}
+
+func (e *event) Event() (_ Event) { return }
+func (e *event) Path() (_ string) { return }
+func (e *event) Sys() (_ interface{}) { return }
+func (e *event) isDir() (_ bool, _ error) { return }
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/event_test.go b/Godeps/_workspace/src/github.com/zillode/notify/event_test.go
new file mode 100644
index 0000000..2803509
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/event_test.go
@@ -0,0 +1,33 @@
+// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+package notify
+
+import (
+ "sort"
+ "strings"
+ "testing"
+)
+
+// S is a workaround for random event strings concatenation order.
+func s(s string) string {
+ z := strings.Split(s, "|")
+ sort.StringSlice(z).Sort()
+ return strings.Join(z, "|")
+}
+
+// This test is not safe to run in parallel with others.
+func TestEventString(t *testing.T) {
+ cases := map[Event]string{
+ Create: "notify.Create",
+ Create | Remove: "notify.Create|notify.Remove",
+ Create | Remove | Write: "notify.Create|notify.Remove|notify.Write",
+ Create | Write | Rename: "notify.Create|notify.Rename|notify.Write",
+ }
+ for e, str := range cases {
+ if s := s(e.String()); s != str {
+ t.Errorf("want s=%s; got %s (e=%#x)", str, s, e)
+ }
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/example_fsevents_test.go b/Godeps/_workspace/src/github.com/zillode/notify/example_fsevents_test.go
new file mode 100644
index 0000000..53d1b34
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/example_fsevents_test.go
@@ -0,0 +1,128 @@
+// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+// +build darwin,!kqueue
+
+package notify_test
+
+import (
+ "log"
+
+ "github.com/rjeczalik/notify"
+)
+
+// This example shows how to use FSEvents-specifc event values.
+func ExampleWatch_darwin() {
+ // Make the channel buffered to ensure no event is dropped. Notify will drop
+ // an event if the receiver is not able to keep up the sending pace.
+ c := make(chan notify.EventInfo, 1)
+
+ // Set up a watchpoint listening for FSEvents-specific events within a
+ // current working directory. Dispatch each FSEventsChangeOwner and FSEventsMount
+ // events separately to c.
+ if err := notify.Watch(".", c, notify.FSEventsChangeOwner, notify.FSEventsMount); err != nil {
+ log.Fatal(err)
+ }
+ defer notify.Stop(c)
+
+ // Block until an event is received.
+ switch ei := <-c; ei.Event() {
+ case notify.FSEventsChangeOwner:
+ log.Println("The owner of", ei.Path(), "has changed.")
+ case notify.FSEventsMount:
+ log.Println("The path", ei.Path(), "has been mounted.")
+ }
+}
+
+// This example shows how to work with EventInfo's underlying FSEvent struct.
+// Investigating notify.(*FSEvent).Flags field we are able to say whether
+// the event's path is a file or a directory and many more.
+func ExampleWatch_darwinDirFileSymlink() {
+ var must = func(err error) {
+ if err != nil {
+ log.Fatal(err)
+ }
+ }
+ var stop = func(c ...chan<- notify.EventInfo) {
+ for _, c := range c {
+ notify.Stop(c)
+ }
+ }
+
+ // Make the channels buffered to ensure no event is dropped. Notify will drop
+ // an event if the receiver is not able to keep up the sending pace.
+ dir := make(chan notify.EventInfo, 1)
+ file := make(chan notify.EventInfo, 1)
+ symlink := make(chan notify.EventInfo, 1)
+ all := make(chan notify.EventInfo, 1)
+
+ // Set up a single watchpoint listening for FSEvents-specific events on
+ // multiple user-provided channels.
+ must(notify.Watch(".", dir, notify.FSEventsIsDir))
+ must(notify.Watch(".", file, notify.FSEventsIsFile))
+ must(notify.Watch(".", symlink, notify.FSEventsIsSymlink))
+ must(notify.Watch(".", all, notify.All))
+ defer stop(dir, file, symlink, all)
+
+ // Block until an event is received.
+ select {
+ case ei := <-dir:
+ log.Println("The directory", ei.Path(), "has changed")
+ case ei := <-file:
+ log.Println("The file", ei.Path(), "has changed")
+ case ei := <-symlink:
+ log.Println("The symlink", ei.Path(), "has changed")
+ case ei := <-all:
+ var kind string
+
+ // Investigate underlying *notify.FSEvent struct to access more
+ // information about the event.
+ switch flags := ei.Sys().(*notify.FSEvent).Flags; {
+ case flags&notify.FSEventsIsFile != 0:
+ kind = "file"
+ case flags&notify.FSEventsIsDir != 0:
+ kind = "dir"
+ case flags&notify.FSEventsIsSymlink != 0:
+ kind = "symlink"
+ }
+
+ log.Printf("The %s under path %s has been %sd\n", kind, ei.Path(), ei.Event())
+ }
+}
+
+// FSEvents may report multiple filesystem actions with one, coalesced event.
+// Notify unscoalesces such event and dispatches series of single events
+// back to the user.
+//
+// This example shows how to coalesce events by investigating notify.(*FSEvent).ID
+// field, for the science.
+func ExampleWatch_darwinCoalesce() {
+ // Make the channels buffered to ensure no event is dropped. Notify will drop
+ // an event if the receiver is not able to keep up the sending pace.
+ c := make(chan notify.EventInfo, 4)
+
+ // Set up a watchpoint listetning for events within current working directory.
+ // Dispatch all platform-independent separately to c.
+ if err := notify.Watch(".", c, notify.All); err != nil {
+ log.Fatal(err)
+ }
+ defer notify.Stop(c)
+
+ var id uint64
+ var coalesced []notify.EventInfo
+
+ for ei := range c {
+ switch n := ei.Sys().(*notify.FSEvent).ID; {
+ case id == 0:
+ id = n
+ coalesced = []notify.EventInfo{ei}
+ case id == n:
+ coalesced = append(coalesced, ei)
+ default:
+ log.Printf("FSEvents reported a filesystem action with the following"+
+ " coalesced events %v groupped by %d ID\n", coalesced, id)
+ return
+ }
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/example_inotify_test.go b/Godeps/_workspace/src/github.com/zillode/notify/example_inotify_test.go
new file mode 100644
index 0000000..e6a68e7
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/example_inotify_test.go
@@ -0,0 +1,83 @@
+// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+// +build linux
+
+package notify_test
+
+import (
+ "log"
+ "syscall"
+
+ "github.com/rjeczalik/notify"
+)
+
+// This example shows how to watch changes made on file-system by text editor
+// when saving a file. Usually, either InCloseWrite or InMovedTo (when swapping
+// with a temporary file) event is created.
+func ExampleWatch_linux() {
+ // Make the channel buffered to ensure no event is dropped. Notify will drop
+ // an event if the receiver is not able to keep up the sending pace.
+ c := make(chan notify.EventInfo, 1)
+
+ // Set up a watchpoint listening for inotify-specific events within a
+ // current working directory. Dispatch each InCloseWrite and InMovedTo
+ // events separately to c.
+ if err := notify.Watch(".", c, notify.InCloseWrite, notify.InMovedTo); err != nil {
+ log.Fatal(err)
+ }
+ defer notify.Stop(c)
+
+ // Block until an event is received.
+ switch ei := <-c; ei.Event() {
+ case notify.InCloseWrite:
+ log.Println("Editing of", ei.Path(), "file is done.")
+ case notify.InMovedTo:
+ log.Println("File", ei.Path(), "was swapped/moved into the watched directory.")
+ }
+}
+
+// This example shows how to use Sys() method from EventInfo interface to tie
+// two separate events generated by rename(2) function.
+func ExampleWatch_linuxMove() {
+ // Make the channel buffered to ensure no event is dropped. Notify will drop
+ // an event if the receiver is not able to keep up the sending pace.
+ c := make(chan notify.EventInfo, 2)
+
+ // Set up a watchpoint listening for inotify-specific events within a
+ // current working directory. Dispatch each InMovedFrom and InMovedTo
+ // events separately to c.
+ if err := notify.Watch(".", c, notify.InMovedFrom, notify.InMovedTo); err != nil {
+ log.Fatal(err)
+ }
+ defer notify.Stop(c)
+
+ // Inotify reports move filesystem action by sending two events tied with
+ // unique cookie value (uint32): one of the events is of InMovedFrom type
+ // carrying move source path, while the second one is of InMoveTo type
+ // carrying move destination path.
+ moves := make(map[uint32]struct {
+ From string
+ To string
+ })
+
+ // Wait for moves.
+ for ei := range c {
+ cookie := ei.Sys().(*syscall.InotifyEvent).Cookie
+
+ info := moves[cookie]
+ switch ei.Event() {
+ case notify.InMovedFrom:
+ info.From = ei.Path()
+ case notify.InMovedTo:
+ info.To = ei.Path()
+ }
+ moves[cookie] = info
+
+ if cookie != 0 && info.From != "" && info.To != "" {
+ log.Println("File:", info.From, "was renamed to", info.To)
+ delete(moves, cookie)
+ }
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/example_readdcw_test.go b/Godeps/_workspace/src/github.com/zillode/notify/example_readdcw_test.go
new file mode 100644
index 0000000..e9e05be
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/example_readdcw_test.go
@@ -0,0 +1,40 @@
+// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+// +build windows
+
+package notify_test
+
+import (
+ "log"
+
+ "github.com/rjeczalik/notify"
+)
+
+// This example shows how to watch directory-name changes in the working directory subtree.
+func ExampleWatch_windows() {
+ // Make the channel buffered to ensure no event is dropped. Notify will drop
+ // an event if the receiver is not able to keep up the sending pace.
+ c := make(chan notify.EventInfo, 4)
+
+ // Since notify package behaves exactly like ReadDirectoryChangesW function,
+ // we must register notify.FileNotifyChangeDirName filter and wait for one
+ // of FileAction* events.
+ if err := notify.Watch("./...", c, notify.FileNotifyChangeDirName); err != nil {
+ log.Fatal(err)
+ }
+ defer notify.Stop(c)
+
+ // Wait for actions.
+ for ei := range c {
+ switch ei.Event() {
+ case notify.FileActionAdded, notify.FileActionRenamedNewName:
+ log.Println("Created:", ei.Path())
+ case notify.FileActionRemoved, notify.FileActionRenamedOldName:
+ log.Println("Removed:", ei.Path())
+ case notify.FileActionModified:
+ panic("notify: unexpected action")
+ }
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/example_test.go b/Godeps/_workspace/src/github.com/zillode/notify/example_test.go
new file mode 100644
index 0000000..3c8df71
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/example_test.go
@@ -0,0 +1,87 @@
+// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+package notify_test
+
+import (
+ "log"
+ "path/filepath"
+ "time"
+
+ "github.com/rjeczalik/notify"
+)
+
+// This is a basic example showing how to work with notify.Watch function.
+func ExampleWatch() {
+ // Make the channel buffered to ensure no event is dropped. Notify will drop
+ // an event if the receiver is not able to keep up the sending pace.
+ c := make(chan notify.EventInfo, 1)
+
+ // Set up a watchpoint listening on events within current working directory.
+ // Dispatch each create and remove events separately to c.
+ if err := notify.Watch(".", c, notify.Create, notify.Remove); err != nil {
+ log.Fatal(err)
+ }
+ defer notify.Stop(c)
+
+ // Block until an event is received.
+ ei := <-c
+ log.Println("Got event:", ei)
+}
+
+// This example shows how to set up a recursive watchpoint.
+func ExampleWatch_recursive() {
+ // Make the channel buffered to ensure no event is dropped. Notify will drop
+ // an event if the receiver is not able to keep up the sending pace.
+ c := make(chan notify.EventInfo, 1)
+
+ // Set up a watchpoint listening for events within a directory tree rooted
+ // at current working directory. Dispatch remove events to c.
+ if err := notify.Watch("./...", c, notify.Remove); err != nil {
+ log.Fatal(err)
+ }
+ defer notify.Stop(c)
+
+ // Block until an event is received.
+ ei := <-c
+ log.Println("Got event:", ei)
+}
+
+// This example shows why it is important to not create leaks by stoping
+// a channel when it's no longer being used.
+func ExampleStop() {
+ waitfor := func(path string, e notify.Event, timeout time.Duration) bool {
+ dir, file := filepath.Split(path)
+ c := make(chan notify.EventInfo, 1)
+
+ if err := notify.Watch(dir, c, e); err != nil {
+ log.Fatal(err)
+ }
+ // Clean up watchpoint associated with c. If Stop was not called upon
+ // return the channel would be leaked as notify holds the only reference
+ // to it and does not release it on its own.
+ defer notify.Stop(c)
+
+ t := time.After(timeout)
+
+ for {
+ select {
+ case ei := <-c:
+ if filepath.Base(ei.Path()) == file {
+ return true
+ }
+ case <-t:
+ return false
+ }
+ }
+ }
+
+ if waitfor("index.lock", notify.Create, 5*time.Second) {
+ log.Println("The git repository was locked")
+ }
+
+ if waitfor("index.lock", notify.Remove, 5*time.Second) {
+ log.Println("The git repository was unlocked")
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/node.go b/Godeps/_workspace/src/github.com/zillode/notify/node.go
new file mode 100644
index 0000000..4302071
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/node.go
@@ -0,0 +1,271 @@
+// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+package notify
+
+import (
+ "errors"
+ "io/ioutil"
+ "os"
+ "path/filepath"
+)
+
+var errSkip = errors.New("notify: skip")
+
+type walkPathFunc func(nd node, isbase bool) error
+
+type walkFunc func(node) error
+
+func errnotexist(name string) error {
+ return &os.PathError{
+ Op: "Node",
+ Path: name,
+ Err: os.ErrNotExist,
+ }
+}
+
+type node struct {
+ Name string
+ Watch watchpoint
+ Child map[string]node
+}
+
+func newnode(name string) node {
+ return node{
+ Name: name,
+ Watch: make(watchpoint),
+ Child: make(map[string]node),
+ }
+}
+
+func (nd node) addchild(name, base string) node {
+ child, ok := nd.Child[base]
+ if !ok {
+ child = newnode(name)
+ nd.Child[base] = child
+ }
+ return child
+}
+
+func (nd node) Add(name string) node {
+ i := indexbase(nd.Name, name)
+ if i == -1 {
+ return node{}
+ }
+ for j := indexSep(name[i:]); j != -1; j = indexSep(name[i:]) {
+ nd = nd.addchild(name[:i+j], name[i:i+j])
+ i += j + 1
+ }
+ return nd.addchild(name, name[i:])
+}
+
+func (nd node) AddDir(fn walkFunc) error {
+ stack := []node{nd}
+Traverse:
+ for n := len(stack); n != 0; n = len(stack) {
+ nd, stack = stack[n-1], stack[:n-1]
+ switch err := fn(nd); err {
+ case nil:
+ case errSkip:
+ continue Traverse
+ default:
+ return err
+ }
+ // TODO(rjeczalik): tolerate open failures - add failed names to
+ // AddDirError and notify users which names are not added to the tree.
+ fi, err := ioutil.ReadDir(nd.Name)
+ if err != nil {
+ return err
+ }
+ for _, fi := range fi {
+ if fi.Mode()&(os.ModeSymlink|os.ModeDir) == os.ModeDir {
+ name := filepath.Join(nd.Name, fi.Name())
+ stack = append(stack, nd.addchild(name, name[len(nd.Name)+1:]))
+ }
+ }
+ }
+ return nil
+}
+
+func (nd node) Get(name string) (node, error) {
+ i := indexbase(nd.Name, name)
+ if i == -1 {
+ return node{}, errnotexist(name)
+ }
+ ok := false
+ for j := indexSep(name[i:]); j != -1; j = indexSep(name[i:]) {
+ if nd, ok = nd.Child[name[i:i+j]]; !ok {
+ return node{}, errnotexist(name)
+ }
+ i += j + 1
+ }
+ if nd, ok = nd.Child[name[i:]]; !ok {
+ return node{}, errnotexist(name)
+ }
+ return nd, nil
+}
+
+func (nd node) Del(name string) error {
+ i := indexbase(nd.Name, name)
+ if i == -1 {
+ return errnotexist(name)
+ }
+ stack := []node{nd}
+ ok := false
+ for j := indexSep(name[i:]); j != -1; j = indexSep(name[i:]) {
+ if nd, ok = nd.Child[name[i:i+j]]; !ok {
+ return errnotexist(name[:i+j])
+ }
+ stack = append(stack, nd)
+ }
+ if nd, ok = nd.Child[name[i:]]; !ok {
+ return errnotexist(name)
+ }
+ nd.Child = nil
+ nd.Watch = nil
+ for name, i = base(nd.Name), len(stack); i != 0; name, i = base(nd.Name), i-1 {
+ nd = stack[i-1]
+ if nd := nd.Child[name]; len(nd.Watch) > 1 || len(nd.Child) != 0 {
+ break
+ } else {
+ nd.Child = nil
+ nd.Watch = nil
+ }
+ delete(nd.Child, name)
+ }
+ return nil
+}
+
+func (nd node) Walk(fn walkFunc) error {
+ stack := []node{nd}
+Traverse:
+ for n := len(stack); n != 0; n = len(stack) {
+ nd, stack = stack[n-1], stack[:n-1]
+ switch err := fn(nd); err {
+ case nil:
+ case errSkip:
+ continue Traverse
+ default:
+ return err
+ }
+ for name, nd := range nd.Child {
+ if name == "" {
+ // Node storing inactive watchpoints has empty name, skip it
+ // form traversing. Root node has also an empty name, but it
+ // never has a parent node.
+ continue
+ }
+ stack = append(stack, nd)
+ }
+ }
+ return nil
+}
+
+func (nd node) WalkPath(name string, fn walkPathFunc) error {
+ i := indexbase(nd.Name, name)
+ if i == -1 {
+ return errnotexist(name)
+ }
+ ok := false
+ for j := indexSep(name[i:]); j != -1; j = indexSep(name[i:]) {
+ switch err := fn(nd, false); err {
+ case nil:
+ case errSkip:
+ return nil
+ default:
+ return err
+ }
+ if nd, ok = nd.Child[name[i:i+j]]; !ok {
+ return errnotexist(name[:i+j])
+ }
+ i += j + 1
+ }
+ switch err := fn(nd, false); err {
+ case nil:
+ case errSkip:
+ return nil
+ default:
+ return err
+ }
+ if nd, ok = nd.Child[name[i:]]; !ok {
+ return errnotexist(name)
+ }
+ switch err := fn(nd, true); err {
+ case nil, errSkip:
+ return nil
+ default:
+ return err
+ }
+}
+
+type root struct {
+ nd node
+}
+
+func (r root) addroot(name string) node {
+ if vol := filepath.VolumeName(name); vol != "" {
+ root, ok := r.nd.Child[vol]
+ if !ok {
+ root = r.nd.addchild(vol, vol)
+ }
+ return root
+ }
+ return r.nd
+}
+
+func (r root) root(name string) (node, error) {
+ if vol := filepath.VolumeName(name); vol != "" {
+ nd, ok := r.nd.Child[vol]
+ if !ok {
+ return node{}, errnotexist(name)
+ }
+ return nd, nil
+ }
+ return r.nd, nil
+}
+
+func (r root) Add(name string) node {
+ return r.addroot(name).Add(name)
+}
+
+func (r root) AddDir(dir string, fn walkFunc) error {
+ return r.Add(dir).AddDir(fn)
+}
+
+func (r root) Del(name string) error {
+ nd, err := r.root(name)
+ if err != nil {
+ return err
+ }
+ return nd.Del(name)
+}
+
+func (r root) Get(name string) (node, error) {
+ nd, err := r.root(name)
+ if err != nil {
+ return node{}, err
+ }
+ if nd.Name != name {
+ if nd, err = nd.Get(name); err != nil {
+ return node{}, err
+ }
+ }
+ return nd, nil
+}
+
+func (r root) Walk(name string, fn walkFunc) error {
+ nd, err := r.Get(name)
+ if err != nil {
+ return err
+ }
+ return nd.Walk(fn)
+}
+
+func (r root) WalkPath(name string, fn walkPathFunc) error {
+ nd, err := r.root(name)
+ if err != nil {
+ return err
+ }
+ return nd.WalkPath(name, fn)
+}
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/notify.go b/Godeps/_workspace/src/github.com/zillode/notify/notify.go
new file mode 100644
index 0000000..4ffca02
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/notify.go
@@ -0,0 +1,70 @@
+// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+// BUG(rjeczalik): Notify does not collect watchpoints, when underlying watches
+// were removed by their os-specific watcher implementations. Instead users are
+// advised to listen on persistant paths to have guarantee they receive events
+// for the whole lifetime of their applications (to discuss see #69).
+
+// BUG(ppknap): Linux (inotify) does not support watcher behavior masks like
+// InOneshot, InOnlydir etc. Instead users are advised to perform the filtering
+// themselves (to discuss see #71).
+
+// BUG(ppknap): Notify was not tested for short path name support under Windows
+// (ReadDirectoryChangesW).
+
+// BUG(ppknap): Windows (ReadDirectoryChangesW) cannot recognize which notification
+// triggers FileActionModified event. (to discuss see #75).
+
+package notify
+
+var defaultTree = newTree()
+
+// Watch sets up a watchpoint on path listening for events given by the events
+// argument.
+//
+// File or directory given by the path must exist, otherwise Watch will fail
+// with non-nil error. Notify resolves, for its internal purpose, any symlinks
+// the provided path may contain, so it may fail if the symlinks form a cycle.
+// It does so, since not all watcher implementations treat passed paths as-is.
+// E.g. FSEvents reports a real path for every event, setting a watchpoint
+// on /tmp will report events with paths rooted at /private/tmp etc.
+//
+// It is allowed to pass the same channel multiple times with different event
+// list or different paths. Calling Watch with different event lists for a single
+// watchpoint expands its event set. The only way to shrink it, is to call
+// Stop on its channel.
+//
+// Calling Watch with empty event list does expand nor shrink watchpoint's event
+// set. If c is the first channel to listen for events on the given path, Watch
+// will seamlessly create a watch on the filesystem.
+//
+// Notify dispatches copies of single filesystem event to all channels registered
+// for each path. If a single filesystem event contains multiple coalesced events,
+// each of them is dispatched separately. E.g. the following filesystem change:
+//
+// ~ $ echo Hello > Notify.txt
+//
+// dispatches two events - notify.Create and notify.Write. However, it may depend
+// on the underlying watcher implementation whether OS reports both of them.
+//
+// Windows and recursive watches
+//
+// If a directory which path was used to create recursive watch under Windows
+// gets deleted, the OS will not report such event. It is advised to keep in
+// mind this limitation while setting recursive watchpoints for your application,
+// e.g. use persistant paths like %userprofile% or watch additionally parent
+// directory of a recursive watchpoint in order to receive delete events for it.
+func Watch(path string, c chan<- EventInfo, events ...Event) error {
+ return defaultTree.Watch(path, c, events...)
+}
+
+// Stop removes all watchpoints registered for c. All underlying watches are
+// also removed, for which c was the last channel listening for events.
+//
+// Stop does not close c. When Stop returns, it is guranteed that c will
+// receive no more signals.
+func Stop(c chan<- EventInfo) {
+ defaultTree.Stop(c)
+}
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/notify_inotify_test.go b/Godeps/_workspace/src/github.com/zillode/notify/notify_inotify_test.go
new file mode 100644
index 0000000..c5984d3
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/notify_inotify_test.go
@@ -0,0 +1,37 @@
+// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+// +build linux
+
+package notify
+
+import "testing"
+
+func TestNotifySystemAndGlobalMix(t *testing.T) {
+ n := NewNotifyTest(t, "testdata/vfs.txt")
+ defer n.Close()
+
+ ch := NewChans(2)
+
+ n.Watch("src/github.com/rjeczalik/fs", ch[0], Create)
+ n.Watch("src/github.com/rjeczalik/fs", ch[1], InCreate)
+
+ cases := []NCase{
+ {
+ Event: icreate(n.W(), "src/github.com/rjeczalik/fs/.main.cc.swr"),
+ Receiver: Chans{ch[0], ch[1]},
+ },
+ }
+
+ n.ExpectNotifyEvents(cases, ch)
+}
+
+func TestUnknownEvent(t *testing.T) {
+ n := NewNotifyTest(t, "testdata/vfs.txt")
+ defer n.Close()
+
+ ch := NewChans(1)
+
+ n.WatchErr("src/github.com/rjeczalik/fs", ch[0], nil, inExclUnlink)
+}
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/notify_readdcw_test.go b/Godeps/_workspace/src/github.com/zillode/notify/notify_readdcw_test.go
new file mode 100644
index 0000000..944b533
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/notify_readdcw_test.go
@@ -0,0 +1,60 @@
+// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+// +build windows
+
+package notify
+
+import "testing"
+
+func TestNotifySystemSpecificEvent(t *testing.T) {
+ n := NewNotifyTest(t, "testdata/vfs.txt")
+ defer n.Close()
+
+ ch := NewChans(1)
+
+ n.Watch("src/github.com/rjeczalik/fs", ch[0], FileNotifyChangeFileName, FileNotifyChangeSize)
+
+ cases := []NCase{
+ {
+ Event: rremove(n.W(), "src/github.com/rjeczalik/fs/fs.go"),
+ Receiver: Chans{ch[0]},
+ },
+ {
+ Event: rwrite(n.W(), "src/github.com/rjeczalik/fs/README.md", []byte("XD")),
+ Receiver: Chans{ch[0]},
+ },
+ }
+
+ n.ExpectNotifyEvents(cases, ch)
+}
+
+func TestUnknownEvent(t *testing.T) {
+ n := NewNotifyTest(t, "testdata/vfs.txt")
+ defer n.Close()
+
+ ch := NewChans(1)
+
+ n.WatchErr("src/github.com/rjeczalik/fs", ch[0], nil, FileActionAdded)
+}
+
+func TestNotifySystemAndGlobalMix(t *testing.T) {
+ n := NewNotifyTest(t, "testdata/vfs.txt")
+ defer n.Close()
+
+ ch := NewChans(3)
+
+ n.Watch("src/github.com/rjeczalik/fs", ch[0], Create)
+ n.Watch("src/github.com/rjeczalik/fs", ch[1], FileNotifyChangeFileName)
+ n.Watch("src/github.com/rjeczalik/fs", ch[2], FileNotifyChangeDirName)
+
+ cases := []NCase{
+ {
+ Event: rcreate(n.W(), "src/github.com/rjeczalik/fs/.main.cc.swr"),
+ Receiver: Chans{ch[0], ch[1]},
+ },
+ }
+
+ n.ExpectNotifyEvents(cases, ch)
+}
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/notify_test.go b/Godeps/_workspace/src/github.com/zillode/notify/notify_test.go
new file mode 100644
index 0000000..c8bc9d4
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/notify_test.go
@@ -0,0 +1,103 @@
+// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+// +build darwin linux freebsd dragonfly netbsd openbsd windows
+
+package notify
+
+import "testing"
+
+func TestNotifyExample(t *testing.T) {
+ n := NewNotifyTest(t, "testdata/vfs.txt")
+ defer n.Close()
+
+ ch := NewChans(3)
+
+ // Watch-points can be set explicitely via Watch/Stop calls...
+ n.Watch("src/github.com/rjeczalik/fs", ch[0], Write)
+ n.Watch("src/github.com/pblaszczyk/qttu", ch[0], Write)
+ n.Watch("src/github.com/pblaszczyk/qttu/...", ch[1], Create)
+ n.Watch("src/github.com/rjeczalik/fs/cmd/...", ch[2], Remove)
+
+ cases := []NCase{
+ // i=0
+ {
+ Event: write(n.W(), "src/github.com/rjeczalik/fs/fs.go", []byte("XD")),
+ Receiver: Chans{ch[0]},
+ },
+ // TODO(rjeczalik): #62
+ // i=1
+ // {
+ // Event: write(n.W(), "src/github.com/pblaszczyk/qttu/README.md", []byte("XD")),
+ // Receiver: Chans{ch[0]},
+ // },
+ // i=2
+ {
+ Event: write(n.W(), "src/github.com/rjeczalik/fs/cmd/gotree/go.go", []byte("XD")),
+ Receiver: nil,
+ },
+ // i=3
+ {
+ Event: create(n.W(), "src/github.com/pblaszczyk/qttu/src/.main.cc.swp"),
+ Receiver: Chans{ch[1]},
+ },
+ // i=4
+ {
+ Event: create(n.W(), "src/github.com/pblaszczyk/qttu/src/.main.cc.swo"),
+ Receiver: Chans{ch[1]},
+ },
+ // i=5
+ {
+ Event: remove(n.W(), "src/github.com/rjeczalik/fs/cmd/gotree/go.go"),
+ Receiver: Chans{ch[2]},
+ },
+ }
+
+ n.ExpectNotifyEvents(cases, ch)
+
+ // ...or using Call structures.
+ stops := [...]Call{
+ // i=0
+ {
+ F: FuncStop,
+ C: ch[0],
+ },
+ // i=1
+ {
+ F: FuncStop,
+ C: ch[1],
+ },
+ }
+
+ n.Call(stops[:]...)
+
+ cases = []NCase{
+ // i=0
+ {
+ Event: write(n.W(), "src/github.com/rjeczalik/fs/fs.go", []byte("XD")),
+ Receiver: nil,
+ },
+ // i=1
+ {
+ Event: write(n.W(), "src/github.com/pblaszczyk/qttu/README.md", []byte("XD")),
+ Receiver: nil,
+ },
+ // i=2
+ {
+ Event: create(n.W(), "src/github.com/pblaszczyk/qttu/src/.main.cc.swr"),
+ Receiver: nil,
+ },
+ // i=3
+ {
+ Event: remove(n.W(), "src/github.com/rjeczalik/fs/cmd/gotree/main.go"),
+ Receiver: Chans{ch[2]},
+ },
+ }
+
+ n.ExpectNotifyEvents(cases, ch)
+}
+
+func TestStop(t *testing.T) {
+ t.Skip("TODO(rjeczalik)")
+}
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/sync_readdcw_test.go b/Godeps/_workspace/src/github.com/zillode/notify/sync_readdcw_test.go
new file mode 100644
index 0000000..1a7f830
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/sync_readdcw_test.go
@@ -0,0 +1,33 @@
+// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+// +build windows
+
+package notify
+
+import (
+ "syscall"
+ "time"
+ "unsafe"
+)
+
+var modkernel32 = syscall.NewLazyDLL("kernel32.dll")
+var procSetSystemFileCacheSize = modkernel32.NewProc("SetSystemFileCacheSize")
+var zero = uintptr(1<<(unsafe.Sizeof(uintptr(0))*8) - 1)
+
+func Sync() {
+ // TODO(pknap): does not work without admin privilages, but I'm going
+ // to hack it.
+ // r, _, err := procSetSystemFileCacheSize.Call(none, none, 0)
+ // if r == 0 {
+ // dbgprint("SetSystemFileCacheSize error:", err)
+ // }
+}
+
+// UpdateWait pauses the program for some minimal amount of time. This function
+// is required only by implementations which work asynchronously. It gives
+// watcher structure time to update its internal state.
+func UpdateWait() {
+ time.Sleep(50 * time.Millisecond)
+}
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/sync_unix_test.go b/Godeps/_workspace/src/github.com/zillode/notify/sync_unix_test.go
new file mode 100644
index 0000000..9804c6c
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/sync_unix_test.go
@@ -0,0 +1,18 @@
+// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+// +build !windows
+
+package notify
+
+import "syscall"
+
+func Sync() {
+ syscall.Sync()
+}
+
+// UpdateWait is required only by windows watcher implementation. On other
+// platforms this function is no-op.
+func UpdateWait() {
+}
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/testdata/vfs.txt b/Godeps/_workspace/src/github.com/zillode/notify/testdata/vfs.txt
new file mode 100644
index 0000000..88afbc6
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/testdata/vfs.txt
@@ -0,0 +1,56 @@
+src/github.com/pblaszczyk/qttu/.travis.yml
+src/github.com/pblaszczyk/qttu/include/qttu/detail/registrator.hh
+src/github.com/pblaszczyk/qttu/include/qttu/detail/registry.hh
+src/github.com/pblaszczyk/qttu/include/qttu/runner.hh
+src/github.com/pblaszczyk/qttu/LICENSE
+src/github.com/pblaszczyk/qttu/qttu.pri
+src/github.com/pblaszczyk/qttu/qttu.pro
+src/github.com/pblaszczyk/qttu/README.md
+src/github.com/pblaszczyk/qttu/src/main.cc
+src/github.com/pblaszczyk/qttu/src/reg.cc
+src/github.com/ppknap/link/.travis.yml
+src/github.com/ppknap/link/include/coost/link/definitions.hpp
+src/github.com/ppknap/link/include/coost/link/detail/bundle.hpp
+src/github.com/ppknap/link/include/coost/link/detail/container_invoker.hpp
+src/github.com/ppknap/link/include/coost/link/detail/container_value_trait.hpp
+src/github.com/ppknap/link/include/coost/link/detail/dummy_type.hpp
+src/github.com/ppknap/link/include/coost/link/detail/function_trait.hpp
+src/github.com/ppknap/link/include/coost/link/detail/immediate_invoker.hpp
+src/github.com/ppknap/link/include/coost/link/detail/stdhelpers/always_same.hpp
+src/github.com/ppknap/link/include/coost/link/detail/stdhelpers/make_unique.hpp
+src/github.com/ppknap/link/include/coost/link/detail/vertex.hpp
+src/github.com/ppknap/link/include/coost/link/detail/wire.hpp
+src/github.com/ppknap/link/include/coost/link/link.hpp
+src/github.com/ppknap/link/include/coost/link.hpp
+src/github.com/ppknap/link/Jamroot.jam
+src/github.com/ppknap/link/LICENSE.md
+src/github.com/ppknap/link/README.md
+src/github.com/ppknap/link/test/counter_helper.hpp
+src/github.com/ppknap/link/test/Jamfile.jam
+src/github.com/ppknap/link/test/test_circular_calls.cpp
+src/github.com/ppknap/link/test/test_container.cpp
+src/github.com/ppknap/link/test/test_copy.cpp
+src/github.com/ppknap/link/test/test_destructor.cpp
+src/github.com/ppknap/link/test/test_immediate.cpp
+src/github.com/ppknap/link/test/test_initialize.cpp
+src/github.com/rjeczalik/fs/.travis.yml
+src/github.com/rjeczalik/fs/appveyor.yml
+src/github.com/rjeczalik/fs/cmd/gotree/go.go
+src/github.com/rjeczalik/fs/cmd/gotree/main.go
+src/github.com/rjeczalik/fs/cmd/mktree/main.go
+src/github.com/rjeczalik/fs/fs.go
+src/github.com/rjeczalik/fs/fsutil/fixture_test.go
+src/github.com/rjeczalik/fs/fsutil/fsutil.go
+src/github.com/rjeczalik/fs/fsutil/fsutil_test.go
+src/github.com/rjeczalik/fs/fsutil/rel.go
+src/github.com/rjeczalik/fs/fsutil/rel_test.go
+src/github.com/rjeczalik/fs/fsutil/tee.go
+src/github.com/rjeczalik/fs/fsutil/tee_test.go
+src/github.com/rjeczalik/fs/LICENSE
+src/github.com/rjeczalik/fs/memfs/memfs.go
+src/github.com/rjeczalik/fs/memfs/memfs_test.go
+src/github.com/rjeczalik/fs/memfs/tree.go
+src/github.com/rjeczalik/fs/memfs/tree_test.go
+src/github.com/rjeczalik/fs/memfs/util.go
+src/github.com/rjeczalik/fs/memfs/util_test.go
+src/github.com/rjeczalik/fs/README.md
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/testing_test.go b/Godeps/_workspace/src/github.com/zillode/notify/testing_test.go
new file mode 100644
index 0000000..9ef41e5
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/testing_test.go
@@ -0,0 +1,895 @@
+// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+package notify
+
+import (
+ "bufio"
+ "fmt"
+ "io/ioutil"
+ "os"
+ "path/filepath"
+ "reflect"
+ "runtime"
+ "sort"
+ "strconv"
+ "strings"
+ "testing"
+ "time"
+)
+
+// NOTE(rjeczalik): some useful environment variables:
+//
+// - NOTIFY_DEBUG gives some extra information about generated events
+// - NOTIFY_TIMEOUT allows for changing default wait time for watcher's
+// events
+// - NOTIFY_TMP allows for changing location of temporary directory trees
+// created for test purpose
+
+var wd = func() string {
+ s, err := os.Getwd()
+ if err != nil {
+ panic(err)
+ }
+ return s
+}()
+
+func timeout() time.Duration {
+ if s := os.Getenv("NOTIFY_TIMEOUT"); s != "" {
+ if t, err := time.ParseDuration(s); err == nil {
+ return t
+ }
+ }
+ return 2 * time.Second
+}
+
+func vfs() (string, string) {
+ if s := os.Getenv("NOTIFY_TMP"); s != "" {
+ return filepath.Split(s)
+ }
+ return "testdata", ""
+}
+
+func isDir(path string) bool {
+ r := path[len(path)-1]
+ return r == '\\' || r == '/'
+}
+
+func tmpcreateall(tmp string, path string) error {
+ isdir := isDir(path)
+ path = filepath.Join(tmp, filepath.FromSlash(path))
+ if isdir {
+ if err := os.MkdirAll(path, 0755); err != nil {
+ return err
+ }
+ } else {
+ if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil {
+ return err
+ }
+ f, err := os.Create(path)
+ if err != nil {
+ return err
+ }
+ if err := nonil(f.Sync(), f.Close()); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+func tmpcreate(root, path string) (bool, error) {
+ isdir := isDir(path)
+ path = filepath.Join(root, filepath.FromSlash(path))
+ if isdir {
+ if err := os.Mkdir(path, 0755); err != nil {
+ return false, err
+ }
+ } else {
+ f, err := os.Create(path)
+ if err != nil {
+ return false, err
+ }
+ if err := nonil(f.Sync(), f.Close()); err != nil {
+ return false, err
+ }
+ }
+ return isdir, nil
+}
+
+func tmptree(root, list string) (string, error) {
+ f, err := os.Open(list)
+ if err != nil {
+ return "", err
+ }
+ defer f.Close()
+ if root == "" {
+ if root, err = ioutil.TempDir(vfs()); err != nil {
+ return "", err
+ }
+ }
+ scanner := bufio.NewScanner(f)
+ for scanner.Scan() {
+ if err := tmpcreateall(root, scanner.Text()); err != nil {
+ return "", err
+ }
+ }
+ if err := scanner.Err(); err != nil {
+ return "", err
+ }
+ return root, nil
+}
+
+func callern(n int) string {
+ _, file, line, ok := runtime.Caller(n)
+ if !ok {
+ return "<unknown>"
+ }
+ return filepath.Base(file) + ":" + strconv.Itoa(line)
+}
+
+func caller() string {
+ return callern(3)
+}
+
+type WCase struct {
+ Action func()
+ Events []EventInfo
+}
+
+func (cas WCase) String() string {
+ s := make([]string, 0, len(cas.Events))
+ for _, ei := range cas.Events {
+ s = append(s, "Event("+ei.Event().String()+")@"+filepath.FromSlash(ei.Path()))
+ }
+ return strings.Join(s, ", ")
+}
+
+type W struct {
+ Watcher watcher
+ C chan EventInfo
+ Timeout time.Duration
+
+ t *testing.T
+ root string
+}
+
+func newWatcherTest(t *testing.T, tree string) *W {
+ root, err := tmptree("", filepath.FromSlash(tree))
+ if err != nil {
+ t.Fatalf(`tmptree("", %q)=%v`, tree, err)
+ }
+ Sync()
+ return &W{
+ t: t,
+ root: root,
+ }
+}
+
+func NewWatcherTest(t *testing.T, tree string, events ...Event) *W {
+ w := newWatcherTest(t, tree)
+ if len(events) == 0 {
+ events = []Event{Create, Remove, Write, Rename}
+ }
+ if rw, ok := w.watcher().(recursiveWatcher); ok {
+ if err := rw.RecursiveWatch(w.root, joinevents(events)); err != nil {
+ t.Fatalf("RecursiveWatch(%q, All)=%v", w.root, err)
+ }
+ } else {
+ fn := func(path string, fi os.FileInfo, err error) error {
+ if err != nil {
+ return err
+ }
+ if fi.IsDir() {
+ if err := w.watcher().Watch(path, joinevents(events)); err != nil {
+ return err
+ }
+ }
+ return nil
+ }
+ if err := filepath.Walk(w.root, fn); err != nil {
+ t.Fatalf("Walk(%q, fn)=%v", w.root, err)
+ }
+ }
+ drainall(w.C)
+ return w
+}
+
+func (w *W) clean(path string) string {
+ path, isrec, err := cleanpath(filepath.Join(w.root, path))
+ if err != nil {
+ w.Fatalf("cleanpath(%q)=%v", path, err)
+ }
+ if isrec {
+ path = path + "..."
+ }
+ return path
+}
+
+func (w *W) Fatal(v interface{}) {
+ w.t.Fatalf("%s: %v", caller(), v)
+}
+
+func (w *W) Fatalf(format string, v ...interface{}) {
+ w.t.Fatalf("%s: %s", caller(), fmt.Sprintf(format, v...))
+}
+
+func (w *W) Watch(path string, e Event) {
+ if err := w.watcher().Watch(w.clean(path), e); err != nil {
+ w.Fatalf("Watch(%s, %v)=%v", path, e, err)
+ }
+}
+
+func (w *W) Rewatch(path string, olde, newe Event) {
+ if err := w.watcher().Rewatch(w.clean(path), olde, newe); err != nil {
+ w.Fatalf("Rewatch(%s, %v, %v)=%v", path, olde, newe, err)
+ }
+}
+
+func (w *W) Unwatch(path string) {
+ if err := w.watcher().Unwatch(w.clean(path)); err != nil {
+ w.Fatalf("Unwatch(%s)=%v", path, err)
+ }
+}
+
+func (w *W) RecursiveWatch(path string, e Event) {
+ rw, ok := w.watcher().(recursiveWatcher)
+ if !ok {
+ w.Fatal("watcher does not implement recursive watching on this platform")
+ }
+ if err := rw.RecursiveWatch(w.clean(path), e); err != nil {
+ w.Fatalf("RecursiveWatch(%s, %v)=%v", path, e, err)
+ }
+}
+
+func (w *W) RecursiveRewatch(oldp, newp string, olde, newe Event) {
+ rw, ok := w.watcher().(recursiveWatcher)
+ if !ok {
+ w.Fatal("watcher does not implement recursive watching on this platform")
+ }
+ if err := rw.RecursiveRewatch(w.clean(oldp), w.clean(newp), olde, newe); err != nil {
+ w.Fatalf("RecursiveRewatch(%s, %s, %v, %v)=%v", oldp, newp, olde, newe, err)
+ }
+}
+
+func (w *W) RecursiveUnwatch(path string) {
+ rw, ok := w.watcher().(recursiveWatcher)
+ if !ok {
+ w.Fatal("watcher does not implement recursive watching on this platform")
+ }
+ if err := rw.RecursiveUnwatch(w.clean(path)); err != nil {
+ w.Fatalf("RecursiveUnwatch(%s)=%v", path, err)
+ }
+}
+
+func (w *W) initwatcher(buffer int) {
+ c := make(chan EventInfo, buffer)
+ w.Watcher = newWatcher(c)
+ w.C = c
+}
+
+func (w *W) watcher() watcher {
+ if w.Watcher == nil {
+ w.initwatcher(512)
+ }
+ return w.Watcher
+}
+
+func (w *W) c() chan EventInfo {
+ if w.C == nil {
+ w.initwatcher(512)
+ }
+ return w.C
+}
+
+func (w *W) timeout() time.Duration {
+ if w.Timeout != 0 {
+ return w.Timeout
+ }
+ return timeout()
+}
+
+func (w *W) Close() error {
+ defer os.RemoveAll(w.root)
+ if err := w.watcher().Close(); err != nil {
+ w.Fatalf("w.Watcher.Close()=%v", err)
+ }
+ return nil
+}
+
+func EqualEventInfo(want, got EventInfo) error {
+ if got.Event() != want.Event() {
+ return fmt.Errorf("want Event()=%v; got %v (path=%s)", want.Event(),
+ got.Event(), want.Path())
+ }
+ path := strings.TrimRight(filepath.FromSlash(want.Path()), `/\`)
+ if !strings.HasSuffix(got.Path(), path) {
+ return fmt.Errorf("want Path()=%s; got %s (event=%v)", path, got.Path(),
+ want.Event())
+ }
+ return nil
+}
+
+func EqualCall(want, got Call) error {
+ if want.F != got.F {
+ return fmt.Errorf("want F=%v; got %v (want.P=%q, got.P=%q)", want.F, got.F, want.P, got.P)
+ }
+ if got.E != want.E {
+ return fmt.Errorf("want E=%v; got %v (want.P=%q, got.P=%q)", want.E, got.E, want.P, got.P)
+ }
+ if got.NE != want.NE {
+ return fmt.Errorf("want NE=%v; got %v (want.P=%q, got.P=%q)", want.NE, got.NE, want.P, got.P)
+ }
+ if want.C != got.C {
+ return fmt.Errorf("want C=%p; got %p (want.P=%q, got.P=%q)", want.C, got.C, want.P, got.P)
+ }
+ if want := filepath.FromSlash(want.P); !strings.HasSuffix(got.P, want) {
+ return fmt.Errorf("want P=%s; got %s", want, got.P)
+ }
+ if want := filepath.FromSlash(want.NP); !strings.HasSuffix(got.NP, want) {
+ return fmt.Errorf("want NP=%s; got %s", want, got.NP)
+ }
+ return nil
+}
+
+func create(w *W, path string) WCase {
+ return WCase{
+ Action: func() {
+ isdir, err := tmpcreate(w.root, filepath.FromSlash(path))
+ if err != nil {
+ w.Fatalf("tmpcreate(%q, %q)=%v", w.root, path, err)
+ }
+ if isdir {
+ dbgprintf("[FS] os.Mkdir(%q)\n", path)
+ } else {
+ dbgprintf("[FS] os.Create(%q)\n", path)
+ }
+ },
+ Events: []EventInfo{
+ &Call{P: path, E: Create},
+ },
+ }
+}
+
+func remove(w *W, path string) WCase {
+ return WCase{
+ Action: func() {
+ if err := os.RemoveAll(filepath.Join(w.root, filepath.FromSlash(path))); err != nil {
+ w.Fatal(err)
+ }
+ dbgprintf("[FS] os.Remove(%q)\n", path)
+ },
+ Events: []EventInfo{
+ &Call{P: path, E: Remove},
+ },
+ }
+}
+
+func rename(w *W, oldpath, newpath string) WCase {
+ return WCase{
+ Action: func() {
+ err := os.Rename(filepath.Join(w.root, filepath.FromSlash(oldpath)),
+ filepath.Join(w.root, filepath.FromSlash(newpath)))
+ if err != nil {
+ w.Fatal(err)
+ }
+ dbgprintf("[FS] os.Rename(%q, %q)\n", oldpath, newpath)
+ },
+ Events: []EventInfo{
+ &Call{P: newpath, E: Rename},
+ },
+ }
+}
+
+func write(w *W, path string, p []byte) WCase {
+ return WCase{
+ Action: func() {
+ f, err := os.OpenFile(filepath.Join(w.root, filepath.FromSlash(path)),
+ os.O_WRONLY, 0644)
+ if err != nil {
+ w.Fatalf("OpenFile(%q)=%v", path, err)
+ }
+ if _, err := f.Write(p); err != nil {
+ w.Fatalf("Write(%q)=%v", path, err)
+ }
+ if err := nonil(f.Sync(), f.Close()); err != nil {
+ w.Fatalf("Sync(%q)/Close(%q)=%v", path, path, err)
+ }
+ dbgprintf("[FS] Write(%q)\n", path)
+ },
+ Events: []EventInfo{
+ &Call{P: path, E: Write},
+ },
+ }
+}
+
+func drainall(c chan EventInfo) (ei []EventInfo) {
+ time.Sleep(50 * time.Millisecond)
+ for {
+ select {
+ case e := <-c:
+ ei = append(ei, e)
+ runtime.Gosched()
+ default:
+ return
+ }
+ }
+}
+
+type WCaseFunc func(i int, cas WCase, ei EventInfo) error
+
+func (w *W) ExpectAnyFunc(cases []WCase, fn WCaseFunc) {
+ UpdateWait() // Wait some time before starting the test.
+Test:
+ for i, cas := range cases {
+ dbgprintf("ExpectAny: i=%d\n", i)
+ cas.Action()
+ Sync()
+ switch cas.Events {
+ case nil:
+ if ei := drainall(w.C); len(ei) != 0 {
+ w.Fatalf("unexpected dangling events: %v (i=%d)", ei, i)
+ }
+ default:
+ select {
+ case ei := <-w.C:
+ dbgprintf("received: path=%q, event=%v, sys=%v (i=%d)", ei.Path(),
+ ei.Event(), ei.Sys(), i)
+ for j, want := range cas.Events {
+ if err := EqualEventInfo(want, ei); err != nil {
+ dbgprint(err, j)
+ continue
+ }
+ if fn != nil {
+ if err := fn(i, cas, ei); err != nil {
+ w.Fatalf("ExpectAnyFunc(%d, %v)=%v", i, ei, err)
+ }
+ }
+ drainall(w.C) // TODO(rjeczalik): revisit
+ continue Test
+ }
+ w.Fatalf("ExpectAny received an event which does not match any of "+
+ "the expected ones (i=%d): want one of %v; got %v", i, cas.Events, ei)
+ case <-time.After(w.timeout()):
+ w.Fatalf("timed out after %v waiting for one of %v (i=%d)", w.timeout(),
+ cas.Events, i)
+ }
+ drainall(w.C) // TODO(rjeczalik): revisit
+ }
+ }
+}
+
+func (w *W) ExpectAny(cases []WCase) {
+ w.ExpectAnyFunc(cases, nil)
+}
+
+// FuncType represents enums for Watcher interface.
+type FuncType string
+
+const (
+ FuncWatch = FuncType("Watch")
+ FuncUnwatch = FuncType("Unwatch")
+ FuncRewatch = FuncType("Rewatch")
+ FuncRecursiveWatch = FuncType("RecursiveWatch")
+ FuncRecursiveUnwatch = FuncType("RecursiveUnwatch")
+ FuncRecursiveRewatch = FuncType("RecursiveRewatch")
+ FuncStop = FuncType("Stop")
+)
+
+type Chans []chan EventInfo
+
+func NewChans(n int) Chans {
+ ch := make([]chan EventInfo, n)
+ for i := range ch {
+ ch[i] = make(chan EventInfo, buffer)
+ }
+ return ch
+}
+
+func (c Chans) Foreach(fn func(chan<- EventInfo, node)) {
+ for i, ch := range c {
+ fn(ch, node{Name: strconv.Itoa(i)})
+ }
+}
+
+func (c Chans) Drain() (ei []EventInfo) {
+ n := len(c)
+ stop := make(chan struct{})
+ eich := make(chan EventInfo, n*buffer)
+ go func() {
+ defer close(eich)
+ cases := make([]reflect.SelectCase, n+1)
+ for i := range c {
+ cases[i].Chan = reflect.ValueOf(c[i])
+ cases[i].Dir = reflect.SelectRecv
+ }
+ cases[n].Chan = reflect.ValueOf(stop)
+ cases[n].Dir = reflect.SelectRecv
+ for {
+ i, v, ok := reflect.Select(cases)
+ if i == n {
+ return
+ }
+ if !ok {
+ panic("(Chans).Drain(): unexpected chan close")
+ }
+ eich <- v.Interface().(EventInfo)
+ }
+ }()
+ <-time.After(50 * time.Duration(n) * time.Millisecond)
+ close(stop)
+ for e := range eich {
+ ei = append(ei, e)
+ }
+ return
+}
+
+// Call represents single call to Watcher issued by the Tree
+// and recorded by a spy Watcher mock.
+type Call struct {
+ F FuncType // denotes type of function to call, for both watcher and notifier interface
+ C chan EventInfo // user channel being an argument to either Watch or Stop function
+ P string // regular Path argument and old path from RecursiveRewatch call
+ NP string // new Path argument from RecursiveRewatch call
+ E Event // regular Event argument and old Event from a Rewatch call
+ NE Event // new Event argument from Rewatch call
+ S interface{} // when Call is used as EventInfo, S is a value of Sys()
+ Dir bool // when Call is used as EventInfo, Dir is a value of isDir()
+}
+
+// Call implements the EventInfo interface.
+func (c *Call) Event() Event { return c.E }
+func (c *Call) Path() string { return c.P }
+func (c *Call) String() string { return fmt.Sprintf("%#v", c) }
+func (c *Call) Sys() interface{} { return c.S }
+func (c *Call) isDir() (bool, error) { return c.Dir, nil }
+
+// CallSlice is a conveniance wrapper for a slice of Call values, which allows
+// to sort them in ascending order.
+type CallSlice []Call
+
+// CallSlice implements sort.Interface inteface.
+func (cs CallSlice) Len() int { return len(cs) }
+func (cs CallSlice) Less(i, j int) bool { return cs[i].P < cs[j].P }
+func (cs CallSlice) Swap(i, j int) { cs[i], cs[j] = cs[j], cs[i] }
+func (cs CallSlice) Sort() { sort.Sort(cs) }
+
+// Spy is a mock for Watcher interface, which records every call.
+type Spy []Call
+
+func (s *Spy) Close() (_ error) { return }
+
+func (s *Spy) Watch(p string, e Event) (_ error) {
+ dbgprintf("%s: (*Spy).Watch(%q, %v)", caller(), p, e)
+ *s = append(*s, Call{F: FuncWatch, P: p, E: e})
+ return
+}
+
+func (s *Spy) Unwatch(p string) (_ error) {
+ dbgprintf("%s: (*Spy).Unwatch(%q)", caller(), p)
+ *s = append(*s, Call{F: FuncUnwatch, P: p})
+ return
+}
+
+func (s *Spy) Rewatch(p string, olde, newe Event) (_ error) {
+ dbgprintf("%s: (*Spy).Rewatch(%q, %v, %v)", caller(), p, olde, newe)
+ *s = append(*s, Call{F: FuncRewatch, P: p, E: olde, NE: newe})
+ return
+}
+
+func (s *Spy) RecursiveWatch(p string, e Event) (_ error) {
+ dbgprintf("%s: (*Spy).RecursiveWatch(%q, %v)", caller(), p, e)
+ *s = append(*s, Call{F: FuncRecursiveWatch, P: p, E: e})
+ return
+}
+
+func (s *Spy) RecursiveUnwatch(p string) (_ error) {
+ dbgprintf("%s: (*Spy).RecursiveUnwatch(%q)", caller(), p)
+ *s = append(*s, Call{F: FuncRecursiveUnwatch, P: p})
+ return
+}
+
+func (s *Spy) RecursiveRewatch(oldp, newp string, olde, newe Event) (_ error) {
+ dbgprintf("%s: (*Spy).RecursiveRewatch(%q, %q, %v, %v)", caller(), oldp, newp, olde, newe)
+ *s = append(*s, Call{F: FuncRecursiveRewatch, P: oldp, NP: newp, E: olde, NE: newe})
+ return
+}
+
+type RCase struct {
+ Call Call
+ Record []Call
+}
+
+type TCase struct {
+ Event Call
+ Receiver Chans
+}
+
+type NCase struct {
+ Event WCase
+ Receiver Chans
+}
+
+type N struct {
+ Timeout time.Duration
+
+ t *testing.T
+ tree tree
+ w *W
+ spy *Spy
+ c chan EventInfo
+ j int // spy offset
+
+ realroot string
+}
+
+func newN(t *testing.T, tree string) *N {
+ n := &N{
+ t: t,
+ w: newWatcherTest(t, tree),
+ }
+ realroot, err := canonical(n.w.root)
+ if err != nil {
+ t.Fatalf("%s: unexpected fixture failure: %v", caller(), err)
+ }
+ n.realroot = realroot
+ return n
+}
+
+func newTreeN(t *testing.T, tree string) *N {
+ c := make(chan EventInfo, buffer)
+ n := newN(t, tree)
+ n.spy = &Spy{}
+ n.w.Watcher = n.spy
+ n.w.C = c
+ n.c = c
+ return n
+}
+
+func NewNotifyTest(t *testing.T, tree string) *N {
+ n := newN(t, tree)
+ if rw, ok := n.w.watcher().(recursiveWatcher); ok {
+ n.tree = newRecursiveTree(rw, n.w.c())
+ } else {
+ n.tree = newNonrecursiveTree(n.w.watcher(), n.w.c(), nil)
+ }
+ return n
+}
+
+func NewRecursiveTreeTest(t *testing.T, tree string) *N {
+ n := newTreeN(t, tree)
+ n.tree = newRecursiveTree(n.spy, n.c)
+ return n
+}
+
+func NewNonrecursiveTreeTest(t *testing.T, tree string) *N {
+ n := newTreeN(t, tree)
+ n.tree = newNonrecursiveTree(n.spy, n.c, nil)
+ return n
+}
+
+func NewNonrecursiveTreeTestC(t *testing.T, tree string) (*N, chan EventInfo) {
+ rec := make(chan EventInfo, buffer)
+ recinternal := make(chan EventInfo, buffer)
+ recuser := make(chan EventInfo, buffer)
+ go func() {
+ for ei := range rec {
+ select {
+ case recinternal <- ei:
+ default:
+ t.Fatalf("failed to send ei to recinternal: not ready")
+ }
+ select {
+ case recuser <- ei:
+ default:
+ t.Fatalf("failed to send ei to recuser: not ready")
+ }
+ }
+ }()
+ n := newTreeN(t, tree)
+ tr := newNonrecursiveTree(n.spy, n.c, recinternal)
+ tr.rec = rec
+ n.tree = tr
+ return n, recuser
+}
+
+func (n *N) timeout() time.Duration {
+ if n.Timeout != 0 {
+ return n.Timeout
+ }
+ return n.w.timeout()
+}
+
+func (n *N) W() *W {
+ return n.w
+}
+
+func (n *N) Close() error {
+ defer os.RemoveAll(n.w.root)
+ if err := n.tree.Close(); err != nil {
+ n.w.Fatalf("(notifier).Close()=%v", err)
+ }
+ return nil
+}
+
+func (n *N) Watch(path string, c chan<- EventInfo, events ...Event) {
+ UpdateWait() // we need to wait on Windows because of its asynchronous watcher.
+ path = filepath.Join(n.w.root, path)
+ if err := n.tree.Watch(path, c, events...); err != nil {
+ n.t.Errorf("Watch(%s, %p, %v)=%v", path, c, events, err)
+ }
+}
+
+func (n *N) WatchErr(path string, c chan<- EventInfo, err error, events ...Event) {
+ path = filepath.Join(n.w.root, path)
+ switch e := n.tree.Watch(path, c, events...); {
+ case err == nil && e == nil:
+ n.t.Errorf("Watch(%s, %p, %v)=nil", path, c, events)
+ case err != nil && e != err:
+ n.t.Errorf("Watch(%s, %p, %v)=%v != %v", path, c, events, e, err)
+ }
+}
+
+func (n *N) Stop(c chan<- EventInfo) {
+ n.tree.Stop(c)
+}
+
+func (n *N) Call(calls ...Call) {
+ for i := range calls {
+ switch calls[i].F {
+ case FuncWatch:
+ n.Watch(calls[i].P, calls[i].C, calls[i].E)
+ case FuncStop:
+ n.Stop(calls[i].C)
+ default:
+ panic("unsupported call type: " + string(calls[i].F))
+ }
+ }
+}
+
+func (n *N) expectDry(ch Chans, i int) {
+ if ei := ch.Drain(); len(ei) != 0 {
+ n.w.Fatalf("unexpected dangling events: %v (i=%d)", ei, i)
+ }
+}
+
+func (n *N) ExpectRecordedCalls(cases []RCase) {
+ for i, cas := range cases {
+ dbgprintf("ExpectRecordedCalls: i=%d\n", i)
+ n.Call(cas.Call)
+ record := (*n.spy)[n.j:]
+ if len(cas.Record) == 0 && len(record) == 0 {
+ continue
+ }
+ n.j = len(*n.spy)
+ if len(record) != len(cas.Record) {
+ n.t.Fatalf("%s: want len(record)=%d; got %d [%+v] (i=%d)", caller(),
+ len(cas.Record), len(record), record, i)
+ }
+ CallSlice(record).Sort()
+ for j := range cas.Record {
+ if err := EqualCall(cas.Record[j], record[j]); err != nil {
+ n.t.Fatalf("%s: %v (i=%d, j=%d)", caller(), err, i, j)
+ }
+ }
+ }
+}
+
+func (n *N) collect(ch Chans) <-chan []EventInfo {
+ done := make(chan []EventInfo)
+ go func() {
+ cases := make([]reflect.SelectCase, len(ch))
+ unique := make(map[<-chan EventInfo]EventInfo, len(ch))
+ for i := range ch {
+ cases[i].Chan = reflect.ValueOf(ch[i])
+ cases[i].Dir = reflect.SelectRecv
+ }
+ for i := len(cases); i != 0; i = len(cases) {
+ j, v, ok := reflect.Select(cases)
+ if !ok {
+ n.t.Fatal("unexpected chan close")
+ }
+ ch := cases[j].Chan.Interface().(chan EventInfo)
+ got := v.Interface().(EventInfo)
+ if ei, ok := unique[ch]; ok {
+ n.t.Fatalf("duplicated event %v (previous=%v) received on collect", got, ei)
+ }
+ unique[ch] = got
+ cases[j], cases = cases[i-1], cases[:i-1]
+ }
+ collected := make([]EventInfo, 0, len(ch))
+ for _, ch := range unique {
+ collected = append(collected, ch)
+ }
+ done <- collected
+ }()
+ return done
+}
+
+func (n *N) abs(rel Call) *Call {
+ rel.P = filepath.Join(n.realroot, filepath.FromSlash(rel.P))
+ if !filepath.IsAbs(rel.P) {
+ rel.P = filepath.Join(wd, rel.P)
+ }
+ return &rel
+}
+
+func (n *N) ExpectTreeEvents(cases []TCase, all Chans) {
+ for i, cas := range cases {
+ dbgprintf("ExpectTreeEvents: i=%d\n", i)
+ // Ensure there're no dangling event left by previous test-case.
+ n.expectDry(all, i)
+ n.c <- n.abs(cas.Event)
+ switch cas.Receiver {
+ case nil:
+ n.expectDry(all, i)
+ default:
+ ch := n.collect(cas.Receiver)
+ select {
+ case collected := <-ch:
+ for _, got := range collected {
+ if err := EqualEventInfo(&cas.Event, got); err != nil {
+ n.w.Fatalf("%s: %s (i=%d)", caller(), err, i)
+ }
+ }
+ case <-time.After(n.timeout()):
+ n.w.Fatalf("ExpectTreeEvents has timed out after %v waiting for"+
+ " %v on %s (i=%d)", n.timeout(), cas.Event.E, cas.Event.P, i)
+ }
+
+ }
+ }
+ n.expectDry(all, -1)
+}
+
+func (n *N) ExpectNotifyEvents(cases []NCase, all Chans) {
+ UpdateWait() // Wait some time before starting the test.
+ for i, cas := range cases {
+ dbgprintf("ExpectNotifyEvents: i=%d\n", i)
+ cas.Event.Action()
+ Sync()
+ switch cas.Receiver {
+ case nil:
+ n.expectDry(all, i)
+ default:
+ ch := n.collect(cas.Receiver)
+ select {
+ case collected := <-ch:
+ Compare:
+ for j, ei := range collected {
+ dbgprintf("received: path=%q, event=%v, sys=%v (i=%d, j=%d)", ei.Path(),
+ ei.Event(), ei.Sys(), i, j)
+ for _, want := range cas.Event.Events {
+ if err := EqualEventInfo(want, ei); err != nil {
+ dbgprint(err, j)
+ continue
+ }
+ continue Compare
+ }
+ n.w.Fatalf("ExpectNotifyEvents received an event which does not"+
+ " match any of the expected ones (i=%d): want one of %v; got %v", i,
+ cas.Event.Events, ei)
+ }
+ case <-time.After(n.timeout()):
+ n.w.Fatalf("ExpectNotifyEvents did not receive any of the expected events [%v] "+
+ "after %v (i=%d)", cas.Event, n.timeout(), i)
+ }
+ }
+ }
+ n.expectDry(all, -1)
+}
+
+func (n *N) Walk(fn walkFunc) {
+ switch t := n.tree.(type) {
+ case *recursiveTree:
+ if err := t.root.Walk("", fn); err != nil {
+ n.w.Fatal(err)
+ }
+ case *nonrecursiveTree:
+ if err := t.root.Walk("", fn); err != nil {
+ n.w.Fatal(err)
+ }
+ default:
+ n.t.Fatal("unknown tree type")
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/tree.go b/Godeps/_workspace/src/github.com/zillode/notify/tree.go
new file mode 100644
index 0000000..cd6afd6
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/tree.go
@@ -0,0 +1,22 @@
+// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+package notify
+
+const buffer = 128
+
+type tree interface {
+ Watch(string, chan<- EventInfo, ...Event) error
+ Stop(chan<- EventInfo)
+ Close() error
+}
+
+func newTree() tree {
+ c := make(chan EventInfo, buffer)
+ w := newWatcher(c)
+ if rw, ok := w.(recursiveWatcher); ok {
+ return newRecursiveTree(rw, c)
+ }
+ return newNonrecursiveTree(w, c, make(chan EventInfo, buffer))
+}
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/tree_nonrecursive.go b/Godeps/_workspace/src/github.com/zillode/notify/tree_nonrecursive.go
new file mode 100644
index 0000000..788a17b
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/tree_nonrecursive.go
@@ -0,0 +1,292 @@
+// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+package notify
+
+import "sync"
+
+// nonrecursiveTree TODO(rjeczalik)
+type nonrecursiveTree struct {
+ rw sync.RWMutex // protects root
+ root root
+ w watcher
+ c chan EventInfo
+ rec chan EventInfo
+}
+
+// newNonrecursiveTree TODO(rjeczalik)
+func newNonrecursiveTree(w watcher, c, rec chan EventInfo) *nonrecursiveTree {
+ if rec == nil {
+ rec = make(chan EventInfo, buffer)
+ }
+ t := &nonrecursiveTree{
+ root: root{nd: newnode("")},
+ w: w,
+ c: c,
+ rec: rec,
+ }
+ go t.dispatch(c)
+ go t.internal(rec)
+ return t
+}
+
+// dispatch TODO(rjeczalik)
+func (t *nonrecursiveTree) dispatch(c <-chan EventInfo) {
+ for ei := range c {
+ dbgprintf("dispatching %v on %q", ei.Event(), ei.Path())
+ go func(ei EventInfo) {
+ var nd node
+ var isrec bool
+ dir, base := split(ei.Path())
+ fn := func(it node, isbase bool) error {
+ isrec = isrec || it.Watch.IsRecursive()
+ if isbase {
+ nd = it
+ } else {
+ it.Watch.Dispatch(ei, recursive)
+ }
+ return nil
+ }
+ t.rw.RLock()
+ // Notify recursive watchpoints found on the path.
+ if err := t.root.WalkPath(dir, fn); err != nil {
+ dbgprint("dispatch did not reach leaf:", err)
+ t.rw.RUnlock()
+ return
+ }
+ // Notify parent watchpoint.
+ nd.Watch.Dispatch(ei, 0)
+ isrec = isrec || nd.Watch.IsRecursive()
+ // If leaf watchpoint exists, notify it.
+ if nd, ok := nd.Child[base]; ok {
+ isrec = isrec || nd.Watch.IsRecursive()
+ nd.Watch.Dispatch(ei, 0)
+ }
+ t.rw.RUnlock()
+ // If the event describes newly leaf directory created within
+ if !isrec || ei.Event() != Create {
+ return
+ }
+ if ok, err := ei.(isDirer).isDir(); !ok || err != nil {
+ return
+ }
+ t.rec <- ei
+ }(ei)
+ }
+}
+
+// internal TODO(rjeczalik)
+func (t *nonrecursiveTree) internal(rec <-chan EventInfo) {
+ for ei := range rec {
+ var nd node
+ var eset = internal
+ t.rw.Lock()
+ t.root.WalkPath(ei.Path(), func(it node, _ bool) error {
+ if e := it.Watch[t.rec]; e != 0 && e > eset {
+ eset = e
+ }
+ nd = it
+ return nil
+ })
+ if eset == internal {
+ t.rw.Unlock()
+ continue
+ }
+ err := nd.Add(ei.Path()).AddDir(t.recFunc(eset))
+ t.rw.Unlock()
+ if err != nil {
+ dbgprintf("internal(%p) error: %v", rec, err)
+ }
+ }
+}
+
+// watchAdd TODO(rjeczalik)
+func (t *nonrecursiveTree) watchAdd(nd node, c chan<- EventInfo, e Event) eventDiff {
+ if e&recursive != 0 {
+ diff := nd.Watch.Add(t.rec, e|Create|omit)
+ nd.Watch.Add(c, e)
+ return diff
+ }
+ return nd.Watch.Add(c, e)
+}
+
+// watchDelMin TODO(rjeczalik)
+func (t *nonrecursiveTree) watchDelMin(min Event, nd node, c chan<- EventInfo, e Event) eventDiff {
+ old, ok := nd.Watch[t.rec]
+ if ok {
+ nd.Watch[t.rec] = min
+ }
+ diff := nd.Watch.Del(c, e)
+ if ok {
+ switch old &^= diff[0] &^ diff[1]; {
+ case old|internal == internal:
+ delete(nd.Watch, t.rec)
+ if set, ok := nd.Watch[nil]; ok && len(nd.Watch) == 1 && set == 0 {
+ delete(nd.Watch, nil)
+ }
+ default:
+ nd.Watch.Add(t.rec, old|Create)
+ switch {
+ case diff == none:
+ case diff[1]|Create == diff[0]:
+ diff = none
+ default:
+ diff[1] |= Create
+ }
+ }
+ }
+ return diff
+}
+
+// watchDel TODO(rjeczalik)
+func (t *nonrecursiveTree) watchDel(nd node, c chan<- EventInfo, e Event) eventDiff {
+ return t.watchDelMin(0, nd, c, e)
+}
+
+// Watch TODO(rjeczalik)
+func (t *nonrecursiveTree) Watch(path string, c chan<- EventInfo, events ...Event) error {
+ if c == nil {
+ panic("notify: Watch using nil channel")
+ }
+ // Expanding with empty event set is a nop.
+ if len(events) == 0 {
+ return nil
+ }
+ path, isrec, err := cleanpath(path)
+ if err != nil {
+ return err
+ }
+ eset := joinevents(events)
+ t.rw.Lock()
+ defer t.rw.Unlock()
+ nd := t.root.Add(path)
+ if isrec {
+ return t.watchrec(nd, c, eset|recursive)
+ }
+ return t.watch(nd, c, eset)
+}
+
+func (t *nonrecursiveTree) watch(nd node, c chan<- EventInfo, e Event) (err error) {
+ diff := nd.Watch.Add(c, e)
+ switch {
+ case diff == none:
+ return nil
+ case diff[1] == 0:
+ // TODO(rjeczalik): cleanup this panic after implementation is stable
+ panic("eset is empty: " + nd.Name)
+ case diff[0] == 0:
+ err = t.w.Watch(nd.Name, diff[1])
+ default:
+ err = t.w.Rewatch(nd.Name, diff[0], diff[1])
+ }
+ if err != nil {
+ nd.Watch.Del(c, diff.Event())
+ return err
+ }
+ return nil
+}
+
+func (t *nonrecursiveTree) recFunc(e Event) walkFunc {
+ return func(nd node) (err error) {
+ switch diff := nd.Watch.Add(t.rec, e|omit|Create); {
+ case diff == none:
+ case diff[1] == 0:
+ // TODO(rjeczalik): cleanup this panic after implementation is stable
+ panic("eset is empty: " + nd.Name)
+ case diff[0] == 0:
+ err = t.w.Watch(nd.Name, diff[1])
+ default:
+ err = t.w.Rewatch(nd.Name, diff[0], diff[1])
+ }
+ return
+ }
+}
+
+func (t *nonrecursiveTree) watchrec(nd node, c chan<- EventInfo, e Event) error {
+ var traverse func(walkFunc) error
+ // Non-recursive tree listens on Create event for every recursive
+ // watchpoint in order to automagically set a watch for every
+ // created directory.
+ switch diff := nd.Watch.dryAdd(t.rec, e|Create); {
+ case diff == none:
+ t.watchAdd(nd, c, e)
+ nd.Watch.Add(t.rec, e|omit|Create)
+ return nil
+ case diff[1] == 0:
+ // TODO(rjeczalik): cleanup this panic after implementation is stable
+ panic("eset is empty: " + nd.Name)
+ case diff[0] == 0:
+ // TODO(rjeczalik): BFS into directories and skip subtree as soon as first
+ // recursive watchpoint is encountered.
+ traverse = nd.AddDir
+ default:
+ traverse = nd.Walk
+ }
+ // TODO(rjeczalik): account every path that failed to be (re)watched
+ // and retry.
+ if err := traverse(t.recFunc(e)); err != nil {
+ return err
+ }
+ t.watchAdd(nd, c, e)
+ return nil
+}
+
+type walkWatchpointFunc func(Event, node) error
+
+func (t *nonrecursiveTree) walkWatchpoint(nd node, fn walkWatchpointFunc) error {
+ type minode struct {
+ min Event
+ nd node
+ }
+ mnd := minode{nd: nd}
+ stack := []minode{mnd}
+Traverse:
+ for n := len(stack); n != 0; n = len(stack) {
+ mnd, stack = stack[n-1], stack[:n-1]
+ // There must be no recursive watchpoints if the node has no watchpoints
+ // itself (every node in subtree rooted at recursive watchpoints must
+ // have at least nil (total) and t.rec watchpoints).
+ if len(mnd.nd.Watch) != 0 {
+ switch err := fn(mnd.min, mnd.nd); err {
+ case nil:
+ case errSkip:
+ continue Traverse
+ default:
+ return err
+ }
+ }
+ for _, nd := range mnd.nd.Child {
+ stack = append(stack, minode{mnd.nd.Watch[t.rec], nd})
+ }
+ }
+ return nil
+}
+
+// Stop TODO(rjeczalik)
+func (t *nonrecursiveTree) Stop(c chan<- EventInfo) {
+ fn := func(min Event, nd node) error {
+ // TODO(rjeczalik): aggregate watcher errors and retry; in worst case
+ // forward to the user.
+ switch diff := t.watchDelMin(min, nd, c, all); {
+ case diff == none:
+ return nil
+ case diff[1] == 0:
+ t.w.Unwatch(nd.Name)
+ default:
+ t.w.Rewatch(nd.Name, diff[0], diff[1])
+ }
+ return nil
+ }
+ t.rw.Lock()
+ err := t.walkWatchpoint(t.root.nd, fn) // TODO(rjeczalik): store max root per c
+ t.rw.Unlock()
+ dbgprintf("Stop(%p) error: %v\n", c, err)
+}
+
+// Close TODO(rjeczalik)
+func (t *nonrecursiveTree) Close() error {
+ err := t.w.Close()
+ close(t.c)
+ return err
+}
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/tree_nonrecursive_test.go b/Godeps/_workspace/src/github.com/zillode/notify/tree_nonrecursive_test.go
new file mode 100644
index 0000000..37625bf
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/tree_nonrecursive_test.go
@@ -0,0 +1,543 @@
+// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+package notify
+
+import (
+ "fmt"
+ "testing"
+)
+
+func TestNonrecursiveTree(t *testing.T) {
+ n := NewNonrecursiveTreeTest(t, "testdata/vfs.txt")
+ defer n.Close()
+
+ ch := NewChans(5)
+
+ watches := [...]RCase{
+ // i=0
+ {
+ Call: Call{
+ F: FuncWatch,
+ P: "src/github.com/rjeczalik/fs/fs.go",
+ C: ch[0],
+ E: Rename,
+ },
+ Record: []Call{
+ {
+ F: FuncWatch,
+ P: "src/github.com/rjeczalik/fs/fs.go",
+ E: Rename,
+ },
+ },
+ },
+ // i=1
+ {
+ Call: Call{
+ F: FuncWatch,
+ P: "src/github.com/rjeczalik/fs/cmd/...",
+ C: ch[1],
+ E: Remove,
+ },
+ Record: []Call{
+ {
+ F: FuncWatch,
+ P: "src/github.com/rjeczalik/fs/cmd",
+ E: Create | Remove,
+ },
+ {
+ F: FuncWatch,
+ P: "src/github.com/rjeczalik/fs/cmd/gotree",
+ E: Create | Remove,
+ },
+ {
+ F: FuncWatch,
+ P: "src/github.com/rjeczalik/fs/cmd/mktree",
+ E: Create | Remove,
+ },
+ },
+ },
+ // i=2
+ {
+ Call: Call{
+ F: FuncWatch,
+ P: "src/github.com/rjeczalik/fs/cmd/...",
+ C: ch[2],
+ E: Rename,
+ },
+ Record: []Call{
+ {
+ F: FuncRewatch,
+ P: "src/github.com/rjeczalik/fs/cmd",
+ E: Create | Remove,
+ NE: Create | Remove | Rename,
+ },
+ {
+ F: FuncRewatch,
+ P: "src/github.com/rjeczalik/fs/cmd/gotree",
+ E: Create | Remove,
+ NE: Create | Remove | Rename,
+ },
+ {
+ F: FuncRewatch,
+ P: "src/github.com/rjeczalik/fs/cmd/mktree",
+ E: Create | Remove,
+ NE: Create | Remove | Rename,
+ },
+ },
+ },
+ // i=3
+ {
+ Call: Call{
+ F: FuncWatch,
+ P: "src/github.com/rjeczalik/fs/cmd/mktree/...",
+ C: ch[2],
+ E: Write,
+ },
+ Record: []Call{
+ {
+ F: FuncRewatch,
+ P: "src/github.com/rjeczalik/fs/cmd/mktree",
+ E: Create | Remove | Rename,
+ NE: Create | Remove | Rename | Write,
+ },
+ },
+ },
+ // i=4
+ {
+ Call: Call{
+ F: FuncWatch,
+ P: "src/github.com/pblaszczyk/qttu/include",
+ C: ch[3],
+ E: Create,
+ },
+ Record: []Call{
+ {
+ F: FuncWatch,
+ P: "src/github.com/pblaszczyk/qttu/include",
+ E: Create,
+ },
+ },
+ },
+ // i=5
+ {
+ Call: Call{
+ F: FuncWatch,
+ P: "src/github.com/pblaszczyk/qttu/include/qttu/detail/...",
+ C: ch[3],
+ E: Write,
+ },
+ Record: []Call{
+ {
+ F: FuncWatch,
+ P: "src/github.com/pblaszczyk/qttu/include/qttu/detail",
+ E: Create | Write,
+ },
+ },
+ },
+ // i=6
+ {
+ Call: Call{
+ F: FuncWatch,
+ P: "src/github.com/pblaszczyk/qttu/include/...",
+ C: ch[0],
+ E: Rename,
+ },
+ Record: []Call{
+ {
+ F: FuncRewatch,
+ P: "src/github.com/pblaszczyk/qttu/include",
+ E: Create,
+ NE: Create | Rename,
+ },
+ {
+ F: FuncWatch,
+ P: "src/github.com/pblaszczyk/qttu/include/qttu",
+ E: Create | Rename,
+ },
+ {
+ F: FuncRewatch,
+ P: "src/github.com/pblaszczyk/qttu/include/qttu/detail",
+ E: Create | Write,
+ NE: Create | Write | Rename,
+ },
+ },
+ },
+ // i=7
+ {
+ Call: Call{
+ F: FuncWatch,
+ P: "src/github.com/pblaszczyk/...",
+ C: ch[1],
+ E: Write,
+ },
+ Record: []Call{
+ {
+ F: FuncWatch,
+ P: "src/github.com/pblaszczyk",
+ E: Create | Write,
+ },
+ {
+ F: FuncWatch,
+ P: "src/github.com/pblaszczyk/qttu",
+ E: Create | Write,
+ },
+ {
+ F: FuncRewatch,
+ P: "src/github.com/pblaszczyk/qttu/include",
+ E: Create | Rename,
+ NE: Create | Rename | Write,
+ },
+ {
+ F: FuncRewatch,
+ P: "src/github.com/pblaszczyk/qttu/include/qttu",
+ E: Create | Rename,
+ NE: Create | Rename | Write,
+ },
+ {
+ F: FuncWatch,
+ P: "src/github.com/pblaszczyk/qttu/src",
+ E: Create | Write,
+ },
+ },
+ },
+ // i=8
+ {
+ Call: Call{
+ F: FuncWatch,
+ P: "src/github.com/pblaszczyk/qttu/include/...",
+ C: ch[4],
+ E: Write,
+ },
+ Record: nil,
+ },
+ // i=9
+ {
+ Call: Call{
+ F: FuncWatch,
+ P: "src/github.com/pblaszczyk/qttu",
+ C: ch[3],
+ E: Remove,
+ },
+ Record: []Call{
+ {
+ F: FuncRewatch,
+ P: "src/github.com/pblaszczyk/qttu",
+ E: Create | Write,
+ NE: Create | Write | Remove,
+ },
+ },
+ },
+ }
+
+ n.ExpectRecordedCalls(watches[:])
+
+ events := [...]TCase{
+ // i=0
+ {
+ Event: Call{P: "src/github.com/rjeczalik/fs/fs.go", E: Rename},
+ Receiver: Chans{ch[0]},
+ },
+ // i=1
+ {
+ Event: Call{P: "src/github.com/rjeczalik/fs/fs.go", E: Create},
+ Receiver: nil,
+ },
+ // i=2
+ {
+ Event: Call{P: "src/github.com/rjeczalik/fs/cmd/cmd.go", E: Remove},
+ Receiver: Chans{ch[1]},
+ },
+ // i=3
+ {
+ Event: Call{P: "src/github.com/rjeczalik/fs/cmd/doc.go", E: Write},
+ Receiver: nil,
+ },
+ // i=4
+ {
+ Event: Call{P: "src/github.com/rjeczalik/fs/cmd/mktree/main.go", E: Write},
+ Receiver: Chans{ch[2]},
+ },
+ // i=5
+ {
+ Event: Call{P: "src/github.com/rjeczalik/fs/cmd/mktree/tree.go", E: Create},
+ Receiver: nil,
+ },
+ // i=6
+ {
+ Event: Call{P: "src/github.com/pblaszczyk/qttu/include/.lock", E: Create},
+ Receiver: Chans{ch[3]},
+ },
+ // i=7
+ {
+ Event: Call{P: "src/github.com/pblaszczyk/qttu/include/qttu/detail/registry.hh", E: Write},
+ Receiver: Chans{ch[3], ch[1], ch[4]},
+ },
+ // i=8
+ {
+ Event: Call{P: "src/github.com/pblaszczyk/qttu/include/qttu", E: Remove},
+ Receiver: nil,
+ },
+ // i=9
+ {
+ Event: Call{P: "src/github.com/pblaszczyk/qttu/include", E: Remove},
+ Receiver: Chans{ch[3]},
+ },
+ }
+
+ n.ExpectTreeEvents(events[:], ch)
+
+ stops := [...]RCase{
+ // i=0
+ {
+ Call: Call{
+ F: FuncStop,
+ C: ch[4],
+ },
+ Record: nil,
+ },
+ // i=1
+ {
+ Call: Call{
+ F: FuncStop,
+ C: ch[3],
+ },
+ Record: []Call{
+ {
+ F: FuncRewatch,
+ P: "src/github.com/pblaszczyk/qttu",
+ E: Create | Write | Remove,
+ NE: Create | Write,
+ },
+ },
+ },
+ // i=2
+ {
+ Call: Call{
+ F: FuncStop,
+ C: ch[2],
+ },
+ Record: []Call{
+ {
+ F: FuncRewatch,
+ P: "src/github.com/rjeczalik/fs/cmd",
+ E: Create | Remove | Rename,
+ NE: Create | Remove,
+ },
+ {
+ F: FuncRewatch,
+ P: "src/github.com/rjeczalik/fs/cmd/gotree",
+ E: Create | Remove | Rename,
+ NE: Create | Remove,
+ },
+ {
+ F: FuncRewatch,
+ P: "src/github.com/rjeczalik/fs/cmd/mktree",
+ E: Create | Remove | Rename | Write,
+ NE: Create | Remove,
+ },
+ },
+ },
+ // i=3
+ {
+ Call: Call{
+ F: FuncStop,
+ C: ch[1],
+ },
+ Record: []Call{
+ {
+ F: FuncUnwatch,
+ P: "src/github.com/pblaszczyk",
+ },
+ {
+ F: FuncUnwatch,
+ P: "src/github.com/pblaszczyk/qttu",
+ },
+ {
+ F: FuncRewatch,
+ P: "src/github.com/pblaszczyk/qttu/include",
+ E: Create | Rename | Write,
+ NE: Create | Rename,
+ },
+ {
+ F: FuncRewatch,
+ P: "src/github.com/pblaszczyk/qttu/include/qttu",
+ E: Create | Rename | Write,
+ NE: Create | Rename,
+ },
+ {
+ F: FuncRewatch,
+ P: "src/github.com/pblaszczyk/qttu/include/qttu/detail",
+ E: Create | Rename | Write,
+ NE: Create | Rename,
+ },
+ {
+ F: FuncUnwatch,
+ P: "src/github.com/pblaszczyk/qttu/src",
+ },
+ {
+ F: FuncUnwatch,
+ P: "src/github.com/rjeczalik/fs/cmd",
+ },
+ {
+ F: FuncUnwatch,
+ P: "src/github.com/rjeczalik/fs/cmd/gotree",
+ },
+ {
+ F: FuncUnwatch,
+ P: "src/github.com/rjeczalik/fs/cmd/mktree",
+ },
+ },
+ },
+ // i=4
+ {
+ Call: Call{
+ F: FuncStop,
+ C: ch[0],
+ },
+ Record: []Call{
+ {
+ F: FuncUnwatch,
+ P: "src/github.com/pblaszczyk/qttu/include",
+ },
+ {
+ F: FuncUnwatch,
+ P: "src/github.com/pblaszczyk/qttu/include/qttu",
+ },
+ {
+ F: FuncUnwatch,
+ P: "src/github.com/pblaszczyk/qttu/include/qttu/detail",
+ },
+ {
+ F: FuncUnwatch,
+ P: "src/github.com/rjeczalik/fs/fs.go",
+ },
+ },
+ },
+ }
+
+ n.ExpectRecordedCalls(stops[:])
+
+ n.Walk(func(nd node) error {
+ if len(nd.Watch) != 0 {
+ return fmt.Errorf("unexpected watchpoint: name=%s, eventset=%v (len=%d)",
+ nd.Name, nd.Watch.Total(), len(nd.Watch))
+ }
+ return nil
+ })
+}
+
+func TestNonrecursiveTreeInternal(t *testing.T) {
+ n, c := NewNonrecursiveTreeTestC(t, "testdata/vfs.txt")
+ defer n.Close()
+
+ ch := NewChans(5)
+
+ watches := [...]RCase{
+ // i=0
+ {
+ Call: Call{
+ F: FuncWatch,
+ P: "src/github.com/rjeczalik/fs/cmd/...",
+ C: ch[0],
+ E: Remove,
+ },
+ Record: []Call{
+ {
+ F: FuncWatch,
+ P: "src/github.com/rjeczalik/fs/cmd",
+ E: Create | Remove,
+ },
+ {
+ F: FuncWatch,
+ P: "src/github.com/rjeczalik/fs/cmd/gotree",
+ E: Create | Remove,
+ },
+ {
+ F: FuncWatch,
+ P: "src/github.com/rjeczalik/fs/cmd/mktree",
+ E: Create | Remove,
+ },
+ },
+ },
+ // i=1
+ {
+ Call: Call{
+ F: FuncWatch,
+ P: "src/github.com/ppknap/link/include/coost/...",
+ C: ch[1],
+ E: Create,
+ },
+ Record: []Call{
+ {
+ F: FuncWatch,
+ P: "src/github.com/ppknap/link/include/coost",
+ E: Create,
+ },
+ {
+ F: FuncWatch,
+ P: "src/github.com/ppknap/link/include/coost/link",
+ E: Create,
+ },
+ {
+ F: FuncWatch,
+ P: "src/github.com/ppknap/link/include/coost/link/detail",
+ E: Create,
+ },
+ {
+ F: FuncWatch,
+ P: "src/github.com/ppknap/link/include/coost/link/detail/stdhelpers",
+ E: Create,
+ },
+ },
+ },
+ }
+
+ n.ExpectRecordedCalls(watches[:])
+
+ events := [...]TCase{
+ // i=0
+ {
+ Event: Call{P: "src/github.com/rjeczalik/fs/cmd/dir", E: Create, Dir: true},
+ Receiver: Chans{c},
+ },
+ // i=1
+ {
+ Event: Call{P: "src/github.com/rjeczalik/fs/cmd/dir/another", E: Create, Dir: true},
+ Receiver: Chans{c},
+ },
+ // i=2
+ {
+ Event: Call{P: "src/github.com/rjeczalik/fs/cmd/file", E: Create, Dir: false},
+ Receiver: nil,
+ },
+ // i=3
+ {
+ Event: Call{P: "src/github.com/ppknap/link/include/coost/dir", E: Create, Dir: true},
+ Receiver: Chans{ch[1], c},
+ },
+ // i=4
+ {
+ Event: Call{P: "src/github.com/ppknap/link/include/coost/dir/another", E: Create, Dir: true},
+ Receiver: Chans{ch[1], c},
+ },
+ // i=5
+ {
+ Event: Call{P: "src/github.com/ppknap/link/include/coost/file", E: Create, Dir: false},
+ Receiver: Chans{ch[1]},
+ },
+ // i=6
+ {
+ Event: Call{P: "src/github.com/rjeczalik/fs/cmd/mktree", E: Remove},
+ Receiver: Chans{ch[0]},
+ },
+ // i=7
+ {
+ Event: Call{P: "src/github.com/rjeczalik/fs/cmd/rmtree", E: Create, Dir: true},
+ Receiver: Chans{c},
+ },
+ }
+
+ n.ExpectTreeEvents(events[:], ch)
+}
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/tree_recursive.go b/Godeps/_workspace/src/github.com/zillode/notify/tree_recursive.go
new file mode 100644
index 0000000..7f00dfe
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/tree_recursive.go
@@ -0,0 +1,354 @@
+// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+package notify
+
+import "sync"
+
+// watchAdd TODO(rjeczalik)
+func watchAdd(nd node, c chan<- EventInfo, e Event) eventDiff {
+ diff := nd.Watch.Add(c, e)
+ if wp := nd.Child[""].Watch; len(wp) != 0 {
+ e = wp.Total()
+ diff[0] |= e
+ diff[1] |= e
+ if diff[0] == diff[1] {
+ return none
+ }
+ }
+ return diff
+}
+
+// watchAddInactive TODO(rjeczalik)
+func watchAddInactive(nd node, c chan<- EventInfo, e Event) eventDiff {
+ wp := nd.Child[""].Watch
+ if wp == nil {
+ wp = make(watchpoint)
+ nd.Child[""] = node{Watch: wp}
+ }
+ diff := wp.Add(c, e)
+ e = nd.Watch.Total()
+ diff[0] |= e
+ diff[1] |= e
+ if diff[0] == diff[1] {
+ return none
+ }
+ return diff
+}
+
+// watchCopy TODO(rjeczalik)
+func watchCopy(src, dst node) {
+ for c, e := range src.Watch {
+ if c == nil {
+ continue
+ }
+ watchAddInactive(dst, c, e)
+ }
+ if wpsrc := src.Child[""].Watch; len(wpsrc) != 0 {
+ wpdst := dst.Child[""].Watch
+ for c, e := range wpsrc {
+ if c == nil {
+ continue
+ }
+ wpdst.Add(c, e)
+ }
+ }
+}
+
+// watchDel TODO(rjeczalik)
+func watchDel(nd node, c chan<- EventInfo, e Event) eventDiff {
+ diff := nd.Watch.Del(c, e)
+ if wp := nd.Child[""].Watch; len(wp) != 0 {
+ diffInactive := wp.Del(c, e)
+ e = wp.Total()
+ // TODO(rjeczalik): add e if e != all?
+ diff[0] |= diffInactive[0] | e
+ diff[1] |= diffInactive[1] | e
+ if diff[0] == diff[1] {
+ return none
+ }
+ }
+ return diff
+}
+
+// watchTotal TODO(rjeczalik)
+func watchTotal(nd node) Event {
+ e := nd.Watch.Total()
+ if wp := nd.Child[""].Watch; len(wp) != 0 {
+ e |= wp.Total()
+ }
+ return e
+}
+
+// watchIsRecursive TODO(rjeczalik)
+func watchIsRecursive(nd node) bool {
+ ok := nd.Watch.IsRecursive()
+ // TODO(rjeczalik): add a test for len(wp) != 0 change the condition.
+ if wp := nd.Child[""].Watch; len(wp) != 0 {
+ // If a watchpoint holds inactive watchpoints, it means it's a parent
+ // one, which is recursive by nature even though it may be not recursive
+ // itself.
+ ok = true
+ }
+ return ok
+}
+
+// recursiveTree TODO(rjeczalik)
+type recursiveTree struct {
+ rw sync.RWMutex // protects root
+ root root
+ // TODO(rjeczalik): merge watcher + recursiveWatcher after #5 and #6
+ w interface {
+ watcher
+ recursiveWatcher
+ }
+ c chan EventInfo
+}
+
+// newRecursiveTree TODO(rjeczalik)
+func newRecursiveTree(w recursiveWatcher, c chan EventInfo) *recursiveTree {
+ t := &recursiveTree{
+ root: root{nd: newnode("")},
+ w: struct {
+ watcher
+ recursiveWatcher
+ }{w.(watcher), w},
+ c: c,
+ }
+ go t.dispatch()
+ return t
+}
+
+// dispatch TODO(rjeczalik)
+func (t *recursiveTree) dispatch() {
+ for ei := range t.c {
+ dbgprintf("dispatching %v on %q", ei.Event(), ei.Path())
+ go func(ei EventInfo) {
+ nd, ok := node{}, false
+ dir, base := split(ei.Path())
+ fn := func(it node, isbase bool) error {
+ if isbase {
+ nd = it
+ } else {
+ it.Watch.Dispatch(ei, recursive)
+ }
+ return nil
+ }
+ t.rw.RLock()
+ defer t.rw.RUnlock()
+ // Notify recursive watchpoints found on the path.
+ if err := t.root.WalkPath(dir, fn); err != nil {
+ dbgprint("dispatch did not reach leaf:", err)
+ return
+ }
+ // Notify parent watchpoint.
+ nd.Watch.Dispatch(ei, 0)
+ // If leaf watchpoint exists, notify it.
+ if nd, ok = nd.Child[base]; ok {
+ nd.Watch.Dispatch(ei, 0)
+ }
+ }(ei)
+ }
+}
+
+// Watch TODO(rjeczalik)
+func (t *recursiveTree) Watch(path string, c chan<- EventInfo, events ...Event) error {
+ if c == nil {
+ panic("notify: Watch using nil channel")
+ }
+ // Expanding with empty event set is a nop.
+ if len(events) == 0 {
+ return nil
+ }
+ path, isrec, err := cleanpath(path)
+ if err != nil {
+ return err
+ }
+ eventset := joinevents(events)
+ if isrec {
+ eventset |= recursive
+ }
+ t.rw.Lock()
+ defer t.rw.Unlock()
+ // case 1: cur is a child
+ //
+ // Look for parent watch which already covers the given path.
+ parent := node{}
+ self := false
+ err = t.root.WalkPath(path, func(nd node, isbase bool) error {
+ if watchTotal(nd) != 0 {
+ parent = nd
+ self = isbase
+ return errSkip
+ }
+ return nil
+ })
+ cur := t.root.Add(path) // add after the walk, so it's less to traverse
+ if err == nil && parent.Watch != nil {
+ // Parent watch found. Register inactive watchpoint, so we have enough
+ // information to shrink the eventset on eventual Stop.
+ // return t.resetwatchpoint(parent, parent, c, eventset|inactive)
+ var diff eventDiff
+ if self {
+ diff = watchAdd(cur, c, eventset)
+ } else {
+ diff = watchAddInactive(parent, c, eventset)
+ }
+ switch {
+ case diff == none:
+ // the parent watchpoint already covers requested subtree with its
+ // eventset
+ case diff[0] == 0:
+ // TODO(rjeczalik): cleanup this panic after implementation is stable
+ panic("dangling watchpoint: " + parent.Name)
+ default:
+ if isrec || watchIsRecursive(parent) {
+ err = t.w.RecursiveRewatch(parent.Name, parent.Name, diff[0], diff[1])
+ } else {
+ err = t.w.Rewatch(parent.Name, diff[0], diff[1])
+ }
+ if err != nil {
+ watchDel(parent, c, diff.Event())
+ return err
+ }
+ watchAdd(cur, c, eventset)
+ // TODO(rjeczalik): account top-most path for c
+ return nil
+ }
+ if !self {
+ watchAdd(cur, c, eventset)
+ }
+ return nil
+ }
+ // case 2: cur is new parent
+ //
+ // Look for children nodes, unwatch n-1 of them and rewatch the last one.
+ var children []node
+ fn := func(nd node) error {
+ if len(nd.Watch) == 0 {
+ return nil
+ }
+ children = append(children, nd)
+ return errSkip
+ }
+ switch must(cur.Walk(fn)); len(children) {
+ case 0:
+ // no child watches, cur holds a new watch
+ case 1:
+ watchAdd(cur, c, eventset) // TODO(rjeczalik): update cache c subtree root?
+ watchCopy(children[0], cur)
+ err = t.w.RecursiveRewatch(children[0].Name, cur.Name, watchTotal(children[0]),
+ watchTotal(cur))
+ if err != nil {
+ // Clean inactive watchpoint. The c chan did not exist before.
+ cur.Child[""] = node{}
+ delete(cur.Watch, c)
+ return err
+ }
+ return nil
+ default:
+ watchAdd(cur, c, eventset)
+ // Copy children inactive watchpoints to the new parent.
+ for _, nd := range children {
+ watchCopy(nd, cur)
+ }
+ // Watch parent subtree.
+ if err = t.w.RecursiveWatch(cur.Name, watchTotal(cur)); err != nil {
+ // Clean inactive watchpoint. The c chan did not exist before.
+ cur.Child[""] = node{}
+ delete(cur.Watch, c)
+ return err
+ }
+ // Unwatch children subtrees.
+ var e error
+ for _, nd := range children {
+ if watchIsRecursive(nd) {
+ e = t.w.RecursiveUnwatch(nd.Name)
+ } else {
+ e = t.w.Unwatch(nd.Name)
+ }
+ if e != nil {
+ err = nonil(err, e)
+ // TODO(rjeczalik): child is still watched, warn all its watchpoints
+ // about possible duplicate events via Error event
+ }
+ }
+ return err
+ }
+ // case 3: cur is new, alone node
+ switch diff := watchAdd(cur, c, eventset); {
+ case diff == none:
+ // TODO(rjeczalik): cleanup this panic after implementation is stable
+ panic("watch requested but no parent watchpoint found: " + cur.Name)
+ case diff[0] == 0:
+ if isrec {
+ err = t.w.RecursiveWatch(cur.Name, diff[1])
+ } else {
+ err = t.w.Watch(cur.Name, diff[1])
+ }
+ if err != nil {
+ watchDel(cur, c, diff.Event())
+ return err
+ }
+ default:
+ // TODO(rjeczalik): cleanup this panic after implementation is stable
+ panic("watch requested but no parent watchpoint found: " + cur.Name)
+ }
+ return nil
+}
+
+// Stop TODO(rjeczalik)
+//
+// TODO(rjeczalik): Split parent watchpoint - transfer watches to children
+// if parent is no longer needed. This carries a risk that underlying
+// watcher calls could fail - reconsider if it's worth the effort.
+func (t *recursiveTree) Stop(c chan<- EventInfo) {
+ var err error
+ fn := func(nd node) (e error) {
+ diff := watchDel(nd, c, all)
+ switch {
+ case diff == none && watchTotal(nd) == 0:
+ // TODO(rjeczalik): There's no watchpoints deeper in the tree,
+ // probably we should remove the nodes as well.
+ return nil
+ case diff == none:
+ // Removing c from nd does not require shrinking its eventset.
+ case diff[1] == 0:
+ if watchIsRecursive(nd) {
+ e = t.w.RecursiveUnwatch(nd.Name)
+ } else {
+ e = t.w.Unwatch(nd.Name)
+ }
+ default:
+ if watchIsRecursive(nd) {
+ e = t.w.RecursiveRewatch(nd.Name, nd.Name, diff[0], diff[1])
+ } else {
+ e = t.w.Rewatch(nd.Name, diff[0], diff[1])
+ }
+ }
+ fn := func(nd node) error {
+ watchDel(nd, c, all)
+ return nil
+ }
+ err = nonil(err, e, nd.Walk(fn))
+ // TODO(rjeczalik): if e != nil store dummy chan in nd.Watch just to
+ // retry un/rewatching next time and/or let the user handle the failure
+ // vie Error event?
+ return errSkip
+ }
+ t.rw.Lock()
+ e := t.root.Walk("", fn) // TODO(rjeczalik): use max root per c
+ t.rw.Unlock()
+ if e != nil {
+ err = nonil(err, e)
+ }
+ dbgprintf("Stop(%p) error: %v\n", c, err)
+}
+
+// Close TODO(rjeczalik)
+func (t *recursiveTree) Close() error {
+ err := t.w.Close()
+ close(t.c)
+ return err
+}
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/tree_recursive_test.go b/Godeps/_workspace/src/github.com/zillode/notify/tree_recursive_test.go
new file mode 100644
index 0000000..329fca0
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/tree_recursive_test.go
@@ -0,0 +1,524 @@
+// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+package notify
+
+import "testing"
+
+func TestRecursiveTree(t *testing.T) {
+ n := NewRecursiveTreeTest(t, "testdata/vfs.txt")
+ defer n.Close()
+
+ ch := NewChans(5)
+
+ watches := [...]RCase{
+ // i=0
+ {
+ Call: Call{
+ F: FuncWatch,
+ P: "src/github.com/rjeczalik/fs/fs.go",
+ C: ch[0],
+ E: Create,
+ },
+ Record: []Call{
+ {
+ F: FuncWatch,
+ P: "src/github.com/rjeczalik/fs/fs.go",
+ E: Create,
+ },
+ },
+ },
+ // i=1
+ {
+ Call: Call{
+ F: FuncWatch,
+ P: "src/github.com/rjeczalik/fs/cmd/...",
+ C: ch[1],
+ E: Remove,
+ },
+ Record: []Call{
+ {
+ F: FuncRecursiveWatch,
+ P: "src/github.com/rjeczalik/fs/cmd",
+ E: Remove,
+ },
+ },
+ },
+ // i=2
+ {
+ Call: Call{
+ F: FuncWatch,
+ P: "src/github.com/rjeczalik/fs",
+ C: ch[2],
+ E: Rename,
+ },
+ Record: []Call{
+ {
+ F: FuncRecursiveWatch,
+ P: "src/github.com/rjeczalik/fs",
+ E: Create | Remove | Rename,
+ },
+ {
+ F: FuncRecursiveUnwatch,
+ P: "src/github.com/rjeczalik/fs/cmd",
+ },
+ {
+ F: FuncUnwatch,
+ P: "src/github.com/rjeczalik/fs/fs.go",
+ },
+ },
+ },
+ // i=3
+ {
+ Call: Call{
+ F: FuncWatch,
+ P: "src/github.com/ppknap/link/README.md",
+ C: ch[0],
+ E: Create,
+ },
+ Record: []Call{
+ {
+ F: FuncWatch,
+ P: "src/github.com/ppknap/link/README.md",
+ E: Create,
+ },
+ },
+ },
+ // i=4
+ {
+ Call: Call{
+ F: FuncWatch,
+ P: "src/github.com/ppknap/link/include/...",
+ C: ch[3],
+ E: Remove,
+ },
+ Record: []Call{
+ {
+ F: FuncRecursiveWatch,
+ P: "src/github.com/ppknap/link/include",
+ E: Remove,
+ },
+ },
+ },
+ // i=5
+ {
+ Call: Call{
+ F: FuncWatch,
+ P: "src/github.com/ppknap/link/include",
+ C: ch[0],
+ E: Write,
+ },
+ Record: []Call{
+ {
+ F: FuncRecursiveRewatch,
+ P: "src/github.com/ppknap/link/include",
+ NP: "src/github.com/ppknap/link/include",
+ E: Remove,
+ NE: Remove | Write,
+ },
+ },
+ },
+ // i=6
+ {
+ Call: Call{
+ F: FuncWatch,
+ P: "src/github.com/ppknap/link/test/Jamfile.jam",
+ C: ch[0],
+ E: Rename,
+ },
+ Record: []Call{
+ {
+ F: FuncWatch,
+ P: "src/github.com/ppknap/link/test/Jamfile.jam",
+ E: Rename,
+ },
+ },
+ },
+ // i=7
+ {
+ Call: Call{
+ F: FuncWatch,
+ P: "src/github.com/ppknap/link/test/Jamfile.jam",
+ C: ch[0],
+ E: Create,
+ },
+ Record: []Call{
+ {
+ F: FuncRewatch,
+ P: "src/github.com/ppknap/link/test/Jamfile.jam",
+ E: Rename,
+ NE: Rename | Create,
+ },
+ },
+ },
+ // i=8
+ {
+ Call: Call{
+ F: FuncWatch,
+ P: "src/github.com/ppknap/...",
+ C: ch[0],
+ E: Create,
+ },
+ Record: []Call{
+ {
+ F: FuncRecursiveWatch,
+ P: "src/github.com/ppknap",
+ E: Create | Remove | Write | Rename,
+ },
+ {
+ F: FuncUnwatch,
+ P: "src/github.com/ppknap/link/README.md",
+ },
+ {
+ F: FuncRecursiveUnwatch,
+ P: "src/github.com/ppknap/link/include",
+ },
+ {
+ F: FuncUnwatch,
+ P: "src/github.com/ppknap/link/test/Jamfile.jam",
+ },
+ },
+ },
+ // i=9
+ {
+ Call: Call{
+ F: FuncWatch,
+ P: "src/github.com/rjeczalik/fs/README.md",
+ C: ch[0],
+ E: Rename,
+ },
+ Record: nil,
+ },
+ // i=10
+ {
+ Call: Call{
+ F: FuncWatch,
+ P: "src/github.com/rjeczalik/fs/cmd/gotree",
+ C: ch[2],
+ E: Create | Remove,
+ },
+ Record: nil,
+ },
+ // i=11
+ {
+ Call: Call{
+ F: FuncWatch,
+ P: "src/github.com/pblaszczyk/qttu/src/main.cc",
+ C: ch[0],
+ E: Create,
+ },
+ Record: []Call{
+ {
+ F: FuncWatch,
+ P: "src/github.com/pblaszczyk/qttu/src/main.cc",
+ E: Create,
+ },
+ },
+ },
+ // i=12
+ {
+ Call: Call{
+ F: FuncWatch,
+ P: "src/github.com/pblaszczyk/qttu/src/main.cc",
+ C: ch[0],
+ E: Remove,
+ },
+ Record: []Call{
+ {
+ F: FuncRewatch,
+ P: "src/github.com/pblaszczyk/qttu/src/main.cc",
+ E: Create,
+ NE: Create | Remove,
+ },
+ },
+ },
+ // i=13
+ {
+ Call: Call{
+ F: FuncWatch,
+ P: "src/github.com/pblaszczyk/qttu/src/main.cc",
+ C: ch[0],
+ E: Create | Remove,
+ },
+ Record: nil,
+ },
+ // i=14
+ {
+ Call: Call{
+ F: FuncWatch,
+ P: "src/github.com/pblaszczyk/qttu/src",
+ C: ch[0],
+ E: Create,
+ },
+ Record: []Call{
+ {
+ F: FuncRecursiveRewatch,
+ P: "src/github.com/pblaszczyk/qttu/src/main.cc",
+ NP: "src/github.com/pblaszczyk/qttu/src",
+ E: Create | Remove,
+ NE: Create | Remove,
+ },
+ },
+ },
+ // i=15
+ {
+ Call: Call{
+ F: FuncWatch,
+ P: "src/github.com/pblaszczyk/qttu",
+ C: ch[4],
+ E: Write,
+ },
+ Record: []Call{
+ {
+ F: FuncRecursiveRewatch,
+ P: "src/github.com/pblaszczyk/qttu/src",
+ NP: "src/github.com/pblaszczyk/qttu",
+ E: Create | Remove,
+ NE: Create | Remove | Write,
+ },
+ },
+ },
+ // i=16
+ {
+ Call: Call{
+ F: FuncWatch,
+ P: "src/github.com/rjeczalik/fs/fs.go",
+ C: ch[3],
+ E: Rename,
+ },
+ Record: nil,
+ },
+ }
+
+ n.ExpectRecordedCalls(watches[:])
+
+ events := [...]TCase{
+ // i=0
+ {
+ Event: Call{P: "src/github.com/rjeczalik/fs/fs.go", E: Rename},
+ Receiver: Chans{ch[2], ch[3]},
+ },
+ // i=1
+ {
+ Event: Call{P: "src/github.com/rjeczalik/fs/fs.go", E: Create},
+ Receiver: Chans{ch[0]},
+ },
+ // i=2
+ {
+ Event: Call{P: "src/github.com/rjeczalik/fs/fs.go/file", E: Create},
+ Receiver: Chans{ch[0]},
+ },
+ // i=3
+ {
+ Event: Call{P: "src/github.com/rjeczalik/fs", E: Rename},
+ Receiver: Chans{ch[2]},
+ },
+ // i=4
+ {
+ Event: Call{P: "src/github.com/rjeczalik/fs/fs_test.go", E: Rename},
+ Receiver: Chans{ch[2]},
+ },
+ // i=5
+ {
+ Event: Call{P: "src/github.com/rjeczalik/fs/cmd/mktree/main.go", E: Remove},
+ Receiver: Chans{ch[1]},
+ },
+ // i=6
+ {
+ Event: Call{P: "src/github.com/rjeczalik/fs/cmd/gotree", E: Remove},
+ Receiver: Chans{ch[1], ch[2]},
+ },
+ // i=7
+ {
+ Event: Call{P: "src/github.com/rjeczalik/fs/cmd", E: Remove},
+ Receiver: Chans{ch[1]},
+ },
+ // i=8
+ {
+ Event: Call{P: "src/github.com/rjeczalik/fs/fs.go/file", E: Write},
+ Receiver: nil,
+ },
+ // i=9
+ {
+ Event: Call{P: "src/github.com/rjeczalik/fs/fs.go/file", E: Write},
+ Receiver: nil,
+ },
+ // i=10
+ {
+ Event: Call{P: "src/github.com/rjeczalik/fs", E: Remove},
+ Receiver: nil,
+ },
+ // i=11
+ {
+ Event: Call{P: "src/github.com/rjeczalik/fs/cmd", E: Rename},
+ Receiver: Chans{ch[2]},
+ },
+ // i=12
+ {
+ Event: Call{P: "src/github.com/rjeczalik/fs/cmd/mktree/main.go", E: Write},
+ Receiver: nil,
+ },
+ // i=13
+ {
+ Event: Call{P: "src/github.com/rjeczalik/fs/cmd/gotree", E: Rename},
+ Receiver: nil,
+ },
+ // i=14
+ {
+ Event: Call{P: "src/github.com/rjeczalik/fs/cmd/file", E: Rename},
+ Receiver: nil,
+ },
+ // i=15
+ {
+ Event: Call{P: "src/github.com/rjeczalik/fs/fs.go", E: Rename},
+ Receiver: Chans{ch[2], ch[3]},
+ },
+ }
+
+ n.ExpectTreeEvents(events[:], ch)
+
+ stops := [...]RCase{
+ // i=0
+ {
+ Call: Call{
+ F: FuncStop,
+ C: ch[1],
+ },
+ Record: nil,
+ },
+ {
+ Call: Call{
+ F: FuncStop,
+ C: ch[4],
+ },
+ Record: []Call{
+ {
+ F: FuncRecursiveRewatch,
+ P: "src/github.com/pblaszczyk/qttu",
+ NP: "src/github.com/pblaszczyk/qttu",
+ E: Create | Remove | Write,
+ NE: Create | Remove,
+ },
+ },
+ },
+ }
+
+ n.ExpectRecordedCalls(stops[:])
+}
+
+func TestRecursiveTreeWatchInactiveMerge(t *testing.T) {
+ n := NewRecursiveTreeTest(t, "testdata/vfs.txt")
+ defer n.Close()
+
+ ch := NewChans(1)
+
+ watches := [...]RCase{
+ // i=0
+ {
+ Call: Call{
+ F: FuncWatch,
+ P: "src/github.com/rjeczalik/fs",
+ C: ch[0],
+ E: Create,
+ },
+ Record: []Call{
+ {
+ F: FuncWatch,
+ P: "src/github.com/rjeczalik/fs",
+ E: Create,
+ },
+ },
+ },
+ // i=1
+ {
+ Call: Call{
+ F: FuncWatch,
+ P: "src/github.com/rjeczalik/fs/cmd/gotree/...",
+ C: ch[0],
+ E: Remove,
+ },
+ Record: []Call{
+ {
+ F: FuncRecursiveRewatch,
+ P: "src/github.com/rjeczalik/fs",
+ NP: "src/github.com/rjeczalik/fs",
+ E: Create,
+ NE: Create | Remove,
+ },
+ },
+ },
+ }
+
+ n.ExpectRecordedCalls(watches[:])
+
+ events := [...]TCase{
+ // i=0
+ {
+ Event: Call{P: "src/github.com/rjeczalik/fs/.fs.go.swp", E: Create},
+ Receiver: Chans{ch[0]},
+ },
+ // i=1
+ {
+ Event: Call{P: "src/github.com/rjeczalik/fs/.fs.go.swp", E: Remove},
+ Receiver: nil,
+ },
+ // i=2
+ {
+ Event: Call{P: "src/github.com/rjeczalik/fs", E: Remove},
+ Receiver: nil,
+ },
+ // i=3
+ {
+ Event: Call{P: "src/github.com/rjeczalik/fs/cmd/gotree/main.go", E: Remove},
+ Receiver: Chans{ch[0]},
+ },
+ }
+
+ n.ExpectTreeEvents(events[:], ch)
+}
+
+func TestRecursiveTree_Windows(t *testing.T) {
+ n := NewRecursiveTreeTest(t, "testdata/vfs.txt")
+ defer n.Close()
+
+ const ChangeFileName = Event(0x1)
+
+ ch := NewChans(1)
+
+ watches := [...]RCase{
+ // i=0
+ {
+ Call: Call{
+ F: FuncWatch,
+ P: "src/github.com/rjeczalik/fs",
+ C: ch[0],
+ E: ChangeFileName,
+ },
+ Record: []Call{
+ {
+ F: FuncWatch,
+ P: "src/github.com/rjeczalik/fs",
+ E: ChangeFileName,
+ },
+ },
+ },
+ }
+
+ n.ExpectRecordedCalls(watches[:])
+
+ events := [...]TCase{
+ // i=0
+ {
+ Event: Call{P: "src/github.com/rjeczalik/fs", E: ChangeFileName},
+ Receiver: Chans{ch[0]},
+ },
+ // i=1
+ {
+ Event: Call{P: "src/github.com/rjeczalik/fs/fs.go", E: ChangeFileName},
+ Receiver: Chans{ch[0]},
+ },
+ }
+
+ n.ExpectTreeEvents(events[:], ch)
+}
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/util.go b/Godeps/_workspace/src/github.com/zillode/notify/util.go
new file mode 100644
index 0000000..bbc84c3
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/util.go
@@ -0,0 +1,146 @@
+// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+package notify
+
+import (
+ "errors"
+ "os"
+ "path/filepath"
+ "strings"
+)
+
+const all = ^Event(0)
+const sep = string(os.PathSeparator)
+
+var errDepth = errors.New("exceeded allowed iteration count (circular symlink?)")
+
+func min(i, j int) int {
+ if i > j {
+ return j
+ }
+ return i
+}
+
+func max(i, j int) int {
+ if i < j {
+ return j
+ }
+ return i
+}
+
+// must panics if err is non-nil.
+func must(err error) {
+ if err != nil {
+ panic(err)
+ }
+}
+
+// nonil gives first non-nil error from the given arguments.
+func nonil(err ...error) error {
+ for _, err := range err {
+ if err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+func cleanpath(path string) (realpath string, isrec bool, err error) {
+ if strings.HasSuffix(path, "...") {
+ isrec = true
+ path = path[:len(path)-3]
+ }
+ if path, err = filepath.Abs(path); err != nil {
+ return "", false, err
+ }
+ if path, err = canonical(path); err != nil {
+ return "", false, err
+ }
+ return path, isrec, nil
+}
+
+// canonical resolves any symlink in the given path and returns it in a clean form.
+// It expects the path to be absolute. It fails to resolve circular symlinks by
+// maintaining a simple iteration limit.
+func canonical(p string) (string, error) {
+ p, err := filepath.Abs(p)
+ if err != nil {
+ return "", err
+ }
+ for i, depth := 1, 1; i < len(p); i, depth = i+1, depth+1 {
+ if depth > 128 {
+ return "", &os.PathError{Op: "canonical", Path: p, Err: errDepth}
+ }
+ if j := strings.IndexRune(p[i:], '/'); j == -1 {
+ i = len(p)
+ } else {
+ i = i + j
+ }
+ fi, err := os.Lstat(p[:i])
+ if err != nil {
+ return "", err
+ }
+ if fi.Mode()&os.ModeSymlink == os.ModeSymlink {
+ s, err := os.Readlink(p[:i])
+ if err != nil {
+ return "", err
+ }
+ p = "/" + s + p[i:]
+ i = 1 // no guarantee s is canonical, start all over
+ }
+ }
+ return filepath.Clean(p), nil
+}
+
+func joinevents(events []Event) (e Event) {
+ if len(events) == 0 {
+ e = All
+ } else {
+ for _, event := range events {
+ e |= event
+ }
+ }
+ return
+}
+
+func split(s string) (string, string) {
+ if i := lastIndexSep(s); i != -1 {
+ return s[:i], s[i+1:]
+ }
+ return "", s
+}
+
+func base(s string) string {
+ if i := lastIndexSep(s); i != -1 {
+ return s[i+1:]
+ }
+ return s
+}
+
+func indexbase(root, name string) int {
+ if n, m := len(root), len(name); m >= n && name[:n] == root &&
+ (n == m || name[n] == os.PathSeparator) {
+ return min(n+1, m)
+ }
+ return -1
+}
+
+func indexSep(s string) int {
+ for i := 0; i < len(s); i++ {
+ if s[i] == os.PathSeparator {
+ return i
+ }
+ }
+ return -1
+}
+
+func lastIndexSep(s string) int {
+ for i := len(s) - 1; i >= 0; i-- {
+ if s[i] == os.PathSeparator {
+ return i
+ }
+ }
+ return -1
+}
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/util_darwin_test.go b/Godeps/_workspace/src/github.com/zillode/notify/util_darwin_test.go
new file mode 100644
index 0000000..8c95db3
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/util_darwin_test.go
@@ -0,0 +1,41 @@
+// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+// +build darwin
+
+package notify
+
+import (
+ "os"
+ "testing"
+)
+
+func TestCanonicalDarwin(t *testing.T) {
+ cases := [...]caseCanonical{
+ {"/etc", "/private/etc"},
+ {"/etc/defaults", "/private/etc/defaults"},
+ {"/etc/hosts", "/private/etc/hosts"},
+ {"/tmp", "/private/tmp"},
+ {"/var", "/private/var"},
+ }
+ testCanonical(t, cases[:])
+}
+
+func TestCanonicalDarwinMultiple(t *testing.T) {
+ etcsym, err := symlink("/etc", "")
+ if err != nil {
+ t.Fatal(err)
+ }
+ tmpsym, err := symlink("/tmp", "")
+ if err != nil {
+ t.Fatal(nonil(err, os.Remove(etcsym)))
+ }
+ defer removeall(etcsym, tmpsym)
+ cases := [...]caseCanonical{
+ {etcsym, "/private/etc"},
+ {etcsym + "/hosts", "/private/etc/hosts"},
+ {tmpsym, "/private/tmp"},
+ }
+ testCanonical(t, cases[:])
+}
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/util_test.go b/Godeps/_workspace/src/github.com/zillode/notify/util_test.go
new file mode 100644
index 0000000..43af3e7
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/util_test.go
@@ -0,0 +1,147 @@
+// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+package notify
+
+import (
+ "os"
+ "path/filepath"
+ "testing"
+)
+
+type caseCanonical struct {
+ path string
+ full string
+}
+
+func testCanonical(t *testing.T, cases []caseCanonical) {
+ for i, cas := range cases {
+ full, err := canonical(cas.path)
+ if err != nil {
+ t.Errorf("want err=nil; got %v (i=%d)", err, i)
+ continue
+ }
+ if full != cas.full {
+ t.Errorf("want full=%q; got %q (i=%d)", cas.full, full, i)
+ continue
+ }
+ }
+}
+
+func TestCanonicalNoSymlink(t *testing.T) {
+ wd, err := os.Getwd()
+ if err != nil {
+ t.Fatalf("os.Getwd()=%v", err)
+ }
+ td := filepath.Join(wd, "testdata")
+ cases := [...]caseCanonical{
+ {".", wd},
+ {"testdata", td},
+ {filepath.Join("testdata", ".."), wd},
+ }
+ testCanonical(t, cases[:])
+}
+
+func TestJoinevents(t *testing.T) {
+ cases := [...]struct {
+ evs []Event
+ ev Event
+ }{
+ 0: {nil, All},
+ 1: {[]Event{}, All},
+ 2: {[]Event{Create}, Create},
+ 3: {[]Event{Rename}, Rename},
+ 4: {[]Event{Create, Write, Remove}, Create | Write | Remove},
+ }
+ for i, cas := range cases {
+ if ev := joinevents(cas.evs); ev != cas.ev {
+ t.Errorf("want event=%v; got %v (i=%d)", cas.ev, ev, i)
+ }
+ }
+}
+
+func TestTreeSplit(t *testing.T) {
+ cases := [...]struct {
+ path string
+ dir string
+ base string
+ }{
+ {"/github.com/rjeczalik/fakerpc", "/github.com/rjeczalik", "fakerpc"},
+ {"/home/rjeczalik/src", "/home/rjeczalik", "src"},
+ {"/Users/pknap/porn/gopher.avi", "/Users/pknap/porn", "gopher.avi"},
+ {"C:/Documents and Users", "C:", "Documents and Users"},
+ {"C:/Documents and Users/pblaszczyk/wiertarka.exe", "C:/Documents and Users/pblaszczyk", "wiertarka.exe"},
+ {"/home/(╯°□°）╯︵ ┻━┻", "/home", "(╯°□°）╯︵ ┻━┻"},
+ }
+ for i, cas := range cases {
+ dir, base := split(filepath.FromSlash(cas.path))
+ if want := filepath.FromSlash(cas.dir); dir != want {
+ t.Errorf("want dir=%s; got %s (i=%d)", want, dir, i)
+ }
+ if want := filepath.FromSlash(cas.base); base != want {
+ t.Errorf("want base=%s; got %s (i=%d)", want, base, i)
+ }
+ }
+}
+
+func TestTreeBase(t *testing.T) {
+ cases := [...]struct {
+ path string
+ base string
+ }{
+ {"/github.com/rjeczalik/fakerpc", "fakerpc"},
+ {"/home/rjeczalik/src", "src"},
+ {"/Users/pknap/porn/gopher.avi", "gopher.avi"},
+ {"C:/Documents and Users", "Documents and Users"},
+ {"C:/Documents and Users/pblaszczyk/wiertarka.exe", "wiertarka.exe"},
+ {"/home/(╯°□°）╯︵ ┻━┻", "(╯°□°）╯︵ ┻━┻"},
+ }
+ for i, cas := range cases {
+ if base := base(filepath.FromSlash(cas.path)); base != cas.base {
+ t.Errorf("want base=%s; got %s (i=%d)", cas.base, base, i)
+ }
+ }
+}
+
+func TestTreeIndexSep(t *testing.T) {
+ cases := [...]struct {
+ path string
+ n int
+ }{
+ {"github.com/rjeczalik/fakerpc", 10},
+ {"home/rjeczalik/src", 4},
+ {"Users/pknap/porn/gopher.avi", 5},
+ {"C:/Documents and Users", 2},
+ {"Documents and Users/pblaszczyk/wiertarka.exe", 19},
+ {"(╯°□°）╯︵ ┻━┻/Downloads", 30},
+ }
+ for i, cas := range cases {
+ if n := indexSep(filepath.FromSlash(cas.path)); n != cas.n {
+ t.Errorf("want n=%d; got %d (i=%d)", cas.n, n, i)
+ }
+ }
+}
+
+func TestTreeLastIndexSep(t *testing.T) {
+ cases := [...]struct {
+ path string
+ n int
+ }{
+ {"github.com/rjeczalik/fakerpc", 20},
+ {"home/rjeczalik/src", 14},
+ {"Users/pknap/porn/gopher.avi", 16},
+ {"C:/Documents and Users", 2},
+ {"Documents and Users/pblaszczyk/wiertarka.exe", 30},
+ {"/home/(╯°□°）╯︵ ┻━┻", 5},
+ }
+ for i, cas := range cases {
+ if n := lastIndexSep(filepath.FromSlash(cas.path)); n != cas.n {
+ t.Errorf("want n=%d; got %d (i=%d)", cas.n, n, i)
+ }
+ }
+}
+
+func TestCleanpath(t *testing.T) {
+ t.Skip("TODO(rjeczalik)")
+}
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/util_unix_test.go b/Godeps/_workspace/src/github.com/zillode/notify/util_unix_test.go
new file mode 100644
index 0000000..0011506
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/util_unix_test.go
@@ -0,0 +1,94 @@
+// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+// +build !windows
+
+package notify
+
+import (
+ "io/ioutil"
+ "os"
+ "path/filepath"
+ "testing"
+)
+
+func tmpfile(s string) (string, error) {
+ f, err := ioutil.TempFile(filepath.Split(s))
+ if err != nil {
+ return "", err
+ }
+ if err = nonil(f.Sync(), f.Close()); err != nil {
+ return "", err
+ }
+ return f.Name(), nil
+}
+
+func symlink(src, dst string) (string, error) {
+ name, err := tmpfile(dst)
+ if err != nil {
+ return "", err
+ }
+ if err = nonil(os.Remove(name), os.Symlink(src, name)); err != nil {
+ return "", err
+ }
+ return name, nil
+}
+
+func removeall(s ...string) {
+ for _, s := range s {
+ os.Remove(s)
+ }
+}
+
+func TestCanonical(t *testing.T) {
+ wd, err := os.Getwd()
+ if err != nil {
+ t.Fatalf("os.Getwd()=%v", err)
+ }
+ wdsym, err := symlink(wd, "")
+ if err != nil {
+ t.Fatalf(`symlink(%q, "")=%v`, wd, err)
+ }
+ td := filepath.Join(wd, "testdata")
+ tdsym, err := symlink(td, td)
+ if err != nil {
+ t.Errorf("symlink(%q, %q)=%v", td, td, nonil(err, os.Remove(wdsym)))
+ }
+ defer removeall(wdsym, tdsym)
+ vfstxt := filepath.Join(td, "vfs.txt")
+ cases := [...]caseCanonical{
+ {wdsym, wd},
+ {tdsym, td},
+ {filepath.Join(wdsym, "notify.go"), filepath.Join(wd, "notify.go")},
+ {filepath.Join(tdsym, "vfs.txt"), vfstxt},
+ {filepath.Join(wdsym, filepath.Base(tdsym), "vfs.txt"), vfstxt},
+ }
+ testCanonical(t, cases[:])
+}
+
+func TestCanonicalCircular(t *testing.T) {
+ tmp1, err := tmpfile("circular")
+ if err != nil {
+ t.Fatal(err)
+ }
+ tmp2, err := tmpfile("circular")
+ if err != nil {
+ t.Fatal(nonil(err, os.Remove(tmp1)))
+ }
+ defer removeall(tmp1, tmp2)
+ // Symlink tmp1 -> tmp2.
+ if err = nonil(os.Remove(tmp1), os.Symlink(tmp2, tmp1)); err != nil {
+ t.Fatal(err)
+ }
+ // Symlnik tmp2 -> tmp1.
+ if err = nonil(os.Remove(tmp2), os.Symlink(tmp1, tmp2)); err != nil {
+ t.Fatal(err)
+ }
+ if _, err = canonical(tmp1); err == nil {
+ t.Fatalf("want canonical(%q)!=nil", tmp1)
+ }
+ if _, ok := err.(*os.PathError); !ok {
+ t.Fatalf("want canonical(%q)=os.PathError; got %T", tmp1, err)
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/watcher.go b/Godeps/_workspace/src/github.com/zillode/notify/watcher.go
new file mode 100644
index 0000000..34148ef
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/watcher.go
@@ -0,0 +1,85 @@
+// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+package notify
+
+import "errors"
+
+var (
+ errAlreadyWatched = errors.New("path is already watched")
+ errNotWatched = errors.New("path is not being watched")
+ errInvalidEventSet = errors.New("invalid event set provided")
+)
+
+// Watcher is a intermediate interface for wrapping inotify, ReadDirChangesW,
+// FSEvents, kqueue and poller implementations.
+//
+// The watcher implementation is expected to do its own mapping between paths and
+// create watchers if underlying event notification does not support it. For
+// the ease of implementation it is guaranteed that paths provided via Watch and
+// Unwatch methods are absolute and clean.
+type watcher interface {
+ // Watch requests a watcher creation for the given path and given event set.
+ Watch(path string, event Event) error
+
+ // Unwatch requests a watcher deletion for the given path and given event set.
+ Unwatch(path string) error
+
+ // Rewatch provides a functionality for modifying existing watch-points, like
+ // expanding its event set.
+ //
+ // Rewatch modifies existing watch-point under for the given path. It passes
+ // the existing event set currently registered for the given path, and the
+ // new, requested event set.
+ //
+ // It is guaranteed that Tree will not pass to Rewatch zero value for any
+ // of its arguments. If old == new and watcher can be upgraded to
+ // recursiveWatcher interface, a watch for the corresponding path is expected
+ // to be changed from recursive to the non-recursive one.
+ Rewatch(path string, old, new Event) error
+
+ // Close unwatches all paths that are registered. When Close returns, it
+ // is expected it will report no more events.
+ Close() error
+}
+
+// RecursiveWatcher is an interface for a Watcher for those OS, which do support
+// recursive watching over directories.
+type recursiveWatcher interface {
+ RecursiveWatch(path string, event Event) error
+
+ // RecursiveUnwatch removes a recursive watch-point given by the path. For
+ // native recursive implementation there is no difference in functionality
+ // between Unwatch and RecursiveUnwatch, however for those platforms, that
+ // requires emulation for recursive watch-points, the implementation differs.
+ RecursiveUnwatch(path string) error
+
+ // RecursiveRewatcher provides a functionality for modifying and/or relocating
+ // existing recursive watch-points.
+ //
+ // To relocate a watch-point means to unwatch oldpath and set a watch-point on
+ // newpath.
+ //
+ // To modify a watch-point means either to expand or shrink its event set.
+ //
+ // Tree can want to either relocate, modify or relocate and modify a watch-point
+ // via single RecursiveRewatch call.
+ //
+ // If oldpath == newpath, the watch-point is expected to change its event set value
+ // from oldevent to newevent.
+ //
+ // If oldevent == newevent, the watch-point is expected to relocate from oldpath
+ // to the newpath.
+ //
+ // If oldpath != newpath and oldevent != newevent, the watch-point is expected
+ // to relocate from oldpath to the newpath first and then change its event set
+ // value from oldevent to the newevent. In other words the end result must be
+ // a watch-point set on newpath with newevent value of its event set.
+ //
+ // It is guaranteed that Tree will not pass to RecurisveRewatcha zero value
+ // for any of its arguments. If oldpath == newpath and oldevent == newevent,
+ // a watch for the corresponding path is expected to be changed for
+ // non-recursive to the recursive one.
+ RecursiveRewatch(oldpath, newpath string, oldevent, newevent Event) error
+}
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/watcher_fsevents.go b/Godeps/_workspace/src/github.com/zillode/notify/watcher_fsevents.go
new file mode 100644
index 0000000..5433491
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/watcher_fsevents.go
@@ -0,0 +1,319 @@
+// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+// +build darwin,!kqueue
+
+package notify
+
+import (
+ "errors"
+ "strings"
+ "sync/atomic"
+)
+
+// TODO(rjeczalik): get rid of calls to canonical, it's tree responsibility
+
+const (
+ failure = uint32(FSEventsMustScanSubDirs | FSEventsUserDropped | FSEventsKernelDropped)
+ filter = uint32(FSEventsCreated | FSEventsRemoved | FSEventsRenamed |
+ FSEventsModified | FSEventsInodeMetaMod)
+)
+
+// FSEvent represents single file event. It is created out of values passed by
+// FSEvents to FSEventStreamCallback function.
+type FSEvent struct {
+ Path string // real path of the file or directory
+ ID uint64 // ID of the event (FSEventStreamEventId)
+ Flags uint32 // joint FSEvents* flags (FSEventStreamEventFlags)
+}
+
+// splitflags separates event flags from single set into slice of flags.
+func splitflags(set uint32) (e []uint32) {
+ for i := uint32(1); set != 0; i, set = i<<1, set>>1 {
+ if (set & 1) != 0 {
+ e = append(e, i)
+ }
+ }
+ return
+}
+
+// watch represents a filesystem watchpoint. It is a higher level abstraction
+// over FSEvents' stream, which implements filtering of file events based
+// on path and event set. It emulates non-recursive watch-point by filtering out
+// events which paths are more than 1 level deeper than the watched path.
+type watch struct {
+ // prev stores last event set per path in order to filter out old flags
+ // for new events, which appratenly FSEvents likes to retain. It's a disgusting
+ // hack, it should be researched how to get rid of it.
+ prev map[string]uint32
+ c chan<- EventInfo
+ stream *stream
+ path string
+ events uint32
+ isrec int32
+ flushed bool
+}
+
+// Example format:
+//
+// ~ $ (trigger command) # (event set) -> (effective event set)
+//
+// Heuristics:
+//
+// 1. Create event is removed when it was present in previous event set.
+// Example:
+//
+// ~ $ echo > file # Create|Write -> Create|Write
+// ~ $ echo > file # Create|Write|InodeMetaMod -> Write|InodeMetaMod
+//
+// 2. Remove event is removed if it was present in previouse event set.
+// Example:
+//
+// ~ $ touch file # Create -> Create
+// ~ $ rm file # Create|Remove -> Remove
+// ~ $ touch file # Create|Remove -> Create
+//
+// 3. Write event is removed if not followed by InodeMetaMod on existing
+// file. Example:
+//
+// ~ $ echo > file # Create|Write -> Create|Write
+// ~ $ chmod +x file # Create|Write|ChangeOwner -> ChangeOwner
+//
+// 4. Write&InodeMetaMod is removed when effective event set contain Remove event.
+// Example:
+//
+// ~ $ echo > file # Write|InodeMetaMod -> Write|InodeMetaMod
+// ~ $ rm file # Remove|Write|InodeMetaMod -> Remove
+//
+func (w *watch) strip(base string, set uint32) uint32 {
+ const (
+ write = FSEventsModified | FSEventsInodeMetaMod
+ both = FSEventsCreated | FSEventsRemoved
+ )
+ switch w.prev[base] {
+ case FSEventsCreated:
+ set &^= FSEventsCreated
+ if set&FSEventsRemoved != 0 {
+ w.prev[base] = FSEventsRemoved
+ set &^= write
+ }
+ case FSEventsRemoved:
+ set &^= FSEventsRemoved
+ if set&FSEventsCreated != 0 {
+ w.prev[base] = FSEventsCreated
+ }
+ default:
+ switch set & both {
+ case FSEventsCreated:
+ w.prev[base] = FSEventsCreated
+ case FSEventsRemoved:
+ w.prev[base] = FSEventsRemoved
+ set &^= write
+ }
+ }
+ dbgprintf("split()=%v\n", Event(set))
+ return set
+}
+
+// Dispatch is a stream function which forwards given file events for the watched
+// path to underlying FileInfo channel.
+func (w *watch) Dispatch(ev []FSEvent) {
+ events := atomic.LoadUint32(&w.events)
+ isrec := (atomic.LoadInt32(&w.isrec) == 1)
+ for i := range ev {
+ if ev[i].Flags&FSEventsHistoryDone != 0 {
+ w.flushed = true
+ continue
+ }
+ if !w.flushed {
+ continue
+ }
+ dbgprintf("%v (0x%x) (%s, i=%d, ID=%d, len=%d)\n", Event(ev[i].Flags),
+ ev[i].Flags, ev[i].Path, i, ev[i].ID, len(ev))
+ if ev[i].Flags&failure != 0 {
+ // TODO(rjeczalik): missing error handling
+ panic("unhandled error: " + Event(ev[i].Flags).String())
+ }
+ if !strings.HasPrefix(ev[i].Path, w.path) {
+ continue
+ }
+ n := len(w.path)
+ base := ""
+ if len(ev[i].Path) > n {
+ if ev[i].Path[n] != '/' {
+ continue
+ }
+ base = ev[i].Path[n+1:]
+ if !isrec && strings.IndexByte(base, '/') != -1 {
+ continue
+ }
+ }
+ // TODO(rjeczalik): get diff only from filtered events?
+ e := w.strip(string(base), ev[i].Flags) & events
+ if e == 0 {
+ continue
+ }
+ for _, e := range splitflags(e) {
+ dbgprintf("%d: single event: %v", ev[i].ID, Event(e))
+ w.c <- &event{
+ fse: ev[i],
+ event: Event(e),
+ }
+ }
+ }
+}
+
+// Stop closes underlying FSEvents stream and stops dispatching events.
+func (w *watch) Stop() {
+ w.stream.Stop()
+ // TODO(rjeczalik): make (*stream).Stop flush synchronously undelivered events,
+ // so the following hack can be removed. It should flush all the streams
+ // concurrently as we care not to block too much here.
+ atomic.StoreUint32(&w.events, 0)
+ atomic.StoreInt32(&w.isrec, 0)
+}
+
+// fsevents implements Watcher and RecursiveWatcher interfaces backed by FSEvents
+// framework.
+type fsevents struct {
+ watches map[string]*watch
+ c chan<- EventInfo
+}
+
+func newWatcher(c chan<- EventInfo) watcher {
+ return &fsevents{
+ watches: make(map[string]*watch),
+ c: c,
+ }
+}
+
+func (fse *fsevents) watch(path string, event Event, isrec int32) (err error) {
+ if path, err = canonical(path); err != nil {
+ return err
+ }
+ if _, ok := fse.watches[path]; ok {
+ return errAlreadyWatched
+ }
+ w := &watch{
+ prev: make(map[string]uint32),
+ c: fse.c,
+ path: path,
+ events: uint32(event),
+ isrec: isrec,
+ }
+ w.stream = newStream(path, w.Dispatch)
+ if err = w.stream.Start(); err != nil {
+ return err
+ }
+ fse.watches[path] = w
+ return nil
+}
+
+func (fse *fsevents) unwatch(path string) (err error) {
+ if path, err = canonical(path); err != nil {
+ return
+ }
+ w, ok := fse.watches[path]
+ if !ok {
+ return errNotWatched
+ }
+ w.stream.Stop()
+ delete(fse.watches, path)
+ return nil
+}
+
+// Watch implements Watcher interface. It fails with non-nil error when setting
+// the watch-point by FSEvents fails or with errAlreadyWatched error when
+// the given path is already watched.
+func (fse *fsevents) Watch(path string, event Event) error {
+ return fse.watch(path, event, 0)
+}
+
+// Unwatch implements Watcher interface. It fails with errNotWatched when
+// the given path is not being watched.
+func (fse *fsevents) Unwatch(path string) error {
+ return fse.unwatch(path)
+}
+
+// Rewatch implements Watcher interface. It fails with errNotWatched when
+// the given path is not being watched or with errInvalidEventSet when oldevent
+// does not match event set the watch-point currently holds.
+func (fse *fsevents) Rewatch(path string, oldevent, newevent Event) error {
+ w, ok := fse.watches[path]
+ if !ok {
+ return errNotWatched
+ }
+ if !atomic.CompareAndSwapUint32(&w.events, uint32(oldevent), uint32(newevent)) {
+ return errInvalidEventSet
+ }
+ atomic.StoreInt32(&w.isrec, 0)
+ return nil
+}
+
+// RecursiveWatch implements RecursiveWatcher interface. It fails with non-nil
+// error when setting the watch-point by FSEvents fails or with errAlreadyWatched
+// error when the given path is already watched.
+func (fse *fsevents) RecursiveWatch(path string, event Event) error {
+ return fse.watch(path, event, 1)
+}
+
+// RecursiveUnwatch implements RecursiveWatcher interface. It fails with
+// errNotWatched when the given path is not being watched.
+//
+// TODO(rjeczalik): fail if w.isrec == 0?
+func (fse *fsevents) RecursiveUnwatch(path string) error {
+ return fse.unwatch(path)
+}
+
+// RecrusiveRewatch implements RecursiveWatcher interface. It fails:
+//
+// * with errNotWatched when the given path is not being watched
+// * with errInvalidEventSet when oldevent does not match the current event set
+// * with errAlreadyWatched when watch-point given by the oldpath was meant to
+// be relocated to newpath, but the newpath is already watched
+// * a non-nil error when setting the watch-point with FSEvents fails
+//
+// TODO(rjeczalik): Improve handling of watch-point relocation? See two TODOs
+// that follows.
+func (fse *fsevents) RecursiveRewatch(oldpath, newpath string, oldevent, newevent Event) error {
+ switch [2]bool{oldpath == newpath, oldevent == newevent} {
+ case [2]bool{true, true}:
+ w, ok := fse.watches[oldpath]
+ if !ok {
+ return errNotWatched
+ }
+ atomic.StoreInt32(&w.isrec, 1)
+ return nil
+ case [2]bool{true, false}:
+ w, ok := fse.watches[oldpath]
+ if !ok {
+ return errNotWatched
+ }
+ if !atomic.CompareAndSwapUint32(&w.events, uint32(oldevent), uint32(newevent)) {
+ return errors.New("invalid event state diff")
+ }
+ atomic.StoreInt32(&w.isrec, 1)
+ return nil
+ default:
+ // TODO(rjeczalik): rewatch newpath only if exists?
+ // TODO(rjeczalik): migrate w.prev to new watch?
+ if _, ok := fse.watches[newpath]; ok {
+ return errAlreadyWatched
+ }
+ if err := fse.Unwatch(oldpath); err != nil {
+ return err
+ }
+ // TODO(rjeczalik): revert unwatch if watch fails?
+ return fse.watch(newpath, newevent, 1)
+ }
+}
+
+// Close unwatches all watch-points.
+func (fse *fsevents) Close() error {
+ for _, w := range fse.watches {
+ w.Stop()
+ }
+ fse.watches = nil
+ return nil
+}
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/watcher_fsevents_cgo.go b/Godeps/_workspace/src/github.com/zillode/notify/watcher_fsevents_cgo.go
new file mode 100644
index 0000000..c88819e
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/watcher_fsevents_cgo.go
@@ -0,0 +1,156 @@
+// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+// +build darwin,!kqueue
+
+package notify
+
+// #include <CoreServices/CoreServices.h>
+//
+// typedef void (*CFRunLoopPerformCallBack)(void*);
+//
+// void gosource(void *);
+// void gostream(void*, void*, size_t, uintptr_t, uintptr_t, uintptr_t);
+//
+// #cgo LDFLAGS: -framework CoreServices
+import "C"
+
+import (
+ "errors"
+ "os"
+ "sync"
+ "sync/atomic"
+ "time"
+ "unsafe"
+)
+
+var nilstream C.FSEventStreamRef
+
+// Default arguments for FSEventStreamCreate function.
+var (
+ latency C.CFTimeInterval
+ flags = C.FSEventStreamCreateFlags(C.kFSEventStreamCreateFlagFileEvents | C.kFSEventStreamCreateFlagNoDefer)
+ since = uint64(C.FSEventsGetCurrentEventId())
+)
+
+var runloop C.CFRunLoopRef // global runloop which all streams are registered with
+var wg sync.WaitGroup // used to wait until the runloop starts
+
+// source is used for synchronization purposes - it signals when runloop has
+// started and is ready via the wg. It also serves purpose of a dummy source,
+// thanks to it the runloop does not return as it also has at least one source
+// registered.
+var source = C.CFRunLoopSourceCreate(nil, 0, &C.CFRunLoopSourceContext{
+ perform: (C.CFRunLoopPerformCallBack)(C.gosource),
+})
+
+// Errors returned when FSEvents functions fail.
+var (
+ errCreate = os.NewSyscallError("FSEventStreamCreate", errors.New("NULL"))
+ errStart = os.NewSyscallError("FSEventStreamStart", errors.New("false"))
+)
+
+// initializes the global runloop and ensures any created stream awaits its
+// readiness.
+func init() {
+ wg.Add(1)
+ go func() {
+ runloop = C.CFRunLoopGetCurrent()
+ C.CFRunLoopAddSource(runloop, source, C.kCFRunLoopDefaultMode)
+ C.CFRunLoopRun()
+ panic("runloop has just unexpectedly stopped")
+ }()
+ C.CFRunLoopSourceSignal(source)
+}
+
+//export gosource
+func gosource(unsafe.Pointer) {
+ time.Sleep(time.Second)
+ wg.Done()
+}
+
+//export gostream
+func gostream(_, ctx unsafe.Pointer, n C.size_t, paths, flags, ids uintptr) {
+ const (
+ offchar = unsafe.Sizeof((*C.char)(nil))
+ offflag = unsafe.Sizeof(C.FSEventStreamEventFlags(0))
+ offid = unsafe.Sizeof(C.FSEventStreamEventId(0))
+ )
+ if n == 0 {
+ return
+ }
+ ev := make([]FSEvent, 0, int(n))
+ for i := uintptr(0); i < uintptr(n); i++ {
+ switch flags := *(*uint32)(unsafe.Pointer((flags + i*offflag))); {
+ case flags&uint32(FSEventsEventIdsWrapped) != 0:
+ atomic.StoreUint64(&since, uint64(C.FSEventsGetCurrentEventId()))
+ default:
+ ev = append(ev, FSEvent{
+ Path: C.GoString(*(**C.char)(unsafe.Pointer(paths + i*offchar))),
+ Flags: flags,
+ ID: *(*uint64)(unsafe.Pointer(ids + i*offid)),
+ })
+ }
+
+ }
+ (*(*streamFunc)(ctx))(ev)
+}
+
+// StreamFunc is a callback called when stream receives file events.
+type streamFunc func([]FSEvent)
+
+// Stream represents single watch-point which listens for events scheduled by
+// the global runloop.
+type stream struct {
+ path string
+ ref C.FSEventStreamRef
+ ctx C.FSEventStreamContext
+}
+
+// NewStream creates a stream for given path, listening for file events and
+// calling fn upon receving any.
+func newStream(path string, fn streamFunc) *stream {
+ return &stream{
+ path: path,
+ ctx: C.FSEventStreamContext{
+ info: unsafe.Pointer(&fn),
+ },
+ }
+}
+
+// Start creates a FSEventStream for the given path and schedules it with
+// global runloop. It's a nop if the stream was already started.
+func (s *stream) Start() error {
+ if s.ref != nilstream {
+ return nil
+ }
+ wg.Wait()
+ p := C.CFStringCreateWithCStringNoCopy(nil, C.CString(s.path), C.kCFStringEncodingUTF8, nil)
+ path := C.CFArrayCreate(nil, (*unsafe.Pointer)(unsafe.Pointer(&p)), 1, nil)
+ ref := C.FSEventStreamCreate(nil, (C.FSEventStreamCallback)(C.gostream),
+ &s.ctx, path, C.FSEventStreamEventId(atomic.LoadUint64(&since)), latency, flags)
+ if ref == nilstream {
+ return errCreate
+ }
+ C.FSEventStreamScheduleWithRunLoop(ref, runloop, C.kCFRunLoopDefaultMode)
+ if C.FSEventStreamStart(ref) == C.Boolean(0) {
+ C.FSEventStreamInvalidate(ref)
+ return errStart
+ }
+ C.CFRunLoopWakeUp(runloop)
+ s.ref = ref
+ return nil
+}
+
+// Stop stops underlying FSEventStream and unregisters it from global runloop.
+func (s *stream) Stop() {
+ if s.ref == nilstream {
+ return
+ }
+ wg.Wait()
+ C.FSEventStreamStop(s.ref)
+ C.FSEventStreamInvalidate(s.ref)
+ C.CFRunLoopWakeUp(runloop)
+ s.ref = nilstream
+}
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/watcher_fsevents_test.go b/Godeps/_workspace/src/github.com/zillode/notify/watcher_fsevents_test.go
new file mode 100644
index 0000000..1d60877
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/watcher_fsevents_test.go
@@ -0,0 +1,111 @@
+// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+// +build darwin,!kqueue
+
+package notify
+
+import (
+ "reflect"
+ "testing"
+)
+
+func TestSplitflags(t *testing.T) {
+ cases := [...]struct {
+ set uint32
+ flags []uint32
+ }{
+ {0, nil},
+ {0xD, []uint32{0x1, 0x4, 0x8}},
+ {0x0010 | 0x0040 | 0x0080 | 0x01000, []uint32{0x0010, 0x0040, 0x0080, 0x01000}},
+ {0x40000 | 0x00100 | 0x00200, []uint32{0x00100, 0x00200, 0x40000}},
+ }
+ for i, cas := range cases {
+ if flags := splitflags(cas.set); !reflect.DeepEqual(flags, cas.flags) {
+ t.Errorf("want flags=%v; got %v (i=%d)", cas.flags, flags, i)
+ }
+ }
+}
+
+func TestWatchStrip(t *testing.T) {
+ const (
+ create = uint32(FSEventsCreated)
+ remove = uint32(FSEventsRemoved)
+ rename = uint32(FSEventsRenamed)
+ write = uint32(FSEventsModified)
+ inode = uint32(FSEventsInodeMetaMod)
+ owner = uint32(FSEventsChangeOwner)
+ )
+ cases := [...][]struct {
+ path string
+ flag uint32
+ diff uint32
+ }{
+ // 1.
+ {
+ {"file", create | write, create | write},
+ {"file", create | write | inode, write | inode},
+ },
+ // 2.
+ {
+ {"file", create, create},
+ {"file", create | remove, remove},
+ {"file", create | remove, create},
+ },
+ // 3.
+ {
+ {"file", create | write, create | write},
+ {"file", create | write | owner, write | owner},
+ },
+ // 4.
+ {
+ {"file", create | write, create | write},
+ {"file", write | inode, write | inode},
+ {"file", remove | write | inode, remove},
+ },
+ {
+ {"file", remove | write | inode, remove},
+ },
+ }
+Test:
+ for i, cas := range cases {
+ if len(cas) == 0 {
+ t.Log("skipped")
+ continue
+ }
+ w := &watch{prev: make(map[string]uint32)}
+ for j, cas := range cas {
+ if diff := w.strip(cas.path, cas.flag); diff != cas.diff {
+ t.Errorf("want diff=%v; got %v (i=%d, j=%d)", Event(cas.diff),
+ Event(diff), i, j)
+ continue Test
+ }
+ }
+ }
+}
+
+// Test for cases 3) and 5) with shadowed write&create events.
+//
+// See comment for (flagdiff).diff method.
+func TestWatcherShadowedWriteCreate(t *testing.T) {
+ w := NewWatcherTest(t, "testdata/vfs.txt")
+ defer w.Close()
+
+ cases := [...]WCase{
+ // i=0
+ create(w, "src/github.com/rjeczalik/fs/.fs.go.swp"),
+ // i=1
+ write(w, "src/github.com/rjeczalik/fs/.fs.go.swp", []byte("XD")),
+ // i=2
+ write(w, "src/github.com/rjeczalik/fs/.fs.go.swp", []byte("XD")),
+ // i=3
+ remove(w, "src/github.com/rjeczalik/fs/.fs.go.swp"),
+ // i=4
+ create(w, "src/github.com/rjeczalik/fs/.fs.go.swp"),
+ // i=5
+ write(w, "src/github.com/rjeczalik/fs/.fs.go.swp", []byte("XD")),
+ }
+
+ w.ExpectAny(cases[:5]) // BUG(rjeczalik): #62
+}
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/watcher_inotify.go b/Godeps/_workspace/src/github.com/zillode/notify/watcher_inotify.go
new file mode 100644
index 0000000..8c0c27b
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/watcher_inotify.go
@@ -0,0 +1,396 @@
+// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+// +build linux
+
+package notify
+
+import (
+ "bytes"
+ "errors"
+ "path/filepath"
+ "runtime"
+ "sync"
+ "sync/atomic"
+ "syscall"
+ "unsafe"
+)
+
+// eventBufferSize defines the size of the buffer given to read(2) function. One
+// should not depend on this value, since it was arbitrary chosen and may be
+// changed in the future.
+const eventBufferSize = 64 * (syscall.SizeofInotifyEvent + syscall.PathMax + 1)
+
+// consumersCount defines the number of consumers in producer-consumer based
+// implementation. Each consumer is run in a separate goroutine and has read
+// access to watched files map.
+const consumersCount = 2
+
+const invalidDescriptor = -1
+
+// watched is a pair of file path and inotify mask used as a value in
+// watched files map.
+type watched struct {
+ path string
+ mask uint32
+}
+
+// inotify implements Watcher interface.
+type inotify struct {
+ sync.RWMutex // protects inotify.m map
+ m map[int32]*watched // watch descriptor to watched object
+ fd int32 // inotify file descriptor
+ pipefd []int // pipe's read and write descriptors
+ epfd int // epoll descriptor
+ epes []syscall.EpollEvent // epoll events
+ buffer [eventBufferSize]byte // inotify event buffer
+ wg sync.WaitGroup // wait group used to close main loop
+ c chan<- EventInfo // event dispatcher channel
+}
+
+// NewWatcher creates new non-recursive inotify backed by inotify.
+func newWatcher(c chan<- EventInfo) watcher {
+ i := &inotify{
+ m: make(map[int32]*watched),
+ fd: invalidDescriptor,
+ pipefd: []int{invalidDescriptor, invalidDescriptor},
+ epfd: invalidDescriptor,
+ epes: make([]syscall.EpollEvent, 0),
+ c: c,
+ }
+ runtime.SetFinalizer(i, func(i *inotify) {
+ i.epollclose()
+ if i.fd != invalidDescriptor {
+ syscall.Close(int(i.fd))
+ }
+ })
+ return i
+}
+
+// Watch implements notify.watcher interface.
+func (i *inotify) Watch(path string, e Event) error {
+ return i.watch(path, e)
+}
+
+// Rewatch implements notify.watcher interface.
+func (i *inotify) Rewatch(path string, _, newevent Event) error {
+ return i.watch(path, newevent)
+}
+
+// watch adds a new watcher to the set of watched objects or modifies the existing
+// one. If called for the first time, this function initializes inotify filesystem
+// monitor and starts producer-consumers goroutines.
+func (i *inotify) watch(path string, e Event) (err error) {
+ if e&^(All|Event(syscall.IN_ALL_EVENTS)) != 0 {
+ return errors.New("notify: unknown event")
+ }
+ if err = i.lazyinit(); err != nil {
+ return
+ }
+ iwd, err := syscall.InotifyAddWatch(int(i.fd), path, encode(e))
+ if err != nil {
+ return
+ }
+ i.RLock()
+ wd := i.m[int32(iwd)]
+ i.RUnlock()
+ if wd == nil {
+ i.Lock()
+ if i.m[int32(iwd)] == nil {
+ i.m[int32(iwd)] = &watched{path: path, mask: uint32(e)}
+ }
+ i.Unlock()
+ } else {
+ i.Lock()
+ wd.mask = uint32(e)
+ i.Unlock()
+ }
+ return nil
+}
+
+// lazyinit sets up all required file descriptors and starts 1+consumersCount
+// goroutines. The producer goroutine blocks until file-system notifications
+// occur. Then, all events are read from system buffer and sent to consumer
+// goroutines which construct valid notify events. This method uses
+// Double-Checked Locking optimization.
+func (i *inotify) lazyinit() error {
+ if atomic.LoadInt32(&i.fd) == invalidDescriptor {
+ i.Lock()
+ defer i.Unlock()
+ if atomic.LoadInt32(&i.fd) == invalidDescriptor {
+ fd, err := syscall.InotifyInit()
+ if err != nil {
+ return err
+ }
+ i.fd = int32(fd)
+ if err = i.epollinit(); err != nil {
+ _, _ = i.epollclose(), syscall.Close(int(fd)) // Ignore errors.
+ i.fd = invalidDescriptor
+ return err
+ }
+ esch := make(chan []*event)
+ go i.loop(esch)
+ i.wg.Add(consumersCount)
+ for n := 0; n < consumersCount; n++ {
+ go i.send(esch)
+ }
+ }
+ }
+ return nil
+}
+
+// epollinit opens an epoll file descriptor and creates a pipe which will be
+// used to wake up the epoll_wait(2) function. Then, file descriptor associated
+// with inotify event queue and the read end of the pipe are added to epoll set.
+// Note that `fd` member must be set before this function is called.
+func (i *inotify) epollinit() (err error) {
+ if i.epfd, err = syscall.EpollCreate(2); err != nil {
+ return
+ }
+ if err = syscall.Pipe(i.pipefd); err != nil {
+ return
+ }
+ i.epes = []syscall.EpollEvent{
+ {Events: syscall.EPOLLIN, Fd: i.fd},
+ {Events: syscall.EPOLLIN, Fd: int32(i.pipefd[0])},
+ }
+ if err = syscall.EpollCtl(i.epfd, syscall.EPOLL_CTL_ADD, int(i.fd), &i.epes[0]); err != nil {
+ return
+ }
+ return syscall.EpollCtl(i.epfd, syscall.EPOLL_CTL_ADD, i.pipefd[0], &i.epes[1])
+}
+
+// epollclose closes the file descriptor created by the call to epoll_create(2)
+// and two file descriptors opened by pipe(2) function.
+func (i *inotify) epollclose() (err error) {
+ if i.epfd != invalidDescriptor {
+ if err = syscall.Close(i.epfd); err == nil {
+ i.epfd = invalidDescriptor
+ }
+ }
+ for n, fd := range i.pipefd {
+ if fd != invalidDescriptor {
+ switch e := syscall.Close(fd); {
+ case e != nil && err == nil:
+ err = e
+ case e == nil:
+ i.pipefd[n] = invalidDescriptor
+ }
+ }
+ }
+ return
+}
+
+// loop blocks until either inotify or pipe file descriptor is ready for I/O.
+// All read operations triggered by filesystem notifications are forwarded to
+// one of the event's consumers. If pipe fd became ready, loop function closes
+// all file descriptors opened by lazyinit method and returns afterwards.
+func (i *inotify) loop(esch chan<- []*event) {
+ epes := make([]syscall.EpollEvent, 1)
+ fd := atomic.LoadInt32(&i.fd)
+ for {
+ switch _, err := syscall.EpollWait(i.epfd, epes, -1); err {
+ case nil:
+ switch epes[0].Fd {
+ case fd:
+ esch <- i.read()
+ epes[0].Fd = 0
+ case int32(i.pipefd[0]):
+ i.Lock()
+ defer i.Unlock()
+ if err = syscall.Close(int(fd)); err != nil && err != syscall.EINTR {
+ panic("notify: close(2) error " + err.Error())
+ }
+ atomic.StoreInt32(&i.fd, invalidDescriptor)
+ if err = i.epollclose(); err != nil && err != syscall.EINTR {
+ panic("notify: epollclose error " + err.Error())
+ }
+ close(esch)
+ return
+ }
+ case syscall.EINTR:
+ continue
+ default: // We should never reach this line.
+ panic("notify: epoll_wait(2) error " + err.Error())
+ }
+ }
+}
+
+// read reads events from an inotify file descriptor. It does not handle errors
+// returned from read(2) function since they are not critical to watcher logic.
+func (i *inotify) read() (es []*event) {
+ n, err := syscall.Read(int(i.fd), i.buffer[:])
+ if err != nil || n < syscall.SizeofInotifyEvent {
+ return
+ }
+ var sys *syscall.InotifyEvent
+ nmin := n - syscall.SizeofInotifyEvent
+ for pos, path := 0, ""; pos <= nmin; {
+ sys = (*syscall.InotifyEvent)(unsafe.Pointer(&i.buffer[pos]))
+ pos += syscall.SizeofInotifyEvent
+ if path = ""; sys.Len > 0 {
+ endpos := pos + int(sys.Len)
+ path = string(bytes.TrimRight(i.buffer[pos:endpos], "\x00"))
+ pos = endpos
+ }
+ es = append(es, &event{
+ sys: syscall.InotifyEvent{
+ Wd: sys.Wd,
+ Mask: sys.Mask,
+ Cookie: sys.Cookie,
+ },
+ path: path,
+ })
+ }
+ return
+}
+
+// send is a consumer function which sends events to event dispatcher channel.
+// It is run in a separate goroutine in order to not block loop method when
+// possibly expensive write operations are performed on inotify map.
+func (i *inotify) send(esch <-chan []*event) {
+ for es := range esch {
+ for _, e := range i.transform(es) {
+ if e != nil {
+ i.c <- e
+ }
+ }
+ }
+ i.wg.Done()
+}
+
+// transform prepares events read from inotify file descriptor for sending to
+// user. It removes invalid events and these which are no longer present in
+// inotify map. This method may also split one raw event into two different ones
+// when system-dependent result is required.
+func (i *inotify) transform(es []*event) []*event {
+ var multi []*event
+ i.RLock()
+ for idx, e := range es {
+ if e.sys.Mask&(syscall.IN_IGNORED|syscall.IN_Q_OVERFLOW) != 0 {
+ es[idx] = nil
+ continue
+ }
+ wd, ok := i.m[e.sys.Wd]
+ if !ok || e.sys.Mask&encode(Event(wd.mask)) == 0 {
+ es[idx] = nil
+ continue
+ }
+ if e.path == "" {
+ e.path = wd.path
+ } else {
+ e.path = filepath.Join(wd.path, e.path)
+ }
+ multi = append(multi, decode(Event(wd.mask), e))
+ if e.event == 0 {
+ es[idx] = nil
+ }
+ }
+ i.RUnlock()
+ es = append(es, multi...)
+ return es
+}
+
+// encode converts notify system-independent events to valid inotify mask
+// which can be passed to inotify_add_watch(2) function.
+func encode(e Event) uint32 {
+ if e&Create != 0 {
+ e = (e ^ Create) | InCreate | InMovedTo
+ }
+ if e&Remove != 0 {
+ e = (e ^ Remove) | InDelete | InDeleteSelf
+ }
+ if e&Write != 0 {
+ e = (e ^ Write) | InModify
+ }
+ if e&Rename != 0 {
+ e = (e ^ Rename) | InMovedFrom | InMoveSelf
+ }
+ return uint32(e)
+}
+
+// decode uses internally stored mask to distinguish whether system-independent
+// or system-dependent event is requested. The first one is created by modifying
+// `e` argument. decode method sets e.event value to 0 when an event should be
+// skipped. System-dependent event is set as the function's return value which
+// can be nil when the event should not be passed on.
+func decode(mask Event, e *event) (syse *event) {
+ if sysmask := uint32(mask) & e.sys.Mask; sysmask != 0 {
+ syse = &event{sys: syscall.InotifyEvent{
+ Wd: e.sys.Wd,
+ Mask: e.sys.Mask,
+ Cookie: e.sys.Cookie,
+ }, event: Event(sysmask), path: e.path}
+ }
+ imask := encode(mask)
+ switch {
+ case mask&Create != 0 && imask&uint32(InCreate|InMovedTo)&e.sys.Mask != 0:
+ e.event = Create
+ case mask&Remove != 0 && imask&uint32(InDelete|InDeleteSelf)&e.sys.Mask != 0:
+ e.event = Remove
+ case mask&Write != 0 && imask&uint32(InModify)&e.sys.Mask != 0:
+ e.event = Write
+ case mask&Rename != 0 && imask&uint32(InMovedFrom|InMoveSelf)&e.sys.Mask != 0:
+ e.event = Rename
+ default:
+ e.event = 0
+ }
+ return
+}
+
+// Unwatch implements notify.watcher interface. It looks for watch descriptor
+// related to registered path and if found, calls inotify_rm_watch(2) function.
+// This method is allowed to return EINVAL error when concurrently requested to
+// delete identical path.
+func (i *inotify) Unwatch(path string) (err error) {
+ iwd := int32(invalidDescriptor)
+ i.RLock()
+ for iwdkey, wd := range i.m {
+ if wd.path == path {
+ iwd = iwdkey
+ break
+ }
+ }
+ i.RUnlock()
+ if iwd == invalidDescriptor {
+ return errors.New("notify: path " + path + " is already watched")
+ }
+ fd := atomic.LoadInt32(&i.fd)
+ if _, err = syscall.InotifyRmWatch(int(fd), uint32(iwd)); err != nil {
+ return
+ }
+ i.Lock()
+ delete(i.m, iwd)
+ i.Unlock()
+ return nil
+}
+
+// Close implements notify.watcher interface. It removes all existing watch
+// descriptors and wakes up producer goroutine by sending data to the write end
+// of the pipe. The function waits for a signal from producer which means that
+// all operations on current monitoring instance are done.
+func (i *inotify) Close() (err error) {
+ i.Lock()
+ if fd := atomic.LoadInt32(&i.fd); fd == invalidDescriptor {
+ i.Unlock()
+ return nil
+ }
+ for iwd := range i.m {
+ if _, e := syscall.InotifyRmWatch(int(i.fd), uint32(iwd)); e != nil && err == nil {
+ err = e
+ }
+ delete(i.m, iwd)
+ }
+ switch _, errwrite := syscall.Write(i.pipefd[1], []byte{0x00}); {
+ case errwrite != nil && err == nil:
+ err = errwrite
+ fallthrough
+ case errwrite != nil:
+ i.Unlock()
+ default:
+ i.Unlock()
+ i.wg.Wait()
+ }
+ return
+}
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/watcher_inotify_test.go b/Godeps/_workspace/src/github.com/zillode/notify/watcher_inotify_test.go
new file mode 100644
index 0000000..5feadaf
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/watcher_inotify_test.go
@@ -0,0 +1,132 @@
+// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+// +build linux
+
+package notify
+
+import (
+ "os"
+ "path/filepath"
+ "testing"
+)
+
+func icreate(w *W, path string) WCase {
+ cas := create(w, path)
+ cas.Events = append(cas.Events,
+ &Call{P: path, E: InCreate},
+ )
+ return cas
+}
+
+func iremove(w *W, path string) WCase {
+ cas := remove(w, path)
+ cas.Events = append(cas.Events,
+ &Call{P: path, E: InDelete},
+ )
+ return cas
+}
+
+func iopen(w *W, path string) WCase {
+ return WCase{
+ Action: func() {
+ f, err := os.OpenFile(filepath.Join(w.root, path), os.O_RDWR, 0644)
+ if err != nil {
+ w.Fatalf("OpenFile(%q)=%v", path, err)
+ }
+ if err := f.Close(); err != nil {
+ w.Fatalf("Close(%q)=%v", path, err)
+ }
+ },
+ Events: []EventInfo{
+ &Call{P: path, E: InAccess},
+ &Call{P: path, E: InOpen},
+ &Call{P: path, E: InCloseNowrite},
+ },
+ }
+}
+
+func iread(w *W, path string, p []byte) WCase {
+ return WCase{
+ Action: func() {
+ f, err := os.OpenFile(filepath.Join(w.root, path), os.O_RDWR, 0644)
+ if err != nil {
+ w.Fatalf("OpenFile(%q)=%v", path, err)
+ }
+ if _, err := f.Read(p); err != nil {
+ w.Fatalf("Read(%q)=%v", path, err)
+ }
+ if err := f.Close(); err != nil {
+ w.Fatalf("Close(%q)=%v", path, err)
+ }
+ },
+ Events: []EventInfo{
+ &Call{P: path, E: InAccess},
+ &Call{P: path, E: InOpen},
+ &Call{P: path, E: InModify},
+ &Call{P: path, E: InCloseNowrite},
+ },
+ }
+}
+
+func iwrite(w *W, path string, p []byte) WCase {
+ cas := write(w, path, p)
+ path = cas.Events[0].Path()
+ cas.Events = append(cas.Events,
+ &Call{P: path, E: InAccess},
+ &Call{P: path, E: InOpen},
+ &Call{P: path, E: InModify},
+ &Call{P: path, E: InCloseWrite},
+ )
+ return cas
+}
+
+func irename(w *W, path string) WCase {
+ const ext = ".notify"
+ return WCase{
+ Action: func() {
+ file := filepath.Join(w.root, path)
+ if err := os.Rename(file, file+ext); err != nil {
+ w.Fatalf("Rename(%q, %q)=%v", path, path+ext, err)
+ }
+ },
+ Events: []EventInfo{
+ &Call{P: path, E: InMovedFrom},
+ &Call{P: path + ext, E: InMovedTo},
+ &Call{P: path, E: InOpen},
+ &Call{P: path, E: InAccess},
+ &Call{P: path, E: InCreate},
+ },
+ }
+}
+
+var events = []Event{
+ InAccess,
+ InModify,
+ InAttrib,
+ InCloseWrite,
+ InCloseNowrite,
+ InOpen,
+ InMovedFrom,
+ InMovedTo,
+ InCreate,
+ InDelete,
+ InDeleteSelf,
+ InMoveSelf,
+}
+
+func TestWatcherInotify(t *testing.T) {
+ w := NewWatcherTest(t, "testdata/vfs.txt", events...)
+ defer w.Close()
+
+ cases := [...]WCase{
+ iopen(w, "src/github.com/rjeczalik/fs/fs.go"),
+ iwrite(w, "src/github.com/rjeczalik/fs/fs.go", []byte("XD")),
+ iread(w, "src/github.com/rjeczalik/fs/fs.go", []byte("XD")),
+ iremove(w, "src/github.com/ppknap/link/README.md"),
+ irename(w, "src/github.com/rjeczalik/fs/LICENSE"),
+ }
+
+ w.ExpectAny(cases[:])
+}
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/watcher_kqueue.go b/Godeps/_workspace/src/github.com/zillode/notify/watcher_kqueue.go
new file mode 100644
index 0000000..e7e2e4d
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/watcher_kqueue.go
@@ -0,0 +1,413 @@
+// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+// +build darwin,kqueue dragonfly freebsd netbsd openbsd
+
+package notify
+
+import (
+ "os"
+ "path/filepath"
+ "sync"
+ "syscall"
+)
+
+// newWatcher returns kqueue Watcher implementation.
+func newWatcher(c chan<- EventInfo) watcher {
+ k := &kqueue{
+ idLkp: make(map[int]*watched, 0),
+ pthLkp: make(map[string]*watched, 0),
+ c: c,
+ s: make(chan struct{}, 1),
+ }
+ if err := k.init(); err != nil {
+ panic(err)
+ }
+ go k.monitor()
+ return k
+}
+
+// Close closes all still open file descriptors and kqueue.
+func (k *kqueue) Close() (err error) {
+ // trigger event used to interrup Kevent call.
+ if _, err = syscall.Write(k.pipefds[1], []byte{0x00}); err != nil {
+ return
+ }
+ <-k.s
+ k.Lock()
+ var e error
+ for _, w := range k.idLkp {
+ if e = k.unwatch(w.p, w.fi); e != nil && err == nil {
+ dbgprintf("kqueue: unwatch %q failed: %q", w.p, e)
+ err = e
+ }
+ }
+ if e := error(syscall.Close(k.fd)); e != nil && err == nil {
+ dbgprintf("kqueue: closing kqueu fd failed: %q", e)
+ err = e
+ }
+ k.idLkp, k.pthLkp = nil, nil
+ k.Unlock()
+ return
+}
+
+// sendEvents sends reported events one by one through chan.
+func (k *kqueue) sendEvents(evn []event) {
+ for i := range evn {
+ k.c <- &evn[i]
+ }
+}
+
+// encode converts requested events to kqueue representation.
+func encode(e Event) (o uint32) {
+ o = uint32(e &^ Create)
+ if e&Write != 0 {
+ o = (o &^ uint32(Write)) | uint32(NoteWrite)
+ }
+ if e&Rename != 0 {
+ o = (o &^ uint32(Rename)) | uint32(NoteRename)
+ }
+ if e&Remove != 0 {
+ o = (o &^ uint32(Remove)) | uint32(NoteDelete)
+ }
+ return
+}
+
+// decode converts event received from kqueue to notify.Event
+// representation taking into account requested events (w).
+func decode(o uint32, w Event) (e Event) {
+ // TODO(someone) : fix me
+ if o&uint32(NoteWrite) != 0 {
+ if w&NoteWrite != 0 {
+ e |= NoteWrite
+ } else {
+ e |= Write
+ }
+ }
+ if o&uint32(NoteRename) != 0 {
+ if w&NoteRename != 0 {
+ e |= NoteRename
+ } else {
+ e |= Rename
+ }
+ }
+ if o&uint32(NoteDelete) != 0 {
+ if w&NoteDelete != 0 {
+ e |= NoteDelete
+ } else {
+ e |= Remove
+ }
+ }
+ e |= Event(o) & w
+ return
+}
+
+// del closes fd for watched and removes it from internal cache of monitored
+// files/directories.
+func (k *kqueue) del(w watched) {
+ syscall.Close(w.fd)
+ delete(k.idLkp, w.fd)
+ delete(k.pthLkp, w.p)
+}
+
+// monitor reads reported kqueue events and forwards them further after
+// performing additional processing. If read event concerns directory,
+// it generates Create/Remove event and sent them further instead of directory
+// event. This event is detected based on reading contents of analyzed
+// directory. If no changes in file list are detected, no event is send further.
+// Reading directory structure is less accurate than kqueue and can lead
+// to lack of detection of all events.
+func (k *kqueue) monitor() {
+ var (
+ kevn [1]syscall.Kevent_t
+ n int
+ err error
+ )
+ for {
+ kevn[0] = syscall.Kevent_t{}
+ switch n, err = syscall.Kevent(k.fd, nil, kevn[:], nil); {
+ case err == syscall.EINTR:
+ case err != nil:
+ dbgprintf("kqueue: failed to read events: %q\n", err)
+ case int(kevn[0].Ident) == k.pipefds[0]:
+ k.s <- struct{}{}
+ return
+ case n > 0:
+ k.sendEvents(k.process(kevn[0]))
+ }
+ }
+}
+
+func (k *kqueue) dir(w watched, kevn syscall.Kevent_t, e Event) (evn []event) {
+ // If it's dir and delete we have to send it and continue, because
+ // other processing relies on opening (in this case not existing) dir.
+ // Events for contents of this dir are reported by kqueue.
+ if (Event(kevn.Fflags) & NoteDelete) != 0 {
+ // Write is reported also for Remove on directory. Because of that
+ // we have to filter it out explicitly.
+ evn = append(evn, event{w.p,
+ e & ^Write & ^NoteWrite, Kevent{&kevn, w.fi}})
+ k.del(w)
+ return
+ }
+ if (Event(kevn.Fflags) & NoteWrite) != 0 {
+ switch err := k.walk(w.p, func(fi os.FileInfo) error {
+ p := filepath.Join(w.p, fi.Name())
+ switch err := k.singlewatch(p, w.eDir, false, fi); {
+ case os.IsNotExist(err) && ((w.eDir & Remove) != 0):
+ evn = append(evn, event{p, Remove, Kevent{nil, fi}})
+ case err == errAlreadyWatched:
+ case err != nil:
+ dbgprintf("kqueue: watching %q failed: %q", p, err)
+ case (w.eDir & Create) != 0:
+ evn = append(evn, event{p, Create, Kevent{nil, fi}})
+ }
+ return nil
+ }); {
+ // If file is already watched, kqueue will return remove event.
+ case os.IsNotExist(err):
+ return
+ case err != nil:
+ dbgprintf("kqueue: dir processing failed: %q", err)
+ default:
+ }
+ }
+ return
+}
+
+func (*kqueue) file(w watched, kevn syscall.Kevent_t, e Event) (evn []event) {
+ evn = append(evn, event{w.p, e, Kevent{&kevn, w.fi}})
+ return
+}
+
+// process event returned by Kevent call.
+func (k *kqueue) process(kevn syscall.Kevent_t) (evn []event) {
+ k.Lock()
+ w := k.idLkp[int(kevn.Ident)]
+ if w == nil {
+ k.Unlock()
+ dbgprintf("kqueue: %v event for not registered fd", kevn)
+ return
+ }
+ e := decode(kevn.Fflags, w.eDir|w.eNonDir)
+ if w.fi.IsDir() {
+ evn = k.dir(*w, kevn, e)
+ } else {
+ evn = k.file(*w, kevn, e)
+ }
+ if (Event(kevn.Fflags) & NoteDelete) != 0 {
+ k.del(*w)
+ }
+ k.Unlock()
+ return
+}
+
+// kqueue is a type holding data for kqueue watcher.
+type kqueue struct {
+ sync.Mutex
+ // fd is a kqueue file descriptor
+ fd int
+ // pipefds are file descriptors used to stop `Kevent` call.
+ pipefds [2]int
+ // idLkp is a data structure mapping file descriptors with data about watching
+ // represented by them files/directories.
+ idLkp map[int]*watched
+ // pthLkp is a data structure mapping file names with data about watching
+ // represented by them files/directories.
+ pthLkp map[string]*watched
+ // c is a channel used to pass events further.
+ c chan<- EventInfo
+ // s is a channel used to stop monitoring.
+ s chan struct{}
+}
+
+// watched is a data structure representing watched file/directory.
+type watched struct {
+ // p is a path to watched file/directory.
+ p string
+ // fd is a file descriptor for watched file/directory.
+ fd int
+ // fi provides information about watched file/dir.
+ fi os.FileInfo
+ // eDir represents events watched directly.
+ eDir Event
+ // eNonDir represents events watched indirectly.
+ eNonDir Event
+}
+
+// init initializes kqueue.
+func (k *kqueue) init() (err error) {
+ if k.fd, err = syscall.Kqueue(); err != nil {
+ return
+ }
+ // Creates pipe used to stop `Kevent` call by registering it,
+ // watching read end and writing to other end of it.
+ if err = syscall.Pipe(k.pipefds[:]); err != nil {
+ return
+ }
+ var kevn [1]syscall.Kevent_t
+ syscall.SetKevent(&kevn[0], k.pipefds[0], syscall.EVFILT_READ, syscall.EV_ADD)
+ _, err = syscall.Kevent(k.fd, kevn[:], nil, nil)
+ return
+}
+
+func (k *kqueue) watch(p string, e Event, fi os.FileInfo) error {
+ if err := k.singlewatch(p, e, true, fi); err != nil {
+ if err != errAlreadyWatched {
+ return nil
+ }
+ }
+ if fi.IsDir() {
+ err := k.walk(p, func(fi os.FileInfo) (err error) {
+ if err = k.singlewatch(filepath.Join(p, fi.Name()), e, false,
+ fi); err != nil {
+ if err != errAlreadyWatched {
+ return
+ }
+ }
+ return nil
+ })
+ if err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+// watch starts to watch given p file/directory.
+func (k *kqueue) singlewatch(p string, e Event, direct bool,
+ fi os.FileInfo) error {
+ w, ok := k.pthLkp[p]
+ if !ok {
+ fd, err := syscall.Open(p, syscall.O_NONBLOCK|syscall.O_RDONLY, 0)
+ if err != nil {
+ return err
+ }
+ w = &watched{fd: fd, p: p, fi: fi}
+ }
+ if direct {
+ w.eDir |= e
+ } else {
+ w.eNonDir |= e
+ }
+ var kevn [1]syscall.Kevent_t
+ syscall.SetKevent(&kevn[0], w.fd, syscall.EVFILT_VNODE,
+ syscall.EV_ADD|syscall.EV_CLEAR)
+ kevn[0].Fflags = encode(w.eDir | w.eNonDir)
+ if _, err := syscall.Kevent(k.fd, kevn[:], nil, nil); err != nil {
+ return err
+ }
+ if !ok {
+ k.idLkp[w.fd], k.pthLkp[w.p] = w, w
+ return nil
+ }
+ return errAlreadyWatched
+}
+
+// unwatch stops watching p file/directory.
+func (k *kqueue) singleunwatch(p string, direct bool) error {
+ w := k.pthLkp[p]
+ if w == nil {
+ return errNotWatched
+ }
+ if direct {
+ w.eDir = 0
+ } else {
+ w.eNonDir = 0
+ }
+ var kevn [1]syscall.Kevent_t
+ syscall.SetKevent(&kevn[0], w.fd, syscall.EVFILT_VNODE, syscall.EV_DELETE)
+ if _, err := syscall.Kevent(k.fd, kevn[:], nil, nil); err != nil {
+ return err
+ }
+ if w.eNonDir&w.eDir != 0 {
+ if err := k.singlewatch(p, w.eNonDir|w.eDir, w.eNonDir == 0,
+ w.fi); err != nil {
+ return err
+ }
+ } else {
+ k.del(*w)
+ }
+ return nil
+}
+
+// walk runs f func on each file/dir from p directory.
+func (k *kqueue) walk(p string, f func(os.FileInfo) error) error {
+ fp, err := os.Open(p)
+ if err != nil {
+ return err
+ }
+ ls, err := fp.Readdir(0)
+ fp.Close()
+ if err != nil {
+ return err
+ }
+ for i := range ls {
+ if err := f(ls[i]); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+func (k *kqueue) unwatch(p string, fi os.FileInfo) error {
+ if fi.IsDir() {
+ err := k.walk(p, func(fi os.FileInfo) error {
+ if !fi.IsDir() {
+ err := k.singleunwatch(filepath.Join(p, fi.Name()), false)
+ if err != errNotWatched {
+ return err
+ }
+ return nil
+ }
+ return nil
+ })
+ if err != nil {
+ return err
+ }
+ }
+ return k.singleunwatch(p, true)
+}
+
+// Watch implements Watcher interface.
+func (k *kqueue) Watch(p string, e Event) error {
+ fi, err := os.Stat(p)
+ if err != nil {
+ return err
+ }
+ k.Lock()
+ err = k.watch(p, e, fi)
+ k.Unlock()
+ return nil
+}
+
+// Unwatch implements Watcher interface.
+func (k *kqueue) Unwatch(p string) error {
+ fi, err := os.Stat(p)
+ if err != nil {
+ return err
+ }
+ k.Lock()
+ err = k.unwatch(p, fi)
+ k.Unlock()
+ return nil
+}
+
+// Rewatch implements Watcher interface.
+//
+// TODO(rjeczalik): This is a naive hack. Rewrite might help.
+func (k *kqueue) Rewatch(p string, _, e Event) error {
+ fi, err := os.Stat(p)
+ if err != nil {
+ return err
+ }
+ k.Lock()
+ if err = k.unwatch(p, fi); err == nil {
+ // TODO(rjeczalik): If watch fails then we leave kqueue in inconsistent
+ // state. Handle? Panic? Native version of rewatch?
+ err = k.watch(p, e, fi)
+ }
+ k.Unlock()
+ return nil
+}
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/watcher_kqueue_test.go b/Godeps/_workspace/src/github.com/zillode/notify/watcher_kqueue_test.go
new file mode 100644
index 0000000..b4a57e8
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/watcher_kqueue_test.go
@@ -0,0 +1,72 @@
+// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+// +build ignore
+
+// TODO(rjeczalik): rewrite with test_test.go
+
+package notify_test
+
+import (
+ "os"
+ "os/exec"
+ "testing"
+
+ "github.com/rjeczalik/notify"
+ "github.com/rjeczalik/notify/test"
+)
+
+var kqueueActions = test.Actions{
+ notify.NoteAttrib: func(p string) (err error) {
+ _, err = exec.Command("touch", p).CombinedOutput()
+ return
+ },
+ notify.NoteExtend: func(p string) (err error) {
+ //TODO: Extend and no Write
+ var f *os.File
+ if f, err = os.OpenFile(p, os.O_RDWR|os.O_APPEND, 0755); err != nil {
+ return
+ }
+ defer f.Close()
+ if _, err = f.WriteString(" "); err != nil {
+ return
+ }
+ return
+ },
+ notify.NoteLink: func(p string) error {
+ return os.Link(p, p+"link")
+ },
+ /*TODO: notify.NoteRevoke: func(p string) error {
+ if err := syscall.Revoke(p); err != nil {
+ fmt.Printf("this is the error %v\n", err)
+ return err
+ }
+ return nil
+ },*/
+}
+
+func ExpectKqueueEvents(t *testing.T, wr notify.watcher, e notify.Event,
+ ei map[notify.EventInfo][]notify.Event) {
+ w := test.W(t, kqueueActions)
+ defer w.Close()
+ if err := w.WatchAll(wr, e); err != nil {
+ t.Fatal(err)
+ }
+ defer w.UnwatchAll(wr)
+ w.ExpectEvents(wr, ei)
+}
+
+func TestKqueue(t *testing.T) {
+ ei := map[notify.EventInfo][]notify.Event{
+ test.EI("github.com/rjeczalik/fs/fs.go",
+ notify.NoteAttrib): {notify.NoteAttrib},
+ test.EI("github.com/rjeczalik/fs/fs.go",
+ notify.NoteExtend): {notify.NoteExtend | notify.NoteWrite},
+ test.EI("github.com/rjeczalik/fs/fs.go",
+ notify.NoteLink): {notify.NoteLink},
+ }
+ ExpectKqueueEvents(t, notify.NewWatcher(), notify.NoteDelete|
+ notify.NoteWrite|notify.NoteExtend|notify.NoteAttrib|notify.NoteLink|
+ notify.NoteRename|notify.NoteRevoke, ei)
+}
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/watcher_readdcw.go b/Godeps/_workspace/src/github.com/zillode/notify/watcher_readdcw.go
new file mode 100644
index 0000000..e8359bb
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/watcher_readdcw.go
@@ -0,0 +1,574 @@
+// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+// +build windows
+
+package notify
+
+import (
+ "errors"
+ "runtime"
+ "sync"
+ "sync/atomic"
+ "syscall"
+ "unsafe"
+)
+
+// readBufferSize defines the size of an array in which read statuses are stored.
+// The buffer have to be DWORD-aligned and, if notify is used in monitoring a
+// directory over the network, its size must not be greater than 64KB. Each of
+// watched directories uses its own buffer for storing events.
+const readBufferSize = 4096
+
+// Since all operations which go through the Windows completion routine are done
+// asynchronously, filter may set one of the constants belor. They were defined
+// in order to distinguish whether current folder should be re-registered in
+// ReadDirectoryChangesW function or some control operations need to be executed.
+const (
+ stateRewatch uint32 = 1 << (28 + iota)
+ stateUnwatch
+ stateCPClose
+)
+
+// Filter used in current implementation was split into four segments:
+// - bits 0-11 store ReadDirectoryChangesW filters,
+// - bits 12-19 store File notify actions,
+// - bits 20-27 store notify specific events and flags,
+// - bits 28-31 store states which are used in loop's FSM.
+// Constants below are used as masks to retrieve only specific filter parts.
+const (
+ onlyNotifyChanges uint32 = 0x00000FFF
+ onlyNGlobalEvents uint32 = 0x0FF00000
+ onlyMachineStates uint32 = 0xF0000000
+)
+
+// grip represents a single watched directory. It stores the data required by
+// ReadDirectoryChangesW function. Only the filter, recursive, and handle members
+// may by modified by watcher implementation. Rest of the them have to remain
+// constant since they are used by Windows completion routine. This indicates that
+// grip can be removed only when all operations on the file handle are finished.
+type grip struct {
+ handle syscall.Handle
+ filter uint32
+ recursive bool
+ pathw []uint16
+ buffer [readBufferSize]byte
+ parent *watched
+ ovlapped *overlappedEx
+}
+
+// overlappedEx stores information used in asynchronous input and output.
+// Additionally, overlappedEx contains a pointer to 'grip' item which is used in
+// order to gather the structure in which the overlappedEx object was created.
+type overlappedEx struct {
+ syscall.Overlapped
+ parent *grip
+}
+
+// newGrip creates a new file handle that can be used in overlapped operations.
+// Then, the handle is associated with I/O completion port 'cph' and its value
+// is stored in newly created 'grip' object.
+func newGrip(cph syscall.Handle, parent *watched, filter uint32) (*grip, error) {
+ g := &grip{
+ handle: syscall.InvalidHandle,
+ filter: filter,
+ recursive: parent.recursive,
+ pathw: parent.pathw,
+ parent: parent,
+ ovlapped: &overlappedEx{},
+ }
+ if err := g.register(cph); err != nil {
+ return nil, err
+ }
+ g.ovlapped.parent = g
+ return g, nil
+}
+
+// NOTE : Thread safe
+func (g *grip) register(cph syscall.Handle) (err error) {
+ if g.handle, err = syscall.CreateFile(
+ &g.pathw[0],
+ syscall.FILE_LIST_DIRECTORY,
+ syscall.FILE_SHARE_READ|syscall.FILE_SHARE_WRITE|syscall.FILE_SHARE_DELETE,
+ nil,
+ syscall.OPEN_EXISTING,
+ syscall.FILE_FLAG_BACKUP_SEMANTICS|syscall.FILE_FLAG_OVERLAPPED,
+ 0,
+ ); err != nil {
+ return
+ }
+ if _, err = syscall.CreateIoCompletionPort(g.handle, cph, 0, 0); err != nil {
+ syscall.CloseHandle(g.handle)
+ return
+ }
+ return g.readDirChanges()
+}
+
+// readDirChanges tells the system to store file change information in grip's
+// buffer. Directory changes that occur between calls to this function are added
+// to the buffer and then, returned with the next call.
+func (g *grip) readDirChanges() error {
+ return syscall.ReadDirectoryChanges(
+ g.handle,
+ &g.buffer[0],
+ uint32(unsafe.Sizeof(g.buffer)),
+ g.recursive,
+ encode(g.filter),
+ nil,
+ (*syscall.Overlapped)(unsafe.Pointer(g.ovlapped)),
+ 0,
+ )
+}
+
+// encode transforms a generic filter, which contains platform independent and
+// implementation specific bit fields, to value that can be used as NotifyFilter
+// parameter in ReadDirectoryChangesW function.
+func encode(filter uint32) uint32 {
+ e := Event(filter & (onlyNGlobalEvents | onlyNotifyChanges))
+ if e&dirmarker != 0 {
+ return uint32(FileNotifyChangeDirName)
+ }
+ if e&Create != 0 {
+ e = (e ^ Create) | FileNotifyChangeFileName
+ }
+ if e&Remove != 0 {
+ e = (e ^ Remove) | FileNotifyChangeFileName
+ }
+ if e&Write != 0 {
+ e = (e ^ Write) | FileNotifyChangeAttributes | FileNotifyChangeSize |
+ FileNotifyChangeCreation | FileNotifyChangeSecurity
+ }
+ if e&Rename != 0 {
+ e = (e ^ Rename) | FileNotifyChangeFileName
+ }
+ return uint32(e)
+}
+
+// watched is made in order to check whether an action comes from a directory or
+// file. This approach requires two file handlers per single monitored folder. The
+// second grip handles actions which include creating or deleting a directory. If
+// these processes are not monitored, only the first grip is created.
+type watched struct {
+ filter uint32
+ recursive bool
+ count uint8
+ pathw []uint16
+ digrip [2]*grip
+}
+
+// newWatched creates a new watched instance. It splits the filter variable into
+// two parts. The first part is responsible for watching all events which can be
+// created for a file in watched directory structure and the second one watches
+// only directory Create/Remove actions. If all operations succeed, the Create
+// message is sent to I/O completion port queue for further processing.
+func newWatched(cph syscall.Handle, filter uint32, recursive bool,
+ path string) (wd *watched, err error) {
+ wd = &watched{
+ filter: filter,
+ recursive: recursive,
+ }
+ if wd.pathw, err = syscall.UTF16FromString(path); err != nil {
+ return
+ }
+ if err = wd.recreate(cph); err != nil {
+ return
+ }
+ return wd, nil
+}
+
+// TODO : doc
+func (wd *watched) recreate(cph syscall.Handle) (err error) {
+ filefilter := wd.filter &^ uint32(FileNotifyChangeDirName)
+ if err = wd.updateGrip(0, cph, filefilter == 0, filefilter); err != nil {
+ return
+ }
+ dirfilter := wd.filter & uint32(FileNotifyChangeDirName|Create|Remove)
+ if err = wd.updateGrip(1, cph, dirfilter == 0, wd.filter|uint32(dirmarker)); err != nil {
+ return
+ }
+ wd.filter &^= onlyMachineStates
+ return
+}
+
+// TODO : doc
+func (wd *watched) updateGrip(idx int, cph syscall.Handle, reset bool,
+ newflag uint32) (err error) {
+ if reset {
+ wd.digrip[idx] = nil
+ } else {
+ if wd.digrip[idx] == nil {
+ if wd.digrip[idx], err = newGrip(cph, wd, newflag); err != nil {
+ wd.closeHandle()
+ return
+ }
+ } else {
+ wd.digrip[idx].filter = newflag
+ wd.digrip[idx].recursive = wd.recursive
+ if err = wd.digrip[idx].register(cph); err != nil {
+ wd.closeHandle()
+ return
+ }
+ }
+ wd.count++
+ }
+ return
+}
+
+// closeHandle closes handles that are stored in digrip array. Function always
+// tries to close all of the handlers before it exits, even when there are errors
+// returned from the operating system kernel.
+func (wd *watched) closeHandle() (err error) {
+ for _, g := range wd.digrip {
+ if g != nil && g.handle != syscall.InvalidHandle {
+ switch suberr := syscall.CloseHandle(g.handle); {
+ case suberr == nil:
+ g.handle = syscall.InvalidHandle
+ case err == nil:
+ err = suberr
+ }
+ }
+ }
+ return
+}
+
+// watcher implements Watcher interface. It stores a set of watched directories.
+// All operations which remove watched objects from map `m` must be performed in
+// loop goroutine since these structures are used internally by operating system.
+type readdcw struct {
+ sync.Mutex
+ m map[string]*watched
+ cph syscall.Handle
+ start bool
+ wg sync.WaitGroup
+ c chan<- EventInfo
+}
+
+// NewWatcher creates new non-recursive watcher backed by ReadDirectoryChangesW.
+func newWatcher(c chan<- EventInfo) watcher {
+ r := &readdcw{
+ m: make(map[string]*watched),
+ cph: syscall.InvalidHandle,
+ c: c,
+ }
+ runtime.SetFinalizer(r, func(r *readdcw) {
+ if r.cph != syscall.InvalidHandle {
+ syscall.CloseHandle(r.cph)
+ }
+ })
+ return r
+}
+
+// Watch implements notify.Watcher interface.
+func (r *readdcw) Watch(path string, event Event) error {
+ return r.watch(path, event, false)
+}
+
+// RecursiveWatch implements notify.RecursiveWatcher interface.
+func (r *readdcw) RecursiveWatch(path string, event Event) error {
+ return r.watch(path, event, true)
+}
+
+// watch inserts a directory to the group of watched folders. If watched folder
+// already exists, function tries to rewatch it with new filters(NOT VALID). Moreover,
+// watch starts the main event loop goroutine when called for the first time.
+func (r *readdcw) watch(path string, event Event, recursive bool) (err error) {
+ if event&^(All|fileNotifyChangeAll) != 0 {
+ return errors.New("notify: unknown event")
+ }
+ r.Lock()
+ wd, ok := r.m[path]
+ r.Unlock()
+ if !ok {
+ if err = r.lazyinit(); err != nil {
+ return
+ }
+ r.Lock()
+ if wd, ok = r.m[path]; ok {
+ r.Unlock()
+ return
+ }
+ if wd, err = newWatched(r.cph, uint32(event), recursive, path); err != nil {
+ r.Unlock()
+ return
+ }
+ r.m[path] = wd
+ r.Unlock()
+ }
+ return nil
+}
+
+// lazyinit creates an I/O completion port and starts the main event processing
+// loop. This method uses Double-Checked Locking optimization.
+func (r *readdcw) lazyinit() (err error) {
+ invalid := uintptr(syscall.InvalidHandle)
+ if atomic.LoadUintptr((*uintptr)(&r.cph)) == invalid {
+ r.Lock()
+ defer r.Unlock()
+ if atomic.LoadUintptr((*uintptr)(&r.cph)) == invalid {
+ cph := syscall.InvalidHandle
+ if cph, err = syscall.CreateIoCompletionPort(cph, 0, 0, 0); err != nil {
+ return
+ }
+ r.cph, r.start = cph, true
+ go r.loop()
+ }
+ }
+ return
+}
+
+// TODO(pknap) : doc
+func (r *readdcw) loop() {
+ var n, key uint32
+ var overlapped *syscall.Overlapped
+ for {
+ err := syscall.GetQueuedCompletionStatus(r.cph, &n, &key, &overlapped, syscall.INFINITE)
+ if key == stateCPClose {
+ r.Lock()
+ handle := r.cph
+ r.cph = syscall.InvalidHandle
+ r.Unlock()
+ syscall.CloseHandle(handle)
+ r.wg.Done()
+ return
+ }
+ if overlapped == nil {
+ // TODO: check key == rewatch delete or 0(panic)
+ continue
+ }
+ overEx := (*overlappedEx)(unsafe.Pointer(overlapped))
+ if n == 0 {
+ r.loopstate(overEx)
+ } else {
+ r.loopevent(n, overEx)
+ if err = overEx.parent.readDirChanges(); err != nil {
+ // TODO: error handling
+ }
+ }
+ }
+}
+
+// TODO(pknap) : doc
+func (r *readdcw) loopstate(overEx *overlappedEx) {
+ filter := atomic.LoadUint32(&overEx.parent.parent.filter)
+ if filter&onlyMachineStates == 0 {
+ return
+ }
+ if overEx.parent.parent.count--; overEx.parent.parent.count == 0 {
+ switch filter & onlyMachineStates {
+ case stateRewatch:
+ r.Lock()
+ overEx.parent.parent.recreate(r.cph)
+ r.Unlock()
+ case stateUnwatch:
+ r.Lock()
+ delete(r.m, syscall.UTF16ToString(overEx.parent.pathw))
+ r.Unlock()
+ case stateCPClose:
+ default:
+ panic(`notify: windows loopstate logic error`)
+ }
+ }
+}
+
+// TODO(pknap) : doc
+func (r *readdcw) loopevent(n uint32, overEx *overlappedEx) {
+ events := []*event{}
+ var currOffset uint32
+ for {
+ raw := (*syscall.FileNotifyInformation)(unsafe.Pointer(&overEx.parent.buffer[currOffset]))
+ name := syscall.UTF16ToString((*[syscall.MAX_PATH]uint16)(unsafe.Pointer(&raw.FileName))[:raw.FileNameLength>>1])
+ events = append(events, &event{
+ pathw: overEx.parent.pathw,
+ filter: overEx.parent.filter,
+ action: raw.Action,
+ name: name,
+ })
+ if raw.NextEntryOffset == 0 {
+ break
+ }
+ if currOffset += raw.NextEntryOffset; currOffset >= n {
+ break
+ }
+ }
+ r.send(events)
+}
+
+// TODO(pknap) : doc
+func (r *readdcw) send(es []*event) {
+ for _, e := range es {
+ var syse Event
+ if e.e, syse = decode(e.filter, e.action); e.e == 0 && syse == 0 {
+ continue
+ }
+ switch {
+ case e.action == syscall.FILE_ACTION_MODIFIED:
+ e.ftype = fTypeUnknown
+ case e.filter&uint32(dirmarker) != 0:
+ e.ftype = fTypeDirectory
+ default:
+ e.ftype = fTypeFile
+ }
+ switch {
+ case e.e == 0:
+ e.e = syse
+ case syse != 0:
+ r.c <- &event{
+ pathw: e.pathw,
+ name: e.name,
+ ftype: e.ftype,
+ action: e.action,
+ filter: e.filter,
+ e: syse,
+ }
+ }
+ r.c <- e
+ }
+}
+
+// Rewatch implements notify.Rewatcher interface.
+func (r *readdcw) Rewatch(path string, oldevent, newevent Event) error {
+ return r.rewatch(path, uint32(oldevent), uint32(newevent), false)
+}
+
+// RecursiveRewatch implements notify.RecursiveRewatcher interface.
+func (r *readdcw) RecursiveRewatch(oldpath, newpath string, oldevent,
+ newevent Event) error {
+ if oldpath != newpath {
+ if err := r.unwatch(oldpath); err != nil {
+ return err
+ }
+ return r.watch(newpath, newevent, true)
+ }
+ return r.rewatch(newpath, uint32(oldevent), uint32(newevent), true)
+}
+
+// TODO : (pknap) doc.
+func (r *readdcw) rewatch(path string, oldevent, newevent uint32, recursive bool) (err error) {
+ if Event(newevent)&^(All|fileNotifyChangeAll) != 0 {
+ return errors.New("notify: unknown event")
+ }
+ var wd *watched
+ r.Lock()
+ if wd, err = r.nonStateWatched(path); err != nil {
+ r.Unlock()
+ return
+ }
+ if wd.filter&(onlyNotifyChanges|onlyNGlobalEvents) != oldevent {
+ panic(`notify: windows re-watcher logic error`)
+ }
+ wd.filter = stateRewatch | newevent
+ wd.recursive, recursive = recursive, wd.recursive
+ if err = wd.closeHandle(); err != nil {
+ wd.filter = oldevent
+ wd.recursive = recursive
+ r.Unlock()
+ return
+ }
+ r.Unlock()
+ return
+}
+
+// TODO : pknap
+func (r *readdcw) nonStateWatched(path string) (wd *watched, err error) {
+ wd, ok := r.m[path]
+ if !ok || wd == nil {
+ err = errors.New(`notify: ` + path + ` path is unwatched`)
+ return
+ }
+ if filter := atomic.LoadUint32(&wd.filter); filter&onlyMachineStates != 0 {
+ err = errors.New(`notify: another re/unwatching operation in progress`)
+ return
+ }
+ return
+}
+
+// Unwatch implements notify.Watcher interface.
+func (r *readdcw) Unwatch(path string) error {
+ return r.unwatch(path)
+}
+
+// RecursiveUnwatch implements notify.RecursiveWatcher interface.
+func (r *readdcw) RecursiveUnwatch(path string) error {
+ return r.unwatch(path)
+}
+
+// TODO : pknap
+func (r *readdcw) unwatch(path string) (err error) {
+ var wd *watched
+ r.Lock()
+ if wd, err = r.nonStateWatched(path); err != nil {
+ r.Unlock()
+ return
+ }
+ wd.filter |= stateUnwatch
+ if err = wd.closeHandle(); err != nil {
+ wd.filter &^= stateUnwatch
+ r.Unlock()
+ return
+ }
+ r.Unlock()
+ return
+}
+
+// Close resets the whole watcher object, closes all existing file descriptors,
+// and sends stateCPClose state as completion key to the main watcher's loop.
+func (r *readdcw) Close() (err error) {
+ r.Lock()
+ if !r.start {
+ r.Unlock()
+ return nil
+ }
+ for _, wd := range r.m {
+ wd.filter &^= onlyMachineStates
+ wd.filter |= stateCPClose
+ if e := wd.closeHandle(); e != nil && err == nil {
+ err = e
+ }
+ }
+ r.start = false
+ r.Unlock()
+ r.wg.Add(1)
+ if e := syscall.PostQueuedCompletionStatus(r.cph, 0, stateCPClose, nil); e != nil && err == nil {
+ return e
+ }
+ r.wg.Wait()
+ return
+}
+
+// decode creates a notify event from both non-raw filter and action which was
+// returned from completion routine. Function may return Event(0) in case when
+// filter was replaced by a new value which does not contain fields that are
+// valid with passed action.
+func decode(filter, action uint32) (Event, Event) {
+ switch action {
+ case syscall.FILE_ACTION_ADDED:
+ return gensys(filter, Create, FileActionAdded)
+ case syscall.FILE_ACTION_REMOVED:
+ return gensys(filter, Remove, FileActionRemoved)
+ case syscall.FILE_ACTION_MODIFIED:
+ return gensys(filter, Write, FileActionModified)
+ case syscall.FILE_ACTION_RENAMED_OLD_NAME:
+ return gensys(filter, Rename, FileActionRenamedOldName)
+ case syscall.FILE_ACTION_RENAMED_NEW_NAME:
+ return gensys(filter, Rename, FileActionRenamedNewName)
+ }
+ panic(`notify: cannot decode internal mask`)
+}
+
+// gensys decides whether the Windows action, system-independent event or both
+// of them should be returned. Since the grip's filter may be atomically changed
+// during watcher lifetime, it is possible that neither Windows nor notify masks
+// are watched by the user when this function is called.
+func gensys(filter uint32, ge, se Event) (gene, syse Event) {
+ isdir := filter&uint32(dirmarker) != 0
+ if isdir && filter&uint32(FileNotifyChangeDirName) != 0 ||
+ !isdir && filter&uint32(FileNotifyChangeFileName) != 0 ||
+ filter&uint32(fileNotifyChangeModified) != 0 {
+ syse = se
+ }
+ if filter&uint32(ge) != 0 {
+ gene = ge
+ }
+ return
+}
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/watcher_readdcw_test.go b/Godeps/_workspace/src/github.com/zillode/notify/watcher_readdcw_test.go
new file mode 100644
index 0000000..ea15b4a
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/watcher_readdcw_test.go
@@ -0,0 +1,67 @@
+// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+// +build windows
+
+package notify
+
+import "testing"
+
+// TODO(ppknap) : remove notify.Create event.
+func rcreate(w *W, path string) WCase {
+ cas := create(w, path)
+ cas.Events = append(cas.Events,
+ &Call{P: path, E: FileActionAdded},
+ )
+ return cas
+}
+
+// TODO(ppknap) : remove notify.Remove event.
+func rremove(w *W, path string) WCase {
+ cas := remove(w, path)
+ cas.Events = append(cas.Events,
+ &Call{P: path, E: FileActionRemoved},
+ )
+ return cas
+}
+
+// TODO(ppknap) : remove notify.Rename event.
+func rrename(w *W, oldpath, newpath string) WCase {
+ cas := rename(w, oldpath, newpath)
+ cas.Events = append(cas.Events,
+ &Call{P: oldpath, E: FileActionRenamedOldName},
+ &Call{P: newpath, E: FileActionRenamedNewName},
+ )
+ return cas
+}
+
+// TODO(ppknap) : remove notify.Write event.
+func rwrite(w *W, path string, p []byte) WCase {
+ cas := write(w, path, p)
+ cas.Events = append(cas.Events,
+ &Call{P: path, E: FileActionModified},
+ )
+ return cas
+}
+
+var events = []Event{
+ FileNotifyChangeFileName,
+ FileNotifyChangeDirName,
+ FileNotifyChangeSize,
+}
+
+func TestWatcherReadDirectoryChangesW(t *testing.T) {
+ w := NewWatcherTest(t, "testdata/vfs.txt", events...)
+ defer w.Close()
+
+ cases := [...]WCase{
+ rcreate(w, "src/github.com/rjeczalik/fs/fs_windows.go"),
+ rcreate(w, "src/github.com/rjeczalik/fs/subdir/"),
+ rremove(w, "src/github.com/rjeczalik/fs/fs.go"),
+ rrename(w, "src/github.com/rjeczalik/fs/LICENSE", "src/github.com/rjeczalik/fs/COPYLEFT"),
+ rwrite(w, "src/github.com/rjeczalik/fs/cmd/gotree/go.go", []byte("XD")),
+ }
+
+ w.ExpectAny(cases[:])
+}
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/watcher_recursive_test.go b/Godeps/_workspace/src/github.com/zillode/notify/watcher_recursive_test.go
new file mode 100644
index 0000000..3b1f148
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/watcher_recursive_test.go
@@ -0,0 +1,102 @@
+// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+// +build darwin,!kqueue windows
+
+package notify
+
+import (
+ "fmt"
+ "testing"
+)
+
+// noevent stripts test-case from expected event list, used when action is not
+// expected to trigger any events.
+func noevent(cas WCase) WCase {
+ return WCase{Action: cas.Action}
+}
+
+func TestWatcherRecursiveRewatch(t *testing.T) {
+ w := newWatcherTest(t, "testdata/vfs.txt")
+ defer w.Close()
+
+ cases := []WCase{
+ create(w, "src/github.com/rjeczalik/file"),
+ create(w, "src/github.com/rjeczalik/dir/"),
+ noevent(create(w, "src/github.com/rjeczalik/fs/dir/")),
+ noevent(create(w, "src/github.com/dir/")),
+ noevent(write(w, "src/github.com/rjeczalik/file", []byte("XD"))),
+ noevent(rename(w, "src/github.com/rjeczalik/fs/LICENSE", "src/LICENSE")),
+ }
+
+ w.Watch("src/github.com/rjeczalik", Create)
+ w.ExpectAny(cases)
+
+ cases = []WCase{
+ create(w, "src/github.com/rjeczalik/fs/file"),
+ create(w, "src/github.com/rjeczalik/fs/cmd/gotree/file"),
+ create(w, "src/github.com/rjeczalik/fs/cmd/dir/"),
+ create(w, "src/github.com/rjeczalik/fs/cmd/gotree/dir/"),
+ noevent(write(w, "src/github.com/rjeczalik/fs/file", []byte("XD"))),
+ noevent(create(w, "src/github.com/anotherdir/")),
+ }
+
+ w.RecursiveRewatch("src/github.com/rjeczalik", "src/github.com/rjeczalik", Create, Create)
+ w.ExpectAny(cases)
+
+ cases = []WCase{
+ create(w, "src/github.com/rjeczalik/1"),
+ create(w, "src/github.com/rjeczalik/2/"),
+ noevent(create(w, "src/github.com/rjeczalik/fs/cmd/1")),
+ noevent(create(w, "src/github.com/rjeczalik/fs/1/")),
+ noevent(write(w, "src/github.com/rjeczalik/fs/file", []byte("XD"))),
+ }
+
+ w.Rewatch("src/github.com/rjeczalik", Create, Create)
+ w.ExpectAny(cases)
+}
+
+// TODO(rjeczalik): move to watcher_test.go after #5
+func TestIsDirCreateEvent(t *testing.T) {
+ w := NewWatcherTest(t, "testdata/vfs.txt")
+ defer w.Close()
+
+ cases := [...]WCase{
+ // i=0
+ create(w, "src/github.com/jszwec/"),
+ // i=1
+ create(w, "src/github.com/jszwec/gojunitxml/"),
+ // i=2
+ create(w, "src/github.com/jszwec/gojunitxml/README.md"),
+ // i=3
+ create(w, "src/github.com/jszwec/gojunitxml/LICENSE"),
+ // i=4
+ create(w, "src/github.com/jszwec/gojunitxml/cmd/"),
+ }
+
+ dirs := [...]bool{
+ true, // i=0
+ true, // i=1
+ false, // i=2
+ false, // i=3
+ true, // i=4
+ }
+
+ fn := func(i int, _ WCase, ei EventInfo) error {
+ d, ok := ei.(isDirer)
+ if !ok {
+ return fmt.Errorf("received EventInfo does not implement isDirer")
+ }
+ switch ok, err := d.isDir(); {
+ case err != nil:
+ return err
+ case ok != dirs[i]:
+ return fmt.Errorf("want ok=%v; got %v", dirs[i], ok)
+ default:
+ return nil
+ }
+ }
+
+ w.ExpectAnyFunc(cases[:], fn)
+}
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/watcher_stub.go b/Godeps/_workspace/src/github.com/zillode/notify/watcher_stub.go
new file mode 100644
index 0000000..df55102
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/watcher_stub.go
@@ -0,0 +1,21 @@
+// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+// +build !darwin,!linux,!freebsd,!dragonfly,!netbsd,!openbsd,!windows
+// +build !kqueue
+
+package notify
+
+type stub struct{ error }
+
+// NewWatcher stub.
+func newWatcher(chan<- EventInfo) stub {
+ return stub{errors.New("notify: not implemented")}
+}
+
+// Following methods implement notify.watcher interface.
+func (s stub) Watch(string, Event) error { return s }
+func (s stub) Rewatch(string, Event, Event) error { return s }
+func (s stub) Unwatch(string) (err error) { return s }
+func (s stub) Close() error { return s }
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/watcher_test.go b/Godeps/_workspace/src/github.com/zillode/notify/watcher_test.go
new file mode 100644
index 0000000..45633e1
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/watcher_test.go
@@ -0,0 +1,32 @@
+// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+// +build darwin linux freebsd dragonfly netbsd openbsd windows
+
+package notify
+
+import "testing"
+
+// NOTE Set DEBUG env var for extra debugging info.
+
+func TestWatcher(t *testing.T) {
+ w := NewWatcherTest(t, "testdata/vfs.txt")
+ defer w.Close()
+
+ cases := [...]WCase{
+ create(w, "src/github.com/ppknap/link/include/coost/.link.hpp.swp"),
+ create(w, "src/github.com/rjeczalik/fs/fs_test.go"),
+ create(w, "src/github.com/rjeczalik/fs/binfs/"),
+ create(w, "src/github.com/rjeczalik/fs/binfs.go"),
+ create(w, "src/github.com/rjeczalik/fs/binfs_test.go"),
+ remove(w, "src/github.com/rjeczalik/fs/binfs/"),
+ create(w, "src/github.com/rjeczalik/fs/binfs/"),
+ create(w, "src/github.com/rjeczalik/fs/virfs"),
+ remove(w, "src/github.com/rjeczalik/fs/virfs"),
+ create(w, "file"),
+ create(w, "dir/"),
+ }
+
+ w.ExpectAny(cases[:])
+}
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/watchpoint.go b/Godeps/_workspace/src/github.com/zillode/notify/watchpoint.go
new file mode 100644
index 0000000..e034013
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/watchpoint.go
@@ -0,0 +1,102 @@
+// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+package notify
+
+// EventDiff describes a change to an event set - EventDiff[0] is an old state,
+// while EventDiff[1] is a new state. If event set has not changed (old == new),
+// functions typically return the None value.
+type eventDiff [2]Event
+
+func (diff eventDiff) Event() Event {
+ return diff[1] &^ diff[0]
+}
+
+// Watchpoint
+//
+// The nil key holds total event set - logical sum for all registered events.
+// It speeds up computing EventDiff for Add method.
+//
+// The rec key holds an event set for a watchpoints created by RecursiveWatch
+// for a Watcher implementation which is not natively recursive.
+type watchpoint map[chan<- EventInfo]Event
+
+// None is an empty event diff, think null object.
+var none eventDiff
+
+// rec is just a placeholder
+var rec = func() (ch chan<- EventInfo) {
+ ch = make(chan<- EventInfo)
+ close(ch)
+ return
+}()
+
+func (wp watchpoint) dryAdd(ch chan<- EventInfo, e Event) eventDiff {
+ if e &^= internal; wp[ch]&e == e {
+ return none
+ }
+ total := wp[ch] &^ internal
+ return eventDiff{total, total | e}
+}
+
+// Add assumes neither c nor e are nil or zero values.
+func (wp watchpoint) Add(c chan<- EventInfo, e Event) (diff eventDiff) {
+ wp[c] |= e
+ diff[0] = wp[nil]
+ diff[1] = diff[0] | e
+ wp[nil] = diff[1] &^ omit
+ // Strip diff from internal events.
+ diff[0] &^= internal
+ diff[1] &^= internal
+ if diff[0] == diff[1] {
+ return none
+ }
+ return
+}
+
+func (wp watchpoint) Del(c chan<- EventInfo, e Event) (diff eventDiff) {
+ wp[c] &^= e
+ if wp[c] == 0 {
+ delete(wp, c)
+ }
+ diff[0] = wp[nil]
+ delete(wp, nil)
+ if len(wp) != 0 {
+ // Recalculate total event set.
+ for _, e := range wp {
+ diff[1] |= e
+ }
+ wp[nil] = diff[1] &^ omit
+ }
+ // Strip diff from internal events.
+ diff[0] &^= internal
+ diff[1] &^= internal
+ if diff[0] == diff[1] {
+ return none
+ }
+ return
+}
+
+func (wp watchpoint) Dispatch(ei EventInfo, extra Event) {
+ e := eventmask(ei, extra)
+ if !matches(wp[nil], e) {
+ return
+ }
+ for ch, eset := range wp {
+ if ch != nil && matches(eset, e) {
+ select {
+ case ch <- ei:
+ default: // Drop event if receiver is too slow
+ }
+ }
+ }
+}
+
+func (wp watchpoint) Total() Event {
+ return wp[nil] &^ internal
+}
+
+func (wp watchpoint) IsRecursive() bool {
+ return wp[nil]&recursive != 0
+}
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/watchpoint_other.go b/Godeps/_workspace/src/github.com/zillode/notify/watchpoint_other.go
new file mode 100644
index 0000000..881631c
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/watchpoint_other.go
@@ -0,0 +1,23 @@
+// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+// +build !windows
+
+package notify
+
+// eventmask uses ei to create a new event which contains internal flags used by
+// notify package logic.
+func eventmask(ei EventInfo, extra Event) Event {
+ return ei.Event() | extra
+}
+
+// matches reports a match only when:
+//
+// - for user events, when event is present in the given set
+// - for internal events, when additionaly both event and set have omit bit set
+//
+// Internal events must not be sent to user channels and vice versa.
+func matches(set, event Event) bool {
+ return (set&omit)^(event&omit) == 0 && set&event == event
+}
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/watchpoint_readdcw.go b/Godeps/_workspace/src/github.com/zillode/notify/watchpoint_readdcw.go
new file mode 100644
index 0000000..9fd1e1d
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/watchpoint_readdcw.go
@@ -0,0 +1,38 @@
+// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+// +build windows
+
+package notify
+
+// eventmask uses ei to create a new event which contains internal flags used by
+// notify package logic. If one of FileAction* masks is detected, this function
+// adds corresponding FileNotifyChange* values. This allows non registered
+// FileAction* events to be passed on.
+func eventmask(ei EventInfo, extra Event) (e Event) {
+ if e = ei.Event() | extra; e&fileActionAll != 0 {
+ if ev, ok := ei.(*event); ok {
+ switch ev.ftype {
+ case fTypeFile:
+ e |= FileNotifyChangeFileName
+ case fTypeDirectory:
+ e |= FileNotifyChangeDirName
+ case fTypeUnknown:
+ e |= fileNotifyChangeModified
+ }
+ return e &^ fileActionAll
+ }
+ }
+ return
+}
+
+// matches reports a match only when:
+//
+// - for user events, when event is present in the given set
+// - for internal events, when additionally both event and set have omit bit set
+//
+// Internal events must not be sent to user channels and vice versa.
+func matches(set, event Event) bool {
+ return (set&omit)^(event&omit) == 0 && (set&event == event || set&fileNotifyChangeModified&event != 0)
+}
diff --git a/Godeps/_workspace/src/github.com/zillode/notify/watchpoint_test.go b/Godeps/_workspace/src/github.com/zillode/notify/watchpoint_test.go
new file mode 100644
index 0000000..e35483d
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/zillode/notify/watchpoint_test.go
@@ -0,0 +1,162 @@
+// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+package notify
+
+import (
+ "fmt"
+ "reflect"
+ "testing"
+)
+
+func call(wp watchpoint, fn interface{}, args []interface{}) eventDiff {
+ vals := []reflect.Value{reflect.ValueOf(wp)}
+ for _, arg := range args {
+ vals = append(vals, reflect.ValueOf(arg))
+ }
+ res := reflect.ValueOf(fn).Call(vals)
+ if n := len(res); n != 1 {
+ panic(fmt.Sprintf("unexpected len(res)=%d", n))
+ }
+ diff, ok := res[0].Interface().(eventDiff)
+ if !ok {
+ panic(fmt.Sprintf("want typeof(diff)=EventDiff; got %T", res[0].Interface()))
+ }
+ return diff
+}
+
+func TestWatchpoint(t *testing.T) {
+ ch := NewChans(5)
+ all := All | recursive
+ cases := [...]struct {
+ fn interface{}
+ args []interface{}
+ diff eventDiff
+ total Event
+ }{
+ // i=0
+ {
+ watchpoint.Add,
+ []interface{}{ch[0], Remove},
+ eventDiff{0, Remove},
+ Remove,
+ },
+ // i=1
+ {
+ watchpoint.Add,
+ []interface{}{ch[1], Create | Remove | recursive},
+ eventDiff{Remove, Remove | Create},
+ Create | Remove | recursive,
+ },
+ // i=2
+ {
+ watchpoint.Add,
+ []interface{}{ch[2], Create | Rename},
+ eventDiff{Create | Remove, Create | Remove | Rename},
+ Create | Remove | Rename | recursive,
+ },
+ // i=3
+ {
+ watchpoint.Add,
+ []interface{}{ch[0], Write | recursive},
+ eventDiff{Create | Remove | Rename, Create | Remove | Rename | Write},
+ Create | Remove | Rename | Write | recursive,
+ },
+ // i=4
+ {
+ watchpoint.Add,
+ []interface{}{ch[2], Remove | recursive},
+ none,
+ Create | Remove | Rename | Write | recursive,
+ },
+ // i=5
+ {
+ watchpoint.Del,
+ []interface{}{ch[0], all},
+ eventDiff{Create | Remove | Rename | Write, Create | Remove | Rename},
+ Create | Remove | Rename | recursive,
+ },
+ // i=6
+ {
+ watchpoint.Del,
+ []interface{}{ch[2], all},
+ eventDiff{Create | Remove | Rename, Create | Remove},
+ Create | Remove | recursive,
+ },
+ // i=7
+ {
+ watchpoint.Add,
+ []interface{}{ch[3], Create | Remove},
+ none,
+ Create | Remove | recursive,
+ },
+ // i=8
+ {
+ watchpoint.Del,
+ []interface{}{ch[1], all},
+ none,
+ Create | Remove,
+ },
+ // i=9
+ {
+ watchpoint.Add,
+ []interface{}{ch[3], recursive | Write},
+ eventDiff{Create | Remove, Create | Remove | Write},
+ Create | Remove | Write | recursive,
+ },
+ // i=10
+ {
+ watchpoint.Del,
+ []interface{}{ch[3], Create},
+ eventDiff{Create | Remove | Write, Remove | Write},
+ Remove | Write | recursive,
+ },
+ // i=11
+ {
+ watchpoint.Add,
+ []interface{}{ch[3], Create | Rename},
+ eventDiff{Remove | Write, Create | Remove | Rename | Write},
+ Create | Remove | Rename | Write | recursive,
+ },
+ // i=12
+ {
+ watchpoint.Add,
+ []interface{}{ch[2], Remove | Write},
+ none,
+ Create | Remove | Rename | Write | recursive,
+ },
+ // i=13
+ {
+ watchpoint.Del,
+ []interface{}{ch[3], Create | Remove | Write},
+ eventDiff{Create | Remove | Rename | Write, Remove | Rename | Write},
+ Remove | Rename | Write | recursive,
+ },
+ // i=14
+ {
+ watchpoint.Del,
+ []interface{}{ch[2], Remove},
+ eventDiff{Remove | Rename | Write, Rename | Write},
+ Rename | Write | recursive,
+ },
+ // i=15
+ {
+ watchpoint.Del,
+ []interface{}{ch[3], Rename | recursive},
+ eventDiff{Rename | Write, Write},
+ Write,
+ },
+ }
+ wp := watchpoint{}
+ for i, cas := range cases {
+ if diff := call(wp, cas.fn, cas.args); diff != cas.diff {
+ t.Errorf("want diff=%v; got %v (i=%d)", cas.diff, diff, i)
+ continue
+ }
+ if total := wp[nil]; total != cas.total {
+ t.Errorf("want total=%v; got %v (i=%d)", cas.total, total, i)
+ continue
+ }
+ }
+}
--
2.5.2
Copy permalink