fog-ecloud 0.0.2 → 0.1.0

data/lib/fog/{ecloud/requests/compute → compute/ecloud/requests}/public_ip_activate.rb

@@ -2,7 +2,7 @@ module Fog
   module Compute
     class Ecloud
       class Real
-        basic_request :public_ip_activate, 201, 'POST'
+        basic_request :public_ip_activate, 201, "POST"
       end
     end
   end

data/lib/fog/{ecloud/requests/compute → compute/ecloud/requests}/rnat_associations_delete.rb

@@ -2,7 +2,7 @@ module Fog
   module Compute
     class Ecloud
       class Real
-        basic_request :rnat_associations_delete, 202, 'DELETE'
+        basic_request :rnat_associations_delete, 202, "DELETE"
       end
     end
   end

data/lib/fog/{ecloud/requests/compute → compute/ecloud/requests}/rows_delete.rb

@@ -2,7 +2,7 @@ module Fog
   module Compute
     class Ecloud
       class Real
-        basic_request :rows_delete, 204, 'DELETE'
+        basic_request :rows_delete, 204, "DELETE"
       end
 
       class Mock

data/lib/fog/{ecloud/requests/compute → compute/ecloud/requests}/rows_movedown.rb

@@ -2,7 +2,7 @@ module Fog
   module Compute
     class Ecloud
       class Real
-        basic_request :rows_movedown, 204, 'POST'
+        basic_request :rows_movedown, 204, "POST"
       end
     end
   end

data/lib/fog/{ecloud/requests/compute → compute/ecloud/requests}/rows_moveup.rb

@@ -2,7 +2,7 @@ module Fog
   module Compute
     class Ecloud
       class Real
-        basic_request :rows_moveup, 204, 'POST'
+        basic_request :rows_moveup, 204, "POST"
       end
     end
   end

data/lib/fog/{ecloud/requests/compute → compute/ecloud/requests}/trusted_network_groups_create.rb

@@ -35,7 +35,7 @@ module Fog
             if data[:networks]
               xml.Networks do
                 data[:networks].each do |network|
-                  address, subnet = network.split('/')
+                  address, subnet = network.split("/")
                   xml.Network do
                     xml.Address address
                     xml.Size subnet

data/lib/fog/{ecloud/requests/compute → compute/ecloud/requests}/trusted_network_groups_delete.rb

@@ -2,7 +2,7 @@ module Fog
   module Compute
     class Ecloud
       class Real
-        basic_request :trusted_network_groups_delete, 202, 'DELETE'
+        basic_request :trusted_network_groups_delete, 202, "DELETE"
       end
     end
   end

data/lib/fog/{ecloud/requests/compute → compute/ecloud/requests}/trusted_network_groups_edit.rb

@@ -35,7 +35,7 @@ module Fog
             if data[:networks]
               xml.Networks do
                 data[:networks].each do |network|
-                  address, subnet = network.split('/')
+                  address, subnet = network.split("/")
                   xml.Network do
                     xml.Address address
                     xml.Size subnet

data/lib/fog/{ecloud/requests/compute → compute/ecloud/requests}/virtual_machine_attach_disk.rb

