vm_shepherd 1.10.1 → 1.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4c28ff60aceef4bca731813761ce712123b7f941
-  data.tar.gz: 055d66480ba8775dab95bd80554556654da54c55
+  metadata.gz: 763cd128f7302c5fb7250c56c5fb6f2902659a7b
+  data.tar.gz: aac10b49759fcb9b8c5b385e8f9a3bb4fc6b32d6
 SHA512:
-  metadata.gz: 930db4b3aba4201353764122080c6badbc9ba2021c5ada38018738647bdbcfb14f65a647113abebb80b3d1a9bb9f04fe1cf051ebcf13ffcc3ccf002f7146310a
-  data.tar.gz: f9fa8ea157d70fb41454e44716616b1b682d868d9c23cfab097e8e8d895c5302e5f65422552bccdc7e52338d42c731c1d42059a9050d9d0153d8037bcfe708cf
+  metadata.gz: b67e18537b886374536aaf33ec441b389c81ffeb283fcaff7ddff1c53899db708f9fceebc9b22ea90a70d29b810b56f04f6486d7689d17721cea9a8304247075
+  data.tar.gz: 7e0e37f43205234107f6350dde7dcbf3d6c409b4b25357fd486710b95504563cd7e3d825f7e5ab6365a8981b0913d9a99d21c1a5e4748b8c19a0ae72377ac1b1

data/lib/vm_shepherd.rb

@@ -1,7 +1,11 @@
 require 'vm_shepherd/shepherd'
+require 'vm_shepherd/data_object'
 require 'vm_shepherd/aws_manager'
 require 'vm_shepherd/openstack_manager'
 require 'vm_shepherd/vcloud_manager'
+require 'vm_shepherd/vcloud/deployer'
+require 'vm_shepherd/vcloud/destroyer'
+require 'vm_shepherd/vcloud/vapp_config'
 require 'vm_shepherd/vsphere_manager'
 
 module VmShepherd

data/lib/vm_shepherd/data_object.rb

@@ -0,0 +1,11 @@
+module VmShepherd
+  module DataObject
+    def ==(other_obj)
+      return false unless self.class === other_obj
+
+      instance_variables.all? do |ivar_name|
+        self.instance_variable_get(ivar_name) == other_obj.instance_variable_get(ivar_name)
+      end
+    end
+  end
+end

data/lib/vm_shepherd/shepherd.rb

@@ -184,7 +184,7 @@ module VmShepherd
 
     def vcloud_deploy_options(vm_shepherd_config)
       vm = vm_shepherd_config.vapp
-      {
+      VmShepherd::Vcloud::VappConfig.new(
         name: vm.ops_manager_name,
         ip: vm.ip,
         gateway: vm.gateway,
@@ -193,7 +193,7 @@ module VmShepherd
         ntp: vm.ntp,
         catalog: vm_shepherd_config.vdc.catalog,
         network: vm_shepherd_config.vdc.network,
-      }
+      )
     end
 
     def ami_manager

data/lib/vm_shepherd/vcloud/deployer.rb

@@ -0,0 +1,23 @@
+module VmShepherd
+  module Vcloud
+    class Deployer
+      def self.deploy_and_power_on_vapp(client:, ovf_dir:, vapp_config:, vdc_name:)
+        catalog = client.create_catalog(vapp_config.catalog)
+
+        # upload template and instantiate vapp
+        catalog.upload_vapp_template(vdc_name, vapp_config.name, ovf_dir)
+
+        # instantiate template
+        network_config = VCloudSdk::NetworkConfig.new(vapp_config.network, 'Network 1')
+        vapp = catalog.instantiate_vapp_template(vapp_config.name, vdc_name, vapp_config.name, nil, nil, network_config)
+
+        # reconfigure vm
+        vm = vapp.find_vm_by_name(vapp_config.name)
+        vm.product_section_properties = vapp_config.build_properties
+
+        # power on vapp
+        vapp.power_on
+      end
+    end
+  end
+end

data/lib/vm_shepherd/vcloud/destroyer.rb

