azure-plus 0.6.5

data/lib/azure/service_bus/brokered_message_serializer.rb

@@ -0,0 +1,159 @@
+#-------------------------------------------------------------------------
+# # Copyright (c) Microsoft and contributors. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#--------------------------------------------------------------------------
+require 'rubygems'
+require 'json'
+require 'time'
+require 'uri'
+
+require 'azure/service_bus/brokered_message'
+
+module Azure
+  module ServiceBus
+    # BrokeredMessageSerializer
+    class BrokeredMessageSerializer
+      PROPERTIES = {
+        'ContentType'             => 'content_type',
+        'CorrelationId'           => 'correlation_id',
+        'SessionID'               => 'session_id',
+        'DeliveryCount'           => 'delivery_count',
+        'LockedUntilUtc'          => 'locked_until_utc',
+        'LockToken'               => 'lock_token',
+        'MessageId'               => 'message_id',
+        'Label'                   => 'label',
+        'ReplyTo'                 => 'reply_to',
+        'EnqueuedTimeUtc'         => 'enqueued_time_utc',
+        'SequenceNumber'          => 'sequence_number',
+        'TimeToLive'              => 'time_to_live',
+        'To'                      => 'to',
+        'ScheduledEnqueueTimeUtc' => 'scheduled_enqueue_time_utc',
+        'ReplyToSessionId'        => 'reply_to_session_id'
+      }.freeze
+
+      attr_reader :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|
+          loc_header = response.headers['location']
+          m.location = URI(loc_header) unless loc_header.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
+          utc_lock = props['LockedUntilUtc']
+          m.locked_until_utc = Time.parse(utc_lock) unless utc_lock.nil?
+
+          enqueued_time_utc = self.parse_dot_net_serialized_datetime(
+            props['EnqueuedTimeUtc']
+          ) unless props['EnqueuedTimeUtc'].nil?
+          m.enqueued_time_utc = enqueued_time_utc unless enqueued_time_utc.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 = %w(
+            brokerproperties
+            date
+            transfer-encoding
+            location
+            server
+            connection
+            content-type
+            content-length
+          )
+
+          props = response.headers.reject do |k, _|
+            header_names_black_list.include?(k.downcase)
+          end
+
+          props.each do |prop_name, value|
+            parsed = JSON.parse('{ "' + prop_name + '" : ' + value + '}')
+            m.properties[prop_name] = parsed[prop_name]
+          end
+        end
+      end
+
+      # Serialize the message's attributes to JSON
+      #
+      # Returns a JSON String
+      def to_json
+        hash = {}
+        PROPERTIES.each do |p, u|
+          attr_name = u.encode('UTF-8')
+          value = @message.send(attr_name)
+          hash[p] = value.to_s.encode('UTF-8') unless value.nil?
+        end
+        hash.to_json
+      end
+
+      # Build a hash based on message properties and ensure
+      # the values are in a valid format for HTTP headers
+      #
+      # Returns a Hash
+      def get_property_headers
+        hash = {}
+        @message.properties.each do |name, value|
+          value = value.httpdate if !value.nil? && value.class == Time
+
+          tmp = JSON.generate [value]
+          hash[name] = tmp[1..(tmp.length - 2)]
+        end
+        hash
+      end
+
+      private
+
+      # Take the .net json serialization of a DateTime (i.e. /Date(...)/)
+      # and return a time object
+      #
+      # Returns a Time instance
+      def self.parse_dot_net_serialized_datetime(datetime)
+        begin
+          Time.parse(datetime)
+        rescue
+          milliseconds_in_second = 1000
+          match = /\/Date\((\d+)\)\//.match(datetime)
+          if !match.nil?
+            ticks = match[1].to_i
+            Time.at(ticks / milliseconds_in_second)
+          else
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/azure/service_bus/correlation_filter.rb

@@ -0,0 +1,45 @@
+#-------------------------------------------------------------------------
+# # Copyright (c) Microsoft and contributors. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#--------------------------------------------------------------------------
+require 'azure/service_bus/filter'
+
+module Azure
+  module ServiceBus
+    class CorrelationFilter < Filter
+      # Public: Initialize the Correlation Id Filter.
+      #
+      # ==== Attributes
+      #
+      # * +hash+   - The resource options Hash
+      #
+      # ==== Options
+      #
+      # Accepted key/value pairs in options parameter are:
+      # * +:correlation_id+ - The correlation identifier.
+      #
+      def initialize(hash=nil)
+        hash = {} unless hash
+        @correlation_id = hash[:correlation_id]
+        super()
+      end
+
+      attr_accessor :correlation_id #CorrelationId
+
+      def to_hash(hash={})
+        hash[:correlation_id]=correlation_id if correlation_id
+        super(hash)
+      end
+    end
+  end
+end

