azure 0.0.0 → 0.1.0

data/lib/azure/service_bus/queues.rb

@@ -0,0 +1,194 @@
+require "nokogiri"
+require "azure/service_bus/queues/queue"
+require "azure/service_bus/queues/queue_serializer"
+require "azure/service_bus/brokered_message"
+require "azure/service_bus/brokered_message_serializer"
+require "azure/service_bus/queues/service"
+
+module Azure
+  module ServiceBus
+    module Queues
+      # Public: Try to create a new queue. If the operation is unsuccessful,
+      # the resulting Queue object will have the error accessible through the
+      # #error method.
+      #
+      # name        - The name of the queue.
+      # properties  - Properties hash describing this queue (optional, default: {}).
+      # service     - The backend service to implement this (optional).
+      #
+      # Returns a Queue.
+      def self.create(name, props={}, service=Services::Create.new)
+        serializer = QueueSerializer.new(props)
+        xml = serializer.to_xml
+        response = service.call(name, xml)
+
+        if response.success?
+          node = Nokogiri::XML(response.body)
+          Queue.from_node(node)
+        else
+          Queue.from_error(response.error)
+        end
+      end
+
+      # Public: Delete a Queue from the server. If the delete operation fails,
+      # the queue is invalidated. Otherwise it's frozen.
+      #
+      # queue   - An Azure::ServiceBus::Queue.
+      # service - The backend service to implement this (optional).
+      #
+      # Returns true|false to indicate success.
+      def self.delete(queue, service=Services::Delete.new)
+        response = service.call(queue.name)
+
+        if response.success?
+          queue.freeze
+        else
+          queue.error = response.error
+        end
+
+        response.success?
+      end
+
+      # Public: Get a queue by name. If the operation fails,
+      # the resulting Queue object will have the error accessible through the
+      # #error method.
+      #
+      # service - The backend service to implement this (optional).
+      #
+      # Returns a Queue
+      def self.get(queue_name, service=Services::Get.new)
+        response = service.call(queue_name)
+
+        if response.success?
+          node = Nokogiri::XML(response.body).remove_namespaces!
+          if (node % 'entry')
+            Queue.from_node(node)
+          else
+            #FIXME: If the queue is not found, Azure returns an atom feed containing links to immediate child nodes
+            # What to do with this?
+          end
+        else
+          Queue.from_error(response.error)
+        end
+      end
+
+      # Public: This operation enumerates the queues in the service namespace.
+      #
+      # options - Options for this query (default: {}):
+      #           :skip - Integer: number of entries to skip
+      #           :top  - Integer: number of entries to retrieve
+      # service - The backend service to implement this (optional).
+      #
+      # Returns an Array of Query elements.
+      def self.list(options={}, service=Services::List.new)
+        response = service.call(options)
+
+        if response.success?
+          result = Nokogiri::XML(response.body).remove_namespaces!
+          (result / 'entry').map {|node| Queue.from_node(node) }
+        else
+          []
+        end
+      end
+
+      # Public: This operation sends a message into the specified queue.
+      #
+      # queue   - The Queue
+      # message - The Message
+      # service - The backend service to implement this (optional).
+      #
+      # Returns true|false to indicate success.
+      def self.send_message_to_queue(queue, message, service=Services::SendMessageToQueue.new)
+        serializer = BrokeredMessageSerializer.new(message)
+        broker_properties = serializer.to_json
+        message_properties = serializer.get_property_headers
+
+        content_type = message.content_type || 'text/plain'
+        response = service.call(queue.name, message.body, content_type, broker_properties, message_properties)
+
+        response.success?
+      end
+
+      # Public: Atomically retrieves and locks a message from a queue for processing.
+      # The message is guaranteed not to be delivered to other receivers during the lock duration 
+      # period specified in the queue description.
+      #
+      # See: http://msdn.microsoft.com/en-us/library/windowsazure/hh780735
+      #
+      # queue   - The message queue
+      # options - A Hash of options for this operation (optional):
+      #           :timeout - An integer representing the request's timeout in seconds
+      # service - The backend service to implement this (optional).
+      #
+      # Returns a BrokeredMeassege.
+      def self.peek_lock_message_from_queue(queue, options={}, service=Azure::ServiceBus::Queues::Services::PeekLockMessageFromQueue.new)
+        response = service.call(queue.name, options)
+
+        if response.code == 201
+          BrokeredMessageSerializer.get_from_http_response(response)
+        elsif response.code == 204
+          msg = "No messages available within the specified timeout period."
+          BrokeredMessage.from_error(Azure::Error.new(msg))
+        else
+          BrokeredMessage.from_error(response.error)
+        end
+      end
+
+      # Public: Unlocks a message for processing by other receivers on a given subscription. 
+      # This operation deletes the lock object, causing the message to be unlocked. 
+      # A message must have first been locked by a receiver before this operation is called.
+      #
+      # See: http://msdn.microsoft.com/en-us/library/windowsazure/hh780723
+      #
+      # queue   - The message queue
+      # message - The message to be unlocked
+      # service - The backend service to implement this (optional).
+      #
+      # Returns true|false to indicate success.
+      def self.unlock_message_from_queue(queue, message, service=Azure::ServiceBus::Queues::Services::UnlockMessageFromQueue.new)
+        response = service.call(queue.name, message.sequence_number, message.lock_token)
+
+        response.success?
+      end
+
+      # Public: Reads and deletes a message from a queue as an atomic operation.
+      #
+      # See: http://msdn.microsoft.com/en-us/library/windowsazure/hh780756
+      #
+      # queue   - The message queue
+      # options - A Hash of options for this operation (optional):
+      #           :timeout - An integer representing the request's timeout in seconds
+      # service - The backend service to implement this (optional).
+      #
+      # Returns a BrokeredMeassege.
+      def self.read_delete_message_from_queue(queue, options={}, service=Azure::ServiceBus::Queues::Services::ReadDeleteMessageFromQueue.new)
+        response = service.call(queue.name, options)
+
+        # Azure documentation says this should be 201
+        if response.code == 200
+          BrokeredMessageSerializer.get_from_http_response(response)
+        elsif response.code == 204
+          msg = "No messages available within the specified timeout period."
+          BrokeredMessage.from_error(Azure::Error.new(msg))
+        else
+          BrokeredMessage.from_error(response.error)
+        end
+      end
+
+      # Public: Deletes a message from a queue.
+      #
+      # See: http://msdn.microsoft.com/en-us/library/windowsazure/hh780767
+      #
+      # queue   - The message queue
+      # message - The message to be deleted
+      # service - The backend service to implement this (optional).
+      #
+      # Returns true|false to indicate success.
+      def self.delete_message_from_queue(queue, message, service=Azure::ServiceBus::Queues::Services::DeleteMessageFromQueue.new)
+        response = service.call(queue.name, message.sequence_number, message.lock_token)
+
+        response.success?
+      end
+    end
+  end
+end

