em-ws-client 0.1.2 → 0.2.0

data/em-ws-client.gemspec

@@ -1,7 +1,11 @@
+$:.unshift File.dirname(__FILE__) + "/lib"
+
+require "em-ws-client"
+
 spec = Gem::Specification.new do |s|
   s.name = "em-ws-client"
-  s.version = "0.1.2"
-  s.date = "2011-09-26"
+  s.version = EM::WebSocketClient::Version
+  s.date = "2012-04-14"
   s.summary = "EventMachine WebSocket Client"
   s.email = "dan@shove.io"
   s.homepage = "https://github.com/dansimpson/em-ws-client"
@@ -9,7 +13,6 @@ spec = Gem::Specification.new do |s|
   s.has_rdoc = true
   
   s.add_dependency("eventmachine", "~> 1.0.0.beta.4")
-  s.add_dependency("state_machine", "~> 1.0.2")
 
   s.authors = ["Dan Simpson"]
 

data/lib/em-ws-client.rb

@@ -1,196 +1,16 @@
 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.2"
-
-    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
+require "digest/sha1"
 
-    # 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
-    
+module EventMachine
+  module WebSocketCodec
   end
-end
+end
+
+require "em-ws-client/handshake.rb"
+require "em-ws-client/protocol.rb"
+require "em-ws-client/encoder.rb"
+require "em-ws-client/decoder.rb"
+require "em-ws-client/client.rb"

data/lib/em-ws-client/client.rb

