fog-maestrodev 1.7.0.20121114190951 → 1.8.0.20130109172219

data/lib/fog/dnsmadeeasy/models/dns/record.rb

@@ -8,7 +8,7 @@ module Fog
         extend Fog::Deprecation
         deprecate :ip, :value
         deprecate :ip=, :value=
-        
+
         identity :id
 
         attribute :name
@@ -23,14 +23,14 @@ module Fog
         attribute :hard_link, :aliases => "hardLink"
 
         attribute :value,          :aliases => "data"
-  
+
         def initialize(attributes={})
           self.ttl ||= 1800
           super
         end
 
         def destroy
-          connection.delete_record(zone.domain, identity)
+          service.delete_record(zone.domain, identity)
           true
         end
 
@@ -57,11 +57,11 @@ module Fog
           end
 
           if id.nil?
-            data = connection.create_record(zone.domain, name, type, value, options).body
+            data = service.create_record(zone.domain, name, type, value, options).body
             merge_attributes(data)
           else
             options.merge!(:name => name, :type => type, :data => value)
-            connection.update_record(zone.domain, id, options).body
+            service.update_record(zone.domain, id, options).body
           end
 
           true

data/lib/fog/dnsmadeeasy/models/dns/records.rb

@@ -13,12 +13,12 @@ module Fog
 
         def all
           requires :zone
-          data = connection.list_records(zone.identity).body
+          data = service.list_records(zone.identity).body
           load(data)
         end
 
         def get(record_id)
-          data = connection.get_record(zone.identity, record_id).body
+          data = service.get_record(zone.identity, record_id).body
           new(data)
         rescue Fog::Service::NotFound
           nil

data/lib/fog/dnsmadeeasy/models/dns/zone.rb

@@ -14,7 +14,7 @@ module Fog
 
         def destroy
           requires :identity
-          connection.delete_domain(identity)
+          service.delete_domain(identity)
           true
         end
 
@@ -22,14 +22,14 @@ module Fog
           @records ||= begin
             Fog::DNS::DNSMadeEasy::Records.new(
               :zone       => self,
-              :connection => connection
+              :service => service
             )
           end
         end
 
         def save
           requires :domain
-          data = connection.create_domain(domain).body
+          data = service.create_domain(domain).body
           self.identity = data['name']
           merge_attributes(data)
           true

data/lib/fog/dnsmadeeasy/models/dns/zones.rb

@@ -11,12 +11,12 @@ module Fog
 
         def all
           clear
-          data = connection.list_domains.body['list'].collect{|domain| {:id => domain}}
+          data = service.list_domains.body['list'].collect{|domain| {:id => domain}}
           load(data)
         end
 
         def get(zone_id)
-          data = connection.get_domain(zone_id).body
+          data = service.get_domain(zone_id).body
           data.merge!(:id => data['name'])
           new(data)
         rescue Fog::Service::NotFound

data/lib/fog/dynect/models/dns/record.rb

@@ -16,7 +16,7 @@ module Fog
 
         def destroy
           requires :identity, :name, :type, :zone
-          connection.delete_record(type, zone.identity, name, identity)
+          service.delete_record(type, zone.identity, name, identity)
           true
         end
 
@@ -28,13 +28,13 @@ module Fog
           }
           options.delete_if {|key, value| value.nil?}
 
-          data = connection.post_record(type, zone.identity, name, rdata, options).body['data']
+          data = service.post_record(type, zone.identity, name, rdata, options).body['data']
           # avoid overwriting zone object with zone string
           data = data.reject {|key, value| key == 'zone'}
           merge_attributes(data)
 
           zone.publish
-          records = connection.get_record(type, zone.identity, name).body['data']
+          records = service.get_record(type, zone.identity, name).body['data']
           # data in format ['/REST/xRecord/domain/fqdn/identity]
           records.map! do |record|
             tokens = record.split('/')

data/lib/fog/dynect/models/dns/records.rb

@@ -14,8 +14,8 @@ module Fog
         def all(options = {})
           requires :zone
           data = []
-          connection.get_node_list(zone.domain, options).body['data'].each do |fqdn|
-            records = connection.get_record('ANY', zone.domain, fqdn).body['data']
+          service.get_node_list(zone.domain, options).body['data'].each do |fqdn|
+            records = service.get_record('ANY', zone.domain, fqdn).body['data']
 
             # data in format ['/REST/xRecord/domain/fqdn/identity]
             records.map! do |record|

data/lib/fog/dynect/models/dns/zone.rb

@@ -23,7 +23,7 @@ module Fog
 
         def destroy
           requires :domain
-          connection.delete_zone(domain)
+          service.delete_zone(domain)
           true
         end
 
@@ -34,12 +34,12 @@ module Fog
 
         def publish
           requires :identity
-          data = connection.put_zone(identity, 'publish' => true)
+          data = service.put_zone(identity, 'publish' => true)
           true
         end
 
         def records
-          @records ||= Fog::DNS::Dynect::Records.new(:zone => self, :connection => connection)
+          @records ||= Fog::DNS::Dynect::Records.new(:zone => self, :service => service)
         end
 
         def nameservers
@@ -48,7 +48,7 @@ module Fog
 
         def save
           requires :domain, :email, :ttl
-          data = connection.post_zone(email, ttl, domain).body['data']
+          data = service.post_zone(email, ttl, domain).body['data']
           merge_attributes(data)
           true
         end

data/lib/fog/dynect/models/dns/zones.rb

