rupnp 0.2.2 → 0.3.0

data/lib/rupnp.rb

@@ -6,7 +6,7 @@ require 'eventmachine-le'
 module RUPNP
 
   # RUPNP version
-  VERSION = '0.2.2'
+  VERSION = '0.3.0'
 
   @logdev = STDERR
   @log_level = :info
@@ -57,7 +57,6 @@ require_relative 'rupnp/cp/base'
 require_relative 'rupnp/cp/remote_service'
 require_relative 'rupnp/cp/remote_device'
 require_relative 'rupnp/cp/event_server'
-require_relative 'rupnp/cp/event_subscriber'
 require_relative 'rupnp/ssdp'
 
 require_relative 'rupnp/device'

data/lib/rupnp/control_point.rb

@@ -24,10 +24,6 @@ module RUPNP
     # Get event listening port
     # @return [Integer]
     attr_reader :event_port
-    # Return channel to add event URL (URL to listen for a specific
-    # event)
-    # @return [EM::Channel]
-    attr_reader :add_event_url
     # Return remote devices controlled by this control point
     # @return [Array<CP::RemoteDevice>]
     attr_reader :devices
@@ -48,7 +44,6 @@ module RUPNP
       @devices = []
       @new_device_channel = EM::Channel.new
       @bye_device_channel = EM::Channel.new
-      @add_event_url = EM::Channel.new
     end
 
     # Start control point.
@@ -79,8 +74,7 @@ module RUPNP
     # @return [void]
     def start_event_server(port=EVENT_SUB_DEFAULT_PORT)
       @event_port ||= port
-      @event_server ||= EM.start_server('0.0.0.0', port, CP::EventServer,
-                                        @add_event_url)
+      @event_server ||= EM.start_server('0.0.0.0', port, CP::EventServer)
     end
 
     # Stop event server

data/lib/rupnp/cp/event_server.rb

@@ -7,44 +7,104 @@ module RUPNP
   class CP::EventServer < EM::HttpServer::Server
     include LogMixin
 
-    # Channel to add url for listening to
-    # @return [EM::Channel]
-    attr_reader :add_url
-
+    # @private
+    @@add_event = EM::Channel.new
+    # @private
+    @@events = []
 
-    # @param [EM::Channel] add_url_channel channel for adding url
-    def initialize(add_url_channel)
-      super
+    @@add_event.subscribe do |url|
+      @@events << url
+    end
 
-      @urls = []
-      @add_url = add_url_channel
+    class << self
+      # Channel to add url for listening to
+      # @param [Event] event
+      # @return [void]
+      def add_event(event)
+        @@add_event << event
+      end
 
-      @add_url.subscribe do |url|
-        log :info, "add URL #{url} for eventing"
-        @urls << url
+      # Remove an event
+      # @param [Event] event
+      # @return [void]
+      def remove_event(event)
+        @@events.delete_if { |e| e == event }
       end
     end
 
+
+    # Channel to return received updated variables from events
+    # @return [EM::Channel]
+    attr_reader :events
+
+
     # Process a HTTP request received from a service/device
     def process_http_request
-      log :debug, 'EventServer: receive request'
-      url, event = @urls.find { |a| a[0] == @http_request_uri }
-
-      if event.is_a? EM::Channel
-        if @http_request_method == 'NOTIFY'
-          if @http[:nt] == 'upnp:event' and @http[:nts] == 'upnp:propchange'
-            event << {
-              :sid => @http[:sid],
-              :seq => @http[:seq],
-              :content => @http_content }
-          else
-            log :warn, 'EventServer: ' +
-              "malformed NOTIFY event message:\n#@http_headers\n#@http_content"
-          end
-        else
-          log :warn, "EventServer: unknown HTTP verb: #@http_request_method"
-        end
+      log :debug, "EventServer: receive request: #@http"
+
+      response = EM::DelegatedHttpResponse.new(self)
+
+      if @http_request_method != 'NOTIFY'
+        log :info, "EventServer: method #@http_request_method not allowed"
+        response.status = 405
+        response.headers['Allow'] = 'NOTIFY'
+        response.send_response
+        return
+      end
+
+      event = @@events.find { |e| e.callback_url == @http_request_uri }
+
+      if event.nil?
+        log :info, "EventServer: Requested URI #@http_request_uri unknown"
+        response.status = 404
+        response.send_response
+        return
+      end
+
+      if !event.is_a? EM::Channel
+        log :error, "EventServer: internal error!"
+        response.status = 500
+        response.send_response
+        return
+      end
+
+      if !@http.has_key?(:nt) or !@http.has_key?(:nts)
+        log :warn, 'EventServer: malformed NOTIFY event message'
+        log :debug, "#@http_headers\n#@http_content"
+        response.status = 400
+        response.send_response
+        return
+      end
+
+      if @http[:nt] != 'upnp:event' or @http[:nts] != 'upnp:propchange' or
+          !@http.has_key?(:sid) or @http[:sid] == ''
+        log :warn, 'EventServer: precondition failed'
+        log :debug, "#@http_headers\n#@http_content"
+        response.status = 412
+        response.send_response
+        return
+      end
+
+      if event.sid != @http[:sid]
+        log :warn, 'EventServer: precondition failed (unknown SID)'
+        log :debug, "#@http_headers\n#@http_content"
+        response.status = 412
+        response.send_response
+        return
       end
