fog 1.9.0 → 1.10.0

data/lib/fog/glesys/models/compute/templates.rb

@@ -4,16 +4,34 @@ require 'fog/glesys/models/compute/template'
 module Fog
   module Compute
     class Glesys
-
       class Templates < Fog::Collection
 
-        model Fog::Glesys::Compute::Template
+        model Fog::Compute::Glesys::Template
 
         def all
-          openvz = service.template_list.body['response']['templates']['OpenVZ']
-          xen    = service.template_list.body['response']['templates']['Xen']
+          # Only select OpenVZ and Xen platforms
+          # Glesys only offers Xen and OpenVZ but they have other platforms in the list
+          images = platform :openvz, :xen
+          load(images)
+        end
+
+        def openvz
+          images = platform :openvz
+          load(images)
+        end
+
+        def xen
+          images = platform :xen
+          load(images)
+        end
+
+        private
 
-          load(xen+openvz)
+        def platform(*platforms)
+          images = service.template_list.body['response']['templates']
+          images.select do |platform, images|
+            platforms.include?(platform.downcase.to_sym)
+          end.collect{|platform, images| images}.flatten
         end
 
       end

data/lib/fog/glesys/requests/compute/ip_details.rb

@@ -3,8 +3,8 @@ module Fog
     class Glesys
       class Real
 
-        def ip_list_free(params)
-          request("/ip/listfree", params)
+        def ip_details(params)
+          request("/ip/details", params)
         end
       end
 

data/lib/fog/glesys/requests/compute/server_details.rb

@@ -3,8 +3,8 @@ module Fog
     class Glesys
       class Real
 
-        def server_details(serverid)
-          request("/server/details", { :serverid => serverid })
+        def server_details(serverid, options = {})
+          request("/server/details", { :serverid => serverid }.merge!(options) )
         end
       end
 

data/lib/fog/glesys/requests/compute/template_list.rb

@@ -3,8 +3,8 @@ module Fog
     class Glesys
       class Real
 
-        def template_list(options = {})
-          request("/server/templates", options)
+        def template_list
+          request("/server/templates")
         end
       end
 

data/lib/fog/hp.rb

@@ -2,6 +2,12 @@ require 'fog/core'
 
 module Fog
   module HP
+
+    # define a specific version for the HP Provider
+    unless const_defined?(:VERSION)
+      VERSION = '0.0.19'
+    end
+
     extend Fog::Provider
 
     module Errors
@@ -13,10 +19,14 @@ module Fog
             data = nil
             message = nil
           else
-            data = Fog::JSON.decode(error.response.body)
-            message = data['message']
-            if message.nil? and !data.values.first.nil?
-              message = data.values.first['message']
+            begin
+              data = Fog::JSON.decode(error.response.body)
+              message = data['message']
+              if message.nil? and !data.values.first.nil?
+                message = data.values.first['message']
+              end
+            rescue MultiJson::DecodeError
+              message = error.response.body  #### body is not in JSON format, so just return as is
             end
           end
 
@@ -29,6 +39,7 @@ module Fog
       class InternalServerError < ServiceError; end
       class Conflict < ServiceError; end
       class NotFound < ServiceError; end
+      class Forbidden < ServiceError; end
       class ServiceUnavailable < ServiceError; end
 
       class BadRequest < ServiceError
@@ -47,6 +58,7 @@ module Fog
     service(:cdn,     'hp/cdn',     'CDN')
     service(:compute, 'hp/compute', 'Compute')
     service(:storage, 'hp/storage', 'Storage')
+    service(:block_storage, 'hp/block_storage', 'BlockStorage')
 
     # legacy swauth 1.0/1.1 style authentication
     def self.authenticate_v1(options, connection_options = {})
@@ -61,14 +73,17 @@ module Fog
         @auth_path = "auth/v1.0"
       end
       service_url = "#{@scheme}://#{@host}:#{@port}"
+      # Set the User-Agent
+      @user_agent = options[:user_agent]
+      set_user_agent_header(connection_options, "fog/#{Fog::VERSION}", @user_agent)
       connection = Fog::Connection.new(service_url, false, connection_options)
