ds9 1.0.0

data/ext/ds9/ds9.h

@@ -0,0 +1,30 @@
+#ifndef DS9_H
+#define DS9_H
+
+#include <ruby.h>
+#include <nghttp2/nghttp2.h>
+
+static const rb_data_type_t ds9_session_type = {
+    "DS9/session",
+    {0, (void (*)(void *))nghttp2_session_del, 0,},
+    0, 0,
+#ifdef RUBY_TYPED_FREE_IMMEDIATELY
+    RUBY_TYPED_FREE_IMMEDIATELY,
+#endif
+};
+
+static const rb_data_type_t ds9_callbacks_type = {
+    "DS9/callbacks",
+    {0, (void (*)(void *))nghttp2_session_callbacks_del, 0,},
+    0, 0,
+#ifdef RUBY_TYPED_FREE_IMMEDIATELY
+    RUBY_TYPED_FREE_IMMEDIATELY,
+#endif
+};
+
+void Init_ds9_client(VALUE mDS9, VALUE cDS9Session);
+void Init_ds9_frames(VALUE mDS9);
+VALUE WrapDS9Frame(const nghttp2_frame *frame);
+VALUE WrapDS9FrameHeader(const nghttp2_frame_hd *hd);
+
+#endif

data/ext/ds9/ds9_frames.c

