Add Solaris FEN using EventPorts from x/sys/unix

.github/workflows/slow-tests.yml

@@ -0,0 +1,17 @@
+name: slow-tests
+on: [workflow_dispatch]
+jobs:
+  test-illumos:
+    runs-on: macos-10.15
+    name: Test in illumos VM
+    steps:
+    - uses: actions/checkout@v2
+    - name: Test on illumos
+      id: test
+      uses: papertigers/illumos-vm@main
+      with:
+        prepare: |
+          pkg set-publisher -r -O https://pkg.omnios.org/r151036/extra extra.omnios
+          pkg install go-117
+        run: |
+          /opt/ooce/go-1.17/bin/go test

AUTHORS

@@ -26,14 +26,17 @@ Eric Lin <linxiulei@gmail.com>
 Evan Phoenix <evan@fallingsnow.net>
 Francisco Souza <f@souza.cc>
 Gautam Dey <gautam.dey77@gmail.com>
+Gereon Frey <gereon.frey@gmail.com>
 Hari haran <hariharan.uno@gmail.com>
 Ichinose Shogo <shogo82148@gmail.com>
+Isaac Davis <isaac.davis@joyent.com>
 Johannes Ebke <johannes@ebke.org>
 John C Barstow <jbowtie@amathaine.com>
 Kelvin Fo <vmirage@gmail.com>
 Ken-ichirou MATSUZAWA <chamas@h4.dion.ne.jp>
 Matt Layher <mdlayher@gmail.com>
 Matthias Stone <matthias@bellstone.ca>
+Nahum Shalman <nahamu@gmail.com>
 Nathan Youngman <git@nathany.com>
 Nickolai Zeldovich <nickolai@csail.mit.edu>
 Oliver Bristow <evilumbrella+github@gmail.com>

CHANGELOG.md

