jebanni 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4d07871c71c8e61694588786942ce74c259fc363
+  data.tar.gz: dd45b3a2e722a3693d7127fd37103e6858db88e3
+SHA512:
+  metadata.gz: 6fe6a45abdcef3393740964022bb4650367f43bf0623d8e5817b3afddc81689ce1475a06d549b9dc858f196546f8c275195922a59db98146ba8989edeb7be350
+  data.tar.gz: 5e510d61a613b73391e062de9d10873c299cd8248c7dde97d7f0405793122b2a9593c5af4bd92e0f55ca8b1e3d18ffd3a74c75518536c06e2fd81a0bd8d3c523

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 uu59
+
+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,52 @@
+# Jebanni
+
+Jebanni is a Sinatra-style Server-Sent Event kit its based on [Reel](https://github.com/celluloid/reel).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'jebanni'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install jebanni
+
+## Usage
+
+```ruby
+class App < Jebanni::Base
+  set :interval, 1
+  set :port, 63123
+
+  get "/:channel_id" do
+    on_first_connect do
+      every(settings[:interval]) do
+        broadcast(Time.now)
+      end
+    end
+  end
+end
+
+App.run
+```
+
+See <./example/> directory for more examples.
+
+## Thanks
+
+Jebanni is heavyly inspired by [Angelo](https://github.com/kenichi/angelo).
+
+If you looking for WebSocket stream server, try it!
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/jebanni/fork )
+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 a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/example/basic.rb

@@ -0,0 +1,69 @@
+require "bundler/setup"
+require "jebanni"
+
+=begin
+$ bundle exec ruby ./example/basic.rb
+I, [2014-06-22T17:56:32.467348 #27470]  INFO -- : Listen on 0.0.0.0:63123
+
+
+at other console
+$ curl -vNH 'Accept: text/event-stream' -H 'Last-Event-ID: 1' -H 'Cache-Control: no-cache' 'http://127.0.0.1:63123/foo'
+* Hostname was NOT found in DNS cache
+*   Trying 127.0.0.1...
+* Connected to 127.0.0.1 (127.0.0.1) port 63123 (#0)
+> GET /foo HTTP/1.1
+> User-Agent: curl/7.37.0
+> Host: 127.0.0.1:63123
+> Accept: text/event-stream
+> Last-Event-ID: 1
+> Cache-Control: no-cache
+>
+< HTTP/1.1 200 OK
+< Content-Type: text/event-stream; charset=utf-8
+< Cache-Control: no-cache
+< X-Accel-Buffering: no
+< Access-Control-Allow-Origin: *
+< Transfer-Encoding: identity
+* no chunk, no close, no size. Assume close to signal end
+<
+retry: 5000
+id
+
+id: 1
+data: "2014-06-22 17:56:40 +0900"
+
+id: 2
+data: "2014-06-22 17:56:41 +0900"
+
+id: 3
+data: "2014-06-22 17:56:42 +0900"
+
+: ping
+id: 4
+data: "2014-06-22 17:56:43 +0900"
+
+id: 5
+data: "2014-06-22 17:56:44 +0900"
+
+id: 6
+data: "2014-06-22 17:56:45 +0900"
+
+^C
+
+
+=end
+
+class App < Jebanni::Base
+  set :interval, 1
+  set :port, 63123
+
+  get "/:channel_id" do
+    on_first_connect do
+      every(1) do
+        broadcast(Time.now)
+      end
+    end
+  end
+end
+
+App.run

data/example/broadcast_by_post.rb

@@ -0,0 +1,49 @@
+require "bundler/setup"
+require "jebanni"
+
+=begin
+$ bundle exec ruby ./example/broadcast_by_post.rb
+I, [2014-06-22T18:01:24.997142 #28625]  INFO -- : Listen on 0.0.0.0:63311
+
+at console A:
+A $ curl -vNH 'Accept: text/event-stream' -H 'Last-Event-ID: 1' -H 'Cache-Control: no-cache' 'http://127.0.0.1:63311/foo'
+: ping
+: ping
+
+at console B:
+B $ curl -d 'number=42' 'http://localhost:63311/foo'
+B $ curl -d '{"json": "capable"}' -H 'Content-Type: application/json' 'http://localhost:63311/foo'
+B $ curl -XPOST 'http://localhost:63311/foo/now'
+
+at A:
+: ping
+: ping
+
+id: 1
+data: {"number":"42","channel_id":"foo"}
+
+id: 2
+data: {"json":"capable","channel_id":"foo"}
+
+id: 3
+data: "2014-06-22 18:04:38 +0900"
+
+
+=end
+
+class App < Jebanni::Base
+  get "/:channel_id" do
+  end
+
+  post "/:channel_id" do
+    broadcast(params)
+    finish! # finish! means this connection doesn't require streaming. normal HTTP request/response operation
+  end
+
+  post "/:channel_id/now" do
+    broadcast(Time.now)
+    finish!
+  end
+end
+
+App.run

data/jebanni.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'jebanni/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "jebanni"
+  spec.version       = Jebanni::VERSION
+  spec.authors       = ["uu59"]
+  spec.email         = ["k@uu59.org"]
+  spec.summary       = %q{SSE Streaming server (not Rack)}
+  spec.description   = %q{SSE Streaming server (not Rack)}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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 "reel"
+  spec.add_dependency "mustermann"
+  spec.add_dependency "rack" # for Rack::Utils#parse_nested_query
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "pry"
+end

data/lib/jebanni.rb

@@ -0,0 +1,7 @@
+require "jebanni/version"
+require "jebanni/base"
+require "jebanni/server"
+
+module Jebanni
+  # Your code goes here...
+end

data/lib/jebanni/base.rb

@@ -0,0 +1,24 @@
+require "jebanni/dsl"
+require "jebanni/server"
+
+module Jebanni
+  class Base
+    include ::Jebanni::DSL
+
+    def self.run
+      new.run
+    end
+
+    def run
+      bind = settings[:bind] || "0.0.0.0"
+      port = settings[:port] || 63311
+      @server = Server.new(bind, port)
+      trap "INT" do
+        @server.terminate if @server and @server.alive?
+        exit
+      end
+      @server.send(:info, "Listen on #{bind}:#{port}")
+      sleep
+    end
+  end
+end

data/lib/jebanni/channel.rb

@@ -0,0 +1,38 @@
+module Jebanni
+  class Channel
+    attr_reader :id, :history, :connections, :server
+
+    def initialize(id, server)
+      @id = id
+      @history = []
+      @last_event_id = 0
+      @server = server
+      @connections = []
+    end
+
+    def join(connection)
+      @connections << connection
+    end
+
+    def leave(connection)
+      @connections.delete connection
+    end
+
+    def refrain(since)
+      @history.each do |history|
+        next if history[:id] <= since
+        server.broadcast_to(self, history[:data], history[:event], history[:id])
+      end
+    end
+
+    def broadcast(data, event = nil)
+      @last_event_id += 1
+      @history << {id: @last_event_id, event: event, data: data}
+      #only keep the last 5000 Events
+      if @history.size >= 6000
+        @history.slice!(0, @history.size - 1000)
+      end
+      server.broadcast_to(self, data, event, @last_event_id)
+    end
+  end
+end

data/lib/jebanni/dsl.rb

@@ -0,0 +1,35 @@
+require "jebanni/request_handler"
+require "jebanni/settings"
+
+module Jebanni
+  module DSL
+    extend Forwardable
+    def self.included(base)
+      base.extend ClassMethods
+      base.include Mixin
+    end
+
+    module Mixin
+      def set(key, value)
+        ::Jebanni::Settings[key] = value
+      end
+
+      def settings
+        ::Jebanni::Settings.to_hash
+      end
+    end
+
+    module ClassMethods
+      include Mixin
+      def register_route(verb, path, options = {}, &process)
+        RequestHandler.register_route(verb, path, options, &process)
+      end
+
+      %w(get post put patch delete head options link unlink).each do |verb|
+        define_method(verb) do |path, options = {}, &process|
+          register_route(verb, path, options, &process)
+        end
+      end
+    end
+  end
+end

data/lib/jebanni/request_handler.rb

@@ -0,0 +1,88 @@
+require "mustermann"
+require "rack/utils"
+require "jebanni/request_handler/processor"
+
+module Jebanni
+  class RequestHandler
+    include Rack::Utils # for #parse_nested_query
+
+    attr_reader :request, :server
+
+    def self.register_route(verb, path, options = {}, &process)
+      verb.downcase!
+      @routes ||= {}
+      @routes[verb] ||= []
+      @routes[verb] << {
+        matcher: Mustermann.new(path, options),
+        process: process
+      }
+    end
+
+    def initialize(request, server)
+      @request = request
+      @server = server
+    end
+
+    def route!
+      processor.response
+    end
+
+    def find_route
+      known = self.class.instance_variable_get(:@routes)
+      found = known[request.method.downcase].find do |route|
+        route[:matcher] === request.path
+      end
+      raise "not found" unless found
+      found
+    end
+
+    def processor
+      @processor ||=
+        begin
+          # Processor define class method internally, so avoid race condition for Class.new(Processor)
+          processor = Class.new(Processor).new(self)
+          processor.route = find_route
+          processor.params = params
+          processor
+        end
+    end
+
+    def request_params
+      query = parse_nested_query(request.query_string)
+      return query if %w(get head options).include?(request.method.downcase)
+
+      content_type = request.headers.find do |(key, _)|
+        key.downcase == "content-type"
+      end
+      if content_type && content_type.last.downcase == "application/json"
+        json_params = JSON.parse(request.body.to_s) rescue {}
+        query.merge! json_params
+      else
+        query.merge! parse_nested_query(request.body.to_s)
+      end
+      query
+    end
+
+    def route_params
+      find_route[:matcher].params(request.path)
+    end
+
+    def params
+      # NOTE: route params is prior than query params for don't accidentally override params with query
+      indiferrent_keys request_params.merge(route_params)
+    end
+
+    def indiferrent_keys(hash)
+      # Either accessible params[:foo] or params["foo"]
+      def hash.[](key)
+        super(key.to_s) || begin
+          # NOTE: Guard from DoS attack using Symbol:
+          #       http://sequel.jeremyevans.net/2011/07/16/dangerous-reflection.html
+          super(key.to_sym) if self.keys.map(&:to_s).include?(key.to_s)
+        end
+      end
+      hash
+    end
+
+  end
+end

data/lib/jebanni/request_handler/processor.rb

@@ -0,0 +1,60 @@
+require "jebanni/settings"
+require "jebanni/channel"
+
+module Jebanni
+  class RequestHandler
+    class Processor
+      extend Forwardable
+      def_delegators :@request_handler, :request, :server
+      def_delegators :server, :async, :after, :every
+      def_delegators :channel, :broadcast
+
+      attr_accessor :params
+
+      def initialize(request_handler)
+        @request_handler = request_handler
+      end
+
+      def route=(found_route)
+        @route = found_route
+        self.class.send(:define_method, :process, @route[:process])
+      end
+
+      def channel_id(id)
+        @channel_id = id
+        unless server.channels[@channel_id]
+          server.channels[@channel_id] = Channel.new(@channel_id, server)
+        end
+      end
+
+      def channel
+        return unless @channel_id
+        server.channels[@channel_id]
+      end
+
+      def on_first_connect(&block)
+        if channel.connections.length == 0
+          instance_eval(&block)
+        end
+      end
+
+      def finish!
+        @finish = true
+      end
+
+      def finished?
+        @finish
+      end
+
+      def response
+        channel_id params[:channel_id] if params[:channel_id]
+        process
+        self
+      end
+
+      def settings
+        Settings.to_hash
+      end
+    end
+  end
+end

data/lib/jebanni/server.rb

@@ -0,0 +1,109 @@
+require 'time'
+require 'reel'
+
+# Based on Reel's sample
+# https://github.com/celluloid/reel/blob/master/examples/server_sent_events.rb
+
+module Jebanni
+  class Server < Reel::Server::HTTP
+    include Celluloid::Logger
+    
+    def initialize(ip = '127.0.0.1', port = 63310)
+      @channels = {}
+      super(ip, port, &method(:on_connection))
+      async.ping
+    end
+
+    def broadcast_to(channel, data, event, id)
+      channel.connections.each do |socket|
+        async.send_sse(socket, data, event, id)
+      end
+      true
+    end
+
+    def channels
+      @channels
+    end
+
+    def all_connections
+      @channels.map{|(_, channel)| channel.connections}.flatten
+    end
+
+    private
+    #event and id are optional, Eventsource only needs data
+    def send_sse(socket, data, event = nil, id = nil)
+      unless data.is_a? String
+        data = JSON.dump(data)
+      end
+      socket.id id if id
+      socket.event event if event
+      socket.data data
+    rescue Reel::SocketError
+      leave_channel(socket)
+    end
+
+    def leave_channel(socket)
+      @channels.each do |id, ch|
+        next unless ch.connections.include?(socket)
+        debug("Disconnect from channel:#{id}")
+        ch.leave(socket)
+      end
+    end
+
+    #Lines that start with a Colon are Comments and will be ignored
+    def send_ping
+      all_connections.each do |socket|
+        begin
+          socket << ": ping\n"
+        rescue Reel::SocketError
+          leave_channel(socket)
+        end
+      end
+    end
+
+    #apache 2.2 closes connections after five seconds when nothing is send, see this as a poor mans Keep-Alive
+    def ping
+      every(5) do
+        send_ping
+      end
+    end
+
+    def handle_request(request)
+      response = RequestHandler.new(request, self).route!
+      return request.respond 204 if response.finished?
+
+      request.respond Reel::StreamResponse.new(:ok, response_headers, event_stream(request, response))
+    end
+
+    def response_headers
+      #X-Accel-Buffering is nginx(?) specific. Setting this to "no" will allow unbuffered responses suitable for Comet and HTTP streaming applications
+      {
+        'Content-Type' => 'text/event-stream; charset=utf-8',
+        'Cache-Control' => 'no-cache',
+        'X-Accel-Buffering' => 'no',
+        'Access-Control-Allow-Origin' => '*',
+      }
+    end
+
+    def event_stream(request, response)
+      Reel::EventStream.new do |socket|
+        channel = response.channel
+        channel.join socket
+        socket.retry 5000
+        #after a Connection reset resend newer Messages to the Client, query['lastEventId'] is needed for https://github.com/Yaffle/EventSource
+        query = Hash[URI.decode_www_form(request.query_string || "")]
+        id = (request.headers['Last-Event-ID'] || query['lastEventId'])
+        socket << "id\n\n"
+        if id && id.to_i > 0
+          channel.refrain(id.to_i)
+        end
+      end
+    end
+
+    def on_connection(connection)
+      connection.each_request do |request|
+        handle_request(request)
+      end
+    end
+  end
+end

data/lib/jebanni/settings.rb

@@ -0,0 +1,19 @@
+module Jebanni
+  module Settings
+    class << self
+      def []=(key, value)
+        @settings ||= {}
+        @settings[key] = value
+      end
+
+      def [](key)
+        @settings ||= {}
+        @settings[key]
+      end
+
+      def to_hash
+        @settings || {}
+      end
+    end
+  end
+end

data/lib/jebanni/version.rb

@@ -0,0 +1,3 @@
+module Jebanni
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification
+name: jebanni
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- uu59
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: reel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mustermann
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: pry
+  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'
+description: SSE Streaming server (not Rack)
+email:
+- k@uu59.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- example/basic.rb
+- example/broadcast_by_post.rb
+- jebanni.gemspec
+- lib/jebanni.rb
+- lib/jebanni/base.rb
+- lib/jebanni/channel.rb
+- lib/jebanni/dsl.rb
+- lib/jebanni/request_handler.rb
+- lib/jebanni/request_handler/processor.rb
+- lib/jebanni/server.rb
+- lib/jebanni/settings.rb
+- lib/jebanni/version.rb
+homepage: ''
+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.2.2
+signing_key: 
+specification_version: 4
+summary: SSE Streaming server (not Rack)
+test_files: []