riddl 1.0.16 → 1.0.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e69bd3fbaa637fa772cb4be483543ea4add9a415688d76c39a01aa3cc627f31e
-  data.tar.gz: 9750596f66325159bc58d156cb1ff71e7fa6b862034d8bf6de25a5f3960a165d
+  metadata.gz: 6ca83f5fe99631dcde4aaa4ad94204809098fd7b23c500c6dc5b46cd065c7759
+  data.tar.gz: 78f8b8be0e7063354fbf1242dad5daf1f0302bd39cce9953fec99c2ed7c5a8f8
 SHA512:
-  metadata.gz: 06f71177f1844c68b56a2c5a022882304f1932b5c21b961cf89dc1ff13f8c4338bc1c196d72e454035cbafd4acaaaaba4ddb41e0d9693dde0a9d8e1c8b090b1e
-  data.tar.gz: fd9102d88a796ccb51f4cb881dc7694d04570b4159c80c5e0a4f5e99b8294b999bc01ec6329e8bbfbd5565eb19e9d991f7b6a8042e3d4b18d3e301417f08bab5
+  metadata.gz: 6563f7de6527989c4cd6f7a6dbb225ebd9da1ed9c593dcf355df00c90fbb5d80060972248eaebebdfe692ffd95dfbf5885ad70629ed1717bd7a1a95745090eab
+  data.tar.gz: a21e42d70f98fedd372a5911e007d23e2426a4a6d4406b2a8ac3ff26bdb565d2ec8e82558a7770286fb8b8fa7c8997d3b79981d9cb91662343345196e02afb56

data/examples/library/server.rb

@@ -36,6 +36,7 @@ end
 
 Riddl::Server.new(File.dirname(__FILE__) + '/description.xml', :port => 9001, :bind => '::') do
   accessible_description true
+  p @riddl_logger
 
   on resource do
     run Riddl::Utils::ERBServe, "static/info.txt"  if get

data/examples/sse/server.rb

