azure 0.0.0 → 0.1.0

data/lib/azure/queues/message.rb

@@ -0,0 +1,174 @@
+require "azure/queues"
+require "azure/queues/uri"
+require "azure/error"
+require "uri"
+require "time"
+
+module Azure
+  module Queues
+    # Public: Representation of a Message in a message queue.
+    class Message
+      include Azure::ErrorHandler
+
+      # The message queue for this message
+      #
+      # Returns a Azure::Queues::Queue object
+      attr_accessor :queue
+
+      # MessageId
+      # GUID value that identifies the message in the queue
+      #
+      # returns a String
+      attr_accessor :id
+
+      # InsertionTime
+      # UTC value formatted as described in RFC 1123
+      #
+      # Returns a String
+      attr_accessor :insertion_time
+
+      # ExpirationTime
+      # UTC value formatted as described in RFC 1123
+      #
+      # Returns a String
+      attr_accessor :expiration_time
+
+      # TimeNextVisible
+      # UTC value formatted as described in RFC 1123
+      #
+      # Returns a String
+      attr_accessor :time_next_visible
+
+      # PopReceipt
+      #
+      # Returns a String
+      attr_accessor :pop_receipt
+
+      # DequeueCount
+      # Has a value of 1 the first time the message is dequeued. This value is incremented each time the message is subsequently dequeued.
+      #
+      # Returns an Integer
+      attr_accessor :dequeue_count
+
+      # MessageText
+      #
+      # Returns a String
+      attr_accessor :text
+
+      # Amount of time in seconds the message remains invisible for GET
+      # operations.
+      #
+      # Returns an Integer.
+      attr_accessor :visibility_timeout
+
+      # Amount of seconds until this message expires.
+      #
+      # Returns an Integer.
+      attr_accessor :ttl
+
+      # Public: Instantiate a message from an XML entry.
+      #
+      # entry - An XML::Node element.
+      #
+      # Returns a Message.
+      def self.from_node(node)
+        pop_receipt       = (node % "PopReceipt")
+        time_next_visible = (node % "TimeNextVisible")
+        text              = (node % "MessageText").text
+
+        new(text) do |m|
+          m.id                = (node % "MessageId").text
+          m.insertion_time    = Time.parse((node % "InsertionTime").text)
+          m.expiration_time   = Time.parse((node % "ExpirationTime").text)
+          m.dequeue_count     = (node % "DequeueCount").text.to_i
+          m.pop_receipt       = pop_receipt && pop_receipt.text
+          m.time_next_visible = time_next_visible && Time.parse(time_next_visible.text)
+          yield m if block_given?
+        end
+      end
+
+      # Public: Instantiate a message from an error object.
+      #
+      # error - An Azure::Error.
+      #
+      # Returns a Message.
+      def self.from_error(error)
+        message = new(nil)
+        message.error = error
+        message
+      end
+
+      # Public: Attempt to convert an object into a Message. If the object can't
+      # be converted, we return nil.
+      #
+      # object - An object that might be converted into a Message.
+      #
+      # Returns a Message or nil.
+      def self.try_convert(object)
+        if object.respond_to?(:to_message)
+          object.to_message
+        elsif object.respond_to?(:to_str)
+          new(object.to_str)
+        end
+      end
+
+      # Public: Initialize the message.
+      #
+      # text    - The message text
+      # service - The Queue service to perform external calls.
+      def initialize(text, service=Azure::Queues)
+        @text = text
+        @visibility_timeout = 0
+        @ttl = 7 * 24 * 3600 # one week
+        @service = service
+        yield self if block_given?
+      end
+
+      # Public: Compare two messages to see if they are the same.
+      #
+      # other - A Message.
+      #
+      # Returns true|false.
+      def ==(other)
+        id == other.id
+      end
+
+      # Public: Deletes this message from the message queue.
+      #
+      # Returns true|false to indicate success.
+      def delete
+        @service.delete_message(self)
+      end
+
+      # Public: Updates this message with a new visibility timeout and new text
+      # if modified.
+      #
+      # Returns true|false to indicate success.
+      def update!
+        @service.update_message(self)
+      end
+
+      # Public: Turn this object into an Azure::Queues::Message. This is here
+      # just so we can use Message.try_convert and Message().
+      #
+      # Returns self.
+      def to_message
+        self
+      end
+    end
+
+    module ::Kernel
+      # Attempt to convert an object into a Message, or fail if the conversion
+      # can't be done.
+      #
+      # object - An object that might be converted into a message.
+      #
+      # Returns a Message.
+      # Raises ArgumentError if the object can't be converted into a Message.
+      def Message(object)
+        Message.try_convert(object) ||
+          raise(ArgumentError, "invalid value for Message(): #{object.inspect}")
+      end
+    end
+  end
+end