+
+      seq = @http[:seq].nil? ? 0 : @http[:seq].to_i
+      notification = {
+        :seq => seq,
+        :content => Nori.new.parse(@http_content)
+      }
+
+      log :debug, "send notification #{notification.inspect}\n" +
+        "    to #{event}"
+      event << notification
+
+      response_status = 200
+      response.send_response
     end
 
   end

data/lib/rupnp/cp/remote_service.rb

@@ -3,304 +3,375 @@ require 'savon'
 require_relative 'base'
 
 module RUPNP
+  module CP
+
+    # Service class for device's services.
+    #
+    # ==Actions
+    # This class defines ruby methods from actions defined in
+    # service description, as provided by the device.
+    #
+    # By example, from this description:
+    #  <action>
+    #    <name>actionName</name>
+    #    <argumentList>
+    #    <argument>
+    #      <name>argumentNameIn</name>
+    #      <direction>in</direction>
+    #      <relatedStateVariable>stateVariableName</relatedStateVariable>
+    #    </argument>
+    #    <argument>
+    #      <name>argumentNameOut</name>
+    #      <direction>out</direction>
+    #      <relatedStateVariable>stateVariableName</relatedStateVariable>
+    #    </argument>
+    #  </action>
+    # a +#action_name+ method is created. This method requires a hash with
+    # an element named +argument_name_in+.
+    # If no <i>in</i> argument is required, an empty hash (<code>{}</code>)
+    # must be passed to the method. Hash keys may not be symbols.
+    #
+    # A Hash is returned, with a key for each <i>out</i> argument.
+    #
+    # ==Evented variables
+    # Some variables in state (see {#state_table}, +:@send_events variable
+    # attribute) are evented. Events to update these variables are received
+    # only after subscription. To subscribe, use {#subscribe_to_event}.
+    #
+    # After subscribing to events, state variables are automagically updated
+    # on events. Their value may be accessed through {#variables}.
+    #
+    # A block may be passed to {#subscribe_to_event} to do a user action
+    # on receiving events.
+    #
+    #   service.subscribe_to_event do |msg|
+    #     puts "receive #{msg}"
+    #   end
+    #
+    # @author Sylvain Daubert
+    class RemoteService < Base
+
+      # @private
+      @@event_sub_count = 0
+
+      # Get event subscription count for all services
+      # (unique ID for subscription)
+      # @return [Integer]
+      def self.event_sub_count
+        @@event_sub_count += 1
+      end
 
-  # Service class for device's services.
-  #
-  # ==Actions
-  # This class defines ruby methods from actions defined in
-  # service description, as provided by the device.
-  #
-  # By example, from this description:
-  #  <action>
-  #    <name>actionName</name>
-  #    <argumentList>
-  #    <argument>
-  #      <name>argumentNameIn</name>
-  #      <direction>in</direction>
-  #      <relatedStateVariable>stateVariableName</relatedStateVariable>
-  #    </argument>
-  #    <argument>
-  #      <name>argumentNameOut</name>
-  #      <direction>out</direction>
-  #      <relatedStateVariable>stateVariableName</relatedStateVariable>
-  #    </argument>
-  #  </action>
-  # a +#action_name+ method is created. This method requires a hash with
-  # an element named +argument_name_in+.
-  # If no <i>in</i> argument is required, an empty hash (<code>{}</code>)
-  # must be passed to the method. Hash keys may not be symbols.
-  #
-  # A Hash is returned, with a key for each <i>out</i> argument.
-  #
-  # @author Sylvain Daubert
-  class CP::RemoteService < CP::Base
-
-    # @private
-    @@event_sub_count = 0
-
-    # Get event subscription count for all services
-    # (unique ID for subscription)
-    # @return [Integer]
-    def self.event_sub_count
-      @@event_sub_count += 1
-    end
-
-
-    # @private SOAP integer types
-    INTEGER_TYPES = %w(ui1 ui2 ui4 i1 i2 i4 int).freeze
-    # @private SOAP float types
-    FLOAT_TYPES = %w(r4 r8 number float).freeze
-    # @private SOAP string types
-    STRING_TYPES = %w(char string uuid).freeze
-    # @private SOAP true values
-    TRUE_TYPES = %w(1 true yes).freeze
-    # @private SOAP false values
-    FALSE_TYPES = %w(0 false no).freeze
-
-    # Get device to which this service belongs to
-    # @return [Device]
-    attr_reader :device
-
-    # Get service type
-    # @return [String]
-    attr_reader :type
-    # Get service id
-    # @return [String]
-    attr_reader :id
-    # URL for service description
-    # @return [String]
-    attr_reader :scpd_url
-    # URL for control
-    # @return [String]
-    attr_reader :control_url
-    # URL for eventing
-    # @return [String]
-    attr_reader :event_sub_url
-
-    # XML namespace for device description
-    # @return [String]
-    attr_reader :xmlns
-    # Define architecture on which the service is implemented
-    # @return [String]
-    attr_reader :spec_version
-    # Available actions on this service
-    # @return [Array<Hash>]
-    attr_reader :actions
-    # State table for the service
-    # @return [Array<Hash>]
-    attr_reader :state_table
-
-    # @param [Device] device
-    # @param [String] url_base
-    # @param [Hash] service
-    def initialize(device, url_base, service)
-      super()
-      @device = device
-      @description = service
-
-      @type = service[:service_type].to_s
-      @id = service[:service_id].to_s
-      @scpd_url = build_url(url_base,  service[:scpdurl].to_s)
-      @control_url =  build_url(url_base, service[:control_url].to_s)
-      @event_sub_url =  build_url(url_base, service[:event_sub_url].to_s)
-      @actions = []
-
-      initialize_savon
-    end
 
