bento-ya 0.0.1

data/lib/bento/delete.rb

@@ -0,0 +1,38 @@
+require 'bento/common'
+require 'bento/httpstuff'
+
+class DeleteRunner
+  include Common
+  include HttpStuff
+
+  attr_reader :boxname, :version
+
+  def initialize(opts)
+    @boxname = opts.box
+    @version = opts.version
+  end
+
+  def start
+    banner("Starting Delete...")
+    time = Benchmark.measure do
+      delete_version(boxname, version)
+    end
+    banner("Delete finished in #{duration(time.real)}.")
+  end
+
+  private
+
+  def delete_version(boxname, version)
+    banner("Deleting version #{version} of box #{boxname}")
+    req = request('delete', "#{atlas_api}/box/#{atlas_org}/#{boxname}/version/#{version}", { 'access_token' => atlas_token }, { 'Content-Type' => 'application/json' })
+
+    case req.code
+    when '200'
+      banner("Version #{version} of box #{boxname} has been successfully deleted")
+    when '404'
+      warn("No box exists for this version")
+    else
+      warn("Something went wrong #{req.code}")
+    end
+  end
+end

data/lib/bento/httpstuff.rb

@@ -0,0 +1,73 @@
+require 'net/http'
+
+module HttpStuff
+
+  def class_for_request(verb)
+    Net::HTTP.const_get(verb.to_s.capitalize)
+  end
+
+  def build_uri(verb, path, params = {})
+    if %w(delete, get).include?(verb)
+      path = [path, to_query_string(params)].compact.join('?')
+    end
+
+    # Parse the URI
+    uri = URI.parse(path)
+
+    # Don't merge absolute URLs
+    uri = URI.parse(File.join(endpoint, path)) unless uri.absolute?
+
+    # Return the URI object
+    uri
+  end
+
+  def to_query_string(hash)
+    hash.map do |key, value|
+      "#{CGI.escape(key)}=#{CGI.escape(value)}"
+    end.join('&')[/.+/]
+  end
+
+  def request(verb, url, data = {}, headers = {})
+    uri = build_uri(verb, url, data)
+
+    # Build the request.
+    request = class_for_request(verb).new(uri.request_uri)
+    if %w(patch post put delete).include?(verb)
+      if data.respond_to?(:read)
+        request.content_length = data.size
+        request.body_stream = data
+      elsif data.is_a?(Hash)
+        request.form_data = data
+      else
+        request.body = data
+      end
+    end
+
+    # Add headers
+    headers.each do |key, value|
+      request.add_field(key, value)
+    end
+
+    connection = Net::HTTP.new(uri.host, uri.port)
+
+    if uri.scheme == 'https'
+      require 'net/https' unless defined?(Net::HTTPS)
+
+      # Turn on SSL
+      connection.use_ssl = true
+      connection.verify_mode = OpenSSL::SSL::VERIFY_PEER
+    end
+
+    connection.start do |http|
+      response = http.request(request)
+
+      case response
+      when Net::HTTPRedirection
+        redirect = URI.parse(response['location'])
+        request(verb, redirect, data, headers)
+      else
+        response
+      end
+    end
+  end
+end

data/lib/bento/normalize.rb

@@ -0,0 +1,81 @@
+require 'bento/common'
+require 'mixlib/shellout'
+
+class NormalizeRunner
+
+  include Common
+  include PackerExec
+
+  attr_reader :templates, :build_timestamp, :debug, :override_version
+
+  def initialize(opts)
+    @templates = opts.templates
+    @debug = opts.debug
+    @modified = []
+    @build_timestamp = Time.now.gmtime.strftime("%Y%m%d%H%M%S")
+  end
+
+  def start
+    banner("Normalizing for templates: #{templates}")
+    time = Benchmark.measure do
+      templates.each do |template|
+        validate(template)
+        fix(template)
+      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 = %x{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) or 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)
+        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,41 @@
+require 'digest'
+
+class ProviderMetadata
+
+  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),
+        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)
+    case provider = file.sub(/^.*\.([^.]+)\.box$/, '\1')
+    when /vmware/i then "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
+end

data/lib/bento/release.rb

