ruby_vcloud_sdk 0.4.8 → 0.5.1

data/lib/ruby_vcloud_sdk/config.rb

@@ -1,17 +1,11 @@
 module VCloudSdk
-
   class Config
     class << self
       attr_accessor :logger
-      attr_accessor :rest_logger
-      attr_accessor :rest_throttle
 
       def configure(config)
-        @logger = config["logger"] || @logger || Logger.new(STDOUT)
-        @rest_logger = config["rest_logger"] || @logger
-        @rest_throttle = config["rest_throttle"]
+        @logger = config[:logger] || @logger || Logger.new(STDOUT)
       end
     end
   end
-
 end

data/lib/ruby_vcloud_sdk/connection/connection.rb

@@ -3,37 +3,43 @@ require "rest_client"
 
 module VCloudSdk
   module Connection
-
     class Connection
-      SECURITY_CHECK = "/cloud/security_check"
-      ACCEPT = "application/*+xml;version=5.1"
-
-      def initialize(hostname_port, organization, request_timeout = nil,
-          rest_client = nil, site = nil, file_uploader = nil)
-        @organization = organization
-        @logger = Config.logger
-        @rest_logger = Config.rest_logger
-        @rest_throttle = Config.rest_throttle
+      ACCEPT = "application/*+xml;version=#{VCloudSdk::Client::VCLOUD_VERSION_NUMBER}"
+
+      REST_THROTTLE = {
+        min: 0,
+        max: 1,
+      }
+
+      private_constant :ACCEPT, :REST_THROTTLE
+
+      def initialize(url, request_timeout = nil,
+          rest_client = nil, site = nil, file_uploader = nil, rest_throttle = nil)
+        @rest_throttle = rest_throttle || REST_THROTTLE
+
+        construct_rest_logger
+        Config.configure(rest_logger: @rest_logger)
+
         rest_client = RestClient unless rest_client
         rest_client.log = @rest_logger
         request_timeout = 60 unless request_timeout
-        @site = site.nil? ? rest_client::Resource.new(hostname_port,
-          :timeout => request_timeout) : site
-        @file_uploader = file_uploader.nil? ? FileUploader : file_uploader
+        @site = site || rest_client::Resource.new(
+                          url,
+                          timeout: request_timeout)
+        @file_uploader = file_uploader || FileUploader
       end
 
       def connect(username, password)
-        login = "#{username}@#{@organization}"
-        login_password = "#{login}:#{password}"
+        login_password = "#{username}:#{password}"
         auth_header_value = "Basic #{Base64.encode64(login_password)}"
-        response = @site["/api/sessions"].post(
-          {:Authorization=>auth_header_value, :Accept=>ACCEPT})
-        @logger.debug(response)
+        response = @site[login_url].post(
+            Authorization: auth_header_value, Accept: ACCEPT)
+        Config.logger.debug(response)
         @cookies = response.cookies
         unless @cookies["vcloud-token"].gsub!("+", "%2B").nil?
-          @logger.debug("@cookies: #{@cookies.inspect}.")
+          Config.logger.debug("@cookies: #{@cookies.inspect}.")
         end
-        VCloudSdk::Xml::WrapperFactory.wrap_document(response)
+        wrap_response(response)
       end
 
       # GET an object from REST and return the unmarshalled object
@@ -41,15 +47,14 @@ module VCloudSdk
         @rest_logger.info "#{__method__.to_s.upcase} #{delay}\t " +
                            "#{self.class.get_href(destination)}"
         sleep(delay)
-        response = @site[get_nested_resource(destination)].get({
-            :Accept=>ACCEPT,
-            :cookies=>@cookies
-        })
+        response = @site[get_nested_resource(destination)].get(
+            Accept: ACCEPT,
+            cookies: @cookies)
         @rest_logger.debug(response)
-        Xml::WrapperFactory.wrap_document(response)
+        wrap_response(response)
       end
 
-      def post(destination, data, content_type = '*/*')
+      def post(destination, data, content_type = "*/*")
         @rest_logger.info "#{__method__.to_s.upcase} #{delay}\t " +
                            "#{self.class.get_href(destination)}"
         sleep(delay)
