bosh_vcloud_cpi 0.4.9 → 0.5.0

data/lib/cloud/vcloud/errors.rb

@@ -0,0 +1,9 @@
+require 'cloud/errors'
+
+module VCloudCloud
+  class ObjectNotFoundError < StandardError
+  end
+
+  class TimeoutError < StandardError
+  end
+end

data/lib/cloud/vcloud/file_uploader.rb

@@ -0,0 +1,39 @@
+module VCloudCloud
+  class FileUploader
+    class << self
+      def upload(href, size, stream, options = {})
+        request = create_request(href, size, stream, options)
+        net = create_connection(href)
+        net.start do |http|
+          response = http.request(request) { |http_response| http_response.read_body }
+          raise "Error Response: #{response.code} #{response.body}" if response.code.to_i >= 400
+          response
+        end
+      end
+
+      private
+
+      def create_request(href, size, stream, options = {})
+        http_method = options[:method] || :Put
+        headers = {}
+        headers['Content-Type'] = options[:content_type] if options[:content_type]
+        headers['X-VCloud-Authorization'] = options[:authorization] if options[:authorization]
+        headers['Cookie'] = options[:cookie].map { |k, v| "#{k.to_s}=#{CGI::unescape(v)}" }.sort.join(';') if options[:cookie]
+        headers['Content-Length'] = size.to_s
+        headers['Transfer-Encoding'] = 'chunked'
+        request_type = Net::HTTP.const_get(http_method)
+        request = request_type.new(href, headers)
+        request.body_stream = stream
+        request
+      end
+
+      def create_connection(href)
+        uri = URI::parse(href)
+        net = Net::HTTP.new(uri.host, uri.port)
+        net.use_ssl = uri.is_a?(URI::HTTPS)
+        net.verify_mode = OpenSSL::SSL::VERIFY_NONE if net.use_ssl?
+        net
+      end
+    end
+  end
+end

data/lib/cloud/vcloud/steps/add_catalog_item.rb

@@ -0,0 +1,28 @@
+module VCloudCloud
+  module Steps
+    class AddCatalogItem < Step
+      def perform(catalog_type, item, &block)
+        catalog = client.catalog catalog_type
+
+        catalog_item = VCloudSdk::Xml::WrapperFactory.create_instance 'CatalogItem'
+        catalog_item.name = item.name
+        catalog_item.entity = item
+        result = client.invoke :post,
+                               catalog.add_item_link,
+                               :payload => catalog_item,
+                               :headers => { :content_type => VCloudSdk::Xml::MEDIA_TYPE[:CATALOG_ITEM] }
+
+        state[:catalog_item] = result
+      end
+
+      def rollback
+        catalog_item = state[:catalog_item]
+        return unless catalog_item
+
+        client.invoke :delete, catalog_item
+        # remove the item from state
+        state.delete :catalog_item
+      end
+    end
+  end
+end

data/lib/cloud/vcloud/steps/add_networks.rb

@@ -0,0 +1,40 @@
+module VCloudCloud
+  module Steps
+    class AddNetworks < Step
+      def perform(networks, &block)
+        vapp = client.reload state[:vapp]
+        org_networks = client.vdc.available_networks
+        networks.each do |name|
+          @logger.debug "NETWORK ADD #{name}"
+          # find the corresponding accessible network object in org
+          org_net = org_networks.find { |n| n.name == name }
+          raise "Network #{name} not accesible to VDC #{client.vdc.name}" unless org_net
+          # clone the configuration
+          config = VCloudSdk::Xml::WrapperFactory.create_instance 'NetworkConfig'
+          copy_network_settings client.reload(org_net), config, org_net.name, VCloudSdk::Xml::FENCE_MODES[:BRIDGED]
+          vapp.network_config_section.add_network_config config
+          client.invoke_and_wait :put, vapp.network_config_section,
+                  :payload => vapp.network_config_section,
+                  :headers => { :content_type => VCloudSdk::Xml::MEDIA_TYPE[:NETWORK_CONFIG_SECTION] }
+        end
+        state[:vapp] = client.reload vapp
+      end
+
+      private
+
+      def copy_network_settings(network, network_config, vapp_net_name, fence_mode)
+        config_ip_scope = network_config.ip_scope
+        net_ip_scope = network.ip_scope
+        config_ip_scope.is_inherited = net_ip_scope.is_inherited?
+        config_ip_scope.gateway= net_ip_scope.gateway
+        config_ip_scope.netmask = net_ip_scope.netmask
+        config_ip_scope.start_address = net_ip_scope.start_address if net_ip_scope.start_address
+        config_ip_scope.end_address = net_ip_scope.end_address if net_ip_scope.end_address
+        network_config.fence_mode = fence_mode
+        network_config.parent_network['name'] = network.name
+        network_config.parent_network['href'] = network.href
+        network_config['networkName'] = vapp_net_name
+      end
+    end
+  end
+end

