vm_shepherd 0.0.1 → 0.1.0

data/lib/vm_shepherd/version.rb

@@ -1,3 +1,3 @@
 module VmShepherd
-  VERSION = '0.0.1'.freeze
+  VERSION = '0.1.0'.freeze
 end

data/lib/vm_shepherd/vsphere_manager.rb

@@ -0,0 +1,293 @@
+require 'logger'
+require 'rbvmomi'
+
+module VmShepherd
+  class VsphereManager
+    TEMPLATE_PREFIX = 'tpl'.freeze
+
+    def initialize(host, username, password, datacenter_name)
+      @host = host
+      @username = username
+      @password = password
+      @datacenter_name = datacenter_name
+      @logger = Logger.new(STDERR)
+    end
+
+    def deploy(ova_path, vm_config, vsphere_config)
+      raise ArgumentError unless folder_name_is_valid?(vsphere_config[:folder])
+
+      ova_path = File.expand_path(ova_path.strip)
+      ensure_no_running_vm(vm_config)
+
+      tmp_dir = untar_vbox_ova(ova_path)
+      ovf_file_path = ovf_file_path_from_dir(tmp_dir)
+
+      template = deploy_ovf_template(ovf_file_path, vsphere_config)
+      vm = create_vm_from_template(template, vsphere_config)
+
+      reconfigure_vm(vm, vm_config)
+      power_on_vm(vm)
+    ensure
+      FileUtils.remove_entry_secure(ovf_file_path, force: true) unless ovf_file_path.nil?
+    end
+
+    def destroy(folder_name)
+      fail("#{folder_name.inspect} is not a valid folder name") unless folder_name_is_valid?(folder_name)
+
+      delete_folder_and_vms(folder_name)
+
+      fail("#{folder_name.inspect} already exists") unless datacenter.vmFolder.traverse(folder_name).nil?
+
+      datacenter.vmFolder.traverse(folder_name, RbVmomi::VIM::Folder, true)
+    end
+
+    private
+
+    attr_reader :host, :username, :password, :datacenter_name, :logger
+
+    def delete_folder_and_vms(folder_name)
+      return unless (folder = datacenter.vmFolder.traverse(folder_name))
+
+      find_vms(folder).each { |vm| power_off(vm) }
+
+      logger.info("BEGIN folder.destroy_task folder=#{folder_name}")
+      folder.Destroy_Task.wait_for_completion
+      logger.info("END   folder.destroy_task folder=#{folder_name}")
+    rescue RbVmomi::Fault => e
+      logger.info("ERROR folder.destroy_task folder=#{folder_name}", e)
+      raise
+    end
+
+    def find_vms(folder)
+      vms = folder.childEntity.grep(RbVmomi::VIM::VirtualMachine)
+      vms << folder.childEntity.grep(RbVmomi::VIM::Folder).map { |child| find_vms(child) }
+      vms.flatten
+    end
+
+    def power_off(vm)
+      2.times do
+        break if vm.runtime.powerState == 'poweredOff'
+
+        begin
+          logger.info("BEGIN vm.power_off_task vm=#{vm.name}, power_state=#{vm.runtime.powerState}")
+          vm.PowerOffVM_Task.wait_for_completion
+          logger.info("END   vm.power_off_task vm=#{vm.name}")
+        rescue StandardError => e
+          logger.info("ERROR vm.power_off_task vm=#{vm.name}")
+          raise unless e.message.start_with?('InvalidPowerState')
+        end
+      end
+    end
+
+    def folder_name_is_valid?(folder_name)
+      /\A([\w-]{1,80}\/)*[\w-]{1,80}\/?\z/.match(folder_name)
+    end
+
+    def ensure_no_running_vm(ova_config)
+      logger.info('--- Running: Checking for existing VM')
+      ip = ova_config[:external_ip] || ova_config[:ip]
+      port = ova_config[:external_port] || 443
+      fail("VM exists at #{ip}") if system("nc -z -w 5 #{ip} #{port}")
+    end
+
+    def untar_vbox_ova(ova_path)
+      logger.info("--- Running: Untarring #{ova_path}")
+      Dir.mktmpdir.tap do |dir|
+        system_or_exit("cd #{dir} && tar xfv '#{ova_path}'")
+      end
+    end
+
+    def ovf_file_path_from_dir(dir)
+      Dir["#{dir}/*.ovf"].first || fail('Failed to find ovf')
+    end
+
+    def deploy_ovf_template(ovf_file_path, vsphere_config)
+      template_name = [TEMPLATE_PREFIX, Time.new.strftime('%F-%H-%M'), cluster(vsphere_config).name].join('-')
+      logger.info("BEGIN deploy_ovf ovf_file=#{ovf_file_path} template_name=#{template_name}")
+      connection.serviceContent.ovfManager.deployOVF(
+        uri: ovf_file_path,
+        vmName: template_name,
+        vmFolder: target_folder(vsphere_config),
+        host: find_deploy_host(vsphere_config),
+        resourcePool: resource_pool(vsphere_config),
+        datastore: datastore(vsphere_config),
+        networkMappings: create_network_mappings(ovf_file_path, vsphere_config),
+        propertyMappings: {},
+      ).tap do |ovf_template|
+        ovf_template.add_delta_disk_layer_on_all_disks
+        ovf_template.MarkAsTemplate
+      end
+    end
+
+    def find_deploy_host(vsphere_config)
+      property_collector = connection.serviceContent.propertyCollector
+
+      hosts = cluster(vsphere_config).host
+      host_properties_by_host =
+        property_collector.collectMultiple(
+          hosts,
+          'datastore',
+          'runtime.connectionState',
+          'runtime.inMaintenanceMode',
+          'name',
+        )
+
+      hosts.shuffle.find do |host|
+        (host_properties_by_host[host]['runtime.connectionState'] == 'connected') && # connected
+          host_properties_by_host[host]['datastore'].member?(datastore(vsphere_config)) && # must have the destination datastore
+          !host_properties_by_host[host]['runtime.inMaintenanceMode'] #not be in maintenance mode
+      end || fail('ERROR finding host to upload OVF to')
+    end
+
+    def create_network_mappings(ovf_file_path, vsphere_config)
+      ovf = Nokogiri::XML(File.read(ovf_file_path))
+      ovf.remove_namespaces!
+      networks = ovf.xpath('//NetworkSection/Network').map { |x| x['name'] }
+      Hash[networks.map { |ovf_network| [ovf_network, network(vsphere_config)] }]
+    end
+
+    def create_vm_from_template(template, vsphere_config)
+      logger.info("BEGIN clone_vm_task tempalte=#{template.name}")
+      template.CloneVM_Task(
+        folder: target_folder(vsphere_config),
+        name: "#{template.name}-vm",
+        spec: {
+          location: {
+            pool: resource_pool(vsphere_config),
+            datastore: datastore(vsphere_config),
+            diskMoveType: :moveChildMostDiskBacking,
+          },
+          powerOn: false,
+          template: false,
+          config: {numCPUs: 2, memoryMB: 2048},
+        }
+      ).wait_for_completion
+      logger.info("END   clone_vm_task tempalte=#{template.name}")
+    end
+
+    def reconfigure_vm(vm, vm_config)
+      virtual_machine_config_spec = create_virtual_machine_config_spec(vm_config)
+      logger.info("BEGIN reconfigure_vm_task virtual_machine_cofig_spec=#{virtual_machine_config_spec.inspect}")
+      vm.ReconfigVM_Task(spec: virtual_machine_config_spec).wait_for_completion
+      logger.info("END   reconfigure_vm_task virtual_machine_cofig_spec=#{virtual_machine_config_spec.inspect}")
+    end
+
+    def create_virtual_machine_config_spec(vm_config)
+      logger.info('BEGIN VmConfigSpec creation')
+      vm_config_spec = RbVmomi::VIM::VmConfigSpec.new
+      vm_config_spec.ovfEnvironmentTransport = ['com.vmware.guestInfo']
+      vm_config_spec.property = create_vapp_property_specs(vm_config)
+      logger.info("END  VmConfigSpec creation: #{vm_config_spec.inspect}")
+
+      logger.info('BEGIN VirtualMachineConfigSpec creation')
+      virtual_machine_config_spec = RbVmomi::VIM::VirtualMachineConfigSpec.new
+      virtual_machine_config_spec.vAppConfig = vm_config_spec
+      logger.info("END  VirtualMachineConfigSpec creation #{virtual_machine_config_spec.inspect}")
+      virtual_machine_config_spec
+    end
+
+    def create_vapp_property_specs(vm_config)
+      ip_configuration = {
+        'ip0' => vm_config[:ip],
+        'netmask0' => vm_config[:netmask],
+        'gateway' => vm_config[:gateway],
+        'DNS' => vm_config[:dns],
+        'ntp_servers' => vm_config[:ntp_servers],
+      }
+
+      vapp_property_specs = []
+
+      logger.info("BEGIN VAppPropertySpec creation configuration=#{ip_configuration.inspect}")
+      # IP Configuration key order must match OVF template property order
+      ip_configuration.each_with_index do |(key, value), i|
+        vapp_property_specs << RbVmomi::VIM::VAppPropertySpec.new.tap do |spec|
+          spec.operation = 'edit'
+          spec.info = RbVmomi::VIM::VAppPropertyInfo.new.tap do |p|
+            p.key = i
+            p.label = key
+            p.value = value
+          end
+        end
+      end
+
+      vapp_property_specs << RbVmomi::VIM::VAppPropertySpec.new.tap do |spec|
+        spec.operation = 'edit'
+        spec.info = RbVmomi::VIM::VAppPropertyInfo.new.tap do |p|
+          p.key = ip_configuration.length
+          p.label = 'admin_password'
+          p.value = vm_config[:vm_password]
+        end
+      end
+      logger.info("END   VAppPropertySpec creation vapp_property_specs=#{vapp_property_specs.inspect}")
+      vapp_property_specs
+    end
+
+    def power_on_vm(vm)
+      logger.info('BEGIN power_on_vm_task')
+      vm.PowerOnVM_Task.wait_for_completion
+      logger.info('END  power_on_vm_task')
+
+      Timeout.timeout(7*60) do
+        until vm.guest_ip
+          logger.info('BEGIN polling for VM IP address')
+          sleep 30
+        end
+        logger.info("END   polling for VM IP address #{vm.guest_ip.inspect}")
+      end
+    end
+
+    def connection
+      RbVmomi::VIM.connect(
+        host: host,
+        user: username,
+        password: password,
+        ssl: true,
+        insecure: true,
+      )
+    end
+
+    def datacenter
+      connection.searchIndex.FindByInventoryPath(inventoryPath: datacenter_name).tap do |dc|
+        fail("ERROR finding datacenter #{datacenter_name.inspect}") unless dc.is_a?(RbVmomi::VIM::Datacenter)
+      end
+    end
+
+    def target_folder(vsphere_config)
+      datacenter.vmFolder.traverse(vsphere_config[:folder], RbVmomi::VIM::Folder, true)
+    end
+
+    def cluster(vsphere_config)
+      datacenter.find_compute_resource(vsphere_config[:cluster]) ||
+        fail("ERROR finding cluster #{vsphere_config[:cluster].inspect}")
+    end
+
+    def network(vsphere_config)
+      datacenter.networkFolder.traverse(vsphere_config[:network]) ||
+        fail("ERROR finding network #{vsphere_config[:network].inspect}")
+    end
+
+    def resource_pool(vsphere_config)
+      find_resource_pool(cluster(vsphere_config), vsphere_config[:resource_pool]) ||
+        fail("ERROR finding resource_pool #{vsphere_config[:resource_pool].inspect}")
+    end
+
+    def datastore(vsphere_config)
+      datacenter.find_datastore(vsphere_config[:datastore]) ||
+        fail("ERROR finding datastore #{vsphere_config[:datastore].inspect}")
+    end
+
+    def find_resource_pool(cluster, resource_pool_name)
+      if resource_pool_name
+        cluster.resourcePool.resourcePool.find { |rp| rp.name == resource_pool_name }
+      else
+        cluster.resourcePool
+      end
+    end
+
+    def system_or_exit(command)
+      logger.info("BEGIN running #{command.inspect}")
+      system(command) || fail("ERROR running #{command.inspect}")
+      logger.info("END   running #{command.inspect}")
+    end
+  end
+end

