bosh_vcloud_cpi 0.4.9 → 0.5.0

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

@@ -0,0 +1,20 @@
+module VCloudCloud
+  module Steps
+    class StemcellInfo < Step
+      def perform(image, &block)
+        tmpdir = state[:stemcell_dir] = Dir.mktmpdir
+        # examine files in the tarball
+        `tar -C #{tmpdir} -xzf #{File.absolute_path(image)}`
+        raise 'Invalid stemcell image' unless $?.success?
+        files = Dir.glob File.join(tmpdir, '*.ovf')
+        # stemcell should only include one .ovf file
+        raise "Invalid stemcell image: having #{files.length} .ovf files" if files.length != 1
+        state[:stemcell_ovf] = File.basename files[0]
+      end
+
+      def cleanup
+        FileUtils.remove_entry_secure state[:stemcell_dir] if state[:stemcell_dir]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module VCloudCloud
+  module Steps
+    # Undeployment means deallocation of all resources for a vApp/VM like CPU and memory from a vDC resource pool.
+    # Undeploying a vApp automatically undeploys all of the virtual machines it contains.
+    # https://www.vmware.com/support/vcd/doc/rest-api-doc-1.5-html/operations/POST-UndeployVApp.html
+    class Undeploy < Step
+      def perform(ref, &block)
+        entity = client.reload state[ref]
+        if entity['deployed'] == 'true'
+          link = entity.undeploy_link
+          raise "#{entity.name} can't be undeployed" unless link
+          params = VCloudSdk::Xml::WrapperFactory.create_instance 'UndeployVAppParams'
+          client.invoke_and_wait :post, link, :payload => params
+          state[ref] = client.reload entity
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module VCloudCloud
+  module Steps
+    class UploadMediaFiles < Step
+      def perform(iso, &block)
+        # get the file to upload
+        media_file = File.new iso, 'rb'
+
+        # upload the file
+        media = state[:media]
+        incomplete_file = media.incomplete_files.pop
+        client.upload_stream incomplete_file.upload_link.href, media_file.stat.size, media_file
+
+        # reload the media file
+        state[:media] = client.reload media
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module VCloudCloud
+  module Steps
+    class UploadTemplateFiles < Step
+      def perform(&block)
+        template = client.reload state[:vapp_template]
+        # After uploading a file, we should reload the template object for incomplete_files list
+        # until all files are uploaded.
+        while template.files && !template.files.empty?
+          template.incomplete_files.each do |file|
+            if file.name.end_with?('.ovf')
+              content = File.new(File.join(state[:stemcell_dir], state[:stemcell_ovf])).read
+              client.invoke :put, file.upload_link.href,
+                      :payload => content,
+                      :headers => { :content_type => VCloudSdk::Xml::MEDIA_TYPE[:OVF] },
+                      :no_wrap => true
+            else
+              f = File.new File.join(state[:stemcell_dir], file.name)
+              @logger.debug "UPLOAD #{f.path}: #{f.size}"
+              client.upload_stream file.upload_link.href, f.size, f
+            end
+          end
+
+          template = client.reload template
+        end
+        state[:vapp_template] = client.wait_entity template
+      end
+    end
+  end
+end

data/lib/cloud/vcloud/steps.rb

