druzy-upnp 1.0.0

data/lib/druzy/upnp/control_point/service.rb

@@ -0,0 +1,387 @@
+require 'savon'
+require_relative 'base'
+require_relative 'error'
+require 'core_ext/hash_patch'
+
+require 'em-http'
+HTTPI.adapter = :em_http
+
+module Druzy
+  module Upnp
+    class ControlPoint
+  
+      # An object of this type functions as somewhat of a proxy to a UPnP device's
+      # service.  The object sort of defines itself when you call #fetch; it
+      # gets the description file from the device, parses it, populates its
+      # attributes (as accessors) and defines singleton methods from the list of
+      # actions that the service defines.
+      #
+      # After the fetch is done, you can call Ruby methods on the service and
+      # expect a Ruby Hash back as a return value.  The methods will look just
+      # the SOAP actions and will always return a Hash, where key/value pairs are
+      # converted from the SOAP response; values are converted to the according
+      # Ruby type based on <dataType> in the <serviceStateTable>.
+      #
+      # Types map like:
+      #   * Integer
+      #     * ui1
+      #     * ui2
+      #     * ui4
+      #     * i1
+      #     * i2
+      #     * i4
+      #     * int
+      #   * Float
+      #     * r4
+      #     * r8
+      #     * number
+      #     * fixed.14.4
+      #     * float
+      #   * String
+      #     * char
+      #     * string
+      #     * uuid
+      #   * TrueClass
+      #     * 1
+      #     * true
+      #     * yes
+      #   * FalseClass
+      #     * 0
+      #     * false
+      #     * no
+      #
+      # @example No "in" params
+      #   my_service.GetSystemUpdateID    # => { "Id" => 1 }
+      #
+      class Service < Base
+        include EventMachine::Deferrable
+  
+        #vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
+        # Passed in by +service_list_info+
+        #
+  
+        # @return [String] UPnP service type, including URN.
+        attr_reader :service_type
+  
+        # @return [String] Service identifier, unique within this service's devices.
+        attr_reader :service_id
+  
+        # @return [URI::HTTP] Service description URL.
+        attr_reader :scpd_url
+  
+        # @return [URI::HTTP] Control URL.
+        attr_reader :control_url
+  
+        # @return [URI::HTTP] Eventing URL.
+        attr_reader :event_sub_url
+  
+        #
+        # DONE +service_list_info+
+        #^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  
+        #vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
+        # Determined by service description file
+        #
+  
+        # @return [String]
+        attr_reader :xmlns
+  
+        # @return [String]
+        attr_reader :spec_version
+  
+        # @return [Array<Hash>]
+        attr_reader :action_list
+  
+        # Probably don't need to keep this long-term; just adding for testing.
+        attr_reader :service_state_table
+  
+        #
+        # DONE description
+        #^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  
+        # @return [Hash] The whole description... just in case.
+        attr_reader :description
+  
+        # @param [String] device_base_url URL given (or otherwise determined) by
+        #   <URLBase> from the device that owns the service.
+        # @param [Hash] service_list_info Info given in the <serviceList> section
+        #   of the device description.
+        def initialize(device_base_url, service_list_info)
+          @service_list_info = service_list_info
+          @action_list = []
+          @xmlns = ''
+          extract_service_list_info(device_base_url)
+          configure_savon
+        end
+  
+        # Fetches the service description file, parses it, extracts attributes
+        # into accessors, and defines Ruby methods from SOAP actions.  Since this
+        # is a long-ish process, this is done using EventMachine Deferrable
+        # behavior.
+        def fetch
+          if @scpd_url.empty?
+            set_deferred_success self
+            return
+          end
+  
+          description_getter = EventMachine::DefaultDeferrable.new
+          get_description(@scpd_url, description_getter)
+  
+          description_getter.errback do
+            msg = 'Failed getting service description.'
+            # @todo Should this return self? or should it succeed?
+            set_deferred_status(:failed, msg)
+  
+            if ControlPoint.raise_on_remote_error
+              raise ControlPoint::Error, msg
+            end
+          end
+  
+          description_getter.callback do |description|
+            @description = description
+            @xmlns = @description[:scpd][:@xmlns]
+            extract_spec_version
+            extract_service_state_table
+  
+            if @description[:scpd][:actionList]
+              define_methods_from_actions(@description[:scpd][:actionList][:action])
+            end
+  
+            set_deferred_status(:succeeded, self)
+          end
+        end
+  
+        private
+  
+        # Extracts all of the basic service information from the information
+        # handed over from the device description about the service.  The actual
+        # service description info gathering is *not* done here.
+        #
+        # @param [String] device_base_url The URLBase from the device.  Used to
+        #   build absolute URLs for the service.
+        def extract_service_list_info(device_base_url)
+          @control_url = if @service_list_info[:controlURL]
+            build_url(device_base_url, @service_list_info[:controlURL])
+          else
+            ''
+          end
+  
+          @event_sub_url = if @service_list_info[:eventSubURL]
+            build_url(device_base_url, @service_list_info[:eventSubURL])
+          else
+            ''
+          end
+  
+          @service_type = @service_list_info[:serviceType]
+          @service_id = @service_list_info[:serviceId]
+  
+          @scpd_url = if @service_list_info[:SCPDURL]
+            build_url(device_base_url, @service_list_info[:SCPDURL])
+          else
+            ''
+          end
+        end
+  
+        def extract_spec_version
+          "#{@description[:scpd][:specVersion][:major]}.#{@description[:scpd][:specVersion][:minor]}"
+        end
+  
+        def extract_service_state_table
+          @service_state_table = if @description[:scpd][:serviceStateTable].is_a? Hash
+            @description[:scpd][:serviceStateTable][:stateVariable]
+          elsif @description[:scpd][:serviceStateTable].is_a? Array
+            @description[:scpd][:serviceStateTable].map do |state|
+              state[:stateVariable]
+            end
+          end
+        end
+  
+        # Determines if <actionList> from the service description contains a
+        # single action or multiple actions and delegates to create Ruby methods
+        # accordingly.
+        #
+        # @param [Hash,Array] action_list The value from <scpd><actionList><action>
+        #   from the service description.
+        def define_methods_from_actions(action_list)
+  
+          if action_list.is_a? Hash
+            @action_list << action_list
+            define_method_from_action(action_list[:name].to_sym,
+              action_list[:argumentList][:argument])
+          elsif action_list.is_a? Array
+            action_list.each do |action|
+=begin
+          in_args_count = action[:argumentList][:argument].find_all do |arg|
+            arg[:direction] == 'in'
+          end.size
+=end
+              @action_list << action
+              args = action[:argumentList] ? action[:argumentList][:argument] : {}
+              define_method_from_action(action[:name].to_sym, args)
+            end
+          end
+        end
+  
+        # Defines a Ruby method from the SOAP action.
+        #
+        # All resulting methods will either take no arguments or a single Hash as
+        # an argument, whatever the SOAP action describes as its "in" arguments.
+        # If the action describes "in" arguments, then you must provide a Hash
+        # where keys are argument names and values are the values for those
+        # arguments.
+        #
+        # For example, the GetCurrentConnectionInfo action from the
+        # "ConnectionManager:1" service describes an "in" argument named
+        # "ConnectionID" whose dataType is "i4".  To call this action via the
+        # Ruby method, it'd look like:
+        #
+        #   connection_manager.GetCurrentConnectionInfo({ "ConnectionID" => 42 })
+        #
+        # There is currently no type checking for these "in" arguments.
+        #
+        # Calling that Ruby method will, in turn, call the SOAP action by the same
+        # name, with the body set to:
+        #
+        #   <connectionID>42</connectionID>
+        #
+        # The UPnP device providing the service will reply with a SOAP
+        # response--either a fault or with good data--and that will get converted
+        # to a Hash. This Hash will contain key/value pairs defined by the "out"
+        # argument names and values.  Each value is converted to an associated
+        # Ruby type, determined from the serviceStateTable.  If no return data
+        # is relevant for the request you made, some devices may return an empty
+        # body.
+        #
+        # @param [Symbol] action_name The extracted value from <actionList>
+        #   <action><name> from the spec.
+        # @param [Hash,Array] argument_info The extracted values from
+        #   <actionList><action><argumentList><argument> from the spec.
+        def define_method_from_action(action_name, argument_info)
+          # Do this here because, for some reason, @service_type is out of scope
+          # in the #request block below.
+          st = @service_type
+  
+          define_singleton_method(action_name) do |params|
+            begin
+              response = @soap_client.call(action_name.to_s) do |locals|
+                locals.message_tags 'xmlns:u' => @service_type
+                locals.soap_action "#{st}##{action_name}"
+                #soap.namespaces["s:encodingStyle"] = "http://schemas.xmlsoap.org/soap/encoding/"
+  
+                unless params.nil?
+                  raise ArgumentError,
+                    'Method only accepts Hashes' unless params.is_a? Hash
+                  soap.body = params.symbolize_keys!
+                end
+              end
+            rescue Savon::SOAPFault, Savon::HTTPError => ex
+              hash = xml_parser.parse(ex.http.body)
+              msg = <<-MSG
+SOAP request failure!
+HTTP response code: #{ex.http.code}
+HTTP headers: #{ex.http.headers}
+HTTP body: #{ex.http.body}
+HTTP body as Hash: #{hash}
+            MSG
+  
+              raise(ActionError, msg) if ControlPoint.raise_on_remote_error
+  
+              if hash.empty?
+                return ex.http.body
+              else
+                return hash[:Envelope][:Body]
+              end
+            end
+  
+            return_value = if argument_info.is_a?(Hash) && argument_info[:direction] == 'out'
+              return_ruby_from_soap(action_name, response, argument_info)
+            elsif argument_info.is_a? Array
+              argument_info.map do |arg|
+                if arg[:direction] == 'out'
+                  return_ruby_from_soap(action_name, response, arg)
+                end
+              end
+            else
+              {}
+            end
+  
+            return_value
+          end
+  
+        end
+  
+        # Uses the serviceStateTable to look up the output from the SOAP response
+        # for the given action, then converts it to the according Ruby data type.
+        #
+        # @param [String] action_name The name of the SOAP action that was called
+        #   for which this will get the response from.
+        # @param [Savon::SOAP::Response] soap_response The response from making
+        #   the SOAP call.
+        # @param [Hash] out_argument The Hash that tells out the "out" argument
+        #   which tells what data type to return.
+        # @return [Hash] Key will be the "out" argument name as a Symbol and the
+        #   key will be the value as its converted Ruby type.
+        def return_ruby_from_soap(action_name, soap_response, out_argument)
+          out_arg_name = out_argument[:name]
+          #puts "out arg name: #{out_arg_name}"
+  
+          related_state_variable = out_argument[:relatedStateVariable]
+          #puts "related state var: #{related_state_variable}"
+  
+          state_variable = @service_state_table.find do |state_var_hash|
+            state_var_hash[:name] == related_state_variable
+          end
+  
+          #puts "state var: #{state_variable}"
+  
+          int_types = %w[ui1 ui2 ui4 i1 i2 i4 int]
+          float_types = %w[r4 r8 number fixed.14.4 float]
+          string_types = %w[char string uuid]
+          true_types = %w[1 true yes]
+          false_types = %w[0 false no]
+  
+          if soap_response.success? && soap_response.to_xml.empty?
+            return {}
+          end
+  
+          if int_types.include? state_variable[:dataType]
+            {
+              out_arg_name.to_sym => soap_response.
+                hash[:Envelope][:Body]["#{action_name}Response".to_sym][out_arg_name.to_sym].to_i
+            }
+          elsif string_types.include? state_variable[:dataType]
+            {
+              out_arg_name.to_sym => soap_response.
+                hash[:Envelope][:Body]["#{action_name}Response".to_sym][out_arg_name.to_sym].to_s
+            }
+          elsif float_types.include? state_variable[:dataType]
+            {
+              out_arg_name.to_sym => soap_response.
+                hash[:Envelope][:Body]["#{action_name}Response".to_sym][out_arg_name.to_sym].to_f
+            }
+          elsif true_types.include? state_variable[:dataType]
+            {
+              out_arg_name.to_sym => true
+            }
+          elsif false_types.include? state_variable[:dataType]
+            {
+              out_arg_name.to_sym => false
+            }
+          end
+        end
+  
+        def configure_savon
+          @soap_client = Savon.client do |globals|
+            globals.endpoint @control_url
+            globals.namespace @service_type
+  
+            globals.convert_request_keys_to :camelcase
+            globals.namespace_identifier :u
+            globals.env_namespace :s
+            globals.log true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/druzy/upnp/control_point.rb

