david 0.3.0 → 0.4.0

data/benchmarks/rackup/grape.ru

@@ -0,0 +1,18 @@
+#\ -o ::1 -p 5683 -O Block=false -O Multicast=false -O Observe=false -O Log=none -E none
+
+require 'bundler/setup'
+Bundler.setup
+
+require 'david'
+require 'grape'
+
+class Dummy < Grape::API
+  content_type :txt, 'text/plain'
+  default_format :txt
+
+  get :hello do
+    'Hello World!'
+  end
+end
+
+run Dummy.new

data/benchmarks/rackup/rack.ru

@@ -0,0 +1,7 @@
+#\ -o ::1 -p 5683 -O Block=false -O Multicast=false -O Observe=false -O Log=none -E none
+
+require 'bundler/setup'
+Bundler.setup
+
+require 'david'
+run Rack::HelloWorld.new

data/benchmarks/rackup/rails.ru

@@ -0,0 +1,14 @@
+#\ -o ::1 -p 5683 -O Block=false -O Multicast=false -O Observe=false -O Log=none -E none
+
+require 'bundler/setup'
+Bundler.setup
+
+require_relative '../../spec/dummy/config/application'
+
+module Dummy
+  class Application
+    config.middleware.delete(Rack::ETag)
+  end
+end
+
+run Rails.application.initialize!

data/benchmarks/rps.rb

@@ -2,18 +2,30 @@
 
 require 'benchmark/ips'
 
+require 'celluloid'
+Celluloid.logger = nil
+
 require 'coap'
 include CoRE
 
 uri = ARGV[0] || 'coap://[::1]/hello'
+n = (ARGV[1] || 100).to_i
+
+class Tester
+  include Celluloid
+
+  def run(uri)
+    response = CoAP::Client.new.get_by_uri(uri)
+    raise unless response.mcode == [2, 5]
+  end
+end
 
 Benchmark.ips do |x|
   x.warmup  = 30
   x.time    = 30
 
   x.report(uri) do
-    response = CoAP::Client.new.get_by_uri(uri)
-    raise unless response.mcode == [2, 5]
+    Tester.pool(size: n).run(uri)
   end
 
   x.compare!