@@ -0,0 +1,164 @@
+#include <ds9.h>
+
+VALUE mDS9Frames;
+
+VALUE cDS9FramesFrame;
+VALUE mDS9FramesFlags;
+VALUE cDS9FramesData;
+VALUE cDS9FramesHeaders;
+VALUE cDS9FramesPriority;
+VALUE cDS9FramesRstStream;
+VALUE cDS9FramesSettings;
+VALUE cDS9FramesPushPromise;
+VALUE cDS9FramesPing;
+VALUE cDS9FramesGoaway;
+VALUE cDS9FramesWindowUpdate;
+VALUE cDS9FramesContinuation;
+
+static const rb_data_type_t ds9_frame_type = {
+    "DS9/frame",
+    {0, xfree, 0,},
+    0, 0,
+#ifdef RUBY_TYPED_FREE_IMMEDIATELY
+    RUBY_TYPED_FREE_IMMEDIATELY,
+#endif
+};
+
+static VALUE frame_type_class(nghttp2_frame *frame)
+{
+    switch(frame->hd.type) {
+	case NGHTTP2_DATA: return cDS9FramesData;
+	case NGHTTP2_HEADERS: return cDS9FramesHeaders;
+	case NGHTTP2_PRIORITY: return cDS9FramesPriority;
+	case NGHTTP2_RST_STREAM: return cDS9FramesRstStream;
+	case NGHTTP2_SETTINGS: return cDS9FramesSettings;
+	case NGHTTP2_PUSH_PROMISE: return cDS9FramesPushPromise;
+	case NGHTTP2_PING: return cDS9FramesPing;
+	case NGHTTP2_GOAWAY: return cDS9FramesGoaway;
+	case NGHTTP2_WINDOW_UPDATE: return cDS9FramesWindowUpdate;
+	case NGHTTP2_CONTINUATION: return cDS9FramesContinuation;
+	default: return cDS9FramesFrame;
+    }
+}
+
+VALUE WrapDS9FrameHeader(const nghttp2_frame_hd *hd)
+{
+    VALUE klass = rb_const_get(cDS9FramesFrame, rb_intern("Header"));
+    return rb_funcall(klass, rb_intern("new"), 4,
+	    INT2NUM(hd->length),
+	    INT2NUM(hd->stream_id),
+	    INT2NUM(hd->type),
+	    INT2NUM(hd->flags));
+}
+
+VALUE WrapDS9Frame(const nghttp2_frame *frame)
+{
+    /* dup the frame so Ruby can manage the struct's memory */
+    nghttp2_frame *dup = xmalloc(sizeof(nghttp2_frame));
+    memcpy(dup, frame, sizeof(nghttp2_frame));
+
+    return TypedData_Wrap_Struct(frame_type_class(dup), &ds9_frame_type, dup);
+}
+
+static VALUE frame_stream_id(VALUE self)
+{
+    nghttp2_frame *frame;
+    TypedData_Get_Struct(self, nghttp2_frame, &ds9_frame_type, frame);
+
+    return INT2NUM(frame->hd.stream_id);
+}
+
+static VALUE frame_type(VALUE self)
+{
+    nghttp2_frame *frame;
+    TypedData_Get_Struct(self, nghttp2_frame, &ds9_frame_type, frame);
+
+    return INT2NUM(frame->hd.type);
+}
+
+static VALUE frame_flags(VALUE self)
+{
+    nghttp2_frame *frame;
+    TypedData_Get_Struct(self, nghttp2_frame, &ds9_frame_type, frame);
+
+    return INT2NUM(frame->hd.flags);
+}
+
+static VALUE promised_stream_id(VALUE self)
+{
+    nghttp2_frame *frame;
+    TypedData_Get_Struct(self, nghttp2_frame, &ds9_frame_type, frame);
+
+    return INT2NUM(frame->push_promise.promised_stream_id);
+}
+
+static VALUE frame_header(VALUE self)
+{
+    nghttp2_frame *frame;
+    TypedData_Get_Struct(self, nghttp2_frame, &ds9_frame_type, frame);
+
+    return WrapDS9FrameHeader((nghttp2_frame_hd *)frame);
+}
+
+static VALUE header_category(VALUE self)
+{
+    nghttp2_frame *frame;
+    TypedData_Get_Struct(self, nghttp2_frame, &ds9_frame_type, frame);
+
+    return INT2NUM(frame->headers.cat);
+}
+
+void Init_ds9_frames(VALUE mDS9)
+{
+    mDS9Frames = rb_define_module_under(mDS9, "Frames");
+    cDS9FramesFrame = rb_define_class_under(mDS9Frames, "Frame", rb_cData);
+
+    mDS9FramesFlags = rb_define_module_under(cDS9FramesFrame, "Flags");
+
+    cDS9FramesData = rb_define_class_under(mDS9Frames, "Data", cDS9FramesFrame);
+    cDS9FramesHeaders = rb_define_class_under(mDS9Frames, "Headers", cDS9FramesFrame);
+    cDS9FramesPriority = rb_define_class_under(mDS9Frames, "Priority", cDS9FramesFrame);
+    cDS9FramesRstStream = rb_define_class_under(mDS9Frames, "RstStream", cDS9FramesFrame);
+    cDS9FramesSettings = rb_define_class_under(mDS9Frames, "Settings", cDS9FramesFrame);
+    cDS9FramesPushPromise = rb_define_class_under(mDS9Frames, "PushPromise", cDS9FramesFrame);
+    cDS9FramesPing = rb_define_class_under(mDS9Frames, "Ping", cDS9FramesFrame);
+    cDS9FramesGoaway = rb_define_class_under(mDS9Frames, "Goaway", cDS9FramesFrame);
+    cDS9FramesWindowUpdate = rb_define_class_under(mDS9Frames, "WindowUpdate", cDS9FramesFrame);
+    cDS9FramesContinuation = rb_define_class_under(mDS9Frames, "Continuation", cDS9FramesFrame);
+
+    rb_define_method(cDS9FramesFrame, "stream_id", frame_stream_id, 0);
+    rb_define_method(cDS9FramesFrame, "type", frame_type, 0);
+    rb_define_method(cDS9FramesFrame, "flags", frame_flags, 0);
+    rb_define_method(cDS9FramesFrame, "header", frame_header, 0);
+    rb_define_method(cDS9FramesPushPromise, "promised_stream_id", promised_stream_id, 0);
+    rb_define_method(cDS9FramesHeaders, "category", header_category, 0);
+
+    rb_define_const(mDS9FramesFlags, "NONE", INT2NUM(NGHTTP2_FLAG_NONE));
+    rb_define_const(mDS9FramesFlags, "END_STREAM", INT2NUM(NGHTTP2_FLAG_END_STREAM));
+    rb_define_const(mDS9FramesFlags, "END_HEADERS", INT2NUM(NGHTTP2_FLAG_END_HEADERS));
+    rb_define_const(mDS9FramesFlags, "ACK", INT2NUM(NGHTTP2_FLAG_ACK));
+    rb_define_const(mDS9FramesFlags, "PADDED", INT2NUM(NGHTTP2_FLAG_PADDED));
+    rb_define_const(mDS9FramesFlags, "PRIORITY", INT2NUM(NGHTTP2_FLAG_PRIORITY));
+
+    rb_define_const(cDS9FramesGoaway, "NO_ERROR", INT2NUM(NGHTTP2_NO_ERROR));
+    rb_define_const(cDS9FramesGoaway, "PROTOCOL_ERROR", INT2NUM(NGHTTP2_PROTOCOL_ERROR));
+    rb_define_const(cDS9FramesGoaway, "INTERNAL_ERROR", INT2NUM(NGHTTP2_INTERNAL_ERROR));
+    rb_define_const(cDS9FramesGoaway, "FLOW_CONTROL_ERROR", INT2NUM(NGHTTP2_FLOW_CONTROL_ERROR));
+    rb_define_const(cDS9FramesGoaway, "SETTINGS_TIMEOUT", INT2NUM(NGHTTP2_SETTINGS_TIMEOUT));
+    rb_define_const(cDS9FramesGoaway, "STREAM_CLOSED", INT2NUM(NGHTTP2_STREAM_CLOSED));
+    rb_define_const(cDS9FramesGoaway, "FRAME_SIZE_ERROR", INT2NUM(NGHTTP2_FRAME_SIZE_ERROR));
+    rb_define_const(cDS9FramesGoaway, "REFUSED_STREAM", INT2NUM(NGHTTP2_REFUSED_STREAM));
+    rb_define_const(cDS9FramesGoaway, "CANCEL", INT2NUM(NGHTTP2_CANCEL));
+    rb_define_const(cDS9FramesGoaway, "COMPRESSION_ERROR", INT2NUM(NGHTTP2_COMPRESSION_ERROR));
+    rb_define_const(cDS9FramesGoaway, "CONNECT_ERROR", INT2NUM(NGHTTP2_CONNECT_ERROR));
+    rb_define_const(cDS9FramesGoaway, "ENHANCE_YOUR_CALM", INT2NUM(NGHTTP2_ENHANCE_YOUR_CALM));
+    rb_define_const(cDS9FramesGoaway, "INADEQUATE_SECURITY", INT2NUM(NGHTTP2_INADEQUATE_SECURITY));
+    rb_define_const(cDS9FramesGoaway, "HTTP_1_1_REQUIRED", INT2NUM(NGHTTP2_HTTP_1_1_REQUIRED));
+
+    rb_define_const(cDS9FramesHeaders, "REQUEST", INT2NUM(NGHTTP2_HCAT_REQUEST));
+    rb_define_const(cDS9FramesHeaders, "RESPONSE", INT2NUM(NGHTTP2_HCAT_RESPONSE));
+    rb_define_const(cDS9FramesHeaders, "PUSH_RESPONSE", INT2NUM(NGHTTP2_HCAT_PUSH_RESPONSE));
+    rb_define_const(cDS9FramesHeaders, "HEADERS", INT2NUM(NGHTTP2_HCAT_HEADERS));
+}
+
+/* vim: set noet sws=4 sw=4: */

