vmfloaty 0.11.0 → 1.3.0

data/lib/vmfloaty/utils.rb

@@ -3,6 +3,7 @@
 require 'vmfloaty/abs'
 require 'vmfloaty/nonstandard_pooler'
 require 'vmfloaty/pooler'
+require 'vmfloaty/conf'
 
 class Utils
   # TODO: Takes the json response body from an HTTP GET
@@ -45,6 +46,10 @@ class Utils
 
     result = {}
 
+    # ABS has a job_id associated with hosts so pass that along
+    abs_job_id = response_body.delete('job_id')
+    result['job_id'] = abs_job_id unless abs_job_id.nil?
+
     filtered_response_body = response_body.reject { |key, _| key == 'request_id' || key == 'ready' }
     filtered_response_body.each do |os, value|
       hostnames = Array(value['hostname'])
@@ -57,7 +62,8 @@ class Utils
 
   def self.format_host_output(hosts)
     hosts.flat_map do |os, names|
-      names.map { |name| "- #{name} (#{os})" }
+      # Assume hosts are stored in Arrays and ignore everything else
+      names.map { |name| "- #{name} (#{os})" } if names.is_a? Array
     end.join("\n")
   end
 
@@ -78,41 +84,101 @@ class Utils
     os_types
   end
 
-  def self.pretty_print_hosts(verbose, service, hostnames = [], print_to_stderr = false)
+  def self.print_fqdn_for_host(service, hostname, host_data)
+    case service.type
+    when 'ABS'
+      abs_hostnames = []
+
+      host_data['allocated_resources'].each do |vm_name, _i|
+        abs_hostnames << vm_name['hostname']
+      end
+
+      puts abs_hostnames.join("\n")
+    when 'Pooler'
+      puts "#{hostname}.#{host_data['domain']}"
+    when 'NonstandardPooler'
+      puts host_data['fqdn']
+    else
+      raise "Invalid service type #{service.type}"
+    end
+  end
+
+  def self.pretty_print_hosts(verbose, service, hostnames = [], print_to_stderr = false, indent = 0)
+    output_target = print_to_stderr ? $stderr : $stdout
+
+    fetched_data = self.get_host_data(verbose, service, hostnames)
+    fetched_data.each do |hostname, host_data|
+      case service.type
+      when 'ABS'
+        # For ABS, 'hostname' variable is the jobID
+        #
+        # Create a vmpooler service to query each hostname there so as to get the metadata too
+
+        output_target.puts "- [JobID:#{host_data['request']['job']['id']}] <#{host_data['state']}>"
+        host_data['allocated_resources'].each do |allocated_resources, _i|
+          if (allocated_resources['engine'] == "vmpooler" || allocated_resources['engine'] == 'ondemand') && service.config["vmpooler_fallback"]
+            vmpooler_service = service.clone
+            vmpooler_service.silent = true
+            vmpooler_service.maybe_use_vmpooler
+            self.pretty_print_hosts(verbose, vmpooler_service, allocated_resources['hostname'].split('.')[0], print_to_stderr, indent+2)
+          else
+            #TODO we could add more specific metadata for the other services, nspooler and aws
+            output_target.puts "  - #{allocated_resources['hostname']} (#{allocated_resources['type']})"
+          end
+        end
+      when 'Pooler'
+        tag_pairs = []
+        tag_pairs = host_data['tags'].map { |key, value| "#{key}: #{value}" } unless host_data['tags'].nil?
+        duration = "#{host_data['running']}/#{host_data['lifetime']} hours"
+        metadata = [host_data['state'], host_data['template'], duration, *tag_pairs]
+        message = "- #{hostname}.#{host_data['domain']} (#{metadata.join(', ')})".gsub(/^/, ' ' * indent)
+        if host_data['state'] && host_data['state'] == "destroyed"
+          output_target.puts message.colorize(:red)
+        else
+          output_target.puts message
+        end
+      when 'NonstandardPooler'
+        line = "- #{host_data['fqdn']} (#{host_data['os_triple']}"
+        line += ", #{host_data['hours_left_on_reservation']}h remaining"
+        line += ", reason: #{host_data['reserved_for_reason']}" unless host_data['reserved_for_reason'].empty?
+        line += ')'
+        output_target.puts line
+      else
+        raise "Invalid service type #{service.type}"
+      end
+    end
+  end
+
+  def self.get_host_data(verbose, service, hostnames = [])
+    result = {}
     hostnames = [hostnames] unless hostnames.is_a? Array
     hostnames.each do |hostname|
       begin
         response = service.query(verbose, hostname)
         host_data = response[hostname]
-
-        case service.type
-        when 'ABS'
-          # For ABS, 'hostname' variable is the jobID
-          if host_data['state'] == 'allocated' || host_data['state'] == 'filled'
-            host_data['allocated_resources'].each do |vm_name, _i|
-              puts "- [JobID:#{host_data['request']['job']['id']}] #{vm_name['hostname']} (#{vm_name['type']}) <#{host_data['state']}>"
+        if block_given?
+          yield host_data result
+        else
+          case service.type
+          when 'ABS'
+            # For ABS, 'hostname' variable is the jobID
+            if host_data['state'] == 'allocated' || host_data['state'] == 'filled'
+              result[hostname] = host_data
             end
