fog 0.5.3 → 0.6.0

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

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

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

@@ -0,0 +1,48 @@
+module Fog
+  module Ecloud
+    class Compute
+
+      class Real
+
+
+        def login
+          unauthenticated_request({
+            :expects  => 200,
+            :headers  => {
+              'Authorization' => authorization_header
+            },
+            :method   => 'POST',
+            :parse    => true,
+            :uri      => login_uri
+          })
+        end
+
+      end
+
+      class Mock
+
+        def login
+          #
+          # Based off of:
+          # http://support.theenterprisecloud.com/kb/default.asp?id=536&Lang=1&SID=
+          # https://community.vcloudexpress.terremark.com/en-us/product_docs/w/wiki/01-get-login-token.aspx
+          # vCloud API Guide v0.9 - Page 17
+          #
+          xml = Builder::XmlMarkup.new
+
+          mock_it 200,
+            xml.OrgList(xmlns) {
+                mock_data.organizations.each do |organization|
+                  xml.Org( :type => "application/vnd.vmware.vcloud.org+xml", :href => organization.href, :name => organization.name )
+                end
+              },
+              { 'Set-Cookie' => 'vcloud-token=fc020a05-21d7-4f33-9b2a-25d8cd05a44e; path=/',
+                'Content-Type' => 'application/vnd.vmware.vcloud.orgslist+xml' }
+
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Fog
+  module Ecloud
+    class Compute
+
+      class Real
+        basic_request :power_off, 202, 'POST'
+      end
+
+      class Mock
+        def power_off(vapp_uri)
+          if vapp = mock_data.virtual_machine_from_href(vapp_uri)
+            vapp.power_off!
+
+            builder = Builder::XmlMarkup.new
+            mock_it 200, builder.Task(xmlns)
+          else
+            mock_error 200, "401 Unauthorized"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Fog
+  module Ecloud
+    class Compute
+
+      class Real
+        basic_request :power_on, 202, 'POST'
+      end
+
+      class Mock
+        def power_on(vapp_uri)
+          if vapp = mock_data.virtual_machine_from_href(vapp_uri)
+            vapp.power_on!
+
+            builder = Builder::XmlMarkup.new
+            mock_it 200, builder.Task(xmlns)
+          else
+            mock_error 200, "401 Unauthorized"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module Fog
+  module Ecloud
+    class Compute
+
+      class Real
+        basic_request :power_reset, 202, 'POST'
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module Fog
+  module Ecloud
+    class Compute
+
+      class Real
+        basic_request :power_shutdown, 204, 'POST'
+      end
+
+    end
+  end
+end

data/lib/fog/compute/requests/voxel/devices_list.rb

@@ -0,0 +1,24 @@
+module Fog
+  module Voxel
+    class Compute
+      class Real
+
+        require 'fog/compute/parsers/voxel/devices_list'
+
+        def devices_list(device_id = nil)
+          options = {
+            :parser     => Fog::Parsers::Voxel::Compute::DevicesList.new,
+            :verbosity  => 'normal'
+          }
+
+          unless device_id.nil?
+            options[:device_id] = device_id
+          end
+
+          request("voxel.devices.list", options)
+        end
+      end
+
+    end
+  end
+end

data/lib/fog/compute/requests/voxel/devices_power.rb

@@ -0,0 +1,22 @@
+module Fog
+  module Voxel
+    class Compute
+      class Real
+
+        require 'fog/compute/parsers/voxel/basic'
+
+        def devices_power(device_id, power_action)
+          options = {
+            :device_id    => device_id,
+            :parser       => Fog::Parsers::Voxel::Compute::Basic.new,
+            :power_action => power_action,
+            :verbosity    => 'normal'
+          }
+
+          request("voxel.devices.power", options)
+        end
+      end
+
+    end
+  end
+end

data/lib/fog/compute/requests/voxel/images_list.rb

@@ -0,0 +1,31 @@
+module Fog
+  module Voxel
+    class Compute
+      class Real
+
+        require 'fog/compute/parsers/voxel/images_list'
+
+        def images_list(image_id = nil)
+          options = {
+            :parser     => Fog::Parsers::Voxel::Compute::ImagesList.new,
+            :verbosity  => 'compact'
+          }
+
+          unless image_id.nil?
+            options[:verbosity] = 'extended'
+            options[:image_id] = image_id
+          end
+
+          data = request("voxel.images.list", options).body
+
+          if data['stat'] == "ok"
+            data['images']
+          else
+            raise Fog::Voxel::Compute::NotFound
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/fog/compute/requests/voxel/voxcloud_create.rb

@@ -0,0 +1,22 @@
+module Fog
+  module Voxel
+    class Compute
+      class Real
+
+        require 'fog/compute/parsers/voxel/voxcloud_create'
+
+        def voxcloud_create(options)
+          options[:parser] = Fog::Parsers::Voxel::Compute::VoxcloudCreate.new
+
+          if options.has_key?(:password)
+            options[:admin_password] = options[:password]
+            options.delete(:password)
+          end
+
+          request("voxel.voxcloud.create", options)
+        end
+      end
+
+    end
+  end
+end

data/lib/fog/compute/requests/voxel/voxcloud_delete.rb

@@ -0,0 +1,20 @@
+module Fog
+  module Voxel
+    class Compute
+      class Real
+
+        require 'fog/compute/parsers/voxel/voxcloud_delete'
+
+        def voxcloud_delete(device_id)
+          options = {
+            :device_id  => device_id,
+            :parser     => Fog::Parsers::Voxel::Compute::VoxcloudDelete.new
+          }
+
+          request("voxel.voxcloud.delete", options)
+        end
+      end
+
+    end
+  end
+end