data/spec/fixtures/shepherd/openstack.yml

@@ -0,0 +1,19 @@
+iaas_type: openstack
+vm_deployer:
+  creds:
+    auth_url: 'http://example.com/version/tokens'
+    username: 'username'
+    api_key: 'api-key'
+    tenant: 'tenant'
+  vm:
+    name: 'some-vm-name'
+    flavor_parameters:
+      min_disk_size: 150
+    network_name: 'some-network'
+    key_name: 'some-key'
+    security_group_names:
+      - 'security-group-A'
+      - 'security-group-B'
+      - 'security-group-C'
+    public_ip: 198.11.195.5
+    private_ip: 192.168.100.100

data/spec/support/patched_fog.rb

@@ -0,0 +1,20 @@
+require 'fog/openstack/requests/image/create_image'
+require 'fog/openstack/requests/image/delete_image'
+require 'fog/openstack/requests/image/list_public_images_detailed'
+
+module PatchedFog
+  def self.included(spec)
+    spec.before do
+      stub_const('::Fog::Image::OpenStack::Mock', PatchedFog::ImageMock)
+      stub_const('::Fog::Time', ::Time)
+    end
+  end
+
+  class ImageMock < Fog::Image::OpenStack::Mock
+    def delete_image(image_id)
+      # Temporarily do what Fog's mock should have done–keep state of images up to date.
+      self.data[:images].delete(image_id)
+      super(image_id)
+    end
+  end
+end

