fog-maestrodev 1.15.0.20130927082724 → 1.18.0.20131111203459

data/lib/fog/rackspace/models/identity/service_catalog.rb

@@ -8,36 +8,51 @@ module Fog
         
         def initialize(attributes)
           @service = attributes.delete(:service)
-          @catalog = {}
+          @catalog = attributes.delete(:catalog) || {}
         end
         
         def services
-          catalog.keys
+          catalog.collect {|s| s["name"]}
         end
-        
-        def get_endpoints(service_type)
-          service_type = service_type.is_a?(String) ? service_type.to_sym : service_type
-          catalog[service_type]
+
+        def get_endpoints(service_name, service_net=false)
+          h = catalog.find {|service| service["name"] == service_name.to_s}
+          return {} unless h
+          key = network_type_key(service_net)
+          h["endpoints"].select {|e| e[key]}
         end
+
         
-        def display_service_regions(service_type)
-          endpoints = get_endpoints(service_type)
-          endpoints.collect { |k,v| ":#{k}" }.join(", ")
+        def display_service_regions(service_name, service_net=false)
+          endpoints = get_endpoints(service_name, service_net)
+          regions = endpoints.collect do |e|
+            e["region"] ? ":#{e["region"].downcase}" : ":global"
+          end
+          regions.join(", ")
         end
         
-        def get_endpoint(service_type, region=nil)
-          endpoint = get_endpoints(service_type)
-          raise "Unable to locate endpoint for service #{service_type}" unless endpoint
+        def get_endpoint(service_name, region=nil, service_net=false)
+          service_region = region_key(region)
+
+          network_type = network_type_key(service_net)
+
+          endpoints = get_endpoints(service_name, service_net)
+          raise "Unable to locate endpoint for service #{service_name}" if endpoints.empty?
+
+          if endpoints.size > 1 && region.nil?
+            raise "There are multiple endpoints available for #{service_name}. Please specify one of the following regions: #{display_service_regions(service_name)}."
+          end
 
-          return endpoint if endpoint.is_a?(String) #There is only one endpoint for service
+          # select multiple endpoints
+          endpoint = endpoints.find {|e| matching_region?(e, service_region) }
+          return endpoint[network_type] if endpoint && endpoint[network_type]
 
-          unless region
-            raise "There are multiple endpoints available for #{service_type}. Please specify one of the following regions: #{display_service_regions(service_type)}."
+          # endpoint doesnt have region
+          if endpoints.size == 1 && matching_region?(endpoints[0], "GLOBAL")
+            return endpoints[0][network_type]
           end
-          region = region.is_a?(String) ? region.to_sym : region
-          endpoint = get_endpoints(service_type)[region]
-          raise "Unknown region :#{region} for service #{service_type}. Please use one of the following regions: #{display_service_regions(service_type)}" unless endpoint
-          endpoint
+
+          raise "Unknown region :#{region} for service #{service_name}. Please use one of the following regions: #{display_service_regions(service_name)}"
         end
         
         def reload
@@ -47,52 +62,22 @@ module Fog
         end
                 
         def self.from_response(service, hash)
-          service_catalog = ServiceCatalog.new :service => service
-          begin
-            services = hash["access"]["serviceCatalog"]
-            services.each do |serv|
-              name = serv["name"] ? serv["name"].to_sym : nil
-              next unless name
-              service_catalog.send(:add_endpoints, name, serv)
-            end
-          rescue => e
-            Logger.warning "Exception occurred while loading service catalog - #{e.inspect}"
-            Logger.warning "Unable to load service catalog. Please specify endpoints manually"
-          end
-          service_catalog
+          ServiceCatalog.new :service => service, :catalog => hash["access"]["serviceCatalog"]
         end
 
         private
         
-        def add_endpoints(service_name, hash)
-          begin
-            endpoints = hash["endpoints"]
-            if endpoints.size == 1
-              catalog[service_name] = endpoints[0]["publicURL"].freeze
-            else
-              catalog[service_name] = endpoints_from_array(service_name, endpoints)
-            end
-          rescue => e
-            Logger.warning "Exception occurred while loading #{service_name} service endpoints - #{e.inspect}"
-            Logger.warning "Unable to load service endpoints for #{service_name}. Please specify #{service_name} endpoints manually."
-          end
+        def network_type_key(service_net)
+          service_net ? "internalURL" : "publicURL"
+        end
+
+        def matching_region?(h, region)
+          region_key(h["region"]) == region
         end
         