data/lib/fog/compute/requests/voxel/voxcloud_status.rb

@@ -0,0 +1,29 @@
+module Fog
+  module Voxel
+    class Compute
+
+      require 'fog/compute/parsers/voxel/voxcloud_status'
+
+      class Real
+        def voxcloud_status(device_id = nil)
+          options = {
+            :parser     => Fog::Parsers::Voxel::Compute::VoxcloudStatus.new,
+            :verbosity  => 'compact'
+          }
+
+          unless device_id.nil?
+            options[:device_id] = device_id
+          end
+
+          request("voxel.voxcloud.status", options)
+        end
+      end
+
+      class Mock
+        def voxcloud_status(device_id = nil)
+          Fog::Mock.not_implemented
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/slicehost.rb

@@ -64,6 +64,8 @@ module Fog
             Formatador.display_line(warning)
           end
 
+          require 'fog/core/parser'
+
           @slicehost_password = options[:slicehost_password]
           @host   = options[:host]    || "api.slicehost.com"
           @port   = options[:port]    || 443

data/lib/fog/compute/voxel.rb

@@ -0,0 +1,112 @@
+module Fog
+  module Voxel
+    class Compute < Fog::Service
+
+      requires :voxel_api_key, :voxel_api_secret
+      recognizes :provider, :host, :port, :scheme, :persistent
+
+      model_path 'fog/compute/models/voxel'
+      model       :image
+      collection  :images
+      model       :server
+      collection  :servers
+
+      request_path 'fog/compute/requests/voxel'
+      request :images_list
+      request :devices_list
+      request :devices_power
+      request :voxcloud_create
+      request :voxcloud_status
+      request :voxcloud_delete
+
+      class Mock
+        include Collections
+
+        def self.data
+          @data ||= {
+            :last_modified => { :servers => {}, :statuses => {}, :images => {} },
+            :servers => [],
+            :statuses => {},
+            :images  => [
+              {'id' => 1,   'name' => "CentOS 4, 32-bit, base install"},
+              {'id' => 2,   'name' => "CentOS 4, 64-bit, base install"},
+              {'id' => 3,   'name' => "CentOS 5, 32-bit, base install"},
+              {'id' => 4,   'name' => "CentOS 5, 64-bit, base install"},
+              {'id' => 7,   'name' => "Fedora 10, 32-bit, base install"},
+              {'id' => 8,   'name' => "Fedora 10, 64-bit, base install"},
+              {'id' => 10,  'name' => "OpenSUSE 11, 64-bit, base install"},
+              {'id' => 11,  'name' => "Debian 5.0 \"lenny\", 32-bit, base install"},
+              {'id' => 12,  'name' => "Debian 5.0 \"lenny\", 64-bit, base install"},
+              {'id' => 13,  'name' => "Ubuntu 8.04 \"Hardy\", 32-bit, base install"},
+              {'id' => 14,  'name' => "Ubuntu 8.04 \"Hardy\", 64-bit, base install"},
+              {'id' => 15,  'name' => "Voxel Server Environment (VSE), 32-bit, base install"},
+              {'id' => 16,  'name' => "Voxel Server Environment (VSE), 64-bit, base install"},
+              {'id' => 32,  'name' => "Pantheon Official Mercury Stack for Drupal (based on VSE/64)"},
+              {'id' => 55,  'name' => "Ubuntu 10.04 \"Lucid\", 64-bit, base install"} ]
+        }
+        end
+
+        def self.reset_data(keys=data.keys)
+          for key in [*keys]
+            data.delete(key)
+          end
+        end
+
+        def initialize(options={})
+          @data = self.class.data
+        end
+      end
+
+      class Real
+        include Collections
+
+        def initialize(options = {})
+          require 'time'
+          require 'digest/md5'
+
+          @voxel_api_key = options[:voxel_api_key]
+          @voxel_api_secret = options[:voxel_api_secret]
+
+          @host   = options[:host]    || "api.voxel.net"
+          @port   = options[:port]    || 443
+          @scheme = options[:scheme]  || 'https'
+          @persistent = options[:persistent] || false
+
+          Excon.ssl_verify_peer = false
+
+          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}", @persistent)
+        end
+
+        def request(method_name, options = {})
+          begin
+            parser = options.delete(:parser)
+            options.merge!({ :method => method_name, :timestamp => Time.now.xmlschema, :key => @voxel_api_key })
+            options[:api_sig] = create_signature(@voxel_api_secret, options)
+            data = @connection.request(
+              :method => "POST",
+              :query  => options,
+              :parser => parser,
+              :path   => "/version/1.0/"
+            )
+            unless data.body['stat'] == 'ok'
+              raise Fog::Voxel::Compute::Error, "#{data.body['err']['msg']}"
+            end
+            data
+          rescue Excon::Errors::HTTPStatusError => error
+            raise case error
+            when Excon::Errors::NotFound
+              Fog::Voxel::Compute::NotFound.slurp(error)
+            else
+              error
+            end
+          end
+        end
+
+        def create_signature(secret, options)
+          to_sign = options.keys.map { |k| k.to_s }.sort.map { |k| "#{k}#{options[k.to_sym]}" }.join("")
+          Digest::MD5.hexdigest( secret + to_sign )
+        end
+      end
+    end
+  end
+end