david 0.3.0.pre → 0.3.0

data/lib/david/resource_discovery.rb

@@ -0,0 +1,92 @@
+module David
+  class ResourceDiscovery
+    include Celluloid
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      dup._call(env)
+    end
+
+    def _call(env)
+      return @app.call(env) if env['PATH_INFO']      != '/.well-known/core'
+      return [405, {}, []]  if env['REQUEST_METHOD'] != 'GET'
+
+      @env = env
+
+      filtered = routes_hash.select { |link| filter(link) }
+      body     = filtered.keys.map(&:to_s).join(',')
+
+      # TODO On multicast, do not respond if result set empty.
+
+      [
+        200,
+        {
+          'Content-Type'   => 'application/link-format',
+          'Content-Length' => body.bytesize.to_s
+        },
+        [body]
+      ]
+    end
+
+    def register(controller, options)
+      name    = controller.controller_name
+      default = options.delete(:default)
+
+      routes_hash.each do |link, route|
+        next unless route[:controller] == name
+
+        link.merge!(default) unless default.nil?
+
+        attrs = options[route[:action].to_sym]
+        link.merge!(attrs) unless attrs.nil?
+      end
+    end
+
+    private
+
+    def clean_routes
+      @clean_routes ||= routes
+        .uniq   { |r| r[0] }
+        .select { |r| r if include_route?(r) }
+        .each   { |r| delete_format!(r) }
+    end
+
+    def delete_format!(route)
+      route[0].gsub!(/\(\.:format\)\z/, '')
+    end
+
+    def filter(link)
+      href = @env['QUERY_STRING'].split('href=').last
+
+      return true if href.blank?
+
+      # TODO If query end in '*', match on prefix.
+      #      Otherwise match on whole string.
+      #      https://tools.ietf.org/html/rfc6690#section-4.1
+      link.uri =~ Regexp.new(href)
+    end
+
+    def include_route?(route)
+      !(route[0] =~ /\A\/(assets|rails)/)
+    end
+
+    def routes
+      Rails.application.routes.routes.map do |route|
+        [
+          route.path.spec.to_s,
+          route.defaults[:controller],
+          route.defaults[:action]
+        ]
+      end
+    end
+
+    def routes_hash
+      @routes_hash ||= Hash[clean_routes.collect { |r|
+        [CoRE::Link.new(r[0]), { controller: r[1], action: r[2] }]
+      }]
+    end
+  end
+end

data/lib/david/resource_discovery_proxy.rb

@@ -0,0 +1,13 @@
+require 'david/resource_discovery'
+
+module David
+  class ResourceDiscoveryProxy
+    def initialize(app)
+      ResourceDiscovery.supervise_as(:discovery, app)
+    end
+
+    def call(env)
+      Celluloid::Actor[:discovery].call(env)
+    end
+  end
+end

data/lib/david/server.rb

@@ -1,35 +1,46 @@
+require 'david/server/deduplication'
+require 'david/server/multicast'
 require 'david/server/options'
-require 'david/server/response'
+require 'david/server/respond'
 
 module David
   class Server
     include Celluloid::IO
-    include CoAP::Codification
+    include CoAP::Coding
 
+    include Deduplication
+    include Multicast
     include Options
-    include Response
+    include Respond
 
-    attr_reader :logger
+    attr_reader :logger, :socket
 
     finalizer :shutdown
 
     def initialize(app, options)
-      @cbor   = choose(:cbor,   options[:CBOR])
-      @host   = choose(:host,   options[:Host])
-      @logger = choose(:logger, options[:Log])
-      @port   = options[:Port].to_i
+      @block   = choose(:block,   options[:Block])
+      @cbor    = choose(:cbor,    options[:CBOR])
+      @host    = choose(:host,    options[:Host])
+      @logger  = choose(:logger,  options[:Log])
+      @mcast   = choose(:mcast,   options[:Multicast])
+      @observe = choose(:observe, options[:Observe])
+      @port    = options[:Port].to_i
 
-      @app    = app.respond_to?(:new) ? app.new : app
+      @app     = app.respond_to?(:new) ? app.new : app
+
+      @default_format = choose(:default_format, options[:DefaultFormat])
+
+      @dedup_cache = {}
 
       logger.info "David #{David::VERSION} on #{RUBY_DESCRIPTION}"
       logger.info "Starting on [#{@host}]:#{@port}"
 
-      ipv6 = IPAddr.new(@host).ipv6?
-      af = ipv6 ? ::Socket::AF_INET6 : ::Socket::AF_INET
+      @ipv6 = IPAddr.new(@host).ipv6?
+      af = @ipv6 ? ::Socket::AF_INET6 : ::Socket::AF_INET
 
-      # Actually Celluloid::IO::UDPServer.
-      # (Use celluloid-io from git, 0.15.0 does not support AF_INET6).
+      # Actually Celluloid::IO::UDPSocket.
       @socket = UDPSocket.new(af)
+      multicast_initialize if @mcast
       @socket.bind(@host, @port)
 
       async.run
