vm_shepherd 1.11.3 → 1.11.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3ea022dca3043409c217daf3acaffbcc0ee73205
-  data.tar.gz: 33265e1f41141d6bcf281f58d887369fb880484a
+  metadata.gz: 82f7c7627b1e94f6470ded478ab7ea83b2c29416
+  data.tar.gz: 6724ee44b46ca3e1a5ca046425cbda5070ccfd4d
 SHA512:
-  metadata.gz: 074f1d4cdc3b3d965e2d8a0c4e5dd25a5d0c747a19787c044af44aa64517fab81166b03b7d8f7217801f55b369c4565e22ae03ac12956501f6334680d1c65737
-  data.tar.gz: c15a7975823d8532fd886488b04bcefed4129ef1b67b92cb8a665fa89447bc2c09a41836dea396e165db633fd513899e33f4a38246b1b928570369d884bc2c61
+  metadata.gz: df11263d19bdeb301a263a1892a749c243ab55ed333a968d9d309fb5fce2c942219705fc9afe3c6ae1742a4344d5fe012c9d0bc8ae5fb9ee3db39eb387576bd0
+  data.tar.gz: 845334333f9acd9fc64051142e169a060b7934600ea7f3c02716333495fda93adb2b312e7dea5c945db84fdbf1fd4eef110517a4f943ef5833e203ec5070203c

data/lib/vm_shepherd/vcloud/destroyer.rb

@@ -2,12 +2,12 @@ module VmShepherd
   module Vcloud
     class Destroyer
       def initialize(client:, vdc_name:)
-        @client   = client
+        @client = client
         @vdc_name = vdc_name
       end
 
-      def delete_catalog_and_vms(catalog, vapp_names, logger)
-        delete_vms_in_vapps(vapp_names, logger)
+      def clean_catalog_and_vapps(catalog:, vapp_names:, logger:, delete_vapps:)
+        clean_vapps(vapp_names, logger, delete_vapps)
         delete_catalog(catalog)
       end
 
@@ -17,21 +17,18 @@ module VmShepherd
         @vdc ||= @client.find_vdc_by_name(@vdc_name)
       end
 
-      def delete_vms_in_vapps(vapp_names, logger)
+      def clean_vapps(vapp_names, logger, delete_vapps)
         vapp_names.each do |vapp_name|
           begin
-            delete_vms_in_vapp(vapp_name)
+            clean_vapp(vapp_name)
+            delete_vapp(vapp_name) if delete_vapps
           rescue VCloudSdk::ObjectNotFoundError => e
             logger.debug "Could not delete vapp '#{vapp_name}': #{e.inspect}"
           end
         end
       end
 
-      def delete_catalog(catalog)
-        @client.delete_catalog_by_name(catalog) if @client.catalog_exists?(catalog)
-      end
-
-      def delete_vms_in_vapp(vapp_name)
+      def clean_vapp(vapp_name)
         vapp = vdc.find_vapp_by_name(vapp_name)
         vapp.vms.map do |vm|
           vm.independent_disks.map do |disk|
@@ -40,6 +37,16 @@ module VmShepherd
           end
         end
       end
+
+      def delete_vapp(vapp_name)
+        vapp = vdc.find_vapp_by_name(vapp_name)
+        vapp.power_off
+        vapp.delete
+      end
+
+      def delete_catalog(catalog)
+        @client.delete_catalog_by_name(catalog) if @client.catalog_exists?(catalog)
+      end
     end
   end
 end

data/lib/vm_shepherd/vcloud_manager.rb

@@ -35,11 +35,12 @@ module VmShepherd
 
     def destroy(vapp_names, catalog)
       VmShepherd::Vcloud::Destroyer.new(client: client, vdc_name: @vdc_name).
-        delete_catalog_and_vms(catalog, vapp_names, @logger)
+        clean_catalog_and_vapps(catalog: catalog, vapp_names: vapp_names, logger: @logger, delete_vapps: true)
     end
 
     def clean_environment(vapp_names, catalog)
-      destroy(vapp_names, catalog)
+      VmShepherd::Vcloud::Destroyer.new(client: client, vdc_name: @vdc_name).
+        clean_catalog_and_vapps(catalog: catalog, vapp_names: vapp_names, logger: @logger, delete_vapps: false)
     end
 
     private

data/lib/vm_shepherd/version.rb

@@ -1,3 +1,3 @@
 module VmShepherd
