vmfloaty 0.9.1 → 1.0.0

data/spec/vmfloaty/pooler_spec.rb

@@ -84,6 +84,26 @@ describe Pooler do
       expect(vm_req['debian-7-i386']['hostname']).to eq %w[sc0o4xqtodlul5w 4m4dkhqiufnjmxy]
       expect(vm_req['centos-7-x86_64']['hostname']).to eq 'zb91y9qbrbf6d3q'
     end
+
+    context 'with ondemand provisioning' do
+      let(:ondemand_response) { '{"ok":true,"request_id":"1234"}' }
+      it 'retreives the vm with a token' do
+        stub_request(:post, "#{@vmpooler_url}/ondemandvm/debian-7-i386")
+          .with(:headers => { 'X-Auth-Token' => 'mytokenfile' })
+          .to_return(:status => 200, :body => ondemand_response, :headers => {})
+
+        stub_request(:get, "#{@vmpooler_url}/ondemandvm/1234")
+          .to_return(:status => 200, :body => @retrieve_response_body_single, :headers => {})
+
+        vm_hash = {}
+        vm_hash['debian-7-i386'] = 1
+        Pooler.retrieve(false, vm_hash, 'mytokenfile', @vmpooler_url, 'user', {}, true)
+        vm_req = Pooler.check_ondemandvm(false, '1234', @vmpooler_url)
+        expect(vm_req).to be_an_instance_of Hash
+        expect(vm_req['ok']).to equal true
+        expect(vm_req['debian-7-i386']['hostname']).to eq 'fq6qlpjlsskycq6'
+      end
+    end
   end
 
   describe '#modify' do

data/spec/vmfloaty/ssh_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'vmfloaty/ssh'
+
+class ServiceStub
+  def retrieve(_verbose, os_types, _use_token)
+    if os_types.keys[0] == 'abs_host_string'
+      return {
+        os_types.keys[0] => { 'hostname' => ['abs-hostname.delivery.puppetlabs.net'] },
+        'ok'             => true,
+      }
+    end
+
+    {
+      os_types.keys[0] => { 'hostname' => 'vmpooler-hostname' },
+      'domain'         => 'delivery.puppetlabs.net',
+      'ok'             => true,
+    }
+  end
+
+  def type
+    return 'abs' if os_types == 'abs_host_string'
+    return 'vmpooler' if os_types == 'vmpooler_host_string'
+  end
+end
+
+describe Ssh do
+  before :each do
+  end
+
+  it 'gets a hostname string for abs' do
+    verbose = false
+    service = ServiceStub.new
+    host_os = 'abs_host_string'
+    use_token = false
+    cmd = Ssh.command_string(verbose, service, host_os, use_token)
+    expect(cmd).to match(/ssh root@abs-hostname.delivery.puppetlabs.net/)
+  end
+
+  it 'gets a hostname string for vmpooler' do
+    verbose = false
+    service = ServiceStub.new
+    host_os = 'vmpooler_host_string'
+    use_token = false
+    cmd = Ssh.command_string(verbose, service, host_os, use_token)
+    expect(cmd).to match(/ssh root@vmpooler-hostname.delivery.puppetlabs.net/)
+  end
+end

data/spec/vmfloaty/utils_spec.rb

@@ -77,9 +77,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 +162,452 @@ 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(Utils).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(Utils).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(Utils).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} (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} (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(Utils).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}, 7.67/48 hours, user: bob, role: agent)" }
+
+      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
+
+      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}, 7.67/48 hours, user: bob, role: agent)" }
+      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