azure 0.0.0 → 0.1.0

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

@@ -0,0 +1,52 @@
+require "azure/configuration"
+require "uri"
+
+module Azure
+  module ServiceBus
+    module Auth
+      module URI
+        # Public: generate the URI for the ACS Wrap service
+        #
+        # options - see Azure::ServiceBus::Auth::WrapService.get_access_token documentation.
+        # host    - The host of the API.
+        #
+        # Returns a URI.
+        def self.wrap(options={}, host=Azure.config.acs_host)
+          generate(host, "WRAPv0.9", options)
+        end
+
+        # Utility method to generate the URI.
+        #
+        # host    - A String with the URI's host.
+        # path    - A String with the URI's path.
+        # params  - A simple Hash with query parameters (default: {}).
+        #
+        # Returns a URI.
+        def self.generate(host, path, params = {})
+          uri = join(host, path)
+          uri.query = to_query(params) unless params.empty?
+          uri
+        end
+
+        # Utility method to URL encode form data from a given hash
+        #
+        # hash - A Hash with params
+        #
+        # Returns a String (application/x-www-form-urlencoded data)
+        def self.to_query(hash)
+          ::URI.encode_www_form(hash)
+        end
+
+        # Utility method to generate the URI.
+        #
+        # host - A String with the URI's host.
+        # path - A String with the URI's path.
+        #
+        # Returns a URI.
+        def self.join(host, path)
+          ::URI.parse(File.join(host, path))
+        end
+      end
+    end
+  end
+end

data/lib/azure/service_bus/auth/wrap.rb

@@ -0,0 +1,37 @@
+require "azure/configuration"
+require "azure/service_bus/auth/wrap_token_manager"
+
+module Azure
+  module ServiceBus
+    module Auth
+      # Signing strategy for WRAP
+      #
+      class Wrap
+        # Public: Initialize the Signer.
+        #
+        # issuer      -
+        # access_key  - The Azure ServiceBus access_key encoded in Base64.
+        def initialize(issuer=Azure.config.sb_issuer, access_key=Azure.config.sb_access_key, token_manager=nil)
+          @wrap_token_manager = token_manager || WrapTokenManager.new(issuer, access_key)
+        end
+
+        # Public: The name of the strategy.
+        #
+        # Returns a String.
+        def name
+          "Wrap"
+        end
+
+        # Public: Generate a request signature.
+        #
+        # request - The HTTP request
+        #
+        # Returns a String
+        def sign(request)
+          access_token = @wrap_token_manager.get_access_token(request.uri)
+          'WRAP access_token="%s"' % access_token
+        end
+      end
+    end
+  end
+end

data/lib/azure/service_bus/auth/wrap_service.rb

@@ -0,0 +1,76 @@
+require "azure/service_bus/auth/wrap_token"
+require "azure/service_bus/auth/uri"
+require 'net/https'
+require 'uri'
+
+module Azure
+  module ServiceBus
+    module Auth
+      class WrapService
+        attr :issuer
+        attr :access_key
+
+        # Constructor
+        #
+        # issuer        -
+        # access_key    -
+        def initialize(issuer, access_key)
+          @issuer         = issuer
+          @access_key     = access_key
+        end
+
+        # Public: Get a valid access token for a given uri
+        #
+        # resource_uri - URI for the resource target
+        #
+        # Returns a valid Azure::ServiceBus::Auth:WrapToken
+        def get_access_token(resource_uri)
+          uri = URI.wrap
+          body = get_body(resource_uri)
+          response = do_request(:post, uri, body)
+
+          if response.code == "200"
+            WrapToken.parse(response.body)
+          else
+            #FIXME: handle errors
+            raise "Couldn't get an access_token from ACS, response was: %s" % response.body
+          end
+        end
+
+        private
+
+        def do_request(method, uri, body)
+          headers = {
+            "Content-Type" => "application/x-www-form-urlencoded",
+            "Content-Length" => "0"
+          }
+          request = Net::HTTP::Post.new(uri.request_uri, headers)
+          request.body = body
+
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+          response = http.request(request)
+          response
+        end
+
+        # Private: Generate the wrap ACS body for the given uri as a String
+        #
+        # resource_uri - The resource URI
+        #
+        # Returns a url-encoded String
+        def get_body(resource_uri)
+          non_ssl_uri = resource_uri.dup
+          non_ssl_uri.scheme = 'http'
+          params = {
+            :wrap_scope => non_ssl_uri.to_s,
+            :wrap_name => @issuer,
+            :wrap_password => @access_key
+          }
+          ::URI.encode_www_form(params)
+        end
+      end
+    end
+  end
+end

data/lib/azure/service_bus/auth/wrap_token.rb

