bento-lpn 1.1.3

data/lib/bento/common.rb

@@ -0,0 +1,105 @@
+require "benchmark"
+require "fileutils"
+require "json"
+require "tempfile"
+require "yaml"
+require "vagrant_cloud"
+
+MEGABYTE = 1024.0 * 1024.0
+
+module Common
+  def vc_account
+    VagrantCloud::Account.new(ENV["VAGRANT_CLOUD_ORG"], ENV["VAGRANT_CLOUD_TOKEN"])
+  end
+
+  def banner(msg)
+    puts "==> #{msg}"
+  end
+
+  def info(msg)
+    puts "    #{msg}"
+  end
+
+  def warn(msg)
+    puts ">>> #{msg}"
+  end
+
+  def duration(total)
+    total = 0 if total.nil?
+    minutes = (total / 60).to_i
+    seconds = (total - (minutes * 60))
+    format("%dm%.2fs", minutes, seconds)
+  end
+
+  def box_metadata(metadata_file)
+    metadata = Hash.new
+    file = File.read(metadata_file)
+    json = JSON.parse(file)
+
+    # metadata needed for upload:  boxname, version, provider, box filename
+    metadata["name"] = json["name"]
+    metadata["version"] = json["version"]
+    metadata["box_basename"] = json["box_basename"]
+    metadata["tools"] = json["tools"]
+    metadata["providers"] = Hash.new
+    json["providers"].each do |provider|
+      metadata["providers"][provider["name"]] = provider.reject { |k, _| k == "name" }
+    end
+    metadata
+  end
+
+  def metadata_files
+    @metadata_files ||= compute_metadata_files
+  end
+
+  def compute_metadata_files
+    `ls builds/*.json`.split("\n")
+  end
+
+  def builds_yml
+    YAML.load(File.read("builds.yml"))
+  end
+
+  def build_list
+    bit32 = []
+    bit64 = []
+    builds_yml["public"].each do |platform, versions|
+      versions.each do |version, archs|
+        archs.each do |arch|
+          folder = case platform
+                   when "opensuse-leap"
+                     "opensuse"
+                   when "oracle"
+                     "oraclelinux"
+                   else
+                     platform
+                   end
+          case arch
+          when "i386"
+            bit32 << "#{folder}/#{platform}-#{version}-#{arch}"
+          else
+            bit64 << "#{folder}/#{platform}-#{version}-#{arch}"
+          end
+        end
+      end
+    end
+    bit64 + bit32
+  end
+
+  def private_box?(boxname)
+    proprietary_os_list = %w{macos windows sles solaris rhel}
+    proprietary_os_list.any? { |p| boxname.include?(p) }
+  end
+
+  def os_x?
+    !!(RUBY_PLATFORM =~ /darwin/)
+  end
+
+  def unix?
+    !windows?
+  end
+
+  def windows?
+    !!(RUBY_PLATFORM =~ /mswin|mingw|windows/)
+  end
+end

data/lib/bento/delete.rb

@@ -0,0 +1,22 @@
+require "bento/common"
+
+class DeleteRunner
+  include Common
+
+  attr_reader :box, :version
+
+  def initialize(opts)
+    @box = opts.box
+    @version = opts.version
+  end
+
+  def start
+    banner("Starting Delete...")
+    time = Benchmark.measure do
+      box = vc_account.get_box(box)
+      version = box.get_version(version)
+      version.delete
+    end
+    banner("Delete finished in #{duration(time.real)}.")
+  end
+end

data/lib/bento/normalize.rb