@@ -0,0 +1,300 @@
+# encoding: UTF-8
+
+module EventMachine
+
+  # Public: A fully functional WebSocket client
+  # implementation.
+  #
+  # Examples
+  #
+  #   ws = WebSocketClient.new "ws://localhost/chat"
+  #
+  #   ws.onmessage do |msg|
+  #     puts msg
+  #   end
+  #
+  #   ws.onopen do
+  #     ws.send_message "Hello!"
+  #   end
+  class WebSocketClient
+    
+    Version = "0.2.0"
+    
+    class WebSocketError < StandardError; end
+
+    # Internal: Wrapper
+    class WebSocketConnection < EM::Connection
+
+      def client=(client)
+        @client = client
+        @client.socket = self
+      end
+
+      def receive_data(data)
+        @client.receive_data data
+      end
+
+      def unbind(reason=nil)
+        @client.unbind
+      end
+
+    end
+
+    include WebSocketCodec::Protocol
+
+    attr_accessor :socket
+
+    # Public: Initialize a WebSocket client
+    #
+    # uri - The endpoint host url
+    # origin - The origin you wish to claim
+    #
+    # Examples
+    #
+    #   WebSocketClient.new "ws://localhost:9000/chat"
+    #   WebSocketClient.new "ws://ws.site.com/chat", "http://www.site.com/chat"
+    #
+    # Returns the client
+    def initialize uri, origin="em-ws-client"
+      super();
+
+      @uri     = URI.parse(uri)
+      @origin  = origin
+      @buffer  = ""
+      
+      @encoder = WebSocketCodec::Encoder.new
+      @decoder = WebSocketCodec::Decoder.new
+      @handshake = WebSocketCodec::Handshake.new @uri, @origin
+      
+      @callbacks = {}
+      @closing = false
+
+      connect
+    end
+
+    # Public: Close the connection
+    #
+    # Examples
+    #
+    #   ws.unbind
+    #   # => ?
+    #
+    # Returns
+    def unbind
+      emit :close
+    end
+
+    # Bind a callback to the open event
+    #
+    # block - A block which is called when
+    # the connection to the remote host is established
+    #
+    # Examples
+    #
+    #   ws.onopen do
+    #   end
+    #
+    # Returns nothing
+    def onopen &block
+      @callbacks[:open] = block
+    end
+    
+    # Bind a callback to the close event
+    #
+    # block - A block which is called when
+    # the connection to the remote host is closed.
+    # Your block receives 2 arguments, with the second
+    # potentially being nil.
+    #
+    # Examples
+    #
+    #   ws.onclose do |code, explain|
+    #   end
+    #
+    # Returns nothing
+    def onclose &block
+      @callbacks[:close] = block
+    end
+    
+    # Bind a callback to the message event
+    #
+    # block - A block which is called when a
+    # message is received. The first argument
+    # for the block is the message, and the second
+    # argument is a binary flag.
+    #
+    # Examples
+    #
+    #   ws.onmessage do |message, binary|
+    #   end
+    #
+    # Returns nothing
+    def onmessage &block
+      @callbacks[:frame] = block
+    end
+    
+    # Bind a callback to the error event
+    #
+    # block - A block which is called when
+    # an error occurs.  The connection is dropped
+    # immediately per spec.  The first argument is
+    # the close code, and the second is the error.
+    #
+    # Examples
+    #
+    #   ws.onerror do |close_code, error|
+    #   end
+    #
+    # Returns nothing
+    def onerror &block
+      @callbacks[:error] = block
+    end
+
+    # Bind a callback to the ping event
+    #
+    # block - A block which is called when
+    # the remote host sends a ping.  A single
+    # argument is sent, which contains the ping
+    # data sent from the remote host.  A pong
+    # is automatically sent.
+    #
+    # Examples
+    #
+    #   ws.onping do |data|
+    #   end
+    #
+    # Returns nothing
+    def onping &block
+      @callbacks[:ping] = block
+    end
+    
+    # Bind a callback to the pong event
+    #
+    # block - A block which is called when
+    # the remote host sends a pong in response
+    # to your ping.  It's possible to get unwarrented
+    # pongs.
+    #
+    # Examples
+    #
+    #   ws.onpong do |data|
+    #   end
+    #
+    # Returns nothing
+    def onpong &block
+      @callbacks[:pong] = block
+    end
+
+    # Internal: called by eventmachine when data is
+    # received
+    def receive_data(data)
+      if @handshake.complete?
+        receive_message_data data
+      else
+        receive_handshake_data data
+      end
+    end
+
+
+    # Send a message to the remote host
+    #
+    # data - The string contents of your message
+    #
+    # Examples
+    #
+    #   ws.onping do |data|
+    #   end
+    #
+    # Returns nothing
+    def send_message data, binary=false
+      if established?
+        unless @closing
+          @socket.send_data(@encoder.encode(data.to_s, binary ? BINARY_FRAME : TEXT_FRAME))
+        end
+      else
+        raise WebSocketError.new "can't send on a closed channel"
+      end
+    end
+
+    def close code=1000, msg=nil
+      @closing = true
+      @socket.send_data @encoder.close(code, msg)
+      @socket.close_connection_after_writing
+    end
+
+    private
+
+    # Internal: is the handshake complete and valid?
+    def established?
+      @handshake.complete? && @handshake.valid?
+    end
+
+    # Internal: process ws data
+    def receive_message_data data
+      @decoder << data
+    end
+
+    # Internal: process handshake data
+    def receive_handshake_data data
+      @handshake << data
+      if @handshake.complete?
+        if @handshake.valid?
+          on_handshake_complete
+        else
+          emit :error, 1, "Handshake failed!"
+          @socket.unbind
+        end
+      end
+    end
+
+    # Internal: setup encoder/decoder and bind
+    # to all decoder events.
+    def on_handshake_complete
+
+      @decoder.onping do |data|
+        @socket.send_data @encoder.pong(data)
+        emit :ping, data
+      end
+
+      @decoder.onpong do |data|
+        emit :pong, data
+      end
+
+      @decoder.onclose do |code|
+        close code
+      end
+
+      @decoder.onframe do |frame, binary|
+        emit :frame, frame, binary
+      end
+
+      @decoder.onerror do |code, message|
+        close code, message
+        emit :error, code, message
+      end
+
+      emit :open
+
+      if @handshake.extra
+       receive_message_data @handshake.extra
+      end
+    end
+
+    # Internal: Connect to the remote host and synchonize the socket
+    # and this client object
+    def connect
+      EM.connect @uri.host, @uri.port || 80, WebSocketConnection do |conn|
+        conn.client = self
+        conn.send_data(@handshake.request)
+      end
+    end
+
+    # Internal: Emit an event
+    def emit event, *args
+      if @callbacks.key?(event)
+        @callbacks[event].call(*args)
+      end
+    end
+
+  end
+end