websocket-eventmachine-server 1.0.0

data/.gitignore

@@ -0,0 +1,3 @@
+Gemfile.lock
+autobahn
+pkg/*.gem

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## 1.0.0
+
+- initial release

data/Gemfile

@@ -0,0 +1,5 @@
+source "http://rubygems.org"
+
+gemspec
+
+gem 'rake'

data/README.md

@@ -0,0 +1,89 @@
+# WebSocket Server for Ruby
+
+WebSocket-EventMachine-Server is Ruby WebSocket server based on EventMachine.
+
+## Why another WebSocket server?
+
+There are multiple Ruby WebSocket servers, each with different quirks and errors. Most commonly used em-websocket is unfortunately slow and have multiple bugs(see Autobahn tests below). This library was created to fix most of them.
+
+[Autobahn tests](http://imanel.github.com/websocket-ruby/autobahn/server)
+
+## Installation
+
+``` bash
+gem install websocket-eventmachine-server
+```
+
+or in Gemfile
+
+``` ruby
+gem 'websocket-eventmachine-server'
+```
+
+## Simple server example
+
+```ruby
+EventMachine.run {
+
+    WebSocket::EventMachine::Server.start(:host => "0.0.0.0", :port => 8080) do |ws|
+        ws.onopen {
+          puts "WebSocket connection open"
+
+          # publish message to the client
+          ws.send "Hello Client"
+        }
+
+        ws.onclose { puts "Connection closed" }
+        ws.onmessage { |msg|
+          puts "Recieved message: #{msg}"
+          ws.send "Pong: #{msg}"
+        }
+    end
+}
+```
+
+## Secure server
+
+It is possible to accept secure wss:// connections by passing :secure => true when opening the connection. Safari 5 does not currently support prompting on untrusted SSL certificates therefore using signed certificates is highly recommended. Pass a :tls_options hash containing keys as described in http://eventmachine.rubyforge.org/EventMachine/Connection.html#M000296
+
+For example,
+
+```ruby
+WebSocket::EventMachine::Server.start({
+    :host => "0.0.0.0",
+    :port => 443,
+    :secure => true,
+    :tls_options => {
+      :private_key_file => "/private/key",
+      :cert_chain_file => "/ssl/certificate"
+    }
+}) do |ws|
+...
+end
+```
+
+## Running behind an SSL Proxy/Terminator, like Stunnel
+
+The :secure_proxy => true option makes it possible to run correctly when behind a secure SSL proxy/terminator like [Stunnel](http://www.stunnel.org/). When setting :secure_proxy => true, any reponse from the em-websocket which contains the websocket url will use the wss:// url scheme. None of the traffic is encrypted.
+
+This option is necessary when using websockets with an SSL proxy/terminator on Safari 5.1.x or earlier, and also on Safari in iOS 5.x and earlier. Most versions of Chrome, Safari 5.2, and Safari in iOS 6 do not appear to have this problem.
+
+For example,
+
+```ruby
+WebSocket::EventMachine::Server.start({
+    :host => "0.0.0.0",
+    :port => 8080,
+    :secure_proxy => true
+}) do |ws|
+...
+end
+```
+
+## Migrating from EM-WebSocket
+
+This library is compatible with EM-WebSocket, so only thing you need to change is running server - you need to change from EM-WebSocket to WebSocket::EventMachine::Server in your application and everything will be working.
+
+## License
+
+The MIT License - Copyright (c) 2012 Bernard Potocki

data/Rakefile

@@ -0,0 +1,16 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+# require 'rspec/core/rake_task'
+
+# RSpec::Core::RakeTask.new do |t|
+#   t.rspec_opts = ["-c", "-f progress"]
+#   t.pattern = 'spec/**/*_spec.rb'
+# end
+
+# task :default => :spec
+
+desc "Run autobahn tests for server"
+task :autobahn do
+  system('wstest --mode=fuzzingclient --spec=autobahn.json')
+end

data/autobahn.json

@@ -0,0 +1,13 @@
+{
+  "options": {"failByDrop": false},
+  "outdir": "./autobahn",
+
+  "servers": [
+    {"agent": "WebSocket-EventMachine-Server<br>(1.0.0)", "url": "ws://localhost:9001", "options": {"version": 18}},
+    {"agent": "EM-WebSocket<br>(0.3.8)", "url": "ws://localhost:8080", "options": {"version": 18}}
+  ],
+
+  "cases": ["*"],
+  "exclude-cases": [],
+  "exclude-agent-cases": {}
+}

data/examples/autobahn_server.rb

@@ -0,0 +1,24 @@
+require File.expand_path('../../lib/websocket-eventmachine-server', __FILE__)
+
+EM.epoll
+EM.run do
+
+  trap("TERM") { stop }
+  trap("INT")  { stop }
+
+  WebSocket::EventMachine::Server.start(:host => "0.0.0.0", :port => 9001) do |ws|
+
+    ws.onmessage do |msg, type|
+      ws.send msg, :type => type
+    end
+
+  end
+
+  puts "Server started at port 9001"
+
+  def stop
+    puts "Terminating WebSocket Server"
+    EventMachine.stop
+  end
+
+end

