fog 1.9.0 → 1.10.0

data/lib/fog/hp/cdn.rb

@@ -5,8 +5,11 @@ module Fog
   module CDN
     class HP < Fog::Service
 
-      requires    :hp_secret_key, :hp_account_id, :hp_tenant_id
-      recognizes  :hp_auth_uri, :hp_cdn_uri, :persistent, :connection_options, :hp_use_upass_auth_style, :hp_auth_version
+      requires    :hp_secret_key, :hp_tenant_id, :hp_avl_zone
+      recognizes  :hp_auth_uri, :hp_cdn_uri
+      recognizes  :hp_use_upass_auth_style, :hp_auth_version, :user_agent
+      recognizes  :persistent, :connection_options
+      recognizes  :hp_access_key, :hp_account_id  # :hp_account_id is deprecated use hp_access_key instead
 
       secrets     :hp_secret_key
 
@@ -39,15 +42,23 @@ module Fog
         end
 
         def initialize(options={})
-          @hp_account_id = options[:hp_account_id]
+          # 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_account_id]
+          self.class.data[@hp_access_key]
         end
 
         def reset_data
-          self.class.data.delete(@hp_account_id)
+          self.class.data.delete(@hp_access_key)
         end
 
       end
@@ -56,11 +67,22 @@ module Fog
         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]
           @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 type for object storage to the authentication call
-          options[:hp_service_type] = "hpext:cdn"
+          ### Pass the service name for object storage to the authentication call
+          options[:hp_service_type] = "CDN"
+          @hp_tenant_id = options[:hp_tenant_id]
 
           ### Make the authentication call
           if (auth_version == :v2)

data/lib/fog/hp/compute.rb

@@ -5,8 +5,11 @@ module Fog
   module Compute
     class HP < Fog::Service
 
-      requires    :hp_secret_key, :hp_account_id, :hp_tenant_id
-      recognizes  :hp_auth_uri, :hp_servicenet, :persistent, :connection_options, :hp_use_upass_auth_style, :hp_auth_version, :hp_avl_zone
+      requires    :hp_secret_key, :hp_tenant_id, :hp_avl_zone
+      recognizes  :hp_auth_uri
+      recognizes  :hp_use_upass_auth_style, :hp_auth_version, :user_agent
+      recognizes  :persistent, :connection_options
+      recognizes  :hp_access_key, :hp_account_id  # :hp_account_id is deprecated use hp_access_key instead
 
       secrets     :hp_secret_key
 
@@ -19,6 +22,8 @@ module Fog
       collection  :images
       model       :key_pair
       collection  :key_pairs
+      model       :meta
+      collection  :metadata
       model       :security_group
       collection  :security_groups
       model       :server
@@ -27,6 +32,7 @@ module Fog
       request_path 'fog/hp/requests/compute'
       request :allocate_address
       request :associate_address
+      request :attach_volume
       request :change_password_server
       #request :confirm_resized_server
       request :create_image
@@ -34,15 +40,21 @@ module Fog
       request :create_security_group
       request :create_security_group_rule
       request :create_server
+      request :create_persistent_server
       request :delete_image
       request :delete_key_pair
+      request :delete_meta
       request :delete_security_group
       request :delete_security_group_rule
       request :delete_server
+      request :detach_volume
       request :disassociate_address
       request :get_address
+      request :get_console_output
       request :get_flavor_details
       request :get_image_details
+      request :get_meta
+      request :get_windows_password
       request :get_security_group
       request :get_server_details
       request :list_addresses
@@ -51,10 +63,12 @@ module Fog
       request :list_images
       request :list_images_detail
       request :list_key_pairs
+      request :list_metadata
       request :list_security_groups
       request :list_server_addresses
       request :list_server_private_addresses
       request :list_server_public_addresses
+      request :list_server_volumes
       request :list_servers
       request :list_servers_detail
       request :reboot_server
@@ -63,9 +77,55 @@ module Fog
       #request :resize_server
       #request :revert_resized_server
       request :server_action
+      request :set_metadata
+      request :update_meta
+      request :update_metadata
       request :update_server
 