@@ -0,0 +1,47 @@
+module VmShepherd
+  module Vcloud
+    class Destroyer
+      def initialize(client:, vdc_name:)
+        @client = client
+        @vdc_name = vdc_name
+      end
+
+      def delete_catalog_and_vapps(catalog, vapp_names, logger)
+        delete_vapps(vapp_names, logger)
+        delete_catalog(catalog)
+      end
+
+      private
+
+      def vdc
+        @vdc ||= @client.find_vdc_by_name(@vdc_name)
+      end
+
+      def delete_vapps(vapp_names, logger)
+        vapp_names.each do |vapp_name|
+          begin
+            delete_vapp(vapp_name)
+          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_vapp(vapp_name)
+        vapp = vdc.find_vapp_by_name(vapp_name)
+        vapp.vms.map do |vm|
+          vm.independent_disks.map do |disk|
+            vm.detach_disk(disk)
+            vdc.delete_disk_by_name(disk.name)
+          end
+        end
+        vapp.power_off
+        vapp.delete
+      end
+    end
+  end
+end

data/lib/vm_shepherd/vcloud/vapp_config.rb

@@ -0,0 +1,78 @@
+module VmShepherd
+  module Vcloud
+    class VappConfig
+      include VmShepherd::DataObject
+      attr_reader :name, :gateway, :dns, :ntp, :ip, :netmask, :catalog, :network
+
+      def initialize(name:, ip:, gateway:, netmask:, dns:, ntp:, catalog:, network:)
+        @name = name
+        @ip = ip
+        @gateway = gateway
+        @netmask = netmask
+        @dns = dns
+        @ntp = ntp
+        @catalog = catalog
+        @network = network
+      end
+
+      def build_properties
+        [
+          {
+            'type' => 'string',
+            'key' => 'gateway',
+            'value' => gateway,
+            'password' => 'false',
+            'userConfigurable' => 'true',
+            'Label' => 'Default Gateway',
+            'Description' => 'The default gateway address for the VM network. Leave blank if DHCP is desired.'
+          },
+          {
+            'type' => 'string',
+            'key' => 'DNS',
+            'value' => dns,
+            'password' => 'false',
+            'userConfigurable' => 'true',
+            'Label' => 'DNS',
+            'Description' => 'The domain name servers for the VM (comma separated). Leave blank if DHCP is desired.',
+          },
+          {
+            'type' => 'string',
+            'key' => 'ntp_servers',
+            'value' => ntp,
+            'password' => 'false',
+            'userConfigurable' => 'true',
+            'Label' => 'NTP Servers',
+            'Description' => 'Comma-delimited list of NTP servers'
+          },
+          {
+            'type' => 'string',
+            'key' => 'admin_password',
+            'value' => 'tempest',
+            'password' => 'true',
+            'userConfigurable' => 'true',
+            'Label' => 'Admin Password',
+            'Description' => 'This password is used to SSH into the VM. The username is "tempest".',
+          },
+          {
+            'type' => 'string',
+            'key' => 'ip0',
+            'value' => ip,
+            'password' => 'false',
+            'userConfigurable' => 'true',
+            'Label' => 'IP Address',
+            'Description' => 'The IP address for the VM. Leave blank if DHCP is desired.',
+          },
+          {
+            'type' => 'string',
+            'key' => 'netmask0',
+            'value' => netmask,
+            'password' => 'false',
+            'userConfigurable' => 'true',
+            'Label' => 'Netmask',
+            'Description' => 'The netmask for the VM network. Leave blank if DHCP is desired.'
+          }
+        ]
+      end
+    end
+  end
+end

data/lib/vm_shepherd/vcloud_manager.rb

@@ -17,9 +17,15 @@ module VmShepherd
 
       untar_vapp_template_tar(File.expand_path(vapp_template_tar_path), tmpdir)
 
-      vapp = deploy_vapp(tmpdir, vapp_config)
-      reconfigure_vm(vapp, vapp_config)
-      vapp.power_on
+      VmShepherd::Vcloud::Deployer.deploy_and_power_on_vapp(
+        client: client,
+        ovf_dir: tmpdir,
+        vapp_config: vapp_config,
+        vdc_name: @vdc_name,
+      )
+    rescue => e
+      logger.error(e.http_body) if e.respond_to?(:http_body)
+      raise e
     ensure
       FileUtils.remove_entry_secure(tmpdir, force: true)
     end
@@ -28,8 +34,8 @@ module VmShepherd
     end
 
     def destroy(vapp_names, catalog)
-      delete_vapps(vapp_names)
-      delete_catalog(catalog)
+      VmShepherd::Vcloud::Destroyer.new(client: client, vdc_name: @vdc_name).
+        delete_catalog_and_vapps(catalog, vapp_names, @logger)
     end
 
     def clean_environment(vapp_names, catalog)
