Rakefile

require 'logger'
require 'rake'
require 'fileutils'
require 'json'
require 'socket'
require 'securerandom'
require 'benchmark'
require 'etc'
require 'erb'
require 'open3'
require 'ostruct'
require 'digest'
require 'rake/clean'
begin
  require 'rspec/core/rake_task'

  RSpec::Core::RakeTask.new
rescue LoadError
  #puts "Warning: Test Framework not loaded."
end


# An IO class to send logs to nowhere
class NullIO # {{{
  def write(*args) ; end
  def close        ; end
end # }}}

$logger = Logger.new(NullIO.new)

templates_dir  = 'templates'
boxes_dir      = 'boxes'
scripts_dir    = 'scripts'
log_dir        = 'log'
temp_dir       = 'tmp'
$cache_dir      = ENV['DAAS_CACHE'] || case RUBY_PLATFORM
  when 'x64-mingw32' then File.join(ENV['PROGRAMDATA'], 'DaaS', 'cache')
  else File.join('/var', 'cache', 'daas')
end
$cache_dir = $cache_dir.gsub(/\\/, '/')
TEMPLATE_FILES = Rake::FileList.new("#{templates_dir}/**/{packer.json}")

$box_aliases = {
  'centos-7'                          => [ 'centos' ],
  'windows-10-enterprise-eval'        => [ 'windows-10' ],
  'windows-8.1-enterprise-eval'       => [ 'windows-8.1' ],
  'windows-2012R2-core-standard-eval' => [ 'windows-2012R2-core' ],
  'windows-2012R2-full-standard-eval' => [ 'windows-2012R2-full', 'windows-2012R2', 'windows-2012r2' ],
}

# Tools {{{

def die(message, exit_code = 1) # {{{
  $logger.error message
  STDERR.puts message
  exit exit_code
end # }}}

def alias_task(alias_task, original_task) # {{{
  desc "Alias #{original_task}" if Rake::Task[original_task].full_comment
  task alias_task, *Rake.application[:original_task].arg_names, needs: original_task
end # }}}

def which(f) # {{{
  if RUBY_PLATFORM == 'x64-mingw32'
    path = ENV['PATH'].split(File::PATH_SEPARATOR).find do |p|
      ['.exe', '.bat', '.cmd', '.ps1'].find do |ext|
        File.exists? File.join(p,f + ext)
      end
    end
  else
    path = ENV['PATH'].split(File::PATH_SEPARATOR).find { |p| File.exist?(File.join(p,f)) }
  end
  return File.join(path, f) unless path.nil?
  nil
end # }}}

def shell(command, options={}) # {{{
  case RUBY_PLATFORM
    when 'x64-mingw32'
      stdin, stdout, stderr = Open3.popen3 "powershell.exe -NoLogo -NoProfile -ExecutionPolicy Bypass -Command \" #{command} \""
      stdin.close
      output = stdout.readlines.join.chomp
      error  = stderr.readlines.join.chomp
      raise error unless error.empty?
      return options[:json] ? JSON.parse(output, symbolize_names: true) : output
    else
      $logger.info "Executing: %x(#{command})"
      stdin, stdout, stderr, wait_thread = Open3.popen3 command
      $logger.info "  PID #{wait_thread[:pid]}: started"
      stdin.close
      output = stdout.readlines.join.chomp
      error  = stderr.readlines.join.chomp
      status = wait_thread.value
      $logger.debug "  PID #{wait_thread[:pid]}: ended. Status: success=#{status.success?}, exitstatus=#{status.exitstatus}, pid=#{status.pid}"
      unless status.success?
        $logger.error "PID #{status.pid}: exit status: #{status.exitstatus}"
        yield(status.exitstatus, error) if block_given?
      end
      return options[:json] ? JSON.parse(output, symbolize_names: true) : output
  end
end # }}}

def load_json(filename) # {{{
  $logger.debug "Checking JSON file: #{filename}"
  return {} unless File.exist? filename
  $logger.debug "Loading JSON file: #{filename}"
  return File.open(filename) { |file| JSON.parse(file.read) }
end # }}}

