ruby_vcloud_sdk 0.4.8 → 0.5.1

data/lib/ruby_vcloud_sdk/ip_ranges.rb

@@ -0,0 +1,95 @@
+require "netaddr"
+require "set"
+
+module VCloudSdk
+  class IpRanges
+    attr_reader :ranges
+
+    def initialize(value = nil)
+      @ranges = Set.new
+
+      parse_ip_ranges(value) unless value.nil?
+    end
+
+    def add(ip_ranges)
+      ip_ranges = objectify ip_ranges
+      result = IpRanges.new
+      result.ranges.merge @ranges
+      result.ranges.merge ip_ranges.ranges
+      result
+    end
+    alias_method :+, :add
+
+    def subtract(ip_ranges)
+      ip_ranges = objectify ip_ranges
+      difference = IpRanges.new
+      difference.ranges.merge @ranges
+      difference.ranges.subtract ip_ranges.ranges
+
+      difference
+    end
+    alias_method :-, :subtract
+
+    def include?(ip_ranges)
+      ip_ranges = objectify ip_ranges
+      @ranges.superset? ip_ranges.ranges
+    end
+
+    protected
+
+    attr_writer :ranges
+
+    private
+
+    def parse_ip_ranges(ip_ranges_string)
+      fail "Parameter is not a string" unless ip_ranges_string.is_a? String
+
+      # remove white space
+      ip_ranges_string.gsub(/\s+/, "").split(",").map do |i|
+        parse_ip_range(i)
+      end
+    end
+
+    def parse_ip_range(ip_range_string)
+      case ip_range_string
+      when /-/
+        ips = ip_range_string.split("-")
+        unless ips.length == 2
+          fail "Invalid input: #{ips.length} field/fields separated by '-'"
+        end
+
+        ips ips[0], ips[1]
+      when /\//
+        ips = NetAddr::CIDR.create(ip_range_string)
+        ips ips.first, ips.last
+      else
+        # A single IP address such as "10.142.15.11"
+        ip = NetAddr::CIDR.create(ip_range_string)
+        fail "IPv6 is not supported" if ip.is_a?(NetAddr::CIDRv6)
+        @ranges.add ip.ip
+      end
+    end
+
+    def ips(ip_start_string, ip_end_string)
+      ip_start = NetAddr::CIDR.create(ip_start_string)
+      ip_end = NetAddr::CIDR.create(ip_end_string)
+      if ip_start.is_a?(NetAddr::CIDRv6) || ip_end.is_a?(NetAddr::CIDRv6)
+        fail "IPv6 is not supported"
+      end
+
+      if ip_start > ip_end
+        fail "IP #{ip_start.ip} is bigger than IP #{ip_end.ip}"
+      end
+
+      @ranges.merge((ip_start..ip_end).map(&:ip))
+    end
+
+    def objectify(ip_ranges)
+      ip_ranges = IpRanges.new(ip_ranges) if ip_ranges.is_a? String
+      unless ip_ranges.is_a? IpRanges
+        fail "Unable to parse object that is not IpRange or string"
+      end
+      ip_ranges
+    end
+  end
+end

data/lib/ruby_vcloud_sdk/memory.rb

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

data/lib/ruby_vcloud_sdk/network.rb

@@ -0,0 +1,32 @@
+require_relative "infrastructure"
+require_relative "ip_ranges"
+
+module VCloudSdk
+  class Network
+    include Infrastructure
+
+    def initialize(session, link)
+      @session = session
+      @link = link
+    end
+
+    def name
+      entity_xml.name
+    end
+
+    def ip_ranges
+      entity_xml.ip_ranges
+        .ranges
+        .reduce(IpRanges.new) do |result, i|
+          result + IpRanges.new("#{i.start_address}-#{i.end_address}")
+        end
+    end
+
+    def allocated_ips
+      allocated_addresses = connection.get(entity_xml.allocated_addresses_link)
+      allocated_addresses.ip_addresses.map do |i|
+        i.ip_address
+      end
+    end
+  end
+end

data/lib/ruby_vcloud_sdk/powerable.rb

