vm_shepherd 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6d6273df41a1db4583c88e2b1139acf836f78983
-  data.tar.gz: 94c0f08587030e100ed9d6dd534769b876516165
+  metadata.gz: e6cdd5ba469fb3cfa60e574e87ef6c374432b22f
+  data.tar.gz: dd14790e5da479762cbb30a2d65b550df146d636
 SHA512:
-  metadata.gz: d03b514667b963aa9f8e15a377258a49fc8d68bf32a806203e3996549bce3ac3d6642dbd04145d71a9688843e86fb0a5f268a796c1da4be20473a8f35c4396d1
-  data.tar.gz: 8559843b647a40f7c09a5ecd95f1063999592e60eb9628a5e0f9cc0718680da97e268ef871000d17f99f2c5c7b4e47cdcdbf8c021775037e6eaa774579a7b2a7
+  metadata.gz: 8f9f862403579de226ee581bbc3ff9305ff95657e23e03c278a73972e8c74e21d43310b33f89be4e31914a7602b800dfe59b010297e1cdb8fbb86e8452bafb65
+  data.tar.gz: 1031f76997f1fdb383d1ac36de08c9edae15cad882df6290b9cb62d423e357b9d67b3947e34e2b8c77302125c39085768c780def915be2b180483f5d1fc363ae

data/.gitignore

@@ -12,3 +12,4 @@
 *.o
 *.a
 mkmf.log
+.idea

data/.ruby-version

@@ -1 +1 @@
-2.1.5
+2.2.1

data/lib/vm_shepherd/aws_manager.rb

@@ -42,15 +42,30 @@ module VmShepherd
       instance.add_tag('Name', value: aws_options.fetch(:vm_name))
     end
 
-    def destroy
+    def clean_environment
       subnets = [
         AWS.ec2.subnets[aws_options.fetch(:public_subnet_id)],
         AWS.ec2.subnets[aws_options.fetch(:private_subnet_id)]
       ]
 
+      volumes = []
       subnets.each do |subnet|
         subnet.instances.each do |instance|
-          instance.terminate unless instance.tags.to_h.fetch(DO_NOT_TERMINATE_TAG_KEY, false)
+          unless instance.tags.to_h.fetch(DO_NOT_TERMINATE_TAG_KEY, false)
+            instance.attachments.each do |_, attachment|
+              volumes.push(attachment.volume) unless attachment.delete_on_termination
+            end
+            instance.terminate
+          end
+        end
+      end
+      destroy_volumes(volumes)
+    end
+
+    def destroy
+      AWS.ec2.elastic_ips.each do |elastic_ip|
+        if elastic_ip.allocation_id == aws_options.fetch(:elastic_ip_id)
+          elastic_ip.instance.terminate if elastic_ip.instance
         end
       end
     end
@@ -58,6 +73,16 @@ module VmShepherd
     private
     attr_reader :aws_options
 
+    def destroy_volumes(volumes)
+      volumes.each do |volume|
+        begin
+          volume.delete
+        rescue AWS::EC2::Errors::VolumeInUse
+          sleep 5
+          retry
+        end
+      end
+    end
 
     def retry_ignoring_error_until(exception_class, &block)
       tries = 0

data/lib/vm_shepherd/openstack_manager.rb

@@ -61,6 +61,9 @@ module VmShepherd
       say('Done destroying Ops Manager instances')
     end
 
+    def clean_environment
+    end
+
     def service
       @service ||= Fog::Compute.new(
         provider: 'openstack',

data/lib/vm_shepherd/shepherd.rb

@@ -1,8 +1,6 @@
 module VmShepherd
   class Shepherd
-    class InvalidIaas < StandardError
-
-    end
+    class InvalidIaas < StandardError; end
 
     def initialize(settings:)
       @settings = settings
@@ -76,14 +74,14 @@ module VmShepherd
               network: settings.vapp_deployer.vdc.network,
             },
             logger
