fog 1.17.0 → 1.18.0

data/lib/fog/hp/models/storage/meta.rb

@@ -0,0 +1,29 @@
+require 'fog/core/model'
+require 'fog/hp/models/storage/meta_parent'
+
+module Fog
+  module Storage
+    class HP
+      class Meta < Fog::Model
+
+        include Fog::Storage::HP::MetaParent
+
+        identity :key
+        attribute :value
+
+        def destroy
+          false
+        end
+
+        def save
+          requires :identity, :value
+          if @parent.key
+            service.put_container(@parent.key, {key => value})
+            true
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/hp/models/storage/meta_parent.rb

@@ -0,0 +1,23 @@
+module Fog
+  module Storage
+    class HP
+      module MetaParent
+
+        def parent
+          @parent
+        end
+
+        def parent=(new_parent)
+          @parent = new_parent
+        end
+
+        def metas_to_hash(metas)
+          hash = {}
+          metas.each { |meta| hash.store(meta.key, meta.value) }
+          hash
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/hp/models/storage/metadata.rb

@@ -0,0 +1,82 @@
+require 'fog/core/collection'
+require 'fog/hp/models/storage/meta_parent'
+require 'fog/hp/models/storage/meta'
+
+module Fog
+  module Storage
+    class HP
+
+      class Metadata < Fog::Collection
+
+        model Fog::Storage::HP::Meta
+
+        include Fog::Storage::HP::MetaParent
+
+        def all
+          requires :parent
+          if @parent.key
+            metadata = service.head_container(@parent.key).headers
+            metas = []
+            metadata.each_pair {|k,v| metas << {'key' => k, 'value' => v} }
+            load(metas)
+          end
+        rescue Fog::Storage::HP::NotFound
+          nil
+        end
+
+        def destroy
+          false
+        end
+
+        def get(key)
+          requires :parent
+          if @parent.key
+            metadata = service.head_container(@parent.key).headers
+            metas = []
+            metas << {'key' => key, 'value' => metadata[key]}
+            new(metas[0])
+          end
+        rescue Fog::Storage::HP::NotFound
+          nil
+        end
+
+        def new(attributes = {})
+          requires :parent
+          super({ :parent => @parent }.merge!(attributes))
+        end
+
+        def set(data=nil)
+          requires :parent
+          if @parent.key
+            service.put_container(@parent.key, meta_hash(data))
+          end
+        end
+
+        def update(data=nil)
+          requires :parent
+          if @parent.key
+            service.post_container(@parent.key, meta_hash(data))
+          end
+        end
+
+
+        private
+        def meta_hash(data=nil)
+          if data.nil?
+            data={}
+            self.each do |meta|
+              if meta.is_a?(Fog::Storage::HP::Meta) then
+                data.store(meta.key, meta.value)
+              else
+                data.store(meta['key'], meta['value'])
+              end
+            end
+          end
+          data
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/hp/network.rb