+      module Utils
+
+        # extract windows password from log
+        def extract_password_from_log(log_text)
+          encrypted_text = ""
+          section        = []
+          return if log_text.nil?
+          log_text.each_line do |line|
+            case line
+              when /^-----BEGIN (\w+)/
+                section.push $1
+                next
+              when /^-----END (\w+)/
+                section.pop
+                next
+            end
+
+            case section
+              when ["BASE64"]
+                encrypted_text << line
+            end
+          end
+          # return the encrypted portion only
+          encrypted_text
+        end
+
+        def encrypt_using_public_key(text, public_key_data)
+          return if (text.nil? || public_key_data.nil?)
+          public_key = OpenSSL::PKey::RSA.new(public_key_data)
+          encrypted_text = public_key.public_encrypt(text).strip
+          Base64.encode64(encrypted_text)
+        end
+
+        def decrypt_using_private_key(encrypted_text, private_key_data)
+          return if (encrypted_text.nil? || private_key_data.nil?)
+          private_key = OpenSSL::PKey::RSA.new(private_key_data)
+          from_base64 = Base64.decode64(encrypted_text)
+          private_key.private_decrypt(from_base64).strip
+        end
+
+      end
+
       class Mock
+        include Utils
 
         def self.data
           @data ||= Hash.new do |hash, key|
@@ -91,30 +151,46 @@ module Fog
         end
 
         def initialize(options={})
-          @hp_account_id = options[:hp_account_id]
+          # 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_account_id]
+          self.class.data[@hp_access_key]
         end
 
         def reset_data
-          self.class.data.delete(@hp_account_id)
+          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_account_id = options[:hp_account_id]
-          @hp_servicenet = options[:hp_servicenet]
           @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 type for compute via the options hash
-          options[:hp_service_type] = "compute"
+          ### Pass the service name for compute via the options hash
+          options[:hp_service_type] = "Compute"
           @hp_tenant_id = options[:hp_tenant_id]
 
           ### Make the authentication call
@@ -133,12 +209,11 @@ module Fog
           @auth_token = credentials[:auth_token]
 
           uri = URI.parse(@hp_compute_uri)
-          @host   = @hp_servicenet == true ? "snet-#{uri.host}" : uri.host
+          @host   = uri.host
           @path   = uri.path
           @persistent = options[:persistent] || false
           @port   = uri.port
           @scheme = uri.scheme
-          Excon.ssl_verify_peer = false if options[:hp_servicenet] == true
 
           @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}", @persistent, @connection_options)
         end
@@ -166,12 +241,8 @@ module Fog
               error
             end
           end
-          unless response.body.empty?
-            begin
-              response.body = Fog::JSON.decode(response.body)
-            rescue MultiJson::DecodeError => error
-              response.body    #### the body is not in JSON format so just return it as it is
-            end
+          if !response.body.empty? && parse_json && response.headers['Content-Type'] =~ %r{application/json}
+            response.body = Fog::JSON.decode(response.body)
           end
           response
         end

data/lib/fog/hp/models/block_storage/bootable_volumes.rb

@@ -0,0 +1,28 @@
+require 'fog/core/collection'
+require 'fog/hp/models/block_storage/volume'
+
+module Fog
+  module HP
+    class BlockStorage
+
+      class BootableVolumes < Fog::Collection
+
+        model Fog::HP::BlockStorage::Volume
+
+        def all
+          data = service.list_bootable_volumes.body['volumes']
+          load(data)
+        end
+
+        def get(volume_id)
+          volume = service.get_bootable_volume_details(volume_id).body['volume']
+          new(volume)
+        rescue Fog::HP::BlockStorage::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/hp/models/block_storage/snapshot.rb

