david 0.3.0.pre → 0.3.0

data/lib/david/server/options.rb

@@ -7,6 +7,10 @@ module David
         send(('choose_' + name.to_s).to_sym, value)
       end
 
+      def choose_block(value)
+        default_to_true(:block, value)
+      end
+
       def choose_cbor(value)
         if value.nil? && defined? Rails
           value = Rails.application.config.coap.cbor
@@ -15,6 +19,14 @@ module David
         !!value
       end
 
+      def choose_default_format(value)
+        if value.nil? && defined? Rails
+          value = Rails.application.config.coap.default_format
+        end
+
+        value.nil? ? 'application/json' : value
+      end
+
       # Rails starts on 'localhost' since 4.2.0.beta1
       # (Resolv class seems not to consider /etc/hosts)
       def choose_host(value)
@@ -42,6 +54,26 @@ module David
 
         logger
       end
+
+      def choose_mcast(value)
+        default_to_true(:multicast, value)
+      end
+
+      def choose_observe(value)
+        default_to_true(:observe, value)
+      end
+
+      def default_to_true(key, value)
+        if value.nil? && defined? Rails
+          value = Rails.application.config.coap.send(key)
+        end
+
+        return true if value.nil? || value.to_s == 'true'
+
+        false
+      end
+
+      module_function :default_to_true
     end
   end
 end

data/lib/david/server/respond.rb

@@ -0,0 +1,146 @@
+require 'david/server/constants'
+require 'david/server/mapping'
+require 'david/server/utility'
+
+module David
+  class Server
+    module Respond
+      include Constants
+      include Mapping
+      include Utility
+
+      def respond(request, env = nil)
+        block_enabled = @block && request.get?
+
+        if block_enabled
+          # Fail if m set.
+          if request.block.more && !request.multicast?
+            return error(request, 4.05)
+          end
+        end
+
+        return error(request, 5.05) if request.proxy?
+
+        env ||= basic_env(request)
+
+        code, headers, body = @app.call(env)
+
+        # No error responses on multicast requests.
+        return if request.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'
+          begin
+            body = body_to_cbor(body)
+            ct = CONTENT_TYPE_CBOR
+          rescue JSON::ParserError
+          end
+        end
+
+        # No response on request for non-existent block.
+        return if block_enabled && !request.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
+
+        response = initialize_response(request, 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)
+          response.options[:observe] = 0
+        end
+
+        if block_enabled
+          block = request.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
+
+        [response, {}]
+      end
+
+      private
+
+      def basic_env(request)
+        m = request.message
+
+        {
+          REMOTE_ADDR       => request.host,
+          REMOTE_PORT       => request.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,
+          CONTENT_LENGTH    => m.payload.bytesize.to_s,
+          CONTENT_TYPE      => EMPTY_STRING,
+          HTTP_ACCEPT       => accept_to_http(request),
+          RACK_VERSION      => [1, 2],
+          RACK_URL_SCHEME   => RACK_URL_SCHEME_HTTP,
+          RACK_INPUT        => StringIO.new(m.payload),
+          RACK_ERRORS       => $stderr,
+          RACK_MULTITHREAD  => true,
+          RACK_MULTIPROCESS => true,
+          RACK_RUN_ONCE     => false,
+          RACK_LOGGER       => @logger,
+          COAP_VERSION      => 1,
+          COAP_MULTICAST    => request.multicast?,
+          COAP_DTLS         => COAP_DTLS_NOSEC,
+          COAP_DTLS_ID      => EMPTY_STRING,
+        }
+      end
+
+      def error(request, mcode)
+        [initialize_response(request, mcode), retransmit: false]
+      end
+
+      def handle_observe(request, env, etag)
+        return unless request.get? && request.observe?
+
+        if request.message.options[:observe] == 0
+          observe.add(request, env, etag)
+          true
+        else
+          observe.delete(request)
+          false
+        end
+      end
+
+      def initialize_response(request, mcode = 2.00)
+        type = request.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]
+      end
+    end
+  end
+end

data/lib/david/server/utility.rb

@@ -6,14 +6,9 @@ module David
       # 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" }
+        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

data/lib/david/show_exceptions.rb

@@ -0,0 +1,52 @@
+module David
+  class ShowExceptions
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      dup._call(env)
+    end
+
+    def _call(env)
+      @app.call(env)
+    rescue Exception => exception
+      if env['action_dispatch.show_exceptions'] == false
+        raise exception
+      end
+
+      @env = env
+
+      render_exception(exception)
+    end
+
+    private
+
+    def render_exception(exception)
+      body = {
+        error: exception.class.to_s,
+        message: exception.message
+      }
+
+      log(:info, [body[:error], body[:message]].join("\n"))
+      
+      body = body.to_json
+
+      code = 500
+      code = 404 if exception.is_a?(ActiveRecord::RecordNotFound)
+
+      [code,
+        {
+          'Content-Type' => 'application/json',
+          'Content-Length' => body.bytesize.to_s
+        },
+        [body]
+      ]
+    end
+
+    def log(level, message)
+      @logger ||= @env['rack.logger']
+      @logger.send(level, message) if @logger
+    end
+  end
+end

data/lib/david/version.rb

