class VCloudSdk::Catalog

Public Class Methods

new(session, link) click to toggle source
# File lib/ruby_vcloud_sdk/catalog.rb, line 10
def initialize(session, link)
  @session = session
  @link = link
end

Public Instance Methods

delete_all_items() click to toggle source
# File lib/ruby_vcloud_sdk/catalog.rb, line 63
def delete_all_items
  admin_xml.catalog_items.map do |link|
    Config.logger.info "Deleting catalog item \"#{link.name}\""
    delete_item_by_link(link)
  end
  self
end
delete_item_by_name_and_type(name, item_type = nil) click to toggle source
# File lib/ruby_vcloud_sdk/catalog.rb, line 54
def delete_item_by_name_and_type(name, item_type = nil)
  link = find_item_link(name)
  item = VCloudSdk::CatalogItem.new(@session, link)

  check_item_type(item, item_type)
  delete_item_by_link(link)
  self
end
find_item(name, item_type = nil) click to toggle source

Find catalog item from catalog by name and type. If item_type is set to nil, returns catalog item as long as its name match. Raises an exception if catalog is not found. Raises ObjectNotFoundError if an item matching the name and type is not found. Otherwise, returns the catalog item.

# File lib/ruby_vcloud_sdk/catalog.rb, line 40
def find_item(name, item_type = nil)
  link = find_item_link(name)
  item = VCloudSdk::CatalogItem.new(@session, link)
  check_item_type(item, item_type)
  item
end
find_media_by_name(name) click to toggle source
# File lib/ruby_vcloud_sdk/catalog.rb, line 103
def find_media_by_name(name)
  find_item(name, Xml::MEDIA_TYPE[:MEDIA])
end
find_vapp_template_by_name(name) click to toggle source
# File lib/ruby_vcloud_sdk/catalog.rb, line 135
def find_vapp_template_by_name(name)
  find_item(name, Xml::MEDIA_TYPE[:VAPP_TEMPLATE])
end
id() click to toggle source
# File lib/ruby_vcloud_sdk/catalog.rb, line 19
def id
  @link.href_id
end
instantiate_vapp_template(template_name, vdc_name, vapp_name, description = nil, disk_locality = nil, network_config = nil) click to toggle source
# File lib/ruby_vcloud_sdk/catalog.rb, line 139
def instantiate_vapp_template(template_name, vdc_name, vapp_name,
    description = nil, disk_locality = nil, network_config = nil)

  instantiate_vapp_params = create_instantiate_vapp_params(
      template_name, vapp_name, description, disk_locality, network_config)

  vdc = find_vdc_by_name vdc_name

  vapp = connection.post(vdc.instantiate_vapp_template_link,
                         instantiate_vapp_params)
  vapp.running_tasks.each do |task|
    begin
      monitor_task(task, @session.time_limit[:instantiate_vapp_template])
    rescue ApiError => e
      Config.logger.error(e, "Instantiate vApp template #{vapp_name} " +
          "failed. Task #{task.operation} did not complete successfully.")
      raise e
    end
  end

  vdc = find_vdc_by_name vdc_name # Refresh information about vdc
  vdc.find_vapp_by_name vapp_name
end
item_exists?(name, item_type = nil) click to toggle source
# File lib/ruby_vcloud_sdk/catalog.rb, line 47
def item_exists?(name, item_type = nil)
  items.any? do |item|
    item.name == name &&
      (item_type.nil? || item.type == item_type)
  end
end
items() click to toggle source
# File lib/ruby_vcloud_sdk/catalog.rb, line 23
def items
  admin_xml.catalog_items.map do |item|
    VCloudSdk::CatalogItem.new(@session, item)
  end
end
list_items() click to toggle source
# File lib/ruby_vcloud_sdk/catalog.rb, line 29
def list_items
  admin_xml.catalog_items.map do |item_link|
    item_link.name
  end
end
name() click to toggle source
# File lib/ruby_vcloud_sdk/catalog.rb, line 15
def name
  admin_xml.name
end
upload_media( vdc_name, media_name, file, storage_profile_name = nil, image_type = "iso") click to toggle source
# File lib/ruby_vcloud_sdk/catalog.rb, line 71
def upload_media(
    vdc_name,
    media_name,
    file,
    storage_profile_name = nil,
    image_type = "iso")

  if item_exists?(media_name)
    fail CloudError,
         "Catalog Item '#{media_name}' already exists in catalog #{name}"
  end

  Config.logger.info %Q{
     Uploading file #{file}
     as media #{media_name} of type #{image_type}
     to catalog #{name}, storage profile #{storage_profile_name}, vdc #{vdc_name}
  }

  media_file = file.is_a?(String) ? File.new(file, "rb") : file

  vdc = find_vdc_by_name vdc_name

  storage_profile = vdc.storage_profile_xml_node storage_profile_name

  media = upload_media_params media_name, vdc, media_file, image_type, storage_profile

  media = upload_media_file media, media_file

  add_item(media)
  find_media_by_name(media_name)
