bosh_vcloud_cpi 0.4.9 → 0.5.0

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

@@ -0,0 +1,32 @@
+module VCloudSdk
+  module Xml
+
+    class Item < Wrapper
+      def add_rasd(name)
+        raise "Cannot add duplicate RASD element #{name}." if get_rasd(name)
+        add_child(name, "rasd", RASD)
+      end
+
+      def edit_link
+        get_nodes("Link", {"rel" => "edit"}, true).first
+      end
+
+      def get_rasd(name)
+        get_nodes(name, nil, true, RASD).first
+      end
+
+      def get_rasd_content(name)
+        node = get_rasd(name)
+        return node.content if node
+        nil
+      end
+
+      def set_rasd(name, value)
+        node = get_rasd(name)
+        raise "The RASD element #{name} does not exist." unless node
+        node.content = value
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,39 @@
+module VCloudSdk
+  module Xml
+
+    class Link < Wrapper
+      def name
+        @root["name"]
+      end
+
+      def name=(name)
+        @root["name"] = name
+      end
+
+      def rel
+        @root["rel"]
+      end
+
+      def rel=(rel)
+        @root["rel"] = rel
+      end
+
+      def type
+        @root["type"]
+      end
+
+      def type=(type)
+        @root["type"] = type
+      end
+
+      def href
+        @root["href"]
+      end
+
+      def href=(href)
+        @root["href"] = href
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,57 @@
+module VCloudSdk
+  module Xml
+
+    class Media < Wrapper
+      def name
+        @root["name"]
+      end
+
+      def name=(name)
+        @root["name"] = name.to_s
+      end
+
+      def size
+        @root["size"]
+      end
+
+      def size=(size)
+        @root["size"] = size.to_s
+      end
+
+      def image_type
+        @root["imageType"]
+      end
+
+      def image_type=(image_type)
+        @root["imageType"] = image_type.to_s
+      end
+
+      def storage_profile=(storage_profile)
+        add_child(storage_profile) unless storage_profile.nil?
+      end
+
+      def files
+        get_nodes("File")
+      end
+
+      # Files that haven"t finished transferring
+      def incomplete_files
+        files.find_all { |f| f["size"].to_i < 0 ||
+          (f["size"].to_i > f["bytesTransferred"].to_i) }
+      end
+
+      def delete_link
+        get_nodes("Link", {"rel" => "remove"}, true).first
+      end
+
+      def running_tasks
+        get_nodes("Task", {"status" => "running"})
+      end
+
+      def tasks
+        get_nodes("Task")
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,17 @@
+module VCloudSdk
+  module Xml
+
+    class MediaInsertOrEjectParams < Wrapper
+      def media_href=(value)
+        media["href"] = value
+      end
+
+      private
+
+      def media
+         get_nodes("Media", nil, true).first
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,15 @@
+module VCloudSdk
+  module Xml
+
+    class MetadataValue < Wrapper
+      def value
+        get_nodes("Value").first.content
+      end
+
+      def value=(v)
+        get_nodes("Value").first.content = v
+      end
+    end
+
+  end
+end

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

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

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

@@ -0,0 +1,27 @@
+module VCloudSdk
+  module Xml
+
+    class NetworkConfig < Wrapper
+      def ip_scope
+        get_nodes("IpScope").first
+      end
+
+      def network_name
+        @root["networkName"]
+      end
+
+      def parent_network
+        get_nodes("ParentNetwork").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/cloud/vcloud/xml/wrapper_classes/network_config_section.rb

