rupnp 0.1.0

data/lib/rupnp/cp/remote_device.rb

@@ -0,0 +1,271 @@
+require 'nori'
+require 'ostruct'
+
+
+module RUPNP
+
+  # A device is a UPnP service provider.
+  # @author Sylvain Daubert.
+  class CP::RemoteDevice < CP::Base
+    # Get control point which controls this device
+    # @return [ControlPoint]
+    attr_reader :control_point
+
+    # Get search target.
+    # @return [String]
+    attr_reader :st
+    # Get Unique Service Name
+    # @return [String]
+    attr_reader :usn
+    # Get SERVER string
+    # @return [String]
+    attr_reader :server
+    # URL to the UPnP description of the root device
+    # @return [String]
+    attr_reader :location
+    # @return [String]
+    attr_reader :ext
+    # Date when response was generated
+    # @return [String]
+    attr_reader :date
+    # Contains +max-age+ directive used to specify advertisement validity
+    # @return [String]
+    attr_reader :cache_control
+    # Expiration time for the advertisement
+    # @return [Time]
+    attr_reader :expiration
+
+    # UPnP version used by the device
+    # @return [String]
+    attr_reader :upnp_version
+    # XML namespace for device description
+    # @return [String]
+    attr_reader :xmlns
+    # URL base for device access
+    # @return [String]
+    attr_reader :url_base
+    # Device type
+    # @return [String]
+    attr_reader :type
+    # Short description for end users
+    # @return [String]
+    attr_reader :friendly_name
+    # Manufacturer's name
+    # @return [String]
+    attr_reader :manufacturer
+    # Web site for manufacturer
+    # @return [String]
+    attr_reader :manufacturer_url
+    # Long decription for end user
+    # @return [String]
+    attr_reader :model_description
+    # Model name
+    # @return [String]
+    attr_reader :model_name
+    # Model number
+    # @return [String]
+    attr_reader :model_number
+    # Web site for model
+    # @return [String]
+    attr_reader :model_url
+    # Serial number
+    # @return [String]
+    attr_reader :serial_umber
+    # Unique Device Name
+    # @return [String]
+    attr_reader :udn
+    # Universal Product Code
+    # @return [String]
+    attr_reader :upc
+    # URL to presentation for device
+    # @return [String]
+    attr_reader :presentation_url
+    # Array of icons to depict device in control point UI
+    # @return [Array<OpenStruct>]
+    attr_reader :icons
+    # List of device's services
+    # @return [Array<Service>]
+    attr_reader :services
+    # List of embedded devices
+    # @return [Array<Device>]
+    attr_reader :devices
+
+
+    # @param [ControlPoint] control_point
+    # @param [Hash] notification
+    def initialize(control_point, notification)
+      super()
+      @control_point = control_point
+      @notification = notification
+
+      @icons = []
+      @services = []
+      @devices = []
+    end
+
+    # Get device from its description
+    # @return [void]
+    def fetch
+      description_getter = EM::DefaultDeferrable.new
+
+      description_getter.errback do
+        msg = "Failed getting description"
+        log :error, "Fetching device: #{msg}"
+        fail self, msg
+      end
+
+      extract_from_ssdp_notification description_getter
+
+      description_getter.callback do |description|
+        @description = description
+        unless description
+          fail self, 'Blank description returned'
+          next
+        end
+
+        if bad_description?
+          fail self, "Bad description returned: #@description"
+          next
+        end
+
+        extract_url_base
+        extract_device_info
+        extract_icons
+
+        @services_extracted = @devices_extracted = false
+        extract_services
+        extract_devices
+
+        tick_loop = EM.tick_loop do
+          :stop if @services_extracted and @devices_extracted
+        end
+        tick_loop.on_stop { succeed self }
+      end
+    end
+
+
+    private
+
+
+    def extract_from_ssdp_notification(getter)
+      @st = @notification['st']
+      @usn = @notification['usn']
+      @server = @notification['server']
+      @location = @notification['location']
+      @ext = @notification['ext']
+      @date = @notification['date'] || ''
+      @cache_control = @notification['cache-control'] || ''
+
+      max_age = @cache_control.match(/max-age\s*=\s*(\d+)/)[1].to_i
+      @expiration = if @date.empty?
+                      Time.now + max_age
+                    else
+                      Time.parse(@date) + max_age
+                    end
+
+      if @location
+        get_description @location, getter
+      else
+        fail self, 'M-SEARCH response has no location'
+      end
+    end
+
+    def bad_description?
+      if @description[:root]
+        bd = false
+        @xmlns = @description[:root][:@xmlns]
+        bd |= @xmlns != 'urn:schemas-upnp-org:device-1-0'
+        bd |= @description[:root][:spec_version][:major].to_i != 1
+        @upnp_version = @description[:root][:spec_version][:major] + '.'
+        @upnp_version += @description[:root][:spec_version][:minor]
+        bd |= !@description[:root][:device]
+      else
+        true
+      end
+    end
+
+    def extract_url_base
+      if @description[:root][:url_base] and @upnp_version != '1.1'
+        @url_base =  @description[:root][:url_base]
+        @url_base += '/' unless @url_base.end_with?('/')
+      else
+        @url_base = @location.match(/[^\/]*\z/).pre_match
+      end
+    end
+
+    def extract_device_info
+      device = @description[:root][:device]
+      @type = device[:device_type]
+      @friendly_name = device[:friendly_name]
+      @manufacturer = device[:manufacturer]
+      @manufacturer_url = device[:manufacturer_url] || ''
+      @model_description = device[:model_description] || ''
+      @model_name = device[:model_name]
+      @model_number = device[:model_number] || ''
+      @model_url = device[:model_url] || ''
+      @serial_umber = device[:serial_number] || ''
+      @udn = device[:udn]
+      @upc = device[:upc] || ''
+      @presentation_url = device[:presentation_url] || ''
+    end
+
+    def extract_icons
+      @description[:root][:device][:icon_list][:icon].each do |h|
+        icon = OpenStruct.new(h)
+        icon.url = build_url(@url_base, icon.url)
+        @icons << icon
+      end
+    end
+
+    def extract_services
+      if @description[:root][:device][:service_list] &&
+          @description[:root][:device][:service_list][:service]
+        sl = @description[:root][:device][:service_list][:service]
+
+        proc_each = Proc.new do |s, iter|
+          service = CP::RemoteService.new(self, @url_base, s)
+
+          service.errback do |msg|
+            log :error, "failed to extract service #{s[:service_id]}: #{msg}"
+            iter.next
+          end
+
+          service.callback do |serv|
+            @services << serv
+            create_method_from_service serv
+            iter.next
+          end
+
+          service.fetch
+        end
+
+        proc_after = Proc.new do
+          @services_extracted = true
+        end
+
+        EM::Iterator.new(sl).each(proc_each, proc_after)
+      else
+        @services_extracted = true
+      end
+    end
+
+    def extract_devices
+      if @description[:root][:device_list]
+        if @description[:root][:device_list][:device]
+          dl = @description[:root][:device_list][:device]
+          ## TODO
+        end
+      end
+      @devices_extracted = true ## TEMP
+    end
+
+    def create_method_from_service(service)
+      if service.type =~ /urn:.*:service:(\w+):\d/
+        name = snake_case($1).to_sym
+        define_singleton_method(name) { service }
+      end
+    end
+
+  end
+
+end