class Task # {{{
  def investigation # {{{
    return unless Rake.application.options.trace == true
    result = "------------------------------\n"
    result << "Investigating #{name}\n"
    result << "class: #{self.class}\n"
    result <<  "task needed: #{needed?}\n"
    result <<  "timestamp: #{timestamp}\n"
    result << "pre-requisites: \n"
    prereqs = @prerequisites.collect {|name| Task[name]}
    prereqs.sort! {|a,b| a.timestamp <=> b.timestamp}
    prereqs.each do |p|
      result << "--#{p.name} (#{p.timestamp})\n"
    end
    latest_prereq = @prerequisites.collect{|n| Task[n].timestamp}.max
    result <<  "latest-prerequisite time: #{latest_prereq}\n"
    result << "................................\n\n"
    return result
  end # }}}
end # }}}

class Binder # {{{
  def initialize(config = {}) # {{{
    self.class.class_eval { config.each {|key, value| define_method(key.to_sym){ value } } }
  end # }}}
  def get_binding ; binding() end
end # }}}

def sources_for_box(box_file, sources_root, scripts_root) # {{{
  # box_file should be like: #{boxes_dir}/#{box_name}_#{box_version}_#{provider}.box
  $logger.info "box file: #{box_file}"
  box_name     = box_file.pathmap("%{_.*,}n")
  box_provider = box_file.pathmap("%{.*_,}n")
  box_version  = box_file.pathmap("%{[^_]*_,;_.*,}n")
  $logger.info "  Finding sources for box: #{box_name} version #{box_version} with provider #{box_provider}"
  box_sources = Rake::FileList.new("#{sources_root}/#{box_name}/*")
  $logger.info "  ==> Box sources: #{box_sources.join(', ')}"
  raise Errno::ENOENT, box_file if box_sources.empty?
  current_builder = $builders.find { |builder| builder[1][:folder] == box_provider }
  raise ArgumentError, box_name if current_builder.nil?
  current_builder = current_builder[1]
  $logger.info "  Collecting scripts for #{current_builder[:name]}"
  box_scripts = []
  box_sources.each do |source|
    next unless source =~ /.*packer\.json$/
    $logger.info "Checking config file: #{source}"
    config = load_json(source)
    config['builders'].each do |packer_builder|
      $logger.debug "  Checking builder: #{packer_builder['type']}"
      next unless packer_builder['type'] == current_builder[:packer_type]
      $logger.debug "  Adding floppy scripts..."
      box_scripts += packer_builder['floppy_files'].find_all {|path| ['.cmd', '.ps1'].include? path.pathmap("%x") } if packer_builder['floppy_files']
    end
    config['provisioners'].each do |provisioner|
      # TODO: support 'only', and 'except' from the JSON data
      $logger.debug "  Checking provisioner: #{provisioner['type']}"
      case provisioner['type']
        when 'file'          then box_scripts << provisioner['source'].sub(/{{user `cache_dir`}}/, $cache_dir)
        when 'powershell', 'windows-shell', 'shell'
          box_scripts << provisioner['script'].sub(/{{user `cache_dir`}}/, $cache_dir)  if provisioner['script']
          box_scripts += provisioner['scripts'].collect {|script| script.sub(/{{user `cache_dir`}}/, $cache_dir)} if provisioner['scripts']
      end
    end
  end
  sources = box_sources + box_scripts
  missing = sources.reject { |source| File.exist? source }
  $logger.info "  Box sources ##{sources.size}: #{sources.join(', ')}"
  raise Errno::ENOENT, "\n  " + missing.join("\n  ") unless missing.empty?
  return sources
rescue Errno::ENOENT
  $logger.error "Missing sources: \n#{$!}.\nBacktrace: " + $!.backtrace.join("\n")
  STDERR.puts $!
  exit 1
rescue JSON::UnparserError
  $logger.error "JSON Format error in #{source}: #{$!}.\nBacktrace: " + $!.backtrace.join("\n")
  STDERR.puts "JSON Format error in #{source}:\n#{$!}"
  exit 1
end # }}}
# }}}

['packer'].each do |application|
  raise RuntimeError, "Program #{application} is not accessible via the command line" unless which(application)
end