@@ -4,26 +4,29 @@ require File.expand_path(File.dirname(__FILE__) + '/../../lib/ruby/riddl/server'
 
 class Bar < Riddl::Implementation
   def response
-    $connections.each do |c|
-      c.send('some data')
+    $connections_mutex.synchronize do
+      $connections.each do |c|
+        c.send('some data')
+      end
     end
     Riddl::Parameter::Complex.new("return","text/plain","hello world")
   end
 end
 
 $connections = []
+$connections_mutex = Mutex.new
 
 class Echo < Riddl::SSEImplementation
   def onopen
     # if true (or any object for that matter) is returned, then 200 is sent
     # if false (or nil) is returned 404, the sse is denied
     puts "Connection established"
-    $connections << self
+    $connections_mutex.synchronize { $connections << self }
   end
 
   def onclose
     puts "Connection closed"
-    $connections.delete(self)
+    $connections_mutex.synchronize { $connections.delete(self) }
   end
 end
 
@@ -32,8 +35,10 @@ Riddl::Server.new(File.dirname(__FILE__) + '/description.xml', :port => 9292) do
 
   parallel do
     loop do
-      $connections.each do |c|
-        c.send('heartbeat')
+      $connections_mutex.synchronize do
+        $connections.each do |c|
+          c.send('heartbeat')
+        end
       end
       sleep 15
     end

data/lib/ruby/riddl/ns/description/1.0/description.rng

@@ -14,21 +14,23 @@
       <data type="anyURI"/>
     </attribute>
     <ref name="riddl-description-other-atts"/>
-    <zeroOrMore>
-      <choice>
-        <element name="message">
-          <ref name="riddl-description-other-atts"/>
-          <ref name="riddl-message"/>
-        </element>
-        <element name="transformation">
-          <ref name="riddl-description-other-atts"/>
-          <ref name="riddl-transformation"/>
-        </element>
-      </choice>
-    </zeroOrMore>
-    <element name="resource">
-      <ref name="riddl-resource-dynamic"/>
-    </element>
+    <interleave>
+      <zeroOrMore>
+        <choice>
+          <element name="message">
+            <ref name="riddl-description-other-atts"/>
+            <ref name="riddl-message"/>
+          </element>
+          <element name="transformation">
+            <ref name="riddl-description-other-atts"/>
+            <ref name="riddl-transformation"/>
+          </element>
+        </choice>
+      </zeroOrMore>
+      <element name="resource">
+        <ref name="riddl-resource-dynamic"/>
+      </element>
+    </interleave>
   </define>
 
   <define name="riddl-message">
@@ -199,7 +201,6 @@
         <data type="anyURI"/>
       </attribute>
     </optional>
-    <ref name="riddl-description-others"/>
   </define>
 
   <define name="riddl-resource-recursive-choice">
@@ -222,21 +223,28 @@
         <data type="boolean"/>
       </attribute>
     </optional>
-    <ref name="riddl-resource-sub"/>
+  </define>
+
+  <define name="riddl-resource-body">
+    <interleave>
+      <ref name="riddl-description-others"/>
+      <ref name="riddl-resource-content"/>
+      <ref name="riddl-resource-sub"/>
+    </interleave>
   </define>
 
   <define name="riddl-resource-dynamic">
     <ref name="riddl-resource-attributes"/>
-    <ref name="riddl-resource-content"/>
     <ref name="riddl-resource-recursive-choice"/>
+    <ref name="riddl-resource-body"/>
   </define>
   <define name="riddl-resource-named">
     <ref name="riddl-resource-attributes"/>
     <attribute name="relative">
       <ref name="riddl-datatype-relpath"/>
     </attribute>
-    <ref name="riddl-resource-content"/>
     <ref name="riddl-resource-recursive-choice"/>
+    <ref name="riddl-resource-body"/>
   </define>
 
   <define name="riddl-resource-sub">

data/lib/ruby/riddl/protocols/http/generator.rb

@@ -18,7 +18,8 @@ module Riddl
             if part.respond_to?(:read)
               part.rewind if part.respond_to?(:rewind)
               while chunk = part.read(CHUNK_SIZE)
-              yield chunk
+                yield chunk
+              end
             else
               yield part.to_s
             end

data/lib/ruby/riddl/protocols/sse.rb

@@ -1,72 +1,168 @@
 module Riddl
   module Protocols
-    class SSE
+    module SSE
       class Error < RuntimeError; end
 
       class ParserData
         attr_accessor :headers, :request_path, :query_string, :http_method, :body, :request_url
       end
 
-      class DeferrableBody
-				include EventMachine::Deferrable
+      class Base #{{{
+        def initialize(app, env)
+          @app = app
+          @env = env
+          @closed = true
+        end
 
-				def call(body)
-					body.each do |chunk|
-						@body_callback.call(chunk)
-					end
-				end
+        def send_with_id(id, data)
+          return if closed?
+          push("#{id}: #{data}" + EOL + EOL)
+        end
 
-				def each(&blk)
-					@body_callback = blk
-				end
-			end
+        def close
+          return if closed?
+          @closed = true
+          do_close
+        end
 
-      def send_with_id(id, data)
-        EM.next_tick do
-          @body.call [ "#{id}: #{data}" + EOL + EOL ]
+        def closed?
+          @closed
         end
-      end
 
-      def close
-        EM.next_tick do
-          @body.succeed
+        def trigger_on_open;  @closed = false; res = @app.onopen; res ? true : false; end
+        def trigger_on_close; @closed = true;  @app.onclose;                          end
+
+        def response_headers(cross_site_xhr)
+          headers = {
+            'Content-Type' => 'text/event-stream',
+            'Cache-Control' => 'no-cache',
+            'X-Accel-Buffering' => 'no'
+          }
+          if @env['HTTP_ORIGIN'] && cross_site_xhr
+            headers['Access-Control-Allow-Origin'] = '*'
+            headers['Access-Control-Max-Age'] = '0'
+          end
+          headers
         end
-      end
+        protected :response_headers
+      end #}}}
 
-      def trigger_on_open(); @closed = false; res = @app.onopen; res ? true : false; end
-      def trigger_on_close;  @closed = true;  @app.onclose; end
+      class Thin < Base #{{{
+        class DeferrableBody #{{{
+          include EventMachine::Deferrable
 
-      def initialize(app, env)
-        @app = app
-        @env = env
-        @env['async.close'].callback { trigger_on_close }
-				@body = DeferrableBody.new
-        @closed = true
-      end
+          def call(body)
+            body.each { |chunk| @body_callback.call(chunk) }
+          end
+
+          def each(&blk)
+            @body_callback = blk
+          end
+        end #}}}
+
+        def initialize(app, env)
+          super
+          @env['async.close'].callback { trigger_on_close }
+          @body = DeferrableBody.new
+        end
+
+        def dispatch(data, cross_site_xhr)
+          headers = response_headers(cross_site_xhr)
+          EventMachine::next_tick {
+            if trigger_on_open
+              @env['async.callback'].call [200, headers, @body]
+            else
+              @body.fail
+              @env['async.callback'].call [404, headers, {}]
+            end
+          }
+          nil
+        end
+
+        def push(str)
+          EM.next_tick { @body.call [str] }
+        end
+        protected :push
+
+        def do_close
+          EM.next_tick { @body.succeed }
+        end
+        protected :do_close
+      end #}}}
 
+      class Generic < Base # other servers like PUMA
+        class QueueBody #{{{
+          def initialize
+            @queue = Queue.new
+            @on_close = nil
+            @closed_fired = false
+          end
+
+          def on_close(&blk)
+            @on_close = blk
+          end
+
+          def call(chunk)
+            Array(chunk).each { |c| @queue << chunk_encode(c) }
+          end
 
-      def dispatch(data,cross_site_xhr)
-        headers = {
-          'Content-Type' => 'text/event-stream',
-          'Cache-Control' => 'no-cache',
-          'X-Accel-Buffering' => 'no'
-        }
-        if @env['HTTP_ORIGIN'] && cross_site_xhr
-          headers['Access-Control-Allow-Origin'] = '*'
-          headers['Access-Control-Max-Age'] = '0'
+          def each
+            loop do
+              chunk = @queue.pop
+              break if chunk.nil?
+              begin
+                yield chunk
+              rescue IOError, Errno::EPIPE, Errno::ECONNRESET
+                break
+              end
+            end
+          ensure
+            fire_on_close
+          end
+
+          def close
+            @queue << "0#{EOL}#{EOL}"
+            @queue << nil
+          end
+
+          def chunk_encode(c)
+            c.bytesize.to_s(16) + EOL + c + EOL
+          end
+          private :chunk_encode
+
+          def fire_on_close
+            return if @closed_fired
+            @closed_fired = true
+            @on_close.call if @on_close
+          end
+          private :fire_on_close
+        end #}}}
+
+        def initialize(app, env)
+          super
+          @body = QueueBody.new
+          @body.on_close { trigger_on_close }
         end
-				EventMachine::next_tick {
+
+        def dispatch(data, cross_site_xhr)
+          headers = response_headers(cross_site_xhr).merge('Transfer-Encoding' => 'chunked')
           if trigger_on_open
-            @env['async.callback'].call [200, headers, @body]
+            [200, headers, @body]
           else
-            @body.fail
-            @env['async.callback'].call [404, headers, {}]
+            @body.close
+            [404, headers, []]
           end
-				}
-      end
+        end
+
+        def push(str)
+          @body.call [str]
+        end
+        protected :push
 
-      def closed?
-        @closed
+        def do_close
+          @body.close
+        end
+        protected :do_close
       end
     end
   end

data/lib/ruby/riddl/protocols/websocket.rb

@@ -1,109 +1,44 @@
-gem 'em-websocket', '>= 0.4.0'
-require 'em-websocket'
-require 'thin'
-
-module Thin #{{{
-  class Connection
-    attr_accessor :websocket
-    def websocket?
-      !self.websocket.nil?
-    end
-
-    def pre_process_with_websocket
-      @request.env['thin.connection'] = self
-      pre_process_without_websocket
-    end
-    alias :pre_process_without_websocket :pre_process
-    alias :pre_process :pre_process_with_websocket
-
-    def receive_data_with_websocket(data)
-      if self.websocket?
-        self.websocket.receive_data(data)
-      else
-        receive_data_without_websocket(data)
-      end
-    end
-    alias :receive_data_without_websocket :receive_data
-    alias :receive_data :receive_data_with_websocket
-
-    def unbind_with_websocket
-      if self.websocket?
-        self.websocket.unbind
-      else
-        unbind_without_websocket
-      end
-    end
-    alias :unbind_without_websocket :unbind
-    alias :unbind :unbind_with_websocket
-  end
-end   #}}}
-
-module EventMachine
-  module WebSocket
-    class Handshake
-      def receive_data(data)
-        data.request_url = Riddl::Protocols::Utils::escape(data.request_url)
-        @parser = data
-        @headers = data.headers
-        process(@headers, data.body)
-      end
-    end
-  end
-end
+require 'faye/websocket'
+Faye::WebSocket.load_adapter('thin')
 
 module Riddl
   module Protocols
-    class WebSocket < ::EventMachine::WebSocket::Connection
+    class WebSocket
       class Error < RuntimeError; end
 
-      class ParserData
-        attr_accessor :headers, :request_path, :query_string, :http_method, :body, :request_url
-        def match(what)
-          @body =~ what
-        end
-        def upgrade?
-          true
-        end
-      end
+      def initialize(app, env)
+        @app = app
+        @closed = true
+        @socket = Faye::WebSocket.new(env)
 
-      def self.new(*args)
-        instance = allocate
-        instance.__send__(:initialize, *args)
-        instance
+        @socket.on(:open)    { trigger_on_open }
+        @socket.on(:message) { |event| trigger_on_message(event.data) }
+        @socket.on(:close)   { trigger_on_close }
+        @socket.on(:error)   { |event| trigger_on_error(event.message) }
       end
 
-      def send_data(data)
-        EM.next_tick do
-          @socket.send_data(data) unless closed?
-        end
+      def dispatch
+        @socket.rack_response
       end
 
-      def close_connection(*args)
-        EM.next_tick do
-          unless closed?
-            @socket.close_connection(*args)
-            trigger_on_close
-          end
-        end
+      def send(data)
+        EM.next_tick { @socket.send(data) unless closed? }
       end
 
-      def trigger_on_message(msg);    @app.onmessage(msg);                        end
-      def trigger_on_open(handshake); @closed = false; @app.onopen;               end
-      def trigger_on_close;           @closed = true;  @app.onclose;              end
-      def trigger_on_error(error);    @closed = true;  @app.onerror(error); true; end
-
-      def initialize(app, socket)
-        @app = app
-        @socket = socket
-        @ssl = socket.backend.respond_to?(:ssl?) && socket.backend.ssl?
-        @closed = true
-        socket.websocket = self
-        socket.comm_inactivity_timeout = 0
+      def close_connection
+        EM.next_tick { @socket.close unless closed? }
       end
 
       def closed?
         @closed
       end
+
+      private
+
+      def trigger_on_open;       @closed = false; @app.onopen;    end
+      def trigger_on_message(m); @app.onmessage(m);                end
+      def trigger_on_close;      @closed = true;  @app.onclose;    end
+      def trigger_on_error(msg); @app.onerror(msg);                end
     end
   end
 end