celluloid-eventsource 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9012f0cf1c6f9e95a413556b650d0d1f24a15e81
-  data.tar.gz: ef92620f9f3f0672b3d8ff62e3b2c8a8a8e4366f
+  metadata.gz: 7fbe88d12ab2285c9b866977ade2ab069c5fce76
+  data.tar.gz: 72e75170841864fd4746aad568c17f43e4984c55
 SHA512:
-  metadata.gz: 952e0b75111a6ba5e979680dc3f8a23f4d7fe64620eb48b1df7a5bfc20f58c6721c34ab4d376ec6b5dce1b493b993d093ed886e6739b6e6819b4bfee4b31297e
-  data.tar.gz: db714b09edea419560f31733560b1decdc0995b0626f7a39aba41773c18e81da86a87da4d22d280320856cfc587ef5e306bb856288357656f529e3449a7c255b
+  metadata.gz: b8ad5063fbcbe45581f9c8b53f8f7b4adf25578b4f26a20c56d942b367ff8bdf226e7d8dfbd8a222a6bd3c5986b9c90a54731ee5b924199168ba5b0f6ea6707e
+  data.tar.gz: e5f052c515980ca818b6bbfac1449c22e8f59b423139215b98d31c798cfbc1afeb9b6004766576496f705736afa227a39bbf890b7d78c6dab463cc736dd65318

data/.gitignore

@@ -18,3 +18,4 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+.idea

data/.travis.yml

@@ -3,6 +3,6 @@ language: ruby
 before_install: gem update bundler
 
 rvm:
-  - "1.9.3"
   - "2.0.0"
   - "2.1.0"
+  - "2.2.2"

data/README.md

