From 7c3ad716af4ff58c55aeceb225e97dc1afbcffed Mon Sep 17 00:00:00 2001
From: Glenn Sarti <glennsarti@users.noreply.github.com>
Date: Fri, 31 Mar 2017 14:30:00 -0700
Subject: [PATCH] (POOLER-70) Update check_pool for VM Provider

Previously the Pool Manager would use a single VM provider per Pool.  This
commit changes Pool Manager to use a single provider that services multiple
pools.
---
 lib/vmpooler/pool_manager.rb   | 24 +++++++++++++++---------
 spec/unit/pool_manager_spec.rb | 26 +++++++-------------------
 2 files changed, 22 insertions(+), 28 deletions(-)

diff --git a/lib/vmpooler/pool_manager.rb b/lib/vmpooler/pool_manager.rb
index d8426f5..56e3074 100644
--- a/lib/vmpooler/pool_manager.rb
+++ b/lib/vmpooler/pool_manager.rb
@@ -522,18 +522,24 @@ module Vmpooler
     def check_pool(pool, maxloop = 0, loop_delay = 5)
       $logger.log('d', "[*] [#{pool['name']}] starting worker thread")
 
-      $providers[pool['name']] ||= Vmpooler::VsphereHelper.new $config, $metrics
-
       $threads[pool['name']] = Thread.new do
-        loop_count = 1
-        loop do
-          _check_pool(pool, $providers[pool['name']])
-          sleep(loop_delay)
+        begin
+          loop_count = 1
+          provider = get_provider_for_pool(pool['name'])
+          raise("Could not find provider '#{pool['provider']}") if provider.nil?
+          loop do
+            _check_pool(pool, provider)
 
-          unless maxloop.zero?
-            break if loop_count >= maxloop
-            loop_count += 1
+            sleep(loop_delay)
+
+            unless maxloop.zero?
+              break if loop_count >= maxloop
+              loop_count += 1
+            end
           end
+        rescue => err
+          $logger.log('s', "[!] [#{pool['name']}] Error while checking the pool: #{err}")
+          raise
         end
       end
     end
diff --git a/spec/unit/pool_manager_spec.rb b/spec/unit/pool_manager_spec.rb
index df5e317..3ff9985 100644
--- a/spec/unit/pool_manager_spec.rb
+++ b/spec/unit/pool_manager_spec.rb
@@ -1855,48 +1855,40 @@ EOT
 
  describe "#check_pool" do
     let(:threads) {{}}
-    let(:provider) {{}}
-
+    let(:provider_name) { 'mock_provider' }
     let(:config) {
       YAML.load(<<-EOT
 ---
 :pools:
   - name: #{pool}
+    provider: #{provider_name}
 EOT
       )
     }
 
-    let(:thread) { double('thread') }
     let(:pool_object) { config[:pools][0] }
 
     before do
       expect(subject).not_to be_nil
       expect(Thread).to receive(:new).and_yield
+      allow(subject).to receive(:get_provider_for_pool).with(pool).and_return(provider)
     end
 
     context 'on startup' do
       before(:each) do
-        # Note the Vmpooler::VsphereHelper is not mocked
-        allow(subject).to receive(:_check_pool)        
+        allow(subject).to receive(:_check_pool)
         expect(logger).to receive(:log).with('d', "[*] [#{pool}] starting worker thread")
       end
 
       after(:each) do
         # Reset the global variable - Note this is a code smell
         $threads = nil
-        $providers = nil
       end
 
       it 'should log a message the worker thread is starting' do
         subject.check_pool(pool_object,1,0)
       end
 
-      it 'should populate the providers global variable' do
-        subject.check_pool(pool_object,1,0)
-
-        expect($providers[pool]).to_not be_nil 
-      end
-
       it 'should populate the threads global variable' do
         subject.check_pool(pool_object,1,0)
 
@@ -1913,22 +1905,18 @@ EOT
       before(:each) do
         allow(logger).to receive(:log)
         # Note the Vmpooler::VsphereHelper is not mocked
-        allow(subject).to receive(:_check_pool)        
+        allow(subject).to receive(:_check_pool)
       end
 
       after(:each) do
         # Reset the global variable - Note this is a code smell
         $threads = nil
-        $provider = nil
       end
 
       it 'when a non-default loop delay is specified' do
-        start_time = Time.now
-        subject.check_pool(pool_object,maxloop,loop_delay)
-        finish_time = Time.now
+        expect(subject).to receive(:sleep).with(loop_delay).exactly(maxloop).times
 
-        # Use a generous delta to take into account various CPU load etc.
-        expect(finish_time - start_time).to be_within(0.75).of(maxloop * loop_delay)
+        subject.check_pool(pool_object,maxloop,loop_delay)
       end
     end