@@ -40,14 +46,15 @@ module VmShepherd
 
     def check_vapp_status(vapp_config)
       log('Checking for existing VM') do
-        ip = vapp_config[:ip]
-        raise "VM exists at #{ip}" if system("ping -c 5 #{ip}")
+        ip = vapp_config.ip
+        system("ping -c 5 #{ip}") and raise "VM exists at #{ip}"
       end
     end
 
     def untar_vapp_template_tar(vapp_template_tar_path, dir)
       log("Untarring #{vapp_template_tar_path}") do
-        system_or_exit("cd #{dir} && tar xfv '#{vapp_template_tar_path}'")
+        cmd = "cd #{dir} && tar xfv '#{vapp_template_tar_path}'"
+        system(cmd) or raise("Error executing: #{cmd}")
       end
     end
 
@@ -61,127 +68,10 @@ module VmShepherd
       )
     end
 
-    def deploy_vapp(ovf_dir, vapp_config)
-      vapp_name = vapp_config.fetch(:name)
-      catalog_name = vapp_config.fetch(:catalog)
-      network = vapp_config.fetch(:network)
-      # setup the catalog
-      client.delete_catalog_by_name(catalog_name) if client.catalog_exists?(catalog_name)
-      catalog = client.create_catalog(catalog_name)
-
-      # upload template and instantiate vapp
-      catalog.upload_vapp_template(@vdc_name, vapp_name, ovf_dir)
-
-      # instantiate template
-      network_config = VCloudSdk::NetworkConfig.new(network, 'Network 1')
-      catalog.instantiate_vapp_template(vapp_name, @vdc_name, vapp_name, nil, nil, network_config)
-    rescue => e
-      @logger.error(e.http_body) if e.respond_to?(:http_body)
-      raise e
-    end
-
-    def reconfigure_vm(vapp, vapp_config)
-      vapp_name = vapp_config.fetch(:name)
-      gateway = vapp_config.fetch(:gateway)
-      dns = vapp_config.fetch(:dns)
-      ntp = vapp_config.fetch(:ntp)
-      ip = vapp_config.fetch(:ip)
-      netmask = vapp_config.fetch(:netmask)
-
-      vm = vapp.find_vm_by_name(vapp_name)
-      vm.product_section_properties = build_properties(gateway: gateway, dns: dns, ntp: ntp, ip: ip, netmask: netmask)
-      vm
-    end
-
-    def build_properties(gateway:, dns:, ntp:, ip:, netmask:)
-      [
-        {
-          'type' => 'string',
-          'key' => 'gateway',
-          'value' => gateway,
-          'password' => 'false',
-          'userConfigurable' => 'true',
-          'Label' => 'Default Gateway',
-          'Description' => 'The default gateway address for the VM network. Leave blank if DHCP is desired.'
-        },
-        {
-          'type' => 'string',
-          'key' => 'DNS',
-          'value' => dns,
-          'password' => 'false',
-          'userConfigurable' => 'true',
-          'Label' => 'DNS',
-          'Description' => 'The domain name servers for the VM (comma separated). Leave blank if DHCP is desired.',
-        },
-        {
-          'type' => 'string',
-          'key' => 'ntp_servers',
-          'value' => ntp,
-          'password' => 'false',
-          'userConfigurable' => 'true',
-          'Label' => 'NTP Servers',
-          'Description' => 'Comma-delimited list of NTP servers'
-        },
-        {
-          'type' => 'string',
-          'key' => 'admin_password',
-          'value' => 'tempest',
-          'password' => 'true',
-          'userConfigurable' => 'true',
-          'Label' => 'Admin Password',
-          'Description' => 'This password is used to SSH into the VM. The username is "tempest".',
-        },
-        {
-          'type' => 'string',
-          'key' => 'ip0',
-          'value' => ip,
-          'password' => 'false',
-          'userConfigurable' => 'true',
-          'Label' => 'IP Address',
-          'Description' => 'The IP address for the VM. Leave blank if DHCP is desired.',
-        },
-        {
-          'type' => 'string',
-          'key' => 'netmask0',
-          'value' => netmask,
-          'password' => 'false',
-          'userConfigurable' => 'true',
-          'Label' => 'Netmask',
-          'Description' => 'The netmask for the VM network. Leave blank if DHCP is desired.'
-        }
-      ]
-    end
-
     def log(title, &blk)
       @logger.debug "--- Begin: #{title.inspect} @ #{DateTime.now}"
       blk.call
       @logger.debug "---   End: #{title.inspect} @ #{DateTime.now}"
     end
