vagrant-mirror 0.1.0.alpha

data/lib/vagrant-mirror/middleware/mirror.rb

@@ -0,0 +1,108 @@
+# Monitors changes on the host and guest instance, and propogates any new, changed
+# or deleted files between machines. Note that this will block the vagrant
+# execution on the host.
+#
+# @author Andrew Coulton < andrew@ingerator.com >
+module Vagrant
+  module Mirror
+    module Middleware
+      class Mirror < Base
+
+        # Loads the rest of the middlewares first, then finishes up by running
+        # the mirror middleware. This allows the listener to start after the
+        # instance has been provisioned.
+        #
+        # @param [Vagrant::Action::Environment] The environment
+        def call(env)
+          @app.call(env)
+
+          mirrors = env[:vm].config.mirror.folders
+          if !mirrors.empty?
+            execute(mirrors, env)
+          else
+            env[:ui].info("No vagrant-mirror mirrored folders configured for this box")
+          end
+        end
+
+        protected
+
+        # Mirrors the folder pairs configured in the vagrantfile
+        #
+        # @param [Array] The folder pairs to synchronise
+        # @param [Vagrant::Action::Environment] The environment
+        def execute(mirrors, env)
+          ui = env[:ui]
+          ui.info("Beginning directory mirroring")
+
+          begin
+            workers = []
+
+            # Create a thread to work off the queue for each folder
+            each_mirror(mirrors) do | host_path, guest_sf_path, mirror_config |
+              workers << Thread.new do
+                # Set up the listener and the changes queue
+                Thread.current["queue"] = Queue.new
+                host_listener = Vagrant::Mirror::Listener::Host.new(host_path, Thread.current["queue"])
+                rsync = Vagrant::Mirror::Rsync.new(env[:vm], guest_sf_path, host_path, mirror_config)
+
+                # Start listening and store the thread reference
+                Thread.current["listener"] = host_listener.listen
+
+                # Just poll indefinitely waiting for changes or to be told to quit
+                quit = false
+                while !quit
+                  change = Thread.current["queue"].pop
+                  if (change[:quit])
+                    quit = true
+                  else
+                    # Handle removed files first - guard sometimes flagged as deleted when they aren't
+                    # So we first check if the file has been deleted on the host. If so, we delete on
+                    # the guest, otherwise we add to the list to rsync in case there are changes
+                    changes = []
+                    change[:removed].each do | relpath |
+                      if (File.exists?(File.join(host_path, relpath)))
+                        changes << relpath
+                      else
+                        target = "#{mirror_config[:guest_path]}/#{relpath}"
+                        ui.warn("XX Deleting #{target}")
+                        env[:vm].channel.sudo("rm #{target}")
+                      end
+                    end
+
+                    # Add to the list of deletions with each of the modified and added files
+                    changes = changes + change[:added] + change[:modified]
+                    changes.each do | relpath |
+                      ui.info(">> #{relpath}")
+                      rsync.run(relpath)
+                    end
+
+                    # Beep if configured
+                    if (mirror_config[:beep])
+                      print "\a"
+                    end
+                  end
+                end
+              end
+            end
+
+            # Wait for the listener thread to exit
+            workers.each do | thread |
+              thread.join
+            end
+          rescue RuntimeError => e
+            # Pass through Vagrant errors
+            if e.is_a? Vagrant::Errors::VagrantError
+              raise
+            end
+
+            # Convert to a vagrant error descendant so that the box is not cleaned up
+            raise Vagrant::Mirror::Errors::Error.new("Vagrant-mirror caught a #{e.class.name} - #{e.message}")
+          end
+
+          ui.success("Completed directory synchronisation")
+        end
+
+      end
+    end
+  end
+end

data/lib/vagrant-mirror/middleware/sync.rb

