bosh_vcloud_cpi 0.4.9 → 0.5.0

data/lib/cloud/vcloud/xml/wrapper.rb

@@ -0,0 +1,292 @@
+require "nokogiri"
+
+module VCloudSdk
+  module Xml
+
+    class WrapperFactory
+      @@xml_dictionary = {}
+      class << self
+        def wrap_document(xml, ns = nil, namespace_defintions = nil, *args)
+          doc = Nokogiri::XML(xml)
+          type_name = doc.root.name
+          node_class = find_wrapper_class(type_name)
+          node_class.new(doc, ns, namespace_defintions, *args)
+        end
+
+        def wrap_node(node, ns, namespace_defintions = nil, *args)
+          type_name = node.node_name
+          node_class = find_wrapper_class(type_name)
+          node_class.new(node, ns, namespace_defintions, *args)
+        end
+
+        def wrap_nodes(nodes, ns, namespace_defintions)
+          nodes.collect { |node| WrapperFactory.wrap_node(node, ns,
+            namespace_defintions) }
+        end
+
+        # TODO: We might run into a bug later if there are ever XML node types
+        # of the same name but different namespace
+        def find_wrapper_class(type_name)
+          # for Ruby 1.9, we would need pass false in as the 2nd parameter
+          if Xml.constants.find { |c| c.to_sym == type_name.to_sym }
+            Xml.const_get(type_name.to_sym)
+          else
+            Wrapper
+          end
+        end
+
+        def create_instance(type_name, ns = nil, namespace_defintions = nil,
+            *args)
+          xml = @@xml_dictionary[type_name]
+          if (xml)
+            wrap_document(xml, ns, namespace_defintions, *args)
+          else
+            raise Bosh::Clouds::CpiError,
+              "XML type #{type_name} not found in xml_templates dir."
+          end
+        end
+
+        # Load all the XML files
+        Dir[File.dirname(__FILE__) + "/xml_templates/*.xml"].each do |f|
+          @@xml_dictionary[File.basename(f, ".xml")] =
+            File.open(File.expand_path(f)).read
+        end
+      end
+    end
+
+    class Wrapper
+      # Because we are wrapping individual nodes in a wrapper and turning them
+      # into XML docs, we need to preserve the namespace information with each
+      # node
+      def initialize(xml, ns = nil, ns_definitions = nil)
+        if xml.is_a?(Nokogiri::XML::Document)
+          @doc = xml
+          @root = @doc.root
+        else
+          @root = xml
+        end
+        if ns
+          @ns = ns
+        else
+          @ns = @root.namespace
+        end
+
+        # Use (server) supplied prefixes defaulting to the preset ones for
+        # those not specified.
+        @doc_namespaces = ns_definitions.nil? ? Array.new :
+          Array.new(ns_definitions)
+        if @root.namespace_definitions
+          @doc_namespaces.concat(@root.namespace_definitions)
+        end
+      end
+
+      def doc_namespaces
+        @doc_namespaces
+      end
+
+      def xpath(*args)
+        WrapperFactory::wrap_nodes(@root.xpath(*args), @ns, @doc_namespaces)
+      end
+
+      def href
+        @root["href"]
+      end
+
+      def name
+        @root["name"]
+      end
+
+      def urn
+        @root["id"]
+      end
+
+      def type
+        @root["type"]
+      end
+
+      def attribute_with_ns(attr, ns)
+        @root.attribute_with_ns(attr, ns)
+      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_list.push(%Q[@#{k}="#{v}"])
+          end
+
+          "#{depth_prefix}#{qualified_name}[#{attrs_list.join(" and ")}]"
+        else
+          "#{depth_prefix}#{qualified_name}"
+        end
+      end
+
+      def create_qualified_name(name, href)
+        namespace_wanted = nil
+        ns_wanted_no_prefix = nil
+        # Do it this way so the namespaces are searched in the order they are
+        # added.  The first one is the one closest to the node, while the ones
+        # at the document root are the last.
+        @doc_namespaces.each do |ns|
+          if ns.href == href
+            if ns.prefix.nil?
+              ns_wanted_no_prefix = ns;
+            else
+              namespace_wanted = ns
+              break
+            end
+          end
+        end
+        namespace_wanted = ns_wanted_no_prefix unless namespace_wanted
+        raise Bosh::Clouds::CpiError, "Namespace #{href} not found." unless namespace_wanted
+        ns_prefix = namespace_wanted.prefix.nil? ? "xmlns" :
+          namespace_wanted.prefix
+        "#{ns_prefix}:#{name}"
+      end
+
+      def get_nodes(type_name, attrs = nil, only_immediate = false,
+          namespace = VCLOUD_NAMESPACE)
+        xpath(create_xpath_query(type_name, attrs, only_immediate, namespace))
+      end
+
+      def [](attr)
+        @root[attr]
+      end
+
+      def []=(attr, value)
+        @root[attr] = value
+      end
+
+      def content
+        @root.content
+      end
+
+      def content=(value)
+        @root.content = value
+      end
+
+      def ==(other)
+        @root.to_s == other.node.to_s
+      end
+
+      def to_s
+        add_namespaces.to_xml.each_line.inject("") {
+          |xml, line| xml.concat(line.sub(/^\s+$/, "")) }
+      end
+
+      def add_child(child, namespace_prefix = nil, namespace_href = nil,
+          parent = @root)
+        if child.is_a? Wrapper
+          parent.add_child(child.node)
+        elsif child.is_a? String
+          node = Nokogiri::XML::Node.new(child, parent)
+          if (namespace_prefix.nil? ^ namespace_href.nil?)
+            raise Bosh::Clouds::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
+          parent.add_child(node)
+        else
+          raise Bosh::Clouds::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)
+      end
+
+      protected
+
+      def node
+        @root
+      end
+
+      def namespace
+        @ns
+      end
+
+      def namespace_definitions
+        @doc_namespaces
+      end
+
+      def fix_if_invalid(link, rel, type, href)
+        if link.nil? || link.href.to_s.nil?
+          link = Xml::WrapperFactory.create_instance("Link")
+          link.rel  = rel
+          link.type = type
+          link.href = href
+        end
+        link
+      end
+
+      private
+
+      def add_namespaces
+        clone = @root.clone
+
+        # This is a workaround for a Nokogiri bug.  If you add a namespace
+        # with a nil for prefix, i.e. the namespace following xmlns, Nokogiri
+        # will remove the original namespace and assume you are setting a new
+        # namespace for the node.
+        default_ns = clone.namespace
+
+        @doc_namespaces.each do |ns|
+          clone.add_namespace_definition(ns.prefix, ns.href)
+        end
+        clone.namespace = default_ns
+        clone
+      end
+    end
+
+  end
+end
+
+require_relative "wrapper_classes/item"
+require_relative "wrapper_classes/admin_catalog"
+require_relative "wrapper_classes/admin_org"
+require_relative "wrapper_classes/catalog"
+require_relative "wrapper_classes/catalog_item"
+require_relative "wrapper_classes/disk"
+require_relative "wrapper_classes/disk_attach_or_detach_params"
+require_relative "wrapper_classes/disk_create_params"
+require_relative "wrapper_classes/entity"
+require_relative "wrapper_classes/file"
+require_relative "wrapper_classes/hard_disk_item_wrapper"
+require_relative "wrapper_classes/instantiate_vapp_template_params"
+require_relative "wrapper_classes/ip_scope"
+require_relative "wrapper_classes/link_wrapper"
+require_relative "wrapper_classes/media"
+require_relative "wrapper_classes/media_insert_or_eject_params"
+require_relative "wrapper_classes/metadata_value"
+require_relative "wrapper_classes/network"
+require_relative "wrapper_classes/network_config"
+require_relative "wrapper_classes/network_config_section"
+require_relative "wrapper_classes/network_connection"
+require_relative "wrapper_classes/network_connection_section"
+require_relative "wrapper_classes/nic_item_wrapper"
+require_relative "wrapper_classes/org"
+require_relative "wrapper_classes/org_network"
+require_relative "wrapper_classes/org_vdc_network"
+require_relative "wrapper_classes/recompose_vapp_wrapper"
+require_relative "wrapper_classes/session"
+require_relative "wrapper_classes/supported_versions"
+require_relative "wrapper_classes/task"
+require_relative "wrapper_classes/upload_vapp_template_params"
+require_relative "wrapper_classes/vapp"
+require_relative "wrapper_classes/vapp_template"
+require_relative "wrapper_classes/vcloud"
+require_relative "wrapper_classes/vdc"
+require_relative "wrapper_classes/vdc_storage_profile"
+require_relative "wrapper_classes/virtual_hardware_section"
+require_relative "wrapper_classes/vm"

data/lib/cloud/vcloud/xml/wrapper_classes/admin_catalog.rb

@@ -0,0 +1,20 @@
+module VCloudSdk
+  module Xml
+
+    class AdminCatalog < Wrapper
+      def add_item_link
+        get_nodes("Link", {"type"=>ADMIN_MEDIA_TYPE[:CATALOG_ITEM],
+          "rel"=>"add"}).first
+      end
+
+      def catalog_items(name = nil)
+        if name
+          get_nodes("CatalogItem", {"name" => name})
+        else
+          get_nodes("CatalogItem")
+        end
+      end
+    end
+
+  end
+end

data/lib/cloud/vcloud/xml/wrapper_classes/admin_org.rb

@@ -0,0 +1,15 @@
+module VCloudSdk
+  module Xml
+
+    class AdminOrg < Wrapper
+      def vdc(name)
+        get_nodes("Vdc", {"name"=>name}).first
+      end
+
+      def catalog(name)
+        get_nodes("CatalogReference", {"name"=>name}).first
+      end
+    end
+
+  end
+end

data/lib/cloud/vcloud/xml/wrapper_classes/catalog.rb

@@ -0,0 +1,20 @@
+module VCloudSdk
+  module Xml
+
+    class Catalog < Wrapper
+      def add_item_link
+        get_nodes("Link", {"type" => MEDIA_TYPE[:CATALOG_ITEM],
+                           "rel"=>"add"}).first
+      end
+
+      def catalog_items(name = nil)
+        if name
+          get_nodes("CatalogItem", {"name" => name})
+        else
+          get_nodes("CatalogItem")
+        end
+      end
+    end
+
+  end
+end

data/lib/cloud/vcloud/xml/wrapper_classes/catalog_item.rb

@@ -0,0 +1,27 @@
+module VCloudSdk
+  module Xml
+
+    class CatalogItem < Wrapper
+      def name=(name)
+        @root["name"] = name
+      end
+
+      def remove_link
+        get_nodes("Link", {"rel" => "remove"}, true).first
+      end
+
+      def entity=(entity)
+        entity_node = get_nodes("Entity").first
+        entity_node["name"] = entity.name
+        entity_node["id"] = entity.urn
+        entity_node["href"] = entity.href
+        entity_node["type"] = entity.type
+      end
+
+      def entity
+        get_nodes("Entity").first
+      end
+    end
+
+  end
+end

data/lib/cloud/vcloud/xml/wrapper_classes/disk.rb

@@ -0,0 +1,42 @@
+module VCloudSdk
+  module Xml
+
+    class Disk < Wrapper
+      def bus_type=(value)
+        @root["busType"] = value.to_s
+      end
+
+      def bus_sub_type=(value)
+        @root["busSubType"] = value.to_s
+      end
+
+      def remove_link(force = false)
+        link = get_nodes("Link", {"rel" => "remove"}, true).first
+        return link unless force
+        fix_if_invalid(link, "remove", MEDIA_TYPE[:DISK], "#{href}")
+      end
+
+      def name=(name)
+        @root["name"] = name.to_s
+      end
+
+      def size_mb
+        @root["size"].to_i/1024/1024
+      end
+
+      def running_tasks
+        tasks.find_all {|t| RUNNING.include?(t.status)}
+      end
+
+      def tasks
+        get_nodes("Task")
+      end
+
+      private
+
+      RUNNING = [TASK_STATUS[:RUNNING], TASK_STATUS[:QUEUED],
+          TASK_STATUS[:PRE_RUNNING]]
+    end
+
+  end
+end

data/lib/cloud/vcloud/xml/wrapper_classes/disk_attach_or_detach_params.rb

@@ -0,0 +1,12 @@
+module VCloudSdk
+  module Xml
+
+    class DiskAttachOrDetachParams < Wrapper
+      def disk_href=(value)
+        disk = get_nodes("Disk").first
+        disk["href"] = value.to_s
+      end
+    end
+
+  end
+end

data/lib/cloud/vcloud/xml/wrapper_classes/disk_create_params.rb

@@ -0,0 +1,47 @@
+module VCloudSdk
+  module Xml
+
+    class DiskCreateParams < Wrapper
+      def bus_type=(value)
+        disk["busType"] = value.to_s
+      end
+
+      def bus_sub_type=(value)
+        disk["busSubType"] = value.to_s
+      end
+
+      def name=(name)
+        disk["name"] = name.to_s
+      end
+
+      def size_bytes=(value)
+        disk["size"] = value.to_s
+      end
+
+      def add_locality(local)
+        if !@local_exists.nil? && @local_exists
+          raise "Cannot add locality more than once to DiskCreateParams"
+        end
+        @local_exists = true
+        node = create_child("Locality")
+        node["href"] = local.href
+        # Bug in create independent disk API.  It needs the UUID part of the
+        # ID instead of the entire ID like other REST API calls.
+        node["id"] = extract_uuid(local.urn)
+        node["type"] = MEDIA_TYPE[:VM]
+        disk.node.after(node)
+      end
+
+      private
+
+      def disk
+        get_nodes("Disk").first
+      end
+
+      def extract_uuid(id)
+        id.split(":").first
+      end
+    end
+
+  end
+end

data/lib/cloud/vcloud/xml/wrapper_classes/entity.rb

@@ -0,0 +1,11 @@
+module VCloudSdk
+  module Xml
+
+    class Entity < Wrapper
+      def link
+        get_nodes("Link").first
+      end
+    end
+
+  end
+end

data/lib/cloud/vcloud/xml/wrapper_classes/file.rb

@@ -0,0 +1,11 @@
+module VCloudSdk
+  module Xml
+
+    class File < Wrapper
+      def upload_link
+        get_nodes("Link", {"rel"=>"upload:default"}).first
+      end
+    end
+
+  end
+end

data/lib/cloud/vcloud/xml/wrapper_classes/hard_disk_item_wrapper.rb

@@ -0,0 +1,56 @@
+module VCloudSdk
+  module Xml
+
+    class HardDiskItemWrapper < Item
+      def hash
+        [disk_id, instance_id, bus_type, bus_sub_type].hash
+      end
+
+      def eql?(other)
+        disk_id == other.disk_id && instance_id == other.instance_id &&
+          bus_type == other.bus_type && bus_sub_type == other.bus_sub_type
+      end
+
+      def initialize(item)
+        super(item.node, item.namespace, item.namespace_definitions)
+      end
+
+      def capacity_mb
+        v = host_resource.attribute_with_ns(HOST_RESOURCE_ATTRIBUTE[:CAPACITY], VCLOUD_NAMESPACE)
+        v && v.value
+      end
+
+      def disk_href
+        v = host_resource.attribute_with_ns(HOST_RESOURCE_ATTRIBUTE[:DISK], VCLOUD_NAMESPACE)
+        v && v.value
+      end
+
+      def disk_id
+        get_rasd_content(RASD_TYPES[:ADDRESS_ON_PARENT])
+      end
+
+      def instance_id
+        get_rasd_content(RASD_TYPES[:INSTANCE_ID])
+      end
+
+      def bus_sub_type
+        v = host_resource.attribute_with_ns(HOST_RESOURCE_ATTRIBUTE[:BUS_SUB_TYPE], VCLOUD_NAMESPACE)
+        v && v.value
+      end
+
+      def bus_type
+        v = host_resource.attribute_with_ns(HOST_RESOURCE_ATTRIBUTE[:BUS_TYPE], VCLOUD_NAMESPACE)
+        v && v.value
+      end
+
+      def parent_instance_id
+        get_rasd_content(RASD_TYPES[:PARENT])
+      end
+
+      def host_resource
+        get_rasd(RASD_TYPES[:HOST_RESOURCE])
+      end
+    end
+
+  end
+end

data/lib/cloud/vcloud/xml/wrapper_classes/instantiate_vapp_template_params.rb

@@ -0,0 +1,71 @@
+module VCloudSdk
+  module Xml
+
+    class InstantiateVAppTemplateParams < Wrapper
+      def name
+        @root["name"]
+      end
+
+      def description
+        get_nodes("Description").first
+      end
+
+      def all_eulas_accepted=(value)
+        eulas_node = get_nodes("AllEULAsAccepted").first
+        eulas_node.content = value
+      end
+
+      def name=(name)
+        @root["name"] = name
+      end
+
+      def description=(desc)
+        description.content = desc
+      end
+
+      def linked_clone=(value)
+        @root["linkedClone"] = value.to_s
+      end
+
+      def source=(src)
+        source_node = get_nodes("Source").first
+        source_node["href"] = src["href"]
+        source_node["id"] = src["id"]
+        source_node["type"] = src["type"]
+        source_node["id"] = src["id"]
+      end
+
+      def set_locality=(locality)
+        return unless locality
+
+        raise "vApp locality already set." if @local_exists
+        @local_exists = true
+
+        locality.each do |k,v|
+          node_sp = create_child("SourcedVmInstantiationParams")
+          is_source_delete.node.after(node_sp)
+
+          node_sv = add_child("Source", nil, nil, node_sp)
+          node_sv["type"] = k.type
+          node_sv["name"] = k.name
+          node_sv["href"] = k.href
+
+          node_lp = create_child("LocalityParams")
+          node_sv.after(node_lp)
+
+          node_re = add_child("ResourceEntity", nil, nil, node_lp)
+          node_re["type"] = v.type
+          node_re["name"] = v.name
+          node_re["href"] = v.href
+        end
+      end
+
+      private
+
+      def is_source_delete
+        get_nodes("IsSourceDelete").first
+      end
+    end
+
+  end
+end

data/lib/cloud/vcloud/xml/wrapper_classes/ip_scope.rb

@@ -0,0 +1,55 @@
+module VCloudSdk
+  module Xml
+
+    class IpScope < Wrapper
+      def is_inherited?
+        get_nodes("IsInherited").first.content
+      end
+
+      def is_inherited=(value)
+        get_nodes("IsInherited").first.content = value
+      end
+
+      def gateway
+        get_nodes("Gateway").first.content
+      end
+
+      def gateway=(value)
+        get_nodes("Gateway").first.content = value
+      end
+
+      def netmask
+        get_nodes("Netmask").first.content
+      end
+
+      def netmask=(value)
+        get_nodes("Netmask").first.content = value
+      end
+
+      def start_address
+        nodes = get_nodes("StartAddress")
+        return nil unless nodes
+        node = nodes.first
+        return nil unless node
+        return node.content
+      end
+
+      def start_address=(value)
+        get_nodes("StartAddress").first.content = value
+      end
+
+      def end_address
+        nodes = get_nodes("EndAddress")
+        return nil unless nodes
+        node = nodes.first
+        return nil unless node
+        return node.content
+      end
+
+      def end_address=(value)
+        get_nodes("EndAddress").first.content = value
+      end
+    end
+
+  end
+end