@@ -10,14 +10,14 @@ module Fog
         model Fog::DNS::Dynect::Zone
 
         def all
-          data = connection.get_zone.body['data'].map do |zone|
+          data = service.get_zone.body['data'].map do |zone|
             { :domain => zone }
           end
           load(data)
         end
 
         def get(zone_id)
-          new(connection.get_zone('zone' => zone_id).body['data'])
+          new(service.get_zone('zone' => zone_id).body['data'])
         rescue Excon::Errors::NotFound
           nil
         end

data/lib/fog/ecloud.rb

@@ -2,16 +2,30 @@ require(File.expand_path(File.join(File.dirname(__FILE__), 'core')))
 
 module Fog
   module Ecloud
+    ECLOUD_OPTIONS = [:ecloud_authentication_method]
 
     extend Fog::Provider
 
     service(:compute, 'ecloud/compute', 'Compute')
 
-  end
-end
+    def self.keep(hash, *keys)
+      {}.tap do |kept|
+        keys.each{|k| kept[k]= hash[k] if hash.key?(k)}
+      end
+    end
 
-module Fog
-  module Ecloud
-    ECLOUD_OPTIONS = [:ecloud_authentication_method]
+    def self.slice(hash, *keys)
+      hash.dup.tap do |sliced|
+        keys.each{|k| sliced.delete(k)}
+      end
+    end
+
+    def self.ip_address
+      4.times.map{ Fog::Mock.random_numbers(3) }.join(".")
+    end
+
+    def self.mac_address
+      6.times.map{ Fog::Mock.random_numbers(2) }.join(":")
+    end
   end
 end

data/lib/fog/ecloud/compute.rb

@@ -1,33 +1,12 @@
 require 'fog/ecloud/collection'
-module Fog
-  module Ecloud
-    class Model < Fog::Model
-
-      attr_accessor :loaded
-      alias_method :loaded?, :loaded
-
-      def reload
-        instance = super
-        @loaded = true
-        instance
-      end
-
-      def load_unless_loaded!
-        unless @loaded
-          reload
-        end
-      end
+require 'fog/ecloud/model'
+require 'builder'
 
-    end
-  end
-end
 module Fog
   module Compute
-
-
     class Ecloud < Fog::Service
-
       API_URL = "https://services.enterprisecloud.terremark.com"
+
       attr_reader :authentication_method, :version
 
       #### Credentials
@@ -38,346 +17,271 @@ module Fog
       model_path 'fog/ecloud/models/compute'
       model :organization
       collection :organizations
-        model :location
-        collection :locations
-          model :catalog_item
-          collection :catalog
-            model :catalog_configuration
-            collection :catalog_configurations
-        model :environment
-        collection :environments
-          model :task
-          collection :tasks
-          model :compute_pool
-          collection :compute_pools
-            model :server
-            collection :servers
-              model :hardware_configuration
-              collection :hardware_configurations
-              model :server_configuration_option
-              collection :server_configuration_options
-              model :guest_process
-              collection :guest_processes
-            model :layout
-            collection :layouts
-              model :row
-              collection :rows
-                model :group
-                collection :groups
-            model :internet_service
-            collection :internet_services
-              model :node
-              collection :nodes
-              model :monitor
-              collection :monitors
-            model :cpu_usage_detail
-            collection :cpu_usage_detail_summary
-            model :memory_usage_detail
-            collection :memory_usage_detail_summary
-            model :storage_usage_detail
-            collection :storage_usage_detail_summary
-            model :operating_system_family
-            collection :operating_system_families
-              model :operating_system
-              collection :operating_systems
-            model :template
-            collection :templates
-          model :firewall_acl
-          collection :firewall_acls
-          model :network
-          collection :networks
-            model :ip_address
-            collection :ip_addresses
-          model :physical_device
-          collection :physical_devices
-          model :public_ip
-          collection :public_ips
-          model :trusted_network_group
-          collection :trusted_network_groups
-          model :backup_internet_service
-          collection :backup_internet_services
-          model :rnat
-          collection :rnats
-            model :association
-            collection :associations
-        model :tag
-        collection :tags
-        model :admin_organization
-        collection :admin_organizations
-          model :ssh_key
-          collection :ssh_keys
-          model :password_complexity_rule
-          collection :password_complexity_rules
-          model :authentication_level
-          collection :authentication_levels
-          model :login_banner
-          collection :login_banners
-        model :user
-        collection :users
-          model :role
-          collection :roles
-          model :ssh_key
-          collection :ssh_keys
-        model :support_ticket
-        collection :support_tickets
+      model :location
+      collection :locations
+      model :catalog_item
+      collection :catalog
+      model :catalog_configuration
+      collection :catalog_configurations
+      model :environment
+      collection :environments
+      model :task
+      collection :tasks
+      model :compute_pool
+      collection :compute_pools
+      model :server
+      collection :servers
+      model :virtual_machine_assigned_ip
+      collection :virtual_machine_assigned_ips
+      model :hardware_configuration
+      collection :hardware_configurations
+      model :server_configuration_option
+      collection :server_configuration_options
+      model :guest_process
+      collection :guest_processes
+      model :layout
+      collection :layouts
+      model :row
+      collection :rows
+      model :group
+      collection :groups
+      model :internet_service
+      collection :internet_services
+      model :node
+      collection :nodes
+      model :monitor
+      collection :monitors
+      model :cpu_usage_detail
+      collection :cpu_usage_detail_summary
+      model :memory_usage_detail
+      collection :memory_usage_detail_summary
+      model :storage_usage_detail
+      collection :storage_usage_detail_summary
+      model :operating_system_family
+      collection :operating_system_families
+      model :operating_system
+      collection :operating_systems
+      model :template
+      collection :templates
+      model :firewall_acl
+      collection :firewall_acls
+      model :network
+      collection :networks
+      model :ip_address
+      collection :ip_addresses
+      model :physical_device
+      collection :physical_devices
+      model :public_ip
+      collection :public_ips
+      model :trusted_network_group
+      collection :trusted_network_groups
+      model :backup_internet_service
+      collection :backup_internet_services
+      model :rnat
+      collection :rnats
+      model :association
+      collection :associations
+      model :tag
+      collection :tags
+      model :admin_organization
+      collection :admin_organizations
+      model :ssh_key
+      collection :ssh_keys
+      model :password_complexity_rule
+      collection :password_complexity_rules
+      model :authentication_level
+      collection :authentication_levels
+      model :login_banner
+      collection :login_banners
+      model :user
+      collection :users
+      model :role
+      collection :roles
+      model :ssh_key
+      collection :ssh_keys
+      model :support_ticket
+      collection :support_tickets
+      model :detached_disk
+      collection :detached_disks
 
       #### Requests
       request_path 'fog/ecloud/requests/compute'
