diff --git a/vendor/github.com/rjeczalik/notify/README.md b/vendor/github.com/rjeczalik/notify/README.md
index a728d1dd04..ad743b2a24 100644
--- a/vendor/github.com/rjeczalik/notify/README.md
+++ b/vendor/github.com/rjeczalik/notify/README.md
@@ -18,4 +18,5 @@ Filesystem event notification library on steroids. (under active development)
 - [github.com/rjeczalik/cmd/notify](https://godoc.org/github.com/rjeczalik/cmd/notify)
 - [github.com/cortesi/devd](https://github.com/cortesi/devd)
 - [github.com/cortesi/modd](https://github.com/cortesi/modd)
-
+- [github.com/syncthing/syncthing-inotify](https://github.com/syncthing/syncthing-inotify)
+- [github.com/OrlovEvgeny/TinyJPG](https://github.com/OrlovEvgeny/TinyJPG)
diff --git a/vendor/github.com/rjeczalik/notify/appveyor.yml b/vendor/github.com/rjeczalik/notify/appveyor.yml
index 8e762d05cb..a0bdc37a38 100644
--- a/vendor/github.com/rjeczalik/notify/appveyor.yml
+++ b/vendor/github.com/rjeczalik/notify/appveyor.yml
@@ -7,16 +7,20 @@ clone_folder: c:\projects\src\github.com\rjeczalik\notify
 environment:
  PATH: c:\projects\bin;%PATH%
  GOPATH: c:\projects
- NOTIFY_TIMEOUT: 5s
+ NOTIFY_TIMEOUT: 10s
+ GOVERSION: 1.10.3
 
 install:
+ - rmdir c:\go /s /q
+ - appveyor DownloadFile https://storage.googleapis.com/golang/go%GOVERSION%.windows-amd64.zip
+ - 7z x go%GOVERSION%.windows-amd64.zip -y -oC:\ > NUL
+
+ - cd %APPVEYOR_BUILD_FOLDER%
  - go version
- - go get -v -t ./...
 
 build_script:
- - go tool vet -all .
  - go build ./...
- - go test -v -race ./...
+ - go test -v -timeout 120s -race ./...
 
 test: off
 
diff --git a/vendor/github.com/rjeczalik/notify/debug.go b/vendor/github.com/rjeczalik/notify/debug.go
index bd9bc468df..2a3eb33700 100644
--- a/vendor/github.com/rjeczalik/notify/debug.go
+++ b/vendor/github.com/rjeczalik/notify/debug.go
@@ -2,10 +2,52 @@
 // 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{}) {}
+import (
+	"log"
+	"os"
+	"runtime"
+	"strings"
+)
 
-func dbgprintf(string, ...interface{}) {}
+var dbgprint func(...interface{})
+
+var dbgprintf func(string, ...interface{})
+
+var dbgcallstack func(max int) []string
+
+func init() {
+	if _, ok := os.LookupEnv("NOTIFY_DEBUG"); ok || debugTag {
+		log.SetOutput(os.Stdout)
+		log.SetFlags(log.Ldate | log.Ltime | log.Lmicroseconds)
+		dbgprint = func(v ...interface{}) {
+			v = append([]interface{}{"[D] "}, v...)
+			log.Println(v...)
+		}
+		dbgprintf = func(format string, v ...interface{}) {
+			format = "[D] " + format
+			log.Printf(format, v...)
+		}
+		dbgcallstack = func(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
+		}
+		return
+	}
+	dbgprint = func(v ...interface{}) {}
+	dbgprintf = func(format string, v ...interface{}) {}
+	dbgcallstack = func(max int) []string { return nil }
+}
diff --git a/vendor/github.com/rjeczalik/notify/debug_debug.go b/vendor/github.com/rjeczalik/notify/debug_debug.go
index f0622917f5..9d234cedda 100644
--- a/vendor/github.com/rjeczalik/notify/debug_debug.go
+++ b/vendor/github.com/rjeczalik/notify/debug_debug.go
@@ -1,4 +1,4 @@
-// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Copyright (c) 2014-2018 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.
 
@@ -6,38 +6,4 @@
 
 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
-}
+var debugTag = true
diff --git a/vendor/github.com/rjeczalik/notify/debug_nodebug.go b/vendor/github.com/rjeczalik/notify/debug_nodebug.go
new file mode 100644
index 0000000000..9ebf880d88
--- /dev/null
+++ b/vendor/github.com/rjeczalik/notify/debug_nodebug.go
@@ -0,0 +1,9 @@
+// Copyright (c) 2014-2018 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
+
+var debugTag = false
diff --git a/vendor/github.com/rjeczalik/notify/doc.go b/vendor/github.com/rjeczalik/notify/doc.go
index 8a99ddda62..60543c0838 100644
--- a/vendor/github.com/rjeczalik/notify/doc.go
+++ b/vendor/github.com/rjeczalik/notify/doc.go
@@ -12,11 +12,14 @@
 // source file.
 //
 // On top of filesystem watchers notify maintains a watchpoint tree, which provides
-// strategy for creating and closing filesystem watches and dispatching filesystem
+// a 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.
+// Both the platform-independent (see Constants) and specific events can be used.
+// Refer to the event_*.go source files for information about the available
+// events.
 //
 // 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
@@ -35,6 +38,6 @@
 // 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
+// user channel can be registered in one or more watchpoints, recursive and
 // non-recursive ones as well.
 package notify
diff --git a/vendor/github.com/rjeczalik/notify/event.go b/vendor/github.com/rjeczalik/notify/event.go
index e045edcecc..c128841972 100644
--- a/vendor/github.com/rjeczalik/notify/event.go
+++ b/vendor/github.com/rjeczalik/notify/event.go
@@ -73,7 +73,7 @@ func (e Event) String() string {
 //
 //    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
+// Under Linux (inotify) Sys() always returns a non-nil *unix.InotifyEvent
 // value, defined as:
 //
 //   type InotifyEvent struct {
diff --git a/vendor/github.com/rjeczalik/notify/event_fen.go b/vendor/github.com/rjeczalik/notify/event_fen.go
index a3079385d7..767f04fa87 100644
--- a/vendor/github.com/rjeczalik/notify/event_fen.go
+++ b/vendor/github.com/rjeczalik/notify/event_fen.go
@@ -20,16 +20,27 @@ const (
 )
 
 const (
-	FileAccess     = fileAccess
-	FileModified   = fileModified
-	FileAttrib     = fileAttrib
-	FileDelete     = fileDelete
-	FileRenameTo   = fileRenameTo
+	// FileAccess is an event reported when monitored file/directory was accessed.
+	FileAccess = fileAccess
+	// FileModified is an event reported when monitored file/directory was modified.
+	FileModified = fileModified
+	// FileAttrib is an event reported when monitored file/directory's ATTRIB
+	// was changed.
+	FileAttrib = fileAttrib
+	// FileDelete is an event reported when monitored file/directory was deleted.
+	FileDelete = fileDelete
+	// FileRenameTo to is an event reported when monitored file/directory was renamed.
+	FileRenameTo = fileRenameTo
+	// FileRenameFrom is an event reported when monitored file/directory was renamed.
 	FileRenameFrom = fileRenameFrom
-	FileTrunc      = fileTrunc
-	FileNoFollow   = fileNoFollow
-	Unmounted      = unmounted
-	MountedOver    = mountedOver
+	// FileTrunc is an event reported when monitored file/directory was truncated.
+	FileTrunc = fileTrunc
+	// FileNoFollow is an flag to indicate not to follow symbolic links.
+	FileNoFollow = fileNoFollow
+	// Unmounted is an event reported when monitored filesystem was unmounted.
+	Unmounted = unmounted
+	// MountedOver is an event reported when monitored file/directory was mounted on.
+	MountedOver = mountedOver
 )
 
 var osestr = map[Event]string{
diff --git a/vendor/github.com/rjeczalik/notify/event_inotify.go b/vendor/github.com/rjeczalik/notify/event_inotify.go
index 82954a9b38..1f32bb73e0 100644
--- a/vendor/github.com/rjeczalik/notify/event_inotify.go
+++ b/vendor/github.com/rjeczalik/notify/event_inotify.go
@@ -6,7 +6,7 @@
 
 package notify
 
-import "syscall"
+import "golang.org/x/sys/unix"
 
 // Platform independent event values.
 const (
@@ -25,18 +25,18 @@ const (
 // 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
+	InAccess       = Event(unix.IN_ACCESS)        // File was accessed
+	InModify       = Event(unix.IN_MODIFY)        // File was modified
+	InAttrib       = Event(unix.IN_ATTRIB)        // Metadata changed
+	InCloseWrite   = Event(unix.IN_CLOSE_WRITE)   // Writtable file was closed
+	InCloseNowrite = Event(unix.IN_CLOSE_NOWRITE) // Unwrittable file closed
+	InOpen         = Event(unix.IN_OPEN)          // File was opened
+	InMovedFrom    = Event(unix.IN_MOVED_FROM)    // File was moved from X
+	InMovedTo      = Event(unix.IN_MOVED_TO)      // File was moved to Y
+	InCreate       = Event(unix.IN_CREATE)        // Subfile was created
+	InDelete       = Event(unix.IN_DELETE)        // Subfile was deleted
+	InDeleteSelf   = Event(unix.IN_DELETE_SELF)   // Self was deleted
+	InMoveSelf     = Event(unix.IN_MOVE_SELF)     // Self was moved
 )
 
 var osestr = map[Event]string{
@@ -56,15 +56,15 @@ var osestr = map[Event]string{
 
 // 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)
+	inDontFollow = Event(unix.IN_DONT_FOLLOW)
+	inExclUnlink = Event(unix.IN_EXCL_UNLINK)
+	inMaskAdd    = Event(unix.IN_MASK_ADD)
+	inOneshot    = Event(unix.IN_ONESHOT)
+	inOnlydir    = Event(unix.IN_ONLYDIR)
 )
 
 type event struct {
-	sys   syscall.InotifyEvent
+	sys   unix.InotifyEvent
 	path  string
 	event Event
 }
@@ -72,4 +72,4 @@ type event struct {
 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 }
+func (e *event) isDir() (bool, error) { return e.sys.Mask&unix.IN_ISDIR != 0, nil }
diff --git a/vendor/github.com/rjeczalik/notify/event_kqueue.go b/vendor/github.com/rjeczalik/notify/event_kqueue.go
index 82e2d8ccae..422ac87f66 100644
--- a/vendor/github.com/rjeczalik/notify/event_kqueue.go
+++ b/vendor/github.com/rjeczalik/notify/event_kqueue.go
@@ -26,7 +26,7 @@ const (
 )
 
 const (
-	// NoteDelete is an even reported when the unlink() system call was called
+	// NoteDelete is an event 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
diff --git a/vendor/github.com/rjeczalik/notify/event_readdcw.go b/vendor/github.com/rjeczalik/notify/event_readdcw.go
index 11ead9e297..f7b82de0c4 100644
--- a/vendor/github.com/rjeczalik/notify/event_readdcw.go
+++ b/vendor/github.com/rjeczalik/notify/event_readdcw.go
@@ -27,7 +27,11 @@ const (
 	dirmarker
 )
 
-// ReadDirectoryChangesW filters.
+// ReadDirectoryChangesW filters
+// On Windows the following events can be passed to Watch. A different set of
+// events (see actions below) are received on the channel passed to Watch.
+// For more information refer to
+// https://msdn.microsoft.com/en-us/library/windows/desktop/aa365465(v=vs.85).aspx
 const (
 	FileNotifyChangeFileName   = Event(syscall.FILE_NOTIFY_CHANGE_FILE_NAME)
 	FileNotifyChangeDirName    = Event(syscall.FILE_NOTIFY_CHANGE_DIR_NAME)
@@ -48,7 +52,13 @@ const (
 // this flag should be declared in: http://golang.org/src/pkg/syscall/ztypes_windows.go
 const syscallFileNotifyChangeSecurity = 0x00000100
 
-// ReadDirectoryChangesW actions.
+// ReadDirectoryChangesW actions
+// The following events are returned on the channel passed to Watch, but cannot
+// be passed to Watch itself (see filters above). You can find a table showing
+// the relation between actions and filteres at
+// https://github.com/rjeczalik/notify/issues/10#issuecomment-66179535
+// The msdn documentation on actions is part of
+// https://msdn.microsoft.com/en-us/library/windows/desktop/aa364391(v=vs.85).aspx
 const (
 	FileActionAdded          = Event(syscall.FILE_ACTION_ADDED) << 12
 	FileActionRemoved        = Event(syscall.FILE_ACTION_REMOVED) << 12
diff --git a/vendor/github.com/rjeczalik/notify/node.go b/vendor/github.com/rjeczalik/notify/node.go
index 29c1bb20af..aced8b9c44 100644
--- a/vendor/github.com/rjeczalik/notify/node.go
+++ b/vendor/github.com/rjeczalik/notify/node.go
@@ -6,7 +6,6 @@ package notify
 
 import (
 	"errors"
-	"fmt"
 	"io/ioutil"
 	"os"
 	"path/filepath"
@@ -71,7 +70,11 @@ Traverse:
 		case errSkip:
 			continue Traverse
 		default:
-			return fmt.Errorf("error while traversing %q: %v", nd.Name, err)
+			return &os.PathError{
+				Op:   "error while traversing",
+				Path: nd.Name,
+				Err:  err,
+			}
 		}
 		// TODO(rjeczalik): tolerate open failures - add failed names to
 		// AddDirError and notify users which names are not added to the tree.
diff --git a/vendor/github.com/rjeczalik/notify/notify.go b/vendor/github.com/rjeczalik/notify/notify.go
index dbf1e7bc24..7d2eec3a24 100644
--- a/vendor/github.com/rjeczalik/notify/notify.go
+++ b/vendor/github.com/rjeczalik/notify/notify.go
@@ -4,7 +4,7 @@
 
 // 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
+// advised to listen on persistent 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
@@ -58,7 +58,7 @@ var defaultTree = newTree()
 // 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
+// e.g. use persistent 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...)
@@ -67,7 +67,7 @@ func Watch(path string, c chan<- EventInfo, events ...Event) error {
 // 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
+// Stop does not close c. When Stop returns, it is guaranteed that c will
 // receive no more signals.
 func Stop(c chan<- EventInfo) {
 	defaultTree.Stop(c)
diff --git a/vendor/github.com/rjeczalik/notify/watcher_fen.go b/vendor/github.com/rjeczalik/notify/watcher_fen.go
index 60e9a36da6..dfe77f2f1d 100644
--- a/vendor/github.com/rjeczalik/notify/watcher_fen.go
+++ b/vendor/github.com/rjeczalik/notify/watcher_fen.go
@@ -33,19 +33,12 @@ type fen struct {
 
 // watched is a data structure representing watched file/directory.
 type watched struct {
-	// p is a path to watched file/directory
-	p string
-	// fi provides information about watched file/dir
-	fi os.FileInfo
-	// eDir represents events watched directly
-	eDir Event
-	// eNonDir represents events watched indirectly
-	eNonDir Event
+	trgWatched
 }
 
 // Stop implements trigger.
 func (f *fen) Stop() error {
-	return f.cf.port_alert(f.p)
+	return f.cf.portAlert(f.p)
 }
 
 // Close implements trigger.
@@ -55,7 +48,7 @@ func (f *fen) Close() (err error) {
 
 // NewWatched implements trigger.
 func (*fen) NewWatched(p string, fi os.FileInfo) (*watched, error) {
-	return &watched{p: p, fi: fi}, nil
+	return &watched{trgWatched{p: p, fi: fi}}, nil
 }
 
 // Record implements trigger.
@@ -92,7 +85,7 @@ func (f *fen) Watched(n interface{}) (*watched, int64, error) {
 
 // init initializes FEN.
 func (f *fen) Init() (err error) {
-	f.p, err = f.cf.port_create()
+	f.p, err = f.cf.portCreate()
 	return
 }
 
@@ -106,12 +99,12 @@ func fi2fo(fi os.FileInfo, p string) FileObj {
 
 // Unwatch implements trigger.
 func (f *fen) Unwatch(w *watched) error {
-	return f.cf.port_dissociate(f.p, FileObj{Name: w.p})
+	return f.cf.portDissociate(f.p, FileObj{Name: w.p})
 }
 
 // Watch implements trigger.
 func (f *fen) Watch(fi os.FileInfo, w *watched, e int64) error {
-	return f.cf.port_associate(f.p, fi2fo(fi, w.p), int(e))
+	return f.cf.portAssociate(f.p, fi2fo(fi, w.p), int(e))
 }
 
 // Wait implements trigger.
@@ -120,7 +113,7 @@ func (f *fen) Wait() (interface{}, error) {
 		pe  PortEvent
 		err error
 	)
-	err = f.cf.port_get(f.p, &pe)
+	err = f.cf.portGet(f.p, &pe)
 	return pe, err
 }
 
@@ -130,16 +123,14 @@ func (f *fen) IsStop(n interface{}, err error) bool {
 }
 
 func init() {
-	encode = func(e Event) (o int64) {
+	encode = func(e Event, dir bool) (o int64) {
 		// Create event is not supported by FEN. Instead FileModified event will
 		// be registered. If this event will be reported on dir which is to be
 		// monitored for Create, dir will be rescanned and Create events will
 		// be generated and returned for new files. In case of files,
 		// if not requested FileModified event is reported, it will be ignored.
-		if e&Create != 0 {
-			o = (o &^ int64(Create)) | int64(FileModified)
-		}
-		if e&Write != 0 {
+		o = int64(e &^ Create)
+		if (e&Create != 0 && dir) || e&Write != 0 {
 			o = (o &^ int64(Write)) | int64(FileModified)
 		}
 		// Following events are 'exception events' and as such cannot be requested
diff --git a/vendor/github.com/rjeczalik/notify/watcher_fen_cgo.go b/vendor/github.com/rjeczalik/notify/watcher_fen_cgo.go
index 58ac8e8c67..8ec8ead343 100644
--- a/vendor/github.com/rjeczalik/notify/watcher_fen_cgo.go
+++ b/vendor/github.com/rjeczalik/notify/watcher_fen_cgo.go
@@ -67,7 +67,7 @@ func unix2C(sec int64, nsec int64) (C.time_t, C.long) {
 	return C.time_t(sec), C.long(nsec)
 }
 
-func (c *cfen) port_associate(p int, fo FileObj, e int) (err error) {
+func (c *cfen) portAssociate(p int, fo FileObj, e int) (err error) {
 	cfo := C.newFo()
 	cfo.fo_atime.tv_sec, cfo.fo_atime.tv_nsec = unix2C(fo.Atim.Unix())
 	cfo.fo_mtime.tv_sec, cfo.fo_mtime.tv_nsec = unix2C(fo.Mtim.Unix())
@@ -78,7 +78,7 @@ func (c *cfen) port_associate(p int, fo FileObj, e int) (err error) {
 	return
 }
 
-func (c *cfen) port_dissociate(port int, fo FileObj) (err error) {
+func (c *cfen) portDissociate(port int, fo FileObj) (err error) {
 	cfo, ok := c.p2fo[fo.Name]
 	if !ok {
 		return errNotWatched
@@ -104,7 +104,7 @@ func cfo2fo(cfo *C.struct_file_obj) *FileObj {
 	return &fo
 }
 
-func (c *cfen) port_get(port int, pe *PortEvent) (err error) {
+func (c *cfen) portGet(port int, pe *PortEvent) (err error) {
 	cpe := C.newPe()
 	if _, err = C.port_get(C.int(port), cpe, nil); err != nil {
 		C.free(unsafe.Pointer(cpe))
@@ -118,12 +118,12 @@ func (c *cfen) port_get(port int, pe *PortEvent) (err error) {
 	return
 }
 
-func (c *cfen) port_create() (int, error) {
+func (c *cfen) portCreate() (int, error) {
 	p, err := C.port_create()
 	return int(p), err
 }
 
-func (c *cfen) port_alert(p int) (err error) {
+func (c *cfen) portAlert(p int) (err error) {
 	_, err = C.port_alert(C.int(p), alertSet, C.int(666), nil)
 	return
 }
diff --git a/vendor/github.com/rjeczalik/notify/watcher_fsevents.go b/vendor/github.com/rjeczalik/notify/watcher_fsevents.go
index 9062c17c7f..7d9b97b65d 100644
--- a/vendor/github.com/rjeczalik/notify/watcher_fsevents.go
+++ b/vendor/github.com/rjeczalik/notify/watcher_fsevents.go
@@ -12,8 +12,6 @@ import (
 	"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 |
@@ -189,9 +187,6 @@ func newWatcher(c chan<- EventInfo) watcher {
 }
 
 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
 	}
@@ -211,9 +206,6 @@ func (fse *fsevents) watch(path string, event Event, isrec int32) (err error) {
 }
 
 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
diff --git a/vendor/github.com/rjeczalik/notify/watcher_fsevents_cgo.go b/vendor/github.com/rjeczalik/notify/watcher_fsevents_cgo.go
index ee9631a61f..95ee704444 100644
--- a/vendor/github.com/rjeczalik/notify/watcher_fsevents_cgo.go
+++ b/vendor/github.com/rjeczalik/notify/watcher_fsevents_cgo.go
@@ -26,9 +26,9 @@ import "C"
 import (
 	"errors"
 	"os"
+	"runtime"
 	"sync"
 	"sync/atomic"
-	"time"
 	"unsafe"
 )
 
@@ -48,7 +48,7 @@ var wg sync.WaitGroup      // used to wait until the runloop starts
 // 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{
+var source = C.CFRunLoopSourceCreate(refZero, 0, &C.CFRunLoopSourceContext{
 	perform: (C.CFRunLoopPerformCallBack)(C.gosource),
 })
 
@@ -63,6 +63,10 @@ var (
 func init() {
 	wg.Add(1)
 	go func() {
+		// There is exactly one run loop per thread. Lock this goroutine to its
+		// thread to ensure that it's not rescheduled on a different thread while
+		// setting up the run loop.
+		runtime.LockOSThread()
 		runloop = C.CFRunLoopGetCurrent()
 		C.CFRunLoopAddSource(runloop, source, C.kCFRunLoopDefaultMode)
 		C.CFRunLoopRun()
@@ -73,7 +77,6 @@ func init() {
 
 //export gosource
 func gosource(unsafe.Pointer) {
-	time.Sleep(time.Second)
 	wg.Done()
 }
 
@@ -87,6 +90,10 @@ func gostream(_, info uintptr, n C.size_t, paths, flags, ids uintptr) {
 	if n == 0 {
 		return
 	}
+	fn := streamFuncs.get(info)
+	if fn == nil {
+		return
+	}
 	ev := make([]FSEvent, 0, int(n))
 	for i := uintptr(0); i < uintptr(n); i++ {
 		switch flags := *(*uint32)(unsafe.Pointer((flags + i*offflag))); {
@@ -101,7 +108,7 @@ func gostream(_, info uintptr, n C.size_t, paths, flags, ids uintptr) {
 		}
 
 	}
-	streamFuncs.get(info)(ev)
+	fn(ev)
 }
 
 // StreamFunc is a callback called when stream receives file events.
@@ -144,7 +151,7 @@ type stream struct {
 }
 
 // NewStream creates a stream for given path, listening for file events and
-// calling fn upon receving any.
+// calling fn upon receiving any.
 func newStream(path string, fn streamFunc) *stream {
 	return &stream{
 		path: path,
@@ -159,8 +166,8 @@ func (s *stream) Start() error {
 		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)
+	p := C.CFStringCreateWithCStringNoCopy(refZero, C.CString(s.path), C.kCFStringEncodingUTF8, refZero)
+	path := C.CFArrayCreate(refZero, (*unsafe.Pointer)(unsafe.Pointer(&p)), 1, nil)
 	ctx := C.FSEventStreamContext{}
 	ref := C.EventStreamCreate(&ctx, C.uintptr_t(s.info), path, C.FSEventStreamEventId(atomic.LoadUint64(&since)), latency, flags)
 	if ref == nilstream {
diff --git a/vendor/github.com/rjeczalik/notify/watcher_fsevents_go1.10.go b/vendor/github.com/rjeczalik/notify/watcher_fsevents_go1.10.go
new file mode 100644
index 0000000000..dd2433d20a
--- /dev/null
+++ b/vendor/github.com/rjeczalik/notify/watcher_fsevents_go1.10.go
@@ -0,0 +1,14 @@
+// Copyright (c) 2018 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,cgo,!go1.11
+
+package notify
+
+/*
+ #include <CoreServices/CoreServices.h>
+*/
+import "C"
+
+var refZero = (*C.struct___CFAllocator)(nil)
diff --git a/vendor/github.com/rjeczalik/notify/watcher_fsevents_go1.11.go b/vendor/github.com/rjeczalik/notify/watcher_fsevents_go1.11.go
new file mode 100644
index 0000000000..92b406ce7c
--- /dev/null
+++ b/vendor/github.com/rjeczalik/notify/watcher_fsevents_go1.11.go
@@ -0,0 +1,9 @@
+// Copyright (c) 2018 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,go1.11
+
+package notify
+
+const refZero = 0
diff --git a/vendor/github.com/rjeczalik/notify/watcher_inotify.go b/vendor/github.com/rjeczalik/notify/watcher_inotify.go
index 3ceaa8f3ab..d082baca0f 100644
--- a/vendor/github.com/rjeczalik/notify/watcher_inotify.go
+++ b/vendor/github.com/rjeczalik/notify/watcher_inotify.go
@@ -13,14 +13,15 @@ import (
 	"runtime"
 	"sync"
 	"sync/atomic"
-	"syscall"
 	"unsafe"
+
+	"golang.org/x/sys/unix"
 )
 
 // 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)
+const eventBufferSize = 64 * (unix.SizeofInotifyEvent + unix.PathMax + 1)
 
 // consumersCount defines the number of consumers in producer-consumer based
 // implementation. Each consumer is run in a separate goroutine and has read
@@ -43,7 +44,7 @@ type inotify struct {
 	fd           int32                 // inotify file descriptor
 	pipefd       []int                 // pipe's read and write descriptors
 	epfd         int                   // epoll descriptor
-	epes         []syscall.EpollEvent  // epoll events
+	epes         []unix.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
@@ -56,13 +57,13 @@ func newWatcher(c chan<- EventInfo) watcher {
 		fd:     invalidDescriptor,
 		pipefd: []int{invalidDescriptor, invalidDescriptor},
 		epfd:   invalidDescriptor,
-		epes:   make([]syscall.EpollEvent, 0),
+		epes:   make([]unix.EpollEvent, 0),
 		c:      c,
 	}
 	runtime.SetFinalizer(i, func(i *inotify) {
 		i.epollclose()
 		if i.fd != invalidDescriptor {
-			syscall.Close(int(i.fd))
+			unix.Close(int(i.fd))
 		}
 	})
 	return i
@@ -82,13 +83,13 @@ func (i *inotify) Rewatch(path string, _, newevent Event) error {
 // 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 {
+	if e&^(All|Event(unix.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))
+	iwd, err := unix.InotifyAddWatch(int(i.fd), path, encode(e))
 	if err != nil {
 		return
 	}
@@ -119,13 +120,13 @@ func (i *inotify) lazyinit() error {
 		i.Lock()
 		defer i.Unlock()
 		if atomic.LoadInt32(&i.fd) == invalidDescriptor {
-			fd, err := syscall.InotifyInit()
+			fd, err := unix.InotifyInit1(unix.IN_CLOEXEC)
 			if err != nil {
 				return err
 			}
 			i.fd = int32(fd)
 			if err = i.epollinit(); err != nil {
-				_, _ = i.epollclose(), syscall.Close(int(fd)) // Ignore errors.
+				_, _ = i.epollclose(), unix.Close(int(fd)) // Ignore errors.
 				i.fd = invalidDescriptor
 				return err
 			}
@@ -145,33 +146,33 @@ func (i *inotify) lazyinit() error {
 // 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.EpollCreate1(0); err != nil {
+	if i.epfd, err = unix.EpollCreate1(0); err != nil {
 		return
 	}
-	if err = syscall.Pipe(i.pipefd); err != nil {
+	if err = unix.Pipe(i.pipefd); err != nil {
 		return
 	}
-	i.epes = []syscall.EpollEvent{
-		{Events: syscall.EPOLLIN, Fd: i.fd},
-		{Events: syscall.EPOLLIN, Fd: int32(i.pipefd[0])},
+	i.epes = []unix.EpollEvent{
+		{Events: unix.EPOLLIN, Fd: i.fd},
+		{Events: unix.EPOLLIN, Fd: int32(i.pipefd[0])},
 	}
-	if err = syscall.EpollCtl(i.epfd, syscall.EPOLL_CTL_ADD, int(i.fd), &i.epes[0]); err != nil {
+	if err = unix.EpollCtl(i.epfd, unix.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])
+	return unix.EpollCtl(i.epfd, unix.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 {
+		if err = unix.Close(i.epfd); err == nil {
 			i.epfd = invalidDescriptor
 		}
 	}
 	for n, fd := range i.pipefd {
 		if fd != invalidDescriptor {
-			switch e := syscall.Close(fd); {
+			switch e := unix.Close(fd); {
 			case e != nil && err == nil:
 				err = e
 			case e == nil:
@@ -187,10 +188,10 @@ func (i *inotify) epollclose() (err error) {
 // 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)
+	epes := make([]unix.EpollEvent, 1)
 	fd := atomic.LoadInt32(&i.fd)
 	for {
-		switch _, err := syscall.EpollWait(i.epfd, epes, -1); err {
+		switch _, err := unix.EpollWait(i.epfd, epes, -1); err {
 		case nil:
 			switch epes[0].Fd {
 			case fd:
@@ -199,17 +200,17 @@ func (i *inotify) loop(esch chan<- []*event) {
 			case int32(i.pipefd[0]):
 				i.Lock()
 				defer i.Unlock()
-				if err = syscall.Close(int(fd)); err != nil && err != syscall.EINTR {
+				if err = unix.Close(int(fd)); err != nil && err != unix.EINTR {
 					panic("notify: close(2) error " + err.Error())
 				}
 				atomic.StoreInt32(&i.fd, invalidDescriptor)
-				if err = i.epollclose(); err != nil && err != syscall.EINTR {
+				if err = i.epollclose(); err != nil && err != unix.EINTR {
 					panic("notify: epollclose error " + err.Error())
 				}
 				close(esch)
 				return
 			}
-		case syscall.EINTR:
+		case unix.EINTR:
 			continue
 		default: // We should never reach this line.
 			panic("notify: epoll_wait(2) error " + err.Error())
@@ -220,22 +221,22 @@ func (i *inotify) loop(esch chan<- []*event) {
 // 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 {
+	n, err := unix.Read(int(i.fd), i.buffer[:])
+	if err != nil || n < unix.SizeofInotifyEvent {
 		return
 	}
-	var sys *syscall.InotifyEvent
-	nmin := n - syscall.SizeofInotifyEvent
+	var sys *unix.InotifyEvent
+	nmin := n - unix.SizeofInotifyEvent
 	for pos, path := 0, ""; pos <= nmin; {
-		sys = (*syscall.InotifyEvent)(unsafe.Pointer(&i.buffer[pos]))
-		pos += syscall.SizeofInotifyEvent
+		sys = (*unix.InotifyEvent)(unsafe.Pointer(&i.buffer[pos]))
+		pos += unix.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{
+			sys: unix.InotifyEvent{
 				Wd:     sys.Wd,
 				Mask:   sys.Mask,
 				Cookie: sys.Cookie,
@@ -268,7 +269,7 @@ 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 {
+		if e.sys.Mask&(unix.IN_IGNORED|unix.IN_Q_OVERFLOW) != 0 {
 			es[idx] = nil
 			continue
 		}
@@ -317,7 +318,7 @@ func encode(e Event) uint32 {
 // 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{
+		syse = &event{sys: unix.InotifyEvent{
 			Wd:     e.sys.Wd,
 			Mask:   e.sys.Mask,
 			Cookie: e.sys.Cookie,
@@ -357,7 +358,7 @@ func (i *inotify) Unwatch(path string) (err error) {
 		return errors.New("notify: path " + path + " is already watched")
 	}
 	fd := atomic.LoadInt32(&i.fd)
-	if _, err = syscall.InotifyRmWatch(int(fd), uint32(iwd)); err != nil {
+	if err = removeInotifyWatch(fd, iwd); err != nil {
 		return
 	}
 	i.Lock()
@@ -377,12 +378,12 @@ func (i *inotify) Close() (err error) {
 		return nil
 	}
 	for iwd := range i.m {
-		if _, e := syscall.InotifyRmWatch(int(i.fd), uint32(iwd)); e != nil && err == nil {
+		if e := removeInotifyWatch(i.fd, iwd); e != nil && err == nil {
 			err = e
 		}
 		delete(i.m, iwd)
 	}
-	switch _, errwrite := syscall.Write(i.pipefd[1], []byte{0x00}); {
+	switch _, errwrite := unix.Write(i.pipefd[1], []byte{0x00}); {
 	case errwrite != nil && err == nil:
 		err = errwrite
 		fallthrough
@@ -394,3 +395,11 @@ func (i *inotify) Close() (err error) {
 	}
 	return
 }
+
+// if path was removed, notify already removed the watch and returns EINVAL error
+func removeInotifyWatch(fd int32, iwd int32) (err error) {
+	if _, err = unix.InotifyRmWatch(int(fd), uint32(iwd)); err != nil && err != unix.EINVAL {
+		return
+	}
+	return nil
+}
diff --git a/vendor/github.com/rjeczalik/notify/watcher_kqueue.go b/vendor/github.com/rjeczalik/notify/watcher_kqueue.go
index d5f7788c4a..22e3c2c4a4 100644
--- a/vendor/github.com/rjeczalik/notify/watcher_kqueue.go
+++ b/vendor/github.com/rjeczalik/notify/watcher_kqueue.go
@@ -36,16 +36,9 @@ type kq struct {
 
 // watched is a data structure representing watched file/directory.
 type watched struct {
-	// p is a path to watched file/directory.
-	p string
+	trgWatched
 	// 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
 }
 
 // Stop implements trigger.
@@ -66,7 +59,10 @@ func (*kq) NewWatched(p string, fi os.FileInfo) (*watched, error) {
 	if err != nil {
 		return nil, err
 	}
-	return &watched{fd: fd, p: p, fi: fi}, nil
+	return &watched{
+		trgWatched: trgWatched{p: p, fi: fi},
+		fd:         fd,
+	}, nil
 }
 
 // Record implements trigger.
@@ -157,14 +153,15 @@ func (k *kq) IsStop(n interface{}, err error) bool {
 }
 
 func init() {
-	encode = func(e Event) (o int64) {
+	encode = func(e Event, dir bool) (o int64) {
 		// Create event is not supported by kqueue. Instead NoteWrite event will
-		// be registered. If this event will be reported on dir which is to be
-		// monitored for Create, dir will be rescanned and Create events will
-		// be generated and returned for new files. In case of files,
-		// if not requested NoteRename event is reported, it will be ignored.
+		// be registered for a directory. If this event will be reported on dir
+		// which is to be monitored for Create, dir will be rescanned
+		// and Create events will be generated and returned for new files.
+		// In case of files, if not requested NoteRename event is reported,
+		// it will be ignored.
 		o = int64(e &^ Create)
-		if e&Write != 0 {
+		if (e&Create != 0 && dir) || e&Write != 0 {
 			o = (o &^ int64(Write)) | int64(NoteWrite)
 		}
 		if e&Rename != 0 {
diff --git a/vendor/github.com/rjeczalik/notify/watcher_notimplemented.go b/vendor/github.com/rjeczalik/notify/watcher_notimplemented.go
new file mode 100644
index 0000000000..bb0672fd88
--- /dev/null
+++ b/vendor/github.com/rjeczalik/notify/watcher_notimplemented.go
@@ -0,0 +1,15 @@
+// Copyright (c) 2014-2018 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,!solaris
+
+package notify
+
+import "errors"
+
+// newWatcher stub.
+func newWatcher(chan<- EventInfo) watcher {
+	return watcherStub{errors.New("notify: not implemented")}
+}
diff --git a/vendor/github.com/rjeczalik/notify/watcher_readdcw.go b/vendor/github.com/rjeczalik/notify/watcher_readdcw.go
index 5923bfddae..b69811a690 100644
--- a/vendor/github.com/rjeczalik/notify/watcher_readdcw.go
+++ b/vendor/github.com/rjeczalik/notify/watcher_readdcw.go
@@ -1,4 +1,4 @@
-// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Copyright (c) 2014-2018 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.
 
@@ -22,7 +22,7 @@ import (
 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
+// asynchronously, filter may set one of the constants below. 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 (
@@ -109,8 +109,13 @@ func (g *grip) register(cph syscall.Handle) (err error) {
 // 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 {
+	handle := syscall.Handle(atomic.LoadUintptr((*uintptr)(&g.handle)))
+	if handle == syscall.InvalidHandle {
+		return nil // Handle was closed.
+	}
+
 	return syscall.ReadDirectoryChanges(
-		g.handle,
+		handle,
 		&g.buffer[0],
 		uint32(unsafe.Sizeof(g.buffer)),
 		g.recursive,
@@ -220,12 +225,27 @@ func (wd *watched) updateGrip(idx int, cph syscall.Handle, reset bool,
 // 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
+		if g == nil {
+			continue
+		}
+
+		for {
+			handle := syscall.Handle(atomic.LoadUintptr((*uintptr)(&g.handle)))
+			if handle == syscall.InvalidHandle {
+				break // Already closed.
+			}
+
+			e := syscall.CloseHandle(handle)
+			if e != nil && err == nil {
+				err = e
+			}
+
+			// Set invalid handle even when CloseHandle fails. This will leak
+			// the handle but, since we can't close it anyway, there won't be
+			// any difference.
+			if atomic.CompareAndSwapUintptr((*uintptr)(&g.handle),
+				(uintptr)(handle), (uintptr)(syscall.InvalidHandle)) {
+				break
 			}
 		}
 	}
@@ -272,48 +292,49 @@ func (r *readdcw) RecursiveWatch(path string, event Event) error {
 // 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) {
+func (r *readdcw) watch(path string, event Event, recursive bool) 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()
+	defer r.Unlock()
+
+	if wd, ok := r.m[path]; ok {
+		dbgprint("watch: already exists")
+		wd.filter &^= stateUnwatch
+		return nil
 	}
+
+	if err := r.lazyinit(); err != nil {
+		return err
+	}
+
+	wd, err := newWatched(r.cph, uint32(event), recursive, path)
+	if err != nil {
+		return err
+	}
+
+	r.m[path] = wd
+	dbgprint("watch: new watch added")
+
 	return nil
 }
 
-// lazyinit creates an I/O completion port and starts the main event processing
-// loop. This method uses Double-Checked Locking optimization.
+// lazyinit creates an I/O completion port and starts the main event loop.
 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()
+		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
 }
 
@@ -337,33 +358,33 @@ func (r *readdcw) loop() {
 			continue
 		}
 		overEx := (*overlappedEx)(unsafe.Pointer(overlapped))
-		if n == 0 {
-			r.loopstate(overEx)
-		} else {
+		if n != 0 {
 			r.loopevent(n, overEx)
 			if err = overEx.parent.readDirChanges(); err != nil {
 				// TODO: error handling
 			}
 		}
+		r.loopstate(overEx)
 	}
 }
 
 // TODO(pknap) : doc
 func (r *readdcw) loopstate(overEx *overlappedEx) {
-	filter := atomic.LoadUint32(&overEx.parent.parent.filter)
+	r.Lock()
+	defer r.Unlock()
+	filter := 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()
+			dbgprint("loopstate rewatch")
 			overEx.parent.parent.recreate(r.cph)
-			r.Unlock()
 		case stateUnwatch:
-			r.Lock()
+			dbgprint("loopstate unwatch")
+			overEx.parent.parent.closeHandle()
 			delete(r.m, syscall.UTF16ToString(overEx.parent.pathw))
-			r.Unlock()
 		case stateCPClose:
 		default:
 			panic(`notify: windows loopstate logic error`)
@@ -450,8 +471,8 @@ func (r *readdcw) rewatch(path string, oldevent, newevent uint32, recursive bool
 	}
 	var wd *watched
 	r.Lock()
-	if wd, err = r.nonStateWatched(path); err != nil {
-		r.Unlock()
+	defer r.Unlock()
+	if wd, err = r.nonStateWatchedLocked(path); err != nil {
 		return
 	}
 	if wd.filter&(onlyNotifyChanges|onlyNGlobalEvents) != oldevent {
@@ -462,21 +483,19 @@ func (r *readdcw) rewatch(path string, oldevent, newevent uint32, recursive bool
 	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) {
+func (r *readdcw) nonStateWatchedLocked(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 {
+	if wd.filter&onlyMachineStates != 0 {
 		err = errors.New(`notify: another re/unwatching operation in progress`)
 		return
 	}
@@ -496,18 +515,30 @@ func (r *readdcw) RecursiveUnwatch(path string) error {
 // 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()
+	defer r.Unlock()
+	if wd, err = r.nonStateWatchedLocked(path); err != nil {
 		return
 	}
+
 	wd.filter |= stateUnwatch
-	if err = wd.closeHandle(); err != nil {
-		wd.filter &^= stateUnwatch
-		r.Unlock()
-		return
+	dbgprint("unwatch: set unwatch state")
+
+	if _, attrErr := syscall.GetFileAttributes(&wd.pathw[0]); attrErr != nil {
+		for _, g := range wd.digrip {
+			if g == nil {
+				continue
+			}
+
+			dbgprint("unwatch: posting")
+			if err = syscall.PostQueuedCompletionStatus(r.cph, 0, 0, (*syscall.Overlapped)(unsafe.Pointer(g.ovlapped))); err != nil {
+				wd.filter &^= stateUnwatch
+				return
+			}
+		}
 	}
-	r.Unlock()
+
 	return
 }
 
diff --git a/vendor/github.com/rjeczalik/notify/watcher_stub.go b/vendor/github.com/rjeczalik/notify/watcher_stub.go
index 68b9c135b0..9b284ddc85 100644
--- a/vendor/github.com/rjeczalik/notify/watcher_stub.go
+++ b/vendor/github.com/rjeczalik/notify/watcher_stub.go
@@ -1,23 +1,13 @@
-// Copyright (c) 2014-2015 The Notify Authors. All rights reserved.
+// Copyright (c) 2014-2018 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,!solaris
-
 package notify
 
-import "errors"
-
-type stub struct{ error }
-
-// newWatcher stub.
-func newWatcher(chan<- EventInfo) watcher {
-	return stub{errors.New("notify: not implemented")}
-}
+type watcherStub struct{ error }
 
 // 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 }
+func (s watcherStub) Watch(string, Event) error          { return s }
+func (s watcherStub) Rewatch(string, Event, Event) error { return s }
+func (s watcherStub) Unwatch(string) (err error)         { return s }
+func (s watcherStub) Close() error                       { return s }
diff --git a/vendor/github.com/rjeczalik/notify/watcher_trigger.go b/vendor/github.com/rjeczalik/notify/watcher_trigger.go
index f25a6fcbf4..1ebe04829e 100644
--- a/vendor/github.com/rjeczalik/notify/watcher_trigger.go
+++ b/vendor/github.com/rjeczalik/notify/watcher_trigger.go
@@ -23,6 +23,7 @@
 package notify
 
 import (
+	"fmt"
 	"os"
 	"path/filepath"
 	"strings"
@@ -56,9 +57,22 @@ type trigger interface {
 	IsStop(n interface{}, err error) bool
 }
 
+// trgWatched is a the base data structure representing watched file/directory.
+// The platform specific full data structure (watched) must embed this type.
+type trgWatched struct {
+	// p is a path to watched file/directory.
+	p string
+	// fi provides information about watched file/dir.
+	fi os.FileInfo
+	// eDir represents events watched directly.
+	eDir Event
+	// eNonDir represents events watched indirectly.
+	eNonDir Event
+}
+
 // encode Event to native representation. Implementation is to be provided by
 // platform specific implementation.
-var encode func(Event) int64
+var encode func(Event, bool) int64
 
 var (
 	// nat2not matches native events to notify's ones. To be initialized by
@@ -92,7 +106,8 @@ func newWatcher(c chan<- EventInfo) watcher {
 	}
 	t.t = newTrigger(t.pthLkp)
 	if err := t.t.Init(); err != nil {
-		panic(err)
+		t.Close()
+		return watcherStub{fmt.Errorf("failed setting up watcher: %v", err)}
 	}
 	go t.monitor()
 	return t
@@ -117,6 +132,9 @@ func (t *trg) Close() (err error) {
 		dbgprintf("trg: closing native watch failed: %q\n", e)
 		err = nonil(err, e)
 	}
+	if remaining := len(t.pthLkp); remaining != 0 {
+		err = nonil(err, fmt.Errorf("Not all watches were removed: len(t.pthLkp) == %v", len(t.pthLkp)))
+	}
 	t.Unlock()
 	return
 }
@@ -145,13 +163,7 @@ func (t *trg) singlewatch(p string, e Event, direct mode, fi os.FileInfo) (err e
 		w.eDir |= e
 		w.eNonDir |= e
 	}
-	var ee int64
-	// Native Write event is added to wait for Create events (Write event on
-	// directory triggers it's rescan).
-	if e&Create != 0 && fi.IsDir() {
-		ee = int64(not2nat[Write])
-	}
-	if err = t.t.Watch(fi, w, encode(w.eDir|w.eNonDir)|ee); err != nil {
+	if err = t.t.Watch(fi, w, encode(w.eDir|w.eNonDir, fi.IsDir())); err != nil {
 		return
 	}
 	if !ok {
@@ -181,7 +193,7 @@ func decode(o int64, w Event) (e Event) {
 func (t *trg) watch(p string, e Event, fi os.FileInfo) error {
 	if err := t.singlewatch(p, e, dir, fi); err != nil {
 		if err != errAlreadyWatched {
-			return nil
+			return err
 		}
 	}
 	if fi.IsDir() {
@@ -290,7 +302,7 @@ func (t *trg) dir(w *watched, n interface{}, e, ge Event) (evn []event) {
 	// However events for rename must be generated for all monitored files
 	// inside of moved directory, because native impl does not report it independently
 	// for each file descriptor being moved in result of move action on
-	// parent dirLiczba dostępnych dni urlopowych: 0ectory.
+	// parent directory.
 	if (ge & (not2nat[Rename] | not2nat[Remove])) != 0 {
 		// Write is reported also for Remove on directory. Because of that
 		// we have to filter it out explicitly.
@@ -367,7 +379,7 @@ func (t *trg) singleunwatch(p string, direct mode) error {
 	}
 	if w.eNonDir|w.eDir != 0 {
 		mod := dir
-		if w.eNonDir == 0 {
+		if w.eNonDir != 0 {
 			mod = ndir
 		}
 		if err := t.singlewatch(p, w.eNonDir|w.eDir, mod,
@@ -399,7 +411,7 @@ func (t *trg) monitor() {
 	}
 }
 
-// process event returned by port_get call.
+// process event returned by native call.
 func (t *trg) process(n interface{}) (evn []event) {
 	t.Lock()
 	w, ge, err := t.t.Watched(n)
@@ -414,13 +426,13 @@ func (t *trg) process(n interface{}) (evn []event) {
 		switch fi, err := os.Stat(w.p); {
 		case err != nil:
 		default:
-			if err = t.t.Watch(fi, w, (encode(w.eDir | w.eNonDir))); err != nil {
+			if err = t.t.Watch(fi, w, encode(w.eDir|w.eNonDir, fi.IsDir())); err != nil {
 				dbgprintf("trg: %q is no longer watched: %q", w.p, err)
 				t.t.Del(w)
 			}
 		}
 	}
-	if e == Event(0) {
+	if e == Event(0) && (!w.fi.IsDir() || (ge&int64(not2nat[Write])) == 0) {
 		t.Unlock()
 		return
 	}
diff --git a/vendor/github.com/rjeczalik/notify/watchpoint_other.go b/vendor/github.com/rjeczalik/notify/watchpoint_other.go
index 881631c99d..9bb381db77 100644
--- a/vendor/github.com/rjeczalik/notify/watchpoint_other.go
+++ b/vendor/github.com/rjeczalik/notify/watchpoint_other.go
@@ -15,7 +15,7 @@ func eventmask(ei EventInfo, extra Event) Event {
 // 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
+//   - 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 {