data/lib/cloud/vcloud/steps/attach_detach_disk.rb

@@ -0,0 +1,15 @@
+module VCloudCloud
+  module Steps
+    class AttachDetachDisk < Step
+      def perform(action, &block)
+        params = VCloudSdk::Xml::WrapperFactory.create_instance 'DiskAttachOrDetachParams'
+        params.disk_href = state[:disk].href
+        client.invoke_and_wait :post, state[:vm].send("#{action.to_s}_disk_link".to_sym),
+            :payload => params,
+            :headers => { :content_type => VCloudSdk::Xml::MEDIA_TYPE[:DISK_ATTACH_DETACH_PARAMS] }
+        state[:vm] = client.reload state[:vm]
+        state[:disk] = client.reload state[:disk]
+      end
+    end
+  end
+end

data/lib/cloud/vcloud/steps/create_disk.rb

@@ -0,0 +1,29 @@
+module VCloudCloud
+  module Steps
+    class CreateDisk < Step
+      def perform(name, size_mb, vm, &block)
+        params = VCloudSdk::Xml::WrapperFactory.create_instance 'DiskCreateParams'
+        params.name         = name
+        params.size_bytes   = size_mb << 20 # VCD expects bytes
+        params.bus_type     = VCloudSdk::Xml::HARDWARE_TYPE[:SCSI_CONTROLLER]
+        params.bus_sub_type = VCloudSdk::Xml::BUS_SUB_TYPE[:LSILOGIC]
+        params.add_locality vm if vm
+        disk = client.invoke :post, client.vdc.add_disk_link,
+                  :payload => params,
+                  :headers => { :content_type => VCloudSdk::Xml::MEDIA_TYPE[:DISK_CREATE_PARAMS] }
+        state[:disk] = client.wait_entity disk
+      end
+
+      def rollback
+        disk = state[:disk]
+        if disk
+          link = disk.remove_link
+          client.invoke_and_wait :delete, link if link
+
+          # remove the item from state
+          state.delete :disk
+        end
+      end
+    end
+  end
+end

data/lib/cloud/vcloud/steps/create_media.rb

@@ -0,0 +1,41 @@
+module VCloudCloud
+  module Steps
+    class CreateMedia < Step
+      def perform(name, iso, image_type, storage_profile, &block)
+        # get the file properties
+        media_file = File.new iso, 'rb'
+
+        # create the media item
+        params = VCloudSdk::Xml::WrapperFactory.create_instance 'Media'
+        params.name = name
+        params.size = media_file.stat.size
+        params.image_type = image_type
+        params.storage_profile = storage_profile
+        media = client.invoke :post, client.vdc.upload_media_link, :payload => params
+
+        # cache the newly created item
+        state[:media] = media
+      end
+
+      def rollback
+        # get the time to delete
+        media = state[:media]
+
+        client.timed_loop do
+          media = client.reload media
+          if media.running_tasks.empty?
+            # delete the item
+            client.invoke_and_wait :delete, media.delete_link
+            break
+          else
+            # need to wait for pending tasks to complete
+            media = client.wait_entity media
+          end
+        end
+
+        # remove the item from the state
+        state.delete :media
+      end
+    end
+  end
+end

data/lib/cloud/vcloud/steps/create_template.rb

