vagrant-nfs_guest 0.0.1

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.vagrant
+Vagrantfile

data/Gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in vagrant-nfs_guest.gemspec
+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.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Alan Garfield
+
+MIT License
+
+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,33 @@
+# Vagrant-NFS_Guest
+
+Allows a guest VM to export synced folders via NFS and the host to mount them.
+
+Basically it's just the usual NFS synced folders in Vagrant but the roles are reversed.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'vagrant-nfs_guest'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install vagrant-nfs_guest
+
+## Usage
+
+To enable for example:
+
+```config.vm.synced_folder 'srv', '/srv', type: 'nfs_guest'```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,3 @@
+require 'rubygems'
+require 'bundler/setup'
+Bundler::GemHelper.install_tasks

data/lib/vagrant-nfs_guest/action/prepare_nfs_guest_settings.rb

@@ -0,0 +1,99 @@
+module VagrantPlugins
+  module SyncedFolderNFSGuest
+    module Action
+      class PrepareNFSGuestSettings
+        include Vagrant::Util::Retryable
+
+        # This is only required to deal with the hard coded :nfs_host_ip and :nfs_machine_ip symbols 
+        # not using the impl name this stops them being availabe in nfsopts because the impl is called
+        # nfs_guest. There has to be a better way.
+
+        def initialize(app,env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::action::vm::nfs_guest")
+        end
+
+        def call(env)
+          @machine = env[:machine]
+          @app.call(env)
+
+          if using_nfs?
+            @logger.info("Using NFS_guest, preparing NFS settings by reading host IP and machine IP")
+            add_nfs_settings_to_env!(env)
+          end
+        end
+
+        # We're using NFS if we have any synced folder with NFS configured. If
+        # we are not using NFS we don't need to do the extra work to
+        # populate these fields in the environment.
+        def using_nfs?
+          @machine.config.vm.synced_folders.any? { |_, opts| opts[:type] == :nfs_guest }
+        end
+
+        # Extracts the proper host and guest IPs for NFS mounts and stores them
+        # in the environment for the SyncedFolder action to use them in
+        # mounting.
+        #
+        # The ! indicates that this method modifies its argument.
+        def add_nfs_settings_to_env!(env)
+          adapter, host_ip = find_host_only_adapter
+          machine_ip       = nil
+          machine_ip       = read_machine_ip(adapter) if adapter
+
+          raise Vagrant::Errors::NFSNoHostonlyNetwork if !host_ip || !machine_ip
+
+          env[:nfs_guest_host_ip]    = host_ip
+          env[:nfs_guest_machine_ip] = machine_ip
+        end
+
+        # Finds first host only network adapter and returns its adapter number
+        # and IP address
+        #
+        # @return [Integer, String] adapter number, ip address of found host-only adapter
+        def find_host_only_adapter
+          @machine.provider.driver.read_network_interfaces.each do |adapter, opts|
+            if opts[:type] == :hostonly
+              @machine.provider.driver.read_host_only_interfaces.each do |interface|
+                if interface[:name] == opts[:hostonly]
+                  return adapter, interface[:ip]
+                end
+              end
+            end
+          end
+
+          nil
+        end
+
+        # Returns the IP address of the guest by looking at vbox guest property
+        # for the appropriate guest adapter.
+        #
+        # For DHCP interfaces, the guest property will not be present until the
+        # guest completes
+        #
+        # @param [Integer] adapter number to read IP for
+        # @return [String] ip address of adapter
+        def read_machine_ip(adapter)
+          # vbox guest properties are 0-indexed, while showvminfo network
+          # interfaces are 1-indexed. go figure.
+          guestproperty_adapter = adapter - 1
+
+          # we need to wait for the guest's IP to show up as a guest property.
+          # retry thresholds are relatively high since we might need to wait
+          # for DHCP, but even static IPs can take a second or two to appear.
+          retryable(retry_options.merge(on: Vagrant::Errors::VirtualBoxGuestPropertyNotFound)) do
+            @machine.provider.driver.read_guest_ip(guestproperty_adapter)
+          end
+        rescue Vagrant::Errors::VirtualBoxGuestPropertyNotFound
+          # this error is more specific with a better error message directing
+          # the user towards the fact that it's probably a reportable bug
+          raise Vagrant::Errors::NFSNoGuestIP
+        end
+
+        # Separating these out so we can stub out the sleep in tests
+        def retry_options
+          {tries: 15, sleep: 1}
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-nfs_guest/action/unmount_mounts.rb

@@ -0,0 +1,20 @@
+module VagrantPlugins
+  module SyncedFolderNFSGuest
+    module Action
+      class UnmountMounts
+        def initialize(app,env)
+          @app = app
+          @logger = Log4r::Logger.new("vagrant::action::vm::nfs_guest")
+        end
+
+        def call(env)
+          @machine = env[:machine]
+          @app.call(env)
+
+          folders = @machine.config.vm.synced_folders
+          @machine.env.host.unmount_nfs_folders(folders)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-nfs_guest/cap/linux/export_nfs_folders.rb

@@ -0,0 +1,115 @@
+require 'vagrant/util/platform'
+
+module VagrantPlugins
+  module SyncedFolderNFSGuest
+    module Cap
+      module Linux
+        class ExportNFS
+          include Vagrant::Util
+
+          def self.export_nfs_capable(machine)
+            me = self.new(machine)
+            return me.nfs_capable?
+          end
+
+          def self.export_nfs_folders(machine, ip, folders)
+            me = self.new(machine, ip, folders)
+
+            me.nfs_opts_setup()
+
+            tpl_path = VagrantPlugins::SyncedFolderNFSGuest.source_root.join(
+              'templates/nfs_guest/guest_export_linux')
+            output = TemplateRenderer.render(tpl_path,
+                                             :uuid => machine.id,
+                                             :ips => [ip],
+                                             :folders => folders,
+                                             :user => Process.uid)
+
+            machine.ui.info I18n.t("vagrant.hosts.linux.nfs_export")
+            sleep 0.5
+
+            me.nfs_cleanup()
+
+            output.split("\n").each do |line|
+              machine.communicate.sudo(%Q[echo '#{line}' >> /etc/exports])
+            end
+
+            me.restart_nfs()
+          end
+
+          def initialize(machine, ip = [], folders = [])
+            @machine = machine
+            @ip = ip
+            @folders = folders
+
+            @folder_test_command  = "test -d"
+            @nfs_test_command  = "test -e /etc/exports"
+            @nfs_apply_command = "/usr/sbin/exportfs -r"
+            @nfs_check_command = "/etc/init.d/nfs-kernel-server status"
+            @nfs_start_command = "/etc/init.d/nfs-kernel-server start"
+          end
+
+          def nfs_running?
+            @machine.communicate.test("#{@nfs_check_command}")
+          end
+
+          def nfs_capable?
+            @machine.communicate.test("#{@nfs_test_command}")
+          end
+
+          # TODO - DRY this; ripped completely from plugins/hosts/linux/host.rb
+          def nfs_opts_setup()
+            @folders.each do |k, opts|
+              if !opts[:linux__nfs_options]
+                opts[:linux__nfs_options] ||= ["rw", "no_subtree_check", "all_squash", "insecure"]
+              end
+
+              # Only automatically set anonuid/anongid if they weren't
+              # explicitly set by the user.
+              hasgid = false
+              hasuid = false
+              opts[:linux__nfs_options].each do |opt|
+                hasgid = !!(opt =~ /^anongid=/) if !hasgid
+                hasuid = !!(opt =~ /^anonuid=/) if !hasuid
+              end
+
+              opts[:linux__nfs_options] << "anonuid=#{opts[:map_uid]}" if !hasuid
+              opts[:linux__nfs_options] << "anongid=#{opts[:map_gid]}" if !hasgid
+              opts[:linux__nfs_options] << "fsid=#{opts[:uuid]}"
+
+              # Expand the guest path so we can handle things like "~/vagrant"
+              expanded_guest_path = @machine.guest.capability(
+                :shell_expand_guest_path, opts[:guestpath])
+
+              # Do the actual creating and mounting
+              @machine.communicate.sudo("mkdir -p #{expanded_guest_path}")
+              @machine.communicate.sudo("chgrp -R vagrant #{expanded_guest_path}")
+              @machine.communicate.sudo("chmod g+rw #{expanded_guest_path}")
+            end
+          end
+
+          def nfs_cleanup()
+            return if !nfs_capable?
+
+            id = @machine.id
+            user = Process.uid
+
+            # Use sed to just strip out the block of code which was inserted
+            # by Vagrant
+            @machine.communicate.sudo("sed -r -e '/^# VAGRANT-BEGIN:( #{user})? #{id}/,/^# VAGRANT-END:( #{user})? #{id}/ d' -ibak /etc/exports")
+          end
+
+          def restart_nfs()
+            if nfs_running?
+              @machine.communicate.sudo("#{@nfs_apply_command}")
+            else
+              @machine.communicate.sudo("#{@nfs_start_command}")
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+

data/lib/vagrant-nfs_guest/cap/linux/halt.rb

@@ -0,0 +1,20 @@
+require Vagrant.source_root.join("plugins/guests/linux/cap/halt")
+
+module VagrantPlugins
+  module SyncedFolderNFSGuest
+    module Cap
+      module Linux
+        class Halt
+          def self.halt(machine)
+            # unmount any host mounted NFS folders
+            folders = machine.config.vm.synced_folders
+            machine.env.host.unmount_nfs_folders(folders)
+
+            VagrantPlugins::GuestLinux::Cap::Halt.halt(machine)
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/vagrant-nfs_guest/cap/linux/read_user_ids.rb

@@ -0,0 +1,29 @@
+module VagrantPlugins
+  module SyncedFolderNFSGuest
+    module Cap
+      module Linux
+        class ReadUserIDs
+          def self.read_uid(machine)
+            command = "id -u"
+            result  = ""
+            machine.communicate.execute(command) do |type, data|
+              result << data if type == :stdout
+            end
+
+            result.chomp.split("\n").first
+          end
+
+          def self.read_gid(machine)
+            command = "id -g"
+            result  = ""
+            machine.communicate.execute(command) do |type, data|
+              result << data if type == :stdout
+            end
+
+            result.chomp.split("\n").first
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-nfs_guest/config.rb

@@ -0,0 +1,26 @@
+require "vagrant"
+
+module VagrantPlugins
+  module SyncedFolderNFSGuest
+    class Config < Vagrant.plugin("2", :config)
+      attr_accessor :map_uid
+      attr_accessor :map_gid
+
+      def initialize
+        super
+
+        @map_uid = UNSET_VALUE
+        @map_gid = UNSET_VALUE
+      end
+
+      def finalize!
+        @map_uid = nil if @map_uid == UNSET_VALUE
+        @map_gid = nil if @map_gid == UNSET_VALUE
+      end
+
+      def to_s
+        "NFS_Guest"
+      end
+    end
+  end
+end

data/lib/vagrant-nfs_guest/errors.rb

@@ -0,0 +1,9 @@
+require "vagrant"
+
+module VagrantPlugins
+  module SyncedFolderNFSGuest
+    class Error < Vagrant::Errors::VagrantError
+      error_namespace("vagrant.config.nfs_guest.errors")
+    end
+  end
+end

data/lib/vagrant-nfs_guest/hosts/bsd/host.rb

@@ -0,0 +1,30 @@
+module VagrantPlugins
+  module HostBSD
+    class Host < Vagrant.plugin("2", :host)
+      def mount_nfs_folders(id, ips, folders)
+        @logger.debug "Mounting NFS mounts..."
+        folders.each do |name, opts|
+          @logger.info opts
+          ips.each do |ip|
+            system("mkdir -p #{opts[:hostpath]}")
+            mount_command = "mount -t nfs -o noatime '#{ip}:#{opts[:guestpath]}' '#{opts[:hostpath]}'"
+            if system(mount_command)
+              break
+            end
+          end
+        end
+      end
+
+      def unmount_nfs_folders(folders)
+        @logger.debug "Unmounting NFS mounts..."
+        folders.each do |name, opts|
+          if opts[:type] == :nfs_guest
+            expanded_host_path = `printf #{opts[:hostpath]}`
+            system("umount '#{expanded_host_path}'")
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/vagrant-nfs_guest/hosts/host.rb

@@ -0,0 +1,23 @@
+module Vagrant
+  module Plugin
+    module V2
+      class Host
+        # Mounts the given hash of folders via the guests NFS export
+        #
+        # @param [String] id A unique ID that is guaranteed to be unique to
+        #   match these sets of folders.
+        # @param [Array<String>] ip IPs of the guest machine.
+        # @param [Hash] folders Shared folders to sync.
+        def mount_nfs_folders(id, ips, folders)
+        end
+
+        # Unmounts the given hash of folders
+        #
+        # @param [Hash] folders Shared folders to sync.
+        def unmount_nfs_folders(folders)
+        end
+      end
+    end
+  end
+end
+

data/lib/vagrant-nfs_guest/plugin.rb

@@ -0,0 +1,60 @@
+require File.expand_path("../hosts/host", __FILE__)
+require File.expand_path("../hosts/bsd/host", __FILE__)
+
+module VagrantPlugins
+  module SyncedFolderNFSGuest
+    class Plugin < Vagrant.plugin("2")
+      name "vagrant-nfs_guest"
+      description <<-DESC
+      Adds support for guest nfs exporting of synced folders
+      DESC
+
+      config(:nfs_guest) do
+        require File.expand_path("../config", __FILE__)
+        Config
+      end
+
+      synced_folder(:nfs_guest, 4) do
+        require File.expand_path("../synced_folder", __FILE__)
+        SyncedFolder
+      end
+
+      guest_capability(:linux, :export_nfs_folders) do
+        require File.expand_path("../cap/linux/export_nfs_folders", __FILE__)
+        Cap::Linux::ExportNFS
+      end
+
+      guest_capability(:linux, :export_nfs_capable) do
+        require File.expand_path("../cap/linux/export_nfs_folders", __FILE__)
+        Cap::Linux::ExportNFS
+      end
+
+      guest_capability(:linux, :read_uid) do
+        require File.expand_path("../cap/linux/read_user_ids", __FILE__)
+        Cap::Linux::ReadUserIDs
+      end
+
+      guest_capability(:linux, :read_gid) do
+        require File.expand_path("../cap/linux/read_user_ids", __FILE__)
+        Cap::Linux::ReadUserIDs
+      end
+
+      guest_capability(:linux, :halt) do
+        require File.expand_path("../cap/linux/halt", __FILE__)
+        Cap::Linux::Halt
+      end
+
+      require File.expand_path("../action/prepare_nfs_guest_settings", __FILE__)
+      action_hook(:nfs_guest, :machine_action_up) do |hook|
+        hook.before(VagrantPlugins::ProviderVirtualBox::Action::PrepareNFSSettings,
+                   Action::PrepareNFSGuestSettings)
+      end
+
+      require File.expand_path("../action/unmount_mounts", __FILE__)
+      action_hook(:nfs_guest, :machine_action_destroy) do |hook|
+        hook.after(Vagrant::Action::Builtin::DestroyConfirm,
+                   Action::UnmountMounts)
+      end
+    end
+  end
+end

data/lib/vagrant-nfs_guest/synced_folder.rb

@@ -0,0 +1,75 @@
+require 'zlib'
+
+module VagrantPlugins
+  module SyncedFolderNFSGuest
+    class SyncedFolder < Vagrant.plugin("2", :synced_folder)
+      def usable?(machine)
+        # NFS is always available
+        true
+      end
+
+      def prepare(machine, folders, opts)
+        # Nothing is necessary to do before VM boot.
+      end
+
+      def enable(machine, folders, nfsopts)
+        raise Vagrant::Errors::NFSNoHostIP if !nfsopts[:nfs_guest_host_ip]
+        raise Vagrant::Errors::NFSNoGuestIP if !nfsopts[:nfs_guest_machine_ip]
+
+        if !machine.guest.capability(:export_nfs_capable)
+          raise VagrantPlugins::SyncedFolderNFSGuest::Error, :no_nfsd
+        end
+        
+        machine_ip = nfsopts[:nfs_guest_machine_ip]
+        machine_ip = [machine_ip] if !machine_ip.is_a?(Array)
+
+        # Prepare the folder, this means setting up various options
+        # and such on the folder itself.
+        folders.each { |id, opts| prepare_folder(machine, opts) }
+
+        # Only mount folders that have a guest path specified.
+        mount_folders = {}
+        folders.each do |id, opts|
+          mount_folders[id] = opts.dup if opts[:guestpath]
+        end
+
+        machine.ui.info I18n.t("vagrant.actions.vm.nfs.exporting")
+        machine.guest.capability(
+          :export_nfs_folders, nfsopts[:nfs_guest_host_ip], mount_folders)
+
+        machine.ui.info I18n.t("vagrant.actions.vm.nfs.mounting")
+        machine.env.host.mount_nfs_folders(
+          machine.id, machine_ip, mount_folders)
+      end
+
+      protected
+
+      def prepare_folder(machine, opts)
+        opts[:map_uid] = prepare_permission(machine, :uid, opts)
+        opts[:map_gid] = prepare_permission(machine, :gid, opts)
+        opts[:nfs_udp] = true if !opts.has_key?(:nfs_udp)
+        opts[:nfs_version] ||= 3
+
+        # We use a CRC32 to generate a 32-bit checksum so that the
+        # fsid is compatible with both old and new kernels.
+        opts[:uuid] = Zlib.crc32(opts[:hostpath]).to_s
+      end
+
+      # Prepares the UID/GID settings for a single folder.
+      def prepare_permission(machine, perm, opts)
+        key = "map_#{perm}".to_sym
+        return nil if opts.has_key?(key) && opts[key].nil?
+
+        # The options on the hash get priority, then the default
+        # values
+        value = opts.has_key?(key) ? opts[key] : machine.config.nfs.send(key)
+        return value if value != :auto
+
+        # Get UID/GID from guests user if we've made it this far
+        # (value == :auto)
+        return machine.guest.capability("read_#{perm}".to_sym)
+      end
+    end
+  end
+end
+

data/lib/vagrant-nfs_guest/version.rb

@@ -0,0 +1,5 @@
+module VagrantPlugins
+  module SyncedFolderNFSGuest
+    VERSION = "0.0.1"
+  end
+end

data/lib/vagrant-nfs_guest.rb

@@ -0,0 +1,27 @@
+begin
+    require "vagrant"
+rescue LoadError
+    raise "The Vagrant nfs_guest 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.4.0"
+    raise "The Vagrant nfs_guest plugin is only compatible with Vagrant 1.4+"
+end
+
+require "vagrant-nfs_guest/plugin"
+require 'vagrant-nfs_guest/errors'
+
+require "pathname"
+
+module VagrantPlugins
+  module SyncedFolderNFSGuest
+    def self.source_root
+      @source_root ||= Pathname.new(File.expand_path("../../", __FILE__))
+    end
+
+    I18n.load_path << File.expand_path('locales/en.yml', source_root)
+    I18n.reload!
+  end
+end

data/locales/en.yml

@@ -0,0 +1,6 @@
+en:
+  vagrant:
+    config:
+      nfs_guest:
+        errors:
+          no_nfsd: "Guest doesn't have the necessary NFS server installed"

data/templates/nfs_guest/guest_export_linux.erb

@@ -0,0 +1,7 @@
+# VAGRANT-BEGIN: <%= user %> <%= uuid %>
+<% ips.each do |ip| %>
+<% folders.each do |name, opts| %>
+"<%= opts[:guestpath] %>" <%= ip %>(<%= opts[:linux__nfs_options].join(",") %>)
+<% end %>
+<% end %>
+# VAGRANT-END: <%= user %> <%= uuid %>

data/vagrant-nfs_guest.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'vagrant-nfs_guest/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "vagrant-nfs_guest"
+  spec.version       = VagrantPlugins::SyncedFolderNFSGuest::VERSION
+  spec.authors       = ["Alan Garfield"]
+  spec.email         = ["alan.garfield@learnosity.com"]
+  spec.description   = %q{Adds support for guest nfs exporting of synced folders}
+  spec.summary       = %q{Adds support for guest nfs exporting of synced folders}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  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", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: vagrant-nfs_guest
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Alan Garfield
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Adds support for guest nfs exporting of synced folders
+email:
+- alan.garfield@learnosity.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/vagrant-nfs_guest.rb
+- lib/vagrant-nfs_guest/action/prepare_nfs_guest_settings.rb
+- lib/vagrant-nfs_guest/action/unmount_mounts.rb
+- lib/vagrant-nfs_guest/cap/linux/export_nfs_folders.rb
+- lib/vagrant-nfs_guest/cap/linux/halt.rb
+- lib/vagrant-nfs_guest/cap/linux/read_user_ids.rb
+- lib/vagrant-nfs_guest/config.rb
+- lib/vagrant-nfs_guest/errors.rb
+- lib/vagrant-nfs_guest/hosts/bsd/host.rb
+- lib/vagrant-nfs_guest/hosts/host.rb
+- lib/vagrant-nfs_guest/plugin.rb
+- lib/vagrant-nfs_guest/synced_folder.rb
+- lib/vagrant-nfs_guest/version.rb
+- locales/en.yml
+- templates/nfs_guest/guest_export_linux.erb
+- vagrant-nfs_guest.gemspec
+homepage: ''
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -1357282251529375209
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -1357282251529375209
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Adds support for guest nfs exporting of synced folders
+test_files: []