@@ -0,0 +1,45 @@
+require 'uri'
+
+module Azure
+  module ServiceBus
+    module Auth
+      class WrapToken
+        attr_accessor :access_token
+        attr_accessor :expire_time
+
+        def initialize(token, expire_time)
+          @access_token = token
+          @expire_time  = expire_time
+        end
+
+        # Public: Instantiate a WrapToken from the HTTP response body.
+        #
+        # boddy - a String as returned by the ACS in the response body.
+        #
+        # Returns a WrapToken.
+        def self.parse(body)
+          begin
+            decoded = ::URI.decode_www_form(body.strip)
+            token = decoded.assoc("wrap_access_token").last
+            expiration = decoded.assoc("wrap_access_token_expires_in").last
+            new(token, expiration)
+          rescue => e
+            # TODO: hanlde errors
+            raise "Cannot get the access token from returned string: %s" % body
+          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
+      end
+    end
+  end
+end

data/lib/azure/service_bus/auth/wrap_token_manager.rb

@@ -0,0 +1,46 @@
+require "azure/service_bus/auth/wrap_service"
+require "azure/service_bus/auth/wrap_token"
+
+module Azure
+  module ServiceBus
+    module Auth
+      class WrapTokenManager
+
+        # The service used to get new tokens from the ACS
+        #
+        # Returns an Azure::ServiceBus::Auth::WrapService
+        attr :wrap_service
+
+        # A list of active WrapTokens
+        #
+        # Returns an Array of Azure::ServiceBus::Auth::WrapToken
+        attr :active_tokens
+
+        # Constructor
+        #
+        # issuer        -
+        # access_key    -
+        # host          -
+        def initialize(issuer, access_key)
+          @active_tokens = {}
+          @wrap_service = WrapService.new(issuer, access_key)
+        end
+
+        # Gets a valid (not expired) access token for the given uri
+        #
+        # uri - URI for the resource target
+        #
+        # Returns a String
+        def get_access_token(uri)
+          token = @active_tokens[uri.path]
+          now = Time.now.utc
+          unless token && token.expire_time > now
+            @active_tokens[uri.path] = @wrap_service.get_access_token(uri)
+            token = @active_tokens[uri.path]
+          end
+          token.access_token
+        end
+      end
+    end
+  end
+end

data/lib/azure/service_bus/brokered_message.rb

@@ -0,0 +1,139 @@
+require "azure/error"
+
+module Azure
+  module ServiceBus
+    class BrokeredMessage
+      include Azure::ErrorHandler
+
+      # Please read http://msdn.microsoft.com/en-us/library/windowsazure/hh780742
+      # for more information on brokered message properties
+
+      # Public: Get/Set the message's ContentType
+      #
+      # Returns a String
+      attr_accessor :content_type
+
+      # Public: Get/Set the message's CorrelationID
+      #
+      # Returns a String
+      attr_accessor :correlation_id
+
+      # Public: Get/Set the message's SessionID
+      #
+      # Returns a String
+      attr_accessor :session_id
+
+      # Public: Get/Set the message's DeliveryCount
+      #
+      # Returns an Integer
+      attr_accessor :delivery_count
+
+      # Public: Get/Set the message's LockedUntilUtc
+      #
+      # Returns a DateTime
+      attr_accessor :locked_until_utc
+
+      # Public: Get/Set the message's LockToken
+      #
+      # Returns a String (GUID)
+      attr_accessor :lock_token
+
+      # Public: Get/Set the message's MessageID
+      #
+      # Returns a String
+      attr_accessor :message_id
+      alias_method :id, :message_id
+
+      # Public: Get/Set the message's Label
+      #
+      # Returns a String
+      attr_accessor :label
+
+      # Public: Get/Set the message's ReplyTo
+      #
+      # Returns a String
+      attr_accessor :reply_to
+
+      # Public: Get/Set the message's EnqueuedTimeUtc
+      #
+      # Returns a DateTime
+      attr_accessor :enqueued_time_utc
+
+      # Public: Get/Set the message's SequenceNumber
+      #
+      # Returns an Integer
+      attr_accessor :sequence_number
+
+      # Public: Get/Set the message's TimeToLive
+      #
+      # Returns an Integer
+      attr_accessor :time_to_live
+
+      # Public: Get/Set the message's To
+      #
+      # Returns a String
+      attr_accessor :to
+
+      # Public: Get/Set the message's ScheduledEnqueueTimeUtc
+      #
+      # Returns a DateTime
+      attr_accessor :scheduled_enqueue_time_utc
+
+      # Public: Get/Set the message's ReplyToSessionId
+      #
+      # Returns a String
+      attr_accessor :reply_to_session_id
+
+      # Public: Get/Set custom key-value properties for the message
+      #
+      # Returns a Hash
+      attr_accessor :properties
+
+      # Public: Get/Set the message's Body
+      #
+      # Returns a String
+      attr_accessor :body
+
+      # Public: Get/Set the URI of the locked message. This URI is needed to unlock or delete the message.
+      #
+      # Returns an URI
+      attr_accessor :location
+
+      # Public: Instantiate a message from an error object.
+      #
+      # error - An Azure::Error.
+      #
+      # Returns a BrokeredMessage.
+      def self.from_error(error)
+        queue = new(nil)
+        queue.error = error
+        queue
+      end
+
+      # Public: Constructor.
+      #
+      # name        - A String with the name of the queue.
+      # description - The queue description Hash
+      # service     - The Queue service to perform external calls.
+      def initialize(body, properties={}, service=Azure::ServiceBus::Queues)
+        @body = body
+        @properties = properties
+        @service = service
+        yield self if block_given?
+      end
+
+      def delete
+        @service.delete(self)
+      end
+
+      # Public: Compare two messages to see if they are the same.
+      #
+      # other - A BrokeredMessage.
+      #
+      # Returns true|false.
+      def ==(other)
+        id == other.id
+      end
+    end
+  end
+end