@@ -0,0 +1,100 @@
+require 'common/thread_formatter' # for with_thread_name
+
+module VCloudCloud
+  # Abstract Step
+  class Step
+    attr_reader :state, :client
+
+    def initialize(state, client)
+      @client = client
+      @logger = client.logger
+      @state = state
+    end
+
+    def rollback
+    end
+
+    def cleanup
+    end
+  end
+
+  # Transactional step execution engine
+  class Transaction
+    attr_reader :name, :state, :client
+
+    def initialize(name, client)
+      @name = name
+      @client = client
+      @logger = client.logger
+      @state = {}
+      @steps = []
+    end
+
+    def next(step_class, *args, &block)
+      step = step_class.new @state, @client
+      @steps << step
+      @logger.debug "STEP #{step_class.to_s}"
+      step.perform *args, &block
+    end
+
+    def perform(options = {}, &block)
+      with_thread_name @name do
+        # Perform all steps guarded by exception handler
+        begin
+          block.call self
+        rescue => ex
+          @logger.error "FAIL #{@name} #{ex}"
+          reverse_steps :rollback
+          raise ex unless options[:no_throws]
+          @state[:error] = ex
+        ensure
+          reverse_steps :cleanup
+        end
+      end
+      @state
+    end
+
+    def self.perform(name, client = nil, options = {}, &block)
+      new(name, client).perform options, &block
+    end
+
+    private
+
+    def reverse_steps(method)
+      @steps.reverse_each do |step|
+        begin
+          @logger.debug "REV #{method.to_s.upcase} #{step.class.to_s}"
+          step.send method
+        rescue => ex
+          @logger.error(ex) if @logger
+        end
+      end
+    end
+  end
+end
+
+require_relative 'steps/stemcell_info'
+require_relative 'steps/create_template'
+require_relative 'steps/create_media'
+require_relative 'steps/upload_template_files'
+require_relative 'steps/add_catalog_item'
+require_relative 'steps/instantiate'
+require_relative 'steps/recompose'
+require_relative 'steps/delete'
+require_relative 'steps/undeploy'
+require_relative 'steps/add_networks'
+require_relative 'steps/delete_unused_networks'
+require_relative 'steps/reconfigure_vm'
+require_relative 'steps/create_update_agent_env'
+require_relative 'steps/load_agent_env'
+require_relative 'steps/save_agent_env'
+require_relative 'steps/eject_catalog_media'
+require_relative 'steps/delete_catalog_media'
+require_relative 'steps/upload_media_files'
+require_relative 'steps/insert_catalog_media'
+require_relative 'steps/poweron'
+require_relative 'steps/poweroff'
+require_relative 'steps/discard_suspended_state'
+require_relative 'steps/reboot'
+require_relative 'steps/create_disk'
+require_relative 'steps/attach_detach_disk'

data/lib/cloud/vcloud/vcd_client.rb

