david 0.3.0.pre

data/README.md

@@ -0,0 +1,5 @@
+David
+=====
+
+David is a CoAP server with Rack interface to bring the illustrious family of
+Rack compatible web frameworks into the Internet of Things.

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/david

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/david'
+require_relative '../lib/rack/hello_world'
+
+debug = true if ARGV.include?('-d')
+
+klass = Rack::HelloWorld.new
+klass = Rack::Lint.new(klass) if ARGV.include?('-l')
+
+Rack::Handler::David.run(klass, :Debug => debug)

data/config.ru

@@ -0,0 +1,4 @@
+require_relative 'lib/david'
+require_relative 'lib/rack/hello_world'
+
+run Rack::HelloWorld.new

data/david.gemspec

@@ -0,0 +1,26 @@
+require_relative 'lib/david/version'
+
+Gem::Specification.new do |s|
+  s.name = 'david'
+  s.version = David::VERSION
+
+  s.summary = 'CoAP server with Rack interface.'
+  s.description = "David is a CoAP server with Rack interface to bring the
+    illustrious family of Rack compatible web frameworks into the Internet of
+    Things."
+
+  s.homepage = 'https://github.com/nning/david'
+  s.license  = 'GPL-3.0'
+  s.author   = 'henning mueller'
+  s.email    = 'henning@orgizm.net'
+
+  s.files         = `git ls-files`.split($/)
+  s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  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 'rack',         '~> 1.5'
+end

data/lib/david.rb

@@ -0,0 +1,33 @@
+module David
+end
+
+require 'bundler/setup'
+Bundler.require
+
+unless defined? JRuby
+  require 'cbor'
+end
+
+require 'celluloid'
+require 'celluloid/io'
+require 'coap'
+require 'ipaddr'
+require 'rack'
+
+include CoRE
+
+$: << File.dirname(__FILE__)
+
+require 'rack/hello_world'
+require 'rack/handler/david'
+require 'rack/handler/coap'
+
+require 'david/guerilla/rack/handler'
+
+require 'david/version'
+require 'david/server'
+
+if defined? Rails
+  require 'david/railties/config'
+  require 'david/railties/middleware'
+end

data/lib/david/guerilla/rack/handler.rb

@@ -0,0 +1,21 @@
+# Monkey-patch Rack to first try David.
+# https://github.com/rack/rack/blob/master/lib/rack/handler.rb#L46-L61
+module Rack
+  module Handler
+    def self.default(options = {})
+      # Guess.
+      if ENV.include?("PHP_FCGI_CHILDREN")
+        # We already speak FastCGI
+        options.delete :File
+        options.delete :Port
+        Rack::Handler::FastCGI
+      elsif ENV.include?("REQUEST_METHOD")
+        Rack::Handler::CGI
+      elsif ENV.include?("RACK_HANDLER")
+        self.get(ENV["RACK_HANDLER"])
+      else
+        pick ['david', 'thin', 'puma', 'webrick']
+      end
+    end
+  end
+end

data/lib/david/railties/config.rb

@@ -0,0 +1,9 @@
+module David
+  module Railties
+    class Config < Rails::Railtie
+      config.coap = ActiveSupport::OrderedOptions.new
+      config.coap.cbor = true
+      config.coap.only = true
+    end
+  end
+end

data/lib/david/railties/middleware.rb

