kosmonaut 0.2.0

data/COPYING

@@ -0,0 +1,19 @@
+Copyright (C) 2012 Krzysztof Kowalik <chris@nu7hat.ch> and folks at Cubox
+
+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/README

@@ -0,0 +1,94 @@
+Ruby wrapper for Kosmonaut - the WebRocket client
+=================================================
+
+Kosmonaut.rb is a ruby backend client for the WebRocket.
+The idea of the Kosmonaut is to keep it simple, straightforward
+and easy to maintain, although to allow to build more
+sophisticated libraries at top of it.
+
+Installation
+------------
+You can install it easily from rubygems:
+
+    $ gem install kosmonaut
+
+Or using bundler, add this line to your gemfile:
+
+    gem 'kosmonaut'
+
+Usage
+-----
+Kosmonaut has two components: Client and Worker. Client is
+used to manage a WebRocket's vhost and broadcast messages,
+for example:
+
+    c = Kosmonaut::Client.new("wr://token@127.0.0.1:8081/vhost")
+    c.open_channel("world")
+    c.broadcast("world", "hello", {:who => "Chris"})
+    c.broadcast("world", "bye", {:see_you_when => "Soon!"})
+    c.request_single_access_token(".*")
+
+Worker is used to listen for incoming messages and handle
+it in user's desired way, example:
+
+   class MyWorker < Kosmonaut::Worker
+     def on_message(event, data)
+       if event == "hello"
+         puts "Hello #{data[:who]}"
+       end
+     end
+
+     def on_error(err)
+       puts "Error encountered (code #{err.to_s})"
+     end
+
+     def on_exception(err)
+       puts "Ouch! something went wrong! Error: #{err.to_s}"
+     end
+   end
+
+   w = MyWorker.new("wr://token@127.0.0.1:8081/vhost")
+   w.listen
+
+Hacking
+-------
+If you want to run kosmonaut.rb in development mode, first clone
+the repo and install dependencies:
+
+   $ git clone https://github.com/webrocket/kosmonaut.rb.git
+   $ cd kosmonaut.rb
+   $ bundle
+
+To run the tests you should have a `webrocket-server` instance
+running with a `/test` vhost created. To create it use the
+`webrocket-admin` tool:
+
+   $ webrocket-admin add_vhost /test
+   Reading cookie... done
+   Adding a vhost... done
+   ---
+   Access token for this vhost: a70d7d2c0bc5761620948b3420d18df9072ca0d1
+
+Now get the access token and run kosmonaut's tests using
+rake task:
+
+   $ VHOST_TOKEN=a70d7d2c0bc5761620948b3420d18df9072ca0d1 rake test
+
+If you want to get debug output add a `DEBUG` environment variable
+while running tests:
+
+   $ VHOST_TOKEN=... DEBUG=1 rake test
+
+With any quirks and doubts don't hesitate to start a github issue
+or email one of the maintainers.
+   
+Sponsors
+--------
+All the work on the project is sponsored and supported by Cubox - an
+awesome dev shop from Uruguay <http://cuboxsa.com>.
+   
+Copyright
+---------
+Copyright (C) 2012 Krzysztof Kowalik <chris@nu7hat.ch> and folks at Cubox
+
+Released under the MIT license. See COPYING for details.

data/Rakefile

@@ -0,0 +1,29 @@
+# -*- ruby -*-
+
+=begin
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "Kosmonaut - The WebRocket backend client"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+=end
+
+require 'rake/testtask'
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/test*.rb']
+  t.verbose = true
+end
+
+task :default => :test
+
+desc "Opens console with loaded mustang env."
+task :console do
+  $LOAD_PATH.unshift("./lib")
+  require 'kosmonaut'
+  require 'irb'
+  ARGV.clear
+  IRB.start
+end

data/kosmonaut.gemspec

@@ -0,0 +1,19 @@
+# -*- ruby -*-
+require 'rubygems'
+
+Gem::Specification.new do |s|
+  s.name = "kosmonaut"
+  s.version = "0.2.0"
+  s.summary = "Ruby client for the WebRocket backend"
+  s.description = "The WebRocket server backend client for ruby programming language"
+  s.authors = ["Krzysztof Kowalik", "Cubox"]
+  s.email = "chris@nu7hat.ch"
+  s.homepage = "http://webrocket.io/"
+  s.license = "MIT"
+
+  s.files = Dir["{lib/**/*.rb,test/*.rb,Rakefile,README*,COPYING,*.gemspec}"]
+  s.test_files = Dir["test/*.rb"]
+  s.require_paths = ["lib"]
+
+  s.add_dependency "json", "~> 1.0"
+end

