fog 1.0.0 → 1.5.0

data/lib/fog/ecloud/compute.rb

@@ -1,804 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'ecloud'))
-require 'ipaddr'
-
-class IPAddr
-  def mask
-    _to_string(@mask_addr)
-  end
-end
-
-module Fog
-  module Ecloud
-    class Collection < Fog::Collection
-
-      def load(objects)
-        objects = [ objects ] if objects.is_a?(Hash)
-        super
-      end
-
-      def check_href!(opts = {})
-        unless href
-          if opts.is_a?(String)
-            t = Hash.new
-            t[:parent] = opts
-            opts = t
-          end
-          msg = ":href missing, call with a :href pointing to #{if opts[:message]
-                  opts[:message]
-                elsif opts[:parent]
-                  "the #{opts[:parent]} whos #{self.class.to_s.split('::').last.downcase} you want to enumerate"
-                else
-                  "the resource"
-                end}"
-          raise Fog::Errors::Error.new(msg)
-        end
-      end
-
-    end
-  end
-end
-
-module Fog
-  module Ecloud
-    module MockDataClasses
-      class Base < Hash
-        def self.base_url=(url)
-          @base_url = url
-        end
-
-        self.base_url = "http://vcloud.example.com"
-
-        def self.base_url
-          @base_url
-        end
-
-        def first
-          raise "Don't do this"
-        end
-
-        def last
-          raise "Don't do this"
-        end
-
-        def initialize(data = {}, parent = nil)
-          @parent = parent
-
-          replace(data)
-        end
-
-        def _parent
-          @parent
-        end
-
-        def base_url
-          Base.base_url
-        end
-
-        def href
-          [base_url, self.class.name.split("::").last, object_id].join("/")
-        end
-
-        def inspect
-          "<#{self.class.name} #{object_id} data=#{super}>"
-        end
-      end
-
-      class MockData < Base
-        def versions
-          @versions ||= []
-        end
-
-        def organizations
-          @organizations ||= []
-        end
-
-        def organization_from_href(href)
-          find_href_in(href, organizations)
-        end
-
-        def all_vdcs
-          organizations.map(&:vdcs).flatten
-        end
-
-        def vdc_from_href(href)
-          find_href_in(href, all_vdcs)
-        end
-
-        def all_catalogs
-          all_vdcs.map(&:catalog).flatten
-        end
-
-        def catalog_from_href(href)
-          find_href_in(href, all_catalogs)
-        end
-
-        def all_catalog_items
-          all_catalogs.map(&:items).flatten
-        end
-
-        def catalog_item_from_href(href)
-          find_href_in(href, all_catalog_items)
-        end
-
-        def all_virtual_machines
-          all_vdcs.map(&:virtual_machines).flatten
-        end
-
-        def virtual_machine_from_href(href)
-          find_href_prefixed_in(href, all_virtual_machines)
-        end
-
-
-        def all_networks
-          all_vdcs.map(&:networks).flatten
-        end
-
-        def network_from_href(href)
-          find_href_in(href, all_networks)
-        end
-
-        def all_network_extensions
-          all_networks.map(&:extensions).flatten
-        end
-
-        def network_extension_from_href(href)
-          find_href_in(href, all_network_extensions)
-        end
-
-        def all_vdc_internet_service_collections
-          all_vdcs.map(&:internet_service_collection).flatten
-        end
-
-        def vdc_internet_service_collection_from_href(href)
-          find_href_in(href, all_vdc_internet_service_collections)
-        end
-
-        def all_backup_internet_services
-          all_vdc_internet_service_collections.map(&:backup_internet_services).flatten
-        end
-
-        def backup_internet_service_from_href(href)
-          find_href_in(href, all_backup_internet_services)
-        end
-
-        def all_public_ip_collections
-          all_vdcs.map {|v| v.public_ip_collection }.flatten
-        end
-
-        def public_ip_collection_from_href(href)
-          find_href_in(href, all_public_ip_collections)
-        end
-
-        def all_public_ips
-          all_public_ip_collections.map(&:items).flatten
-        end
-
-        def public_ip_from_href(href)
-          find_href_in(href, all_public_ips)
-        end
-
-        def all_public_ip_internet_service_collections
-          all_public_ips.map(&:internet_service_collection).flatten
-        end
-
-        def public_ip_internet_service_collection_from_href(href)
-          find_href_in(href, all_public_ip_internet_service_collections)
-        end
-
-        def all_public_ip_internet_services
-          all_public_ip_internet_service_collections.map(&:items).flatten
-        end
-
-        def public_ip_internet_service_from_href(href)
-          find_href_in(href, all_public_ip_internet_services)
-        end
-
-        def all_public_ip_internet_service_node_collections
-          all_public_ip_internet_services.map(&:node_collection).flatten
-        end
-
-        def public_ip_internet_service_node_collection_from_href(href)
-          find_href_in(href, all_public_ip_internet_service_node_collections)
-        end
-
-        def all_public_ip_internet_service_nodes
-          all_public_ip_internet_service_node_collections.map(&:items).flatten
-        end
-
-        def public_ip_internet_service_node_from_href(href)
-          find_href_in(href, all_public_ip_internet_service_nodes)
-        end
-
-        def all_network_ip_collections
-          all_networks.map(&:ip_collection)
-        end
-
-        def network_ip_collection_from_href(href)
-          find_href_in(href, all_network_ip_collections)
-        end
-
-        def all_network_ips
-          all_network_ip_collections.map {|c| c.items.values }.flatten
-        end
-
-        def network_ip_from_href(href)
-          find_href_in(href, all_network_ips)
-        end
-
-        private
-
-        def find_href_in(href, objects)
-          objects.detect {|o| o.href == href }
-        end
-
-        def find_href_prefixed_in(href, objects)
-          objects.detect {|o| href =~ %r{^#{o.href}($|/)} }
-        end
-      end
-
-      class MockVersion < Base
-        def version
-          self[:version]
-        end
-
-        def supported
-          !!self[:supported]
-        end
-
-        def login_url
-          href
-        end
-      end
-
-      class MockOrganization < Base
-        def name
-          self[:name]
-        end
-
-        def vdcs
-          @vdcs ||= []
-        end
-      end
-
-      class MockVdc < Base
-        def name
-          self[:name]
-        end
-
-        def storage_allocated
-          self[:storage_allocated] || 200
-        end
-
-        def storage_used
-          self[:storage_used] || 105
-        end
-
-        def cpu_allocated
-          self[:cpu_allocated] || 10000
-        end
-
-        def memory_allocated
-          self[:memory_allocated] || 20480
-        end
-
-        def catalog
-          @catalog ||= MockCatalog.new({}, self)
-        end
-
-        def networks
-          @networks ||= []
-        end
-
-        def virtual_machines
-          @virtual_machines ||= []
-        end
-
-        def task_list
-          @task_list ||= MockTaskList.new({}, self)
-        end
-
-        # for TM eCloud, should probably be subclassed
-        def public_ip_collection
-          @public_ip_collection ||= MockPublicIps.new({}, self)
-        end
-
-        def internet_service_collection
-          @internet_service_collection ||= MockVdcInternetServices.new({}, self)
-        end
-
-        def firewall_acls
-          @firewall_acls ||= MockFirewallAcls.new({}, self)
-        end
-      end
-
-      class MockTaskList < Base
-        def name
-          self[:name] || "Tasks List"
-        end
-      end
-
-      class MockCatalog < Base
-        def name
-          self[:name] || "Catalog"
-        end
-
-        def items
-          @items ||= []
-        end
-      end
-
-      class MockCatalogItem < Base
-        def name
-          self[:name]
-        end
-
-        def disks
-          @disks ||= MockVirtualMachineDisks.new(self)
-        end
-
-        def customization
-          @customization ||= MockCatalogItemCustomization.new({}, self)
-        end
-
-        def vapp_template
-          @vapp_template ||= MockCatalogItemVappTemplate.new({ :name => name }, self)
-        end
-      end
-
-      class MockCatalogItemCustomization < Base
-        def name
-          self[:name] || "Customization Options"
-        end
-      end
-
-      class MockCatalogItemVappTemplate < Base
-        def name
-          self[:name]
-        end
-      end
-
-      class MockNetwork < Base
-        def name
-          self[:name] || subnet
-        end
-
-        def subnet
-          self[:subnet]
-        end
-
-        def gateway
-          self[:gateway] || subnet_ips[1]
-        end
-
-        def netmask
-          self[:netmask] || subnet_ipaddr.mask
-        end
-
-        def dns
-          "8.8.8.8"
-        end
-
-        def features
-          [
-           { :type => :FenceMode, :value => "isolated" }
-          ]
-        end
-
-        def ip_collection
-          @ip_collection ||= MockNetworkIps.new({}, self)
-        end
-
-        def extensions
-          @extensions ||= MockNetworkExtensions.new({}, self)
-        end
-
-        def random_ip
-          usable_subnet_ips[rand(usable_subnet_ips.length)]
-        end
-
-        # for TM eCloud. should probably be a subclass
-        def rnat
-          self[:rnat]
-        end
-
-        def usable_subnet_ips
-          subnet_ips[3..-2]
-        end
-
-        def address
-          subnet_ips.first
-        end
-
-        def broadcast
-          subnet_ips.last
-        end
-
-        private
-
-        def subnet_ipaddr
-          @ipaddr ||= IPAddr.new(subnet)
-        end
-
-        def subnet_ips
-          subnet_ipaddr.to_range.to_a.map(&:to_s)
-        end
-      end
-
-      class MockNetworkIps < Base
-        def items
-          @items ||= _parent.usable_subnet_ips.inject({}) do |out, subnet_ip|
-            out.update(subnet_ip => MockNetworkIp.new({ :ip => subnet_ip }, self))
-          end
-        end
-
-        def ordered_ips
-          items.values.sort_by {|i| i.ip.split(".").map(&:to_i) }
-        end
-
-        def name
-          "IP Addresses"
-        end
-      end
-
-      class MockNetworkIp < Base
-        def name
-          self[:name] || ip
-        end
-
-        def ip
-          self[:ip]
-        end
-
-        def used_by
-          self[:used_by] || _parent._parent._parent.virtual_machines.detect {|v| v.ip == ip }
-        end
-
-        def status
-          if used_by
-            "Assigned"
-          else
-            "Available"
-          end
-        end
-
-        def rnat
-          self[:rnat] || _parent._parent.rnat
-        end
-
-        def rnat_set?
-          !!self[:rnat]
-        end
-      end
-
-      class MockNetworkExtensions < Base
-        def name
-          _parent.name
-        end
-
-        def gateway
-          _parent.gateway
-        end
-
-        def broadcast
-          _parent.broadcast
-        end
-
-        def address
-          _parent.address
-        end
-
-        def rnat
-          _parent.rnat
-        end
-
-        def type
-          self[:type] || "DMZ"
-        end
-
-        def vlan
-          object_id.to_s
-        end
-
-        def friendly_name
-          "#{name} (#{type}_#{object_id})"
-        end
-      end
-
-      class MockVirtualMachine < Base
-        def name
-          self[:name]
-        end
-
-        def ip
-          self[:ip]
-        end
-
-        def cpus
-          self[:cpus] || 1
-        end
-
-        def memory
-          self[:memory] || 1024
-        end
-
-        def disks
-          @disks ||= MockVirtualMachineDisks.new(self)
-        end
-
-        def status
-          self[:status] || 2
-        end
-
-        def power_off!
-          self[:status] = 2
-        end
-
-        def power_on!
-          self[:status] = 4
-        end
-
-        def size
-          disks.inject(0) {|s, d| s + d.vcloud_size }
-        end
-
-        def network_ip
-          if network = _parent.networks.detect {|n| n.ip_collection.items[ip] }
-            network.ip_collection.items[ip]
-          end
-        end
-
-        # from fog ecloud server's _compose_vapp_data
-        def to_configure_vapp_hash
-          {
-            :name   => name,
-            :cpus   => cpus,
-            :memory => memory,
-            :disks  => disks.map {|d| { :number => d.address.to_s, :size => d.vcloud_size, :resource => d.vcloud_size.to_s } }
-          }
-        end
-
-        def href(purpose = :base)
-          case purpose
-          when :base
-            super()
-          when :power_on
-            super() + "/power/action/powerOn"
-          when :power_off
-            super() + "/power/action/powerOff"
-          end
-        end
-      end
-
-      class MockVirtualMachineDisks < Array
-        def initialize(parent = nil)
-          @parent = parent
-        end
-
-        def _parent
-          @parent
-        end
-
-        def <<(disk)
-          next_address = 0
-          disk_with_max_address = max {|a, b| a[:address] <=> b[:address] }
-          disk_with_max_address && next_address = disk_with_max_address.address + 1
-          disk[:address] ||= next_address
-
-          super(disk)
-
-          if (addresses = map {|d| d.address }).uniq.size != size
-            raise "Duplicate disk address in: #{addresses.inspect} (#{size})"
-          end
-
-          sort! {|a, b| a.address <=> b.address }
-          self
-        end
-
-        def at_address(address)
-          detect {|d| d.address == address }
-        end
-      end
-
-      class MockVirtualMachineDisk < Base
-        def size
-          self[:size].to_i
-        end
-
-        def vcloud_size
-          # kilobytes
-          size * 1024
-        end
-
-        def address
-          self[:address].to_i
-        end
-      end
-
-      # for Terremark eCloud
-
-      class MockVdcInternetServices < Base
-        def href
-          _parent.href + "/internetServices"
-        end
-
-        def name
-          "Internet Services"
-        end
-
-        def items
-          public_ip_internet_services + backup_internet_services
-        end
-
-        def public_ip_internet_services
-          _parent.public_ip_collection.items.inject([]) do |services, public_ip|
-            services + public_ip.internet_service_collection.items
-          end
-        end
-
-        def backup_internet_services
-          @backup_internet_services ||= []
-        end
-      end
-
-      class MockBackupInternetService < Base
-        def name
-          self[:name] || "Backup Internet Service #{object_id}"
-        end
-
-        def protocol
-          self[:protocol]
-        end
-
-        def port
-          0
-        end
-
-        def enabled
-          self[:enabled].to_s.downcase != "false"
-        end
-
-        def timeout
-          self[:timeout] || 2
-        end
-
-        def description
-          self[:description] || "Description for Backup Service #{name}"
-        end
-
-        def redirect_url
-          nil
-        end
-
-        def node_collection
-          @node_collection ||= MockPublicIpInternetServiceNodes.new({}, self)
-        end
-      end
-
-      class MockFirewallAcls < Base
-        def name
-          "Firewall Access List"
-        end
-      end
-
-      class MockPublicIps < Base
-        def name
-          self[:name] || "Public IPs"
-        end
-
-        def items
-          @items ||= []
-        end
-      end
-
-      class MockPublicIp < Base
-        def name
-          self[:name]
-        end
-
-        def internet_service_collection
-          @internet_service_collection ||= MockPublicIpInternetServices.new({}, self)
-        end
-      end
-
-      class MockPublicIpInternetServices < Base
-        def href
-          _parent.href + "/internetServices"
-        end
-
-        def items
-          @items ||= []
-        end
-      end
-
-      class MockPublicIpInternetService < Base
-        def name
-          self[:name] || "Public IP Service #{object_id}"
-        end
-
-        def description
-          self[:description] || "Description for Public IP Service #{name}"
-        end
-
-        def protocol
-          self[:protocol]
-        end
-
-        def port
-          self[:port]
-        end
-
-        def enabled
-          !!self[:enabled]
-        end
-
-        def redirect_url
-          self[:redirect_url]
-        end
-
-        def timeout
-          self[:timeout] || 2
-        end
-
-        def node_collection
-          @node_collection ||= MockPublicIpInternetServiceNodes.new({}, self)
-        end
-
-        def monitor
-          nil
-        end
-
-        def backup_service
-          self[:backup_service]
-        end
-      end
-
-      class MockPublicIpInternetServiceNodes < Base
-        def href
-          _parent.href + "/nodeServices"
-        end
-
-        def items
-          @items ||= [].tap do |node_array|
-            node_array.instance_variable_set("@default_port", _parent.port)
-
-            def node_array.<<(node)
-              node[:port] ||= @default_port
-              super
-            end
-          end
-        end
-      end
-
-      class MockPublicIpInternetServiceNode < Base
-        def ip_address
-          self[:ip_address]
-        end
-
-        def name
-          self[:name] || "Public IP Service Node #{object_id}"
-        end
-
-        def description
-          self[:description] || "Description for Public IP Service Node #{name}"
-        end
-
-        def port
-          self[:port]
-        end
-
-        def enabled
-          self[:enabled].to_s.downcase != "false"
-        end
-
-        def enabled=(new_value)
-          self[:enabled] = new_value
-        end
-      end
-    end
-  end
-end
-
-
+require 'fog/ecloud/collection'
 module Fog
   module Ecloud
     class Model < Fog::Model
@@ -821,78 +21,239 @@ module Fog
     end
   end
 end
-
 module Fog
   module Compute
+
+
     class Ecloud < Fog::Service
 
-      class UnsupportedVersion < Exception ; end
+      API_URL = "https://services.enterprisecloud.terremark.com"
+      attr_reader :authentication_method, :version
 
-      requires   :ecloud_username, :ecloud_password, :ecloud_versions_uri
-      recognizes :ecloud_version
+      #### Credentials
+      #requires 
+      recognizes :ecloud_username, :ecloud_password, :ecloud_version, :ecloud_access_key, :ecloud_private_key, :ecloud_authentication_method
 
+      #### Models
       model_path 'fog/ecloud/models/compute'
-      model :catalog_item
-      model :catalog
-      model :firewall_acl
-      collection :firewall_acls
-      model :internet_service
-      collection :internet_services
-      model :backup_internet_service
-      collection :backup_internet_services
-      model :ip
-      collection :ips
-      model :network
-      collection :networks
-      model :node
-      collection :nodes
-      model :public_ip
-      collection :public_ips
-      model :server
-      collection :servers
-      model :task
-      collection :tasks
-      model :vdc
-      collection :vdcs
-
+      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
+
+      #### Requests
       request_path 'fog/ecloud/requests/compute'
-      request :add_internet_service
-      request :add_backup_internet_service
-      request :add_node
-      request :clone_vapp
-      request :configure_internet_service
-      request :configure_network
-      request :configure_network_ip
-      request :configure_node
-      request :configure_vapp
-      request :delete_internet_service
-      request :delete_node
-      request :delete_vapp
-      request :get_catalog
-      request :get_catalog_item
-      request :get_customization_options
-      request :get_firewall_acls
-      request :get_firewall_acl
-      request :get_internet_services
-      request :get_network
-      request :get_network_ip
-      request :get_network_ips
-      request :get_network_extensions
       request :get_organization
-      request :get_node
-      request :get_nodes
+      request :get_organizations
+      request :get_location
+      request :get_locations
+      request :get_environment
+      request :get_task
+      request :get_tasks
+      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_task
-      request :get_task_list
-      request :get_vapp
-      request :get_vapp_template
-      request :get_vdc
-      request :get_versions
-      request :instantiate_vapp_template
-      request :login
-      request :power_off
+      request :get_network_summary
+      request :get_internet_service
+      request :get_internet_services
+      request :get_node
+      request :get_nodes
+      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_guest_process
+      request :get_guest_processes
+      request :get_cpu_usage_detail
+      request :get_cpu_usage_detail_summary
+      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_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_role
+      request :get_roles
+      request :get_api_key
+      request :get_api_keys
+      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_edit_hardware_configuration
+      request :virtual_machine_delete
+      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 :monitors_create_default
+      request :monitors_create_ping
+      request :monitors_create_http
+      request :monitors_create_ecv
+      request :monitors_create_loopback
+      request :monitors_edit_ping
+      request :monitors_edit_http
+      request :monitors_edit_ecv
+      request :monitors_enable
+      request :monitors_disable
+      request :rnat_associations_edit_network
+      request :rnat_associations_create_device
+      request :rnat_associations_delete
+      request :rows_create
+      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 :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
 
@@ -919,13 +280,12 @@ module Fog
         # login handles the auth, but we just need the Set-Cookie
         # header from that call.
         def do_login
-          @login_results = login
-          @cookie = @login_results.headers['Set-Cookie']
+          @login_results = get_organizations
         end
 
         def ecloud_xmlns
           {
-            "xmlns"     => "urn:tmrk:eCloudExtensions-2.6",
+            "xmlns"     => "urn:tmrk:eCloudExtensions-2.8",
             "xmlns:i"   => "http://www.w3.org/2001/XMLSchema-instance"
           }
         end
@@ -948,178 +308,53 @@ module Fog
             "xmlns:xsd" => "http://www.w3.org/2001/XMLSchema" }
         end
 
-      end
-
-      class Mock
-        include Shared
-        include Fog::Ecloud::MockDataClasses
-
-        def self.base_url
-          "https://fakey.com/api/v0.8b-ext2.6"
+        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
 
-        def self.data( base_url = self.base_url )
-          @mock_data ||= MockData.new.tap do |vcloud_mock_data|
-            vcloud_mock_data.versions.clear
-            vcloud_mock_data.versions << MockVersion.new(:version => "v0.8b-ext2.6", :supported => true)
-
-            vcloud_mock_data.organizations << MockOrganization.new(:name => "Boom Inc.").tap do |mock_organization|
-              mock_organization.vdcs << MockVdc.new(:name => "Boomstick").tap do |mock_vdc|
-                mock_vdc.catalog.items << MockCatalogItem.new(:name => "Item 0").tap do |mock_catalog_item|
-                  mock_catalog_item.disks << MockVirtualMachineDisk.new(:size => 25 * 1024)
-                end
-                mock_vdc.catalog.items << MockCatalogItem.new(:name => "Item 1").tap do |mock_catalog_item|
-                  mock_catalog_item.disks << MockVirtualMachineDisk.new(:size => 25 * 1024)
-                end
-                mock_vdc.catalog.items << MockCatalogItem.new(:name => "Item 2").tap do |mock_catalog_item|
-                  mock_catalog_item.disks << MockVirtualMachineDisk.new(:size => 25 * 1024)
-                end
-
-                mock_vdc.networks << MockNetwork.new({ :subnet => "1.2.3.0/24" }, mock_vdc)
-                mock_vdc.networks << MockNetwork.new({ :subnet => "4.5.6.0/24" }, mock_vdc)
-
-                mock_vdc.virtual_machines << MockVirtualMachine.new({ :name => "Broom 1", :ip => "1.2.3.3" }, mock_vdc)
-                mock_vdc.virtual_machines << MockVirtualMachine.new({ :name => "Broom 2", :ip => "1.2.3.4" }, mock_vdc)
-                mock_vdc.virtual_machines << MockVirtualMachine.new({ :name => "Email!", :ip => "1.2.3.10" }, mock_vdc)
-              end
-
-              mock_organization.vdcs << MockVdc.new(:name => "Rock-n-Roll", :storage_allocated => 150, :storage_used => 40, :cpu_allocated => 1000, :memory_allocated => 2048).tap do |mock_vdc|
-                mock_vdc.networks << MockNetwork.new({ :subnet => "7.8.9.0/24" }, mock_vdc)
-
-                mock_vdc.virtual_machines << MockVirtualMachine.new({ :name => "Master Blaster", :ip => "7.8.9.10" }, mock_vdc)
-              end
-            end
-
-            vcloud_mock_data.organizations.detect {|o| o.name == "Boom Inc." }.tap do |mock_organization|
-              mock_organization.vdcs.detect {|v| v.name == "Boomstick" }.tap do |mock_vdc|
-                mock_vdc.public_ip_collection.items << MockPublicIp.new(:name => "99.1.2.3").tap do |mock_public_ip|
-                  mock_public_ip.internet_service_collection.items << MockPublicIpInternetService.new({
-                                                                                                        :protocol => "HTTP",
-                                                                                                        :port => 80,
-                                                                                                        :name => "Web Site",
-                                                                                                        :description => "Web Servers",
-                                                                                                        :redirect_url => "http://fakey.com"
-                                                                                                      }, mock_public_ip.internet_service_collection
-                                                                                                      ).tap do |mock_public_ip_service|
-                    mock_public_ip_service.node_collection.items << MockPublicIpInternetServiceNode.new({:ip_address => "1.2.3.5", :name => "Test Node 1", :description => "web 1"}, mock_public_ip_service.node_collection)
-                    mock_public_ip_service.node_collection.items << MockPublicIpInternetServiceNode.new({:ip_address => "1.2.3.6", :name => "Test Node 2", :description => "web 2"}, mock_public_ip_service.node_collection)
-                    mock_public_ip_service.node_collection.items << MockPublicIpInternetServiceNode.new({:ip_address => "1.2.3.7", :name => "Test Node 3", :description => "web 3"}, mock_public_ip_service.node_collection)
-                  end
-
-                  mock_public_ip.internet_service_collection.items << MockPublicIpInternetService.new({
-                                                                                                        :protocol => "TCP",
-                                                                                                        :port => 7000,
-                                                                                                        :name => "An SSH Map",
-                                                                                                        :description => "SSH 1"
-                                                                                                      }, mock_public_ip.internet_service_collection
-                                                                                                      ).tap do |mock_public_ip_service|
-                    mock_public_ip_service.node_collection.items << MockPublicIpInternetServiceNode.new({ :ip_address => "1.2.3.5", :port => 22, :name => "SSH", :description => "web ssh" }, mock_public_ip_service.node_collection)
-                  end
-                end
-
-                mock_vdc.public_ip_collection.items << MockPublicIp.new(:name => "99.1.2.4").tap do |mock_public_ip|
-                  mock_public_ip.internet_service_collection.items << MockPublicIpInternetService.new({
-                                                                                                        :protocol => "HTTP",
-                                                                                                        :port => 80,
-                                                                                                        :name => "Web Site",
-                                                                                                        :description => "Web Servers",
-                                                                                                        :redirect_url => "http://fakey.com"
-                                                                                                      }, mock_public_ip.internet_service_collection
-                                                                                                      )
-
-                  mock_public_ip.internet_service_collection.items << MockPublicIpInternetService.new({
-                                                                                                        :protocol => "TCP",
-                                                                                                        :port => 7000,
-                                                                                                        :name => "An SSH Map",
-                                                                                                        :description => "SSH 2"
-                                                                                                      }, mock_public_ip.internet_service_collection
-                                                                                                      )
-                end
-
-                mock_vdc.public_ip_collection.items << MockPublicIp.new(:name => "99.1.9.7")
-
-                mock_vdc.internet_service_collection.backup_internet_services << MockBackupInternetService.new({ :port => 10000, :protocol => "TCP"}, self)
-              end
-
-              mock_organization.vdcs.detect {|v| v.name == "Rock-n-Roll" }.tap do |mock_vdc|
-                mock_vdc.public_ip_collection.items << MockPublicIp.new(:name => "99.99.99.99")
-              end
-            end
+      end
 
-            vcloud_mock_data.organizations.each do |organization|
-              organization.vdcs.each do |vdc|
-                vdc.networks.each do |network|
-                  network[:rnat] = vdc.public_ip_collection.items.first.name
-                end
-                vdc.virtual_machines.each do |virtual_machine|
-                  virtual_machine.disks << MockVirtualMachineDisk.new(:size => 25 * 1024)
-                  virtual_machine.disks << MockVirtualMachineDisk.new(:size => 50 * 1024)
-                end
-              end
-            end
+      class Mock
+        def self.data
+          @data ||= Hash.new do |hash, key|
+            hash[key] = {}
           end
         end
 
         def self.reset
-          @mock_data = nil
-        end
-
-        def self.data_reset
-          Fog::Logger.warning("#{self} => #data_reset is deprecated, use #reset instead [light_black](#{caller.first})[/]")
-          self.reset
-        end
-
-        def initialize(options = {})
-          require 'builder'
-          require 'fog/core/parser'
-
-          @versions_uri = URI.parse('https://vcloud.fakey.com/api/versions')
+          @data = nil
         end
 
-        def mock_data
-          Fog::Compute::Ecloud::Mock.data
+        def initialize(options={})
+          @ecloud_api_key = options[:ecloud]
         end
 
-        def mock_error(expected, status, body='', headers={})
-          raise Excon::Errors::Unauthorized.new("Expected(#{expected}) <=> Actual(#{status})")
+        def data
+          self.class.data[@ecloud_api_key]
         end
 
-        def mock_it(status, mock_data, mock_headers = {})
-          response = Excon::Response.new
-
-          #Parse the response body into a hash
-          if mock_data.empty?
-            response.body = mock_data
-          else
-            document = Fog::ToHashDocument.new
-            parser = Nokogiri::XML::SAX::PushParser.new(document)
-            parser << mock_data
-            parser.finish
-            response.body = document.body
-          end
-
-          response.status = status
-          response.headers = mock_headers
-          response
+        def reset_data
+          self.class.data.delete(@ecloud_api_key)
         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 })
