ld-celluloid-eventsource 0.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f33aac634f96a65252e98eaca774d9f5df2a12e6
+  data.tar.gz: 77f105c227ead24d0d477345f1a30bb0093eb661
+SHA512:
+  metadata.gz: dd143c0275f774054aaf7a1246f87ca462fd03202d011984f57735c8f7480eb1aa3aee77a40816e0acd1fc1c0e8adac9d18162eb9e27ececcad74651724393c8
+  data.tar.gz: 2896213a7d5a0155df43ca9aab8b097d4a45bdae971c45fc4befaa92113929791dd5e1e4da90557e9518a4310a9a702bf464bea6c169b240f82e45bf8693857a

data/.gitignore

@@ -0,0 +1,21 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+.ruby-version
+.ruby-gemset
+examples/
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.idea

data/.rspec

@@ -0,0 +1 @@
+--color

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+
+before_install: gem update bundler
+
+rvm:
+  - "2.0.0"
+  - "2.1.0"
+  - "2.2.2"

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in celluloid-eventsource.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Leo Correa
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,86 @@
+# Celluloid::Eventsource
+
+[![Gem Version](https://badge.fury.io/rb/celluloid-eventsource.png)](http://badge.fury.io/rb/celluloid-eventsource)
+[![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)
+
+An EventSource client based off Celluloid::IO.
+
+Specification based on [EventSource](http://www.w3.org/TR/2012/CR-eventsource-20121211/)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'celluloid-eventsource'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install celluloid-eventsource
+
+then somewhere in your project:
+
+    require 'celluloid/eventsource'
+
+## Usage
+
+Initializing a new `Celluloid::EventSource` object will create the connection:
+
+```ruby
+es = Celluloid::EventSource.new("http://example.com/")
+```
+
+Messages can be received on events such as `on_open`, `on_message` and `on_error`.
+
+These can be assigned at initialize time
+
+```ruby
+es = Celluloid::EventSource.new("http://example.com/") do |conn|
+  conn.on_open do
+    puts "Connection was made"
+  end
+
+  conn.on_message do |event|
+    puts "Message: #{event.data}"
+  end
+
+  conn.on_error do |message|
+    puts "Response status #{message[:status_code]}, Response body #{message[:body]}"
+  end
+
+  conn.on(:time) do |event|
+    puts "The time is #{event.data}"
+  end
+end
+```
+
+To close the connection `#close` will shut the socket connection but keep the actor alive.
+
+### Event Handlers
+
+Event handlers should be added when initializing the eventsource.
+
+**Warning**
+To change event handlers after initializing there is a [Gotcha](https://github.com/celluloid/celluloid/wiki/Gotchas).
+Celluloid sends messages to actors through thread-safe proxies.
+
+To get around this, use `wrapped_object` to set the handler on the actor but be aware of the concequences.
+
+```ruby
+es.wrapped_object.on_messsage { |message| puts "Different #{message}" }
+```
+
+This same concept applies for changing the `url` of the eventsource.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+

data/Rakefile

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

data/ld-celluloid-eventsource.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'celluloid/eventsource/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ld-celluloid-eventsource"
+  spec.version       = Celluloid::EventSource::VERSION
+  spec.authors       = ["Leo Correa"]
+  spec.email         = ["lcorr005@gmail.com"]
+  spec.description   = %q{Celluloid::IO based library to consume Server-Sent Events. This library was forked from https://github.com/Tonkpils/celluloid-eventsource}
+  spec.summary       = %q{ld-celluloid-eventsource is a gem to consume SSE streaming API.}
+  spec.homepage      = "https://github.com/launchdarkly/celluloid-eventsource"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'celluloid-io', '~> 0.17.3'
+  spec.add_dependency 'http_parser.rb', '~> 0.6.0'
+
+  spec.add_development_dependency 'atomic', '~> 1.1'
+  spec.add_development_dependency "rspec", '~> 3.0'
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", '~> 10.1'
+  spec.add_development_dependency "pry", '~> 0.9'
+end

data/lib/celluloid/eventsource/response_parser.rb

@@ -0,0 +1,61 @@
+require 'http/parser'
+
+module Celluloid
+
+  class EventSource
+
+    class ResponseParser
+      extend Forwardable
+
+      attr_reader :headers
+
+      delegate [:status_code, :<<] => :@parser
+
+      def initialize
+        @parser = Http::Parser.new(self)
+        @headers = nil
+        @chunk = ""
+      end
+
+      def headers?
+        !!@headers
+      end
+
+      def status
+        @parser.status_code
+      end
+
+      def on_headers_complete(headers)
+        @headers = canonical_headers(headers)
+      end
+
+      def on_body(chunk)
+        @chunk << chunk
+      end
+
+      def chunk
+        chunk = @chunk
+        unless chunk.empty?
+          @chunk = ""
+        end
+
+        chunk.to_s
+      end
+
+      private
+
+      def canonical_headers(headers)
+        headers.each_with_object({}) do |(key, value), canonicalized_headers|
+          name = canonicalize_header(key)
+          canonicalized_headers[name] = value
+        end
+      end
+
+      def canonicalize_header(name)
+        name.gsub('_', '-').split("-").map(&:capitalize).join("-")
+      end
+    end
+
+  end
+
+end

data/lib/celluloid/eventsource/version.rb

@@ -0,0 +1,5 @@
+module Celluloid
+  class EventSource
+    VERSION = "0.4.0"
+  end
+end

data/lib/celluloid/eventsource.rb

@@ -0,0 +1,232 @@
+require 'celluloid/current'
+require "celluloid/eventsource/version"
+require 'celluloid/io'
+require 'celluloid/eventsource/response_parser'
+require 'uri'
+
+module Celluloid
+  class EventSource
+    include Celluloid::IO
+
+    attr_reader :url, :with_credentials
+    attr_reader :ready_state
+
+    CONNECTING = 0
+    OPEN = 1
+    CLOSED = 2
+
+    execute_block_on_receiver :initialize
+
+    def initialize(uri, options = {})
+      self.url = uri
+      options  = options.dup
+      @ready_state = CONNECTING
+      @with_credentials = options.delete(:with_credentials) { false }
+      @headers = default_request_headers.merge(options.fetch(:headers, {}))
+
+      @event_type_buffer = ""
+      @last_event_id_buffer = ""
+      @data_buffer = ""
+
+      @last_event_id = String.new
+
+      @reconnect_timeout = 10
+      @on = { open: ->{}, message: ->(_) {}, error: ->(_) {} }
+      @parser = ResponseParser.new
+
+      @chunked = false
+
+      yield self if block_given?
+
+      async.listen
+    end
+
+    def url=(uri)
+      @url = URI(uri)
+    end
+
+    def connected?
+      ready_state == OPEN
+    end
+
+    def closed?
+      ready_state == CLOSED
+    end
+
+    def listen
+      establish_connection
+
+      chunked? ? process_chunked_stream : process_stream
+    rescue 
+      after(1){ listen }
+    end
+
+    def close
+      @socket.close if @socket
+      @ready_state = CLOSED
+    end
+
+    def on(event_name, &action)
+      @on[event_name.to_sym] = action
+    end
+
+    def on_open(&action)
+      @on[:open] = action
+    end
+
+    def on_message(&action)
+      @on[:message] = action
+    end
+
+    def on_error(&action)
+      @on[:error] = action
+    end
+
+    private
+
+    MessageEvent = Struct.new(:type, :data, :last_event_id)
+
+    def ssl?
+      url.scheme == 'https'
+    end
+
+    def establish_connection
+      @socket = Celluloid::IO::TCPSocket.new(@url.host, @url.port)
+
+      if ssl?
+        @socket = Celluloid::IO::SSLSocket.new(@socket)
+        @socket.connect
+      end
+
+      @socket.write(request_string)
+
+      until @parser.headers?
+        @parser << @socket.readline
+      end
+
+      if @parser.status_code != 200
+        until @socket.eof?
+          @parser << @socket.readline
+        end
+        close
+        @on[:error].call({status_code: @parser.status_code, body: @parser.chunk})
+        return
+      end
+
+      handle_headers(@parser.headers)
+    end
+
+    def default_request_headers
+      {
+        'Accept'        => 'text/event-stream',
+        'Cache-Control' => 'no-cache',
+        'Host'          => url.host
+      }
+    end
+
+    def clear_buffers!
+      @data_buffer = ""
+      @event_type_buffer = ""
+    end
+
+    def dispatch_event(event)
+      unless closed?
+        @on[event.type] && @on[event.type].call(event)
+      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
+
+    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
+        close
+        @on[:error].call({status_code: @parser.status_code, body: "Invalid Content-Type #{headers['Content-Type']}. Expected text/event-stream"})
+      end
+    end
+
+    def request_string
+      headers = @headers.map { |k, v| "#{k}: #{v}" }
+
+      ["GET #{url.request_uri} HTTP/1.1", headers].flatten.join("\r\n").concat("\r\n\r\n")
+    end
+
+  end
+
+end

data/log/.gitignore

@@ -0,0 +1 @@
+*.log

data/spec/celluloid/eventsource/response_parser_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+RSpec.describe Celluloid::EventSource::ResponseParser do
+
+  let(:success_headers) {<<-eos
+HTTP/1.1 200 OK
+Last-Modified: Wed, 08 Jan 2003 23:11:55 GMT
+Content-Type: text/html; charset=UTF-8
+Content-Length: 131
+X_CASE_HEADER: foo
+X_Mixed-Case: bar
+x-lowcase-header: hello
+eos
+}
+
+  let(:error_headers) {<<-eos
+HTTP/1.1 400 OK
+Last-Modified: Wed, 08 Jan 2003 23:11:55 GMT
+Content-Type: text/html; charset=UTF-8
+Content-Length: 131
+eos
+}
+
+  let(:response_string) { "#{success_headers}\n\n{'hello' : 'world'}\n"}
+
+  let(:parser) { subject }
+
+
+  def streamed(string)
+    stream = StringIO.new(string)
+    stream.each do |line|
+      yield line
+    end
+  end
+
+  it 'parses a complete http response' do
+    streamed(response_string) do |line|
+      parser << line
+    end
+
+    expect(parser.status).to eq(200)
+    expect(parser.headers?).to be_truthy
+    expect(parser.headers['Content-Type']).to eq('text/html; charset=UTF-8')
+    expect(parser.headers['Content-Length']).to eq("131")
+  end
+
+  it 'waits until the entire request is found' do
+    streamed(success_headers) do |line|
+      parser << line
+    end
+
+    expect(parser.status).to eq(200)
+    expect(parser.headers?).to be_falsey
+    expect(parser.headers).to be_nil
+  end
+
+  it 'makes response headers canonicalized' do
+    streamed(response_string) { |line| parser << line }
+    expected_headers = {
+      'X-Mixed-Case' => 'bar', 'Content-Type' => 'text/html; charset=UTF-8', 'Content-Length' => "131",
+      'X-Case-Header' => 'foo', 'X-Lowcase-Header' => "hello"
+    }
+    expect(parser.headers).to include(expected_headers)
+  end
+
+end

data/spec/celluloid/eventsource_spec.rb

@@ -0,0 +1,176 @@
+require 'spec_helper'
+require 'support/dummy_server'
+
+
+# See: https://html.spec.whatwg.org/multipage/comms.html#event-stream-interpretation
+RSpec.describe Celluloid::EventSource do
+
+  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
+    let(:url)  { "example.com" }
+
+    it 'runs asynchronously' do
+      ces = double(Celluloid::EventSource)
+      expect_any_instance_of(Celluloid::EventSource).to receive_message_chain(:async, :listen).and_return(ces)
+
+      Celluloid::EventSource.new("http://#{url}")
+    end
+
+    it 'allows customizing headers' do
+      auth_header = { "Authorization" => "Basic aGVsbG86dzBybGQh" }
+
+      allow_any_instance_of(Celluloid::EventSource).to receive_message_chain(:async, :listen)
+      es = Celluloid::EventSource.new("http://#{url}", :headers => auth_header)
+
+      headers = es.instance_variable_get('@headers')
+      expect(headers['Authorization']).to eq(auth_header["Authorization"])
+    end
+  end
+
+  context 'callbacks' do
+
+    let(:future) { Celluloid::Future.new }
+    let(:value_class) { Class.new(Struct.new(:value)) }
+
+    describe '#on_open' do
+
+      it 'the client has an opened connection' do
+
+        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
+
+        expect(future.value).to eq({ called: true, state: Celluloid::EventSource::OPEN })
+      end
+    end
+
+    describe '#on_error' do
+
+      it 'receives response body through error event' do
+
+        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
+
+        expect(future.value).to eq({ msg: { status_code: 400, body: '{"msg": "blop"}' },
+                                     state: Celluloid::EventSource::CLOSED })
+      end
+    end
+
+    describe '#on_message' do
+
+      it 'receives data through message event' do
+
+        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
+
+        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
+
+      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 "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
+
+      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
+
+        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
+
+          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(future.value(3)[:msg].data).to eq({test: "long_chunk", another_chunk: "a" * chunk_size, chunks: "f" * chunk_size }.to_json)
+        end
+      end
+    end
+
+    describe '#on' do
+      let(:custom) { :custom_event }
+
+      it 'receives custom events and handles them' do
+
+        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

@@ -0,0 +1,27 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'celluloid/current'
+require 'celluloid/test'
+require 'celluloid/eventsource'
+
+logfile = File.open(File.expand_path("../../log/test.log", __FILE__), 'a')
+logfile.sync = true
+
+Celluloid.logger = Logger.new(logfile)
+
+RSpec.configure do |config|
+  config.expose_dsl_globally = false
+
+  config.around(:each) do |ex|
+    Celluloid.boot
+    ex.run
+    Celluloid.shutdown
+  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

@@ -0,0 +1,165 @@
+--- !ruby/object:Gem::Specification
+name: ld-celluloid-eventsource
+version: !ruby/object:Gem::Version
+  version: 0.4.0
+platform: ruby
+authors:
+- Leo Correa
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-03-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: celluloid-io
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.17.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.17.3
+- !ruby/object:Gem::Dependency
+  name: http_parser.rb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+- !ruby/object:Gem::Dependency
+  name: atomic
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.1'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: Celluloid::IO based library to consume Server-Sent Events. This library
+  was forked from https://github.com/Tonkpils/celluloid-eventsource
+email:
+- lcorr005@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- ld-celluloid-eventsource.gemspec
+- lib/celluloid/eventsource.rb
+- lib/celluloid/eventsource/response_parser.rb
+- lib/celluloid/eventsource/version.rb
+- log/.gitignore
+- 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/launchdarkly/celluloid-eventsource
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.0
+signing_key: 
+specification_version: 4
+summary: ld-celluloid-eventsource is a gem to consume SSE streaming API.
+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