tecnh-fog 0.2.23.vpc

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

@@ -0,0 +1,93 @@
+module Fog
+  module Vcloud
+    module Terremark
+      module Ecloud
+        module Real
+
+          def generate_internet_service_response(service_data,ip_address_data)
+            builder = Builder::XmlMarkup.new
+            builder.InternetService(:"xmlns:i" => "http://www.w3.org/2001/XMLSchema-instance",
+                                    :xmlns => "urn:tmrk:eCloudExtensions-2.3") {
+              builder.Id(service_data[:id])
+              builder.Href(service_data[:href].to_s)
+              builder.Name(service_data[:name])
+              builder.Protocol(service_data[:protocol])
+              builder.Port(service_data[:port])
+              builder.Enabled(service_data[:enabled])
+              builder.Description(service_data[:description])
+              builder.Timeout(service_data[:timeout])
+              builder.RedirectURL(service_data[:redirect_url])
+              builder.PublicIpAddress {
+                builder.Id(ip_address_data[:id])
+                builder.Href(ip_address_data[:href].to_s)
+                builder.Name(ip_address_data[:name])
+              }
+              if monitor = service_data[:monitor]
+                generate_monitor_section(builder,monitor)
+              end
+            }
+          end
+
+          def validate_public_ip_address_data(ip_address_data)
+            valid_opts = [:name, :href, :id]
+            unless valid_opts.all? { |opt| ip_address_data.keys.include?(opt) }
+              raise ArgumentError.new("Required Internet Service data missing: #{(valid_opts - ip_address_data.keys).map(&:inspect).join(", ")}")
+            end
+          end
+
+          def configure_internet_service(internet_service_uri, service_data, ip_address_data)
+            validate_internet_service_data(service_data, true)
+
+            validate_public_ip_address_data(ip_address_data)
+
+            if monitor = service_data[:monitor]
+              validate_internet_service_monitor(monitor)
+              ensure_monitor_defaults!(monitor)
+            end
+
+            request(
+              :body     => generate_internet_service_response(service_data, ip_address_data),
+              :expects  => 200,
+              :headers  => {'Content-Type' => 'application/vnd.tmrk.ecloud.internetService+xml'},
+              :method   => 'PUT',
+              :uri      => internet_service_uri,
+              :parse    => true
+            )
+          end
+
+        end
+
+        module Mock
+          #
+          # Based on
+          # http://support.theenterprisecloud.com/kb/default.asp?id=583&Lang=1&SID=
+          #
+
+          def configure_internet_service(internet_service_uri, service_data, ip_address_data)
+            validate_internet_service_data(service_data, true)
+
+            validate_public_ip_address_data(ip_address_data)
+
+            internet_service_uri = ensure_unparsed(internet_service_uri)
+
+            xml = nil
+
+            if ip = ip_from_uri(ip_address_data[:href])
+              if service = ip[:services].detect { |service| service[:id] == internet_service_uri.split('/')[-1] }
+                ip[:services][ip[:services].index(service)] = service_data
+                xml = generate_internet_service_response(service_data, ip)
+              end
+            end
+
+            if xml
+              mock_it 200, xml, {'Content-Type' => 'application/vnd.tmrk.ecloud.internetService+xml'}
+            else
+              mock_error 200, "401 Unauthorized"
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,54 @@
+module Fog
+  module Vcloud
+    module Terremark
+      module Ecloud
+        module Real
+
+          def validate_network_data(network_data, configure=false)
+            valid_opts = [:id, :href, :name, :rnat, :address, :broadcast, :gateway]
+            unless valid_opts.all? { |opt| network_data.keys.include?(opt) }
+              raise ArgumentError.new("Required data missing: #{(valid_opts - network_data.keys).map(&:inspect).join(", ")}")
+            end
+          end
+
+          def configure_network(network_uri, network_data)
+            validate_network_data(network_data)
+
+            request(
+              :body     => generate_configure_network_request(network_data),
+              :expects  => 200,
+              :headers  => {'Content-Type' => 'application/vnd.tmrk.ecloud.networkService+xml'},
+              :method   => 'PUT',
+              :uri      => network_uri,
+              :parse    => true
+            )
+          end
+
+          private
+
+          def generate_configure_network_request(network_data)
+            builder = Builder::XmlMarkup.new
+            builder.Network(:"xmlns:i" => "http://www.w3.org/2001/XMLSchema-instance",
+                            :xmlns => "urn:tmrk:eCloudExtensions-2.3") {
+              builder.Id(network_data[:id])
+              builder.Href(network_data[:href])
+              builder.Name(network_data[:name])
+              builder.RnatAddress(network_data[:rnat])
+              builder.Address(network_data[:address])
+              builder.BroadcastAddress(network_data[:broadcast])
+              builder.GatewayAddress(network_data[:gateway])
+            }
+          end
+
+        end
+
+        module Mock
+
+          def configure_network(network_uri, network_data)
+            Fog::Mock.not_implemented
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+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,
+              :parse    => true
+            )
+          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,54 @@
+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,
+              :parse    => true
+            )
+          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)
+            node_uri = ensure_unparsed(node_uri)
+
+            validate_node_data(node_data, true)
+
+            if node = mock_node_from_url(node_uri)
+              node[:name] = node_data[:name]
+              node[:enabled] = node_data[:enabled]
+              node[:description] = node_data[:description]
+              mock_it 200, mock_node_service_response(node, ecloud_xmlns), { '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,116 @@
+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,
+              :parse    => true
+            )
+          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

@@ -0,0 +1,33 @@
+module Fog
+  module Vcloud
+    module Terremark
+      module Ecloud
+
+        module Real
+          basic_request :delete_internet_service, 200, 'DELETE', {}, ""
+        end
+
+        module Mock
+
+          def delete_internet_service(service_uri)
+
+            deleted = false
+            if ip = mock_ip_from_service_url(service_uri)
+              if service = ip[:services].detect { |service| service[:href] == service_uri }
+                ip[:services].delete(service)
+                deleted = true
+              end
+            end
+
+            if deleted
+              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,28 @@
+module Fog
+  module Vcloud
+    module Terremark
+      module Ecloud
+
+        module Real
+          basic_request :delete_node, 200, 'DELETE', {}, ""
+        end
+
+        module Mock
+
+          def delete_node(node_uri)
+            node_uri = ensure_unparsed(node_uri)
+
+            node = mock_node_from_url(node_uri)
+            service = mock_service_from_node_url(node_uri)
+            if node and service
+              service[:nodes].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,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
+