@@ -0,0 +1,161 @@
+require 'open-uri'
+require 'nori'
+require 'em-synchrony'
+require_relative 'ssdp'
+require_relative 'control_point/service'
+require_relative 'control_point/device'
+require_relative 'control_point/error'
+
+module Druzy
+  module Upnp
+  
+    # Allows for controlling a UPnP device as defined in the UPnP spec for control
+    # points.
+    #
+    # It uses +Nori+ for parsing the description XML files, which will use +Nokogiri+
+    # if you have it installed.
+    class ControlPoint
+  
+      def self.config
+        yield self
+      end
+  
+      class << self
+        attr_accessor :raise_on_remote_error
+      end
+  
+      @@raise_on_remote_error ||= true
+  
+      attr_reader :devices
+  
+      # @param [String] search_target The device(s) to control.
+      # @param [Hash] search_options Options to pass on to SSDP search and listen calls.
+      # @option options [Fixnum] response_wait_time
+      # @option options [Fixnum] m_search_count
+      # @option options [Fixnum] ttl
+      def initialize(search_target, search_options = {})
+        @search_target = search_target
+        @search_options = search_options
+        @search_options[:ttl] ||= 4
+        @devices = []
+        @new_device_channel = EventMachine::Channel.new
+        @old_device_channel = EventMachine::Channel.new
+      end
+  
+      # Starts the ControlPoint.  If an EventMachine reactor is running already,
+      # it'll join that reactor, otherwise it'll start the reactor.
+      #
+      # @yieldparam [EventMachine::Channel] new_device_channel The means through
+      #   which clients can get notified when a new device has been discovered
+      #   either through SSDP searching or from an +ssdp:alive+ notification.
+      # @yieldparam [EventMachine::Channel] old_device_channel The means through
+      #   which clients can get notified when a device has gone offline (have sent
+      #   out a +ssdp:byebye+ notification).
+      def start(&blk)
+        @stopping = false
+  
+        starter = -> do
+          ssdp_search_and_listen(@search_target, @search_options)
+          blk.call(@new_device_channel, @old_device_channel)
+          @running = true
+        end
+  
+        if EM.reactor_running?
+          starter.call
+        else
+          EM.synchrony(&starter)
+        end
+      end
+  
+      def listen(ttl)
+        EM.defer do
+          listener = SSDP.listen(ttl)
+  
+          listener.alive_notifications.subscribe do |advertisement|
+  
+            if @devices.any? { |d| d.usn == advertisement[:usn] }
+            else
+              create_device(advertisement)
+            end
+          end
+  
+          listener.byebye_notifications.subscribe do |advertisement|
+  
+            @devices.reject! do |device|
+              device.usn == advertisement[:usn]
+            end
+  
+            @old_device_channel << advertisement
+          end
+        end
+      end
+  
+      def ssdp_search_and_listen(search_for, options = {})
+        searcher = SSDP.search(search_for, options)
+  
+        searcher.discovery_responses.subscribe do |notification|
+          create_device(notification)
+        end
+  
+        # Do I need to do this?
+        EM.add_timer(options[:response_wait_time]) do
+          searcher.close_connection
+          listen(options[:ttl])
+        end
+  
+        EM.add_periodic_timer(5) do
+          @timer_time = Time.now
+          puts "<#{self.class}> Device count: #{@devices.size}"
+          puts "<#{self.class}> Device unique: #{@devices.uniq.size}"
+        end
+  
+        trap_signals
+      end
+  
+      def create_device(notification)
+        deferred_device = Device.new(ssdp_notification: notification)
+  
+        deferred_device.errback do |partially_built_device, message|
+          #add_device(partially_built_device)
+  
+          if self.class.raise_on_remote_error
+            raise ControlPoint::Error, message
+          end
+        end
+  
+        deferred_device.callback do |built_device|
+          add_device(built_device)
+        end
+  
+        deferred_device.fetch
+      end
+  
+      def add_device(built_device)
+        if (@devices.any? { |d| d.usn == built_device.usn }) ||
+          (@devices.any? { |d| d.udn == built_device.udn })
+        #if @devices.any? { |d| d.usn == built_device.usn }
+        else
+          @new_device_channel << built_device
+          @devices << built_device
+        end
+      end
+  
+      def stop
+        @running = false
+        @stopping = false
+  
+        EM.stop if EM.reactor_running?
+      end
+  
+      def running?
+        @running
+      end
+  
+      def trap_signals
+        trap('INT') { stop }
+        trap('TERM') { stop }
+        trap('HUP') { stop } if RUBY_PLATFORM !~ /mswin|mingw/
+      end
+    end
+  end
+end

