playful 0.1.0.alpha.1

data/features/support/env.rb

@@ -0,0 +1,17 @@
+require 'socket'
+require 'log_buddy'
+require_relative '../../lib/playful/control_point'
+
+def local_ip_and_port
+  orig, Socket.do_not_reverse_lookup = Socket.do_not_reverse_lookup, true
+
+  UDPSocket.open do |s|
+    s.connect '64.233.187.99', 1
+    s.addr.last
+    [s.addr.last, s.addr[1]]
+  end
+ensure
+  Socket.do_not_reverse_lookup = orig
+end
+
+ENV['RUBY_UPNP_ENV'] = 'testing'

data/features/support/fake_upnp_device_collection.rb

@@ -0,0 +1,108 @@
+require 'singleton'
+require 'socket'
+require 'ipaddr'
+
+require_relative '../../lib/playful/ssdp/network_constants'
+
+class FakeUPnPDeviceCollection
+  include Singleton
+  include UPnP::SSDP::NetworkConstants
+
+  attr_accessor :respond_with
+
+  def initialize
+    @response = ''
+    @ssdp_listen_thread = nil
+    @serve_description = false
+    @local_ip, @local_port = local_ip_and_port
+  end
+
+  def expect_discovery(type)
+    case type
+    when :m_search
+
+    end
+
+  end
+
+  def stop_ssdp_listening
+    puts "<#{self.class}> Stopping..."
+    @ssdp_listen_thread.kill if @ssdp_listen_thread && @ssdp_listen_thread.alive?
+    puts "<#{self.class}> Stopped."
+  end
+
+  # @return [Thread] The thread that's doing the listening.
+  def start_ssdp_listening
+    multicast_socket = setup_multicast_socket
+    multicast_socket.bind(MULTICAST_IP, MULTICAST_PORT)
+
+    ttl = [4].pack 'i'
+    unicast_socket = UDPSocket.open
+    unicast_socket.setsockopt(Socket::IPPROTO_IP, Socket::IP_MULTICAST_TTL, ttl)
+
+    @ssdp_listen_thread = Thread.new do
+      loop do
+        text, sender = multicast_socket.recvfrom(1024)
+        #puts "<#{self.class}> received text:\n#{text} from #{sender}"
+
+        #if text =~ /ST: upnp:rootdevice/
+        #if text =~ /#{@response}/m
+        if text =~ /M-SEARCH.*#{@local_ip}/m
+          puts "<#{self.class}> received text:\n#{text} from #{sender}"
+          return_port, return_ip = sender[1], sender[2]
+
+          puts "<#{self.class}> sending response\n#{@response}\n back to: #{return_ip}:#{return_port}"
+          unicast_socket.send(@response, 0, return_ip, return_port)
+          #multicast_socket.close
+        end
+      end
+    end
+  end
+
+  def start_serving_description
+=begin
+    tcp_server = TCPServer.new('0.0.0.0', 4567)
+    @serve_description = true
+
+    while @serve_description
+      @description_serve_thread = Thread.start(tcp_server.accept) do |s|
+        print(s, " is accepted\n")
+        s.write(Time.now)
+        print(s, " is gone\n")
+        s.close
+      end
+    end
+=end
+    require 'webrick'
+    @description_server = WEBrick::HTTPServer.new(Port: 4567)
+    trap('INT') { @description_server.shutdown }
+    @description_server.mount_proc '/' do |req, res|
+      res.body = "<start>\n</start>"
+    end
+    @description_server.start
+  end
+
+  def stop_serving_description
+=begin
+    @serve_description = false
+
+    if @description_serve_thread && @description_serve_thread.alive?
+      @description_serve_thread.join
+    end
+=end
+    @description_server.stop
+  end
+
+  def setup_multicast_socket
+    membership = IPAddr.new(MULTICAST_IP).hton + IPAddr.new('0.0.0.0').hton
+    ttl = [4].pack 'i'
+
+    socket = UDPSocket.new
+    socket.setsockopt(Socket::IPPROTO_IP, Socket::IP_ADD_MEMBERSHIP, membership)
+    socket.setsockopt(Socket::IPPROTO_IP, Socket::IP_MULTICAST_LOOP, "\000")
+    socket.setsockopt(Socket::IPPROTO_IP, Socket::IP_MULTICAST_TTL, ttl)
+    socket.setsockopt(Socket::IPPROTO_IP, Socket::IP_TTL, ttl)
+
+    socket
+  end
+end