+          when 'Pooler'
+            result[hostname] = host_data
+          when 'NonstandardPooler'
+            result[hostname] = host_data
+          else
+            raise "Invalid service type #{service.type}"
           end
-        when 'Pooler'
-          tag_pairs = []
-          tag_pairs = host_data['tags'].map { |key, value| "#{key}: #{value}" } unless host_data['tags'].nil?
-          duration = "#{host_data['running']}/#{host_data['lifetime']} hours"
-          metadata = [host_data['template'], duration, *tag_pairs]
-          puts "- #{hostname}.#{host_data['domain']} (#{metadata.join(', ')})"
-        when 'NonstandardPooler'
-          line = "- #{host_data['fqdn']} (#{host_data['os_triple']}"
-          line += ", #{host_data['hours_left_on_reservation']}h remaining"
-          line += ", reason: #{host_data['reserved_for_reason']}" unless host_data['reserved_for_reason'].empty?
-          line += ')'
-          puts line
-        else
-          raise "Invalid service type #{service.type}"
         end
       rescue StandardError => e
         FloatyLogger.error("Something went wrong while trying to gather information on #{hostname}:")
         FloatyLogger.error(e)
       end
     end
+    result
   end
 
   def self.pretty_print_status(verbose, service)
@@ -173,12 +239,15 @@ class Utils
   end
 
   def self.get_service_object(type = '')
-    nspooler_strings = %w[ns nspooler nonstandard nonstandard_pooler]
     abs_strings = %w[abs alwaysbescheduling always_be_scheduling]
-    if nspooler_strings.include? type.downcase
-      NonstandardPooler
-    elsif abs_strings.include? type.downcase
+    nspooler_strings = %w[ns nspooler nonstandard nonstandard_pooler]
+    vmpooler_strings = %w[vmpooler]
+    if abs_strings.include? type.downcase
       ABS
+    elsif nspooler_strings.include? type.downcase
+      NonstandardPooler
+    elsif vmpooler_strings.include? type.downcase
+      Pooler
     else
       Pooler
     end
@@ -190,6 +259,7 @@ class Utils
       'url'   => config['url'],
       'user'  => config['user'],
       'token' => config['token'],
+      'vmpooler_fallback' => config['vmpooler_fallback'],
       'type'  => config['type'] || 'vmpooler',
     }
 
@@ -206,6 +276,9 @@ class Utils
         # If the service is configured but some values are missing, use the top-level defaults to fill them in
         service_config.merge! config['services'][options.service]
       end
+    # No config file but service is declared on command line
+    elsif !config['services'] && options.service
+      service_config['type'] = options.service
     end
 
     # Prioritize an explicitly specified url, user, or token if the user provided one
@@ -216,4 +289,30 @@ class Utils
 
     service_config
   end
+
+  # This method gets the vmpooler service configured in ~/.vmfloaty
+  def self.get_vmpooler_service_config(vmpooler_fallback)
+    config = Conf.read_config
+    # The top-level url, user, and token values in the config file are treated as defaults
+    service_config = {
+        'url'   => config['url'],
+        'user'  => config['user'],
+        'token' => config['token'],
+        'type'  => 'vmpooler',
+    }
+
+    # at a minimum, the url needs to be configured
+    if config['services'] && config['services'][vmpooler_fallback] && config['services'][vmpooler_fallback]['url']
+      # If the service is configured but some values are missing, use the top-level defaults to fill them in
+      service_config.merge! config['services'][vmpooler_fallback]
+    else
+      if vmpooler_fallback.nil?
+        raise ArgumentError, "The abs service should have a key named 'vmpooler_fallback' in ~/.vmfloaty.yml with a value that points to a vmpooler service name use this format:\nservices:\n  myabs:\n    url: 'http://abs.com'\n    user: 'superman'\n    token: 'kryptonite'\n    vmpooler_fallback: 'myvmpooler'\n  myvmpooler:\n    url: 'http://vmpooler.com'\n    user: 'superman'\n    token: 'kryptonite'"
+      else
+        raise ArgumentError, "Could not find a configured service named '#{vmpooler_fallback}' in ~/.vmfloaty.yml use this format:\nservices:\n  #{vmpooler_fallback}:\n    url: 'http://vmpooler.com'\n    user: 'superman'\n    token: 'kryptonite'"
+      end
+    end
+
+    service_config
+  end
 end

data/lib/vmfloaty/version.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
 class Vmfloaty
-  VERSION = '0.11.0'
+  VERSION = '1.3.0'
 end
+

data/spec/vmfloaty/abs_spec.rb

@@ -9,15 +9,60 @@ describe ABS do
   before :each do
   end
 
