ruby_vcloud_sdk 0.5.1 → 0.6.0

data/lib/ruby_vcloud_sdk/vdc.rb

@@ -15,23 +15,15 @@ module VCloudSdk
     include Infrastructure
 
     extend Forwardable
-    def_delegators :@vdc_xml_obj,
+    def_delegators :entity_xml,
                    :name, :upload_link, :upload_media_link,
                    :instantiate_vapp_template_link
 
-    BUS_TYPE = {
-      "scsi" => Xml::HARDWARE_TYPE[:SCSI_CONTROLLER]
-    }
+    public :find_network_by_name
 
-    BUS_SUB_TYPE = {
-      "lsilogic" => Xml::BUS_SUB_TYPE[:LSILOGIC]
-    }
-
-    private_constant :BUS_TYPE, :BUS_SUB_TYPE
-
-    def initialize(session, vdc_xml_obj)
+    def initialize(session, link)
       @session = session
-      @vdc_xml_obj = vdc_xml_obj
+      @link = link
     end
 
     def storage_profiles
@@ -57,19 +49,19 @@ module VCloudSdk
     end
 
     def vapps
-      @vdc_xml_obj.vapps.map do |vapp_link|
+      entity_xml.vapps.map do |vapp_link|
         VCloudSdk::VApp.new(@session, vapp_link)
       end
     end
 
     def list_vapps
-      @vdc_xml_obj.vapps.map do |vapp_link|
+      entity_xml.vapps.map do |vapp_link|
         vapp_link.name
       end
     end
 
     def find_vapp_by_name(name)
-      @vdc_xml_obj.vapps.each do |vapp_link|
+      entity_xml.vapps.each do |vapp_link|
         if vapp_link.name == name
           return VCloudSdk::VApp.new(@session, vapp_link)
         end
@@ -79,8 +71,8 @@ module VCloudSdk
     end
 
     def resources
-      cpu = VCloudSdk::CPU.new(@vdc_xml_obj.available_cpu_cores)
-      memory = VCloudSdk::Memory.new(@vdc_xml_obj.available_memory_mb)
+      cpu = VCloudSdk::CPU.new(entity_xml.available_cpu_cores)
+      memory = VCloudSdk::Memory.new(entity_xml.available_memory_mb)
       VCloudSdk::Resources.new(cpu, memory)
     end
 
@@ -96,19 +88,9 @@ module VCloudSdk
       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)
+        .get(entity_xml.edge_gateways_link)
         .edge_gateway_records
         .map do |edge_gateway_link|
         VCloudSdk::EdgeGateway.new(@session, edge_gateway_link.href)
@@ -116,19 +98,19 @@ module VCloudSdk
     end
 
     def disks
-      @vdc_xml_obj.disks.map do |disk_link|
+      entity_xml.disks.map do |disk_link|
         VCloudSdk::Disk.new(@session, disk_link)
       end
     end
 
     def list_disks
-      @vdc_xml_obj.disks.map do |disk_link|
+      entity_xml.disks.map do |disk_link|
         disk_link.name
       end
     end
 
     def find_disks_by_name(name)
-      disks = @vdc_xml_obj
+      disks = entity_xml
                 .disks
                 .select { |disk_link| disk_link.name == name }
                 .map { |disk_link| VCloudSdk::Disk.new(@session, disk_link.href) }
@@ -148,28 +130,28 @@ module VCloudSdk
 
     def create_disk(
           name,
-          size_mb,
+          capacity,
           vm = nil,
           bus_type = "scsi",
           bus_sub_type = "lsilogic")
 
       fail(CloudError,
-           "Invalid size in MB #{size_mb}") if size_mb <= 0
+           "Invalid size in MB #{capacity}") if capacity <= 0
 
-      bus_type = BUS_TYPE[bus_type.downcase]
+      bus_type = Xml::BUS_TYPE_NAMES[bus_type.downcase]
       fail(CloudError,
            "Invalid bus type!") unless bus_type
 