-        def endpoints_from_array(service_name, endpoints)
-          hash = {}
-          endpoints.each do |endpoint|
-            begin
-              region_name = endpoint["region"]
-              region = region_name ? region_name.downcase.to_sym : :global
-              url = endpoint["publicURL"].freeze
-              hash[region] = url
-            rescue => e
-              Logger.warning "Exception occurred while loading #{service_name} service endpoints - #{e.inspect}"
-              Logger.warning "Unable to parse #{service_name} endpoint - #{endpoint}"
-              Logger.warning "You may need to specify #{service_name} endpoints manually."
-            end
-          end
-          hash
+        def region_key(region)
+          return region.to_s.upcase if region.is_a? Symbol
+          (region.nil? || region.empty?) ? "GLOBAL" : region.to_s.upcase
         end
         
       end

data/lib/fog/rackspace/models/queues/claim.rb

@@ -0,0 +1,92 @@
+require 'fog/core/model'
+
+module Fog
+  module Rackspace
+    class Queues
+      class Claim < Fog::Model
+
+        identity :identity
+
+        attribute :grace
+        attribute :ttl
+        attribute :limit
+        attribute :messages
+
+        def save
+          if identity.nil?
+            create
+          else
+            update
+          end
+        end
+
+        def destroy
+          requires :identity, :queue
+          service.delete_claim(queue.name, identity)
+
+          #Since Claims aren't a server side collection, we should remove
+          # the claim from the collection.
+          collection.delete(self)
+
+          true
+        end
+
+        def messages=(messages)
+          #HACK - Models require a collection, but I don't really want to expose
+          # the messages collection to users here.
+          message_collection = Fog::Rackspace::Queues::Messages.new({
+              :service => service,
+              :queue => queue,
+              :client_id => service.client_id,
+              :echo => true
+            })
+          attributes[:messages] = messages.collect do |message|
+            if message.instance_of? Fog::Rackspace::Queues::Message
+              message
+            else
+              Fog::Rackspace::Queues::Message.new(
+                message.merge({
+                  :service => service,
+                  :collection => message_collection
+                }.merge(message))
+              )
+            end
+          end
+        end
+
+        private
+
+        def queue
+          collection.queue
+        end
+
+        def create
+          requires :queue, :ttl, :grace, :collection
+
+          options = {}
+          options[:limit] = limit unless limit.nil?
+
+          response = service.create_claim(queue.identity, ttl, grace, options)
+
+          if [200, 201].include? response.status
+            self.identity = response.headers['Location'].split('/').last
+            self.messages = response.body
+
+            #Since Claims aren't a server side collection, we need to
+            # add the claim to the collection
+            collection << self
+            true
+          else
+            false
+          end
+        end
+
+        def update
+          requires :identity, :queue, :ttl
+          service.update_claim(queue.identity, identity, ttl)
+          true
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/models/queues/claims.rb

@@ -0,0 +1,40 @@
+require 'fog/core/collection'
+require 'fog/rackspace/models/queues/claim'
+
+module Fog
+  module Rackspace
+    class Queues
+      class Claims < Fog::Collection
+
+        model Fog::Rackspace::Queues::Claim
+
+        attr_accessor :queue
+
+        def all
+          self
+        end
+
+        def create(attributes = {})
+          object = new(attributes)
+          if object.save
+            object
+          else
+            false
+          end
+        end
+
+        def get(claim_id)
+          requires :queue
+          data = service.get_claim(queue.identity, claim_id).body
+          new(data)
+        rescue Fog::Rackspace::Queues::NotFound
+          nil
+        # HACK - This has been escalated to the Rackspace Queues team, as this 
+        # behavior is not normal HTTP behavior.
+        rescue Fog::Rackspace::Queues::ServiceError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/models/queues/message.rb