+  describe '#list' do
+    it 'skips empty platforms and lists aws' do
+      stub_request(:get, "http://foo/api/v2/status/platforms/vmpooler").
+          to_return(:status => 200, :body => "", :headers => {})
+      stub_request(:get, "http://foo/api/v2/status/platforms/ondemand_vmpooler").
+          to_return(:status => 200, :body => "", :headers => {})
+      stub_request(:get, "http://foo/api/v2/status/platforms/nspooler").
+          to_return(:status => 200, :body => "", :headers => {})
+      body = '{
+                "aws_platforms": [
+                  "amazon-6-x86_64",
+                  "amazon-7-x86_64",
+                  "amazon-7-arm64",
+                  "centos-7-x86-64-west",
+                  "redhat-8-arm64"
+                ]
+              }'
+      stub_request(:get, "http://foo/api/v2/status/platforms/aws").
+          to_return(:status => 200, :body => body, :headers => {})
+
+
+      results = ABS.list(false, "http://foo")
+
+      expect(results).to include("amazon-6-x86_64", "amazon-7-x86_64", "amazon-7-arm64", "centos-7-x86-64-west", "redhat-8-arm64")
+    end
+    it 'legacy JSON string, prior to PR 306' do
+      stub_request(:get, "http://foo/api/v2/status/platforms/vmpooler").
+          to_return(:status => 200, :body => "", :headers => {})
+      stub_request(:get, "http://foo/api/v2/status/platforms/ondemand_vmpooler").
+          to_return(:status => 200, :body => "", :headers => {})
+      stub_request(:get, "http://foo/api/v2/status/platforms/nspooler").
+          to_return(:status => 200, :body => "", :headers => {})
+      body = '{
+          "aws_platforms": "[\"amazon-6-x86_64\",\"amazon-7-x86_64\",\"amazon-7-arm64\",\"centos-7-x86-64-west\",\"redhat-8-arm64\"]"
+      }'
+      stub_request(:get, "http://foo/api/v2/status/platforms/aws").
+          to_return(:status => 200, :body => body, :headers => {})
+
+      results = ABS.list(false, "http://foo")
+
+      expect(results).to include("amazon-6-x86_64", "amazon-7-x86_64", "amazon-7-arm64", "centos-7-x86-64-west", "redhat-8-arm64")
+    end
+  end
+
   describe '#format' do
-    it 'returns an hash formatted like a vmpooler return' do
+    it 'returns an hash formatted like a vmpooler return, plus the job_id' do
+      job_id = "generated_by_floaty_12345"
       abs_formatted_response = [
         { 'hostname' => 'aaaaaaaaaaaaaaa.delivery.puppetlabs.net', 'type' => 'centos-7.2-x86_64', 'engine' => 'vmpooler' },
         { 'hostname' => 'aaaaaaaaaaaaaab.delivery.puppetlabs.net', 'type' => 'centos-7.2-x86_64', 'engine' => 'vmpooler' },
         { 'hostname' => 'aaaaaaaaaaaaaac.delivery.puppetlabs.net', 'type' => 'ubuntu-7.2-x86_64', 'engine' => 'vmpooler' },
       ]
 