data/spec/vm_shepherd/{ami_manager_spec.rb → aws_manager_spec.rb}

@@ -1,7 +1,7 @@
-require 'vm_shepherd/ami_manager'
+require 'vm_shepherd/aws_manager'
 
 module VmShepherd
-  RSpec.describe AmiManager do
+  RSpec.describe AwsManager do
     let(:access_key) { 'access-key' }
     let(:secret_key) { 'secret-key' }
     let(:ami_id) { 'ami-deadbeef' }
@@ -21,7 +21,7 @@ module VmShepherd
       }
     end
 
-    subject(:ami_manager) { AmiManager.new(aws_options) }
+    subject(:ami_manager) { AwsManager.new(aws_options) }
 
     before do
       expect(AWS).to receive(:config).with(
@@ -48,7 +48,6 @@ module VmShepherd
             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)
@@ -64,9 +63,9 @@ module VmShepherd
 
         it 'stops retrying after 60 times' do
           expect(instances).to receive(:create).and_raise(AWS::EC2::Errors::InvalidIPAddress::InUse).
-              exactly(AmiManager::RETRY_LIMIT).times
+              exactly(AwsManager::RETRY_LIMIT).times
 
-          expect { ami_manager.deploy(ami_file_path) }.to raise_error(AmiManager::RetryLimitExceeded)
+          expect { ami_manager.deploy(ami_file_path) }.to raise_error(AwsManager::RetryLimitExceeded)
         end
       end
 