data/features/support/world_extensions.rb

@@ -0,0 +1,15 @@
+module HelperStuff
+  def control_point
+    @control_point ||= UPnP::ControlPoint.new
+  end
+
+  def fake_device_collection
+    @fake_device_collection ||= FakeUPnPDeviceCollection.instance
+  end
+
+  def local_ip
+    @local_ip ||= local_ip_and_port.first
+  end
+end
+
+World(HelperStuff)

data/lib/core_ext/hash_patch.rb

@@ -0,0 +1,5 @@
+class Hash
+  def symbolize_keys!
+    self.inject({}) { |result, (k, v)| result[k.to_sym] = v; result }
+  end
+end

data/lib/core_ext/socket_patch.rb

@@ -0,0 +1,16 @@
+require 'socket'
+
+# Workaround for missing constants on Windows
+module Socket::Constants
+  IP_ADD_MEMBERSHIP = 12 unless defined? IP_ADD_MEMBERSHIP
+  IP_MULTICAST_LOOP = 11 unless defined? IP_MULTICAST_LOOP
+  IP_MULTICAST_TTL  = 10 unless defined? IP_MULTICAST_TTL
+  IP_TTL            =  4 unless defined? IP_TTL
+end
+
+class Socket
+  IP_ADD_MEMBERSHIP = 12 unless defined? IP_ADD_MEMBERSHIP
+  IP_MULTICAST_LOOP = 11 unless defined? IP_MULTICAST_LOOP
+  IP_MULTICAST_TTL  = 10 unless defined? IP_MULTICAST_TTL
+  IP_TTL            =  4 unless defined? IP_TTL
+end

data/lib/core_ext/to_upnp_s.rb

@@ -0,0 +1,65 @@
+class Hash
+
+  # Converts Hash search targets to SSDP search target String.  Conversions are
+  # as follows:
+  #   uuid: "someUUID"                 # => "uuid:someUUID"
+  #   device_type: "someDeviceType:1"    # => "urn:schemas-upnp-org:device:someDeviceType:1"
+  #   service_type: "someServiceType:2"  # => "urn:schemas-upnp-org:service:someServiceType:2"
+  #
+  # You can use custom UPnP domain names too:
+  #   { device_type: "someDeviceType:3",
+  #   domain_name: "mydomain-com" }    # => "urn:my-domain:device:someDeviceType:3"
+  #   { service_type: "someServiceType:4",
+  #   domain_name: "mydomain-com" }    # => "urn:my-domain:service:someDeviceType:4"
+  #
+  # @return [String] The converted String, according to the UPnP spec.
+  def to_upnp_s
+    if self.has_key? :uuid
+      return "uuid:#{self[:uuid]}"
+    elsif self.has_key? :device_type
+      if self.has_key? :domain_name
+        return "urn:#{self[:domain_name]}:device:#{self[:device_type]}"
+      else
+        return "urn:schemas-upnp-org:device:#{self[:device_type]}"
+      end
+    elsif self.has_key? :service_type
+      if self.has_key? :domain_name
+        return "urn:#{self[:domain_name]}:service:#{self[:service_type]}"
+      else
+        return "urn:schemas-upnp-org:service:#{self[:service_type]}"
+      end
+    else
+      self.to_s
+    end
+  end
+end
+
+
+class Symbol
+
+  # Converts Symbol search targets to SSDP search target String.  Conversions are
+  # as follows:
+  #   :all    # => "ssdp:all"
+  #   :root   # => "upnp:rootdevice"
+  #   "root"  # => "upnp:rootdevice"
+  #
+  # @return [String] The converted String, according to the UPnP spec.
+  def to_upnp_s
+    if self == :all
+      'ssdp:all'
+    elsif self == :root
+      'upnp:rootdevice'
+    else
+      self
+    end
+  end
+end
+
+
+class String
+  # This doesn't do anything to the string; just allows users to call the
+  # method without having to check type first.
+  def to_upnp_s
+    self
+  end
+end