-          ).destroy(settings.vapp_deployer.vapp.name)
+          ).destroy([settings.vapp_deployer.vapp.ops_manager_name] + settings.vapp_deployer.vapp.product_names)
         when VmShepherd::VSPHERE_IAAS_TYPE then
           VmShepherd::VsphereManager.new(
             settings.vm_deployer.vcenter_creds.ip,
             settings.vm_deployer.vcenter_creds.username,
             settings.vm_deployer.vcenter_creds.password,
             settings.vm_deployer.vsphere.datacenter,
-          ).destroy(settings.vm_deployer.vsphere.folder)
+          ).destroy(settings.vm_deployer.vm.ip)
         when VmShepherd::AWS_IAAS_TYPE then
           ami_manager.destroy
         when VmShepherd::OPENSTACK_IAAS_TYPE then
@@ -93,6 +91,43 @@ module VmShepherd
       end
     end
 
+    def clean_environment
+      case settings.iaas_type
+        when VmShepherd::VCLOUD_IAAS_TYPE then
+          VmShepherd::VcloudManager.new(
+            {
+              url: settings.vapp_deployer.creds.url,
+              organization: settings.vapp_deployer.creds.organization,
+              user: settings.vapp_deployer.creds.user,
+              password: settings.vapp_deployer.creds.password,
+            },
+            {
+              vdc: settings.vapp_deployer.vdc.name,
+              catalog: settings.vapp_deployer.vdc.catalog,
+              network: settings.vapp_deployer.vdc.network,
+            },
+            logger
+          ).clean_environment
+        when VmShepherd::VSPHERE_IAAS_TYPE then
+          VmShepherd::VsphereManager.new(
+            settings.vm_deployer.vcenter_creds.ip,
+            settings.vm_deployer.vcenter_creds.username,
+            settings.vm_deployer.vcenter_creds.password,
+            settings.vm_deployer.vsphere.datacenter,
+          ).clean_environment(
+            datacenter_folders_to_clean: settings.vm_deployer.vsphere.datacenter_folders_to_clean,
+            datastore: settings.vm_deployer.vsphere.datastore,
+            datastore_folders_to_clean: settings.vm_deployer.vsphere.datastore_folders_to_clean,
+          )
+        when VmShepherd::AWS_IAAS_TYPE then
+          ami_manager.clean_environment
+        when VmShepherd::OPENSTACK_IAAS_TYPE then
+          openstack_vm_manager.clean_environment
+        else
+          fail(InvalidIaas, "Unknown IaaS type: #{settings.iaas_type.inspect}")
+      end
+    end
+
     private
 
     attr_reader :settings

data/lib/vm_shepherd/vcloud_manager.rb

@@ -27,11 +27,14 @@ module VmShepherd
       FileUtils.remove_entry_secure(tmpdir, force: true)
     end
 
-    def destroy(vapp_name)
-      delete_vapp(vapp_name)
+    def destroy(vapp_names)
+      delete_vapps(vapp_names)
       delete_catalog
     end
 
+    def clean_environment
+    end
+
     private
 
     def check_vapp_status(vapp_config)
@@ -155,12 +158,16 @@ module VmShepherd
       @vdc ||= client.find_vdc_by_name(@location[:vdc])
     end
 
-    def delete_vapp(vapp_name)
-      vapp = vdc.find_vapp_by_name(vapp_name)
-      vapp.power_off
-      vapp.delete
-    rescue VCloudSdk::ObjectNotFoundError => e
-      @logger.debug "Could not delete vapp '#{vapp_name}': #{e.inspect}"
+    def delete_vapps(vapp_names)
+      vapp_names.each do |vapp_name|
+        begin
+          vapp = vdc.find_vapp_by_name(vapp_name)
+          vapp.power_off
+          vapp.delete
+        rescue VCloudSdk::ObjectNotFoundError => e
+          @logger.debug "Could not delete vapp '#{vapp_name}': #{e.inspect}"
+        end
+      end
     end
 
     def delete_catalog

