david 0.3.0.pre → 0.3.0

data/config.ru

@@ -1,4 +1,8 @@
+#\ -o :: -p 5683 -O Log=debug
+
 require_relative 'lib/david'
 require_relative 'lib/rack/hello_world'
 
+use Rack::ETag
+
 run Rack::HelloWorld.new

data/david.gemspec

@@ -1,4 +1,5 @@
-require_relative 'lib/david/version'
+$:.unshift File.expand_path('lib', File.dirname(__FILE__))
+require 'david/version'
 
 Gem::Specification.new do |s|
   s.name = 'david'
@@ -19,8 +20,13 @@ Gem::Specification.new do |s|
   s.test_files    = s.files.grep(%r{^(test|spec|features)/})
   s.require_paths = ['lib']
 
-  s.add_dependency 'cbor',         '~> 0.5'
-  s.add_dependency 'celluloid-io', '~> 0.16'
-  s.add_dependency 'coap',         '~> 0'
+  s.add_dependency 'celluloid-io', '~> 0.16', '>= 0.16.1'
+  s.add_dependency 'coap',         '~> 0.1'
   s.add_dependency 'rack',         '~> 1.5'
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec', '~> 3.1'
+
+  s.add_development_dependency 'rspec-rails', '~> 3.1'
+  s.add_development_dependency 'rails', '~> 4.2'
 end

data/experiments/mcast.rb

@@ -0,0 +1,37 @@
+require 'celluloid/io'
+require 'ipaddr'
+require 'socket'
+
+ifname, af = ARGV
+
+ifname ||= 'lo'
+af     ||= 'inet6'
+
+ifaddr  = Socket.getifaddrs.select { |x| x.name == ifname }.first
+ifindex = ifaddr.ifindex
+
+if af == 'inet6'
+  maddr = 'ff02::fd'
+# maddr = 'ff05::fd'
+
+  mreq = IPAddr.new(maddr).hton + [ifindex].pack('i_')
+
+  sock = Celluloid::IO::UDPSocket.new(Socket::AF_INET6)
+  sock.to_io.setsockopt(Socket::IPPROTO_IPV6, Socket::IPV6_JOIN_GROUP, mreq)
+else
+  maddr = '224.0.1.187'
+
+  # Ignore interface for now.
+  mreq = IPAddr.new(maddr).hton + IPAddr.new('0.0.0.0').hton
+
+  sock = Celluloid::IO::UDPSocket.new
+  sock.to_io.setsockopt(Socket::IPPROTO_IP, Socket::IP_ADD_MEMBERSHIP, mreq)
+end
+
+puts `netstat -g`
+
+if af == 'inet6'
+  sock.to_io.setsockopt(Socket::IPPROTO_IPV6, Socket::IPV6_LEAVE_GROUP, mreq)
+else
+  sock.to_io.setsockopt(Socket::IPPROTO_IP, Socket::IP_DROP_MEMBERSHIP, mreq)
+end

data/experiments/structs.rb

@@ -0,0 +1,45 @@
+require 'benchmark'
+
+Foo = Struct.new(:a, :b, :c)
+Bar = Struct.new(:a, :b, :c)
+
+data = []
+
+arrays  = {}
+structs = {}
+
+1000000.times do
+  a, b, c = ([0]*3).map { rand(0..9999) }
+  data.push [a, b, c]
+end
+
+Benchmark.bm do |x|
+  x.report('fill arrays ') do
+    data.each do |d|
+      a, b, c = d
+      arrays[[a, b, c]] = [a, b, c]
+    end
+  end
+
+  x.report('fill structs') do
+    data.each do |d|
+      a, b, c = d
+      structs[Foo.new(a, b, c)] = Bar.new(a, b, c)
+    end
+  end
+
+
+  x.report('read arrays ') do
+    100000.times do
+      a, b, c = data.sample
+      arrays[[a, b, c]]
+    end
+  end
+
+  x.report('read structs') do
+    100000.times do
+      a, b, c = data.sample
+      structs[Foo.new(a, b, c)]
+    end
+  end
+end

data/lib/david.rb

@@ -2,10 +2,15 @@ module David
 end
 
 require 'bundler/setup'
-Bundler.require
+Bundler.require(:default, :cbor)
 
 unless defined? JRuby