data/lib/azure/service_bus/queues/queue.rb

@@ -0,0 +1,100 @@
+require "azure/error"
+
+module Azure
+  module ServiceBus
+    module Queues
+      class Queue
+        include Azure::ErrorHandler
+        # Get the Queue's ID.
+        #
+        # Returns a URI.
+        attr_accessor :id
+        alias_method :url, :id
+
+        # Get the Queue's name.
+        #
+        # Returns a String.
+        attr_accessor :name
+        alias_method :title, :name
+
+        # Public: Get the published time
+        #
+        # Returns a Time
+        attr_accessor :published
+
+        # Public: Get the updated time
+        #
+        # Returns a Time
+        attr_accessor :updated
+
+        # Public: Get the author name
+        #
+        # Returns a String
+        attr_accessor :author_name
+
+        # Public: Queue description
+        #
+        # Returns a Hash
+        attr_accessor :description
+
+        # Public: Instantiate a queue from an XML entry.
+        #
+        # entry - An XML::Node element.
+        #
+        # Returns a Queue.
+        def self.from_node(node)
+          name = (node % "title").text
+
+          new(name) do |q|
+            q.id          = URI((node % "id").text)
+            # q.title       = (node % "title").text
+            q.published   = Time.parse((node % "published").text)
+            q.updated     = Time.parse((node % "updated").text)
+            q.author_name = (node % "author/name").text
+            # q.description = Description.from_node(node % 'content/QueueDescription')
+
+            q.description = (node / "content/QueueDescription *").each_with_object({}) do |el, desc|
+              desc[el.name] = el.text
+            end
+          end
+        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.
+        # description - The queue description Hash
+        # service     - The Queue service to perform external calls.
+        def initialize(name, description = {}, service=Azure::ServiceBus::Queues)
+          @name = name
+          @description = description
+          @service = service
+          yield self if block_given?
+        end
+
+        def delete
+          @service.delete(self)
+        end
+
+        # Public: Compare two queues to see if they are the same.
+        #
+        # other - A queue.
+        #
+        # Returns true|false.
+        def ==(other)
+          id == other.id
+        end
+      end
+    end
+  end
+end

