fog 0.2.0 → 0.2.1

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

@@ -0,0 +1,52 @@
+module Fog
+  module Vcloud
+    module Terremark
+      module Ecloud
+        module Real
+
+          def validate_network_ip_data(network_ip_data, configure=false)
+            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
+
+          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
+            )
+          end
+
+          private
+
+          def generate_configure_network_ip_request(network_ip_data)
+            builder = Builder::XmlMarkup.new
+            builder.IpAddress(:"xmlns:i" => "http://www.w3.org/2001/XMLSchema-instance",
+                              :xmlns => "urn:tmrk:eCloudExtensions-2.3") {
+              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
+
+        module Mock
+
+          def configure_network_ip(network_ip_uri, network_ip_data)
+            Fog::Mock.not_implemented
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+module Fog
+  module Vcloud
+    module Terremark
+      module Ecloud
+        module Real
+
+          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
+            )
+          end
+
+          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
+
+        module Mock
+
+          def configure_node(node_uri, node_data)
+            Fog::Mock.not_implemented
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,115 @@
+module Fog
+  module Vcloud
+    module Terremark
+      module Ecloud
+        module Real
+
+          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 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
+
+          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
+            )
+          end
+
+        end
+
+        module Mock
+          def configure_vapp(vapp_uri, vapp_data)
+            Fog::Mock.not_implemented
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -2,34 +2,15 @@ module Fog
   module Vcloud
     module Terremark
       module Ecloud
-        module Real
-
-          def delete_internet_service(internet_service_uri)
-            request(
-              :body     => "",
-              :expects  => 200,
-              #:headers  => {'Content-Type' => 'application/vnd.tmrk.ecloud.internetService+xml'},
-              :method   => 'DELETE',
-              :uri      => internet_service_uri
-            )
-          end
 
+        module Real
+          basic_request :delete_node, 200, 'DELETE', {}, ""
         end
 
         module Mock
-          #
-          # Based on
-          # http://support.theenterprisecloud.com/kb/default.asp?id=561&Lang=1&SID=
-          #
 
-          def delete_internet_service(internet_service_uri)
-            if service = Fog::Vcloud::Mock.data[:organizations].map { |org| org[:vdcs].map { |vdc| vdc[:public_ips].map { |public_ip| public_ip[:services].map { |service| service } } } }.
-              flatten.detect { |service| service[:id].to_s == internet_service_uri.to_s.split('/')[-1] }
-              Fog::Vcloud::Mock.data[:organizations].map { |org| org[:vdcs].map { |vdc| vdc[:public_ips].map { |public_ip| public_ip[:services].delete(service) } } }
-              mock_it nil, 200, "", {}
-            else
-              mock_error 200, "401 Unauthorized"
-            end
+          def delete_node(node_uri)
+            Fog::Mock.not_implemented
           end
         end
       end

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

@@ -0,0 +1,19 @@
+module Fog
+  module Vcloud
+    module Terremark
+      module Ecloud
+
+        module Real
+          basic_request :delete_vapp, 202, "DELETE"
+        end
+
+        module Mock
+          def delete_vapp(vapp_uri)
+            Fog::Mock.not_implemented
+          end
+        end
+      end
+    end
+  end
+end
+

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

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

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

@@ -0,0 +1,18 @@
+module Fog
+  module Vcloud
+    module Terremark
+      module Ecloud
+
+        module Real
+          basic_request :get_catalog_item
+        end
+
+        module Mock
+          def get_catalog(catalog_uri)
+            Fog::Mock.not_implemented
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -4,15 +4,7 @@ module Fog
       module Ecloud
 
         module Real
-
-          def get_internet_services(internet_services_uri)
-            request(
-              :expects  => 200,
-              :method   => 'GET',
-              :parser   => Fog::Parsers::Vcloud::Terremark::Ecloud::GetInternetServices.new,
-              :uri      => internet_services_uri
-            )
-          end
+          basic_request :get_internet_services
         end
 
         module Mock
@@ -39,28 +31,29 @@ module Fog
                 xml.Enabled(service[:enabled])
                 xml.Timeout(service[:timeout])
                 xml.Description(service[:description])
-                xml.UrlSendString
-                xml.HttpHeader
+                xml.RedirectURL
+                xml.Monitor
               }
             end
           end
 
           def get_internet_services(internet_services_uri)
+            internet_services_uri = ensure_unparsed(internet_services_uri)
             xml = nil
             builder = Builder::XmlMarkup.new