-      request :get_organization
-      request :get_organizations
-      request :get_location
-      request :get_locations
-      request :get_environment
-      request :get_task
-      request :get_tasks
+      request :backup_internet_service_create
+      request :backup_internet_service_delete
+      request :backup_internet_service_edit
+      request :compute_pool_edit
+      request :firewall_acls_create
+      request :firewall_acls_delete
+      request :get_admin_organization
+      request :get_api_key
+      request :get_api_keys
+      request :get_association
+      request :get_associations
+      request :get_authentication_level
+      request :get_authentication_levels
+      request :get_backup_internet_service
+      request :get_backup_internet_services
+      request :get_catalog
+      request :get_catalog_configuration
+      request :get_catalog_configurations
+      request :get_catalog_item
       request :get_compute_pool
       request :get_compute_pools
-      request :get_server
-      request :get_servers
-      request :get_network
-      request :get_networks
-      request :get_physical_device
-      request :get_physical_devices
-      request :get_layout
-      request :get_layouts
-      request :get_row
-      request :get_rows
-      request :get_group
-      request :get_groups
-      request :get_public_ip
-      request :get_public_ips
-      request :get_network_summary
-      request :get_internet_service
-      request :get_internet_services
-      request :get_node
-      request :get_nodes
+      request :get_cpu_usage_detail
+      request :get_cpu_usage_detail_summary
+      request :get_environment
       request :get_firewall_acl
       request :get_firewall_acls
-      request :get_trusted_network_group
-      request :get_trusted_network_groups
-      request :get_catalog
-      request :get_catalog_item
-      request :get_tag
-      request :get_tags
-      request :get_hardware_configuration
-      request :get_hardware_configurations
-      request :get_server_configuration_option
-      request :get_server_configuration_options
+      request :get_group
+      request :get_groups
       request :get_guest_process
       request :get_guest_processes
-      request :get_cpu_usage_detail
-      request :get_cpu_usage_detail_summary
+      request :get_hardware_configuration
+      request :get_internet_service
+      request :get_internet_services
+      request :get_ip_address
+      request :get_layout
+      request :get_layouts
+      request :get_location
+      request :get_locations
+      request :get_login_banner
+      request :get_login_banners
       request :get_memory_usage_detail
       request :get_memory_usage_detail_summary
-      request :get_storage_usage_detail
-      request :get_storage_usage_detail_summary
-      request :get_operating_system_family
-      request :get_operating_system_families
-      request :get_operating_system
-      request :get_template
-      request :get_templates
       request :get_monitor
       request :get_monitors
-      request :get_backup_internet_service
-      request :get_backup_internet_services
-      request :get_rnat
-      request :get_rnats
-      request :get_association
-      request :get_associations
-      request :get_admin_organization
-      request :get_admin_organizations
-      request :get_ssh_key
-      request :get_ssh_keys
+      request :get_network
+      request :get_network_summary
+      request :get_networks
+      request :get_node
+      request :get_nodes
+      request :get_operating_system
+      request :get_operating_system_families
+      request :get_organization
+      request :get_organizations
       request :get_password_complexity_rule
       request :get_password_complexity_rules
-      request :get_authentication_level
-      request :get_authentication_levels
-      request :get_login_banner
-      request :get_login_banners
-      request :get_user
-      request :get_users
+      request :get_physical_device
+      request :get_physical_devices
+      request :get_public_ip
+      request :get_public_ips
+      request :get_rnat
+      request :get_rnats
       request :get_role
       request :get_roles
-      request :get_api_key
-      request :get_api_keys
+      request :get_row
+      request :get_rows
+      request :get_server
+      request :get_server_configuration_option
+      request :get_server_configuration_options
+      request :get_servers
+      request :get_ssh_key
+      request :get_ssh_keys
+      request :get_storage_usage_detail
+      request :get_storage_usage_detail_summary
       request :get_support_ticket
       request :get_support_tickets