@@ -59,13 +64,13 @@ module VCloudSdk
         end
         @rest_logger.info("#{__method__.to_s.upcase} data:#{data.to_s}")
         response = @site[get_nested_resource(destination)].post(data.to_s, {
-            :Accept=>ACCEPT,
-            :cookies=>@cookies,
-            :content_type=>content_type
+            Accept: ACCEPT,
+            cookies: @cookies,
+            content_type: content_type
         })
-        raise ApiRequestError if http_error?(response)
+        fail ApiRequestError if http_error?(response)
         @rest_logger.debug(response)
-        Xml::WrapperFactory.wrap_document(response)
+        wrap_response(response)
       end
 
       def put(destination, data, content_type = "*/*")
@@ -77,16 +82,16 @@ module VCloudSdk
             "Warning: content type not specified.  Default to '*/*'")
         end
         @rest_logger.info("#{__method__.to_s.upcase} data:#{data.to_s}")
-        response = @site[get_nested_resource(destination)].put(data.to_s, {
-            :Accept=>ACCEPT,
-            :cookies=>@cookies,
-            :content_type=>content_type
-        })
-        raise ApiRequestError if http_error?(response)
+        response = @site[get_nested_resource(destination)].put(data.to_s,
+            Accept: ACCEPT,
+            cookies: @cookies,
+            content_type: content_type
+        )
+        fail ApiRequestError if http_error?(response)
         @rest_logger.debug((response && !response.strip.empty?) ?
           response : "Received empty response.")
         if response && !response.strip.empty?
-          Xml::WrapperFactory.wrap_document(response)
+          wrap_response(response)
         else
           nil
         end
@@ -96,13 +101,13 @@ module VCloudSdk
         @rest_logger.info "#{__method__.to_s.upcase} #{delay}\t " +
                            "#{self.class.get_href(destination)}"
         sleep(delay)
-        response = @site[get_nested_resource(destination)].delete({
-            :Accept=>ACCEPT,
-            :cookies=>@cookies
-        })
+        response = @site[get_nested_resource(destination)].delete(
+            Accept: ACCEPT,
+            cookies: @cookies
+        )
         @rest_logger.debug(response)
         if response && !response.strip.empty?
-          Xml::WrapperFactory.wrap_document(response)
+          wrap_response(response)
         else
           nil
         end
@@ -120,27 +125,83 @@ module VCloudSdk
       end
 
       private
+
+      def wrap_response(response)
+        VCloudSdk::Xml::WrapperFactory.wrap_document response
+      end
+
+      def login_url
+        return @login_url if @login_url
+        default_login_url = "/api/sessions"
+
+        begin
+          url_node = get("/api/versions")
+          if url_node.nil?
+            Config.logger.warn %Q{
+              Unable to find version=#{VCLOUD_VERSION_NUMBER}. Default to #{default_login_url}
+            }
+            @login_url = default_login_url
+          else
+            # Typically url_content is the full URL such as "https://10.146.21.135/api/sessions"
+            # In this case we need to trim the beginning of the url string
+            @login_url = get_nested_resource(url_node.login_url.content)
+          end
+        rescue => ex
+          Config.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 construct_rest_logger
+        Config.logger.debug("constructing rest_logger")
+
+        config_logger_dev = Config.logger.instance_eval { @logdev }.dev
+        if config_logger_dev.respond_to?(:path)
+          rest_log_filename = File.join(
+            File.dirname(config_logger_dev.path),
+            "rest")
+          log_file = File.open(rest_log_filename, "w")
+          log_file.sync = true
+          @rest_logger = Logger.new(log_file)
+          @rest_logger.level = Config.logger.level
+          @rest_logger.formatter = Config.logger.formatter
+        else
+          @rest_logger = Config.logger
+        end
+      end
+
       def log_exceptions(e)
         if e.is_a? RestClient::Exception
