vagrant-instant-rsync-auto 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4117f71f6469b9f328afbfcc926054dd2c3b1751
+  data.tar.gz: db01eb256c20cb008295fedad381169c4b35a950
+SHA512:
+  metadata.gz: b298fe657fb8ee55ab6919a0531f19472b1024f541b22e454fa5a3dd56ccf125b3309b737ad915c220d4e5449b91c8ee3d2d2bd581bd05506717ade64b7a03e8
+  data.tar.gz: 1782ff3141f6e2a1eebc070358cfd2dde42ed33a5d878eb1c0bd8320f72288d0a101505fd610cf2651a92ac996d425dcc2daaef98c0c26ad511fcd714d64a037

data/.ruby-version

@@ -0,0 +1 @@
+2.2.3

data/Gemfile

@@ -0,0 +1,12 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in vagrant-instant-rsync-auto.gemspec
+gemspec
+
+group :development do
+  gem 'vagrant', git: 'https://github.com/mitchellh/vagrant.git', tag: 'v1.8.1'
+end
+
+group :plugins do
+  gem 'vagrant-instant-rsync-auto', path: '.'
+end

data/Gemfile.lock

@@ -0,0 +1,120 @@
+GIT
+  remote: https://github.com/mitchellh/vagrant.git
+  revision: c1c00e2f3cf69c579a5aa6922d67bb838a2de9cd
+  tag: v1.8.1
+  specs:
+    vagrant (1.8.1)
+      bundler (>= 1.5.2, <= 1.10.6)
+      childprocess (~> 0.5.0)
+      erubis (~> 2.7.0)
+      hashicorp-checkpoint (~> 0.1.1)
+      i18n (>= 0.6.0, <= 0.8.0)
+      listen (~> 3.0.2)
+      log4r (~> 1.1.9, < 1.1.11)
+      net-scp (~> 1.1.0)
+      net-sftp (~> 2.1)
+      net-ssh (~> 3.0.1)
+      nokogiri (= 1.6.3.1)
+      rb-kqueue (~> 0.2.0)
+      rest-client (>= 1.6.0, < 2.0)
+      wdm (~> 0.1.0)
+      winrm (~> 1.3)
+      winrm-fs (~> 0.2.2)
+
+PATH
+  remote: .
+  specs:
+    vagrant-instant-rsync-auto (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    builder (3.2.2)
+    childprocess (0.5.9)
+      ffi (~> 1.0, >= 1.0.11)
+    coderay (1.1.1)
+    domain_name (0.5.20160310)
+      unf (>= 0.0.5, < 1.0.0)
+    erubis (2.7.0)
+    ffi (1.9.10)
+    gssapi (1.2.0)
+      ffi (>= 1.0.1)
+    gyoku (1.3.1)
+      builder (>= 2.1.2)
+    hashicorp-checkpoint (0.1.4)
+    http-cookie (1.0.2)
+      domain_name (~> 0.5)
+    httpclient (2.8.0)
+    i18n (0.7.0)
+    json (1.8.3)
+    listen (3.0.8)
+      rb-fsevent (~> 0.9, >= 0.9.4)
+      rb-inotify (~> 0.9, >= 0.9.7)
+    little-plugger (1.1.4)
+    log4r (1.1.10)
+    logging (1.8.2)
+      little-plugger (>= 1.1.3)
+      multi_json (>= 1.8.4)
+    method_source (0.8.2)
+    mime-types (2.99.1)
+    mini_portile (0.6.0)
+    multi_json (1.12.1)
+    net-scp (1.1.2)
+      net-ssh (>= 2.6.5)
+    net-sftp (2.1.2)
+      net-ssh (>= 2.6.5)
+    net-ssh (3.0.2)
+    netrc (0.11.0)
+    nokogiri (1.6.3.1)
+      mini_portile (= 0.6.0)
+    nori (2.6.0)
+    pry (0.10.3)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rake (11.1.2)
+    rb-fsevent (0.9.7)
+    rb-inotify (0.9.7)
+      ffi (>= 0.5.0)
+    rb-kqueue (0.2.4)
+      ffi (>= 0.5.0)
+    rest-client (1.8.0)
+      http-cookie (>= 1.0.2, < 2.0)
+      mime-types (>= 1.16, < 3.0)
+      netrc (~> 0.7)
+    rubyntlm (0.4.0)
+    rubyzip (1.2.0)
+    slop (3.6.0)
+    unf (0.1.4)
+      unf_ext
+    unf_ext (0.0.7.2)
+    uuidtools (2.1.5)
+    wdm (0.1.1)
+    winrm (1.3.6)
+      builder (>= 2.1.2)
+      gssapi (~> 1.2)
+      gyoku (~> 1.0)
+      httpclient (~> 2.2, >= 2.2.0.2)
+      logging (>= 1.6.1, < 3.0)
+      nori (~> 2.0)
+      rubyntlm (~> 0.4.0)
+      uuidtools (~> 2.1.2)
+    winrm-fs (0.2.3)
+      erubis (~> 2.7)
+      logging (~> 1.6, >= 1.6.1)
+      rubyzip (~> 1.1)
+      winrm (~> 1.3.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler
+  json (~> 1.8.1)
+  pry
+  rake
+  vagrant!
+  vagrant-instant-rsync-auto!
+
+BUNDLED WITH
+   1.10.5

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Steven Merrill
+
+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,24 @@
+# vagrant-instant-rsync-auto
+
+An rsync watcher for Vagrant 1.5.1+ that's much faster than the native
+`vagrant rsync-auto` command.
+
+## Installation
+
+To get started, you need to have Vagrant 1.5.1 installed on your Linux, Mac, or
+Windows host machine. To install the plugin, use the following command.
+
+```bash
+vagrant plugin install vagrant-instant-rsync-auto
+```
+
+## Usage
+
+This plugin should behave exactly the same as `vagrant rsync-auto`, and in
+particular it uses the same configuration. So simply run
+```bash
+vagrant instant-rsync-auto```
+_in lieu_ of your usual `vagrant rsync-auto`, and you should be good to go!
+
+Hopefully this will make it into Vagrant proper, there's a pull request opened
+for that: https://github.com/mitchellh/vagrant/pull/7332

data/Rakefile

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

data/lib/vagrant-instant-rsync-auto.rb

@@ -0,0 +1,12 @@
+# This file is required because Vagrant's plugin system expects
+# an eponymous ruby file matching the rubygem.
+#
+# So this gem is called 'vagrant-instant-rsync-auto' and thus vagrant tries
+# to require 'vagrant-instant-rsync-auto'
+
+require 'vagrant-instant-rsync-auto/plugin'
+
+module VagrantPlugins
+  module InstantRsyncAuto
+  end
+end

data/lib/vagrant-instant-rsync-auto/command/instant_rsync_auto.rb

@@ -0,0 +1,241 @@
+require "log4r"
+require 'optparse'
+require "thread"
+
+require "vagrant/action/builtin/mixin_synced_folders"
+require "vagrant/util/busy"
+require "vagrant/util/platform"
+
+require_relative "../helper"
+
+# This is to avoid a bug in nio 1.0.0. Remove around nio 1.0.1
+if Vagrant::Util::Platform.windows?
+  ENV["NIO4R_PURE"] = "1"
+end
+
+require "listen"
+
+module VagrantPlugins
+  module InstantRsyncAuto
+    module Command
+      class RsyncAuto < Vagrant.plugin('2', :command)
+        include Vagrant::Action::Builtin::MixinSyncedFolders
+
+        def self.synopsis
+          "syncs rsync synced folders automatically when files change, faster than Vagrant's native rsync-auto"
+        end
+
+        def execute
+          @logger = Log4r::Logger.new("vagrant::commands::instant-rsync-auto")
+          @rsync_helpers = {}
+
+          options = {}
+          opts = OptionParser.new do |o|
+            o.banner = "Usage: vagrant instant-rsync-auto [vm-name]"
+            o.separator ""
+            o.separator "Options:"
+            o.separator ""
+
+            o.on("--[no-]poll", "Force polling filesystem (slow)") do |poll|
+              options[:poll] = poll
+            end
+          end
+
+          # Parse the options and return if we don't have any target.
+          argv = parse_options(opts)
+          return if !argv
+
+          # Build up the paths that we need to listen to.
+          paths = {}
+          ignores = []
+          with_target_vms(argv) do |machine|
+            if machine.provider.capability?(:proxy_machine)
+              proxy = machine.provider.capability(:proxy_machine)
+              if proxy
+                machine.ui.warn(I18n.t(
+                  "vagrant.rsync_proxy_machine",
+                  name: machine.name.to_s,
+                  provider: machine.provider_name.to_s))
+
+                machine = proxy
+              end
+            end
+
+            cached = synced_folders(machine, cached: true)
+            fresh  = synced_folders(machine)
+            diff   = synced_folders_diff(cached, fresh)
+            if !diff[:added].empty?
+              machine.ui.warn(I18n.t("vagrant.rsync_auto_new_folders"))
+            end
+
+            folders = cached[:rsync]
+            next if !folders || folders.empty?
+
+            # Get the SSH info for this machine so we can do an initial
+            # sync to the VM.
+            ssh_info = machine.ssh_info
+            if ssh_info
+              machine.ui.info(I18n.t("vagrant.rsync_auto_initial"))
+              folders.each do |id, folder_opts|
+                rsync_helper(machine, id, folder_opts).rsync_single
+              end
+            end
+
+            folders.each do |id, folder_opts|
+              # If we marked this folder to not auto sync, then
+              # don't do it.
+              next if folder_opts.key?(:auto) && !folder_opts[:auto]
+
+              hostpath = folder_opts[:hostpath]
+              hostpath = File.expand_path(hostpath, machine.env.root_path)
+              paths[hostpath] ||= []
+              paths[hostpath] << {
+                id: id,
+                machine: machine,
+                opts:    folder_opts,
+              }
+
+              if folder_opts[:exclude]
+                Array(folder_opts[:exclude]).each do |pattern|
+                  ignores << RsyncHelper.exclude_to_regexp(hostpath, pattern.to_s)
+                end
+              end
+            end
+          end
+
+          # Exit immediately if there is nothing to watch
+          if paths.empty?
+            @env.ui.info(I18n.t("vagrant.rsync_auto_no_paths"))
+            return 1
+          end
+
+          # Output to the user what paths we'll be watching
+          paths.keys.sort.each do |path|
+            paths[path].each do |path_opts|
+              path_opts[:machine].ui.info(I18n.t(
+                "vagrant.rsync_auto_path",
+                path: path.to_s,
+              ))
+            end
+          end
+
+          @logger.info("Listening to paths: #{paths.keys.sort.inspect}")
+          @logger.info("Ignoring #{ignores.length} paths:")
+          ignores.each do |ignore|
+            @logger.info("  -- #{ignore.to_s}")
+          end
+          @logger.info("Listening via: #{Listen::Adapter.select.inspect}")
+          callback = method(:callback).to_proc.curry[paths]
+          listopts = { ignore: ignores, force_polling: !!options[:poll] }
+          listener = Listen.to(*paths.keys, listopts, &callback)
+
+          # Create the callback that lets us know when we've been interrupted
+          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 is the callback that is called when any changes happen
+        def callback(paths, modified, added, removed)
+          @logger.info("File change callback called!")
+          @logger.info("  - Modified: #{modified.inspect}")
+          @logger.info("  - Added: #{added.inspect}")
+          @logger.info("  - Removed: #{removed.inspect}")
+
+          tosync = []
+          paths.each do |hostpath, folders|
+            # Find out if this path should be synced
+            found = catch(:done) do
+              [modified, added, removed].each do |changed|
+                changed.each do |listenpath|
+                  throw :done, true if listenpath.start_with?(hostpath)
+                end
+              end
+
+              # Make sure to return false if all else fails so that we
+              # don't sync to this machine.
+              false
+            end
+
+            # If it should be synced, store it for later
+            tosync << folders if found
+          end
+
+          # Sync all the folders that need to be synced
+          tosync.each do |folders|
+            folders.each do |opts|
+              # Reload so we get the latest ID
+              opts[:machine].reload
+              if !opts[:machine].id || opts[:machine].id == ""
+                # Skip since we can't get SSH info without an ID
+                next
+              end
+
+              ssh_info = opts[:machine].ssh_info
+              begin
+                start = Time.now
+                rsync_helper(opts[:machine], opts[:id], opts[:opts]).rsync_single
+                finish = Time.now
+                time_spent_msg = "Time spent in rsync: #{finish-start} (in seconds)"
+                @logger.info(time_spent_msg)
+                opts[:machine].ui.info(time_spent_msg)
+              rescue Vagrant::Errors::MachineGuestNotReady
+                # Error communicating to the machine, probably a reload or
+                # halt is happening. Just notify the user but don't fail out.
+                opts[:machine].ui.error(I18n.t(
+                  "vagrant.rsync_communicator_not_ready_callback"))
+              rescue Vagrant::Errors::RSyncError => e
+                # Error executing rsync, so show an error
+                opts[:machine].ui.error(I18n.t(
+                  "vagrant.rsync_auto_rsync_error", message: e.to_s))
+              end
+            end
+          end
+        end
+
+        def rsync_helper(machine, folder_id, folder_opts)
+          machine_helpers = rsync_helpers_for_machine(machine)
+
+          rsync_helpers_for_id(machine, folder_id, folder_opts, machine_helpers)
+        end
+
+        def rsync_helpers_for_machine(machine)
+          @rsync_helpers[machine.id] ||= {}
+        end
+
+        def rsync_helpers_for_id(machine, folder_id, folder_opts, machine_helpers)
+          unless machine_helpers.key?(folder_id)
+            rsync_helper = nil
+            ssh_info = machine.ssh_info
+
+            if ssh_info
+              folder_opts = folder_opts.merge(
+                skip_rsync_pre_after_first_sync: true,
+                skip_rsync_post_after_first_sync: true
+              )
+
+              rsync_helper = RsyncHelper.new(machine, ssh_info, folder_opts)
+            end
+
+            machine_helpers[folder_id] = rsync_helper
+          end
+
+          machine_helpers[folder_id]
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-instant-rsync-auto/helper.rb

@@ -0,0 +1,257 @@
+require "vagrant/util/platform"
+require "vagrant/util/subprocess"
+
+module VagrantPlugins
+  module InstantRsyncAuto
+    # This is a helper that abstracts out the functionality of rsyncing
+    # folders so that it can be called from anywhere.
+    class RsyncHelper
+      def initialize(machine, ssh_info, opts)
+        @machine = machine
+
+        @opts = normalize_opts(opts, ssh_info)
+
+        @guestpath = guestpath
+        @hostpath = hostpath
+        @excludes = excludes
+
+        @rsync_command = rsync_command(ssh_info)
+        @rsync_command_opts = rsync_command_opts
+
+        @first_sync_done = false
+      end
+
+      def rsync_single
+        log_info
+
+        # If we have tasks to do before rsyncing, do those.
+        if !skip_rsync_pre? && @machine.guest.capability?(:rsync_pre)
+          @machine.guest.capability(:rsync_pre, @opts)
+        end
+
+        subprocess = if verbose?
+          Vagrant::Util::Subprocess.execute(*(@rsync_command + [@rsync_command_opts])) {
+            |io_name,data| data.each_line { |line|
+              @machine.ui.info("rsync[#{io_name}] -> #{line}") }
+          }
+        else
+          Vagrant::Util::Subprocess.execute(*(@rsync_command + [@rsync_command_opts]))
+        end
+
+        if subprocess.exit_code != 0
+          raise Vagrant::Errors::RSyncError,
+            command: @rsync_command.join(" "),
+            guestpath: @guestpath,
+            hostpath: @hostpath,
+            stderr: subprocess.stderr
+        end
+
+        # If we have tasks to do after rsyncing, do those.
+        if !skip_rsync_post? && @machine.guest.capability?(:rsync_post)
+          @machine.guest.capability(:rsync_post, @opts)
+        end
+
+        @first_sync_done = true
+      end
+
+      # This converts an rsync exclude pattern to a regular expression
+      # we can send to Listen.
+      def self.exclude_to_regexp(path, exclude)
+        start_anchor = false
+
+        if exclude.start_with?("/")
+          start_anchor = true
+          exclude      = exclude[1..-1]
+        end
+
+        path   = "#{path}/" if !path.end_with?("/")
+        regexp = "^#{Regexp.escape(path)}"
+        regexp += ".*" if !start_anchor
+
+        # This is REALLY ghetto, but its a start. We can improve and
+        # keep unit tests passing in the future.
+        exclude = exclude.gsub("**", "|||GLOBAL|||")
+        exclude = exclude.gsub("*", "|||PATH|||")
+        exclude = exclude.gsub("|||PATH|||", "[^/]*")
+        exclude = exclude.gsub("|||GLOBAL|||", ".*")
+        regexp += exclude
+
+        Regexp.new(regexp)
+      end
+
+      def self.rsync_single(machine, ssh_info, opts)
+        machine.ui.warn("WARNING: `VagrantPlugins::SyncedFolderRSync::RsyncHelper.rsync_single`")
+        machine.ui.warn("is a deprecated internal API. Please use an instance of that class instead.")
+
+        instance = new(machine, ssh_info, opts)
+        instance.rsync_single
+      end
+
+      private
+
+      def verbose?
+        @opts.include?(:verbose)
+      end
+
+      def normalize_opts(opts, ssh_info)
+        # Folder options
+        opts[:owner] ||= ssh_info[:username]
+        opts[:group] ||= ssh_info[:username]
+
+        opts
+      end
+
+      def guestpath
+        # if the guest has a guest path scrubber capability, use it
+        if @machine.guest.capability?(:rsync_scrub_guestpath)
+          @machine.guest.capability(:rsync_scrub_guestpath, @opts)
+        else
+          @opts[:guestpath]
+        end
+      end
+
+      def hostpath
+        hostpath = @opts[:hostpath]
+        hostpath = File.expand_path(hostpath, @machine.env.root_path)
+        hostpath = Vagrant::Util::Platform.fs_real_path(hostpath).to_s
+
+        if Vagrant::Util::Platform.windows?
+          # rsync for Windows expects cygwin style paths, always.
+          hostpath = Vagrant::Util::Platform.cygwin_path(hostpath)
+        end
+
+        # Make sure the host path ends with a "/" to avoid creating
+        # a nested directory...
+        if !hostpath.end_with?("/")
+          hostpath += "/"
+        end
+
+        hostpath
+      end
+
+      # Builds up the actual command to execute
+      def rsync_command(ssh_info)
+        [
+          "rsync",
+          rsync_args,
+          "-e", rsync_ssh_command(ssh_info),
+          @excludes.map { |e| ["--exclude", e] },
+          @hostpath,
+          "#{ssh_connection_info(ssh_info)}:#{@guestpath}",
+        ].flatten
+      end
+
+      def rsync_ssh_command(ssh_info)
+        # Create the path for the control sockets. We used to do this
+        # in the machine data dir but this can result in paths that are
+        # too long for unix domain sockets.
+        controlpath = File.join(Dir.tmpdir, "ssh.#{rand(1000)}")
+
+        [
+          "ssh -p #{ssh_info[:port]} " +
+          proxy_command(ssh_info) +
+          "-o ControlMaster=auto " +
+          "-o ControlPath=#{controlpath} " +
+          "-o ControlPersist=10m " +
+          "-o StrictHostKeyChecking=no " +
+          "-o IdentitiesOnly=true " +
+          "-o UserKnownHostsFile=/dev/null",
+          private_key_paths(ssh_info),
+        ].flatten.join(' ')
+      end
+
+      def proxy_command(ssh_info)
+        if ssh_info[:proxy_command]
+          "-o ProxyCommand='#{ssh_info[:proxy_command]}' "
+        else
+          ''
+        end
+      end
+
+      def private_key_paths(ssh_info)
+        ssh_info[:private_key_path].map { |p| "-i '#{p}'" }
+      end
+
+      def ssh_connection_info(ssh_info)
+        username = ssh_info[:username]
+        host     = ssh_info[:host]
+
+        "#{username}@#{host}"
+      end
+
+      # Exclude some files by default, and any that might be configured
+      # by the user.
+      def excludes
+        excludes = ['.vagrant/']
+        excludes += Array(@opts[:exclude]).map(&:to_s) if @opts[:exclude]
+        excludes.uniq
+      end
+
+      # Builds the command-line arguments for rsync
+      def rsync_args
+        args = nil
+        args = Array(@opts[:args]).dup if @opts[:args]
+        args ||= ['--verbose', '--archive', '--delete', '-z', '--copy-links']
+
+        # On Windows, we have to set a default chmod flag to avoid permission issues
+        if Vagrant::Util::Platform.windows? && !args.any? { |arg| arg.start_with?('--chmod=') }
+          # Ensures that all non-masked bits get enabled
+          args << '--chmod=ugo=rwX'
+
+          # Remove the -p option if --archive is enabled (--archive equals -rlptgoD)
+          # otherwise new files will not have the destination-default permissions
+          args << '--no-perms' if args.include?('--archive') || args.include?('-a')
+        end
+
+        # Disable rsync's owner/group preservation (implied by --archive) unless
+        # specifically requested, since we adjust owner/group to match shared
+        # folder setting ourselves.
+        args << '--no-owner' unless args.include?('--owner') || args.include?('-o')
+        args << '--no-group' unless args.include?('--group') || args.include?('-g')
+
+        # Tell local rsync how to invoke remote rsync with sudo
+        rsync_path = @opts[:rsync_path]
+        if !rsync_path && @machine.guest.capability?(:rsync_command)
+          rsync_path = @machine.guest.capability(:rsync_command)
+        end
+        if rsync_path
+          args << "--rsync-path"<< rsync_path
+        end
+
+        args
+      end
+
+      def rsync_command_opts
+        # The working directory should be the root path
+        command_opts = {}
+        command_opts[:workdir] = @machine.env.root_path.to_s
+
+        if verbose?
+          command_opts[:notify] = [:stdout, :stderr]
+        end
+
+        command_opts
+      end
+
+      def log_info
+        @machine.ui.info(I18n.t(
+          "vagrant.rsync_folder", guestpath: @guestpath, hostpath: @hostpath))
+        if excludes.length > 1
+          @machine.ui.info(I18n.t(
+            "vagrant.rsync_folder_excludes", excludes: @excludes.inspect))
+        end
+        if verbose?
+          @machine.ui.info(I18n.t("vagrant.rsync_showing_output"));
+        end
+      end
+
+      def skip_rsync_pre?
+        @opts[:skip_rsync_pre] || @first_sync_done && @opts[:skip_rsync_pre_after_first_sync]
+      end
+
+      def skip_rsync_post?
+        @opts[:skip_rsync_post] || @first_sync_done && @opts[:skip_rsync_post_after_first_sync]
+      end
+    end
+  end
+end

data/lib/vagrant-instant-rsync-auto/plugin.rb

@@ -0,0 +1,19 @@
+begin
+  require 'vagrant'
+rescue LoadError
+  raise 'The Vagrant instant-rsync-auto plugin must be run within Vagrant.'
+end
+
+module VagrantPlugins
+  module InstantRsyncAuto
+    class Plugin < Vagrant.plugin('2')
+      name 'Instant Rsync Auto'
+      description 'A vagrant plugin that does the same as `vagrant rsync-auto`, except much faster!'
+
+      command 'instant-rsync-auto' do
+        require_relative 'command/instant_rsync_auto'
+        Command::RsyncAuto
+      end
+    end
+  end
+end

data/lib/vagrant-instant-rsync-auto/version.rb

@@ -0,0 +1,5 @@
+module VagrantPlugins
+  module InstantRsyncAuto
+    VERSION = '0.1.0'
+  end
+end

data/vagrant-instant-rsync-auto.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'vagrant-instant-rsync-auto/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'vagrant-instant-rsync-auto'
+  spec.version       = VagrantPlugins::InstantRsyncAuto::VERSION
+  spec.authors       = ['Jean Rouge']
+  spec.email         = ['jer329@cornell.edu']
+  spec.summary       = %q{A faster alternative to `vagrant rsync-auto`}
+  spec.homepage      = 'https://github.com/wk8/vagrant-instant-rsync-auto'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject {|f| f.start_with?('example/files')}
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'pry'
+  # Make Vagrant work on Linux for development.
+  spec.add_development_dependency 'json', '~> 1.8.1'
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: vagrant-instant-rsync-auto
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jean Rouge
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-05-20 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'
+- !ruby/object:Gem::Dependency
+  name: pry
+  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: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.1
+description: 
+email:
+- jer329@cornell.edu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".ruby-version"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- lib/vagrant-instant-rsync-auto.rb
+- lib/vagrant-instant-rsync-auto/command/instant_rsync_auto.rb
+- lib/vagrant-instant-rsync-auto/helper.rb
+- lib/vagrant-instant-rsync-auto/plugin.rb
+- lib/vagrant-instant-rsync-auto/version.rb
+- vagrant-instant-rsync-auto.gemspec
+homepage: https://github.com/wk8/vagrant-instant-rsync-auto
+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.4.5.1
+signing_key: 
+specification_version: 4
+summary: A faster alternative to `vagrant rsync-auto`
+test_files: []