data/lib/vm_shepherd/version.rb

@@ -1,3 +1,3 @@
 module VmShepherd
-  VERSION = '0.1.2'.freeze
+  VERSION = '0.2.0'.freeze
 end

data/lib/vm_shepherd/vsphere_manager.rb

@@ -5,6 +5,9 @@ module VmShepherd
   class VsphereManager
     TEMPLATE_PREFIX = 'tpl'.freeze
     VALID_FOLDER_REGEX = /\A([\w-]{1,80}\/)*[\w-]{1,80}\/?\z/
+    VALID_DISK_FOLDER_REGEX = /\A[\w-]{1,80}\z/
+
+    attr_writer :logger
 
     def initialize(host, username, password, datacenter_name)
       @host = host
@@ -26,10 +29,41 @@ module VmShepherd
       FileUtils.remove_entry_secure(ovf_file_path, force: true) unless ovf_file_path.nil?
     end
 
-    def destroy(folder_name)
-      validate_folder_name!(folder_name)
+    def clean_environment(datacenter_folders_to_clean:, datastore:, datastore_folders_to_clean:)
+      datacenter_folders_to_clean.each do |folder_name|
+        validate_folder_name!(folder_name)
+        delete_folder_and_vms(folder_name)
+      end
+
+      datastore_folders_to_clean.each do |folder_name|
+        VALID_DISK_FOLDER_REGEX.match(folder_name) || fail("#{folder_name.inspect} is not a valid disk folder name")
+        begin
+          logger.info("BEGIN datastore_folder.destroy_task folder=#{folder_name}")
+
+          connection.serviceContent.fileManager.DeleteDatastoreFile_Task(
+            datacenter: datacenter,
+            name: "[#{datastore}] #{folder_name}"
+          ).wait_for_completion
+
+          logger.info("END   datastore_folder.destroy_task folder=#{folder_name}")
+        rescue RbVmomi::Fault => e
+          logger.info("ERROR datastore_folder.destroy_task folder=#{folder_name} #{e.inspect}")
+        end
+      end
+    end
+
+    def destroy(ip_address)
+      vm = datacenter.vmFolder.findByIp(ip_address)
+      return unless vm
+      power_off_vm(vm)
+      destroy_vm(vm)
+    end
 
-      delete_folder_and_vms(folder_name)
+    def destroy_vm(vm)
+      vm_name = vm.name
+      logger.info("BEGIN vm.destroy_task vm=#{vm_name}")
+      vm.Destroy_Task.wait_for_completion
+      logger.info("END   vm.destroy_task vm=#{vm_name}")
     end
 
     private
@@ -79,7 +113,7 @@ module VmShepherd
       folder = datacenter.vmFolder.traverse(folder_name) ||
         fail("ERROR no folder found with name=#{folder_name.inspect}")
 
-      find_vms(folder).each { |vm| power_off(vm) }
+      find_vms(folder).each { |vm| power_off_vm(vm) }
 
       logger.info("BEGIN folder.destroy_task folder=#{folder_name}")
       folder.Destroy_Task.wait_for_completion
@@ -87,7 +121,7 @@ module VmShepherd
 
       fail("#{folder_name.inspect} already exists") unless datacenter.vmFolder.traverse(folder_name).nil?
     rescue RbVmomi::Fault => e
-      logger.info("ERROR folder.destroy_task folder=#{folder_name}", e)
+      logger.info("ERROR folder.destroy_task folder=#{folder_name} #{e.inspect}")
       raise
     end
 
@@ -97,7 +131,7 @@ module VmShepherd
       vms.flatten
     end
 
-    def power_off(vm)
+    def power_off_vm(vm)
       2.times do
         break if vm.runtime.powerState == 'poweredOff'
 

data/spec/fixtures/shepherd/vcloud.yml

