vanagon 0.15.36 → 0.17.0

data/lib/vanagon/cli/build.rb

@@ -0,0 +1,75 @@
+require 'docopt'
+
+class Vanagon
+  class CLI
+    class Build < Vanagon::CLI
+      DOCUMENTATION = <<~DOCOPT.freeze
+        Usage:
+        build [options] <project-name> <platforms> [<targets>]
+
+        Options:
+          -h, --help                       Display help
+          -c, --configdir DIRECTORY        Configuration directory [default: #{Dir.pwd}/configs]
+          -e, --engine ENGINE              Custom engine to use [base, local, docker, pooler] [default: pooler]
+          -o, --only-build COMPONENT,COMPONENT,...
+                                           Only build listed COMPONENTs
+          -p, --preserve [RULE]            Rule for VM preservation: never, on-failure, always
+                                             [Default: always]
+          -r, --remote-workdir DIRECTORY   Working directory on the remote host
+          -s, --skipcheck                  Skip the "check" stage when building components
+          -w, --workdir DIRECTORY          Working directory on the local host
+          -v, --verbose                    Only here for backwards compatibility. Does nothing.
+      DOCOPT
+
+      def parse(argv)
+        Docopt.docopt(DOCUMENTATION, { argv: argv })
+      rescue Docopt::Exit => e
+        puts e.message
+        exit 1
+      end
+
+      def run(options) # rubocop:disable Metrics/AbcSize
+        project = options[:project_name]
+        platform_list = options[:platforms].split(',')
+        target_list = []
+        unless options[:targets].nil? || options[:targets].empty?
+          target_list = options[:targets].split(',')
+        end
+
+        platform_list.zip(target_list).each do |pair|
+          platform, target = pair
+          artifact = Vanagon::Driver.new(platform, project, options.merge({ 'target' => target }))
+          artifact.run
+        end
+      end
+
+      def options_translate(docopt_options)
+        translations = {
+          '--verbose' => :verbose,
+          '--workdir' => :workdir,
+          '--remote-workdir' => :"remote-workdir",
+          '--configdir' => :configdir,
+          '--engine' => :engine,
+          '--skipcheck' => :skipcheck,
+          '--preserve' => :preserve,
+          '--only-build' => :only_build,
+          '<project-name>' => :project_name,
+          '<platforms>' => :platforms,
+          '<targets>' => :targets
+        }
+        return docopt_options.map { |k, v| [translations[k], v] }.to_h
+      end
+
+      def options_validate(options)
+        # Handle --preserve option checking
+        valid_preserves = %w[always never on-failure]
+        unless valid_preserves.include? options[:preserve]
+          raise InvalidArgument, "--preserve option can only be one of: " +
+                                 valid_preserves.join(', ')
+        end
+        options[:preserve] = options[:preserve].to_sym
+        return options
+      end
+    end
+  end
+end

data/lib/vanagon/cli/build_host_info.rb

@@ -0,0 +1,49 @@
+require 'docopt'
+
+class Vanagon
+  class CLI
+    class BuildHostInfo < Vanagon::CLI
+      DOCUMENTATION = <<~DOCOPT.freeze
+        Usage:
+        build_host_info [options] <project-name> <platforms>
+
+        Options:
+          -h, --help                       Display help
+          -c, --configdir DIRECTORY        Configuration directory [default: #{Dir.pwd}/configs]
+          -e, --engine ENGINE              Custom engine to use [base, local, docker, pooler] [default: pooler]
+          -w, --workdir DIRECTORY          Working directory on the local host
+          -v, --verbose                    Only here for backwards compatibility. Does nothing.
+      DOCOPT
+
+      def parse(argv)
+        Docopt.docopt(DOCUMENTATION, { argv: argv })
+      rescue Docopt::Exit => e
+        puts e.message
+        exit 1
+      end
+
+      def run(options)
+        platforms = options[:platforms].split(',')
+        project = options[:project_name]
+
+        platforms.each do |platform|
+          driver = Vanagon::Driver.new(platform, project, options)
+          $stdout.puts JSON.generate(driver.build_host_info)
+        end
+      end
+
+      def options_translate(docopt_options)
+        translations = {
+          '--verbose' => :verbose,
+          '--workdir' => :workdir,
+          '--configdir' => :configdir,
+          '--engine' => :engine,
+          '<project-name>' => :project_name,
+          '<platforms>' => :platforms,
+          '<targets>' => :targets
+        }
+        return docopt_options.map { |k, v| [translations[k], v] }.to_h
+      end
+    end
+  end
+end

data/lib/vanagon/cli/build_requirements.rb

@@ -0,0 +1,60 @@
+require 'docopt'
+require 'json'
+
+class Vanagon
+  class CLI
+    class BuildRequirements < Vanagon::CLI
+      DOCUMENTATION = <<~DOCOPT.freeze
+        Usage:
+        build_requirements [options] <project-name> <platform>
+
+        Options:
+          -h, --help                       Display help
+          -c, --configdir DIRECTORY        Configuration directory [default: #{Dir.pwd}/configs]
+          -e, --engine ENGINE              Custom engine to use [base, local, docker, pooler] [default: pooler]
+          -w, --workdir DIRECTORY          Working directory on the local host
+          -v, --verbose                    Only here for backwards compatibility. Does nothing.
+      DOCOPT
+
+      def parse(argv)
+        Docopt.docopt(DOCUMENTATION, { argv: argv })
+      rescue Docopt::Exit => e
+        puts e.message
+        exit 1
+      end
+
+      def run(options) # rubocop:disable Metrics/AbcSize
+        platform = options[:platform]
+        project = options[:project_name]
+        driver = Vanagon::Driver.new(platform, project)
+
+        components = driver.project.components
+        component_names = components.map(&:name)
+        build_requirements = []
+        components.each do |component|
+          build_requirements << component.build_requires.reject do |requirement|
+            # only include external requirements: i.e. those that do not match
+            # other components in the project
+            component_names.include?(requirement)
+          end
+        end
+
+        $stdout.puts
+        $stdout.puts "**** External packages required to build #{project} on #{platform}: ***"
+        $stdout.puts JSON.pretty_generate(build_requirements.flatten.uniq.sort)
+      end
+
+      def options_translate(docopt_options)
+        translations = {
+          '--verbose' => :verbose,
+          '--workdir' => :workdir,
+          '--configdir' => :configdir,
+          '--engine' => :engine,
+          '<project-name>' => :project_name,
+          '<platform>' => :platform,
+        }
+        return docopt_options.map { |k, v| [translations[k], v] }.to_h
+      end
+    end
+  end
+end

data/lib/vanagon/cli/inspect.rb

@@ -0,0 +1,65 @@
+require 'docopt'
+require 'json'
+
+class Vanagon
+  class CLI
+    class Inspect < Vanagon::CLI
+      DOCUMENTATION = <<~DOCOPT.freeze
+        Usage:
+        inspect [options] <project-name> <platforms>
+
+        Options:
+          -h, --help                       Display help
+          -c, --configdir DIRECTORY        Configuration directory [default: #{Dir.pwd}/configs]
+          -e, --engine ENGINE              Custom engine to use [base, local, docker, pooler] [default: pooler]
+
+          -p, --preserve [RULE]            Rule for VM preservation: never, on-failure, always
+                                             [Default: on-failure]
+          -w, --workdir DIRECTORY          Working directory on the local host
+          -v, --verbose                    Only here for backwards compatibility. Does nothing.
+      DOCOPT
+
+      def parse(argv)
+        Docopt.docopt(DOCUMENTATION, { argv: argv })
+      rescue Docopt::Exit => e
+        puts e.message
+        exit 1
+      end
+
+      def run(options)
+        platforms = options[:platforms].split(',')
+        project = options[:project_name]
+
+        platforms.each do |platform|
+          driver = Vanagon::Driver.new(platform, project, options)
+          components = driver.project.components.map(&:to_hash)
+          $stdout.puts JSON.pretty_generate(components)
+        end
+      end
+
+      def options_translate(docopt_options)
+        translations = {
+          '--verbose' => :verbose,
+          '--workdir' => :workdir,
+          '--configdir' => :configdir,
+          '--engine' => :engine,
+          '--preserve' => :preserve,
+          '<project-name>' => :project_name,
+          '<platforms>' => :platforms
+        }
+        return docopt_options.map { |k, v| [translations[k], v] }.to_h
+      end
+
+      def options_validate(options)
+        # Handle --preserve option checking
+        valid_preserves = %w[always never on-failure]
+        unless valid_preserves.include? options[:preserve]
+          raise InvalidArgument, "--preserve option can only be one of: " +
+                                 valid_preserves.join(', ')
+        end
+        options[:preserve] = options[:preserve].to_sym
+        return options
+      end
+    end
+  end
+end

data/lib/vanagon/cli/render.rb

@@ -0,0 +1,51 @@
+require 'docopt'
+require 'json'
+
+class Vanagon
+  class CLI
+    class Render < Vanagon::CLI
+      DOCUMENTATION = <<~DOCOPT.freeze
+        Usage:
+        render [options] <project-name> <platforms>
+
+        Options:
+          -h, --help                       Display help
+          -c, --configdir DIRECTORY        Configuration directory [default: #{Dir.pwd}/configs]
+          -e, --engine ENGINE              Custom engine to use [base, local, docker, pooler] [default: pooler]
+          -w, --workdir DIRECTORY          Working directory on the local host
+          -v, --verbose                    Only here for backwards compatibility. Does nothing.
+      DOCOPT
+
+      def parse(argv)
+        Docopt.docopt(DOCUMENTATION, { argv: argv })
+      rescue Docopt::Exit => e
+        puts e.message
+        exit 1
+      end
+
+      def run(options)
+        platforms = options[:platforms].split(',')
+        project = options[:project_name]
+        target_list = []
+
+        platforms.zip(target_list).each do |pair|
+          platform, target = pair
+          artifact = Vanagon::Driver.new(platform, project, options.merge({ :target => target }))
+          artifact.render
+        end
+      end
+
+      def options_translate(docopt_options)
+        translations = {
+          '--verbose' => :verbose,
+          '--workdir' => :workdir,
+          '--configdir' => :configdir,
+          '--engine' => :engine,
+          '<project-name>' => :project_name,
+          '<platforms>' => :platforms,
+        }
+        return docopt_options.map { |k, v| [translations[k], v] }.to_h
+      end
+    end
+  end
+end

data/lib/vanagon/cli/ship.rb

@@ -0,0 +1,52 @@
+require 'docopt'
+
+class Vanagon
+  class CLI
+    class Ship < Vanagon::CLI
+      DOCUMENTATION = <<~DOCOPT.freeze
+        Usage:
+          ship [--help]
+
+        Options:
+          -h, --help                       Display help
+      DOCOPT
+
+      def parse(argv)
+        Docopt.docopt(DOCUMENTATION, { argv: argv })
+      rescue Docopt::Exit => e
+        puts e.message
+        exit 1
+      end
+
+      def run(_)
+        ENV['PROJECT_ROOT'] = Dir.pwd
+
+        artifactory_warning = <<-DOC
+          Unable to ship packages to artifactory. Please make sure you are pointing to a
+          recent version of packaging in your Gemfile. Please also make sure you include
+          the artifactory gem in your Gemfile.
+
+          Examples:
+            gem 'packaging', :github => 'puppetlabs/packaging', branch: '1.0.x'
+            gem 'artifactory'
+        DOC
+
+        if Dir['output/**/*'].select { |entry| File.file?(entry) }.empty?
+          warn 'vanagon: Error: No packages to ship in the "output" directory. Maybe build some first?'
+          exit 1
+        end
+
+        require 'packaging'
+        Pkg::Util::RakeUtils.load_packaging_tasks
+        Pkg::Util::RakeUtils.invoke_task('pl:jenkins:ship', 'artifacts', 'output')
+        begin
+          Pkg::Util::RakeUtils.invoke_task('pl:jenkins:ship_to_artifactory', 'output')
+        rescue LoadError
+          warn artifactory_warning
+        rescue StandardError
+          warn artifactory_warning
+        end
+      end
+    end
+  end
+end

data/lib/vanagon/cli/sign.rb

@@ -0,0 +1,34 @@
+require 'docopt'
+
+class Vanagon
+  class CLI
+    class Sign < Vanagon::CLI
+      DOCUMENTATION = <<~DOCOPT.freeze
+        Usage:
+          sign [--help]
+
+        Options:
+          -h, --help                       Display help
+      DOCOPT
+
+      def parse(argv)
+        Docopt.docopt(DOCUMENTATION, { argv: argv })
+      rescue Docopt::Exit => e
+        puts e.message
+        exit 1
+      end
+
+      def run(_)
+        ENV['PROJECT_ROOT'] = Dir.pwd
+        if Dir['output/**/*'].select { |entry| File.file?(entry) }.empty?
+          warn 'sign: Error: No packages to sign in the "output" directory. Maybe build some first?'
+          exit 1
+        end
+
+        require 'packaging'
+        Pkg::Util::RakeUtils.load_packaging_tasks
+        Pkg::Util::RakeUtils.invoke_task('pl:jenkins:sign_all', 'output')
+      end
+    end
+  end
+end

data/lib/vanagon/driver.rb

@@ -29,7 +29,6 @@ class Vanagon
       components = options[:components] || []
       only_build = options[:only_build]
       target = options[:target]
-      engine = options[:engine] || 'pooler'
 
       @platform = Vanagon::Platform.load_platform(platform, File.join(@@configdir, "platforms"))
       @project = Vanagon::Project.load_project(project, File.join(@@configdir, "projects"), @platform, components)
@@ -40,9 +39,14 @@ class Vanagon
 
       @remote_workdir = options[:"remote-workdir"]
 
-      load_engine(engine, @platform, target)
-    rescue LoadError => e
-      raise Vanagon::Error.wrap(e, "Could not load the desired engine '#{engine}'")
+      if options[:engine]
+        # Use the explicitly configured engine.
+        load_engine_object(options[:engine], @platform, target)
+      else
+        # Use 'pooler' as a default, but also apply selection logic that may
+        # choose something different based on platform configuration.
+        load_engine('pooler', @platform, target)
+      end
     end
 
     def filter_out_components(only_build)
@@ -73,8 +77,8 @@ class Vanagon
     def load_engine_object(engine_type, platform, target)
       require "vanagon/engine/#{engine_type}"
       @engine = Object::const_get("Vanagon::Engine::#{camelize(engine_type)}").new(platform, target, remote_workdir: remote_workdir)
-    rescue StandardError
-      fail "No such engine '#{camelize(engine_type)}'"
+    rescue StandardError, ScriptError => e
+      raise Vanagon::Error.wrap(e, "Could not load the desired engine '#{engine_type}'")
     end
 
     def camelize(string)
@@ -140,7 +144,7 @@ class Vanagon
       @project.make_bill_of_materials(workdir)
       # Don't generate packaging artifacts if no_packaging is set
       @project.generate_packaging_artifacts(workdir) unless @project.no_packaging
-      @project.save_manifest_json(@platform)
+      @project.save_manifest_json(@platform, workdir)
       @engine.ship_workdir(workdir)
       @engine.dispatch("(cd #{@engine.remote_workdir}; #{@platform.make} #{make_target})")
       @engine.retrieve_built_artifact(@project.artifacts_to_fetch, @project.no_packaging)

data/lib/vanagon/engine/always_be_scheduling.rb

@@ -1,5 +1,6 @@
-require 'vanagon/engine/base'
 require 'json'
+require 'vanagon/engine/base'
+require 'yaml'
 
 class Vanagon
   class Engine
@@ -82,9 +83,15 @@ class Vanagon
     # {"name":"aix-53-ppc","engine":"always_be_scheduling"}
     # ```
     class AlwaysBeScheduling < Base
+      attr_reader :token
+      attr_reader :token_vmpooler
+
       def initialize(platform, target, **opts)
         super
 
+        @available_abs_endpoint = "https://abs-prod.k8s.infracore.puppet.net/api/v2"
+        @token_vmpooler = ENV['VMPOOLER_TOKEN']
+        @token = load_token
         Vanagon::Driver.logger.debug "AlwaysBeScheduling engine invoked."
       end
 
@@ -94,6 +101,7 @@ class Vanagon
       end
 
       # return the platform name as the "host" name
+      # order of preference: abs_resource_name, vmpooler_template or name
       def build_host_name
         if @platform.abs_resource_name
           @platform.abs_resource_name
@@ -103,6 +111,268 @@ class Vanagon
           @platform.name
         end
       end
+
+      # Retrieve the ABS token from an environment variable
+      # ("ABS_TOKEN") or from a number of potential configuration
+      # files (~/.vanagon-token or ~/.vmfloaty.yml).
+      # @return [String, nil] token for use with the vmpooler
+      def load_token
+        ENV['ABS_TOKEN'] || token_from_file
+      end
+
+      # a wrapper method around retrieving a token,
+      # with an explicitly ordered preference for a Vanagon-specific
+      # token file or a preexisting vmfoaty yaml file.
+      #
+      # @return [String, nil] token for use with the vmpooler
+      def token_from_file
+        read_vanagon_token || read_vmfloaty_token
+      end
+      private :token_from_file
+
+      # Read an ABS/vmpooler token from the plaintext vanagon-token file,
+      # as outlined in the project README.
+      # The first line should be the ABS token
+      # and the second (optional) line should be the vmpooler token
+      # Saves the second line into the @token_vmpooler variable
+      #
+      # @return [String, nil] the vanagon vmpooler token value
+      def read_vanagon_token(path = "~/.vanagon-token")
+        absolute_path = File.expand_path(path)
+        return nil unless File.exist?(absolute_path)
+
+        warn "Reading ABS token from: #{path}"
+        contents = File.read(absolute_path).chomp
+        lines = contents.each_line.map(&:chomp)
+
+        abs = lines.shift
+        @token_vmpooler = lines.shift
+
+        warn "Please add a second line with the vmpooler token to be able to modify or see the VM in floaty/bit-bar" if @token_vmpooler.nil?
+        return abs
+      end
+      private :read_vanagon_token
+
+      # Read a vmpooler token from the yaml formatted vmfloaty config,
+      # as outlined by the vmfloaty project:
+      # https://github.com/puppetlabs/vmfloaty
+      #
+      # It returns the top-level token value or the first 'abs' service
+      # token value it finds in the services list
+      # it sets @token_vmpooler with the optional vmpooler token
+      # if the abs services has a vmpooler_fallback, and that service
+      # has a token eg
+      #
+      # TOP-LEVEL DEFINED  => would get only the abs token
+      # user: 'jdoe'
+      # url: 'https://abs.example.net'
+      # token: '456def789'
+      #
+      # MULTIPLE SERVICES DEFINED => would get the abs token in 'abs-prod' and the vmpooler token in 'vmpooler-prod'
+      # user: 'jdoe'
+      # services:
+      #   abs-prod:
+      #     type: 'abs'
+      #     url: 'https://abs.example.net/api/v2'
+      #     token: '123abc456'
+      #     vmpooler_fallback: 'vmpooler-prod'
+      #   vmpooler-dev:
+      #     type: 'vmpooler'
+      #     url: 'https://vmpooler-dev.example.net'
+      #     token: '987dsa654'
+      #   vmpooler-prod:
+      #     type: 'vmpooler'
+      #     url: 'https://vmpooler.example.net'
+      #     token: '456def789'
+      #
+      # @return [String, nil] the vmfloaty vmpooler token value
+      def read_vmfloaty_token(path = "~/.vmfloaty.yml") # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity
+        absolute_path = File.expand_path(path)
+        return nil unless File.exist?(absolute_path)
+
+        yaml_config = YAML.load_file(absolute_path)
+        abs_token = nil
+        abs_service_name = nil
+        if yaml_config['token'] # top level
+          abs_token = yaml_config['token']
+        elsif yaml_config['services']
+          yaml_config['services'].each do |name, value|
+            if value['type'] == "abs" && value['token']
+              abs_token = value['token']
+              abs_service_name = name
+              vmpooler_fallback = value['vmpooler_fallback']
+              unless vmpooler_fallback.nil? || yaml_config['services'][vmpooler_fallback].nil? || yaml_config['services'][vmpooler_fallback]['token'].nil?
+                @token_vmpooler = yaml_config['services'][vmpooler_fallback]['token']
+              end
+              break
+            end
+          end
+        end
+        message = "Reading ABS token from: #{path}"
+        if abs_service_name
+          message.concat(" for service named #{abs_service_name}")
+          if @token_vmpooler.nil?
+            message.concat(" but there was no vmpooler_fallback value, please add one if you want to be able to modify the VM via bit-bar/floaty")
+          else
+            message.concat(" with a vmpooler_fallback token")
+          end
+        end
+        warn message
+        return abs_token
+      end
+      private :read_vmfloaty_token
+
+      # This method is used to obtain a vm to build upon using Puppet's internal
+      # ABS (https://github.com/puppetlabs/always-be-scheduling) which is a level of abstraction for other
+      # engines using similar APIs
+      # @raise [Vanagon::Error] if a target cannot be obtained
+      def select_target
+        @pooler = select_target_from(@available_abs_endpoint)
+        raise Vanagon::Error, "Something went wrong getting a target vm to build on" if @pooler.empty?
+      end
+
+      # Attempt to provision a host from a specific pooler.
+      def select_target_from(pooler) # rubocop:disable Metrics/AbcSize
+        request_object = build_request_object
+
+        warn "Requesting VMs with job_id: #{@saved_job_id}.  Will poll for up to an hour."
+        #the initial request is always replied with "come back again"
+        response = Vanagon::Utilities.http_request_generic(
+          "#{pooler}/request",
+          'POST',
+          request_object.to_json,
+          { 'X-AUTH-TOKEN' => @token }
+        )
+
+        unless response.code == "202"
+          warn "failed to request ABS with code #{response.code}"
+          if valid_json?(response.body)
+            response_json = JSON.parse(response.body)
+            warn "reason: #{response_json['reason']}"
+          end
+          return ''
+        end
+        response_body = check_queue(pooler, request_object)
+
+        return '' unless response_body["ok"]
+        @target = response_body[build_host_name]['hostname']
+        Vanagon::Driver.logger.info "Reserving #{@target} (#{build_host_name}) [#{@token ? 'token used' : 'no token used'}]"
+        return pooler
+      end
+
+      # main loop where the status of the request is checked, to see if the request
+      # has been allocated
+      def check_queue(pooler, request_object)
+        retries = 360 # ~ one hour
+        response_body = nil
+        begin
+          (1..retries).each do |i|
+            response = Vanagon::Utilities.http_request_generic(
+              "#{pooler}/request",
+              'POST',
+              request_object.to_json,
+              { 'X-AUTH-TOKEN' => @token }
+            )
+            response_body = validate_queue_status_response(response.code, response.body)
+            break if response_body
+
+            sleep_seconds = 10 if i >= 10
+            sleep_seconds = i if i < 10
+            warn "Waiting #{sleep_seconds} seconds to check if ABS request has been filled. (x#{i})"
+
+            sleep(sleep_seconds)
+          end
+        rescue SystemExit, Interrupt
+          warn "\nVanagon interrupted during mains ABS polling. Make sure you delete the requested job_id #{@saved_job_id}"
+          raise
+        end
+        response_body = translated(response_body, @saved_job_id)
+        response_body
+      end
+
+      def validate_queue_status_response(status_code, body)
+        case status_code
+        when "200"
+          return JSON.parse(body) unless body.empty? || !valid_json?(body)
+        when "202"
+          return nil
+        when "401"
+          raise Vanagon::Error, "HTTP #{status_code}: The token provided could not authenticate.\n#{body}"
+        when "503"
+          return nil
+        else
+          raise Vanagon::Error, "HTTP #{status_code}: request to ABS failed!\n#{body}"
+        end
+      end
+
+      # This method is used to tell the ABS to delete the job_id requested
+      # otherwise the resources will eventually get allocated asynchronously
+      # and will keep running until the end of their lifetime.
+      def teardown # rubocop:disable Metrics/AbcSize
+        request_object = {
+            'job_id' => @saved_job_id,
+        }
+
+        response = Vanagon::Utilities.http_request_generic(
+          "#{@available_abs_endpoint}/return",
+          "POST",
+          request_object.to_json,
+          { 'X-AUTH-TOKEN' => @token }
+        )
+        if response && response.body == 'OK'
+          Vanagon::Driver.logger.info "#{@saved_job_id} has been scheduled for removal"
+          warn "#{@saved_job_id} has been scheduled for removal"
+        else
+          Vanagon::Driver.logger.info "#{@saved_job_id} could not be scheduled for removal: #{response.body}"
+          warn "#{@saved_job_id} could not be scheduled for removal"
+        end
+      rescue Vanagon::Error => e
+        Vanagon::Driver.logger.info "#{@saved_job_id} could not be scheduled for removal (#{e.message})"
+        warn "#{@saved_job_id} could not be scheduled for removal (#{e.message})"
+      end
+
+      private
+
+      def translated(response_body, job_id)
+        vmpooler_formatted_body = { 'job_id' => job_id }
+
+        response_body.each do |host| # in this context there should be only one host
+          vmpooler_formatted_body[host['type']] = { 'hostname' => host['hostname'] }
+        end
+        vmpooler_formatted_body['ok'] = true
+
+        vmpooler_formatted_body
+      end
+
+      def build_request_object
+        user = ENV['USER'] || ENV['USERNAME'] || 'unknown'
+
+        @saved_job_id = user + "-" + DateTime.now.strftime('%Q')
+        request_object = {
+            :resources => { build_host_name => 1 },
+            :job       => {
+                :id   => @saved_job_id,
+                :tags => {
+                    :jenkins_build_url => ENV['BUILD_URL'],
+                    :project           => ENV['JOB_NAME'] || 'vanagon',
+                    :created_by        => user,
+                    :user              => user
+                },
+            },
+            :priority => 1, # DO NOT use priority 1 in automated CI runs
+        }
+        unless @token_vmpooler.nil?
+          request_object[:vm_token] = @token_vmpooler
+        end
+        request_object
+      end
+
+      def valid_json?(json)
+        JSON.parse(json)
+        return true
+      rescue TypeError, JSON::ParserError
+        return false
+      end
     end
   end
 end