-    # Get service from its description
-    # @return [void]
-    def fetch
-      scpd_getter = EM::DefaultDeferrable.new
+      # @private SOAP integer types
+      INTEGER_TYPES = %w(ui1 ui2 ui4 i1 i2 i4 int).freeze
+      # @private SOAP float types
+      FLOAT_TYPES = %w(r4 r8 number float).freeze
+      # @private SOAP string types
+      STRING_TYPES = %w(char string uuid).freeze
+      # @private SOAP true values
+      TRUE_TYPES = %w(1 true yes).freeze
+      # @private SOAP false values
+      FALSE_TYPES = %w(0 false no).freeze
+
+      # Get device to which this service belongs to
+      # @return [Device]
+      attr_reader :device
+
+      # Get service type
+      # @return [String]
+      attr_reader :type
+      # Get service id
+      # @return [String]
+      attr_reader :id
+      # URL for service description
+      # @return [String]
+      attr_reader :scpd_url
+      # URL for control
+      # @return [String]
+      attr_reader :control_url
+      # URL for eventing
+      # @return [String]
+      attr_reader :event_sub_url
+
+      # XML namespace for device description
+      # @return [String]
+      attr_reader :xmlns
+      # Define architecture on which the service is implemented
+      # @return [String]
+      attr_reader :spec_version
+      # Available actions on this service
+      # @return [Array<Hash>]
+      attr_reader :actions
+      # State table for the service
+      # @return [Array<Hash>]
+      attr_reader :state_table
+      # Variables from state table
+      # @return [Hash]
+      attr_reader :variables
+
+      # @param [Device] device
+      # @param [String] url_base
+      # @param [Hash] service
+      def initialize(device, url_base, service)
+        super()
+        @device = device
+        @description = service
+
+        @type = service[:service_type].to_s
+        @id = service[:service_id].to_s
+        @scpd_url = build_url(url_base,  service[:scpdurl].to_s)
+        @control_url =  build_url(url_base, service[:control_url].to_s)
+        @event_sub_url =  build_url(url_base, service[:event_sub_url].to_s)
+        @actions = []
+        @variables = {}
+        @update_variables = EM::Channel.new
+
+        @update_variables.subscribe do |var, value|
+          @variables[var] = value
+          log :debug, "varibale #{var} set to #{value}"
+        end
 
-      scpd_getter.errback do
-        fail "cannot get SCPD from #@scpd_url"
-        next
+        initialize_savon
       end
 
-      scpd_getter.callback do |scpd|
-        if bad_description?(scpd)
-          fail 'not a UPNP 1.0/1.1 SCPD'
+      # Get service from its description
+      # @return [void]
+      def fetch
+        scpd_getter = EM::DefaultDeferrable.new
+
+        scpd_getter.errback do
+          fail "cannot get SCPD from #@scpd_url"
           next
         end
 
-        extract_service_state_table scpd
-        extract_actions scpd
+        scpd_getter.callback do |scpd|
+          if bad_description?(scpd)
+            fail 'not a UPNP 1.0/1.1 SCPD'
+            next
+          end
 
