Cross-platform file system notifications for Go.

Related tags

File System fsnotify
Overview

File system notifications for Go

GoDoc Go Report Card

fsnotify utilizes golang.org/x/sys rather than syscall from the standard library. Ensure you have the latest version installed by running:

go get -u golang.org/x/sys/...

Cross platform: Windows, Linux, BSD and macOS.

Adapter OS Status
inotify Linux 2.6.27 or later, Android* Supported
kqueue BSD, macOS, iOS* Supported
ReadDirectoryChangesW Windows Supported
FSEvents macOS Planned
FEN Solaris 11 In Progress
fanotify Linux 2.6.37+ Planned
USN Journals Windows Maybe
Polling All Maybe

* Android and iOS are untested.

Please see the documentation and consult the FAQ for usage information.

API stability

fsnotify is a fork of howeyc/fsnotify with a new API as of v1.0. The API is based on this design document.

All releases are tagged based on Semantic Versioning. Further API changes are planned, and will be tagged with a new major revision number.

Go 1.6 supports dependencies located in the vendor/ folder. Unless you are creating a library, it is recommended that you copy fsnotify into vendor/github.com/fsnotify/fsnotify within your project, and likewise for golang.org/x/sys.

Usage

package main

import (
	"log"

	"github.com/fsnotify/fsnotify"
)

func main() {
	watcher, err := fsnotify.NewWatcher()
	if err != nil {
		log.Fatal(err)
	}
	defer watcher.Close()

	done := make(chan bool)
	go func() {
		for {
			select {
			case event, ok := <-watcher.Events:
				if !ok {
					return
				}
				log.Println("event:", event)
				if event.Op&fsnotify.Write == fsnotify.Write {
					log.Println("modified file:", event.Name)
				}
			case err, ok := <-watcher.Errors:
				if !ok {
					return
				}
				log.Println("error:", err)
			}
		}
	}()

	err = watcher.Add("/tmp/foo")
	if err != nil {
		log.Fatal(err)
	}
	<-done
}

Contributing

Please refer to CONTRIBUTING before opening an issue or pull request.

Example

See example_test.go.

FAQ

When a file is moved to another directory is it still being watched?

