da15105a8f
This involved defaulting all box searching at the moment to VirtualBox. Additionally, box upgrading is not yet handled. This needs to be done at some point.
149 lines
3.9 KiB
Ruby
149 lines
3.9 KiB
Ruby
require "fileutils"
|
|
require "pathname"
|
|
require "tempfile"
|
|
|
|
require "archive/tar/minitar"
|
|
require "log4r"
|
|
|
|
require "vagrant/util/platform"
|
|
|
|
require "support/isolated_environment"
|
|
require "support/tempdir"
|
|
|
|
module Unit
|
|
class IsolatedEnvironment < ::IsolatedEnvironment
|
|
def create_vagrant_env(options=nil)
|
|
options = {
|
|
:cwd => @workdir,
|
|
:home_path => @homedir
|
|
}.merge(options || {})
|
|
|
|
Vagrant::Environment.new(options)
|
|
end
|
|
|
|
# This creates a file in the isolated environment. By default this file
|
|
# will be created in the working directory of the isolated environment.
|
|
def file(name, contents)
|
|
@workdir.join(name).open("w+") do |f|
|
|
f.write(contents)
|
|
end
|
|
end
|
|
|
|
def vagrantfile(contents, root=nil)
|
|
root ||= @workdir
|
|
root.join("Vagrantfile").open("w+") do |f|
|
|
f.write(contents)
|
|
end
|
|
end
|
|
|
|
def box(name, vagrantfile_contents="")
|
|
# Create the box directory
|
|
box_dir = boxes_dir.join(name)
|
|
box_dir.mkpath
|
|
|
|
# Create the "box.ovf" file because that is how Vagrant heuristically
|
|
# determines a box is a V1 box.
|
|
box_dir.join("box.ovf").open("w") { |f| f.write("") }
|
|
|
|
# Populate the vagrantfile
|
|
vagrantfile(vagrantfile_contents, box_dir)
|
|
|
|
# Return the directory
|
|
box_dir
|
|
end
|
|
|
|
# Create an alias because "box" makes a V1 box, so "box1"
|
|
alias :box1 :box
|
|
|
|
# Creates a fake box to exist in this environment.
|
|
#
|
|
# @param [String] name Name of the box
|
|
# @param [Symbol] provider Provider the box was built for.
|
|
# @return [Pathname] Path to the box directory.
|
|
def box2(name, provider, options=nil)
|
|
# Default options
|
|
options = {
|
|
:vagrantfile => ""
|
|
}.merge(options || {})
|
|
|
|
# Make the box directory
|
|
box_dir = boxes_dir.join(name, provider.to_s)
|
|
box_dir.mkpath
|
|
|
|
# Create a metadata.json file
|
|
box_metadata_file = box_dir.join("metadata.json")
|
|
box_metadata_file.open("w") do |f|
|
|
f.write("{}")
|
|
end
|
|
|
|
# Create a Vagrantfile
|
|
box_vagrantfile = box_dir.join("Vagrantfile")
|
|
box_vagrantfile.open("w") do |f|
|
|
f.write(options[:vagrantfile])
|
|
end
|
|
|
|
# Return the box directory
|
|
box_dir
|
|
end
|
|
|
|
# This creates a "box" file with the given provider.
|
|
#
|
|
# @param [Symbol] provider Provider for the box.
|
|
# @return [Pathname] Path to the newly created box.
|
|
def box2_file(provider)
|
|
# This is the metadata we want to store in our file
|
|
metadata = {
|
|
"type" => "v2_box",
|
|
"provider" => provider
|
|
}
|
|
|
|
# Create a temporary directory to store our data we will tar up
|
|
td_source = Tempdir.new
|
|
td_dest = Tempdir.new
|
|
|
|
# Store the temporary directory so it is not deleted until
|
|
# this instance is garbage collected.
|
|
@_box2_file_temp ||= []
|
|
@_box2_file_temp << td_dest
|
|
|
|
# The source as a Pathname, which is easier to work with
|
|
source = Pathname.new(td_source.path)
|
|
|
|
# The destination file
|
|
result = Pathname.new(td_dest.path).join("temporary.box")
|
|
|
|
File.open(result, Vagrant::Util::Platform.tar_file_options) do |tar|
|
|
Archive::Tar::Minitar::Output.open(tar) do |output|
|
|
begin
|
|
# Switch to the source directory so that Archive::Tar::Minitar
|
|
# can tar things up.
|
|
current_dir = FileUtils.pwd
|
|
FileUtils.cd(source)
|
|
|
|
# Put the metadata.json in here.
|
|
source.join("metadata.json").open("w") do |f|
|
|
f.write(JSON.generate(metadata))
|
|
end
|
|
|
|
# Add all the files
|
|
Dir.glob(File.join(".", "**", "*")).each do |entry|
|
|
Archive::Tar::Minitar.pack_file(entry, output)
|
|
end
|
|
ensure
|
|
FileUtils.cd(current_dir)
|
|
end
|
|
end
|
|
end
|
|
|
|
# Resulting box
|
|
result
|
|
end
|
|
|
|
def boxes_dir
|
|
dir = @homedir.join("boxes")
|
|
dir.mkpath
|
|
dir
|
|
end
|
|
end
|
|
end
|