+                :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
@@ -1128,142 +363,56 @@ module Fog
             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 })
+                :expects => #{args[1] || 200},
+                :method => '#{args[2] || 'GET'}',
+                :headers => #{args[3] ? args[3].inspect : '{}'},
+                :parse => true,
+                :uri => uri })
               end
             EOS
           end
-
         end
 
+
         def initialize(options = {})
           require 'builder'
           require 'fog/core/parser'
-
-          @connections = {}
-          @connection_options = options[:connection_options] || {}
-          @versions_uri = URI.parse(options[:ecloud_versions_uri])
-          @version    = options[:ecloud_version]
-          @username   = options[:ecloud_username]
-          @password   = options[:ecloud_password]
-          @persistent = options[:persistent] || false
-        end
-
-        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
+          @connections             = {}
+          @connection_options      = options[:connection_options] || {}
+          @host                    = options[:ecloud_host] || API_URL
+          @persistent              = options[:persistent] || false
+          @version                 = options[:ecloud_version] || "2012-03-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 RuntimeError, "No credentials (cloud auth, or basic auth) passed!"
             end
+          else
+            @hmac                  = Fog::HMAC.new("sha256", @private_key)
           end
         end
 
-        def reload
-          @connections.each_value { |k,v| v.reset if v }
+        def default_organization_uri
+          "/cloudapi/ecloud/organizations/"
         end
 