data/lib/azure/service_bus/queues/queue_serializer.rb

@@ -0,0 +1,51 @@
+require "nokogiri"
+
+module Azure
+  module ServiceBus
+    module Queues
+      class QueueSerializer
+        attr_accessor :properties
+
+        # Please note that order IS important
+        PROPERTIES = [
+          'DefaultMessageTimeToLive',
+          'DuplicateDetectionHistoryTimeWindow',
+          'EnableBatchedOperations',
+          'EnableDeadLetteringOnMessageExpiration',
+          'ExtensionData',
+          'IsReadOnly',
+          'LockDuration',
+          'MaxDeliveryCount',
+          'MaxSizeInMegabytes',
+          'MessageCount',
+          'Path',
+          'RequiresDuplicateDetection',
+          'RequiresSession',
+          'SizeInBytes'
+        ].freeze
+
+        def initialize(properties={})
+          @properties = properties
+          yield self if block_given?
+        end
+
+        def to_xml
+          doc = Nokogiri::XML::Builder.new do |xml|
+            xml.entry(:xmlns => 'http://www.w3.org/2005/Atom') {
+              xml.content(:type => 'application/xml') {
+                xml.QueueDescription('xmlns' => 'http://schemas.microsoft.com/netservices/2010/10/servicebus/connect', 'xmlns:i' => 'http://www.w3.org/2001/XMLSchema-instance') {
+                  PROPERTIES.each do |p|
+                    unless @properties[p].nil?
+                      xml.send(p, @properties[p].to_s)
+                    end
+                  end
+                }
+              }
+            }
+          end
+          doc.to_xml
+        end
+      end
+    end
+  end
+end

data/lib/azure/service_bus/queues/service.rb