-      request :get_ip_address
-      request :get_ip_addresses
-      request :get_catalog_configuration
-      request :get_catalog_configurations
-      request :compute_pool_edit
-      request :virtual_machine_create_from_template
-      request :virtual_machine_import
-      request :virtual_machine_copy
-      request :virtual_machine_copy_identical
-      request :virtual_machine_edit
-      request :virtual_machine_add_ip
-      request :virtual_machine_edit_hardware_configuration
-      request :virtual_machine_delete
-      request :virtual_machine_upload_file
+      request :get_tag
+      request :get_tags
+      request :get_task
+      request :get_tasks
+      request :get_template
+      request :get_templates
+      request :get_trusted_network_group
+      request :get_trusted_network_groups
+      request :get_user
+      request :get_users
+      request :get_virtual_machine_assigned_ips
+      request :get_detached_disks
+      request :get_detached_disk
+      request :groups_create
+      request :groups_delete
+      request :groups_edit
+      request :groups_movedown
+      request :groups_moveup
       request :internet_service_create
-      request :internet_service_edit
       request :internet_service_delete
-      request :backup_internet_service_create
-      request :backup_internet_service_edit
-      request :backup_internet_service_delete
-      request :node_service_create
-      request :node_service_delete
-      request :node_service_edit
+      request :internet_service_edit
       request :monitors_create_default
-      request :monitors_create_ping
-      request :monitors_create_http
       request :monitors_create_ecv
+      request :monitors_create_http
       request :monitors_create_loopback
-      request :monitors_edit_ping
-      request :monitors_edit_http
+      request :monitors_create_ping
+      request :monitors_disable
       request :monitors_edit_ecv
+      request :monitors_edit_http
+      request :monitors_edit_ping
       request :monitors_enable
-      request :monitors_disable
-      request :rnat_associations_edit_network
+      request :node_service_create
+      request :node_service_delete
+      request :node_service_edit
+      request :power_off
+      request :power_on
+      request :power_reset
+      request :power_shutdown
+      request :public_ip_activate
       request :rnat_associations_create_device
       request :rnat_associations_delete
+      request :rnat_associations_edit_network
       request :rows_create
+      request :rows_delete
       request :rows_edit
-      request :rows_moveup
       request :rows_movedown
-      request :rows_delete
-      request :groups_create
-      request :groups_edit
-      request :groups_moveup
-      request :groups_movedown
-      request :groups_delete
+      request :rows_moveup
       request :trusted_network_groups_create
-      request :trusted_network_groups_edit
       request :trusted_network_groups_delete
-      request :firewall_acls_create
-      request :firewall_acls_delete
-      request :public_ip_activate
-      request :power_on
-      request :power_off
-      request :power_reset
-      request :power_shutdown
+      request :trusted_network_groups_edit
+      request :virtual_machine_edit_assigned_ips
+      request :virtual_machine_copy
+      request :virtual_machine_copy_identical
+      request :virtual_machine_create_from_template
+      request :virtual_machine_delete
+      request :virtual_machine_edit
+      request :virtual_machine_edit_hardware_configuration
+      request :virtual_machine_import
+      request :virtual_machine_upload_file
+      request :virtual_machine_detach_disk
+      request :virtual_machine_attach_disk
 
       module Shared
 
         attr_reader :versions_uri
 
-        def default_organization_uri
-          @default_organization_uri ||= begin
-            unless @login_results
-              do_login
-            end
-            case @login_results.body[:Org]
-            when Array
-              @login_results.body[:Org].first[:href]
-            when Hash
-              @login_results.body[:Org][:href]
-            else
-              nil
-            end
-          end
-        end
-
-        # login handles the auth, but we just need the Set-Cookie
-        # header from that call.
-        def do_login
-          @login_results = get_organizations
-        end
-
-        def ecloud_xmlns
-          {
-            "xmlns"     => "urn:tmrk:eCloudExtensions-2.8",
-            "xmlns:i"   => "http://www.w3.org/2001/XMLSchema-instance"
-          }
-        end
-
-        def ensure_unparsed(uri)
-          if uri.is_a?(String)
-            uri
-          else
-            uri.to_s
-          end
-        end
-
-        def supported_versions
-          @supported_versions ||= get_versions(@versions_uri).body[:VersionInfo]
-        end
-
-        def xmlns
-          { "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" }
-        end
-
         def validate_data(required_opts = [], options = {})
           unless required_opts.all? { |opt| options.has_key?(opt) }
             raise ArgumentError.new("Required data missing: #{(required_opts - options.keys).map(&:inspect).join(", ")}")
           end
         end
 
-      end
-
-      class Mock
-        def self.data
-          @data ||= Hash.new do |hash, key|
-            hash[key] = {}
-          end
-        end
-
-        def self.reset
-          @data = nil
-        end
-
-        def initialize(options={})
-          @ecloud_api_key = options[:ecloud]
-        end
-
-        def data
-          self.class.data[@ecloud_api_key]
+        def id_from_uri(uri)
+          uri.match(/(\d+)$/)[1].to_i
         end
 
-        def reset_data
-          self.class.data.delete(@ecloud_api_key)
+        def default_organization_uri
+          "/cloudapi/ecloud/organizations/"
         end
       end
 
-
       class Real
         include Shared
 
         class << self
