david 0.3.0 → 0.4.0

data/lib/david/rails/action_controller/base.rb

@@ -1,11 +1,13 @@
-class ActionController::Base
-  def self.discoverable(options)
-    discovery_actor.register(self, options)
-  end
+module ActionController
+  class Base
+    def self.discoverable(options)
+      discovery_actor.register(self, options)
+    end
 
-  protected
+    protected
 
-  def self.discovery_actor
-    Celluloid::Actor[:discovery]
+    def self.discovery_actor
+      Celluloid::Actor[:discovery]
+    end
   end
 end

data/lib/david/railties/config.rb

@@ -4,19 +4,19 @@ module David
       config.coap = ActiveSupport::OrderedOptions.new
 
       # Blockwise transfer
-      config.coap.block = true
+      config.coap.block = nil
 
       # Transparent JSON<>CBOR conversion
-      config.coap.cbor = false
+      config.coap.cbor = nil
 
       # Default Content-Type if HTTP_ACCEPT is empty
       config.coap.default_format = nil
 
       # Multicast
-      config.coap.multicast = true
+      config.coap.multicast = nil
 
       # Observe
-      config.coap.observe = true
+      config.coap.observe = nil
 
       # david as default Rack handler (`rails s` starts david)
       config.coap.only = true

data/lib/david/registry.rb

@@ -0,0 +1,22 @@
+module David
+  module Registry
+    protected
+
+    def log
+      @log ||= Celluloid.logger 
+      @log ||= ::Logger.new(nil)
+    end
+
+    def gc
+      Celluloid::Actor[:gc]
+    end
+
+    def observe
+      Celluloid::Actor[:observe]
+    end
+
+    def server
+      Celluloid::Actor[:server]
+    end
+  end
+end

data/lib/david/server.rb

@@ -1,103 +1,103 @@
-require 'david/server/deduplication'
+require 'david/app_config'
+require 'david/server/mid_cache'
 require 'david/server/multicast'
-require 'david/server/options'
 require 'david/server/respond'
 
 module David
   class Server
     include Celluloid::IO
-    include CoAP::Coding
 
-    include Deduplication
+    include MidCache
     include Multicast
-    include Options
     include Respond
 
-    attr_reader :logger, :socket
+    attr_reader :socket
 
     finalizer :shutdown
 
     def initialize(app, options)
-      @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
+      @mid_cache  = {}
+      @options    = AppConfig.new(options)
 
-      @app     = app.respond_to?(:new) ? app.new : app
+      host, port  = @options.values_at(:Host, :Port)
 
-      @default_format = choose(:default_format, options[:DefaultFormat])
+      log.info "David #{David::VERSION} on #{RUBY_DESCRIPTION}"
+      log.info "Starting on [#{host}]:#{port}"
 
-      @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
+      af = ipv6? ? ::Socket::AF_INET6 : ::Socket::AF_INET
 
       # Actually Celluloid::IO::UDPSocket.
       @socket = UDPSocket.new(af)
-      multicast_initialize if @mcast
-      @socket.bind(@host, @port)
+      multicast_initialize! if @options[:Multicast]
+      @socket.bind(host, port)
+    end
 
-      async.run
+    def run
+      loop do
+        if defined?(JRuby) || defined?(Rubinius)
+          dispatch(*@socket.recvfrom(1152))
+        else
+          begin
+            dispatch(*@socket.to_io.recvmsg_nonblock)
+          rescue ::IO::WaitReadable
+            Celluloid::IO.wait_readable(@socket)
+            retry
+          end
+        end
+      end
     end
 
     private
 
-    def handle_input(*args)
+    def dispatch(*args)
       data, sender, _, anc = args
 
-      if defined?(JRuby)
+      if defined?(JRuby) || defined?(Rubinius)
         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)
+      message  = CoAP::Message.parse(data)
+      exchange = Exchange.new(host, port, message, anc)
+
+      return if !exchange.non? && exchange.multicast?
 
-      return unless request.con? || request.non?
-      return unless request.valid_method?
-      return if !request.non? && request.multicast?
+      log.info('<- ' + exchange.to_s)
+      log.debug(message.inspect)
 
