azure 0.0.0 → 0.1.0

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

@@ -0,0 +1,44 @@
+require "nokogiri"
+
+module Azure
+  module ServiceBus
+    module Topics
+      class TopicSerializer
+        attr_accessor :properties
+
+        PROPERTIES = [
+          'MaxSizeInMegabytes',
+          'SizeInBytes',
+          'DefaultMessageTimeToLive',
+          'RequiresDuplicateDetection',
+          'DuplicateDetectionHistoryTimeWindow',
+          'MaximumNumberOfSubscriptions',
+          'EnableBatchedOperations',
+          'DeadLetteringOnFilterEvaluationExceptions'
+        ].freeze
+
+        def initialize(properties={})
+          @properties = properties
+          yield self if block_given?
+        end
+
+        def to_xml(builder=Nokogiri::XML::Builder)
+          doc = builder.new do |xml|
+            xml.entry(:xmlns => 'http://www.w3.org/2005/Atom') {
+              xml.content(:type => 'application/xml') {
+                xml.TopicDescription('xmlns' => 'http://schemas.microsoft.com/netservices/2010/10/servicebus/connect', 'xmlns:i' => 'http://www.w3.org/2001/XMLSchema-instance') {
+                  PROPERTIES.each do |p|
+                    if prop = @properties.fetch(p, nil)
+                      xml.send(p, prop)
+                    end
+                  end
+                }
+              }
+            }
+          end
+          doc.to_xml
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+require "azure/configuration"
+require "uri"
+
+module Azure
+  module ServiceBus
+    module Topics
+      module URI
+        # Public: Generate the URI for a given topic.
+        #
+        # topic_name - The name of the topic.
+        # host       - The host of the API.
+        #
+        # Returns a URI.
+        def self.topic(name, host=Azure.config.service_bus_host)
+          generate(host, name)
+        end
+
+        # Public: generate the URI for the topics collection.
+        #
+        # options - Options for this query (default: {}):
+        #           :skip - Integer: number of entries to skip
+        #           :top  - Integer: number of entries to retrieve
+        # host    - The host of the API.
+        #
+        # Returns a URI.
+        def self.collection(options={}, host=Azure.config.service_bus_host)
+          generate(host, "$Resources/Topics", options)
+        end
+
+        # Public: generate the URI for the given topic's messages
+        #
+        # topic_name  - The topic name
+        # host        - The host of the API.
+        #
+        # Returns a URI.
+        def self.messages(topic_name, host=Azure.config.service_bus_host)
+          generate(host, "#{topic_name}/messages")
+        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
+      end
+    end
+  end
+end

data/lib/azure/service_runtime/client/goal_state_pipe_monitor.rb

@@ -0,0 +1,21 @@
+require 'eventmachine'
+
+module Azure
+  module ServiceRuntime
+    class GoalStatePipeMonitor < EM::Connection
+
+      # Public: Initializes a new monitor.
+      #
+      # callback - a lambda to invoke when a new message arraives
+      def initialize(new_message_callback)
+        @new_message_callback = new_message_callback
+      end
+
+      def notify_readable
+        state_message = GoalStateProtocol.read_message(@io)
+        @new_message_callback.call(state_message)
+      end
+    end
+
+  end
+end

data/lib/azure/service_runtime/client/goal_state_protocol.rb

@@ -0,0 +1,18 @@
+module Azure
+  module ServiceRuntime
+    class GoalStateProtocol
+
+      def self.read_message(channel)
+        message_header = ""
+        while ("\n" != char = channel.readchar)
+          message_header << char
+        end
+        size = message_header.to_i(16)
+        message = channel.read(size)
+
+        message
+      end
+
+    end
+  end
+end

data/lib/azure/service_runtime/client/runtime_client.rb