data/lib/azure/queues/queue.rb

@@ -0,0 +1,187 @@
+require "azure/queues"
+require "azure/queues/uri"
+require "azure/error"
+require "uri"
+
+module Azure
+  module Queues
+    # Public: Representation of a Queue in the storage system.
+    class Queue
+      include Azure::ErrorHandler
+
+      # Get the Queue's URI.
+      #
+      # Returns a URI.
+      attr :url
+
+      # Get the Queue's name.
+      #
+      # Returns a String.
+      attr :name
+
+      # Get the Queue's metadata.
+      #
+      # Returns a Hash.
+      attr_accessor :metadata
+
+      # Public: Instantiate a queue from an XML entry.
+      #
+      # entry - An XML::Node element.
+      #
+      # Returns a Queue.
+      def self.from_node(node)
+        name = (node % "Name").text
+        url  = URI((node % "Url").text)
+
+        metadata = (node / "Metadata *").each_with_object({}) do |n, metadata|
+          metadata[n.name] = n.text
+        end
+
+        new(name, url, metadata)
+      end
+
+      # Public: Instantiate a queue from an error object.
+      #
+      # error - An Azure::Error.
+      #
+      # Returns a Queue.
+      def self.from_error(error)
+        queue = new(nil)
+        queue.error = error
+        queue
+      end
+
+      # Public: Initialize the queue.
+      #
+      # name      - A String with the name of the queue.
+      # url       - The URI of the queue in the service.
+      # metadata  - A Hash with metadata key-value pairs.
+      # service   - The Queue service to perform external calls.
+      def initialize(name, url=Azure::Queues::URI.queue(name), metadata = {}, service=Azure::Queues)
+        @name = name
+        @url = url
+        @metadata = metadata
+        @service = service
+      end
+
+      # Public: Add a message into the queue.
+      #
+      # message - An Azure::Queues::Message.
+      #
+      # Returns self.
+      def push(message)
+        message = Message(message)
+
+        @service.put_message(self, message, {
+          visibilitytimeout: message.visibility_timeout,
+          messagettl:        message.ttl
+        })
+
+        self
+      end
+      alias_method :<<,  :push
+      alias_method :enq, :push
+
+      # Public: Get the latest message from the queue.
+      #
+      # options - A Hash of options (optional):
+      #           :visibilitytimeout - Update the message returned to be
+      #                                invisible for this many seconds
+      #                                (default: 0).
+      #
+      # Returns the message, or nil if the queue is empty.
+      def pop(options={})
+        get(1, options).first
+      end
+      alias_method :deq, :pop
+      alias_method :shift, :pop
+
+      # Public: Get a list of messages from the queue.
+      #
+      # num     - The amount of messages to peek (must be 1 <= num <= 32).
+      # options - A Hash of options (optional):
+      #           :visibilitytimeout - Update the messages returned to be
+      #                                invisible for this many seconds (must be
+      #                                1 second <= timeout <= 7 days).
+      #                                (default: 1 second).
+      #
+      # Returns an Array of Messages.
+      def get(num, options={})
+        options[:numofmessages] = num
+        @service.get_messages(self, options)
+      end
+
+      # Public: Peek the latest message from the queue (without changing its
+      # visibility).
+      #
+      # Returns the message, or nil if the queue is empty.
+      def peek
+        look_at(1).first
+      end
+
+      # Public: Peek a list of messages from the queue (without changing their
+      # visibility).
+      #
+      # num - The amount of messages to peek (must be 1 <= num <= 32).
+      #
+      # Returns an Array of Messages.
+      def look_at(num)
+        @service.peek_messages(self, numofmessages: num)
+      end
+
+      # Public: Remove all messages from the queue.
+      #
+      # Returns true|false to indicate success.
+      def clear
+        @service.clear_messages(self)
+      end
+
+      # Public: Compare two queues to see if they are the same.
+      #
+      # other - A queue.
+      #
+      # Returns true|false.
+      def ==(other)
+        name == other.name
+      end
+
+      # Public: Force a reload of this queue metadata from the server.
+      #
+      # Returns the Hash of metadata.
+      def load_metadata!
+        @service.load_metadata(self)
+      end
+
+      # Public: Put the current queue's metadata into the storage service.
+      #
+      # Returns true|false to indicate success.
+      def save_metadata!
+        @service.save_metadata(self)
+      end
+
+      # Public: Extracts metadata from a hash containing HTTP headers (so
+      # "x-ms-meta-Name" => "Foo" is extracted as "Name" => "Foo"). This
+      # replaces the metadata of this container.
+      #
+      # hash - A hash of String => String with HTTP header values.
+      #
+      # Returns a Hash with the extracted metadata.
+      def extract_metadata(hash)
+        new_metadata = hash.each_with_object({}) do |(k,v), hash|
+          if key = k[/^x-ms-meta-(?<key>.*)?/, :key]
+            hash[key] = v
+          end
+        end
+
+        metadata.replace(new_metadata)
+      end
+
+      # Public: Deletes this queue from the storage service.
+      #
+      # Returns true|false to indicate whether the delete was successful or not.
+      def delete
+        @service.delete(self)
+      end
+    end
+  end
+end

