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
|