@@ -0,0 +1,78 @@
+module VCloudSdk
+  # Shared functions by classes VM and VApp
+  module Powerable
+    def status
+      status_code = entity_xml[:status].to_i
+      Xml::RESOURCE_ENTITY_STATUS.each_pair do |k, v|
+        return k.to_s if v == status_code
+      end
+
+      fail CloudError,
+           "Fail to find corresponding status for code '#{status_code}'"
+    end
+
+    # Power on VApp or VM
+    def power_on
+      target = entity_xml
+      class_name = self.class.name.split("::").last
+      Config.logger.debug "#{class_name} status: #{target[:status]}"
+      if is_status?(target, :POWERED_ON)
+        Config.logger.info "#{class_name} #{target.name} is already powered-on."
+        return
+      end
+
+      power_on_link = target.power_on_link
+      unless power_on_link
+        fail CloudError,
+             "#{class_name} #{target.name} not in a state able to power on."
+      end
+
+      Config.logger.info "Powering on #{class_name} #{target.name}."
+      task = connection.post(power_on_link, nil)
+      task = monitor_task task, @session.time_limit[:power_on]
+      Config.logger.info "#{class_name} #{target.name} is powered on."
+      task
+    end
+
+    # Power off VApp or VM
+    def power_off
+      target = entity_xml
+      class_name = self.class.name.split("::").last
+      Config.logger.debug "#{class_name} status: #{target[:status]}"
+      if is_status?(target, :SUSPENDED)
+        error_msg = "#{class_name} #{target.name} suspended, discard state before powering off."
+        fail class_name == "VApp" ? VappSuspendedError : VmSuspendedError,
+             error_msg
+      end
+      if is_status?(target, :POWERED_OFF)
+        Config.logger.info "#{class_name} #{target.name} is already powered off."
+        return
+      end
+
+      power_off_link = target.power_off_link
+      unless power_off_link
+        fail CloudError, "#{class_name} #{target.name} is not in a state that could be powered off."
+      end
+
+      task = connection.post(power_off_link, nil)
+      monitor_task task, @session.time_limit[:power_off]
+      Config.logger.info "#{class_name} #{target.name} is powered off."
+
+      undeploy(target, class_name)
+    end
+
+    private
+
+    def is_status?(target, status)
+      target[:status] == Xml::RESOURCE_ENTITY_STATUS[status].to_s
+    end
+
+    def undeploy(target, class_name)
+      params = Xml::WrapperFactory.create_instance("UndeployVAppParams") # Even for VM it's called UndeployVappParams
+      task = connection.post(target.undeploy_link, params)
+      task = monitor_task(task, @session.time_limit[:undeploy])
+      Config.logger.info "#{class_name} #{target.name} is undeployed."
+      task
+    end
+  end
+end

data/lib/ruby_vcloud_sdk/resources.rb

@@ -0,0 +1,13 @@
+module VCloudSdk
+
+  class Resources
+    attr_reader :cpu
+    attr_reader :memory
+
+    def initialize(cpu, memory)
+      @cpu = cpu
+      @memory = memory
+    end
+
+  end
+end

data/lib/ruby_vcloud_sdk/session.rb

@@ -0,0 +1,46 @@
+module VCloudSdk
+  class Session
+    attr_reader :connection
+    attr_accessor :retries, :time_limit, :delay
+
+    RETRIES = {
+      default: 5,
+      upload_vapp_files: 7,
+      cpi: 1,
+    }
+
+    TIME_LIMIT_SEC = {
+      default: 120,
+      delete_vapp_template: 120,
+      delete_vapp: 120,
+      delete_media: 120,
+      instantiate_vapp_template: 300,
+      power_on: 600,
+      power_off: 600,
+      undeploy: 720,
+      process_descriptor_vapp_template: 300,
+      http_request: 240,
+      recompose_vapp: 200,
+    }
+
+    DELAY = 1
+
+    private_constant :RETRIES, :TIME_LIMIT_SEC, :DELAY
+
+    def initialize(url, username, password, options)
+      @time_limit = options[:time_limit_sec] || TIME_LIMIT_SEC
+      @retries = options[:retries] || RETRIES
+      @delay = options[:delay] || DELAY
+      @connection = Connection::Connection.new(
+        url,
+        @time_limit[:http_request])
+      @session_xml_obj = @connection.connect(username, password)
+      @org_link = @session_xml_obj.organization
+    end
+
+    def org
+      @connection.get(@org_link)
+    end
+
+  end
+end

data/lib/ruby_vcloud_sdk/vapp.rb

