RubyGems - breakout - Versions diffs - 0.0.1 - Mend

breakout 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (28) hide show

data/.gitignore +7 -0
data/Gemfile +4 -0
data/README.md +31 -0
data/Rakefile +53 -0
data/_LICENSE +20 -0
data/breakout.gemspec +21 -0
data/examples/chat.rb +27 -0
data/examples/echo.rb +10 -0
data/examples/ping.rb +9 -0
data/examples/public/javascripts/chat.js +35 -0
data/examples/public/javascripts/echo.js +50 -0
data/examples/public/javascripts/jquery-1.4.2.min.js +154 -0
data/examples/public/javascripts/ping.js +34 -0
data/examples/web_app.rb +72 -0
data/examples/worker_app.rb +13 -0
data/lib/breakout.rb +13 -0
data/lib/breakout/api.rb +36 -0
data/lib/breakout/app.rb +41 -0
data/lib/breakout/config.rb +50 -0
data/lib/breakout/railtie.rb +9 -0
data/lib/breakout/socket.rb +25 -0
data/lib/breakout/version.rb +4 -0
data/lib/breakout/web_socket.rb +295 -0
data/lib/breakout/worker.rb +20 -0
data/spec/breakout_spec.rb +7 -0
data/spec/spec.opts +1 -0
data/spec/spec_helper.rb +9 -0
metadata +74 -0

data/examples/web_app.rb ADDED Viewed

@@ -0,0 +1,72 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'sinatra'
+#require 'breakout'
+require File.expand_path("../../lib/breakout", __FILE__)
+Breakout.load_or_create_config_file('breakout.yml')
+layout = <<-APP
+<!DOCTYPE html>
+<html>
+  <head>
+   <title>Example</title>
+  </head>
+  <body>
+    %s
+  </body>
+</html>
+APP
+get '/' do
+  layout % <<-HTML
+<h1><a href="/echo">Echo</a></h1>
+<h1><a href="/ping">Ping</a></h1>
+<h1><a href="/chat">Chat</a></h1>
+HTML
+end
+get '/echo' do
+  layout % <<-SCRIPT
+<script type='text/javascript' src='/javascripts/jquery-1.4.2.min.js'></script>
+<script type='text/javascript'>
+var echo_url = '#{Breakout.browser_url('echo')}';
+jQuery.getScript("/javascripts/echo.js");
+</script>
+SCRIPT
+end
+get '/ping' do
+  layout % <<-SCRIPT
+<script type='text/javascript' src='/javascripts/jquery-1.4.2.min.js'></script>
+<script type='text/javascript'>
+jQuery.getScript("/javascripts/ping.js", function() { new Ping('#{Breakout.browser_url('ping')}'); });
+</script>
+SCRIPT
+end
+get '/chat' do
+  layout % <<-SCRIPT
+<div>
+  <h2>Name</h2>
+  <form action="/chat" method="post">
+  <input type="text" name="name" />
+  <input type="submit" name="submit" />
+  </form>
+</div>
+SCRIPT
+end
+post '/chat' do
+  halt 400 unless name = params[:name]
+  chat_url = Breakout.browser_url('chat', :bid => name, :notify => true)
+  layout % <<-SCRIPT
+<script type='text/javascript' src='/javascripts/jquery-1.4.2.min.js'></script>
+<script type='text/javascript'>
+var chat_url = '#{chat_url}';
+jQuery.getScript("/javascripts/chat.js");
+</script>
+SCRIPT
+end

data/examples/worker_app.rb ADDED Viewed

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+#require 'breakout'
+require File.expand_path("../../lib/breakout", __FILE__)
+Breakout.load_or_create_config_file('breakout.yml')
+['ping', 'echo', 'chat'].each do |worker|
+  require File.expand_path("../#{worker}", __FILE__)
+end
+Breakout::Worker::App.new.run()

data/lib/breakout.rb ADDED Viewed

@@ -0,0 +1,13 @@
+dir = File.dirname(__FILE__)
+$LOAD_PATH.unshift dir unless $LOAD_PATH.include?(dir)
+require 'json'
+require 'yaml'
+require 'breakout/web_socket'
+require 'breakout/api'
+require 'breakout/app'
+require 'breakout/config'
+require 'lib/breakout/railtie' if defined?(Rails)
+require 'breakout/socket'
+require 'breakout/worker'

