em-ws-client 0.1

data/.gitignore

@@ -0,0 +1 @@
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,5 @@
+# A sample Gemfile
+source "http://rubygems.org"
+
+gem "eventmachine"
+gem "state_machine", "= 1.0.0"

data/README.markdown

@@ -0,0 +1,40 @@
+# EM WebSocket Client
+Mimics the browser client implementation to some degree.  Currently implements hixie draft 10.
+
+# Installing
+```bash
+$ gem install em-ws-client
+```
+
+# Establishing a Connection
+
+```ruby
+EM.run do
+
+  # Establish the connection
+  connection = EM::WebSocketClient.new("ws://server/path")
+
+  connection.onopen do
+    # Handle open event
+  end
+
+  conn.onclose do
+    # Handle close event
+  end
+
+end
+```
+
+# Sending Data
+Send data as a string.  It can be JSON, CSV, etc.  As long
+as you can serialize it.
+
+```ruby
+connection.send_data "message"
+
+# JSON
+connection.send_data {
+  :category => "fun",
+  :message => "times"
+}.to_json
+```

data/Rakefile

@@ -0,0 +1 @@
+$: << File.dirname(__FILE__) + "/lib"

data/em-ws-client.gemspec

@@ -0,0 +1,19 @@
+spec = Gem::Specification.new do |s|
+  s.name = "em-ws-client"
+  s.version = "0.1"
+  s.date = "2011-09-26"
+  s.summary = "EventMachine WebSocket Client"
+  s.email = "dan@shove.io"
+  s.homepage = "https://github.com/dansimpson/em-ws-client"
+  s.description = "A simple, fun, evented WebSocket client for your ruby projects"
+  s.has_rdoc = true
+  
+  s.add_dependency("eventmachine", "= 0.12.10")
+  s.add_dependency("state_machine", "= 1.0.2")
+
+  s.authors = ["Dan Simpson"]
+
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
+
+end

data/example/echo.rb

@@ -0,0 +1,33 @@
+$: << File.dirname(__FILE__) + "/../lib/"
+
+require "em-websocket-client"
+
+
+dec = EM::Draft10Decoder.new
+enc = EM::Draft10Encoder.new
+
+puts dec.decode(enc.encode("monkey"))
+
+EM.run do
+
+  conn = EM::WebSocketClient.new("ws://localhost:8080/test")
+  puts conn.state
+  puts conn.disconnected?
+
+  conn.onopen do
+    puts "Opened"
+
+    EM.add_periodic_timer(2) do
+      conn.send_data "Ping!"
+    end
+  end
+
+  conn.onclose do
+    puts "Closed"
+  end
+
+  conn.onmessage do |msg|
+    puts msg
+  end
+
+end

data/lib/codec/draft10decoder.rb