-        # If the cookie isn't set, do a get_organizations call to set it
-        # and try the request.
-        # If we get an Unauthorized error, we assume the token expired, re-auth and try again
         def request(params)
-          unless @cookie
-            do_login
-          end
           begin
             do_request(params)
           rescue Excon::Errors::Unauthorized => e
-            do_login
-            do_request(params)
-          end
-        end
-
-        def supporting_versions
-          ["v0.8b-ext2.6", "0.8b-ext2.6"]
-        end
-
-        private
-
-        def ensure_parsed(uri)
-          if uri.is_a?(String)
-            URI.parse(uri)
-          else
-            uri
+            raise RuntimeError, "Invalid authentication data: #{e}"
           end
         end
 
-        def supported_version_numbers
-          case supported_versions
-          when Array
-            supported_versions.map { |version| version[:Version] }
-          when Hash
-            [ supported_versions[:Version] ]
-          end
-        end
-
-        def get_login_uri
-          check_versions
-          URI.parse case supported_versions
-          when Array
-            supported_versions.detect {|version| version[:Version] == @version }[:LoginUrl]
-          when Hash
-            supported_versions[:LoginUrl]
-          end
-        end
-
-        # If we don't support any versions the service does, then raise an error.
-        # If the @version that super selected isn't in our supported list, then select one that is.
-        def check_versions
-          if @version
-            unless supported_version_numbers.include?(@version.to_s)
-              raise UnsupportedVersion.new("#{@version} is not supported by the server.")
-            end
-            unless supporting_versions.include?(@version.to_s)
-              raise UnsupportedVersion.new("#{@version} is not supported by #{self.class}")
-            end
-          else
-            unless @version = (supported_version_numbers & supporting_versions).sort.first
-              raise UnsupportedVersion.new("\nService @ #{@versions_uri} supports: #{supported_version_numbers.join(', ')}\n" +
-                                           "#{self.class} supports: #{supporting_versions.join(', ')}")
-            end
-          end
-        end
-
-        # Don't need to  set the cookie for these or retry them if the cookie timed out
-        def unauthenticated_request(params)
-          do_request(params)
-        end
-
-        # Use this to set the Authorization header for login
-        def authorization_header
-          "Basic #{Base64.encode64("#{@username}:#{@password}").chomp!}"
-        end
-
-        def login_uri
-          @login_uri ||= get_login_uri
-        end
-
-        # login handles the auth, but we just need the Set-Cookie
-        # header from that call.
-        def do_login
-          @login_results = login
-          @cookie = @login_results.headers['Set-Cookie']
-        end
-
-        # Actually do the request
         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(params[:uri])