-  require 'cbor'
+  begin
+    require 'cbor'
+  rescue LoadError
+    $stderr << "`gem install cbor` for transparent JSON/CBOR conversion "
+    $stderr << "support.\n"
+  end
 end
 
 require 'celluloid'
@@ -16,7 +21,7 @@ require 'rack'
 
 include CoRE
 
-$: << File.dirname(__FILE__)
+$:.unshift(File.expand_path(File.dirname(__FILE__)))
 
 require 'rack/hello_world'
 require 'rack/handler/david'
@@ -24,10 +29,16 @@ require 'rack/handler/coap'
 
 require 'david/guerilla/rack/handler'
 
-require 'david/version'
+require 'david/actor'
+require 'david/garbage_collector'
+require 'david/observe'
+require 'david/request'
 require 'david/server'
+require 'david/version'
 
 if defined? Rails
+  require 'david/rails/action_controller/base'
+
   require 'david/railties/config'
   require 'david/railties/middleware'
 end

data/lib/david/actor.rb

@@ -0,0 +1,18 @@
+module David
+  module Actor
+    def self.included(base)
+      base.send(:include, Celluloid)
+    end
+
+    protected
+
+    def log
+      @log ||= Celluloid.logger 
+      @log ||= ::Logger.new(nil)
+    end
+
+    def server
+      Celluloid::Actor[:server]
+    end
+  end
+end

data/lib/david/garbage_collector.rb

@@ -0,0 +1,35 @@
+module David
+  class GarbageCollector
+    include Actor
+
+    def initialize(tick_interval = 10, dedup_timeout = 5)
+      @tick_interval = tick_interval
+      @dedup_timeout = dedup_timeout
+
+      async.run
+
+      log.debug 'GarbageCollector initialized'
+    end
+
+    def clean_dedup_cache(now = Time.now.to_i)
+      server.dedup_cache.delete_if do |k, v|
+        now - v[1] >= @dedup_timeout
+      end
+    end
+
+    private
+
+    def run
+      loop { sleep @tick_interval; tick }
+    end
+
+    def tick
+      unless server.dedup_cache.empty?
+        log.debug 'GarbageCollector tick'
+
+        clean_dedup_cache
+        log.debug server.dedup_cache 
+      end
+    end
+  end
+end

data/lib/david/observe.rb

@@ -0,0 +1,102 @@
+module David
+  class Observe < Hash
+    include Actor
+
+    alias_method :_delete, :delete
+    alias_method :_include?, :include?
+
+    def initialize(tick_interval = 3)
+      @tick_interval = tick_interval
+      async.run
+
+      log.debug 'Observe initialized'
+    end
+
+    def add(request, env, etag)
+      request.message.mid = nil
+      request.message.options.delete(:observe)
+
+      # TODO Check if Array or Struct is more efficient.
+      self[[request.host, request.token]] ||=
+        [0, request, env, etag, Time.now.to_i]
+    end
+
+    def delete(request)
+      _delete([request.host, request.token])
+    end
+
+    def include?(request)
+      _include?([request.host, request.token])
+    end
+
+    def to_s
+      self.map { |k, v| [*k, v[2]['PATH_INFO'], v[0]].inspect }.join(', ')
+    end
+
+    private
+
+    def bump(key, n, response)
+      self[key][0] = n
+      self[key][3] = response.options[:etag]
+      self[key][4] = Time.now.to_i
+    end
+
+    # TODO If ETag did not change but max-age of last notification is expired,
+    #      return empty 2.03.
+    def handle_update(key)
+      n, request, env, etag = self[key]
+      n += 1
+
+      response, options = server.respond(request, env)
+
+      return if response.nil?
+
+      if response.mcode[0] != 2
+        self.delete(request)
+        request(response, request.host, request.port, options)
+        return
+      end
+
+      if etag != response.options[:etag]
+        response.options[:observe] = n
+
+        answer = request(response, request.host, request.port, options)
+
+        if !answer.nil? && answer.tt == :rst
+          self.delete(request)
+          return
+        end
+
+        bump(key, n, response)
+      end
+    end
+
+    def request(message, host, port, options)
+      answer = nil
+
+      log.debug message.inspect
+
+      begin
+        options.merge!(retransmit: false, socket: server.socket)
+        answer = CoAP::Transmission.request(message, host, port, options).last
+        log.debug answer.inspect
+      rescue Timeout::Error, RuntimeError
+      end
+
+      answer
+    end
+
+    def run
+      loop { tick; sleep @tick_interval }
+    end
+
+    def tick
+      unless self.empty?
+        log.debug 'Observe tick'
+        log.debug self
+      end
+
+      self.each_key { |key| async.handle_update(key) }
+    end
+  end
+end

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

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

