ruby_vcloud_sdk 0.4.8

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

@@ -0,0 +1,91 @@
+require "item"
+
+module VCloudSdk
+  module Xml
+
+    class NicItemWrapper < Item
+      def initialize(item)
+        super(item.node, item.namespace, item.namespace_definitions)
+
+        # Ensure the underlying XML has all the necessary RASD elements.
+        # This is useful for NIC creation.
+        # Should have no effect when receiving XML from VCD.
+        [:ADDRESS_ON_PARENT, :CONNECTION, :INSTANCE_ID].each { |t|
+          rt = RASD_TYPES[t]
+          add_rasd(rt) unless get_rasd(rt) }
+
+        rt = RASD_TYPES[:RESOURCE_SUB_TYPE]
+        unless get_rasd(rt)
+          add_rasd(rt)
+          set_rasd(rt, RESOURCE_SUB_TYPE[:VMXNET3])
+        end
+
+        rt = RASD_TYPES[:RESOURCE_TYPE]
+        unless get_rasd(rt)
+          add_rasd(rt)
+          set_rasd(rt, HARDWARE_TYPE[:NIC])
+        end
+      end
+
+      def is_primary
+        connection["primaryNetworkConnection"]
+      end
+
+      def is_primary=(value)
+        primary_attr = create_qualified_name("primaryNetworkConnection",
+          VCLOUD_NAMESPACE)
+        connection[primary_attr] = value.to_s
+      end
+
+      def nic_index
+        get_rasd_content(RASD_TYPES[:ADDRESS_ON_PARENT])
+      end
+
+      def nic_index=(value)
+        set_rasd(RASD_TYPES[:ADDRESS_ON_PARENT], value)
+      end
+
+      def ip_addressing_mode
+        attr = create_qualified_name("ipAddressingMode", VCLOUD_NAMESPACE)
+        connection[attr]
+      end
+
+      def set_ip_addressing_mode(mode, ip = nil)
+        unless IP_ADDRESSING_MODE.values.include?(mode)
+          raise ArgumentError, "Invalid choice for IP addressing mode."
+        end
+
+        if ip && !ip_addressing_mode == IP_ADDRESSING_MODE[:MANUAL]
+          raise ArgumentError,
+            "Cannot set IP address unless IP addressing mode is MANUAL"
+        end
+
+        mode_attr = create_qualified_name("ipAddressingMode",
+          VCLOUD_NAMESPACE)
+        connection[mode_attr] = mode
+
+        ip_attr =  create_qualified_name("ipAddress", VCLOUD_NAMESPACE)
+        connection[ip_attr] = !ip.nil? ? ip : ""
+      end
+
+      def mac_address
+        get_rasd_content(RASD_TYPES[:ADDRESS])
+      end
+
+      def network
+        connection.content
+      end
+
+      def network=(value)
+        connection.content = value
+      end
+
+      private
+
+      def connection
+        get_rasd(RASD_TYPES[:CONNECTION])
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,19 @@
+module VCloudSdk
+  module Xml
+
+    class OrgNetwork < Wrapper
+      def ip_scope
+        get_nodes("IpScope").first
+      end
+
+      def fence_mode
+        get_nodes("FenceMode").first.content
+      end
+
+      def fence_mode=(value)
+        get_nodes("FenceMode").first.content = value
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,11 @@
+module VCloudSdk
+  module Xml
+
+    class OrgVdcNetwork < Wrapper
+      def ip_scope
+        get_nodes("IpScope").first
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,17 @@
+module VCloudSdk
+  module Xml
+
+    class Session < Wrapper
+      def admin_root
+        get_nodes("Link", {"type" =>
+          VCloudSdk::Xml::ADMIN_MEDIA_TYPE[:VCLOUD]}).first
+      end
+
+      def entity_resolver
+        get_nodes("Link", {"type" =>
+          VCloudSdk::Xml::MEDIA_TYPE[:ENTITY]}).first
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,32 @@
+module VCloudSdk
+  module Xml
+
+    class Task < Wrapper
+      def cancel_link
+        get_nodes("Link", {"rel" => "task:cancel"}).first
+      end
+
+      def status
+        self["status"]
+      end
+
+      # Friendly description of the task
+      def operation
+        self["operation"]
+      end
+
+      # Short form name of the operation
+      def operation_name
+        self["operationName"]
+      end
+
+      # Not all tasks will have progress
+      def progress
+        task_progress = get_nodes("Progress").first
+        return task_progress.content unless task_progress.nil?
+        nil
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,11 @@
+module VCloudSdk
+  module Xml
+
+    class UploadVAppTemplateParams < Wrapper
+      def name=(name)
+        @root["name"] = name
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,55 @@
+module VCloudSdk
+  module Xml
+
+    class VApp < Wrapper
+      def description
+        get_nodes("Description").first.content
+      end
+
+      def network_config_section
+        get_nodes("NetworkConfigSection").first
+      end
+
+      def power_on_link
+        get_nodes("Link", {"rel" => "power:powerOn"}, true).first
+      end
+
+      def power_off_link
+        get_nodes("Link", {"rel" => "power:powerOff"}, true).first
+      end
+
+      def reboot_link
+        get_nodes("Link", {"rel" => "power:reboot"}, true).first
+      end
+
+      def remove_link
+        get_nodes("Link", {"rel" => "remove"}, true).first
+      end
+
+      def running_tasks
+        get_nodes("Task", {"status" => "running"})
+      end
+
+      def tasks
+        get_nodes("Task")
+      end
+
+      def undeploy_link
+        get_nodes("Link", {"rel" => "undeploy"}, true).first
+      end
+
+      def discard_state
+        get_nodes("Link", {"rel" => "discardState"}, true).first
+      end
+
+      def vms
+        get_nodes("Vm")
+      end
+
+      def vm(name)
+        get_nodes("Vm", {"name" => name}).first
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,19 @@
+require "vapp"
+
+module VCloudSdk
+  module Xml
+
+    class VAppTemplate < VApp
+      def files
+        get_nodes("File")
+      end
+
+      # Files that have not finished transferring
+      def incomplete_files
+        files.find_all {|f| f["size"].to_i < 0 ||
+          (f["size"].to_i > f["bytesTransferred"].to_i)}
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,15 @@
+module VCloudSdk
+  module Xml
+
+    class VCloud < Wrapper
+      def organizations
+        get_nodes("OrganizationReference")
+      end
+
+      def organization(name)
+        get_nodes("OrganizationReference", {"name" => name}).first
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,54 @@
+module VCloudSdk
+  module Xml
+
+    class Vdc < Wrapper
+      def add_disk_link
+         get_nodes("Link", {"type"=>MEDIA_TYPE[:DISK_CREATE_PARAMS]}).first
+      end
+
+      def disks(name = nil)
+        if name.nil?
+          get_nodes("ResourceEntity", {"type"=>MEDIA_TYPE[:DISK]})
+        else
+          get_nodes("ResourceEntity",
+            {"type"=>MEDIA_TYPE[:DISK], "name"=>name})
+        end
+      end
+
+      def instantiate_vapp_template_link
+        get_nodes("Link",
+          {"type"=>MEDIA_TYPE[:INSTANTIATE_VAPP_TEMPLATE_PARAMS]}).first
+      end
+
+      def upload_link
+        get_nodes("Link",
+          {"type"=>MEDIA_TYPE[:UPLOAD_VAPP_TEMPLATE_PARAMS]}).first
+      end
+
+      def upload_media_link
+        get_nodes("Link", {"type"=>MEDIA_TYPE[:MEDIA]}).first
+      end
+
+      # vApp Template names are not unique so multiple ones can be returned.
+      def get_vapp_templates(name)
+        get_nodes("ResourceEntity",
+          {"type"=>MEDIA_TYPE[:VAPP_TEMPLATE], "name"=>name})
+      end
+
+      def available_networks
+        get_nodes("Network", {"type"=>MEDIA_TYPE[:NETWORK]})
+      end
+
+      def available_network(name)
+        get_nodes("Network",
+          {"type"=>MEDIA_TYPE[:NETWORK], "name"=>name}).first
+      end
+
+      def storage_profiles
+        get_nodes("VdcStorageProfile",
+          {"type"=>MEDIA_TYPE[:VDC_STORAGE_PROFILE]})
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,15 @@
+module VCloudSdk
+  module Xml
+
+    class VdcStorageProfile < Wrapper
+      def name
+        @root["name"]
+      end
+
+      def name=(value)
+        @root["name"] = value
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,68 @@
+module VCloudSdk
+  module Xml
+
+    class VirtualHardwareSection < Wrapper
+      def add_item(item)
+        system_node = get_nodes("System", nil, true, OVF).first
+        system_node.node.after(item.node)
+      end
+
+      def edit_link
+        get_nodes("Link", {"rel" => "edit",
+          "type" => MEDIA_TYPE[:VIRTUAL_HARDWARE_SECTION]}, true).first
+      end
+
+      def cpu
+        hardware.find { |h| h.get_rasd_content(RASD_TYPES[:RESOURCE_TYPE]) ==
+          HARDWARE_TYPE[:CPU] }
+      end
+
+      def memory
+        hardware.find { |h| h.get_rasd_content(RASD_TYPES[:RESOURCE_TYPE]) ==
+          HARDWARE_TYPE[:MEMORY] }
+      end
+
+      def scsi_controller
+        hardware.find { |h| h.get_rasd_content(RASD_TYPES[:RESOURCE_TYPE]) ==
+          HARDWARE_TYPE[:SCSI_CONTROLLER] }
+      end
+
+      def highest_instance_id
+        hardware.map{|h| h.instance_id}.max
+      end
+
+      def nics
+        items = hardware.find_all {|h| h.get_rasd_content(
+          RASD_TYPES[:RESOURCE_TYPE]) == HARDWARE_TYPE[:NIC] }
+        items.map { |i| NicItemWrapper.new(i) }
+      end
+
+      def remove_nic(index)
+        remove_hw(HARDWARE_TYPE[:NIC], index)
+      end
+
+      def remove_hw(hw_type, index)
+        item = hardware.find { |h|
+          h.get_rasd_content(RASD_TYPES[:RESOURCE_TYPE]) == hw_type &&
+          h.get_rasd_content(RASD_TYPES[:ADDRESS_ON_PARENT]) == index }
+        if item
+          item.node.remove
+        else
+          raise ObjectNotFoundError,
+            "Cannot remove hw item #{hw_type}:#{index}, does not exist."
+        end
+      end
+
+      def hard_disks
+        items = hardware.find_all { |h| h.get_rasd_content(
+          RASD_TYPES[:RESOURCE_TYPE]) == HARDWARE_TYPE[:HARD_DISK] }
+        items.map { |i| HardDiskItemWrapper.new(i) }
+      end
+
+      def hardware
+        get_nodes("Item", nil, false, OVF)
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,179 @@
+module VCloudSdk
+  module Xml
+
+    class Vm < Wrapper
+      def initialize(xml, ns = nil, ns_definitions = nil)
+        super(xml, ns, ns_definitions)
+        @logger = Config.logger
+      end
+
+      def attach_disk_link
+        get_nodes("Link", {"rel" => "disk:attach",
+          "type" => MEDIA_TYPE[:DISK_ATTACH_DETACH_PARAMS]}, true).first
+      end
+
+      def description
+        nodes = get_nodes("Description")
+        return nodes unless nodes
+        node = nodes.first
+        return node unless node
+        node.content
+      end
+
+      def description=(value)
+        nodes = get_nodes("Description")
+        return unless nodes
+        node = nodes.first
+        return unless node
+        node.content = value
+      end
+
+      def detach_disk_link
+        get_nodes("Link", {"rel" => "disk:detach",
+          "type" => MEDIA_TYPE[:DISK_ATTACH_DETACH_PARAMS]}, true).first
+      end
+
+      def edit_link
+        get_nodes("Link", {"rel" => "edit"}, true).first
+      end
+
+      def reconfigure_link
+        get_nodes("Link", {"rel" => "reconfigureVm"}, true).first
+      end
+
+      def insert_media_link
+        get_nodes("Link", {"rel" => "media:insertMedia"}, true).first
+      end
+
+      def eject_media_link
+        get_nodes("Link", {"rel" => "media:ejectMedia"}, true).first
+      end
+
+      def metadata_link
+        get_nodes("Link", {"type" => MEDIA_TYPE[:METADATA]}, true).first
+      end
+
+      def name
+         @root["name"]
+      end
+
+      def name=(value)
+         @root["name"]= value
+      end
+
+      def hardware_section
+        get_nodes("VirtualHardwareSection", nil, false,
+          "http://schemas.dmtf.org/ovf/envelope/1").first
+      end
+
+      def network_connection_section
+        get_nodes("NetworkConnectionSection",
+          {"type" => MEDIA_TYPE[:NETWORK_CONNECTION_SECTION]}).first
+      end
+
+      # hardware modification methods
+
+      def add_hard_disk(size_mb)
+        section = hardware_section
+        scsi_controller = section.scsi_controller
+        unless scsi_controller
+          raise ObjectNotFoundError, "No SCSI controller found for VM #{name}"
+        end
+        # Create a RASD item
+        new_disk = WrapperFactory.create_instance("Item", nil,
+          hardware_section.doc_namespaces)
+        section.add_item(new_disk)
+        # The order matters!
+        new_disk.add_rasd(RASD_TYPES[:HOST_RESOURCE])
+        new_disk.add_rasd(RASD_TYPES[:INSTANCE_ID])
+        rt = RASD_TYPES[:RESOURCE_TYPE]
+        new_disk.add_rasd(rt)
+        new_disk.set_rasd(rt, HARDWARE_TYPE[:HARD_DISK])
+        host_resource = new_disk.get_rasd(RASD_TYPES[:HOST_RESOURCE])
+        host_resource[new_disk.create_qualified_name(
+          "capacity", VCLOUD_NAMESPACE)] = size_mb.to_s
+        host_resource[new_disk.create_qualified_name(
+          "busSubType", VCLOUD_NAMESPACE)] = scsi_controller.get_rasd_content(
+            RASD_TYPES[:RESOURCE_SUB_TYPE])
+        host_resource[new_disk.create_qualified_name(
+          "busType", VCLOUD_NAMESPACE)] = HARDWARE_TYPE[:SCSI_CONTROLLER]
+      end
+
+      def change_cpu_count(quantity)
+        @logger.debug("Updating CPU count on vm #{name} to #{quantity} ")
+        item = hardware_section.cpu
+        item.set_rasd("VirtualQuantity", quantity)
+      end
+
+      def change_memory(mb)
+        @logger.debug("Updating memory on vm #{name} to #{mb} MB")
+        item = hardware_section.memory
+        item.set_rasd("VirtualQuantity", mb)
+      end
+
+      def add_nic(nic_index, network_name, addressing_mode, ip = nil)
+        section = hardware_section
+        is_primary = hardware_section.nics.length == 0
+        new_nic = Xml::NicItemWrapper.new(Xml::WrapperFactory.create_instance(
+          "Item", nil, hardware_section.doc_namespaces))
+        section.add_item(new_nic)
+        new_nic.nic_index = nic_index
+        new_nic.network = network_name
+        new_nic.set_ip_addressing_mode(addressing_mode, ip)
+        new_nic.is_primary = is_primary
+        @logger.info("Adding NIC #{nic_index} to VM #{name} with the " +
+          "following parameters: Network name: #{network_name}, " +
+          "Addressing mode #{addressing_mode}, " +
+          "IP address: #{ip.nil? ? "blank" : ip}")
+      end
+
+      # NIC modification methods
+
+      def connect_nic(nic_index, network_name, addressing_mode,
+          ip_address = nil)
+        section = network_connection_section
+        new_connection = WrapperFactory.create_instance("NetworkConnection",
+          nil, network_connection_section.doc_namespaces)
+        section.add_item(new_connection)
+        new_connection.network_connection_index = nic_index
+        new_connection.network = network_name
+        new_connection.ip_address_allocation_mode = addressing_mode
+        new_connection.ip_address = ip_address if ip_address
+        new_connection.is_connected = true
+      end
+
+      # Deletes NIC from VM.  Accepts variable number of arguments for NICs.
+      # To delete all NICs from VM use the splat operator
+      # ex: delete_nic(vm, *vm.hardware_section.nics)
+      def delete_nic(*nics)
+        # Trying to remove a NIC without removing the network connection
+        # first will cause an error.  Removing the network connection of a NIC
+        # in the NetworkConnectionSection will automatically delete the NIC.
+        net_conn_section = network_connection_section
+        vhw_section = hardware_section
+        nics.each do |nic|
+          nic_index = nic.nic_index
+          @logger.info("Removing NIC #{nic_index} from VM #{name}")
+          net_conn_section.remove_network_connection(nic_index)
+          vhw_section.remove_nic(nic_index)
+        end
+      end
+
+      def set_nic_is_connected(nic_index, is_connected)
+        net_conn_section = network_connection_section
+        connection = net_conn_section.network_connection(nic_index)
+        unless connection
+          raise ObjectNotFoundError,
+            "NIC #{nic_index} cannot be found on VM #{name}."
+        end
+        connection.is_connected = is_connected
+      end
+
+      def set_primary_nic(nic_index)
+        net_conn_section = network_connection_section
+        net_conn_section.primary_network_connection_index = nic_index
+      end
+    end
+
+  end
+end