vm_shepherd 0.0.1 → 0.1.0

data/lib/vm_shepherd/vapp_manager/destroyer.rb

@@ -1,46 +0,0 @@
-require 'ruby_vcloud_sdk'
-
-module VmShepherd
-  module VappManager
-    class Destroyer
-      def initialize(login_info, location, logger)
-        @login_info = login_info
-        @location = location
-        @logger = logger
-      end
-
-      def destroy(vapp_name)
-        delete_vapp(vapp_name)
-        delete_catalog
-      end
-
-      private
-
-      def client
-        @client ||= VCloudSdk::Client.new(
-          @login_info[:url],
-          "#{@login_info[:user]}@#{@login_info[:organization]}",
-          @login_info[:password],
-          {},
-          @logger,
-        )
-      end
-
-      def vdc
-        @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}"
-      end
-
-      def delete_catalog
-        client.delete_catalog_by_name(@location[:catalog]) if client.catalog_exists?(@location[:catalog])
-      end
-    end
-  end
-end

data/spec/vm_shepherd/ova_manager/base_spec.rb

@@ -1,56 +0,0 @@
-require 'vm_shepherd/ova_manager/base'
-
-module VmShepherd
-  module OvaManager
-    RSpec.describe Base do
-      subject(:base) { Base.new(vcenter) }
-
-      let(:vcenter) { { host: 'host', user: 'user', password: 'password' } }
-      let(:search_index) { double('searchIndex') }
-      let(:connection) { double('RbVmomi::VIM', searchIndex: search_index) }
-      let(:datacenter) { FakeDatacenter.new }
-
-      class FakeDatacenter < RbVmomi::VIM::Datacenter
-        def initialize
-        end
-      end
-
-      before { allow(RbVmomi::VIM).to receive(:connect).and_return(connection) }
-
-      def stub_search(find_result)
-        allow(search_index).to receive(:FindByInventoryPath).and_return(find_result)
-      end
-
-      describe '#find_datacenter' do
-        it 'should return datacenter with valid name' do
-          stub_search(datacenter)
-          expect(base.find_datacenter('valid_datacenter')).to be(datacenter)
-        end
-
-        it 'should return nil with invalid name' do
-          stub_search(nil)
-          expect(base.find_datacenter('does_not_exist')).to be_nil
-        end
-
-        it 'should return nil when find returns non-datacenter' do
-          stub_search(double)
-          expect(base.find_datacenter('non_a_datacenter')).to be_nil
-        end
-      end
-
-      describe '#connection' do
-        it 'should return a connection' do
-          conn = base.send(:connection)
-          expect(conn).to be(connection)
-        end
-
-        it 'should return the same connection on subsequent invocations' do
-          conn = base.send(:connection)
-          conn_again = base.send(:connection)
-          expect(conn).to be(conn_again)
-          expect(RbVmomi::VIM).to have_received(:connect).once
-        end
-      end
-    end
-  end
-end

data/spec/vm_shepherd/ova_manager/deployer_spec.rb

