phpfog-fog 0.4.1

data/lib/fog/vcloud/terremark/ecloud/requests/get_network_extensions.rb

@@ -0,0 +1,35 @@
+module Fog
+  class Vcloud
+    module Terremark
+      class Ecloud
+
+        class Real
+          basic_request :get_network_extensions
+        end
+
+        class Mock
+
+          def get_network_extensions(network_extension_uri)
+            if network_extension = mock_data.network_extension_from_href(ensure_unparsed(network_extension_uri))
+              xml = Builder::XmlMarkup.new
+              mock_it 200, xml.Network(ecloud_xmlns) {
+                xml.Address network_extension.address
+                xml.RnatAddress network_extension.rnat
+                xml.Href network_extension.href
+                xml.Id network_extension.object_id
+                xml.Name network_extension.name
+                xml.GatewayAddress network_extension.gateway
+                xml.BroadcastAddress network_extension.broadcast
+                xml.NetworkType network_extension.type
+                xml.Vlan network_extension.vlan
+                xml.FriendlyName network_extension.friendly_name
+              }, { 'Content-Type' => "application/vnd.tmrk.ecloud.network+xml" }
+            else
+              mock_error 200, "401 Unauthorized"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/vcloud/terremark/ecloud/requests/get_network_ip.rb

@@ -0,0 +1,45 @@
+#
+# AFAICT this is basically undocumented ATM - 6/18/2010 - freeformz
+#
+
+module Fog
+  class Vcloud
+    module Terremark
+      class Ecloud
+
+        class Real
+          basic_request :get_network_ip
+        end
+
+        class Mock
+
+          def get_network_ip(network_ip_uri)
+            if network_ip = mock_data.network_ip_from_href(network_ip_uri)
+              builder = Builder::XmlMarkup.new
+              xml = network_ip_response(builder, network_ip, ecloud_xmlns)
+
+              mock_it 200, xml, { 'Content-Type' => 'application/vnd.tmrk.ecloud.ip+xml' }
+            else
+              mock_error 200, "401 Unauthorized"
+            end
+          end
+
+          def network_ip_response(builder, network_ip, xmlns = {})
+            builder.IpAddress(xmlns) do
+              builder.Id network_ip.object_id
+              builder.Href network_ip.href
+              builder.Name network_ip.name
+
+              builder.Status network_ip.status
+              if network_ip.used_by
+                builder.Server network_ip.used_by.name
+              end
+
+              builder.RnatAddress(network_ip.rnat)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/vcloud/terremark/ecloud/requests/get_network_ips.rb

@@ -0,0 +1,37 @@
+#
+# AFAICT - This is basically undocumented - 6/18/2010 - freeformz
+#
+
+module Fog
+  class Vcloud
+    module Terremark
+      class Ecloud
+
+        class Real
+          basic_request :get_network_ips
+        end
+
+        class Mock
+
+          def get_network_ips(network_ips_uri)
+            network_ips_uri = ensure_unparsed(network_ips_uri)
+
+            if network_ip_collection = mock_data.network_ip_collection_from_href(network_ips_uri)
+              builder = Builder::XmlMarkup.new
+              xml = builder.IpAddresses do
+                network_ip_collection.ordered_ips.each do |network_ip|
+                  network_ip_response(builder, network_ip)
+                end
+              end
+
+              mock_it 200, xml, { 'Content-Type' => 'application/vnd.tmrk.ecloud.ipAddressesList+xml' }
+            else
+              mock_error 200, "401 Unauthorized"
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/fog/vcloud/terremark/ecloud/requests/get_node.rb

@@ -0,0 +1,42 @@
+module Fog
+  class Vcloud
+    module Terremark
+      class Ecloud
+
+        class Real
+          basic_request :get_node
+        end
+
+        class Mock
+          #
+          # Based on http://support.theenterprisecloud.com/kb/default.asp?id=641&Lang=1&SID=
+          #
+
+          def mock_node_service_response(node)
+            xml = Builder::XmlMarkup.new
+            xml.NodeService(ecloud_xmlns) {
+              xml.Id(node.object_id)
+              xml.Href(node.href)
+              xml.Name(node.name)
+              xml.IpAddress(node.ip_address)
+              xml.Port(node.port)
+              xml.Enabled(node.enabled)
+              xml.Description(node.description)
+            }
+          end
+
+          def get_node(node_uri)
+            node_uri = ensure_unparsed(node_uri)
+
+            if public_ip_internet_service_node = mock_data.public_ip_internet_service_node_from_href(node_uri)
+              xml = Builder::XmlMarkup.new
+              mock_it 200, mock_node_service_response(public_ip_internet_service_node), { 'Content-Type' => 'application/vnd.tmrk.ecloud.nodeService+xml' }
+            else
+              mock_error 200, "401 Unauthorized"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/vcloud/terremark/ecloud/requests/get_nodes.rb