@@ -0,0 +1,122 @@
+module EM
+
+  # A replaying decoder for the IETF Hybi
+  # WebSocket protocol specification
+  class Draft10Decoder
+
+    CONTINUATION  = 0x0
+    TEXT_FRAME    = 0x1
+    BINARY_FRAME  = 0x2
+    CLOSE         = 0x8
+    PING          = 0x9
+    PONG          = 0xA
+
+    def initialize
+      @buffer = ""
+      @chunks = ""
+    end
+
+    # Decode a WebSocket frame
+    # +data+ the frame data
+    # returns false if the packet is incomplete
+    # and a decoded message otherwise
+    def decode data
+
+      # broken frame
+      if data && data.length < 2
+        return false
+      end
+
+      # put the data into the buffer, as
+      # we might be replaying
+      @buffer << data
+
+      # decode the first 2 bytes, with
+      # opcode, lengthgth, masking bit, and frag bit
+      h1, h2 = @buffer.unpack("CC")
+
+      # check the fragmentation bit to see
+      # if this is a message fragment
+      @chunked = ((h1 & 0x80) != 0x80)
+
+      # used to keep track of our position in the buffer
+      offset = 2
+
+      # see above for possible opcodes
+      opcode = (h1 & 0x0F)
+
+      # the leading length idicator
+      length = (h2 & 0x7F)
+
+      # masking bit, is the data masked with
+      # a specified masking key?
+      masked = ((h2 & 0x80) == 0x80)
+
+      # spare no bytes hybi!
+      if length > 125
+        if length == 126
+          length = @buffer.unpack("@#{offset}n").first
+          offset += 2
+        else
+          length1, length2 = @buffer.unpack("@#{offset}NN")
+          # TODO.. bigint?
+          offset += 8
+        end
+      end
+
+      # unpack the masking key
+      if masked
+        key = @buffer.unpack("@#{offset}N").first
+        offset += 4
+      end
+
+      # replay on next frame
+      if @buffer.size < (length + offset)
+        return false
+      end
+
+      # Read the important bits
+      payload = @buffer.unpack("@#{offset}C*")
+
+      # Unmask the data if it's masked
+      if masked
+        payload.size.times do |i|
+          payload[i] = ((payload[i] ^ (key >> ((3 - (i % 4)) * 8))) & 0xFF)
+        end
+      end
+      
+      # finally, extract the message!
+      payload = payload.pack("C*")
+
+      case opcode
+      when CONTINUATION
+        @chunks << payload
+        unless @chunked
+          result = @chunks
+          @chunks = ""
+          return result
+        end
+        false
+      when TEXT_FRAME
+        unless @chunked
+          @buffer = ""
+          #@buffer.slice!(offset + length, -1)
+          return payload
+        end
+        false
+      when BINARY_FRAME
+        false #TODO
+      when CLOSE
+        false #TODO
+      when PING
+        false #TODO send pong
+      when PONG
+        false
+      else
+        false
+      end
+    end
+
+
+  end
+end

data/lib/codec/draft10encoder.rb

@@ -0,0 +1,45 @@
+module EM
+  class Draft10Encoder
+
+    # Encode a standard payload to a hybi10
+    # WebSocket frame
+  	def encode data
+      frame = []
+      frame << (0x1 | 0x80)
+
+      packr = "CC"
+
+      # append frame length and mask bit 0x80
+      len = data.size
+      if len <= 125
+        frame << (len | 0x80)
+      elsif length < 65536
+        frame << (126 | 0x80)
+        frame << (len)
+        packr << "n"
+      else
+        frame << (127 | 0x80)
+        frame << (len >> 32)
+        frame << (len & 0xFFFFFFFF)
+        packr << "NN"
+      end
+
+      # generate a masking key
+      key = rand(2 ** 31)
+
+      # mask each byte with the key
+      frame << key
+      packr << "N"
+
+      # The spec says we have to waste cycles and
+      # impact the atmosphere with a small amount of
+      # heat dissapation
+      data.size.times do |i|
+        frame << ((data.getbyte(i) ^ (key >> ((3 - (i % 4)) * 8))) & 0xFF)
+      end
+
+      frame.pack("#{packr}C*")
+  	end
+
+  end
+end

data/lib/em-websocket-client.rb