-
-    def system_or_exit(command)
-      log(command) do
-        system(command) || raise("Error executing: #{command.inspect}")
-      end
-    end
-
-    def vdc
-      @vdc ||= client.find_vdc_by_name(@vdc_name)
-    end
-
-    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(catalog)
-      client.delete_catalog_by_name(catalog) if client.catalog_exists?(catalog)
-    end
   end
 end

data/lib/vm_shepherd/version.rb

@@ -1,3 +1,3 @@
 module VmShepherd
-  VERSION = '1.10.1'.freeze
+  VERSION = '1.11.0'.freeze
 end

data/spec/vm_shepherd/data_object_spec.rb

@@ -0,0 +1,49 @@
+require 'vm_shepherd/data_object'
+
+module VmShepherd
+  class TestDataObject
+    include DataObject
+
+    attr_accessor :name
+  end
+
+  RSpec.describe(DataObject) do
+    describe '#==' do
+      it 'returns false for objects of a different class' do
+        class DifferentDataObject
+          include DataObject
+        end
+
+        expect(TestDataObject.new == DifferentDataObject.new).to be_falsey
+      end
+
+      it 'returns true for objects of a descendent class' do
+        class DescendentDataObject < TestDataObject
+          include DataObject
+        end
+
+        expect(TestDataObject.new == DescendentDataObject.new).to be_truthy
+      end
+
+      it 'returns false when any attribute is unequal' do
+        a = TestDataObject.new
+        b = TestDataObject.new
+
+        a.name = 'a'
+        b.name = 'b'
+
+        expect(a == b).to be_falsey
+      end
+
+      it 'returns true when all attributes are equal' do
+        eleventy_one = TestDataObject.new
+        hundred_and_eleven = TestDataObject.new
+
+        eleventy_one.name = '111'
+        hundred_and_eleven.name = '111'
+
+        expect(eleventy_one == hundred_and_eleven).to be_truthy
+      end
+    end
+  end
+end

data/spec/vm_shepherd/shepherd_spec.rb

@@ -84,7 +84,7 @@ module VmShepherd
 
           expect(first_vcloud_manager).to receive(:deploy).with(
               'FIRST_FAKE_PATH',
-              {
+              Vcloud::VappConfig.new(
                 name: first_config.vapp.ops_manager_name,
                 ip: first_config.vapp.ip,
                 gateway: first_config.vapp.gateway,
@@ -93,12 +93,12 @@ module VmShepherd
                 ntp: first_config.vapp.ntp,
                 catalog: first_config.vdc.catalog,
                 network: first_config.vdc.network,
-              }
+              )
             )
 
           expect(last_vcloud_manager).to receive(:deploy).with(
               'LAST_FAKE_PATH',
-              {
+              Vcloud::VappConfig.new(
                 name: last_config.vapp.ops_manager_name,
                 ip: last_config.vapp.ip,
                 gateway: last_config.vapp.gateway,
@@ -107,7 +107,7 @@ module VmShepherd
                 ntp: last_config.vapp.ntp,
                 catalog: last_config.vdc.catalog,
                 network: last_config.vdc.network,
-              }
+              )
             )
 
           manager.deploy(paths: ['FIRST_FAKE_PATH', 'LAST_FAKE_PATH'])

data/spec/vm_shepherd/vcloud/deployer_spec.rb