data/benchmarks/stress.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+# (60+(28*3*(30+15)))/60=64
+
+uri="coap://[::1]:5683/hello"
+
+./coapbench.sh -c 1000 -t 60 $uri > /dev/null 2>&1
+
+seq="$(seq 10 10 90) $(seq 100 100 900) $(seq 1000 1000 10000)"
+
+for c in $seq; do
+	for i in $(seq 1 3); do
+		./coapbench.sh -c $c -t 30 $uri 2>&1 | grep throughput
+		sleep 15
+	done
+done
+
+rm -f coapbench\(*

data/david.gemspec

@@ -26,7 +26,4 @@ Gem::Specification.new do |s|
 
   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/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+gem 'benchmark-ips'
+gem 'celluloid'
+gem 'celluloid-io'
+gem 'thread_safe'

data/experiments/concurrency/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gem 'david', path: '../..'

data/experiments/concurrency/stub.rb

@@ -0,0 +1,88 @@
+require 'celluloid'
+require 'coap'
+require 'david'
+
+class Listener
+  include David::Server::Respond
+
+  def initialize(mode, socket, cache)
+    @mode = mode
+    @socket = socket
+    @cache = cache
+    @app = Rack::HelloWorld.new
+    @block = true
+    @observe = true
+  end
+
+  def run
+    loop do
+      if defined?(JRuby) || @mode == :prefork || @mode == :threaded
+        data, sender = @socket.recvfrom(1152)
+        port, _, host = sender[1..3]
+      else
+        begin
+          data, sender, _, anc = @socket.to_io.recvmsg_nonblock
+        rescue ::IO::WaitReadable
+          Celluloid::IO.wait_readable(@socket)
+          retry
+        end
+
+        host, port = sender.ip_address, sender.ip_port
+      end
+
+      message = CoAP::Message.parse(data)
+      exchange = David::Exchange.new(host, port, message, anc)
+
+      return if !exchange.non? && exchange.multicast?
+      
+      key = exchange.key
+      cached = @cache[key]
+
+      if exchange.ack? && !cached.nil?
+        @cache.delete(key)
+      elsif exchange.request?
+        if exchange.con? && !cached.nil?
+          response = cached[0]
+        else
+          response, _ = respond(exchange)
+        end
+      end
+
+      unless response.nil?
+        @socket.send(response.to_wire, 0, host, port)
+
+        if !cached.nil?
+          cached[1] = Time.now.to_i
+        elsif exchange.reliable?
+          @cache[[host, response.mid]] = [response, Time.now.to_i]
+        end
+      end
+    end
+  end
+end
+
+
+trap('EXIT') { socket.close }
+
+cache = {}
+
+case ARGV[0]
+  when 'prefork'
+    # ~33000
+    socket = UDPSocket.new(Socket::AF_INET6)
+    socket.bind('::', 5683)
+    4.times { fork { Listener.new(:prefork, socket, cache).run } }
+  when 'threaded'
+    # ~16000
+    socket = UDPSocket.new(Socket::AF_INET6)
+    socket.bind('::', 5683)
+    Listener.send(:include, Celluloid)
+    Listener.pool(size: 8, args: [:threaded, socket, cache]).run
+  else
+    # ~14000
+    socket = Celluloid::IO::UDPSocket.new(Socket::AF_INET6)
+    socket.bind('::', 5683)
+    Listener.new(:sped, socket, cache).run
+end
+
+Process.waitall

data/experiments/hash_key.rb

@@ -0,0 +1,64 @@
+require 'benchmark/ips'
+
+max = 10000
+
+keys1  = ([0]*max).map { rand(0..99999).to_s }
+keys2  = ([0]*max).map { rand(0..99999) }
+values = ([0]*max).map { rand(0..99999) }
+
+a = {}
+b = {}
+
+Benchmark.ips do |x|
+  x.report('Array key (insert)') do
+    max.times do |i|
+      a[[keys1[i], keys2[i]]] = values[i]
+    end
+  end
+
+  x.report('Nested Hash (insert)') do
+    max.times do |i|
+      if b[keys1[i]].nil?
+        b[keys1[i]] = {keys2[i] => values[i]}
+      else
+        b[keys1[i]].merge!(keys2[i] => values[i])
+      end
+    end
+  end
+
+  x.report('Set key (insert)') do
+    max.times do |i|
+      key = Set.new
+      key << keys1[i]
+      key << keys2[i]
+      a[key] = values[i]
+    end
+  end
+
+  x.compare!
+end
+
+Benchmark.ips do |x|
+  x.report('Array key (lookup)') do
+    max.times do |i|
+      v = a[[keys1[i], keys2[i]]]
+    end
+  end
+
+  x.report('Nested Hash (lookup)') do
+    max.times do |i|
+      v = b[keys1[i]][keys2[i]]
+    end
+  end
+
+  x.report('Set key (lookup)') do
+    max.times do |i|
+      key = Set.new
+      key << keys1[i]
+      key << keys2[i]
+      v = a[key]
+    end
+  end
+
+  x.compare!
+end

data/experiments/string_concat.rb

@@ -0,0 +1,21 @@
+require 'benchmark/ips'
+
+def r
+  rand(0..99999)
+end
+
+Benchmark.ips do |x|
+  x.report('interpolation') do
+    "foo #{r} #{r} #{r}"
+  end
+
+  x.report('addition') do
+    'foo ' + r.to_s + ' ' + r.to_s
+  end
+
+  x.report('concatenation') do
+    'foo ' << r.to_s << ' ' << r.to_s
+  end
+
+  x.compare!
+end

data/experiments/symbol_to_proc.rb

@@ -0,0 +1,15 @@
+require 'benchmark/ips'
+
+Benchmark.ips do |x|
+  a = [0..99999]
+
+  x.report('map') do
+    a.map { |e| e.to_s }
+  end
+
+  x.report('symbol to proc') do
+    a.map(&:to_s)
+  end
+
+  x.compare!
+end

data/experiments/thread_safe.rb

@@ -0,0 +1,40 @@
+require 'benchmark/ips'
+require 'celluloid'
+require 'thread_safe'
+
+class Stresser
+  include Celluloid
+
+  def run(&block)
+    block.call
+  end
+end
+
+Benchmark.ips do |x|
+  x.time = 60
+  x.warmup = 60
+
+  a = ThreadSafe::Hash.new
+  b = Hash.new
+  c = ThreadSafe::Cache.new
+
+  p = Stresser.pool(size: 1000)
+
+  def r
+    rand(0..9999)
+  end
+
+  x.report('ThreadSafe::Hash') do
+    p.run { a[[r.to_s, r]] = [r] }
+  end
+
+  x.report('Hash') do
+    p.run { b[[r.to_s, r]] = [r] }
+  end
+
+  x.report('ThreadSafe::Cache') do
+    p.run { c[[r.to_s, r]] = [r] }
+  end
+
+  x.compare!
+end

data/lib/david.rb

@@ -4,7 +4,7 @@ end
 require 'bundler/setup'
 Bundler.require(:default, :cbor)
 
-unless defined? JRuby
+unless defined?(JRuby)
   begin
     require 'cbor'
   rescue LoadError
@@ -28,15 +28,19 @@ require 'rack/handler/david'
 require 'rack/handler/coap'
 
 require 'david/guerilla/rack/handler'
+require 'david/guerilla/rack/utils'
 
 require 'david/actor'
+require 'david/registry'
+require 'david/exchange'
 require 'david/garbage_collector'
+require 'david/transmitter'
+require 'david/version'
+
 require 'david/observe'
-require 'david/request'
 require 'david/server'
-require 'david/version'
 
-if defined? Rails
+if defined?(Rails)
   require 'david/rails/action_controller/base'
 
   require 'david/railties/config'

data/lib/david/actor.rb

@@ -2,17 +2,7 @@ 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]
+      base.send(:include, Registry)
     end
   end
 end