@@ -0,0 +1,196 @@
+require "rubygems"
+require "eventmachine"
+require "state_machine"
+require "uri"
+require "digest/sha1"
+require "base64"
+require "codec/draft10encoder.rb"
+require "codec/draft10decoder.rb"
+
+
+module EM
+  class WebSocketClient
+    
+    Version = "0.1"
+
+    class WebSocketConnection < EM::Connection
+
+      def client=(client)
+        @client = client
+        @client.connection = self
+      end
+
+      def receive_data(data)
+        @client.receive_data data
+      end
+
+      def unbind(reason=nil)
+        @client.disconnect
+      end
+
+    end
+
+    attr_accessor :connection
+
+    state_machine :initial => :disconnected do
+
+      # States
+      state :disconnected
+      state :connecting
+      state :negotiating
+      state :established
+      state :failed
+
+      after_transition :to => :connecting, :do => :connect
+      after_transition :to => :negotiating, :do => :on_negotiating
+      after_transition :to => :established, :do => :on_established
+
+      event :start do
+        transition :disconnected => :connecting
+      end
+
+      event :negotiate do
+        transition :connecting => :negotiating
+      end
+
+      event :complete do
+        transition :negotiating => :established
+      end
+
+      event :error do
+        transition all => :failed
+      end
+
+      event :disconnect do
+        transition all => :disconnected
+      end
+
+    end
+
+    def initialize uri, origin="em-websocket-client"
+      super();
+
+      @uri = URI.parse(uri)
+      @origin = origin
+      @queue = []
+
+      @encoder = Draft10Encoder.new
+      @decoder = Draft10Decoder.new
+      
+      @request_key = build_request_key
+      @buffer = ""
+
+      start
+    end
+
+    # Called on opening of the websocket
+    def onopen &block
+      @open_handler = block
+    end
+    
+    # Called on the close of the connection
+    def onclose &block
+      @cblock = block
+    end
+    
+    # Called when a message is received
+    def onmessage &block
+      @message_handler = block
+    end
+    
+    # EM callback
+    def receive_data(data)
+      if negotiating?
+        @buffer << data
+        request, rest = @buffer.split("\r\n\r\n", 2)
+        if rest
+          @buffer = ""
+          handle_response(request)
+          receive_data rest
+        end
+      else
+        message = @decoder.decode(data)
+        if message
+          if @message_handler
+           @message_handler.call(message)
+         end
+        end
+      end
+    end
+
+    # Send a WebSocket frame to the remote
+    # host.
+    def send_data data
+      if established?
+        connection.send_data(@encoder.encode(data))
+      else
+        @queue << data
+      end
+    end
+
+    private
+
+    # Connect to the remote host and synchonize the connection
+    # and this client object
+    def connect
+      EM.connect @uri.host, @uri.port || 80, WebSocketConnection do |conn|
+        conn.client = self
+        negotiate
+      end
+    end
+
+    # Send HTTP request with upgrade goodies
+    # to the remote host
+    def on_negotiating
+      request = "GET #{@uri.path} HTTP/1.1\r\n"
+      request << "Upgrade: WebSocket\r\n"
+      request << "Connection: Upgrade\r\n"
+      request << "Host: #{@uri.host}\r\n"
+      request << "Sec-WebSocket-Key: #{@request_key}\r\n"
+      request << "Sec-WebSocket-Version: 8\r\n"
+      request << "Sec-WebSocket-Origin: #{@origin}\r\n"
+      request << "\r\n"
+      connection.send_data(request)
+    end
+
+    def on_established
+      if @open_handler
+        @open_handler.call
+      end
+      
+      while !@queue.empty?
+        send_data @queue.shift
+      end
+    end
+
+    # Handle the HTTP response and ensure it's valid
+    # by checking the Sec-WebSocket-Accept header
+    def handle_response response
+      lines = response.split("\r\n")
+      table = {}
+
+      lines.each do |line|
+        header = /^([^:]+):\s*(.+)$/.match(line)
+        table[header[1].downcase.strip] = header[2].strip if header
+      end
+
+      if table["sec-websocket-accept"] == build_response_key
+        complete
+      else
+        error
+      end
+    end
+
+    # Build a unique request key to match against
+    def build_request_key
+      Base64.encode64(Time.now.to_i.to_s(16)).chomp
+    end
+
+    # Build the response key from the given request key
+    # for comparison with the response value.
+    def build_response_key
+      Base64.encode64(Digest::SHA1.digest("#{@request_key}258EAFA5-E914-47DA-95CA-C5AB0DC85B11")).chomp
+    end
+    
+  end
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: em-ws-client
+version: !ruby/object:Gem::Version
+  version: '0.1'
+  prerelease: 
+platform: ruby
+authors:
+- Dan Simpson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-09-26 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: &70353611766080 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - =
+      - !ruby/object:Gem::Version
+        version: 0.12.10
+  type: :runtime
+  prerelease: false
+  version_requirements: *70353611766080
+- !ruby/object:Gem::Dependency
+  name: state_machine
+  requirement: &70353611765580 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - =
+      - !ruby/object:Gem::Version
+        version: 1.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: *70353611765580
+description: A simple, fun, evented WebSocket client for your ruby projects
+email: dan@shove.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.markdown
+- Rakefile
+- em-ws-client.gemspec
+- example/echo.rb
+- lib/codec/draft10decoder.rb
+- lib/codec/draft10encoder.rb
+- lib/em-websocket-client.rb
+- spec/em-ws-client.rb
+homepage: https://github.com/dansimpson/em-ws-client
+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.6
+signing_key: 
+specification_version: 3
+summary: EventMachine WebSocket Client
+test_files:
+- spec/em-ws-client.rb