@@ -1,134 +0,0 @@
-require 'tempfile'
-require 'vm_shepherd/ova_manager/deployer'
-
-module VmShepherd
-  module OvaManager
-    RSpec.describe Deployer do
-      let(:connection) { double('connection') }
-      let(:cluster) { double('cluster', resourcePool: cluster_resource_pool) }
-      let(:cluster_resource_pool) { double(:cluster_resource_pool, resourcePool: [a_resource_pool, another_resource_pool]) }
-
-      let(:a_resource_pool) { double('resource_pool', name: 'resource_pool_name') }
-      let(:another_resource_pool) { double('another_resource_pool', name: 'another_resource_pool_name') }
-
-      let(:target_folder) { double('target_folder') }
-      let(:datastore) { double('datastore') }
-      let(:network) { double('network', name: 'network') }
-      let(:datacenter) { double('datacenter', network: [network]) }
-      let(:cached_ova_deployer) {
-        double('CachedOvaDeployer', upload_ovf_as_template: template, linked_clone: linked_clone)
-      }
-      let(:template) { double('template', name: 'template name') }
-      let(:ova_path) { File.join(SPEC_ROOT, 'fixtures', 'ova_manager', 'foo.ova') }
-      let(:linked_clone) { double('linked clone', guest_ip: '1.1.1.1') }
-      let(:vcenter_config) {
-        {
-          host: 'foo',
-          user: 'bar',
-          password: 'secret'
-        }
-      }
-
-      subject(:deployer) { Deployer.new(vcenter_config, location) }
-
-      before do
-        allow(deployer).to receive(:system).with(/cd .* && tar xfv .*/).and_call_original
-        allow(deployer).to receive(:system).with(/nc -z -w 5 .* 443/).and_return(false)
-
-        allow(datacenter).to receive(:find_compute_resource).with('cluster').and_return(cluster)
-
-        allow(datacenter).to receive(:find_datastore).with('datastore').and_return(datastore)
-
-        allow(linked_clone).to receive_message_chain(:ReconfigVM_Task, :wait_for_completion)
-        allow(linked_clone).to receive_message_chain(:PowerOnVM_Task, :wait_for_completion)
-
-        allow(RbVmomi::VIM).to receive(:connect).with({
-              host: vcenter_config[:host],
-              user: vcenter_config[:user],
-              password: vcenter_config[:password],
-              ssl: true,
-              insecure: true
-            }).and_return connection
-
-        allow(deployer).to receive(:find_datacenter).and_return(datacenter)
-
-        allow(datacenter).to receive_message_chain(:vmFolder, :traverse).
-            with('target_folder', RbVmomi::VIM::Folder, true).and_return(target_folder)
-        allow(datacenter).to receive(:networkFolder).and_return(
-            double(:networkFolder).tap do |network_folder|
-              allow(network_folder).to receive(:traverse).with('network').and_return(network)
-            end
-          )
-      end
-
-      context 'resource pool is a parameter' do
-        let(:location) {
-          {
-            connection: connection,
-            network: 'network',
-            cluster: 'cluster',
-            folder: 'target_folder',
-            datastore: 'datastore',
-            datacenter: 'datacenter',
-            resource_pool: resource_pool_name
-          }
-        }
-
-        context 'resource pool can be found' do
-          let(:resource_pool_name) { a_resource_pool.name }
-
-          it 'uses VsphereClient::CachedOvfDeployer to deploy an OVA within a resource pool' do
-            expect(VsphereClients::CachedOvfDeployer).to receive(:new).with(
-                connection,
-                network,
-                cluster,
-                a_resource_pool,
-                target_folder,
-                target_folder,
-                datastore
-              ).and_return(cached_ova_deployer)
-
-            deployer.deploy('foo', ova_path, { ip: '1.1.1.1' })
-          end
-        end
-
-        context 'resource pool cannot be found' do
-          let(:resource_pool_name) { 'i am no body' }
-
-          it 'uses VsphereClient::CachedOvfDeployer to deploy an OVA within a resource pool' do
-            expect {
-              deployer.deploy('foo', ova_path, { ip: '1.1.1.1' })
-            }.to raise_error(/Failed to find resource pool '#{resource_pool_name}'/)
-          end
-        end
-      end
-
-      context 'when there is no resource pool in location' do
-        let(:location) {
-          {
-            connection: connection,
-            network: 'network',
-            cluster: 'cluster',
-            folder: 'target_folder',
-            datastore: 'datastore',
-            datacenter: 'datacenter',
-          }
-        }
-
-        it 'uses the cluster resource pool' do
-          expect(VsphereClients::CachedOvfDeployer).to receive(:new).with(
-              connection,
-              network,
-              cluster,
-              cluster_resource_pool,
-              target_folder,
-              target_folder,
-              datastore
-            ).and_return(cached_ova_deployer)
-
-          deployer.deploy('foo', ova_path, { ip: '1.1.1.1' })
-        end
-      end
-    end
-  end
-end

data/spec/vm_shepherd/ova_manager/destroyer_spec.rb