@@ -0,0 +1,154 @@
+require "azure/core/service"
+require "azure/core/utils/queryable"
+require "azure/service_bus/service_bus_service"
+require "azure/service_bus/auth/wrap"
+require "azure/service_bus/auth/authorizer"
+require "azure/service_bus/queues/uri"
+
+module Azure
+  module ServiceBus
+    module Queues
+      class Service < Core::Service
+        def initialize(signer=Azure::ServiceBus::Auth::Wrap.new)
+          super(signer, Azure::ServiceBus::Auth::Authorizer.new)
+        end
+      end
+
+      module Services
+        # Public: Create a queue.
+        class Create < Service
+          # Public: Invoke the service.
+          #
+          # name  - A String with the queue name.
+          # xml   - An xml String according to the Azure docs
+          #
+          # Returns a Response.
+          def call(name, xml)
+            super(:put, URI.queue(name), xml)
+          end
+        end
+
+        # Public: Delete a queue.
+        class Delete < Service
+          # Public: Invoke the service.
+          #
+          # name - A String with the queue name.
+          #
+          # Returns a Response.
+          def call(name)
+            super(:delete, URI.queue(name))
+          end
+        end
+
+        # Public: Get a queue.
+        class Get < Service
+          # Public: Invoke the service.
+          #
+          # name - A String with the queue name.
+          #
+          # Returns a Response.
+          def call(name)
+            super(:get, URI.queue(name))
+          end
+        end
+
+        # Public: List queues
+        class List < Service
+          include Core::Utils::Queryable
+
+          # Public: Invoke the service.
+          #
+          # options - Options for this query (default: {}):
+          #           :skip - Integer: number of entries to skip
+          #           :top  - Integer: number of entries to retrieve
+          #
+          # Returns a Response.
+          def call(options={})
+            options = translate_options_hash(options)
+            super(:get, URI.collection(options))
+          end
+        end
+
+        ## Messages
+
+        # Public: Sends a message to a queue
+        class SendMessageToQueue < ServiceBusService
+          # Public: Invoke the service.
+          #
+          # queue_name              - A String with the queue name
+          # body                    - A String with the message's body
+          # broker_properties_json  - A JSON encoded String with the message's properties.
+          # content_type            - A String with the desired Content-Type for the message body
+          # message_properties      - A Hash with the user-defined message's properties.
+          #
+          # Returns a Response.
+          def call(queue_name, body, content_type, broker_properties_json, message_properties)
+            super(:post, URI.messages(queue_name), body) do |request|
+              request.headers['BrokerProperties'] = broker_properties_json
+              message_properties.each do |k,v|
+                request.headers[k.to_s] = v
+              end
+              request.headers["Content-Type"] = content_type
+            end
+          end
+        end
+
+        # Public: Peek-lock message from a Queue
+        class PeekLockMessageFromQueue < ServiceBusService
+          # Public: Invoke the service.
+          #
+          # queue_name  - A String with the queue name
+          # options     - Options for this query (default: {}):
+          #               :timeout - Integer: request's timeout in seconds
+          #
+          # Returns a Response.
+          def call(queue_name, options={})
+            super(:post, URI.messages_head(queue_name, options))
+          end
+        end
+
+        # Public: Unlocks a message from a Queue
+        class UnlockMessageFromQueue < ServiceBusService
+          # Public: Invoke the service.
+          #
+          # queue_name  - A String with the queue name
+          # seq_number  - A String with the message's sequence_number
+          # lock_token  - A String with the message's lock_token
+          #
+          # Returns a Response.
+          def call(queue_name, seq_number, lock_token)
+            super(:put, URI.message(queue_name, seq_number, lock_token))
+          end
+        end
+
+        # Public: Reads and Deletes a message from a Queue
+        class ReadDeleteMessageFromQueue < ServiceBusService
+          # Public: Invoke the service.
+          #
+          # queue_name  - A String with the queue name
+          # options     - Options for this query (default: {}):
+          #               :timeout - Integer: request's timeout in seconds
+          #
+          # Returns a Response.
+          def call(queue_name, options={})
+            super(:delete, URI.messages_head(queue_name, options))
+          end
+        end
+
+        # Public: Deletes a message from a Queue
+        class DeleteMessageFromQueue < ServiceBusService
+          # Public: Invoke the service.
+          #
+          # queue_name  - A String with the queue name
+          # seq_number  - A String with the message's sequence_number
+          # lock_token  - A String with the message's lock_token
+          #
+          # Returns a Response.
+          def call(queue_name, seq_number, lock_token)
+            super(:delete, URI.message(queue_name, seq_number, lock_token))
+          end
+        end
+      end
+    end
+  end
+end