phpfog-fog 0.4.1

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

@@ -0,0 +1,68 @@
+module Fog
+  class Vcloud
+    module Terremark
+      class Ecloud
+        module Shared
+          private
+
+          def validate_network_ip_data(network_ip_data)
+            valid_opts = [:id, :href, :name, :status, :server, :rnat]
+            unless valid_opts.all? { |opt| network_ip_data.keys.include?(opt) }
+              raise ArgumentError.new("Required data missing: #{(valid_opts - network_ip_data.keys).map(&:inspect).join(", ")}")
+            end
+          end
+        end
+
+        class Real
+          include Shared
+
+          def configure_network_ip(network_ip_uri, network_ip_data)
+            validate_network_ip_data(network_ip_data)
+
+            request(
+              :body     => generate_configure_network_ip_request(network_ip_data),
+              :expects  => 200,
+              :headers  => {'Content-Type' => 'application/vnd.tmrk.ecloud.ip+xml' },
+              :method   => 'PUT',
+              :uri      => network_ip_uri,
+              :parse    => true
+            )
+          end
+
+          private
+
+          def generate_configure_network_ip_request(network_ip_data)
+            builder = Builder::XmlMarkup.new
+            builder.IpAddress(ecloud_xmlns) {
+              builder.Id(network_ip_data[:id])
+              builder.Href(network_ip_data[:href])
+              builder.Name(network_ip_data[:name])
+              builder.Status(network_ip_data[:status])
+              builder.Server(network_ip_data[:server])
+              builder.RnatAddress(network_ip_data[:rnat])
+            }
+          end
+        end
+
+        class Mock
+          include Shared
+
+          def configure_network_ip(network_ip_uri, network_ip_data)
+            validate_network_ip_data(network_ip_data)
+
+            if network_ip = mock_data.network_ip_from_href(network_ip_uri)
+              network_ip[:rnat] = network_ip_data[:rnat]
+
+              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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+module Fog
+  class Vcloud
+    module Terremark
+      class Ecloud
+        module Shared
+          private
+
+          def generate_configure_node_request(node_data)
+            builder = Builder::XmlMarkup.new
+            builder.NodeService(:"xmlns:i" => "http://www.w3.org/2001/XMLSchema-instance",
+                                    :xmlns => "urn:tmrk:eCloudExtensions-2.0") {
+              builder.Name(node_data[:name])
+              builder.Enabled(node_data[:enabled].to_s)
+              builder.Description(node_data[:description])
+            }
+          end
+
+        end
+
+        class Real
+          include Shared
+
+          def configure_node(node_uri, node_data)
+            validate_node_data(node_data, true)
+
+            request(
+              :body     => generate_configure_node_request(node_data),
+              :expects  => 200,
+              :headers  => {'Content-Type' => 'application/vnd.tmrk.ecloud.nodeService+xml'},
+              :method   => 'PUT',
+              :uri      => node_uri,
+              :parse    => true
+            )
+          end
+
+        end
+
+        class Mock
+          include Shared
+
+          def configure_node(node_uri, node_data)
+            validate_node_data(node_data, true)
+
+            if node = mock_data.public_ip_internet_service_node_from_href(ensure_unparsed(node_uri))
+              node.update(node_data)
+              #if node_data[:enabled] 
+              #  node.enabled = (node_data[:enabled] == "true") ? true : false
+              #end
+              mock_it 200, mock_node_service_response(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/configure_vapp.rb

@@ -0,0 +1,147 @@
+module Fog
+  class Vcloud
+    module Terremark
+      class Ecloud
+        module Shared
+          private
+
+          def validate_vapp_data(vapp_data)
+            valid_opts = [:name, :cpus, :memory, :disks]
+            unless valid_opts.all? { |opt| vapp_data.keys.include?(opt) }
+              raise ArgumentError.new("Required Vapp data missing: #{(valid_opts - vapp_data.keys).map(&:inspect).join(", ")}")
+            end
+          end
+        end
+
+        class Real
+          include Shared
+
+          def generate_configure_vapp_request(vapp_uri, vapp_data)
+            rasd_xmlns = { "xmlns" => "http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData" }
+
+            xml = Nokogiri::XML(request( :uri => vapp_uri).body)
+            xml.root['name'] = vapp_data[:name]
+
+            #cpu
+            xml.at("//xmlns:ResourceType[.='3']/..", rasd_xmlns).at('.//xmlns:VirtualQuantity', rasd_xmlns).content = vapp_data[:cpus]
+
+            #memory
+            xml.at("//xmlns:ResourceType[.='4']/..", rasd_xmlns).at('.//xmlns:VirtualQuantity', rasd_xmlns).content = vapp_data[:memory]
+
+            #disks
+            real_disks = xml.xpath("//xmlns:ResourceType[ .='17']/..", rasd_xmlns)
+            real_disk_numbers = real_disks.map { |disk| disk.at('.//xmlns:AddressOnParent', rasd_xmlns).content }
+            disk_numbers = vapp_data[:disks].map { |vdisk| vdisk[:number].to_s }
+
+            if vapp_data[:disks].length < real_disks.length
+              #Assume we're removing a disk
+              remove_disk_numbers = real_disk_numbers - disk_numbers
+              remove_disk_numbers.each do |number|
+                if result = xml.at("//xmlns:ResourceType[ .='17']/../xmlns:AddressOnParent[.='#{number}']/..", rasd_xmlns)
+                  result.remove
+                end
+              end
+            elsif vapp_data[:disks].length > real_disks.length
+              add_disk_numbers = disk_numbers - real_disk_numbers
+
+              add_disk_numbers.each do |number|
+                new_disk = real_disks.first.dup
+                new_disk.at('.//xmlns:AddressOnParent', rasd_xmlns).content = -1
+                new_disk.at('.//xmlns:VirtualQuantity', rasd_xmlns).content = vapp_data[:disks].detect { |disk| disk[:number].to_s == number.to_s }[:size]
+                real_disks.first.parent << new_disk
+              end
+            end
+
+            #puts xml.root.to_s
+            xml.root.to_s
+
+            #builder = Builder::XmlMarkup.new
+            #builder.Vapp(:href => vapp_uri.to_s,
+            #             :type => 'application/vnd.vmware.vcloud.vApp+xml',
+            #             :name => vapp_data[:name],
+            #             :status => 2,
+            #             :size => 0,
+            #             :xmlns => 'http://www.vmware.com/vcloud/v0.8',
+            #             :"xmlns:xsi" => 'http://www.w3.org/2001/XMLSchema-instance',
+            #             :"xmlns:xsd" => 'http://www.w3.org/2001/XMLSchema') {
+            #  #builder.VirtualHardwareSection(:xmlns => 'http://schemas.dmtf.org/ovf/envelope/1') {
+            #  builder.Section(:"xsi:type" => "q2:VirtualHardwareSection_Type", :xmlns => "http://schemas.dmtf.org/ovf/envelope/1", :"xmlns:q2" => "http://www.vmware.com/vcloud/v0.8") {
+            #    builder.Info('Virtual Hardware')
+            #    builder.Item(:xmlns => 'http://schemas.dmtf.org/ovf/envelope/1') {
+            #    #builder.Item {
+            #      builder.InstanceID(1, :xmlns => 'http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData')
+            #      builder.ResourceType(3, :xmlns => 'http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData')
+            #      builder.VirtualQuantity(vapp_data[:cpus], :xmlns => 'http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData')
+            #    }
+            #    builder.Item(:xmlns => 'http://schemas.dmtf.org/ovf/envelope/1') {
+            #    #builder.Item {
+            #      builder.InstanceID(2, :xmlns => 'http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData')
+            #      builder.ResourceType(4, :xmlns => 'http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData')
+            #      builder.VirtualQuantity(vapp_data[:memory], :xmlns => 'http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData')
+            #    }
+            #    vapp_data[:disks].each do |disk_data|
+            #      #builder.Item(:xmlns => 'http://schemas.dmtf.org/ovf/envelope/1') {
+            #      builder.Item {
+            #        builder.AddressOnParent(disk_data[:number], :xmlns => 'http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData')
+            #        builder.HostResource(disk_data[:resource], :xmlns => 'http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData')
+            #        builder.InstanceID(9, :xmlns => 'http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData')
+            #        builder.ResourceType(17, :xmlns => 'http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData')
+            #        builder.VirtualQuantity(disk_data[:size], :xmlns => 'http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData')
+            #      }
+            #    end
+            #
+            #  }
+            #}
+          end
+
+          def configure_vapp(vapp_uri, vapp_data)
+            validate_vapp_data(vapp_data)
+
+            request(
+              :body     => generate_configure_vapp_request(vapp_uri, vapp_data),
+              :expects  => 202,
+              :headers  => {'Content-Type' => 'application/vnd.vmware.vcloud.vApp+xml' },
+              :method   => 'PUT',
+              :uri      => vapp_uri,
+              :parse    => true
+            )
+          end
+
+        end
+
+        class Mock
+          include Shared
+
+          def configure_vapp(vapp_uri, vapp_data)
+            validate_vapp_data(vapp_data)
+
+            if vapp = mock_data.virtual_machine_from_href(vapp_uri)
+              vapp_data.each do |key, value|
+                case key
+                when :cpus, :memory
+                  vapp[key] = value
+                when :disks
+                  addresses_to_delete = vapp.disks.map {|d| d.address } - value.map {|d| d[:number] }
+                  addresses_to_delete.each do |address_to_delete|
+                    vapp.disks.delete(vapp.disks.at_address(address_to_delete))
+                  end
+
+                  current_addresses = vapp.disks.map {|d| d.address }
+                  disks_to_add = value.find_all {|d| !current_addresses.include?(d[:number]) }
+                  disks_to_add.each do |disk_to_add|
+                    vapp.disks << MockVirtualMachineDisk.new(:size => disk_to_add[:size] / 1024, :address => disk_to_add[:number])
+                  end
+                end
+              end
+
+              mock_it 200, '', { "Location" => mock_data.base_url + "/some_tasks/1234" }
+            else
+              mock_error 200, "401 Unauthorized"
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,25 @@
+module Fog
+  class Vcloud
+    module Terremark
+      class Ecloud
+
+        class Real
+          basic_request :delete_internet_service, 200, 'DELETE', {}, ""
+        end
+
+        class Mock
+          def delete_internet_service(service_uri)
+            if public_ip_internet_service = mock_data.public_ip_internet_service_from_href(service_uri)
+              public_ip_internet_service._parent.items.delete(public_ip_internet_service)
+
+              mock_it 200, '', { }
+            else
+              mock_error 200, "401 Unauthorized"
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,24 @@
+module Fog
+  class Vcloud
+    module Terremark
+      class Ecloud
+
+        class Real
+          basic_request :delete_node, 200, 'DELETE', {}, ""
+        end
+
+        class Mock
+
+          def delete_node(node_uri)
+            if node = mock_data.public_ip_internet_service_node_from_href(ensure_unparsed(node_uri))
+              node._parent.items.delete(node)
+              mock_it 200, '', {}
+            else
+              mock_error 200, "401 Unauthorized"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module Fog
+  class Vcloud
+    module Terremark
+      class Ecloud
+
+        class Real
+          basic_request :delete_vapp, 202, "DELETE"
+        end
+
+        class Mock
+          def delete_vapp(vapp_uri)
+            if virtual_machine = mock_data.virtual_machine_from_href(vapp_uri)
+              vdc = virtual_machine._parent
+
+              if vdc.internet_service_collection.items.detect {|is| is.node_collection.items.any? {|isn| isn.ip_address == virtual_machine.ip } } ||
+                  virtual_machine.status != 2 ||
+                  virtual_machine.network_ip.rnat_set?
+                mock_it 202, '', {}
+              else
+                vdc.virtual_machines.delete(virtual_machine)
+                mock_it 202, '', { "Location" => mock_data.base_url + "/some_tasks/1234" }
+              end
+            else
+              mock_error 200, "401 Unauthorized"
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,46 @@
+module Fog
+  class Vcloud
+    module Terremark
+      class Ecloud
+
+        class Real
+          basic_request :get_catalog
+        end
+
+        class Mock
+          def get_catalog(catalog_uri)
+            catalog_uri = ensure_unparsed(catalog_uri)
+            xml = nil
+
+            if catalog = mock_data.catalog_from_href(catalog_uri)
+              builder = Builder::XmlMarkup.new
+
+              xml = builder.Catalog(xmlns.merge(
+                                                :type => "application/vnd.vmware.vcloud.catalog+xml",
+                                                :href => catalog.href,
+                                                :name => catalog.name
+                                    )) do |xml|
+                xml.CatalogItems do |xml|
+                  catalog.items.each do |catalog_item|
+                    xml.CatalogItem(
+                                    :type => "application/vnd.vmware.vcloud.catalogItem+xml",
+                                    :href => catalog_item.href,
+                                    :name => catalog_item.name
+                                    )
+                  end
+                end
+              end
+            end
+
+            if xml
+              mock_it 200,
+                xml, { 'Content-Type' => 'application/vnd.vmware.vcloud.catalog+xml' }
+            else
+              mock_error 200, "401 Unauthorized"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+module Fog
+  class Vcloud
+    module Terremark
+      class Ecloud
+
+        class Real
+          basic_request :get_catalog_item
+        end
+
+        class Mock
+
+          #
+          # Based on
+          # http://support.theenterprisecloud.com/kb/default.asp?id=542&Lang=1&SID=
+          #
+
+          def get_catalog_item(catalog_item_uri)
+            if catalog_item = mock_data.catalog_item_from_href(catalog_item_uri)
+              builder = Builder::XmlMarkup.new
+
+              xml = builder.CatalogItem(xmlns.merge(:href => catalog_item.href, :name => catalog_item.name)) do
+                builder.Link(
+                             :rel => "down",
+                             :href => catalog_item.customization.href,
+                             :type => "application/vnd.tmrk.ecloud.catalogItemCustomizationParameters+xml",
+                             :name => catalog_item.customization.name
+                             )
+
+                builder.Entity(
+                               :href => catalog_item.vapp_template.href,
+                               :type => "application/vnd.vmware.vcloud.vAppTemplate+xml",
+                               :name => catalog_item.vapp_template.name
+                               )
+
+                builder.Property(0, :key => "LicensingCost")
+              end
+            end
+
+            if xml
+              mock_it 200, xml, {'Content-Type' => 'application/vnd.vmware.vcloud.catalogItem+xml'}
+            else
+              mock_error 200, "401 Unauthorized"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Fog
+  class Vcloud
+    module Terremark
+      class Ecloud
+
+        class Real
+          basic_request :get_customization_options
+        end
+
+        class Mock
+          def get_customization_options(options_uri)
+            builder = Builder::XmlMarkup.new
+            xml = builder.CustomizationParameters(xmlns) do
+              builder.CustomizeNetwork "true"
+              builder.CustomizePassword "false"
+            end
+
+            mock_it 200, xml, "Content-Type" => "application/vnd.tmrk.ecloud.catalogItemCustomizationParameters+xml"
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

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

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

@@ -0,0 +1,84 @@
+module Fog
+  class Vcloud
+    module Terremark
+      class Ecloud
+
+        class Real
+          basic_request :get_internet_services
+        end
+
+        class Mock
+          #
+          #Based off of:
+          #http://support.theenterprisecloud.com/kb/default.asp?id=580&Lang=1&SID=
+          #http://support.theenterprisecloud.com/kb/default.asp?id=560&Lang=1&SID=
+          #
+          #
+
+          def get_internet_services(internet_services_uri)
+            internet_services_uri = ensure_unparsed(internet_services_uri)
+            xml = nil
+
+            if vdc_internet_service_collection = mock_data.vdc_internet_service_collection_from_href(internet_services_uri)
+              xml = generate_internet_services(vdc_internet_service_collection.items)
+            elsif public_ip_internet_service_collection = mock_data.public_ip_internet_service_collection_from_href(internet_services_uri)
+              xml = generate_internet_services(public_ip_internet_service_collection.items)
+            end
+
+            if xml
+              mock_it 200,
+                xml, { 'Content-Type' => 'application/vnd.tmrk.ecloud.internetServicesList+xml' }
+            else
+              mock_error 200, "401 Unauthorized"
+            end
+          end
+
+          private
+
+          def generate_internet_services(services)
+            builder = Builder::XmlMarkup.new
+
+            builder.InternetServices("xmlns" => "urn:tmrk:eCloudExtensions-2.5", "xmlns:i" => "http://www.w3.org/2001/XMLSchema-instance") {|xml|
+              services.each do |service|
+                generate_internet_service(xml, service)
+              end
+            }
+          end
+
+          def generate_internet_service(xml, service, by_itself = false)
+            xml.InternetService(by_itself ? { "xmlns" => "urn:tmrk:eCloudExtensions-2.5", "xmlns:i" => "http://www.w3.org/2001/XMLSchema-instance" } : {}) {
+              xml.Id service.object_id
+              xml.Href service.href
+              xml.Name service.name
+              if MockDataClasses::MockBackupInternetService === service
+                xml.PublicIpAddress "i:nil" => true
+              else
+                xml.PublicIpAddress {
+                  xml.Id service._parent._parent.object_id
+                  xml.Href service._parent._parent.href
+                  xml.Name service._parent._parent.name
+                }
+              end
+              xml.Port service.port
+              xml.Protocol service.protocol
+              xml.Enabled service.enabled
+              xml.Timeout service.timeout
+              xml.Description service.description
+              xml.RedirectURL service.redirect_url
+              xml.Monitor "i:nil" => true
+              xml.IsBackupService MockDataClasses::MockBackupInternetService === service
+              if MockDataClasses::MockPublicIpInternetService === service && service.backup_service
+                xml.BackupService do
+                  xml.Href service.backup_service.href
+                end
+              else
+                xml.BackupService "i:nil" => true
+              end
+              xml.BackupOf
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+module Fog
+  class Vcloud
+    module Terremark
+      class Ecloud
+
+        class Real
+          # Handled by the main Vcloud get_network
+        end
+
+        class Mock
+          #
+          # Based off of:
+          # http://support.theenterprisecloud.com/kb/default.asp?id=546&Lang=1&SID=
+          #
+
+          def get_network(network_uri)
+            network_uri = ensure_unparsed(network_uri)
+
+            if network = mock_data.network_from_href(network_uri)
+              builder = Builder::XmlMarkup.new
+              xml = builder.Network(xmlns.merge(:href => network.href, :name => network.name, :type => "application/vnd.vmware.vcloud.network+xml")) {
+                builder.Link(:rel => "down", :href => network.ip_collection.href, :type => "application/xml", :name => network.ip_collection.name)
+                builder.Link(:rel => "down", :href => network.extensions.href, :type => "application/xml", :name => network.name)
+                builder.Configuration {
+                  builder.Gateway(network.gateway)
+                  builder.Netmask(network.netmask)
+                }
+                if network.features
+                  builder.Features {
+                    network.features.each do |feature|
+                      builder.tag!(feature[:type], feature[:value])
+                    end
+                  }
+                end
+              }
+
+              mock_it 200, xml, { "Content-Type" => "application/vnd.vmware.vcloud.network+xml" }
+            else
+              mock_error 200, "401 Unauthorized"
+            end
+          end
+        end
+      end
+    end
+  end
+end
+