azure 0.0.0 → 0.1.0

data/lib/azure/service_bus/service_bus_service.rb

@@ -0,0 +1,22 @@
+require "azure/core/service"
+
+module Azure
+  module ServiceBus
+    class ServiceBusService < Core::Service
+      def initialize(signer=Azure::ServiceBus::Auth::Wrap.new)
+        super(signer, Azure::ServiceBus::Auth::Authorizer.new)
+      end
+
+      def call(method, uri, body=nil)
+        super(method, uri, body) do |request|
+          request.headers.delete("x-ms-date")
+          request.headers.delete("x-ms-version")
+          request.headers.delete("DataServiceVersion")
+          request.headers.delete("MaxDataServiceVersion")
+
+          yield request if block_given?
+        end
+      end
+    end
+  end
+end

data/lib/azure/service_bus/subscriptions.rb

@@ -0,0 +1,170 @@
+require "nokogiri"
+require "azure/service_bus/subscriptions/service"
+require "azure/service_bus/subscriptions/subscription"
+require "azure/service_bus/subscriptions/subscription_serializer"
+
+module Azure
+  module ServiceBus
+    module Subscriptions
+      # Public: Try to create a new subscription. If the operation is
+      # unsuccessful the resulting Subscription object will be invalidated and
+      # the error will be accessible through the #error method.
+      #
+      # subscription - A Subscription.
+      # service      - The backend service to implement this (optional).
+      #
+      # Returns a Subscription.
+      def self.create(subscription, service=Services::Create.new)
+        response = service.call(
+          subscription.topic.name,
+          subscription.name,
+          SubscriptionSerializer.new(subscription).to_xml
+        )
+
+        if response.success?
+          SubscriptionSerializer.parse(response.body) do |sub|
+            sub.topic = subscription.topic
+          end
+        else
+          subscription.error = response.error
+        end
+      end
+
+      # Public: Get a list of subscriptions from the server.
+      #
+      # topic   - A Topic.
+      # service - The backend service to implement this (optional).
+      #
+      # Returns an Array of Subscriptions.
+      def self.all(topic, service=Services::List.new)
+        response = service.call(topic.name)
+
+        # FIXME: handle errors!
+        feed = Nokogiri::XML(response.body)
+        (feed / "entry").map do |entry|
+          SubscriptionSerializer.parse(entry.to_xml)
+        end
+      end
+
+      # Public: Find a new subscription by name. The resulting subscription will
+      # be invalid if no subscription could be found.
+      #
+      # topic   - A Topic.
+      # name    - The name of the subscription.
+      # service - The backend service to implement this (optional).
+      #
+      # Returns a Subscription.
+      def self.fetch(topic, name, service=Services::Fetch.new)
+        response = service.call(topic.name, name)
+
+        if response.success?
+          SubscriptionSerializer.parse(response.body)
+        else
+          Subscription.from_error(response.error)
+        end
+      end
+
+      # Public: Delete the subscription from the remote service. If the
+      # operation is successful, this subscription is frozen. If not, it's
+      # invalidated.
+      #
+      # subscription - A Subscription.
+      # service      - The backend service to implement this (optional).
+      #
+      # Returns true|false to indicate success.
+      def self.delete(subscription, service=Services::Delete.new)
+        response = service.call(subscription.topic.name, subscription.name)
+
+        if response.success?
+          subscription.freeze
+        else
+          subscription.error = response.error
+        end
+
+        response.success?
+      end
+
+      ## Messages
+
+      # Public: Atomically retrieves and locks a message from a subscription for processing.
+      #
+      # See: http://msdn.microsoft.com/en-us/library/windowsazure/hh780722
+      #
+      # subscription  - The subscription
+      # 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_subscription(subscription,
+                                                   options={},
+                                                   service=Azure::ServiceBus::Subscriptions::Services::PeekLockMessageFromSubscription.new)
+        response = service.call(subscription.topic.name, subscription.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: This operation is used to unlock 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/hh780737
+      #
+      # subscription  - The subscription
+      # 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_subscription(subscription, message, service=Azure::ServiceBus::Subscriptions::Services::UnlockMessageFromSubscription.new)
+        response = service.call(subscription.topic.name, subscription.name, message.sequence_number, message.lock_token)
+
+        response.success?
+      end
+
+      # Public: Reads and deletes a message from a subscription as an atomic operation.
+      #
+      # See: http://msdn.microsoft.com/en-us/library/windowsazure/hh780770
+      #
+      # subscription  - The subscription
+      # 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_subscription(subscription, options={}, service=Azure::ServiceBus::Subscriptions::Services::ReadDeleteMessageFromSubscription.new)
+        response = service.call(subscription.topic.name, subscription.name, options)
+
+        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 subscription.
+      #
+      # See: http://msdn.microsoft.com/en-us/library/windowsazure/hh780768
+      #
+      # subscription  - The message subscription
+      # 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_subscription(subscription, message, service=Azure::ServiceBus::Subscriptions::Services::DeleteMessageFromSubscription.new)
+        response = service.call(subscription.topic.name, subscription.name, message.sequence_number, message.lock_token)
+
+        response.success?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,133 @@
+require "azure/core/service"
+require "azure/service_bus/auth/wrap"
+require "azure/service_bus/auth/authorizer"
+require "azure/service_bus/subscriptions/uri"
+require "azure/service_bus/service_bus_service"
+
+module Azure
+  module ServiceBus
+    module Subscriptions
+      class Service < Core::Service
+        def initialize(signer=Azure::ServiceBus::Auth::Wrap.new)
+          super(signer, Azure::ServiceBus::Auth::Authorizer.new)
+        end
+      end
+
+      module Services
+        class Create < Service
+          # Public: Invoke the service.
+          #
+          # topic_name - The name of the subscription's topic.
+          # name       - The name of the subscription name.
+          # body       - The SubscriptionDescription XML serialization.
+          #
+          # Returns a Response.
+          def call(topic_name, name, body)
+            uri = Subscriptions::URI.subscription(topic_name, name)
+            super(:put, uri, body)
+          end
+        end
+
+        class List < Service
+          # Public: Invoke the service.
+          #
+          # topic_name - The name of the subscriptions' topic.
+          #
+          # Returns a Response.
+          def call(topic_name)
+            uri = Subscriptions::URI.collection(topic_name)
+            super(:get, uri)
+          end
+        end
+
+        class Fetch < Service
+          # Public: Invoke the service.
+          #
+          # topic_name - The name of the subscription's topic.
+          # name       - The name of the subscription name.
+          #
+          # Returns a Response.
+          def call(topic_name, name)
+            uri = Subscriptions::URI.subscription(topic_name, name)
+            super(:get, uri)
+          end
+        end
+
+        class Delete < Service
+          # Public: Invoke the service.
+          #
+          # topic_name - The name of the subscription's topic.
+          # name       - The name of the subscription name.
+          #
+          # Returns a Response.
+          def call(topic_name, name)
+            uri = Subscriptions::URI.subscription(topic_name, name)
+            super(:delete, uri)
+          end
+        end
+
+        ## Messages
+
+        # Public: Peek-lock message from a Subscription
+        class PeekLockMessageFromSubscription < ServiceBusService
+          # Public: Invoke the service.
+          #
+          # topic_name        - A String with the topic name
+          # subscription_name - A String with the subscription name
+          # options           - Options for this query (default: {}):
+          #                     :timeout - Integer: request's timeout in seconds
+          #
+          # Returns a Response.
+          def call(topic_name, subscription_name, options={})
+            super(:post, URI.messages_head(topic_name, subscription_name, options))
+          end
+        end
+
+        # Public: Unlocks a message from a Subscription
+        class UnlockMessageFromSubscription < Service
+          # Public: Invoke the service.
+          #
+          # topic_name        - A String with the topic name
+          # subscription_name - A String with the subscription 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(topic_name, subscription_name, seq_number, lock_token)
+            super(:put, URI.message(topic_name, subscription_name, seq_number, lock_token))
+          end
+        end
+
+        # Public: Reads and Deletes a message from a Subscription
+        class ReadDeleteMessageFromSubscription < Service
+          # Public: Invoke the service.
+          #
+          # topic_name        - A String with the topic name
+          # subscription_name - A String with the subscription name
+          # options           - Options for this query (default: {}):
+          #                     :timeout - Integer: request's timeout in seconds
+          #
+          # Returns a Response.
+          def call(topic_name, subscription_name, options={})
+            super(:delete, URI.messages_head(topic_name, subscription_name, options))
+          end
+        end
+
+        # Public: Deletes a message from a Subscription
+        class DeleteMessageFromSubscription < Service
+          # Public: Invoke the service.
+          #
+          # topic_name        - A String with the topic name
+          # subscription_name - A String with the subscription 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(topic_name, subscription_name, seq_number, lock_token)
+            super(:delete, URI.message(topic_name, subscription_name, seq_number, lock_token))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,164 @@
+require "azure/error"
+require "azure/service_bus/subscriptions"
+require "azure/service_bus/rules"
+require "azure/core/utils/interval"
+
+module Azure
+  module ServiceBus
+    module Subscriptions
+      # Public: A Subscription to a Topic.
+      #
+      # See http://msdn.microsoft.com/en-us/library/windowsazure/hh780763
+      class Subscription
+        include Azure::ErrorHandler
+
+        # Public: Get the String name of this subscription.
+        attr :name
+
+        # Public: Get/Set the Topic of this subscription.
+        attr_accessor :topic
+
+        # Public: Whether the subscription requires a session. This is always
+        # false since session-aware subscriptions are not allowed through the
+        # REST API.
+        attr_reader   :requires_session
+
+        # Public: Whether to put messages in the dead-letter queue after its
+        # TTL expires. Can be true|false.
+        attr_accessor :keep_expired
+
+        # Public: Whether to put messages in the dead-letter queue when the
+        # message causes an exception during a subscription's filter
+        # evaluation. Can be true|false.
+        attr_accessor :keep_on_errors
+
+        # Public: Initialize a Subscription from an Error.
+        #
+        # error - An Azure::Error.
+        #
+        # Returns an invalid Subscription.
+        def self.from_error(error)
+          new(nil) { |sub| sub.error = error }
+        end
+
+        # Public: Initialize the Subscription.
+        #
+        # name    - A String with the subscription's name.
+        # service - Backend service to delegate remote calls (optional).
+        def initialize(name, service=Azure::ServiceBus::Subscriptions)
+          @name = name
+          @requires_session = false
+          @default_ttl = nil
+          @lock_duration = nil
+          @service = service
+          yield self if block_given?
+        end
+
+        # Public: Set the time to live of a message in the subscription.
+        #
+        # interval - An Interval, or anything that can be converted into one.
+        #
+        # Returns an Interval or nil.
+        def default_ttl=(interval)
+          @default_ttl = Core::Utils::Interval.try_convert(interval)
+        end
+
+        # Public: Get the time to live of a message in the subscription in
+        # seconds.
+        #
+        # Returns an Interval or nil.
+        def default_ttl
+          Core::Utils::Interval.try_convert(@default_ttl)
+        end
+
+        # Public: Duration of the lock in seconds.
+        #
+        # Returns an Interval or nil.
+        def lock_duration
+          Core::Utils::Interval.try_convert(@lock_duration)
+        end
+
+        # Public: Set the duration of the lock in seconds. Can go from 0
+        # (unlocked) to 5 minutes.
+        #
+        # interval - An Interval, or anything that can be converted into one.
+        #
+        # Returns an Interval or nil.
+        def lock_duration=(interval)
+          @lock_duration = Core::Utils::Interval.try_convert(interval)
+        end
+
+        # Public: Two subscriptions are the same if they belong to the same
+        # topic and have the same name.
+        #
+        # other - A Subscription.
+        #
+        # Returns true|false.
+        def ==(other)
+          !topic.nil? && topic == other.topic && name == other.name
+        end
+
+        # Public: Delete the subscription from the remote service. If the
+        # operation is successful, this subscription is frozen. If not, it's
+        # invalidated.
+        #
+        # Returns true|false to indicate success.
+        def delete
+          @service.delete(self)
+        end
+
+        # Public: Creates a new Rule for this Subscription.
+        #
+        # name         - String representing the name of the new rule.
+        # filter       - A Hash representing `filter` option.
+        #
+        #               Example:
+        #
+        #               {"SqlFilterExpression" => {
+        #                 "SqlExpression" => "MyProperty='XYZ'"
+        #               }}
+        #
+        #               Becomes:
+        #
+        #               <Filter i:type="SqlFilterExpression">
+        #                 <SqlExpression>MyProperty='XYZ'</SqlExpression>
+        #               </Filter>
+        #
+        # action       - A Hash representing `action` option.
+        #
+        #               Example:
+        #
+        #               {"SqlFilterAction" => {
+        #                 "SqlExpression" => "set MyProperty2 = 'ABC'"
+        #               }}
+        #
+        #               Becomes:
+        #
+        #               <Action i:type="SqlFilterAction">
+        #                 <SqlExpression>set MyProperty2 = 'ABC'</SqlExpression>
+        #               </Action>
+        #
+        # Returns an instance of ServiceBus::Rules::Rule.
+        def create_rule(name, filter=nil, action=nil, service=Azure::ServiceBus::Rules)
+          service.create(self, name, filter, action)
+        end
+
+        # Public: Get a list of Rules for this Subscription.
+        #
+        # Returns an Array of Rules.
+        def get_rules(service=Azure::ServiceBus::Rules)
+          service.all(self)
+        end
+
+        # Public: Get a Rule by name.
+        #
+        # name - String representing the name of the Rule.
+        #
+        # Returns an instance of Rules::Rule.
+        def get_rule(name, service=Azure::ServiceBus::Rules)
+          service.get(self, name)
+        end
+      end
+    end
+  end
+end