data/ext/ds9/extconf.rb

@@ -0,0 +1,16 @@
+require 'mkmf'
+
+if with_config("static")
+  ldflags = pkg_config 'libnghttp2', 'libs-only-L'
+
+  archive = File.join ldflags.sub(/^-L/, ''), 'libnghttp2.a'
+  if File.exist? archive
+    $LDFLAGS << " #{archive}"
+  else
+    raise "couldn't find archive"
+  end
+else
+  pkg_config 'libnghttp2'
+end
+
+create_makefile 'ds9'

data/lib/ds9.rb

@@ -0,0 +1,106 @@
+require 'ds9.so'
+
+module DS9
+  VERSION = '1.0.0'
+
+  module Frames
+    class Frame
+      Header = Struct.new :length, :stream_id, :type, :flags
+
+      def length
+        header.length
+      end
+
+      def settings?; false; end
+      def headers?;  false; end
+      def data?;     false; end
+      def push_promise?; false; end
+      def priority?; false; end
+      def rst_stream?; false; end
+      def ping?; false; end
+      def goaway?; false; end
+      def window_update?; false; end
+      def continuation?; false; end
+
+      def end_stream?
+        flags & Flags::END_STREAM > 0
+      end
+    end
+
+    class Continuation
+      def continuation?; true; end
+    end
+    class WindowUpdate
+      def window_update?; true; end
+    end
+
+    class Goaway
+      def goaway?; true; end
+    end
+
+    class Ping
+      def ping?; true; end
+    end
+
+    class Priority
+      def priority?; true; end
+    end
+
+    class RstStream
+      def rst_stream?; true; end
+    end
+
+    class PushPromise
+      def push_promise?; true; end
+    end
+
+    class Data
+      def data?;     true; end
+    end
+
+    class Settings
+      def settings?; true; end
+    end
+
+    class Headers
+      def headers?; true; end
+      def request?;       category == REQUEST; end
+      def response?;      category == RESPONSE; end
+      def push_response?; category == PUSH_RESPONSE; end
+    end
+  end
+
+  class Session
+    def initialize
+      cbs = make_callbacks
+      init_internals cbs
+    end
+
+    private
+
+    def send_event string
+      raise NotImplementedError
+    end
+
+    def on_data_source_read stream_id, length
+      raise NotImplementedError
+    end
+
+    def recv_event length
+      raise NotImplementedError
+    end
+  end
+
+  class Exception < StandardError
+    def self.abort code
+      raise new(to_string(code), code)
+    end
+
+    attr_reader :code
+
+    def initialize str, code
+      @code = code
+      super(str)
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,201 @@
+require 'minitest/autorun'
+require 'ds9'
+require 'io/wait'
+require 'thread'
+require 'stringio'
+
+Thread.abort_on_exception = true
+
+trap("INFO") {
+  Thread.list.each do |k|
+    puts "#" * 90
+    puts k.backtrace
+    puts "#" * 90
+  end
+}
+
+module DS9
+  class TestCase < Minitest::Test
+    def pipe &block
+      rd1, wr1 = IO.pipe
+      rd2, wr2 = IO.pipe
+
+      server = Server.new rd1, wr2, block
+      server.submit_settings [
+        [DS9::Settings::MAX_CONCURRENT_STREAMS, 100],
+      ]
+
+      client = Client.new rd2, wr1, Queue.new
+      client.submit_settings [
+        [DS9::Settings::MAX_CONCURRENT_STREAMS, 100],
+        [DS9::Settings::INITIAL_WINDOW_SIZE, 65535],
+      ]
+      [server, client]
+    end
+
+    module IOEvents
+      attr_reader :reader, :writer
+
+      def initialize reader, writer
+        @reader = reader
+        @writer = writer
+        super()
+      end
+
+      def send_event string
+        writer.write_nonblock string
+      end
+
+      def recv_event length
+        case data = reader.read_nonblock(length, nil, exception: false)
+        when :wait_readable
+          DS9::ERR_WOULDBLOCK
+        when nil
+          DS9::ERR_EOF
+        else
+          data
+        end
+      rescue IOError
+        DS9::ERR_EOF
+      end
+
+      def run
+        while want_read? || want_write?
+          if want_write?
+            @writer.wait_writable 0.1
+            send
+          end
+
+          if want_read?
+            @reader.wait_readable 0.1
+            receive
+          end
+        end
+      end
+    end
+
+    class Client < DS9::Client
+      include IOEvents
+
+      class Response
+        attr_reader :stream_id, :body
+
+        def initialize stream_id
+          @stream_id = stream_id
+          @headers   = {}
+          @body      = StringIO.new
+        end
+
+        def [] k; @headers[k]; end
+        def []= k, v; @headers[k] = v; end
+      end
+
+      attr_reader :responses, :response_queue, :frames
+
+      def initialize read, write, response_queue
+        @response_streams = {}
+        @responses        = response_queue
+        @frames           = []
+        super(read, write)
+      end
+
+      def on_frame_recv frame
+        @frames << frame
+      end
+
+      def on_begin_headers frame
+        @response_streams[frame.stream_id] = Response.new(frame.stream_id)
+      end
+
+      def on_header name, value, frame, flags
+        @response_streams[frame.stream_id][name] = value
+      end
+
+      def on_stream_close id, err
+        @responses << @response_streams.delete(id)
+      end
+
+      def on_data_chunk_recv stream_id, data, flags
+        @response_streams[stream_id].body << data
+      end
+
+      def terminate_session err
+        super
+        @responses << nil
+      end
+    end
+
+    class Server < DS9::Server
+      include IOEvents
+
+      def initialize read, write, app
+        @app           = app
+        @read_streams  = {}
+        @write_streams = {}
+        super(read, write)
+      end
+
+      def before_frame_send frame
+      end
+
+      def on_begin_headers frame
+        @read_streams[frame.stream_id] = []
+      end
+
+      def on_data_source_read stream_id, length
+        @write_streams[stream_id].body.shift
+      end
+
+      def on_stream_close id, error_code
+        @read_streams.delete id
+        @write_streams.delete id
+      end
+
+      def submit_push_promise stream_id, headers
+        response = Response.new(self, super(stream_id, headers), [])
+        request = Request.new(self, stream_id, Hash[headers])
+        @app.call request, response
+        @write_streams[response.stream_id] = response
+      end
+
+      def on_header name, value, frame, flags
+        @read_streams[frame.stream_id] << [name, value]
+      end
+
+      class Request < Struct.new :stream, :stream_id, :headers
+        def path
+          headers[':path']
+        end
+      end
+
+      class Response < Struct.new :stream, :stream_id, :body
+        def push headers
+          stream.submit_push_promise stream_id, headers
+        end
+
+        def submit_response headers
+          stream.submit_response stream_id, headers
+        end
+
+        def finish str
+          body << str
+          body << nil
+        end
+      end
+
+      def on_frame_recv frame
+        return unless frame.headers?
+
+        req_headers = @read_streams[frame.stream_id]
+
+        response = Response.new(self, frame.stream_id, [])
+        request = Request.new(self, frame.stream_id, Hash[req_headers])
+
+        @app.call request, response
+
+        @write_streams[frame.stream_id] = response
+      end
+
+    end
+  end
+end