easy_upnp 1.0.1 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a1d0115b9fa09e9153b84782c6e5c79d86fa80d6
-  data.tar.gz: 3d3383dc43d280a1a5db1e56f7c7479ea9e8eff7
+  metadata.gz: b697312acbbe5ad906d385375b5da32f41e99976
+  data.tar.gz: cb2b7666648460e0d7632cdde1022ec73872a7f0
 SHA512:
-  metadata.gz: 4315c796f88ba6fc46dcf6bbaf0f8fe4c51e80c8601ad10c20afcb81e73e185625a4a5a40b35bbc1d437c8837c8368aa69be2008e08c2c562edc6945fba08dab
-  data.tar.gz: 226784376fa3b7db72b722260aa722a348a3e5ff02ee585d06e421652d53eb5d8e9e0ef92dd773f790e7a56536a2fd064c242918beb774c9607f61fac7eb9a26
+  metadata.gz: 8ecf14d57ea0826ba2a9471ac36914962c84ec4138d1b4f22c04b450e3df8a1c9cf916737d0a353597fb797ea4a0cdab5b6c809586f966e02931490152ac0237
+  data.tar.gz: 222a363cc222047da62f344f2ef554445cab219c661c7f13f3e55a31cb0d2ff829128719cf4d7109347d17ce99a58d3525c56143321c574e2240d2a72d73f49b

data/lib/easy_upnp/control_point/device_control_point.rb

@@ -2,15 +2,21 @@ require 'nokogiri'
 require 'open-uri'
 require 'nori'
 
+require_relative '../options_base'
+
 require_relative 'validator_provider'
 require_relative 'client_wrapper'
 require_relative 'service_method'
 
+require_relative '../events/event_client'
+require_relative '../events/http_listener'
+require_relative '../events/subscription_manager'
+
 module EasyUpnp
   class DeviceControlPoint
-    attr_reader :service_endpoint
+    attr_reader :event_vars, :service_endpoint, :events_endpoint
 
-    class Options
+    class Options < EasyUpnp::OptionsBase
       DEFAULTS = {
         advanced_typecasting: true,
         validate_arguments: false,
@@ -19,31 +25,31 @@ module EasyUpnp
         call_options: {}
       }
 
-      attr_reader :options
-
       def initialize(o = {}, &block)
-        @options = o.merge(DEFAULTS)
-
-        DEFAULTS.map do |k, v|
-          define_singleton_method(k) do
-            @options[k]
-          end
+        super(o, DEFAULTS, &block)
+      end
+    end
 
-          define_singleton_method("#{k}=") do |v|
-            @options[k] = v
-          end
-        end
+    class EventConfigOptions < EasyUpnp::OptionsBase
+      DEFAULTS = {
+        configure_http_listener: ->(c) { },
+        configure_subscription_manager: ->(c) { }
+      }
 
-        block.call(self) unless block.nil?
+      def initialize(&block)
+        super({}, DEFAULTS, &block)
       end
     end
 
-    def initialize(urn, service_endpoint, definition, options, &block)
+    def initialize(urn, service_endpoint, events_endpoint, definition, options, &block)
       @urn = urn
       @service_endpoint = service_endpoint
       @definition = definition
       @options = Options.new(options, &block)
 
