vagrant-reflect 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b77f5185eaca2cb86349a56fc5280c7cf85a4c03
-  data.tar.gz: 6880a8b81c7948a72ecc81015e1c91027d873c45
+  metadata.gz: 10bf068f0fcd1751185c72edc2b8a9d0f9d3fc62
+  data.tar.gz: 62751eb5164e9a8f7bfd1f9d8793d245a300de67
 SHA512:
-  metadata.gz: 96b6e7acdf4ba6d4ac037d5470b2d072d7d12f315bd49e99007764e153828caaa57858ebbf3c6c0389c0355f89487dab96bae30599ac86a3f5583a77d3a389ae
-  data.tar.gz: a1a38e17fc7eb0d66bfef0482bdd4412723816eaa08cc4fd07c1404d49721e4c51cb0dc826399a39cd586348ba194b97426f73c74b9276e4304386bceef4c33c
+  metadata.gz: f5639afa42e9dc1767a9a29978dbcbed82904fa70b079d12d3c72ee4bec3c93751ea1422ad8838911383426a14d7e56bfb0a1b241af353340f9603fd29366c91
+  data.tar.gz: 2fe41628e246d06af901be938cded207f5a635a627cf1844f2d3ffdbeeda2f47f8319f9898c9d0170734eed42e700217254e98b049d3ee78bcfbe3965e1e7ae5

data/lib/vagrant-reflect/command/reflect.rb

@@ -6,7 +6,7 @@ require 'vagrant/action/builtin/mixin_synced_folders'
 require 'vagrant/util/busy'
 require 'vagrant/util/platform'
 
-require_relative '../helper'
+require_relative '../util/syncer'
 
 require 'driskell-listen'
 
@@ -74,29 +74,30 @@ module VagrantReflect
           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.plugins.vagrant-reflect.rsync_auto_initial'))
-            folders.each do |_, folder_opts|
-              SyncHelper.sync_single(machine, ssh_info, folder_opts)
-            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]
 
+            # Push on .vagrant exclude
+            folder_opts = folder_opts.dup
+            folder_opts[:exclude] ||= []
+            folder_opts[:exclude] << '.vagrant/'
+
+            syncer = Syncer.new(machine, folder_opts)
+
+            machine.ui.info(
+              I18n.t('vagrant.plugins.vagrant-reflect.rsync_auto_initial'))
+            syncer.sync_full
+
             hostpath = folder_opts[:hostpath]
             hostpath = File.expand_path(hostpath, machine.env.root_path)
             paths[hostpath] ||= []
             paths[hostpath] << {
-              id: id,
+              id:      id,
               machine: machine,
-              opts:    folder_opts
+              opts:    folder_opts,
+              syncer:  syncer
             }
           end
         end
@@ -124,10 +125,10 @@ module VagrantReflect
                 'vagrant.plugins.vagrant-reflect.rsync_auto_path',
                 path: path.to_s))
 
-            next unless path_opts[:exclude]
+            next unless path_opts[:opts][:exclude]
 
-            Array(path_opts[:exclude]).each do |pattern|
-              ignores << SyncHelper.exclude_to_regexp(hostpath, pattern.to_s)
+            Array(path_opts[:opts][:exclude]).each do |pattern|
+              ignores << Syncer.exclude_to_regexp(pattern.to_s)
             end
           end
 
@@ -171,13 +172,6 @@ module VagrantReflect
 
         # Perform the sync for each machine
         opts.each do |path_opts|
-          # Reload so we get the latest ID
-          path_opts[:machine].reload
-          if !path_opts[:machine].id || path_opts[:machine].id == ''
-            # Skip since we can't get SSH info without an ID
-            next
-          end
-
           begin
             # If we have any removals or have disabled incremental, perform a
             # single full sync