@@ -0,0 +1,43 @@
+module Fog
+  class Vcloud
+    module Terremark
+      class Ecloud
+
+        class Real
+          basic_request :get_nodes
+        end
+
+        class Mock
+          #
+          # Based off of:
+          # http://support.theenterprisecloud.com/kb/default.asp?id=637&Lang=1&SID=
+          #
+
+          def get_nodes(nodes_uri)
+            nodes_uri = ensure_unparsed(nodes_uri)
+
+            if public_ip_internet_service_node_collection = mock_data.public_ip_internet_service_node_collection_from_href(nodes_uri)
+              xml = Builder::XmlMarkup.new
+              mock_it 200,
+                xml.NodeServices(ecloud_xmlns) {
+                  public_ip_internet_service_node_collection.items.each do |node|
+                    xml.NodeService {
+                      xml.Id node.object_id
+                      xml.Href node.href
+                      xml.Name node.name
+                      xml.IpAddress node.ip_address
+                      xml.Port node.port
+                      xml.Enabled node.enabled
+                      xml.Description node.description
+                    }
+                  end
+                }, { 'Content-Type' => 'application/vnd.tmrk.ecloud.nodeService+xml' }
+            else
+              mock_error 200, "401 Unauthorized"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/vcloud/terremark/ecloud/requests/get_public_ip.rb

@@ -0,0 +1,36 @@
+module Fog
+  class Vcloud
+    module Terremark
+      class Ecloud
+
+        class Real
+          basic_request :get_public_ip
+        end
+
+        class Mock
+          #
+          #Based off of:
+          #http://support.theenterprisecloud.com/kb/default.asp?id=567&Lang=1&SID=
+          #
+
+          def get_public_ip(public_ip_uri)
+            public_ip_uri = ensure_unparsed(public_ip_uri)
+
+            if public_ip = mock_data.public_ip_from_href(public_ip_uri)
+              xml = Builder::XmlMarkup.new
+              mock_it 200,
+                xml.PublicIp(:xmlns => "urn:tmrk:eCloudExtensions-2.0", :"xmlns:i" => "http://www.w3.org/2001/XMLSchema-instance") {
+                  xml.Id public_ip.object_id
+                  xml.Href public_ip.href
+                  xml.Name public_ip.name
+                }, { 'Content-Type' => 'application/vnd.tmrk.ecloud.publicIp+xml' }
+            else
+              mock_error 200, "401 Unauthorized"
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/fog/vcloud/terremark/ecloud/requests/get_public_ips.rb

@@ -0,0 +1,41 @@
+module Fog
+  class Vcloud
+    module Terremark
+      class Ecloud
+
+        class Real
+          basic_request :get_public_ips
+        end
+
+        class Mock
+          #
+          # Based off of:
+          # http://support.theenterprisecloud.com/kb/default.asp?id=577&Lang=1&SID=
+          #
+
+          def get_public_ips(public_ips_uri)
+            public_ips_uri = ensure_unparsed(public_ips_uri)
+
+            if public_ip_collection = mock_data.public_ip_collection_from_href(public_ips_uri)
+              xml = Builder::XmlMarkup.new
+              mock_it 200,
+                xml.PublicIPAddresses {
+                  public_ip_collection.items.each do |ip|
+                    xml.PublicIPAddress {
+                      xml.Id ip.object_id
+                      xml.Href ip.href
+                      xml.Name ip.name
+                    }
+                  end
+                }, { 'Content-Type' => 'application/vnd.tmrk.ecloud.publicIpsList+xml'}
+            else
+              mock_error 200, "401 Unauthorized"
+            end
+          end
+
+        end
+      end
+    end
+  end
+end
+

data/lib/fog/vcloud/terremark/ecloud/requests/get_task.rb

@@ -0,0 +1,18 @@
+module Fog
+  class Vcloud
+    module Terremark
+      class Ecloud
+
+        class Real
+          basic_request :get_task
+        end
+
+        class Mock
+          def get_task(task__uri)
+            Fog::Mock.not_implemented
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/vcloud/terremark/ecloud/requests/get_task_list.rb

@@ -0,0 +1,19 @@
+module Fog
+  class Vcloud
+    module Terremark
+      class Ecloud
+
+        class Real
+          basic_request :get_task_list
+        end
+
+        class Mock
+          def get_task_list(task_list_uri)
+            Fog::Mock.not_implemented
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/fog/vcloud/terremark/ecloud/requests/get_vapp.rb