@@ -0,0 +1,51 @@
+require 'fog/core/model'
+
+module Fog
+  module Rackspace
+    class Queues
+      class Message < Fog::Model
+
+        attribute :age
+        attribute :ttl
+        attribute :body
+        attribute :href
+        attribute :claim_id
+
+        def identity
+          if href
+            href.split('/').last
+          else
+            nil
+          end
+        end
+
+        def save
+          requires :queue, :client_id, :body, :ttl
+          raise "Message has already been created and may not be updated." unless identity.nil?
+          data = service.create_message(client_id, queue.name, body, ttl).body
+          self.href = data['resources'][0]
+          true
+        end
+
+        def destroy
+          requires :identity, :queue
+          options = {}
+          options[:claim_id] = claim_id unless claim_id.nil?
+
+          service.delete_message(queue.name, identity, options)
+          true
+        end
+
+        private
+
+        def queue
+          collection.queue
+        end
+
+        def client_id
+          collection.client_id
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/models/queues/messages.rb

@@ -0,0 +1,54 @@
+require 'fog/core/collection'
+require 'fog/rackspace/models/queues/message'
+
+module Fog
+  module Rackspace
+    class Queues
+      class Messages < Fog::Collection
+
+        model Fog::Rackspace::Queues::Message
+
+        attr_accessor :client_id
+        attr_accessor :queue
+        attr_accessor :echo
+        attr_accessor :limit
+        attr_accessor :marker
+        attr_accessor :include_claimed
+
+        def all
+          requires :client_id, :queue
+          response = service.list_messages(client_id, queue.name, options)
+          if response.status == 204
+            data = []
+          else
+            data = response.body['messages']
+          end
+          load(data)
+        end
+
+        def get(message_id)
+          requires :client_id, :queue
+          data = service.get_message(client_id, queue.name, message_id).body
+          new(data)
+        rescue Fog::Rackspace::Queues::NotFound
+          nil
+        # HACK - This has been escalated to the Rackspace Queues team, as this 
+        # behavior is not normal HTTP behavior.
+        rescue Fog::Rackspace::Queues::ServiceError
+          nil
+        end
+
+        private
+
+        def options
+          data = {}
+          data[:echo] = echo.to_s unless echo.nil?
+          data[:limit] = limit.to_s unless limit.nil?
+          data[:marker] = marker.to_s unless marker.nil?
+          data[:include_claimed] = include_claimed.to_s unless include_claimed.nil?
+          data
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/models/queues/queue.rb

@@ -0,0 +1,73 @@
+require 'fog/core/model'
+
+module Fog
+  module Rackspace
+    class Queues
+      class Queue < Fog::Model
+
+        identity :name
+
+        def messages
+          @messages ||= begin
+            Fog::Rackspace::Queues::Messages.new({
+              :service => service,
+              :queue => self,
+              :client_id => service.client_id,
+              :echo => true
+            })
+          end
+        end
+
+        def stats
+          service.get_queue_stats(name).body['messages']
+        end
+
+        def claims
+          @claims ||= begin
+            Fog::Rackspace::Queues::Claims.new({
+              :service => service,
+              :queue => self
+            })
+          end
+        end
+
+        #Helper method to enqueue a single message
+        def enqueue(body, ttl, options = {})
+          messages.create(options.merge(options.merge({:body => body, :ttl => ttl})))
+        end
+
+        #Helper method to claim (dequeue) a single message, including destroying it
+        def dequeue(ttl, grace, options = {}, &block)
+          claim = claims.create(
+            options.merge(
+            {
+              :limit => 1,
+              :ttl => ttl,
+              :grace => grace
+            }))
+
+          if claim
+            message = claim.messages.first
+            yield message
+            message.destroy
+            true
+          else
+            false
+          end
+        end
+
+        def save
+          requires :name
+          data = service.create_queue(name)
+          true
+        end
+
+        def destroy
+          requires :name
+          service.delete_queue(name)
+          true
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/models/queues/queues.rb

@@ -0,0 +1,32 @@
+require 'fog/core/collection'
+require 'fog/rackspace/models/queues/queue'
+
+module Fog
+  module Rackspace
+    class Queues
+      class Queues < Fog::Collection
+
+        model Fog::Rackspace::Queues::Queue
+
+        def all
+          response = service.list_queues
+          if service.list_queues.status == 204
+            data = []
+          else
+            data = service.list_queues.body['queues']
+          end
+          load(data)
+        end
+
+        def get(queue_name)
+          #204 no content is returned on success.  That's why no data is passed 
+          # from the GET to the constructor.
+          service.get_queue(queue_name)
+          new({:name => queue_name})
+        rescue Fog::Rackspace::Queues::NotFound
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -42,6 +42,11 @@ module Fog
         # @see http://docs.rackspace.com/files/api/v1/cf-devguide/content/CORS_Container_Header-d1e1300.html
         attribute :origin,          :aliases => ['Origin']
 