-          def basic_request(*args)
-            self.class_eval <<-EOS, __FILE__,__LINE__
-              def #{args[0]}(uri)
-                request({
-                :expects => #{args[1] || 200},
-                :method => '#{args[2] || 'GET'}',
-                :headers => #{args[3] ? args[3].inspect : '{}'},
-                :body => '#{args[4] ? args[4] : ''}',
-                :parse => true,
-                :uri => uri })
-              end
-            EOS
-          end
-
-          def unauthenticated_basic_request(*args)
-            self.class_eval <<-EOS, __FILE__,__LINE__
-              def #{args[0]}(uri)
-                unauthenticated_request({
-                :expects => #{args[1] || 200},
-                :method => '#{args[2] || 'GET'}',
-                :headers => #{args[3] ? args[3].inspect : '{}'},
-                :parse => true,
-                :uri => uri })
-              end
-            EOS
+          def basic_request(name, expects=[200], method=:get, headers={}, body='')
+            define_method(name) do |uri|
+              request({
+                :expects => expects,
+                :method  => method,
+                :headers => headers,
+                :body    => body,
+                :parse   => true,
+                :uri     => uri
+              })
+            end
           end
         end
 
 
         def initialize(options = {})
-          require 'builder'
           require 'fog/core/parser'
           @connections             = {}
           @connection_options      = options[:connection_options] || {}
@@ -392,26 +296,14 @@ module Fog
             @username              = options[:ecloud_username]
             @password              = options[:ecloud_password]
             if @username.nil? || @password.nil?
-              raise RuntimeError, "No credentials (cloud auth, or basic auth) passed!"
+              raise ArgumentError, "No credentials (cloud auth, or basic auth) passed!"
             end
           else
-            @hmac                  = Fog::HMAC.new("sha256", @private_key)
+            @hmac = Fog::HMAC.new("sha256", @private_key)
           end
         end
 
-        def default_organization_uri
-          "/cloudapi/ecloud/organizations/"
-        end
-
         def request(params)
-          begin
-            do_request(params)
-          rescue Excon::Errors::Unauthorized => e
-            raise RuntimeError, "Invalid authentication data: #{e}"
-          end
-        end
-
-        def do_request(params)
           # Convert the uri to a URI if it's a string.
           if params[:uri].is_a?(String)
             params[:uri] = URI.parse(@host + params[:uri])
@@ -426,13 +318,16 @@ module Fog
           headers = set_extra_headers_for(params) || set_extra_headers_for({})
 
           # Make the request