-      vmpooler_formatted_response = ABS.translated(abs_formatted_response)
+      vmpooler_formatted_response = ABS.translated(abs_formatted_response, job_id)
 
       vmpooler_formatted_compare = {
         'centos-7.2-x86_64' => {},
@@ -29,6 +74,8 @@ describe ABS do
 
       vmpooler_formatted_compare['ok'] = true
 
+      vmpooler_formatted_compare['job_id'] = job_id
+
       expect(vmpooler_formatted_response).to eq(vmpooler_formatted_compare)
       vmpooler_formatted_response.delete('ok')
       vmpooler_formatted_compare.delete('ok')
@@ -68,9 +115,9 @@ describe ABS do
         # rubocop:disable Layout/LineLength
         @active_requests_response = '
         [
-          "{ \"state\":\"allocated\",\"last_processed\":\"2019-12-16 23:00:34 +0000\",\"allocated_resources\":[{\"hostname\":\"take-this.delivery.puppetlabs.net\",\"type\":\"win-2012r2-x86_64\",\"engine\":\"vmpooler\"}],\"audit_log\":{\"2019-12-13 16:45:29 +0000\":\"Allocated take-this.delivery.puppetlabs.net for job 1576255517241\"},\"request\":{\"resources\":{\"win-2012r2-x86_64\":1},\"job\":{\"id\":\"1576255517241\",\"tags\":{\"user\":\"test-user\"},\"user\":\"test-user\",\"time-received\":1576255519},\"priority\":1}}",
+          { "state":"allocated","last_processed":"2019-12-16 23:00:34 +0000","allocated_resources":[{"hostname":"take-this.delivery.puppetlabs.net","type":"win-2012r2-x86_64","engine":"vmpooler"}],"audit_log":{"2019-12-13 16:45:29 +0000":"Allocated take-this.delivery.puppetlabs.net for job 1576255517241"},"request":{"resources":{"win-2012r2-x86_64":1},"job":{"id":"1576255517241","tags":{"user":"test-user"},"user":"test-user","time-received":1576255519},"priority":1}},
           "null",
-          "{\"state\":\"allocated\",\"last_processed\":\"2019-12-16 23:00:34 +0000\",\"allocated_resources\":[{\"hostname\":\"not-this.delivery.puppetlabs.net\",\"type\":\"win-2012r2-x86_64\",\"engine\":\"vmpooler\"}],\"audit_log\":{\"2019-12-13 16:46:14 +0000\":\"Allocated not-this.delivery.puppetlabs.net for job 1576255565159\"},\"request\":{\"resources\":{\"win-2012r2-x86_64\":1},\"job\":{\"id\":\"1576255565159\",\"tags\":{\"user\":\"not-test-user\"},\"user\":\"not-test-user\",\"time-received\":1576255566},\"priority\":1}}"
+          {"state":"allocated","last_processed":"2019-12-16 23:00:34 +0000","allocated_resources":[{"hostname":"not-this.delivery.puppetlabs.net","type":"win-2012r2-x86_64","engine":"vmpooler"}],"audit_log":{"2019-12-13 16:46:14 +0000":"Allocated not-this.delivery.puppetlabs.net for job 1576255565159"},"request":{"resources":{"win-2012r2-x86_64":1},"job":{"id":"1576255565159","tags":{"user":"not-test-user"},"user":"not-test-user","time-received":1576255566},"priority":1}}
         ]'
         # rubocop:enable Layout/LineLength
         @token = 'utpg2i2xswor6h8ttjhu3d47z53yy47y'
@@ -78,7 +125,7 @@ describe ABS do
       end
 
       it 'will skip a line with a null value returned from abs' do
-        stub_request(:get, 'https://abs.example.com/status/queue')
+        stub_request(:get, 'https://abs.example.com/api/v2/status/queue')
           .to_return(:status => 200, :body => @active_requests_response, :headers => {})
 
         ret = ABS.get_active_requests(false, @abs_url, @test_user)
@@ -98,7 +145,7 @@ describe ABS do
         # rubocop:disable Layout/LineLength
         @active_requests_response = '
         [
-          "{ \"state\":\"allocated\", \"last_processed\":\"2020-01-17 22:29:13 +0000\", \"allocated_resources\":[{\"hostname\":\"craggy-chord.delivery.puppetlabs.net\", \"type\":\"centos-7-x86_64\", \"engine\":\"vmpooler\"}, {\"hostname\":\"visible-revival.delivery.puppetlabs.net\", \"type\":\"centos-7-x86_64\", \"engine\":\"vmpooler\"}], \"audit_log\":{\"2020-01-17 22:28:45 +0000\":\"Allocated craggy-chord.delivery.puppetlabs.net, visible-revival.delivery.puppetlabs.net for job 1579300120799\"}, \"request\":{\"resources\":{\"centos-7-x86_64\":2}, \"job\":{\"id\":\"1579300120799\", \"tags\":{\"user\":\"test-user\"}, \"user\":\"test-user\", \"time-received\":1579300120}, \"priority\":3}}"
+          { "state":"allocated", "last_processed":"2020-01-17 22:29:13 +0000", "allocated_resources":[{"hostname":"craggy-chord.delivery.puppetlabs.net", "type":"centos-7-x86_64", "engine":"vmpooler"}, {"hostname":"visible-revival.delivery.puppetlabs.net", "type":"centos-7-x86_64", "engine":"vmpooler"}], "audit_log":{"2020-01-17 22:28:45 +0000":"Allocated craggy-chord.delivery.puppetlabs.net, visible-revival.delivery.puppetlabs.net for job 1579300120799"}, "request":{"resources":{"centos-7-x86_64":2}, "job":{"id":"1579300120799", "tags":{"user":"test-user"}, "user":"test-user", "time-received":1579300120}, "priority":3}}
         ]'
         @return_request = { '{"job_id":"1579300120799","hosts":{"hostname":"craggy-chord.delivery.puppetlabs.net","type":"centos-7-x86_64","engine":"vmpooler"},{"hostname":"visible-revival.delivery.puppetlabs.net","type":"centos-7-x86_64","engine":"vmpooler"}}'=>true }
         # rubocop:enable Layout/LineLength
@@ -109,9 +156,9 @@ describe ABS do
       end
 
       it 'will delete the whole job' do
-        stub_request(:get, 'https://abs.example.com/status/queue')
+        stub_request(:get, 'https://abs.example.com/api/v2/status/queue')
           .to_return(:status => 200, :body => @active_requests_response, :headers => {})
-        stub_request(:post, 'https://abs.example.com/return')
+        stub_request(:post, 'https://abs.example.com/api/v2/return')
           .with(:body => @return_request)
           .to_return(:status => 200, :body => 'OK', :headers => {})
 

data/spec/vmfloaty/utils_spec.rb

@@ -5,6 +5,11 @@ require 'json'
 require 'commander/command'
 require_relative '../../lib/vmfloaty/utils'
 
+# allow changing config in service for tests
+class Service
+  attr_writer :config
+end
+
 describe Utils do
   describe '#standardize_hostnames' do
     before :each do
@@ -77,9 +82,17 @@ describe Utils do
       expect(Utils.get_service_object).to be Pooler
     end
 
+    it 'uses abs when told explicitly' do
+      expect(Utils.get_service_object('abs')).to be ABS
+    end
+
     it 'uses nspooler when told explicitly' do
       expect(Utils.get_service_object('nspooler')).to be NonstandardPooler
     end
+
+    it 'uses vmpooler when told explicitly' do
+      expect(Utils.get_service_object('vmpooler')).to be Pooler
+    end
   end
 
   describe '#get_service_config' do
@@ -154,97 +167,473 @@ describe Utils do
     end
   end
 
-  describe '#pretty_print_hosts' do
+  describe '#print_fqdn_for_host' do
     let(:url) { 'http://pooler.example.com' }
 
-    it 'prints a vmpooler output with host fqdn, template and duration info' do
-      hostname = 'mcpy42eqjxli9g2'
-      response_body = { hostname => {
-        'template' => 'ubuntu-1604-x86_64',
-        'lifetime' => 12,
-        'running'  => 9.66,
-        'state'    => 'running',
-        'ip'       => '127.0.0.1',
-        'domain'   => 'delivery.mycompany.net',
-      } }
-      output = '- mcpy42eqjxli9g2.delivery.mycompany.net (ubuntu-1604-x86_64, 9.66/12 hours)'
-
-      expect(STDOUT).to receive(:puts).with(output)
-
-      service = Service.new(MockOptions.new, 'url' => url)
-      allow(service).to receive(:query)
-        .with(nil, hostname)
-        .and_return(response_body)
-
-      Utils.pretty_print_hosts(nil, service, hostname)
+    subject { Utils.print_fqdn_for_host(service, hostname, host_data) }
+
+    describe 'with vmpooler host' do
+      let(:service) { Service.new(MockOptions.new, 'url' => url) }
+      let(:hostname) { 'mcpy42eqjxli9g2' }
+      let(:domain) { 'delivery.mycompany.net' }
+      let(:fqdn) { [hostname, domain].join('.') }
+
+      let(:host_data) do
+        {
+          'template' => 'ubuntu-1604-x86_64',
+          'lifetime' => 12,
+          'running'  => 9.66,
+          'state'    => 'running',
+          'ip'       => '127.0.0.1',
+          'domain'   => domain,
+        }
+      end
+
+      it 'outputs fqdn for host' do
+        expect(STDOUT).to receive(:puts).with(fqdn)
+
+        subject
+      end
     end
 
-    it 'prints a vmpooler output with host fqdn, template, duration info, and tags when supplied' do
-      hostname = 'aiydvzpg23r415q'
-      response_body = { hostname => {
-        'template' => 'redhat-7-x86_64',
-        'lifetime' => 48,
-        'running'  => 7.67,
-        'state'    => 'running',
-        'tags'     => {
-          'user' => 'bob',
-          'role' => 'agent',
-        },
-        'ip'       => '127.0.0.1',
-        'domain'   => 'delivery.mycompany.net',
-      } }
-      output = '- aiydvzpg23r415q.delivery.mycompany.net (redhat-7-x86_64, 7.67/48 hours, user: bob, role: agent)'
+    describe 'with nonstandard pooler host' do
+      let(:service) { Service.new(MockOptions.new, 'url' => url, 'type' => 'ns') }
+      let(:hostname) { 'sol11-9.delivery.mycompany.net' }
+      let(:host_data) do
+        {
+          'fqdn'                      => hostname,
+          'os_triple'                 => 'solaris-11-sparc',
+          'reserved_by_user'          => 'first.last',
+          'reserved_for_reason'       => '',
+          'hours_left_on_reservation' => 35.89,
+        }
+      end
+      let(:fqdn) { hostname } # for nspooler these are the same
+
+      it 'outputs fqdn for host' do
+        expect(STDOUT).to receive(:puts).with(fqdn)
+
+        subject
+      end
+    end
 
-      expect(STDOUT).to receive(:puts).with(output)
+    describe 'with ABS host' do
+      let(:service) { Service.new(MockOptions.new, 'url' => url, 'type' => 'abs') }
+      let(:hostname) { '1597952189390' }
+      let(:fqdn) { 'example-noun.delivery.puppetlabs.net' }
+      let(:template) { 'ubuntu-1604-x86_64' }
+
+      # This seems to be the miminal stub response from ABS for the current output
+      let(:host_data) do
+        {
+          'state' => 'allocated',
+          'allocated_resources' => [
+            {
+              'hostname' => fqdn,
+              'type' => template,
+              'enging' => 'vmpooler',
+            },
+          ],
+          'request' => {
+            'job' => {
+              'id' => hostname,
+            }
+          },
+        }
+      end
 
-      service = Service.new(MockOptions.new, 'url' => url)
-      allow(service).to receive(:query)
-        .with(nil, hostname)
-        .and_return(response_body)
+      it 'outputs fqdn for host' do
+        expect(STDOUT).to receive(:puts).with(fqdn)
 
-      Utils.pretty_print_hosts(nil, service, hostname)
+        subject
+      end
     end
+  end
 
-    it 'prints a nonstandard pooler output with host, template, and time remaining' do
-      hostname = 'sol11-9.delivery.mycompany.net'
-      response_body = { hostname => {
-        'fqdn'                      => hostname,
-        'os_triple'                 => 'solaris-11-sparc',
-        'reserved_by_user'          => 'first.last',
-        'reserved_for_reason'       => '',
-        'hours_left_on_reservation' => 35.89,
-      } }
-      output = '- sol11-9.delivery.mycompany.net (solaris-11-sparc, 35.89h remaining)'
-
-      expect(STDOUT).to receive(:puts).with(output)
+  describe '#pretty_print_hosts' do
+    let(:url) { 'http://pooler.example.com' }
+    let(:verbose) { nil }
+    let(:print_to_stderr) { false }
 
-      service = Service.new(MockOptions.new, 'url' => url, 'type' => 'ns')
+    before(:each) do
       allow(service).to receive(:query)
-        .with(nil, hostname)
+        .with(anything, hostname)
         .and_return(response_body)
+    end
 
-      Utils.pretty_print_hosts(nil, service, hostname)
+    subject { Utils.pretty_print_hosts(verbose, service, hostname, print_to_stderr) }
+
+    describe 'with vmpooler service' do
+      let(:service) { Service.new(MockOptions.new, 'url' => url) }
+
+      let(:hostname) { 'mcpy42eqjxli9g2' }
+      let(:domain) { 'delivery.mycompany.net' }
+      let(:fqdn) { [hostname, domain].join('.') }
+
+      let(:response_body) do
+        {
+          hostname => {
+            'template' => 'ubuntu-1604-x86_64',
+            'lifetime' => 12,
+            'running'  => 9.66,
+            'state'    => 'running',
+            'ip'       => '127.0.0.1',
+            'domain'   => domain,
+          }
+        }
+      end
+
+      let(:default_output) { "- #{fqdn} (running, ubuntu-1604-x86_64, 9.66/12 hours)" }
+
+      it 'prints output with host fqdn, template and duration info' do
+        expect(STDOUT).to receive(:puts).with(default_output)
+
+        subject
+      end
+
+      context 'when tags are supplied' do
+        let(:hostname) { 'aiydvzpg23r415q' }
+        let(:response_body) do
+          {
+            hostname => {
+              'template' => 'redhat-7-x86_64',
+              'lifetime' => 48,
+              'running'  => 7.67,
+              'state'    => 'running',
+              'tags'     => {
+                'user' => 'bob',
+                'role' => 'agent',
+              },
+              'ip'       => '127.0.0.1',
+              'domain'   => domain,
+            }
+          }
+        end
+
+        it 'prints output with host fqdn, template, duration info, and tags' do
+          output = "- #{fqdn} (running, redhat-7-x86_64, 7.67/48 hours, user: bob, role: agent)"
+
+          expect(STDOUT).to receive(:puts).with(output)
+
+          subject
+        end
+      end
+
+      context 'when print_to_stderr option is true' do
+        let(:print_to_stderr) { true }
+
+        it 'outputs to stderr instead of stdout' do
+          expect(STDERR).to receive(:puts).with(default_output)
+
+          subject
+        end
+      end
     end
 
-    it 'prints a nonstandard pooler output with host, template, time remaining, and reason' do
-      hostname = 'sol11-9.delivery.mycompany.net'
-      response_body = { hostname => {
-        'fqdn'                      => hostname,
-        'os_triple'                 => 'solaris-11-sparc',
-        'reserved_by_user'          => 'first.last',
-        'reserved_for_reason'       => 'testing',
-        'hours_left_on_reservation' => 35.89,
-      } }
-      output = '- sol11-9.delivery.mycompany.net (solaris-11-sparc, 35.89h remaining, reason: testing)'
+    describe 'with nonstandard pooler service' do
+      let(:service) { Service.new(MockOptions.new, 'url' => url, 'type' => 'ns') }
+
+      let(:hostname) { 'sol11-9.delivery.mycompany.net' }
+      let(:response_body) do
+        {
+          hostname => {
+            'fqdn'                      => hostname,
+            'os_triple'                 => 'solaris-11-sparc',
+            'reserved_by_user'          => 'first.last',
+            'reserved_for_reason'       => '',
+            'hours_left_on_reservation' => 35.89,
+          }
+        }
+      end
+
+      let(:default_output) { "- #{hostname} (solaris-11-sparc, 35.89h remaining)" }
+
+      it 'prints output with host, template, and time remaining' do
+        expect(STDOUT).to receive(:puts).with(default_output)
+
+        subject
+      end
+
+      context 'when reason is supplied' do
+        let(:response_body) do
+          {
+            hostname => {
+              'fqdn'                      => hostname,
+              'os_triple'                 => 'solaris-11-sparc',
+              'reserved_by_user'          => 'first.last',
+              'reserved_for_reason'       => 'testing',
+              'hours_left_on_reservation' => 35.89,
+            }
+          }
+        end
+
+        it 'prints output with host, template, time remaining, and reason' do
+          output = '- sol11-9.delivery.mycompany.net (solaris-11-sparc, 35.89h remaining, reason: testing)'
+
+          expect(STDOUT).to receive(:puts).with(output)
+
+          subject
+        end
+      end
+
+      context 'when print_to_stderr option is true' do
+        let(:print_to_stderr) { true }
+
+        it 'outputs to stderr instead of stdout' do
+          expect(STDERR).to receive(:puts).with(default_output)
+
+          subject
+        end
+      end
+    end
 
-      expect(STDOUT).to receive(:puts).with(output)
+    describe 'with ABS service' do
+      let(:service) { Service.new(MockOptions.new, 'url' => url, 'type' => 'abs') }
+
+      let(:hostname) { '1597952189390' }
+      let(:fqdn) { 'example-noun.delivery.mycompany.net' }
+      let(:fqdn_hostname) {'example-noun'}
+      let(:template) { 'ubuntu-1604-x86_64' }
+
+      # This seems to be the miminal stub response from ABS for the current output
+      let(:response_body) do
+        {
+          hostname => {
+            'state' => 'allocated',
+            'allocated_resources' => [
+              {
+                'hostname' => fqdn,
+                'type' => template,
+                'engine' => 'vmpooler',
+              },
+            ],
+            'request' => {
+              'job' => {
+                'id' => hostname,
+              }
+            },
+          }
+        }
+      end
+
+      # The vmpooler response contains metadata that is printed
+      let(:domain) { 'delivery.mycompany.net' }
+      let(:response_body_vmpooler) do
+        {
+            fqdn_hostname => {
+                'template' => template,
+                'lifetime' => 48,
+                'running'  => 7.67,
+                'state'    => 'running',
+                'tags'     => {
+                    'user' => 'bob',
+                    'role' => 'agent',
+                },
+                'ip'       => '127.0.0.1',
+                'domain'   => domain,
+            }
+        }
+      end
+
+      before(:each) do
+        allow(Utils).to receive(:get_vmpooler_service_config).and_return({
+          'url' => 'http://vmpooler.example.com',
+          'token' => 'krypto-knight'
+        })
+        allow(service).to receive(:query)
+                              .with(anything, fqdn_hostname)
+                              .and_return(response_body_vmpooler)
+      end
+
+      let(:default_output_first_line) { "- [JobID:#{hostname}] <allocated>" }
+      let(:default_output_second_line) { "  - #{fqdn} (#{template})" }
+
+      it 'prints output with job id, host, and template' do
+        expect(STDOUT).to receive(:puts).with(default_output_first_line)
+        expect(STDOUT).to receive(:puts).with(default_output_second_line)
+
+        subject
+      end
+
+      it 'prints more information when vmpooler_fallback is set output with job id, host, template, lifetime, user and role' do
+        fallback = {'vmpooler_fallback' => 'vmpooler'}
+        service.config.merge! fallback
+        default_output_second_line="  - #{fqdn} (running, #{template}, 7.67/48 hours, user: bob, role: agent)"
+        expect(STDOUT).to receive(:puts).with(default_output_first_line)
+        expect(STDOUT).to receive(:puts).with(default_output_second_line)
+
+        subject
+      end
+
+      it 'prints in red when destroyed' do
+        fallback = {'vmpooler_fallback' => 'vmpooler'}
+        service.config.merge! fallback
+        response_body_vmpooler[fqdn_hostname]['state'] = "destroyed"
+        default_output_second_line_red="  - #{fqdn} (destroyed, #{template}, 7.67/48 hours, user: bob, role: agent)".red
+        expect(STDOUT).to receive(:puts).with(default_output_first_line)
+        expect(STDOUT).to receive(:puts).with(default_output_second_line_red)
+
+        subject
+      end
+
+      context 'when print_to_stderr option is true' do
+        let(:print_to_stderr) { true }
+
+        it 'outputs to stderr instead of stdout' do
+          expect(STDERR).to receive(:puts).with(default_output_first_line)
+          expect(STDERR).to receive(:puts).with(default_output_second_line)
+
+          subject
+        end
+      end
+    end
 
-      service = Service.new(MockOptions.new, 'url' => url, 'type' => 'ns')
-      allow(service).to receive(:query)
-        .with(nil, hostname)
-        .and_return(response_body)
+    describe 'with ABS service returning vmpooler and nspooler resources' do
+      let(:service) { Service.new(MockOptions.new, 'url' => url, 'type' => 'abs') }
+
+      let(:hostname) { '1597952189390' }
+      let(:fqdn) { 'this-noun.delivery.mycompany.net' }
+      let(:fqdn_ns) { 'that-noun.delivery.mycompany.net' }
+      let(:fqdn_hostname) {'this-noun'}
+      let(:fqdn_ns_hostname) {'that-noun'}
+      let(:template) { 'ubuntu-1604-x86_64' }
+      let(:template_ns) { 'solaris-10-sparc' }
+
+      # This seems to be the miminal stub response from ABS for the current output
+      let(:response_body) do
+        {
+            hostname => {
+                'state' => 'allocated',
+                'allocated_resources' => [
+                    {
+                        'hostname' => fqdn,
+                        'type' => template,
+                        'engine' => 'vmpooler',
+                    },
+                    {
+                        'hostname' => fqdn_ns,
+                        'type' => template_ns,
+                        'engine' => 'nspooler',
+                    },
+                ],
+                'request' => {
+                    'job' => {
+                        'id' => hostname,
+                    }
+                },
+            }
+        }
+      end
+
+      # The vmpooler response contains metadata that is printed
+      let(:domain) { 'delivery.mycompany.net' }
+      let(:response_body_vmpooler) do
+        {
+            fqdn_hostname => {
+                'template' => template,
+                'lifetime' => 48,
+                'running'  => 7.67,
+                'state'    => 'running',
+                'tags'     => {
+                    'user' => 'bob',
+                    'role' => 'agent',
+                },
+                'ip'       => '127.0.0.1',
+                'domain'   => domain,
+            }
+        }
+      end
+
+      before(:each) do
+        allow(Utils).to receive(:get_vmpooler_service_config).and_return({
+                                                                             'url' => 'http://vmpooler.example.com',
+                                                                             'token' => 'krypto-knight'
+                                                                         })
+        allow(service).to receive(:query)
+                              .with(anything, fqdn_hostname)
+                              .and_return(response_body_vmpooler)
+      end
+
+      let(:default_output_first_line) { "- [JobID:#{hostname}] <allocated>" }
+      let(:default_output_second_line) { "  - #{fqdn} (#{template})" }
+      let(:default_output_third_line) { "  - #{fqdn_ns} (#{template_ns})" }
+
+      it 'prints output with job id, host, and template' do
+        expect(STDOUT).to receive(:puts).with(default_output_first_line)
+        expect(STDOUT).to receive(:puts).with(default_output_second_line)
+        expect(STDOUT).to receive(:puts).with(default_output_third_line)
+
+        subject
+      end
+
+      context 'when print_to_stderr option is true' do
+        let(:print_to_stderr) { true }
+
+        it 'outputs to stderr instead of stdout' do
+          expect(STDERR).to receive(:puts).with(default_output_first_line)
+          expect(STDERR).to receive(:puts).with(default_output_second_line)
+          expect(STDERR).to receive(:puts).with(default_output_third_line)
+
+          subject
+        end
+      end
+    end
+  end
 
-      Utils.pretty_print_hosts(nil, service, hostname)
+  describe '#get_vmpooler_service_config' do
+    let(:Conf) { double }
+    it 'returns an error if the vmpooler_fallback is not setup' do
+      config = {
+        'user' => 'foo',
+        'services' => {
+            'myabs' => {
+              'url' => 'http://abs.com',
+              'token' => 'krypto-night',
+              'type' => 'abs'
+            }
+        }
+      }
+      allow(Conf).to receive(:read_config).and_return(config)
+      expect{Utils.get_vmpooler_service_config(config['services']['myabs']['vmpooler_fallback'])}.to raise_error(ArgumentError)
+    end
+    it 'returns an error if the vmpooler_fallback is setup but cannot be found' do
+      config = {
+        'user' => 'foo',
+        'services' => {
+          'myabs' => {
+              'url' => 'http://abs.com',
+              'token' => 'krypto-night',
+              'type' => 'abs',
+              'vmpooler_fallback' => 'myvmpooler'
+          }
+        }
+      }
+      allow(Conf).to receive(:read_config).and_return(config)
+      expect{Utils.get_vmpooler_service_config(config['services']['myabs']['vmpooler_fallback'])}.to raise_error(ArgumentError, /myvmpooler/)
+    end
+    it 'returns the vmpooler_fallback config' do
+      config = {
+        'user' => 'foo',
+        'services' => {
+          'myabs' => {
+              'url' => 'http://abs.com',
+              'token' => 'krypto-night',
+              'type' => 'abs',
+              'vmpooler_fallback' => 'myvmpooler'
+          },
+          'myvmpooler' => {
+              'url' => 'http://vmpooler.com',
+              'token' => 'krypto-knight'
+          }
+        }
+      }
+      allow(Conf).to receive(:read_config).and_return(config)
+      expect(Utils.get_vmpooler_service_config(config['services']['myabs']['vmpooler_fallback'])).to include({
+                                                                                       'url' => 'http://vmpooler.com',
+                                                                                       'token' => 'krypto-knight',
+                                                                                       'user' => 'foo',
+                                                                                       'type' => 'vmpooler'
+                                                                                   })
     end
   end
 end