data/lib/druzy/upnp/device.rb

@@ -0,0 +1,31 @@
+require 'thin'
+require 'em-synchrony'
+require 'rack'
+require 'rack/lobster'
+
+module Druzy
+  module Upnp
+    
+    class Device
+  
+      # Multicasts discovery messages to advertise its root device, any embedded
+      # devices, and any services.
+      def start
+        EM.synchrony do
+          web_server = Thin::Server.start('0.0.0.0', 3000) do
+            use Rack::CommonLogger
+            use Rack::ShowExceptions
+  
+            map '/presentation' do
+              use Rack::Lint
+              run Rack::Lobster.new
+            end
+          end
+  
+          # Do advertisement
+          # Listen for subscribers
+        end
+      end
+    end
+  end
+end

data/lib/druzy/upnp/ssdp/broadcast_searcher.rb

@@ -0,0 +1,110 @@
+require 'core_ext/socket_patch'
+require_relative 'network_constants'
+require 'ipaddr'
+require 'socket'
+require 'eventmachine'
+
+
+# TODO: DRY this up!!  (it's mostly the same as Playful::SSDP::MulticastConnection)
+module Druzy
+  module Upnp
+    class SSDP
+      class BroadcastSearcher < EventMachine::Connection
+        include EventMachine::Deferrable
+        include Druzy::Upnp::SSDP::NetworkConstants
+  
+        # @return [Array] The list of responses from the current discovery request.
+        attr_reader :discovery_responses
+  
+        attr_reader :available_responses
+        attr_reader :byebye_responses
+  
+        def initialize(search_target, response_wait_time, ttl=TTL)
+          @ttl = ttl
+          @discovery_responses = []
+          @alive_notifications = []
+          @byebye_notifications = []
+  
+          setup_broadcast_socket
+  
+          @search = m_search(search_target, response_wait_time)
+        end
+  
+        def post_init
+          if send_datagram(@search, BROADCAST_IP, MULTICAST_PORT) > 0
+          end
+        end
+  
+        def m_search(search_target, response_wait_time)
+          <<-MSEARCH
+M-SEARCH * HTTP/1.1\r
+HOST: #{MULTICAST_IP}:#{MULTICAST_PORT}\r
+MAN: "ssdp:discover"\r
+MX: #{response_wait_time}\r
+ST: #{search_target}\r
+\r
+          MSEARCH
+        end
+  
+        # Gets the IP and port from the peer that just sent data.
+        #
+        # @return [Array<String,Fixnum>] The IP and port.
+        def peer_info
+          peer_bytes = get_peername[2, 6].unpack('nC4')
+          port = peer_bytes.first.to_i
+          ip = peer_bytes[1, 4].join('.')
+  
+          [ip, port]
+        end
+  
+        def receive_data(response)
+          ip, port = peer_info
+          parsed_response = parse(response)
+  
+          if parsed_response.has_key? :nts
+            if parsed_response[:nts] == 'ssdp:alive'
+              @alive_notifications << parsed_response
+            elsif parsed_response[:nts] == 'ssdp:bye-bye'
+              @byebye_notifications << parsed_response
+            else
+              raise "Unknown NTS value: #{parsed_response[:nts]}"
+            end
+          else
+            @discovery_responses << parsed_response
+          end
+        end
+  
+        # Converts the headers to a set of key-value pairs.
+        #
+        # @param [String] data The data to convert.
+        # @return [Hash] The converted data.  Returns an empty Hash if it didn't
+        #   know how to parse.
+        def parse(data)
+          new_data = {}
+  
+          unless data =~ /\n/
+            return new_data
+          end
+  
+          data.each_line do |line|
+            line =~ /(\S*):(.*)/
+  
+            unless $1.nil?
+              key = $1
+              value = $2
+              key = key.gsub('-', '_').downcase.to_sym
+              new_data[key] = value.strip
+            end
+          end
+  
+          new_data
+        end
+  
+        # Sets Socket options to allow for brodcasting.
+        def setup_broadcast_socket
+          set_sock_opt(Socket::SOL_SOCKET, Socket::SO_BROADCAST, true)
+        end
+      end
+    end
+  end
+end

data/lib/druzy/upnp/ssdp/error.rb

@@ -0,0 +1,8 @@
+module Druzy
+  module Upnp
+    class SSDP
+      class Error < StandardError
+      end
+    end
+  end
+end