ruby_vcloud_sdk 0.4.8 → 0.5.1

data/lib/ruby_vcloud_sdk/vdc_storage_profile.rb

@@ -0,0 +1,23 @@
+module VCloudSdk
+
+  class VdcStorageProfile
+    attr_reader :name
+
+    def initialize(storage_profile_xml_obj)
+      @storage_profile_xml_obj = storage_profile_xml_obj
+      @name = @storage_profile_xml_obj[:name]
+      @storage_used_mb = @storage_profile_xml_obj[:storageUsedMB].to_i
+      @storage_limit_mb = @storage_profile_xml_obj[:storageLimitMB].to_i
+      @vdc_name = @storage_profile_xml_obj[:vdcName]
+    end
+
+    # Return storageLimitMB - storageUsedMB
+    # Return -1 if 'storageLimitMB' is 0
+    def available_storage
+      return -1 if @storage_limit_mb == 0
+
+      @storage_limit_mb - @storage_used_mb
+    end
+  end
+
+end

data/lib/ruby_vcloud_sdk/version.rb

@@ -1,3 +1,3 @@
 module VCloudSdk
-  VERSION = "0.4.8"
+  VERSION = '0.5.0'
 end

data/lib/ruby_vcloud_sdk/vm.rb

@@ -0,0 +1,132 @@
+require "forwardable"
+require_relative "infrastructure"
+require_relative "powerable"
+
+module VCloudSdk
+  class VM
+    include Infrastructure
+    include Powerable
+
+    extend Forwardable
+    def_delegator :entity_xml, :name
+
+    def initialize(session, link)
+      @session = session
+      @link = link
+    end
+
+    def href
+      @link
+    end
+
+    def independent_disks
+      hardware_section = entity_xml.hardware_section
+      disks = []
+      hardware_section.hard_disks.each do |disk|
+        disk_link = disk.host_resource.attribute("disk")
+        unless disk_link.nil?
+          disks << VCloudSdk::Disk.new(@session, disk_link.to_s)
+        end
+      end
+      disks
+    end
+
+    def list_disks
+      entity_xml.hardware_section.hard_disks.map do |disk|
+        disk_link = disk.host_resource.attribute("disk")
+        if disk_link.nil?
+          disk.element_name
+        else
+          "#{disk.element_name} (#{VCloudSdk::Disk.new(@session, disk_link.to_s).name})"
+        end
+      end
+    end
+
+    def attach_disk(disk)
+      fail CloudError,
+           "Disk '#{disk.name}' of link #{disk.href} is attached to VM '#{disk.vm.name}'" if disk.attached?
+
+      task = connection.post(entity_xml.attach_disk_link.href,
+                             disk_attach_or_detach_params(disk),
+                             Xml::MEDIA_TYPE[:DISK_ATTACH_DETACH_PARAMS])
+      task = monitor_task(task)
+
+      Config.logger.info "Disk '#{disk.name}' is attached to VM '#{name}'"
+      task
+    end
+
+    def detach_disk(disk)
+      parent_vapp = vapp
+      if parent_vapp.status == "SUSPENDED"
+        fail VmSuspendedError,
+             "vApp #{parent_vapp.name} suspended, discard state before detaching disk."
+      end
+
+      unless (vm = disk.vm).href == href
+        fail CloudError,
+             "Disk '#{disk.name}' is attached to other VM - name: '#{vm.name}', link '#{vm.href}'"
+      end
+
+      task = connection.post(entity_xml.detach_disk_link.href,
+                             disk_attach_or_detach_params(disk),
+                             Xml::MEDIA_TYPE[:DISK_ATTACH_DETACH_PARAMS])
+      task = monitor_task(task)
+
+      Config.logger.info "Disk '#{disk.name}' is detached from VM '#{name}'"
+      task
+    end
+
+    def insert_media(catalog_name, media_file_name)
+      catalog = find_catalog_by_name(catalog_name)
+      media = catalog.find_item(media_file_name, Xml::MEDIA_TYPE[:MEDIA])
+
+      vm = entity_xml
+      media_xml = connection.get(media.href)
+      Config.logger.info("Inserting media #{media_xml.name} into VM #{vm.name}")
+
+      wait_for_running_tasks(media_xml, "Media '#{media_xml.name}'")
+
+      task = connection.post(vm.insert_media_link.href,
+                             media_insert_or_eject_params(media),
+                             Xml::MEDIA_TYPE[:MEDIA_INSERT_EJECT_PARAMS])
+      monitor_task(task)
+    end
+
+    def eject_media(catalog_name, media_file_name)
+      catalog = find_catalog_by_name(catalog_name)
+      media = catalog.find_item(media_file_name, Xml::MEDIA_TYPE[:MEDIA])
+
+      vm = entity_xml
+      media_xml = connection.get(media.href)
+      Config.logger.info("Ejecting media #{media_xml.name} from VM #{vm.name}")
+
+      wait_for_running_tasks(media_xml, "Media '#{media_xml.name}'")
+
+      task = connection.post(vm.eject_media_link.href,
+                             media_insert_or_eject_params(media),
+                             Xml::MEDIA_TYPE[:MEDIA_INSERT_EJECT_PARAMS])
+      monitor_task(task)
+    end
+
+    private
+
+    def disk_attach_or_detach_params(disk)
+      Xml::WrapperFactory
+        .create_instance("DiskAttachOrDetachParams")
+        .tap do |params|
+        params.disk_href = disk.href
+      end
+    end
+
+    def vapp
+      vapp_link = entity_xml.vapp_link
+      VCloudSdk::VApp.new(@session, vapp_link.href)
+    end
+
+    def media_insert_or_eject_params(media)
+      Xml::WrapperFactory.create_instance("MediaInsertOrEjectParams").tap do |params|
+        params.media_href = media.href
+      end
+    end
+  end
+end