-          @logger.error("HTTP Code: #{e.http_code}")
-          @logger.error("HTTP Body: #{e.http_body}")
-          @logger.error("Message: #{e.message}")
-          @logger.error("Response: #{e.response}")
+          Config.logger.error("HTTP Code: #{e.http_code}")
+          Config.logger.error("HTTP Body: #{e.http_body}")
+          Config.logger.error("Message: #{e.message}")
+          Config.logger.error("Response: #{e.response}")
         end
       end
 
-      def delay()
-        @rest_throttle["min"] + rand(@rest_throttle["max"] -
-          @rest_throttle["min"])
+      def delay
+        @rest_throttle[:min] + rand(@rest_throttle[:max] -
+          @rest_throttle[:min])
       end
 
       def get_nested_resource(destination)
         href = self.class.get_href(destination)
         if href.is_a?(String)
-          URI.parse(href).path
+          uri = URI.parse(href)
+          if uri.query.nil?
+            uri.path
+          else
+            "#{uri.path}?#{uri.query}"
+          end
         else
-          raise ApiError,
-            "href is not a string. href:#{href.inspect}, dst:#{destination}."
+          fail ApiError,
+               "href is not a string. href:#{href.inspect}, dst:#{destination}."
         end
       end
 
@@ -158,6 +219,5 @@ module VCloudSdk
         end
       end
     end
-
   end
 end

data/lib/ruby_vcloud_sdk/cpu.rb

@@ -0,0 +1,11 @@
+module VCloudSdk
+
+  class CPU
+    attr_reader :available_cores
+
+    def initialize(available_cores)
+      @available_cores = available_cores
+    end
+  end
+
+end

data/lib/ruby_vcloud_sdk/disk.rb

@@ -0,0 +1,55 @@
+require "forwardable"
+require_relative "session"
+require_relative "infrastructure"
+
+module VCloudSdk
+  class Disk
+    include Infrastructure
+
+    extend Forwardable
+    def_delegators :entity_xml,
+                   :name, :bus_type, :bus_sub_type,
+                   :size_mb, :status
+
+    def initialize(session, link)
+      @session = session
+      @link = link
+    end
+
+    def href
+      @link
+    end
+
+    def attached?
+      !vm_reference.nil?
+    end
+
+    def vm
+      vm_link = vm_reference
+      fail ObjectNotFoundError,
+           "No vm is attached to disk '#{name}'" if vm_link.nil?
+
+      VCloudSdk::VM.new(@session, vm_link.href)
+    end
+
+    def delete
+      fail CloudError,
+           "Disk '#{name}' of link #{href} is attached to VM '#{vm.name}'" if attached?
+
+      disk_name = name
+      task = connection.delete(entity_xml.remove_link.href)
+      task = monitor_task(task)
+
+      Config.logger.info "Disk '#{disk_name}' of link #{@link} is deleted successfully"
+      task
+    end
+
+    private
+
+    def vm_reference
+      connection
+        .get(entity_xml.vms_link)
+        .vm_reference
+    end
+  end
+end

data/lib/ruby_vcloud_sdk/edge_gateway.rb

@@ -0,0 +1,32 @@
+require "forwardable"
+require_relative "infrastructure"
+require_relative "ip_ranges"
+
+module VCloudSdk
+  class EdgeGateway
+    include Infrastructure
+
+    extend Forwardable
+    def_delegator :entity_xml, :name
+
+    def initialize(session, link)
+      @session = session
+      @link = link
+    end
+
+    def public_ip_ranges
+      uplink_gateway_interface = entity_xml
+                                   .gateway_interfaces
+                                   .find { |g| g.interface_type == "uplink" }
+
+      ip_ranges = uplink_gateway_interface.ip_ranges
+      return IpRanges.new unless ip_ranges
+
+      ip_ranges
+        .ranges
+        .reduce(IpRanges.new) do |result, i|
+          result + IpRanges.new("#{i.start_address}-#{i.end_address}")
+        end
+    end
+  end
+end

data/lib/ruby_vcloud_sdk/infrastructure.rb