data/lib/rupnp/cp/remote_service.rb

@@ -0,0 +1,304 @@
+require 'uri'
+require 'savon'
+require_relative 'base'
+
+module RUPNP
+
+  # 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.
+  #
+  # 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
+    # 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
+      @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
+      if @scpd_url.empty?
+        fail 'no SCPD URL'
+        return
+      end
+
+      scpd_getter = EM::DefaultDeferrable.new
+
+      scpd_getter.errback do
+        fail "cannot get SCPD from #@scpd_url"
+      end
+
+      scpd_getter.callback do |scpd|
+        if !scpd or scpd.empty?
+          fail "SCPD from #@scpd_url is empty"
+          next
+        end
+
+        if bad_description?(scpd)
+          fail 'not a UPNP 1.0/1.1 SCPD'
+          next
+        end
+
+        extract_service_state_table scpd
+        extract_actions scpd
+
+        succeed self
+      end
+
+      get_description @scpd_url, scpd_getter
+    end
+
+    # Subscribe to event
+    # @param [Hash] options
+    # @option options [Integer] timeout
+    # @yieldparam [Event] event event received
+    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
+      subscribe_req = <<EOR
+SUSCRIBE #{uri.path} HTTP/1.1\r
+HOST: #{HOST_IP}:#{port}\r
+USER-AGENT: #{RUPNP::USER_AGENT}\r
+CALLBACK: #@callback_url\r
+NT: upnp:event
+TIMEOUT: Second-#{options[:timeout]}\r
+\r
+EOR
+
+      server = uri.host
+      port = (uri.port || 80).to_i
+      ap @event_sub_url
+      ap server
+      ap port
+      con = EM.connect(server, port, CP::EventSubscriber, subscribe_req)
+
+      con.response.subscribe do |resp|
+        if resp[:status_code] != 200
+          log :warn, "Cannot subscribe to event #@event_sub_url: #{resp[:status]}"
+        else
+          event = Event.new(resp[:sid], resp[:timeout].match(/(\d+)/)[1].to_i)
+          cp.add_event_url << ["/event#{num}", event]
+          event.subscribe(event, blk)
+        end
+        log :info, 'Close connection to subscribe event URL'
+        con.close_connection
+      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
+      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]
+        # ease debug print
+        @state_table.each { |s| s.each { |k, v| s[k] = v.to_s } }
+      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.each do |action|
+          action[:arguments] = action[:argument_list][:argument]
+          action.delete :argument_list
+          define_method_from_action action
+        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
+      define_singleton_method(name) do |params|
+        response = @soap.call(action_name) do |locals|
+          locals.attributes 'xmlns:u' => @type
+          locals.soap_action "#{type}##{action_name}"
+          if params
+            unless params.is_a? Hash
+              raise ArgumentError, 'only hash arguments are accepted'
+            end
+            locals.message params
+          end
+        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]
+          end
+        else
+          log :debug, 'true argument list'
+          action[:arguments].map do |arg|
+            if params arg[:direction] == 'out'
+              process_soap_response name, response, arg
+            end
+          end
+        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 {}
+      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]
+
+      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]}"
+        {}
+      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'
+      end
+    end
+
+  end
+
+end