$builders = builders = { # {{{
  hyperv: # {{{
  {
    name:           'hyperv',
    say:            'Hi-per V',
    folder:         'hyperv',
    vagrant_type:   'hyperv',
    packer_type:    'hyperv-iso',
    supported:      lambda {
      case RUBY_PLATFORM
        when 'x64-mingw32'
          shell("(Get-WindowsOptionalFeature -Online -FeatureName Microsoft-Hyper-V).State") == "Enabled"
        else false
      end
    },
    preclean:       lambda { |box_name|  },
    share_user:     'packer',
    share_password: SecureRandom.urlsafe_base64(9)
  }, # }}}
  qemu: # {{{
  {
    name:         'qemu',
    say:          'KVM',
    folder:       'qemu',
    vagrant_type: 'libvirt',
    packer_type:  'qemu',
    supported:    lambda { RUBY_PLATFORM == 'x86_64-linux' && which('kvm') },
    preclean:     lambda { |box_name|  }
  }, # }}}
  parallels: # {{{
  {
    name:         'parallels',
    say:          'Parallels Desktop',
    folder:       'parallels',
    vagrant_type: 'parallels',
    packer_type:  'parallels-iso',
    supported:    lambda { RUBY_PLATFORM =~ /.*darwin.*/ && which('prlctl') },
    preclean:     lambda { |box_name|
      tries = 3
      begin
        $logger.info "Checking if Parallels Desktop was initialized properly"
        shell('prlctl list') do |error_code, error|
          case error_code
            when 6 then raise RuntimeError, 'not initialized'
            else
              STDERR.puts "Error #{error_code} while checking Parallels Desktop"
              STDERR.puts error
              exit error_code
          end
        end
      rescue RuntimeError
        $logger.warn "Parallels Desktop is not initialized"
        puts "Initializing Parallels Desktop"
        shell('sudo "/Applications/Parallels Desktop.app/Contents/MacOS/inittool" init -b "/Applications/Parallels Desktop.app"') do |error_code, error|
          STDERR.puts "Error #{error_code} while checking Parallels Desktop"
          STDERR.puts error
          exit error_code
        end
        retry unless (tries -= 1).zero?
      end

      $logger.info "Checking if Virtual Machine packer-#{box_name} exists"
      shell("prlctl list --info --json \"packer-#{box_name}\"") do |error_code, error|
        case error_code
          when 255 then return # The VM was not found, no need to clean
          else
            STDERR.puts "Error #{error_code} while checking Virtual Machine packer-#{box_name}"
            STDERR.puts error
            exit error_code
        end
      end

      puts "Deleting Virtual Machine packer-#{box_name}"
      $logger.info "Deleting Virtual Machine packer-#{box_name}"
      shell("prlctl unregister \"packer-#{box_name}\"") do |error_code, error|
        STDERR.puts "Error #{error_code} while deleting Virtual Machine packer-#{box_name}"
        STDERR.puts error
        exit error_code
      end
    }
  }, # }}}
  virtualbox: # {{{
  {
    name:         'virtualbox',
    say:          'Virtual Box',
    folder:       'virtualbox',
    vagrant_type: 'virtualbox',
    packer_type:  'virtualbox-iso',
    supported:    lambda {
      case RUBY_PLATFORM
        when 'x64-mingw32'
          ENV['VBOX_MSI_INSTALL_PATH'] && File.exist?(File.join(ENV['VBOX_MSI_INSTALL_PATH'], 'VBoxManage.exe'))
        else which('VBoxManage')
      end
    },
    preclean:     lambda { |box_name|
      puts "Cleaning #{box_name}"
      case RUBY_PLATFORM
        when 'x64-mingw32'
          VBOXMGR=File.join(ENV['VBOX_MSI_INSTALL_PATH'], 'VBoxManage.exe')
        else
          VBOXMGR='VBoxManage'
      end
      begin
        shell "\"#{VBOXMGR}\" showvminfo \"packer-#{box_name}\" --machinereadable"
      rescue
        puts "  Deleting Virtual Machine in Virtualbox"
        begin
          shell "\"#{VBOXMGR}\" unregistervm \"packer-#{box_name}\" --delete"
        rescue
          STDERR.puts "Errors while deleting the Virtual Machine: #{$!}"
        end
      end

      vm_dir = nil
      begin
        stdout = shell "\"#{VBOXMGR}\" list systemproperties"
        stdout.each_line do |line|
          next unless line =~ /^Default machine folder/
          vm_dir = File.join(line.chomp.sub(/^[^:]+:\s+/, ''), "packer-#{box_name}")
          break
        end
      rescue
        STDERR.puts "Errors while querying Virtualbox configuration: #{$!}"
      end
      if !vm_dir.nil? && Dir.exist?(vm_dir)
        puts "  Deleting Virtual Machine folder"
        FileUtils.rm_rf vm_dir
      end
    }
  }, # }}}
  vmware: # {{{
  {
    name:         'vmware',
    say:          'VM ware',
    folder:       'vmware',
    vagrant_type: 'vmware_desktop',
    packer_type:  'vmware-iso',
    supported:    lambda {
      case RUBY_PLATFORM
        when 'x64-mingw32'
          File.exist?(File.join(ENV['ProgramFiles(x86)'], 'VMWare', 'VMWare Workstation', 'vmrun.exe'))
        else which('vmrun') || File.exist?('/Applications/VMware Fusion.app/Contents/Library/vmrun')
      end
    },
    preclean:     lambda { |box_name|  }
  }, # }}}
} # }}}