+            params[:uri] = URI.parse(@host + params[:uri])
           end
           host_url = "#{params[:uri].scheme}://#{params[:uri].host}#{params[:uri].port ? ":#{params[:uri].port}" : ''}"
 
@@ -1272,24 +421,17 @@ module Fog
           @connections[host_url] ||= Fog::Connection.new(host_url, @persistent, @connection_options)
 
           # Set headers to an empty hash if none are set.
-          headers = params[:headers] || {}
-
-          # Add our auth cookie to the headers
-          if @cookie
-            headers.merge!('Cookie' => @cookie)
-          end
+          headers = set_extra_headers_for(params) || set_extra_headers_for({})
 
           # Make the request
-          response = @connections[host_url].request({
-            :body     => params[:body] || '',
-            :expects  => params[:expects] || 200,
-            :headers  => headers,
-            :method   => params[:method] || 'GET',
-            :path     => params[:uri].path
-          })
+          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.merge!({:body => params[:body]})
+          end
+          #puts options[:body].inspect
+          response = @connections[host_url].request(options)
 
           # Parse the response body into a hash
-          #puts response.body
           unless response.body.empty?
             if params[:parse]
               document = Fog::ToHashDocument.new
@@ -1300,12 +442,72 @@ module Fog
               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)
+         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'})
+           params[:headers].merge!({"Accept" => 'application/xml'})
+         end
+         unless 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
+
+        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.inject({}) {|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
 
+
     end
   end
 end