end
upload_vapp_template( vdc_name, template_name, directory, storage_profile_name = nil) click to toggle source
# File lib/ruby_vcloud_sdk/catalog.rb, line 107
def upload_vapp_template(
    vdc_name,
    template_name,
    directory,
    storage_profile_name = nil)
  if item_exists?(template_name)
    fail CloudError,
         "vApp template '#{template_name}' already exists in catalog #{name}"
  end

  vdc = find_vdc_by_name vdc_name

  storage_profile = vdc.storage_profile_xml_node storage_profile_name

  Config.logger.info "Uploading vApp #{template_name} to #{vdc.name}"
  vapp_template = upload_vapp_template_params(template_name, vdc, storage_profile)

  vapp_template = upload_vapp_files(vapp_template, ovf_directory(directory))

  validate_vapp_template_tasks vapp_template

  Config.logger.info %Q{
    Template #{template_name} uploaded, adding to catalog #{name}.
  }
  add_item(vapp_template)
  find_vapp_template_by_name(template_name)
end

Private Instance Methods

add_item(item) click to toggle source
# File lib/ruby_vcloud_sdk/catalog.rb, line 165
def add_item(item)
  payload = create_catalog_item_payload(item)
  catalog_name = name
  catalog_item_name = item.name
  Config.logger.info "Adding #{catalog_item_name} to catalog #{catalog_name}"
  connection.post(admin_xml.add_item_link,
                  payload,
                  Xml::ADMIN_MEDIA_TYPE[:CATALOG_ITEM])
  Config.logger.info %Q{
    catalog_item #{catalog_item_name} added to catalog #{catalog_name}
  }
end
admin_xml() click to toggle source
# File lib/ruby_vcloud_sdk/catalog.rb, line 232
def admin_xml
  admin_catalog_link = "/api/admin/catalog/#{id}"
  admin_catalog = connection.get(admin_catalog_link)

  unless admin_catalog
    fail ObjectNotFoundError,
         "Catalog link #{admin_catalog_link} not available."
  end

  admin_catalog
end
check_item_type(item, item_type) click to toggle source
# File lib/ruby_vcloud_sdk/catalog.rb, line 204
def check_item_type(item, item_type)
  unless item_type.nil? || item.type == item_type
    fail ObjectNotFoundError, "Catalog Item '#{item.name}' is not found"
  end
end
create_catalog_item_payload(item) click to toggle source
# File lib/ruby_vcloud_sdk/catalog.rb, line 244
def create_catalog_item_payload(item)
  Xml::WrapperFactory.create_instance(Xml::XML_TYPE[:CATALOGITEM]).tap do |payload|
    payload.name = item.name
    payload.entity = item
  end
end
create_instantiate_vapp_params(template_name, vapp_name, description, disk_locality, network_config) click to toggle source
# File lib/ruby_vcloud_sdk/catalog.rb, line 332
def create_instantiate_vapp_params(template_name,
    vapp_name, description, disk_locality, network_config)

  source_vapp_template = retrieve_vapp_template_xml_node(template_name)

  instantiate_vapp_params = Xml::WrapperFactory.create_instance(
      "InstantiateVAppTemplateParams")
  instantiate_vapp_params.name = vapp_name
  instantiate_vapp_params.description = description

  set_vapp_network_config_param(instantiate_vapp_params, network_config)

  instantiate_vapp_params.source = source_vapp_template
  instantiate_vapp_params.all_eulas_accepted = true
  instantiate_vapp_params.linked_clone = false
  instantiate_vapp_params.set_locality = locality_spec(
      source_vapp_template, disk_locality)

  instantiate_vapp_params
end
delete_item_entity(entity) click to toggle source
# File lib/ruby_vcloud_sdk/catalog.rb, line 185
def delete_item_entity(entity)
  linked_obj = connection.get(entity)

  wait_for_running_tasks(linked_obj, linked_obj.href)
  Config.logger.info "Deleting #{linked_obj.href}."
  monitor_task(connection.delete(linked_obj))
  Config.logger.info "#{linked_obj.href} deleted."
end
locality_spec(vapp_template, disk_locality) click to toggle source
# File lib/ruby_vcloud_sdk/catalog.rb, line 353
def locality_spec(vapp_template, disk_locality)
  disk_locality ||= []
  locality = {}
  disk_locality.each do |disk|
    current_disk = connection.get(disk)
    unless current_disk
      Config.logger.info "Disk #{disk.name} no longer exists."
      next
    end
    vapp_template.vms.each do |vm|
      locality[vm] = current_disk
    end
  end
  locality
end
ovf_directory(directory) click to toggle source
# File lib/ruby_vcloud_sdk/catalog.rb, line 218
def ovf_directory(directory)
  # if directory behaves like an OVFDirectory, then use it
  is_ovf_directory = [:ovf_file, :ovf_file_path, :vmdk_file, :vmdk_file_path]
    .reduce(true) do |present, name|
    present && directory.respond_to?(name)
  end

  if is_ovf_directory
    directory
  else
    OVFDirectory.new(directory)
  end