@@ -4,8 +4,6 @@
 [![Code Climate](https://codeclimate.com/github/Tonkpils/celluloid-eventsource.png)](https://codeclimate.com/github/Tonkpils/celluloid-eventsource)
 [![Build Status](https://travis-ci.org/Tonkpils/celluloid-eventsource.svg?branch=master)](https://travis-ci.org/Tonkpils/celluloid-eventsource)
 
-#### Under Development!! Use at your own risk :)
-
 An EventSource client based off Celluloid::IO.
 
 Specification based on [EventSource](http://www.w3.org/TR/2012/CR-eventsource-20121211/)

data/celluloid-eventsource.gemspec

@@ -21,8 +21,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'celluloid-io', '>= 0.15.0', '<= 0.16.2'
   spec.add_dependency 'http_parser.rb', '~> 0.6.0'
 
-  spec.add_development_dependency "timers"
-  spec.add_development_dependency "reel", '>= 0.5.0'
+  spec.add_development_dependency 'atomic', '~> 1.1.99'
   spec.add_development_dependency "rspec", '~> 3.0.0'
   spec.add_development_dependency "bundler", ">= 1.7.0"
   spec.add_development_dependency "rake", '~> 10.1.0'

data/lib/celluloid/eventsource.rb

@@ -33,6 +33,8 @@ module Celluloid
       @on = { open: ->{}, message: ->(_) {}, error: ->(_) {} }
       @parser = ResponseParser.new
 
+      @chunked = false
+
       yield self if block_given?
 
       async.listen
@@ -53,7 +55,7 @@ module Celluloid
     def listen
       establish_connection
 
-      process_stream
+      chunked? ? process_chunked_stream : process_stream
     rescue IOError
       # Closing the socket during read causes this exception and kills the actor
       # We really don't wan to do anything if the socket is closed.
@@ -82,6 +84,8 @@ module Celluloid
 
     private
 
+    MessageEvent = Struct.new(:type, :data, :last_event_id)
+
     def ssl?
       url.scheme == 'https'
     end
@@ -120,35 +124,6 @@ module Celluloid
       }
     end
 
-    def process_field(line)
-      case line
-      when /^data:(.+)$/
-        @data_buffer << $1.lstrip.concat("\n")
-      when /^id:(.+)$/
-        @last_event_id_buffer = $1.lstrip
-      when /^retry:(\d+)$/
-        @reconnect_timeout = $1.to_i
-      when /^event:(.+)$/
-        @event_type_buffer = $1.lstrip
-      end
-    end
-
-    MessageEvent = Struct.new(:type, :data, :last_event_id)
-
-    def process_event
-      @last_event_id = @last_event_id_buffer
-
-      unless @data_buffer.empty?
-        @data_buffer = @data_buffer.chomp("\n") if @data_buffer.end_with?("\n")
-        event = MessageEvent.new(:message, @data_buffer, @last_event_id)
-        event.type = @event_type_buffer.to_sym unless @event_type_buffer.empty?
-
-        dispatch_event(event)
-      end
-
-      clear_buffers!
-    end
-
     def clear_buffers!
       @data_buffer = ""
       @event_type_buffer = ""
@@ -160,20 +135,84 @@ module Celluloid
       end
     end
 
+    def chunked?
+      @chunked
+    end
+
+    def process_chunked_stream
+      until closed? || @socket.eof?
+        handle_chunked_stream
+      end
+    end
+
     def process_stream
       until closed? || @socket.eof?
         line = @socket.readline
+        line.strip.empty? ? process_event : parse_line(line)
+      end
+    end
+
+    def handle_chunked_stream
+      chunk_header = @socket.readline
+      bytes_to_read = chunk_header.to_i(16)
+      bytes_read = 0
+      while bytes_read < bytes_to_read do
+        line = @socket.readline
+        bytes_read += line.size
+
+        line.strip.empty? ? process_event : parse_line(line)
+      end
+
+      if !line.nil? && line.strip.empty?
+        process_event
+      end
+    end
+
+    def parse_line(line)
+      case line
+      when /^:.*$/
+      when /^(\w+): ?(.*)$/
+        process_field($1, $2)
+      else
+        if chunked? && !@data_buffer.empty?
+          @data_buffer.rstrip!
+          process_field("data", line.rstrip)
+        end
+      end
+    end
+
+    def process_event
+      @last_event_id = @last_event_id_buffer
+
+      return if @data_buffer.empty?
+
+      @data_buffer.chomp!("\n") if @data_buffer.end_with?("\n")
+      event = MessageEvent.new(:message, @data_buffer, @last_event_id)
+      event.type = @event_type_buffer.to_sym unless @event_type_buffer.empty?
+
+      dispatch_event(event)
+    ensure
+      clear_buffers!
+    end
 
-        if line.strip.empty?
-          process_event
-        else
-          process_field(line)
+    def process_field(field_name, field_value)
+      case field_name
+      when "event"
+        @event_type_buffer = field_value
+      when "data"
+        @data_buffer << field_value.concat("\n")
+      when "id"
+        @last_event_id_buffer = field_value
+      when "retry"
+        if /^(?<num>\d+)$/ =~ field_value
+          @reconnect_timeout = num.to_i
         end
       end
     end
 
     def handle_headers(headers)
       if headers['Content-Type'].include?("text/event-stream")
+        @chunked = !headers["Transfer-Encoding"].nil? && headers["Transfer-Encoding"].include?("chunked")
         @ready_state = OPEN
         @on[:open].call
       else

data/lib/celluloid/eventsource/version.rb

@@ -1,5 +1,5 @@
 module Celluloid
   class EventSource
-    VERSION = "0.2.2"
+    VERSION = "0.3.0"
   end
 end

data/spec/celluloid/eventsource_spec.rb

@@ -1,15 +1,23 @@
 require 'spec_helper'
+require 'support/dummy_server'
 
-TIMEOUT = 0.0001
 
+# See: https://html.spec.whatwg.org/multipage/comms.html#event-stream-interpretation
 RSpec.describe Celluloid::EventSource do
-  let(:data) { "foo bar " }
 
-  def with_sse_server
-    server = ServerSentEvents.new
-    yield server
-  ensure
-    server.terminate if server && server.alive?
+  let!(:chunk_size) { DummyServer::CHUNK_SIZE }
+
+  def dummy
+    @dummy ||= DummyServer.new
+  end
+
+  before(:all) do
+    dummy.listen(DummyServer::CONFIG[:BindAddress], DummyServer::CONFIG[:Port])
+    Thread.new { dummy.start }
+  end
+
+  after(:all) do
+    dummy.shutdown
   end
 
   describe '#initialize' do
@@ -33,93 +41,136 @@ RSpec.describe Celluloid::EventSource do
     end
   end
 
-  it "keeps track of last event id" do
-    with_sse_server do |server|
-      @last_event_id = ""
-      ces = Celluloid::EventSource.new("http://localhost:63310") do |conn|
-        conn.on_message { |event| @last_event_id = event.last_event_id }
-      end
+  context 'callbacks' do
 
-      sleep TIMEOUT until ces.connected?
+    let(:future) { Celluloid::Future.new }
+    let(:value_class) { Class.new(Struct.new(:value)) }
 
-      expect { server.broadcast(nil, data); sleep TIMEOUT }.to change { @last_event_id }.to("1")
-    end
-  end
+    describe '#on_open' do
+
+      it 'the client has an opened connection' do
 
-  it "ignores comment ':' lines" do
-    with_sse_server do |server|
-      expect { |event|
-        ces = Celluloid::EventSource.new("http://localhost:63310") do |conn|
-          conn.on_message(&event)
+        Celluloid::EventSource.new(dummy.endpoint) do |conn|
+          conn.on_open do
+            future.signal(value_class.new({ called: true, state: conn.ready_state }))
+            conn.close
+          end
         end
 
-        sleep TIMEOUT until ces.connected?
+        expect(future.value).to eq({ called: true, state: Celluloid::EventSource::OPEN })
+      end
+    end
 
-        server.send_ping
+    describe '#on_error' do
 
-        sleep TIMEOUT
-      }.to_not yield_control
-    end
-  end
+      it 'receives response body through error event' do
 
-  it 'receives data through message event' do
-    with_sse_server do |server|
-      expect { |event|
-        ces = Celluloid::EventSource.new("http://localhost:63310") do |conn|
-          conn.on_message(&event)
+        Celluloid::EventSource.new("#{dummy.endpoint}/error") do |conn|
+          conn.on_error do |error|
+            future.signal(value_class.new({ msg: error, state: conn.ready_state }))
+          end
         end
 
-        sleep TIMEOUT until ces.connected?
+        expect(future.value).to eq({ msg: { status_code: 400, body: '{"msg": "blop"}' },
+                                     state: Celluloid::EventSource::CLOSED })
+      end
+    end
 
-        server.broadcast(nil, data)
+    describe '#on_message' do
 
-        sleep TIMEOUT
-      }.to yield_with_args(Celluloid::EventSource::MessageEvent)
-    end
-  end
+      it 'receives data through message event' do
 
-  it 'receives response body through error event' do
-    with_sse_server do |server|
-      expect { |error|
-        ces = Celluloid::EventSource.new("http://localhost:63310/error") do |conn|
-          conn.on_error(&error)
+        Celluloid::EventSource.new(dummy.endpoint) do |conn|
+          conn.on_message do |message|
+            if '3' == message.last_event_id
+              future.signal(value_class.new({ msg: message, state: conn.ready_state }))
+              conn.close
+            end
+          end
         end
 
-        sleep TIMEOUT until ces.closed?
+        payload = future.value
+        expect(payload[:msg]).to be_a(Celluloid::EventSource::MessageEvent)
+        expect(payload[:msg].type).to eq(:message)
+        expect(payload[:msg].last_event_id).to eq('3')
+        expect(payload[:state]).to eq(Celluloid::EventSource::OPEN)
+      end
 
-      }.to yield_with_args({status_code: 400, body:"blop"})
-    end
-  end
+      it 'ignores lines starting with ":"' do
+        Celluloid::EventSource.new("#{dummy.endpoint}/ping") do |conn|
+          conn.on_message do |message|
+            future.signal(value_class.new({ msg: message, state: conn.ready_state }))
+            conn.close
+          end
+        end
+
+        expect(future.value(3)[:msg].data).to eq('pong')
+      end
 
-  it 'receives response without a body through error event' do
-    with_sse_server do |server|
-      expect { |error|
-        ces = Celluloid::EventSource.new("http://localhost:63310/error/no_body") do |conn|
-          conn.on_error(&error)
+      it "aggregates events properly" do
+        Celluloid::EventSource.new("#{dummy.endpoint}/continuous") do |conn|
+          conn.on_message do |message|
+            future.signal(value_class.new({ msg: message, state: conn.ready_state }))
+            conn.close
+          end
         end
+        expect(future.value(3)[:msg].data).to eq("YHOO\n+2\n10")
+      end
 
-        sleep TIMEOUT until ces.closed?
+      context "with chunked streams" do
+        it "properly parses chunked encoding" do
+          Celluloid::EventSource.new("#{dummy.endpoint}/chunk") do |conn|
+            conn.on_message do |message|
+              future.signal(value_class.new({ msg: message, state: conn.ready_state }))
+              conn.close
+            end
+          end
+          expect(future.value(3)[:msg].data).to eq("f" * (chunk_size + 25))
+        end
 
-      }.to yield_with_args({status_code: 400, body:""})
-    end
-  end
+        it "parses multiple continuous chunks" do
+          Celluloid::EventSource.new("#{dummy.endpoint}/continuous_chunks") do |conn|
+            conn.on_message do |message|
+              future.signal(value_class.new({ msg: message, state: conn.ready_state }))
+              conn.close
+            end
+          end
 
-  it 'receives custom events through event handlers' do
-    with_sse_server do |server|
-      event_name = :custom_event
+          data = "o" * chunk_size + "\n" + "m" * chunk_size + "\n" + "g" * chunk_size
+          expect(future.value(3)[:msg].data).to eq(data)
+        end
+
+        it "parses multiple chunks" do
+          Celluloid::EventSource.new("#{dummy.endpoint}/multiple_chunks") do |conn|
+            conn.on_message do |message|
+              future.signal(value_class.new({ msg: message, state: conn.ready_state }))
+              conn.close
+            end
+          end
 
-      expect { |event|
-        ces = Celluloid::EventSource.new("http://localhost:63310") do |conn|
-          conn.on(event_name, &event)
+          expect(future.value(3)[:msg].data).to eq({test: "long_chunk", another_chunk: "a" * chunk_size, chunks: "f" * chunk_size }.to_json)
         end
+      end
+    end
 
-        sleep TIMEOUT until ces.connected?
+    describe '#on' do
+      let(:custom) { :custom_event }
 
-        server.broadcast(event_name, data)
+      it 'receives custom events and handles them' do
 
-        sleep TIMEOUT
-      }.to yield_with_args(Celluloid::EventSource::MessageEvent)
+        Celluloid::EventSource.new("#{dummy.endpoint}/#{custom}") do |conn|
+          conn.on(custom) do |message|
+            future.signal(value_class.new({ msg: message, state: conn.ready_state }))
+            conn.close
+          end
+        end
+
+        payload = future.value
+        expect(payload[:msg]).to be_a(Celluloid::EventSource::MessageEvent)
+        expect(payload[:msg].type).to eq(custom)
+        expect(payload[:msg].last_event_id).to eq('1')
+        expect(payload[:state]).to eq(Celluloid::EventSource::OPEN)
+      end
     end
   end
-
 end

data/spec/spec_helper.rb

@@ -4,8 +4,6 @@ require 'bundler/setup'
 require 'celluloid/eventsource'
 require 'celluloid/rspec'
 
-require 'reel'
-
 logfile = File.open(File.expand_path("../../log/test.log", __FILE__), 'a')
 logfile.sync = true
 
@@ -13,89 +11,10 @@ Celluloid.logger = Logger.new(logfile)
 
 RSpec.configure do |config|
   config.expose_dsl_globally = false
-end
-
-class ServerSentEvents < Reel::Server::HTTP
-  include Celluloid::Logger
-
-  attr_reader :last_event_id, :connections
-
-  def initialize(ip = '127.0.0.1', port = 63310)
-    @connections = []
-    @history = []
-    @last_event_id = 0
-    super(ip, port, &method(:on_connection))
-  end
-
-  def broadcast(event, data)
-    if @history.size >= 10
-      @history.slice!(0, @history.size - 1000)
-    end
-
-    @last_event_id += 1
-    @history << { id: @last_event_id, event: event, data: data }
-
-    @connections.each do |socket|
-      async.send_sse(socket, data, event, @last_event_id)
-    end
-    true
-  end
-
-  def send_ping
-    @connections.each do |socket|
-      begin
-        socket << ":\n"
-      rescue Reel::SocketError
-        @connections.delete(socket)
-      end
-    end
-  end
-
-  private
-    # event and id are optional, Eventsource only needs data
-    def send_sse(socket, data, event = nil, id = nil)
-      begin
-        socket.id id if id
-        socket.event event if event
-        socket.data data
-      rescue Reel::SocketError, NoMethodError
-        @connections.delete(socket) if @connections.include?(socket)
-      end
-    end
-
-  def handle_request(request)
-    event_stream = Reel::EventStream.new do |socket|
-      @connections << socket
-      socket.retry 5000
-      # after a Connection reset resend newer Messages to the Client, query['last_event_id'] is needed for https://github.com/Yaffle/EventSource
-      if @history.count > 0 && id = request.headers['Last-Event-ID']
-        begin
-          if history = @history.select {|h| h[:id] >= Integer(id)}.map {|a| "id: \nevent: %s%s\ndata: %s" % [a[:id], a[:event], a[:data]]}.join("\n\n")
-            socket << "%s\n\n" % [history]
-          end
-        rescue ArgumentError, Reel::SocketError
-          @connections.delete(socket)
-          request.close
-        end
-      end
-    end
-
-    request.respond Reel::StreamResponse.new(:ok, {
-        'Content-Type' => 'text/event-stream; charset=utf-8',
-        'Cache-Control' => 'no-cache'}, event_stream)
-  end
 
-  def on_connection(connection)
-    connection.each_request do |request|
-      if request.path == '/error'
-        request.respond :bad_request, {'Content-Type' => 'application/json; charset=UTF-8'}, "blop"
-        request.close
-      elsif request.path == '/error/no_body'
-        request.respond :bad_request, {'Content-Type' => 'application/json; charset=UTF-8'}
-        request.close
-      else
-        handle_request(request)
-      end
-    end
-  end
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
 end

data/spec/support/black_hole.rb

@@ -0,0 +1,5 @@
+module BlackHole
+  def self.method_missing(*)
+    self
+  end
+end

data/spec/support/dummy_server.rb

@@ -0,0 +1,100 @@
+require 'webrick'
+require 'atomic'
+require 'json'
+
+require 'support/black_hole'
+
+class DummyServer < WEBrick::HTTPServer
+  CHUNK_SIZE = 100
+  CONFIG = {
+      :BindAddress  => '127.0.0.1',
+      :Port         => 5000,
+      :AccessLog    => BlackHole,
+      :Logger       => BlackHole,
+      :DoNotListen  => true,
+      :OutputBufferSize => CHUNK_SIZE
+  }.freeze
+
+  def initialize(options = {})
+    super(CONFIG)
+    mount('/', SSETestServlet)
+    mount('/error', ErrorServlet)
+  end
+
+  def endpoint
+    "#{scheme}://#{addr}:#{port}"
+  end
+
+  def addr
+    config[:BindAddress]
+  end
+
+  def port
+    config[:Port]
+  end
+
+  def scheme
+    'http'
+  end
+
+  # Simple server that broadcasts Time.now
+  class SSETestServlet < WEBrick::HTTPServlet::AbstractServlet
+
+    def initialize(*args)
+      @event_id = Atomic.new(0)
+      super
+    end
+
+    def do_GET(req, res)
+      event = String(Array(req.path.match(/\/?(\w+)/i)).pop).to_sym
+      res.content_type = 'text/event-stream; charset=utf-8'
+      res['Cache-Control'] = 'no-cache'
+      r,w = IO.pipe
+      res.body = r
+      res.chunked = true
+      t = Thread.new do
+        begin
+          w << "retry: 1000\n"
+          case event
+          when :continuous_chunks
+            data = "data: %s\ndata: %s\ndata: %s\n\n" % ["o" * CHUNK_SIZE, "m" * CHUNK_SIZE, "g" * CHUNK_SIZE]
+            w << data
+          when :multiple_chunks
+            data = {test: "long_chunk", another_chunk: "a" * CHUNK_SIZE, chunks: "f" * CHUNK_SIZE}.to_json
+            w << "data: #{data}\n\n"
+          when :continuous
+            w << "data: YHOO\ndata: +2\ndata: 10\n\n"
+          when :chunk
+            data = "f" * (CHUNK_SIZE + 25)
+            w << "data: %s\n\n" % data
+          when :ping
+            w << ": ignore this line\n"
+            w << "event: \ndata: pong\n\n"  # easy way to know a 'ping' has been sent
+          else
+            42.times do
+              w << "id: %s\nevent: %s\ndata: %s\n\n" % [ @event_id.update { |v| v + 1 },
+                                                         event,
+                                                         Time.now ]
+            end
+            w << "event: %s\ndata: %s\n\n" % %w(end end)
+          end
+        rescue => ex
+          puts $!.inspect, $@ unless ex.is_a?(Errno::EPIPE)
+        ensure
+          w.close
+        end
+      end
+    end
+  end
+
+  class ErrorServlet < WEBrick::HTTPServlet::AbstractServlet
+    def do_GET(req, res)
+      res.content_type = 'application/json; charset=utf-8'
+      res.status = 400
+      res.keep_alive = false  # true by default
+      res.body = '{"msg": "blop"}'
+    end
+  end
+end
+
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: celluloid-eventsource
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors:
 - Leo Correa
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-29 00:00:00.000000000 Z
+date: 2015-06-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: celluloid-io
@@ -45,33 +45,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.6.0
 - !ruby/object:Gem::Dependency
-  name: timers
+  name: atomic
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: reel
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 1.1.99
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 1.1.99
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -139,7 +125,7 @@ files:
 - ".rspec"
 - ".travis.yml"
 - Gemfile
-- LICENSE.md
+- LICENSE
 - README.md
 - Rakefile
 - celluloid-eventsource.gemspec
@@ -150,6 +136,8 @@ files:
 - spec/celluloid/eventsource/response_parser_spec.rb
 - spec/celluloid/eventsource_spec.rb
 - spec/spec_helper.rb
+- spec/support/black_hole.rb
+- spec/support/dummy_server.rb
 homepage: https://github.com/Tonkpils/celluloid-eventsource
 licenses:
 - MIT
@@ -178,3 +166,5 @@ test_files:
 - spec/celluloid/eventsource/response_parser_spec.rb
 - spec/celluloid/eventsource_spec.rb
 - spec/spec_helper.rb
+- spec/support/black_hole.rb
+- spec/support/dummy_server.rb