@@ -0,0 +1,135 @@
+require 'nokogiri'
+require 'thread'
+require 'uuid'
+require 'eventmachine'
+require 'azure/service_runtime/client/goal_state_protocol'
+require 'azure/service_runtime/client/goal_state_pipe_monitor'
+
+module Azure
+  module ServiceRuntime
+    class RuntimeClient
+
+      # Public: Defines the client id that is used when communicating with the runtime.
+      def client_id
+        @client_id = defined?(@client_id) ? @client_id : UUID.new.generate
+      end
+
+      def incarnation
+        @gs_incarnation
+      end
+
+      # Public: Initializes a new instance of the client, and reads the initial state synchronously.
+      # It also starts monitoring the pipe to receive status updates and automatically refresh the state
+      # and call the appropiate events.
+      def initialize(endpoint)
+        return unless @is_available = File.exists?(endpoint)
+
+        @gs_incarnation = 0
+
+        @changed_event = []
+        @changing_event = []
+        @stopping_event = []
+
+        goal_state_np = nil
+        File.open(endpoint, 0) do |runtime_np|
+          runtime_xml = Nokogiri::XML(runtime_np.read)
+          # read the initial state
+          File.open(runtime_xml.css('RuntimeServerEndpoint')[0]['path']) do |goalstate_np|
+            state_message = GoalStateProtocol.read_message(goalstate_np)
+            set_goal_state(state_message)
+          end
+          # open again to receive status changes
+          goal_state_np = File.open(runtime_xml.css('RuntimeServerEndpoint')[0]['path'])
+        end # close the runtime named pipe only
+
+        # start watching the pipe for changes
+        gspm = EM.watch goal_state_np, GoalStatePipeMonitor, ->(msg){ set_goal_state(msg) }
+        gspm.notify_readable = true
+      end
+
+      def is_available?
+        @is_available
+      end
+
+      def write(&block)
+        File.open(@gs_current_state_endpoint, "w") do |pipe|
+          block.call(pipe)
+        end
+
+        nil
+      end
+
+      def write_status(new_status)
+        write do |pipe|
+          builder = Nokogiri::XML::Builder.new do |xml|
+            xml.CurrentState {
+              xml.StatusLease(:ClientId => self.client_id) {
+                xml.Acquire {
+                  xml.Incarnation self.incarnation
+                  xml.Status new_status
+                  xml.StatusDetail new_status
+                  xml.Expiration "9999-12-31T23:59:59.999Z"
+                }
+              }
+            }
+          end
+          pipe.write(builder.to_xml)
+        end
+      end
+
+      def read(&block)
+        raise StandardError, "State not available" unless @gs_xml
+        block.call(@gs_xml)
+
+        nil
+      end
+
+      def on_changed(&block)
+        @changed_event << block
+      end
+
+      def on_changing(&block)
+        @changing_event << block
+      end
+
+      def on_stopping(&block)
+        @stopping_event << block
+      end
+
+      def set_goal_state(new_goal_state)
+        new_goal_state_xml = Nokogiri::XML(new_goal_state)
+        new_incarnation = new_goal_state_xml.css('Incarnation').size > 0 ? new_goal_state_xml.css('Incarnation')[0].content.to_i : 0
+        new_status = new_goal_state_xml.css('ExpectedState').size > 0 ? new_goal_state_xml.css('ExpectedState')[0].content : nil
+
+        case new_status
+        when 'Stopped'
+          @gs_xml = nil
+          @stopping_event.each {|block| block.call }
+          write_status('Stopped')
+
+        when 'Started'
+          return if @gs_incarnation >= new_incarnation
+
+          @gs_incarnation = new_incarnation
+          @gs_expected_state = new_status
+          @gs_current_state_endpoint ||= new_goal_state_xml.css('CurrentStateEndpoint').size > 0 ? new_goal_state_xml.css('CurrentStateEndpoint')[0].content : nil
+
+          if new_goal_state_xml.css('RoleEnvironmentPath').size > 0
+            File.open(new_goal_state_xml.css('RoleEnvironmentPath')[0].content) do |role_environment_file|
+              current_xml = @gs_xml ? Nokogiri::XML(@gs_xml) : nil
+              goal_xml = Nokogiri::XML(role_environment_file.read)
+
+              @changing_event.each {|block| block.call(current_xml, goal_xml) }
+              @gs_xml = goal_xml
+              @changed_event.each {|block| block.call(current_xml, goal_xml) }
+            end
+          else
+            @gs_xml = nil
+            @stopping_event.each {|block| block.call }
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/azure/service_runtime/deployment.rb