data/lib/ruby_vcloud_sdk/xml/constants.rb

@@ -24,7 +24,8 @@ module VCloudSdk
         :ADDRESS_ON_PARENT => "AddressOnParent",
         :ADDRESS => "Address",
         :CONNECTION => "Connection",
-        :PARENT => "Parent"
+        :PARENT => "Parent",
+        :ELEMENT_NAME => "ElementName",
     }
 
     RESOURCE_SUB_TYPE = {
@@ -174,7 +175,6 @@ module VCloudSdk
 
     ADMIN_MEDIA_TYPE = {
       :ADMIN_MEDIA_TYPE_PREFIX => "application/vnd.vmware.admin.",
-      :VCLOUD => "application/vnd.vmware.admin.vcloud+xml",
       :PROVIDER_VDC => "application/vnd.vmware.admin.providervdc+xml",
       :ADMIN_VDC => "application/vnd.vmware.admin.vdc+xml",
       :VDC => "application/vnd.vmware.vcloud.vdc+xml",
@@ -185,14 +185,13 @@ module VCloudSdk
       :SYSTEM_ADMIN_ORGANIZATION =>
         "application/vnd.vmware.admin.systemOrganization+xml",
       :ADMIN_ORGANIZATION => "application/vnd.vmware.admin.organization+xml",
-      :ORGANIZATION => "application/vnd.vmware.vcloud.org+xml",
       :TASKS_LIST => "application/vnd.vmware.vcloud.tasksList+xml",
       :USER => "application/vnd.vmware.admin.user+xml",
       :GROUP => "application/vnd.vmware.admin.group+xml",
       :ROLE => "application/vnd.vmware.admin.role+xml",
       :RIGHT => "application/vnd.vmware.admin.right+xml",
       :ADMIN_CATALOG => "application/vnd.vmware.admin.catalog+xml",
-      :CATALOG => "application/vnd.vmware.vcloud.catalog+xml",
+      :CATALOG => "application/vnd.vmware.admin.catalog+xml",
       :ADMIN_CATALOG_ITEM => "application/vnd.vmware.admin.catalogItem+xml",
       :CATALOG_ITEM => "application/vnd.vmware.vcloud.catalogItem+xml",
       :ADMIN_NETWORK => "application/vnd.vmware.admin.network+xml",
@@ -215,6 +214,7 @@ module VCloudSdk
     }
 
     XML_TYPE = {
+      :ADD => "add",
       :ADMINALLOCATEDEXTIPRECORD => "AdminAllocatedExtIpRecord",
       :ADMINCATALOG => "AdminCatalog",
       :ADMINCATALOGITEMRECORD => "AdminCatalogItemRecord",
@@ -265,6 +265,7 @@ module VCloudSdk
       :DEPLOYVAPPPARAMS => "DeployVAppParams",
       :DHCPSERVICE => "DhcpService",
       :DVSWITCHRECORD => "DvSwitchRecord",
+      :EDIT => "edit",
       :ENTITY => "Entity",
       :ERROR => "Error",
       :EVENTRECORD => "EventRecord",
@@ -341,6 +342,7 @@ module VCloudSdk
       :REFERENCE => "Reference",
       :REFERENCES => "References",
       :RELOCATEPARAMS => "RelocateParams",
+      :REMOVE => "remove",
       :RESOURCEENTITY => "ResourceEntity",
       :RESOURCEPOOLRECORD => "ResourcePoolRecord",
       :RIGHT => "Right",

data/lib/ruby_vcloud_sdk/xml/wrapper.rb

@@ -2,7 +2,6 @@ require "nokogiri"
 
 module VCloudSdk
   module Xml
-
     class WrapperFactory
       @@xml_dictionary = {}
       class << self
@@ -20,8 +19,11 @@ module VCloudSdk
         end
 
         def wrap_nodes(nodes, ns, namespace_defintions)
-          nodes.collect { |node| WrapperFactory.wrap_node(node, ns,
-            namespace_defintions) }
+          nodes.map do |node|
+            WrapperFactory.wrap_node(node,
+                                     ns,
+                                     namespace_defintions)
+          end
         end
 
         # TODO: We might run into a bug later if there are ever XML node types
@@ -38,11 +40,11 @@ module VCloudSdk
         def create_instance(type_name, ns = nil, namespace_defintions = nil,
             *args)
           xml = @@xml_dictionary[type_name]
-          if (xml)
+          if xml
             wrap_document(xml, ns, namespace_defintions, *args)
           else
-            raise CpiError,
-              "XML type #{type_name} not found in xml_templates dir."
+            fail CpiError,
+                 "XML type #{type_name} not found in xml_templates dir."
           end
         end
 
@@ -73,7 +75,7 @@ module VCloudSdk
 
         # Use (server) supplied prefixes defaulting to the preset ones for
         # those not specified.
-        @doc_namespaces = ns_definitions.nil? ? Array.new :
+        @doc_namespaces = ns_definitions.nil? ? [] :
           Array.new(ns_definitions)
         if @root.namespace_definitions
           @doc_namespaces.concat(@root.namespace_definitions)
@@ -85,17 +87,30 @@ module VCloudSdk
       end
 
       def xpath(*args)
-        WrapperFactory::wrap_nodes(@root.xpath(*args), @ns, @doc_namespaces)
+        WrapperFactory.wrap_nodes(@root.xpath(*args), @ns, @doc_namespaces)
       end
 
       def href
         @root["href"]
       end
 
+      def href=(href)
+        @root["href"] = href
+      end
+
+      def href_id
+        # Sample href: "https://10.146.21.135/api/org/a3783d64-0b9b-42d6-93cf-23bb08ec5520"
+        URI.parse(href).path.split('/')[-1]
+      end
+
       def name
         @root["name"]
       end
 
+      def name=(name)
+        @root["name"] = name
+      end
+
       def urn
         @root["id"]
       end
@@ -104,13 +119,52 @@ module VCloudSdk
         @root["type"]
       end
 
+      def type=(type)
+        @root["type"] = type
+      end
+
+      def remove_link
+        get_nodes(XML_TYPE[:LINK],
+                  { rel: XML_TYPE[:REMOVE] },
+                  true).first
+      end
+
+      def edit_link
+        get_nodes(XML_TYPE[:LINK],
+                  { rel: XML_TYPE[:EDIT] },
+                  true).first
+      end
+
+      def power_on_link
+        get_nodes(XML_TYPE[:LINK],
+                  { rel: "power:powerOn"},
+                  true).first
+      end
+
+      def power_off_link
+        get_nodes(XML_TYPE[:LINK],
+                  { rel: "power:powerOff"},
+                  true).first
+      end
+
+      def undeploy_link
+        get_nodes(XML_TYPE[:LINK],
+                  { rel: "undeploy" },
+                  true).first
+      end
+
+      def running_tasks
+        get_nodes(XML_TYPE[:TASK],
+                  { status: TASK_STATUS[:RUNNING] })
+      end
+
       def create_xpath_query(type_name, attrs = nil, only_immediate = false,
           namespace = VCLOUD_NAMESPACE)
         qualified_name = create_qualified_name(type_name, namespace)
         depth_prefix = only_immediate ? nil : ".//"
         if attrs && attrs.length > 0
           attrs_list = []
-          attrs.each do |k,v|
+          attrs.each do |k, v|
             attrs_list.push(%Q[@#{k}="#{v}"])
           end
 
@@ -129,7 +183,7 @@ module VCloudSdk
         @doc_namespaces.each do |ns|
           if ns.href == href
             if ns.prefix.nil?
-              ns_wanted_no_prefix = ns;
+              ns_wanted_no_prefix = ns
             else
               namespace_wanted = ns
               break
@@ -137,7 +191,8 @@ module VCloudSdk
           end
         end
         namespace_wanted = ns_wanted_no_prefix unless namespace_wanted
-        raise CpiError, "Namespace #{href} not found." unless namespace_wanted
+        fail CpiError,
+             "Namespace #{href} not found." unless namespace_wanted
         ns_prefix = namespace_wanted.prefix.nil? ? "xmlns" :
           namespace_wanted.prefix
         "#{ns_prefix}:#{name}"
@@ -155,6 +210,11 @@ module VCloudSdk
         @root[attr]
       end
 
+      # get the attribute regardless what namespace the attribute has
+      def attribute(name)
+        @root.attribute(name)
+      end
+
       def []=(attr, value)
         @root[attr] = value
       end
@@ -172,37 +232,38 @@ module VCloudSdk
       end
 
       def to_s
-        add_namespaces.to_xml.each_line.inject("") {
-          |xml, line| xml.concat(line.sub(/^\s+$/, "")) }
+        add_namespaces
+          .to_xml
+          .each_line
+          .reduce("") do |xml, line|
+          xml.concat(line.sub(/^\s+$/, ""))
+        end
       end
 
-      def add_child(child, namespace_prefix = nil, namespace_href = nil,
-          parent = @root)
+      def add_child(
+            child,
+            namespace_prefix = nil,
+            namespace_href = nil,
+            parent = @root)
         if child.is_a? Wrapper
           @root.add_child(child.node)
         elsif child.is_a? String
           node = Nokogiri::XML::Node.new(child, parent)
-          if (namespace_prefix.nil? ^ namespace_href.nil?)
-            raise CpiError,
-              "Namespace prefix must both be nil or defined together."
-          end
-          # This is a little more cumbersome but Nokogiri has problems
-          # figuring out the right namespace prefix otherwise
-          if namespace_prefix
-            ns = node.add_namespace_definition(namespace_prefix,
-              namespace_href)
-            node.namespace = ns
-          end
+          set_namespace(node, namespace_prefix, namespace_href)
           parent.add_child(node)
         else
-          raise CpiError, "Cannot add child.  Unknown object passed in."
+          fail CpiError, "Cannot add child.  Unknown object passed in."
         end
       end
 
       # Creates a child node but does not add it to the document.  Used when
       # a new child node has to be in a specific location or order.
-      def create_child(tag)
-        Nokogiri::XML::Node.new(tag, @root)
+      def create_child(tag,
+                       namespace_prefix = nil,
+                       namespace_href = nil)
+        node = Nokogiri::XML::Node.new(tag, @root)
+        set_namespace(node, namespace_prefix, namespace_href)
+        node
       end
 
       protected
@@ -236,7 +297,25 @@ module VCloudSdk
         clone.namespace = default_ns
         clone
       end
-    end
 
+      def set_namespace(node, namespace_prefix, namespace_href)
+        if namespace_prefix.nil? && namespace_href.nil?
+          return
+        elsif namespace_prefix.nil? || namespace_href.nil?
+          fail CpiError,
+               "Namespace prefix must both be nil or defined together."
+        end
+
+        if !node.namespace.nil? &&
+          node.namespace.prefix == namespace_prefix &&
+          node.namespace.href == namespace_href
+          return
+        end
+
+        ns = node.add_namespace_definition(namespace_prefix,
+                                           namespace_href)
+        node.namespace = ns
+      end
+    end
   end
 end