@@ -78,7 +77,7 @@ module VmShepherd
 
       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
+            exactly(AwsManager::RETRY_LIMIT - 1).times
         expect(instance).to receive(:status).and_return(:running).once
 
         ami_manager.deploy(ami_file_path)
@@ -86,9 +85,9 @@ module VmShepherd
 
       it 'stops retrying after 60 times' do
         expect(instance).to receive(:status).and_return(:pending).
-            exactly(AmiManager::RETRY_LIMIT).times
+            exactly(AwsManager::RETRY_LIMIT).times
 
-        expect { ami_manager.deploy(ami_file_path) }.to raise_error(AmiManager::RetryLimitExceeded)
+        expect { ami_manager.deploy(ami_file_path) }.to raise_error(AwsManager::RetryLimitExceeded)
       end
 
       it 'attaches the elastic IP' do
@@ -131,7 +130,7 @@ module VmShepherd
         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' } }
+          let(:persist_tag) { { AwsManager::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)

data/spec/vm_shepherd/openstack_manager_spec.rb

@@ -0,0 +1,237 @@
+require 'vm_shepherd/openstack_manager'
+require 'support/patched_fog'
+
+module VmShepherd
+  RSpec.describe OpenstackManager do
+    include PatchedFog
+
+    let(:openstack_options) do
+      {
+        auth_url: 'http://example.com/version/tokens',
+        username: 'username',
+        api_key: 'api-key',
+        tenant: 'tenant',
+      }
+    end
+    let(:openstack_vm_options) do
+      {
+        name: 'some-vm-name',
+        min_disk_size: 150,
+        network_name: 'Public',
+        key_name: 'some-key',
+        security_group_names: [
+          'security-group-A',
+          'security-group-B',
+          'security-group-C',
+        ],
+        public_ip: '192.168.27.129', #magik ip to Fog::Mock
+        private_ip: '192.168.27.100',
+      }
+    end
+
+    subject(:openstack_vm_manager) { OpenstackManager.new(openstack_options) }
+
+    describe '#service' do
+      it 'creates a Fog::Compute connection' do
+        expect(Fog::Compute).to receive(:new).with(
+            {
+              provider: 'openstack',
+              openstack_auth_url: openstack_options[:auth_url],
+              openstack_username: openstack_options[:username],
+              openstack_tenant: openstack_options[:tenant],
+              openstack_api_key: openstack_options[:api_key],
+            }
+          )
+        openstack_vm_manager.service
+      end
+    end
+
+    describe '#image_service' do
+      it 'creates a Fog::Image connection' do
+        expect(Fog::Image).to receive(:new).with(
+            {
+              provider: 'openstack',
+              openstack_auth_url: openstack_options[:auth_url],
+              openstack_username: openstack_options[:username],
+              openstack_tenant: openstack_options[:tenant],
+              openstack_api_key: openstack_options[:api_key],
+              openstack_endpoint_type: 'publicURL',
+            }
+          )
+        openstack_vm_manager.image_service
+      end
+    end
+
+    describe '#network_service' do
+      it 'creates a Fog::Network connection' do
+        expect(Fog::Network).to receive(:new).with(
+            {
+              provider: 'openstack',
+              openstack_auth_url: openstack_options[:auth_url],
+              openstack_username: openstack_options[:username],
+              openstack_tenant: openstack_options[:tenant],
+              openstack_api_key: openstack_options[:api_key],
+              openstack_endpoint_type: 'publicURL',
+            }
+          )
+        openstack_vm_manager.network_service
+      end
+    end
+
+    describe '#deploy' do
+      let(:path) { 'path/to/qcow2/file' }
+      let(:file_size) { 42 }
+
+      let(:compute_service) { openstack_vm_manager.service }
+      let(:image_service) { openstack_vm_manager.image_service }
+      let(:network_service) { openstack_vm_manager.network_service }
+
+      let(:servers) { compute_service.servers }
+      let(:addresses) { compute_service.addresses }
+      let(:instance) { servers.find { |server| server.name == openstack_vm_options[:name] } }
+
+      before do
+        allow(File).to receive(:size).with(path).and_return(file_size)
+        allow(openstack_vm_manager).to receive(:say)
+
+        Fog.mock!
+        Fog::Mock.reset
+        Fog::Mock.delay = 0
+
+        allow(compute_service).to receive(:servers).and_return(servers)
+        allow(compute_service).to receive(:addresses).and_return(addresses)
+      end
+
+      it 'uploads the image' do
+        file_size = 2
+        expect(File).to receive(:size).with(path).and_return(file_size)
+
+        openstack_vm_manager.deploy(path, openstack_vm_options)
+
+        uploaded_image = image_service.images.find { |image| image.name == openstack_vm_options[:name] }
+        expect(uploaded_image).to be
+        expect(uploaded_image.size).to eq(file_size)
+      end
+
+      context 'when launching an instance' do
+        it 'launches an image instance' do
+          openstack_vm_manager.deploy(path, openstack_vm_options)
+
+          expect(instance).to be
+        end
+
+        it 'uses the correct flavor for the instance' do
+          openstack_vm_manager.deploy(path, openstack_vm_options)
+
+          instance_flavor = compute_service.flavors.find { |flavor| flavor.id == instance.flavor['id'] }
+          expect(instance_flavor.disk).to be >= 150
+        end
+
+        it 'uses the previously uploaded image' do
+          openstack_vm_manager.deploy(path, openstack_vm_options)
+
+          instance_image = image_service.images.get instance.image['id']
+          expect(instance_image.name).to eq(openstack_vm_options[:name])
+        end
+
+        it 'assigns the correct key_name to the instance' do
+          expect(servers).to receive(:create).with(
+              hash_including(:key_name => openstack_vm_options[:key_name])
+            ).and_call_original
+
+          openstack_vm_manager.deploy(path, openstack_vm_options)
+        end
+
+        it 'assigns the correct security groups' do
+          expect(servers).to receive(:create).with(
+              hash_including(:security_groups => openstack_vm_options[:security_group_names])
+            ).and_call_original
+
+          openstack_vm_manager.deploy(path, openstack_vm_options)
+        end
+
+        it 'assigns the correct private network information' do
+          assigned_network = network_service.networks.find { |network| network.name == openstack_vm_options[:network_name] }
+          expect(servers).to receive(:create).with(
+              hash_including(:nics => [
+                  { net_id: assigned_network.id, v4_fixed_ip: openstack_vm_options[:private_ip]}
+                ]
+              )
+            ).and_call_original
+
+          openstack_vm_manager.deploy(path, openstack_vm_options)
+        end
+      end
+
+      it 'waits for the server to be ready' do
+        openstack_vm_manager.deploy(path, openstack_vm_options)
+        expect(instance.state).to eq('ACTIVE')
+      end
+
+      it 'assigns an IP to the instance' do
+        openstack_vm_manager.deploy(path, openstack_vm_options)
+        ip = addresses.find { |address| address.ip == openstack_vm_options[:public_ip] }
+
+        expect(ip.instance_id).to eq(instance.id)
+      end
+    end
+
+    describe '#destroy' do
+      let(:path) { 'path/to/qcow2/file' }
+      let(:file_size) { 42 }
+
+      let(:compute_service) { openstack_vm_manager.service }
+      let(:image_service) { openstack_vm_manager.image_service }
+      let(:network_service) { openstack_vm_manager.network_service }
+
+      let(:servers) { compute_service.servers }
+      let(:addresses) { compute_service.addresses }
+      let(:images) { image_service.images }
+      let(:image) { images.find { |image| image.name == openstack_vm_options[:name] } }
+      let(:instance) { servers.find { |server| server.name == openstack_vm_options[:name] } }
+
+      before do
+        allow(File).to receive(:size).with(path).and_return(file_size)
+        allow(openstack_vm_manager).to receive(:say)
+
+        Fog.mock!
+        Fog::Mock.reset
+        Fog::Mock.delay = 0
+
+        allow(compute_service).to receive(:servers).and_return(servers)
+        allow(compute_service).to receive(:addresses).and_return(addresses)
+        allow(image_service).to receive(:images).and_return(images)
+
+        openstack_vm_manager.deploy(path, openstack_vm_options)
+      end
+
+      it 'calls destroy on the correct instance' do
+        destroy_correct_server = change do
+          servers.reload
+          servers.find { |server| server.name == openstack_vm_options[:name] }
+        end.to(nil)
+
+        expect { openstack_vm_manager.destroy(openstack_vm_options) }.to(destroy_correct_server)
+      end
+
+      it 'calls destroy on the correct image' do
+        destroy_correct_image = change do
+          images.reload
+          images.find { |image| image.name == openstack_vm_options[:name] }
+        end.to(nil)
+
+        expect { openstack_vm_manager.destroy(openstack_vm_options) }.to(destroy_correct_image)
+      end
+
+      context 'when the server does not exist' do
+        before do
+          allow(servers).to receive(:get).and_return(nil)
+        end
+
+        it 'returns without error' do
+          expect { openstack_vm_manager.destroy(openstack_vm_options) }.not_to raise_error
+        end
+      end
+    end
+  end
+end