+        # @!attribute [rw] content_encoding
+        # @return [String] The content encoding of the file
+        # @see http://docs.rackspace.com/files/api/v1/cf-devguide/content/Enabling_File_Compression_with_the_Content-Encoding_Header-d1e2198.html
+        attribute :content_encoding, :aliases => 'Content-Encoding'
+
         # @!attribute [r] directory
         # @return [Fog::Storage::Rackspace::Directory] directory containing file
         attr_accessor :directory
@@ -87,6 +92,7 @@ module Fog
           options['Content-Type'] ||= content_type if content_type
           options['Access-Control-Allow-Origin'] ||= access_control_allow_origin if access_control_allow_origin
           options['Origin'] ||= origin if origin
+          options['Content-Encoding'] ||= content_encoding if content_encoding
           service.copy_object(directory.key, key, target_directory_key, target_file_key, options)
           target_directory = service.directories.new(:key => target_directory_key)
           target_directory.files.get(target_file_key)
@@ -160,6 +166,25 @@ module Fog
           directory.public?
         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
+        # @note This URL does not use the Rackspace CDN
+        #
+        def url(expires, options = {})
+          requires :key
+          if service.ssl?
+            service.get_object_https_url(directory.key, key, expires, options)
+          else
+            service.get_object_http_url(directory.key, key, expires, options)
+          end
+        end
+
         # Returns the public url for the file.
         # If the file has not been published to the CDN, this method will return nil as it is not publically accessible. This method will return the approprate
         # url in the following order:
@@ -228,6 +253,7 @@ module Fog
           options['Origin'] = origin if origin
           options['Content-Disposition'] = content_disposition if content_disposition
           options['Etag'] = etag if etag
+          options['Content-Encoding'] = content_encoding if content_encoding
           options.merge!(metadata.to_headers)
 
           data = service.put_object(directory.key, key, body, options)

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

@@ -137,6 +137,31 @@ module Fog
           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
+        # @note This URL does not use the Rackspace CDN
+        def get_http_url(key, expires, options = {})
+          requires :directory
+          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
+        # @note This URL does not use the Rackspace CDN
+        def get_https_url(key, expires, options = {})
+          service.get_object_https_url(directory.key, key, expires, options)
+        end
+
         # View directory detail without loading file contents
         # @param key of the object
         # @param options Required for compatibility with other Fog providers. Not Used.

data/lib/fog/rackspace/monitoring.rb

@@ -13,10 +13,26 @@ module Fog
       class IdentifierTaken < Fog::Errors::Error; end
       class ServiceError < Fog::Rackspace::Errors::ServiceError; end
       class InternalServerError < Fog::Rackspace::Errors::InternalServerError; end
-      class BadRequest < Fog::Rackspace::Errors::BadRequest; end
       class Conflict < Fog::Rackspace::Errors::Conflict; end
       class ServiceUnavailable < Fog::Rackspace::Errors::ServiceUnavailable; end
 
+
+      class BadRequest < Fog::Rackspace::Errors::BadRequest
+        attr_reader :validation_errors
+
+        def self.slurp(error, service=nil)
+          new_error = super(error)
+          if  new_error.response_data && new_error.response_data['details']
+            new_error.instance_variable_set(:@validation_errors, new_error.response_data['details'])
+          end
+
+          status_code = error.response ? error.response.status : nil
+          new_error.instance_variable_set(:@status_code, status_code)
+          new_error.set_transaction_id(error, service)
+          new_error
+        end
+      end
+
       requires :rackspace_api_key, :rackspace_username
       recognizes :rackspace_auth_url
       recognizes :persistent
@@ -82,6 +98,9 @@ module Fog
 
       request      :evaluate_alarm_example
 
+      request      :list_monitoring_zones
+      request      :get_monitoring_zone
+
 
       class Mock < Fog::Rackspace::Service