vagrant-fsevents 0.4.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e0a6d6d376834556d231f0e1376359fa89dd630d7fe6b83e3085a438761ecd53
+  data.tar.gz: f41efcf688d7db03e6c4c97de5d86cfdae48da94cc530ecdea9291e3fd4d4eb7
+SHA512:
+  metadata.gz: 64788d3f168c09d03fd19389cebeb49bf45af4508d2d82d11d8b36dd0913a42be3c135c1644e9f8752ed66b2d38fc1cd2d39daffe690ecfb0ae9bd2f5613ace2
+  data.tar.gz: afb788a561c4be1b5d203b1a299096d7434dda51a1ab13c37d60e7ad083dfbe18501ca7a101112a876f3792abd270f6f9583269b8575ff62f4770e3031d9a8fa

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/.history
+/.vscode
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+.vagrant/
+*.gem
+vagrant.log

data/.rubocop.yml

@@ -0,0 +1,8 @@
+Layout/EndOfLine:
+  EnforcedStyle: lf
+
+Naming/FileName:
+  Enabled: false
+
+Style/RaiseArgs:
+  Enabled: false

data/AUTHORS

@@ -0,0 +1,6 @@
+# This file lists all individuals having contributed content to the repository.
+
+Adrien Kohlbecker <adrien.kohlbecker@gmail.com>
+Don Morrison <github@elskwid.net>
+Leandro Facchinetti <me@leafac.com>
+Wolf Hatch <wolf@mechrus.com>

data/CHANGELOG.md