data/lib/breakout/api.rb ADDED Viewed

@@ -0,0 +1,36 @@
+module Breakout
+  module Worker
+    module API
+      # The breakout server API for workers
+      # commands are symbols :send_messages, :disconnect, :done_work
+      # commands are sent to breakout server as a hash :command => args
+      # args are
+      #   :done_work => requeue? #true or false whether to put worker back on work queue
+      #   :send_messages => { message => [bid1, bid2, ...] }
+      #   :disconnect => bid
+      #
+      # for messages incoming from the server (in worker.do_work) the notify api
+      #  (if the browser url included notify=true)
+      #  when the browser socket opens, the message will be "/open"
+      #  when the browser socket closes, the mesage will be "/close"
+      def disconnect(bid)
+        socket.send :disconnect => bid
+      end
+      def send_messages(args)
+        raise Exception unless args.is_a?(Hash)
+        socket.send :send_messages => args
+      end
+      alias send_message send_messages
+      def done_work(requeue=true)
+        socket.send :done_work => requeue
+      end
+    end
+  end
+end

data/lib/breakout/app.rb ADDED Viewed

@@ -0,0 +1,41 @@
+module Breakout
+  module Worker
+    class App
+      include API
+      attr_accessor :worker_by_route, :socket, :stop
+      def dispatch(data)
+        route, bid, message = data.split("\n", 3)
+        raise "#{route}\n#{bid}\n#{message}" unless worker = worker_by_route[route]
+        worker.do_work(bid, message)
+      end
+      def run(url=nil)
+        unless url
+          url = Breakout.worker_url
+        end
+        self.socket = Socket.new(url)
+        self.worker_by_route = Hash.new
+        Worker::WORKERS.each do |klass|
+          worker = klass.new
+          worker.socket = socket
+          worker_by_route[klass.route] = worker
+        end
+        done_work
+        while data = socket.receive() do
+          dispatch(data)
+          if @stop
+            done_work false
+            break
+          end
+          done_work
+        end
+      end
+    end
+  end
+end

data/lib/breakout/config.rb ADDED Viewed

@@ -0,0 +1,50 @@
+require 'digest'
+module Breakout
+  CONFIG = {}
+  def self.random_config
+    {
+      :breakout_host => 'localhost',
+      :worker_port => 9001,
+      :browser_port => 9002,
+      :grid => (Digest::SHA2.new << rand.to_s).to_s[0..4],
+      :grid_key => (Digest::SHA2.new << rand.to_s).to_s[0..30]
+    }
+  end
+  def self.random_bid
+    (Digest::SHA2.new << rand.to_s).to_s[0..10]
+  end
+  def self.config(opts={})
+    CONFIG.merge!(opts)
+  end
+  def self.grid_access_token(route, bid, e, notify, grid_key=nil)
+    grid_key ||= CONFIG[:grid_key]
+    (Digest::SHA2.new << "#{grid_key}#{route}#{bid}#{e}#{notify}").to_s
+  end
+  def self.worker_url()
+    "ws://#{CONFIG[:breakout_host]}:#{CONFIG[:worker_port]}/#{CONFIG[:grid]}?grid_key=#{CONFIG[:grid_key]}"
+  end
+  def self.browser_url(route, opts={})
+    bid = opts[:bid] || random_bid
+    e = opts[:e] || (Time.now + 3).to_i
+    notify = opts[:notify] || false
+    gat = grid_access_token(route, bid, e, notify)
+    "ws://#{CONFIG[:breakout_host]}:#{CONFIG[:browser_port]}/#{CONFIG[:grid]}?route=#{route}&bid=#{bid}&e=#{e}&notify=#{notify}&gat=#{gat}"
+  end
+  def self.load_or_create_config_file(config_filename)
+    unless File.exist?(config_filename)
+      File.open(config_filename, 'w') do |f|
+        f.write random_config.to_yaml
+      end
+    end
+    config(YAML.load(File.open(config_filename, 'r')))
+  end
+end

