fog-maestrodev 1.15.0.20130927082724 → 1.18.0.20131111203459

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

@@ -1,5 +1,6 @@
 require 'fog/core/model'
 require 'fog/hp/models/storage/files'
+require 'fog/hp/models/storage/metadata'
 
 module Fog
   module Storage
@@ -7,12 +8,16 @@ module Fog
 
       class Directory < Fog::Model
 
-        identity  :key,       :aliases => 'name'
+        identity  :key,               :aliases => 'name'
 
-        attribute :bytes,     :aliases => 'X-Container-Bytes-Used'
-        attribute :count,     :aliases => 'X-Container-Object-Count'
-        attribute :sync_to,   :aliases => 'X-Container-Sync-To'
-        attribute :sync_key,  :aliases => 'X-Container-Sync-Key'
+        attribute :bytes,             :aliases => 'X-Container-Bytes-Used'
+        attribute :count,             :aliases => 'X-Container-Object-Count'
+        attribute :sync_to,           :aliases => 'X-Container-Sync-To'
+        attribute :sync_key,          :aliases => 'X-Container-Sync-Key'
+        attribute :web_index,         :aliases => 'X-Container-Meta-Web-Index'
+        attribute :web_listings,      :aliases => 'X-Container-Meta-Web-Listings'
+        attribute :web_listings_css,  :aliases => 'X-Container-Meta-Web-Listings-Css'
+        attribute :web_error,         :aliases => 'X-Container-Meta-Web-Error'
 
         def initialize(attributes = {})
             @read_acl  = []
@@ -96,6 +101,21 @@ module Fog
           true
         end
 
+        def metadata
+          @metadata ||= begin
+            Fog::Storage::HP::Metadata.new({
+              :service => service,
+              :parent => self
+            })
+          end
+        end
+
+        def metadata=(new_metadata={})
+          metas = []
+          new_metadata.each_pair {|k,v| metas << {'key' => k, 'value' => v} }
+          metadata.load(metas)
+        end
+
         def destroy
           requires :key
           service.delete_container(key)
@@ -234,6 +254,16 @@ module Fog
           options.merge!(service.perm_acl_to_header(@read_acl, @write_acl))
           options.merge!({'X-Container-Sync-To' => self.sync_to}) unless self.sync_to.nil?
           options.merge!({'X-Container-Sync-Key' => self.sync_key}) unless self.sync_key.nil?
+          options.merge!({'X-Container-Meta-Web-Index' => self.web_index}) unless self.web_index.nil?
+          options.merge!({'X-Container-Meta-Web-Listings' => self.web_listings})
+          options.merge!({'X-Container-Meta-Web-Listings-Css' => self.web_listings_css}) unless self.web_listings_css.nil?
+          options.merge!({'X-Container-Meta-Web-Error' => self.web_error}) unless self.web_error.nil?
+          # get the metadata and merge them in
+          meta_hash = {}
+          metadata.each { |meta| meta_hash.store(meta.key, meta.value) }
+          if meta_hash
+            options.merge!(meta_hash)
+          end
           service.put_container(key, options)
           # Added an extra check to see if CDN is enabled for the container
           if (!service.cdn.nil? && service.cdn.enabled?)
@@ -241,8 +271,9 @@ module Fog
             if @cdn_enable
               # check to make sure that the container exists. If yes, cdn enable it.
               begin response = service.cdn.head_container(key)
-                ### Deleting a container from CDN is much more expensive than flipping the bit to disable it
-                service.cdn.post_container(key, {'X-CDN-Enabled' => 'True'})
+                if response.headers['X-Cdn-Enabled'] == 'False'
+                  service.cdn.post_container(key, {'X-Cdn-Enabled' => 'True'})
+                end
               rescue Fog::CDN::HP::NotFound
                 service.cdn.put_container(key)
               rescue Excon::Errors::SocketError
@@ -252,7 +283,9 @@ module Fog
               # check to make sure that the container exists. If yes, cdn disable it.
               begin response = service.cdn.head_container(key)
                 ### Deleting a container from CDN is much more expensive than flipping the bit to disable it
-                service.cdn.post_container(key, {'X-CDN-Enabled' => 'False'})
+                if response.headers['X-Cdn-Enabled'] == 'True'
+                  service.cdn.post_container(key, {'X-Cdn-Enabled' => 'False'})
+                end
               rescue Fog::CDN::HP::NotFound
                 # just continue, as container is not cdn-enabled.
               rescue Excon::Errors::SocketError

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

@@ -60,6 +60,18 @@ module Fog
           self.collection.get_url(self.key)
         end
 
+        # Get a url for file.
+        # 
+        # required attributes: key
+        # 
+        # @param expires [String] number of seconds (since 1970-01-01 00:00) before url expires
+        # @param options [Hash]
+        # @return [String] url
+        def url(expires, options = {})
+          requires :directory,:key
+          service.create_temp_url(directory.key, key, expires, "GET", options)
+        end
+
         def cdn_public_url
           requires :key
           self.collection.get_cdn_url(self.key)

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

@@ -71,7 +71,29 @@ module Fog
             "#{self.directory.public_url}/#{Fog::HP.escape(key)}"
           end
         end
-
+        
+        # Get a temporary http url for a file.
+        # 
+        # required attributes: key
+        # @param key [String] the key of the file within the directory
+        # @param expires [String] number of seconds (since 1970-01-01 00:00) before url expires
+        # @param options [Hash]
+        # @return [String] url
+        def get_http_url(key, expires, options = {})
+          service.get_object_http_url(directory.key, key, expires, options)
+        end
+        
+        # Get a temporary https url for a file.
+        # 
+        # required attributes: key
+        # @param key [String] the key of the file within the directory
+        # @param expires [String] number of seconds (since 1970-01-01 00:00) before url expires
+        # @param options [Hash]
+        # @return [String] url
+        def get_https_url(key, expires, options = {})
+          service.get_object_https_url(directory.key, key, expires, options)
+        end
+        
         def get_cdn_url(key)
           requires :directory
           if self.directory.cdn_public_url

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