data/examples/echo_server.rb

@@ -0,0 +1,45 @@
+require File.expand_path('../../lib/websocket-eventmachine-server', __FILE__)
+
+EM.epoll
+EM.run do
+
+  trap("TERM") { stop }
+  trap("INT")  { stop }
+
+  WebSocket::EventMachine::Server.start(:host => "0.0.0.0", :port => 9001) do |ws|
+
+    ws.onopen do
+      puts "Client connected"
+    end
+
+    ws.onmessage do |msg, type|
+      puts "Received message: #{msg}"
+      ws.send msg, :type => type
+    end
+
+    ws.onclose do
+      puts "Client disconnected"
+    end
+
+    ws.onerror do |e|
+      puts "Error: #{e}"
+    end
+
+    ws.onping do |msg|
+      puts "Receied ping: #{msg}"
+    end
+
+    ws.onpong do |msg|
+      puts "Received pong: #{msg}"
+    end
+
+  end
+
+  puts "Server started at port 9001"
+
+  def stop
+    puts "Terminating WebSocket Server"
+    EventMachine.stop
+  end
+
+end

data/lib/websocket-eventmachine-server.rb

@@ -0,0 +1 @@
+require File.expand_path('../websocket/eventmachine/server', __FILE__)

data/lib/websocket/eventmachine/server.rb

@@ -0,0 +1,229 @@
+require 'websocket'
+require 'eventmachine'
+
+module WebSocket
+  module EventMachine
+
+    # WebSocket Server (using EventMachine)
+    # @example
+    #   WebSocket::EventMachine::Server.start(:host => "0.0.0.0", :port => 8080) do |ws|
+    #     ws.onopen    { ws.send "Hello Client!"}
+    #     ws.onmessage { |msg| ws.send "Pong: #{msg}" }
+    #     ws.onclose   { puts "WebSocket closed" }
+    #     ws.onerror   { |e| puts "Error: #{e}" }
+    #   end
+    class Server < ::EventMachine::Connection
+
+      ###########
+      ### API ###
+      ###########
+
+      # Start server
+      # @param options [Hash] The request arguments
+      # @option args [String] :host The host IP/DNS name
+      # @option args [Integer] :port The port to connect too(default = 80)
+      def self.start(options, &block)
+        ::EventMachine::start_server(options[:host], options[:port], self, options) do |c|
+          block.call(c)
+        end
+      end
+
+      # Initialize connection
+      # @param args [Hash] Arguments for server
+      # @option args [Boolean] :debug Should server log debug data?
+      # @option args [Boolean] :secure If true then server will run over SSL
+      # @option args [Boolean] :secure_proxy If true then server will use wss protocol but will not encrypt connection. Usefull for sll proxies.
+      # @option args [Hash] :tls_options Options for SSL if secure = true
+      def initialize(args)
+        @debug = !!args[:debug]
+        @secure = !!args[:secure]
+        @secure_proxy = args[:secure_proxy] || @secure
+        @tls_options = args[:tls_options] || {}
+      end
+
+      # Called when connection is opened.
+      # No parameters are passed to block
+      def onopen(&blk);     @onopen = blk;    end
+
+      # Called when connection is closed.
+      # No parameters are passed to block
+      def onclose(&blk);    @onclose = blk;   end
+
+      # Called when error occurs.
+      # One parameter passed to block:
+      #   error - string with error message
+      def onerror(&blk);    @onerror = blk;   end
+
+      # Called when message is received from server.
+      # Two parameters passed to block:
+      #   message - string with message sent to server
+      #   type - type of message. Valid values are :text and :binary
+      def onmessage(&blk);  @onmessage = blk; end
+
+      # Called when ping message is received from server.
+      # One parameter passed to block:
+      #   message - string with ping message
+      def onping(&blk);     @onping = blk;    end
+
+      # Called when pond message is received from server.
+      # One parameter passed to block:
+      #   message - string with pong message
+      def onpong(&blk);     @onpong = blk;    end
+
+      # Send data to client
+      # @param data [String] Data to send
+      # @param args [Hash] Arguments for send
+      # @option args [String] :type Type of frame to send - available types are "text", "binary", "ping", "pong" and "close"
+      # @option args [Integer] :code Code for close frame
+      # @return [Boolean] true if data was send, otherwise call on_error if needed
+      def send(data, args = {})
+        type = args[:type] || :text
+        unless type == :plain
+          frame = WebSocket::Frame::Outgoing::Server.new args.merge(:version => @handshake.version, :data => data)
+          if !frame.supported?
+            trigger_onerror("Frame type '#{type}' is not supported in protocol version #{@handshake.version}")
+            return false
+          elsif !frame.require_sending?
+            return false
+          end
+          data = frame.to_s
+        end
+        debug "Sending raw: ", data
+        send_data(data)
+        true
+      end
+
+      # Close connection
+      # @return [Boolean] true if connection is closed immediately, false if waiting for server to close connection
+      def close(code = 1000, data = nil)
+        if @state == :open
+          @state = :closing
+          return false if send(data, :type => :close, :code => code)
+        else
+          send(data, :type => :close) if @state == :closing
+          @state = :closed
+        end
+        close_connection_after_writing
+        true
+      end
+
+      # Send ping message to client
+      # @return [Boolean] false if protocol version is not supporting ping requests
+      def ping(data = '')
+        send(data, :type => :ping)
+      end
+
+      # Send pong message to client
+      # @return [Boolean] false if protocol version is not supporting pong requests
+      def pong(data = '')
+        send(data, :type => :pong)
+      end
+
+      ############################
+      ### EventMachine methods ###
+      ############################
+
+      # Eventmachine internal
+      # @private
+      def post_init
+        @state = :connecting
+        @handshake = WebSocket::Handshake::Server.new(:secure => @secure_proxy)
+        start_tls(@tls_options) if @secure
+      end
+
+      # Eventmachine internal
+      # @private
+      def receive_data(data)
+        debug "Received raw: ", data
+        case @state
+        when :connecting then handle_connecting(data)
+        when :open then handle_open(data)
+        when :closing then handle_closing(data)
+        end
+      end
+
+      # Eventmachine internal
+      # @private
+      def unbind
+        unless @state == :closed
+          @state = :closed
+          close
+          trigger_onclose('')
+        end
+      end
+
+      #######################
+      ### Private methods ###
+      #######################
+
+      private
+
+      ['onopen'].each do |m|
+        define_method "trigger_#{m}" do
+          callback = instance_variable_get("@#{m}")
+          callback.call if callback
+        end
+      end
+
+      ['onerror', 'onping', 'onpong', 'onclose'].each do |m|
+        define_method "trigger_#{m}" do |data|
+          callback = instance_variable_get("@#{m}")
+          callback.call(data) if callback
+        end
+      end
+
+      def trigger_onmessage(data, type)
+        @onmessage.call(data, type) if @onmessage
+      end
+
+      def handle_connecting(data)
+        @handshake << data
+        return unless @handshake.finished?
+        if @handshake.valid?
+          send(@handshake.to_s, :type => :plain) if @handshake.should_respond?
+          @frame = WebSocket::Frame::Incoming::Server.new(:version => @handshake.version)
+          @state = :open
+          trigger_onopen
+          handle_open(@handshake.leftovers) if @handshake.leftovers
+        else
+          trigger_onerror(@handshake.error)
+          close
+        end
+      end
+
+      def handle_open(data)
+        @frame << data
+        while frame = @frame.next
+          case frame.type
+          when :close
+            @state = :closing
+            close
+            trigger_onclose(frame.to_s)
+          when :ping
+            pong(frame.to_s)
+            trigger_onping(frame.to_s)
+          when :pong
+            trigger_onpong(frame.to_s)
+          when :text
+            trigger_onmessage(frame.to_s, :text)
+          when :binary
+            trigger_onmessage(frame.to_s, :binary)
+          end
+        end
+        unbind if @frame.error?
+      end
+
+      def handle_closing(data)
+        @state = :closed
+        close
+        trigger_onclose
+      end
+
+      def debug(description, data)
+        return unless @debug
+        puts(description + data.bytes.to_a.collect{|b| '\x' + b.to_s(16).rjust(2, '0')}.join) unless @state == :connecting
+      end
+
+    end
+  end
+end