@@ -0,0 +1,24 @@
+module Azure
+  module ServiceRuntime
+    class Deployment
+      attr_accessor :name, :is_emulated
+      alias :is_emulated? :is_emulated
+
+      def initialize(node)
+        self.name = node["id"]
+        self.is_emulated = node["emulated"] == "true"
+      end
+
+      # Public: Retrieves the deployment identifier.
+      #
+      # Returns an integer that identifies the current deployment.
+      def id
+        if /\((?<deployment_id>\d+)\)/i =~ self.name
+          return deployment_id.to_i
+        end
+
+        nil
+      end
+    end
+  end
+end

data/lib/azure/service_runtime/local_resource.rb

@@ -0,0 +1,15 @@
+module Azure
+  module ServiceRuntime
+    class LocalResource
+      attr_accessor :name, :path, :size
+      alias :maximumSizeInMegabytes :size
+      alias :root_path :path
+
+      def initialize(node)
+        self.name = node["name"]
+        self.path = node["path"]
+        self.size = node["sizeInMB"].to_i
+      end
+    end
+  end
+end

data/lib/azure/service_runtime/role.rb

@@ -0,0 +1,17 @@
+module Azure
+  module ServiceRuntime
+    class Role
+      attr_accessor :name, :instances
+
+      def initialize(node)
+        self.name = node["name"]
+        self.instances = node.css('Instances > Instance').inject({}) do |hash, instance_xml| 
+          role_instance = RoleInstance.new(instance_xml)
+          role_instance.role_name = self.name
+          hash[role_instance.id] = role_instance
+          hash
+        end
+      end
+    end
+  end
+end

data/lib/azure/service_runtime/role_environment.rb

