fog 0.5.3 → 0.6.0

data/lib/fog/compute/requests/ecloud/clone_vapp.rb

@@ -0,0 +1,40 @@
+module Fog
+  module Ecloud
+    class Compute
+      class Real
+
+        def validate_clone_vapp_options(options)
+          valid_opts = [:name, :poweron]
+          unless valid_opts.all? { |opt| options.keys.include?(opt) }
+            raise ArgumentError.new("Required data missing: #{(valid_opts - options.keys).map(&:inspect).join(", ")}")
+          end
+        end
+
+        def generate_clone_vapp_request(uri, options)
+          xml = Builder::XmlMarkup.new
+          xml.CloneVAppParams(xmlns.merge!(:name => options[:name], :deploy => "true", :powerOn => options[:poweron])) {
+            xml.VApp( :href => uri, :type => "application/vnd.vmware.vcloud.vApp+xml",
+                      :xmlns => "http://www.vmware.com/vcloud/v0.8")
+          }
+        end
+
+        def clone_vapp(vdc_uri, vapp_uri, options = {})
+          unless options.has_key?(:poweron)
+            options[:poweron] = "false"
+          end
+
+          validate_clone_vapp_options(options)
+
+          request(
+            :body     => generate_clone_vapp_request(vapp_uri, options),
+            :expects  => 202,
+            :headers  => {'Content-Type' => 'application/vnd.vmware.vcloud.cloneVAppParams+xml'},
+            :method   => 'POST',
+            :uri      => vdc_uri + '/action/clonevapp',
+            :parse    => true
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/requests/ecloud/configure_internet_service.rb

@@ -0,0 +1,112 @@
+module Fog
+  module Ecloud
+    class Compute
+      module Shared
+        private
+
+        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
+      end
+
+      class Real
+        include Shared
+
+        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_configure_internet_service_request(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
+
+        private
+
+        def generate_configure_internet_service_request(service_data, ip_address_data)
+          builder = Builder::XmlMarkup.new
+          builder.InternetService(ecloud_xmlns) {
+            builder.Id(service_data[:id])
+            builder.Href(service_data[:href])
+            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])
+              builder.Name(ip_address_data[:name])
+            }
+            if monitor = service_data[:monitor]
+              generate_monitor_section(builder, monitor)
+            end
+            if service_data[:backup_service_uri]
+              builder.BackupService do
+                builder.Href(service_data[:backup_service_uri])
+              end
+            end
+          }
+        end
+      end
+
+      class Mock
+        include Shared
+
+        #
+        # 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)
+          service_data = service_data.dup
+
+          validate_internet_service_data(service_data, true)
+
+          if monitor = service_data[:monitor]
+            validate_internet_service_monitor(monitor)
+            ensure_monitor_defaults!(monitor)
+          end
+
+          validate_public_ip_address_data(ip_address_data)
+
+          internet_service_uri = ensure_unparsed(internet_service_uri)
+
+          backup_service_uri = service_data.delete(:backup_service_uri)
+          backup_service = backup_service_uri && mock_data.backup_internet_service_from_href(backup_service_uri)
+
+          xml = nil
+
+          if (public_ip_internet_service = mock_data.public_ip_internet_service_from_href(internet_service_uri)) &&
+              (backup_service_uri.nil? || backup_service)
+            public_ip_internet_service.update(service_data.reject {|k, v| [:id, :href].include?(k) })
+            public_ip_internet_service[:backup_service] = backup_service
+            xml = generate_internet_service(Builder::XmlMarkup.new, public_ip_internet_service, true)
+          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

data/lib/fog/compute/requests/ecloud/configure_network.rb

@@ -0,0 +1,44 @@
+module Fog
+  module Ecloud
+    class Compute
+      class 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(ecloud_xmlns) {
+            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
+    end
+  end
+end

data/lib/fog/compute/requests/ecloud/configure_network_ip.rb

@@ -0,0 +1,66 @@
+module Fog
+  module Ecloud
+    class Compute
+      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

data/lib/fog/compute/requests/ecloud/configure_node.rb

@@ -0,0 +1,56 @@
+module Fog
+  module Ecloud
+    class Compute
+      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

data/lib/fog/compute/requests/ecloud/configure_vapp.rb

@@ -0,0 +1,144 @@
+module Fog
+  module Ecloud
+    class Compute
+      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