@@ -10,7 +10,10 @@ vapp_deployer:
     catalog: VDC_CATALOG
     network: VDC_NETWORK
   vapp:
-    name: VAPP_NAME
+    ops_manager_name: VAPP_NAME
+    product_names:
+    - PRODUCT_1
+    - PRODUCT_2
     ip: VAPP_IP
     public_ip:
     gateway: VAPP_GATEWAY

data/spec/fixtures/shepherd/vsphere.yml

@@ -12,6 +12,11 @@ vm_deployer:
     resource_pool: VSPHERE_RESOURCE_POOL
     datastore: VSPHERE_DATASTORE
     folder: VSPHERE_FOLDER
+    datacenter_folders_to_clean:
+      - DC_FOLDER_ONE
+      - DC_FOLDER_TWO
+    datastore_folders_to_clean:
+      - DS_DISK_FOLDER
   vm:
     ip: OVA_IP
     gateway: OVA_GATEWAY

data/spec/vm_shepherd/aws_manager_spec.rb

@@ -6,6 +6,7 @@ module VmShepherd
     let(:secret_key) { 'secret-key' }
     let(:ami_id) { 'ami-deadbeef' }
     let(:ami_file_path) { Tempfile.new('ami-id-file').tap { |f| f.write("#{ami_id}\n"); f.close }.path }
+    let(:elastic_ip_id) { 'elastic-ip-id' }
     let(:ec2) { double('AWS.ec2') }
 
     let(:aws_options) do
@@ -16,7 +17,7 @@ module VmShepherd
         security_group_id: 'security-group-id',
         public_subnet_id: 'public-subnet-id',
         private_subnet_id: 'private-subnet-id',
-        elastic_ip_id: 'elastic-ip-id',
+        elastic_ip_id: elastic_ip_id,
         vm_name: 'Ops Manager: clean_install_spec'
       }
     end
@@ -103,7 +104,7 @@ module VmShepherd
       end
     end
 
-    describe '#destroy' do
+    describe '#clean_environment' do
       let(:subnets) { instance_double(AWS::EC2::SubnetCollection) }
       let(:subnet1) { instance_double(AWS::EC2::Subnet, instances: subnet1_instances) }
       let(:subnet2) { instance_double(AWS::EC2::Subnet, instances: subnet2_instances) }
@@ -112,17 +113,25 @@ module VmShepherd
       let(:subnet1_instances) { [instance1] }
       let(:subnet2_instances) { [instance2] }
 
+      let(:instance1_volume) { instance_double(AWS::EC2::Volume)}
+      let(:instance1_attachment) do
+        instance_double(AWS::EC2::Attachment, volume: instance1_volume, delete_on_termination: true)
+      end
+
       before do
         allow(ec2).to receive(:subnets).and_return(subnets)
         allow(subnets).to receive(:[]).with('public-subnet-id').and_return(subnet1)
         allow(subnets).to receive(:[]).with('private-subnet-id').and_return(subnet2)
+
+        allow(instance1).to receive(:attachments).and_return({'/dev/test' => instance1_attachment})
+        allow(instance2).to receive(:attachments).and_return({})
       end
 
       it 'terminates all VMs in the subnet' do
         expect(instance1).to receive(:terminate)
         expect(instance2).to receive(:terminate)
 
-        ami_manager.destroy
+        ami_manager.clean_environment
       end
 
       context 'when an instance has the magical tag' do
@@ -136,6 +145,67 @@ module VmShepherd
             expect(instance2).to receive(:terminate)
             expect(persistent_instance).not_to receive(:terminate)
 