data/lib/playful.rb

@@ -0,0 +1,5 @@
+require_relative 'playful/version'
+
+module Playful
+
+end

data/lib/playful/control_point.rb

@@ -0,0 +1,175 @@
+require 'open-uri'
+require 'nori'
+require 'em-synchrony'
+require_relative 'logger'
+require_relative 'ssdp'
+require_relative 'control_point/service'
+require_relative 'control_point/device'
+require_relative 'control_point/error'
+
+
+module Playful
+
+  # 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
+    include LogSwitch::Mixin
+
+    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?
+        log 'Joining reactor...'
+        starter.call
+      else
+        log 'Starting reactor...'
+        EM.synchrony(&starter)
+      end
+    end
+
+    def listen(ttl)
+      EM.defer do
+        listener = SSDP.listen(ttl)
+
+        listener.alive_notifications.subscribe do |advertisement|
+          log "Got alive #{advertisement}"
+
+          if @devices.any? { |d| d.usn == advertisement[:usn] }
+            log "Device with USN #{advertisement[:usn]} already exists."
+          else
+            log "Device with USN #{advertisement[:usn]} not found. Creating..."
+            create_device(advertisement)
+          end
+        end
+
+        listener.byebye_notifications.subscribe do |advertisement|
+          log "Got bye-bye from #{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
+        log "Time since last timer: #{Time.now - @timer_time}" if @timer_time
+        log "Connections: #{EM.connection_count}"
+        @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|
+        log 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|
+        log "Device created from #{notification}"
+        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 })
+        log 'Newly created device already exists in internal list. Not adding.'
+      #if @devices.any? { |d| d.usn == built_device.usn }
+      #  log "Newly created device (#{built_device.usn}) already exists in internal list. Not adding."
+      else
+        log 'Adding newly created device to internal list..'
+        @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

data/lib/playful/control_point/base.rb

@@ -0,0 +1,74 @@
+require 'nori'
+require 'em-http-request'
+require_relative 'error'
+require_relative '../logger'
+require_relative '../../playful'
+
+
+module Playful
+  class ControlPoint
+    class Base
+      include LogSwitch::Mixin
+
+      protected
+
+      def get_description(location, description_getter)
+        log "Getting description with getter ID #{description_getter.object_id} for: #{location}"
+        http = EM::HttpRequest.new(location).aget
+
+        t = EM::Timer.new(30) do
+          http.fail(:timeout)
+        end
+
+        http.errback do |error|
+          if error == :timeout
+            log 'Timed out getting description.  Retrying...'
+            http = EM::HttpRequest.new(location).get
+          else
+            log "Unable to retrieve DDF from #{location}", :error
+            log "Request error: #{http.error}"
+            log "Response status: #{http.response_header.status}"
+
+            description_getter.set_deferred_status(:failed)
+
+            if ControlPoint.raise_on_remote_error
+              raise ControlPoint::Error, "Unable to retrieve DDF from #{location}"
+            end
+          end
+        end
+
+        http.callback {
+          log "HTTP callback called for #{description_getter.object_id}"
+          response = xml_parser.parse(http.response)
+          description_getter.set_deferred_status(:succeeded, response)
+        }
+      end
+
+      def build_url(url_base, rest_of_url)
+        if url_base.end_with?('/') && rest_of_url.start_with?('/')
+          rest_of_url.sub!('/', '')
+        end
+
+        url_base + rest_of_url
+      end
+
+      # @return [Nori::Parser]
+      def xml_parser
+        @xml_parser if @xml_parser
+
+        options = {
+          convert_tags_to: lambda { |tag| tag.to_sym }
+        }
+
+        begin
+          require 'nokogiri'
+          options.merge! parser: :nokogiri
+        rescue LoadError
+          warn "Tried loading nokogiri for XML couldn't.  This is OK, just letting you know."
+        end
+
+        @xml_parser = Nori.new(options)
+      end
+    end
+  end
+end