-      bus_sub_type = BUS_SUB_TYPE[bus_sub_type.downcase]
+      bus_sub_type = Xml::BUS_SUB_TYPE_NAMES[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."
+        .info "Creating independent disk #{name} of #{capacity}MB."
 
-      disk = connection.post(@vdc_xml_obj.add_disk_link,
-                             disk_create_params(name, size_mb, bus_type, bus_sub_type, vm),
+      disk = connection.post(entity_xml.add_disk_link,
+                             disk_create_params(name, capacity, bus_type, bus_sub_type, vm),
                              Xml::MEDIA_TYPE[:DISK_CREATE_PARAMS])
 
       wait_for_running_tasks(disk, "Disk #{name}")
@@ -177,10 +159,36 @@ module VCloudSdk
       VCloudSdk::Disk.new(@session, disk.href)
     end
 
+    def delete_disk_by_name(name)
+      disks = find_disks_by_name(name)
+      fail CloudError,
+           "#{disks.size} disks with name #{name} were found" if disks.size > 1
+
+      delete_single_disk(disks.first)
+      nil
+    end
+
+    def delete_all_disks_by_name(name)
+      disks = find_disks_by_name(name)
+      success = true
+      disks.each do |disk|
+        begin
+          delete_single_disk(disk)
+        rescue RuntimeError => e
+          success = false
+          Config.logger.error("Disk deletion failed with exception: #{e}")
+        end
+      end
+
+      fail CloudError,
+           "Failed to delete one or more of the disks with name '#{name}'. Check logs for details." unless success
+      nil
+    end
+
     def storage_profile_xml_node(name)
       return nil if name.nil?
 
-      storage_profile = @vdc_xml_obj.storage_profile(name)
+      storage_profile = entity_xml.storage_profile(name)
       unless storage_profile
         fail ObjectNotFoundError,
              "Storage profile '#{name}' does not exist"
@@ -197,14 +205,26 @@ module VCloudSdk
         .org_vdc_storage_profile_records
     end
 
-    def disk_create_params(name, size_mb, bus_type, bus_sub_type, vm)
+    def disk_create_params(name, capacity, 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.size_bytes = capacity * 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
+
+    def delete_single_disk(disk)
+      Config.logger.info "Deleting disk '#{disk.name}', link #{disk.href}"
+      fail CloudError,
+           "Disk '#{disk.name}', link #{disk.href} is attached to VM '#{disk.vm.name}'" if disk.attached?
+
+      entity_xml = connection.get(disk.href)
+      task = connection.delete(entity_xml.remove_link.href)
+      monitor_task(task)
+
+      Config.logger.info "Disk deleted successfully"
+    end
   end
 end

data/lib/ruby_vcloud_sdk/vm.rb

@@ -1,6 +1,7 @@
 require "forwardable"
 require_relative "infrastructure"
 require_relative "powerable"
+require_relative "internal_disk"
 
 module VCloudSdk
   class VM
@@ -19,6 +20,78 @@ module VCloudSdk
       @link
     end
 
+    # returns size of memory in megabytes
+    def memory
+      m = entity_xml
+            .hardware_section
+            .memory
+      allocation_units = m.get_rasd_content(Xml::RASD_TYPES[:ALLOCATION_UNITS])
+      bytes = eval_memory_allocation_units(allocation_units)
+
+      virtual_quantity = m.get_rasd_content(Xml::RASD_TYPES[:VIRTUAL_QUANTITY]).to_i
+      memory_mb = virtual_quantity * bytes / BYTES_PER_MEGABYTE
+      fail CloudError,
+           "Size of memory is less than 1 MB." if memory_mb == 0
+      memory_mb
+    end
+
+    # sets size of memory in megabytes
+    def memory=(size)
+      fail(CloudError,
+           "Invalid vm memory size #{size}MB") if size <= 0
+
+      Config
+        .logger
+        .info "Changing the vm memory to #{size}MB."
+
+      payload = entity_xml
+      payload.change_memory(size)
+
+      task = connection.post(payload.reconfigure_link.href,
+                             payload,
+                             Xml::MEDIA_TYPE[:VM])
+      monitor_task(task)
+      self
+    end
+
+    # returns number of virtual cpus of VM
+    def vcpu
+      cpus = entity_xml
+              .hardware_section
+              .cpu
+              .get_rasd_content(Xml::RASD_TYPES[:VIRTUAL_QUANTITY])
+
+      fail CloudError,
+           "Uable to retrieve number of virtual cpus of VM #{name}" if cpus.nil?
+      cpus.to_i
+    end
+
+    # sets number of virtual cpus of VM
+    def vcpu=(count)
+      fail(CloudError,
+           "Invalid virtual CPU count #{count}") if count <= 0
+
+      Config
+        .logger
+        .info "Changing the virtual CPU count to #{count}."
+
+      payload = entity_xml
+      payload.change_cpu_count(count)
+
+      task = connection.post(payload.reconfigure_link.href,
+                             payload,
+                             Xml::MEDIA_TYPE[:VM])
+      monitor_task(task)
+      self
+    end
+
+    def list_networks
+      entity_xml
+        .network_connection_section
+        .network_connections
+        .map { |network_connection| network_connection.network }
+    end
+
     def independent_disks
       hardware_section = entity_xml.hardware_section
       disks = []
@@ -108,6 +181,115 @@ module VCloudSdk
       monitor_task(task)
     end
 
+    def add_nic(
+          network_name,
+          ip_addressing_mode = Xml::IP_ADDRESSING_MODE[:POOL],
+          ip = nil)
+      fail CloudError,
+           "Invalid IP_ADDRESSING_MODE '#{ip_addressing_mode}'" unless Xml::IP_ADDRESSING_MODE
+                                                                       .each_value
+                                                                       .any? { |m| m == ip_addressing_mode }
+
+      fail CloudError,
+           "IP is missing for MANUAL IP_ADDRESSING_MODE" if ip_addressing_mode == Xml::IP_ADDRESSING_MODE[:MANUAL] &&
+                                                              ip.nil?
+
+      fail ObjectNotFoundError,
+           "Network #{network_name} is not added to parent VApp #{vapp.name}" unless vapp
+                                                                                       .list_networks
+                                                                                       .any? { |n| n == network_name }
+
+      payload = entity_xml
+      fail CloudError,
+           "VM #{name} is powered-on and cannot add NIC." if is_status?(payload, :POWERED_ON)
+
+      nic_index = list_networks.size # nic index begins with 0
+
+      Config.logger
+        .info("Adding NIC #{nic_index}, network #{network_name} using mode '#{ip_addressing_mode}' #{ip.nil? ? "" : "IP: #{ip}"}")
+
+      # Add NIC
+      payload
+        .hardware_section
+        .add_item(nic_params(payload.hardware_section,
+                             nic_index,
+                             network_name,
+                             ip_addressing_mode,
+                             ip))
+
+      # Connect NIC
+      payload
+        .network_connection_section
+        .add_item(network_connection_params(payload.network_connection_section,
+                                            nic_index,
+                                            network_name,
+                                            ip_addressing_mode,
+                                            ip))
+
+      task = connection.post(payload.reconfigure_link.href,
+                             payload,
+                             Xml::MEDIA_TYPE[:VM])
+      monitor_task(task)
+    end
+
+    def product_section_properties
+      product_section = entity_xml.product_section
+      return [] if product_section.nil?
+
+      product_section.properties
+    end
+
+    def product_section_properties=(properties)
+      Config.logger
+        .info("Updating VM #{name} production sections with properties: #{properties.pretty_inspect}")
+      task = connection.put(entity_xml.product_sections_link.href,
+                            product_section_list_params(properties),
+                            Xml::MEDIA_TYPE[:PRODUCT_SECTIONS])
+      monitor_task(task)
+      self
+    end
+
+    def internal_disks
+      hardware_section = entity_xml.hardware_section
+      internal_disks = []
+      hardware_section.hard_disks.each do |disk|
+        disk_link = disk.host_resource.attribute("disk")
+        if disk_link.nil?
+          internal_disks << VCloudSdk::InternalDisk.new(disk)
+        end
+      end
+      internal_disks
+    end
+
+    def create_internal_disk(
+          capacity,
+          bus_type = "scsi",
+          bus_sub_type = "lsilogic")
+
+      fail(CloudError,
+           "Invalid size in MB #{capacity}") if capacity <= 0
+
+      bus_type = Xml::BUS_TYPE_NAMES[bus_type.downcase]
+      fail(CloudError,
+           "Invalid bus type!") unless bus_type
+
+      bus_sub_type = Xml::BUS_SUB_TYPE_NAMES[bus_sub_type.downcase]
+      fail(CloudError,
+           "Invalid bus sub type!") unless bus_sub_type
+
+      Config
+        .logger
+        .info "Creating internal disk #{name} of #{capacity}MB."
+
+      payload = entity_xml
+      payload.add_hard_disk(capacity, bus_type, bus_sub_type)
+
+      task = connection.post(payload.reconfigure_link.href,
+                             payload,
+                             Xml::MEDIA_TYPE[:VM])
+      monitor_task(task)
+    end
+
     private
 
     def disk_attach_or_detach_params(disk)
@@ -128,5 +310,56 @@ module VCloudSdk
         params.media_href = media.href
       end
     end
+
+    def eval_memory_allocation_units(allocation_units)
+      # allocation_units is in the form of "byte * modifier * base ^ exponent" such as "byte * 2^20"
+      # "modifier", "base" and "exponent" are positive integers and optional.
+      # "base" and "exponent" must be present together.
+      # Parsing logic: remove starting "byte" and first char "*" and replace power "^" with ruby-understandable "**"
+      bytes = allocation_units.sub(/byte\s*(\*)?/, "").sub(/\^/, "**")
+      return 1 if bytes.empty? # allocation_units is "byte" without "modifier", "base" or "exponent"
+      fail unless bytes =~ /(\d+\s*\*)?(\d+\s*\*\*\s*\d+)?/
+      eval bytes
+    rescue
+      raise ApiError,
+            "Unexpected form of AllocationUnits of memory: '#{allocation_units}'"
+    end
+
+    def nic_params(section, nic_index, network_name, addressing_mode, ip)
+      is_primary = section.nics.empty?
+      item = Xml::WrapperFactory
+               .create_instance("Item", nil, section.doc_namespaces)
+
+      Xml::NicItemWrapper
+        .new(item)
+        .tap do |params|
+          params.nic_index = nic_index
+          params.network = network_name
+          params.set_ip_addressing_mode(addressing_mode, ip)
+          params.is_primary = is_primary
+      end
+    end
+
+    def network_connection_params(section, nic_index, network_name, addressing_mode, ip)
+      Xml::WrapperFactory
+        .create_instance("NetworkConnection", nil, section.doc_namespaces)
+        .tap do |params|
+          params.network_connection_index = nic_index
+          params.network = network_name
+          params.ip_address_allocation_mode = addressing_mode
+          params.ip_address = ip unless ip.nil?
+          params.is_connected = true
+      end
+    end
+
+    def product_section_list_params(properties)
+      Xml::WrapperFactory.create_instance("ProductSectionList").tap do |params|
+        properties.each do |property|
+          params.add_property(property)
+        end
+      end
+    end
+
+    BYTES_PER_MEGABYTE = 1_048_576 # 1048576 = 1024 * 1024 = 2^20
   end
 end

data/lib/ruby_vcloud_sdk/xml/constants.rb

@@ -26,6 +26,8 @@ module VCloudSdk
         :CONNECTION => "Connection",
         :PARENT => "Parent",
         :ELEMENT_NAME => "ElementName",
+        :ALLOCATION_UNITS => "AllocationUnits",
+        :VIRTUAL_QUANTITY => "VirtualQuantity"
     }
 
     RESOURCE_SUB_TYPE = {
@@ -60,6 +62,14 @@ module VCloudSdk
         :BUS_TYPE => "busType"
     }
 
+    BUS_TYPE_NAMES = {
+        "scsi" => Xml::HARDWARE_TYPE[:SCSI_CONTROLLER]
+    }
+
+    BUS_SUB_TYPE_NAMES = {
+        "lsilogic" => Xml::BUS_SUB_TYPE[:LSILOGIC]
+    }
+
     TASK_STATUS = {
         :QUEUED => "queued",
         :RUNNING => "running",

data/lib/ruby_vcloud_sdk/xml/wrapper.rb

@@ -99,7 +99,7 @@ module VCloudSdk
       end
 
       def href_id
-        # Sample href: "https://10.146.21.135/api/org/a3783d64-0b9b-42d6-93cf-23bb08ec5520"
+        # Sample href: "https://10.147.0.0/api/org/a3783d64-0b9b-42d6-93cf-23bb08ec5520"
         URI.parse(href).path.split('/')[-1]
       end
 
@@ -316,6 +316,15 @@ module VCloudSdk
                                            namespace_href)
         node.namespace = ns
       end
+
+      def ovf_namespace_prefix
+        return @ovf_namespace_prefix if @ovf_namespace_prefix
+        namespace = namespace_definitions.find { |ns| ns.href == OVF }
+        fail VCloudSdk::CloudError,
+             "Namespace of href '#{OVF}' is not found" if namespace.nil?
+
+        @ovf_namespace_prefix = namespace.prefix
+      end
     end
   end
 end

data/lib/ruby_vcloud_sdk/xml/wrapper_classes/disk.rb

@@ -17,7 +17,7 @@ module VCloudSdk
         @root["busSubType"] = value.to_s
       end
 
-      def size_mb
+      def capacity
         @root["size"].to_i / 1024 / 1024
       end
 

data/lib/ruby_vcloud_sdk/xml/wrapper_classes/ip_ranges.rb

@@ -4,6 +4,22 @@ module VCloudSdk
       def ranges
         get_nodes(:IpRange)
       end
+
+      def add_ranges(ranges)
+        ranges.each do |range|
+          ip_range_node = add_child("IpRange")
+          start_address = add_child("StartAddress",
+                                    nil,
+                                    nil,
+                                    ip_range_node)
+          start_address.content = range.start_address
+          end_address = add_child("EndAddress",
+                                  nil,
+                                  nil,
+                                  ip_range_node)
+          end_address.content = range.end_address
+        end
+      end
     end
   end
 end

data/lib/ruby_vcloud_sdk/xml/wrapper_classes/ip_scope.rb

@@ -1,6 +1,10 @@
 module VCloudSdk
   module Xml
     class IpScope < Wrapper
+      def ip_ranges
+        get_nodes(:IpRanges).first
+      end
+
       def is_inherited?
         get_nodes(:IsInherited).first.content
       end

data/lib/ruby_vcloud_sdk/xml/wrapper_classes/network_config_section.rb

@@ -1,6 +1,5 @@
 module VCloudSdk
   module Xml
-
     class NetworkConfigSection < Wrapper
       def network_configs
         get_nodes("NetworkConfig")
@@ -8,18 +7,17 @@ module VCloudSdk
 
       def add_network_config(config)
         unless config.is_a? NetworkConfig
-          raise CloudError, "Only NetworkConfig can be added to #{self.class}"
+          fail CloudError, "Only NetworkConfig can be added to #{self.class}"
         end
         add_child(config)
       end
 
       def delete_network_config(net_name)
-        net_config = network_configs.find {|n| n.network_name == net_name }
-        raise ObjectNotFoundError,
-          "Cannot delete network #{net_name}: not found" unless net_config
+        net_config = network_configs.find { |n| n.network_name == net_name }
+        fail ObjectNotFoundError,
+             "Cannot delete network #{net_name}: not found" unless net_config
         net_config.node.remove
       end
     end
-
   end
 end

data/lib/ruby_vcloud_sdk/xml/wrapper_classes/org_vdc_network.rb

@@ -5,10 +5,6 @@ module VCloudSdk
         get_nodes(:IpScope).first
       end
 
-      def ip_ranges
-        get_nodes(:IpRanges).first
-      end
-
       def allocated_addresses_link
         get_nodes(XML_TYPE[:LINK],
                   { type: MEDIA_TYPE[:ALLOCATED_NETWORK_IPS] },

data/lib/ruby_vcloud_sdk/xml/wrapper_classes/product_section.rb

@@ -0,0 +1,35 @@
+module VCloudSdk
+  module Xml
+    class ProductSection < Wrapper
+      def add_property(property)
+        property_node = add_child("Property",
+                                  ovf_namespace_prefix,
+                                  OVF)
+        property_node["#{ovf_namespace_prefix}:type"] = property["type"].nil? ? "string" : property["type"]
+        property_node["#{ovf_namespace_prefix}:key"] = property["key"]
+        property_node["#{ovf_namespace_prefix}:value"] = property["value"]
+        property_node["#{ovf_namespace_prefix}:password"] = property["password"] if property["password"]
+
+        unless property["Label"].nil?
+          label_node = add_child("Label", ovf_namespace_prefix, OVF, property_node)
+          label_node.content = property["Label"]
+        end
+      end
+
+      def properties
+        get_nodes("Property", nil, true, OVF).map do |property_node|
+          property = {}
+          property["type"] = property_node.attribute("type").content
+          property["key"] = property_node.attribute("key").content
+          property["value"] = property_node.attribute("value").content
+          property["password"] = property_node.attribute("password").content
+
+          label_node = property_node.get_nodes("Label", nil, true, OVF).first
+          property["Label"] = label_node.content unless label_node.nil?
+
+          property
+        end
+      end
+    end
+  end
+end

data/lib/ruby_vcloud_sdk/xml/wrapper_classes/product_section_list.rb

@@ -0,0 +1,14 @@
+require "forwardable"
+
+module VCloudSdk
+  module Xml
+    class ProductSectionList < Wrapper
+      extend Forwardable
+      def_delegator :production_section, :add_property
+
+      def production_section
+        get_nodes("ProductSection", nil, true, OVF).first
+      end
+    end
+  end
+end

data/lib/ruby_vcloud_sdk/xml/wrapper_classes/query_result_records.rb

@@ -9,6 +9,10 @@ module VCloudSdk
       def edge_gateway_records
         get_nodes("EdgeGatewayRecord")
       end
+
+      def right_records
+        get_nodes("RightRecord")
+      end
     end
   end
 end

data/lib/ruby_vcloud_sdk/xml/wrapper_classes/virtual_hardware_section.rb

@@ -14,13 +14,15 @@ module VCloudSdk
       end
 
       def cpu
-        hardware.find { |h| h.get_rasd_content(RASD_TYPES[:RESOURCE_TYPE]) ==
-          HARDWARE_TYPE[:CPU] }
+        hardware.find do |h|
+          h.get_rasd_content(RASD_TYPES[:RESOURCE_TYPE]) == HARDWARE_TYPE[:CPU]
+        end
       end
 
       def memory
-        hardware.find { |h| h.get_rasd_content(RASD_TYPES[:RESOURCE_TYPE]) ==
-          HARDWARE_TYPE[:MEMORY] }
+        hardware.find do |h|
+          h.get_rasd_content(RASD_TYPES[:RESOURCE_TYPE]) == HARDWARE_TYPE[:MEMORY]
+        end
       end
 
       def scsi_controller