@@ -0,0 +1,206 @@
+require 'azure/service_runtime/role_instance'
+require 'azure/service_runtime/role'
+require 'azure/service_runtime/deployment'
+require 'azure/service_runtime/client/runtime_client'
+require 'nokogiri'
+require 'uuid'
+
+module Azure
+  module ServiceRuntime
+    class RoleEnvironment
+      VersionEndpointFixedPath = '\\\\.\\pipe\\WindowsAzureRuntime'
+      VersionEndpointEnvironmentName = 'WaRuntimeEndpoint'
+
+      # Public: Retrieves the resolved Service Runtime endpoint name.
+      #
+      # Returns a string with the endpoint name.
+      def self.endpoint
+        (defined?(@@endpoint) && @@endpoint) || ENV[VersionEndpointEnvironmentName] || VersionEndpointFixedPath
+      end
+
+      # Public: Allows to manually set an endpoint (used for testing).
+      def self.endpoint=(value)
+        @@endpoint = value
+      end
+
+      def self.client_id
+        @runtime ||= RuntimeClient.new(endpoint)
+        @runtime.client_id
+      end
+
+      # Public: Returns true if and only if the Service Runtime is available (ie, this
+      # is running in Azure or the emulator.
+      # This is a precondition for all of the other Service Runtime methods.
+      #
+      # Returns a boolean that is true if the Service Runtime is available.
+      def self.is_available?
+        @runtime ||= RuntimeClient.new(endpoint)
+        @runtime.is_available?
+      end
+
+      # Public: Retrieves the current deployment information.
+      #
+      # Returns a Deployment object.
+      def self.deployment(&block)
+        @runtime ||= RuntimeClient.new(endpoint)
+        @runtime.read do |data|
+          return Deployment.new(data.css('RoleEnvironment > Deployment')[0])
+        end
+      end
+
+      # Public: Retrieves a RoleInstance object that represents the role instance in which this code is running.
+      #
+      # Returns a RoleInstance object.
+      def self.current_role_instance(&block)
+        @runtime ||= RuntimeClient.new(endpoint)
+        @runtime.read do |data|
+          return build_current_role_instance(data)
+        end
+      end
+
+      # Public: Retrieves the Role objects defined for the hosted service.
+      #
+      # Returns a hash of Role objects.
+      def self.roles
+        @runtime ||= RuntimeClient.new(endpoint)
+        @runtime.read do |data|
+          return build_roles(data)
+        end
+      end
+
+      # Public: Requests that the current role instance be stopped and restarted.
+      def self.request_recycle
+        @runtime ||= RuntimeClient.new(endpoint)
+        @runtime.write_status("Recycle")
+      end
+
+      def self.set_status(new_status)
+        @runtime ||= RuntimeClient.new(endpoint)
+        new_runtime_status =
+          case new_status
+            when :busy, "busy"
+              "Busy"
+            when :ready, "ready"
+              "Started"
+            else
+              raise ArgumentError, "unknown state #{new_status}"
+          end
+
+        @runtime.write_status(new_runtime_status)
+      end
+
+      def self.on_changing(&block)
+        @runtime ||= RuntimeClient.new(endpoint)
+        @runtime.on_changing do |current_xml, goal_xml|
+          change_list = calculate_changes(current_xml, goal_xml)
+          block.call(change_list)
+        end
+      end
+
+      def self.on_changed(&block)
+        @runtime ||= RuntimeClient.new(endpoint)
+        @runtime.on_changed do |last_xml, current_xml|
+          change_list = calculate_changes(last_xml, current_xml)
+          block.call(change_list)
+        end
+      end
+
+      def self.on_stopping(&block)
+        @runtime ||= RuntimeClient.new(endpoint)
+        @runtime.on_stopping(&block)
+      end
+
+      private
+
+      def self.build_roles(state_xml)
+        state_xml.css('RoleEnvironment > Roles')[0].css('Role').inject({}) do |hash, role_xml|
+          role = Role.new(role_xml)
+          hash[role.name] = role
+          hash
+        end
+      end
+
+      def self.build_current_role_instance(state_xml)
+        RoleInstance.new(state_xml.css('RoleEnvironment > CurrentInstance')[0])
+      end
+
+      def self.calculate_changes(source, target)
+        if !source && !target
+          return [[],[]]
+        end
+
+        if !source && target
+          return [build_current_role_instance(target).configuration_settings.keys, build_roles(target).keys]
+        end
+
+        if source && !target
+          return [build_current_role_instance(source).configuration_settings.keys, build_roles(target).keys]
+        end
+
+        changed_settings = []
+        changed_roles = []
+
+        source_role_instance = build_current_role_instance(source)
+        target_role_instance = build_current_role_instance(target)
+
+        # find edited or removed settings
+        source_role_instance.configuration_settings.each do |name, value|
+          if !(target_value = target_role_instance.configuration_settings[setting.name]) || value != target_value
+            changed_settings << name
+          end
+        end
+
+        # find added settings
+        target_role_instance.configuration_settings.each do |name, value|
+          if !source_role_instance.configuration_settings[name]
+            changed_settings << name
+          end
+        end
+
+        source_roles = build_roles(source)
+        target_roles = build_roles(target)
+
+        # find edited or removed roles
+        source_roles.each do |source_role_name, source_role|
+          if target_role = target_roles[source_role_name]
+            source_role.instances.each do |source_instance_id, source_instance|
+              if target_instance = target_role.instances[source_instance_id]
+                if target_instance.fault_domain == source_instance.fault_domain &&
+                  target_instance.update_domain == source_instance.update_domain
+
+                  source_instance.endpoints.each do |source_endpoint_name, source_endpoint|
+                    if target_endpoint = target_instance.endpoints[source_endpoint_name]
+                      if target_endpoint.address != source_endpoint.address ||
+                        target_endpoint.port != source_endpoint.port ||
+                        target_endpoint.protocol != source_endpoint.protocol
+
+                        changed_roles << source_role_name
+                      end
+                    else
+                      changed_roles << source_role_name
+                    end
+                  end
+                else
+                  changed_roles << source_role_name
+                end
+              else
+                changed_roles << source_role_name
+              end
+            end
+          else
+            changed_roles << source_role_name
+          end
+        end
+
+        # find added roles
+        target_roles.each do |target_role_name, target_role|
+          if !source_roles[target_role_name]
+            changed_roles << target_role_name
+          end
+        end
+
+        [changed_settings, changed_roles]
+      end
+    end
+  end
+end