-        succeed self
-      end
+          extract_service_state_table scpd
+          extract_actions scpd
 
-      get_description @scpd_url, scpd_getter
-    end
+          succeed self
+        end
 
-    # Subscribe to event
-    # @param [Hash] options
-    # @option options [Integer] timeout
-    # @yieldparam [Event] event event received
-    # @yieldparam [Object] msg message received
-    # @return [Integer] subscribe id. May be used to unsubscribe on event
-    def subscribe_to_event(options={}, &blk)
-      cp = device.control_point
-
-      cp.start_event_server
-
-      port = cp.event_port
-      num = self.class.event_sub_count
-      @callback_url = "http://#{HOST_IP}:#{port}/event#{num}}"
-
-      uri = URI(@event_sub_url)
-      options[:timeout] ||= EVENT_SUB_DEFAULT_TIMEOUT
-
-      log :info, "send SUBSCRIBE request to #{uri}"
-      con = EM::HttpRequest.new(@event_sub_url)
-      http = con.setup_request(:subscribe, :head => {
-                                 'HOST' => "#{uri.host}:#{uri.port}",
-                                 'USER-AGENT' => RUPNP::USER_AGENT,
-                                 'CALLBACK' => @callback_url,
-                                 'NT' => 'upnp:event',
-                                 'TIMEOUT' => "Second-#{options[:timeout]}"})
-
-      http.errback do |client|
-        log :warn, "Cannot subscribe to event: #{client.error}"
+        get_description @scpd_url, scpd_getter
       end
 
-      http.callback do
-        log :debug, 'Close connection to subscribe event URL'
-        con.close
-        if http.response_header.status != 200
-          log :warn, "Cannot subscribe to event #@event_sub_url:" +
-            " #{http.response_header.http_reason}"
-        else
-          timeout = http.response_header['TIMEOUT'].match(/(\d+)/)[1] || 1800
-          event = Event.new(@event_sub_url, @callback_url,
-                            http.response_header['SID'], timeout.to_i)
-          cp.add_event_url << ["/event#{num}", event]
-          event.subscribe &blk
+      # Subscribe to event
+      # @param [Hash] options
+      # @option options [Integer] timeout
+      # @yieldparam [Event] event event received
+      # @yieldparam [Object] msg message received
+      # @return [Integer] subscribe id. May be used to unsubscribe on event
+      # @since 0.3.0
+      def subscribe_to_event(options={}, &blk)
+        cp = device.control_point
+
+        cp.start_event_server
+
+        port = cp.event_port
+        num = self.class.event_sub_count
+        @callback_url = "http://#{HOST_IP}:#{port}/events/#{num}"
+
+        uri = URI(@event_sub_url)
+        options[:timeout] ||= EVENT_SUB_DEFAULT_TIMEOUT
+
+        log :info, "send SUBSCRIBE request to #{uri}"
+        con = EM::HttpRequest.new(@event_sub_url)
+        http = con.setup_request(:subscribe, :head => {
+                                   'HOST' => "#{uri.host}:#{uri.port}",
+                                   'USER-AGENT' => RUPNP::USER_AGENT,
+                                   'CALLBACK' => @callback_url,
+                                   'NT' => 'upnp:event',
+                                   'TIMEOUT' => "Second-#{options[:timeout]}"})
+
+        http.errback do |client|
+          log :warn, "Cannot subscribe to event: #{client.error}"
+        end
+
+        http.callback do
+          log :debug, 'Close connection to subscribe event URL'
+          con.close
+          if http.response_header.status != 200
+            log :warn, "Cannot subscribe to event #@event_sub_url:" +
+              " #{http.response_header.http_reason}"
+          else
+            timeout = http.response_header['TIMEOUT'].match(/(\d+)/)[1] || 1800
+            event = Event.new(@event_sub_url, URI(@callback_url).path,
+                              http.response_header['SID'], timeout.to_i)
+            EventServer.add_event event
+            log :info, 'event subscribtion registered'
+            log :debug, "event: #{event.inspect}"
+
+            event.subscribe do |msg|
+              log :debug, "event #{event} received"
+              if msg.is_a? Hash and msg[:content].is_a? Hash
+                msg[:content].each do |k, v|
+                  if @variables.has_key? k
+                    log :info, "update evented variable #{k}"
+                    type = get_data_type_from_table(k)
+                    @update_variables << [k, get_value_from_type(type, v)]
+                  end
+                end
+              end
+              log :debug, "call user block"
+              blk.call(msg) if blk
+            end
+          end
         end
       end