@@ -0,0 +1,46 @@
+require 'bento/common'
+require 'mixlib/shellout'
+
+class ReleaseRunner
+  include Common
+  include HttpStuff
+
+  attr_reader :boxname, :version
+
+  def initialize(opts)
+    @boxname = opts.box
+    @version = opts.version
+  end
+
+  def start
+    banner("Starting Release...")
+    time = Benchmark.measure do
+      release_version(boxname, version)
+    end
+    banner("Release finished in #{duration(time.real)}.")
+  end
+
+  private
+
+  def release_version(boxname, version)
+    case status(boxname, version)
+    when 'unreleased'
+      banner("Releasing version #{version} of box #{boxname}")
+      req = request('put', "#{atlas_api}/box/#{atlas_org}/#{boxname}/version/#{version}/release", { 'access_token' => atlas_token }, { 'Content-Type' => 'application/json' })
+      if req.code == '200'
+        banner("Version #{version} of box #{boxname} has been successfully released")
+      else
+        warn("Something went wrong #{req.code}")
+      end
+    when 'active'
+      banner("Version #{version} of box #{boxname} has already been released - nothing to do")
+    else
+      warn("Unexpected status retrieved from Atlas")
+    end
+  end
+
+  def status(boxname, version)
+    req = request('get', "#{atlas_api}/box/#{atlas_org}/#{boxname}/version/#{version}", { 'access_token' => atlas_token }, { 'Content-Type' => 'application/json' })
+    status = JSON.parse(req.body)['status']
+  end
+end

data/lib/bento/revoke.rb

@@ -0,0 +1,34 @@
+require 'bento/common'
+require 'mixlib/shellout'
+
+class RevokeRunner
+  include Common
+  include HttpStuff
+
+  attr_reader :boxname, :version
+
+  def initialize(opts)
+    @boxname = opts.box
+    @version = opts.version
+  end
+
+  def start
+    banner("Starting Revoke...")
+    time = Benchmark.measure do
+      revoke_version(boxname, version)
+    end
+    banner("Revoke finished in #{duration(time.real)}.")
+  end
+
+  private
+
+  def revoke_version(boxname, version)
+    banner("Revoking version #{version} of box #{boxname}")
+    req = request('put', "#{atlas_api}/box/#{atlas_org}/#{boxname}/version/#{version}/revoke", { 'access_token' => atlas_token }, { 'Content-Type' => 'application/json' })
+    if req.code == '200'
+      banner("Version #{version} of box #{boxname} has been successfully revoked")
+    else
+      banner("Something went wrong #{req.code}")
+    end
+  end
+end

data/lib/bento/test.rb

@@ -0,0 +1,71 @@
+require 'bento/common'
+require 'kitchen'
+
+class TestRunner
+  include Common
+
+  attr_reader :shared_folder, :boxname, :provider, :box_url, :share_disabled, :provisioner
+
+  def initialize(opts)
+    @debug = opts.debug
+    @shared_folder = opts.shared_folder
+    @provisioner = opts.provisioner.nil? ? "shell" : opts.provisioner
+  end
+
+  def start
+    banner("Starting testing...")
+    time = Benchmark.measure do
+      metadata_files.each do |metadata_file|
+        m = box_metadata(metadata_file)
+        destroy_all_bento
+        test_box(m['name'], m['providers'])
+        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(boxname, providers)
+    providers.each do |provider, provider_data|
+
+      if provider == 'vmware_desktop'
+        case RUBY_PLATFORM
+        when /darwin/
+          provider = 'vmware_fusion'
+        when /linux/
+          provider = 'vmware_workstation'
+        end
+      end
+
+      @boxname = boxname
+      @provider = provider
+      @share_disabled = shared_folder ? false : true
+      @box_url = "file://#{ENV['PWD']}/builds/#{provider_data['file']}"
+
+      kitchen_cfg = ERB.new(File.read('.kitchen.yml.erb'), nil, '-').result(binding)
+      File.open(".kitchen.#{provider}.yml", "w") { |f| f.puts kitchen_cfg }
+
+      Kitchen.logger = Kitchen.default_file_logger
+      @loader = Kitchen::Loader::YAML.new(project_config: "./.kitchen.#{provider}.yml")
+      config = Kitchen::Config.new(loader: @loader)
+      config.instances.each do |instance|
+        instance.test(:always)
+      end
+    end
+  end
+end

data/lib/bento/upload.rb