@@ -0,0 +1,122 @@
+require_relative "infrastructure"
+require_relative "powerable"
+require_relative "vm"
+
+module VCloudSdk
+  class VApp
+    include Infrastructure
+    include Powerable
+
+    def initialize(session, link)
+      @session = session
+      @link = link
+    end
+
+    def name
+      entity_xml.name
+    end
+
+    def delete
+      vapp = entity_xml
+      vapp_name = name
+
+      if is_status?(vapp, :POWERED_ON)
+        fail CloudError,
+             "vApp #{vapp_name} is powered on, power-off before deleting."
+      end
+
+      wait_for_running_tasks(vapp, "VApp #{vapp_name}")
+
+      Config.logger.info "Deleting vApp #{vapp_name}."
+      monitor_task(connection.delete(vapp.remove_link),
+                   @session.time_limit[:delete_vapp]) do |task|
+        Config.logger.info "vApp #{vapp_name} deleted."
+        return task
+      end
+
+      fail ApiRequestError,
+           "Fail to delete vApp #{vapp_name}"
+    end
+
+    def recompose_from_vapp_template(catalog_name, template_name)
+      recompose_vapp_link = get_recompose_vapp_link
+
+      Config.logger.info "Recomposing from template '#{template_name}' in catalog '#{catalog_name}'."
+      catalog = find_catalog_by_name catalog_name
+
+      template = catalog.find_vapp_template_by_name template_name
+
+      task = connection.post recompose_vapp_link.href,
+                             recompose_from_vapp_template_param(template)
+
+      monitor_task task, @session.time_limit[:recompose_vapp]
+      Config.logger.info "vApp #{name} is recomposed."
+      self
+    end
+
+    def vms
+      entity_xml.vms.map do |vm|
+        VCloudSdk::VM.new(@session, vm.href)
+      end
+    end
+
+    def list_vms
+      entity_xml.vms.map do |vm|
+        vm.name
+      end
+    end
+
+    def find_vm_by_name(name)
+      entity_xml.vms.each do |vm|
+        return VCloudSdk::VM.new(@session, vm.href) if vm.name == name
+      end
+
+      fail ObjectNotFoundError, "VM '#{name}' is not found"
+    end
+
+    def remove_vm_by_name(vm_name)
+      target_vm = find_vm_by_name vm_name
+      recompose_vapp_link = get_recompose_vapp_link
+
+      task = connection.post recompose_vapp_link.href,
+                             remove_vm_param(target_vm)
+
+      monitor_task task, @session.time_limit[:recompose_vapp]
+      Config.logger.info "VM #{vm_name} is removed."
+      self
+    end
+
+    private
+
+    def recompose_from_vapp_template_param(template)
+      Xml::WrapperFactory.create_instance("RecomposeVAppParams").tap do |params|
+        params.name = name
+        params.all_eulas_accepted = true
+        params.add_source_item template.href
+      end
+    end
+
+    def get_recompose_vapp_link
+      recompose_vapp_link = connection
+                              .get(@link)
+                              .recompose_vapp_link
+
+      if recompose_vapp_link.nil?
+        # We are able to recompose vapp when it is suspended or powered off
+        # If vapp is powered on, throw exception
+        fail CloudError,
+             "VApp is in status of '#{status}' and can not be recomposed"
+      end
+
+      recompose_vapp_link
+    end
+
+    def remove_vm_param(vm)
+      Xml::WrapperFactory.create_instance("RecomposeVAppParams").tap do |params|
+        params.name = name
+        params.all_eulas_accepted = true
+        params.add_delete_item vm.href
+      end
+    end
+  end
+end

data/lib/ruby_vcloud_sdk/vdc.rb