+            ami_manager.clean_environment
+          end
+        end
+      end
+
+      context 'when the instance has volumes that are NOT delete_on_termination' do
+        let(:instance1_attachment) do
+          instance_double(AWS::EC2::Attachment, volume: instance1_volume, delete_on_termination: false)
+        end
+
+        before do
+          allow(instance1).to receive(:terminate)
+          allow(instance2).to receive(:terminate)
+        end
+
+        it 'deletes the volumes' do
+          expect(instance1_volume).to receive(:delete)
+
+          ami_manager.clean_environment
+        end
+
+        context 'when the instance has not finished termination' do
+          before do
+            expect(instance1_volume).to receive(:delete).and_raise(AWS::EC2::Errors::VolumeInUse)
+            expect(instance1_volume).to receive(:delete).and_return(nil)
+            allow(ami_manager).to receive(:sleep)
+          end
+
+          it 'retries the delete' do
+            ami_manager.clean_environment
+          end
+        end
+      end
+    end
+
+    describe '#destroy' do
+      let(:elastic_ips) { instance_double(AWS::EC2::ElasticIpCollection) }
+      let(:elastic_ip) { instance_double(AWS::EC2::ElasticIp, instance: instance, allocation_id: elastic_ip_id) }
+      let(:instance) { instance_double(AWS::EC2::Instance, tags: {}) }
+
+      before do
+        allow(ec2).to receive(:elastic_ips).and_return(elastic_ips)
+        allow(elastic_ips).to receive(:each).and_yield(elastic_ip)
+      end
+
+      it 'terminates the VM that matches the IP' do
+        expect(instance).to receive(:terminate)
+
+        ami_manager.destroy
+      end
+
+      context 'when an instance has the magical tag' do
+        let(:persistent_instance) { instance_double(AWS::EC2::Instance, tags: persist_tag) }
+        let(:instances) { [instance1, instance2, persistent_instance] }
+
+        context 'when there is no instance attached' do
+          before do
+            allow(elastic_ip).to receive(:instance).and_return(nil)
+          end
+
+          it 'does not explode' do
             ami_manager.destroy
           end
         end

data/spec/vm_shepherd/shepherd_spec.rb

@@ -12,7 +12,7 @@ module VmShepherd
         end
         let(:vcloud_manager) { instance_double(VcloudManager) }
 