@@ -1,42 +0,0 @@
-require 'vm_shepherd/ova_manager/destroyer'
-
-module VmShepherd
-  module OvaManager
-    RSpec.describe Destroyer do
-      subject(:destroyer) { Destroyer.new('datacenter_name', vcenter_config) }
-      let(:vcenter_config) { { host: 'host', user: 'user', password: 'password' } }
-
-      describe '#clean_folder' do
-        # Crappy temporary test to at least ensure that Destroyer requires the appropriate files
-        it 'is wired up correctly' do
-          connection = double('connection', serviceInstance: double('serviceInstance'))
-          datacenter = double('datacenter')
-          allow(datacenter).to receive(:is_a?).with(RbVmomi::VIM::Datacenter).and_return(true)
-          vm_folder_client = double('vm_folder_client')
-
-          expect(RbVmomi::VIM).to receive(:connect).with(
-              host: 'host',
-              user: 'user',
-              password: 'password',
-              ssl: true,
-              insecure: true,
-            ).and_return(connection)
-          expect(connection).to receive(:searchIndex).and_return(
-              double(:searchIndex).tap do |search_index|
-                expect(search_index).to receive(:FindByInventoryPath).
-                    with(inventoryPath: 'datacenter_name').
-                    and_return(datacenter)
-              end
-            )
-          expect(VsphereClients::VmFolderClient).to receive(:new).
-              with(datacenter, instance_of(Logger)).
-              and_return(vm_folder_client)
-          expect(vm_folder_client).to receive(:delete_folder).with('folder_name')
-          expect(vm_folder_client).to receive(:create_folder).with('folder_name')
-
-          destroyer.clean_folder('folder_name')
-        end
-      end
-    end
-  end
-end

data/spec/vm_shepherd/vapp_manager/deployer_spec.rb