@@ -0,0 +1,83 @@
+require 'vm_shepherd/data_object'
+require 'vm_shepherd/vcloud/vapp_config'
+require 'vm_shepherd/vcloud/deployer'
+require 'ruby_vcloud_sdk'
+
+module VmShepherd
+  module Vcloud
+    RSpec.describe Deployer do
+      describe '.deploy_and_power_on_vapp' do
+        let(:vapp_config) do
+          VappConfig.new(
+            name: 'NAME',
+            ip: 'IP',
+            gateway: 'GATEWAY',
+            netmask: 'NETMASK',
+            dns: 'DNS',
+            ntp: 'NTP',
+            catalog: 'CATALOG',
+            network: 'NETWORK',
+          )
+        end
+
+        let(:client) { instance_double(VCloudSdk::Client) }
+        let(:catalog) { instance_double(VCloudSdk::Catalog) }
+        let(:vapp) { instance_double(VCloudSdk::VApp) }
+        let(:vm) { instance_double(VCloudSdk::VM) }
+        let(:network_config) { instance_double(VCloudSdk::NetworkConfig) }
+
+        before do
+          allow(client).to receive(:create_catalog).and_return(catalog)
+          allow(catalog).to receive(:upload_vapp_template)
+          allow(catalog).to receive(:instantiate_vapp_template).and_return(vapp)
+          allow(vapp).to receive(:find_vm_by_name).and_return(vm)
+          allow(vm).to receive(:product_section_properties=)
+          allow(vapp).to receive(:power_on)
+
+          allow(VCloudSdk::NetworkConfig).to receive(:new).with('NETWORK', 'Network 1').and_return(network_config)
+        end
+
+        it 'creates a catalog' do
+          expect(client).to receive(:create_catalog).with('CATALOG')
+
+          Deployer.deploy_and_power_on_vapp(client: client, ovf_dir: nil, vapp_config: vapp_config, vdc_name: nil)
+        end
+
+        it 'uploads a vapp template' do
+          expect(catalog).to receive(:upload_vapp_template).with('VDC_NAME', 'NAME', 'OVF_DIR')
+
+          Deployer.deploy_and_power_on_vapp(client: client, ovf_dir: 'OVF_DIR', vapp_config: vapp_config, vdc_name: 'VDC_NAME')
+        end
+
+        it 'instantiates the template' do
+          expect(catalog).to receive(:upload_vapp_template).with('VDC_NAME', 'NAME', 'OVF_DIR')
+          expect(catalog).to receive(:instantiate_vapp_template).with('NAME', 'VDC_NAME', 'NAME', nil, nil, network_config)
+
+          Deployer.deploy_and_power_on_vapp(client: client, ovf_dir: 'OVF_DIR', vapp_config: vapp_config, vdc_name: 'VDC_NAME')
+        end
+
+        it 'reconfigures the vm' do
+          expect(vm).to receive(:product_section_properties=).with(vapp_config.build_properties)
+
+          Deployer.deploy_and_power_on_vapp(client: client, ovf_dir: 'OVF_DIR', vapp_config: vapp_config, vdc_name: 'VDC_NAME')
+        end
+
+        it 'powers on the vapp' do
+          expect(vapp).to receive(:power_on)
+
+          Deployer.deploy_and_power_on_vapp(client: client, ovf_dir: 'OVF_DIR', vapp_config: vapp_config, vdc_name: 'VDC_NAME')
+        end
+
+        it 'does things in order' do
+          Deployer.deploy_and_power_on_vapp(client: client, ovf_dir: 'OVF_DIR', vapp_config: vapp_config, vdc_name: 'VDC_NAME')
+
+          expect(client).to have_received(:create_catalog).ordered
+          expect(catalog).to have_received(:upload_vapp_template).ordered
+          expect(catalog).to have_received(:instantiate_vapp_template).ordered
+          expect(vm).to have_received(:product_section_properties=).ordered
+          expect(vapp).to have_received(:power_on).ordered
+        end
+      end
+    end
+  end
+end

data/spec/vm_shepherd/vcloud/destroyer_spec.rb