@@ -0,0 +1,27 @@
+module VCloudCloud
+  module Steps
+    class CreateTemplate < Step
+      def perform(name, &block)
+        params = VCloudSdk::Xml::WrapperFactory.create_instance 'UploadVAppTemplateParams'
+        params.name = name
+        template = client.invoke :post, client.vdc.upload_link, :payload => params
+
+        # commit states
+        state[:vapp_template] = template
+      end
+
+      def rollback
+        template = state[:vapp_template]
+        if template
+          if template.cancel_link
+            client.invoke :post, template.cancel_link
+            template = client.reload template
+          end
+          if template.remove_link
+            client.invoke_and_wait :delete, template.remove_link
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cloud/vcloud/steps/create_update_agent_env.rb

@@ -0,0 +1,66 @@
+module VCloudCloud
+  module Steps
+    class CreateOrUpdateAgentEnv < Step
+      def perform(networks, environment, agent_properties, &block)
+        vm = state[:vm] = client.reload state[:vm]
+
+        system_disk = state[:disks][0]
+        ephemeral_disk = CreateOrUpdateAgentEnv.get_newly_added_disk vm, state[:disks]
+        state[:env] = {
+          'vm' => { 'name' => vm.name, 'id' => vm.urn },
+          'agent_id' => vm.name,
+          'disks' => {
+            'system' => system_disk.disk_id,
+            'ephemeral' => ephemeral_disk.disk_id,
+            'persistent' => {}
+          },
+          'networks' => CreateOrUpdateAgentEnv.generate_network_env(vm.hardware_section.nics, networks),
+          'env' => environment || {}
+        }.merge! agent_properties
+      end
+
+      private
+
+      def self.get_newly_added_disk(vm, previous_disks_list)
+        disks = vm.hardware_section.hard_disks
+        newly_added = disks - previous_disks_list
+        if newly_added.size != 1
+          raise "Expecting #{previous_disks_list.size + 1} disks, found #{disks.size}"
+        end
+        newly_added[0]
+      end
+
+      def self.generate_network_env(nics, networks)
+        nic_net = {}
+        nics.each do |nic|
+          nic_net[nic.network] = nic
+        end
+
+        network_env = {}
+        networks.each do |network_name, network|
+          network_entry = network.dup
+          v_network_name = network['cloud_properties']['name']
+          nic = nic_net[v_network_name]
+          next if nic.nil?
+          network_entry['mac'] = nic.mac_address
+          network_env[network_name] = network_entry
+        end
+        network_env
+      end
+
+      public
+
+      def self.update_network_env(env, vm, networks)
+        env['networks'] = generate_network_env vm.hardware_section.nics, networks
+      end
+
+      def self.update_persistent_disk(env, vm, disk_id, previous_disks_list)
+        env['disks'] ||= {}
+        env['disks']['persistent'] ||= {}
+
+        persistent_disk = get_newly_added_disk(vm, previous_disks_list)
+        env['disks']['persistent'][disk_id] = persistent_disk.disk_id
+      end
+    end
+  end
+end

data/lib/cloud/vcloud/steps/delete.rb

@@ -0,0 +1,12 @@
+module VCloudCloud
+  module Steps
+    class Delete < Step
+      def perform(entity, force = false, &block)
+        entity = client.reload entity
+        link = entity.remove_link force
+        raise "#{entity.name} can't be removed" unless link
+        client.invoke_and_wait :delete, link
+      end
+    end
+  end
+end

data/lib/cloud/vcloud/steps/delete_catalog_media.rb

@@ -0,0 +1,23 @@
+module VCloudCloud
+  module Steps
+    class DeleteCatalogMedia < Step
+      def perform(name, &block)
+        catalog_media = client.catalog_item :media, name, VCloudSdk::Xml::MEDIA_TYPE[:MEDIA]
+        # return if doesn't exist
+        return unless catalog_media
+        media = client.resolve_link catalog_media.entity
+        @logger.info "DELETEMEDIA #{media.name}"
+        client.timed_loop do
+          media = client.reload media
+          if media.running_tasks.empty?
+            client.invoke_and_wait :delete, media.delete_link
+            client.invoke :delete, catalog_media
+            return
+          else
+            media = client.wait_entity media
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cloud/vcloud/steps/delete_unused_networks.rb