@@ -37,26 +48,60 @@ module David
 
     private
 
-    def shutdown
-      @socket.close unless @socket.nil?
-    end
+    def handle_input(*args)
+      data, sender, _, anc = args
 
-    def run
-      loop { async.handle_input(*@socket.recvfrom(1024)) }
-    end
+      if defined?(JRuby)
+        port, _, host = sender[1..3]
+      else
+        host, port = sender.ip_address, sender.ip_port
+      end
+
+      message = CoAP::Message.parse(data)
+      request = Request.new(host, port, message, anc)
 
-    def handle_input(data, sender)
-      _, port, host = sender
-      request = CoAP::Message.parse(data)
+      return unless request.con? || request.non?
+      return unless request.valid_method?
+      return if !request.non? && request.multicast?
 
-      logger.info "[#{host}]:#{port}: #{request}"
-      logger.debug request.inspect
+      logger.info "[#{host}]:#{port}: #{message} (block #{request.block.num})"
+      logger.debug message.inspect
 
-      response = respond(host, port, request)
+      if request.con? && duplicate?(request) #&& !request.idempotent?
+        response, options = cached_response(request)
+        logger.debug "(mid:#{request.mid} duplicate, response cached)"
+      else
+        response, options = respond(request)
+      end
 
-      logger.debug response.inspect
+      unless response.nil?
+        logger.debug response.inspect
 
-      CoAP::Ether.send(response, host, port, socket: @socket)
+        CoAP::Transmission.send(response, host, port,
+          options.merge(socket: @socket))
+
+        request.options = options
+        cache_response(request, response)
+      end
+    end
+
+    def run
+      loop do
+        if defined?(JRuby)
+          async.handle_input(*@socket.recvfrom(1152))
+        else
+          begin
+            async.handle_input(*@socket.to_io.recvmsg_nonblock)
+          rescue ::IO::WaitReadable
+            Celluloid::IO.wait_readable(@socket)
+            retry
+          end
+        end
+      end
+    end
+
+    def shutdown
+      @socket.close unless @socket.nil?
     end
   end
 end

data/lib/david/server/constants.rb

@@ -0,0 +1,48 @@
+module David
+  class Server
+    module Constants
+      # Freeze some WSGI env keys.
+      REMOTE_ADDR     = 'REMOTE_ADDR'.freeze
+      REMOTE_PORT     = 'REMOTE_PORT'.freeze
+      REQUEST_METHOD  = 'REQUEST_METHOD'.freeze
+      SCRIPT_NAME     = 'SCRIPT_NAME'.freeze
+      PATH_INFO       = 'PATH_INFO'.freeze
+      QUERY_STRING    = 'QUERY_STRING'.freeze
+      SERVER_NAME     = 'SERVER_NAME'.freeze
+      SERVER_PORT     = 'SERVER_PORT'.freeze
+      CONTENT_LENGTH  = 'CONTENT_LENGTH'.freeze
+      CONTENT_TYPE    = 'CONTENT_TYPE'.freeze
+      HTTP_ACCEPT     = 'HTTP_ACCEPT'.freeze
+
+      # Freeze some Rack env keys.
+      RACK_VERSION      = 'rack.version'.freeze
+      RACK_URL_SCHEME   = 'rack.url_scheme'.freeze
+      RACK_INPUT        = 'rack.input'.freeze
+      RACK_ERRORS       = 'rack.errors'.freeze
+      RACK_MULTITHREAD  = 'rack.multithread'.freeze
+      RACK_MULTIPROCESS = 'rack.multiprocess'.freeze
+      RACK_RUN_ONCE     = 'rack.run_once'.freeze
+      RACK_LOGGER       = 'rack.logger'.freeze
+
+      # Freeze CoAP specific env keys.
+      COAP_VERSION    = 'coap.version'.freeze
+      COAP_MULTICAST  = 'coap.multicast'.freeze
+      COAP_DTLS       = 'coap.dtls'.freeze
+      COAP_DTLS_ID    = 'coap.dtls.id'.freeze
+      COAP_DTLS_NOSEC = 'NoSec'.freeze
+
+      # Freeze some Rack env values.
+      EMPTY_STRING          = ''.freeze
+      CONTENT_TYPE_JSON     = 'application/json'.freeze
+      CONTENT_TYPE_CBOR     = 'application/cbor'.freeze
+      RACK_URL_SCHEME_HTTP  = 'http'.freeze
+
+      # Freeze HTTP header strings.
+      HTTP_CACHE_CONTROL  = 'Cache-Control'.freeze
+      HTTP_CONTENT_LENGTH = 'Content-Length'.freeze
+      HTTP_CONTENT_TYPE   = 'Content-Type'.freeze
+      HTTP_ETAG           = 'ETag'.freeze
+      HTTP_LOCATION       = 'Location'.freeze
+    end
+  end
+end

data/lib/david/server/deduplication.rb