@@ -0,0 +1,101 @@
+module Fog
+  class Vcloud
+    module Terremark
+      class Ecloud
+
+        class Real
+          basic_request :get_vapp
+        end
+
+        class Mock
+          def return_vapp_as_creating!(name)
+            vapps_to_return_as_creating[name] = true
+          end
+
+          def vapps_to_return_as_creating
+            @vapps_to_return_as_creating ||= {}
+          end
+
+          def get_vapp(vapp_uri)
+            xml = nil
+
+            if vapp = mock_data.virtual_machine_from_href(vapp_uri)
+              if vapps_to_return_as_creating[vapp.name]
+                xml = generate_instantiate_vapp_template_response(vapp)
+              else
+                xml = generate_get_vapp_response(vapp)
+              end
+            end
+
+            if xml
+              mock_it 200, xml, "Content-Type" => "application/vnd.vmware.vcloud.vApp+xml"
+            else
+              mock_error 200, "401 Unauthorized"
+            end
+          end
+
+          private
+
+          def generate_get_vapp_response(vapp)
+            builder = Builder::XmlMarkup.new
+            builder.VApp(xmlns.merge(
+                                     :href => vapp.href,
+                                     :type => "application/vnd.vmware.vcloud.vApp+xml",
+                                     :name => vapp.name,
+                                     :status => vapp.status,
+                                     :size => vapp.size
+                                     )) do
+              builder.Link(:rel => "up", :href => vapp._parent.href, :type => "application/vnd.vmware.vcloud.vdc+xml")
+
+              builder.NetworkConnectionSection(:xmlns => "http://schemas.dmtf.org/ovf/envelope/1") do
+                builder.NetworkConnection(:Network => "Internal", :xmlns => "http://www.vmware.com/vcloud/v0.8") do
+                  builder.IpAddress vapp.ip
+                end
+              end
+
+              builder.OperatingSystemSection(
+                                             "d2p1:id" => 4,
+                                             :xmlns => "http://schemas.dmtf.org/ovf/envelope/1",
+                                             "xmlns:d2p1" => "http://schemas.dmtf.org/ovf/envelope/1") do
+                builder.Info "The kind of installed guest operating system"
+                builder.Description "Red Hat Enterprise Linux 5 (64-bit)"
+              end
+
+              builder.VirtualHardwareSection(:xmlns => "http://schemas.dmtf.org/ovf/envelope/1") do
+                builder.Info
+                builder.System
+                builder.Item do
+                  # CPUs
+                  builder.VirtualQuantity vapp.cpus
+                  builder.ResourceType 3
+                end
+                builder.Item do
+                  # memory
+                  builder.VirtualQuantity vapp.memory
+                  builder.ResourceType 4
+                end
+                builder.Item do
+                  # SCSI controller
+                  builder.Address 0
+                  builder.ResourceType 6
+                  builder.InstanceId 3
+                end
+
+                # Hard Disks
+                vapp.disks.each do |disk|
+                  builder.Item do
+                    builder.Parent 3
+                    builder.VirtualQuantity disk.vcloud_size
+                    builder.HostResource disk.vcloud_size
+                    builder.ResourceType 17
+                    builder.AddressOnParent disk.address
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/vcloud/terremark/ecloud/requests/get_vapp_template.rb

@@ -0,0 +1,18 @@
+module Fog
+  class Vcloud
+    module Terremark
+      class Ecloud
+
+        class Real
+          basic_request :get_vapp_template
+        end
+
+        class Mock
+          def get_vapp_template(templace_uri)
+            Fog::Mock.not_implemented
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/vcloud/terremark/ecloud/requests/get_vdc.rb