@@ -0,0 +1,210 @@
+require "forwardable"
+require "uri"
+require_relative "vdc_storage_profile"
+require_relative "vapp"
+require_relative "infrastructure"
+require_relative "resources"
+require_relative "cpu"
+require_relative "disk"
+require_relative "memory"
+require_relative "network"
+require_relative "edge_gateway"
+
+module VCloudSdk
+  class VDC
+    include Infrastructure
+
+    extend Forwardable
+    def_delegators :@vdc_xml_obj,
+                   :name, :upload_link, :upload_media_link,
+                   :instantiate_vapp_template_link
+
+    BUS_TYPE = {
+      "scsi" => Xml::HARDWARE_TYPE[:SCSI_CONTROLLER]
+    }
+
+    BUS_SUB_TYPE = {
+      "lsilogic" => Xml::BUS_SUB_TYPE[:LSILOGIC]
+    }
+
+    private_constant :BUS_TYPE, :BUS_SUB_TYPE
+
+    def initialize(session, vdc_xml_obj)
+      @session = session
+      @vdc_xml_obj = vdc_xml_obj
+    end
+
+    def storage_profiles
+      storage_profile_records.map do |storage_profile|
+        VCloudSdk::VdcStorageProfile.new(storage_profile)
+      end
+    end
+
+    def list_storage_profiles
+      storage_profile_records.map do |storage_profile|
+        storage_profile.name
+      end
+    end
+
+    def find_storage_profile_by_name(name)
+      storage_profile_records.each do |storage_profile|
+        if storage_profile.name == name
+          return VCloudSdk::VdcStorageProfile.new(storage_profile)
+        end
+      end
+
+      fail ObjectNotFoundError, "Storage profile '#{name}' is not found"
+    end
+
+    def vapps
+      @vdc_xml_obj.vapps.map do |vapp_link|
+        VCloudSdk::VApp.new(@session, vapp_link)
+      end
+    end
+
+    def list_vapps
+      @vdc_xml_obj.vapps.map do |vapp_link|
+        vapp_link.name
+      end
+    end
+
+    def find_vapp_by_name(name)
+      @vdc_xml_obj.vapps.each do |vapp_link|
+        if vapp_link.name == name
+          return VCloudSdk::VApp.new(@session, vapp_link)
+        end
+      end
+
+      fail ObjectNotFoundError, "VApp '#{name}' is not found"
+    end
+
+    def resources
+      cpu = VCloudSdk::CPU.new(@vdc_xml_obj.available_cpu_cores)
+      memory = VCloudSdk::Memory.new(@vdc_xml_obj.available_memory_mb)
+      VCloudSdk::Resources.new(cpu, memory)
+    end
+
+    def networks
+      @session.org.networks.map do |network_link|
+        VCloudSdk::Network.new(@session, network_link)
+      end
+    end
+
+    def list_networks
+      @session.org.networks.map do |network_link|
+        network_link.name
+      end
+    end
+
+    def find_network_by_name(name)
+      @session.org.networks.each do |network_link|
+        if network_link.name == name
+          return VCloudSdk::Network.new(@session, network_link)
+        end
+      end
+
+      fail ObjectNotFoundError, "Network '#{name}' is not found"
+    end
+
+    def edge_gateways
+      connection
+        .get(@vdc_xml_obj.edge_gateways_link)
+        .edge_gateway_records
+        .map do |edge_gateway_link|
+        VCloudSdk::EdgeGateway.new(@session, edge_gateway_link.href)
+      end
+    end
+
+    def disks
+      @vdc_xml_obj.disks.map do |disk_link|
+        VCloudSdk::Disk.new(@session, disk_link)
+      end
+    end
+
+    def list_disks
+      @vdc_xml_obj.disks.map do |disk_link|
+        disk_link.name
+      end
+    end
+
+    def find_disks_by_name(name)
+      disks = @vdc_xml_obj
+                .disks
+                .select { |disk_link| disk_link.name == name }
+                .map { |disk_link| VCloudSdk::Disk.new(@session, disk_link.href) }
+
+      if disks.empty?
+        fail ObjectNotFoundError, "Disk '#{name}' is not found"
+      end
+
+      disks
+    end
+
+    def disk_exists?(name)
+      disks.any? do |disk|
+        disk.name == name
+      end
+    end
+
+    def create_disk(
+          name,
+          size_mb,
+          vm = nil,
+          bus_type = "scsi",
+          bus_sub_type = "lsilogic")
+
+      fail(CloudError,
+           "Invalid size in MB #{size_mb}") if size_mb <= 0
+
+      bus_type = BUS_TYPE[bus_type.downcase]
+      fail(CloudError,
+           "Invalid bus type!") unless bus_type
+
+      bus_sub_type = BUS_SUB_TYPE[bus_sub_type.downcase]
+      fail(CloudError,
+           "Invalid bus sub type!") unless bus_sub_type
+
+      Config
+        .logger
+        .info "Creating independent disk #{name} of #{size_mb}MB."
+
+      disk = connection.post(@vdc_xml_obj.add_disk_link,
+                             disk_create_params(name, size_mb, bus_type, bus_sub_type, vm),
+                             Xml::MEDIA_TYPE[:DISK_CREATE_PARAMS])
+
+      wait_for_running_tasks(disk, "Disk #{name}")
+
+      VCloudSdk::Disk.new(@session, disk.href)
+    end
+
+    def storage_profile_xml_node(name)
+      return nil if name.nil?
+
+      storage_profile = @vdc_xml_obj.storage_profile(name)
+      unless storage_profile
+        fail ObjectNotFoundError,
+             "Storage profile '#{name}' does not exist"
+      end
+
+      storage_profile
+    end
+
+    private
+
+    def storage_profile_records
+      connection
+        .get("/api/query?type=orgVdcStorageProfile&filter=vdcName==#{URI.encode(name)}")
+        .org_vdc_storage_profile_records
+    end
+
+    def disk_create_params(name, size_mb, bus_type, bus_sub_type, vm)
+      Xml::WrapperFactory.create_instance("DiskCreateParams").tap do |params|
+        params.name = name
+        params.size_bytes = size_mb * 1024 * 1024 # VCD expects bytes
+        params.bus_type = bus_type
+        params.bus_sub_type = bus_sub_type
+        params.add_locality(connection.get(vm.href)) if vm # Use xml form of vm
+      end
+    end
+  end
+end