-    end
 
 
-    private
-
-    def bad_description?(scpd)
-      if scpd[:scpd]
-        bd = false
-        @xmlns = scpd[:scpd][:@xmlns]
-        bd |= @xmlns != "urn:schemas-upnp-org:service-1-0"
-        bd |= scpd[:scpd][:spec_version][:major].to_i != 1
-        @spec_version = scpd[:scpd][:spec_version][:major] + '.'
-        @spec_version += scpd[:scpd][:spec_version][:minor]
-        bd |= !scpd[:scpd][:service_state_table]
-        bd | scpd[:scpd][:service_state_table].empty?
-      else
-        true
+      private
+
+      def bad_description?(scpd)
+        if scpd[:scpd]
+          bd = false
+          @xmlns = scpd[:scpd][:@xmlns]
+          bd |= @xmlns != "urn:schemas-upnp-org:service-1-0"
+          bd |= scpd[:scpd][:spec_version][:major].to_i != 1
+          @spec_version = scpd[:scpd][:spec_version][:major] + '.'
+          @spec_version += scpd[:scpd][:spec_version][:minor]
+          bd |= !scpd[:scpd][:service_state_table]
+          bd | scpd[:scpd][:service_state_table].empty?
+        else
+          true
+        end
       end
-    end
 
-    def extract_service_state_table(scpd)
-      if scpd[:scpd][:service_state_table][:state_variable]
-        @state_table = scpd[:scpd][:service_state_table][:state_variable]
+      def extract_service_state_table(scpd)
+        if scpd[:scpd][:service_state_table][:state_variable]
+          @state_table = scpd[:scpd][:service_state_table][:state_variable]
+
+          if @state_table.is_a? Hash
+            @state_table = [@state_table]
+          end
 
-        if @state_table.is_a? Hash
-          @state_table = [@state_table]
+           @state_table.each do |var|
+            name = var[:name]
+            if INTEGER_TYPES.include? var[:data_type]
+              value = var[:default_value] ||
+                var[:allowed_value_range][:minimum] || 0
+            elsif FLOAT_TYPES.include? var[:data_type]
+              value = var[:default_value] ||
+                var[:allowed_value_range][:minimum] || 0
+            elsif STRING_TYPES.include? var[:data_type]
+              value = var[:default_value] ||
+                var[:allowed_value_list][:allowed_value].first || ''
+            else
+              value = nil
+            end
+
+            value = get_value_from_type(var[:data_type], value)
+            @update_variables << [name, value]
+          end
         end
       end
-    end
 
-    def extract_actions(scpd)
-      if scpd[:scpd][:action_list] and scpd[:scpd][:action_list][:action]
-        log :info, "extract actions for service #@type"
-        @actions = scpd[:scpd][:action_list][:action]
-        @actions = [@actions] unless @actions.is_a? Array
-        @actions.each do |action|
-          action[:arguments] = action[:argument_list][:argument]
-          action.delete :argument_list
-          define_method_from_action action
+      def extract_actions(scpd)
+        if scpd[:scpd][:action_list] and scpd[:scpd][:action_list][:action]
+          log :info, "extract actions for service #@type"
+          @actions = scpd[:scpd][:action_list][:action]
+          @actions = [@actions] unless @actions.is_a? Array
+          @actions.each do |action|
+            action[:arguments] = action[:argument_list][:argument]
+            action.delete :argument_list
+            define_method_from_action action
+          end
         end
       end
-    end
 
-    def define_method_from_action(action)
-      action[:name] = action[:name].to_s
-      action_name = action[:name]
-      name = snake_case(action_name).to_sym
+      def define_method_from_action(action)
+        action[:name] = action[:name].to_s
+        action_name = action[:name]
+        name = snake_case(action_name).to_sym
 
-      define_singleton_method(name) do |params|
-        if params
-          unless params.is_a? Hash
-            raise ArgumentError, 'only hash arguments are accepted'
+        define_singleton_method(name) do |params|
+          if params
+            unless params.is_a? Hash
+              raise ArgumentError, 'only hash arguments are accepted'
+            end
           end
-        end
-        response = @soap.call(action_name) do |locals|
-          locals.attributes 'xmlns:u' => @type
-          locals.soap_action "#{type}##{action_name}"
-          locals.message params
-        end
-
-        if action[:arguments].is_a? Hash
-          log :debug, 'only one argument in argument list'
-          if action[:arguments][:direction] == 'out'
-            process_soap_response name, response, action[:arguments]
+          response = @soap.call(action_name) do |locals|
+            locals.attributes 'xmlns:u' => @type
+            locals.soap_action "#{type}##{action_name}"
+            locals.message params
           end
