socky-client 0.4.2

data/CHANGELOG.md

@@ -0,0 +1,25 @@
+Changelog
+=========
+
+## 0.4.2 / 2010-10-29
+
+- new features:
+  - change config_path and config from constant to method
+- bugfixes:
+  - none
+
+## 0.4.1 / 2010-10-28
+
+- new features:
+  - none
+- bugfixes:
+  - require by 'socky-client' to stop interfering with socky-ruby-server
+  - return 'true' after successful sending message
+
+## 0.4.0 / 2010-10-28
+
+- new features:
+  - split project to 3 parts - socky-client-ruby, socky-client-rails and socky-js
+  - release as gem
+- bugfixes:
+  - none

data/README.md

@@ -0,0 +1,25 @@
+Socky - client in Ruby
+===========
+
+Socky is push server for Ruby based on WebSockets. It allows you to break border between your application and client browser by letting the server initialize a connection and push data to the client.
+
+## Getting Started
+
+- [Install](http://github.com/socky/socky-client-ruby/wiki/install) the gem
+- Read up about its [Usage](http://github.com/socky/socky-client-ruby/wiki/usage) and [Configuration](http://github.com/socky/socky-client-ruby/wiki/configuration)
+- Try [Example Application](http://github.com/socky/socky-example) or [demo page](http://sockydemo.imanel.org)
+- Fork and Contribute your own modifications
+- See [sites using socky](http://github.com/socky/socky-server-ruby/wiki/sites)
+- Discuss on [google group](http://groups.google.com/group/socky-framework)
+
+## License
+
+(The MIT License)
+
+Copyright (c) 2010 Bernard Potocki 
+
+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/Rakefile

@@ -0,0 +1,27 @@
+require 'rake'
+require 'rake/clean'
+CLEAN.include %w(**/*.{log,rbc})
+
+require 'rspec/core/rake_task'
+
+task :default => :spec
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "socky-client"
+    gemspec.summary = "Socky is a WebSocket server and client for Ruby"
+    gemspec.description = "Socky is a WebSocket server and client for Ruby"
+    gemspec.email = "bernard.potocki@imanel.org"
+    gemspec.homepage = "http://imanel.org/projects/socky"
+    gemspec.authors = ["Bernard Potocki"]
+    gemspec.add_dependency 'json'
+    gemspec.add_development_dependency 'rspec', '~> 2.0'
+    gemspec.files.exclude ".gitignore"
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end

data/VERSION

@@ -0,0 +1 @@
+0.4.2

data/lib/socky-client.rb

@@ -0,0 +1,116 @@
+require 'yaml'
+require 'json'
+
+require File.dirname(__FILE__) + '/socky-client/websocket'
+
+module Socky
+
+  class << self
+    
+    attr_accessor :config_path
+    def config_path
+      @config_path ||= 'socky_hosts.yml'
+    end
+    
+    def config
+      @config ||= YAML.load_file(config_path).freeze
+    end
+
+    def send(*args)
+      options = normalize_options(*args)
+      send_message(options.delete(:data), options)
+    end
+
+    def show_connections
+      send_query(:show_connections)
+    end
+
+    def hosts
+      config[:hosts]
+    end
+
+  private
+
+    def normalize_options(data, options = {})
+      case data
+        when Hash
+          options, data = data, nil
+        when String, Symbol
+          options[:data] = data
+      else
+        options.merge!(:data => data)
+      end
+
+      options[:data] = options[:data].to_s
+      options
+    end
+
+    def send_message(data, opts = {})
+      to = opts[:to] || {}
+      except = opts[:except] || {}
+
+      unless to.is_a?(Hash) && except.is_a?(Hash)
+        raise "recipiend data should be in hash format"
+      end
+
+      to_clients = to[:client] || to[:clients]
+      to_channels = to[:channel] || to[:channels]
+      except_clients = except[:client] || except[:clients]
+      except_channels = except[:channel] || except[:channels]
+
+      # If clients or channels are non-nil but empty then there's no users to target message
+      return if (to_clients.is_a?(Array) && to_clients.empty?) || (to_channels.is_a?(Array) && to_channels.empty?)
+
+      hash = {
+        :command  => :broadcast,
+        :body     => data,
+        :to => {
+          :clients  => to_clients,
+          :channels => to_channels,
+        },
+        :except => {
+          :clients  => except_clients,
+          :channels => except_channels,
+        }
+      }
+
+      [:to, :except].each do |type|
+        hash[type].reject! { |key,val| val.nil? || (type == :except && val.empty?)}
+        hash.delete(type) if hash[type].empty?
+      end
+
+      send_data(hash)
+    end
+
+    def send_query(type)
+      hash = {
+        :command  => :query,
+        :type     => type
+      }
+      send_data(hash, true)
+    end
+
+    def send_data(hash, response = false)
+      res = []
+      hosts.each do |address|
+        begin
+          scheme = (address[:secure] ? "wss" : "ws")
+          @socket = WebSocket.new("#{scheme}://#{address[:host]}:#{address[:port]}/?admin=1&client_secret=#{address[:secret]}")
+          @socket.send(hash.to_json)
+          res << @socket.receive if response
+        rescue
+          puts "ERROR: Connection to server at '#{scheme}://#{address[:host]}:#{address[:port]}' failed"
+        ensure
+          @socket.close if @socket && !@socket.tcp_socket.closed?
+        end
+      end
+      if response
+        res.collect {|r| JSON.parse(r)["body"] }
+      else
+        true
+      end
+    end
+
+  end
+
+end

data/lib/socky-client/websocket.rb

@@ -0,0 +1,230 @@
+# Copyright: Hiroshi Ichikawa <http://gimite.net/en/>
+# Lincense: New BSD Lincense
+# Reference: http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol
+
+require "socket"
+require "uri"
+require "digest/md5"
+require "openssl"
+
+
+class WebSocket
+
+    class << self
+
+        attr_accessor(:debug)
+
+    end
+
+    class Error < RuntimeError
+
+    end
+
+    def initialize(arg, params = {})
+
+        uri = arg.is_a?(String) ? URI.parse(arg) : arg
+
+        if uri.scheme == "ws"
+          default_port = 80
+        elsif uri.scheme = "wss"
+          default_port = 443
+        else
+          raise(WebSocket::Error, "unsupported scheme: #{uri.scheme}")
+        end
+
+        @path = (uri.path.empty? ? "/" : uri.path) + (uri.query ? "?" + uri.query : "")
+        host = uri.host + (uri.port == default_port ? "" : ":#{uri.port}")
+        origin = params[:origin] || "http://#{uri.host}"
+        key1 = generate_key()
+        key2 = generate_key()
+        key3 = generate_key3()
+
+        socket = TCPSocket.new(uri.host, uri.port || default_port)
+
+        if uri.scheme == "ws"
+          @socket = socket
+        else
+          @socket = ssl_handshake(socket)
+        end
+
+        write(
+          "GET #{@path} HTTP/1.1\r\n" +
+          "Upgrade: WebSocket\r\n" +
+          "Connection: Upgrade\r\n" +
+          "Host: #{host}\r\n" +
+          "Origin: #{origin}\r\n" +
+          "Sec-WebSocket-Key1: #{key1}\r\n" +
+          "Sec-WebSocket-Key2: #{key2}\r\n" +
+          "\r\n" +
+          "#{key3}")
+        flush()
+
+        line = gets().chomp()
+        raise(WebSocket::Error, "bad response: #{line}") if !(line =~ /\AHTTP\/1.1 101 /n)
+        read_header()
+        if @header["Sec-WebSocket-Origin"] != origin
+          raise(WebSocket::Error,
+            "origin doesn't match: '#{@header["WebSocket-Origin"]}' != '#{origin}'")
+        end
+        reply_digest = read(16)
+        expected_digest = security_digest(key1, key2, key3)
+        if reply_digest != expected_digest
+          raise(WebSocket::Error,
+            "security digest doesn't match: %p != %p" % [reply_digest, expected_digest])
+        end
+        @handshaked = true
+
+      @closing_started = false
+    end
+
+    attr_reader(:header, :path)
+
+    def send(data)
+      if !@handshaked
+        raise(WebSocket::Error, "call WebSocket\#handshake first")
+      end
+      data = force_encoding(data.dup(), "ASCII-8BIT")
+      write("\x00#{data}\xff")
+      flush()
+    end
+
+    def receive()
+      if !@handshaked
+        raise(WebSocket::Error, "call WebSocket\#handshake first")
+      end
+      packet = gets("\xff")
+      return nil if !packet
+      if packet =~ /\A\x00(.*)\xff\z/nm
+        return force_encoding($1, "UTF-8")
+      elsif packet == "\xff" && read(1) == "\x00" # closing
+        if @server
+          @socket.close()
+        else
+          close()
+        end
+        return nil
+      else
+        raise(WebSocket::Error, "input must be either '\\x00...\\xff' or '\\xff\\x00'")
+      end
+    end
+
+    def tcp_socket
+      return @socket
+    end
+
+    def host
+      return @header["Host"]
+    end
+
+    def origin
+      return @header["Origin"]
+    end
+
+    # Does closing handshake.
+    def close()
+      return if @closing_started
+      write("\xff\x00")
+      @socket.close() if !@server
+      @closing_started = true
+    end
+
+    def close_socket()
+      @socket.close()
+    end
+
+  private
+
+    NOISE_CHARS = ("\x21".."\x2f").to_a() + ("\x3a".."\x7e").to_a()
+
+    def read_header()
+      @header = {}
+      while line = gets()
+        line = line.chomp()
+        break if line.empty?
+        if !(line =~ /\A(\S+): (.*)\z/n)
+          raise(WebSocket::Error, "invalid request: #{line}")
+        end
+        @header[$1] = $2
+      end
+      if @header["Upgrade"] != "WebSocket"
+        raise(WebSocket::Error, "invalid Upgrade: " + @header["Upgrade"])
+      end
+      if @header["Connection"] != "Upgrade"
+        raise(WebSocket::Error, "invalid Connection: " + @header["Connection"])
+      end
+    end
+
+    def gets(rs = $/)
+      line = @socket.gets(rs)
+      $stderr.printf("recv> %p\n", line) if WebSocket.debug
+      return line
+    end
+
+    def read(num_bytes)
+      str = @socket.read(num_bytes)
+      $stderr.printf("recv> %p\n", str) if WebSocket.debug
+      return str
+    end
+
+    def write(data)
+      if WebSocket.debug
+        data.scan(/\G(.*?(\n|\z))/n) do
+          $stderr.printf("send> %p\n", $&) if !$&.empty?
+        end
+      end
+      @socket.write(data)
+    end
+
+    def flush()
+      @socket.flush()
+    end
+
+    def security_digest(key1, key2, key3)
+      bytes1 = websocket_key_to_bytes(key1)
+      bytes2 = websocket_key_to_bytes(key2)
+      return Digest::MD5.digest(bytes1 + bytes2 + key3)
+    end
+
+    def generate_key()
+      spaces = 1 + rand(12)
+      max = 0xffffffff / spaces
+      number = rand(max + 1)
+      key = (number * spaces).to_s()
+      (1 + rand(12)).times() do
+        char = NOISE_CHARS[rand(NOISE_CHARS.size)]
+        pos = rand(key.size + 1)
+        key[pos...pos] = char
+      end
+      spaces.times() do
+        pos = 1 + rand(key.size - 1)
+        key[pos...pos] = " "
+      end
+      return key
+    end
+
+    def generate_key3()
+      return [rand(0x100000000)].pack("N") + [rand(0x100000000)].pack("N")
+    end
+
+    def websocket_key_to_bytes(key)
+      num = key.gsub(/[^\d]/n, "").to_i() / key.scan(/ /).size
+      return [num].pack("N")
+    end
+
+    def force_encoding(str, encoding)
+      if str.respond_to?(:force_encoding)
+        return str.force_encoding(encoding)
+      else
+        return str
+      end
+    end
+
+    def ssl_handshake(socket)
+      ssl_context = OpenSSL::SSL::SSLContext.new()
+      ssl_socket = OpenSSL::SSL::SSLSocket.new(socket, ssl_context)
+      ssl_socket.sync_close = true
+      ssl_socket.connect()
+      return ssl_socket
+    end
+
+end

data/socky_hosts.yml

@@ -0,0 +1,5 @@
+:hosts:
+  - :host: 127.0.0.1
+    :port: 8080
+    :secret: my_secret_key
+    :secure: false

data/spec/socky-client_spec.rb

@@ -0,0 +1,143 @@
+require 'spec_helper'  
+
+describe Socky do
+  it "should have config in hash form" do
+    Socky.config.should_not be_nil
+    Socky.config.class.should eql(Hash)
+  end
+  
+  it "should have host list taken from config" do
+    Socky.hosts.should eql(Socky.config[:hosts])
+  end
+  
+  context "#send" do
+    before(:each) do
+      Socky.stub!(:send_data)
+    end
+    it "should send broadcast with data" do
+      Socky.should_receive(:send_data).with({:command => :broadcast, :body => "test"})
+      Socky.send("test")
+    end
+    context "should normalize options" do
+      it "when nil given" do
+        Socky.should_receive(:send_data).with({:command => :broadcast, :body => ""})
+        Socky.send(nil)
+      end
+      it "when string given" do
+        Socky.should_receive(:send_data).with({:command => :broadcast, :body => "test"})
+        Socky.send("test")
+      end
+      it "when hash given" do
+        Socky.should_receive(:send_data).with({:command => :broadcast, :body => "test"})
+        Socky.send({:data => "test"})
+      end
+      it "when hash without body given" do
+        Socky.should_receive(:send_data).with({:command => :broadcast, :body => ""})
+        Socky.send({})
+      end
+    end
+    context "should handle recipient conditions for" do
+      it ":to => :client" do
+        Socky.should_receive(:send_data).with({:command => :broadcast, :body => "test", :to => { :clients => "first" }})
+        Socky.send("test", :to => { :client => "first" })
+      end
+      it ":to => :clients" do
+        Socky.should_receive(:send_data).with({:command => :broadcast, :body => "test", :to => { :clients => ["first","second"] }})
+        Socky.send("test", :to => { :clients => ["first","second"] })
+      end
+      it ":to => :channel" do
+        Socky.should_receive(:send_data).with({:command => :broadcast, :body => "test", :to => { :channels => "first" }})
+        Socky.send("test", :to => { :channel => "first" })
+      end
+      it ":to => :channels" do
+        Socky.should_receive(:send_data).with({:command => :broadcast, :body => "test", :to => { :channels => ["first","second"] }})
+        Socky.send("test", :to => { :channels => ["first","second"] })
+      end
+      it ":except => :client" do
+        Socky.should_receive(:send_data).with({:command => :broadcast, :body => "test", :except => { :clients => "first" }})
+        Socky.send("test", :except => { :client => "first" })
+      end
+      it ":except => :clients" do
+        Socky.should_receive(:send_data).with({:command => :broadcast, :body => "test", :except => { :clients => ["first","second"] }})
+        Socky.send("test", :except => { :clients => ["first","second"] })
+      end
+      it ":except => :channel" do
+        Socky.should_receive(:send_data).with({:command => :broadcast, :body => "test", :except => { :channels => "first" }})
+        Socky.send("test", :except => { :channel => "first" })
+      end
+      it ":except => :channels" do
+        Socky.should_receive(:send_data).with({:command => :broadcast, :body => "test", :except => { :channels => ["first","second"] }})
+        Socky.send("test", :except => { :channels => ["first","second"] })
+      end
+      it "combination" do
+        Socky.should_receive(:send_data).with({
+          :command => :broadcast,
+          :body => "test",
+          :to => {
+            :clients => "allowed_user",
+            :channels => "allowed_channel"
+          },
+          :except => {
+            :clients => "disallowed_user",
+            :channels => "disallowed_channel"
+          }
+        })
+        Socky.send("test", :to => {
+          :clients => "allowed_user",
+          :channels => "allowed_channel"
+        },
+        :except => {
+          :clients => "disallowed_user",
+          :channels => "disallowed_channel"
+        })
+      end
+    end
+    context "should ignore nil value for" do
+      it ":to => :clients" do
+        Socky.should_receive(:send_data).with({:command => :broadcast, :body => "test"})
+        Socky.send("test", :to => { :clients => nil })
+      end
+      it ":to => :channels" do
+        Socky.should_receive(:send_data).with({:command => :broadcast, :body => "test"})
+        Socky.send("test", :to => { :channels => nil })
+      end
+      it ":except => :clients" do
+        Socky.should_receive(:send_data).with({:command => :broadcast, :body => "test"})
+        Socky.send("test", :except => { :clients => nil })
+      end
+      it ":except => :channels" do
+        Socky.should_receive(:send_data).with({:command => :broadcast, :body => "test"})
+        Socky.send("test", :except => { :channels => nil })
+      end
+    end
+    context "should handle empty array for" do
+      it ":to => :clients by not sending message" do
+        Socky.should_not_receive(:send_data)
+        Socky.send("test", :to => { :clients => [] })
+      end
+      it ":to => :channels by not sending message" do
+        Socky.should_not_receive(:send_data)
+        Socky.send("test", :to => { :channels => [] })
+      end
+      it ":except => :clients by ignoring it" do
+        Socky.should_receive(:send_data).with({:command => :broadcast, :body => "test"})
+        Socky.send("test", :except => { :clients => [] })
+      end
+      it ":except => :channels by ignoring it" do
+        Socky.should_receive(:send_data).with({:command => :broadcast, :body => "test"})
+        Socky.send("test", :except => { :channels => [] })
+      end
+    end
+  end
+  
+  context "#show_connections" do
+    before(:each) do
+      Socky.stub!(:send_data)
+    end
+    it "should send query :show_connections" do
+      Socky.should_receive(:send_data).with({:command => :query, :type => :show_connections}, true)
+      Socky.show_connections
+    end
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require 'rubygems'
+require 'rspec'
+
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+require 'socky-client'

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification 
+name: socky-client
+version: !ruby/object:Gem::Version 
+  hash: 11
+  prerelease: false
+  segments: 
+  - 0
+  - 4
+  - 2
+  version: 0.4.2
+platform: ruby
+authors: 
+- Bernard Potocki
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-29 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 2
+        - 0
+        version: "2.0"
+  type: :development
+  version_requirements: *id002
+description: Socky is a WebSocket server and client for Ruby
+email: bernard.potocki@imanel.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+files: 
+- CHANGELOG.md
+- README.md
+- Rakefile
+- VERSION
+- lib/socky-client.rb
+- lib/socky-client/websocket.rb
+- socky_hosts.yml
+- spec/socky-client_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://imanel.org/projects/socky
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Socky is a WebSocket server and client for Ruby
+test_files: 
+- spec/socky-client_spec.rb
+- spec/spec_helper.rb