websocket-eventmachine-client 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,208 @@
+# WebSocket Client for Ruby
+
+WebSocket-EventMachine-Client is Ruby WebSocket client based on EventMachine.
+
+- [Autobahn tests](http://imanel.github.com/websocket-ruby/autobahn/client)
+- [Docs](http://rdoc.info/github/imanel/websocket-eventmachine-client/master/frames)
+
+## Installation
+
+``` bash
+gem install websocket-eventmachine-client
+```
+
+or in Gemfile
+
+``` ruby
+gem 'websocket-eventmachine-client'
+```
+
+## Simple client example
+
+```ruby
+EM.run do
+
+  ws = WebSocket::EventMachine::Client.connect(:uri => 'ws://localhost:8080')
+
+  ws.onopen do
+    puts "Connected"
+  end
+
+  ws.onmessage do |msg, type|
+    puts "Received message: #{msg}"
+  end
+
+  ws.onclose do
+    puts "Disconnected"
+  end
+
+  ws.send "Hello Server!"
+
+end
+```
+
+## Options
+
+Following options can be passed to WebSocket::EventMachine::Client initializer:
+
+- `[String] :host` - IP or host of server to connect
+- `[Integer] :port` - Port of server to connect
+- `[String] :uri` - Full URI for server(optional - use instead of host/port combination)
+- `[Integer] :version` - Version of WebSocket to use. Default: 13
+
+## Methods
+
+Following methods are available for WebSocket::EventMachine::Client object:
+
+### onopen
+
+Called after successfully connecting.
+
+Example:
+
+```ruby
+ws.onopen do
+  puts "Client connected"
+end
+```
+
+### onclose
+
+Called after closing connection.
+
+Example:
+
+```ruby
+ws.onclose do
+  puts "Client disconnected"
+end
+```
+
+### onmessage
+
+Called when client receive message.
+
+Parameters:
+
+- `[String] message` - content of message
+- `[Symbol] type` - type is type of message(:text or :binary)
+
+Example:
+
+```ruby
+ws.onmessage do |msg, type|
+  puts "Received message: #{msg} or type: #{type}"
+end
+```
+
+### onerror
+
+Called when client discovers error.
+
+Parameters:
+
+- `[String] error` - error reason.
+
+Example:
+
+```ruby
+ws.onerror do |error|
+  puts "Error occured: #{error}"
+end
+```
+
+### onping
+
+Called when client receive ping request. Pong request is sent automatically.
+
+Parameters:
+
+- `[String] message` - message for ping request.
+
+Example:
+
+```ruby
+ws.onping do |message|
+  puts "Ping received: #{message}"
+end
+```
+
+### onpong
+
+Called when client receive pong response.
+
+Parameters:
+
+- `[String] message` - message for pong response.
+
+Example:
+
+```ruby
+ws.onpong do |message|
+  puts "Pong received: #{message}"
+end
+```
+
+### send
+
+Sends message to server.
+
+Parameters:
+
+- `[String] message` - message that should be sent to client
+- `[Hash] params` - params for message(optional)
+  - `[Symbol] :type` - type of message. Valid values are :text, :binary(default is :text)
+
+Example:
+
+```ruby
+ws.send "Hello Server!"
+ws.send "binary data", :type => :binary
+```
+
+### close
+
+Closes connection and optionally send close frame to server.
+
+Parameters:
+
+- `[Integer] code` - code of closing, according to WebSocket specification(optional)
+- `[String] data` - data to send in closing frame(optional)
+
+Example:
+
+```ruby
+ws.close
+```
+
+### ping
+
+Sends ping request.
+
+Parameters:
+
+- `[String] data` - data to send in ping request(optional)
+
+Example:
+
+```ruby
+ws.ping 'Hi'
+```
+
+### pong
+
+Sends pong request. Usually there should be no need to send this request, as pong responses are sent automatically by client.
+
+Parameters:
+
+- `[String] data` - data to send in pong request(optional)
+
+Example:
+
+``` ruby
+ws.pong 'Hello'
+```
+
+## 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 client"
+task :autobahn do
+  system('wstest --mode=fuzzingserver --spec=autobahn.json')
+end

data/autobahn.json

@@ -0,0 +1,11 @@
+{
+   "url": "ws://127.0.0.1:9001",
+
+   "options": {"failByDrop": false},
+   "outdir": "./autobahn",
+   "webport": 8080,
+
+   "cases": ["*"],
+   "exclude-cases": [],
+   "exclude-agent-cases": {}
+}

data/examples/autobahn_client.rb

@@ -0,0 +1,50 @@
+require File.expand_path('../../lib/websocket-eventmachine-client', __FILE__)
+
+require 'cgi'
+
+EM.epoll
+EM.run do
+
+  host   = 'ws://localhost:9001'
+  agent  = "WebSocket-EventMachine-Client (1.0.0)"
+  cases  = 0
+  skip   = []
+
+  ws = WebSocket::EventMachine::Client.connect(:uri => "#{host}/getCaseCount")
+
+  ws.onmessage do |msg, type|
+    puts "$ Total cases to run: #{msg}"
+    cases = msg.to_i
+  end
+
+  ws.onclose do
+
+    run_case = lambda do |n|
+
+      if n > cases
+        puts "$ Requesting report"
+        ws = WebSocket::EventMachine::Client.connect(:uri => "#{host}/updateReports?agent=#{CGI.escape agent}")
+        ws.onclose do
+          EM.stop
+        end
+
+      elsif skip.include?(n)
+        EM.next_tick { run_case.call(n+1) }
+
+      else
+        ws = WebSocket::EventMachine::Client.connect(:uri => "#{host}/runCase?case=#{n}&agent=#{CGI.escape agent}")
+
+        ws.onmessage do |msg, type|
+          ws.send(msg, :type => type)
+        end
+
+        ws.onclose do |msg|
+          EM.add_timer(0.1) { run_case.call(n + 1) }
+        end
+      end
+    end
+
+    run_case.call(1)
+  end
+
+end

data/examples/echo_client.rb

@@ -0,0 +1,42 @@
+require File.expand_path('../../lib/websocket-eventmachine-client', __FILE__)
+
+EM.epoll
+EM.run do
+
+  trap("TERM") { stop }
+  trap("INT")  { stop }
+
+  ws = WebSocket::EventMachine::Client.connect(:uri => "ws://localhost:9001");
+
+  ws.onopen do
+    puts "Connected"
+    ws.send "Hello"
+  end
+
+  ws.onmessage do |msg, type|
+    puts "Received message: #{msg}"
+    ws.send msg, :type => type
+  end
+
+  ws.onclose do
+    puts "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
+
+  def stop
+    puts "Terminating connection"
+    EventMachine.stop
+  end
+
+end

data/lib/websocket-eventmachine-client.rb

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

data/lib/websocket/eventmachine/client.rb

@@ -0,0 +1,134 @@
+require 'websocket-eventmachine-base'
+require 'uri'
+
+module WebSocket
+  module EventMachine
+
+    # WebSocket Client (using EventMachine)
+    # @example
+    #   ws = WebSocket::EventMachine::Client.connect(:host => "0.0.0.0", :port => 8080)
+    #   ws.onmessage { |msg| ws.send "Pong: #{msg}" }
+    #   ws.send "data"
+    class Client < Base
+
+      ###########
+      ### API ###
+      ###########
+
+      # Connect to websocket server
+      # @param args [Hash] The request arguments
+      # @option args [String] :host The host IP/DNS name
+      # @option args [Integer] :port The port to connect too(default = 80)
+      # @option args [Integer] :version Version of protocol to use(default = 13)
+      def self.connect(args = {})
+        host = nil
+        port = nil
+        if args[:uri]
+          uri = URI.parse(args[:uri])
+          host = uri.host
+          port = uri.port
+        end
+        host = args[:host] if args[:host]
+        port = args[:port] if args[:port]
+        port ||= 80
+
+        ::EventMachine.connect host, port, self, args
+      end
+
+      # Initialize connection
+      # @param args [Hash] Arguments for connection
+      # @option args [String] :host The host IP/DNS name
+      # @option args [Integer] :port The port to connect too(default = 80)
+      # @option args [Integer] :version Version of protocol to use(default = 13)
+      def initialize(args)
+        @args = args
+      end
+
+      ############################
+      ### EventMachine methods ###
+      ############################
+
+      # Called after initialize of connection, but before connecting to server
+      # Eventmachine internal
+      # @private
+      def post_init
+        @state = :connecting
+        @handshake = WebSocket::Handshake::Client.new(@args)
+      end
+
+      # Called by EventMachine after connecting.
+      # Sends handshake to server
+      # Eventmachine internal
+      # @private
+      def connection_completed
+        send(@handshake.to_s, :type => :plain)
+      end
+
+      private
+
+      def incoming_frame
+        WebSocket::Frame::Incoming::Client
+      end
+
+      def outgoing_frame
+        WebSocket::Frame::Outgoing::Client
+      end
+
+      public
+
+      #########################
+      ### Inherited methods ###
+      #########################
+
+      # Called when connection is opened.
+      # No parameters are passed to block
+      def onopen(&blk); super; end
+
+      # Called when connection is closed.
+      # No parameters are passed to block
+      def onclose(&blk); super; end
+
+      # Called when error occurs.
+      # One parameter passed to block:
+      #   error - string with error message
+      def onerror(&blk); super; end
+
+      # Called when message is received.
+      # Two parameters passed to block:
+      #   message - string with received message
+      #   type - type of message. Valid values are :text and :binary
+      def onmessage(&blk); super; end
+
+      # Called when ping message is received
+      # One parameter passed to block:
+      #   message - string with ping message
+      def onping(&blk); super; end
+
+      # Called when pond message is received
+      # One parameter passed to block:
+      #   message - string with pong message
+      def onpong(&blk); super; end
+
+      # Send data
+      # @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 = {}); super; end
+
+      # Close connection
+      # @return [Boolean] true if connection is closed immediately, false if waiting for other side to close connection
+      def close(code = 1000, data = nil); super; end
+
+      # Send ping message
+      # @return [Boolean] false if protocol version is not supporting ping requests
+      def ping(data = ''); super; end
+
+      # Send pong message
+      # @return [Boolean] false if protocol version is not supporting pong requests
+      def pong(data = ''); super; end
+
+    end
+  end
+end

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

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

data/websocket-eventmachine-client.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "websocket/eventmachine/client/version"
+
+Gem::Specification.new do |s|
+  s.name        = "websocket-eventmachine-client"
+  s.version     = WebSocket::EventMachine::Client::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Bernard Potocki"]
+  s.email       = ["bernard.potocki@imanel.org"]
+  s.homepage    = "http://github.com/imanel/websocket-eventmachine-client"
+  s.summary     = %q{WebSocket client for Ruby}
+  s.description = %q{WebSocket client for Ruby}
+
+  s.add_dependency 'websocket-eventmachine-base', '~> 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,73 @@
+--- !ruby/object:Gem::Specification
+name: websocket-eventmachine-client
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Bernard Potocki
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: websocket-eventmachine-base
+  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 client for Ruby
+email:
+- bernard.potocki@imanel.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- CHANGELOG.md
+- Gemfile
+- README.md
+- Rakefile
+- autobahn.json
+- examples/autobahn_client.rb
+- examples/echo_client.rb
+- lib/websocket-eventmachine-client.rb
+- lib/websocket/eventmachine/client.rb
+- lib/websocket/eventmachine/client/version.rb
+- websocket-eventmachine-client.gemspec
+homepage: http://github.com/imanel/websocket-eventmachine-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.24
+signing_key: 
+specification_version: 3
+summary: WebSocket client for Ruby
+test_files: []