-  VERSION = '1.11.3'.freeze
+  VERSION = '1.11.4'.freeze
 end

data/spec/vm_shepherd/vcloud/destroyer_spec.rb

@@ -28,14 +28,14 @@ module VmShepherd
         allow(vm).to receive(:detach_disk)
       end
 
-      describe '#delete_catalog_and_vms' do
+      describe '#clean_catalog_and_vapps' do
         context 'when the catalog exists' do
           before do
             allow(client).to receive(:catalog_exists?).with('CATALOG_NAME').and_return(true)
           end
 
           it 'deletes the catalog' do
-            destroyer.delete_catalog_and_vms('CATALOG_NAME', [], fake_logger)
+            destroyer.clean_catalog_and_vapps(catalog: 'CATALOG_NAME', vapp_names: [], logger: fake_logger, delete_vapps: false)
 
             expect(client).to have_received(:delete_catalog_by_name).with('CATALOG_NAME')
           end
@@ -47,18 +47,36 @@ module VmShepherd
           end
 
           it 'skips deleting the catalog' do
-            destroyer.delete_catalog_and_vms('CATALOG_NAME', [], fake_logger)
+            destroyer.clean_catalog_and_vapps(catalog: 'CATALOG_NAME', vapp_names: [], logger: fake_logger, delete_vapps: false)
 
             expect(client).not_to have_received(:delete_catalog_by_name).with('CATALOG_NAME')
           end
         end
 
         it 'detaches and deletes persistent disks' do
-          destroyer.delete_catalog_and_vms('CATALOG_NAME', ['VAPP_NAME'], fake_logger)
+          destroyer.clean_catalog_and_vapps(catalog: 'CATALOG_NAME', vapp_names: ['VAPP_NAME'], logger: fake_logger, delete_vapps: false)
 
           expect(vm).to have_received(:detach_disk).with(disk)
           expect(vdc).to have_received(:delete_disk_by_name).with('DISK_NAME')
         end
+
+        context 'when the delete_vapps flag is true' do
+          it 'deletes the vapps' do
+            destroyer.clean_catalog_and_vapps(catalog: 'CATALOG_NAME', vapp_names: ['VAPP_NAME'], logger: fake_logger, delete_vapps: true)
+
+            expect(vapp).to have_received(:power_off).ordered
+            expect(vapp).to have_received(:delete).ordered
+          end
+        end
+
+        context 'when the delete_vapps flag is false' do
+          it 'does not delete the vapps' do
+            destroyer.clean_catalog_and_vapps(catalog: 'CATALOG_NAME', vapp_names: ['VAPP_NAME'], logger: fake_logger, delete_vapps: false)
+
+            expect(vapp).not_to have_received(:power_off)
+            expect(vapp).not_to have_received(:delete)
+          end
+        end
       end
     end
   end

data/spec/vm_shepherd/vcloud_manager_spec.rb

@@ -264,101 +264,37 @@ module VmShepherd
 
     describe '#destroy' do
       let(:client) { instance_double(VCloudSdk::Client) }
-      let(:vdc) { instance_double(VCloudSdk::VDC) }
-      let(:vapp) { instance_double(VCloudSdk::VApp) }
       let(:vapp_name) { 'FAKE_VAPP_NAME' }
       let(:vapp_catalog) { 'FAKE_VAPP_CATALOG' }
-      let(:vm) { instance_double(VCloudSdk::VM) }
-      let(:disk) { instance_double(VCloudSdk::InternalDisk, name: 'disk name') }
 
       before do
-        allow(vapp).to receive(:vms).and_return([vm])
-        allow(vm).to receive(:independent_disks).and_return([disk])
+        allow(VCloudSdk::Client).to receive(:new).and_return(client)
       end
 