@@ -1,287 +0,0 @@
-require 'vm_shepherd/vapp_manager/deployer'
-
-module VmShepherd
-  module VappManager
-    RSpec.describe Deployer do
-      let(:login_info) do
-        {
-          url: 'FAKE_URL',
-          organization: 'FAKE_ORGANIZATION',
-          user: 'FAKE_USER',
-          password: 'FAKE_PASSWORD',
-        }
-      end
-      let(:location) do
-        {
-          catalog: 'FAKE_CATALOG',
-          network: 'FAKE_NETWORK',
-          vdc: 'FAKE_VDC',
-        }
-      end
-      let(:logger) { instance_double(Logger).as_null_object }
-
-      let(:deployer) { Deployer.new(login_info, location, logger) }
-
-      describe '#deploy' do
-        let(:vapp_config) do
-          {
-            ip: 'FAKE_IP',
-            name: 'FAKE_NAME',
-            gateway: 'FAKE_GATEWAY',
-            dns: 'FAKE_DNS',
-            ntp: 'FAKE_NTP',
-            ip: 'FAKE_IP',
-            netmask: 'FAKE_NETMASK',
-          }
-        end
-        let(:vapp_template_path) { 'FAKE_VAPP_TEMPLATE_PATH' }
-        let(:tmpdir) { 'FAKE_TMP_DIR' }
-
-        before { allow(Dir).to receive(:mktmpdir).and_return(tmpdir) }
-
-        context 'when NO host exists at the specified IP' do
-          let(:expanded_vapp_template_path) { 'FAKE_EXPANDED_VAPP_TEMPLATE_PATH' }
-
-          before do
-            allow(deployer).to receive(:system).with("ping -c 5 #{vapp_config.fetch(:ip)}").and_return(false)
-
-            allow(File).to receive(:expand_path).with(vapp_template_path).and_return(expanded_vapp_template_path)
-
-            allow(FileUtils).to receive(:remove_entry_secure)
-          end
-
-          it 'expands the vapp_template into a TMP dir' do
-            expect(deployer).to receive(:system).with("cd #{tmpdir} && tar xfv '#{expanded_vapp_template_path}'")
-
-            expect { deployer.deploy(vapp_template_path, vapp_config) }.to raise_error
-          end
-
-          context 'when the template can be expanded' do
-            let(:client) { instance_double(VCloudSdk::Client) }
-            let(:catalog) { instance_double(VCloudSdk::Catalog) }
-            let(:network_config) { instance_double(VCloudSdk::NetworkConfig) }
-            let(:vapp) { instance_double(VCloudSdk::VApp) }
-            let(:vm) { instance_double(VCloudSdk::VM) }
-
-            before do
-              allow(deployer).to receive(:system).with("cd #{tmpdir} && tar xfv '#{expanded_vapp_template_path}'").
-                  and_return(true)
-            end
-
-            context 'when the vApp can be deployed' do
-              let(:expected_properties) do
-                [
-                  {
-                    'type' => 'string',
-                    'key' => 'gateway',
-                    'value' => vapp_config.fetch(: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' => vapp_config.fetch(: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' => vapp_config.fetch(: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' => vapp_config.fetch(: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' => vapp_config.fetch(:netmask),
-                    'password' => 'false',
-                    'userConfigurable' => 'true',
-                    'Label' => 'Netmask',
-                    'Description' => 'The netmask for the VM network. Leave blank if DHCP is desired.'
-                  }
-                ]
-              end
-
-              before do
-                allow(VCloudSdk::Client).to receive(:new).and_return(client)
-                allow(client).to receive(:catalog_exists?)
-                allow(client).to receive(:delete_catalog_by_name)
-
-                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(VCloudSdk::NetworkConfig).to receive(:new).and_return(network_config)
-
-                allow(vapp).to receive(:find_vm_by_name).and_return(vm)
-                allow(vm).to receive(:product_section_properties=)
-                allow(vapp).to receive(:power_on)
-              end
-
-              it 'uses VCloudSdk::Client' do
-                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)
-
-                deployer.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(location.fetch(:catalog))
-
-                    deployer.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(location.fetch(:catalog))
-
-                    deployer.deploy(vapp_template_path, vapp_config)
-                  end
-                end
-              end
-
-              it 'creates the catalog' do
-                expect(client).to receive(:create_catalog).with(location.fetch(:catalog)).and_return(catalog)
-
-                deployer.deploy(vapp_template_path, vapp_config)
-              end
-
-              it 'uploads the vApp template' do
-                expect(catalog).to receive(:upload_vapp_template).with(
-                    location.fetch(:vdc),
-                    vapp_config.fetch(:name),
-                    tmpdir,
-                  ).and_return(catalog)
-
-                deployer.deploy(vapp_template_path, vapp_config)
-              end
-
-              it 'creates a VCloudSdk::NetworkConfig' do
-                expect(VCloudSdk::NetworkConfig).to receive(:new).with(
-                    location.fetch(:network),
-                    'Network 1',
-                  ).and_return(network_config)
-
-                deployer.deploy(vapp_template_path, vapp_config)
-              end
-
-              it 'instantiates the vApp template' do
-                expect(catalog).to receive(:instantiate_vapp_template).with(
-                    vapp_config.fetch(:name),
-                    location.fetch(:vdc),
-                    vapp_config.fetch(:name),
-                    nil,
-                    nil,
-                    network_config
-                  ).and_return(vapp)
-
-                deployer.deploy(vapp_template_path, vapp_config)
-              end
-
-              it 'sets the product section properties' do
-                expect(vm).to receive(:product_section_properties=).with(expected_properties)
-
-                deployer.deploy(vapp_template_path, vapp_config)
-              end
-
-              it 'powers on the vApp' do
-                expect(vapp).to receive(:power_on)
-
-                deployer.deploy(vapp_template_path, vapp_config)
-              end
-
-              it 'removes the expanded vApp template' do
-                expect(FileUtils).to receive(:remove_entry_secure).with(tmpdir, force: true)
-
-                deployer.deploy(vapp_template_path, vapp_config)
-              end
-            end
-
-            context 'when the vApp can NOT be deployed' do
-              it 'removes the expanded vApp template' do
-                expect(FileUtils).to receive(:remove_entry_secure).with(tmpdir, force: true)
-
-                expect { deployer.deploy(vapp_template_path, vapp_config) }.to raise_error
-              end
-            end
-          end
-
-          context 'when the template can NOT be expanded' do
-            let(:tar_expand_cmd) { "cd #{tmpdir} && tar xfv '#{expanded_vapp_template_path}'" }
-            before do
-              allow(deployer).to receive(:system).with(tar_expand_cmd).and_return(false)
-            end
-
-            it 'raises an error' do
-              expect { deployer.deploy(vapp_template_path, vapp_config) }.to raise_error("Error executing: #{tar_expand_cmd.inspect}")
-            end
-
-            it 'removes the expanded vApp template' do
-              expect(FileUtils).to receive(:remove_entry_secure).with(tmpdir, force: true)
-
-              expect { deployer.deploy(vapp_template_path, vapp_config) }.to raise_error
-            end
-          end
-        end
-
-        context 'when a host exists at the specified IP' do
-          before do
-            allow(deployer).to receive(:system).with("ping -c 5 #{vapp_config.fetch(:ip)}").and_return(true)
-          end
-
-          it 'raises an error' do
-            expect { deployer.deploy(vapp_template_path, vapp_config) }.to raise_error("VM exists at #{vapp_config.fetch(:ip)}")
-          end
-
-          it 'removes the expanded vApp template' do
-            expect(FileUtils).to receive(:remove_entry_secure).with(tmpdir, force: true)
-
-            expect { deployer.deploy(vapp_template_path, vapp_config) }.to raise_error
-          end
-        end
-      end
-    end
-  end
-end