@@ -0,0 +1,198 @@
+require 'fog/hp'
+
+module Fog
+  module HP
+    class Network < Fog::Service
+
+      requires    :hp_access_key, :hp_secret_key, :hp_tenant_id, :hp_avl_zone
+      recognizes  :hp_auth_uri, :credentials, :hp_service_type
+      recognizes  :persistent, :connection_options
+      recognizes  :hp_use_upass_auth_style, :hp_auth_version, :user_agent
+
+      secrets     :hp_secret_key
+
+      model_path 'fog/hp/models/network'
+      model       :floating_ip
+      collection  :floating_ips
+      model       :network
+      collection  :networks
+      model       :port
+      collection  :ports
+      model       :router
+      collection  :routers
+      model       :security_group
+      collection  :security_groups
+      model       :security_group_rule
+      collection  :security_group_rules
+      model       :subnet
+      collection  :subnets
+
+      request_path 'fog/hp/requests/network'
+      request :add_router_interface
+      request :associate_floating_ip
+      request :create_floating_ip
+      request :create_network
+      request :create_port
+      request :create_router
+      request :create_security_group
+      request :create_security_group_rule
+      request :create_subnet
+      request :disassociate_floating_ip
+      request :delete_floating_ip
+      request :delete_network
+      request :delete_port
+      request :delete_router
+      request :delete_security_group
+      request :delete_security_group_rule
+      request :delete_subnet
+      request :get_floating_ip
+      request :get_network
+      request :get_port
+      request :get_router
+      request :get_security_group
+      request :get_security_group_rule
+      request :get_subnet
+      request :list_floating_ips
+      request :list_networks
+      request :list_ports
+      request :list_routers
+      request :list_security_group_rules
+      request :list_security_groups
+      request :list_subnets
+      request :remove_router_interface
+      request :update_network
+      request :update_port
+      request :update_router
+      request :update_subnet
+
+      module Utils
+
+      end
+
+      class Mock
+        include Utils
+
+        def self.data
+          @data ||= Hash.new do |hash, key|
+            hash[key] = {
+              :floating_ips => {},
+              :networks => {
+                'X0X0X0ExtNetX0X0X0' =>
+                  {
+                    'id'              => 'X0X0X0ExtNetX0X0X0',
+                    'name'            => 'Mock-Ext-Net',
+                    'tenant_id'       => Fog::Mock.random_numbers(14).to_s,
+                    'status'          => 'ACTIVE',
+                    'subnets'         => [],
+                    'router:external' => true,
+                    'admin_state_up'  => true,
+                    'shared'          => true
+                  }
+              },
+              :ports => {},
+              :routers => {},
+              :security_groups => {},
+              :security_group_rules => {},
+              :subnets => {}
+            }
+          end
+        end
+
+        def self.reset
+          @data = nil
+        end
+
+        def initialize(options={})
+          @hp_access_key = options[:hp_access_key]
+        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
+        attr_reader :credentials
+
+        def initialize(options={})
+          @hp_access_key = options[:hp_access_key]
+          @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 network to the authentication call
+          options[:hp_service_type] ||= "Networking"
+          @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 network endpoint
+            @hp_network_uri = credentials[:endpoint_url]
+            @credentials = credentials
+          else
+            # Call the legacy v1.0/v1.1 authentication
+            credentials = Fog::HP.authenticate_v1(options, @connection_options)
+            # the user sends in the network endpoint
+            @hp_network_uri = options[:hp_auth_uri]
+          end
+
+          @auth_token = credentials[:auth_token]
+          @persistent = options[:persistent] || false
+
+          uri = URI.parse(@hp_network_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',
+                'Accept'       => 'application/json',
+                'X-Auth-Token' => @auth_token
+              }.merge!(params[:headers] || {}),
+              :path     => "#{@path}/v2.0/#{params[:path]}"
+            }), &block)
+          rescue Excon::Errors::HTTPStatusError => error
+            raise case error
+            when Excon::Errors::NotFound
+              Fog::HP::Network::NotFound.slurp(error)
+            else
+              error
+            end
+          end
+          if !response.body.empty? && parse_json && response.headers['Content-Type'] =~ %r{application/json}
+            if response.body.nil? || response.body == 'null'
+              response.body = ''
+            else
+              response.body = Fog::JSON.decode(response.body)
+            end
+          end
+          response
+        end
+
+      end
+
+    end
+  end
+end
+

data/lib/fog/hp/requests/block_storage_v2/create_snapshot.rb

@@ -0,0 +1,76 @@
+module Fog
+  module HP
+    class BlockStorageV2
+      class Real
+
+        # Create a new block storage snapshot
+        # The snapshot is created in the same availability_zone as the specified volume
+        #
+        # ==== Parameters
+        # * 'volume_id'<~String>  - UUId of the volume to create the snapshot from
+        # * options<~Hash>:
+        #   * 'display_name'<~String>        - Name of the snapshot
+        #   * 'display_description'<~String> - Description of the snapshot
+        #   * 'force'<~Boolean>  - true or false, defaults to false. It allows online snapshots (i.e. when volume is attached)
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * snapshot<~Hash>:
+        #       * 'id'<~String>: - UUId for the snapshot
+        #       * 'display_name'<~String>: - Name of the snapshot
+        #       * 'display_description'<~String>: - Description of the snapshot
+        #       * 'size'<~Integer>: - Size in GB for the snapshot
+        #       * 'status'<~String>: - Status of the snapshot i.e. "available"
+        #       * 'volume_id'<~String>: - UUId of the volume from which the snapshot was created
+        #       * 'created_at'<~String>: - Timestamp in UTC when volume was created
+        #       * metadata<~Hash>: Hash of metadata for the snapshot
+        def create_snapshot(volume_id, options={})
+          data = {
+            'snapshot' => {
+              'volume_id'  => volume_id
+            }
+          }
+
+          l_options = ['display_name', 'display_description', 'force']
+          l_options.select{|o| options[o]}.each do |key|
+            data['snapshot'][key] = options[key]
+          end
+
+          request(
+            :body     => Fog::JSON.encode(data),
+            :expects  => 200,
+            :method   => 'POST',
+            :path     => 'snapshots'
+          )
+        end
+
+      end
+
+      class Mock  # :nodoc:all
+
+        def create_snapshot(volume_id, options={})
+          response = Excon::Response.new
+          if self.data[:volumes][volume_id]
+            response.status = 200
+            data = {
+              'id'                  => Fog::HP::Mock.uuid.to_s,
+              'display_name'        => options['display_name'] || '',
+              'display_description' => options['display_description'] || '',
+              'size'                => self.data[:volumes][volume_id]['size'],
+              'status'              => 'available',
+              'volume_id'           => volume_id,
+              'created_at'          => Time.now.to_s
+            }
+            self.data[:snapshots][data['id']] = data
+            response.body = { 'snapshot' => data }
+          else
+            raise Fog::HP::BlockStorageV2::NotFound
+          end
+          response
+        end
+      end
+
+    end
+  end
+end