@@ -0,0 +1,31 @@
+require 'david/well_known'
+
+module David
+  module Railties
+    class Middleware < Rails::Railtie
+      UNWANTED = [
+        ActionDispatch::Cookies,
+        ActionDispatch::DebugExceptions,
+        ActionDispatch::Flash,
+        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|
+        if config.coap.only
+          UNWANTED.each { |klass| app.middleware.delete klass }
+        end
+
+        app.middleware.insert_after(Rails::Rack::Logger, David::WellKnown)
+      end
+    end
+  end
+end

data/lib/david/server.rb

@@ -0,0 +1,62 @@
+require 'david/server/options'
+require 'david/server/response'
+
+module David
+  class Server
+    include Celluloid::IO
+    include CoAP::Codification
+
+    include Options
+    include Response
+
+    attr_reader :logger
+
+    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
+
+      @app    = app.respond_to?(:new) ? app.new : app
+
+      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
+
+      # Actually Celluloid::IO::UDPServer.
+      # (Use celluloid-io from git, 0.15.0 does not support AF_INET6).
+      @socket = UDPSocket.new(af)
+      @socket.bind(@host, @port)
+
+      async.run
+    end
+
+    private
+
+    def shutdown
+      @socket.close unless @socket.nil?
+    end
+
+    def run
+      loop { async.handle_input(*@socket.recvfrom(1024)) }
+    end
+
+    def handle_input(data, sender)
+      _, port, host = sender
+      request = CoAP::Message.parse(data)
+
+      logger.info "[#{host}]:#{port}: #{request}"
+      logger.debug request.inspect
+
+      response = respond(host, port, request)
+
+      logger.debug response.inspect
+
+      CoAP::Ether.send(response, host, port, socket: @socket)
+    end
+  end
+end

data/lib/david/server/mapping.rb

@@ -0,0 +1,32 @@
+module David
+  class Server
+    module Mapping
+      protected
+
+      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 http_to_coap_code(code)
+        code = code.to_i
+
+        h = {200 => 205}
+        code = h[code] if h[code]
+
+        a = code / 100
+        b = code - (a * 100)
+
+        [a, b]
+      end
+    end
+  end
+end

data/lib/david/server/options.rb

@@ -0,0 +1,47 @@
+module David
+  class Server
+    module Options
+      protected
+
+      def choose(name, value)
+        send(('choose_' + name.to_s).to_sym, value)
+      end
+
+      def choose_cbor(value)
+        if value.nil? && defined? Rails
+          value = Rails.application.config.coap.cbor
+        end
+
+        !!value
+      end
+
+      # Rails starts on 'localhost' since 4.2.0.beta1
+      # (Resolv class seems not to consider /etc/hosts)
+      def choose_host(value)
+        Socket::getaddrinfo(value, nil, nil, Socket::SOCK_STREAM)[0][3]
+      end
+
+      def choose_logger(log)
+        fd = $stderr
+        level = ::Logger::INFO
+
+        case log
+        when 'debug'
+          level = ::Logger::DEBUG
+        when 'none'
+          fd = File.open('/dev/null', 'w')
+        end
+
+        logger = ::Logger.new(fd)
+        logger.level = level
+        logger.formatter = proc do |sev, time, prog, msg|
+          "#{time.strftime('[%Y-%m-%d %H:%M:%S]')} #{sev}  #{msg}\n"
+        end
+
+        Celluloid.logger = logger
+
+        logger
+      end
+    end
+  end
+end

data/lib/david/server/response.rb

@@ -0,0 +1,124 @@
+require 'david/server/mapping'
+require 'david/server/utility'
+
+module David
+  class Server
+    module Response
+      include Mapping
+      include Utility
+
+      # 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 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
+
+      protected
+
+      def respond(host, port, request)
+        block = CoAP::Block.new(request.options[:block2]).decode
+        block.size = 1024 if request.options[:block2] == 0
+
+        # Fail if m set.
+        if block.more
+          response = initialize_response(request)
+          response.mcode = 4.05
+          return response
+        end
+
+        env = basic_env(host, port, request)
+        logger.debug env
+
+        code, options, body = @app.call(env)
+
+        ct = content_type(options)
+        body = body_to_string(body)
+
+        body.close if body.respond_to?(:close)
+
+        if @cbor
+          body = body_to_cbor(body)
+          ct = CONTENT_TYPE_CBOR
+        end
+
+        mcode = http_to_coap_code(code)
+        etag  = etag(options, 4)
+        cf    = CoAP::Registry.convert_content_format(ct)
+
+        response = initialize_response(request)
+
+        response.mcode = mcode
+        response.payload = block.chunk(body)
+
+        response.options[:etag] = etag
+        response.options[:content_format] = cf
+
+        block.more = !block.last?(body)
+
+        response.options[:block2] = block.encode
+
+        logger.debug block.inspect
+
+        response
+      end
+
+      def basic_env(host, port, request)
+        {
+          REMOTE_ADDR       => host,
+          REMOTE_PORT       => port.to_s,
+          REQUEST_METHOD    => coap_to_http_method(request.mcode),
+          SCRIPT_NAME       => EMPTY_STRING,
+          PATH_INFO         => path_encode(request.options[:uri_path]),
+          QUERY_STRING      => query_encode(request.options[:uri_query])
+                                  .gsub(/^\?/, ''),
+          SERVER_NAME       => @host,
+          SERVER_PORT       => @port.to_s,
+          CONTENT_LENGTH    => request.payload.size.to_s,
+          CONTENT_TYPE      => CONTENT_TYPE_JSON,
+          HTTP_ACCEPT       => CONTENT_TYPE_JSON,
+          RACK_VERSION      => [1, 2],
+          RACK_URL_SCHEME   => RACK_URL_SCHEME_HTTP,
+          RACK_INPUT        => StringIO.new(request.payload),
+          RACK_ERRORS       => $stderr,
+          RACK_MULTITHREAD  => true,
+          RACK_MULTIPROCESS => true,
+          RACK_RUN_ONCE     => false,
+          RACK_LOGGER       => @logger,
+        }
+      end
+
+      def initialize_response(request)
+        type = request.tt == :con ? :ack : :non
+
+        CoAP::Message.new \
+          tt: type,
+          mcode: 2.00,
+          mid: request.mid,
+          token: request.options[:token]
+      end
+    end
+  end
+end

data/lib/david/server/utility.rb

@@ -0,0 +1,19 @@
+module David
+  class Server
+    module Utility
+      protected
+
+      # This can only use each on body and currently does not support streaming.
+      def body_to_string(body)
+        s = ''
+        body.each { |line| s += line + "\r\n" }
+        s.chomp
+      end
+
+      def content_type(options)
+        ct = options['Content-Type']
+        ct.split(';').first unless ct.nil?
+      end
+    end
+  end
+end