data/lib/kosmonaut.rb

@@ -0,0 +1,16 @@
+require 'kosmonaut/errors'
+require 'kosmonaut/socket'
+require 'kosmonaut/worker'
+require 'kosmonaut/client'
+require 'kosmonaut/version'
+
+module Kosmonaut
+  extend self
+  attr_accessor :debug
+
+  def log(msg)
+    print("DEBUG: ", msg, "\n") if Kosmonaut.debug
+  end
+end
+
+Kosmonaut.debug = false

data/lib/kosmonaut/client.rb

@@ -0,0 +1,77 @@
+require 'json'
+require 'uri'
+require 'socket'
+require 'securerandom'
+require 'timeout'
+require 'thread'
+
+module Kosmonaut
+  class Client < Socket
+    include Kosmonaut
+
+    REQUEST_TIMEOUT = 5 # in seconds
+
+    def initialize(url)
+      super(url)
+      @mtx = Mutex.new
+    end
+
+    def broadcast(channel, event, data)
+      payload = ["BC", channel, event, data.to_json]
+      perform_request(payload)
+    end
+
+    def open_channel(name, type)
+      payload = ["OC", name, type]
+      perform_request(payload)
+    end
+
+    def close_channel(name)
+      payload = ["CC", name]
+      perform_request(payload)
+    end
+
+    def request_single_access_token(permission)
+      payload = ["AT", permission]
+      perform_request(payload)
+    end
+
+    def socket_type
+      "req"
+    end
+
+    private
+
+    def perform_request(payload)
+      @mtx.synchronize {
+        response = []
+        Timeout.timeout(REQUEST_TIMEOUT) {
+          s = connect
+          packet = pack(payload)
+          log("Client/REQ : #{packet.inspect}")
+          s.write(packet)
+          response = recv(s)
+          s.close
+        }
+        parse_response(response)
+      }
+    end
+
+    def parse_response(response)
+      cmd = response[0].to_s
+      log("Client/RES : #{response.join("\n").inspect}")
+      case cmd
+      when "OK"
+        return 0
+      when "ER"
+        errcode = response[1].to_i
+        error = ERRORS[errcode]
+        raise error.new if error
+      when "AT"
+        token = response[1].to_s
+        return token if token.size == 128
+      end
+      raise UnknownServerError.new
+    end
+  end
+end

data/lib/kosmonaut/errors.rb

@@ -0,0 +1,62 @@
+module Kosmonaut
+  class Error < StandardError
+  end
+
+  class BadRequestError < Error
+    def initialize
+      super "400: Bad request"
+    end
+  end
+
+  class UnauthorizedError < Error
+    def initialize
+      super "402: Unauthorized"
+    end
+  end
+
+  class ForbiddenError < Error
+    def initialize
+      super "403: Forbidden"
+    end
+  end
+
+  class InvalidChannelNameError < Error
+    def initialize
+      super "451: Invalid channel name"
+    end
+  end
+
+  class ChannelNotFoundError < Error
+    def initialize
+      super "454: Channel not found"
+    end
+  end
+
+  class InternalError < Error
+    def initialize
+      super "597: Internal error"
+    end
+  end
+
+  class EndOfFileError < Error
+    def initialize
+      super "598: End of file"
+    end
+  end
+
+  class UnknownServerError < Error
+    def initialize
+      super "Unknown server error"
+    end
+  end
+
+  ERRORS = {
+    400 => BadRequestError,
+    402 => UnauthorizedError,
+    403 => ForbiddenError,
+    451 => InvalidChannelNameError,
+    454 => ChannelNotFoundError,
+    597 => InternalError,
+    598 => EndOfFileError,
+  }
+end

data/lib/kosmonaut/socket.rb