-      @hp_account_id = options[:hp_account_id]
+      @hp_access_key = options[:hp_access_key]
       @hp_secret_key  = options[:hp_secret_key]
       response = connection.request({
         :expects  => [200, 204],
         :headers  => {
           'X-Auth-Key'  => @hp_secret_key,
-          'X-Auth-User' => @hp_account_id
+          'X-Auth-User' => @hp_access_key
         },
         :host     => @host,
         :port     => @port,
@@ -101,16 +116,19 @@ module Fog
         @auth_path = "v2.0/tokens"
       end
       service_url = "#{@scheme}://#{@host}:#{@port}"
+      # Set the User-Agent. If the caller sets a user_agent, use it.
+      @user_agent = options[:user_agent]
+      set_user_agent_header(connection_options, "fog/#{Fog::VERSION}", @user_agent)
       connection = Fog::Connection.new(service_url, false, connection_options)
 
       ### Implement HP Control Services Authentication services ###
       # Get the style of auth credentials passed, defaults to access/secret key style
       @hp_use_upass_auth_style = options[:hp_use_upass_auth_style] || false
-      @hp_account_id = options[:hp_account_id]
+      @hp_access_key = options[:hp_access_key]
       @hp_secret_key = options[:hp_secret_key]
       @hp_tenant_id  = options[:hp_tenant_id]
       @hp_service_type  = options[:hp_service_type]
-      @hp_avl_zone   = options[:hp_avl_zone] || :az1
+      @hp_avl_zone   = options[:hp_avl_zone]
 
       ### Decide which auth style to use
       unless (@hp_use_upass_auth_style)
@@ -118,7 +136,7 @@ module Fog
         request_body = {
             'auth' => {
                 'apiAccessKeyCredentials' => {
-                    'accessKey' => "#{@hp_account_id}",
+                    'accessKey' => "#{@hp_access_key}",
                     'secretKey' => "#{@hp_secret_key}"
                 }
             }
@@ -128,17 +146,17 @@ module Fog
         request_body = {
             'auth' => {
                 'passwordCredentials' => {
-                    'username' => "#{@hp_account_id}",
+                    'username' => "#{@hp_access_key}",
                     'password' => "#{@hp_secret_key}"
                 }
             }
         }
       end
       # add tenant_id if specified
-      request_body['auth']['tenantId'] = "#{@hp_tenant_id}" if @hp_tenant_id
+      request_body['auth']['tenantId'] = @hp_tenant_id if @hp_tenant_id
 
       ### Make the call to CS to get auth token and service catalog
-      response = service.request(
+      response = connection.request(
         {
           :expects => 200,
           :headers => {
@@ -157,9 +175,9 @@ module Fog
       ### fish out auth_token and endpoint for the service
       auth_token = body['access']['token']['id']
       endpoint_url = get_endpoint_from_catalog(body['access']['serviceCatalog'], @hp_service_type, @hp_avl_zone)
-      # If service is Storage, then get the CDN endpoint as well
-      if @hp_service_type == "object-store"
-        cdn_endpoint_url = get_endpoint_from_catalog(body['access']['serviceCatalog'], "hpext:cdn", @hp_avl_zone)
+      # If service is Storage, then get the CDN endpoint as well. 'Name' is unique instead of 'Type'
+      if @hp_service_type == "Object Storage"
+        cdn_endpoint_url = get_endpoint_from_catalog(body['access']['serviceCatalog'], "CDN", @hp_avl_zone)
       end
 
       return {
@@ -180,19 +198,31 @@ module Fog
     private
 
     def self.get_endpoint_from_catalog(service_catalog, service_type, avl_zone)
-      if service_catalog
-        service_item = service_catalog.select {|s| s["type"] == service_type}.first
-        if service_item and service_item['endpoints'] and
-          if avl_zone == :az1
-            endpoint_url = service_item['endpoints'][0]['publicURL'] if service_item['endpoints'][0]
-          elsif avl_zone == :az2
-            endpoint_url = service_item['endpoints'][1]['publicURL'] if service_item['endpoints'][1]
-          end
-          raise "Unable to retrieve endpoint service url from service catalog." if endpoint_url.nil?
-          return endpoint_url
+      raise "Unable to parse service catalog." unless service_catalog
+      service_item = service_catalog.detect do |s|
+        # 'Name' is unique instead of 'Type'
+        s["name"] == service_type
+      end
+      if service_item and service_item['endpoints']
+        endpoint = service_item['endpoints'].detect do |ep|
+          ep['region'] == avl_zone
         end
+        endpoint_url = endpoint['publicURL'] if endpoint
+        raise "Unable to retrieve endpoint service url for availability zone '#{avl_zone}' from service catalog. " if endpoint_url.nil?
+        return endpoint_url
+      end
+    end
+
+    def self.set_user_agent_header(conn_opts, base_str, client_str)
+      if client_str
+        user_agent = {'User-Agent' => base_str + " (#{client_str})"}
+      else
+        user_agent = {'User-Agent' => base_str}
+      end
+      if conn_opts[:headers]
+        conn_opts[:headers] = user_agent.merge!(conn_opts[:headers])
       else
-        raise "Unable to parse service catalog."
+        conn_opts[:headers] = user_agent
       end
     end
 

data/lib/fog/hp/CHANGELOG.hp

@@ -0,0 +1,113 @@
+0.0.19 18/01/2013
+=================
+- update Block Storage namespace to be Fog::HP::BlockStorage
+- merge with upstream fog v1.8.0
+- deprecate hp_account_id to use hp_access_key instead
+
+0.0.18 12/04/2012
+=================
+- add support for controlled access via cross-tenant ACLs
+- add support for creating bootable volumes
+- add support for creating persistent server instances using bootable volumes
+
+0.0.17 10/16/2012
+=================
+- add support for generating temporary urls
+- add support for retrieving encrypted password for Windows instances
+- add support for creating Windows instances
+
+0.0.16 08/15/2012
+=================
+- add support for User-Agent string in header
+- add support for Snapshots API to BlockStorage provider
+- add support for Volumes API to BlockStorage provider
+- add BlockStorage service to HP provider
+- upgrade to excon 0.14.0 to take advantage of instrumentation
+- add a head method for  the directories collection
+- update image model
+- update put_object and get_object to accept blocks
+
+0.0.15 06/08/2012
+=================
+- add metadata attribute in server and image models to manage metadata
+- add metadata model and request layer functionality with mocking support
+- add tests for metadata
+- upgrade to excon 0.13.0 to take advantage of ssl passthru functionality
+- add security_groups attribute to the server model
+- add support for future availability zones for all HP services
+- change hp_avl_zone to be a required parameter for all HP services
+- add support for console output in compute service
+- add helper method for cdn public ssl url
+- add tests for storage, compute and cdn services
+- improve quality of mocks to match real implementation
+
+0.0.14 02/23/2012
+=================
+ - minor fix for public ip address
+ - minor fix for exceptions raised by CDN service
+ - add keypair get/set methods to server model
+
+0.0.13 02/09/2012
+=================
+ - provide access to availability zones for compute
+ - minor fix for CS authentication uri
+ - update inline documentation
+ - update README_HP with copyright message
+
+0.0.12 02/02/2012
+=================
+ - integrate CS authentication
+ - refactor HP provider to work with legacy v1 authentication as well
+ - integrate CDN to work with Storage provider
+ - add additional attributes for CDN provider
+ - remove bits and add cores as alias to vcpus in flavor model
+ - update inline documentation
+ - update README_HP with copyright message
+
+0.0.11 01/09/2012
+=================
+ - add ability to customize various connection timeouts options
+ - add CDN service capabilities
+ - integrate the CDN service with the Storage service
+ - add a new CDN Uri option to Storage service
+ - incorporate Diablo 4 API changes
+    - update image, server and flavor models
+    - update create_image and create_server calls
+    - add rebuild_server and change_password_server calls
+ - new extensions APIs
+    - add keypair model and request layer with mocking support
+    - add security group model and request layer with mocking support
+    - add security group rule model and request layer with mocking support
+    - add address model and request layer with mocking support
+    - update server model with address management methods
+    - update server creation to use keypairs, security groups and other options
+ - update inline documentation
+
+0.0.10 10/18/2011
+=================
+ - merge with upstream fog v1.0.0
+
+0.0.9 09/21/2011
+================
+ - minor bug fixes
+ - add support for special char. including '?' in container and object names
+ - fix public_url for special char. in container and object names
+
+0.0.8 08/29/2011
+================
+ - add README_HP.rdoc
+ - add CHANGELOG.hp
+ - remove resize_server, confirm_resized_server and revert_resized_server from HP Cloud Compute
+
+0.0.7 08/10/2011
+================
+ - minor fixes
+ - added acl support to directory
+ - added public? method to directory model
+ - added mock support for HP Cloud Object Storage
+
+0.0.6 07/26/2011
+================
+ - initial release with name change to 'hpfog'
+ - HP provider for HP Cloud Object Storage
+ - HP provider for HP Cloud Compute

data/lib/fog/hp/README_HP.rdoc

@@ -29,11 +29,14 @@ If you should ever need to remove the library:
 The Ruby Fog library is well documented on the community web site at {fog.io}[http://fog.io], but for specific examples
 using HP's extensions, see:
 
-* {HP Cloud Fog library - Object Storage Examples}[https://build.hpcloud.com/bindings/fog/object-storage]
-* {HP Cloud Fog library - Compute Examples}[https://build.hpcloud.com/bindings/fog/compute]
-* {HP Cloud Fog library - CDN Examples}[https://build.hpcloud.com/bindings/fog/cdn]
+* {HP Cloud Fog library - Object Storage Examples}[https://docs.hpcloud.com/bindings/fog/object-storage]
+* {HP Cloud Fog library - Compute Examples}[https://docs.hpcloud.com/bindings/fog/compute]
+* {HP Cloud Fog library - CDN Examples}[https://docs.hpcloud.com/bindings/fog/cdn]
+* {HP Cloud Fog library - Block Storage Examples}[https://docs.hpcloud.com/bindings/fog/block-storage]
+
+Having trouble? Get help over at the {Forums}[https://community.hpcloud.com/forum] or
+at the {Knowledge Base}[https://community.hpcloud.com/knowledge-base] areas.
 
-Having trouble? {Get help over at the Forums}[https://connect.hpcloud.com]
 
 == Notice
 
@@ -56,5 +59,3 @@ PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 DEALINGS IN THE SOFTWARE.
-
-

data/lib/fog/hp/block_storage.rb

@@ -0,0 +1,169 @@
+require 'fog/hp'
+
+module Fog
+  module HP
+    class BlockStorage < Fog::Service
+
+      requires    :hp_secret_key, :hp_tenant_id, :hp_avl_zone
+      recognizes  :hp_auth_uri
+      recognizes  :persistent, :connection_options
+      recognizes  :hp_use_upass_auth_style, :hp_auth_version, :user_agent
+      recognizes  :hp_access_key, :hp_account_id  # :hp_account_id is deprecated use hp_access_key instead
+
+      secrets     :hp_secret_key
+
+      model_path  'fog/hp/models/block_storage'
+      model       :volume
+      collection  :volumes
+      collection  :bootable_volumes
+
+      model       :snapshot
+      collection  :snapshots
+
+      request_path 'fog/hp/requests/block_storage'
+      request :create_volume
+      request :delete_volume
+      request :get_bootable_volume_details
+      request :get_volume_details
+      request :list_bootable_volumes
+      request :list_volumes
+
+      request :create_snapshot
+      request :delete_snapshot
+      request :get_snapshot_details
+      request :list_snapshots
+
+      module Utils
+
+        def compute
+          @compute ||= Fog::Compute.new(
+            :provider       => 'HP',
+            :hp_access_key  => @hp_access_key,
+            :hp_secret_key  => @hp_secret_key,
+            :hp_auth_uri    => @hp_auth_uri,
+            :hp_tenant_id   => @hp_tenant_id,
+            :hp_avl_zone    => @hp_avl_zone,
+            :connection_options => @connection_options
+          )
+        end
+
+      end
+
+      class Mock
+        include Utils
+
+        def self.data
+          @data ||= Hash.new do |hash, key|
+            hash[key] = {
+              :volumes => {},
+              :snapshots => {}
+            }
+          end
+        end
+
+        def self.reset
+          @data = nil
+        end
+
+        def initialize(options={})
+          # deprecate hp_account_id
+          if options[:hp_account_id]
+            Fog::Logger.deprecation(":hp_account_id is deprecated, please use :hp_access_key instead.")
+            @hp_access_key = options.delete(:hp_account_id)
+          end
+          @hp_access_key = options[:hp_access_key]
+          unless @hp_access_key
+            raise ArgumentError.new("Missing required arguments: hp_access_key. :hp_account_id is deprecated, please use :hp_access_key instead.")
+          end
+        end
+
+        def data
+          self.class.data[@hp_access_key]
+        end
+
+        def reset_data
+          self.class.data.delete(@hp_access_key)
+        end
+
+      end
+
+      class Real
+        include Utils
+
+        def initialize(options={})
+          # deprecate hp_account_id
+          if options[:hp_account_id]
+            Fog::Logger.deprecation(":hp_account_id is deprecated, please use :hp_access_key instead.")
+            options[:hp_access_key] = options.delete(:hp_account_id)
+          end
+          @hp_access_key = options[:hp_access_key]
+          unless @hp_access_key
+            raise ArgumentError.new("Missing required arguments: hp_access_key. :hp_account_id is deprecated, please use :hp_access_key instead.")
+          end
+          @hp_secret_key = options[:hp_secret_key]
+          @hp_auth_uri   = options[:hp_auth_uri]
+          @connection_options = options[:connection_options] || {}
+          ### Set an option to use the style of authentication desired; :v1 or :v2 (default)
+          auth_version = options[:hp_auth_version] || :v2
+          ### Pass the service name for object storage to the authentication call
+          options[:hp_service_type] = "Block Storage"
+          @hp_tenant_id = options[:hp_tenant_id]
+          @hp_avl_zone  = options[:hp_avl_zone]
+
+          ### Make the authentication call
+          if (auth_version == :v2)
+            # Call the control services authentication
+            credentials = Fog::HP.authenticate_v2(options, @connection_options)
+            # the CS service catalog returns the block storage endpoint
+            @hp_block_uri = credentials[:endpoint_url]
+          else
+            # Call the legacy v1.0/v1.1 authentication
+            credentials = Fog::HP.authenticate_v1(options, @connection_options)
+            # the user sends in the block storage endpoint
+            @hp_block_uri = options[:hp_auth_uri]
+          end
+
+          @auth_token = credentials[:auth_token]
+          @persistent = options[:persistent] || false
+
+          uri = URI.parse(@hp_block_uri)
+          @host   = uri.host
+          @path   = uri.path
+          @port   = uri.port
+          @scheme = uri.scheme
+
+          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}", @persistent, @connection_options)
+        end
+
+        def reload
+          @connection.reset
+        end
+
+        def request(params, parse_json = true, &block)
+          begin
+            response = @connection.request(params.merge!({
+              :headers  => {
+                'Content-Type' => 'application/json',
+                'X-Auth-Token' => @auth_token
+              }.merge!(params[:headers] || {}),
+              :host     => @host,
+              :path     => "#{@path}/#{params[:path]}",
+            }), &block)
+          rescue Excon::Errors::HTTPStatusError => error
+            raise case error
+            when Excon::Errors::NotFound
+              Fog::HP::BlockStorage::NotFound.slurp(error)
+            else
+              error
+            end
+          end
+          if !response.body.empty? && parse_json && response.headers['Content-Type'] =~ %r{application/json}
+            response.body = Fog::JSON.decode(response.body)
+          end
+          response
+        end
+
+      end
+    end
+  end
+end