directory boxes_dir
directory temp_dir
directory log_dir
task :folders => [ boxes_dir, temp_dir, log_dir ]

# rule .md5 {{{
rule(/\.box\.md5$/ => proc {|task_name| task_name.sub(/\.box\.md5$/, '.box') }) do |_rule|
  puts "Calculating MD5 checksum for #{_rule.source.pathmap("%2d").pathmap("%f")}"
  chksum = Digest::MD5.file _rule.source
  puts "===> md5: #{chksum}"
  File.write _rule.name, chksum
end # }}}

# rule .box {{{
rule(/\.box$/ => [->(box) { sources_for_box(box, templates_dir, scripts_dir) }, boxes_dir, log_dir]) do |_rule|
  $logger.info "Executing rule: #{_rule}"
  verbose "Building: #{_rule}"
  box_filename  = _rule.name.pathmap("%f")
  box_name      = box_filename.pathmap("%{_.*,}n")
  box_provider  = box_filename.pathmap("%{.*_,}n")
  box_version   = box_filename.pathmap("%{[^_]*_,;_.*,}n") || '0.1.0'
  template_path = _rule.source.pathmap("%d")
  builder       = builders[box_provider.to_sym] || raise(ArgumentError, box_filename)
  $logger.debug "  builder: #{builder[:name]}, calling preclean"
  builder[:preclean].call(box_name)
  $logger.info "Building box #{box_name} version #{box_version} in #{box_filename} using #{builder[:name]}"
  puts "Building box #{box_name} version #{box_version} in #{box_filename} using #{builder[:name]}"
  $logger.info "  Rule source: #{_rule.source}"
  FileUtils.rm_rf "output-#{builder[:packer_type]}-#{box_name}"
  packer_log    = File.join(log_dir, "packer-build-#{builder[:name]}-#{box_filename}.log")
  config_file   = File.join(template_path, 'config.json')
  template_file = File.join(template_path, 'packer.json')
  File.open(packer_log, "a") { |f| f.puts "==== BEGIN %s %s" % ['=' * 60, Time.now.to_s] }
  ENV['PACKER_LOG']='1'               # Set up child processes environment
  ENV['PACKER_LOG_PATH']=packer_log   # Set up child processes environment
  packer_args=''
  case builder[:name]
    when 'hyperv'
      # Make sure password is complex enough
      share_password = ''
      good=0
      while good < 3
        share_password = SecureRandom.urlsafe_base64(9)
        good = 0
        good +=1 if share_password !~ /[a-zA-Z0-9]/
        good +=1 if share_password =~ /[0-9]/
        good +=1 if share_password =~ /[a-z]/
        good +=1 if share_password =~ /[A-Z]/
        puts "Generating a new password (#{share_password} did not meet Windows complexity requirements)" unless good >= 3
      end
      # Create a temp user
      puts "Creating temporary user: #{builder[:share_user]}, password: #{share_password}"
      $logger.info "Creating temporary user: #{builder[:share_user]}, password: #{share_password}"
      system "net user #{builder[:share_user]} /DEL >NUL"  if system("net user #{builder[:share_user]} 2>NUL >NUL")
      system "net user #{builder[:share_user]} #{share_password} /ADD"
      # Makes sure the user can write to the log folder
      shell "$acl = (Get-Item \"#{Dir.pwd}/log\").GetAccessControl('Access') ; $ar = New-Object System.Security.AccessControl.FileSystemAccessRule('BUILTIN\\Users', 'Modify', 'ContainerInherit,ObjectInherit','None','Allow') ; $acl.SetAccessRule($ar) ; Set-Acl -Path \"#{Dir.pwd}/log\" -AclObject $acl"
      # Share log, full permission the temp user
      puts "Creating share: log at #{Dir.pwd}/log"
      shell "if (Get-SmbShare log -ErrorAction SilentlyContinue) { Remove-SmbShare log -Force }" 
      shell "New-SmbShare -Name log -Path '#{Dir.pwd}/log' -Temporary -FullAccess '#{builder[:share_user]}'"
      share_info = shell("Get-SmbShareAccess -Name log | ConvertTo-Json -Compress", json: true)
      die "Could not give full access to share 'log' to user #{builder[:share_user]}" unless share_info[:AccountName].casecmp(Socket.gethostname + "\\" + builder[:share_user]) == 0
      # Share daas/cache, read permission the temp user
      puts "Creating share: daas-cache at #{$cache_dir}"
      shell "if (Get-SmbShare daas-cache -ErrorAction SilentlyContinue) { Remove-SmbShare daas-cache -Force }" 
      shell "New-SmbShare -Name daas-cache -Path '#{$cache_dir}' -Temporary -ReadAccess '#{builder[:share_user]}'"
      host_ip=shell("Get-NetIPConfiguration | Where InterfaceAlias -like '*Bridged Switch*' | Select -ExpandProperty IPv4Address | Select -ExpandProperty IPAddress")
      packer_args += " -var \"share_host=#{host_ip}\""
      packer_args += " -var \"share_username=#{builder[:share_user]}\""
      packer_args += " -var \"share_password=#{share_password}\""
    when 'vmware'
      case RUBY_PLATFORM
        when 'x64-mingw32'
          vmware_iso_dir  = File.join(ENV['ProgramFiles(x86)'], 'VMWare', 'VMWare Workstation')
          packer_args    += " -var \"vmware_iso_dir=#{vmware_iso_dir}\""
        when /.*darwin[0-9]+/
          packer_args += " -var \"vmware_iso_dir=/Applications/VMware Fusion.app/Contents/Library/isoimages\""
      end
  end
  packer_args += " -var \"cache_dir=#{$cache_dir}\" -var \"version=#{box_version}\""
  $logger.info "Executing: packer build -only=#{builder[:packer_type]} -var-file=\"#{config_file}\" #{packer_args} \"#{template_file}\""
  begin
  build_time = Benchmark.measure {
    sh "packer build -only=#{builder[:packer_type]} -var-file=\"#{config_file}\" #{packer_args} \"#{template_file}\""
  }
  puts "Build time: #{build_time.real} seconds"
  `say --voice=Samantha "Box built for #{builder[:say]}"` if RUBY_PLATFORM =~ /.*darwin.*/
  ensure
    case builder[:name]
      when 'hyperv'
        # Unshare log
        puts "Removing share: log"
        shell "Remove-SmbShare log -Force" 
        # Unshare daas/cache
        puts "Removing share: daas-cache"
        shell "Remove-SmbShare daas-cache -Force" 
        # Delete the temp user
        puts "Deleting temporary user: #{builder[:share_user]}"
        sh "net user #{builder[:share_user]} /DEL"
    end
    File.open(packer_log, "a") { |f|
      f.puts "Build time: #{build_time.real} seconds" unless build_time.nil?
      f.puts "==== END   %s %s" % ['=' * 60, Time.now.to_s]
    }
  end