data/lib/fog/hp/requests/block_storage_v2/create_volume.rb

@@ -0,0 +1,90 @@
+module Fog
+  module HP
+    class BlockStorageV2
+      class Real
+
+        # Create a new block storage volume
+        #
+        # ==== Parameters
+        # * options<~Hash>:
+        #   * 'display_name'<~String> - Name of the volume
+        #   * 'display_description'<~String> - Description of the volume
+        #   * 'size'<~Integer> - Size of the volume (in GBs). Size is optional only if 'snapshot_id' is specified.
+        #   * 'snapshot_id'<~String> - UUId of the volume snapshot to create the volume from. The snapshot_id, imageRef and the source_volid parameters are mutually exclusive, and only one should be specified in the request.
+        #   * 'imageRef'<~String> - UUId of the image to create the volume from. This creates a bootable volume. The snapshot_id, imageRef and the source_volid parameters are mutually exclusive, and only one should be specified in the request.
+        #   * 'source_volid'<~String> - UUId of an 'available' volume to create the volume from. The request is invalid if the volume is not available. The snapshot_id, imageRef and the source_volid parameters are mutually exclusive, and only one should be specified in the request.
+        #   * 'availability_zone'<~String> - Availability zone where the volume should be created. Defaults to 'az1'.
+        #   * 'volume_type'<~String> - Type of the volume
+        #   * 'metadata'<~Hash> - Up to 5 key value pairs containing 255 bytes of info
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * volume<~Hash>:
+        #       * 'id'<~String> - UUId for the volume
+        #       * 'display_name'<~String> - Name of the volume
+        #       * 'display_description'<~String> - Description of the volume
+        #       * 'size'<~Integer> - Size in GB for the volume
+        #       * 'status'<~String> - Status of the volume i.e. "creating"
+        #       * 'volume_type'<~String> - Type of the volume
+        #       * 'snapshot_id'<~String> - UUId of the snapshot, the volume was created from.
+        #       * 'source_volid'<~String> - UUId of a volume, the volume was created from.
+        #       * 'created_at'<~String> - Timestamp in UTC when volume was created
+        #       * 'availability_zone'<~String> - Availability zone i.e. "az1"
+        #       * attachments<~Array>: Array of hashes of attachments
+        #       * metadata<~Hash>: Hash of metadata for the volume
+        def create_volume(options={})
+          data = {
+            'volume' => {}
+          }
+
+          l_options = ['display_name', 'display_description', 'size',
+                       'snapshot_id', 'imageRef', 'source_volid',
+                       'availability_zone', 'volume_type', 'metadata']
+          l_options.select{|o| options[o]}.each do |key|
+            data['volume'][key] = options[key]
+          end
+
+          request(
+            :body     => Fog::JSON.encode(data),
+            :expects  => 200,
+            :method   => 'POST',
+            :path     => 'volumes'
+          )
+        end
+
+      end
+
+      class Mock  # :nodoc:all
+
+        def create_volume(options={})
+          if options['snapshot_id'] && options['imageRef'] && options['source_volid']
+            raise Fog::Errors::BadRequest.new('The snapshot_id, imageRef and the source_volid parameters are mutually exclusive, and only one should be specified in the request.')
+          else
+            response = Excon::Response.new
+            response.status = 200
+            data = {
+              'id'                  => Fog::HP::Mock.uuid.to_s,
+              'status'              => 'available',
+              'display_name'        => options['display_name'] || '',
+              'attachments'         => [{}],
+              'availability_zone'   => options['availability_zone'] || 'az1',
+              'bootable'            => false,
+              'created_at'          => Time.now.to_s,
+              'display_description' => options['display_description'] || '',
+              'volume_type'         => 'None',
+              'snapshot_id'         => options['snapshot_id'] || '',
+              'source_volid'        => options['source_volid'] || '',
+              'metadata'            => options['metadata'] || {},
+              'size'                => options['size']
+            }
+            self.data[:volumes][data['id']] = data
+            response.body = { 'volume' => data }
+            response
+          end
+        end
+      end
+
+    end
+  end
+end