@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## v1.6.0 / 2022-01-28
+
+* Solaris: add support for File Event Notifications (fen) [#12](https://github.com/fsnotify/fsnotify/issues/12)
+
 ## [1.5.1] - 2021-08-24
 
 * Revert Add AddRaw to not follow symlinks

LICENSE

@@ -1,5 +1,5 @@
 Copyright (c) 2012 The Go Authors. All rights reserved.
-Copyright (c) 2012-2019 fsnotify Authors. All rights reserved.
+Copyright (c) 2012-2022 fsnotify Authors. All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are

README.md

@@ -6,15 +6,15 @@
 
 fsnotify utilizes [golang.org/x/sys](https://godoc.org/golang.org/x/sys) rather than `syscall` from the standard library. 
 
-Cross platform: Windows, Linux, BSD and macOS.
+Cross platform: Windows, Linux, BSD, macOS, and Solaris/illumos.
 
 | Adapter               | OS                               | Status                                                                                                                          |
 | --------------------- | -------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
 | inotify               | Linux 2.6.27 or later, Android\* | Supported |
 | kqueue                | BSD, macOS, iOS\*                | Supported |
 | ReadDirectoryChangesW | Windows                          | Supported |
 | FSEvents              | macOS                            | [Planned](https://github.com/fsnotify/fsnotify/issues/11)                                                                       |
-| FEN                   | Solaris 11                       | [In Progress](https://github.com/fsnotify/fsnotify/pull/371)                                                                   |
+| FEN                   | Solaris 11, illumos              | Supported |
 | fanotify              | Linux 2.6.37+                    | [Maybe](https://github.com/fsnotify/fsnotify/issues/114)                                                                      |
 | USN Journals          | Windows                          | [Maybe](https://github.com/fsnotify/fsnotify/issues/53)                                                                         |
 | Polling               | *All*                            | [Maybe](https://github.com/fsnotify/fsnotify/issues/9)                                                                          |

fen.go

@@ -9,30 +9,299 @@ package fsnotify
 
 import (
 	"errors"
+	"fmt"
+	"golang.org/x/sys/unix"
+	"io/ioutil"
+	"os"
+	"path/filepath"
 )
 
 // Watcher watches a set of files, delivering events to a channel.
 type Watcher struct {
 	Events chan Event
 	Errors chan error
+
+	port *unix.EventPort
+
+	done chan struct{} // Channel for sending a "quit message" to the reader goroutine
 }
 
 // NewWatcher establishes a new watcher with the underlying OS and begins waiting for events.
 func NewWatcher() (*Watcher, error) {
-	return nil, errors.New("FEN based watcher not yet supported for fsnotify\n")
+	var err error
+
+	w := new(Watcher)
+	w.Events = make(chan Event)
+	w.Errors = make(chan error)
+	w.port, err = unix.NewEventPort()
+	if err != nil {
+		return nil, err
+	}
+	w.done = make(chan struct{})
+
+	go w.readEvents()
+	return w, nil
+}
+
+// sendEvent attempts to send an event to the user, returning true if the event
+// was put in the channel successfully and false if the watcher has been closed.
+func (w *Watcher) sendEvent(e Event) (sent bool) {
+	select {
+	case w.Events <- e:
+		return true
+	case <-w.done:
+		return false
+	}
+}
+
+// sendError attempts to send an error to the user, returning true if the error
+// was put in the channel successfully and false if the watcher has been closed.
+func (w *Watcher) sendError(err error) (sent bool) {
+	select {
+	case w.Errors <- err:
+		return true
+	case <-w.done:
+		return false
+	}
+}
+
+func (w *Watcher) isClosed() bool {
+	select {
+	case <-w.done:
+		return true
+	default:
+		return false
+	}
 }
 
 // Close removes all watches and closes the events channel.
 func (w *Watcher) Close() error {
+	if w.isClosed() {
+		return nil
+	}
+	close(w.done)
+	w.port.Close()
 	return nil
 }
 
 // Add starts watching the named file or directory (non-recursively).
 func (w *Watcher) Add(name string) error {
-	return nil
+	if w.isClosed() {
+		return errors.New("FEN watcher already closed")
+	}
+	if w.port.PathIsWatched(name) {
+		return nil
+	}
+	stat, err := os.Stat(name)
+	switch {
+	case err != nil:
+		return err
+	case stat.IsDir():
+		return w.handleDirectory(name, stat, w.associateFile)
+	default:
+		return w.associateFile(name, stat)
+	}
 }
 
 // Remove stops watching the the named file or directory (non-recursively).
 func (w *Watcher) Remove(name string) error {
+	if w.isClosed() {
+		return errors.New("FEN watcher already closed")
+	}
+	if !w.port.PathIsWatched(name) {
+		return fmt.Errorf("can't remove non-existent FEN watch for: %s", name)
+	}
+	stat, err := os.Stat(name)
+	switch {
+	case err != nil:
+		return err
+	case stat.IsDir():
+		return w.handleDirectory(name, stat, w.dissociateFile)
+	default:
+		return w.port.DissociatePath(name)
+	}
+}
+
+// readEvents contains the main loop that runs in a goroutine watching for events.
+func (w *Watcher) readEvents() {
+	// If this function returns, the watcher has been closed and we can
+	// close these channels
+	defer close(w.Errors)
+	defer close(w.Events)
+
+	pevents := make([]unix.PortEvent, 8, 8)
+	for {
+		count, err := w.port.Get(pevents, 1, nil)
+		if err != nil {
+			// Interrupted system call (count should be 0) ignore and continue
+			if err == unix.EINTR && count == 0 {
+				continue
+			}
+			// Get failed because we called w.Close()
+			if err == unix.EBADF && w.isClosed() {
+				return
+			}
+			// There was an error not caused by calling w.Close()
+			if !w.sendError(err) {
+				return
+			}
+		}
+
+		p := pevents[:count]
+		for _, pevent := range p {
+			if pevent.Source != unix.PORT_SOURCE_FILE {
+				// Event from unexpected source received; should never happen.
+				if !w.sendError(errors.New("Event from unexpected source received")) {
+					return
+				}
+				continue
+			}
+
+			err = w.handleEvent(&pevent)
+			if err != nil {
+				if !w.sendError(err) {
+					return
+				}
+			}
+		}
+	}
+}
+
+func (w *Watcher) handleDirectory(path string, stat os.FileInfo, handler func(string, os.FileInfo) error) error {
+	files, err := ioutil.ReadDir(path)
+	if err != nil {
+		return err
+	}
+
+	// Handle all children of the directory.
+	for _, finfo := range files {
+		if !finfo.IsDir() {
+			err := handler(filepath.Join(path, finfo.Name()), finfo)
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	// And finally handle the directory itself.
+	return handler(path, stat)
+}
+
+// handleEvent might need to emit more than one fsnotify event
+// if the events bitmap matches more than one event type
+// (e.g. the file was both modified and had the
+// attributes changed between when the association
+// was created and the when event was returned)
+func (w *Watcher) handleEvent(event *unix.PortEvent) error {
+	events := event.Events
+	path := event.Path
+	fmode := event.Cookie.(os.FileMode)
+
+	var toSend *Event
+	reRegister := true
+
+	fmt.Printf("NAHUM: %b\n", events)
+
+	if events&unix.FILE_MODIFIED == unix.FILE_MODIFIED{
+		if fmode.IsDir() {
+			if err := w.updateDirectory(path); err != nil {
+				return err
+			}
+		} else {
+			toSend = &Event{path, Write}
+			if !w.sendEvent(*toSend) {
+				return nil
+			}
+		}
+	}
+	if events&unix.FILE_ATTRIB == unix.FILE_ATTRIB{
+		toSend = &Event{path, Chmod}
+		if !w.sendEvent(*toSend) {
+			return nil
+		}
+	}
+	if events&unix.FILE_DELETE == unix.FILE_DELETE{
+		toSend = &Event{path, Remove}
+		if !w.sendEvent(*toSend) {
+			return nil
+		}
+		reRegister = false
+	}
+	if events&unix.FILE_RENAME_FROM == unix.FILE_RENAME_FROM{
+		toSend = &Event{path, Rename}
+		if !w.sendEvent(*toSend) {
+			return nil
+		}
+		// Don't keep watching the new file name
+		reRegister = false
+	}
+	if events&unix.FILE_RENAME_TO == unix.FILE_RENAME_TO{
+		// We don't report a Rename event for this case, because
+		// Rename events are interpreted as referring to the _old_ name
+		// of the file, and in this case the event would refer to the
+		// new name of the file. This type of rename event is not
+		// supported by fsnotify.
+
+		// inotify reports a Remove event in this case, so we simulate
+		// this here.
+		toSend = &Event{path, Remove}
+		if !w.sendEvent(*toSend) {
+			return nil
+		}
+		// Don't keep watching the file that was removed
+		reRegister = false
+	}
+
+	if !reRegister {
+		return nil
+	}
+
+	// If we get here, it means we've hit an event above that requires us to
+	// continue watching the file or directory
+	stat, err := os.Stat(path)
+	if err != nil {
+		return err
+	}
+	return w.associateFile(path, stat)
+}
+
+func (w *Watcher) updateDirectory(path string) error {
+	// The directory was modified, so we must find unwatched entites and
+	// watch them. If something was removed from the directory, nothing will
+	// happen, as everything else should still be watched.
+	files, err := ioutil.ReadDir(path)
+	if err != nil {
+		return err
+	}
+
+	for _, finfo := range files {
+		path := filepath.Join(path, finfo.Name())
+		if w.port.PathIsWatched(path) {
+			continue
+		}
+
+		err := w.associateFile(path, finfo)
+		if err != nil {
+			if !w.sendError(err) {
+				return nil
+			}
+		}
+		if !w.sendEvent(Event{path, Create}) {
+			return nil
+		}
+	}
 	return nil
 }
+
+func (w *Watcher) associateFile(path string, stat os.FileInfo) error {
+	mode := unix.FILE_MODIFIED | unix.FILE_ATTRIB | unix.FILE_NOFOLLOW
+	fmode := stat.Mode()
+	return w.port.AssociatePath(path, stat, mode, fmode)
+}
+
+func (w *Watcher) dissociateFile(path string, stat os.FileInfo) error {
+	if !w.port.PathIsWatched(path) {
+		return nil
+	}
+	return w.port.DissociatePath(path)
+}

go.mod

@@ -2,6 +2,6 @@ module github.com/fsnotify/fsnotify
 
 go 1.16
 
-require golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c
+require golang.org/x/sys v0.0.0-20210817134402-fefb4affbef3
 
 retract v1.5.0

integration_test.go

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build !plan9 && !solaris
-// +build !plan9,!solaris
+//go:build !plan9
+// +build !plan9
 
 package fsnotify