-        it 'uses VcloudManager::Deployer to launch a vm' do
+        it 'uses VcloudManager to launch a vm' do
           expect(VcloudManager).to receive(:new).
               with(
                 {
@@ -51,7 +51,7 @@ module VmShepherd
         end
         let(:ova_manager) { instance_double(VsphereManager) }
 
-        it 'uses VsphereManager::Deployer to launch a vm' do
+        it 'uses VsphereManager to launch a vm' do
           expect(VsphereManager).to receive(:new).with(
               settings.vm_deployer.vcenter_creds.ip,
                 settings.vm_deployer.vcenter_creds.username,
@@ -100,7 +100,7 @@ module VmShepherd
           }
         end
 
-        it 'uses AwsManager::Deployer to launch a VM' do
+        it 'uses AwsManager to launch a VM' do
           expect(AwsManager).to receive(:new).with(aws_options).and_return(ams_manager)
           expect(ams_manager).to receive(:deploy).with(ami_file_path)
           manager.deploy(path: ami_file_path)
@@ -137,7 +137,7 @@ module VmShepherd
           }
         end
 
-        it 'uses QCow2Manager to launch a VM' do
+        it 'uses OpenstackManager to launch a VM' do
           expect(OpenstackManager).to receive(:new).with(openstack_options).and_return(qcow2_manager)
           expect(qcow2_manager).to receive(:deploy).with(qcow2_file_path, openstack_vm_options)
           manager.deploy(path: qcow2_file_path)
@@ -162,7 +162,7 @@ module VmShepherd
         end
         let(:vcloud_manager) { instance_double(VcloudManager) }
 
-        it 'uses VcloudManager::Destroyer to destroy a vm' do
+        it 'uses VcloudManager to destroy a vm' do
           expect(VcloudManager).to receive(:new).with(
               {
                 url: settings.vapp_deployer.creds.url,
@@ -177,7 +177,8 @@ module VmShepherd
               },
               instance_of(Logger)
             ).and_return(vcloud_manager)
-          expect(vcloud_manager).to receive(:destroy).with(settings.vapp_deployer.vapp.name)
+          vapp_names = [settings.vapp_deployer.vapp.ops_manager_name] + settings.vapp_deployer.vapp.product_names
+          expect(vcloud_manager).to receive(:destroy).with(vapp_names)
 
           manager.destroy
         end
@@ -189,14 +190,14 @@ module VmShepherd
         end
         let(:ova_manager) { instance_double(VsphereManager) }
 
-        it 'uses VsphereManager::Destroyer to destroy a vm' do
+        it 'uses VsphereManager to destroy a vm' do
           expect(VsphereManager).to receive(:new).with(
               settings.vm_deployer.vcenter_creds.ip,
               settings.vm_deployer.vcenter_creds.username,
               settings.vm_deployer.vcenter_creds.password,
               settings.vm_deployer.vsphere.datacenter,
             ).and_return(ova_manager)
-          expect(ova_manager).to receive(:destroy).with(settings.vm_deployer.vsphere.folder)
+          expect(ova_manager).to receive(:destroy).with(settings.vm_deployer.vm.ip)
 
           manager.destroy
         end
@@ -207,7 +208,7 @@ module VmShepherd
           RecursiveOpenStruct.new(YAML.load_file(File.join(SPEC_ROOT, 'fixtures', 'shepherd', 'aws.yml')))
         end
         let(:ams_manager) { instance_double(AwsManager) }
-        let(:ami_destroy_options) do
+        let(:ami_options) do
           {
             aws_access_key: 'aws-access-key',
             aws_secret_key: 'aws-secret-key',
@@ -220,8 +221,8 @@ module VmShepherd
           }
         end
 
-        it 'uses AwsManager::Deployer to launch a VM' do
-          expect(AwsManager).to receive(:new).with(ami_destroy_options).and_return(ams_manager)
+        it 'uses AwsManager to destroy a VM' do
+          expect(AwsManager).to receive(:new).with(ami_options).and_return(ams_manager)
           expect(ams_manager).to receive(:destroy)
           manager.destroy
         end
@@ -257,7 +258,7 @@ module VmShepherd
           }
         end
 
-        it 'uses QCow2Manager to destroy a VM' do
+        it 'uses OpenstackManager to destroy a VM' do
           expect(OpenstackManager).to receive(:new).with(openstack_options).and_return(qcow2_manager)
           expect(qcow2_manager).to receive(:destroy).with(openstack_vm_options)
           manager.destroy
@@ -270,7 +271,119 @@ module VmShepherd
         end
 
         it 'raises an exception' do