@@ -0,0 +1,87 @@
+module Fog
+  class Vcloud
+    module Terremark
+      class Ecloud
+
+        class Real
+          # Handled by the main Vcloud get_vdc
+        end
+
+        class Mock
+          #
+          #Based off of:
+          #http://support.theenterprisecloud.com/kb/default.asp?id=545&Lang=1&SID=
+
+          def get_vdc(vdc_uri)
+            vdc_uri = ensure_unparsed(vdc_uri)
+
+            if vdc = mock_data.vdc_from_href(vdc_uri)
+              xml = Builder::XmlMarkup.new
+              mock_it 200,
+              xml.Vdc(xmlns.merge(:href => vdc.href, :name => vdc.name)) {
+                xml.Link(:rel => "down",
+                         :href => vdc.catalog.href,
+                         :type => "application/vnd.vmware.vcloud.catalog+xml",
+                         :name => vdc.catalog.name)
+                xml.Link(:rel => "down",
+                         :href => vdc.public_ip_collection.href,
+                         :type => "application/vnd.tmrk.ecloud.publicIpsList+xml",
+                         :name => vdc.public_ip_collection.name)
+                xml.Link(:rel => "down",
+                         :href => vdc.internet_service_collection.href,
+                         :type => "application/vnd.tmrk.ecloud.internetServicesList+xml",
+                         :name => vdc.internet_service_collection.name)
+                xml.Link(:rel => "down",
+                         :href => vdc.firewall_acls.href,
+                         :type => "application/vnd.tmrk.ecloud.firewallAclsList+xml",
+                         :name => vdc.firewall_acls.name)
+                xml.Description("")
+                xml.StorageCapacity {
+                  xml.Units("bytes * 10^9")
+                  xml.Allocated(vdc.storage_allocated)
+                  xml.Used(vdc.storage_used)
+                }
+                xml.ComputeCapacity {
+                  xml.Cpu {
+                    xml.Units("hz * 10^6")
+                    xml.Allocated(vdc.cpu_allocated)
+                  }
+                  xml.Memory {
+                    xml.Units("bytes * 2^20")
+                    xml.Allocated(vdc.memory_allocated)
+                  }
+                  xml.DeployedVmsQuota {
+                    xml.Limit("-1")
+                    xml.Used("-1")
+                  }
+                  xml.InstantiatedVmsQuota {
+                    xml.Limit("-1")
+                    xml.Used("-1")
+                  }
+                }
+                xml.ResourceEntities {
+                  vdc.virtual_machines.each do |virtual_machine|
+                    xml.ResourceEntity(:href => virtual_machine.href,
+                                       :type => "application/vnd.vmware.vcloud.vApp+xml",
+                                       :name => virtual_machine.name)
+                  end
+                }
+                xml.AvailableNetworks {
+                  vdc.networks.each do |network|
+                    xml.Network(:href => network.href,
+                                :type => "application/vnd.vmware.vcloud.network+xml",
+                                :name => network.name)
+                  end
+                }
+              }, { 'Content-Type' => 'application/vnd.vmware.vcloud.vdc+xml'}
+            else
+              mock_error 200, "401 Unauthorized"
+            end
+          end
+
+        end
+      end
+    end
+  end
+end
+

data/lib/fog/vcloud/terremark/ecloud/requests/instantiate_vapp_template.rb