@@ -0,0 +1,92 @@
+require 'date'
+require 'fileutils'
+
+# Executes a full sync from the host to the guest instance based on the configuration
+# in the vagrantfile, copying new or changed files to the guest as required.
+#
+# @author Andrew Coulton < andrew@ingerator.com >
+module Vagrant
+  module Mirror
+    module Middleware
+      class Sync < Base
+
+        # Loads the rest of the middlewares first, then finishes up by running
+        # the sync middleware. This is required because the core share_folders
+        # middleware does not mount the shares until the very end of the process
+        # and we need to run after that
+        #
+        # @param [Vagrant::Action::Environment] The environment
+        def call(env)
+          @app.call(env)
+
+          mirrors = env[:vm].config.mirror.folders
+          if !mirrors.empty?
+            execute(mirrors, env)
+          else
+            env[:ui].info("No vagrant-mirror mirrored folders configured for this box")
+          end
+        end
+
+        protected
+
+        # Synchronizes the folder pairs configured in the vagrantfile
+        #
+        # @param [Array] The folder pairs to synchronise
+        # @param [Vagrant::Action::Environment] The environment
+        def execute(mirrors, env)
+          ui = env[:ui]
+          ui.info("Beginning directory synchronisation at " + DateTime.now.iso8601)
+
+          begin
+            each_mirror(mirrors) do | host_path, guest_sf_path, mirror_config |
+              ui.info("Synchronising for #{host_path}")
+
+              # Create any required symlinks
+              mirror_config[:symlinks].each do | relpath |
+                relpath.sub!(/^\//, '')
+                source = "#{guest_sf_path}/#{relpath}"
+                target = "#{mirror_config[:guest_path]}/#{relpath}"
+
+                # Find the parent directory - we have to do this with regexp as we don't have the
+                # right filesystem to use File.expand
+                dirs = /^(.*)(\/.+)$/.match(target)
+                if (dirs)
+                  target_dir = dirs[1]
+                else
+                  target_dir = '/'
+                end
+
+                # Create the host directory if required
+                host_dir = "#{host_path}/#{relpath}"
+                if ( ! File.exists?(host_dir))
+                  FileUtils.mkdir_p(host_dir)
+                end
+
+                # Create the parent directory and create the symlink
+                ui.info("Creating link from #{target} to #{source}")
+                env[:vm].channel.sudo("rm -f #{target} && mkdir -p #{target_dir} && ln -s #{source} #{target}")
+              end
+
+              # Trigger the sync on the remote host
+              ui.info("Synchronising from #{guest_sf_path} to #{mirror_config[:guest_path]}")
+              rsync = Vagrant::Mirror::Rsync.new(env[:vm], guest_sf_path, host_path, mirror_config)
+              rsync.run('/')
+            end
+
+          rescue RuntimeError => e
+            # Pass through Vagrant errors
+            if e.is_a? Vagrant::Errors::VagrantError
+              raise
+            end
+
+            # Convert to a vagrant error descendant so that the box is not cleaned up
+            raise Vagrant::Mirror::Errors::Error.new("Vagrant-mirror caught a #{e.class.name} - #{e.message}")
+          end
+
+          ui.success("Completed directory synchronisation at " + DateTime.now.iso8601)
+        end
+
+      end
+    end
+  end
+end

data/lib/vagrant-mirror/rsync.rb

@@ -0,0 +1,91 @@
+# Executes rsync on the guest to update files between the shared folder and the local virtual disk.
+# Propogates deletes if configured to do so, but not otherwise.
+#
+# @author Andrew Coulton < andrew@ingerator.com >
+module Vagrant
+  module Mirror
+    class Rsync
+      # @return [Vagrant::VM] The VM to mirror on
+      attr_reader :vm
+
+      # @return [String] The path to the virtualbox shared folder on the guest
+      attr_reader :guest_sf_path
+
+      # @return [String] The path to the virtualbox shared folder on the host
+      attr_reader :host_path
+
+      # @return [Bool] Whether Rsync should delete unexpected files
+      attr_reader :delete
+
+      # @return [Array] The array of paths to exclude
+      attr_reader :excludes
+
+      # @return [String] The exclude paths formatted as an array of rsync exclude arguments
+      attr_reader :exclude_args
+
+      # @return [String] The path to the mirror folder on the guest
+      attr_reader :guest_path
+
+      # Creates an instance
+      #
+      # @param [Vagrant::VM] The VM to mirror on
+      # @param [String]      The path of the shared folder on the guest to use as the rsync source
+      # @param [String]      The path of the shared folder on the host - used to check whether a path is a directory
+      # @param [Hash]        The config.mirror options hash with the guest mirror destination, delete, etc
+      def initialize(vm, guest_sf_path, host_path, mirror_config)
+        @vm = vm
+        @guest_sf_path = guest_sf_path
+        @host_path = host_path
+        @delete = mirror_config[:delete]
+        @excludes = mirror_config[:exclude]
+        @guest_path = mirror_config[:guest_path]
+
+        # Build the exclude argument array
+        @exclude_args = []
+        if (@excludes.count > 0)
+          @excludes.each do | exclude |
+            exclude_args << "--exclude '#{exclude}'"
+          end
+        end
+      end
+
+      # Run rsync on the guest to update a path - either the whole mirror directory or individual
+      # files and folders within it.
+      #
+      # @param [String] The path to run in
+      def run(path)
+        # Strip a leading / off the path to avoid any problems
+        path.sub!(/^\//, '')
+
+        # Build the source and destination paths
+        source = "#{guest_sf_path}/#{path}"
+        dest = "#{guest_path}/#{path}"
+
+        # Check if the source is a directory on the host - if so, add a / for rsync
+        if ((path != '') && (File.directory?(File.join(host_path, path))))
+          source << '/'
+          dest << '/'
+        end
+
+
+        # Build the rsync command
+        args = ['rsync -av']
+
+        if (delete)
+          args << '--del'
+        end
+
+        args = args + exclude_args
+
+        args << source
+        args << dest
+
+        cmd = args.join(' ')
+
+        # Run rsync
+        vm.channel.sudo(cmd)
+      end
+
+    end
+  end
+end

data/lib/vagrant-mirror/sync/all.rb

@@ -0,0 +1,60 @@
+# Compares the contents of the host and guest paths and transfers any
+# missing or modified paths to the other side of the mirror. If a whole
+# directory is missing, uses recursive upload/download from the SFTP class,
+# otherwise it iterates over and compares the directory contents.
+#
+# This class does not detect deletions - if a file is missing on one side
+# of the mirror it will simply be replaced.
+#
+# @author Andrew Coulton < andrew@ingenerator.com >
+module Vagrant
+  module Mirror
+    module Sync
+      class All < Base
+
+        # Compares a folder between guest and host, transferring any new or
+        # modified files in the right direction.
+        #
+        # @param [string] The base path to compare
+        def execute(path)
+          path = path.chomp('/')
+          host_dir = host_path(path).chomp('/')
+          guest_dir = guest_path(path).chomp('/')
+
+          if !@connection.exists?(guest_dir)
+            # Create the guest directory
+            @connection.mkdir(guest_dir)
+          end
+
+          if !File.exists?(host_dir)
+            # Create the host directory
+            FileUtils.mkdir_p(host_dir)
+          end
+
+          # If the guest path already exists, have to sync manually
+          # First get a combined listing of the two paths
+          all_files = @connection.dir_entries(guest_dir) | Dir.entries(host_dir)
+          all_files.each do | file |
+            # Ignore . and ..
+            if (file == '.') or (file == '..')
+              next
+            end
+
+            # Get local paths
+            host_file = File.join(host_dir, file)
+            guest_file = File.join(guest_dir, file)
+            # Recurse for directories
+            if File.directory?(host_file) \
+               or ( !File.exists?(host_file) and @connection.directory?(guest_file))
+              execute("#{path}/#{file}")
+            else
+              # Transfer new/modified files between host and guest
+              compare_and_transfer(host_file, guest_file)
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-mirror/sync/base.rb

@@ -0,0 +1,98 @@
+# Base class for file sync actions, providing common required functionality
+#
+# @author Andrew Coulton < andrew@ingerator.com >
+module Vagrant
+  module Mirror
+    module Sync
+      class Base
+
+        # Initialises the synchroniser
+        #
+        # @param [Vagrant::Mirror::Connection::SFTP] The sftp connection instance
+        # @param [String] The root path on the host to mirror
+        # @param [String] The root path on the guest to mirror
+        # @param [Vagrant::UI::Interface] The Vagrant UI class
+        def initialize(connection, host_path, guest_path, ui)
+          @connection = connection
+          @host_root = host_path
+          @guest_root = guest_path
+          @ui = ui
+        end
+
+        # ==================================================================
+        # Begin protected internal methods
+        # ==================================================================
+        protected
+
+        # Gets the absolute host path for a file
+        #
+        # @param [String] Relative path to the file
+        # @return [String] Absolute path to the file on the host
+        def host_path(relative_path)
+          File.join(@host_root, relative_path)
+        end
+
+        # Gets the absolute guest path for a file
+        #
+        # @param [String] Relative path to the file
+        # @return [String] Absolute path to the file on the guest
+        def guest_path(relative_path)
+          File.join(@guest_root, relative_path)
+        end
+
+        # Gets the mtime of a file on the host from an absolute path
+        #
+        # @param [String] Absolute host path
+        # @return [Time] mtime, or nil if the file does not exist
+        def host_mtime(path)
+          if !File.exists?(path)
+            return nil
+          end
+          return File.mtime(path)
+        end
+
+        # Gets the mtime of a file on the guest from an absolute path
+        #
+        # @param [String] Absolute guest path
+        # @return [Time] mtime, or nil if the file does not exist
+        def guest_mtime(path)
+          @connection.mtime(path)
+        end
+
+        # Compares files on the host and the guest and transfers the newest
+        # to the other side.
+        #
+        # @param [String] Absolute host path
+        # @param [String] Absolute guest path
+        def compare_and_transfer(host_file, guest_file)
+
+          # Get the mtimes
+          host_time = host_mtime(host_file)
+          guest_time = guest_mtime(guest_file)
+
+          # Check what to do
+          if (host_time.nil? and guest_time.nil?) then
+            # Report an error
+            @ui.error("#{host_file} was not found on either the host or guest filesystem - cannot sync")
+          elsif (host_time == guest_time)
+            # Do nothing
+            return
+          elsif (guest_time.nil?)
+            # Transfer to guest
+            @connection.upload(host_file, guest_file, host_time)
+          elsif (host_time.nil?)
+            # Transfer to host
+            @connection.download(guest_file, host_file, guest_time)
+          elsif (host_time > guest_time)
+            # Transfer to guest
+            @connection.upload(host_file, guest_file, host_time)
+          elsif (host_time < guest_time)
+            # Transfer to guest
+            @connection.download(guest_file, host_file, guest_time)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/vagrant-mirror/sync/changes.rb

@@ -0,0 +1,61 @@
+# Processes notified file additions, modifications and deletions notified by
+# guard/listen, and replays them on the other side of the mirror.
+# The execute method will be called for each changeset notified whether
+# by guard or over the TCP socket (from guard on the guest). This could
+# cause a race condition as changes on the guest trigger changes on the host
+# and vice versa.
+#
+# Therefore, on notification of added or modified file, the class just
+# syncs whichever is the newest file between the two machines. On deletion
+# it will quietly fail if the file it is notified of has already been
+# deleted.
+#
+# @author Andrew Coulton < andrew@ingenerator.com >
+module Vagrant
+  module Mirror
+    module Sync
+      class Changes < Base
+
+        # Compares a single notified changeset and transfers any changed,
+        # modified or removed files in the right direction.
+        #
+        # @param [Symbol] Which side of the mirror the change was detected
+        # @param [Array] Array of added paths
+        # @param [Array] Array of changed paths
+        # @param [Array] Array of removed paths
+        def execute(source, added, modified, removed)
+
+          # Combine added and modified, they're the same for our purposes
+          changed = added + modified
+          changed.each do |file|
+            # Transfer the newest file to the other side, or do nothing
+            compare_and_transfer(host_path(file), guest_path(file))
+          end
+
+          # Process deleted files
+          removed.each do |file|
+            # Expect a cascade - only delete on opposite side if exists
+            if source == :host
+              guest_file = guest_path(file)
+              if !guest_mtime(guest_file).nil?
+                @connection.delete(guest_file)
+              else
+                @ui.info("#{file} was not found on guest - nothing to delete")
+              end
+            elsif source == :guest
+              host_file = host_path(file)
+              if File.exists?(host_file)
+                File.delete(host_file)
+              else
+                @ui.info("#{file} was not found on host - nothing to delete")
+              end
+            end
+          end
+
+          # Complete all transfers
+          @connection.finish_transfers
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-mirror/version.rb

@@ -0,0 +1,5 @@
+module Vagrant
+  module Mirror
+    VERSION = "0.1.0.alpha"
+  end
+end

data/lib/vagrant-mirror.rb

@@ -0,0 +1,34 @@
+require 'vagrant'
+
+require 'vagrant-mirror/errors'
+require 'vagrant-mirror/version'
+require 'vagrant-mirror/config'
+
+# Require the host listener
+require 'vagrant-mirror/listener/host'
+
+# Require the rsync wrapper
+require 'vagrant-mirror/rsync'
+
+# Require the middlewares
+require 'vagrant-mirror/middleware/base'
+require 'vagrant-mirror/middleware/sync'
+require 'vagrant-mirror/middleware/mirror'
+
+# Require the command
+require 'vagrant-mirror/command'
+
+# Register the config
+Vagrant.config_keys.register(:mirror) { Vagrant::Mirror::Config }
+
+# Register the command
+Vagrant.commands.register(:mirror) { Vagrant::Mirror::Command }
+
+# Add the sync middleware to the start stack
+Vagrant.actions[:start].insert Vagrant::Action::VM::ShareFolders, Vagrant::Mirror::Middleware::Sync
+
+# Add the mirror middleware to the standard stacks
+Vagrant.actions[:start].insert Vagrant::Action::VM::Provision, Vagrant::Mirror::Middleware::Mirror
+
+# Abort on unhandled exceptions in any thread
+Thread.abort_on_exception = true

data/lib/vagrant_init.rb

@@ -0,0 +1,4 @@
+# This file is automatically loaded by Vagrant to load any
+# plugins. This file kicks off this plugin.
+
+require 'vagrant-mirror'

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+require 'vagrant-mirror'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+
+  config.include Vagrant::TestHelpers
+end

data/spec/vagrant-mirror/command_spec.rb

@@ -0,0 +1,91 @@
+describe Vagrant::Mirror::Command do
+  let (:argv) { []  }
+  let (:env)  { double("Vagrant::Environment").as_null_object }
+  let (:vm)   { double("Vagrant::VM").as_null_object }
+  let (:ui)   { double("Vagrant::UI::Interface").as_null_object }
+
+  before (:each) do
+    env.stub(:primary_vm).and_return vm
+    env.stub(:multivm?).and_return false
+    env.stub(:ui).and_return ui
+  end
+
+  subject { Vagrant::Mirror::Command.new(argv, env) }
+
+  describe "#execute" do
+    shared_examples "cannot run in multivm" do
+      before (:each) do
+        env.stub(:multivm?).and_return(true)
+      end
+
+      it "throws a SingleVMEnvironmentRequired error" do
+        expect { subject.execute }.to raise_error(Vagrant::Mirror::Errors::SingleVMEnvironmentRequired)
+      end
+    end
+
+    context "with vagrant mirror sync" do
+      let (:argv) { ['sync' ] }
+
+      it_behaves_like "cannot run in multivm"
+
+      it "runs the sync middleware with primary vm" do
+        vm.should_receive(:run_action).with(Vagrant::Mirror::Middleware::Sync)
+
+        subject.execute
+      end
+
+    end
+
+    shared_examples "the monitor command" do
+
+      it "runs the monitor middleware with primary vm" do
+        vm.should_receive(:run_action).with(Vagrant::Mirror::Middleware::Mirror)
+
+        subject.execute
+      end
+    end
+
+    context "with vagrant mirror monitor" do
+      let (:argv) { ['monitor' ] }
+
+      it_behaves_like "cannot run in multivm"
+      it_behaves_like "the monitor command"
+    end
+
+    context "with an empty command" do
+      let (:argv) { [] }
+
+      it_behaves_like "cannot run in multivm"
+      it_behaves_like "the monitor command"
+    end
+
+    shared_examples "the help command" do
+      it "prints valid usage" do
+        ui.should_receive(:info).with(/monitor/, anything())
+
+        subject.execute
+      end
+
+      it "does not run anything" do
+        ui.stub(:info)
+        vm.should_not_receive(:run_action)
+
+        subject.execute
+      end
+    end
+
+    context "with unknown command" do
+      let (:argv) { ['nothing'] }
+
+      it_behaves_like "cannot run in multivm"
+      it_behaves_like "the help command"
+    end
+
+    context "with help command" do
+      let (:argv) { ['-h', 'monitor'] }
+
+      it_behaves_like "the help command"
+    end
+
+  end
+end