@@ -2,6 +2,7 @@ module David
   MAJOR = 0
   MINOR = 3
   PATCH = 0
+  SUFFIX = nil
 
-  VERSION = [MAJOR, MINOR, PATCH, 'pre'].join('.').freeze
+  VERSION = [MAJOR, MINOR, PATCH, SUFFIX].compact.join('.')
 end

data/lib/rack/handler/david.rb

@@ -9,12 +9,18 @@ module Rack
       def self.run(app, options={})
         options = DEFAULT_OPTIONS.merge(options)
 
-        supervisor = ::David::Server.supervise_as(:david, app, options)
+        g = Celluloid::SupervisionGroup.run!
+
+        g.supervise_as(:server, ::David::Server, app, options)
+        g.supervise_as(:observe, ::David::Observe) if options[:Observe] != false
+        g.supervise_as(:gc, ::David::GarbageCollector)
 
         begin
           sleep
         rescue Interrupt
-          supervisor.terminate
+          Celluloid.logger.info 'Terminated'
+          Celluloid.logger = nil
+          g.terminate
         end
       end
 
@@ -22,10 +28,14 @@ module Rack
         host, port = DEFAULT_OPTIONS.values_at(:Host, :Port)
 
         {
-          'Host=HOST'     => "Hostname to listen on (default: #{host})",
-          'Port=PORT'     => "Port to listen on (default: #{port})",
-          'CBOR=BOOLEAN'  => 'Transparent JSON/CBOR conversion.',
-          'Log=LOG'       => 'Change logging (debug|none).'
+          'Block=BOOLEAN'     => 'Support for blockwise transfer (default: true)',
+          'CBOR=BOOLEAN'      => 'Transparent JSON/CBOR conversion (default: false)',
+          'DefaultFormat=F'   => 'Content-Type if CoAP accept option on request is undefined',
+          'Host=HOST'         => "Hostname to listen on (default: #{host})",
+          'Log=LOG'           => 'Change logging (debug|none)',
+          'Multicast=BOOLEAN' => 'Multicast support (default: true)',
+          'Observe=BOOLEAN'   => 'Observe support (default: true)',
+          'Port=PORT'         => "Port to listen on (default: #{port})"
         }
       end
     end

data/lib/rack/hello_world.rb

@@ -17,6 +17,11 @@ module Rack
           {'Content-Type' => 'application/link-format'},
           ['</hello>;rt="hello";ct=0']
         ]
+      when '/echo/accept'
+        [200,
+          {'Content-Type' => env['HTTP_ACCEPT'], 'Content-Length' => '0'},
+          []
+        ]
       when '/hello'
         [200,
           # If Content-Length is not given, Rack assumes chunked transfer.
@@ -37,6 +42,24 @@ module Rack
           {'Content-Type' => 'text/plain'},
           ["#{@@value}"]
         ]
+      when '/block'
+        n = 17
+        [200,
+          {'Content-Type' => 'text/plain', 'Content-Length' => n.to_s},
+          ['+'*n]
+        ]
+      when '/code'
+        [2.05,
+          {'Content-Type' => 'text/plain'},
+          []
+        ]
+      when '/time'
+        # Rack::ETag does not add an ETag header, if response code other than
+        # 200 or 201, so CoAP/Float return codes do not work, here.
+        [200,
+          {'Content-Type' => 'text/plain'},
+          [Time.now.to_s]
+        ]
       else
         [404, {}, ['']]
       end

data/spec/dummy/Rakefile

@@ -0,0 +1,6 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+
+Rails.application.load_tasks

data/spec/dummy/app/assets/javascripts/application.js

@@ -0,0 +1,13 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or vendor/assets/javascripts of plugins, if any, can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// compiled file.
+//
+// Read Sprockets README (https://github.com/sstephenson/sprockets#sprockets-directives) for details
+// about supported directives.
+//
+//= require_tree .

data/spec/dummy/app/assets/stylesheets/application.css

@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or vendor/assets/stylesheets of plugins, if any, can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any styles
+ * defined in the other CSS/SCSS files in this directory. It is generally better to create a new
+ * file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */

data/spec/dummy/app/controllers/application_controller.rb

@@ -0,0 +1,5 @@
+class ApplicationController < ActionController::Base
+  # Prevent CSRF attacks by raising an exception.
+  # For APIs, you may want to use :null_session instead.
+  protect_from_forgery with: :exception
+end

data/spec/dummy/app/helpers/application_helper.rb

@@ -0,0 +1,2 @@
+module ApplicationHelper
+end

data/spec/dummy/app/views/layouts/application.html.erb

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Dummy</title>
+  <%= stylesheet_link_tag    'application', media: 'all', 'data-turbolinks-track' => true %>
+  <%= javascript_include_tag 'application', 'data-turbolinks-track' => true %>
+  <%= csrf_meta_tags %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/spec/dummy/bin/bundle

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile', __FILE__)
+load Gem.bin_path('bundler', 'bundle')

data/spec/dummy/bin/rails

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+APP_PATH = File.expand_path('../../config/application',  __FILE__)
+require_relative '../config/boot'
+require 'rails/commands'

data/spec/dummy/bin/rake

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require_relative '../config/boot'
+require 'rake'
+Rake.application.run