data/lib/breakout/railtie.rb ADDED Viewed

@@ -0,0 +1,9 @@
+require 'breakout'
+require 'rails'
+module Breakout
+  class Railtie < Rails::Railtie
+    railtie_name :breakout
+  end
+end

data/lib/breakout/socket.rb ADDED Viewed

@@ -0,0 +1,25 @@
+module Breakout
+  class Socket < WebSocket
+    def initialize(url)
+      #WebSocket.debug = true
+      @ws = WebSocket.new(url)
+    end
+    def close
+      @ws.close
+    end
+    def receive
+      @ws.receive
+    end
+    def send(msg)
+      if msg.is_a?(String)
+        @ws.send(msg)
+      else
+        @ws.send(msg.to_json)
+      end
+    end
+  end
+end

data/lib/breakout/version.rb ADDED Viewed

@@ -0,0 +1,4 @@
+module Breakout
+  VERSION = "0.0.1"
+end

data/lib/breakout/web_socket.rb ADDED Viewed

@@ -0,0 +1,295 @@
+# Adapted from https://github.com/gimite/web-socket-ruby/blob/abbbe0b674cb71fb7658b2792b4ccc5d98e6f0cd/lib/web_socket.rb
+# 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 = {})
+      if params[:server] # server
+        @server = params[:server]
+        @socket = arg
+        line = gets().chomp()
+        if !(line =~ /\AGET (\S+) HTTP\/1.1\z/n)
+          raise(WebSocket::Error, "invalid request: #{line}")
+        end
+        @path = $1
+        read_header()
+        if @header["sec-websocket-key1"] && @header["sec-websocket-key2"]
+          @key3 = read(8)
+        else
+          # Old Draft 75 protocol
+          @key3 = nil
+        end
+        if !@server.accepted_origin?(self.origin)
+          raise(WebSocket::Error,
+            ("Unaccepted origin: %s (server.accepted_domains = %p)\n\n" +
+              "To accept this origin, write e.g. \n" +
+              "  WebSocketServer.new(..., :accepted_domains => [%p]), or\n" +
+              "  WebSocketServer.new(..., :accepted_domains => [\"*\"])\n") %
+            [self.origin, @server.accepted_domains, @server.origin_to_domain(self.origin)])
+        end
+        @handshaked = false
+      else # client
+        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"] || "").downcase() != origin.downcase()
+          raise(WebSocket::Error,
+            "origin doesn't match: '#{@header["sec-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
+      end
+      @received = []
+      @buffer = ""
+      @closing_started = false
+    end
+    attr_reader(:server, :header, :path)
+    def handshake(status = nil, header = {})
+      if @handshaked
+        raise(WebSocket::Error, "handshake has already been done")
+      end
+      status ||= "101 Web Socket Protocol Handshake"
+      sec_prefix = @key3 ? "Sec-" : ""
+      def_header = {
+        "#{sec_prefix}WebSocket-Origin" => self.origin,
+        "#{sec_prefix}WebSocket-Location" => self.location,
+      }
+      header = def_header.merge(header)
+      header_str = header.map(){ |k, v| "#{k}: #{v}\r\n" }.join("")
+      if @key3
+        digest = security_digest(
+          @header["Sec-WebSocket-Key1"], @header["Sec-WebSocket-Key2"], @key3)
+      else
+        digest = ""
+      end
+      # Note that Upgrade and Connection must appear in this order.
+      write(
+        "HTTP/1.1 #{status}\r\n" +
+        "Upgrade: WebSocket\r\n" +
+        "Connection: Upgrade\r\n" +
+        "#{header_str}\r\n#{digest}")
+      flush()
+      @handshaked = true
+    end
+    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
+    def location
+      return "ws://#{self.host}#{@path}"
+    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
+        @header[$1.downcase()] = $2
+      end
+      if !(@header["upgrade"] =~ /\AWebSocket\z/i)
+        raise(WebSocket::Error, "invalid Upgrade: " + @header["upgrade"])
+      end
+      if !(@header["connection"] =~ /\AUpgrade\z/i)
+        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