azure 0.0.0 → 0.1.0

data/lib/azure/service_bus/subscriptions/subscription_serializer.rb

@@ -0,0 +1,74 @@
+require "nokogiri"
+require "azure/service_bus/subscriptions/subscription"
+
+module Azure
+  module ServiceBus
+    module Subscriptions
+      # Public: Serialize a Subscription to/from XML.
+      #
+      # See http://msdn.microsoft.com/en-us/library/windowsazure/hh780763
+      class SubscriptionSerializer
+        MAPPINGS = {
+          LockDuration:                              :lock_duration,
+          RequiresSession:                           :requires_session,
+          DefaultMessageTimeToLive:                  :default_ttl,
+          DeadLetteringOnMessageExpiration:          :keep_expired,
+          DeadLetteringOnFilterEvaluationExceptions: :keep_on_errors
+        }.freeze
+
+        # Public: Parse an AtomPub fragment and return a Subscription from it.
+        #
+        # xml - A String.
+        #
+        # Returns a Subscription.
+        def self.parse(xml)
+          body = Nokogiri::XML(xml)
+          body.remove_namespaces!
+
+          name = (body % "title").text
+
+          Subscription.new(name) do |sub|
+            MAPPINGS.each do |tag, method|
+              tag = (body % tag.to_s)
+
+              if sub.respond_to?("#{method}=") && tag
+                sub.send("#{method}=", tag.text)
+              end
+            end
+
+            yield sub if block_given?
+          end
+        end
+
+        attr :object
+
+        # Public: Initialize the serializer
+        #
+        # subscription - A Subscription.
+        def initialize(subscription)
+          @subscription = subscription
+        end
+
+        # Public: Generate an XML that represents the subscription.
+        #
+        # xml - A Nokogiri::XML::Builder.
+        #
+        # Returns a String.
+        def to_xml(xml=Nokogiri::XML::Builder.new)
+          xml.entry(xmlns: "http://www.w3.org/2005/Atom") do |xml|
+            xml.content(type: "application/xml") do |xml|
+              xml.SubscriptionDescription("xmlns" => "http://schemas.microsoft.com/netservices/2010/10/servicebus/connect", "xmlns:i" => "http://www.w3.org/2001/XMLSchema-instance") do |xml|
+                MAPPINGS.each do |tag, method|
+                  property = @subscription.send(method)
+                  xml.send(tag, property.to_s) unless property.nil?
+                end
+              end
+            end
+          end
+
+          xml.to_xml
+        end
+      end
+    end
+  end
+end

data/lib/azure/service_bus/subscriptions/uri.rb

@@ -0,0 +1,71 @@
+require "azure/configuration"
+require "uri"
+
+module Azure
+  module ServiceBus
+    module Subscriptions
+      module URI
+        # Public: Generate the URI for a given subscription.
+        #
+        # topic_name - The name of the topic.
+        # name       - The name of the subscription.
+        # host       - The host of the API.
+        #
+        # Returns a URI.
+        def self.subscription(topic_name, name, host=Azure.config.service_bus_host)
+          generate(host, File.join(topic_name, "Subscriptions", name))
+        end
+
+        # Public: Generate the URI for the list of subscriptions.
+        #
+        # topic_name - The name of the topic.
+        # host       - The host of the API.
+        #
+        # Returns a URI.
+        def self.collection(topic_name, host=Azure.config.service_bus_host)
+          generate(host, File.join(topic_name, "Subscriptions"))
+        end
+
+        #TODO: we need to move this method to other module to be mixedin here
+        #
+        # Utility method to generate the URI.
+        #
+        # host  - A String with the URI's host.
+        # path  - A String with the URI's path.
+        # query - A simple Hash with query parameters (default: {}).
+        #
+        # Returns a URI.
+        def self.generate(host, path, query={})
+          uri = ::URI.parse(File.join(host, path))
+          uri.query = ::URI.encode_www_form(query) unless query.empty?
+          uri
+        end
+
+        # Public: generate the URI for the given subscription's head
+        #
+        # topic_name        - The topic's name
+        # subscription_name - The subscription's name
+        # options           - Options for this query (optional, default: {})
+        # host              - The host of the API.
+        #
+        # Returns a URI.
+        def self.messages_head(topic_name, subscription_name, options={}, host=Azure.config.service_bus_host)
+          generate(host, "#{topic_name}/Subscriptions/#{subscription_name}/messages/head", options)
+        end
+
+        # Public: generate the URI to operate on the given message in the given subscription
+        #
+        # topic_name        - The topic's name
+        # subscription_name - The subscription's name
+        # seq_number        - The message's sequence_number
+        # lock_token        - The message's lock_token
+        # host              - The host of the API (optional).
+        #
+        # Returns a URI.
+        def self.message(topic_name, subscription_name, seq_number, lock_token, host=Azure.config.service_bus_host)
+          generate(host, "#{topic_name}/Subscriptions/#{subscription_name}/messages/#{seq_number}/#{lock_token}")
+        end
+      end
+    end
+  end
+end