-      logger.info "[#{host}]:#{port}: #{message} (block #{request.block.num})"
-      logger.debug message.inspect
+      key = exchange.key
+      cached = cache_get(key)
 
-      if request.con? && duplicate?(request) #&& !request.idempotent?
-        response, options = cached_response(request)
-        logger.debug "(mid:#{request.mid} duplicate, response cached)"
+      if exchange.response? && !cached.nil?
+        cache_delete(key)
+      elsif exchange.request?
+        handle_request(exchange, key, cached)
+      end
+    end
+
+    def handle_request(exchange, key, cached)
+      if exchange.con? && !cached.nil? #&& !exchange.idempotent?
+        response = cached[0]
+        log.debug("dedup cache hit #{exchange.mid}")
       else
-        response, options = respond(request)
+        response, _ = respond(exchange)
       end
 
       unless response.nil?
-        logger.debug response.inspect
+        @socket.send(response.to_wire, 0, exchange.host, exchange.port)
 
-        CoAP::Transmission.send(response, host, port,
-          options.merge(socket: @socket))
+        exchange.message = response if log.info?
+        log.info('-> ' + exchange.to_s)
+        log.debug(response.inspect)
 
-        request.options = options
-        cache_response(request, response)
+        cache_add(key, response) if response.tt == :ack
       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
+    def ipv6?
+      IPAddr.new(@options[:Host]).ipv6?
     end
 
     def shutdown

data/lib/david/server/constants.rb

@@ -27,6 +27,7 @@ module David
       # Freeze CoAP specific env keys.
       COAP_VERSION    = 'coap.version'.freeze
       COAP_MULTICAST  = 'coap.multicast'.freeze
+      COAP_CBOR       = 'coap.cbor'.freeze
       COAP_DTLS       = 'coap.dtls'.freeze
       COAP_DTLS_ID    = 'coap.dtls.id'.freeze
       COAP_DTLS_NOSEC = 'NoSec'.freeze

data/lib/david/server/mapping.rb

@@ -20,32 +20,41 @@ module David
         511 => 500,
       }.freeze
 
+      HTTP_TO_COAP_CODES_MINIMAL = {
+        200 => 205,
+      }.freeze
+
       protected
     
       def accept_to_http(request)
         if request.accept.nil?
-          @default_format
+          @options[:DefaultFormat]
         else
           CoAP::Registry.convert_content_format(request.accept)
         end
       end
 
-      def body_to_cbor(body)
-        JSON.parse(body).to_cbor
+      def body_to_cbor(json)
+        JSON.parse(json).to_cbor
       end
 
-      def code_to_coap(code)
-        if code.is_a?(Float)
-          return [code.to_i, (code * 100 % 100).round]
+      def body_to_json(cbor)
+        if cbor.is_a?(String)
+          CBOR.load(cbor).to_json
+        else
+          cbor.to_json
         end
+      end
 
-        code = code.to_i
-        code = HTTP_TO_COAP_CODES[code] if HTTP_TO_COAP_CODES[code]
+      def code_to_coap(code)
+        set_http_to_coap_codes!
 
-        a = code / 100
-        b = code - (a * 100)
+        return float_to_array(code) if code.is_a?(Float)
 
-        [a, b]
+        code = code.to_i
+        code = @http_to_coap_codes[code] if @http_to_coap_codes[code]
+
+        int_to_array(code)
       end
 
       def etag_to_coap(headers, bytes = 8)
@@ -63,6 +72,19 @@ module David
         end
       end
 
+      def float_to_array(float)
+        [float.to_i, (float * 100 % 100).round]
+      end
+
+      def int_to_array(int)
+        int = int.to_i
+
+        a = int / 100
+        b = int - (a * 100)
+
+        [a, b]
+      end
+
       def location_to_coap(headers)
         l = headers[HTTP_LOCATION].split('/').reject(&:empty?)
         return l.empty? ? nil : l
@@ -79,6 +101,16 @@ module David
       def method_to_http(method)
         method.to_s.upcase
       end
+
+      def set_http_to_coap_codes!
+        @http_to_coap_codes ||= begin
+          if @options && @options[:MinimalMapping]
+            HTTP_TO_COAP_CODES_MINIMAL
+          else
+            HTTP_TO_COAP_CODES
+          end
+        end
+      end
     end
   end
 end