+      @events_endpoint = events_endpoint
+      @events_client = EasyUpnp::EventClient.new(events_endpoint)
+
       @client = ClientWrapper.new(
         service_endpoint,
         urn,
@@ -66,12 +72,18 @@ module EasyUpnp
         # Adds a method to the class
         define_service_method(method, @client, @validator_provider, @options)
       end
+
+      @event_vars = definition_xml.
+        xpath('//serviceStateTable/stateVariable[@sendEvents = "yes"]/name').
+        map(&:text).
+        map(&:to_sym)
     end
 
     def to_params
       {
         urn: @urn,
         service_endpoint: @service_endpoint,
+        events_endpoint: @events_endpoint,
         definition: @definition,
         options: @options.options
       }
@@ -81,6 +93,7 @@ module EasyUpnp
       DeviceControlPoint.new(
           params[:urn],
           params[:service_endpoint],
+          params[:events_endpoint],
           params[:definition],
           params[:options]
       )
@@ -102,9 +115,14 @@ module EasyUpnp
         service_definition_uri = URI.join(root_uri, service.xpath('service/SCPDURL').text).to_s
         service_definition = open(service_definition_uri) { |f| f.read }
 
+        endpoint_url = ->(xpath) do
+          URI.join(root_uri, service.xpath(xpath).text).to_s
+        end
+
         DeviceControlPoint.new(
             urn,
-            URI.join(root_uri, service.xpath('service/controlURL').text).to_s,
+            endpoint_url.call('service/controlURL'),
+            endpoint_url.call('service/eventSubURL'),
             service_definition,
             options,
             &block
@@ -134,6 +152,39 @@ module EasyUpnp
       @service_methods.keys
     end
 
+    def add_event_callback(url)
+      manager = EasyUpnp::SubscriptionManager.new(@events_client, url)
+      manager.subscribe
+      manager
+    end
+
+    def on_event(callback, &block)
+      raise ArgumentError, 'Must provide block' if callback.nil?
+
+      options = EventConfigOptions.new(&block)
+
+      listener = EasyUpnp::HttpListener.new(callback: callback) do |c|
+        options.configure_http_listener.call(c)
+      end
+
+      # exposing the URL as a lambda allows the subscription manager to get a
+      # new URL should the server stop and start again on a different port.
+      url = ->() { listener.listen }
+
+      manager = EasyUpnp::SubscriptionManager.new(@events_client, url) do |c|
+        options.configure_subscription_manager.call(c)
+
+        user_shutdown = c.on_shutdown
+        c.on_shutdown = ->() do
+          user_shutdown.call if user_shutdown
+          listener.shutdown
+        end
+      end
+
+      manager.subscribe
+      manager
+    end
+
     private
 
     def define_service_method(method, client, validator_provider, options)

data/lib/easy_upnp/events/event_client.rb

@@ -0,0 +1,126 @@
+require 'net/http'
+
+require_relative '../options_base'
+
+module EasyUpnp
+  class EventClient
+    class SubscriptionError < StandardError; end
+
+    def initialize(events_endpoint)
+      @events_endpoint = URI(events_endpoint)
+    end
+
+    def subscribe(callback, timeout: 300)
+      req = SubscribeRequest.new(
+        @events_endpoint,
+        callback,
+        timeout
+      )
+
+      response = do_request(req)
+
+      if !response['SID']
+        raise SubscriptionError, "SID header not present in response: #{response.to_hash}"
+      end
+
+      SubscribeResponse.new(response)
+    end
+
+    def unsubscribe(sid)
+      req = UnsubscribeRequest.new(
+        @events_endpoint,
+        sid
+      )
+      do_request(req)
+      true
+    end
+
+    def resubscribe(sid, timeout: 300)
+      req = ResubscribeRequest.new(
+        @events_endpoint,
+        sid,
+        timeout
+      )
+
+      response = do_request(req)
+
+      SubscribeResponse.new(response)
+    end
+
+    private
+
+    def do_request(req)
+      uri = URI(@events_endpoint)
+      Net::HTTP.start(uri.host, uri.port) do |http|
+        response = http.request(req)
+
+        if response.code.to_i != 200
+          raise SubscriptionError, "Unexpected response type (#{response.code}): #{response.body}"
+        end
+
+        return response
+      end
+    end
+
+    class SubscribeResponse
+      TIMEOUT_HEADER_REGEX = /Second-(\d+)/i
+
+      attr_reader :sid, :timeout
+
+      def initialize(request)
+        @sid = request['SID']
+        @timeout = TIMEOUT_HEADER_REGEX.match(request['TIMEOUT'])[1].to_i
+      end
+    end
+
+    class EventRequest < Net::HTTPRequest
+      def timeout=(v)
+        self['TIMEOUT'] = "Second-#{v}"
+      end
+
+      def callback=(v)
+        self['CALLBACK'] = "<#{v}>"
+        self['NT'] = 'upnp:event'
+      end
+
+      def sid=(v)
+        self['SID'] = v
+      end
+    end
+
+    class ResubscribeRequest < EventRequest
+      METHOD = 'SUBSCRIBE'
+      REQUEST_HAS_BODY = false
+      RESPONSE_HAS_BODY = true
+
+      def initialize(event_url, sid, timeout)
+        super(URI(event_url))
+        self.timeout = timeout
+        self.sid = sid
+      end
+    end
+
+    class SubscribeRequest < EventRequest
+      METHOD = 'SUBSCRIBE'
+      REQUEST_HAS_BODY = false
+      RESPONSE_HAS_BODY = true
+
+      def initialize(event_url, callback_url, timeout)
+        super(URI(event_url))
+        self.timeout = timeout
+        self.callback = callback_url
+      end
+    end
+
+    class UnsubscribeRequest < EventRequest
+      METHOD = 'UNSUBSCRIBE'
+      REQUEST_HAS_BODY = false
+      RESPONSE_HAS_BODY = true
+
+      def initialize(event_url, sid)
+        super(URI(event_url))
+        self.sid = sid
+      end
+    end
+  end
+end

data/lib/easy_upnp/events/http_listener.rb

@@ -0,0 +1,76 @@
+require 'webrick'
+require 'thread'
+
+require_relative '../options_base'
+
+module EasyUpnp
+  class HttpListener
+    class Options < EasyUpnp::OptionsBase
+      DEFAULTS = {
+        # Port to listen on. Default value "0" will cause OS to choose a random
+        # ephemeral port
+        listen_port: 0,
+
+        # Address to bind listener on. Default value binds to all IPv4
+        # interfaces.
+        bind_address: '0.0.0.0',
+
+        # By default, event callback just prints the request body
+        callback: ->(request) { puts request.body }
+      }
+
+      def initialize(options)
+        super(options, DEFAULTS)
+      end
+    end
+
+    def initialize(o = {}, &block)
+      @options = Options.new(o, &block)
+    end
+
+    def listen
+      if !@listen_thread
+        @server = WEBrick::HTTPServer.new(
+          Port: @options.listen_port,
+          AccessLog: [],
+          BindAddress: @options.bind_address
+        )
+        @server.mount('/', NotifyServlet, @options.callback)
+      end
+
+      @listen_thread ||= Thread.new do
+        @server.start
+      end
+
+      url
+    end
+
+    def url
+      if !@listen_thread or !@server
+        raise RuntimeError, 'Server not started'
+      end
+
+      addr = Socket.ip_address_list.detect{|intf| intf.ipv4_private?}
+      port = @server.config[:Port]
+
+      "http://#{addr.ip_address}:#{port}"
+    end
+
+    def shutdown
+      raise RuntimeError, "Illegal state: server is not started" if @listen_thread.nil?
+
+      @listen_thread.kill
+      @listen_thread = nil
+    end
+  end
+
+  class NotifyServlet < WEBrick::HTTPServlet::AbstractServlet
+    def initialize(_server, block)
+      @callback = block
+    end
+
+    def do_NOTIFY(request, response)
+      @callback.call(request)
+    end
+  end
+end

data/lib/easy_upnp/events/subscription_manager.rb

@@ -0,0 +1,153 @@
+require_relative '../options_base'
+
+module EasyUpnp
+  class Options < EasyUpnp::OptionsBase
+    DEFAULTS = {
+      ##
+      # Number of seconds to request our event subscription be active for. The
+      # server can set it to whatever it wants.
+      requested_timeout: 300,
+
+      ##
+      # Number of seconds before a subscription expires before we request that
+      # it be refreshed.
+      resubscription_interval_buffer: 10,
+
+      ##
+      # Specifies an existing subscription ID. If non-nil, will attempt to
+      # maintain the existing subscription, creating a new one if there's an
+      # error. If nil, will always create a new subscription.
+      existing_sid: nil,
+
+      logger: Logger.new($stdout),
+      log_level: Logger::WARN,
+
+      on_shutdown: -> { }
+    }
+
+    def initialize(o, &block)
+      super(o, DEFAULTS, &block)
+    end
+  end
+
+  class SubscriptionManager
+    def initialize(event_client, callback_url, options = {}, &block)
+      @options = Options.new(options, &block)
+      @event_client = event_client
+      @callback_url = callback_url
+      @sid = @options.existing_sid
+
+      logger.level = @options.log_level
+    end
+
+    def subscription_id
+      @sid
+    end
+
+    def callback_url
+      if @callback_url.is_a? Proc
+        @callback_url.call
+      else
+        @callback_url
+      end
+    end
+
+    def subscribe
+      @subscription_thread ||= Thread.new do
+        logger.info "Starting subscription thread..."
+
+        resubscribe_time = start_or_renew_subscription
+
+        begin
+          while true
+            if Time.now >= resubscribe_time
+              resubscribe_time = renew_subscription
+            else
+              sleep 1
+            end
+          end
+        rescue Exception => e
+          logger.error "Caught error: #{e}"
+          raise e
+        end
+
+        logger.info "Ending subscription"
+      end
+
+      true
+    end
+
+    def unsubscribe
+      if @subscription_thread.nil?
+        raise RuntimeError, "Illegal state: no active subscription"
+      end
+      @subscription_thread.kill
+      @subscription_thread = nil
+
+      begin
+        if @sid
+          @event_client.unsubscribe(@sid)
+          @sid = nil
+        end
+      rescue Exception => e
+        logger.error "Error unsubscribing with SID #{@sid}: #{e}"
+      end
+
+      @options.on_shutdown.call
+    end
+
+    private
+
+    def start_or_renew_subscription
+      if !@sid
+        start_subscription
+      else
+        renew_subscription
+      end
+    end
+
+    def renew_subscription
+      begin
+        logger.info "Refreshing subscription for: #{@sid}"
+        response = @event_client.resubscribe(
+          @sid,
+          timeout: @options.requested_timeout
+        )
+        logger.info "Got resubscribe response: #{response.inspect}"
+        @resubscribe_time = calculate_refresh_time(response)
+      rescue EasyUpnp::EventClient::SubscriptionError => e
+        logger.error "Error renewing subscription; trying to start a new one"
+        start_subscription
+      rescue Exception => e
+        logger.error "Unrecoverable exception renewing subscription: #{e}"
+        raise e
+      end
+    end
+
+    def start_subscription
+      begin
+        response = @event_client.subscribe(
+          callback_url,
+          timeout: @options.requested_timeout
+        )
+
+        logger.info "Got subscription response: #{response.inspect}"
+
+        @sid = response.sid
+        @resubscribe_time = calculate_refresh_time(response)
+      rescue Exception => e
+        logger.error "Error subscribing to event: #{e}"
+        raise e
+      end
+    end
+
+    def calculate_refresh_time(response)
+      timeout = response.timeout
+      Time.now + timeout - @options.resubscription_interval_buffer
+    end
+
+    def logger
+      @options.logger
+    end
+  end
+end

data/lib/easy_upnp/options_base.rb

@@ -0,0 +1,37 @@
+module EasyUpnp
+  class OptionsBase
+    class Builder
+      attr_reader :options
+
+      def initialize(supported_options)
+        @options = {}
+
+        supported_options.each do |k|
+          define_singleton_method("#{k}=") { |v| @options[k] = v }
+          define_singleton_method("#{k}") do |&block|
+            @options[k] = block if block
+            @options[k]
+          end
+        end
+      end
+    end
+
+    attr_reader :options
+
+    def initialize(options, defaults, &block)
+      @options = defaults.merge(options)
+
+      if block
+        block_builder = Builder.new(defaults.keys)
+        block.call(block_builder)
+        @options = @options.merge(block_builder.options)
+      end
+
+      defaults.map do |k, v|
+        define_singleton_method(k) do
+          @options[k]
+        end
+      end
+    end
+  end
+end

data/lib/easy_upnp/version.rb

@@ -1,3 +1,3 @@
 module EasyUpnp
-  VERSION = '1.0.1'
+  VERSION = '1.1.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: easy_upnp
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.1
 platform: ruby
 authors:
 - Christopher Mullins
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-16 00:00:00.000000000 Z
+date: 2016-04-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -71,6 +71,10 @@ files:
 - lib/easy_upnp/control_point/device_control_point.rb
 - lib/easy_upnp/control_point/service_method.rb
 - lib/easy_upnp/control_point/validator_provider.rb
+- lib/easy_upnp/events/event_client.rb
+- lib/easy_upnp/events/http_listener.rb
+- lib/easy_upnp/events/subscription_manager.rb
+- lib/easy_upnp/options_base.rb
 - lib/easy_upnp/ssdp_searcher.rb
 - lib/easy_upnp/upnp_device.rb
 - lib/easy_upnp/version.rb