data/lib/david/railties/config.rb

@@ -2,8 +2,27 @@ module David
   module Railties
     class Config < Rails::Railtie
       config.coap = ActiveSupport::OrderedOptions.new
-      config.coap.cbor = true
+
+      # Blockwise transfer
+      config.coap.block = true
+
+      # Transparent JSON<>CBOR conversion
+      config.coap.cbor = false
+
+      # Default Content-Type if HTTP_ACCEPT is empty
+      config.coap.default_format = nil
+
+      # Multicast
+      config.coap.multicast = true
+
+      # Observe
+      config.coap.observe = true
+
+      # david as default Rack handler (`rails s` starts david)
       config.coap.only = true
+
+      # Resource Discovery
+      config.coap.resource_discovery = true
     end
   end
 end

data/lib/david/railties/middleware.rb

@@ -1,4 +1,5 @@
-require 'david/well_known'
+require 'david/resource_discovery_proxy'
+require 'david/show_exceptions'
 
 module David
   module Railties
@@ -10,21 +11,32 @@ module David
         ActionDispatch::RemoteIp,
         ActionDispatch::RequestId,
         ActionDispatch::Session::CookieStore,
-#       ActionDispatch::ShowExceptions,
         Rack::ConditionalGet,
-#       Rack::ETag,
         Rack::Head,
-        Rack::Lock,
         Rack::MethodOverride,
         Rack::Runtime,
       ]
 
       initializer 'david.clear_out_middleware' do |app|
+        # Remove middleware not applicable to CoAP
         if config.coap.only
-          UNWANTED.each { |klass| app.middleware.delete klass }
+          UNWANTED.each { |klass| app.middleware.delete(klass) }
         end
 
-        app.middleware.insert_after(Rails::Rack::Logger, David::WellKnown)
+        # Enable multithreading for Rails
+        app.middleware.delete(Rack::Lock)
+
+        # Show exceptions as JSON
+        app.middleware.swap \
+          ActionDispatch::ShowExceptions,
+          David::ShowExceptions
+
+        # Include Resource Discovery middleware
+        if config.coap.resource_discovery
+          app.middleware.insert_after \
+            David::ShowExceptions,
+            David::ResourceDiscoveryProxy
+        end
       end
     end
   end

data/lib/david/request.rb

@@ -0,0 +1,80 @@
+class Request < Struct.new(:host, :port, :message, :ancillary, :options)
+  def accept
+    message.options[:accept]
+  end
+
+  def block
+    @block ||= if message.options[:block2].nil?
+      CoAP::Block.new(0, false, 1024)
+    else
+      CoAP::Block.new(message.options[:block2]).decode
+    end
+  end
+
+  def con?
+    message.tt == :con
+  end
+
+  def delete?
+    message.mcode == :delete
+  end
+
+  def etag
+    message.options[:etag]
+  end
+
+  def get_etag?
+    message.options[:etag].nil? && get?
+  end
+
+  def get?
+    message.mcode == :get
+  end
+
+  def idempotent?
+    get? || put? || delete?
+  end
+
+  def mid
+    message.mid
+  end
+
+  def multicast?
+    a = ancillary
+    return false if a.nil?
+
+    return @multicast unless @multicast.nil?
+
+    @multicast =
+      a.cmsg_is?(:IP, :PKTINFO) && a.ip_pktinfo[0].ipv4_multicast? ||
+      a.cmsg_is?(:IPV6, :PKTINFO) && a.ipv6_pktinfo[0].ipv6_multicast?
+  end
+
+  def non?
+    message.tt == :non
+  end
+
+  def observe?
+    !message.options[:observe].nil?
+  end
+
+  def post?
+    message.mcode == :post
+  end
+
+  def proxy?
+    !(message.options[:proxy_uri].nil? && message.options[:proxy_scheme].nil?)
+  end
+
+  def put?
+    message.mcode == :put
+  end
+
+  def token
+    message.options[:token]
+  end
+
+  def valid_method?
+    CoAP::METHODS.include?(message.mcode)
+  end
+end