bento-lpn 1.1.3

data/Rakefile

@@ -0,0 +1,22 @@
+require "bundler/gem_tasks"
+
+begin
+  require "rspec/core/rake_task"
+
+  RSpec::Core::RakeTask.new do |t|
+    t.pattern = "spec/**/*_spec.rb"
+  end
+rescue LoadError
+  desc "rspec is not installed, this task is disabled"
+  task :spec do
+    abort "rspec is not installed. `(sudo) gem install rspec` to run unit tests"
+  end
+end
+
+task :default => :spec
+
+require "chefstyle"
+require "rubocop/rake_task"
+RuboCop::RakeTask.new(:style) do |task|
+  task.options += ["--display-cop-names", "--no-color"]
+end

data/bento-lpn.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.unshift File.expand_path("../lib", __FILE__)
+require "bento/version"
+require "English"
+
+Gem::Specification.new do |gem|
+  gem.name          = "bento-lpn"
+  gem.version       = Bento::VERSION
+  gem.license       = "Apache-2.0"
+  gem.authors       = ["Stephan Linz"]
+  gem.email         = ["linz@li-pro.net"]
+  gem.description   = "bento-lpn (fork of bento-ya) builds bento boxes"
+  gem.summary       = "A RubyGem for managing chef/bento builds"
+  gem.homepage      = "https://github.com/rexut/bento-lpn"
+
+  gem.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
+  gem.bindir        = "bin"
+  gem.executables   = %w{bento}
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.required_ruby_version = ">= 2.3.1"
+
+  gem.add_dependency "mixlib-shellout", ">= 2.3.2"
+  gem.add_dependency "vagrant_cloud", "~> 1.0"
+end

data/bin/bento

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+# -*- encoding: utf-8 -*-
+
+Signal.trap("INT") { exit 1 }
+
+$stdout.sync = true
+$stderr.sync = true
+
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), %w{.. lib})
+require "bento/cli"
+
+begin
+  Runner.new(Options.parse(ARGV)).start
+rescue => ex
+  $stderr.puts ">>> #{ex.message}"
+  exit(($? && $?.exitstatus) || 99)
+end

data/lib/bento.rb

@@ -0,0 +1,2 @@
+require "bento/common"
+require "bento/version"

data/lib/bento/build.rb