-        else
-          log :debug, 'true argument list'
-          hsh = {}
-          outer = action[:arguments].select { |arg| arg[:direction] == 'out' }
-          outer.each do |arg|
-            hsh.merge! process_soap_response(name, response, arg)
+
+          if action[:arguments].is_a? Hash
+            log :debug, 'only one argument in argument list'
+            if action[:arguments][:direction] == 'out'
+              process_soap_response name, response, action[:arguments]
+            end
+          else
+            log :debug, 'true argument list'
+            hsh = {}
+            outer = action[:arguments].select { |arg| arg[:direction] == 'out' }
+            outer.each do |arg|
+              hsh.merge! process_soap_response(name, response, arg)
+            end
+            hsh
           end
-          hsh
         end
       end
-    end
 
-    def process_soap_response(action, resp, out_arg)
-      if resp.success? and resp.to_xml.empty?
-        log :debug, 'Successful SOAP request but empty response'
-        return {}
+      def process_soap_response(action, resp, out_arg)
+        if resp.success? and resp.to_xml.empty?
+          log :debug, 'Successful SOAP request but empty response'
+          return {}
+        end
+
+        state_var = @state_table.find do |h|
+          h[:name] == out_arg[:related_state_variable]
+        end
+
+        action_response = "#{action}_response".to_sym
+        out_arg_name = snake_case(out_arg[:name]).to_sym
+        value = resp.hash[:envelope][:body][action_response][out_arg_name]
+
+        { out_arg_name => get_value_from_type(state_var[:data_type], value) }
       end
 
-      state_var = @state_table.find do |h|
-        h[:name] == out_arg[:related_state_variable]
+      def get_value_from_type(type, value)
+        transform_method = if INTEGER_TYPES.include? type
+                             :to_i
+                           elsif FLOAT_TYPES.include? type
+                             :to_f
+                           elsif STRING_TYPES.include? type
+                             :to_s
+                           end
+        if transform_method
+          value.send(transform_method)
+        elsif TRUE_TYPES.include? type
+          true
+        elsif FALSE_TYPES.include? type
+          false
+        else
+          log :warn, "SOAP response has an unknown type: #{type}"
+          nil
+        end
       end
 
-      action_response = "#{action}_response".to_sym
-      out_arg_name = snake_case(out_arg[:name]).to_sym
-      value = resp.hash[:envelope][:body][action_response][out_arg_name]
-
-      transform_method = if INTEGER_TYPES.include? state_var[:data_type]
-                           :to_i
-                         elsif FLOAT_TYPES.include? state_var[:data_type]
-                           :to_f
-                         elsif STRING_TYPES.include? state_var[:data_type]
-                           :to_s
-                         end
-      if transform_method
-        { out_arg_name => value.send(transform_method) }
-      elsif TRUE_TYPES.include? state_var[:data_type]
-        {  out_arg_name => true }
-      elsif FALSE_TYPES.include? state_var[:data_type]
-        {  out_arg_name => false }
-      else
-        log :warn, "SOAP response has an unknown type: #{state_var[:data_type]}"
-        {}
+      def get_data_type_from_table(var_name)
+        @state_table.find { |v| v[:name] == var_name }[:data_type]
       end
-    end
 
-    def initialize_savon
-      @soap = Savon.client do |globals|
-        globals.log_level :error
-        globals.endpoint @control_url
-        globals.namespace @type
-        globals.convert_request_keys_to :camel_case
-        globals.log true
-        globals.headers :HOST => "#{HOST_IP}"
-        globals.env_namespace 's'
-        globals.namespace_identifier 'u'
+      def initialize_savon
+        @soap = Savon.client do |globals|
+          globals.log_level :error
+          globals.endpoint @control_url
+          globals.namespace @type
+          globals.convert_request_keys_to :camel_case
+          globals.log true
+          globals.headers :HOST => "#{HOST_IP}"
+          globals.env_namespace 's'
+          globals.namespace_identifier 'u'
+        end
       end
+
     end
 
   end
-
 end

data/lib/rupnp/event.rb

@@ -8,6 +8,7 @@ module RUPNP
     # Get service ID
     # @return [Integer]
     attr_reader :sid
+    attr_reader :callback_url
 
     # @param [String] event_suburl Event subscription URL
     # @param [String] callback_url Callback URL to receive events
@@ -16,17 +17,20 @@ module RUPNP
     def initialize(event_suburl, callback_url, sid, timeout)
       super()
       @event_suburl = event_suburl
+      @callback_url = callback_url
       @sid, @timeout = sid, timeout
 
       @timeout_timer = EM.add_timer(@timeout) { self << :timeout }
     end
 
     # Renew subscription to event
+    # @todo
     def renew_subscription
       raise NotImplementedError
     end
 
     # Cancel subscription to event
+    # @todo
     def cancel_subscription
       raise NotImplementedError
     end

data/spec/cp/event_server_spec.rb