@@ -0,0 +1,21 @@
+module David
+  module Deduplication
+    def self.included(base)
+      attr_reader :dedup_cache
+    end
+
+    def cache_response(request, response)
+      return if duplicate?(request)
+      @dedup_cache[[request.host, request.mid]] = [response, Time.now.to_i]
+    end
+
+    def cached_response(request)
+      response = @dedup_cache[[request.host, request.mid]]
+      [response[0], response[0].options] if response
+    end
+
+    def duplicate?(request)
+      return !!cached_response(request)
+    end
+  end
+end

data/lib/david/server/mapping.rb

@@ -1,32 +1,84 @@
 module David
   class Server
     module Mapping
+      include Constants
+
+      HTTP_TO_COAP_CODES = {
+        200 => 205,
+        202 => 201,
+        203 => 205,
+        204 => 205,
+        304 => 203,
+        407 => 401,
+        408 => 400,
+        409 => 412,
+        410 => 404,
+        411 => 402,
+        414 => 402,
+        505 => 500,
+        506 => 500,
+        511 => 500,
+      }.freeze
+
       protected
+    
+      def accept_to_http(request)
+        if request.accept.nil?
+          @default_format
+        else
+          CoAP::Registry.convert_content_format(request.accept)
+        end
+      end
 
       def body_to_cbor(body)
         JSON.parse(body).to_cbor
       end
 
-      def coap_to_http_method(method)
-        method.to_s.upcase
-      end
-
-      def etag(options, bytes = 8)
-        etag = options['ETag']
-        etag.delete('"').bytes.first(bytes * 2).pack('C*').hex if etag
-      end
+      def code_to_coap(code)
+        if code.is_a?(Float)
+          return [code.to_i, (code * 100 % 100).round]
+        end
 
-      def http_to_coap_code(code)
         code = code.to_i
-
-        h = {200 => 205}
-        code = h[code] if h[code]
+        code = HTTP_TO_COAP_CODES[code] if HTTP_TO_COAP_CODES[code]
 
         a = code / 100
         b = code - (a * 100)
 
         [a, b]
       end
+
+      def etag_to_coap(headers, bytes = 8)
+        etag = headers[HTTP_ETAG]
+
+        if etag
+          etag = etag.split('"')
+          etag = etag[1] || etag[0]
+
+          etag
+            .bytes
+            .first(bytes * 2)
+            .pack('C*')
+            .hex
+        end
+      end
+
+      def location_to_coap(headers)
+        l = headers[HTTP_LOCATION].split('/').reject(&:empty?)
+        return l.empty? ? nil : l
+      rescue NoMethodError
+        nil
+      end
+
+      def max_age_to_coap(headers)
+        headers[HTTP_CACHE_CONTROL][/max-age=([0-9]*)/, 1]
+      rescue NoMethodError
+        nil
+      end
+
+      def method_to_http(method)
+        method.to_s.upcase
+      end
     end
   end
 end

data/lib/david/server/multicast.rb

@@ -0,0 +1,54 @@
+module David
+  class Server
+    # See https://tools.ietf.org/html/rfc7252#section-12.8
+    module Multicast
+      def multicast_initialize
+        @socket.to_io.setsockopt(:SOL_SOCKET, :SO_REUSEADDR, 1)
+
+        if @ipv6
+          maddrs = ['ff02::fd', 'ff05::fd']
+          maddrs << 'ff02::1' if OS.osx? # OSX needs ff02::1 explicitly joined.
+          maddrs.each { |maddr| multicast_listen_ipv6(maddr) }
+
+          setsockopts_ipv6
+        else
+          maddrs = ['224.0.1.187']
+          multicast_listen_ipv4(maddrs.first)
+
+          setsockopts_ipv4
+        end
+
+        logger.debug "Joined multicast groups: #{maddrs.join(', ')}"
+      rescue Errno::ENODEV, Errno::EADDRNOTAVAIL
+        logger.warn 'Multicast initialization failure: Device not found.'
+        @mcast = false
+      end
+
+      def multicast_listen_ipv4(address)
+        mreq = IPAddr.new(address).hton + IPAddr.new('0.0.0.0').hton
+        @socket.to_io.setsockopt(:IPPROTO_IP, :IP_ADD_MEMBERSHIP, mreq)
+      end
+
+      def multicast_listen_ipv6(address)
+        ifindex = 0
+
+        # http://lists.apple.com/archives/darwin-kernel/2014/Mar/msg00012.html
+        if OS.osx?
+          ifname  = Socket.if_up?('en1') ? 'en1' : 'en0'
+          ifindex = Socket.if_nametoindex(ifname)
+        end
+
+        mreq = IPAddr.new(address).hton + [ifindex].pack('i_')
+        @socket.to_io.setsockopt(:IPPROTO_IPV6, :IPV6_JOIN_GROUP, mreq)
+      end
+
+      def setsockopts_ipv4
+        @socket.to_io.setsockopt(:IPPROTO_IP, :IP_PKTINFO, 1)
+      end
+
+      def setsockopts_ipv6
+        @socket.to_io.setsockopt(:IPPROTO_IPV6, :IPV6_RECVPKTINFO, 1)
+      end
+    end
+  end
+end