vagrant-vaimo-unison 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 665a6ac67e4fccd7dc7277186858488fbe94214f
+  data.tar.gz: a42e74a68dcd28324af7c9a0e01dbe97d7c76380
+SHA512:
+  metadata.gz: d1681956f1bdd042532d52f5229e265a4d5c6592f04ef58cafd610b422f9c570c11ef826b708602483e88ed1619168f556b4d5e2753e9c9ee772a91cba067fa4
+  data.tar.gz: 9a71bcbfb28214619e303b7085317db6ebaec8d0b6d55b90fe9f1e5bc6992dfdad3ad65eaf245d20f6a58700c809ebc36b88c0d893a51f6cc50d4023e8dc5d91

data/.gitignore

@@ -0,0 +1,19 @@
+# OS-specific
+.DS_Store
+
+# Bundler/Rubygems
+*.gem
+.bundle
+pkg/*
+tags
+Gemfile.lock
+
+# Vagrant
+.vagrant
+Vagrantfile
+!example_box/Vagrantfile
+
+# IDEs
+.project
+.idea
+.tags*

data/CHANGELOG.md

@@ -0,0 +1,21 @@
+# 1.0.2 (Feb 2016)
+* fix the cleanup command to delete contents of directory in Vagrant but not the directory itself, because deleteing the directory can mess up e.g. a docker container that has that directory mounted.
+
+# 1.0.1
+* Small bugfix release
+
+# 1.0.0 (Jan 2016)
+
+* Breaking commit on dcosson fork
+* Renames all of the `vagrant ___` commands to start with `unison`, e.g. `vagrant-unison-sync`
+* Adds a command to sync once and exit, `vagrant unison-sync-once`
+* Fix bug where cleanup tried to delete `~/.unison` as root, which resolved to wrong thing (at least in Virtualbox) and failed silently bc what we want to delete is `/home/vagrant/.unison`
+* Pin to newer syntax of the listen gem and stop using a method that had been renamed.
+
+# 0.0.17 (Jan 2016)
+
+* Fix bug in validation. Previously, you couldn't run vagrant on a Vagrantfile that didn't use vagrant-unison if you had the plugin installed, because all the config args were required.
+
+# 0.1.0 (March 2013)
+
+* Initial release.

data/Gemfile

@@ -0,0 +1,10 @@
+source "https://rubygems.org"
+
+gemspec
+
+group :development do
+  # We depend on Vagrant for development, but we don't add it as a
+  # gem dependency because we expect to be installed within the
+  # Vagrant environment itself using `vagrant plugin`.
+  gem "vagrant", :git => "git://github.com/mitchellh/vagrant.git"
+end

data/LICENSE

@@ -0,0 +1,8 @@
+The MIT License (MIT)
+Copyright (c) 2013 Mitchell Hashimoto
+
+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,185 @@
+# Vagrant Unison 2 Plugin
+
+This is a [Vagrant](http://www.vagrantup.com) 1.7+ plugin that syncs files over SSH from a local folder
+to your Vagrant VM (local or on AWS).  Under the covers it uses [Unison](http://www.cis.upenn.edu/~bcpierce/unison/)
+
+**NOTE:** This plugin requires Vagrant 1.7+,
+
+## Features
+
+* Unisoned folder support via `unison` over `ssh` -> will work with any vagrant provider, eg Virtualbox or AWS, though it's most tested on a local VM via Virtualbox.
+
+## Usage
+
+1. You must already have [Unison](http://www.cis.upenn.edu/~bcpierce/unison/) installed on your path on your host and guest machines, and it must be the same version of Unison on both.
+     * On Mac you can install this with Homebrew:  `brew install unison`
+        * This will install unison 2.48.3
+     * On Ubuntu:
+        * [Xenial (16.04)](https://launchpad.net/ubuntu/xenial/+source/unison): `sudo apt-get install unison`
+        * Ubuntu Trusty (14.04):
+            * `sudo add-apt-repository ppa:eugenesan/ppa`
+            * `sudo apt-get update`
+            * `sudo apt-get install unison=2.48.3-1ubuntu1.02~eugenesan~trusty2`
+     * Other 64-bit Linux:
+        * Install package from `http://ftp5.gwdg.de/pub/linux/archlinux/extra/os/x86_64/unison-2.48.3-2-x86_64.pkg.tar.xz`. (Install at your own risk, this is a plain http link. If someone knows of a signed version, checksum, or https host let me know so I can update it).
+     * On Windows, download [2.48.3](http://www.pps.univ-paris-diderot.fr/~vouillon/unison/unison 2.48.3.zip), unzip, rename `unison-2.48.3 text.exe` to `unison.exe` and copy to somewhere in your path. Alternatively, install [using Chocolatey](https://chocolatey.org/packages/unison).
+
+2. Install using standard Vagrant 1.1+ plugin installation methods.
+    * `vagrant plugin install vagrant-vaimo-unison`
+
+3. Configure unison in your Vagrantfile, as shown below.
+
+4. Start your vagrant box as normal (eg: `vagrant up`)
+
+## Configuration
+
+  ```ruby
+  Vagrant.configure("2") do |config|
+    config.vm.box = "dummy"
+
+    # Required configs
+    config.unison.host_folder = "src/"  #relative to the folder your Vagrantfile is in
+    config.unison.guest_folder = "src/" #relative to the vagrant home folder (e.g. /home/vagrant)
+
+    # Optional configs
+    # File patterns to ignore when syncing. Ensure you don't have spaces between the commas!
+    config.unison.ignore = "Name {.DS_Store,.git,node_modules}" # Default: none
+
+    # SSH connection details for Vagrant to communicate with VM.
+    config.unison.ssh_host = "10.0.0.1" # Default: '127.0.0.1'
+    config.unison.ssh_port = 22 # Default: 2222
+    config.unison.ssh_user = "deploy" # Default: 'vagrant'
+    config.unison.perms = 0 # if you get "properties changed on both sides" error 
+
+    # `vagrant unison-sync-polling` command will restart unison in VM if memory
+    # usage gets above this threshold (in MB).
+    config.unison.mem_cap_mb = 500 # Default: 200
+
+    # Change polling interval (in seconds) at which to sync changes
+    config.unison.repeat = 5 # Default: 1
+  end
+  ```
+
+
+## Start syncing Folders
+
+Run `vagrant unison-sync-once` to run a single, non-interactive sync and then exit.
+
+Run `vagrant unison-sync-polling` to start in bidirect monitor (repeat) mode - every second unison checks for changes on either side and syncs them.
+
+## (Legacy) Sync using OSX inotify events
+
+Run `vagrant unison-sync` to sync then start watching the local_folder for changes, and syncing these to your vagrang VM.
+
+This uses the `watch` ruby gem and runs a one-off unison sync when it gets change events.
+
+For some reason, this does not always get all the events immediately which can be frustrating. Since the polling mode (unison repeat mode) is not too resource intensive, I recommend that instead.
+
+## Sync in interactive mode
+
+Run `vagrant unison-sync-interactive` to start in interactive mode. The first time
+it will ask what to do for every top-level file & directory, otherwise is asks
+about changes. It allows solving conflicts in various ways. Press "?" in
+interactive mode to see options for resolving.
+
+This is a useful tool when the automatic sync sees a change in a file on both
+sides and skips it.
+
+## Cleanup unison database
+Run `vagrant unison-cleanup` to clear the unison metadata from `~/Library/Application Support/Unison/` as well as all files.
+
+## Error states
+
+### Inconsistent state with unison metadata
+
+When you get
+```
+Fatal error: Warning: inconsistent state.  
+The archive file is missing on some hosts.
+For safety, the remaining copies should be deleted.
+  Archive arb126d8de1ef26a835b94cf51975c530f on host blablabla.local should be DELETED
+  Archive arbc6a36f85b3d1473c55565dd220acf68 on host blablabla is MISSING
+Please delete archive files as appropriate and try again
+or invoke Unison with -ignorearchives flag.
+```
+
+You should run a unison-cleanup
+
+Running Unison with -ignorearchives flag is a bad idea, since it will produce conflicts.
+
+### Uncaught exception `bad bigarray kind`
+
+The error is:
+```
+Unison failed: Uncaught exception Failure("input_value: bad bigarray kind")
+```
+
+This is caused when the unison on your host and guest were compiled with different versions of ocaml. To fix ensure that
+both are compiled with the same ocaml version. [More Info Here](https://gist.github.com/pch/aa1c9c4ec8522a11193b)
+
+### Skipping files changed on both sides
+
+This is most often caused in my experience by files that get changed by different users with different permissions.
+
+For instance, if you're running an Ubuntu VM then the unison process is running
+as the vagrant user. If you have the unison synced folder loaded as a volume in
+a docker container and a new file gets created in the container, the vagrant
+user in the VM won't own that file and this can keep unison from being able to
+sync the file. (I'm looking for a way to fix this particular error case).
+
+Running a unison-cleanup should fix this state.
+
+### Properties changed on both sides
+
+The error is:
+```
+Synchronization complete at 13:00:33  (0 item transferred, 1 skipped, 0 failed)
+  skipped:  (properties changed on both sides)
+props    <-?-> props      /
+```
+
+This can be caused by file permissions being synced. If you get this error set
+the perms arg to 0 as in the [example configuration](#configuration).
+
+See [perms documentation](http://www.cis.upenn.edu/~bcpierce/unison/download/releases/stable/unison-manual.html#perms) for more info.
+
+
+## Development
+
+To work on the `vagrant-unison` plugin, clone this repository out, and use
+[Bundler](http://gembundler.com) to get the dependencies:
+
+```
+$ bundle
+```
+
+Once you have the dependencies, verify the unit tests pass with `rake`:
+
+```
+$ bundle exec rake
+```
+
+If those pass, you're ready to start developing the plugin. You can test
+the plugin without installing it into your Vagrant environment by just
+creating a `Vagrantfile` in the top level of this directory (it is gitignored)
+that uses it, and uses bundler to execute Vagrant:
+
+```
+$ bundle exec vagrant up
+$ bundle exec vagrant unison-sync
+```
+
+Or, install the plugin from your local build to use with an existing project's
+Vagrantfile on your machine.
+
+Build the plugin with
+
+```
+rake build
+```
+
+Now you'll see the built gem in a pkg directory. Install it with
+
+```
+vagrant plugin install pkg/vagrant-unison-VERSION.gem
+```

data/Rakefile

@@ -0,0 +1,21 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'rspec/core/rake_task'
+
+# Immediately sync all stdout so that tools like buildbot can
+# immediately load in the output.
+$stdout.sync = true
+$stderr.sync = true
+
+# Change to the directory of this file.
+Dir.chdir(File.expand_path("../", __FILE__))
+
+# This installs the tasks that help with gem creation and
+# publishing.
+Bundler::GemHelper.install_tasks
+
+# Install the `spec` task so that we can run tests.
+RSpec::Core::RakeTask.new
+
+# Default task is to run the unit tests
+task :default => "spec"

data/lib/vagrant-vaimo-unison/command.rb

@@ -0,0 +1,168 @@
+require "log4r"
+require "vagrant"
+require "thread"
+
+require_relative 'unison_paths'
+require_relative 'ssh_command'
+require_relative 'shell_command'
+require_relative 'unison_sync'
+
+module VagrantPlugins
+  module Unison
+    class CommandOnce < Vagrant.plugin("2", :command)
+      include UnisonSync
+
+      def self.synopsis
+        "sync the unison shared folder once"
+      end
+
+      def execute
+        status = nil
+        with_target_vms do |machine|
+          execute_sync_command(machine) do |command|
+            command.batch = true
+            command.terse = true
+            command = command.to_s
+
+            @env.ui.info "Running unison once"
+            @env.ui.info "    #{command}"
+
+            status = system(command)
+            @env.ui.info "**** unison exited. success: #{status} ****"
+          end
+        end
+        if status
+          return 0
+        else
+          return 1
+        end
+      end
+    end
+
+    class CommandPolling < Vagrant.plugin("2", :command)
+      include UnisonSync
+      attr_accessor :bg_thread
+
+      def self.synopsis
+        "sync the unison shared folder forever, by polling for changes"
+      end
+
+      def execute
+        status = nil
+        with_target_vms do |machine|
+          @bg_thread = watch_vm_for_memory_leak(machine)
+          execute_sync_command(machine) do |command|
+            command.repeat = true
+            command.terse = true
+            command = command.to_s
+
+            @env.ui.info "Running #{command}"
+
+            # Re-run on a crash.
+            # On a sigint, wait 2 seconds before respawning command.
+            # If INT comes in again while waiting, program exits.
+            # If INT comes in after we've respanwned,
+            # will bring us back to this trap handler.
+            exit_on_next_sigint = false
+            while true
+              begin
+                sleep 2 if exit_on_next_sigint
+                exit_on_next_sigint = false
+                status = system(command)
+                @env.ui.info "**** unison exited. success: #{status} ****"
+              rescue Interrupt
+                if exit_on_next_sigint
+                  Thread.kill(@bg_thread) if @bg_thread
+                  exit 1
+                end
+                @env.ui.info '** Hit Ctrl + C again to kill. **'
+                exit_on_next_sigint = true
+              rescue Exception
+                  @env.ui.info '** Sync crashed. Respawning. Hit Ctrl + C twice to kill. **'
+              end
+            end
+          end
+        end
+        if status
+          return 0
+        else
+          return 1
+        end
+      end
+
+      def watch_vm_for_memory_leak(machine)
+        ssh_command = SshCommand.new(machine)
+        Thread.new(ssh_command.ssh, machine.config.unison.mem_cap_mb) do |ssh_command_text, mem_cap_mb|
+          while true
+            sleep 15
+            total_mem = `#{ssh_command_text} 'free -m | egrep "^Mem:" | awk "{print \\$2}"' 2>/dev/null`
+            _unison_proc_returnval = (
+              `#{ssh_command_text} 'ps aux | grep "[u]nison -server" | awk "{print \\$2, \\$4}"' 2>/dev/null`
+            )
+            if _unison_proc_returnval == ''
+              puts "Unison not running in VM"
+              next
+            end
+            pid, mem_pct_unison = _unison_proc_returnval.strip.split(' ')
+            mem_unison = (total_mem.to_f * mem_pct_unison.to_f/100).round(1)
+            # Debugging: uncomment to log every loop tick
+            # puts "Unison running as #{pid} using #{mem_unison} mb"
+            if mem_unison > mem_cap_mb
+              puts "Unison using #{mem_unison}MB memory is over limit of #{mem_cap_mb}MB, restarting"
+              `#{ssh_command_text} kill -HUP #{pid} 2>/dev/null`
+            end
+          end
+        end
+      end
+    end
+
+    class CommandCleanup < Vagrant.plugin("2", :command)
+      def self.synopsis
+        "remove all unison supporting state on local and remote system"
+      end
+
+      def execute
+        with_target_vms do |machine|
+          guest_path = UnisonPaths.new(@env, machine).guest
+
+          command = "rm -rf ~/Library/'Application Support'/Unison/*"
+          @env.ui.info "Running #{command} on host"
+          system(command)
+
+          command = "rm -rf #{guest_path}/* #{guest_path}/..?* #{guest_path}/.[!.]*"
+          @env.ui.info "Running #{command} on guest VM (delete all files from directory including hidden ones)"
+          machine.communicate.sudo(command)
+
+          command = "rm -rf ~/.unison"
+          @env.ui.info "Running #{command} on guest VM"
+          machine.communicate.execute(command)
+        end
+
+        0
+      end
+    end
+
+    class CommandInteract < Vagrant.plugin("2", :command)
+      include UnisonSync
+
+      def self.synopsis
+        "run unison in interactive mode, to resolve conflicts"
+      end
+
+      def execute
+        with_target_vms do |machine|
+          execute_sync_command(machine) do |command|
+            command.terse = true
+            command = command.to_s
+
+            @env.ui.info "Running #{command}"
+
+            system(command)
+          end
+        end
+
+        0
+      end
+    end
+  end
+end

data/lib/vagrant-vaimo-unison/config.rb

@@ -0,0 +1,100 @@
+require "vagrant"
+
+module VagrantPlugins
+  module Unison
+    class Config < Vagrant.plugin("2", :config)
+      # Host Folder to Sync
+      #
+      # @return [String]
+      attr_accessor :host_folder
+
+      # Guest Folder to Sync.
+      #
+      # @return [String]
+      attr_accessor :guest_folder
+
+      # Pattern of files to ignore.
+      #
+      # @return [String, Array<String>]
+      attr_accessor :ignore
+
+      # Repeat speed.
+      #
+      # @return [String]
+      attr_accessor :repeat
+
+      # SSH host.
+      #
+      # @return [String]
+      attr_accessor :ssh_host
+
+      # SSH port.
+      #
+      # @return [String]
+      attr_accessor :ssh_port
+
+      # SSH user.
+      #
+      # @return [String]
+      attr_accessor :ssh_user
+
+      # Memory usage cap in MB
+      # Restart Unison in the VM when it's consuming more than this
+      # amount of memory (in MB)
+      # @return [int]
+      attr_accessor :mem_cap_mb
+
+      # perms arg value
+      #
+      # @return [int]
+      attr_accessor :perms
+
+      # Airlab-specific config option to leave off the Vagrant identity file, so
+      # SSH will just use ssh-agent
+      #
+      # @return [Boolean]
+      attr_accessor :ssh_use_agent
+
+      def initialize(region_specific = false)
+        @host_folder   = UNSET_VALUE
+        @guest_folder  = UNSET_VALUE
+        @ignore        = UNSET_VALUE
+        @repeat        = UNSET_VALUE
+        @ssh_host      = UNSET_VALUE
+        @ssh_port      = UNSET_VALUE
+        @ssh_user      = UNSET_VALUE
+        @ssh_use_agent = UNSET_VALUE
+        @mem_cap_mb    = UNSET_VALUE
+        @perms         = UNSET_VALUE
+      end
+
+      def finalize!
+        # The access keys default to nil
+        @host_folder  = nil         if @host_folder  == UNSET_VALUE
+        @guest_folder = nil         if @guest_folder == UNSET_VALUE
+        @ignore       = nil         if @ignore       == UNSET_VALUE
+        @repeat       = 1           if @repeat       == UNSET_VALUE
+        @ssh_host     = '127.0.0.1' if @ssh_host     == UNSET_VALUE
+        @ssh_port     = 2222        if @ssh_port     == UNSET_VALUE
+        @ssh_user     = 'vagrant'   if @ssh_user     == UNSET_VALUE
+        @mem_cap_mb   = 200         if @mem_cap_mb   == UNSET_VALUE
+        @perms        = nil         if @perms        == UNSET_VALUE
+        @ssh_use_agent = false      if @ssh_use_agent == UNSET_VALUE
+
+        # Mark that we finalized
+        @__finalized = true
+      end
+
+      def validate(machine)
+        errors = []
+
+        if !(@host_folder.nil? && @guest_folder.nil?)
+          errors << I18n.t("vagrant_unison.config.unison_host_folder_required") if @host_folder.nil?
+          errors << I18n.t("vagrant_unison.config.unison_guest_folder_required") if @guest_folder.nil?
+        end
+
+        { "Unison" => errors }
+      end
+    end
+  end
+end

data/lib/vagrant-vaimo-unison/errors.rb

@@ -0,0 +1,9 @@
+require "vagrant"
+
+module Vagrant
+  module Errors
+    class UnisonError < VagrantError
+      error_key(:unison_error, "vagrant_unison.errors")
+    end
+  end
+end

data/lib/vagrant-vaimo-unison/plugin.rb

@@ -0,0 +1,103 @@
+begin
+  require "vagrant"
+rescue LoadError
+  raise "The vagrant-unison plugin must be run within Vagrant."
+end
+
+# This is a sanity check to make sure no one is attempting to install
+# this into an early Vagrant version.
+if Vagrant::VERSION < "1.1.0"
+  raise "The vagrant-unison plugin is only compatible with Vagrant 1.1+"
+end
+
+module VagrantPlugins
+  module Unison
+    class Plugin < Vagrant.plugin("2")
+      name "Unison"
+      description <<-DESC
+      This plugin syncs files over SSH from a local folder
+      to your Vagrant VM (local or on AWS).
+      DESC
+
+      config "unison" do
+        require_relative "config"
+        Config
+      end
+
+      command "unison-sync-once" do
+        setup_logging
+        setup_i18n
+
+        #Return the command
+        require_relative "command"
+        CommandOnce
+      end
+
+      command "unison-sync-interact" do
+        # Setup logging and i18n
+        setup_logging
+        setup_i18n
+
+        #Return the command
+        require_relative "command"
+        CommandInteract
+      end
+
+
+      command "unison-sync-polling" do
+        # Setup logging and i18n
+        setup_logging
+        setup_i18n
+
+        #Return the command
+        require_relative "command"
+        CommandPolling
+      end
+
+      command "unison-cleanup" do
+        # Setup logging and i18n
+        setup_logging
+        setup_i18n
+
+        #Return the command
+        require_relative "command"
+        CommandCleanup
+      end
+
+      # This initializes the internationalization strings.
+      def self.setup_i18n
+        I18n.load_path << File.expand_path("locales/en.yml", Unison.source_root)
+        I18n.reload!
+      end
+
+      # This sets up our log level to be whatever VAGRANT_LOG is.
+      def self.setup_logging
+        require "log4r"
+
+        level = nil
+        begin
+          level = Log4r.const_get(ENV["VAGRANT_LOG"].upcase)
+        rescue NameError
+          # This means that the logging constant wasn't found,
+          # which is fine. We just keep `level` as `nil`. But
+          # we tell the user.
+          level = nil
+        end
+
+        # Some constants, such as "true" resolve to booleans, so the
+        # above error checking doesn't catch it. This will check to make
+        # sure that the log level is an integer, as Log4r requires.
+        level = nil if !level.is_a?(Integer)
+
+        # Set the logging level on all "vagrant" namespaced
+        # logs as long as we have a valid level.
+        if level
+          logger = Log4r::Logger.new("vagrant_unison")
+          logger.outputters = Log4r::Outputter.stderr
+          logger.level = level
+          logger = nil
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-vaimo-unison/shell_command.rb

@@ -0,0 +1,117 @@
+module VagrantPlugins
+  module Unison
+    class ShellCommand
+      def initialize(machine, unison_paths, ssh_command)
+        @machine = machine
+        @unison_paths = unison_paths
+        @ssh_command = ssh_command
+      end
+
+      attr_accessor :batch, :repeat, :terse
+      attr_accessor :force_remote, :force_local
+      attr_accessor :prefer_remote, :prefer_local
+
+      def to_a
+        args.map do |arg|
+          arg = arg[1...-1] if arg =~ /\A"(.*)"\z/
+          arg
+        end
+      end
+
+      def to_s
+        args.join(' ')
+      end
+
+      private
+
+      def args
+        _args = [
+          'unison',
+          local_root_arg,
+          remote_root_arg,
+          batch_arg,
+          terse_arg,
+          repeat_arg,
+          ignore_arg,
+          perms_arg,
+          force_arg,
+          prefer_arg,
+          ssh_args,
+        ].flatten.compact
+        _args
+      end
+
+      def local_root_arg
+        @unison_paths.host
+      end
+
+      def remote_root_arg
+        @ssh_command.uri(@unison_paths)
+      end
+
+      def ssh_args
+        ['-sshargs', %("#{@ssh_command.ssh_args}")]
+      end
+
+      def batch_arg
+        '-batch' if batch
+      end
+
+      def ignore_arg
+        patterns = []
+        if @machine.config.unison.ignore.is_a? ::Array
+          patterns += @machine.config.unison.ignore
+        elsif @machine.config.unison.ignore
+          patterns << @machine.config.unison.ignore
+        end
+
+        patterns.map do |pattern|
+          ['-ignore', %("#{pattern}")]
+        end
+      end
+
+      def perms_arg
+        ['-perms', @machine.config.unison.perms] if @machine.config.unison.perms
+      end
+
+      def repeat_arg
+        ['-repeat', @machine.config.unison.repeat] if repeat && @machine.config.unison.repeat
+      end
+
+      def terse_arg
+        '-terse' if terse
+      end
+
+      # from the docs:
+      #
+      # Including the preference  -force root causes Unison to resolve all
+      # differences (even non-conflicting changes) in favor of root. This
+      # effectively changes Unison from a synchronizer into a mirroring
+      # utility. You can also specify -force newer (or  -force older) to force
+      # Unison to choose the file with the later (earlier) modtime. In this
+      # case, the  -times preference must also be enabled. This preference is
+      # overridden by the forcepartial preference. This preference should be
+      # used only if you are sure you know what you are doing!
+      #
+      # soo. I'm not sure if I know what I'm doing. Need to make sure that this
+      # doesn't end up deleting .git or some other ignored but critical
+      # directory.
+      def force_arg
+        return ['-force', local_root_arg] if force_local
+        return ['-force', remote_root_arg] if force_remote
+      end
+
+      # from the docs, via Daniel Low (thx daniel):
+      #
+      # Including the preference -prefer root causes Unison always to resolve
+      # conflicts in favor of root, rather than asking for guidance from the
+      # user.
+      #
+      # This is much safer than -force
+      def prefer_arg
+        return ['-prefer', local_root_arg] if prefer_local
+        return ['-prefer', remote_root_arg] if prefer_remote
+      end
+    end
+  end
+end

data/lib/vagrant-vaimo-unison/ssh_command.rb

@@ -0,0 +1,54 @@
+module VagrantPlugins
+  module Unison
+    class SshCommand
+      def initialize(machine)
+        @machine = machine
+      end
+
+      def ssh
+        %W(
+          ssh
+          #{@machine.config.unison.ssh_user}@#{@machine.config.unison.ssh_host}
+          #{ssh_args}
+        ).compact.join(' ')
+      end
+
+      def ssh_args
+        %W(
+          -p #{@machine.config.unison.ssh_port}
+          #{proxy_command}
+          -o StrictHostKeyChecking=no
+          -o UserKnownHostsFile=/dev/null
+          #{identity}
+        ).compact.join(' ')
+      end
+
+      def uri(unison_paths)
+        username = @machine.config.unison.ssh_user
+        host = @machine.config.unison.ssh_host
+
+        "ssh://#{username}@#{host}/#{unison_paths.guest}"
+      end
+
+      private
+
+      def proxy_command
+        command = @machine.ssh_info[:proxy_command]
+        return nil unless command
+        "-o ProxyCommand='#{command}'"
+      end
+
+      def identity
+        if @machine.config.unison.ssh_use_agent
+          ''
+        else
+          (%w(-o IdentitiesOnly=yes) <<  key_paths).join(' ')
+        end
+      end
+
+      def key_paths
+        @machine.ssh_info[:private_key_path].map { |p| "-i #{p.shellescape}" }.join(' ')
+      end
+    end
+  end
+end

data/lib/vagrant-vaimo-unison/unison_paths.rb

@@ -0,0 +1,24 @@
+module VagrantPlugins
+  module Unison
+    class UnisonPaths
+      def initialize(env, machine)
+        @env = env
+        @machine = machine
+      end
+
+      def guest
+        @machine.config.unison.guest_folder
+      end
+
+      def host
+        @host ||= begin
+          path = File.expand_path(@machine.config.unison.host_folder, @env.root_path)
+
+          # Make sure there is a trailing slash on the host path to
+          # avoid creating an additional directory with rsync
+          path = "#{path}/" if path !~ /\/$/
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-vaimo-unison/unison_sync.rb

@@ -0,0 +1,99 @@
+require "optparse"
+
+module VagrantPlugins
+  module Unison
+    # mixin providing common functionality for our vagrant commands
+    module UnisonSync
+      def execute_sync_command(machine)
+        parse_options!
+
+        return unless machine.config.unison.host_folder
+
+        unison_paths = UnisonPaths.new(@env, machine)
+        guest_path = unison_paths.guest
+        host_path = unison_paths.host
+
+        @env.ui.info "Unisoning changes from {host}::#{host_path} --> {guest VM}::#{guest_path}"
+
+        # Create the guest path
+        machine.communicate.sudo("mkdir -p '#{guest_path}'")
+        machine.communicate.sudo("chown #{machine.config.unison.ssh_user} '#{guest_path}'")
+
+        ssh_command = SshCommand.new(machine)
+        shell_command = ShellCommand.new(machine, unison_paths, ssh_command)
+
+        shell_command.prefer_local = options[:prefer_local]
+        shell_command.prefer_remote = options[:prefer_remote]
+        shell_command.force_local = options[:force_local]
+        shell_command.force_remote = options[:force_remote]
+
+        yield shell_command
+      end
+
+      def parse_options!
+        # parse_options(option_parser) is provided by vagrant, but
+        # documentation is scarse. Best way to view the docs (imo) is to put
+        # a binding.pry in here and then type `? parse_options`
+        @parsed_argv ||= parse_options(options_parser)
+
+        if options[:verbose]
+          @env.ui.info "Options: #{options}"
+        end
+
+        # According to the docs:
+        # > If parse_options returns `nil`, then you should assume that
+        # > help was printed and parsing failed.
+        if @parsed_argv == nil
+          exit 1
+        end
+      end
+
+      def options
+        @options ||= {
+          :prefer_local => false,
+          :prefer_remote => false,
+          :force_local => false,
+          :force_remote => false,
+          :verbose => false,
+        }
+      end
+
+      def options_parser
+        @option_parser ||= OptionParser.new do |o|
+          o.banner = "Usage: vagrant #{ARGV[0]} [options]"
+
+          o.on('--push', 'prefer changes on the local machine.') do |flag|
+            options[:prefer_local] = flag
+            check_conflicting_options!
+          end
+
+          o.on('--pull', 'prefer changes on the remote machine.') do |flag|
+            options[:prefer_remote] = flag
+            check_conflicting_options!
+          end
+
+          o.on('--force-push', 'force-push changes to the remote machine. Dangerous!') do |flag|
+            options[:force_local] = flag
+            check_conflicting_options!
+          end
+
+          o.on('--force-pull', 'force-pull changes from the remote machine. Super dangerous!') do |flag|
+            options[:force_remote] = flag
+            check_conflicting_options!
+          end
+
+          o.on('--verbose', 'Print additional debug information') do |flag|
+            options[:verbose] = flag
+          end
+        end
+      end
+
+      def check_conflicting_options!
+        enabled = [:prefer_local, :prefer_remote, :force_local, :force_remote].select do |opt|
+          options[opt]
+        end
+        raise ArgumentError.new("Conflicting options: #{enabled.inspect}") if enabled.length > 1
+      end
+    end
+  end
+end

data/lib/vagrant-vaimo-unison/version.rb

@@ -0,0 +1,5 @@
+module VagrantPlugins
+  module Unison
+    VERSION = '0.0.1'
+  end
+end

data/lib/vagrant-vaimo-unison.rb

@@ -0,0 +1,15 @@
+require "pathname"
+
+require "vagrant-vaimo-unison/plugin"
+require "vagrant-vaimo-unison/errors"
+
+module VagrantPlugins
+  module Unison
+    # This returns the path to the source of this plugin.
+    #
+    # @return [Pathname]
+    def self.source_root
+      @source_root ||= Pathname.new(File.expand_path("../../", __FILE__))
+    end
+  end
+end

data/locales/en.yml

@@ -0,0 +1,19 @@
+en:
+  vagrant_unison:
+    
+    config:
+      host_folder_required: |-
+        Host folder is required
+      guest_folder_required: |-
+        Guest folder is required
+
+    errors:
+      unison_error: |-
+        There was an error when attemping to sync folders using unison.
+        Please inspect the error message below for more info.
+
+        Host path: %{hostpath}
+        Guest path: %{guestpath}
+        Error: %{stderr}
+        Full command causing error: 
+        %{command}

data/spec/vagrant-unison/config_spec.rb

@@ -0,0 +1,32 @@
+require "vagrant-vaimo-unison/config"
+
+describe VagrantPlugins::Unison::Config do
+  let(:instance) { described_class.new }
+
+  describe "defaults" do
+    subject do
+      instance.tap do |o|
+        o.finalize!
+      end
+    end
+
+    its("host_folder")     { should be_nil }
+    its("guest_folder")    { should be_nil }
+    its("ignore")          { should be_nil }
+  end
+
+  describe "overriding defaults" do
+    # I typically don't meta-program in tests, but this is a very
+    # simple boilerplate test, so I cut corners here. It just sets
+    # each of these attributes to "foo" in isolation, and reads the value
+    # and asserts the proper result comes back out.
+    [:host_folder, :guest_folder].each do |attribute|
+
+      it "should not default #{attribute} if overridden" do
+        instance.send("#{attribute}=".to_sym, "foo")
+        instance.finalize!
+        instance.send(attribute).should == "foo"
+      end
+    end
+  end
+end

data/vagrant-vaimo-unison.gemspec

@@ -0,0 +1,55 @@
+$:.unshift File.expand_path("../lib", __FILE__)
+require "vagrant-vaimo-unison/version"
+
+Gem::Specification.new do |s|
+  s.name          = "vagrant-vaimo-unison"
+  s.version       = VagrantPlugins::Unison::VERSION
+  s.platform      = Gem::Platform::RUBY
+  s.authors       = ["David Laing", "dmatora", "Danny Cosson"]
+  s.email         = "dcosson@gmail.com"
+  s.homepage      = "http://github.com/dcosson/vagrant-unison"
+  s.summary       = "Vagrant 1.7+ plugin to sync local files to VM over SSH using Unison"
+  s.description   = "Vagrant 1.7+ plugin to sync local files to VM over SSH using Unison"
+
+  s.required_rubygems_version = ">= 1.3.6"
+
+  s.add_development_dependency 'rake', '< 11.0'
+  s.add_development_dependency "rspec-core", "~> 2.12.2"
+  s.add_development_dependency "rspec-expectations", "~> 2.12.1"
+  s.add_development_dependency "rspec-mocks", "~> 2.12.1"
+
+  # The following block of code determines the files that should be included
+  # in the gem. It does this by reading all the files in the directory where
+  # this gemspec is, and parsing out the ignored files from the gitignore.
+  # Note that the entire gitignore(5) syntax is not supported, specifically
+  # the "!" syntax, but it should mostly work correctly.
+  root_path      = File.dirname(__FILE__)
+  all_files      = Dir.chdir(root_path) { Dir.glob("**/{*,.*}") }
+  all_files.reject! { |file| [".", ".."].include?(File.basename(file)) }
+  gitignore_path = File.join(root_path, ".gitignore")
+  gitignore      = File.readlines(gitignore_path)
+  gitignore.map!    { |line| line.chomp.strip }
+  gitignore.reject! { |line| line.empty? || line =~ /^(#|!)/ }
+
+  unignored_files = all_files.reject do |file|
+    # Ignore any directories, the gemspec only cares about files
+    next true if File.directory?(file)
+
+    # Ignore any paths that match anything in the gitignore. We do
+    # two tests here:
+    #
+    #   - First, test to see if the entire path matches the gitignore.
+    #   - Second, match if the basename does, this makes it so that things
+    #     like '.DS_Store' will match sub-directories too (same behavior
+    #     as git).
+    #
+    gitignore.any? do |ignore|
+      File.fnmatch(ignore, file, File::FNM_PATHNAME) ||
+        File.fnmatch(ignore, File.basename(file), File::FNM_PATHNAME)
+    end
+  end
+
+  s.files         = unignored_files
+  s.executables   = unignored_files.map { |f| f[/^bin\/(.*)/, 1] }.compact
+  s.require_path  = 'lib'
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: vagrant-vaimo-unison
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- David Laing
+- dmatora
+- Danny Cosson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-06-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '11.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '11.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.12.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.12.2
+- !ruby/object:Gem::Dependency
+  name: rspec-expectations
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.12.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.12.1
+- !ruby/object:Gem::Dependency
+  name: rspec-mocks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.12.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.12.1
+description: Vagrant 1.7+ plugin to sync local files to VM over SSH using Unison
+email: dcosson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- CHANGELOG.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/vagrant-vaimo-unison.rb
+- lib/vagrant-vaimo-unison/command.rb
+- lib/vagrant-vaimo-unison/config.rb
+- lib/vagrant-vaimo-unison/errors.rb
+- lib/vagrant-vaimo-unison/plugin.rb
+- lib/vagrant-vaimo-unison/shell_command.rb
+- lib/vagrant-vaimo-unison/ssh_command.rb
+- lib/vagrant-vaimo-unison/unison_paths.rb
+- lib/vagrant-vaimo-unison/unison_sync.rb
+- lib/vagrant-vaimo-unison/version.rb
+- locales/en.yml
+- spec/vagrant-unison/config_spec.rb
+- vagrant-vaimo-unison.gemspec
+homepage: http://github.com/dcosson/vagrant-unison
+licenses: []
+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: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.12
+signing_key: 
+specification_version: 4
+summary: Vagrant 1.7+ plugin to sync local files to VM over SSH using Unison
+test_files: []