vagrant-sparseimage 1.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2a0f121456732b4aeacec24a5796225d43c6d71e
+  data.tar.gz: 4ffeb73df027750366d21955d52a55f6c4aa4f49
+SHA512:
+  metadata.gz: 808161d145589729590d300e26672dc1962d2dcf4581462cba39d51eee9409b559d4403bb08a1ea713fe4a4554bac0eb940d5eec1be3f4e7bb720411afe84568
+  data.tar.gz: 56fbfcaf2dac82c1aa4f97bbb6b6e1742c5ce5e9015280bf0cadc8a8fcea558bc9db93461981d5536b4479d0153839d750da4f2f78ac880e8dc69c7ee58770b0

data/.gitignore

@@ -0,0 +1,6 @@
+Gemfile.lock
+pkg/
+*.gem
+
+/example_box
+!/example_box/Vagrantfile

data/Gemfile

@@ -0,0 +1,7 @@
+source "http://rubygems.org"
+
+gemspec
+
+group :development do
+	gem "vagrant", :git => 'https://github.com/mitchellh/vagrant.git'
+end

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2006-2013 Learnosity Ltd.
+
+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/Rakefile

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

data/Readme.md

@@ -0,0 +1,57 @@
+# vagrant-sparseimage
+
+`vagrant-sparseimage` is a [Vagrant](http://vagrantup.com) plugin which automatically creates and mounts a sparseimage for the guest system to share. This allows alternative filesystems to be used between the host and the guest (eg. journaled, case sensitive).
+
+The image can be browser from OSX Finder and is completely configurable. It can be unmounted automatically when the guest is halted, or left mounted for other uses. When the Vagrant guest is destroyed, the image can optionally be destroyed too.
+
+## Dependencies
+
+Only runs in OSX. Requires Vagrant v1.2+.
+
+## Installation
+
+See **building** below for building the gem.
+
+Use `vagrant plugin` to install the gem in your Vagrant environment:
+
+```bash
+$ vagrant plugin install vagrant-sparseimage.gem
+```
+
+## Configuration
+
+See `example-box/Vagrantfile`. Each vm has a sparseimage configuration object which can have an arbitrary number of images added to it.
+
+The following config properties for `config.sparseimage` are compulsory:
+
+* **volume_name**: the name that will be used to mount the volume and derive its filename
+* **image_type**: `SPARSEIMAGE` or `SPARSEBUNDLE`
+* **image_fs**: filesystem type: see below for list of supported formats
+* **vm_mountpoint**: where to mount the image wihtin the guest
+* **image_size**: size in MB. both image types will consume space lazily
+* **image_folder**: the folder on the host to store the image file in
+
+The following properties are optional:
+
+* **auto_unmount**: whether to unmount the image from the host when the guest is stopped. Defaults to true.
+* **mounted_name**: the full path to mount the sparse bundles in. Defaults using the name of the volume.
+
+## Filesystems
+
+* HFS+
+* HFS+J (`JHFS+` in the config)
+* HFSX
+* JHFS+X
+* MS-DOS
+* UDF
+
+## Building
+
+If you installed vagrant using RubyGems, use:
+
+```bash
+$ bundle install
+$ gem build vagrant-sparseimage.gemspec
+```
+
+If you installed Vagrant with a prebuilt package or installer, you need to use Vagrant's gem wrapper:

data/lib/vagrant-sparseimage.rb

@@ -0,0 +1,302 @@
+begin
+	FileUtils
+rescue NameError
+	begin
+		require 'FileUtils'
+	rescue LoadError
+		require 'fileutils'
+	end
+end
+
+require 'pp'
+require 'optparse'
+
+begin
+	require 'vagrant'
+rescue LoadError
+	raise 'The Vagrant SparseImage plugin must be run within Vagrant.'
+end
+require Vagrant.source_root.join("plugins/commands/up/start_mixins")
+
+require File.expand_path("../vagrant-sparseimage/command", __FILE__)
+require File.expand_path("../vagrant-sparseimage/hdiutil", __FILE__)
+
+module SparseImage
+
+	class << self
+		# Run the command, wait for exit and return the Process object.
+		def run(cmd)
+			pid = Process.fork { exec(cmd) }
+			Process.waitpid(pid)
+			return $?
+		end
+
+		def list(vm)
+			vm.config.sparseimage.to_hash[:images].each do |opts|
+				pp opts.to_hash
+			end
+		end
+
+		def mount(vm)
+			# mount each configured sparse image
+			vm.config.sparseimage.to_hash[:images].each do |opts|
+				# Derive the full image filename and volume mount path (for the host)
+				full_image_filename = "#{opts.image_folder}/#{opts.volume_name}.#{opts.image_type}".downcase
+
+				# Does the image need to be created?
+				if File.exists? full_image_filename
+					vm.ui.info "Found sparse disk image: #{full_image_filename}"
+				else
+					# Create the directory if it does not exist
+					FileUtils.mkdir_p opts.image_folder if not File.exists? opts.image_folder
+
+					# hdiutil is finnicky with image type
+					type = opts.image_type == 'SPARSEIMAGE' ? 'SPARSE' : opts.image_type
+					vm.ui.info "Creating #{opts.image_size}MB sparse disk image: #{full_image_filename}"
+					# TODO - move this into SparseImage::HDIUTIL::create
+					# TODO - raise an exception if create fails
+					SparseImage::HDIUTIL::create(vm, type, opts.image_size, opts.image_fs, opts.volume_name, full_image_filename)
+					vm.ui.info("Created disk image in the host: #{full_image_filename}")
+				end
+
+				# Mount the image in the host
+				vm.ui.info("Mounting disk image in the host: #{full_image_filename} at #{opts.mounted_name}")
+				SparseImage::HDIUTIL::mount(vm, opts.mounted_name, full_image_filename)
+
+				# Remove nonsense hidden files
+				errors = SparseImage::HDIUTIL::remove_OSX_fuzz(vm, opts.mounted_name)
+				if errors.length > 0
+					errors.each do |error| vm.ui.info(error) end
+				end
+
+				if opts.vm_mountpoint
+					vm.config.vm.synced_folders[opts.volume_name] = {
+						:hostpath => opts.mounted_name,
+						:guestpath => opts.vm_mountpoint,
+						:disabled => false,
+					}
+					vm.ui.info("Mounted disk image in the guest: #{full_image_filename} at #{opts.vm_mountpoint}")
+				end
+			end
+		end
+
+		def unmount(vm)
+			# Unmount each configured sparse image
+			vm.config.sparseimage.to_hash[:images].each do |opts|
+				if opts.auto_unmount
+					SparseImage::HDIUTIL::unmount(vm, opts.mounted_name)
+				end
+			end
+		end
+
+		def destroy(vm)
+			# Prompt to destroy each configured sparse image
+			vm.config.sparseimage.to_hash[:images].each do |opts|
+				cancel = false
+				full_image_filename = "#{opts.image_folder}/#{opts.volume_name}.#{opts.image_type}".downcase
+				# Confirm destruction of the sparse image
+				while cancel == false
+					choice = vm.ui.ask("Do you want to delete the sparse image at #{full_image_filename}? [y/N] ")
+					if choice.upcase == 'Y'
+						choice = vm.ui.ask("Confirm the name of the volume to destroy [#{ opts.volume_name}] ")
+						if choice == opts.volume_name
+							# TODO - Test first whether it's mounted before trying to unmount
+							#SparseImage::HDIUTIL::unmount(vm, opts.mounted_name)
+							SparseImage::HDIUTIL::destroy(vm, full_image_filename)
+							cancel = true
+						else
+							vm.ui.error("name does not match.")
+						end
+					else
+						cancel = true
+						vm.ui.error("Image '#{opts.volume_name}' was not destroyed.")
+					end
+				end
+			end
+		end
+	end
+
+	class ImageConfig
+		# Configuration for a single sparse image
+		# Not exposed to vagrant.
+
+		attr_accessor :vm_mountpoint, :image_size, :image_fs, :image_type, :volume_name, :image_folder,
+						:auto_unmount, :mounted_name
+
+		@@required = [
+			:volume_name,
+			:image_type,
+			:image_fs,
+			:image_size,
+			:image_folder
+		]
+
+		@@valid_image_types = ["SPARSEIMAGE", "SPARSEBUNDLE"]
+
+		def validate
+			errors = []
+			# Check for the required config keys
+			@@required.each do |key|
+				if not to_hash[key] or (to_hash[key].is_a? String  and to_hash[key].length == 0)
+					errors.push "#{key} must be present."
+				end
+			end
+
+			# Validate image type
+			if not @@valid_image_types.include?(@image_type)
+				errors.push "image_type: invalid value: only supports #{@@valid_image_types.join(',')}"
+			end
+
+			# Size must be an int
+			if @image_size and not @image_size.is_a? Fixnum
+				errors.push "image_size: Must be a number."
+			end
+			{ "vagrant-sparseimage" => errors }
+		end
+
+		def finalize!
+			if @auto_unmount.nil?
+				@auto_unmount = true
+			end
+			if @mounted_name.nil?
+				@mounted_name = "./#{@volume_name}"
+			end
+		end
+
+		def to_hash
+			{	:vm_mountpoint  => @vm_mountpoint,
+				:image_size     => @image_size,
+				:image_fs       => @image_fs,
+				:image_type     => @image_type,
+				:volume_name	=> @volume_name,
+				:auto_unmount	=> @auto_unmount,
+				:image_folder	=> @image_folder,
+				:mounted_name	=> @mounted_name
+			}
+		end
+	end
+
+	class Mount
+		# Mount sparse images on the host machine and add them to the config for the guest
+		# Create the sparse image files if necessary.
+
+		def initialize(app, env)
+			@app = app
+			@env = env
+		end
+
+		def call(env)
+			vm = env[:machine]
+			SparseImage::mount(vm)
+			@app.call(env)
+		end
+	end
+
+	class Unmount
+		# Startup hook
+		# Unmount the shared drive from the host machine
+		# Fails silently if the drive was not mounted
+		def initialize(app, env)
+			@app = app
+			@env = env
+		end
+		def call(env)
+			vm = env[:machine]
+			SparseImage::mount(vm)
+			@app.call(env)
+		end
+	end
+
+	class Unmount
+		# Shutdown hook
+		# Unmount the shared drive from the host machine
+		# Fails silently if the drive was not mounted
+		def initialize(app, env)
+			@app = app
+			@env = env
+		end
+		def call(env)
+			vm = env[:machine]
+			SparseImage::unmount(vm)
+			@app.call(env)
+		end
+	end
+
+	class Destroy
+		# Shutdown hook
+		# Unmount the shared drive from the host machine and delete it.
+		# Confirm with the user first.
+		def initialize(app, env)
+			@app = app
+			@env = env
+		end
+		def call(env)
+			vm = env[:machine]
+			SparseImage::destroy(vm)
+			@app.call(env)
+		end
+	end
+
+	class Config < Vagrant.plugin("2", :config)
+		# Singleton
+		@@images = []
+		class << self
+			attr_accessor :images
+		end
+
+		def add_image
+			if not block_given?
+				raise 'add_image must be given a block.'
+			end
+			image = ImageConfig.new
+			yield image
+			@@images.push(image)
+		end
+
+		def finalize!
+			@@images.each do |image|
+				image.finalize!
+			end
+		end
+
+		def validate(machine)
+			errors = {}
+			# Validate each of the image configs in turn
+			@@images.each_with_index do |image, i|
+				image_errors = image.validate()
+				if image_errors.length > 0
+					image_errors.each do |key, value|
+						errors[key] ||= []
+						errors[key] += value
+					end
+				end
+			end
+			errors
+		end
+
+		def to_hash
+			return { :images => @@images }
+		end
+	end
+
+	class Plugin < Vagrant.plugin("2")
+		name "vagrant sparse image support"
+		description "A vagrant plugin to managed shared sparse images."
+
+		config(:sparseimage) do
+			# Yield a config object to the vagrant file.
+			# Vagrant will handle persisting the state of this object for each VM.
+			Config
+		end
+
+		command("sparseimage") do
+			Command::Root
+		end
+
+		action_hook(self::ALL_ACTIONS) do |hook|
+			hook.before(Vagrant::Action::Builtin::SyncedFolders, Mount)
+			hook.after(Vagrant::Action::Builtin::GracefulHalt, Unmount)
+			hook.after(Vagrant::Action::Builtin::DestroyConfirm, Destroy)
+		end
+	end
+end

data/lib/vagrant-sparseimage/command.rb

@@ -0,0 +1,120 @@
+require 'vagrant'
+
+module SparseImage
+	module Command
+		class Root < Vagrant.plugin("2", :command)
+			def initialize(argv, env)
+				super
+				@main_args, @sub_command, @sub_args = split_main_and_subcommand(argv)
+				@subcommands = Vagrant::Registry.new
+				@subcommands.register(:mount) do
+					Mount
+				end
+				@subcommands.register(:unmount) do
+					Unmount
+				end
+				@subcommands.register(:destroy) do
+					Destroy
+				end
+				@subcommands.register(:list) do
+					List
+				end
+			end
+
+			def execute
+				if @main_args.include?("-h") || @main_args.include?("--help")
+					# Print the help for all the sparseimage commands.
+					return help
+				end
+
+				# If we reached this far then we must have a subcommand. If not,
+				# then we also just print the help and exit.
+				command_class = @subcommands.get(@sub_command.to_sym) if @sub_command
+				return help if !command_class || !@sub_command
+				@logger.debug("Invoking command class: #{command_class} #{@sub_args.inspect}")
+				# Initialize and execute the command class
+				command_class.new(@sub_args, @env).execute
+			end
+
+			# Prints the help out for this command
+			def help
+				opts = OptionParser.new do |opts|
+				opts.banner = "Usage: vagrant sparseimage <command>"
+				opts.separator ""
+				opts.separator "Available subcommands:"
+
+				# Add the available subcommands as separators in order to print them
+				# out as well.
+				keys = []
+				@subcommands.each { |key, value| keys << key.to_s }
+
+					keys.sort.each do |key|
+						opts.separator "     #{key}"
+					end
+
+					opts.separator ""
+					opts.separator "For help on any individual command run `vagrant sparseimage COMMAND -h`"
+				end
+				@env.ui.info(opts.help, :prefix => false)
+			end
+		end
+
+		class List < Vagrant.plugin("2", :command)
+			def execute
+				@env.machine_names.each do |mname|
+					machine = @env.machine(mname, :virtualbox)
+					machine.ui.info("Listing sparse images for machine #{mname}")
+					SparseImage::list(machine)
+				end
+			end
+			def help
+				@env.ui.info("Usage: vagrant sparseimage mount")
+				@env.ui.info("\tMount all configured sparse images")
+			end
+		end
+
+
+
+		class Mount < Vagrant.plugin("2", :command)
+			def execute
+				@env.machine_names.each do |mname|
+					machine = @env.machine(mname, :virtualbox)
+					machine.ui.info("Mounting sparse images for machine #{mname}")
+					SparseImage::mount(machine)
+				end
+			end
+			def help
+				@env.ui.info("Usage: vagrant sparseimage mount")
+				@env.ui.info("\tMount all configured sparse images")
+			end
+		end
+
+		class Unmount < Vagrant.plugin("2", :command)
+			def execute
+				@env.machine_names.each do |mname|
+					machine = @env.machine(mname, :virtualbox)
+					machine.ui.info("Unmounting sparse images for machine #{mname}")
+					SparseImage::unmount(machine)
+				end
+			end
+			def help
+				@env.ui.info("Usage: vagrant sparseimage unmount")
+				@env.ui.info("\tUnmount all configured sparse images")
+			end
+		end
+
+		class Destroy < Vagrant.plugin("2", :command)
+			def execute
+				@env.machine_names.each do |mname|
+					machine = @env.machine(mname, :virtualbox)
+					machine.ui.info("Destroying sparse images for machine #{mname}")
+					SparseImage::destroy(machine)
+				end
+			end
+			def help
+				@env.ui.info("Usage: vagrant sparseimage destroy")
+				@env.ui.info("\tDestroy all configured sparse images")
+			end
+		end
+	end
+end

data/lib/vagrant-sparseimage/hdiutil.rb

@@ -0,0 +1,61 @@
+module SparseImage
+	module HDIUTIL
+		class << self
+			# Try to mount the image. If it fails, return a warning (as a string)
+			def mount(vm, mount_in, image_path)
+				if not SparseImage::run("hdiutil attach -mountpoint '#{mount_in}' '#{image_path}'").success?
+					vm.ui.error("WARNING: Failed to mount #{image_path} at #{mount_in}")
+				end
+			end
+
+			# Unmount the image
+			def unmount(vm, mounted_in)
+				vm.ui.info("Unmounting disk image from host: #{mounted_in}")
+				if not SparseImage::run("hdiutil detach -quiet '#{mounted_in}'").success?
+					vm.ui.error("WARNING: Failed to unmount #{mounted_in}. It may not have been mounted.")
+				end
+			end
+
+			# Delete the image
+			def destroy(vm, image_filename)
+				vm.ui.info("Destroying disk image at #{image_filename}")
+				if File.exists?(image_filename)
+					if File.directory?(image_filename)
+						FileUtils.rm_rf(image_filename)
+					else
+						File.delete(image_filename)
+					end
+				end
+			end
+
+			# Create a sparseimage
+			def create(vm, type, image_size, image_fs, volume_name, full_image_filename)
+				if not SparseImage::run("hdiutil create -type '#{type}' " +
+					   "-size '#{image_size}m' " +
+					   "-fs '#{image_fs}' " +
+					   "-volname '#{volume_name}' " +
+					   "'#{full_image_filename}'")
+					vm.ui.error("ERROR: Failed to create sparseimage #{full_image_filename}")
+				end
+			end
+
+			# Remove all the nonsense that comes with a mounted sparse image in OSX
+			def remove_OSX_fuzz(vm, mounted_dir)
+				# Append trailing slash if it's missing from the mounted dir
+				mounted_dir = "#{mounted_dir}/" unless mounted_dir[-1] == '/'
+				errors = []
+				['.fseventsd', '.Spotlight-V*', '.Trashes'].each do |rubbish|
+					path = "#{mounted_dir}#{rubbish}"
+					if File.exists?(path)
+						p = SparseImage::run("rm -rf #{path}")
+						vm.ui.info("Removing #{path}")
+						if not p.success?
+							vm.ui.error("Failed to remove #{rubbish} from #{mounted_dir}. It may not have existed.")
+						end
+					end
+				end
+				return errors
+			end
+		end
+	end
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module SparseImage
+	VERSION = "1.0.2"
+end

data/vagrant-sparseimage.gemspec

@@ -0,0 +1,26 @@
+$:.unshift File.expand_path("../lib", __FILE__)
+require 'version.rb'
+
+Gem::Specification.new do |s|
+	s.name			= 'vagrant-sparseimage'
+	s.version		= SparseImage::VERSION
+	s.platform		= Gem::Platform::RUBY
+	s.authors		= ['Alan Garfield', 'Daniel Bryan']
+	s.license		= 'MIT'
+	s.email			= ['alan.garfield@learnosity.com', 'danbryan@gmail.com']
+	s.homepage		= 'https://github.com/Learnosity/vagrant-sparseimage'
+	s.summary		= %q{A vagrant plugin to create a mount sparse images into the guest VM.}
+	s.description	= %q{A vagrant plugin to create a mount sparse images into the guest VM.}
+	s.files         = `git ls-files`.split("\n")
+	s.require_paths = ['lib']
+
+	s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+
+	if s.respond_to? :specification_version
+		current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+		s.specification_version = 2
+	end
+	
+	s.add_development_dependency 'bundler', '>= 1.2.0'
+	s.add_development_dependency 'vagrant', '>= 1.2'
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: vagrant-sparseimage
+version: !ruby/object:Gem::Version
+  version: 1.0.2
+platform: ruby
+authors:
+- Alan Garfield
+- Daniel Bryan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+- !ruby/object:Gem::Dependency
+  name: vagrant
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.2'
+description: A vagrant plugin to create a mount sparse images into the guest VM.
+email:
+- alan.garfield@learnosity.com
+- danbryan@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE
+- Rakefile
+- Readme.md
+- example_box/Vagrantfile
+- lib/vagrant-sparseimage.rb
+- lib/vagrant-sparseimage/command.rb
+- lib/vagrant-sparseimage/hdiutil.rb
+- lib/version.rb
+- vagrant-sparseimage.gemspec
+homepage: https://github.com/Learnosity/vagrant-sparseimage
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 2
+summary: A vagrant plugin to create a mount sparse images into the guest VM.
+test_files: []