data/lib/azure/service_bus/brokered_message_serializer.rb

@@ -0,0 +1,113 @@
+require "azure/core/utils/string"
+require "json"
+require "time"
+require "uri"
+
+module Azure
+  module ServiceBus
+    class BrokeredMessageSerializer
+      include Azure::Core::Utils::String
+
+      PROPERTIES = [
+        'ContentType',
+        'CorrelationId',
+        'SessionID',
+        'DeliveryCount',
+        'LockedUntilUtc',
+        'LockToken',
+        'MessageId',
+        'Label',
+        'ReplyTo',
+        'EnqueuedTimeUtc',
+        'SequenceNumber',
+        'TimeToLive',
+        'To',
+        'ScheduledEnqueueTimeUtc',
+        'ReplyToSessionId'
+      ].freeze
+
+      attr :message
+
+      def initialize(msg)
+        @message = msg
+      end
+
+      def self.get_from_http_response(response)
+        props = JSON.parse(response.headers['brokerproperties'])
+        BrokeredMessage.new(response.body) do |m|
+          m.location                    = URI(response.headers['location']) unless response.headers['location'].nil?
+          m.content_type                = response.headers['content-type']
+
+          # String based properties
+          m.lock_token                  = props['LockToken']
+          m.message_id                  = props['MessageId']
+          m.label                       = props['Label']
+          m.to                          = props['To']
+          m.session_id                  = props['SessionID']
+          m.correlation_id              = props['CorrelationId']
+          m.reply_to                    = props['ReplyTo']
+          m.reply_to                    = props['ReplyTo']
+          m.reply_to_session_id         = props['ReplyToSessionId']
+
+          # Time based properties
+          m.locked_until_utc            = Time.parse(props['LockedUntilUtc']) unless props['LockedUntilUtc'].nil?
+          m.enqueued_time_utc           = Time.parse(props['EnqueuedTimeUtc']) unless props['EnqueuedTimeUtc'].nil?
+          m.scheduled_enqueue_time_utc  = Time.parse(props['ScheduledEnqueueTimeUtc']) unless props['ScheduledEnqueueTimeUtc'].nil?
+
+          # Numeric based properties
+          m.delivery_count              = props['DeliveryCount'].to_i
+          m.sequence_number             = props['SequenceNumber'].to_i
+          m.time_to_live                = props['TimeToLive'].to_f
+
+          # Custom Properties
+          header_names_black_list = [
+            'brokerproperties',
+            'date',
+            'transfer-encoding',
+            'location',
+            'server',
+            'connection',
+            'content-type'
+          ]
+          props = response.headers.reject {|k,_| header_names_black_list.include?(k.downcase) }
+          props.each do |prop_name, value|
+            m.properties[prop_name] = value.gsub(/"/, '')
+          end
+        end
+      end
+
+      # Serialize the message's attributes to JSON
+      #
+      # Returns a JSON String
+      def to_json
+        hash = {}
+        PROPERTIES.each do |p|
+          attr_name = underscore(p)
+          value = @message.send(attr_name)
+          hash[p] = value unless value.nil?
+        end
+        hash.to_json
+      end
+
+      # Build a hash based on message properties and make it
+      # compliant with Azure policy for Message Property values
+      # in HTTP headers
+      #
+      # Returns a Hash
+      def get_property_headers
+        hash = {}
+        @message.properties.each do |name, value|
+          val = value
+          # Check for an RFC2626 Date
+          begin
+            val = '"' + Time.parse(value).httpdate + '"'
+          rescue ArgumentError
+            val = '"' + value + '"' if value.is_a? String
+          end
+          hash[name] = val
+        end
+        hash
+      end
+    end
+  end
+end