data/lib/azure/service_bus/empty_rule_action.rb

@@ -0,0 +1,30 @@
+#-------------------------------------------------------------------------
+# # Copyright (c) Microsoft and contributors. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#--------------------------------------------------------------------------
+require 'azure/service_bus/action'
+
+module Azure
+  module ServiceBus
+    class EmptyRuleAction < Action
+      # Public: Initialize the empty rule action.
+      #
+      # ==== Attributes
+      #
+      # * +hash+   - The resource options Hash
+      def initialize(hash=nil)
+        super()
+      end
+    end
+  end
+end

data/lib/azure/service_bus/false_filter.rb

@@ -0,0 +1,38 @@
+#-------------------------------------------------------------------------
+# # Copyright (c) Microsoft and contributors. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#--------------------------------------------------------------------------
+require 'azure/service_bus/sql_filter'
+
+module Azure
+  module ServiceBus
+    class FalseFilter < SqlFilter
+      # Public: Initialize the SQL false Filter.
+      #
+      # ==== Attributes
+      #
+      # * +hash+   - The resource options Hash
+      #
+      # ==== Options
+      #
+      # Accepted key/value pairs in options parameter are:
+      # * +:sql_expression+                                  - The SQL expression.
+      #
+      def initialize(hash=nil)
+        hash = {} unless hash
+        hash[:sql_expression] = "1 = 0" unless hash[:sql_expression]
+        super(hash)
+      end
+    end
+  end
+end

data/lib/azure/service_bus/filter.rb

@@ -0,0 +1,21 @@
+#-------------------------------------------------------------------------
+# # Copyright (c) Microsoft and contributors. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#--------------------------------------------------------------------------
+require 'azure/service_bus/rule_aspect'
+
+module Azure
+  module ServiceBus
+    class Filter < RuleAspect; end
+  end
+end

data/lib/azure/service_bus/interval.rb

@@ -0,0 +1,104 @@
+#-------------------------------------------------------------------------
+# # Copyright (c) Microsoft and contributors. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#--------------------------------------------------------------------------
+require "delegate"
+
+module Azure
+  module ServiceBus
+      # Public: Helper class to decorate a numeric duration so it can be output
+      # as an ISO8601-compliant Duration. (This class only implements the subset
+      # of the ISO8601 standard that the Azure REST API uses.)
+      #
+      # Examples
+      #
+      #   # Initialize an Interval from a Number, or use .try_convert to be
+      #   # intelligent:
+      #
+      #   Interval.new(10)              #=> PT10S
+      #   Interval.try_convert(10)      #=> PT10S
+      #   Interval.try_convert("PT10S") #=> PT10S
+      #   Interval.try_convert(nil)     #=> nil
+      class Interval < SimpleDelegator
+
+        # Public: Attempt to convert an object into an Interval.
+        #
+        # object - An object that might be converted into an Interval.
+        #
+        # Returns an Interval or nil.
+        def self.try_convert(object)
+          if object.respond_to?(:to_interval)
+            object.to_interval
+          elsif object.respond_to?(:to_int)
+            new(object)
+          elsif object.respond_to?(:to_str)
+            parse(object)
+          else
+            nil
+          end
+        end
+
+        # Public: Parse a String into an Interval.
+        #
+        # string - A String in the Interval format.
+        #
+        # Returns an Interval.
+        def self.parse(string)
+          re = /P([\d\.\,]+Y)?([\d\.\,]+M)?([\d\.\,]+D)?(?:T([\d\.\,]+H)?([\d\.\,]+M)?([\d\.\,]+S)?)?/
+
+          match = re.match(string)
+
+          return nil if match.nil?
+
+          #years   = match[1].to_f
+          #months  = match[2].to_f         
+          days    = match[3].to_f
+          hours   = match[4].to_f
+          minutes = match[5].to_f
+          seconds = match[6].to_f 
+
+          new(seconds + minutes * 60 + hours * 3600 + days * 86400)
+        end
+
+        # Public: Return this amount of seconds formatted as an interval.
+        #
+        # Returns a String.
+        def to_s
+          days    = to_i / 86400
+          hours   = (to_i % 86400) / 3600
+          minutes = (to_i % 3600) / 60
+          seconds = (self % 60)
+
+          days = "%<d>s" % {
+            :d => days.zero? ? nil : "#{days}D"
+          }
+
+          time = "%<h>s%<m>s%<s>s" % {
+            :h => hours.zero?               ? nil : "#{hours}H",
+            :m => minutes.zero?             ? nil : "#{minutes}M",
+            :s => nonzero? && seconds.zero? ? nil : "#{seconds}S"
+          }
+
+          "P#{days}" + (time.empty? ? "" : "T#{time}")
+        end
+        alias_method :inspect, :to_s
+
+        # Public: Convert this object into an interval.
+        #
+        # Returns self.
+        def to_interval
+          self
+        end
+    end
+  end
+end