data/lib/david/server/mid_cache.rb

@@ -0,0 +1,29 @@
+module David
+  module MidCache
+    def self.included(base)
+      base.send(:attr_reader, :mid_cache)
+    end
+
+    def cache
+      @mid_cache
+    end
+
+    def cache_add(key, message)
+      @mid_cache[key] = [message, Time.now.to_i]
+    end
+
+    def cache_clean!(timeout)
+      now = Time.now.to_i
+      @mid_cache.delete_if { |_, v| now - v[1] >= timeout }
+      log.debug(@mid_cache.map { |k, v| v[0].to_s })
+    end
+
+    def cache_delete(key)
+      @mid_cache.delete(key)
+    end
+
+    def cache_get(key)
+      @mid_cache[key]
+    end
+  end
+end

data/lib/david/server/multicast.rb

@@ -2,10 +2,10 @@ module David
   class Server
     # See https://tools.ietf.org/html/rfc7252#section-12.8
     module Multicast
-      def multicast_initialize
+      def multicast_initialize!
         @socket.to_io.setsockopt(:SOL_SOCKET, :SO_REUSEADDR, 1)
 
-        if @ipv6
+        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) }
@@ -18,12 +18,14 @@ module David
           setsockopts_ipv4
         end
 
-        logger.debug "Joined multicast groups: #{maddrs.join(', ')}"
+        log.debug "Joined multicast groups: #{maddrs.join(', ')}"
       rescue Errno::ENODEV, Errno::EADDRNOTAVAIL
-        logger.warn 'Multicast initialization failure: Device not found.'
-        @mcast = false
+        log.warn 'Multicast initialization failure: Device not found.'
+        @options[:Multicast] = false
       end
 
+      private
+
       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)

data/lib/david/server/respond.rb

@@ -5,35 +5,51 @@ require 'david/server/utility'
 module David
   class Server
     module Respond
+      include CoAP::Coding
+
       include Constants
       include Mapping
+      include Registry
       include Utility
 
-      def respond(request, env = nil)
-        block_enabled = @block && request.get?
+      def respond(exchange, env = nil)
+        block_enabled = @options[:Block] && exchange.get?
 
         if block_enabled
           # Fail if m set.
-          if request.block.more && !request.multicast?
-            return error(request, 4.05)
+          if exchange.block.more && !exchange.multicast?
+            return error(exchange, 4.05)
           end
         end
 
-        return error(request, 5.05) if request.proxy?
+        return error(exchange, 5.05) if exchange.proxy?
+
+        env ||= basic_env(exchange)
+
+        if @options[:CBOR] && exchange.cbor?
+          begin
+            cbor = CBOR.load(exchange.message.payload)
+
+            body = body_to_json(cbor)
+            body = body.force_encoding('ASCII-8BIT') # Rack::Lint insisted...
 
-        env ||= basic_env(request)
+            env[COAP_CBOR]      = cbor
+            env[CONTENT_LENGTH] = body.bytesize
+            env[CONTENT_TYPE]   = CONTENT_TYPE_JSON
+            env[RACK_INPUT]     = StringIO.new(body)
+          rescue EOFError, CBOR::MalformedFormatError
+          end
+        end
 
         code, headers, body = @app.call(env)
 
-        # No error responses on multicast requests.
-        return if request.multicast? && !(200..299).include?(code)
+        # No error responses on multicast exchanges.
+        return if exchange.multicast? && !(200..299).include?(code)
 
         ct = headers[HTTP_CONTENT_TYPE]
         body = body_to_string(body)
 
-        body.close if body.respond_to?(:close)
-
-        if @cbor && ct == 'application/json'
+        if @options[:CBOR] && ct == CONTENT_TYPE_JSON
           begin
             body = body_to_cbor(body)
             ct = CONTENT_TYPE_CBOR
@@ -41,37 +57,35 @@ module David
           end
         end
 
-        # No response on request for non-existent block.
-        return if block_enabled && !request.block.included_by?(body)
+        # No response on exchange for non-existent block.
+        return if block_enabled && !exchange.block.included_by?(body)
 
         cf    = CoAP::Registry.convert_content_format(ct)
         etag  = etag_to_coap(headers, 4)
         loc   = location_to_coap(headers)
         ma    = max_age_to_coap(headers)
         mcode = code_to_coap(code)