end # }}}

# builders tasks {{{
builders_in_use=0
builders.each do |builder_name, builder|
  if builder[:supported][]
    builders_in_use += 1
    TEMPLATE_FILES.each do |template_file|
      config        = load_json(template_file.pathmap("%d/config.json"))
      $logger.info "Processing Template: #{config['template']}"
      box_version   = config['version'] || case config['template']
        when 'cic'
          $logger.debug "  Calculating version..."
          $logger.debug "  Search cache in #{$cache_dir}"
          cic_iso = Rake::FileList.new(File.join($cache_dir, 'CIC_[0-9]*.iso')).sort.last
          $logger.debug "  Using ISO: #{cic_iso}"
          /CIC_(\d+)_R(\d+)(?:_Patch(\d+))?\.iso/i =~ cic_iso ? "#{$1[2..-1]}.#{$2}.#{$3 || 0}" : '0.1.0'
        else '0.1.0'
      end
      $logger.info "  Box Version: #{box_version}"
      box_name      = template_file.pathmap("%{templates/,}d")
      box_file      = "#{boxes_dir}/#{box_name}_#{box_version}_#{builder[:folder]}.box"
      box_url       = "file:///#{Dir.pwd}/#{box_file}"
      metadata_file = "#{boxes_dir}/#{box_name}/metadata.json"

      namespace :validate do # {{{
        namespace builder_name.to_sym do
          desc "Validate template #{box_name} version #{box_version} with #{builder_name}"
          task box_name do
            sh "packer validate -only=#{builder[:packer_type]} -var-file=#{template_file.pathmap("%d")}/config.json #{template_file}"
          end

          desc "Validate all templates for #{builder_name}"
          task :all => box_name
        end

        desc "Validate all templates for all providers"
        task :all => "#{builder_name}:all"
      end # }}}

      namespace :build do # {{{
        namespace builder_name.to_sym do
          desc "Build box #{box_name} version #{box_version} with #{builder_name}"
          task box_name => [ :folders, box_file ]

          $box_aliases[box_name].each do |box_alias|
            desc "Alias to build box #{box_name} in vagrant for #{builder_name}"
            task box_alias => [ :folders, box_file ]
          end if $box_aliases[box_name]

          desc "Build all boxes for #{builder_name}"
          task :all => box_name
        end

        desc "Build all boxes for all providers"
        task :all => "#{builder_name}:all"
      end # }}}

      namespace :load do # {{{
        namespace builder_name.to_sym do
          box_root = "#{ENV['VAGRANT_HOME'] || (ENV['HOME'] + '/.vagrant.d')}/boxes/#{box_name}"
          vagrant_provider = builders[builder_name][:vagrant_type]
          loaded_box_marker = "#{box_root}/#{box_version}/#{vagrant_provider}/metadata.json"

          file loaded_box_marker => box_file do |_task|
            $logger.info _task.investigation

            if Dir.exist? "#{box_root}/#{box_version}"
              $logger.info "removing #{box_root}/#{box_version}/#{vagrant_provider}"
              FileUtils.rm_r "#{box_root}/#{box_version}/#{vagrant_provider}", force: true
            else
              $logger.info "removing #{box_root}/#{box_version}"
              FileUtils.mkdir_p "#{box_root}/#{box_version}"
            end
            $logger.info "adding #{box_file} as #{box_name}"
            load_time = Benchmark.measure {
              sh "vagrant box add --force #{box_name} #{box_file}"
            }
            puts "Load time: #{load_time.real} seconds"
            `say --voice=Samantha "Box loaded in Vagrant"` if RUBY_PLATFORM =~ /.*darwin.*/
            # Now move the new box in the proper box_version folder
            $logger.info "moving #{box_root}/0/#{vagrant_provider} to #{box_root}/#{box_version}"
            FileUtils.mv   "#{box_root}/0/#{vagrant_provider}", "#{box_root}/#{box_version}"
            $logger.info "removing #{box_root}/0"
            FileUtils.rm_r "#{box_root}/0", force: true
            puts "==> box: Successfully updated box '#{box_name}' version to #{box_version} for '#{vagrant_provider}'"
          end

          desc "Load box #{box_name} in vagrant for #{builder_name}"
          task box_name => loaded_box_marker

          $box_aliases[box_name].each do |box_alias|
            desc "Alias to load box #{box_name} in vagrant for #{builder_name}"
            task box_alias => loaded_box_marker
          end if $box_aliases[box_name]

          desc "Load all boxes in vagrant for #{builder_name}"
          task :all => box_name
        end

        desc "Load all boxes in vagrant"
        task :all => "#{builder_name}:all"
      end # }}}

      namespace :md5 do # {{{
        namespace builder_name.to_sym do
          desc "Calculate the MD5 checksum of the box #{box_name} in #{builder_name}"
          task box_name => "#{box_file}.md5"

          $box_aliases[box_name].each do |box_alias|
            desc "Alias to calculate MD5 checksum of box #{box_name} in vagrant for #{builder_name}"
            task box_alias => box_name
          end if $box_aliases[box_name]
        end
      end # }}}

      namespace :push do # {{{
        require 'rest-client'

        namespace builder_name.to_sym do
          desc "Uploads box #{box_name} built with #{builder_name} to Atlas"
          task box_name => "md5:#{builder_name}:#{box_name}" do
            die "Please set ATLAS_ACCESS_TOKEN!" unless ENV['ATLAS_ACCESS_TOKEN']
            url = "https://atlas.hashicorp.com/api/v1/box/daas/#{box_name}/version/#{box_version}/provider/#{builder_name}/upload?access_token=#{ENV['ATLAS_ACCESS_TOKEN']}"
            $logger.info "Query URL: #{url}"
            response = RestClient.get "https://atlas.hashicorp.com/api/v1/box/daas/#{box_name}/version/#{box_version}/provider/#{builder_name}/upload", { params: {access_token: ENV['ATLAS_ACCESS_TOKEN'] }, accept: :json }
            response = JSON.parse(response, symbolize_names: true)
            $logger.info "Response: #{response}"
            hosted_token = response[:token]
            upload_url   = response[:upload_path]
            $logger.info "Box token: #{hosted_token}, url: #{upload_url}"
            puts "Uploading image to Atlas... (this can take a really long time)"
            shell("curl --progress-bar --show-error --request PUT --upload-file \"#{box_file}\" #{upload_url}")
            response = RestClient.get "https://atlas.hashicorp.com/api/v1/box/daas/#{box_name}/version/#{box_version}/provider/#{builder_name}", { params: {access_token: ENV['ATLAS_ACCESS_TOKEN'] }, accept: :json }
            response = JSON.parse(response, symbolize_names: true)
            die "uploaded token is different! :(" unless hosted_token == response[:hosted_token]
            # Verify:
            # curl "https://atlas.hashicorp.com/api/v1/box/daas/#{box_name}/version/#{box_version}/provider/#{builder_name}?access_token=#{ENV['ATLAS_ACCESS_TOKEN']}"
            # response:
            #  {"name":"parallels","hosted":true,"hosted_token":"a0bb0df8-9aaf-499a-885f-730d905714d6","original_url":null,"created_at":"2016-06-28T13:58:07.828Z","updated_at":"2016-06-28T13:58:07.828Z","download_url":"https://atlas.hashicorp.com/daas/boxes/cic/versions/16.3.0/providers/parallels.box"}


            # For simple http sites, Retrieve the metadata.json from ENV['VAGRANT_REPO']
            #   if not exist, create it
            #     upload box and md5
            #     update json
            #     upload json
            #   if exist,
            #     find box_name, builder_name box_version in json
            #       if exist
            #         check md5 from repo
            #           if same, end
            #           if different, upload box and md5
            #       if not exist
            #         upload box and md5
            #         update json
            #         upload json
          end

          $box_aliases[box_name].each do |box_alias|
            desc "Alias to upload box #{box_name} built with #{builder_name} to a repository"
            task box_alias => box_name
          end if $box_aliases[box_name]
        end
      end if !ENV['VAGRANT_REPO'].nil? # }}}

      namespace :remove do # {{{
        namespace builder_name.to_sym do
          desc "Remove box #{box_name} from #{builder_name}"
          task box_name => "destroy:#{builder_name}:#{box_name}" do
            sh "vagrant box remove -f --provider #{builder[:vagrant_type]} #{box_name}"
          end

          desc "Remove all boxes from #{builder_name}"
          task :all => box_name
        end

        desc "Remove all boxes from all providers"
        task :all => "#{builder_name}:all"
      end # }}}

      CLOBBER << box_file
      CLOBBER << metadata_file
    end
  end
end # }}}

unless builders_in_use > 0
    STDERR.puts "Error: could not find any virtualization builder!"
end

desc "Turn on verbose mode"
task :verbose do
  $logger = Logger.new(STDERR)
  $logger.level = Logger::INFO
  $logger.info "Verbose started at: %s" % [ Time.now.to_s ]
end

desc "Turn on debug mode"
task :debug => [:verbose] do
  $logger.level = Logger::DEBUG
  $logger.debug "Debug started at: %s" % [ Time.now.to_s ]
end

task :default => ['build:all', 'metadata:all']