data/lib/david/app_config.rb

@@ -0,0 +1,112 @@
+require 'david/fake_logger'
+
+module David
+  class AppConfig < Hash
+    DEFAULT_OPTIONS = {
+      :Block => true,
+      :CBOR => false,
+      :DefaultFormat => 'application/json',
+      :Host => ENV['RACK_ENV'] == 'development' ? '::1' : '::',
+      :Log => nil,
+      :MinimalMapping => false,
+      :Multicast => true,
+      :Observe => true,
+      :Port => ::CoAP::PORT
+    }
+
+    def initialize(hash = {})
+      self.merge!(DEFAULT_OPTIONS)
+      self.merge!(hash)
+
+      (self.keys & DEFAULT_OPTIONS.keys).each do |key|
+        optionize!(key)
+      end
+    end
+
+    private
+
+    def choose_block(value)
+      default_to_true(:block, value)
+    end
+
+    def choose_cbor(value)
+      default_to_false(:cbor, value)
+    end
+
+    def choose_defaultformat(value)
+      value = from_rails(:default_format)
+      return nil if value.nil?
+      value
+    end
+
+    # Rails starts on 'localhost' since 4.2.0.beta1
+    # (Resolv class seems not to consider /etc/hosts)
+    def choose_host(value)
+      return nil if value.nil?
+      Socket::getaddrinfo(value, nil, nil, Socket::SOCK_STREAM)[0][3]
+    end
+
+    def choose_log(value)
+      return FakeLogger.new if value == 'none'
+
+      log = ::Logger.new($stderr)
+
+      log.level = ::Logger::INFO
+      log.level = ::Logger::DEBUG if value == 'debug'
+
+      log.formatter = proc do |sev, time, prog, msg|
+        "#{time.strftime('[%Y-%m-%d %H:%M:%S]')} #{sev}  #{msg}\n"
+      end
+
+      Celluloid.logger = log
+
+      log
+    end
+
+    def choose_minimalmapping(value)
+      value
+    end
+
+    def choose_multicast(value)
+      default_to_true(:multicast, value)
+    end
+    
+    def choose_observe(value)
+      default_to_true(:observe, value)
+    end
+
+    def choose_port(value)
+      value.nil? ? nil : value.to_i
+    end
+
+    def default_to_false(key, value)
+      return true if value.to_s == 'true'
+
+      r = from_rails(key)
+      return r unless r.nil? || value == 'false'
+
+      false
+    end
+  
+    def default_to_true(key, value)
+      return false if value.to_s == 'false'
+
+      r = from_rails(key)
+      return r unless r.nil? || value == 'true'
+
+      true
+    end
+
+    def from_rails(key)
+      if defined?(Rails) && !Rails.application.nil?
+        Rails.application.config.coap.send(key)
+      end
+    end
+
+    def optionize!(key)
+      method = ('choose_' << key.to_s.downcase).to_sym
+      value = self.send(method, self[key])
+      self[key] = value unless value.nil?
+    end
+  end
+end