@@ -0,0 +1,56 @@
+require 'fog/core/model'
+
+module Fog
+  module HP
+    class BlockStorage
+
+      class Snapshot < Fog::Model
+
+        identity  :id
+
+        attribute :name,                 :aliases => 'displayName'
+        attribute :description,          :aliases => 'displayDescription'
+        attribute :size
+        attribute :status
+        attribute :created_at,           :aliases => 'createdAt'
+        attribute :volume_id,            :aliases => 'volumeId'
+        #attribute :metadata
+
+        def initialize(attributes = {})
+          # assign these attributes first to prevent race condition with persisted?
+          self.force = attributes.delete(:force)   # force snapshotting of attached volumes
+          super
+        end
+
+        def destroy
+          requires :id
+          service.delete_snapshot(id)
+          true
+        end
+
+        def force=(new_force)
+          @force = new_force
+        end
+
+        def ready?
+          self.status == 'available'
+        end
+
+        def save
+          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if persisted?
+          requires :name, :volume_id
+          options = {
+            #'metadata'        => metadata,      # TODO: Add metadata when snapshots support it
+            'force'           => @force
+          }
+          options = options.reject {|key, value| value.nil?}
+          data = service.create_snapshot(name, description, volume_id, options)
+          merge_attributes(data.body['snapshot'])
+          true
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/hp/models/block_storage/snapshots.rb

@@ -0,0 +1,29 @@
+require 'fog/core/collection'
+require 'fog/hp/models/block_storage/snapshot'
+
+module Fog
+  module HP
+    class BlockStorage
+
+      class Snapshots < Fog::Collection
+
+        model Fog::HP::BlockStorage::Snapshot
+
+        def all
+          data = service.list_snapshots.body['snapshots']
+          load(data)
+        end
+
+        def get(snapshot_id)
+          if snapshot = service.get_snapshot_details(snapshot_id).body['snapshot']
+            new(snapshot)
+          end
+        rescue Fog::HP::BlockStorage::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/hp/models/block_storage/volume.rb

@@ -0,0 +1,102 @@
+require 'fog/core/model'
+
+module Fog
+  module HP
+    class BlockStorage
+
+      class Volume < Fog::Model
+
+        identity  :id
+
+        attribute :name,                 :aliases => 'displayName'
+        attribute :description,          :aliases => 'displayDescription'
+        attribute :size
+        attribute :status
+        attribute :type,                 :aliases => 'volumeType'
+        attribute :created_at,           :aliases => 'createdAt'
+        attribute :availability_zone,    :aliases => 'availabilityZone'
+        attribute :snapshot_id,          :aliases => 'snapshotId'
+        attribute :source_image_id,      :aliases => 'sourceImageRef'   # only for bootable volumes
+        attribute :attachments
+        attribute :metadata
+
+        attr_reader :server_id
+        attr_reader :device
+
+        def initialize(attributes = {})
+          # assign these attributes first to prevent race condition with new_record?
+          self.image_id = attributes.delete(:image_id)
+          super
+        end
+
+        def device
+          attachments[0]['device'] if has_attachments?
+        end
+
+        def server_id
+          attachments[0]['serverId'] if has_attachments?
+        end
+
+        # used for creating bootable volumes
+        def image_id=(new_image_id)
+          @image_id = new_image_id
+        end
+
+        # a volume can be attached to only one server at a time
+        def has_attachments?
+          !(attachments.nil? || attachments.empty? || attachments[0].empty?)
+        end
+
+        def in_use?
+          self.status == 'in-use'
+        end
+
+        def ready?
+          self.status == 'available'
+        end
+
+        # volume can be attached to only one server at a time
+        def attach(new_server_id, device)
+          requires :id
+          unless in_use?
+            data = service.compute.attach_volume(new_server_id, id, device)
+            merge_attributes(:attachments => attachments << data.body['volumeAttachment'])
+            true
+          else
+            false
+          end
+        end
+
+        def detach
+          requires :id
+          if has_attachments?
+            service.compute.detach_volume(server_id, id)
+          end
+          true
+        end
+
+        def destroy
+          requires :id
+          service.delete_volume(id)
+          true
+        end
+
+        def save
+          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if persisted?
+          requires :name, :size
+          options = {
+            'metadata'          => metadata,
+            'snapshot_id'       => snapshot_id,
+            'imageRef'          => @image_id
+          }
+          options = options.reject {|key, value| value.nil?}
+          data = service.create_volume(name, description, size, options)
+          merge_attributes(data.body['volume'])
+          true
+        end
+
+      end
+
+    end
+  end
+end