data/lib/websocket/eventmachine/server/version.rb

@@ -0,0 +1,7 @@
+module WebSocket
+  module EventMachine
+    class Server
+      VERSION = '1.0.0'
+    end
+  end
+end

data/websocket-eventmachine-server.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "websocket/eventmachine/server/version"
+
+Gem::Specification.new do |s|
+  s.name        = "websocket-eventmachine-server"
+  s.version     = WebSocket::EventMachine::Server::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Bernard Potocki"]
+  s.email       = ["bernard.potocki@imanel.org"]
+  s.homepage    = "http://github.com/imanel/websocket-eventmachine-server"
+  s.summary     = %q{WebSocket server for Ruby}
+  s.description = %q{WebSocket server for Ruby}
+
+  s.add_dependency 'websocket', '~> 1.0'
+  s.add_dependency 'websocket-native', '~> 1.0'
+  s.add_dependency 'eventmachine', '~> 1.0'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: websocket-eventmachine-server
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Bernard Potocki
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: websocket
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: websocket-native
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: WebSocket server for Ruby
+email:
+- bernard.potocki@imanel.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- CHANGELOG.md
+- Gemfile
+- README.md
+- Rakefile
+- autobahn.json
+- examples/autobahn_server.rb
+- examples/echo_server.rb
+- lib/websocket-eventmachine-server.rb
+- lib/websocket/eventmachine/server.rb
+- lib/websocket/eventmachine/server/version.rb
+- websocket-eventmachine-server.gemspec
+homepage: http://github.com/imanel/websocket-eventmachine-server
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: WebSocket server for Ruby
+test_files: []