end
retrieve_vapp_template_xml_node(template_name) click to toggle source
# File lib/ruby_vcloud_sdk/catalog.rb, line 322
def retrieve_vapp_template_xml_node(template_name)
  vapp_template = find_vapp_template_by_name(template_name)
  unless vapp_template
    fail ObjectNotFoundError, "vapp_template #{template_name}" +
        "cannot be found in catalog #{@name}."
  end

  connection.get(vapp_template.href)
end
set_vapp_network_config_param(instantiate_vapp_params, network_config) click to toggle source
# File lib/ruby_vcloud_sdk/catalog.rb, line 387
def set_vapp_network_config_param(instantiate_vapp_params, network_config)
  return unless network_config

  network = find_network_by_name(network_config.network_name)
  target_vapp_net_name = network_config.vapp_net_name.nil? ?
                         network.name : network_config.vapp_net_name

  instantiate_vapp_params.set_network_config(target_vapp_net_name,
                                             network.href["href"].to_s,
                                             network_config.fence_mode.to_s)
end
upload_media_file(media, media_file) click to toggle source
# File lib/ruby_vcloud_sdk/catalog.rb, line 379
def upload_media_file(media, media_file)
  incomplete_file = media.incomplete_files.pop
  connection.put_file(incomplete_file.upload_link, media_file)
  connection.get(media)
end
upload_media_params(media_name, vdc, media_file, image_type, storage_profile) click to toggle source
# File lib/ruby_vcloud_sdk/catalog.rb, line 369
def upload_media_params(media_name, vdc, media_file, image_type, storage_profile)
  upload_params = Xml::WrapperFactory.create_instance("Media")
  upload_params.name = media_name
  upload_params.size = media_file.stat.size
  upload_params.image_type = image_type
  upload_params.storage_profile = storage_profile

  connection.post(vdc.upload_media_link, upload_params)
end
upload_vapp_files( vapp_template, ovf_directory, tries = @session.retries[:upload_vapp_files]) click to toggle source
# File lib/ruby_vcloud_sdk/catalog.rb, line 266
def upload_vapp_files(
    vapp_template,
    ovf_directory,
    tries = @session.retries[:upload_vapp_files])
  tries.times do |try|
    current_vapp_template = connection.get(vapp_template)
    if !current_vapp_template.files || current_vapp_template.files.empty?
      Config.logger.info %Q{
        #{current_vapp_template.name} has tasks in progress...
        Waiting until done...
      }
      current_vapp_template.running_tasks.each do |task|
        monitor_task(task,
                     @session.time_limit[:process_descriptor_vapp_template])
      end

      return current_vapp_template
    end

    Config.logger.debug "vapp files left to upload #{current_vapp_template.files}."
    Config.logger.debug %Q{
      vapp incomplete files left to upload:
      #{current_vapp_template.incomplete_files}
    }

    current_vapp_template.incomplete_files.each do |f|
      # switch on extension
      case f.name.split(".")[-1].downcase
      when "ovf"
        Config.logger.info %Q{
          Uploading OVF file:
          #{ovf_directory.ovf_file_path} for #{vapp_template.name}
        }
        connection.put(f.upload_link, ovf_directory.ovf_file.read,
                       Xml::MEDIA_TYPE[:OVF])
      when "vmdk"
        Config.logger.info %Q{
          Uploading VMDK file:
          #{ovf_directory.vmdk_file_path(f.name)} for #{vapp_template.name}
        }
        connection.put_file(f.upload_link,
                            ovf_directory.vmdk_file(f.name))
      end
    end
    # Repeat
    sleep 2**try
  end

  fail ApiTimeoutError,
       %Q{
         Unable to finish uploading vApp after #{tries} tries.
         current_vapp_template.files:
         #{current_vapp_template.files}
       }
end
upload_vapp_template_params(template_name, vdc, storage_profile) click to toggle source
# File lib/ruby_vcloud_sdk/catalog.rb, line 210
def upload_vapp_template_params(template_name, vdc, storage_profile)
  upload_params = Xml::WrapperFactory.create_instance(
    "UploadVAppTemplateParams")
  upload_params.name = template_name
  upload_params.storage_profile = storage_profile
  connection.post(vdc.upload_link, upload_params)
end
validate_vapp_template_tasks(vapp_template) click to toggle source
# File lib/ruby_vcloud_sdk/catalog.rb, line 251
def validate_vapp_template_tasks(vapp_template)
  err_tasks = connection.get(vapp_template).tasks.select do |t|
    t.status != Xml::TASK_STATUS[:SUCCESS]
  end
  unless err_tasks.empty?

    Config.logger.error %Q{
      Error uploading vApp template.
      Non-successful tasks:
      #{err_tasks}
    }
    fail CloudError, "Error uploading vApp template"
  end
end