@@ -0,0 +1,144 @@
+module Fog
+  class Vcloud
+    module Terremark
+      class Ecloud
+        module Shared
+          private
+
+          def validate_instantiate_vapp_template_options(catalog_item_uri, options)
+            valid_opts = [:name, :vdc_uri, :network_uri, :cpus, :memory, :row, :group]
+            unless valid_opts.all? { |opt| options.keys.include?(opt) }
+              raise ArgumentError.new("Required data missing: #{(valid_opts - options.keys).map(&:inspect).join(", ")}")
+            end
+
+            # Figure out the template_uri
+            catalog_item = get_catalog_item( catalog_item_uri ).body
+            catalog_item[:Entity] = [ catalog_item[:Entity] ] if catalog_item[:Entity].is_a?(Hash)
+            catalog_item[:Link] = [ catalog_item[:Link] ] if catalog_item[:Link].is_a?(Hash)
+
+            options[:template_uri] = begin
+               catalog_item[:Entity].detect { |entity| entity[:type] == "application/vnd.vmware.vcloud.vAppTemplate+xml" }[:href]
+            rescue
+              raise RuntimeError.new("Unable to locate template uri for #{catalog_item_uri}")
+            end
+
+            customization_options = begin
+                customization_href = catalog_item[:Link].detect { |link| link[:type] == "application/vnd.tmrk.ecloud.catalogItemCustomizationParameters+xml" }[:href]
+                get_customization_options( customization_href ).body
+            rescue
+              raise RuntimeError.new("Unable to get customization options for #{catalog_item_uri}")
+            end
+
+            # Check to see if we can set the password
+            if options[:password] and customization_options[:CustomizePassword] == "false"
+              raise ArgumentError.new("This catalog item (#{catalog_item_uri}) does not allow setting a password.")
+            end
+
+            # According to the docs if CustomizePassword is "true" then we NEED to set a password
+            if customization_options[:CustomizePassword] == "true" and ( options[:password].nil? or options[:password].empty? )
+              raise ArgumentError.new("This catalog item (#{catalog_item_uri}) requires a :password to instantiate.")
+            end
+          end
+
+          def generate_instantiate_vapp_template_request(options)
+            xml = Builder::XmlMarkup.new
+            xml.InstantiateVAppTemplateParams(xmlns.merge!(:name => options[:name], :"xml:lang" => "en")) {
+              xml.VAppTemplate(:href => options[:template_uri])
+              xml.InstantiationParams {
+                xml.ProductSection( :"xmlns:q1" => "http://www.vmware.com/vcloud/v0.8", :"xmlns:ovf" => "http://schemas.dmtf.org/ovf/envelope/1") {
+                  if options[:password]
+                    xml.Property( :xmlns => "http://schemas.dmtf.org/ovf/envelope/1", :"ovf:key" => "password", :"ovf:value" => options[:password] )
+                  end
+                  xml.Property( :xmlns => "http://schemas.dmtf.org/ovf/envelope/1", :"ovf:key" => "row", :"ovf:value" => options[:row] )
+                  xml.Property( :xmlns => "http://schemas.dmtf.org/ovf/envelope/1", :"ovf:key" => "group", :"ovf:value" => options[:group] )
+                }
+                xml.VirtualHardwareSection( :"xmlns:q1" => "http://www.vmware.com/vcloud/v0.8" ) {
+                  # # of CPUS
+                  xml.Item( :xmlns => "http://schemas.dmtf.org/ovf/envelope/1" ) {
+                    xml.InstanceID(1, :xmlns => "http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData")
+                    xml.ResourceType(3, :xmlns => "http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData")
+                    xml.VirtualQuantity(options[:cpus], :xmlns => "http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData")
+                  }
+                  # Memory
+                  xml.Item( :xmlns => "http://schemas.dmtf.org/ovf/envelope/1" ) {
+                    xml.InstanceID(2, :xmlns => "http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData")
+                    xml.ResourceType(4, :xmlns => "http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData")
+                    xml.VirtualQuantity(options[:memory], :xmlns => "http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData")
+                  }
+                }
+                xml.NetworkConfigSection {
+                  xml.NetworkConfig {
+                    xml.NetworkAssociation( :href => options[:network_uri] )
+                  }
+                }
+              }
+            }
+          end
+        end
+
+        class Real
+          include Shared
+
+          def instantiate_vapp_template(catalog_item_uri, options = {})
+            validate_instantiate_vapp_template_options(catalog_item_uri, options)
+
+            request(
+              :body     => generate_instantiate_vapp_template_request(options),
+              :expects  => 200,
+              :headers  => {'Content-Type' => 'application/vnd.vmware.vcloud.instantiateVAppTemplateParams+xml'},
+              :method   => 'POST',
+              :uri      => options[:vdc_uri] + '/action/instantiatevAppTemplate',
+              :parse    => true
+            )
+          end
+        end
+
+        class Mock
+          include Shared
+
+          #
+          # Based on
+          # http://support.theenterprisecloud.com/kb/default.asp?id=554&Lang=1&SID=
+          #
+
+          def instantiate_vapp_template(catalog_item_uri, options = {})
+            validate_instantiate_vapp_template_options(catalog_item_uri, options)
+            catalog_item = mock_data.catalog_item_from_href(catalog_item_uri)
+
+            xml = nil
+            if vdc = mock_data.vdc_from_href(options[:vdc_uri])
+              if network = mock_data.network_from_href(options[:network_uri])
+                new_vm = MockVirtualMachine.new({ :name => options[:name], :ip => network.random_ip, :cpus => options[:cpus], :memory => options[:memory] }, vdc)
+                new_vm.disks.push(*catalog_item.disks.dup)
+                vdc.virtual_machines << new_vm
+
+                xml = generate_instantiate_vapp_template_response(new_vm)
+              end
+            end
+
+            if xml
+              mock_it 200, xml, {'Content-Type' => 'application/xml'}
+            else
+              mock_error 200, "401 Unauthorized"
+            end
+          end
+
+          private
+
+          def generate_instantiate_vapp_template_response(vapp)
+            builder = Builder::XmlMarkup.new
+            builder.VApp(xmlns.merge(
+                                     :href => vapp.href,
+                                     :type => "application/vnd.vmware.vcloud.vApp+xml",
+                                     :name => vapp.name,
+                                     :status => 0,
+                                     :size => 4
+                                     )) {
+              builder.Link(:rel => "up", :href => vapp._parent.href, :type => "application/vnd.vmware.vcloud.vdc+xml")
+            }
+          end
+        end
+      end
+    end
+  end
+end