@@ -0,0 +1,72 @@
+require 'vm_shepherd/data_object'
+require 'vm_shepherd/vcloud/vapp_config'
+require 'vm_shepherd/vcloud/destroyer'
+require 'ruby_vcloud_sdk'
+
+module VmShepherd
+  module Vcloud
+    RSpec.describe Destroyer do
+      subject(:destroyer) { Destroyer.new(client: client, vdc_name: vdc_name) }
+      let(:client) { instance_double(VCloudSdk::Client) }
+      let(:vdc_name) { 'VDC_NAME' }
+      let(:fake_logger) { double(:logger, debug: nil) }
+      let(:vm) { instance_double(VCloudSdk::VM) }
+      let(:vdc) { instance_double(VCloudSdk::VDC) }
+      let(:vapp) { instance_double(VCloudSdk::VApp) }
+      let(:disk) { instance_double(VCloudSdk::InternalDisk, name: 'DISK_NAME') }
+
+      before do
+        allow(client).to receive(:delete_catalog_by_name)
+        allow(client).to receive(:catalog_exists?)
+        allow(client).to receive(:find_vdc_by_name).with(vdc_name).and_return(vdc)
+        allow(vdc).to receive(:find_vapp_by_name).with('VAPP_NAME').and_return(vapp)
+        allow(vdc).to receive(:delete_disk_by_name)
+        allow(vapp).to receive(:vms).and_return([vm])
+        allow(vapp).to receive(:power_off)
+        allow(vapp).to receive(:delete)
+        allow(vm).to receive(:independent_disks).and_return([disk])
+        allow(vm).to receive(:detach_disk)
+      end
+
+      describe '#delete_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_vapps('CATALOG_NAME', [], fake_logger)
+
+            expect(client).to have_received(:delete_catalog_by_name).with('CATALOG_NAME')
+          end
+        end
+
+        context 'when the catalog does not exist' do
+          before do
+            allow(client).to receive(:catalog_exists?).with('CATALOG_NAME').and_return(false)
+          end
+
+          it 'skips deleting the catalog' do
+            destroyer.delete_catalog_and_vapps('CATALOG_NAME', [], fake_logger)
+
+            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_vapps('CATALOG_NAME', ['VAPP_NAME'], fake_logger)
+
+          expect(vm).to have_received(:detach_disk).with(disk)
+          expect(vdc).to have_received(:delete_disk_by_name).with('DISK_NAME')
+        end
+
+        it 'powers off and deletes vapps' do
+          destroyer.delete_catalog_and_vapps('CATALOG_NAME', ['VAPP_NAME'], fake_logger)
+
+          expect(vapp).to have_received(:power_off)
+          expect(vapp).to have_received(:delete)
+        end
+      end
+    end
+  end
+end

data/spec/vm_shepherd/vcloud/vapp_config_spec.rb

@@ -0,0 +1,25 @@
+require 'vm_shepherd/data_object'
+require 'vm_shepherd/vcloud/vapp_config'
+
+module VmShepherd
+  module Vcloud
+    RSpec.describe(VappConfig) do
+      subject(:vapp_config) do
+        VappConfig.new(
+          name: 'NAME',
+          ip: 'IP',
+          gateway: 'GATEWAY',
+          netmask: 'NETMASK',
+          dns: 'DNS',
+          ntp: 'NTP',
+          catalog: 'CATALOG',
+          network: 'NETWORK',
+        )
+      end
+
+      it 'is a DataObject' do
+        expect(vapp_config).to be_a(DataObject)
+      end
+    end
+  end
+end

data/spec/vm_shepherd/vcloud_manager_spec.rb

@@ -1,4 +1,8 @@
+require 'vm_shepherd/data_object'
 require 'vm_shepherd/vcloud_manager'
+require 'vm_shepherd/vcloud/deployer'
+require 'vm_shepherd/vcloud/destroyer'
+require 'vm_shepherd/vcloud/vapp_config'
 
 module VmShepherd
   RSpec.describe VcloudManager do
@@ -18,7 +22,7 @@ module VmShepherd
 
     describe '#deploy' do
       let(:vapp_config) do
-        {
+        Vcloud::VappConfig.new(
           ip: 'FAKE_IP',
           name: 'FAKE_NAME',
           gateway: 'FAKE_GATEWAY',
@@ -27,7 +31,7 @@ module VmShepherd
           netmask: 'FAKE_NETMASK',
           catalog: 'FAKE_VAPP_CATALOG',
           network: 'FAKE_NETWORK',
-        }
+        )
       end
 
       let(:vapp_template_path) { 'FAKE_VAPP_TEMPLATE_PATH' }
@@ -39,7 +43,7 @@ module VmShepherd
         let(:expanded_vapp_template_path) { 'FAKE_EXPANDED_VAPP_TEMPLATE_PATH' }
 
         before do
-          allow(vcloud_manager).to receive(:system).with("ping -c 5 #{vapp_config.fetch(:ip)}").and_return(false)
+          allow(vcloud_manager).to receive(:system).with("ping -c 5 #{vapp_config.ip}").and_return(false)
 
           allow(File).to receive(:expand_path).with(vapp_template_path).and_return(expanded_vapp_template_path)
 