@@ -0,0 +1,49 @@
+module Kosmonaut
+  class Socket
+    attr_reader :uri
+
+    def initialize(url)
+      @uri = URI.parse(url)
+      generate_identity
+    end
+
+    protected
+
+    def connect
+      TCPSocket.open(@uri.host, @uri.port)
+    end
+
+    def pack(payload=[])
+      payload.unshift("")
+      payload.unshift(@identity)
+      payload.join("\n") + "\n\r\n\r\n"
+    end
+
+    def recv(s)
+      data = []
+      possible_eom = false # possible end of message
+      while !s.eof?
+        line = s.gets
+        if line == "\r\n"
+          break if possible_eom
+          possible_eom = true
+        else
+          possible_eom = false
+          data << line.strip
+        end
+      end
+      data
+    end
+    
+    private
+
+    def generate_identity
+      parts = []
+      parts << socket_type
+      parts << @uri.path
+      parts << @uri.user # secret
+      parts << SecureRandom.uuid
+      @identity = parts.join(":")
+    end
+  end
+end

data/lib/kosmonaut/version.rb

@@ -0,0 +1,15 @@
+module Kosmonaut
+  module Version
+    MAJOR = 0
+    MINOR = 2
+    PATCH = 0
+
+    def self.to_s
+      [MAJOR, MINOR, PATCH].join('.')
+    end
+  end
+
+  def self.version
+    Version.to_s
+  end
+end

data/lib/kosmonaut/worker.rb

@@ -0,0 +1,128 @@
+require 'json'
+require 'thread'
+
+module Kosmonaut
+  class Worker < Socket
+    include Kosmonaut
+
+    RECONNECT_DELAY = 1000 # in milliseconds
+    HEARTBEAT_INTERVAL = 2000 # in milliseconds
+    LIVENESS = 3
+
+    def initialize(url)
+      super(url)
+      @mtx = Mutex.new
+      @sock = nil
+      @alive = false
+      @reconnect_delay = RECONNECT_DELAY
+      @heartbeat_ivl = HEARTBEAT_INTERVAL
+      @heartbeat_at = 0
+      @liveness = 0
+    end
+
+    def listen
+      reconnect
+      @alive = true
+      while true
+        if !alive?
+          send(@sock, ["QT"])
+          disconnect
+          break
+        end
+        begin
+          Timeout.timeout(((@heartbeat_ivl * 2).to_f / 1000.0).to_i + 1) {
+            msg = recv(@sock)
+            @liveness = LIVENESS
+            log("Worker/RECV : #{msg.join("\n").inspect}")
+            next if msg.size < 1
+            cmd = msg.shift
+          
+            case cmd
+            when "HB"
+              # nothing to do...
+            when "QT"
+              reconnect
+              next
+            when "TR"
+              message_handler(msg[0])
+            when "ER"
+              error_handler(msg.size < 1 ? 597 : msg[0])
+            end
+          }
+        rescue Timeout::Error, Errno::ECONNRESET
+          if (@liveness -= 1) == 0
+            sleep(@reconnect_delay.to_f / 1000.0)
+            reconnect
+          end
+        end
+        if Time.now.to_f > @heartbeat_at
+          send(@sock, ["HB"])
+          @heartbeat_at = Time.now.to_f + (@heartbeat_ivl.to_f / 1000.0)
+        end
+      end
+    end
+    
+    def stop
+      @mtx.synchronize { @alive = false }
+    end
+
+    def alive?
+      @mtx.synchronize { @alive }
+    end
+
+    def socket_type
+      "dlr"
+    end
+
+    private
+
+    def send(s, payload)
+      packet = pack(payload)
+      @sock.write(packet)
+      log("Worker/SENT : #{packet.inspect}")
+    end
+
+    def disconnect
+      if @sock
+        @sock.close
+        @sock = nil
+      end
+    end
+
+    def reconnect
+      disconnect
+      @sock = connect
+      @sock.write(pack(["RD"]))
+      @liveness = LIVENESS
+      @heartbeat_at = Time.now.to_f + (@heartbeat_ivl.to_f / 1000.0)
+    end
+
+    def message_handler(data)
+      if respond_to?(:on_message)
+        payload = JSON.parse(data.to_s)
+        event = payload.keys.first
+        data = data[event]
+        on_message(event, data)
+      end
+    rescue => err
+      exception_handler(err)
+    end
+
+    def error_handler(errcode)
+      if respond_to?(:on_error)
+        err = ERRORS[errcode.to_i]
+        on_error(err ? err : UnknownServerError)
+      end
+    rescue => err
+      exception_handler(err)
+    end
+
+    def exception_handler(err)
+      if respond_to?(:on_exception)
+        on_exception(err)
+      else
+        raise err
+      end
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,5 @@
+$LOAD_PATH.unshift(File.expand_path("../../lib", __FILE__))
+require "minitest/autorun"
+require "kosmonaut"
+
+Kosmonaut.debug = (ENV["DEBUG"] == "1")