-          expect { manager.deploy(path: 'FAKE_PATH') }.to raise_error(Shepherd::InvalidIaas)
+          expect { manager.destroy }.to raise_error(Shepherd::InvalidIaas)
+        end
+      end
+    end
+
+    describe '#clean_environment' do
+      context 'when IAAS is vcloud' do
+        let(:settings) do
+          RecursiveOpenStruct.new(YAML.load_file(File.join(SPEC_ROOT, 'fixtures', 'shepherd', 'vcloud.yml')))
+        end
+        let(:vcloud_manager) { instance_double(VcloudManager) }
+
+        it 'uses VcloudManager to destroy a vm' do
+          expect(VcloudManager).to receive(:new).with(
+              {
+                url: settings.vapp_deployer.creds.url,
+                organization: settings.vapp_deployer.creds.organization,
+                user: settings.vapp_deployer.creds.user,
+                password: settings.vapp_deployer.creds.password,
+              },
+              {
+                vdc: settings.vapp_deployer.vdc.name,
+                catalog: settings.vapp_deployer.vdc.catalog,
+                network: settings.vapp_deployer.vdc.network,
+              },
+              instance_of(Logger)
+            ).and_return(vcloud_manager)
+          expect(vcloud_manager).to receive(:clean_environment)
+
+          manager.clean_environment
+        end
+      end
+
+      context 'when IAAS is vsphere' do
+        let(:settings) do
+          RecursiveOpenStruct.new(YAML.load_file(File.join(SPEC_ROOT, 'fixtures', 'shepherd', 'vsphere.yml')))
+        end
+        let(:ova_manager) { instance_double(VsphereManager) }
+        let(:clean_environment_options) do
+          {
+            datacenter_folders_to_clean: settings.vm_deployer.vsphere.datacenter_folders_to_clean,
+            datastore: settings.vm_deployer.vsphere.datastore,
+            datastore_folders_to_clean: settings.vm_deployer.vsphere.datastore_folders_to_clean,
+          }
+        end
+
+        it 'uses VsphereManager to destroy a vm' do
+          expect(VsphereManager).to receive(:new).with(
+              settings.vm_deployer.vcenter_creds.ip,
+              settings.vm_deployer.vcenter_creds.username,
+              settings.vm_deployer.vcenter_creds.password,
+              settings.vm_deployer.vsphere.datacenter,
+            ).and_return(ova_manager)
+          expect(ova_manager).to receive(:clean_environment).with(clean_environment_options)
+
+          manager.clean_environment
+        end
+      end
+
+      context 'when IAAS is AWS' do
+        let(:settings) do
+          RecursiveOpenStruct.new(YAML.load_file(File.join(SPEC_ROOT, 'fixtures', 'shepherd', 'aws.yml')))
+        end
+        let(:ams_manager) { instance_double(AwsManager) }
+        let(:ami_options) do
+          {
+            aws_access_key: 'aws-access-key',
+            aws_secret_key: 'aws-secret-key',
+            ssh_key_name: 'ssh-key-name',
+            security_group_id: 'security-group-id',
+            public_subnet_id: 'public-subnet-id',
+            private_subnet_id: 'private-subnet-id',
+            elastic_ip_id: 'elastic-ip-id',
+            vm_name: 'vm-name'
+          }
+        end
+
+        it 'uses AwsManager to destroy a VM' do
+          expect(AwsManager).to receive(:new).with(ami_options).and_return(ams_manager)
+          expect(ams_manager).to receive(:clean_environment)
+          manager.clean_environment
+        end
+      end
+
+      context 'when IAAS is Openstack' do
+        let(:settings) do
+          RecursiveOpenStruct.new(YAML.load_file(File.join(SPEC_ROOT, 'fixtures', 'shepherd', 'openstack.yml')))
+        end
+        let(:qcow2_manager) { instance_double(OpenstackManager) }
+        let(:qcow2_file_path) { 'PATH_TO_QCOW2_FILE' }
+        let(:openstack_options) do
+          {
+            auth_url: 'http://example.com/version/tokens',
+            username: 'username',
+            api_key: 'api-key',
+            tenant: 'tenant',
+          }
+        end
+
+        it 'uses OpenstackManager to destroy a VM' do
+          expect(OpenstackManager).to receive(:new).with(openstack_options).and_return(qcow2_manager)
+          expect(qcow2_manager).to receive(:clean_environment)
+          manager.clean_environment
+        end
+      end
+
+      context 'when IAAS is unknown' do
+        let(:settings) do
+          RecursiveOpenStruct.new(YAML.load_file(File.join(SPEC_ROOT, 'fixtures', 'shepherd', 'unknown.yml')))
+        end
+
+        it 'raises an exception' do
+          expect { manager.clean_environment }.to raise_error(Shepherd::InvalidIaas)
         end
       end
     end

data/spec/vm_shepherd/vcloud_manager_spec.rb

@@ -29,7 +29,6 @@ module VmShepherd
           gateway: 'FAKE_GATEWAY',
           dns: 'FAKE_DNS',
           ntp: 'FAKE_NTP',