@@ -0,0 +1,95 @@
+require "bento/common"
+require "bento/buildmetadata"
+require "bento/providermetadata"
+require "bento/packerexec"
+
+class BuildRunner
+  include Common
+  include PackerExec
+
+  attr_reader :template_files, :config, :dry_run, :debug, :only, :except, :mirror, :headed, :single,
+              :override_version, :build_timestamp, :cpus, :mem
+
+  def initialize(opts)
+    @template_files = opts.template_files
+    @config = opts.config ||= false
+    @dry_run = opts.dry_run
+    @debug = opts.debug
+    @only = opts.only ||= "parallels-iso,virtualbox-iso,vmware-iso"
+    @except = opts.except
+    @mirror = opts.mirror
+    @headed = opts.headed ||= false
+    @single = opts.single ||= false
+    @override_version = opts.override_version
+    @build_timestamp = Time.now.gmtime.strftime("%Y%m%d%H%M%S")
+    @cpus = opts.cpus
+    @mem = opts.mem
+  end
+
+  def start
+    templates = config ? build_list : template_files
+    banner("Starting build for templates:")
+    templates.each { |t| puts "- #{t}" }
+    time = Benchmark.measure do
+      templates.each { |template| build(template) }
+    end
+    banner("Build finished in #{duration(time.real)}.")
+  end
+
+  private
+
+  def build(file)
+    dir, template = file.split("/")[0], file.split("/")[1]
+    Dir.chdir dir
+    for_packer_run_with(template) do |md_file, var_file|
+      cmd = packer_build_cmd(template, md_file.path)
+      banner("[#{template}] Building: '#{cmd.join(' ')}'")
+      time = Benchmark.measure do
+        system(*cmd) || raise("[#{template}] Error building, exited #{$?}")
+      end
+      write_final_metadata(template, time.real.ceil)
+      banner("[#{template}] Finished building in #{duration(time.real)}.")
+    end
+    Dir.chdir("..")
+  end
+
+  def packer_build_cmd(template, var_file)
+    vars = "#{template}.variables.json"
+    cmd = %W{packer build -var-file=#{var_file} #{template}.json}
+    cmd.insert(2, "-var-file=#{vars}") if File.exist?(vars)
+    cmd.insert(2, "-only=#{only}")
+    cmd.insert(2, "-except=#{except}") if except
+    # Build the command line in the correct order and without spaces as future input for the splat operator.
+    cmd.insert(2, "cpus=#{cpus}") if cpus
+    cmd.insert(2, "-var") if cpus
+    cmd.insert(2, "memory=#{mem}") if mem
+    cmd.insert(2, "-var") if mem
+    cmd.insert(2, "mirror=#{mirror}") if mirror
+    cmd.insert(2, "-var") if mirror
+    cmd.insert(2, "headless=true") unless headed
+    cmd.insert(2, "-var") unless headed
+    cmd.insert(2, "-parallel=false") if single
+    cmd.insert(2, "-debug") if debug
+    cmd.insert(0, "echo") if dry_run
+    cmd
+  end
+
+  def write_final_metadata(template, buildtime)
+    md = BuildMetadata.new(template, build_timestamp, override_version).read
+    path = File.join("../builds")
+    filename = File.join(path, "#{md[:box_basename]}.metadata.json")
+    md[:providers] = ProviderMetadata.new(path, md[:box_basename]).read
+    md[:providers].each do |p|
+      p[:build_time] = buildtime
+      p[:build_cpus] = cpus unless cpus.nil?
+      p[:build_mem] = mem unless mem.nil?
+    end
+
+    if dry_run
+      banner("(Dry run) Metadata file contents would be something similar to:")
+      puts JSON.pretty_generate(md)
+    else
+      File.open(filename, "wb") { |file| file.write(JSON.pretty_generate(md)) }
+    end
+  end
+end

data/lib/bento/buildmetadata.rb

@@ -0,0 +1,87 @@
+require "bento/common"
+require "mixlib/shellout"
+
+class BuildMetadata
+  include Common
+
+  def initialize(template, build_timestamp, override_version)
+    @template = template
+    @build_timestamp = build_timestamp
+    @override_version = override_version
+  end
+
+  def read
+    {
+      name:             name,
+      version:          version,
+      build_timestamp:  build_timestamp,
+      git_revision:     git_revision,
+      git_status:       git_clean? ? "clean" : "dirty",
+      box_basename:     box_basename,
+      template:         template_vars.fetch("template", UNKNOWN),
+      packer:           packer_ver,
+      vagrant:          vagrant_ver,
+    }
+  end
+
+  private
+
+  UNKNOWN = "__unknown__".freeze
+
+  attr_reader :template, :build_timestamp, :override_version
+
+  def box_basename
+    "#{name.gsub("/", "__")}-#{version}"
+  end
+
+  def git_revision
+    sha = `git rev-parse HEAD`.strip
+  end
+
+  def git_clean?
+    `git status --porcelain`.strip.empty?
+  end
+
+  def merged_vars
+    @merged_vars ||= begin
+      if File.exist?("#{template}.variables.json")
+        template_vars.merge(JSON.load(IO.read("#{template}.variables.json")))
+      else
+        template_vars
+      end
+    end
+  end
+
+  def name
+    merged_vars.fetch("name", template)
+  end
+
+  def template_vars
+    @template_vars ||= JSON.load(IO.read("#{template}.json")).fetch("variables")
+  end
+
+  def version
+    if override_version
+      override_version
+    else
+      merged_vars.fetch("version", "#{UNKNOWN}.TIMESTAMP").
+        rpartition(".").first.concat("#{build_timestamp}")
+    end
+  end
+
+  def packer_ver
+    cmd = Mixlib::ShellOut.new("packer --version")
+    cmd.run_command
+    cmd.stdout.split("\n")[0]
+  end
+
+  def vagrant_ver
+    if ENV["TRAVIS"]
+      "travis"
+    else
+      cmd = Mixlib::ShellOut.new("vagrant --version")
+      cmd.run_command
+      cmd.stdout.split(" ")[1]
+    end
+  end
+end

data/lib/bento/cli.rb

@@ -0,0 +1,227 @@
+require "optparse"
+require "ostruct"
+
+require "bento/common"
+require "bento/build"
+require "bento/delete"
+require "bento/normalize"
+require "bento/release"
+require "bento/revoke"
+require "bento/test"
+require "bento/upload"
+
+class Options
+  NAME = File.basename($0).freeze
+
+  def self.parse(args)
+    options = OpenStruct.new
+    options.template_files = calculate_templates("**/*.json")
+
+    global = OptionParser.new do |opts|
+      opts.banner = "Usage: #{NAME} [SUBCOMMAND [options]]"
+      opts.separator ""
+      opts.separator <<-COMMANDS.gsub(/^ {8}/, "")
+        build        :   build one or more templates
+        help         :   prints this help message
+        list         :   list all templates in project
+        normalize    :   normalize one or more templates
+        test         :   test one or more builds with kitchen
+        upload       :   upload one or more builds to Atlas and S3
+        release      :   release a version of a box on Atlas
+        revoke       :   revoke a version of a box on Atlas
+        delete       :   delete a version of a box from Atlas
+      COMMANDS
+    end
+
+    platforms_argv_proc = proc { |options|
+      options.platforms = builds["public"] unless args.empty?
+    }
+
+    templates_argv_proc = proc { |options|
+      options.template_files = calculate_templates(args) unless args.empty?
+
+      options.template_files.each do |t|
+        if !File.exists?("#{t}.json")
+          $stderr.puts "File #{t}.json does not exist for template '#{t}'"
+          exit(1)
+        end
+      end
+    }
+
+    box_version_argv_proc = proc { |options|
+      options.box = ARGV[0]
+      options.version = ARGV[1]
+    }
+
+    md_json_argv_proc = proc { |options|
+      options.md_json = ARGV[0]
+    }
+
+    subcommand = {
+      help: {
+        parser: OptionParser.new {},
+        argv: proc { |options|
+          puts global
+          exit(0)
+        },
+      },
+      build: {
+        class: BuildRunner,
+        parser: OptionParser.new do |opts|
+          opts.banner = "Usage: #{NAME} build [options] TEMPLATE[ TEMPLATE ...]"
+
+          opts.on("-n", "--dry-run", "Dry run (what would happen)") do |opt|
+            options.dry_run = opt
+          end
+
+          opts.on("-c BUILD_YML", "--config BUILD_YML", "Use a configuration file") do |opt|
+            options.config = opt
+          end
+
+          opts.on("-d", "--[no-]debug", "Run packer with debug output") do |opt|
+            options.debug = opt
+          end
+
+          opts.on("-o BUILDS", "--only BUILDS", "Only build some Packer builds") do |opt|
+            options.only = opt
+          end
+
+          opts.on("-e BUILDS", "--except BUILDS", "Build all Packer builds except these") do |opt|
+            options.except = opt
+          end
+
+          opts.on("-m MIRROR", "--mirror MIRROR", "Look for isos at MIRROR") do |opt|
+            options.mirror = opt
+          end
+
+          opts.on("-C cpus", "--cpus CPUS", "# of CPUs per provider") do |opt|
+            options.cpus = opt
+          end
+
+          opts.on("-M MEMORY", "--memory MEMORY", "Memory (MB) per provider") do |opt|
+            options.mem = opt
+          end
+
+          opts.on("-H", "--headed", "Display provider UI windows") do |opt|
+            options.headed = opt
+          end
+
+          opts.on("-S", "--single", "Disable parallelization of Packer builds") do |opt|
+            options.single = opt
+          end
+
+          opts.on("-v VERSION", "--version VERSION", "Override the version set in the template") do |opt|
+            options.override_version = opt
+          end
+        end,
+        argv: templates_argv_proc,
+      },
+      list: {
+        class: ListRunner,
+        parser: OptionParser.new do |opts|
+          opts.banner = "Usage: #{NAME} list [TEMPLATE ...]"
+        end,
+        argv: templates_argv_proc,
+      },
+      normalize: {
+        class: NormalizeRunner,
+        parser: OptionParser.new do |opts|
+          opts.banner = "Usage: #{NAME} normalize TEMPLATE[ TEMPLATE ...]"
+
+          opts.on("-d", "--[no-]debug", "Run packer with debug output") do |opt|
+            options.debug = opt
+          end
+        end,
+        argv: templates_argv_proc,
+      },
+      test: {
+        class: TestRunner,
+        parser: OptionParser.new do |opts|
+          opts.banner = "Usage: #{NAME} test [options]"
+
+          opts.on("--no-shared-folder", "Disable shared folder testing") do |opt|
+            options.no_shared = opt
+          end
+
+          opts.on("-p", "--provisioner PROVISIONER", "Use a specfic provisioner") do |opt|
+            options.provisioner = opt
+          end
+        end,
+        argv: Proc.new {},
+      },
+      upload: {
+        class: UploadRunner,
+        parser: OptionParser.new do |opts|
+          opts.banner = "Usage: #{NAME} upload"
+        end,
+        argv: md_json_argv_proc,
+      },
+      release: {
+        class: ReleaseRunner,
+        parser: OptionParser.new do |opts|
+          opts.banner = "Usage: #{NAME} release BOX VERSION"
+        end,
+        argv: box_version_argv_proc,
+      },
+      revoke: {
+        class: RevokeRunner,
+        parser: OptionParser.new do |opts|
+          opts.banner = "Usage: #{NAME} revoke BOX VERSION"
+        end,
+        argv: box_version_argv_proc,
+      },
+      delete: {
+        class: DeleteRunner,
+        parser: OptionParser.new do |opts|
+          opts.banner = "Usage: #{NAME} delete BOX VERSION"
+        end,
+        argv: box_version_argv_proc,
+      },
+    }
+
+    global.order!
+    command = args.empty? ? :help : ARGV.shift.to_sym
+    subcommand.fetch(command).fetch(:parser).order!
+    subcommand.fetch(command).fetch(:argv).call(options)
+
+    options.command = command
+    options.klass = subcommand.fetch(command).fetch(:class)
+
+    options
+  end
+
+  def self.calculate_templates(globs)
+    Array(globs).
+      map { |glob| result = Dir.glob(glob); result.empty? ? glob : result }.
+      flatten.
+      sort.
+      delete_if { |file| file =~ /\.(variables||metadata)\.json/ }.
+      map { |template| template.sub(/\.json$/, "") }
+  end
+end
+
+class ListRunner
+  include Common
+
+  attr_reader :templates
+
+  def initialize(opts)
+    @templates = opts.templates
+  end
+
+  def start
+    templates.each { |template| puts template }
+  end
+end
+
+class Runner
+  attr_reader :options
+
+  def initialize(options)
+    @options = options
+  end
+
+  def start
+    options.klass.new(options).start
+  end
+end