@@ -0,0 +1,20 @@
+module VCloudCloud
+  module Steps
+    class DeleteUnusedNetworks < Step
+      def perform(network_names_in_use, &block)
+        vapp = client.reload state[:vapp]
+        networks = vapp.network_config_section.network_configs.map { |n| n.network_name }
+        unused = networks - network_names_in_use
+        if unused && !unused.empty?
+          unused.uniq.each do |n|
+            vapp.network_config_section.delete_network_config n
+          end
+          client.invoke_and_wait :put, vapp.network_config_section,
+                    :payload => vapp.network_config_section,
+                    :headers => { :content_type => VCloudSdk::Xml::MEDIA_TYPE[:NETWORK_CONFIG_SECTION] }
+          state[:vapp] = client.reload vapp
+        end
+      end
+    end
+  end
+end

data/lib/cloud/vcloud/steps/discard_suspended_state.rb

@@ -0,0 +1,15 @@
+module VCloudCloud
+  module Steps
+    class DiscardSuspendedState < Step
+      def perform(ref, &block)
+        entity = client.reload state[ref]
+        if entity['status'] != VCloudSdk::Xml::RESOURCE_ENTITY_STATUS[:SUSPENDED].to_s
+          @logger.debug "#{entity.name} not suspended"
+          return
+        end
+        client.invoke_and_wait :post, entity.discard_state
+        state[ref] = client.reload entity
+      end
+    end
+  end
+end

data/lib/cloud/vcloud/steps/eject_catalog_media.rb

@@ -0,0 +1,29 @@
+module VCloudCloud
+  module Steps
+    class EjectCatalogMedia < Step
+      def perform(name, &block)
+        catalog_media = client.catalog_item :media, name, VCloudSdk::Xml::MEDIA_TYPE[:MEDIA]
+        # return if doesn't exist
+        return unless catalog_media
+        media = client.resolve_link catalog_media.entity
+        params = VCloudSdk::Xml::WrapperFactory.create_instance 'MediaInsertOrEjectParams'
+        params.media_href = media.href
+        vm = state[:vm]
+        @logger.debug "EJECTMEDIA #{media.name} from VM #{vm.name}"
+        client.timed_loop do
+          media = client.reload media
+          vm = client.reload vm
+          if media.running_tasks.empty?
+            client.invoke_and_wait :post, vm.eject_media_link,
+                    :payload => params,
+                    :headers => { :content_type => VCloudSdk::Xml::MEDIA_TYPE[:MEDIA_INSERT_EJECT_PARAMS] }
+            break
+          else
+            media = client.wait_entity media
+          end
+        end
+        state[:vm] = client.reload vm
+      end
+    end
+  end
+end

data/lib/cloud/vcloud/steps/insert_catalog_media.rb

@@ -0,0 +1,26 @@
+module VCloudCloud
+  module Steps
+    class InsertCatalogMedia < Step
+      def perform(name, &block)
+        media, _ = client.media name
+        params = VCloudSdk::Xml::WrapperFactory.create_instance 'MediaInsertOrEjectParams'
+        params.media_href = media.href
+        vm = state[:vm]
+        @logger.debug "INSERTMEDIA #{media.name} into VM #{vm.name}"
+        client.timed_loop do
+          media = client.reload media
+          vm = client.reload vm
+          if media.running_tasks.empty?
+            client.invoke_and_wait :post, vm.insert_media_link,
+                    :payload => params,
+                    :headers => { :content_type => VCloudSdk::Xml::MEDIA_TYPE[:MEDIA_INSERT_EJECT_PARAMS] }
+            break
+          else
+            media = client.wait_entity media
+          end
+        end
+        state[:vm] = client.reload vm
+      end
+    end
+  end
+end

data/lib/cloud/vcloud/steps/instantiate.rb