data/lib/rupnp/discover.rb

@@ -0,0 +1,55 @@
+require 'eventmachine-le'
+require 'pry'
+require 'rupnp'
+
+class RUPNP::Discover
+  attr_reader :devices
+
+  def self.run
+    d = new
+    d.pry
+  end
+
+  def initialize
+    configure_rupnp
+    configure_pry
+    create_command_set
+  end
+
+
+  private
+
+  def configure_rupnp
+    RUPNP.logdev = devnull = File.open('/dev/null', 'w')
+    at_exit { devnull.close }
+  end
+
+  def configure_pry
+    ::Pry.config.should_load_rc = false
+    ::Pry.config.history.should_save = false
+    ::Pry.config.history.should_load = false
+    ::Pry.config.prompt = [proc { 'discover> ' }, proc { 'discover* ' }]
+  end
+
+  def create_command_set
+    discover = self
+
+    command_set = Pry::CommandSet.new do
+      block_command 'search', 'Search for devices' do |target|
+        target ||= :all
+        cp = RUPNP::ControlPoint.new(target)
+        EM.run do
+          cp.search_only
+          EM.add_timer(RUPNP::ControlPoint::DEFAULT_RESPONSE_WAIT_TIME+2) do
+            discover.instance_eval { @devices = cp.devices }
+            output.puts "#{discover.devices.size} devices found"
+            EM.stop
+          end
+        end
+      end
+    end
+
+    Pry::Commands.import command_set
+  end
+
+end

data/lib/rupnp/event.rb

@@ -0,0 +1,32 @@
+module RUPNP
+
+  # Event class to handle events from devices
+  # @todo Renewal and cancellation of subscription are not coded
+  # @author Sylvain Daubert
+  class Event < EM::Channel
+
+    # Get service ID
+    # @return [Integer]
+    attr_reader :sid
+
+    # @param [#to_i] sid
+    # @param [Integer] timeout for event (in seconds)
+    def initialize(sid, timeout)
+      @sid, @timeout = sid, timeout
+
+      @timeout_timer = EM.add_timer(@timeout) { self << :timeout }
+    end
+
+    # Renew subscription to event
+    def renew_subscription
+      raise NotImplementedError
+    end
+
+    # Cancel subscription to event
+    def cancel_subscription
+      raise NotImplementedError
+    end
+
+  end
+
+end

data/lib/rupnp/log_mixin.rb

@@ -0,0 +1,30 @@
+module RUPNP
+
+  # Mixin to add log facility to others classes.
+  # @author Sylvain Daubert
+  module LogMixin
+
+
+    # Log severity levels
+    LOG_LEVEL = {
+      :failure => 5,
+      :error   => 4,
+      :warn    => 3,
+      :info    => 2,
+      :debug   => 1
+    }
+    LOG_LEVEL.default = 0
+
+    # log a message
+    # @param [Symbol] level severity level.  May be +:debug+,
+    #    +:info+, +warn+, or +:error+
+    # @param [String] msg message to log
+    def log(level, msg='')
+      if LOG_LEVEL[level] >= LOG_LEVEL[RUPNP.log_level]
+        RUPNP.logdev.puts "[#{level}] #{msg}"
+      end
+    end
+
+  end
+
+end