@@ -0,0 +1,140 @@
+require_relative '../spec_helper'
+
+def start_server
+  EM.start_server('127.0.0.1', RUPNP::EVENT_SUB_DEFAULT_PORT,
+                  RUPNP::CP::EventServer)
+end
+
+
+module RUPNP
+  module CP
+
+    describe EventServer do
+      include EM::SpecHelper
+
+      let(:timeout) { 2 }
+      let(:sid) { "uuid:#{UUID.generate}" }
+      let(:event_uri) { '/event/1' }
+      let(:event) { Event.new('', event_uri, sid, timeout) }
+      let(:port) { RUPNP::EVENT_SUB_DEFAULT_PORT }
+      let(:req) {EM::HttpRequest.new("http://127.0.0.1:#{port}#{event_uri}")}
+
+      it 'should return 404 error on bad HTTP method URI' do
+        em do
+          start_server
+
+          req = EM::HttpRequest.new("http://127.0.0.1:#{port}/unknown")
+          http = send_notify_request(req)
+          http.errback { fail 'must not fail!' }
+          http.callback do
+            expect(http.response_header.status).to eq(404)
+            done
+          end
+        end
+      end
+
+      it 'should return 405 error on bad HTTP method' do
+        em do
+          start_server
+
+          http = req.get
+          http.callback do
+            expect(http.response_header.status).to eq(405)
+            done
+          end
+        end
+      end
+
+      it 'should return 400 error on malformed request' do
+        em do
+          req2 = req.dup
+          EventServer.add_event event
+          start_server
+
+          http = send_notify_request(req, :delete => 'NT')
+          http.errback { fail 'must not fail!' }
+          http.callback do
+            expect(http.response_header.status).to eq(400)
+            http2 = send_notify_request(req2, :delete => 'NTS')
+            http2.callback do
+              expect(http2.response_header.status).to eq(400)
+              done
+            end
+          end
+        end
+        EventServer.remove_event event
+      end
+
+      it 'should return 412 error on bad request' do
+        em do
+          EventServer.add_event event
+          start_server
+          http = send_notify_request(req, 'SID' => "uuid:#{UUID.generate}")
+          http.errback { fail 'must not fail!' }
+          http.callback do
+            expect(http.response_header.status).to eq(412)
+            done
+          end
+        end
+
+        em do
+          start_server
+          http = send_notify_request(req, 'NT' => "upnp:other")
+          http.errback { fail 'must not fail!' }
+          http.callback do
+            expect(http.response_header.status).to eq(412)
+            done
+          end
+        end
+
+
+        em do
+          start_server
+          http = send_notify_request(req, 'NTS' => "upnp:other")
+          http.errback { fail 'must not fail!' }
+          http.callback do
+            expect(http.response_header.status).to eq(412)
+            done
+          end
+        end
+
+        em do
+          start_server
+          http = send_notify_request(req, :delete => 'SID')
+          http.errback { fail 'must not fail!' }
+          http.callback do
+            expect(http.response_header.status).to eq(412)
+            done
+          end
+        end
+        EventServer.remove_event event
+      end
+
+      it 'should receive a NOTIFY request' do
+        em do
+          EventServer.add_event event
+          start_server
+          http = send_notify_request(req, 'SID' => sid)
+          http.errback { fail 'must not fail!' }
+          http_ok = event_ok = false
+          http.callback do
+            expect(http.response_header.status).to eq(200)
+            http_ok = true
+            done if event_ok
+          end
+          event.subscribe do |h|
+            expect(h[:seq]).to be_a(Integer)
+            expect(h[:content]).to be_a(Hash)
+            event_ok = true
+            done if http_ok
+          end
+        end
+        EventServer.remove_event event
+      end
+
+      it "should return updated variables through 'events' channel"
+      it 'should serve multiple URLs'
+    end
+
+  end
+end

data/spec/cp/remote_service_spec.rb

@@ -37,12 +37,19 @@ module RUPNP
           em do
             rs.errback { fail 'RemoteService#fetch should work' }
             rs.callback do
-              expect(rs.state_table).to have(4).items
+              expect(rs.state_table).to have(5).items
               expect(rs.state_table[0][:name]).to eq('X_variableName1')
               expect(rs.state_table[1][:data_type]).to eq('ui4')
               expect(rs.state_table[2][:default_value]).to eq('2')
               expect(rs.state_table[3][:allowed_value_range][:maximum]).
                 to eq('255')
+              expect(rs.state_table[4][:data_type]).to eq('string')
+              expect(rs.state_table[4][:default_value]).to eq('none')
+
+              expect(rs.variables['X_variableName1']).to be_a(Fixnum)
+              4.times do |i|
+                expect(rs.variables["X_variableName#{i+1}"]).to eq(i)
+              end
               done
             end
             rs.fetch
@@ -147,14 +154,19 @@ module RUPNP
           em do
             rs.errback { fail 'RemoteService#fetch should work' }
             rs.callback do