-            if vdc = Fog::Vcloud::Mock.vdc_from_uri(internet_services_uri)
-              xml = builder.InternetServices( :xmlns => "urn:tmrk:eCloudExtensions-2.0",:"xmlns:i" => "http://www.w3.org/2001/XMLSchema-instance" ) { |xml|
+            if vdc = vdc_from_uri(internet_services_uri)
+              xml = builder.InternetServices( :xmlns => "urn:tmrk:eCloudExtensions-2.3",:"xmlns:i" => "http://www.w3.org/2001/XMLSchema-instance" ) { |xml|
                 vdc[:public_ips].each do |ip|
                   Fog::Vcloud::Terremark::Ecloud::Mock.internet_services_for_ip(xml,ip)
                 end
               }
-            elsif ip = Fog::Vcloud::Mock.ip_from_uri(internet_services_uri)
-              xml = builder.InternetServices( :xmlns => "urn:tmrk:eCloudExtensions-2.0",:"xmlns:i" => "http://www.w3.org/2001/XMLSchema-instance" ) { |xml|
+            elsif ip = ip_from_uri(internet_services_uri)
+              xml = builder.InternetServices( :xmlns => "urn:tmrk:eCloudExtensions-2.3",:"xmlns:i" => "http://www.w3.org/2001/XMLSchema-instance" ) { |xml|
                 Fog::Vcloud::Terremark::Ecloud::Mock.internet_services_for_ip(xml,ip)
               }
             end
             if xml
-              mock_it Fog::Parsers::Vcloud::Terremark::Ecloud::GetInternetServices.new, 200,
+              mock_it 200,
                 xml, { 'Content-Type' => 'application/vnd.tmrk.ecloud.internetServicesList+xml' }
             else
               mock_error 200, "401 Unauthorized"

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

@@ -2,17 +2,9 @@ module Fog
   module Vcloud
     module Terremark
       module Ecloud
-        module Real
-
-          def get_network(network_uri)
-           request(
-              :expects  => 200,
-              :method   => 'GET',
-              :parser   => Fog::Parsers::Vcloud::Terremark::Ecloud::Network.new,
-              :uri      => network_uri
-            )
-          end
 
+        module Real
+          # Handled by the main Vcloud get_network
         end
 
         module Mock
@@ -22,21 +14,23 @@ module Fog
             # Based off of:
             # http://support.theenterprisecloud.com/kb/default.asp?id=546&Lang=1&SID=
             #
+            network_uri = ensure_unparsed(network_uri)
             type = "application/vnd.vmware.vcloud.network+xml"
             response = Excon::Response.new
-            if network = mock_data[:organizations].map { |org| org[:vdcs].map { |vdc| vdc[:networks] } }.flatten.detect { |network| network[:href] == network_uri.to_s }
+            if network = mock_data[:organizations].map { |org| org[:vdcs].map { |vdc| vdc[:networks] } }.flatten.detect { |network| network[:href] == network_uri }
               xml = Builder::XmlMarkup.new
-              mock_it Fog::Parsers::Vcloud::Terremark::Ecloud::Network.new, 200,
+              mock_it 200,
                 xml.Network(xmlns.merge(:href => network[:href], :name => network[:name], :type => type)) {
                   xml.Link( :rel => "down", :href => network[:href] + "/ips", :type => "application/xml", :name => "IP Addresses" )
+                  xml.Link( :rel => "down", :href => network[:extension_href], :type => "application/xml", :name => network[:name] )
                   xml.Configuration {
                     xml.Gateway(network[:gateway])
                     xml.Netmask(network[:netmask])
                   }
                   if network[:features]
                     xml.Features {
-                      if feature = network[:features].detect { |feature| feature[:type] == :fencemode }
-                        xml.FenceMode(feature[:value])
+                      network[:features].each do |feature|
+                        eval "xml.#{feature[:type].to_sym}('#{feature[:value]}')"
                       end
                     }
                   end

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

@@ -0,0 +1,36 @@
+module Fog
+  module Vcloud
+    module Terremark
+      module Ecloud
+
+        module Real
+          basic_request :get_network_extensions
+        end
+
+        module Mock
+
+          def get_network_extensions(network_uri)
+            network_uri = ensure_unparsed(network_uri)
+            type = "application/vnd.vmware.vcloud.network+xml"
+            response = Excon::Response.new
+            if network = mock_data[:organizations].map { |org| org[:vdcs].map { |vdc| vdc[:networks] } }.flatten.detect { |network| network[:extension_href] == network_uri }
+              xml = Builder::XmlMarkup.new
+              mock_it 200,
+                xml.Network(:xmlns => "urn:tmrk:eCloudExtensions-2.3", :"xmlns:i" => "http://www.w3.org/2001/XMLSchema-instance") {
+                  xml.Address(network[:name].split("/")[0])
+                  xml.RnatAddress(network[:rnat])
+                  xml.Href(network[:extension_href])
+                  xml.Id(network[:id])
+                  xml.Name(network[:name])
+                  xml.GatewayAddress(network[:gateway])
+                  xml.BroadcastAddress(IPAddr.new(network[:subnet]).to_range.last.to_s)
+                }, { 'Content-Type' => type }
+            else
+              mock_error 200, "401 Unauthorized"
+            end
+          end
+        end
+      end
+    end
+  end
+end