@@ -185,25 +179,33 @@ module VagrantReflect
             if !options[:incremental] || !removed.empty?
               removed.each do |remove|
                 path_opts[:machine].ui.info(
-                  I18n.t('vagrant.plugins.vagrant-reflect.rsync_auto_remove',
-                         path: remove))
+                  I18n.t(
+                    'vagrant.plugins.vagrant-reflect.rsync_auto_full_remove',
+                    path: strip_path(path, remove)))
               end
 
               [modified, added].each do |changes|
                 changes.each do |change|
                   path_opts[:machine].ui.info(
-                    I18n.t('vagrant.plugins.vagrant-reflect.rsync_auto_change',
-                           path: change))
+                    I18n.t(
+                      'vagrant.plugins.vagrant-reflect.rsync_auto_full_change',
+                      path: strip_path(path, change)))
                 end
               end
 
-              SyncHelper.sync_single(
-                path_opts[:machine],
-                path_opts[:machine].ssh_info,
-                path_opts[:opts]
-              )
+              path_opts[:machine].ui.info(
+                I18n.t('vagrant.plugins.vagrant-reflect.rsync_auto_full'))
+
+              path_opts[:syncer].sync_full
             elsif !modified.empty? || !added.empty?
-              synchronize_changes(path, path_opts, options, [modified, added])
+              # Pass the list of changes to rsync so we quickly synchronise only
+              # the changed files instead of the whole folder
+              items = strip_paths(path, modified + added)
+              path_opts[:syncer].sync_incremental(items) do |item|
+                path_opts[:machine].ui.info(
+                  I18n.t('vagrant.plugins.vagrant-reflect.rsync_auto_increment',
+                         path: item))
+              end
             end
 
             path_opts[:machine].ui.info(
@@ -215,70 +217,19 @@ module VagrantReflect
               I18n.t('vagrant.plugins.vagrant-reflect.'\
                      'rsync_communicator_not_ready_callback'))
           rescue Vagrant::Errors::VagrantError => e
-            path_opts[:machine].ui.error(e)
+            path_opts[:machine].ui.error(e.message)
           end
         end
       end
 
-      # Helper to pull the next change from a set of changes of the form
-      # [ set1, set2, set3 ]
-      # Sets are removed as they are emptied
-      def next_change(sets, path)
-        line = sets[0].pop
-        sets.shift while !sets.empty? && sets[0].empty?
-        line[path.length..line.length] + "\n"
+      def strip_paths(path, items)
+        items.map do |item|
+          item[path.length..-1]
+        end
       end
 
-      def synchronize_changes(path, path_opts, options, sets)
-        # Grab the first change
-        sets.shift while sets[0].empty?
-        line = false
-
-        # Pass the list of changes to rsync so we quickly synchronise only
-        # the changed files instead of the whole folder
-        SyncHelper.sync_single(
-          path_opts[:machine],
-          path_opts[:machine].ssh_info,
-          path_opts[:opts].merge(from_stdin: true)
-        ) do |what, io|
-          next if what != :stdin
-
-          if line.nil?
-            io.close_write
-            next
-          end
-
-          begin
-            loop do
-              # If we don't have a line, grab one and print it
-              unless line
-                line = next_change(sets, path)
-                path_opts[:machine].ui.info(
-                  I18n.t('vagrant.plugins.vagrant-reflect.rsync_auto_increment',
-                         path: line))
-              end
-
-              # Handle partial writes
-              n = io.write_nonblock(line)
-              if n < line.length
-                line = line[n..line.length]
-                break
-              end
-
-              # When we've finished giving rsync the file list, set line to nil
-              # and return - on the next notify we will EOT stdin
-              if sets.empty?
-                line = nil
-                break
-              end
-
-              # Request a new line for next write
-              line = false
-            end
-          rescue IO::WaitWritable, Errno::EINTR
-            # Ignore
-          end
-        end
+      def strip_path(path, item)
+        item[path.length..-1]
       end
     end
   end

data/lib/vagrant-reflect/util/syncer.rb