@@ -0,0 +1,59 @@
+module VCloudCloud
+  module Steps
+    # Create a vApp from a vApp template
+    # Ref: http://pubs.vmware.com/vcd-51/index.jsp?topic=%2Fcom.vmware.vcloud.api.reference.doc_51%2Fdoc%2Foperations%2FPOST-InstantiateVAppTemplate.html
+    class Instantiate < Step
+      def perform(template_id, vapp_name, description, disk_locality, &block)
+        catalog_item = client.resolve_entity template_id
+        raise ObjectNotFoundError, "Invalid vApp template Id: #{template_id}" unless catalog_item
+        template = client.resolve_link catalog_item.entity
+
+        params = VCloudSdk::Xml::WrapperFactory.create_instance 'InstantiateVAppTemplateParams'
+        params.name = vapp_name
+        params.description = description
+        params.source = template
+        params.all_eulas_accepted = true
+        params.linked_clone = false
+        params.set_locality = locality_spec template, disk_locality
+
+        vapp = client.invoke :post, client.vdc.instantiate_vapp_template_link, :payload => params
+
+        state[:vapp] = client.wait_entity vapp
+      end
+
+      def rollback
+        vapp = state[:vapp]
+        if vapp
+          @logger.debug "Requesting vApp: #{vapp.name}"
+
+          # Note that when renaming vApp, the remove_link stays the same and points to
+          # the original vApp. To avoid potential inconsistency, fetch vApp from the server.
+          begin
+            client.flush_cache  # flush cached vdc which contains vapp list
+            vapp = client.vapp_by_name vapp.name
+            link = vapp.remove_link true
+            client.invoke_and_wait :delete, link if link
+          rescue => ex
+            @logger.debug(ex) if @logger
+          end
+
+          # remove the item from state
+          state.delete :vapp
+        end
+      end
+
+      private
+
+      def locality_spec(template, disk_locality)
+        locality = {}
+        disk_locality.each do |disk|
+          next unless disk
+          template.vms.each do |vm|
+            locality[vm] = disk
+          end
+        end
+        locality
+      end
+    end
+  end
+end

data/lib/cloud/vcloud/steps/load_agent_env.rb

@@ -0,0 +1,14 @@
+require 'yajl'
+
+module VCloudCloud
+  module Steps
+    class LoadAgentEnv < Step
+      def perform(&block)
+        vm = state[:vm] = client.reload state[:vm]
+        metadata_link = "#{vm.metadata_link.href}/#{state[:env_metadata_key]}"
+        metadata = client.invoke :get, metadata_link
+        state[:env] = Yajl.load(metadata.value || '{}')
+      end
+    end
+  end
+end

data/lib/cloud/vcloud/steps/poweroff.rb

@@ -0,0 +1,21 @@
+module VCloudCloud
+  module Steps
+    class PowerOff < Step
+      def perform(ref, discard_suspend_state = false, &block)
+        entity = client.reload state[ref]
+        if entity['status'] == VCloudSdk::Xml::RESOURCE_ENTITY_STATUS[:POWERED_OFF].to_s
+          @logger.debug "#{entity.name} already powered off"
+          return
+        end
+        if discard_suspend_state && entity['status'] == VCloudSdk::Xml::RESOURCE_ENTITY_STATUS[:SUSPENDED].to_s
+          client.invoke_and_wait :post, entity.discard_state
+          entity = state[ref] = client.reload entity
+        end
+        poweroff_link = entity.power_off_link
+        raise "#{entity.name} unable to power off" unless poweroff_link
+        client.invoke_and_wait :post, poweroff_link
+        state[ref] = client.reload entity
+      end
+    end
+  end
+end

data/lib/cloud/vcloud/steps/poweron.rb

@@ -0,0 +1,17 @@
+module VCloudCloud
+  module Steps
+    class PowerOn < Step
+      def perform(ref, &block)
+        entity = client.reload state[ref]
+        if entity['status'] == VCloudSdk::Xml::RESOURCE_ENTITY_STATUS[:POWERED_ON].to_s
+          @logger.debug "#{entity.name} already powered on"
+          return
+        end
+        poweron_link = entity.power_on_link
+        raise "#{entity.name} unable to power on" unless poweron_link
+        client.invoke_and_wait :post, poweron_link
+        state[ref] = client.reload entity
+      end
+    end
+  end
+end

data/lib/cloud/vcloud/steps/reboot.rb

@@ -0,0 +1,13 @@
+module VCloudCloud
+  module Steps
+    class Reboot < Step
+      def perform(ref, &block)
+        entity = client.reload state[ref]
+        reboot_link = entity.reboot_link
+        raise "#{entity.name} unable to reboot" unless reboot_link
+        client.invoke_and_wait :post, reboot_link
+        state[ref] = client.reload entity
+      end
+    end
+  end
+end

data/lib/cloud/vcloud/steps/recompose.rb