data/lib/azure/service_bus/topics.rb

@@ -0,0 +1,120 @@
+require "nokogiri"
+require "azure/service_bus/topics/service"
+require "azure/service_bus/topics/topic"
+require "azure/service_bus/topics/topic_serializer"
+require "azure/service_bus/brokered_message"
+require "azure/service_bus/brokered_message_serializer"
+
+module Azure
+  module ServiceBus
+    module Topics
+      # Public: Try to create a new topic. If the operation is unsuccessful,
+      # the resulting Topic object will have the error accessible through the
+      # #error method.
+      #
+      # name        - The name of the topic.
+      # properties  - Properties hash describing this topic (optional, default: {}).
+      # service     - The backend service to implement this (optional).
+      #
+      # Returns a Topic.
+      def self.create(name, props={}, service=Services::Create.new)
+        serializer = TopicSerializer.new(props)
+        xml = serializer.to_xml
+        response = service.call(name, xml)
+
+        if response.success?
+          node = Nokogiri::XML(response.body)
+          Topic.from_node(node)
+        else
+          Topic.from_error(response.error)
+        end
+      end
+
+      # Public: Delete a Topic from the server. If the delete operation fails,
+      # the topic is invalidated. Otherwise it's frozen.
+      #
+      # topic   - An Azure::ServiceBus::Topics::Topic.
+      # service - The backend service to implement this (optional).
+      #
+      # Returns true|false to indicate success.
+      def self.delete(topic, service=Services::Delete.new)
+        response = service.call(topic.name)
+
+        if response.success?
+          topic.freeze
+        else
+          topic.error = response.error
+        end
+
+        response.success?
+      end
+
+      # Public: Get a topic by name. If the operation fails,
+      # the resulting Topic object will have the error accessible through the
+      # #error method.
+      #
+      # service - The backend service to implement this (optional).
+      #
+      # Returns a Topic
+      def self.get(topic_name, service=Services::Get.new)
+        response = service.call(topic_name)
+
+        if response.success?
+          node = Nokogiri::XML(response.body).remove_namespaces!
+          if (node % 'entry')
+            Topic.from_node(node)
+          else
+            #FIXME: If the topic is not found, Azure returns an atom feed containing links to immediate child nodes
+            # What to do with this?
+          end
+        else
+          Topic.from_error(response.error)
+        end
+      end
+
+      # Public: This operation enumerates the topics 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| Topic.from_node(node) }
+        else
+          []
+        end
+      end
+
+      # Public: This operation sends a message into the specified topic.
+      # If the operation is unsuccessful the resulting BrokeredMessage object will be invalidated
+      # and the error will be accessible through the #error method.
+      #
+      # queue   - The Topic
+      # message - The Message
+      # service - The backend service to implement this (optional).
+      #
+      # Returns true|false to indicate success.
+      def self.send_message_to_topic(topic, message, service=Services::SendMessageToTopic.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(topic.name, message.body, content_type, broker_properties, message_properties)
+
+        if !response.success?
+          message.error = response.error
+        end
+
+        response.success?
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+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/topics/uri"
+
+module Azure
+  module ServiceBus
+    module Topics
+      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 topic.
+        class Create < Service
+          # Public: Invoke the service.
+          #
+          # name  - A String with the topic name.
+          # xml   - An xml String according to the Azure docs
+          #
+          # Returns a Response.
+          def call(name, xml)
+            super(:put, URI.topic(name), xml)
+          end
+        end
+
+        # Public: Delete a topic.
+        class Delete < Service
+          # Public: Invoke the service.
+          #
+          # name - A String with the topic name.
+          #
+          # Returns a Response.
+          def call(name)
+            super(:delete, URI.topic(name))
+          end
+        end
+
+        # Public: Get a topic.
+        class Get < Service
+          # Public: Invoke the service.
+          #
+          # name - A String with the topic name.
+          #
+          # Returns a Response.
+          def call(name)
+            super(:get, URI.topic(name))
+          end
+        end
+
+        # Public: List topics
+        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 topic
+        class SendMessageToTopic < ServiceBusService
+          # Public: Invoke the service.
+          #
+          # topic_name              - A String with the topic 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(topic_name, body, content_type, broker_properties_json, message_properties)
+            super(:post, URI.messages(topic_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
+      end
+    end
+  end
+end

data/lib/azure/service_bus/topics/topic.rb

@@ -0,0 +1,122 @@
+require "azure/error"
+require "azure/service_bus/topics"
+require "azure/service_bus/subscriptions"
+require "azure/service_bus/subscriptions/subscription"
+require "azure/core/collection"
+
+module Azure
+  module ServiceBus
+    module Topics
+      class Topic
+        include Azure::ErrorHandler
+        # Get the Topic's ID.
+        #
+        # Returns a URI.
+        attr_accessor :id
+        alias_method :url, :id
+
+        # Get the Topic'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: Topic description
+        #
+        # Returns a Hash
+        attr_accessor :description
+
+        # Public: Instantiate a topic from an XML entry.
+        #
+        # entry - An XML::Node element.
+        #
+        # Returns a Topic.
+        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/TopicDescription')
+
+            q.description = (node / "content/TopicDescription *").each_with_object({}) do |el, desc|
+              desc[el.name] = el.text
+            end
+          end
+        end
+
+        # Public: Instantiate a topic from an error object.
+        #
+        # error - An Azure::Error.
+        #
+        # Returns a Topic.
+        def self.from_error(error)
+          topic = new(nil)
+          topic.error = error
+          topic
+        end
+
+        # Public: Initialize the topic.
+        #
+        # name                 - A String with the name of the topic.
+        # description          - The topic description Hash
+        # topic_service        - The Topic service to perform external calls
+        #                        (optional).
+        # subscription_service - The Subscription service to perform external
+        #                        calls (optional).
+        def initialize(name, description = {}, topic_service=Azure::ServiceBus::Topics,
+                                               subscription_service=Azure::ServiceBus::Subscriptions)
+          @name = name
+          @description = description
+          @topic_service = topic_service
+          @subscription_service = subscription_service
+
+          yield self if block_given?
+        end
+
+        # Public: List subscriptions in this topic.
+        #
+        # Returns Azure::Core::Collection.
+        def subscriptions
+          @subscriptions ||= Core::Collection.new(
+            self,
+            :topic,
+            Subscriptions::Subscription,
+            @subscription_service
+          )
+        end
+
+        def delete
+          @topic_service.delete(self)
+        end
+
+        # Public: Compare two topics to see if they are the same.
+        #
+        # other - A topic.
+        #
+        # Returns true|false.
+        def ==(other)
+          id == other.id
+        end
+      end
+    end
+  end
+end