@@ -0,0 +1,82 @@
+require "bento/common"
+
+class NormalizeRunner
+  include Common
+  include PackerExec
+
+  attr_reader :templates, :build_timestamp, :debug, :override_version
+
+  def initialize(opts)
+    @templates = opts.template_files
+    @debug = opts.debug
+    @modified = []
+    @build_timestamp = Time.now.gmtime.strftime("%Y%m%d%H%M%S")
+  end
+
+  def start
+    banner("Normalizing for templates:")
+    templates.each { |t| puts "- #{t}" }
+    time = Benchmark.measure do
+      templates.each do |file|
+        dir, template = file.split("/")[0], file.split("/")[1]
+        Dir.chdir dir
+        validate(template)
+        Dir.chdir("..")
+      end
+    end
+    if !@modified.empty?
+      info("")
+      info("The following templates were modified:")
+      @modified.sort.each { |template| info("  * #{template}") }
+    end
+    banner("Normalizing finished in #{duration(time.real)}.")
+  end
+
+  private
+
+  def checksum(file)
+    Digest::MD5.file(file).hexdigest
+  end
+
+  def fix(template)
+    file = "#{template}.json"
+
+    banner("[#{template}] Fixing")
+    original_checksum = checksum(file)
+    output = `packer fix #{file}`
+    raise "[#{template}] Error fixing, exited #{$?}" if $?.exitstatus != 0
+    # preserve ampersands in shell commands,
+    # see: https://github.com/mitchellh/packer/issues/784
+    output.gsub!("\\u0026", "&")
+    File.open(file, "wb") { |dest| dest.write(output) }
+    fixed_checksum = checksum(file)
+
+    if original_checksum == fixed_checksum
+      puts("No changes made.")
+    else
+      warn("Template #{template} has been modified.")
+      @modified << template
+    end
+  end
+
+  def packer_validate_cmd(template, var_file)
+    vars = "#{template}.variables.json"
+    cmd = %W{packer validate -var-file=#{var_file} #{template}.json}
+    cmd.insert(2, "-var-file=#{vars}") if File.exist?(vars)
+    cmd
+  end
+
+  def validate(template)
+    for_packer_run_with(template) do |md_file, var_file|
+      cmd = packer_validate_cmd(template, var_file.path)
+      banner("[#{template}] Validating: '#{cmd.join(' ')}'")
+      if debug
+        banner("[#{template}] DEBUG: var_file(#{var_file.path}) is:")
+        puts IO.read(var_file.path)
+        banner("[#{template}] DEBUG: md_file(#{md_file.path}) is:")
+        puts IO.read(md_file.path)
+      end
+      system(*cmd) || raise( "[#{template}] Error validating, exited #{$?}")
+    end
+  end
+end

data/lib/bento/packerexec.rb

@@ -0,0 +1,31 @@
+
+module PackerExec
+  def for_packer_run_with(template)
+    Tempfile.open("#{template}-metadata.json") do |md_file|
+      Tempfile.open("#{template}-metadata-var-file") do |var_file|
+        write_box_metadata(template, md_file)
+        write_var_file(template, md_file, var_file)
+        yield md_file, var_file
+      end
+    end
+  end
+
+  def write_box_metadata(template, io)
+    md = BuildMetadata.new(template, build_timestamp, override_version).read
+    io.write(JSON.pretty_generate(md))
+    io.close
+  end
+
+  def write_var_file(template, md_file, io)
+    md = BuildMetadata.new(template, build_timestamp, override_version).read
+
+    io.write(JSON.pretty_generate({
+      box_basename:     md[:box_basename],
+      build_timestamp:  md[:build_timestamp],
+      git_revision:     md[:git_revision],
+      metadata:         md_file.path,
+      version:          md[:version],
+    }))
+    io.close
+  end
+end

data/lib/bento/providermetadata.rb

@@ -0,0 +1,84 @@
+require "digest"
+require "bento/common"
+
+class ProviderMetadata
+  include Common
+
+  def initialize(path, box_basename)
+    @base = File.join(path, box_basename)
+  end
+
+  def read
+    Dir.glob("#{base}.*.box").map do |file|
+      {
+        name: provider_from_file(file),
+        version: version(provider_from_file(file)),
+        file: "#{File.basename(file)}",
+        checksum_type: "sha256",
+        checksum: shasum(file),
+        size: "#{size_in_mb(file)} MB",
+      }
+    end
+  end
+
+  private
+
+  attr_reader :base
+
+  def provider_from_file(file)
+    provider = file.sub(/^.*\.([^.]+)\.box$/, '\1')
+    if provider == "vmware"
+      "vmware_desktop"
+    else
+      provider
+    end
+  end
+
+  def shasum(file)
+    Digest::SHA256.file(file).hexdigest
+  end
+
+  def size_in_mb(file)
+    size = File.size(file)
+    size_mb = size / MEGABYTE
+    size_mb.ceil.to_s
+  end
+
+  def version(provider)
+    case provider
+    when /vmware/
+      ver_vmware
+    when /virtualbox/
+      ver_vbox
+    when /parallels/
+      ver_parallels
+    end
+  end
+
+  def ver_vmware
+    if os_x?
+      path = File.join('/Applications/VMware\ Fusion.app/Contents/Library')
+      fusion_cmd = File.join(path, "vmware-vmx -v")
+      cmd = Mixlib::ShellOut.new(fusion_cmd)
+      cmd.run_command
+      cmd.stderr.split(" ")[5]
+    else
+      cmd = Mixlib::ShellOut.new("vmware --version")
+      cmd.run_command
+      cmd.stdout.split(" ")[2]
+    end
+  end
+
+  def ver_parallels
+    raise "Platform is not macOS / OS X, exiting..." unless os_x?
+    cmd = Mixlib::ShellOut.new("prlctl --version")
+    cmd.run_command
+    cmd.stdout.split(" ")[2]
+  end
+
+  def ver_vbox
+    cmd = Mixlib::ShellOut.new("VBoxManage --version")
+    cmd.run_command
+    cmd.stdout.split("r")[0]
+  end
+end

data/lib/bento/release.rb

@@ -0,0 +1,22 @@
+require "bento/common"
+
+class ReleaseRunner
+  include Common
+
+  attr_reader :box, :version
+
+  def initialize(opts)
+    @box = opts.box
+    @version = opts.version
+  end
+
+  def start
+    banner("Releasing #{box}/#{version}...")
+    time = Benchmark.measure do
+      b = vc_account.get_box(box)
+      v = b.get_version(version)
+      v.release
+    end
+    banner("Release finished in #{duration(time.real)}.")
+  end
+end

data/lib/bento/revoke.rb

@@ -0,0 +1,22 @@
+require "bento/common"
+
+class RevokeRunner
+  include Common
+
+  attr_reader :box, :version
+
+  def initialize(opts)
+    @box = opts.box
+    @version = opts.version
+  end
+
+  def start
+    banner("Revoking #{box}/#{version}...")
+    time = Benchmark.measure do
+      box = vc_account.get_box(box)
+      version = box.get_version(version)
+      version.revoke
+    end
+    banner("Revoke finished in #{duration(time.real)}.")
+  end
+end

data/lib/bento/test.rb

@@ -0,0 +1,60 @@
+require "bento/common"
+require "mixlib/shellout"
+require "erb"
+
+class TestRunner
+  include Common
+
+  attr_reader :shared_folder, :boxname, :provider, :box_url, :no_shared, :provisioner
+
+  def initialize(opts)
+    @debug = opts.debug
+    @no_shared = opts.no_shared
+    @provisioner = opts.provisioner.nil? ? "shell" : opts.provisioner
+  end
+
+  def start
+    banner("Starting testing...")
+    time = Benchmark.measure do
+      metadata_files.each do |metadata_file|
+        destroy_all_bento
+        test_box(metadata_file)
+        destroy_all_bento
+      end
+    end
+    banner("Testing finished in #{duration(time.real)}.")
+  end
+
+  private
+
+  def destroy_all_bento
+    cmd = Mixlib::ShellOut.new("vagrant box list | grep 'bento-'")
+    cmd.run_command
+    boxes = cmd.stdout.split("\n")
+
+    boxes.each do |box|
+      b = box.split(" ")
+      rm_cmd = Mixlib::ShellOut.new("vagrant box remove --force #{b[0]} --provider #{b[1].to_s.gsub(/(,|\()/, '')}")
+      banner("Removing #{b[0]} for provider #{b[1].to_s.gsub(/(,|\()/, '')}")
+      rm_cmd.run_command
+    end
+  end
+
+  def test_box(md_json)
+    md = box_metadata(md_json)
+    @boxname = md["name"]
+    @providers = md["providers"]
+    @share_disabled = no_shared || /(bsd|opensuse)/.match(boxname) ? true : false
+
+    dir = "#{File.expand_path("../../", File.dirname(__FILE__))}/templates"
+    %w{.kitchen.yml bootstrap.sh}.each do |file|
+      t = file =~ /kitchen/ ? "kitchen.yml.erb" : "#{file}.erb"
+      erb = ERB.new(File.read(dir + "/#{t}"), nil, "-").result(binding)
+      File.open(file, "w") { |f| f.puts erb }
+    end
+
+    test = Mixlib::ShellOut.new("kitchen test", :timeout => 900, live_stream: STDOUT)
+    test.run_command
+    test.error!
+  end
+end

data/lib/bento/upload.rb

@@ -0,0 +1,47 @@
+require "bento/common"
+
+class UploadRunner
+  include Common
+
+  attr_reader :md_json
+
+  def initialize(opts)
+    @md_json = opts.md_json
+  end
+
+  def start
+    banner("Starting uploads...")
+    time = Benchmark.measure do
+      files = md_json ? [md_json] : metadata_files
+      files.each do |md_file|
+        upload(md_file)
+      end
+    end
+    banner("Uploads finished in #{duration(time.real)}.")
+  end
+
+  def upload(md_file)
+    md = box_metadata(md_file)
+    box_desc = "a bento box for #{md['name']}"
+    box = vc_account.ensure_box(md["name"], box_desc, private_box?(md["name"]))
+    box_ver = box.ensure_version(md["version"], File.read(md_file))
+
+    if builds_yml["slugs"].values.include?(box.name)
+      slug_desc = "a bento box for #{builds_yml['slugs'].key(box.name)}"
+      slug = vc_account.ensure_box(builds_yml["slugs"].key(box.name), slug_desc, false)
+      slug_ver = slug.ensure_version(md["version"], File.read(md_file))
+    end
+
+    md["providers"].each do |k, v|
+      provider = box_ver.ensure_provider(k, nil)
+      banner("Uploading #{box.name}/#{box_ver.version}/#{provider.name}...")
+      provider.upload_file("builds/#{v['file']}")
+      banner("#{provider.download_url}")
+      next unless builds_yml["slugs"].values.include?(box.name)
+      slug_provider = slug_ver.ensure_provider(k, nil)
+      banner("Uploading #{slug.name}/#{slug_ver.version}/#{slug_provider.name}...")
+      slug_provider.upload_file("builds/#{v['file']}")
+      banner("#{slug_provider.download_url}")
+    end
+  end
+end