vm_shepherd 0.0.1

data/spec/vm_shepherd/ami_manager_spec.rb

@@ -0,0 +1,146 @@
+require 'vm_shepherd/ami_manager'
+
+module VmShepherd
+  RSpec.describe AmiManager do
+    let(:access_key) { 'access-key' }
+    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(:ec2) { double('AWS.ec2') }
+
+    let(:aws_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: 'Ops Manager: clean_install_spec'
+      }
+    end
+
+    subject(:ami_manager) { AmiManager.new(aws_options) }
+
+    before do
+      expect(AWS).to receive(:config).with(
+          access_key_id: aws_options.fetch(:aws_access_key),
+          secret_access_key: aws_options.fetch(:aws_secret_key),
+          region: 'us-east-1',
+        )
+
+      allow(AWS).to receive(:ec2).and_return(ec2)
+    end
+
+    describe '#deploy' do
+      let(:instance) { instance_double(AWS::EC2::Instance, status: :running, associate_elastic_ip: nil, add_tag: nil) }
+      let(:instances) { instance_double(AWS::EC2::InstanceCollection, create: instance) }
+
+      before do
+        allow(ec2).to receive(:instances).and_return(instances)
+        allow(ami_manager).to receive(:sleep) # speed up retry logic
+      end
+
+      it 'creates an instance using AWS SDK v1' do
+        expect(ec2).to receive_message_chain(:instances, :create).with(
+            image_id: ami_id,
+            key_name: 'ssh-key-name',
+            security_group_ids: ['security-group-id'],
+            subnet: aws_options.fetch(:public_subnet_id),
+            private_ip_address: AmiManager::OPS_MANAGER_PRIVATE_IP,
+            instance_type: 'm3.medium').and_return(instance)
+
+        ami_manager.deploy(ami_file_path)
+      end
+
+      context 'when the ip address is in use' do
+        it 'retries until the IP address is available' do
+          expect(instances).to receive(:create).and_raise(AWS::EC2::Errors::InvalidIPAddress::InUse).once
+          expect(instances).to receive(:create).and_return(instance).once
+
+          ami_manager.deploy(ami_file_path)
+        end
+
+        it 'stops retrying after 60 times' do
+          expect(instances).to receive(:create).and_raise(AWS::EC2::Errors::InvalidIPAddress::InUse).
+              exactly(AmiManager::RETRY_LIMIT).times
+
+          expect { ami_manager.deploy(ami_file_path) }.to raise_error(AmiManager::RetryLimitExceeded)
+        end
+      end
+
+      it 'does not return until the instance is running' do
+        expect(instance).to receive(:status).and_return(:pending, :pending, :pending, :running)
+
+        ami_manager.deploy(ami_file_path)
+      end
+
+      it 'handles API endpoints not knowing (right away) about the instance created' do
+        expect(instance).to receive(:status).and_raise(AWS::EC2::Errors::InvalidInstanceID::NotFound).
+            exactly(AmiManager::RETRY_LIMIT - 1).times
+        expect(instance).to receive(:status).and_return(:running).once
+
+        ami_manager.deploy(ami_file_path)
+      end
+
+      it 'stops retrying after 60 times' do
+        expect(instance).to receive(:status).and_return(:pending).
+            exactly(AmiManager::RETRY_LIMIT).times
+
+        expect { ami_manager.deploy(ami_file_path) }.to raise_error(AmiManager::RetryLimitExceeded)
+      end
+
+      it 'attaches the elastic IP' do
+        expect(instance).to receive(:associate_elastic_ip).with(aws_options.fetch(:elastic_ip_id))
+
+        ami_manager.deploy(ami_file_path)
+      end
+
+      it 'tags the instance with a name' do
+        expect(instance).to receive(:add_tag).with('Name', value: aws_options.fetch(:vm_name))
+
+        ami_manager.deploy(ami_file_path)
+      end
+    end
+
+    describe '#destroy' 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) }
+      let(:instance1) { instance_double(AWS::EC2::Instance, tags: {}) }
+      let(:instance2) { instance_double(AWS::EC2::Instance, tags: {}) }
+      let(:subnet1_instances) { [instance1] }
+      let(:subnet2_instances) { [instance2] }
+
+      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)
+      end
+
+      it 'terminates all VMs in the subnet' do
+        expect(instance1).to receive(:terminate)
+        expect(instance2).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 the do not terminate tag is present' do
+          let(:persist_tag) { { AmiManager::DO_NOT_TERMINATE_TAG_KEY => 'any value' } }
+          it 'does not attempt to terminate this instance' do
+            expect(instance1).to receive(:terminate)
+            expect(instance2).to receive(:terminate)
+            expect(persistent_instance).not_to receive(:terminate)
+
+            ami_manager.destroy
+          end
+        end
+      end
+    end
+  end
+end

data/spec/vm_shepherd/ova_manager/base_spec.rb

@@ -0,0 +1,56 @@
+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

@@ -0,0 +1,134 @@
+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

@@ -0,0 +1,42 @@
+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/shepherd_spec.rb