-        size  = headers[HTTP_CONTENT_LENGTH].to_i
 
         # App returned cf different from accept
-        return error(request, 4.06) if request.accept && request.accept != cf
+        return error(exchange, 4.06) if exchange.accept && exchange.accept != cf
 
-        response = initialize_response(request, mcode)
+        response = initialize_response(exchange, mcode)
 
         response.options[:content_format] = cf
         response.options[:etag] = etag
         response.options[:location_path] = loc unless loc.nil?
         response.options[:max_age] = ma.to_i unless ma.nil?
 
-        if @observe && handle_observe(request, env, etag)
+        if @options[:Observe] && handle_observe(exchange, env, etag)
           response.options[:observe] = 0
         end
 
         if block_enabled
-          block = request.block.dup
+          block = exchange.block.dup
           block.set_more!(body)
 
           response.payload = block.chunk(body)
           response.options[:block2] = block.encode
-#         response.options[:size2]  = size if size != 0
         else
           response.payload = body
         end
@@ -81,22 +95,22 @@ module David
 
       private
 
-      def basic_env(request)
-        m = request.message
+      def basic_env(exchange)
+        m = exchange.message
 
         {
-          REMOTE_ADDR       => request.host,
-          REMOTE_PORT       => request.port.to_s,
+          REMOTE_ADDR       => exchange.host,
+          REMOTE_PORT       => exchange.port.to_s,
           REQUEST_METHOD    => method_to_http(m.mcode),
           SCRIPT_NAME       => EMPTY_STRING,
           PATH_INFO         => path_encode(m.options[:uri_path]),
           QUERY_STRING      => query_encode(m.options[:uri_query])
                                  .gsub(/^\?/, ''),
-          SERVER_NAME       => @host,
-          SERVER_PORT       => @port.to_s,
+          SERVER_NAME       => @options[:Host],
+          SERVER_PORT       => @options[:Port].to_s,
           CONTENT_LENGTH    => m.payload.bytesize.to_s,
           CONTENT_TYPE      => EMPTY_STRING,
-          HTTP_ACCEPT       => accept_to_http(request),
+          HTTP_ACCEPT       => accept_to_http(exchange),
           RACK_VERSION      => [1, 2],
           RACK_URL_SCHEME   => RACK_URL_SCHEME_HTTP,
           RACK_INPUT        => StringIO.new(m.payload),
@@ -104,42 +118,38 @@ module David
           RACK_MULTITHREAD  => true,
           RACK_MULTIPROCESS => true,
           RACK_RUN_ONCE     => false,
-          RACK_LOGGER       => @logger,
+          RACK_LOGGER       => @options[:Log],
           COAP_VERSION      => 1,
-          COAP_MULTICAST    => request.multicast?,
+          COAP_MULTICAST    => exchange.multicast?,
           COAP_DTLS         => COAP_DTLS_NOSEC,
           COAP_DTLS_ID      => EMPTY_STRING,
         }
       end
 
-      def error(request, mcode)
-        [initialize_response(request, mcode), retransmit: false]
+      def error(exchange, mcode)
+        [initialize_response(exchange, mcode), retransmit: false]
       end
 
-      def handle_observe(request, env, etag)
-        return unless request.get? && request.observe?
+      def handle_observe(exchange, env, etag)
+        return unless exchange.get? && exchange.observe?
 
-        if request.message.options[:observe] == 0
-          observe.add(request, env, etag)
+        if exchange.message.options[:observe] == 0
+          observe.add(exchange, env, etag)
           true
         else
-          observe.delete(request)
+          observe.delete(exchange)
           false
         end
       end
 
-      def initialize_response(request, mcode = 2.00)
-        type = request.con? ? :ack : :non
+      def initialize_response(exchange, mcode = 2.05)
+        type = exchange.con? ? :ack : :non
 
         CoAP::Message.new \
           tt: type,
           mcode: mcode,
-          mid: request.message.mid || SecureRandom.random_number(0xffff),
-          token: request.token
-      end
-
-      def observe
-        Celluloid::Actor[:observe]
+          mid: exchange.message.mid || SecureRandom.random_number(0xffff),
+          token: exchange.token
       end
     end
   end