@@ -0,0 +1,25 @@
+module VCloudSdk
+  module Xml
+
+    class NetworkConfigSection < Wrapper
+      def network_configs
+        get_nodes("NetworkConfig")
+      end
+
+      def add_network_config(config)
+        unless config.is_a? NetworkConfig
+          raise 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.node.remove
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,71 @@
+module VCloudSdk
+  module Xml
+
+    class NetworkConnection < Wrapper
+      def network
+        @root["network"]
+      end
+
+      # Value should be the name of the vApp network to connect to
+      def network=(value)
+        @root["network"] = value
+      end
+
+      def network_connection_index
+        get_nodes("NetworkConnectionIndex").first.content
+      end
+
+      def network_connection_index=(value)
+        unless get_nodes("NetworkConnectionIndex").first
+          index_node = create_child("NetworkConnectionIndex")
+          add_child(index_node)
+        end
+        get_nodes("NetworkConnectionIndex").first.content = value
+      end
+
+      def ip_address
+        get_nodes("IpAddress").first.content
+      end
+
+      def ip_address=(value)
+        # When addressing mode is other than MANUAL this node does not exist.
+        unless get_nodes("IpAddress").first
+          # must be after network connection index
+          index_node = get_nodes("NetworkConnectionIndex").first
+          ip_node = create_child("IpAddress")
+          index_node.node.after(ip_node)
+        end
+        get_nodes("IpAddress").first.content = value
+      end
+
+      def is_connected
+        get_nodes("IsConnected").first.content
+      end
+
+      def is_connected=(value)
+        get_nodes("IsConnected").first.content = value
+      end
+
+      def mac_address
+        get_nodes("MACAddress").first.content
+      end
+
+      def mac_address=(value)
+        get_nodes("MACAddress").first.content = value
+      end
+
+      def ip_address_allocation_mode
+        get_nodes("IpAddressAllocationMode").first.content
+      end
+
+      def ip_address_allocation_mode=(value)
+        if !IP_ADDRESSING_MODE.values.include?(value)
+          raise ArgumentError, "Invalid IP addressing mode.  Valid modes " +
+              "are: #{IP_ADDRESSING_MODE.values.join(" ")}"
+        end
+        get_nodes("IpAddressAllocationMode").first.content = value
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,67 @@
+module VCloudSdk
+  module Xml
+
+    class NetworkConnectionSection < Wrapper
+      def add_item(item)
+        link_node = get_nodes("Link").first
+        link_node.node.before(item.node)
+      end
+
+      def edit_link
+        get_nodes("Link", {"rel" => "edit"}, true).first
+      end
+
+      def network_connections
+        get_nodes("NetworkConnection")
+      end
+
+      def network_connection(index)
+        net = network_connections.find {
+          |n| n.network_connection_index == index.to_s }
+        unless net
+          raise ObjectNotFoundError, "Network connection #{index} does not exist."
+        end
+        net
+      end
+
+      # This will be nil if there are no network connections
+      def primary_network_connection_index
+        node = get_nodes("PrimaryNetworkConnectionIndex").first
+        if node.nil?
+          nil
+        else
+          node.content
+        end
+      end
+
+      def primary_network_connection_index=(index)
+        get_nodes("PrimaryNetworkConnectionIndex").first.content = index
+      end
+
+      def remove_network_connection(index)
+        connection = network_connection(index)
+        if connection
+          connection.node.remove
+          reconcile_primary_network()
+        else
+          raise ObjectNotFoundError,
+            "Cannot remove network connection #{index}: does not exist."
+        end
+      end
+
+      private
+
+      def reconcile_primary_network()
+        new_primary = network_connections.first
+        if new_primary
+          self.primary_network_connection_index =
+            new_primary.network_connection_index
+        else
+          primary = get_nodes("PrimaryNetworkConnectionIndex").first
+          primary.node.remove if primary
+        end
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,89 @@
+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/cloud/vcloud/xml/wrapper_classes/org.rb

@@ -0,0 +1,21 @@
+module VCloudSdk
+  module Xml
+
+    class Org < Wrapper
+
+      def vdc_link(name)
+        get_nodes("Link",
+                  { "type" => MEDIA_TYPE[:VDC],
+                    "name" => name},
+                  true).first
+      end
+
+      def catalog_link(name)
+        get_nodes("Link",
+                  { "type" => MEDIA_TYPE[:CATALOG],
+                    "name" => name},
+                  true).first
+      end
+    end
+  end
+end

data/lib/cloud/vcloud/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/cloud/vcloud/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/cloud/vcloud/xml/wrapper_classes/recompose_vapp_wrapper.rb

@@ -0,0 +1,51 @@
+module VCloudSdk
+  module Xml
+
+    class RecomposeVAppParams < Wrapper
+      def name
+        @root["name"]
+      end
+
+      def name=(name)
+        @root["name"] = name
+      end
+
+      def description
+        get_nodes("Description").first
+      end
+
+      def description=(desc)
+        description.content = desc
+      end
+
+      def all_eulas_accepted=(value)
+        eulas_node = get_nodes("AllEULAsAccepted").first
+        eulas_node.content = value
+      end
+
+      def add_source_item(entity_to_add_href)
+        return unless entity_to_add_href
+
+        prefix = namespace.prefix
+        prefix += ':' if prefix
+
+        node_sourced_item = create_child("#{prefix}SourcedItem")
+        node_sourced_item["sourceDelete"] = "true"
+
+        node_source = add_child("#{prefix}Source", nil, nil, node_sourced_item)
+        node_source["href"] = entity_to_add_href
+
+        get_nodes("AllEULAsAccepted").first.node.before(node_sourced_item)
+      end
+
+      def add_delete_item(entity_to_delete_href)
+        return unless entity_to_delete_href
+
+        node_delete_item = create_child("DeleteItem")
+        node_delete_item["href"] = entity_to_delete_href
+
+        get_nodes("AllEULAsAccepted").first.node.after(node_delete_item)
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,19 @@
+module VCloudSdk
+  module Xml
+
+    class SupportedVersions < Wrapper
+      def login_url
+        ns = namespace.href # Typically it's 'http://www.vmware.com/vcloud/versions'
+        get_nodes('VersionInfo', nil, false, ns).each do |node|
+          if node.get_nodes('Version', nil, false, ns).first.content  \
+            == VCloudClient::VCLOUD_VERSION_NUMBER
+            return node.get_nodes('LoginUrl', nil, false, ns).first
+          end
+        end
+
+        nil
+      end
+    end
+
+  end
+end

data/lib/cloud/vcloud/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/cloud/vcloud/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