@@ -0,0 +1,213 @@
+require 'vm_shepherd/shepherd'
+require 'recursive_open_struct'
+
+module VmShepherd
+  RSpec.describe Shepherd do
+    subject(:manager) { Shepherd.new(settings: settings) }
+
+    specify { expect(Shepherd::VCLOUD_IAAS_TYPE).to eq('vcloud') }
+    specify { expect(Shepherd::VSPHERE_IAAS_TYPE).to eq('vsphere') }
+    specify { expect(Shepherd::VSPHERE_TEMPLATE_PREFIX).to eq('tpl') }
+
+    describe '#deploy' do
+      context 'with vcloud settings' do
+        let(:settings) do
+          RecursiveOpenStruct.new(YAML.load_file(File.join(SPEC_ROOT, 'fixtures', 'shepherd', 'vcloud.yml')))
+        end
+        let(:deployer) { instance_double(VappManager::Deployer) }
+
+        it 'uses VappManager::Deployer to launch a vm' do
+          expect(VappManager::Deployer).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(deployer)
+
+          expect(deployer).to receive(:deploy).with(
+              'FAKE_PATH',
+              {
+                name: settings.vapp_deployer.vapp.name,
+                ip: settings.vapp_deployer.vapp.ip,
+                gateway: settings.vapp_deployer.vapp.gateway,
+                netmask: settings.vapp_deployer.vapp.netmask,
+                dns: settings.vapp_deployer.vapp.dns,
+                ntp: settings.vapp_deployer.vapp.ntp,
+              }
+            )
+
+          manager.deploy(path: 'FAKE_PATH')
+        end
+      end
+
+      context 'with vsphere settings' do
+        let(:settings) do
+          RecursiveOpenStruct.new(YAML.load_file(File.join(SPEC_ROOT, 'fixtures', 'shepherd', 'vsphere.yml')))
+        end
+        let(:deployer) { instance_double(OvaManager::Deployer) }
+
+        it 'uses OvaManager::Deployer to launch a vm' do
+          expect(OvaManager::Deployer).to receive(:new).
+              with(
+                {
+                  host: settings.vm_deployer.vcenter_creds.ip,
+                  user: settings.vm_deployer.vcenter_creds.username,
+                  password: settings.vm_deployer.vcenter_creds.password,
+                },
+                {
+                  datacenter: settings.vm_deployer.vsphere.datacenter,
+                  cluster: settings.vm_deployer.vsphere.cluster,
+                  resource_pool: settings.vm_deployer.vsphere.resource_pool,
+                  datastore: settings.vm_deployer.vsphere.datastore,
+                  network: settings.vm_deployer.vsphere.network,
+                  folder: settings.vm_deployer.vsphere.folder,
+                },
+              ).and_return(deployer)
+
+          expect(deployer).to receive(:deploy).with(
+              Shepherd::VSPHERE_TEMPLATE_PREFIX,
+              'FAKE_PATH',
+              {
+                ip: settings.vm_deployer.vm.ip,
+                gateway: settings.vm_deployer.vm.gateway,
+                netmask: settings.vm_deployer.vm.netmask,
+                dns: settings.vm_deployer.vm.dns,
+                ntp_servers: settings.vm_deployer.vm.ntp_servers,
+              }
+            )
+
+          manager.deploy(path: 'FAKE_PATH')
+        end
+      end
+
+      context 'with AWS settings' do
+        let(:settings) do
+          RecursiveOpenStruct.new(YAML.load_file(File.join(SPEC_ROOT, 'fixtures', 'shepherd', 'aws.yml')))
+        end
+        let(:ams_manager) { instance_double(AmiManager) }
+        let(:ami_file_path) { 'PATH_TO_AMI_FILE' }
+        let(:aws_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::Deployer to launch a VM' do
+          expect(AmiManager).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)
+        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.deploy(path: 'FAKE_PATH') }.to raise_error(Shepherd::InvalidIaas)
+        end
+      end
+    end
+
+    describe '#destroy' 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(:destroyer) { instance_double(VappManager::Destroyer) }
+
+        it 'uses VappManager::Destroyer to destroy a vm' do
+          expect(VappManager::Destroyer).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,
+              },
+              instance_of(Logger)
+            ).and_return(destroyer)
+          expect(destroyer).to receive(:destroy).with(settings.vapp_deployer.vapp.name)
+
+          manager.destroy
+        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(:destroyer) { instance_double(OvaManager::Destroyer) }
+
+        it 'uses OvaManager::Destroyer to destroy a vm' do
+          expect(OvaManager::Destroyer).to receive(:new).with(
+              settings.vm_deployer.vsphere.datacenter,
+              {
+                host: settings.vm_deployer.vcenter_creds.ip,
+                user: settings.vm_deployer.vcenter_creds.username,
+                password: settings.vm_deployer.vcenter_creds.password,
+              }
+            ).and_return(destroyer)
+          expect(destroyer).to receive(:clean_folder).with(settings.vm_deployer.vsphere.folder)
+
+          manager.destroy
+        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(AmiManager) }
+        let(:ami_destroy_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::Deployer to launch a VM' do
+          expect(AmiManager).to receive(:new).with(ami_destroy_options).and_return(ams_manager)
+          expect(ams_manager).to receive(:destroy)
+          manager.destroy
+        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.deploy(path: 'FAKE_PATH') }.to raise_error(Shepherd::InvalidIaas)
+        end
+      end
+    end
+  end
+end