@@ -0,0 +1,214 @@
+require 'vagrant/util/platform'
+
+require_relative '../patched/subprocess'
+
+module VagrantReflect
+  # This is a helper that abstracts out the functionality of rsyncing
+  # folders so that it can be called from anywhere.
+  class Syncer
+    # This converts an rsync exclude pattern to a regular expression
+    # we can send to Listen.
+    def self.exclude_to_regexp(exclude)
+      start_anchor = false
+      dir_only = false
+
+      if exclude.start_with?('/')
+        start_anchor = true
+        exclude      = exclude[1..-1]
+      end
+
+      if exclude.end_with?('/')
+        dir_only = true
+        exclude      = exclude[0..-2]
+      end
+
+      regexp = start_anchor ? '^' : '(?:^|/)'
+
+      # This is REALLY ghetto, but its a start. We can improve and
+      # keep unit tests passing in the future.
+      # TODO: Escaped wildcards get substituted incorrectly - replace with FSM?
+      exclude = exclude.gsub('.', '\\.')
+      exclude = exclude.gsub('***', '|||EMPTY|||')
+      exclude = exclude.gsub('**', '|||GLOBAL|||')
+      exclude = exclude.gsub('*', '|||PATH|||')
+      exclude = exclude.gsub('?', '[^/]')
+      exclude = exclude.gsub('|||PATH|||', '[^/]+')
+      exclude = exclude.gsub('|||GLOBAL|||', '.+')
+      exclude = exclude.gsub('|||EMPTY|||', '.*')
+      regexp += exclude
+
+      regexp += dir_only ? '/' : '(?:/|$)'
+
+      Regexp.new(regexp)
+    end
+
+    def initialize(machine, opts)
+      @opts = opts
+      @machine = machine
+      @workdir = @machine.env.root_path.to_s
+
+      # Folder info
+      @guestpath = @opts[:guestpath]
+      @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...
+      @hostpath += '/' unless @hostpath.end_with?('/')
+
+      # Connection information
+      username = @machine.ssh_info[:username]
+      host     = @machine.ssh_info[:host]
+      proxy_command = ''
+      if @machine.ssh_info[:proxy_command]
+        proxy_command = "-o ProxyCommand='#{@machine.ssh_info[:proxy_command]}' "
+      end
+
+      rsh = [
+        "ssh -p #{@machine.ssh_info[:port]} " +
+          proxy_command +
+          '-o StrictHostKeyChecking=no '\
+          '-o IdentitiesOnly=true '\
+          '-o UserKnownHostsFile=/dev/null',
+        @machine.ssh_info[:private_key_path].map { |p| "-i '#{p}'" }
+      ].flatten.join(' ')
+
+      @target = "#{username}@#{host}:#{@guestpath}"
+
+      # Exclude some files by default, and any that might be configured
+      # by the user.
+      excludes = []
+      excludes += Array(@opts[:exclude]).map(&:to_s) if @opts[:exclude]
+      excludes.uniq!
+
+      # Get the command-line arguments
+      @command = ['rsync']
+      @command += Array(@opts[:args]).dup if @opts[:args]
+      @command ||= ['--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?
+        unless @command.any? { |arg| arg.start_with?('--chmod=') }
+          # Ensures that all non-masked bits get enabled
+          @command << '--chmod=ugo=rwX'
+
+          # Remove the -p option if --archive is enabled (--archive equals
+          # -rlptgoD) otherwise new files will not have the destination-default
+          # permissions
+          @command << '--no-perms' if
+            @command.include?('--archive') || @command.include?('-a')
+        end
+      end
+
+      # Disable rsync's owner/group preservation (implied by --archive) unless
+      # specifically requested, since we adjust owner/group to match shared
+      # folder setting ourselves.
+      @command << '--no-owner' unless
+        @command.include?('--owner') || @command.include?('-o')
+      @command << '--no-group' unless
+        @command.include?('--group') || @command.include?('-g')
+
+      # Tell local rsync how to invoke remote rsync with sudo
+      if @machine.guest.capability?(:rsync_command)
+        @command << '--rsync-path' << @machine.guest.capability(:rsync_command)
+      end
+
+      @command += [
+        '-e', rsh
+      ]
+
+      excludes.map { |e| @command += ['--exclude', e] }
+
+      machine.ui.info(
+        I18n.t(
+          'vagrant.plugins.vagrant-reflect.rsync_folder_configuration',
+          guestpath: @guestpath,
+          hostpath: @hostpath))
+      if excludes.length > 1
+        machine.ui.info(
+          I18n.t(
+            'vagrant.plugins.vagrant-reflect.rsync_folder_excludes',
+            excludes: excludes.inspect))
+      end
+    end
+
+    def sync_incremental(items, &block)
+      command = @command.dup + [
+        '--files-from=-',
+        @hostpath,
+        @target,
+        {
+          workdir: @workdir,
+          notify: :stdin
+        }
+      ]
+
+      current = false
+      r = Vagrant::Util::SubprocessPatched.execute(*command) do |what, io|
+        next if what != :stdin
+
+        current = process_items(io, items, current, &block)
+      end
+
+      check_exit command, r
+    end
+
+    def sync_full
+      command = @command.dup + [
+        @hostpath,
+        @target,
+        {
+          workdir: @workdir
+        }
+      ]
+
+      r = Vagrant::Util::SubprocessPatched.execute(*command)
+
+      check_exit command, r
+    end
+
+    protected
+
+    def process_items(io, items, current, &block)
+      until items.empty?
+        # If we don't have a line, grab one and print it
+        if current === false
+          current = items.shift + "\n"
+          block.call(current) if block_given?
+        end
+
+        # Handle partial writes
+        n = io.write_nonblock(current)
+        if n < current.length
+          current = current[n..current.length]
+          break
+        end
+
+        # Request a new line for next write
+        current = false
+      end
+
+      # Finished! Close stdin
+      io.close_write
+    rescue IO::WaitWritable, Errno::EINTR
+      # Ignore
+    end
+
+    def check_exit(command, r)
+      return if r.exit_code == 0
+
+      raise Vagrant::Errors::RSyncError,
+            command: command.join(' '),
+            guestpath: @guestpath,
+            hostpath: @hostpath,
+            stderr: r.stderr
+    end
+  end
+end

data/lib/vagrant-reflect/version.rb

@@ -1,3 +1,3 @@
 module VagrantReflect
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
 end

data/templates/locales/en.yml

@@ -16,20 +16,20 @@ en:
           Watching: %{path}
         rsync_auto_increment: |-
           Sending change: %{path}
-        rsync_auto_change: |-
+        rsync_auto_full_change: |-
           Processing change: %{path}
-        rsync_auto_remove: |-
+        rsync_auto_full_remove: |-
           Processing removal: %{path}
+        rsync_auto_full: |-
+          Performing full synchronisation due to removals
         rsync_auto_synced: |-
           Synchronization completed
         rsync_communicator_not_ready_callback: |-
           Failed to connect to remote machine. This is usually caused by the
           machine rebooting or being halted. Please make sure the machine is
           running, and modify a file to try again.
-        rsync_folder: |-
-          Rsyncing folder: %{hostpath} => %{guestpath}
-        rsync_folder_changes: |-
-          Rsyncing changes only: %{hostpath} => %{guestpath}
+        rsync_folder_configuration: |-
+          Configuring rsync: %{hostpath} => %{guestpath}
         rsync_folder_excludes: "  - Exclude: %{excludes}"
         rsync_proxy_machine: |-
           The provider ('%{provider}') for the machine '%{name}' is

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vagrant-reflect
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Jason Woods
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-22 00:00:00.000000000 Z
+date: 2016-03-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: driskell-listen
@@ -33,9 +33,9 @@ extra_rdoc_files: []
 files:
 - lib/vagrant-reflect.rb
 - lib/vagrant-reflect/command/reflect.rb
-- lib/vagrant-reflect/helper.rb
 - lib/vagrant-reflect/patched/subprocess.rb
 - lib/vagrant-reflect/plugin.rb
+- lib/vagrant-reflect/util/syncer.rb
 - lib/vagrant-reflect/version.rb
 - templates/locales/en.yml
 homepage: https://github.com/driskell/vagrant-reflect

data/lib/vagrant-reflect/helper.rb

@@ -1,169 +0,0 @@
-require 'vagrant/util/platform'
-
-require_relative 'patched/subprocess'
-
-module VagrantReflect
-  # This is a helper that abstracts out the functionality of rsyncing
-  # folders so that it can be called from anywhere.
-  class SyncHelper
-    # 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}/" unless path.end_with?('/')
-      regexp = "^#{Regexp.escape(path)}"
-      regexp += '.*' unless 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.sync_single(machine, ssh_info, opts, &block)
-      # Folder info
-      guestpath = opts[:guestpath]
-      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...
-      hostpath += '/' unless hostpath.end_with?('/')
-
-      # Folder options
-      opts[:owner] ||= ssh_info[:username]
-      opts[:group] ||= ssh_info[:username]
-
-      # Connection information
-      username = ssh_info[:username]
-      host     = ssh_info[:host]
-      proxy_command = ''
-      if ssh_info[:proxy_command]
-        proxy_command = "-o ProxyCommand='#{ssh_info[:proxy_command]}' "
-      end
-
-      rsh = [
-        "ssh -p #{ssh_info[:port]} " +
-          proxy_command +
-          '-o StrictHostKeyChecking=no '\
-          '-o IdentitiesOnly=true '\
-          '-o UserKnownHostsFile=/dev/null',
-        ssh_info[:private_key_path].map { |p| "-i '#{p}'" }
-      ].flatten.join(' ')
-
-      # Exclude some files by default, and any that might be configured
-      # by the user.
-      excludes = ['.vagrant/']
-      excludes += Array(opts[:exclude]).map(&:to_s) if opts[:exclude]
-      excludes.uniq!
-
-      # Get the command-line arguments
-      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?
-        unless 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
-      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
-      if machine.guest.capability?(:rsync_command)
-        args << '--rsync-path' << machine.guest.capability(:rsync_command)
-      end
-
-      args << '--files-from=-' if opts[:from_stdin] && block_given?
-
-      # Build up the actual command to execute
-      command = [
-        'rsync',
-        args,
-        '-e', rsh,
-        excludes.map { |e| ['--exclude', e] },
-        hostpath,
-        "#{username}@#{host}:#{guestpath}"
-      ].flatten
-
-      # The working directory should be the root path
-      command_opts = {}
-      command_opts[:workdir] = machine.env.root_path.to_s
-      command_opts[:notify] = [:stdin] if opts[:from_stdin] && block_given?
-
-      if opts[:from_stdin] && block_given?
-        machine.ui.info(
-          I18n.t(
-            'vagrant.plugins.vagrant-reflect.rsync_folder_changes',
-            guestpath: guestpath,
-            hostpath: hostpath))
-      else
-        machine.ui.info(
-          I18n.t(
-            'vagrant.plugins.vagrant-reflect.rsync_folder',
-            guestpath: guestpath,
-            hostpath: hostpath))
-      end
-      if excludes.length > 1
-        machine.ui.info(
-          I18n.t(
-            'vagrant.plugins.vagrant-reflect.rsync_folder_excludes',
-            excludes: excludes.inspect))
-      end
-
-      # If we have tasks to do before rsyncing, do those.
-      if machine.guest.capability?(:rsync_pre)
-        machine.guest.capability(:rsync_pre, opts)
-      end
-
-      r = Vagrant::Util::SubprocessPatched.execute(*(command + [command_opts]), &block)
-      if r.exit_code != 0
-        raise Vagrant::Errors::RSyncError,
-              command: command.join(' '),
-              guestpath: guestpath,
-              hostpath: hostpath,
-              stderr: r.stderr
-      end
-
-      # If we have tasks to do after rsyncing, do those.
-      # REMOVE THESE - it triggers for VirtualBox an expensive find command that
-      # changes ownership, but we don't believe this is necessary
-      # if machine.guest.capability?(:rsync_post)
-      #   machine.guest.capability(:rsync_post, opts)
-      # end
-    end
-  end
-end