@@ -0,0 +1,135 @@
+module VCloudSdk
+  # Shared functions by classes such as Client, Catalog and VDC
+  # Make sure instance variable @session is available
+  module Infrastructure
+    ERROR_STATUSES = [Xml::TASK_STATUS[:ABORTED], Xml::TASK_STATUS[:ERROR],
+                      Xml::TASK_STATUS[:CANCELED]]
+    SUCCESS_STATUS = [Xml::TASK_STATUS[:SUCCESS]]
+
+    private
+
+    def find_vdc_by_name(name)
+      vdc_link = @session.org.vdc_link(name)
+      fail ObjectNotFoundError, "VDC #{name} not found" unless vdc_link
+      VCloudSdk::VDC.new(@session, connection.get(vdc_link))
+    end
+
+    def catalogs
+      @session.org.catalogs.map do |catalog_link|
+        VCloudSdk::Catalog.new(@session, catalog_link)
+      end
+    end
+
+    def list_catalogs
+      @session.org.catalogs.map do |catalog_link|
+        catalog_link.name
+      end
+    end
+
+    def catalog_exists?(name)
+      @session.org.catalogs.any? do |catalog|
+        catalog.name == name
+      end
+    end
+
+    def find_catalog_by_name(name)
+      @session.org.catalogs.each do |catalog_link|
+        if catalog_link.name == name
+          return VCloudSdk::Catalog.new(@session, catalog_link)
+        end
+      end
+
+      fail ObjectNotFoundError, "Catalog '#{name}' is not found"
+    end
+
+    def connection
+      @session.connection
+    end
+
+    def monitor_task(
+      task,
+      time_limit = @session.time_limit[:default],
+      error_statuses = ERROR_STATUSES,
+      success = SUCCESS_STATUS,
+      delay = @session.delay,
+      &b)
+
+      iterations = time_limit / delay
+      i = 0
+      prev_progress = task.progress
+      prev_status = task.status
+      current_task = task
+      while i < iterations
+        Config.logger.debug %Q{
+          #{current_task.urn} #{current_task.operation} is #{current_task.status}
+        }
+
+        if task_is_success(current_task, success)
+          if b
+            return b.call(current_task)
+          else
+            return current_task
+          end
+        elsif task_has_error(current_task, error_statuses)
+          fail ApiRequestError,
+               "Task #{task.urn} #{task.operation} did not complete successfully."
+        elsif task_progressed?(current_task, prev_progress, prev_status)
+          Config.logger.debug %Q{
+            task status #{prev_status} =>
+            #{current_task.status}, progress #{prev_progress}% =>
+            #{current_task.progress}%, timer #{i} reset.
+          }
+          prev_progress = current_task.progress
+          prev_status = current_task.status
+          i = 0  # Reset clock if status changes or running task makes progress
+          sleep(delay)
+        else
+          Config.logger.debug %Q{
+            Approximately #{i * delay}s elapsed waiting for #{current_task.operation} to
+            reach #{success.join("/")}/#{error_statuses.join("/")}.
+            Checking again in #{delay} seconds.
+          }
+          if current_task.progress
+            Config.logger.debug(
+              "Task #{task.urn} progress: #{current_task.progress} %.")
+          end
+          sleep(delay)
+        end
+        current_task = connection.get(task)
+        i += 1
+      end
+      fail ApiTimeoutError,
+           "Task #{task.operation} did not complete within limit of #{time_limit} seconds."
+    end
+
+    def task_progressed?(current_task, prev_progress, prev_status)
+      (current_task.progress && (current_task.progress != prev_progress)) ||
+        (current_task.status && (current_task.status != prev_status))
+    end
+
+    def task_is_success(current_task, success = SUCCESS_STATUS)
+      success.find do |s|
+        s.downcase == current_task.status.downcase
+      end
+    end
+
+    def task_has_error(current_task, error_statuses = ERROR_STATUSES)
+      error_statuses.find do |s|
+        s.downcase == current_task.status.downcase
+      end
+    end
+
+    def entity_xml
+      connection.get(@link)
+    end
+
+    def wait_for_running_tasks(subject, subject_display)
+      unless subject.running_tasks.empty?
+        Config.logger.info "#{subject_display} has tasks in progress, wait until done."
+        subject.running_tasks.each do |task|
+          monitor_task(task)
+        end
+      end
+    end
+  end
+end