-          options = {:expects => params[:expects] || 200, :method => params[:method] || 'GET', :path => params[:uri].path + "#{"?#{params[:uri].query}" if params[:uri].query}", :headers => headers}
-          unless params[:body].empty?
+          options = {
+            :expects => (params[:expects] || 200),
+            :method  => params[:method] || 'GET',
+            :path    => params[:uri].path + "#{"?#{params[:uri].query}" if params[:uri].query}",
+            :headers => headers
+          }
+          unless params[:body].nil? || params[:body].empty?
             options.merge!({:body => params[:body]})
           end
-          #puts options[:body].inspect
           response = @connections[host_url].request(options)
-
           # Parse the response body into a hash
           unless response.body.empty?
             if params[:parse]
@@ -444,6 +339,7 @@ module Fog
               response.body = document.body
             end
           end
+
           response
         end
 
@@ -451,27 +347,27 @@ module Fog
 
         # if Authorization and x-tmrk-authorization are used, the x-tmrk-authorization takes precendence.
         def set_extra_headers_for(params)
-         maor_headers = {
-           'x-tmrk-version' => @version,
-           'Date' => Time.now.utc.strftime("%a, %d %b %Y %H:%M:%S GMT"),
-         }
-         params[:headers].merge!(maor_headers)
-         if params[:method]=="POST" || params[:method]=="PUT"
-           params[:headers].merge!({"Content-Type" => 'application/xml'}) unless params[:headers]['Content-Type']
-           params[:headers].merge!({"Accept" => 'application/xml'})
-         end
-         unless params[:body].empty?
+          params[:headers] = {
+            'x-tmrk-version' => @version,
+            'Date'           => Time.now.utc.strftime("%a, %d %b %Y %H:%M:%S GMT"),
+          }.merge(params[:headers] || {})
+          if params[:method]=="POST" || params[:method]=="PUT"
+            params[:headers].merge!({"Content-Type" => 'application/xml'}) unless params[:headers]['Content-Type']
+            params[:headers].merge!({"Accept" => 'application/xml'})
+          end
+          unless params[:body].nil? || params[:body].empty?
             params[:headers].merge!({"x-tmrk-contenthash" => "Sha256 #{Base64.encode64(Digest::SHA2.digest(params[:body].to_s)).chomp}"})
-         end
-         if @authentication_method == :basic_auth
-           params[:headers].merge!({'Authorization' => "Basic #{Base64.encode64(@username+":"+@password).delete("\r\n")}"})
-         elsif @authentication_method == :cloud_api_auth
-           signature = cloud_api_signature(params)
-           params[:headers].merge!({
-             "x-tmrk-authorization" => %{CloudApi AccessKey="#{@access_key}" SignatureType="HmacSha256" Signature="#{signature}"}
-           })
-         end
-         params[:headers]
+          end
+          if @authentication_method == :basic_auth
+            params[:headers].merge!({'Authorization' => "Basic #{Base64.encode64(@username+":"+@password).delete("\r\n")}"})
+          elsif @authentication_method == :cloud_api_auth
+            signature = cloud_api_signature(params)
+            params[:headers].merge!({
+              "x-tmrk-authorization" => %{CloudApi AccessKey="#{@access_key}" SignatureType="HmacSha256" Signature="#{signature}"},
+              "Authorization" => %{CloudApi AccessKey="#{@access_key}" SignatureType="HmacSha256" Signature="#{signature}"}
+            })
+          end
+          params[:headers]
         end
 
         def cloud_api_signature(params)
@@ -480,13 +376,14 @@ module Fog
           path = params[:uri].path
           canonicalized_headers = canonicalize_headers(headers)
           canonicalized_resource = canonicalize_resource(path)
-          string = [ verb,
-                     headers['Content-Length'].to_s,
-                     headers['Content-Type'].to_s,
-                     headers['Date'].to_s,
-                     canonicalized_headers,
-                     canonicalized_resource + "\n"
-                   ].join("\n")
+          string = [
+            verb,
+            headers['Content-Length'].to_s,
+            headers['Content-Type'].to_s,
+            headers['Date'].to_s,
+            canonicalized_headers,
+            canonicalized_resource + "\n"
+          ].join("\n")
           Base64.encode64(@hmac.sign(string)).chomp
         end
 
@@ -510,6 +407,421 @@ module Fog
       end
 
 
+      class Mock
+        include Shared
+
+        def self.data
+          @data ||= Hash.new do |hash, key|
+            hash[key] = begin
+                          compute_pool_id            = Fog.credentials[:ecloud_compute_pool_id]  || Fog::Mock.random_numbers(3).to_i
+                          environment_id             = Fog.credentials[:ecloud_environment_id]   || Fog::Mock.random_numbers(3).to_i
+                          public_ip_id               = Fog.credentials[:ecloud_public_ip_id]     || Fog::Mock.random_numbers(6).to_i
+                          internet_service_id        = Fog::Mock.random_numbers(6).to_i
+                          node_service_id            = Fog::Mock.random_numbers(6).to_i
+                          environment_name           = Fog.credentials[:ecloud_environment_name] || Fog::Mock.random_letters(12)
+                          location_id                = Fog::Mock.random_numbers(4).to_i
+                          network_id                 = Fog.credentials[:ecloud_network_id]       || Fog::Mock.random_numbers(6).to_i
+                          network_ip                 = Fog::Ecloud.ip_address
+                          public_ip                  = Fog.credentials[:ecloud_public_ip_name]   || Fog::Ecloud.ip_address
+                          ip_address_id              = Fog::Ecloud.ip_address
+                          ip_address2_id             = Fog::Ecloud.ip_address
+                          operating_system_id        = Fog::Mock.random_numbers(7).to_i
+                          operating_system_family_id = Fog::Mock.random_numbers(7).to_i
+                          organization_id            = Fog::Mock.random_numbers(7).to_i
+                          organization_name          = Fog::Mock.random_letters(7)
+                          template_id                = Fog.credentials[:ecloud_template_id]      || Fog::Mock.random_numbers(7).to_i
+                          ssh_key_id                 = Fog.credentials[:ecloud_ssh_key_id]       || Fog::Mock.random_numbers(4).to_i
+                          ssh_key_name               = Fog.credentials[:ecloud_ssh_key_name]     || "root"
+
+                          environment = {
+                            :id   => environment_id,
+                            :href => "/cloudapi/ecloud/environments/#{environment_id}",
+                            :name => environment_name,
+                            :type => "application/vnd.tmrk.cloud.environment"
+                          }
+
+                          organization = {
+                            :href => "/cloudapi/ecloud/organizations/#{organization_id}",
+                            :type => "application/vnd.tmrk.cloud.organization",
+                            :name => organization_name,
+                            :Links => {
+                              :Link => [
+                                Fog::Ecloud.keep(environment, :href, :name, :type),
+                                {
+                                  :href => "/cloudapi/ecloud/admin/organizations/#{organization_id}",
+                                  :name => organization_name,
+                                  :type => "application/vnd.tmrk.cloud.admin.organization",
+                                  :rel  => "alternate",
+                                },
+                                {
+                                  :href => "/cloudapi/ecloud/devicetags/organizations/#{organization_id}",
+                                  :type => "application/vnd.tmrk.cloud.deviceTag; type=collection",
+                                  :rel  => "down",
+                                },
+                                {
+                                  :href => "/cloudapi/ecloud/alerts/organizations/#{organization_id}",
+                                  :type => "application/vnd.tmrk.cloud.alertLog",
+                                  :rel  => "down",
+                                },
+                              ],
+                            },
+                            :Locations => {
+                              :Location => [
+                                {
+                                  :href => "/cloudapi/ecloud/locations/#{location_id}",
+                                  :name => organization_name,
+                                  :Catalog => {
+                                    :href => "/cloudapi/ecloud/admin/catalog/organizations/#{organization_id}/locations/#{location_id}",
+                                  :type => "application/vnd.tmrk.cloud.admin.catalogEntry; type=collection"
+                                  },
+                                  :Environments => { :Environment => [environment] }
+                                }
+                              ]
+                            }
+                          }
+                          environment.merge!(
+                            :Links => {
+                              :Link => [ Fog::Ecloud.keep(organization, :href, :name, :type), ]
+                            }
+                          )
+
+                          admin_organization = {
+                            :id    => organization_id,
+                            :href  => "/cloudapi/ecloud/admin/organizations/#{organization_id}",
+                            :type  => "application/vnd.tmrk.cloud.admin.organization",
+                            :name  => organization_name,
+                            :Links => {
+                              :Link => [
+                                Fog::Ecloud.keep(organization, :href, :type, :name)
+                              ],
+                            },
+                            :organization_id => organization_id,
+                          }
+
+                          compute_pool = {
+                            :id             => compute_pool_id,
+                            :href           => "/cloudapi/ecloud/computepools/#{compute_pool_id}",
+                            :name           => Fog::Mock.random_letters(12),
+                            :type           => "application/vnd.tmrk.cloud.computePool",
+                            :environment_id => environment_id,
+                            :Links          => {
+                              :Link => [
+                                Fog::Ecloud.keep(organization, :href, :name, :type),
+                                Fog::Ecloud.keep(environment, :href, :name, :type),
+                              ]
+                            }
+                          }
+
+
+                          public_ip = {
+                            :id             => public_ip_id,
+                            :href           => "/cloudapi/ecloud/publicips/#{public_ip_id}",
+                            :name           => public_ip,
+                            :type           => "application/vnd.tmrk.cloud.publicIp",
+                            :IpType         => "none",
+                            :environment_id => environment_id,
+                            :Links          => {
+                              :Link => [
+                                Fog::Ecloud.keep(environment, :href, :name, :type),
+                              ],
+                            },
+                            :InternetServices => {
+                              :InternetService => [
+                              ],
+                            },
+                          }
+
+                          internet_service = {
+                            :id           => internet_service_id,
+                            :href         => "/cloudapi/ecloud/internetservices/#{internet_service_id}",
+                            :name         => Fog::Mock.random_letters(6),
+                            :type         => "application/vnd.tmrk.cloud.internetService",
+                            :public_ip_id => public_ip_id,
+                            :Links => {
+                              :Link => [
+                                Fog::Ecloud.keep(public_ip, :href, :name, :type),
+                              ],
+                            },
+                            :NodeServices => {
+                              :NodeService => [
+                              ]
+                            },
+                          }
+
+                          node_service = {
+                            :id                  => node_service_id,
+                            :href                => "/cloudapi/ecloud/nodeservices/#{node_service_id}",
+                            :name                => Fog::Mock.random_letters(6),
+                            :type                => "application/vnd.tmrk.cloud.nodeService",
+                            :internet_service_id => internet_service_id,
+                            :Links               => {
+                              :Link => [
+                                Fog::Ecloud.keep(internet_service, :href, :name, :type)
+                              ],
+                            },
+                          }
+
+                          internet_service[:NodeServices][:NodeService].push(node_service)
+                          public_ip[:InternetServices][:InternetService].push(internet_service)
+
+                          network = {
+                            :id               => network_id,
+                            :href             => "/cloudapi/ecloud/networks/#{network_id}",
+                            :name             => "#{network_ip}/#{Fog::Mock.random_numbers(2)}",
+                            :type             => "application/vnd.tmrk.cloud.network",
+                            :Address          => network_ip,
+                            :NetworkType      => "Dmz",
+                            :BroadcastAddress => network_ip,
+                            :GatewayAddress   => network_ip,
+                            :environment_id   => environment_id,
+                            :Links => {
+                              :Link => [
+                                Fog::Ecloud.keep(environment, :href, :name, :type),
+                              ]
+                            },
+                            :IpAddresses => {
+                              :IpAddress => [],
+                            },
+                          }
+
+                          ip_address = {
+                              :id         => ip_address_id,
+                              :href       => "/cloudapi/ecloud/ipaddresses/networks/#{network_id}/#{ip_address_id}",
+                              :name       => ip_address_id,
+                              :type       => "application/vnd.tmrk.cloud.ipAddress",
+                              :network_id => network_id,
+                              :Links      => {
+                                :Link     => [ Fog::Ecloud.keep(network, :href, :name, :type), ],
+                              },
+                              :Reserved   => "false",
+                              :Host       => nil,
+                              :DetectedOn => nil,
+                          }
+
+                          ip_address2 = ip_address.dup.merge(:id => ip_address2_id, :href => "/cloudapi/ecloud/ipaddresses/networks/#{network_id}/#{ip_address2_id}", :name => ip_address2_id)
+
+                          network[:IpAddresses][:IpAddress].push(ip_address).push(ip_address2)
+
+
+                          short_name = "solaris10_64guest"
+                          operating_system = {
+                            :short_name      => short_name,
+                            :compute_pool_id => compute_pool_id,
+                            :href            => "/cloudapi/ecloud/operatingsystems/#{short_name}/computepools/#{compute_pool_id}",
+                            :name            => "Sun Solaris 10 (64-bit)",
+                            :type            => "application/vnd.tmrk.cloud.operatingSystem",
+                            :FamilyName      => "Solaris",
+                            :Links           => {
+                              :Link => Fog::Ecloud.keep(compute_pool, :href, :name, :type),
+                            },
+                            :ConfigurationOptions => {
+                              :Processor => {
+                                :Minimum    => "1",
+                                :Maximum    => "8",
+                                :StepFactor => "1"
+                              },
+                              :Memory => {
+                                :MinimumSize => {
+                                  :Unit  => "MB",
+                                  :Value => "800"
+                                },
+                                :MaximumSize => {
+                                  :Unit  => "MB",
+                                  :Value => "16384"
+                                },
+                                :StepFactor => {
+                                  :Unit  => "MB",
+                                  :Value => "4"
+                                }
+                              },
+                              :Disk => {
+                                :Minimum => "1",
+                                :Maximum => "15",
+                                :SystemDisk => {
+                                  :ResourceCapacityRange => {
+                                    :MinimumSize => {
+                                      :Unit => "GB",
+                                      :Value => "1"
+                                    },
+                                    :MaximumSize => {
+                                      :Unit => "GB",
+                                      :Value => "512"
+                                    },
+                                    :StepFactor => {
+                                      :Unit => "GB",
+                                      :Value => "1"}
+                                  },
+                                  :MonthlyCost => "0"
+                                },
+                                :DataDisk => {
+                                  :ResourceCapacityRange => {
+                                    :MinimumSize => {
+                                      :Unit => "GB",
+                                      :Value => "1"
+                                    },
+                                    :MaximumSize => {
+                                      :Unit => "GB",
+                                      :Value => "512"
+                                    },
+                                    :StepFactor => {
+                                      :Unit  => "GB",
+                                      :Value => "1"
+                                    }
+                                  },
+                                  :MonthlyCost => "0"
+                                }
+                              },
+                              :NetworkAdapter=> {
+                                :Minimum    => "1",
+                                :Maximum    => "4",
+                                :StepFactor => "1"
+                              }
+                            }
+                          }
+
+
+                          template = {
+                            :id              => template_id,
+                            :href            => "/cloudapi/ecloud/templates/#{template_id}/computepools/#{compute_pool_id}",
+                            :type            => "application/vnd.tmrk.cloud.template",
+                            :name            => "Sun Solaris 10 (x64)",
+                            :compute_pool_id => compute_pool_id,
+                            :OperatingSystem => Fog::Ecloud.keep(operating_system, :href, :name, :type),
+                            :Memory => {
+                              :MinimumSize => {
+                                :Unit  => "MB",
+                                :Value => "800"
+                              },
+                              :MaximumSize => {
+                                :Unit  => "MB",
+                                :Value => "16384"
+                              },
+                              :StepFactor => {
+                                :Unit  => "MB",
+                                :Value => "4"
+                              }
+                            },
+                            :Storage => {
+                              :Size => {
+                                :Unit  => "GB",
+                                :Value => "7"
+                              }
+                            },
+                            :NetworkAdapters => "1",
+                            :Links           => {
+                              :Link => [
+                                Fog::Ecloud.keep(compute_pool, :href, :name, :type),
+                              ]
+                            }
+                          }
+
+                          operating_system_family = {
+                            :id                    => operating_system_family_id,
+                            :compute_pool_id       => compute_pool_id,
+                            :OperatingSystemFamily => {
+                              :Name             => "Linux",
+                              :OperatingSystems => {
+                                :OperatingSystem => [Fog::Ecloud.keep(operating_system, :href, :name, :type)],
+                              }
+                            },
+                            :Links => {
+                              :Link => [
+                                Fog::Ecloud.keep(compute_pool, :href, :name, :type),
+                              ]
+                            }
+                          }
+
+                          ssh_key = {
+                            :id                    => ssh_key_id,
+                            :href                  => "/cloudapi/ecloud/admin/sshKeys/#{ssh_key_id}",
+                            :name                  => ssh_key_name,
+                            :admin_organization_id => organization_id,
+                            :Links => {
+                              :Link => [
+                                Fog::Ecloud.keep(admin_organization, :href, :name, :type),
+                                Fog::Ecloud.keep(organization, :href, :name, :type),
+                              ]
+                            },
+                            :Default => "true",
+                            :FingerPrint => Fog::Ecloud.mac_address
+                          }
+
+                          layout = {
+                            :id => environment_id,
+                            :href => "/cloudapi/ecloud/layout/environments/#{environment_id}",
+                            :type => "application/vnd.tmrk.cloud.deviceLayout",
+                            :Links => {
+                              :Link => [
+                                Fog::Ecloud.keep(environment, :name, :href, :type),
+                              ],
+                            },
+                            :Rows => {
+                              :Row => [
+                              ],
+                            },
+                            :environment_id => environment_id
+                          }
+
+
+                          {
+                            :compute_pools             => {compute_pool_id            => compute_pool},
+                            :environments              => {environment_id             => environment},
+                            :public_ips                => {public_ip_id               => public_ip},
+                            :internet_services         => {internet_service_id        => internet_service},
+                            :node_services             => {node_service_id            => node_service},
+                            :networks                  => {network_id                 => network},
+                            :organizations             => {organization_id            => organization},
+                            :admin_organizations       => {organization_id            => admin_organization},
+                            :operating_systems         => {operating_system_id        => operating_system},
+                            :operating_system_families => {operating_system_family_id => operating_system_family},
+                            :servers                   => {},
+                            :tasks                     => {},
+                            :templates                 => {template_id                => template},
+                            :ssh_keys                  => {ssh_key_id                 => ssh_key},
+                            :detached_disks            => {},
+                            :template_href             => (Fog.credentials[:ecloud_template_href] || "/cloudapi/ecloud/templates/#{template_id}/computepools/#{compute_pool_id}"),
+                            :rows                      => {},
+                            :groups                    => {},
+                            :layouts                   => {environment_id             => layout},
+                          }
+                        end
+          end
+        end
+
+        def self.reset
+          @data = nil
+        end
+
+        def initialize(options={})
+          @ecloud_api_key = options[:ecloud]
+        end
+
+        def data
+          self.class.data[@ecloud_api_key]
+        end
+
+        def reset_data
+          self.class.data.delete(@ecloud_api_key)
+        end
+
+        def response(params={})
+          body    = params[:body]
+          headers = {
+            "Content-Type" => "application/xml"
+          }.merge(params[:headers] || {})
+          status  = params[:status] || 200
+
+          response = Excon::Response.new(:body => body, :headers => headers, :status => status)
+          if params.has_key?(:expects) && ![*params[:expects]].include?(response.status)
+            raise(Excon::Errors.status_error(params, response))
+          else response
+          end
+        end
+
+        def deep_copy(o)
+          Marshal.load(Marshal.dump(o))
+        end
+      end
     end
   end
 end