-          ip: 'FAKE_IP',
           netmask: 'FAKE_NETMASK',
         }
       end
@@ -308,7 +307,7 @@ module VmShepherd
               logger,
             ).and_return(client)
 
-          vcloud_manager.destroy(vapp_name)
+          vcloud_manager.destroy([vapp_name])
         end
 
         context 'when an VCloudSdk::ObjectNotFoundError is thrown' do
@@ -325,13 +324,13 @@ module VmShepherd
           it 'catches the error' do
             allow(client).to receive(:find_vdc_by_name).and_raise(VCloudSdk::ObjectNotFoundError)
 
-            expect { vcloud_manager.destroy(vapp_name) }.not_to raise_error
+            expect { vcloud_manager.destroy([vapp_name]) }.not_to raise_error
           end
 
           it 'deletes to catalog' do
             expect(client).to receive(:delete_catalog_by_name).with(location.fetch(:catalog))
 
-            vcloud_manager.destroy(vapp_name)
+            vcloud_manager.destroy([vapp_name])
           end
         end
       end
@@ -356,7 +355,7 @@ module VmShepherd
               logger,
             ).and_return(client)
 
-          vcloud_manager.destroy(vapp_name)
+          vcloud_manager.destroy([vapp_name])
         end
       end
     end

data/spec/vm_shepherd/vsphere_manager_spec.rb

@@ -6,11 +6,61 @@ module VmShepherd
     let(:username) { 'FAKE_USERNAME' }
     let(:password) { 'FAKE_PASSWORD' }
     let(:datacenter_name) { 'FAKE_DATACENTER_NAME' }
+    let(:vm) { instance_double(RbVmomi::VIM::VirtualMachine, name: 'vm_name') }
 
-    subject(:vsphere_manager) { VsphereManager.new(host, username, password, datacenter_name) }
+    subject(:vsphere_manager) do
+      manager = VsphereManager.new(host, username, password, datacenter_name)
+      manager.logger = Logger.new(StringIO.new)
+      manager
+    end
 
     it 'loads' do
       expect { vsphere_manager }.not_to raise_error
     end
+
+    describe 'destroy' do
+      let(:datacenter) { instance_double(RbVmomi::VIM::Datacenter, vmFolder: vm_folder) }
+      let(:vm_folder) { instance_double(RbVmomi::VIM::Folder) }
+      let(:ip_address) { '127.0.0.1' }
+
+      before do
+        allow(vsphere_manager).to receive(:datacenter).and_return(datacenter)
+        allow(vm_folder).to receive(:findByIp).with(ip_address).and_return(vm)
+      end
+
+      it 'destroys the VM that matches the given ip address' do
+        expect(vsphere_manager).to receive(:power_off_vm).with(vm)
+        expect(vsphere_manager).to receive(:destroy_vm).with(vm)
+
+        vsphere_manager.destroy(ip_address)
+      end
+
+      context 'when the vm does not exist' do
+        before do
+          allow(vm_folder).to receive(:findByIp).and_return(nil)
+        end
+
+        it 'does not explode' do
+          expect(vsphere_manager).not_to receive(:power_off_vm)
+          expect(vsphere_manager).not_to receive(:destroy_vm)
+
+          vsphere_manager.destroy(ip_address)
+        end
+      end
+    end
+
+    describe 'destroy_vm' do
+      let(:destroy_task) { instance_double(RbVmomi::VIM::Task) }
+
+      before do
+        allow(vm).to receive(:Destroy_Task).and_return(destroy_task)
+      end
+
+      it 'runs the Destroy_Task and waits for completion' do
+        expect(destroy_task).to receive(:wait_for_completion)
+
+        vsphere_manager.destroy_vm(vm)
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vm_shepherd
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Ops Manager Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-08 00:00:00.000000000 Z
+date: 2015-04-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk-v1