@@ -0,0 +1,19 @@
+module VCloudCloud
+  module Steps
+    # Recompose a vApp to add or remove VMs.
+    # Ref: http://pubs.vmware.com/vcd-51/index.jsp#operations/POST-RecomposeVApp.html
+
+    class Recompose < Step
+      def perform(name, container_vapp, vm = nil, &block)
+        params = VCloudSdk::Xml::WrapperFactory.create_instance 'RecomposeVAppParams'
+        params.name = name
+        params.all_eulas_accepted = true
+        params.add_source_item vm.href if vm
+
+        # HACK: Workaround. recomposeLink is not available when vapp is running (so force construct the link)
+        recompose_vapp_link = container_vapp.recompose_vapp_link true
+        client.invoke_and_wait :post, recompose_vapp_link, :payload => params
+      end
+    end
+  end
+end

data/lib/cloud/vcloud/steps/reconfigure_vm.rb

@@ -0,0 +1,35 @@
+module VCloudCloud
+  module Steps
+    class ReconfigureVM < Step
+      def perform(name, description, resource_pool, networks, &block)
+        vapp = state[:vapp] = client.reload state[:vapp]
+        vm = state[:vm] = client.reload state[:vm]
+
+        vm.name = name unless name.nil?
+        vm.description = description unless description.nil?
+
+        unless resource_pool.nil?
+          vm.change_cpu_count Integer(resource_pool['cpu'])
+          vm.change_memory Integer(resource_pool['ram'])
+          vm.add_hard_disk Integer(resource_pool['disk'])
+        end
+
+        unless networks.nil?
+          vm.delete_nic *vm.hardware_section.nics
+
+          networks.values.each_with_index do |network, nic_index|
+            name = network['cloud_properties']['name']
+            vm.add_nic nic_index, name, VCloudSdk::Xml::IP_ADDRESSING_MODE[:MANUAL], network['ip']
+            vm.connect_nic nic_index, name, VCloudSdk::Xml::IP_ADDRESSING_MODE[:MANUAL], network['ip']
+          end
+        end
+
+        client.invoke_and_wait :post, vm.reconfigure_link,
+                :payload => vm,
+                :headers => { :content_type => VCloudSdk::Xml::MEDIA_TYPE[:VM] }
+
+        state[:vm] = client.reload vm
+      end
+    end
+  end
+end

data/lib/cloud/vcloud/steps/save_agent_env.rb

@@ -0,0 +1,43 @@
+require 'common/common'
+require 'yajl'
+
+module VCloudCloud
+  module Steps
+    class SaveAgentEnv < Step
+      def perform(&block)
+        vm = client.reload state[:vm]
+        metadata_link = "#{vm.metadata_link.href}/#{state[:env_metadata_key]}"
+
+        @logger.debug "AGENT_ENV #{vm.urn} #{state[:env].inspect}"
+
+        env_json = Yajl::Encoder.encode state[:env]
+        @logger.debug "ENV.ISO Content: #{env_json}"
+        tmpdir = state[:tmpdir] = Dir.mktmpdir
+        env_path = File.join tmpdir, 'env'
+        iso_path = File.join tmpdir, 'env.iso'
+        File.open(env_path, 'w') { |f| f.write env_json }
+        output = `#{genisoimage} -o #{iso_path} #{env_path} 2>&1`
+        @logger.debug "GENISOIMAGE #{output}"
+        raise "genisoimage: #{$?.exitstatus}: #{output}" unless $?.success?
+
+        metadata = VCloudSdk::Xml::WrapperFactory.create_instance 'MetadataValue'
+        metadata.value = env_json
+        client.invoke_and_wait :put, metadata_link,
+                  :payload => metadata,
+                  :headers => { :content_type => VCloudSdk::Xml::MEDIA_TYPE[:METADATA_ITEM_VALUE] }
+        state[:vm] = client.reload state[:vm]
+        state[:iso] = iso_path
+      end
+
+      def cleanup
+        FileUtils.remove_entry_secure state[:tmpdir] if state[:tmpdir]
+      end
+
+      private
+
+      def genisoimage  # TODO: this should exist in bosh_common, eventually
+        @genisoimage ||= Bosh::Common.which(%w{genisoimage mkisofs})
+      end
+    end
+  end
+end