+              expect(rs.variables['X_variableName1']).to eq(0)
               rs.subscribe_to_event do |msg|
+                expect(rs.variables['X_variableName1']).to eq(12)
                 done
               end
             end
             rs.fetch
 
-            rs.device.control_point.add_event_url.subscribe do |url, event|
-              EM.add_timer(0) { event << 'message' }
+            EM.add_timer(1) do
+              event = class EventServer; @@events.last; end
+              url = "http://127.0.0.1:8080#{event.callback_url}"
+              conn = EM::HttpRequest.new(url)
+              send_notify_request(conn, 'SID' => event.sid)
             end
           end
         end

data/spec/spec_helper.rb

@@ -10,6 +10,7 @@ require 'webmock/rspec'
 
 RUPNP.log_level = :failure
 
+WebMock.disable_net_connect!(allow_localhost: true)
 
 class FakeMulticast < RUPNP::SSDP::MulticastConnection
   attr_reader :handshake_response, :packets
@@ -151,6 +152,17 @@ EOAL
     </stateVariable>
 EOSV
   end
+  scpd << <<EOSV2
+    <stateVariable sendEvents="#{opt[:send_event] ? 'yes' : 'no'}">
+      <name>X_variableStr</name>
+      <dataType>string</dataType>
+      <defaultValue>none</defaultValue>
+      <allowedValueList>
+        <allowedValue>none</allowedValue>
+        <allowedValue>another value</allowedValue>
+      </allowedValueList>
+    </stateVariable>
+EOSV2
   scpd << "  </serviceStateTable>\n</scpd>\n"
 end
 
@@ -175,6 +187,34 @@ EOD
 end
 
 
+def event_body
+  <<EOD
+<?xml version="1.0"?>
+<e:propertyset xmlns:e="urn:schemas-upnp-org:event-1-0">
+  <e:property>
+    <X_variableName1>12</variableName>
+  </e:property>
+</e:propertyset>
+EOD
+end
+
+
+def send_notify_request(req, options={})
+  delete = options.delete(:delete)
+  headers = {
+    'HOST' => "127.0.0.1:1234",
+    'USER-AGENT' => RUPNP::USER_AGENT,
+    'CONTENT-TYPE' => 'text/xml; charset="utf-8"',
+    'NT' => 'upnp:event',
+    'NTS' => 'upnp:propchange',
+    'SID' => "uuid:#{UUID.generate}",
+    'SEQ' => 0 }.merge(options)
+  headers.delete delete if delete
+
+  req.setup_request(:notify, :head => headers, :body => event_body)
+end
+
+
 NOTIFY_REGEX = {
   :common => [
               /^NOTIFY \* HTTP\/1.1\r\n/,

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rupnp
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-01 00:00:00.000000000 Z
+date: 2014-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: uuid
@@ -187,6 +187,7 @@ files:
 - spec/ssdp/searcher_spec.rb
 - spec/cp/remote_service_spec.rb
 - spec/cp/remote_device_spec.rb
+- spec/cp/event_server_spec.rb
 - spec/control_point_spec.rb
 - spec/spec_helper.rb
 - lib/rupnp.rb
@@ -203,7 +204,6 @@ files:
 - lib/rupnp/cp/base.rb
 - lib/rupnp/cp/event_server.rb
 - lib/rupnp/cp/remote_device.rb
-- lib/rupnp/cp/event_subscriber.rb
 - lib/rupnp/discover.rb
 - lib/rupnp/ssdp.rb
 - lib/rupnp/log_mixin.rb

data/lib/rupnp/cp/event_subscriber.rb

@@ -1,47 +0,0 @@
-module RUPNP
-
-  # Event subscriber to an event's service
-  # @author Sylvain Daubert
-  class CP::EventSubscriber < EM::Connection
-    include LogMixin
-
-    # Response from device
-    # @return [EM::Channel]
-    attr_reader :response
-
-
-    # @param [String] msg message to send for subscribing
-    def initialize(msg)
-      @msg = msg
-      @response = EM::Channel.new
-    end
-
-    # @return [void]
-    def post_init
-      log :debug, "send event subscribe request:\n#@msg"
-      send_data @msg
-    end
-
-    # Receive response from device and send it through {#response}
-    # @param [String] data
-    # @return [void]
-    def receive_data(data)
-      log :debug, "receive data from subscribe event action:\n#{data}"
-      resp = {}
-      io = StringIO.new(data)
-
-      status = io.readline
-
-      if status =~ /HTTP\/1\.1 (\d+) (.+)/
-        resp[:status] = $2
-        resp[:status_code] = $1
-
-        resp.merge!(get_http_headers(io))
-
-        @response << resp
-      end
-    end
-
-  end
-
-end