-      context 'when the catalog exists' do
-        before do
-          allow(client).to receive(:catalog_exists?).with(vapp_catalog).and_return(true)
-        end
-
-        it 'uses VCloudSdk::Client to delete the vApp' do
-          expect(client).to receive(:find_vdc_by_name).with(vdc_name).and_return(vdc)
-          expect(vdc).to receive(:find_vapp_by_name).with(vapp_name).and_return(vapp)
-          expect(vm).to receive(:detach_disk).with(disk)
-          expect(vdc).to receive(:delete_disk_by_name).with('disk name')
-          expect(client).to receive(:delete_catalog_by_name).with(vapp_catalog)
-
-          expect(VCloudSdk::Client).to receive(:new).with(
-              login_info.fetch(:url),
-              [login_info.fetch(:user), login_info.fetch(:organization)].join('@'),
-              login_info.fetch(:password),
-              {},
-              logger,
-            ).and_return(client)
-
-          vcloud_manager.destroy([vapp_name], vapp_catalog)
-        end
-
-        context 'when an VCloudSdk::ObjectNotFoundError is thrown' do
-          before do
-            allow(VCloudSdk::Client).to receive(:new).and_return(client)
-            allow(client).to receive(:find_vdc_by_name).and_return(vdc)
-            allow(vdc).to receive(:find_vapp_by_name).and_return(vapp)
-            allow(vm).to receive(:detach_disk)
-            allow(vdc).to receive(:delete_disk_by_name)
-            allow(vapp).to receive(:power_off)
-            allow(vapp).to receive(:delete)
-
-            allow(client).to receive(:delete_catalog_by_name)
-          end
-
-          it 'catches the error' do
-            allow(vdc).to receive(:find_vapp_by_name).and_raise(VCloudSdk::ObjectNotFoundError)
-
-            expect { vcloud_manager.destroy([vapp_name], vapp_catalog) }.not_to raise_error
-          end
-
-          it 'deletes to catalog' do
-            expect(client).to receive(:delete_catalog_by_name).with(vapp_catalog)
+      it 'destroys everything including vapps' do
+        destroyer = instance_double(VmShepherd::Vcloud::Destroyer)
+        expect(VmShepherd::Vcloud::Destroyer).to receive(:new).with(client: client, vdc_name: vdc_name).and_return(destroyer)
+        expect(destroyer).to receive(:clean_catalog_and_vapps).with(catalog: vapp_catalog, vapp_names: [vapp_name], logger: logger, delete_vapps: true)
 
-            vcloud_manager.destroy([vapp_name], vapp_catalog)
-          end
-        end
-      end
-
-      context 'when the catalog does not exist' do
-        before do
-          allow(client).to receive(:catalog_exists?).with(vapp_catalog).and_return(false)
-        end
-
-        it 'uses VCloudSdk::Client to delete the vApp' do
-          expect(client).to receive(:find_vdc_by_name).with(vdc_name).and_return(vdc)
-          expect(vdc).to receive(:find_vapp_by_name).with(vapp_name).and_return(vapp)
-          expect(vm).to receive(:detach_disk).with(disk)
-          expect(vdc).to receive(:delete_disk_by_name).with('disk name')
-          expect(client).not_to receive(:delete_catalog_by_name).with(vapp_catalog)
-
-          expect(VCloudSdk::Client).to receive(:new).with(
-              login_info.fetch(:url),
-              [login_info.fetch(:user), login_info.fetch(:organization)].join('@'),
-              login_info.fetch(:password),
-              {},
-              logger,
-            ).and_return(client)
-
-          vcloud_manager.destroy([vapp_name], vapp_catalog)
-        end
+        vcloud_manager.destroy([vapp_name], vapp_catalog)
       end
     end
 
     describe '#clean_environment' do
-      let(:vapp_names) { ['VAPP_ONE', 'VAPP_TWO'] }
+      let(:client) { instance_double(VCloudSdk::Client) }
+      let(:vapp_name) { ['VAPP_ONE', 'VAPP_TWO'] }
       let(:vapp_catalog) { 'VAPP_CATALOG' }
 
-      it 'calls #destroy' do
-        expect(vcloud_manager).to receive(:destroy).with(vapp_names, vapp_catalog)
+      before do
+        allow(VCloudSdk::Client).to receive(:new).and_return(client)
+      end
+
+      it 'destroys the environment expect for vapps' do
+        destroyer = instance_double(VmShepherd::Vcloud::Destroyer)
+        expect(VmShepherd::Vcloud::Destroyer).to receive(:new).with(client: client, vdc_name: vdc_name).and_return(destroyer)
+        expect(destroyer).to receive(:clean_catalog_and_vapps).with(catalog: vapp_catalog, vapp_names: [vapp_name], logger: logger, delete_vapps: false)
 
-        vcloud_manager.clean_environment(vapp_names, vapp_catalog)
+        vcloud_manager.clean_environment([vapp_name], vapp_catalog)
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vm_shepherd
 version: !ruby/object:Gem::Version
-  version: 1.11.3
+  version: 1.11.4
 platform: ruby
 authors:
 - Ops Manager Team