@@ -0,0 +1,284 @@
+require 'base64'
+require 'uri'
+require 'rest_client'
+
+require_relative 'cache'
+require_relative 'file_uploader'
+require_relative 'xml/constants'
+require_relative 'xml/wrapper'
+
+module VCloudCloud
+  class VCloudClient
+    attr_reader :logger
+
+    VCLOUD_VERSION_NUMBER = '5.1'
+
+    def initialize(vcd_settings, logger)
+      @logger = logger
+      @url  = vcd_settings['url']
+      @user = vcd_settings['user']
+      @pass = vcd_settings['password']
+      @entities = vcd_settings['entities']
+
+      control = @entities['control'] || {}
+      @wait_max       = control['wait_max'] || WAIT_MAX
+      @wait_delay     = control['wait_delay'] || WAIT_DELAY
+      @retry_max      = control['retry_max'] || RETRY_MAX
+      @retry_delay    = control['retry_delay'] || RETRY_DELAY
+      @cookie_timeout = control['cookie_timeout'] || COOKIE_TIMEOUT
+
+      @cache = Cache.new
+    end
+
+    def org_name
+      @entities['organization']
+    end
+
+    def vdc_name
+      @entities['virtual_datacenter']
+    end
+
+    def vapp_catalog_name
+      @entities['vapp_catalog']
+    end
+
+    def media_catalog_name
+      @entities['media_catalog']
+    end
+
+    def org
+      @cache.get :org do
+        session
+        resolve_link @org_link
+      end
+    end
+
+    def vdc
+      @cache.get :vdc do
+        vdc_link = org.vdc_link vdc_name
+        raise ObjectNotFoundError, "Invalid virtual datacenter name: #{vdc_name}" unless vdc_link
+        resolve_link vdc_link
+      end
+    end
+
+    # catalog should be either :vapp or :media
+    def catalog(catalog_type)
+      catalog_link = org.catalog_link @entities["#{catalog_type.to_s}_catalog"]
+      raise ObjectNotFoundError, "Invalid catalog type: #{catalog_type}" unless catalog_link
+      resolve_link catalog_link
+    end
+
+    # TODO we can discard type parameter since name should be
+    # the unique identifier of a item in one catalog.
+    def catalog_item(catalog_type, name, type)
+      cat = catalog catalog_type
+      items = cat.catalog_items name
+      result = nil
+      items.any? do |item|
+        object = resolve_link item
+        result = object if object.entity['type'] == type
+        result
+      end if items
+      result
+    end
+
+    def media(name)
+      catalog_media = catalog_item :media, name, VCloudSdk::Xml::MEDIA_TYPE[:MEDIA]
+      raise ObjectNotFoundError, "Invalid catalog media: #{name}" unless catalog_media
+      media = resolve_link catalog_media.entity
+      [media, catalog_media]
+    end
+
+    def vapp_by_name(name)
+      node = vdc.get_vapp name
+      raise ObjectNotFoundError, "vApp #{name} does not exist" unless node
+      resolve_link node.href
+    end
+
+    def resolve_link(link)
+      invoke :get, link
+    end
+
+    def resolve_entity(id)
+      session
+      entity = invoke :get, "#{@entity_resolver_link.href}#{id}"
+      raise ObjectNotFoundError, "Invalid entity urn: #{id}" unless entity
+      resolve_link entity.link
+    end
+
+    def reload(object)
+      resolve_link object.href
+    end
+
+    def invoke(method, path, options = {})
+      session
+
+      response = send_request method, path, options
+      (options[:no_wrap] || response.code == 204) ? nil : wrap_response(response)
+    end
+
+    def upload_stream(url, size, stream, options = {})
+      session
+      FileUploader.upload url, size, stream, options.merge({ :cookie => @cookie, :authorization => @auth_token })
+    end
+
+    def invoke_and_wait(*args)
+      wait_task invoke(*args)
+    end
+
+    def wait_task(task, accept_failure = false)
+      timed_loop do
+        task = reload task
+        status = task.status.downcase
+        @logger.debug "WAIT TASK #{task.urn} #{task.operation} #{status}"
+        return task if status == VCloudSdk::Xml::TASK_STATUS[:SUCCESS]
+        if [:ABORTED, :ERROR, :CANCELED].any? { |s| status == VCloudSdk::Xml::TASK_STATUS[s] }
+          return task if accept_failure
+          raise "Task #{task.urn} #{task.operation} completed unsuccessfully"
+        end
+      end
+      task
+    end
+
+    def wait_entity(entity, accept_failure = false)
+      entity.running_tasks.each do |task|
+        wait_task task, accept_failure
+      end if entity.running_tasks && !entity.running_tasks.empty?
+
+      entity = reload entity
+
+      # verify all tasks succeeded
+      unless accept_failure || entity.tasks.nil? || entity.tasks.empty?
+        failed_tasks = entity.tasks.find_all { |task| task.status.downcase != VCloudSdk::Xml::TASK_STATUS[:SUCCESS] }
+        unless failed_tasks.empty?
+          @logger.error "Failed tasks: #{failed_tasks}"
+          raise "Some tasks failed"
+        end
+      end
+
+      entity
+    end
+
+    def timed_loop(raise_exception = true)
+      start_time = Time.now
+      while Time.now - start_time < @wait_max
+        yield
+        sleep @wait_delay
+      end
+      raise TimeoutError if raise_exception
+    end
+
+    def flush_cache
+      @cache.clear
+    end
+
+    private
+
+    WAIT_MAX       = 300    # maximum wait seconds for a single task
+    WAIT_DELAY     = 5      # delay in seconds for pooling next task status
+    COOKIE_TIMEOUT = 600    # default timeout in seconds, if not specified in configuration file, after which session must be re-created
+    RETRY_MAX      = 3      # maximum attempts
+    RETRY_DELAY    = 100    # delay of first retry, the next is * 2
+
+    def cookie_available?
+      @cookie && Time.now < @cookie_expiration
+    end
+
+    def login_url
+      return @login_url if @login_url
+      default_login_url = '/api/sessions'
+
+      begin
+        response = send_request :get, '/api/versions'
+        url_node = wrap_response(response)
+        if url_node.nil?
+          @logger.warn "Unable to find version=#{VCLOUD_VERSION_NUMBER}. Default to #{default_login_url}"
+          @login_url = default_login_url
+        else
+          @login_url = url_node.login_url.content
+        end
+      rescue => ex
+        @logger.warn %Q{
+          Caught exception when retrieving login url:
+          #{ex.to_s}"
+
+          Default to #{default_login_url}
+        }
+
+        @login_url = default_login_url
+      end
+    end
+
+    def send_request(method, path, options = {})
+      path = path.href unless path.is_a?(String)
+
+      params = {
+          :method => method,
+          :url => if path.start_with?('/')
+                    @url + path
+                  else
+                    path
+                  end,
+          :headers => {
+              :Accept => "application/*+xml;version=#{VCLOUD_VERSION_NUMBER}",
+              :content_type => '*/*'
+          }
+      }
+      params[:headers][:x_vcloud_authorization] = @auth_token if !options[:login] && @auth_token
+      params[:cookies] = @cookie if !options[:login] && cookie_available?
+      params[:payload] = options[:payload].to_s if options[:payload]
+      params[:headers].merge! options[:headers] if options[:headers]
+      response = retry_for_network_issue do
+        @logger.debug "REST REQ #{method.to_s.upcase} #{params[:url]} #{params[:headers].inspect} #{params[:cookies].inspect} #{params[:payload]}"
+        RestClient::Request.execute params do |response, request, result, &block|
+          @logger.debug "REST RES #{response.code} #{response.headers.inspect} #{response.body}"
+          response.return! request, result, &block
+        end
+      end
+    end
+
+    def session
+      unless cookie_available?
+        auth = "#{@user}@#{@entities['organization']}:#{@pass}"
+        auth_header = "Basic #{Base64.encode64(auth)}"
+        response = send_request :post, login_url,
+                    :headers => { :Authorization => auth_header, :content_type => 'application/x-www-form-urlencoded' },
+                    :payload => URI.encode_www_form({ :Authorization => auth_header, :Accept => "application/*+xml;version=#{VCLOUD_VERSION_NUMBER}" }),
+                    :with_response => true
+
+        @auth_token = response.headers[:x_vcloud_authorization]
+        @cookie = response.cookies
+        @cookie_expiration = Time.now + @cookie_timeout
+        @session = wrap_response(response)
+
+        flush_cache
+        @entity_resolver_link = @session.entity_resolver
+        @org_link = @session.org_link @entities['organization']
+      end
+      @session
+    end
+
+    def wrap_response(response)
+      VCloudSdk::Xml::WrapperFactory.wrap_document response
+    end
+
+    def retry_for_network_issue
+      retries = 0
+      delay = @retry_delay
+      result = nil
+      loop do
+        begin
+          result = yield
+          break
+        rescue RestClient::Exception => ex
+          raise ex if retries >= @retry_max
+          @logger.error "RestClient exception (retry after #{delay}ms): #{ex}"
+          sleep(delay / 1000)
+          delay *= 2
+          retries += 1
+        end
+      end
+      result
+    end
+  end
+end

data/lib/cloud/vcloud/version.rb

@@ -2,7 +2,7 @@ module Bosh
   module Clouds
 
     class VCloud
-      VERSION = "0.4.9"
+      VERSION = '1.5.0.pre.3'
     end
 
   end