data/lib/azure/queues/service.rb

@@ -0,0 +1,263 @@
+require "azure/core/service"
+require "azure/core/auth/shared_key"
+require "azure/queues/uri"
+require "nokogiri"
+
+module Azure
+  module Queues
+
+    class Service < Core::Service
+      def initialize(signer=Azure::Core::Auth::SharedKey.new)
+        super(signer)
+      end
+    end
+
+    module Services
+
+      # Public: gets the properties of a storage account’s Queue Service.
+      class GetServiceProperties < Service
+
+        # Public: Invoke the service.
+        #
+        # options - Options for this query:
+        #           :timeout  - (optional) timeout for the request in seconds
+        #
+        # Returns a Response.
+        def call(options = {})
+          uri = Queues::URI.service_properties(options)
+
+          super(:get, uri)
+        end
+      end
+
+      # Public: sets the properties of a storage account’s Queue Service.
+      class SetServiceProperties < Service
+
+        # Public: Invoke the service.
+        #
+        # properties  - an Azure::Queues::ServiceProperties object
+        # options     - Options for this query:
+        #               :timeout  - (optional) timeout for the request in seconds
+        #
+        # Returns a Response.
+        def call(properties, options = {})
+          uri = Queues::URI.service_properties(options)
+
+          body = properties.to_xml
+
+          super(:put, uri, body)
+        end
+      end
+
+      # Public: List queues from a storage account
+      class ListQueues < Service
+        # Public: Invoke the service.
+        #
+        # options - A hash of options
+        #           :prefix           - Filters the results to return only
+        #                               queues with names that begin with the
+        #                               specified prefix.
+        #           :marker           - A string value that identifies the
+        #                               portion of the list to be returned
+        #                               with the next list operation.
+        #           :maxresults       - Specifies the maximum number of queues
+        #                               to return.
+        #
+        # Returns a Response.
+        def call(options)
+          uri = Queues::URI.collection(options)
+          super(:get, uri)
+        end
+      end
+
+      # Public: Add a queue to the storage account.
+      class CreateQueue < Service
+
+        # Public: Invoke the service.
+        #
+        # name     - The name of the new container.
+        # metadata - User defined metadata for this queue (default: {}).
+        #
+        # Returns a Response.
+        def call(name, metadata = {})
+          uri = Queues::URI.queue(name)
+
+          super(:put, uri) do |request|
+            metadata.each do |name, value|
+              request.headers["x-ms-meta-#{name}"] = value
+            end
+          end
+        end
+      end
+
+      # Public: Deletes a queue from the storage account.
+      class DeleteQueue < Service
+
+        # Public: Invoke the service.
+        #
+        # name     - The name of the queue.
+        #
+        # Returns a Response.
+        def call(name)
+          uri = Queues::URI.queue(name)
+          super(:delete, uri)
+        end
+      end
+
+      # Public: Get queue metadata
+      class GetMetadata < Service
+        # Public: Invoke the service.
+        #
+        # name - The queue name.
+        #
+        # Returns a Response.
+        def call(name)
+          uri = Queues::URI.queue(name, comp: "metadata")
+          super(:head, uri)
+        end
+      end
+
+      # Public: Set queue metadata.
+      class SetMetadata < Service
+        # Public: Invoke the service.
+        #
+        # name     - The queue name.
+        # metadata - User defined metadata for this queue.
+        #
+        # Returns a Response.
+        def call(name, metadata)
+          uri = Queues::URI.queue(name, comp: "metadata")
+
+          super(:put, uri) do |request|
+            metadata.each do |name, value|
+              request.headers["x-ms-meta-#{name}"] = value
+            end
+          end
+        end
+      end
+
+      ## Messages
+
+      # Public: Add a message to the message queue
+      class PutMessage < Service
+        # Public: Invoke the service.
+        #
+        # queue_name - The name of the queue.
+        # text       - The message's text.
+        # options    - A Hash of options for this message (optional):
+        #              :visibilitytimeout - Amount of seconds during which the
+        #                                   message will be invisible
+        #                                   (default: 0).
+        #              :messagettl        - Time in seconds until the message is
+        #                                   unreacable, between 1 second and 7
+        #                                   days (default: 7 days).
+        #
+        # Returns a Response.
+        def call(queue_name, text, options = {})
+          uri = Queues::URI.messages(queue_name, options)
+
+          body = Nokogiri::XML::Builder.new do |xml|
+            xml.QueueMessage {
+              xml.MessageText text
+            }
+          end
+
+          super(:post, uri, body.to_xml)
+        end
+      end
+
+      # Public: Get a list of messages from the front of the message queue.
+      class GetMessages < Service
+        # Public: Invoke the service.
+        #
+        # queue_name - The name of the message queue.
+        # options    - A Hash of options for this operation (optional):
+        #              :visibilitytimeout - Update the returned messages'
+        #                                   visibilitytimeout to this number (at
+        #                                   least 1, the default).
+        #              :numofmessages     - A number between 1 and 32 of messages
+        #                                   to return (default: 1).
+        #
+        # Returns a Response.
+        def call(queue_name, options={})
+          uri = Queues::URI.messages(queue_name, options)
+          super(:get, uri)
+        end
+      end
+
+      # Public: Peek at a list of messages from the front of the message queue.
+      class PeekMessages < Service
+        # Public: Invoke the service.
+        #
+        # queue_name - The name of the message queue.
+        # options    - A Hash of options for this operation (optional):
+        #              :numofmessages     - A number between 1 and 32 of messages
+        #                                   to return (default: 1).
+        #
+        # Returns a Response.
+        def call(queue_name, options={})
+          options.update(peekonly: 'true')
+          uri = Queues::URI.messages(queue_name, options)
+          super(:get, uri)
+        end
+      end
+
+      # Public: Deletes a message from the message queue.
+      class DeleteMessage < Service
+        # Public: Invoke the service.
+        #
+        # queue_name  - The name of the message queue.
+        # message_id  - The message id.
+        # pop_receipt - The receipt of a previous pop operation on this message.
+        #
+        # Returns a Response.
+        def call(queue_name, message_id, pop_receipt)
+          uri = Queues::URI.message(
+            queue_name, message_id, popreceipt: pop_receipt
+          )
+          super(:delete, uri)
+        end
+      end
+
+      # Public: Deletes all messages on the given queue.
+      class ClearMessages < Service
+        # Public: Invoke the service.
+        #
+        # queue_name - The name of the queue.
+        #
+        # Returns a Response.
+        def call(queue_name)
+          uri = Queues::URI.messages(queue_name)
+          super(:delete, uri)
+        end
+      end
+
+      # Public: Update a message from the message queue.
+      class UpdateMessage < Service
+        # Public: Invoke the service.
+        #
+        # queue_name  - The name of the message queue.
+        # message_id  - The message's id.
+        # text        - The message's new text.
+        # timeout     - A New visibilitytimeout for the message.
+        # pop_receipt - The receipt of a previous pop operation on this message.
+        #
+        # Returns a Response.
+        def call(queue_name, message_id, text, timeout, pop_receipt)
+          uri = Queues::URI.message(queue_name, message_id, {
+            popreceipt: pop_receipt, visibilitytimeout: timeout
+          })
+
+          body = Nokogiri::XML::Builder.new do |xml|
+            xml.QueueMessage {
+              xml.MessageText text
+            }
+          end
+
+          super(:put, uri, body.to_xml)
+        end
+      end
+
+    end
+  end
+end