@@ -71,7 +75,7 @@ module VmShepherd
                 {
                   'type' => 'string',
                   'key' => 'gateway',
-                  'value' => vapp_config.fetch(:gateway),
+                  'value' => vapp_config.gateway,
                   'password' => 'false',
                   'userConfigurable' => 'true',
                   'Label' => 'Default Gateway',
@@ -80,7 +84,7 @@ module VmShepherd
                 {
                   'type' => 'string',
                   'key' => 'DNS',
-                  'value' => vapp_config.fetch(:dns),
+                  'value' => vapp_config.dns,
                   'password' => 'false',
                   'userConfigurable' => 'true',
                   'Label' => 'DNS',
@@ -89,7 +93,7 @@ module VmShepherd
                 {
                   'type' => 'string',
                   'key' => 'ntp_servers',
-                  'value' => vapp_config.fetch(:ntp),
+                  'value' => vapp_config.ntp,
                   'password' => 'false',
                   'userConfigurable' => 'true',
                   'Label' => 'NTP Servers',
@@ -107,7 +111,7 @@ module VmShepherd
                 {
                   'type' => 'string',
                   'key' => 'ip0',
-                  'value' => vapp_config.fetch(:ip),
+                  'value' => vapp_config.ip,
                   'password' => 'false',
                   'userConfigurable' => 'true',
                   'Label' => 'IP Address',
@@ -116,7 +120,7 @@ module VmShepherd
                 {
                   'type' => 'string',
                   'key' => 'netmask0',
-                  'value' => vapp_config.fetch(:netmask),
+                  'value' => vapp_config.netmask,
                   'password' => 'false',
                   'userConfigurable' => 'true',
                   'Label' => 'Netmask',
@@ -153,34 +157,8 @@ module VmShepherd
               vcloud_manager.deploy(vapp_template_path, vapp_config)
             end
 
-            describe 'catalog deletion' do
-              before do
-                allow(client).to receive(:catalog_exists?).and_return(catalog_exists)
-              end
-
-              context 'when the catalog exists' do
-                let(:catalog_exists) { true }
-
-                it 'deletes the catalog' do
-                  expect(client).to receive(:delete_catalog_by_name).with(vapp_config.fetch(:catalog))
-
-                  vcloud_manager.deploy(vapp_template_path, vapp_config)
-                end
-              end
-
-              context 'when the catalog does not exist' do
-                let(:catalog_exists) { false }
-
-                it 'does not delete the catalog' do
-                  expect(client).not_to receive(:delete_catalog_by_name).with(vapp_config.fetch(:catalog))
-
-                  vcloud_manager.deploy(vapp_template_path, vapp_config)
-                end
-              end
-            end
-
             it 'creates the catalog' do
-              expect(client).to receive(:create_catalog).with(vapp_config.fetch(:catalog)).and_return(catalog)
+              expect(client).to receive(:create_catalog).with(vapp_config.catalog).and_return(catalog)
 
               vcloud_manager.deploy(vapp_template_path, vapp_config)
             end
@@ -188,7 +166,7 @@ module VmShepherd
             it 'uploads the vApp template' do
               expect(catalog).to receive(:upload_vapp_template).with(
                   vdc_name,
-                  vapp_config.fetch(:name),
+                  vapp_config.name,
                   tmpdir,
                 ).and_return(catalog)
 
@@ -197,7 +175,7 @@ module VmShepherd
 
             it 'creates a VCloudSdk::NetworkConfig' do
               expect(VCloudSdk::NetworkConfig).to receive(:new).with(
-                  vapp_config.fetch(:network),
+                  vapp_config.network,
                   'Network 1',
                 ).and_return(network_config)
 
@@ -206,9 +184,9 @@ module VmShepherd
 
             it 'instantiates the vApp template' do
               expect(catalog).to receive(:instantiate_vapp_template).with(
-                  vapp_config.fetch(:name),
+                  vapp_config.name,
                   vdc_name,
-                  vapp_config.fetch(:name),
+                  vapp_config.name,
                   nil,
                   nil,
                   network_config
@@ -256,7 +234,7 @@ module VmShepherd
           end
 
           it 'raises an error' do
-            expect { vcloud_manager.deploy(vapp_template_path, vapp_config) }.to raise_error("Error executing: #{tar_expand_cmd.inspect}")
+            expect { vcloud_manager.deploy(vapp_template_path, vapp_config) }.to raise_error("Error executing: #{tar_expand_cmd}")
           end
 
           it 'removes the expanded vApp template' do
@@ -269,11 +247,11 @@ module VmShepherd
 
       context 'when a host exists at the specified IP' do
         before do
-          allow(vcloud_manager).to receive(:system).with("ping -c 5 #{vapp_config.fetch(:ip)}").and_return(true)
+          allow(vcloud_manager).to receive(:system).with("ping -c 5 #{vapp_config.ip}").and_return(true)
         end
 
         it 'raises an error' do
-          expect { vcloud_manager.deploy(vapp_template_path, vapp_config) }.to raise_error("VM exists at #{vapp_config.fetch(:ip)}")
+          expect { vcloud_manager.deploy(vapp_template_path, vapp_config) }.to raise_error("VM exists at #{vapp_config.ip}")
         end
 
         it 'removes the expanded vApp template' do
@@ -290,6 +268,13 @@ module VmShepherd
       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])
+      end
 
       context 'when the catalog exists' do
         before do
@@ -299,6 +284,8 @@ module VmShepherd
         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(vapp).to receive(:power_off)
           expect(vapp).to receive(:delete)
           expect(client).to receive(:delete_catalog_by_name).with(vapp_catalog)
@@ -319,6 +306,8 @@ module VmShepherd
             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)
 
@@ -326,7 +315,7 @@ module VmShepherd
           end
 
           it 'catches the error' do
-            allow(client).to receive(:find_vdc_by_name).and_raise(VCloudSdk::ObjectNotFoundError)
+            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
@@ -347,6 +336,8 @@ module VmShepherd
         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(vapp).to receive(:power_off)
           expect(vapp).to receive(:delete)
           expect(client).not_to receive(:delete_catalog_by_name).with(vapp_catalog)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vm_shepherd
 version: !ruby/object:Gem::Version
-  version: 1.10.1
+  version: 1.11.0
 platform: ruby
 authors:
 - Ops Manager Team
@@ -168,9 +168,13 @@ files:
 - ci/run_specs.sh
 - lib/vm_shepherd.rb
 - lib/vm_shepherd/aws_manager.rb
+- lib/vm_shepherd/data_object.rb
 - lib/vm_shepherd/openstack_manager.rb
 - lib/vm_shepherd/retry_helper.rb
 - lib/vm_shepherd/shepherd.rb
+- lib/vm_shepherd/vcloud/deployer.rb
+- lib/vm_shepherd/vcloud/destroyer.rb
+- lib/vm_shepherd/vcloud/vapp_config.rb
 - lib/vm_shepherd/vcloud_manager.rb
 - lib/vm_shepherd/version.rb
 - lib/vm_shepherd/vsphere_manager.rb
@@ -184,9 +188,13 @@ files:
 - spec/spec_helper.rb
 - spec/support/patched_fog.rb
 - spec/vm_shepherd/aws_manager_spec.rb
+- spec/vm_shepherd/data_object_spec.rb
 - spec/vm_shepherd/openstack_manager_spec.rb
 - spec/vm_shepherd/retry_helper_spec.rb
 - spec/vm_shepherd/shepherd_spec.rb
+- spec/vm_shepherd/vcloud/deployer_spec.rb
+- spec/vm_shepherd/vcloud/destroyer_spec.rb
+- spec/vm_shepherd/vcloud/vapp_config_spec.rb
 - spec/vm_shepherd/vcloud_manager_spec.rb
 - spec/vm_shepherd/vsphere_manager_spec.rb
 - vm_shepherd.gemspec
@@ -209,7 +217,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.4.7
 signing_key: 
 specification_version: 4
 summary: A tool for booting and tearing down Ops Manager VMs on various Infrastructures.
@@ -224,8 +232,12 @@ test_files:
 - spec/spec_helper.rb
 - spec/support/patched_fog.rb
 - spec/vm_shepherd/aws_manager_spec.rb
+- spec/vm_shepherd/data_object_spec.rb
 - spec/vm_shepherd/openstack_manager_spec.rb
 - spec/vm_shepherd/retry_helper_spec.rb
 - spec/vm_shepherd/shepherd_spec.rb
+- spec/vm_shepherd/vcloud/deployer_spec.rb
+- spec/vm_shepherd/vcloud/destroyer_spec.rb
+- spec/vm_shepherd/vcloud/vapp_config_spec.rb
 - spec/vm_shepherd/vcloud_manager_spec.rb
 - spec/vm_shepherd/vsphere_manager_spec.rb