ruby_vcloud_sdk 0.4.8

data/lib/ruby_vcloud_sdk/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/ruby_vcloud_sdk/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

data/lib/ruby_vcloud_sdk/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/ruby_vcloud_sdk/xml/wrapper_classes/media.rb

@@ -0,0 +1,53 @@
+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
+    end
+
+  end
+end

data/lib/ruby_vcloud_sdk/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/ruby_vcloud_sdk/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/ruby_vcloud_sdk/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/ruby_vcloud_sdk/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/ruby_vcloud_sdk/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/ruby_vcloud_sdk/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/ruby_vcloud_sdk/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