No (it shouldn't be, unless you are watching where it was moved to).

When I watch a directory, are all subdirectories watched as well?

No, you must add watches for any directory you want to watch (a recursive watcher is on the roadmap #18).

Do I have to watch the Error and Event channels in a separate goroutine?

As of now, yes. Looking into making this single-thread friendly (see howeyc #7)

Why am I receiving multiple events for the same file on OS X?

Spotlight indexing on OS X can result in multiple events (see howeyc #62). A temporary workaround is to add your folder(s) to the Spotlight Privacy settings until we have a native FSEvents implementation (see #11).

How many files can be watched at once?

There are OS-specific limits as to how many watches can be created:

  • Linux: /proc/sys/fs/inotify/max_user_watches contains the limit, reaching this limit results in a "no space left on device" error.
  • BSD / OSX: sysctl variables "kern.maxfiles" and "kern.maxfilesperproc", reaching these limits results in a "too many open files" error.

Why don't notifications work with NFS filesystems or filesystem in userspace (FUSE)?

fsnotify requires support from underlying OS to work. The current NFS protocol does not provide network level support for file notifications.

Related Projects

Issues
  • Does not work in powerpc64 or arm64

    Does not work in powerpc64 or arm64

    Hi,

    I package prometheus for Debian. And I am getting build errors in ppc64el, which seem to originate in fsnotify. If I try to run fsnotify's tests there I get all kind of failures, and a hang:

    github.com/go-fsnotify/fsnotify
       dh_auto_test -O--buildsystem=golang
        go test -v github.com/go-fsnotify/fsnotify
    === RUN   TestPollerWithBadFd
    --- PASS: TestPollerWithBadFd (0.00s)
    === RUN   TestPollerWithData
    --- FAIL: TestPollerWithData (0.00s)
        inotify_poller_test.go:85: expected poller to return true
    === RUN   TestPollerWithWakeup
    --- PASS: TestPollerWithWakeup (0.00s)
    === RUN   TestPollerWithClose
    --- FAIL: TestPollerWithClose (0.00s)
        inotify_poller_test.go:119: expected poller to return true
    === RUN   TestPollerWithWakeupAndData
    --- FAIL: TestPollerWithWakeupAndData (0.00s)
        inotify_poller_test.go:140: expected poller to return true
    === RUN   TestPollerConcurrent
    --- FAIL: TestPollerConcurrent (0.05s)
        inotify_poller_test.go:197: expected true
    === RUN   TestInotifyCloseRightAway
    --- PASS: TestInotifyCloseRightAway (0.05s)
    === RUN   TestInotifyCloseSlightlyLater
    --- PASS: TestInotifyCloseSlightlyLater (0.10s)
    === RUN   TestInotifyCloseSlightlyLaterWithWatch
    --- PASS: TestInotifyCloseSlightlyLaterWithWatch (0.10s)
    === RUN   TestInotifyCloseAfterRead
    --- PASS: TestInotifyCloseAfterRead (0.10s)
    === RUN   TestInotifyCloseCreate
    --- FAIL: TestInotifyCloseCreate (0.05s)
        inotify_test.go:136: Took too long to wait for event
    === RUN   TestInotifyStress
    --- FAIL: TestInotifyStress (5.00s)
        inotify_test.go:238: Expected at least 50 creates, got 0
    === RUN   TestInotifyRemoveTwice
    --- PASS: TestInotifyRemoveTwice (0.00s)
    === RUN   TestInotifyInnerMapLength
    
    signal: terminated
    FAIL    github.com/go-fsnotify/fsnotify 348.362s
    
    defect Linux (inotify) investigate 
    opened by NightTsarina 39
  • add Solaris FEN support

    add Solaris FEN support

    This pull request fixes #12.

    I'm an employee of Joyent, Inc., and have completed the Google corporate CLA.

    What does this pull request do?

    This pull request adds fsnotify support for Solaris and illumos via Solaris FEN. It is heavily based on #196, authored by @gfrey. As such, and with his approval, I have added @gfrey in the AUTHORS file in addition to myself.

    One major revision to @gfrey's work concerns liveness when the watcher is closed when there is an unconsumed event in the channel - the old pull request would sometimes hang on the TestWatcherClose test. The new concurrency model is borrowed from fsnotify's inotify implementation.

    Another major revision concerns proper translation of FEN events to fsnotify events, in particular the FILE_RENAME_TO FEN event.

    Where should the reviewer start?

    These pages are useful as an introduction to FEN:

    • https://xnet.fi/solaris/
    • https://solarisrants.wordpress.com/2013/07/24/solaris-file-event-notification/

    The illumos man pages for port_create and related functions are also helpful for understanding how to interface with FEN.

    The discussion on #196 is also worth reading. Some points I'll address here:

    • The use of syscall appears necessary here because golang.org/x/sys/unix does not (to my knowledge) provide a way to get atime and ctime.
    • cgo is used because, for illumos, the officially supported interface to the OS is libc rather than syscalls, and thus user-level code should refrain from making syscalls directly.

    How should this be manually tested?

    I ran all tests on a SmartOS host. On SmartOS, Go can be installed from Joyent's pkgsrc repository. fsnotify can then be built and tested as normal.

    Solaris (FEN) 
    opened by isaacdavis 34
  • Could we please get back the master-branch on this repository?

    Could we please get back the master-branch on this repository?

    This request not about anything else but to get our build scripts to run again.

    In our scenario, we use Yocto and its meta-layer meta-virtualization, which includes a script of how to generate this package. Until 12 days ago, the repository from where to pull the codebase was noted as git://github.com/fsnotify/fsnotify.git;branch=master;protocol=https. Since the branch master was removed from this repository, all previous states of the repository cannot be used to build a valid Linux distribution without first having to change the branch name.

    For us this now creates a really big challenge between not being able to build. Solutions we see on our side are getting everything up to date, which would require a ton of time and testing; or to just fork the repo and having to maintain it ourselves from the state we're now on - more maintenance.

    I guess many other people are facing the same problem, where I just want to ask - what's wrong with keeping it called master vs breaking almost any build script which relies on the existence of the branch?

    opened by SimonSimCity 28
  • inotify: code cleanup. Closing watcher should now always shut down goroutine

    inotify: code cleanup. Closing watcher should now always shut down goroutine

    fixes go-fsnotify/fsnotify#3

    Also fixed a racey access to w.watches in Close.

    I put the tests in notify_test.go, so it doesn't break any other builds. These tests should be checked against the other platforms one by one before pulling them into integration_test.go.

    opened by PieterD 25
  • Maintainers wanted

    Maintainers wanted

    I think it makes sense to split fsnotify out into smaller platform-specific libraries that fsnotify (or alternatives) can use. Each library needs maintainers to go off and create the library with integration tests and documentation, and to handle issues and code reviews on an ongoing basis.

    • fsevents is one such library, currently in progress (macOS)
    • inotify for Linux is another, see #173 for my thoughts on it
    • Windows also needs a library
    • kqueue for BSD (and macOS, iOS)
    • poller for Plan9, NFS shares, Sharepoint volumes, etc.
    • also FEN for Solaris

    Are you interested?

    related: https://github.com/pickhardt/maintainers-wanted

    letter posted to forum: https://groups.google.com/forum/#!topic/golang-nuts/Ix4sg_gDLNE

    help-wanted 
    opened by nathany 23
  • Add support for solaris FEN

    Add support for solaris FEN

    Fixes #12 I've signed the CLA.

    What does this pull request do?

    This is a basic implementation of fsnotify for Solaris FEN. It at least passes all integration tests.

    Where should the reviewer start?

    I used the following two resource to get a basic understanding how this should work:

    • https://solarisrants.wordpress.com/2013/07/24/solaris-file-event-notification/
    • https://blogs.oracle.com/praks/entry/file_events_notification

    How should this be manually tested?

    The available integration tests are enabled for solaris now and succeed.

    Solaris (FEN) help-wanted 
    opened by gfrey 20
  • Received EINTR on error chan

    Received EINTR on error chan

    I just got this: Error from fsnotify: read: interrupted system call

    At first glance, this does not look like something that was meant to happen, but I may be mistaken. I don't know what caused it, and I have not yet had time to reproduce it, but I could give it a shot if you wish.

    opened by PieterD 17
  • Watch.Add improvements (avoid race, fix consistency, reduce garbage)

    Watch.Add improvements (avoid race, fix consistency, reduce garbage)

    This PR fixes two potential problems in Watch.Add in inotify.go:

    • Race when Add() is called concurrently.
    • Incorrect flags stored when InotifyAddWatch fails.

    In addition, it re-uses the existing watch entry when modifying an existing watch.

    The individual commits contain more details.

    Linux (inotify) 
    opened by twpayne 15
  • Inotify: fix watcher.watches and paths leaks

    Inotify: fix watcher.watches and paths leaks

    Thanks to @PieterD Watcher.Close() can stop goroutine cleanly. But I think watches and paths map still leaks, and feel a bit strange Remove() invalid filename returns differently between at first time and after. I tried to fix those, would you revew the patches?

    Linux (inotify) 
    opened by chamaken 15
  • Date race

    Date race

    While race testing some of my code I got the following. Seems like watcher are being close although they have been already removed...

    WARNING: DATA RACE
    Write by goroutine 101:
      runtime.mapdelete()
          /usr/local/Cellar/go/1.5.1/libexec/src/runtime/hashmap.go:511 +0x0
      ./vendor/gopkg.in/fsnotify%2ev1.(*Watcher).Remove()
          ./vendor/gopkg.in/fsnotify.v1/kqueue.go:119 +0x4ed
      ./vendor/gopkg.in/fsnotify%2ev1.(*Watcher).readEvents()
          ./vendor/gopkg.in/fsnotify.v1/kqueue.go:291 +0x878
    
    Previous read by goroutine 189:
      runtime.mapiternext()
          /usr/local/Cellar/go/1.5.1/libexec/src/runtime/hashmap.go:621 +0x0
      ./vendor/gopkg.in/fsnotify%2ev1.(*Watcher).Close()
          ./vendor/gopkg.in/fsnotify.v1/kqueue.go:80 +0x233
      ./vendor/gopkg.in/fsnotify%2ev1.(*Watcher).Close-fm()
          ./foo/foo.go:157 +0x3b
      ..LogCloseError()
          ./log_close_error.go:9 +0x48
      ./foo.(*fooReader).monitor.func1()
          ./foo/foo.go:178 +0x512
    
    Goroutine 101 (running) created at:
      ./vendor/gopkg.in/fsnotify%2ev1.NewWatcher()
          ./vendor/gopkg.in/fsnotify.v1/kqueue.go:61 +0x443
      ./foo.(*fooReader).monitor()
          ./foo/foo.go:146 +0x58
      ./foo.New()
          ./foo/foo.go:48 +0x31b
      ./foo_test.TestClosing()
          ./foo/foo_test.go:118 +0x3e2
      testing.tRunner()
          /usr/local/Cellar/go/1.5.1/libexec/src/testing/testing.go:456 +0xdc
    
    Goroutine 189 (running) created at:
      ./foo.(*fooReader).monitor()
          ./foo/foo.go:181 +0x228
      ./foo.New()
          ./foo/foo.go:48 +0x31b
      ./foo_test.TestClosing()
          ./foo/foo_test.go:118 +0x3e2
      testing.tRunner()
          /usr/local/Cellar/go/1.5.1/libexec/src/testing/testing.go:456 +0xdc
    ==================
    Found 1 data race(s)
    
    defect macOS (kqueue) BSD (kqueue) 
    opened by djui 14
  • Fixes inotify not notifying on deletion of open files.

    Fixes inotify not notifying on deletion of open files.

    What does this pull request do?

    Fixes issue #194: no notification arrives when a file with open handles is deleted. The change essentially stops ignoring the Chmod notification when the file in question does not exist. Such situation can arise on Linux, when a process holds an open handle for the file and the file is being deleted. In that case the watcher receives an IN_ATTRIB notification to indicate the changed count of hard links to the file. But the file will not be actually deleted from disk until all open handles are closed, and correspondingly IN_DELETE_SELF notifications will be postponed until then. With this change, a watcher process will receive a Chmod notification and have a chance to respond.

    Where should the reviewer start?

    The test explains the scenario well and can be a good place to understand it better.

    How should this be manually tested?

    A unit test is included and is executed as part of the CI build. The test fails without the code change.

    opened by vladlosev 13
  • Inconsistent behavior when watching for REMOVE event on single file

    Inconsistent behavior when watching for REMOVE event on single file

    I am using the latest fsnotify release v1.5.4.

    Describe the bug When a file that is being watched is removed, an event is triggered when running on macOS but not on Linux.

    To Reproduce

    Minimal reproducible example:

    package main
    
    import (
    	"github.com/fsnotify/fsnotify"
    	"log"
    	"os"
    	"time"
    )
    
    func main() {
    	file, _ := os.CreateTemp("", "fsnotify-issue-reproduction")
    
    	watcher, _ := fsnotify.NewWatcher()
    	_ = watcher.Add(file.Name())
    
    	ch := make(chan struct{})
    
    	go func() {
    		select {
    		case event, _ := <-watcher.Events:
    			log.Printf("%v", event)
    		case <-time.After(1 * time.Second):
    			log.Println("Event not received!")
    		}
                    ch <- struct{}{}
    	}()
    
    	_ = os.Remove(file.Name())
    	<-ch
    }
    

    When on macOS, a REMOVE event's details are printed, while on Linux Event not received! is printed.

    Expected behavior The output should either be consistent across platforms or a warning should be added to inform users of the library of the differences.

    Which operating system and version are you using?

    Linux: golang:1.18 Docker image

    macOS: ProductName: macOS ProductVersion: 11.6.7 BuildVersion: 20G630

    opened by denis-ismailaj 0
  • Watcher.Close panics on racing Close's due to double closing the done chan

    Watcher.Close panics on racing Close's due to double closing the done chan

    Before reporting an issue, please ensure you are using the latest release of fsnotify, and please search for existing issue to avoid duplicates.

    Describe the bug

    Watcher.Close() (as of today's master) currently does not protect the critical section of closing a watcher's internal done channel against racing Close calls here: https://github.com/fsnotify/fsnotify/blob/0f4b979323bea7ee6677faa4a88078ec558b1b80/inotify.go#L80. It can panic under racing Close calls due to the channel getting closed more than once, due to the ineffective guard using w.isClosed not being in a guarded critical section with its corresponding close. When two goroutines happen to be scheduled on racing OS threads and CPU cores they can pass the isClosed check at nearly the same time and then one of the racing threads/goroutine will attempt to close and already closed channel, triggering a runtime panic.

    opened by thediveo 0
  • No error when stopping watching a non watched file

    No error when stopping watching a non watched file

    What does this pull request do?

    Currently, when a non-watched item is requested to be removed from a watch, an error is returned. However, the post-condition of removing it is: "This file/dir should not be watched anymore", which is the case also when the item wasn't being watched in the first place. Rather than returning an error. Return nil and skip a part of the work.

    Where should the reviewer start?

    inotify.go, the Remove function definition.

    How should this be manually tested?

    We've noticed this because this lib is being used in promtail and it was logging errors because of this.

    opened by MidasLamb 4
  • windows: protect access to isClosed with mutex

    windows: protect access to isClosed with mutex

    isClosed may be read and modified concurrently on Windows if the Watcher is closed at the same time as a new entry being added. This change protects isClosed to prevent race conditions.

    The order of fields for the Windows Watcher have been rearranged to group fields protected by the mutex together to make it easier for reviewers to understand at a glance which fields are expected to be accessed through the mutex.

    opened by rfratto 0
  • False Positive REMOVE Events with Git Sync

    False Positive REMOVE Events with Git Sync

    Describe the bug

    We have an application that evaluates alerts rules specified as alert files in Github. We use git-sync side-car to sync these rules to a shared K8s volume. The application adds a fsNotify watch to this directory during bootstrap, and responds to its events. For example, if a PR is merged upstream that deletes an alert-rule file, a REMOVE event is sent and the application remove all the rules in that file.

    Screenshot 2022-05-16 at 1 32 40 PM

    However, I have observed that the application is receiving REMOVE events for all alert-rule files inside the directory being watched. This happens after it has run for some time after bootstrap. Since this happens for all alert-rule files, the application ultimately stops evaluating any alerts.

    Here are some logs. As soon as I receive the REMOVE event, I log the contents of entire directory. I receive the event for the file name present in the last log (ignoring removing rules):

    {"level":"DEBUG","time":"2022-05-16T08:20:27.162Z","caller":"orchestrator/orchestrator.go:174","message":"walked file name","fileName":"[redacted].yaml"}
    {"level":"DEBUG","time":"2022-05-16T08:20:27.162Z","caller":"orchestrator/orchestrator.go:174","message":"walked file name","fileName":"[redacted].yaml"}
    {"level":"DEBUG","time":"2022-05-16T08:20:27.162Z","caller":"orchestrator/orchestrator.go:174","message":"walked file name","fileName":"[redacted].yaml"}
    {"level":"DEBUG","time":"2022-05-16T08:20:27.162Z","caller":"orchestrator/orchestrator.go:174","message":"walked file name","fileName":"[redacted].yaml"}
    {"level":"DEBUG","time":"2022-05-16T08:20:27.162Z","caller":"orchestrator/orchestrator.go:174","message":"walked file name","fileName":"[redacted].yaml"}
    {"level":"DEBUG","time":"2022-05-16T08:20:27.162Z","caller":"orchestrator/orchestrator.go:174","message":"walked file name","fileName":"[redacted].yaml"}
    {"level":"DEBUG","time":"2022-05-16T08:20:27.162Z","caller":"orchestrator/orchestrator.go:174","message":"walked file name","fileName":"[redacted].yaml"}
    {"level":"DEBUG","time":"2022-05-16T08:20:27.162Z","caller":"orchestrator/orchestrator.go:174","message":"walked file name","fileName":"[redacted].yaml"}
    **{"level":"DEBUG","time":"2022-05-16T08:20:27.162Z","caller":"orchestrator/orchestrator.go:174","message":"walked file name","fileName":"test-file-obsv-700.yaml"}**
    {"level":"DEBUG","time":"2022-05-16T08:20:27.162Z","caller":"orchestrator/orchestrator.go:174","message":"walked file name","fileName":"resources"}
    {"level":"DEBUG","time":"2022-05-16T08:20:27.162Z","caller":"orchestrator/orchestrator.go:174","message":"walked file name","fileName":"[redacted].png"}
    {"level":"DEBUG","time":"2022-05-16T08:20:27.162Z","caller":"orchestrator/orchestrator.go:174","message":"walked file name","fileName":"[redacted].png"}
    {"level":"DEBUG","time":"2022-05-16T08:20:27.162Z","caller":"orchestrator/orchestrator.go:174","message":"walked file name","fileName":"[redacted]"}
    {"level":"DEBUG","time":"2022-05-16T08:20:27.162Z","caller":"orchestrator/orchestrator.go:174","message":"walked file name","fileName":"[redacted]yaml"}
    **{"level":"INFO","time":"2022-05-16T08:20:27.162Z","caller":"orchestrator/orchestrator.go:180","message":"ignoring removing rules","file":"/rules/{$commit}/production/test-file-obsv-700.yaml"}**
    
    

    As you can see, the application received a REMOVED event for test-file-obsv-700.yaml although it is present in the directory.

    To Reproduce

    Not exactly sure how this can be reproduced. It should not need this entire setup though.

    Expected behavior I am not expecting any REMOVE events as no alert-rule files are being deleted upstream.

    Which operating system and version are you using?

    K8s, image is based on golang-1.17-alpine for Linux.

    Additional context

    None

    opened by suddendust 0
  • GetPaths function to read out all watched paths.

    GetPaths function to read out all watched paths.

    I need to get the paths, which are watched by the fsNotify.Watcher. Because there is no .removeAll() function, I need to iterate over all watched Paths to then decide which Paths I want to remove.

    A Solution like .getAllWatchedPaths() to get the Path map/array.

    Target is, that I want to "Clear out" the Watcher, without closing and recreating it. I need just One single Instance to work with, and want more possibilities to manipulate, like .removeAll() , .getAllPaths() , .addMultiplePaths() etc...

    opened by chamabreu 0
Releases(v1.5.4)
  • v1.5.4(Apr 27, 2022)

    What's Changed

    • Fix compilation for OpenBSD by @mattn in https://github.com/fsnotify/fsnotify/pull/443
    • go.mod: use latest x/sys by @kevinburkesegment in https://github.com/fsnotify/fsnotify/pull/444
    • README.md: link to pkg.go.dev for golang.org/x/sys package by @tklauser in https://github.com/fsnotify/fsnotify/pull/441
    • Windows: add missing defer to Watcher.WatchList by @Sojamann in https://github.com/fsnotify/fsnotify/pull/447
    • Prepare for v1.5.4 by @shogo82148 in https://github.com/fsnotify/fsnotify/pull/448

    New Contributors

    • @mattn made their first contribution in https://github.com/fsnotify/fsnotify/pull/443
    • @kevinburkesegment made their first contribution in https://github.com/fsnotify/fsnotify/pull/444
    • @Sojamann made their first contribution in https://github.com/fsnotify/fsnotify/pull/447

    Full Changelog: https://github.com/fsnotify/fsnotify/compare/v1.5.2...v1.5.4

    Source code(tar.gz)
    Source code(zip)
  • v1.5.2(Apr 27, 2022)

    What's Changed

    • Removed dead link by @COil in https://github.com/fsnotify/fsnotify/pull/337
    • Update issue templates by @nathany in https://github.com/fsnotify/fsnotify/pull/410
    • Test on Go 1.18 and two most recent versions by @nathany in https://github.com/fsnotify/fsnotify/pull/411
    • fix go vet warnings: call to (*T).Fatalf from a non-test goroutine by @shogo82148 in https://github.com/fsnotify/fsnotify/pull/416
    • Run cross-compilation builds on every push by @nshalman in https://github.com/fsnotify/fsnotify/pull/420
    • Don't set poller.fd twice in newFdPoller by @tklauser in https://github.com/fsnotify/fsnotify/pull/406
    • Re-enable tests for PRs by @nshalman in https://github.com/fsnotify/fsnotify/pull/415
    • Enable cross-compilation builds on PRs by @nshalman in https://github.com/fsnotify/fsnotify/pull/423
    • Integration Tests: change 1ms sleeps to 50ms by @nshalman in https://github.com/fsnotify/fsnotify/pull/422
    • Add FreeBSD testing in Github Actions (fix #389) by @r-darwish in https://github.com/fsnotify/fsnotify/pull/419
    • Allow build on unsupported GOOS by @tklauser in https://github.com/fsnotify/fsnotify/pull/424
    • Fix potential crash on windows if raw.FileNameLength exceeds syscall.MAX_PATH by @hu13 in https://github.com/fsnotify/fsnotify/pull/361
    • Add a feature to return the directories and files that are being monitored by @NitroCao in https://github.com/fsnotify/fsnotify/pull/374

    New Contributors

    • @COil made their first contribution in https://github.com/fsnotify/fsnotify/pull/337
    • @r-darwish made their first contribution in https://github.com/fsnotify/fsnotify/pull/419
    • @hu13 made their first contribution in https://github.com/fsnotify/fsnotify/pull/361
    • @NitroCao made their first contribution in https://github.com/fsnotify/fsnotify/pull/374

    Full Changelog: https://github.com/fsnotify/fsnotify/compare/v1.5.1...v1.5.2

    Source code(tar.gz)
    Source code(zip)
  • v1.5.1(Aug 24, 2021)

  • v1.5.0(Aug 18, 2021)

    • Go: Increase minimum required version to Go 1.12 #381
    • Feature: Add AddRaw method which does not follow symlinks when adding a watch #289
    • Windows: Follow symlinks by default like on all other systems #289
    • CI: Use GitHub Actions for CI and cover go 1.12-1.17 #378 #381 #385
    • Go 1.14+: Fix unsafe pointer conversion #325
    Source code(tar.gz)
    Source code(zip)
  • v1.4.9(Mar 11, 2020)

  • v1.4.8(Mar 10, 2020)

    • CI: test more go versions (@nathany 1d13583d846ea9d66dcabbfefbfb9d8e6fb05216)
    • Tests: Queued inotify events could have been read by the test before max_queued_events was hit (@matthias-stone #265)
    • Tests: t.Fatalf -> t.Errorf in go routines (@gdey #266)
    • CI: Less verbosity (@nathany #267)
    • Tests: Darwin: Exchangedata is deprecated on 10.13 (@nathany #267)
    • Tests: Check if channels are closed in the example (@alexeykazakov #244)
    • CI: Only run golint on latest version of go and fix issues (@cpuguy83 #284)
    • CI: Add windows to travis matrix (@cpuguy83 #284)
    • Docs: Remover appveyor badge (@nathany 11844c0959f6fff69ba325d097fce35bd85a8e93)
    • Linux: create epoll and pipe fds with close-on-exec (@JohannesEbke #219)
    • Linux: open files with close-on-exec (@linxiulei #273)
    • Docs: Plan to support fanotify (@nathany ab058b44498e8b7566a799372a39d150d9ea0119 )
    • Project: Add go.mod (@nathany #309)
    • Project: Revise editor config (@nathany #309)
    • Project: Update copyright for 2019 (@nathany #309)
    • CI: Drop go1.8 from CI matrix (@nathany #309)
    • Docs: Updating the FAQ section for supportability with NFS & FUSE filesystems (@Pratik32 4bf2d1fec78374803a39307bfb8d340688f4f28e )
    Source code(tar.gz)
    Source code(zip)
  • v1.4.7(Jan 10, 2018)

    • BSD/macOS: Fix possible deadlock on closing the watcher on kqueue (thanks @nhooyr and @glycerine)
    • Tests: Fix missing verb on format string (thanks @rchiossi)
    • Linux: Fix deadlock in Remove (thanks @aarondl)
    • Linux: Watch.Add improvements (avoid race, fix consistency, reduce garbage) (thanks @twpayne)
    • Docs: Moved FAQ into the README (thanks @vahe)
    • Linux: Properly handle inotify's IN_Q_OVERFLOW event (thanks @zeldovich)
    • Docs: replace references to OS X with macOS
    Source code(tar.gz)
    Source code(zip)
  • v1.4.2(Oct 11, 2016)

    Linux: use InotifyInit1 with IN_CLOEXEC to stop leaking a file descriptor to a child process when using fork/exec #178 (thanks @pattyshack)

    Source code(tar.gz)
    Source code(zip)
  • v1.4.1(Oct 5, 2016)

  • v1.4.0(Oct 2, 2016)

  • v1.3.1(Jun 29, 2016)

  • v1.3.0(Apr 20, 2016)

    Support linux/arm64 by patching x/sys/unix and switching to to it from syscall #135 (thanks @suihkulokki)

    Please see the README for updated information on installation.

    Source code(tar.gz)
    Source code(zip)
  • v1.2.10(Mar 3, 2016)

  • v1.2.9(Jan 14, 2016)

  • v1.2.8(Dec 17, 2015)

    • kqueue: fix race condition in Close #105 (thanks @djui for reporting the issue and @ppknap for writing a failing test)
    • inotify: fix race in test
    • enable race detection for continuous integration (Linux, Mac, Windows)
    Source code(tar.gz)
    Source code(zip)
  • v1.2.5(Nov 17, 2015)

    • inotify: use epoll_create1 for arm64 support (requires Linux 2.6.27 or later) #100 (thanks @suihkulokki)
    • inotify: fix path leaks #73 (thanks @chamaken)
    • kqueue: watch for rename events on subdirectories #83 (thanks @guotie)
    • kqueue: avoid infinite loops from symlinks cycles #101 (thanks @illicitonion)
    Source code(tar.gz)
    Source code(zip)
  • v1.2.1(Oct 14, 2015)

  • v1.2.0(Feb 8, 2015)

    This releases resolves several issues when Close() is used, from leaking file descriptors to blocking issues. It also is using epoll when reading events on Linux to avoid blocking.

    • inotify: use epoll to wake up readEvents #66 #5 (thanks @PieterD)
    • inotify: deleted file watches can now be removed #40
    • inotify: closing watcher should now always shut down goroutine #63 (thanks @PieterD)
    • kqueue: close kqueue after removing watches, fixes #59
    Source code(tar.gz)
    Source code(zip)
  • v1.1.1(Feb 6, 2015)

  • v0.9.3(Jan 1, 2015)

  • v1.1.0(Dec 13, 2014)

    kqueue

    • rework internals #43
    • add low-level functions
    • only need to store flags on directories
    • less mutexes #13
    • done can be an unbuffered channel
    • remove calls to os.NewSyscallError
    • fix regression in rework causing subdirectories to be watched #48
    • cleanup internal watch before sending remove event #51

    other

    • More efficient string concatenation for Event.String() #52 (thanks @mdlayher)
    Source code(tar.gz)
    Source code(zip)
  • v1.0.4(Sep 8, 2014)

    • kqueue: add dragonfly to the build tags.
    • Rename source code files, rearrange code so exported APIs are at the top.
    • Add done channel to example code. (thanks @chenyukang)
    Source code(tar.gz)
    Source code(zip)
  • v1.0.3(Aug 20, 2014)

  • v1.0.2(Aug 17, 2014)

  • v0.9.2(Aug 17, 2014)

  • v1.0.0(Aug 17, 2014)

    • Improve documentation for exported identifiers. #30
    • Minor updates based on feedback from golint.

    v1 contains a number of API changes and improvements over v0.9.0. See the CHANGELOG for the full details.

    Source code(tar.gz)
    Source code(zip)
Owner
fsnotify
File system notifications for Go.
fsnotify
Kitten is a distributed file system optimized for small file storage, inspired by Facebook's Haystack.

Kitten is a distributed file system optimized for small file storage, inspired by Facebook's Haystack.

Jack Lee 8 Jun 20, 2022
JuiceFS is a distributed POSIX file system built on top of Redis and S3.

JuiceFS is a high-performance POSIX file system released under GNU Affero General Public License v3.0. It is specially optimized for the cloud-native

Juicedata, Inc 5.5k Jun 25, 2022
A user-space file system for interacting with Google Cloud Storage

gcsfuse is a user-space file system for interacting with Google Cloud Storage. Current status Please treat gcsfuse as beta-quality software. Use it fo

Google Cloud Platform 1.5k Jun 23, 2022
The Swift Virtual File System

*** This project is not maintained anymore *** The Swift Virtual File System SVFS is a Virtual File System over Openstack Swift built upon fuse. It is

OVHcloud 375 Mar 16, 2022
Goofys is a high-performance, POSIX-ish Amazon S3 file system written in Go

Goofys is a high-performance, POSIX-ish Amazon S3 file system written in Go Overview Goofys allows you to mount an S3 bucket as a filey system. It's a

Ka-Hing Cheung 4.2k Jun 22, 2022
A FileSystem Abstraction System for Go

A FileSystem Abstraction System for Go Overview Afero is a filesystem framework providing a simple, uniform and universal API interacting with any fil

Steve Francia 4.5k Jun 27, 2022
SeaweedFS a fast distributed storage system for blobs, objects, files, and data lake, for billions of files

SeaweedFS is a fast distributed storage system for blobs, objects, files, and data lake, for billions of files! Blob store has O(1) disk seek, cloud tiering. Filer supports Cloud Drive, cross-DC active-active replication, Kubernetes, POSIX FUSE mount, S3 API, S3 Gateway, Hadoop, WebDAV, encryption, Erasure Coding.

Chris Lu 14.7k Jun 30, 2022
Cross-platform file system notifications for Go.

File system notifications for Go fsnotify utilizes golang.org/x/sys rather than syscall from the standard library. Ensure you have the latest version

fsnotify 7k Jun 22, 2022
Cross-platform file system notifications for Go.

File system notifications for Go fsnotify utilizes golang.org/x/sys rather than syscall from the standard library. Ensure you have the latest version

fsnotify 7k Jun 24, 2022
Cross-platform file system notifications for Go.

File system notifications for Go fsnotify utilizes golang.org/x/sys rather than syscall from the standard library. Ensure you have the latest version

alan liu 0 Aug 7, 2017
cross-platform library for sending desktop notifications

Golang-Toast cross-platform library for sending desktop notifications Installation go get

雷系泡泡 8 Apr 27, 2022
Github-notifications - Small script to alert me when I have notifications on Github. I use it in my Polybar conf

Github notification polybar widget This tool is meant to be used with Polybar, in order to let the user know when they have notifications on Github. R

Ghislain Rodrigues 1 Jan 26, 2022
Cross-platform Go library to place an icon in the host operating system's taskbar.

trayhost Package trayhost is a cross-platform Go library to place an icon in the host operating system's taskbar. Platform Support macOS - Fully imple

null 226 Jun 10, 2022
🐘 Cross-platform, neofetch alternative for fetching system info.

elefetch ?? Cross-platform, neofetch alternative for fetching system info. Installation go get: go get -u github.com/burntcarrot/elefetch Binaries Bin

Aadhav Vignesh 1 Jan 23, 2022
oDrop, a fast efficient cross-platform file transfer software for server and home environments

oDrop is a cross-platform LAN file transfer software to efficiently transfer files between computers, oDrop is useful in environments where GUI is not available.

Flew Software 16 Jun 4, 2022
Lockgate is a cross-platform locking library for Go with distributed locks using Kubernetes or lockgate HTTP lock server as well as the OS file locks support.

Lockgate Lockgate is a locking library for Go. Classical interface: 2 types of locks: shared and exclusive; 2 modes of locking: blocking and non-block

werf 230 Jun 16, 2022
A cross-platform changelog file generator

changelogger A changelog file generator heavily inspired on towncrier. Why? I'm looking for an alternative to towncrier that doesn't require a Python

Diego Garcia 12 Jun 15, 2022
A cross platform desktop service that watches custom folders for file changes and updates the corresponding database in Notion.

A cross platform desktop service that watches custom folders for file changes and updates the corresponding database in Notion. Perfect for tracking reading lists

Carl Kugblenu 2 Mar 12, 2022
A feature flag solution, with only a YAML file in the backend (S3, GitHub, HTTP, local file ...), no server to install, just add a file in a central system and refer to it. 🎛️

??️ go-feature-flag A feature flag solution, with YAML file in the backend (S3, GitHub, HTTP, local file ...). No server to install, just add a file i

Thomas Poignant 445 Jun 21, 2022
💨 A real time messaging system to build a scalable in-app notifications, multiplayer games, chat apps in web and mobile apps.

Beaver A Real Time Messaging Server. Beaver is a real-time messaging server. With beaver you can easily build scalable in-app notifications, realtime

Ahmed 1.3k Jun 27, 2022
Get notifications about unexpected system state from your local Gesundheitsdienst.

Get notifications about unexpected system state from your local Gesundheitsdienst.

ushi 2 Feb 27, 2022
This is a simple file storage server. User can upload file, delete file and list file on the server.

Simple File Storage Server This is a simple file storage server. User can upload file, delete file and list file on the server. If you want to build a

BH_Lin 0 Jan 19, 2022
:100:Go Struct and Field validation, including Cross Field, Cross Struct, Map, Slice and Array diving

Package validator Package validator implements value validations for structs and individual fields based on tags. It has the following unique features

Go Playgound 10.7k Jun 26, 2022
💯 Go Struct and Field validation, including Cross Field, Cross Struct, Map, Slice and Array diving

Package validator implements value validations for structs and individual fields based on tags.

Flamego 12 Feb 16, 2022
Cross commerce challenge - Cross Commerce Store Challenge With Golang

Cross Commerce Store Desafio Simples Aplicação ETL Todo o código fonte está cont

Leonardo Gonçalves 0 Feb 13, 2022
Cross-poster - A cross-posting tool for golang

How to start cp config.example.json config.json update config in config.json Bui

Sagleft 0 Feb 19, 2022
A simple logging interface that supports cross-platform color and concurrency.

WLog Package wlog creates simple to use UI structure. The UI is used to simply print to the screen. There a wrappers that will wrap each other to crea

Will Dixon 57 May 31, 2022
Console Text Colors - The non-invasive cross-platform terminal color library does not need to modify the Print method

ctc - Console Text Colors The non-invasive cross-platform terminal color library does not need to modify the Print method Virtual unix-like environmen

null 37 Dec 15, 2021
✨ #PTerm is a modern go module to beautify console output. Featuring charts, progressbars, tables, trees, and many more 🚀 It's completely configurable and 100% cross-platform compatible.

?? PTerm | Pretty Terminal Printer A golang module to print pretty text Show Demo Code PTerm.sh | Installation | Documentation | Quick Start | Example

null 2.6k Jun 21, 2022