@@ -0,0 +1,118 @@
+require 'aws-sdk'
+require 'bento/common'
+
+class UploadRunner
+  include Common
+  include HttpStuff
+
+  attr_reader :templates
+
+  def initialize(opts)
+    @templates = opts.templates
+  end
+
+  def start
+    banner("Starting uploads...")
+    time = Benchmark.measure do
+      metadata_files.each do |file|
+        md = box_metadata(file)
+        create_box(md['name'])
+        create_box_version(md['name'], md['version'], file)
+        create_providers(md['name'], md['version'], md['providers'].keys)
+        upload_to_atlas(md['name'], md['version'], md['providers'])
+        #upload_to_s3(md['name'], md['version'], md['providers'])
+      end
+    end
+    banner("Atlas uploads finished in #{duration(time.real)}.")
+  end
+
+  private
+
+  def create_box(boxname)
+    req = request('get', "#{atlas_api}/box/#{atlas_org}/#{boxname}", { 'box[username]' => atlas_org, 'access_token' => atlas_token } )
+    if req.code.eql?('404')
+      if private_box?(boxname)
+        banner("Creating the private box #{boxname} in Atlas.")
+        req = request('post', "#{atlas_api}/boxes", { 'box[name]' => boxname, 'box[username]' => atlas_org, 'access_token' => atlas_token }, { 'Content-Type' => 'application/json' } )
+      else
+        banner("Creating the box #{boxname} in Atlas.")
+        req = request('post', "#{atlas_api}/boxes", { 'box[name]' => boxname, 'box[username]' => atlas_org, 'access_token' => atlas_token }, { 'Content-Type' => 'application/json' } )
+        make_public(boxname)
+      end
+    else
+      banner("The box #{boxname} exists in Atlas, continuing...")
+    end
+  end
+
+  def make_public(boxname)
+    banner("Making #{boxname} public")
+    req = request('put', "#{atlas_api}/box/#{atlas_org}/#{boxname}", { 'box[is_private]' => false, 'access_token' => atlas_token }, { 'Content-Type' => 'application/json' } )
+    banner("#{boxname} successfully made public") if req.code == '200'
+  end
+
+  def create_box_version(boxname, version, md_json)
+		payload = { 
+	  	'version[version]' => version,
+	  	'access_token' => atlas_token,
+		'version[description]' => File.read(md_json)
+		}
+    req = request('post', "#{atlas_api}/box/#{atlas_org}/#{boxname}/versions", payload, { 'Content-Type' => 'application/json' } ) 
+
+    banner("Created box version #{boxname} #{version}.") if req.code == '200'
+    banner("Box version #{boxname} #{version} already exists, continuing.") if req.code == '422'
+  end
+
+  def create_providers(boxname, version, provider_names)
+    provider_names.each do |provider|
+      banner("Creating provider #{provider} for #{boxname} #{version}")
+      req = request('post', "#{atlas_api}/box/#{atlas_org}/#{boxname}/version/#{version}/providers", { 'provider[name]' => provider, 'access_token' => atlas_token }, { 'Content-Type' => 'application/json' }  )
+      banner("Created #{provider} for #{boxname} #{version}") if req.code == '200'
+      banner("Provider #{provider} for #{boxname} #{version} already exists, continuing.") if req.code == '422'
+    end
+  end
+
+  def upload_to_atlas(boxname, version, providers)
+    providers.each do |provider, provider_data|
+      boxfile = provider_data['file']
+      req = request('get', "#{atlas_api}/box/#{atlas_org}/#{boxname}/version/#{version}/provider/#{provider}/upload?access_token=#{atlas_token}")
+      upload_path = JSON.parse(req.body)['upload_path']
+      token = JSON.parse(req.body)['token']
+
+      banner("Atlas: Uploading #{boxfile}")
+      info("Name: #{boxname}")
+      info("Version: #{version}")
+      info("Provider: #{provider}")
+      info("Upload Path: #{upload_path}")
+      upload_request = request('put', upload_path, File.open("builds/#{boxfile}"))
+
+      req = request('get', "#{atlas_api}/box/#{atlas_org}/#{boxname}/version/#{version}/provider/#{provider}?access_token=#{atlas_token}")
+      hosted_token = JSON.parse(req.body)['hosted_token']
+
+      if token == hosted_token
+        banner("Successful upload of box #{boxfile}")
+      else
+        banner("Failed upload due to non-matching tokens of box #{boxfile} to atlas box: #{boxname}, version: #{version}, provider: #{provider}")
+        warn("Code: #{req.code}")
+        warn("Body: #{req.body}")
+      end
+    end
+
+    def upload_to_s3(boxname, version, providers)
+      providers.each do |provider, provider_data|
+        boxfile = provider_data['file']
+        provider = 'vmware' if provider == 'vmware_desktop'
+        box_path = "vagrant/#{provider}/opscode_#{boxname}_chef-provisionerless.box"
+        credentials = Aws::Credentials.new(ENV['AWS_ACCESS_KEY_ID'], ENV['AWS_SECRET_ACCESS_KEY'])
+
+        s3 = Aws::S3::Resource.new(credentials: credentials, endpoint: s3_endpoint)
+        banner("S3: Uploading #{boxfile}")
+        info("Name: #{boxname}")
+        info("Version: #{version}")
+        info("Provider: #{provider}")
+        s3_object = s3.bucket(s3_bucket).object(box_path)
+        s3_object.upload_file("builds/#{boxfile}", acl:'public-read')
+        banner("Upload Path: #{s3_object.public_url}")
+      end
+    end
+  end
+end