@@ -0,0 +1,57 @@
+# Changelog
+
+## 0.4.1 - 2019-03-07
+
+- File change lock-out scales with number of files changed (+0.02s/file)
+- Touch and rm commands on guest machine now sent at the same time
+
+## 0.4.0 - 2019-03-06
+
+- Renamed to vagrant-fsevents
+- Updated readme
+- Applied Rubocop linting
+- Extensive refactor/restructure
+
+## 0.3.0 - 2016-04-13
+
+- Fix for "No such file or directory" on Windows host (#11)
+
+## 0.2.0 - 2015-07-14
+
+- *Breaking change:* Minimum required Vagrant version changed to 1.7.3+
+- Fixed a dependency issue with celluloid (#10, @leafac)
+
+## 0.1.1 - 2015-07-05 (yanked)
+
+Note: This release was yanked due to a dependency issue
+
+- Added command synopsis (#7, @leafac)
+- Fix issue with vagrant runtime dependency on celluloid (#8, @leafac)
+
+## 0.1.0 - 2015-07-05 (yanked)
+
+Note: This release was yanked due to a dependency issue
+
+- *Breaking change:* Added support for forwarding file addition/removal (#6, @leafac)
+- Depend on `vagrant` rather than `listen` for better compatibility with upstream (#5, @leafac)
+- Added documentation (#3 & #4, @leafac)
+
+## 0.0.6 - 2015-04-16
+
+- Fix multimachine use, allow specifying which machine to target (@elskwid)
+
+## 0.0.5 - 2015-04-11
+
+- Fix `listen` dependency
+
+## 0.0.4 - 2014-08-18
+
+- Uses access time modification, rather than modified time
+
+## 0.0.3 - 2014-08-15
+
+- Allow guest path overriding
+
+## 0.0.2 - 2014-08-15
+
+- Increase the delay between changes to 2 seconds

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+group :development do
+  gem "vagrant", git: "https://github.com/hashicorp/vagrant.git"
+end
+
+group :plugins do
+  gem "vagrant-fsevents", path: "."
+end

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Vagrant-fsnotify copyright (c) 2015-2016 Adrien Kohlbecker
+Vagrant-fsevents copyright (c) 2019 Wolf Hatch
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,140 @@
+# vagrant-fsevents
+
+Activatable filesystem change forwarding to your [Vagrant][vagrant] VM.
+
+## Problem this solves
+
+When developing inside [VirtualBox][virtualbox]-based VMs with synced folders,
+filesystem events in the host system do not propagate to processes running inside
+the VM. This causes difficulty for some development environments, particularly
+when using packagers such as Webpack, as they do not update/rebuild in response
+to editor changes.
+
+There are a number of partial solutions in the wild, but none are perfect in all
+circumstances. This project builds on [`vagrant-fsnotify`][vagrant-fsnotify] by
+@adrienkohlbecker to provide a simple on-demand, low resource, and highly
+transparent solution. It is particularly effective for a standard development
+VM which is used widely by multiple teams where perhaps only a few people even
+need filesystem event forwarding, and it's not desirable to have an always-on
+solution that hogs system resources.
+
+## Mechanism
+
+`vagrant-fsevents` runs a process listening for filesystem changes on the host
+that affect shared folders, and forwards them to the VM as shell commands such
+as `touch` (and `rm`, as appropriate) using Vagrant's VM administration API.
+
+## Caveats
+
+Inconveniently, while filesystem events are not properly forwarded into the VM,
+they're forwarded back out without issue, so every time this plugin triggers an
+update in the VM, a second filesystem event is fired in the host system. To
+prevent the obvious infinite-loop issue this could cause, a minimum 2-second
+per-file dead-zone is used after each update event (with additional time for
+updates with many files changed)
+
+This is unfortunately only a partial solution, and large filesystem changes such
+as checking out another git branch can still cause issues such as infinite
+notification loops and accidental creation of blank files that should have been
+removed. However, these issues are usually minor, easily fixed via git, and can
+be entirely avoided by killing the monitor process before major changes.
+
+## Installation
+
+`vagrant-fsevents` is a [Vagrant][vagrant] plugin and can be installed by
+running:
+
+```console
+$ vagrant plugin install vagrant-fsevents
+```
+
+[Vagrant][vagrant] version 1.7.3 or greater is required.
+
+## Usage
+
+### Basic setup
+
+In `Vagrantfile` synced folder configuration, add the `fsevents: true`
+option. For example, in order to enable `vagrant-fsevents` for the the default
+`/vagrant` shared folder, add the following:
+
+```ruby
+config.vm.synced_folder ".", "/vagrant", fsevents: true
+```
+
+When the guest virtual machine is up, run the following:
+
+```console
+$ vagrant fsevents
+```
+
+This starts the long running process that captures filesystem events on the host
+and forwards them to the guest virtual machine.
+
+### Multi-VM environments
+
+In multi-VM environments, you can specify the name of the VMs targeted by
+`vagrant-fsevents` using:
+
+```console
+$ vagrant fsevents <vm-name-1> <vm-name-2> ...
+```
+
+### Excluding files
+
+To exclude files or directories from being watched, you can add an `:exclude`
+option, which takes an array of strings (matched as a regexp against relative
+paths):
+
+```ruby
+config.vm.synced_folder ".", "/vagrant", fsevents: true,
+                                         exclude: ["path1", "some/directory"]
+```
+
+This will exclude all files inside the `path1` and `some/directory`. It will
+also exclude files such as `another/directory/path1`.
+
+### Guest path override
+
+If your actual path on the VM is not the same as the one in `synced_folder`, for
+example when using [`vagrant-bindfs`][vagrant-bindfs], you can use the
+`:override_guestpath` option:
+
+```ruby
+config.vm.synced_folder ".", "/vagrant", fsevents: true,
+                                         override_guestpath: "/real/path"
+```
+
+This will forward a notification on `./myfile` to `/real/path/myfile` instead of
+`/vagrant/myfile`.
+
+### Select filesystem events
+
+By default, when the `:fsevents` key in the `Vagrantfile` is configured with
+`true`, all filesystem events are forwarded to the VM (creation, modification,
+and removal). If, instead, you want to select only some of those events to be
+forwarded (e.g. you don't care about file removals), you can use an Array of
+Symbols among the following options: `:added`, `:modified` and `:removed`.
+
+For example, to forward only added files events to the default `/vagrant`
+folder, add the following to the `Vagrantfile`:
+
+```ruby
+config.vm.synced_folder ".", "/vagrant", fsevents: [:added]
+```
+
+## Original work
+
+This plugin was originally [`vagrant-fsnotify`][vagrant-fsnotify] by @adrienkohlbecker,
+but was renamed to facilitate continued development.
+This plugin used [`vagrant-rsync-back`][vagrant-rsync-back] by @smerill and the
+[Vagrant][vagrant] source code as a starting point.
+
+[vagrant]: https://www.vagrantup.com/
+[virtualbox]: https://www.virtualbox.org/
+[jekyll]: http://jekyllrb.com/
+[guard]: http://guardgem.org/
+[forwarding-file-events-over-tcp]: https://github.com/guard/listen#forwarding-file-events-over-tcp
+[vagrant-bindfs]: https://github.com/gael-ian/vagrant-bindfs
+[vagrant-rsync-back]: https://github.com/smerrill/vagrant-rsync-back
+[vagrant-fsnotify]: https://github.com/adrienkohlbecker/vagrant-fsnotify

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/Vagrantfile

@@ -0,0 +1,122 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+# Vagrantfile API/syntax version. Don't touch unless you know what you're doing!
+VAGRANTFILE_API_VERSION = "2"
+
+Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
+  # All Vagrant configuration is done here. The most common configuration
+  # options are documented and commented below. For a complete reference,
+  # please see the online documentation at vagrantup.com.
+
+  # Every Vagrant virtual environment requires a box to build off of.
+  config.vm.box = "ubuntu/trusty64"
+
+  # Disable automatic box update checking. If you disable this, then
+  # boxes will only be checked for updates when the user runs
+  # `vagrant box outdated`. This is not recommended.
+  # config.vm.box_check_update = false
+
+  # Create a forwarded port mapping which allows access to a specific port
+  # within the machine from a port on the host machine. In the example below,
+  # accessing "localhost:8080" will access port 80 on the guest machine.
+  # config.vm.network "forwarded_port", guest: 80, host: 8080
+
+  # Create a private network, which allows host-only access to the machine
+  # using a specific IP.
+  config.vm.network "private_network", ip: "192.168.33.10"
+
+  # Create a public network, which generally matched to bridged network.
+  # Bridged networks make the machine appear as another physical device on
+  # your network.
+  # config.vm.network "public_network"
+
+  # If true, then any SSH connections made will enable agent forwarding.
+  # Default value: false
+  # config.ssh.forward_agent = true
+
+  # Share an additional folder to the guest VM. The first argument is
+  # the path on the host to the actual folder. The second argument is
+  # the path on the guest to mount the folder. And the optional third
+  # argument is a set of non-required options.
+  config.vm.synced_folder ".", "/vagrant", fsevents: true
+
+  # Provider-specific configuration so you can fine-tune various
+  # backing providers for Vagrant. These expose provider-specific options.
+  # Example for VirtualBox:
+  #
+  # config.vm.provider "virtualbox" do |vb|
+  #   # Don't boot with headless mode
+  #   vb.gui = true
+  #
+  #   # Use VBoxManage to customize the VM. For example to change memory:
+  #   vb.customize ["modifyvm", :id, "--memory", "1024"]
+  # end
+  #
+  # View the documentation for the provider you're using for more
+  # information on available options.
+
+  # Enable provisioning with CFEngine. CFEngine Community packages are
+  # automatically installed. For example, configure the host as a
+  # policy server and optionally a policy file to run:
+  #
+  # config.vm.provision "cfengine" do |cf|
+  #   cf.am_policy_hub = true
+  #   # cf.run_file = "motd.cf"
+  # end
+  #
+  # You can also configure and bootstrap a client to an existing
+  # policy server:
+  #
+  # config.vm.provision "cfengine" do |cf|
+  #   cf.policy_server_address = "10.0.2.15"
+  # end
+
+  # Enable provisioning with Puppet stand alone.  Puppet manifests
+  # are contained in a directory path relative to this Vagrantfile.
+  # You will need to create the manifests directory and a manifest in
+  # the file default.pp in the manifests_path directory.
+  #
+  # config.vm.provision "puppet" do |puppet|
+  #   puppet.manifests_path = "manifests"
+  #   puppet.manifest_file  = "site.pp"
+  # end
+
+  # Enable provisioning with chef solo, specifying a cookbooks path, roles
+  # path, and data_bags path (all relative to this Vagrantfile), and adding
+  # some recipes and/or roles.
+  #
+  # config.vm.provision "chef_solo" do |chef|
+  #   chef.cookbooks_path = "../my-recipes/cookbooks"
+  #   chef.roles_path = "../my-recipes/roles"
+  #   chef.data_bags_path = "../my-recipes/data_bags"
+  #   chef.add_recipe "mysql"
+  #   chef.add_role "web"
+  #
+  #   # You may also specify custom JSON attributes:
+  #   chef.json = { mysql_password: "foo" }
+  # end
+
+  # Enable provisioning with chef server, specifying the chef server URL,
+  # and the path to the validation key (relative to this Vagrantfile).
+  #
+  # The Opscode Platform uses HTTPS. Substitute your organization for
+  # ORGNAME in the URL and validation key.
+  #
+  # If you have your own Chef Server, use the appropriate URL, which may be
+  # HTTP instead of HTTPS depending on your configuration. Also change the
+  # validation key to validation.pem.
+  #
+  # config.vm.provision "chef_client" do |chef|
+  #   chef.chef_server_url = "https://api.opscode.com/organizations/ORGNAME"
+  #   chef.validation_key_path = "ORGNAME-validator.pem"
+  # end
+  #
+  # If you're using the Opscode platform, your validator client is
+  # ORGNAME-validator, replacing ORGNAME with your organization name.
+  #
+  # If you have your own Chef Server, the default validation client name is
+  # chef-validator, unless you changed the configuration.
+  #
+  #   chef.validation_client_name = "ORGNAME-validator"
+end

data/lib/vagrant-fsevents/alerter.rb

@@ -0,0 +1,21 @@
+module VagrantPlugins
+  module Fsevents
+    # Place to store messages that will be seen by the user
+    class Alerter
+      # Alert the user to a successful folder watch start
+      def watching(machine, rel_path)
+        machine.ui.info("fsevents: Watching #{rel_path}")
+      end
+
+      def event(event)
+        word = 'Changed' if event.type == :modified
+        word = 'Added' if event.type == :added
+        word = 'Removed' if event.type == :removed
+
+        event.watch[:machine].ui.info(
+          "fsevents: #{word}: #{event.relative_path}"
+        )
+      end
+    end
+  end
+end

data/lib/vagrant-fsevents/changeEvents.rb

@@ -0,0 +1,42 @@
+require_relative 'errors'
+
+module VagrantPlugins
+  module Fsevents
+    # A single changed path string of a specified change type
+    class ChangeEvents
+      attr_reader :path
+      attr_reader :type
+      attr_reader :watch
+      attr_reader :watch_path
+      attr_reader :relative_path
+      attr_reader :full_path_on_guest
+
+      # Takes the output of a listen callback (as arrays of strings of
+      # files split by type of change) and converts them into single events
+      # for a specific watch definition
+      def self.make(mods, adds, removes, watch_path, watch)
+        change_events = []
+        structure = { modified: mods, added: adds, removed: removes }
+        structure.each do |type, files|
+          files.each do |path|
+            change_events.push new(path, type, watch_path, watch)
+          end
+        end
+        change_events
+      end
+
+      def initialize(path, type, watch_path, watch)
+        @path = path
+        @type = type
+        @watch_path = watch_path
+        @watch = watch
+
+        @relative_path = path.sub(watch_path, '')
+        @full_path_on_guest = File.join(
+          (watch[:opts][:override_guestpath] || watch[:opts][:guestpath]),
+          @relative_path
+        )
+      end
+    end
+  end
+end

data/lib/vagrant-fsevents/errors.rb

@@ -0,0 +1,28 @@
+module VagrantPlugins
+  module Fsevents
+    # Error indicating that there is no valid path to watch for changes
+    class NothingToSyncError < Vagrant::Errors::VagrantError
+      error_message %q(
+        Nothing to sync.
+
+        Note that the valid values for the `:fsevents' configuration key on
+        `Vagrantfile' are either `true' (which forwards all kinds of filesystem
+        events) or an Array containing symbols among the following options:
+        `:modified', `:added' and `:removed' (in which case, only the specified
+        filesystem events are forwarded).
+
+        For example, to forward all filesystem events to the default `/vagrant'
+        folder, add the following to the `Vagrantfile':
+
+          config.vm.synced_folder ".", "/vagrant", fsevents: true
+
+        And to forward only added files events to the default `/vagrant' folder,
+        add the following to the `Vagrantfile':
+
+          config.vm.synced_folder ".", "/vagrant", fsevents: [:added]
+
+        Exiting...
+      ).gsub(/^[ ]{8}/, '')
+    end
+  end
+end

data/lib/vagrant-fsevents/logger.rb

@@ -0,0 +1,31 @@
+module VagrantPlugins
+  module Fsevents
+    # Methods that log to Vagrant's internal log for debugging
+    class Logger < Log4r::Logger
+      # Logs listening start messages
+      def listening_with_adapter(adapter, paths, ignores)
+        info("Listening to paths: #{paths.keys.sort.inspect}")
+        info("Listening via: #{adapter}")
+        info("Ignoring #{ignores.length} paths:")
+        ignores.each do |ignore|
+          info("  -- #{ignore}")
+        end
+      end
+
+      # Logs when the file change callback is triggered
+      def callback_start(mods, adds, removes)
+        info('File change callback called!')
+        info("  - Modified: #{mods.inspect}")
+        info("  - Added: #{adds.inspect}")
+        info("  - Removed: #{removes.inspect}")
+      end
+
+      # Logs when a path was changed too quickly and was ignored
+      def change_too_soon(rel_path)
+        info(
+          "Skipping #{rel_path} - was changed too recently"
+        )
+      end
+    end
+  end
+end

data/lib/vagrant-fsevents/main.rb

@@ -0,0 +1,99 @@
+require 'listen'
+require_relative 'errors'
+
+module VagrantPlugins
+  module Fsevents
+    # Class containing the main plugin activities
+    class Main < Vagrant.plugin('2', :command)
+      include Vagrant::Action::Builtin::MixinSyncedFolders
+
+      LOGGING_CONTEXT = 'vagrant::commands::fsevents'.freeze
+      ADAPTER = Listen::Adapter.select.inspect.freeze
+
+      # Main method for constructing the plugin
+      def execute
+        init_supporting_classes
+        init_path_data
+        log_listening_start_event
+        print_watch_paths_to_console
+        start_listening
+      end
+
+      # Instantiate supporting classes
+      def init_supporting_classes
+        @logger = VagrantPlugins::Fsevents::Logger.new LOGGING_CONTEXT
+        @alerter = VagrantPlugins::Fsevents::Alerter.new
+        @responder = VagrantPlugins::Fsevents::Responder.new @logger, @alerter
+        @paths = VagrantPlugins::Fsevents::Paths.new
+      end
+
+      # Build list of paths to watch and ignore
+      def init_path_data
+        with_target_vms(command_line_argv) do |machine|
+          unless machine.communicate.ready?
+            raise Vagrant::Errors::VMNotCreatedError
+          end
+
+          @paths.process(machine, synced_folders(machine))
+        end
+
+        raise NothingToSyncError.new if @paths.watch.empty?
+      end
+
+      def self.synopsis
+        'forwards filesystem events to virtual machine'
+      end
+
+      # Log that we've started listening
+      def log_listening_start_event
+        @logger.listening_with_adapter(ADAPTER, @paths.watch, @paths.ignore)
+      end
+
+      # Alert the user to the paths we're watching
+      def print_watch_paths_to_console
+        @paths.watch.each do |path, data|
+          @alerter.watching(data[:machine], path)
+        end
+      end
+
+      # Start the actual listener that will respond to file changes
+      def start_listening
+        listener = Listen.to(
+          *@paths.watch.keys,
+          ignore: @paths.ignore,
+          &@responder.callback_proc.curry[@paths.watch]
+        )
+
+        create_interrupt_callback(listener)
+      end
+
+      # Create the callback that lets us know when we've been interrupted
+      def create_interrupt_callback(listener)
+        queue    = Queue.new
+        callback = lambda do
+          # This needs to execute in another thread because Thread
+          # synchronization can't happen in a trap context.
+          Thread.new { queue << true }
+        end
+
+        # Run the listener in a busy block so that we can cleanly
+        # exit once we receive an interrupt.
+        Vagrant::Util::Busy.busy(callback) do
+          listener.start
+          queue.pop
+          listener.stop if listener.state != :stopped
+        end
+
+        0
+      end
+
+      # This parses the command line arguments passed by the user
+      def command_line_argv
+        parse_options OptionParser.new do |o|
+          o.banner = 'Usage: vagrant fsevents [vm-name]'
+          o.separator ''
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-fsevents/paths.rb

@@ -0,0 +1,74 @@
+module VagrantPlugins
+  module Fsevents
+    # Logic for paths to watch and ignore
+    class Paths
+      attr_reader :watch
+      attr_reader :ignore
+
+      def initialize
+        @watch = {}
+        @ignore = []
+      end
+
+      def process(machine, folders)
+        add_folders_to_watch(machine, folders)
+        add_folders_to_ignore(folders)
+      end
+
+      # Populates `@watch` attribute from a single VM instance
+      def add_folders_to_watch(machine, folders)
+        folders.values.each do |folder|
+          folder.each do |id, opts|
+            next unless active_for_folder? opts[:fsevents]
+
+            hostpath = File.expand_path(opts[:hostpath], machine.env.root_path)
+            hostpath = Vagrant::Util::Platform.fs_real_path(hostpath).to_s
+
+            # Avoid creating a nested directory
+            hostpath += '/' unless hostpath.end_with?('/')
+
+            @watch[hostpath] = { id: id, machine: machine, opts: opts }
+          end
+        end
+      end
+
+      # Populates `@ignore` attribute from a single VM instance
+      def add_folders_to_ignore(folders)
+        folders.values.each do |folder|
+          folder.values.each do |opts|
+            next unless active_for_folder?(opts[:fsevents])
+
+            Array(opts[:exclude]).each do |pattern|
+              @ignore << exclude_to_regexp(pattern.to_s)
+            end
+          end
+        end
+      end
+
+      # This is REALLY ghetto, but its a start. We can improve and
+      # keep unit tests passing in the future.
+      def exclude_to_regexp(exclude)
+        exclude = exclude.gsub('**', '|||GLOBAL|||')
+        exclude = exclude.gsub('*', '|||PATH|||')
+        exclude = exclude.gsub('|||PATH|||', '[^/]*')
+        exclude = exclude.gsub('|||GLOBAL|||', '.*')
+
+        Regexp.new(exclude)
+      end
+
+      # checks to ensure that a path watch is not completely disabled
+      def active_for_folder?(options)
+        (
+          (options == true) || (
+            options.respond_to?(:include?) &&
+            (
+              options.include?(:modified) ||
+              options.include?(:added) ||
+              options.include?(:removed)
+            )
+          )
+        )
+      end
+    end
+  end
+end

data/lib/vagrant-fsevents/plugin.rb

@@ -0,0 +1,27 @@
+begin
+  require 'vagrant'
+rescue LoadError
+  raise 'The vagrant-fsevents plugin must be run within Vagrant.'
+end
+
+if Vagrant::VERSION < '1.7.3'
+  raise <<-ERROR
+    The vagrant-fsevents plugin is only compatible with Vagrant 1.7.3+. If you can't
+    upgrade, consider installing an old version of vagrant-fsnotify with:
+    $ vagrant plugin install vagrant-fsnotify --plugin-version 0.0.6.
+  ERROR
+end
+
+module VagrantPlugins
+  module Fsevents
+    # Class to instantiate the plugin
+    class Plugin < Vagrant.plugin('2')
+      name 'vagrant-fsevents'
+
+      command 'fsevents' do
+        require_relative 'main'
+        Main
+      end
+    end
+  end
+end

data/lib/vagrant-fsevents/responder.rb

@@ -0,0 +1,96 @@
+require_relative 'changeEvents'
+
+module VagrantPlugins
+  module Fsevents
+    # Defines how to respond to a change event
+    class Responder
+      def initialize(logger, alerter)
+        @logger = logger
+        @alerter = alerter
+        @recently_changed = Hash.new { |hash, key| hash[key] = 0 }
+      end
+
+      # This is the main callback that responds to a change detection event
+      def callback(watches, mods, adds, removes)
+        @logger.callback_start(mods, adds, removes)
+
+        clear_expired_change_locks
+
+        events_to_sync = watches.map do |watch_path, watch|
+          events = ChangeEvents.make(mods, adds, removes, watch_path, watch)
+          add_locks(remove_locked_events(select_by_relevance(events)))
+        end
+
+        forward_events_to_vms(events_to_sync.flatten)
+      rescue StandardError => e
+        @logger.error("#{e}: #{e.message}")
+      end
+
+      # Return the callback as a proc that can be passed to the listener
+      def callback_proc
+        method(:callback).to_proc
+      end
+
+      # Filters out events whose path or type don't match their watch
+      def select_by_relevance(events)
+        events.select do |event|
+          next unless event.path.start_with?(event.watch_path)
+
+          watch = event.watch[:opts][:fsevents]
+          (watch == true || watch.includes?(event.type))
+        end
+      end
+
+      # Filters out events still in their change deadzone
+      def remove_locked_events(events)
+        events.select do |event|
+          if @recently_changed[event.relative_path] >= Time.now.to_f
+            @logger.change_too_soon(event.relative_path)
+            next
+          end
+
+          true
+        end
+      end
+
+      # Adds deadzone locks for given events
+      def add_locks(events)
+        lock_duration = Time.now.to_f + 2 + (0.02 * events.length)
+        events.each do |event|
+          @recently_changed[event.relative_path] = lock_duration
+          @alerter.event(event)
+        end
+        events
+      end
+
+      def group_events_by_machine(events)
+        machine_hash = Hash.new { |hash, key| hash[key] = [] }
+        events.each { |event| machine_hash[event.watch[:machine]] << event }
+        machine_hash
+      end
+
+      # Action events that have been bound to a watch and passed checks
+      def forward_events_to_vms(ungrouped_events)
+        group_events_by_machine(ungrouped_events).each do |machine, events|
+          changed_files = events.map(&:full_path_on_guest)
+          delete_events = events.select { |event| event.type == :removed }
+          sync_command = "touch -a '#{changed_files.join("' '")}'"
+
+          unless delete_events.empty?
+            deleted_files = delete_events.map(&:full_path_on_guest)
+            sync_command += "; rm -rf '#{deleted_files.join("' '")}'"
+          end
+
+          machine.communicate.execute(sync_command)
+        end
+      end
+
+      # Clear any stored change events from runs older than two seconds
+      def clear_expired_change_locks
+        @recently_changed.each do |rel_path, time|
+          @recently_changed.delete(rel_path) if time < Time.now.to_f
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-fsevents/version.rb

@@ -0,0 +1,5 @@
+module VagrantPlugins
+  module Fsevents
+    VERSION = '0.4.1'.freeze
+  end
+end

data/lib/vagrant-fsevents.rb

@@ -0,0 +1,13 @@
+require 'vagrant-fsevents/version'
+require 'vagrant-fsevents/plugin'
+
+module VagrantPlugins
+  # Plugin core module
+  module Fsevents
+    lib_path = Pathname.new(File.expand_path('vagrant-fsevents', __dir__))
+    autoload :Alerter, lib_path.join('alerter')
+    autoload :Logger, lib_path.join('logger')
+    autoload :Responder, lib_path.join('responder')
+    autoload :Paths, lib_path.join('paths')
+  end
+end

data/vagrant-fsevents.gemspec

@@ -0,0 +1,26 @@
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'vagrant-fsevents/version'
+
+Gem::Specification.new do |spec|
+  spec.name           = 'vagrant-fsevents'
+  spec.version        = VagrantPlugins::Fsevents::VERSION
+  spec.authors        = ['Wolf Hatch']
+  spec.email          = ['wolf@mechrus.com']
+  spec.summary        = 'Forward filesystem change notifications '\
+                        'to your Vagrant VM'
+  spec.description    = 'Use vagrant-fsevents to forward filesystem '\
+                        'change notifications to your Vagrant VM'
+  spec.homepage       = 'https://github.com/Fendrian/vagrant-fsevents'
+  spec.license        = 'MIT'
+
+  spec.files          = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir         = 'exe'
+  spec.executables    = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths  = ['lib']
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: vagrant-fsevents
+version: !ruby/object:Gem::Version
+  version: 0.4.1
+platform: ruby
+authors:
+- Wolf Hatch
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-03-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Use vagrant-fsevents to forward filesystem change notifications to your
+  Vagrant VM
+email:
+- wolf@mechrus.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- AUTHORS
+- CHANGELOG.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- Vagrantfile
+- lib/vagrant-fsevents.rb
+- lib/vagrant-fsevents/alerter.rb
+- lib/vagrant-fsevents/changeEvents.rb
+- lib/vagrant-fsevents/errors.rb
+- lib/vagrant-fsevents/logger.rb
+- lib/vagrant-fsevents/main.rb
+- lib/vagrant-fsevents/paths.rb
+- lib/vagrant-fsevents/plugin.rb
+- lib/vagrant-fsevents/responder.rb
+- lib/vagrant-fsevents/version.rb
+- vagrant-fsevents.gemspec
+homepage: https://github.com/Fendrian/vagrant-fsevents
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Forward filesystem change notifications to your Vagrant VM
+test_files: []