data/lib/azure/service_bus/queue.rb

@@ -0,0 +1,230 @@
+#-------------------------------------------------------------------------
+# # Copyright (c) Microsoft and contributors. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#--------------------------------------------------------------------------
+require 'azure/service_bus/resource'
+
+module Azure
+  module ServiceBus
+    class Queue < Resource
+      # Public: Initialize the queue.
+      #
+      # ==== Attributes
+      #
+      # * +name+      - A String with the name of the queue.
+      # * +options+   - The resource options Hash
+      #
+      # ==== Options
+      #
+      # Accepted key/value pairs in options parameter are:
+      # * +:default_message_time_to_live+                - XML datetime. Determines how long a message lives in the associated subscriptions.
+      # * +:duplicate_detection_history_time_window+     - XML datetime. Specifies the time span during which the Service Bus will detect message duplication.
+      # * +:enable_batched_operations+                   - Boolean. Enables or disables service side batching behavior when performing operations for the specific queue.
+      # * +:dead_lettering_on_message_expiration:+       - Boolean. This field controls how the Service Bus handles a message whose TTL has expired.
+      # * +:lock_duration+                               - XML datetime. Determines the amount of time in seconds in which a message should be locked for processing by a receiver.
+      # * +:max_delivery_count+                          - Number. A message is automatically deadlettered after this number of deliveries.
+      # * +:max_size_in_megabytes+                       - Number. Specifies the maximum topic size in megabytes
+      # * +:message_count+                               - Number. Displays the number of messages currently in the queue.
+      # * +:requires_duplicate_detection+                - Boolean. If enabled, the topic will detect duplicate messages within the time span specified by the DuplicateDetectionHistoryTimeWindow property
+      # * +:requires_session+                            - Boolean. If set to true, the queue will be session-aware and only SessionReceiver will be supported.
+      # * +:size_in_bytes+                               - Number. Reflects the actual bytes toward the topic quota that messages in the topic currently occupy.
+      #
+      def initialize(name, options = {})
+        normalized_options = {}
+        normalized_options["DefaultMessageTimeToLive"] = options[:default_message_time_to_live].to_s if options.has_key?(:default_message_time_to_live)
+        normalized_options["DuplicateDetectionHistoryTimeWindow"] = options[:duplicate_detection_history_time_window].to_s if options.has_key?(:duplicate_detection_history_time_window)
+        normalized_options["EnableBatchedOperations"] = options[:enable_batched_operations].to_s if options.has_key?(:enable_batched_operations)
+        normalized_options["DeadLetteringOnMessageExpiration"] = options[:dead_lettering_on_message_expiration].to_s if options.has_key?(:dead_lettering_on_message_expiration)
+        normalized_options["LockDuration"] = options[:lock_duration].to_s if options.has_key?(:lock_duration)
+        normalized_options["MaxDeliveryCount"] = options[:max_delivery_count].to_s if options.has_key?(:max_delivery_count)
+        normalized_options["MaxSizeInMegabytes"] = options[:max_size_in_megabytes].to_s if options.has_key?(:max_size_in_megabytes)
+        normalized_options["MessageCount"] = options[:message_count].to_s if options.has_key?(:message_count)
+        normalized_options["RequiresDuplicateDetection"] = options[:requires_duplicate_detection].to_s if options.has_key?(:requires_duplicate_detection)
+        normalized_options["RequiresSession"] = options[:requires_session].to_s if options.has_key?(:requires_session)
+        normalized_options["SizeInBytes"] = options[:size_in_bytes].to_s if options.has_key?(:size_in_bytes)
+
+        super(name, normalized_options)
+      end
+
+      # MessageCount: Number
+      #
+      # Displays the number of messages currently in the queue.
+      def message_count
+        to_i description['MessageCount']
+      end
+
+      def message_count=(val)
+        _set 'MessageCount', val
+      end
+      
+      # LockDuration: XML datetime
+      #
+      # Determines the amount of time in seconds in which a message should be locked for processing by a receiver. 
+      # After this period, the message is unlocked and available for consumption by the next receiver. Settable 
+      # only at queue creation time:
+      #
+      # Range: 0 - 5 minutes. 0 means that the message is not locked 
+      # Default: 30 seconds
+      def lock_duration
+        to_interval description['LockDuration']
+      end
+
+      def lock_duration=(val)
+        _set 'LockDuration', val
+      end
+
+      # RequiresSession: True, False
+      #
+      # Settable only at queue creation time. If set to true, the queue will be session-aware and only SessionReceiver
+      # will be supported. Session-aware queues are not supported through REST.
+      #
+      # Default for durable queue: false
+      def requires_session
+        to_bool description['RequiresSession']
+      end
+
+      def requires_session=(val)
+        _set 'RequiresSession', val
+      end
+
+      # DeadLetteringOnMessageExpiration: True, False
+      #
+      # This field controls how the Service Bus handles a message whose TTL has expired. If it is enabled and a message
+      # expires, the Service Bus moves the message from the queue into the queue's dead-letter sub-queue. If disabled,
+      # message will be permanently deleted from the queue. Settable only at queue creation time.
+      #
+      # Default: false
+      def dead_lettering_on_message_expiration
+        to_bool description['DeadLetteringOnMessageExpiration']
+      end
+
+      def enable_dead_lettering_on_message_expiration=(val)
+        _set 'DeadLetteringOnMessageExpiration', val
+      end
+
+      # MaxDeliveryCount: Number
+      #
+      # A message is automatically deadlettered after this number of deliveries.
+      def max_delivery_count
+        to_i description['MaxDeliveryCount']
+      end
+
+      def max_delivery_count=(val)
+        _set 'MaxDeliveryCount', val
+      end
+
+      # MaxSizeInMegaBytes: Number
+      #
+      # Specifies the maximum queue size in megabytes. Any attempt to enqueue a message that will cause the queue to 
+      # exceed this value will fail. You can only set this parameter at queue creation time using the following values:
+      #
+      # Range: 1 - 1024 (valid values are 1024, 2048, 3072, 4096, 5120) 
+      # Default: 1*1024 (valid values are 1024, 2048, 3072, 4096, 5120)
+      def max_size_in_megabytes
+        to_i description['MaxSizeInMegabytes']
+      end
+
+      def max_size_in_megabytes=(val)
+        _set 'MaxSizeInMegabytes', val
+      end
+
+      # SizeinBytes: Number
+      #
+      # Reflects the actual bytes that messages in the queue currently occupy toward the queue's quota.
+      #
+      # Range: 0 - MaxTopicSizeinMegaBytes
+      def size_in_bytes
+        to_i description['SizeInBytes']
+      end
+
+      def size_in_bytes=(val)
+        _set 'SizeInBytes', val
+      end
+
+
+      # DefaultMessageTimeToLive: XML datetime
+      #
+      # Depending on whether DeadLettering is enabled, a message is automatically moved to the DeadLetterQueue or 
+      # deleted if it has been stored in the queue for longer than the specified time. This value is overwritten 
+      # by a TTL specified on the message if and only if the message TTL is smaller than the TTL set on the queue.
+      # This value is immutable after the Queue has been created:
+      #
+      # Range: 1 second - TimeSpan.MaxValue 
+      # Default: TimeSpan.MaxValue
+      def default_message_time_to_live
+        to_interval description['DefaultMessageTimeToLive']
+      end
+
+      def default_message_time_to_live=(val)
+        _set 'DefaultMessageTimeToLive', val
+      end
+
+      # RequiresDuplicateDetection: True, False
+      #
+      # Settable only at queue creation time.
+      #
+      # Default for durable queue: false
+      def requires_duplicate_detection
+        to_bool description['RequiresDuplicateDetection']
+      end
+
+      def requires_duplicate_detection=(val)
+        _set 'RequiresDuplicateDetection', val
+      end
+
+      # DuplicateDetectionHistoryTimeWindow
+      #
+      # Specifies the time span during which the Service Bus will detect message duplication.
+      #
+      # Range: 1 second - 7 days
+      # Default: 10 minutes
+      def duplicate_detection_history_time_window
+        to_interval description['DuplicateDetectionHistoryTimeWindow']
+      end
+
+      def duplicate_detection_history_time_window=(val)
+        _set 'DuplicateDetectionHistoryTimeWindow', val
+      end
+
+      # EnableBatchedOperations
+      #
+      # Enables or disables service side batching behavior when performing operations for the specific queue. When 
+      # enabled, service bus will collect/batch multiple operations to the backend to be more connection efficient. 
+      #
+      # If user wants lower operation latency then they can disable this feature.
+      def enable_batched_operations
+        to_bool description['EnableBatchedOperations']
+      end
+
+      def enable_batched_operations=(val)
+        _set 'EnableBatchedOperations', val
+      end
+
+      def ordered_props
+        [
+          'LockDuration',
+          'MaxSizeInMegabytes',
+          'RequiresDuplicateDetection',
+          'RequiresSession',
+          'DefaultMessageTimeToLive',
+          'DeadLetteringOnMessageExpiration',
+          'DuplicateDetectionHistoryTimeWindow',
+          'MaxDeliveryCount',
+          'EnableBatchedOperations',
+          'SizeInBytes',
+          'MessageCount'
+        ]
+      end
+    end
+  end
+end