@@ -17,7 +17,7 @@ module Fog
           body = build_request_body_attach_disk(options)
           request(
             :expects => 202,
-            :method => 'POST',
+            :method => "POST",
             :headers => {},
             :body => body,
             :uri => href,

data/lib/fog/{ecloud/requests/compute → compute/ecloud/requests}/virtual_machine_copy.rb

@@ -103,7 +103,7 @@ module Fog
           body = build_request_body_copy(options)
           request(
             :expects => 201,
-            :method => 'POST',
+            :method => "POST",
             :headers => {},
             :body => body,
             :uri => template_uri,

data/lib/fog/{ecloud/requests/compute → compute/ecloud/requests}/virtual_machine_copy_identical.rb

@@ -30,7 +30,7 @@ module Fog
           body = build_request_body_identical(options)
           request(
             :expects => 201,
-            :method => 'POST',
+            :method => "POST",
             :headers => {},
             :body => body,
             :uri => template_uri,

data/lib/fog/{ecloud/requests/compute → compute/ecloud/requests}/virtual_machine_create_from_template.rb

@@ -104,7 +104,7 @@ module Fog
 
           request(
             :expects => 201,
-            :method  => 'POST',
+            :method  => "POST",
             :body    => build_request_body(options),
             :uri     => options[:uri],
             :parse   => true

data/lib/fog/{ecloud/requests/compute → compute/ecloud/requests}/virtual_machine_delete.rb

@@ -2,7 +2,7 @@ module Fog
   module Compute
     class Ecloud
       class Real
-        basic_request :virtual_machine_delete, 202, 'DELETE'
+        basic_request :virtual_machine_delete, 202, "DELETE"
       end
 
       class Mock

data/lib/fog/{ecloud/requests/compute → compute/ecloud/requests}/virtual_machine_detach_disk.rb

@@ -18,7 +18,7 @@ module Fog
           body = build_request_body_detach_disk(options)
           request(
             :expects => 201,
-            :method => 'POST',
+            :method => "POST",
             :headers => {},
             :body => body,
             :uri => href,

data/lib/fog/{ecloud/requests/compute → compute/ecloud/requests}/virtual_machine_edit.rb

@@ -32,7 +32,7 @@ module Fog
           body = build_request_body_edit(options)
           request(
             :expects => [202,204],
-            :method => 'PUT',
+            :method => "PUT",
             :headers => {},
             :body => body,
             :uri => vm_uri,

data/lib/fog/{ecloud/requests/compute → compute/ecloud/requests}/virtual_machine_edit_assigned_ips.rb

@@ -25,7 +25,7 @@ module Fog
           body = build_request_body_edit_assigned_ips(options)
           request(
             :expects => 202,
-            :method => 'PUT',
+            :method => "PUT",
             :headers => {},
             :body => body,
             :uri => href,

data/lib/fog/{ecloud/requests/compute → compute/ecloud/requests}/virtual_machine_edit_hardware_configuration.rb

@@ -7,7 +7,7 @@ module Fog
           body = build_request_body_edit_hardware_configuration(data)
           request(
             :expects => 202,
-            :method => 'PUT',
+            :method => "PUT",
             :headers => {},
             :body => body,
             :uri => vm_uri,

data/lib/fog/{ecloud/requests/compute → compute/ecloud/requests}/virtual_machine_import.rb

@@ -52,7 +52,7 @@ module Fog
 
           request(
             :expects => 201,
-            :method  => 'POST',
+            :method  => "POST",
             :body    => build_request_body_import(options),
             :uri     => options[:uri],
             :parse   => true

data/lib/fog/{ecloud/requests/compute → compute/ecloud/requests}/virtual_machine_upload_file.rb

@@ -5,7 +5,7 @@ module Fog
         def validate_upload_file_options(options)
           required_opts = [:file, :path, :credentials]
           unless required_opts.all? { |opt| options.key?(opt) }
-            raise ArgumentError.new("Required data missing: #{(required_opts - options.keys).map(&:inspect).join(", ")}")
+            raise ArgumentError.new("Required data missing: #{(required_opts - options.keys).map(&:inspect).join(', ')}")
           end
         end
       end
@@ -15,8 +15,8 @@ module Fog
           validate_upload_file_options(options)
           request(
             :expects => 204,
-            :method => 'POST',
-            :headers => {'Content-Type' => 'application/octet-stream', 'X-Guest-User' => options[:credentials][:user], 'X-Guest-Password' => options[:credentials][:password], 'Content-Range' => "0-#{options[:file].bytesize - 1}/#{options[:file].bytesize}"},
+            :method => "POST",
+            :headers => { "Content-Type" => "application/octet-stream", "X-Guest-User" => options[:credentials][:user], "X-Guest-Password" => options[:credentials][:password], "Content-Range" => "0-#{options[:file].bytesize - 1}/#{options[:file].bytesize}" },
             :body => options[:file],
             :uri => vm_uri + "?path=#{options[:path]}",
             :parse => true

data/lib/fog/ecloud.rb

@@ -1,8 +1,42 @@
-require 'fog/ecloud/version'
-require 'fog/ecloud/compute'
+require "fog/core"
+require "fog/xml"
+require "builder"
+
+require File.expand_path("../ecloud/version", __FILE__)
+require File.expand_path("../ecloud/ipaddr", __FILE__)
 
 module Fog
+  module Compute
+    autoload :Ecloud, File.expand_path("../compute/ecloud", __FILE__)
+  end
+
   module Ecloud
-    # Your code goes here...
+    ECLOUD_OPTIONS = [:ecloud_authentication_method]
+
+    autoload :MockDataClasses, File.expand_path("../ecloud/mock_data_classes", __FILE__)
+
+    extend Fog::Provider
+
+    service(:compute, "Compute")
+
+    def self.keep(hash, *keys)
+      {}.tap do |kept|
+        keys.each{ |k| kept[k] = hash[k] if hash.key?(k) }
+      end
+    end
+
+    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,824 +1 @@
-require 'fog/ecloud/core'
-require 'fog/ecloud/collection'
-require 'fog/ecloud/model'
-require 'builder'
-
-module Fog
-  module Compute
-    class Ecloud < Fog::Service
-      API_URL = "https://services.enterprisecloud.terremark.com"
-
-      attr_reader :authentication_method, :version
-
-      #### Credentials
-      #requires
-      recognizes :ecloud_username, :ecloud_password, :ecloud_version,
-                 :ecloud_access_key, :ecloud_private_key,
-                 :ecloud_authentication_method, :base_path
-
-      #### Models
-      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 :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 :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_cpu_usage_detail
-      request :get_cpu_usage_detail_summary
-      request :get_environment
-      request :get_firewall_acl
-      request :get_firewall_acls
-      request :get_group
-      request :get_groups
-      request :get_guest_process
-      request :get_guest_processes
-      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_monitor
-      request :get_monitors
-      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_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_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_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_delete
-      request :internet_service_edit
-      request :monitors_create_default
-      request :monitors_create_ecv
-      request :monitors_create_http
-      request :monitors_create_loopback
-      request :monitors_create_ping
-      request :monitors_disable
-      request :monitors_edit_ecv
-      request :monitors_edit_http
-      request :monitors_edit_ping
-      request :monitors_enable
-      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_movedown
-      request :rows_moveup
-      request :trusted_network_groups_create
-      request :trusted_network_groups_delete
-      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_accessor :base_path
-        attr_reader :versions_uri
-
-        def validate_data(required_opts = [], options = {})
-          unless required_opts.all? { |opt| options.key?(opt) }
-            raise ArgumentError.new("Required data missing: #{(required_opts - options.keys).map(&:inspect).join(", ")}")
-          end
-        end
-
-        def id_from_uri(uri)
-          uri.match(/(\d+)$/)[1].to_i
-        end
-
-        def default_organization_uri
-          "#{@base_path}/organizations"
-        end
-      end
-
-      class Real
-        include Shared
-
-        class << self
-          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 = {})
-          @base_path               = options[:base_path] || '/cloudapi/ecloud'
-          @connections             = {}
-          @connection_options      = options[:connection_options] || {}
-          @host                    = options[:ecloud_host] || API_URL
-          @persistent              = options[:persistent] || false
-          @version                 = options[:ecloud_version] || "2013-06-01"
-          @authentication_method   = options[:ecloud_authentication_method] || :cloud_api_auth
-          @access_key              = options[:ecloud_access_key]
-          @private_key             = options[:ecloud_private_key]
-          if @private_key.nil? || @authentication_method == :basic_auth
-            @authentication_method = :basic_auth
-            @username              = options[:ecloud_username]
-            @password              = options[:ecloud_password]
-            if @username.nil? || @password.nil?
-              raise ArgumentError, "No credentials (cloud auth, or basic auth) passed!"
-            end
-          else
-            @hmac = Fog::HMAC.new("sha256", @private_key)
-          end
-        end
-
-        def 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])
-          end
-          host_url = "#{params[:uri].scheme}://#{params[:uri].host}#{params[:uri].port ? ":#{params[:uri].port}" : ''}"
-
-          # Hash connections on the host_url ... There's nothing to say we won't get URI's that go to
-          # different hosts.
-          @connections[host_url] ||= Fog::XML::Connection.new(host_url, @persistent, @connection_options)
-
-          # Set headers to an empty hash if none are set.
-          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].nil? || params[:body].empty?
-            options.merge!({:body => params[:body]})
-          end
-          response = @connections[host_url].request(options)
-          # Parse the response body into a hash
-          unless response.body.empty?
-            if params[:parse]
-              document = Fog::ToHashDocument.new
-              parser = Nokogiri::XML::SAX::PushParser.new(document)
-              parser << response.body
-              parser.finish
-
-              response.body = document.body
-            end
-          end
-
-          response
-        end
-
-        private
-
-        # if Authorization and x-tmrk-authorization are used, the x-tmrk-authorization takes precendence.
-        def set_extra_headers_for(params)
-          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}"},
-              "Authorization" => %{CloudApi AccessKey="#{@access_key}" SignatureType="HmacSha256" Signature="#{signature}"}
-            })
-          end
-          params[:headers]
-        end
-
-        def cloud_api_signature(params)
-          verb = params[:method].upcase
-          headers = params[:headers]
-          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")
-          Base64.encode64(@hmac.sign(string)).chomp
-        end
-
-        # section 5.6.3.2 in the ~1000 page pdf spec
-        def canonicalize_headers(headers)
-          tmp = headers.reduce({}) {|ret, h| ret[h.first.downcase] = h.last if h.first.match(/^x-tmrk/i) ; ret }
-          tmp.reject! {|k,v| k == "x-tmrk-authorization" }
-          tmp = tmp.sort.map{|e| "#{e.first}:#{e.last}" }.join("\n")
-          tmp
-        end
-
-        # section 5.6.3.3 in the ~1000 page pdf spec
-        def canonicalize_resource(path)
-          uri, query_string = path.split("?")
-          return uri if query_string.nil?
-          query_string_pairs = query_string.split("&").sort.map{|e| e.split("=") }
-          tm_query_string = query_string_pairs.map{|x| "#{x.first.downcase}:#{x.last}" }.join("\n")
-          "#{uri.downcase}\n#{tm_query_string}\n"
-        end
-      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={})
-          @base_path = '/cloudapi/ecloud'
-          @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.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
+# This file was intentionally left blank