vcloud-rest 0.3.0 → 1.0.0

data/lib/vcloud-rest/vcloud/catalog.rb

@@ -0,0 +1,113 @@
+module VCloudClient
+  class Connection
+    ##
+    # Fetch details about a given catalog
+    def get_catalog(catalogId)
+      params = {
+        'method' => :get,
+        'command' => "/catalog/#{catalogId}"
+      }
+
+      response, headers = send_request(params)
+      description = response.css("Description").first
+      description = description.text unless description.nil?
+
+      items = {}
+      response.css("CatalogItem[type='application/vnd.vmware.vcloud.catalogItem+xml']").each do |item|
+        items[item['name']] = item['href'].gsub(/.*\/catalogItem\//, "")
+      end
+      { :id => catalogId, :description => description, :items => items }
+    end
+
+    ##
+    # Friendly helper method to fetch an catalog id by name
+    # - organization hash (from get_organization/get_organization_by_name)
+    # - catalog name
+    def get_catalog_id_by_name(organization, catalogName)
+      result = nil
+
+      organization[:catalogs].each do |catalog|
+        if catalog[0].downcase == catalogName.downcase
+          result = catalog[1]
+        end
+      end
+
+      result
+    end
+
+    ##
+    # Friendly helper method to fetch an catalog by name
+    # - organization hash (from get_organization/get_organization_by_name)
+    # - catalog name
+    def get_catalog_by_name(organization, catalogName)
+      result = nil
+
+      organization[:catalogs].each do |catalog|
+        if catalog[0].downcase == catalogName.downcase
+          result = get_catalog(catalog[1])
+        end
+      end
+
+      result
+    end
+
+    ##
+    # Fetch details about a given catalog item:
+    # - description
+    # - vApp templates
+    def get_catalog_item(catalogItemId)
+      params = {
+        'method' => :get,
+        'command' => "/catalogItem/#{catalogItemId}"
+      }
+
+      response, headers = send_request(params)
+      description = response.css("Description").first
+      description = description.text unless description.nil?
+
+      items = []
+      response.css("Entity[type='application/vnd.vmware.vcloud.vAppTemplate+xml']").each do |item|
+        itemId = item['href'].gsub(/.*\/vAppTemplate\/vappTemplate\-/, "")
+
+        # Fetch the catalogItemId information
+        params = {
+          'method' => :get,
+          'command' => "/vAppTemplate/vappTemplate-#{itemId}"
+        }
+        response, headers = send_request(params)
+
+        # VMs Hash for all the vApp VM entities
+        vms_hash = {}
+        response.css("/VAppTemplate/Children/Vm").each do |vmElem|
+          vmName = vmElem["name"]
+          vmId = vmElem["href"].gsub(/.*\/vAppTemplate\/vm\-/, "")
+
+          # Add the VM name/id to the VMs Hash
+          vms_hash[vmName] = { :id => vmId }
+        end
+
+        items << { :id => itemId,
+                   :name => item['name'],
+                   :vms_hash => vms_hash }
+      end
+      { :id => catalogItemId, :description => description, :items => items }
+    end
+
+    ##
+    # friendly helper method to fetch an catalogItem  by name
+    # - catalogId (use get_catalog_name(org, name))
+    # - catalagItemName
+    def get_catalog_item_by_name(catalogId, catalogItemName)
+      result = nil
+      catalogElems = get_catalog(catalogId)
+
+      catalogElems[:items].each do |k, v|
+        if (k.downcase == catalogItemName.downcase)
+          result = get_catalog_item(v)
+        end
+      end
+
+      result
+    end
+  end
+end

data/lib/vcloud-rest/vcloud/network.rb

@@ -0,0 +1,78 @@
+module VCloudClient
+  class Connection
+    ##
+    # Fetch details about a given network
+    def get_network(networkId)
+      response = get_base_network(networkId)
+
+      name = response.css('OrgVdcNetwork').attribute('name').text
+
+      description = response.css("Description").first
+      description = description.text unless description.nil?
+
+      gateway = response.css('Gateway')
+      gateway = gateway.text unless gateway.nil?
+
+      netmask = response.css('Netmask')
+      netmask = netmask.text unless netmask.nil?
+
+      fence_mode = response.css('FenceMode')
+      fence_mode = fence_mode.text unless fence_mode.nil?
+
+      start_address = response.css('StartAddress')
+      start_address = start_address.text unless start_address.nil?
+
+      end_address = response.css('EndAddress')
+      end_address = end_address.text unless end_address.nil?
+
+
+      { :id => networkId, :name => name, :description => description,
+        :gateway => gateway, :netmask => netmask, :fence_mode => fence_mode,
+        :start_address => start_address, :end_address => end_address }
+    end
+
+    ##
+    # Friendly helper method to fetch an network id by name
+    # - organization hash (from get_organization/get_organization_by_name)
+    # - network name
+    def get_network_id_by_name(organization, networkName)
+      result = nil
+
+      organization[:networks].each do |network|
+        if network[0].downcase == networkName.downcase
+          result = network[1]
+        end
+      end
+
+      result
+    end
+
+    ##
+    # Friendly helper method to fetch an network by name
+    # - organization hash (from get_organization/get_organization_by_name)
+    # - network name
+    def get_network_by_name(organization, networkName)
+      result = nil
+
+      organization[:networks].each do |network|
+        if network[0].downcase == networkName.downcase
+          result = get_network(network[1])
+        end
+      end
+
+      result
+    end
+
+    private
+      # Get a network configuration
+      def get_base_network(networkId)
+        params = {
+          'method' => :get,
+          'command' => "/network/#{networkId}"
+        }
+
+        base_network, headers = send_request(params)
+        base_network
+      end
+  end
+end

data/lib/vcloud-rest/vcloud/org.rb

@@ -0,0 +1,145 @@
+module VCloudClient
+  class Connection
+    ##
+    # Fetch existing organizations and their IDs
+    def get_organizations
+      params = {
+        'method' => :get,
+        'command' => '/org'
+      }
+
+      response, headers = send_request(params)
+      orgs = response.css('OrgList Org')
+
+      results = {}
+      orgs.each do |org|
+        results[org['name']] = org['href'].gsub(/.*\/org\//, "")
+      end
+      results
+    end
+
+    ##
+    # friendly helper method to fetch an Organization Id by name
+    # - name (this isn't case sensitive)
+    def get_organization_id_by_name(name)
+      result = nil
+
+      # Fetch all organizations
+      organizations = get_organizations()
+
+      organizations.each do |organization|
+        if organization[0].downcase == name.downcase
+          result = organization[1]
+        end
+      end
+      result
+    end
+
+
+    ##
+    # friendly helper method to fetch an Organization by name
+    # - name (this isn't case sensitive)
+    def get_organization_by_name(name)
+      result = nil
+
+      # Fetch all organizations
+      organizations = get_organizations()
+
+      organizations.each do |organization|
+        if organization[0].downcase == name.downcase
+          result = get_organization(organization[1])
+        end
+      end
+      result
+    end
+
+    ##
+    # Fetch details about an organization:
+    # - catalogs
+    # - vdcs
+    # - networks
+    # - task lists
+    def get_organization(orgId)
+      params = {
+        'method' => :get,
+        'command' => "/org/#{orgId}"
+      }
+
+      response, headers = send_request(params)
+      catalogs = {}
+      response.css("Link[type='application/vnd.vmware.vcloud.catalog+xml']").each do |item|
+        catalogs[item['name']] = item['href'].gsub(/.*\/catalog\//, "")
+      end
+
+      vdcs = {}
+      response.css("Link[type='application/vnd.vmware.vcloud.vdc+xml']").each do |item|
+        vdcs[item['name']] = item['href'].gsub(/.*\/vdc\//, "")
+      end
+
+      networks = {}
+      response.css("Link[type='application/vnd.vmware.vcloud.orgNetwork+xml']").each do |item|
+        networks[item['name']] = item['href'].gsub(/.*\/network\//, "")
+      end
+
+      tasklists = {}
+      response.css("Link[type='application/vnd.vmware.vcloud.tasksList+xml']").each do |item|
+        tasklists[item['name']] = item['href'].gsub(/.*\/tasksList\//, "")
+      end
+
+      { :catalogs => catalogs, :vdcs => vdcs, :networks => networks, :tasklists => tasklists }
+    end
+
+    ##
+    # Fetch tasks from a given task list
+    #
+    # Note: id can be retrieved using get_organization
+    def get_tasks_list(id)
+      params = {
+        'method' => :get,
+        'command' => "/tasksList/#{id}"
+      }
+
+      response, headers = send_request(params)
+
+      tasks = []
+
+      response.css('Task').each do |task|
+        id = task['href'].gsub(/.*\/task\//, "")
+        operation = task['operationName']
+        status = task['status']
+        error = nil
+        error = task.css('Error').first['message'] if task['status'] == 'error'
+        start_time = task['startTime']
+        end_time = task['endTime']
+        user_canceled = task['cancelRequested'] == 'true'
+
+        tasks << {
+          :id => id,
+          :operation => operation,
+          :status => status,
+          :error => error,
+          :start_time => start_time,
+          :end_time => end_time,
+          :user_canceled => user_canceled
+         }
+      end
+      tasks
+    end
+
+    ##
+    # Cancel a given task
+    #
+    # The task will be marked for cancellation
+    def cancel_task(id)
+      params = {
+        'method' => :post,
+        'command' => "/task/#{id}/action/cancel"
+      }
+
+      # Nothing useful is returned here
+      # If return code is 20x return true
+      send_request(params)
+      true
+    end
+  end
+end

data/lib/vcloud-rest/vcloud/ovf.rb

@@ -0,0 +1,251 @@
+module VCloudClient
+  class Connection
+    ##
+    # Upload an OVF package
+    # - vdcId
+    # - vappName
+    # - vappDescription
+    # - ovfFile
+    # - catalogId
+    # - uploadOptions {}
+    def upload_ovf(vdcId, vappName, vappDescription, ovfFile, catalogId, uploadOptions={})
+      raise ::IOError, "OVF #{ovfFile} is missing." unless File.exists?(ovfFile)
+
+      # if send_manifest is not set, setting it true
+      if uploadOptions[:send_manifest].nil? || uploadOptions[:send_manifest]
+        uploadManifest = "true"
+      else
+        uploadManifest = "false"
+      end
+
+      builder = Nokogiri::XML::Builder.new do |xml|
+        xml.UploadVAppTemplateParams(
+          "xmlns" => "http://www.vmware.com/vcloud/v1.5",
+          "xmlns:ovf" => "http://schemas.dmtf.org/ovf/envelope/1",
+          "manifestRequired" => uploadManifest,
+          "name" => vappName) {
+          xml.Description vappDescription
+        }
+      end
+
+      params = {
+        'method' => :post,
+        'command' => "/vdc/#{vdcId}/action/uploadVAppTemplate"
+      }
+
+      response, headers = send_request(
+        params,
+        builder.to_xml,
+        "application/vnd.vmware.vcloud.uploadVAppTemplateParams+xml"
+      )
+
+      # Get vAppTemplate Link from location
+      vAppTemplate = headers[:location].gsub(/.*\/vAppTemplate\/vappTemplate\-/, "")
+      descriptorUpload = response.css("Files Link [rel='upload:default']").first[:href].gsub("#{@host_url}/transfer/", "")
+      transferGUID = descriptorUpload.gsub("/descriptor.ovf", "")
+
+      ovfFileBasename = File.basename(ovfFile, ".ovf")
+      ovfDir = File.dirname(ovfFile)
+
+      # Send OVF Descriptor
+      uploadURL = "/transfer/#{descriptorUpload}"
+      uploadFile = "#{ovfDir}/#{ovfFileBasename}.ovf"
+      upload_file(uploadURL, uploadFile, vAppTemplate, uploadOptions)
+
+      @logger.debug "OVF Descriptor uploaded."
+
+      # Begin the catch for upload interruption
+      begin
+        params = {
+          'method' => :get,
+          'command' => "/vAppTemplate/vappTemplate-#{vAppTemplate}"
+        }
+
+        # Loop to wait for the upload links to show up in the vAppTemplate we just created
+        while true
+          response, headers = send_request(params)
+
+          errored_task = response.css("Tasks Task [status='error']").first
+          if errored_task
+            error_msg = errored_task.css('Error').first['message']
+            raise OVFError, "OVF Upload failed: #{error_msg}"
+          end
+
+          break unless response.css("Files Link [rel='upload:default']").count == 1
+          sleep 1
+        end
+
+        if uploadManifest == "true"
+          uploadURL = "/transfer/#{transferGUID}/descriptor.mf"
+          uploadFile = "#{ovfDir}/#{ovfFileBasename}.mf"
+          upload_file(uploadURL, uploadFile, vAppTemplate, uploadOptions)
+          @logger.debug "OVF Manifest uploaded."
+        end
+
+        # Start uploading OVF VMDK files
+        params = {
+          'method' => :get,
+          'command' => "/vAppTemplate/vappTemplate-#{vAppTemplate}"
+        }
+        response, headers = send_request(params)
+        response.css("Files File [bytesTransferred='0'] Link [rel='upload:default']").each do |file|
+          fileName = file[:href].gsub("#{@host_url}/transfer/#{transferGUID}/","")
+          uploadFile = "#{ovfDir}/#{fileName}"
+          uploadURL = "/transfer/#{transferGUID}/#{fileName}"
+          upload_file(uploadURL, uploadFile, vAppTemplate, uploadOptions)
+        end
+
+        # Add item to the catalog catalogId
+        builder = Nokogiri::XML::Builder.new do |xml|
+          xml.CatalogItem(
+            "xmlns" => "http://www.vmware.com/vcloud/v1.5",
+            "type" => "application/vnd.vmware.vcloud.catalogItem+xml",
+            "name" => vappName) {
+            xml.Description vappDescription
+            xml.Entity(
+              "href" => "#{@api_url}/vAppTemplate/vappTemplate-#{vAppTemplate}"
+              )
+          }
+        end
+
+        params = {
+          'method' => :post,
+          'command' => "/catalog/#{catalogId}/catalogItems"
+        }
+
+        @logger.debug "Add item to catalog."
+        response, headers = send_request(params, builder.to_xml,
+                        "application/vnd.vmware.vcloud.catalogItem+xml")
+
+        entity = response.css("Entity").first
+
+        # TODO: the best thing would detect the real importing status.
+        result = {}
+        if entity
+          result[:id] = entity['href'].gsub(/.*\/vAppTemplate\/vappTemplate\-/, "")
+          result[:name] = entity['name']
+        end
+        result
+      rescue Exception => e
+        @logger.error "Exception detected: #{e.message}."
+
+        # Get vAppTemplate Task
+        params = {
+          'method' => :get,
+          'command' => "/vAppTemplate/vappTemplate-#{vAppTemplate}"
+        }
+        response, headers = send_request(params)
+
+        # Cancel Task
+        # Note that it might not exist (i.e., error for existing vdc entity)
+        tasks = response.css("Tasks")
+        unless tasks.empty?
+          tasks.css("Task").each do |task|
+            if task['status'] == 'error'
+              @logger.error task.css('Error').first['message']
+            else
+              id = task['href'].gsub(/.*\/task\//, "")
+              @logger.error "Aborting task #{id}..."
+              cancel_task(id)
+            end
+          end
+        end
+
+        raise e
+      end
+    end
+
+    private
+      ##
+      # Upload a large file in configurable chunks, output an optional progressbar
+      def upload_file(uploadURL, uploadFile, vAppTemplate, config={})
+        raise ::IOError, "#{uploadFile} not found." unless File.exists?(uploadFile)
+
+        # Set chunksize to 10M if not specified otherwise
+        chunkSize = (config[:chunksize] || 10485760)
+
+        # Set progress bar to default format if not specified otherwise
+        progressBarFormat = (config[:progressbar_format] || "%e <%B> %p%% %t")
+
+        # Set progress bar length to 120 if not specified otherwise
+        progressBarLength = (config[:progressbar_length] || 120)
+
+        # Open our file for upload
+        uploadFileHandle = File.new(uploadFile, "rb" )
+        fileName = File.basename(uploadFileHandle)
+
+        progressBarTitle = "Uploading: " + uploadFile.to_s
+
+        # Create a progressbar object if progress bar is enabled
+        if config[:progressbar_enable] == true && uploadFileHandle.size.to_i > chunkSize
+          progressbar = ProgressBar.create(
+            :title => progressBarTitle,
+            :starting_at => 0,
+            :total => uploadFileHandle.size.to_i,
+            :length => progressBarLength,
+            :format => progressBarFormat
+          )
+        else
+          @logger.info progressBarTitle
+        end
+        # Create a new HTTP client
+        clnt = HTTPClient.new
+
+        # Disable SSL cert verification
+        clnt.ssl_config.verify_mode=(OpenSSL::SSL::VERIFY_NONE)
+
+        # Suppress SSL depth message
+        clnt.ssl_config.verify_callback=proc{ |ok, ctx|; true };
+
+        # Perform ranged upload until the file reaches its end
+        until uploadFileHandle.eof?
+
+          # Create ranges for this chunk upload
+          rangeStart = uploadFileHandle.pos
+          rangeStop = uploadFileHandle.pos.to_i + chunkSize
+
+          # Read current chunk
+          fileContent = uploadFileHandle.read(chunkSize)
+
+          # If statement to handle last chunk transfer if is > than filesize
+          if rangeStop.to_i > uploadFileHandle.size.to_i
+            contentRange = "bytes #{rangeStart.to_s}-#{uploadFileHandle.size.to_s}/#{uploadFileHandle.size.to_s}"
+            rangeLen = uploadFileHandle.size.to_i - rangeStart.to_i
+          else
+            contentRange = "bytes #{rangeStart.to_s}-#{rangeStop.to_s}/#{uploadFileHandle.size.to_s}"
+            rangeLen = rangeStop.to_i - rangeStart.to_i
+          end
+
+          # Build headers
+          extheader = {
+            'x-vcloud-authorization' => @auth_key,
+            'Content-Range' => contentRange,
+            'Content-Length' => rangeLen.to_s
+          }
+
+          begin
+            uploadRequest = "#{@host_url}#{uploadURL}"
+            connection = clnt.request('PUT', uploadRequest, nil, fileContent, extheader)
+
+            if config[:progressbar_enable] == true && uploadFileHandle.size.to_i > chunkSize
+              params = {
+                'method' => :get,
+                'command' => "/vAppTemplate/vappTemplate-#{vAppTemplate}"
+              }
+              response, headers = send_request(params)
+
+              response.css("Files File [name='#{fileName}']").each do |file|
+                progressbar.progress=file[:bytesTransferred].to_i
+              end
+            end
+          rescue
+            retryTime = (config[:retry_time] || 5)
+            @logger.warn "Range #{contentRange} failed to upload, retrying the chunk in #{retryTime.to_s} seconds, to stop the action press CTRL+C."
+            sleep retryTime.to_i
+            retry
+          end
+        end
+        uploadFileHandle.close
+      end
+  end
+end