data/test/test_kosmonaut_client.rb

@@ -0,0 +1,55 @@
+require File.expand_path("../helper", __FILE__)
+
+class TestKosmonautClient < MiniTest::Unit::TestCase
+  def setup
+    @client = Kosmonaut::Client.new("wr://#{ENV["VHOST_TOKEN"].to_s}@127.0.0.1:8081/test")
+  end
+
+  def test_api
+    # tests depends each other, so we have to run it in
+    # correct order...
+    _test_open_channel
+    _test_open_channel_with_invalid_name
+    _test_broadcast
+    _test_broadcast_to_not_existing_channel
+    _test_close_channel
+    _test_close_not_existing_channel
+    _test_request_single_access_token
+  end
+  
+  def _test_open_channel
+    @client.open_channel("foo", 0)
+  end
+
+  def _test_open_channel_with_invalid_name
+    @client.open_channel("%%%", 0)
+    assert false
+  rescue Kosmonaut::InvalidChannelNameError
+  end
+
+  def _test_broadcast
+    @client.broadcast("foo", "test", {})
+  end
+
+  def _test_broadcast_to_not_existing_channel
+    @client.broadcast("foobar", "test", {})
+    assert false
+  rescue Kosmonaut::ChannelNotFoundError
+  end
+  
+  def _test_close_channel
+    @client.close_channel("foo")
+  end
+
+  def _test_close_not_existing_channel
+    @client.close_channel("bar")
+    assert false
+  rescue Kosmonaut::ChannelNotFoundError
+  end
+
+  def _test_request_single_access_token
+    token = @client.request_single_access_token(".*")
+    assert token
+    assert_equal 128, token.size
+  end
+end

data/test/test_kosmonaut_worker.rb

@@ -0,0 +1,29 @@
+require File.expand_path("../helper", __FILE__)
+
+class MyWorker < Kosmonaut::Worker
+  def on_message(event, data)
+    puts "MSG", event, data
+  end
+  
+  def on_error(err)
+    puts "ERR", err.to_s
+  end
+
+  def on_exception(err)
+    puts "EXC", err.to_s
+  end
+end
+
+class TestKosmonautWorker < MiniTest::Unit::TestCase
+  def setup
+    @worker = MyWorker.new("wr://#{ENV["VHOST_TOKEN"].to_s}@127.0.0.1:8081/test")
+  end
+
+  def test_api
+    Thread.new {
+      sleep(15)
+      @worker.stop
+    }
+    @worker.listen
+  end
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification 
+name: kosmonaut
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.2.0
+platform: ruby
+authors: 
+- Krzysztof Kowalik
+- Cubox
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-01-16 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "1.0"
+  type: :runtime
+  version_requirements: *id001
+description: The WebRocket server backend client for ruby programming language
+email: chris@nu7hat.ch
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/kosmonaut/client.rb
+- lib/kosmonaut/errors.rb
+- lib/kosmonaut/socket.rb
+- lib/kosmonaut/version.rb
+- lib/kosmonaut/worker.rb
+- lib/kosmonaut.rb
+- test/helper.rb
+- test/test_kosmonaut_client.rb
+- test/test_kosmonaut_worker.rb
+- Rakefile
+- README
+- COPYING
+- kosmonaut.gemspec
+homepage: http://webrocket.io/
+licenses: 
+- MIT
+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.10
+signing_key: 
+specification_version: 3
+summary: Ruby client for the WebRocket backend
+test_files: 
+- test/helper.rb
+- test/test_kosmonaut_client.rb
+- test/test_kosmonaut_worker.rb