umka_juggernaut 0.0.1

data/Manifest.txt

@@ -0,0 +1,11 @@
+Manifest.txt
+README.txt
+Rakefile
+bin/juggernaut
+lib/juggernaut.rb
+lib/juggernaut/client.rb
+lib/juggernaut/message.rb
+lib/juggernaut/miscel.rb
+lib/juggernaut/runner.rb
+lib/juggernaut/server.rb
+lib/juggernaut/utils.rb

data/README.txt

@@ -0,0 +1,37 @@
+Notice!
+
+This repo has now been deprecated - please see:
+http://github.com/maccman/juggernaut
+
+Juggernaut
+    by Alex MacCaw http://www.eribium.org
+    minor fixes and unit tests by Ripta Pasay
+
+== DESCRIPTION:
+See Plugin README:
+    http://juggernaut.rubyforge.org/svn/trunk/juggernaut/README
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008 Alex MacCaw
+
+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,16 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require './lib/juggernaut.rb'
+
+Hoe.new('juggernaut', Juggernaut::VERSION) do |p|
+  p.rubyforge_name = 'juggernaut'
+  p.author = 'Alex MacCaw'
+  p.email = 'info@eribium.org'
+  p.url = 'http://juggernaut.rubyforge.org'
+  p.extra_deps << ['eventmachine', '>=0.10.0']
+  p.extra_deps << ['json', '>=1.1.2']
+end
+
+# vim: syntax=Ruby

data/bin/juggernaut

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), '..', 'lib', 'juggernaut')
+Juggernaut::Runner.run

data/lib/juggernaut.rb

@@ -0,0 +1,158 @@
+require 'rubygems'
+require 'logger'
+require 'eventmachine'
+require 'json'
+$:.unshift(File.dirname(__FILE__))
+
+module Juggernaut
+  VERSION   = '0.5.8'
+
+  class JuggernautError < StandardError #:nodoc:
+  end
+
+  @@options = {}
+  
+  DEFAULT_CONFIG_FILE = <<-EOF
+     # ======================
+     # Juggernaut Options
+     # ======================
+
+     # === Subscription authentication ===
+     # Leave all subscription options uncommented to allow anyone to subscribe.
+
+     # If specified, subscription_url is called everytime a client subscribes.
+     # Parameters passed are: session_id, client_id and an array of channels.
+     # 
+     # The server should check that the session_id matches up to the client_id
+     # and that the client is allowed to access the specified channels.
+     # 
+     # If a status code other than 200 is encountered, the subscription_request fails
+     # and the client is disconnected.
+     # 
+     # :subscription_url:  http://localhost:3000/sessions/juggernaut_subscription
+
+     # === Broadcast and query authentication ===
+     # Leave all broadcast/query options uncommented to allow anyone to broadcast/query.
+     # 
+     # Broadcast authentication in a production environment is very importantant since broadcasters
+     # can execute JavaScript on subscribed clients, leaving you vulnerable to cross site scripting
+     # attacks if broadcasters aren't authenticated. 
+
+     # 1) Via IP address
+     # 
+     # If specified, if a client has an ip that is specified in allowed_ips, than it is automatically
+     # authenticated, even if a secret_key isn't provided. 
+     # 
+     # This is the recommended method for broadcast authentication.
+     #
+     :allowed_ips: 
+                  - 127.0.0.1
+                  # - 192.168.0.1
+
+     # 2) Via HTTP request
+     # 
+     # If specified, if a client attempts a broadcast/query, without a secret_key or using an IP
+     # no included in allowed_ips, then broadcast_query_login_url will be called.
+     # Parameters passed, if given, are: session_id, client_id, channels and type.
+     # 
+     # The server should check that the session_id matches up to the client id, and the client
+     # is allowed to perform that particular type of broadcast/query.
+     # 
+     # If a status code other than 200 is encountered, the broadcast_query_login_url fails
+     # and the client is disconnected.
+     # 
+     # :broadcast_query_login_url: http://localhost:3000/sessions/juggernaut_broadcast
+
+     # 3) Via shared secret key
+     # 
+     # This secret key must be sent with any query/broadcast commands. 
+     # It must be the same as the one in the Rails config file.
+     # 
+     # You shouldn't authenticate broadcasts from subscribed clients using this method
+     # since the secret_key will be easily visible in the page (and not so secret any more)!
+     # 
+     # :secret_key: your_secret_key_here
+
+     # == Subscription Logout ==
+
+     # If specified, logout_connection_url is called everytime a specific connection from a subscribed client disconnects. 
+     # Parameters passed are session_id, client_id and an array of channels specific to that connection.
+     # 
+     # :logout_connection_url: http://localhost:3000/sessions/juggernaut_connection_logout
+
+     # Logout url is called when all connections from a subscribed client are closed.
+     # Parameters passed are session_id and client_id.
+     # 
+     # :logout_url: http://localhost:3000/sessions/juggernaut_logout
+
+     # === Miscellaneous ===
+
+     # timeout defaults to 10. A timeout is the time between when a client closes a connection
+     # and a logout_request or logout_connection_request is made. The reason for this is that a client
+     # may only temporarily be disconnected, and may attempt a reconnect very soon.
+     # 
+     # :timeout: 10
+
+     # store_messages defaults to false. If this option is true, messages send to connections will be stored. 
+     # This is useful since a client can then receive broadcasted message that it has missed (perhaps it was disconnected).
+     #
+     # :store_messages: false
+
+     # === Server ===
+
+     # Host defaults to "0.0.0.0". You shouldn't need to change this.
+     # :host: 0.0.0.0
+
+     # Port is mandatory
+     :port: 5001
+     
+     # Defaults to value of :port. If you are doing port forwarding you'll need to configure this to the same 
+     # value as :public_port in the juggernaut_hosts.yml file
+     # :public_port: 5001
+
+  EOF
+
+  class << self
+    def options
+      @@options
+    end
+    
+    def options=(val)
+      @@options = val
+    end
+    
+    def logger
+      return @@logger if defined?(@@logger) && !@@logger.nil?
+      FileUtils.mkdir_p(File.dirname(log_path))
+      @@logger = Logger.new(log_path)
+      @@logger.level = Logger::INFO if options[:debug] == false
+      @@logger
+    rescue
+      @@logger = Logger.new(STDOUT)
+    end
+    
+    def logger=(logger)
+      @@logger = logger
+    end
+    
+    def log_path
+      options[:log_path] || File.join(%w( / var run juggernaut.log ))
+    end
+    
+    def pid_path
+      options[:pid_path] || File.join(%w( / var run ), "juggernaut.#{options[:port]}.pid" )
+    end
+      
+    def config_path
+      options[:config_path] || File.join(%w( / var run juggernaut.yml ))
+    end
+    
+  end
+end
+
+require 'juggernaut/utils'
+require 'juggernaut/miscel'
+require 'juggernaut/message'
+require 'juggernaut/client'
+require 'juggernaut/server'
+require 'juggernaut/runner'

data/lib/juggernaut/client.rb

@@ -0,0 +1,267 @@
+require 'timeout'
+require 'net/http'
+require 'net/https'
+require 'uri'
+
+module Juggernaut
+  class Client
+    include Juggernaut::Miscel
+
+    @@clients = [ ]
+
+    attr_reader   :id
+    attr_accessor :session_id
+    attr_reader   :connections
+
+    class << self
+      # Actually does a find_or_create_by_id
+      def find_or_create(subscriber, request)
+        if client = find_by_id(request[:client_id])
+          client.session_id = request[:session_id]
+          client.add_new_connection(subscriber)
+          client
+        else
+          self.new(subscriber, request)
+        end
+      end
+
+      # Client find methods
+      def find_all
+        @@clients
+      end
+
+      def find(&block)
+        @@clients.select(&block).uniq
+      end
+
+      def find_by_id(id)
+        find { |client| client.id == id }.first
+      end
+
+      def find_by_signature(signature)
+        # signature should be unique
+        find do |client| 
+          client.connections.select { |connection| connection.signature == signature }.any?
+        end.first
+      end
+
+      def find_by_channels(channels)
+        find do |client| 
+          client.has_channels?(channels)
+        end
+      end
+
+      def find_by_id_and_channels(id, channels)
+        find do |client| 
+          client.has_channels?(channels) && client.id == id
+        end.first
+      end
+
+      def send_logouts_after_timeout
+        @@clients.each do |client|
+          if client.give_up?
+            client.logout_request
+          end
+        end
+      end
+
+      # Called when the server is shutting down
+      def send_logouts_to_all_clients
+        @@clients.each do |client|
+          client.logout_request
+        end
+      end
+
+      def reset!
+        @@clients.clear
+      end
+
+      def register_client(client)
+        @@clients << client unless @@clients.include?(client)
+      end
+
+      def client_registered?(client)
+        @@clients.include?(client)
+      end
+
+      def unregister_client(client)
+        @@clients.delete(client)
+      end
+    end
+
+    def initialize(subscriber, request)
+      @connections = []
+      @id         = request[:client_id]
+      @session_id = request[:session_id]
+      @messages   = []
+      @logout_timeout = 0
+      self.register
+      add_new_connection(subscriber)
+    end
+
+    def to_hash 
+      {
+        :client_id  => @id, 
+        :num_connections => @connections.size,
+        :session_id => @session_id
+      }
+    end
+    
+    def to_json
+      to_hash.to_json
+    end
+
+    def add_new_connection(subscriber)
+      @connections << subscriber
+    end
+
+    def friendly_id
+      if self.id
+        "with ID #{self.id}"
+      else
+        "session #{self.session_id}"
+      end
+    end
+
+    def subscription_request(channels)
+      return true unless options[:subscription_url]
+      post_request(options[:subscription_url], channels, :timeout => options[:post_request_timeout] || 5)
+    end
+
+    def logout_connection_request(channels)
+      return true unless options[:logout_connection_url]
+      post_request(options[:logout_connection_url], channels, :timeout => options[:post_request_timeout] || 5)
+    end
+
+    def logout_request
+      self.unregister
+      logger.debug("Timed out client #{friendly_id}")
+      return true unless options[:logout_url]
+      post_request(options[:logout_url], [ ], :timeout => options[:post_request_timeout] || 5)
+    end
+    
+    def remove_connection(connection)
+      @connections.delete(connection)
+      self.reset_logout_timeout!
+      self.logout_request if self.give_up?
+    end
+
+    def send_message(msg, channels = nil)
+      store_message(msg, channels) if options[:store_messages]
+      send_message_to_connections(msg, channels)
+    end
+
+    # Send messages that are queued up for this particular client.
+    # Messages are only queued for previously-connected clients.
+    def send_queued_messages(connection)
+      self.expire_queued_messages!
+
+      # Weird looping because we don't want to send messages that get
+      # added to the array after we start iterating (since those will
+      # get sent to the client anyway).
+      @length = @messages.length
+
+      logger.debug("Sending #{@length} queued message(s) to client #{friendly_id}")
+
+      @length.times do |id|
+        message = @messages[id]
+        send_message_to_connection(connection, message[:message], message[:channels])
+      end
+    end
+
+    def channels
+      @connections.collect { |em| em.channels }.flatten.uniq
+    end
+
+    def has_channels?(channels)
+      @connections.each do |em|
+        return true if em.has_channels?(channels)
+      end
+      false
+    end
+
+    def remove_channels!(channels)
+      @connections.each do |em|
+        em.remove_channels!(channels)
+      end
+    end
+
+    def alive?
+      @connections.select { |em| em.alive? }.any?
+    end
+
+    # This client is only dead if there are no connections and we are
+    # past the timeout (if we are within the timeout, the user could
+    # just be doing a page reload or going to a new page)
+    def give_up?
+      !alive? and (Time.now > @logout_timeout)
+    end
+
+    protected
+
+    def register
+      self.class.register_client(self)
+    end
+
+    def registered?
+      self.class.client_registered?(self)
+    end
+
+    def unregister
+      self.class.unregister_client(self)
+    end
+
+    def post_request(url, channels = [ ], options = { })
+      uri = URI.parse(url)
+      uri.path = '/' if uri.path == ''
+      params = []
+      params << "client_id=#{id}" if id
+      params << "session_id=#{session_id}" if session_id
+      channels.each {|chan| params << "channels[]=#{chan}" }
+      headers = {"User-Agent" => "Ruby/#{RUBY_VERSION}"}
+      begin
+        http = Net::HTTP.new(uri.host, uri.port)
+        if uri.scheme == 'https'
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        end
+        http.read_timeout = options[:timeout] || 5
+        resp, data = http.post(uri.path, params.join('&'), headers)
+        return resp.is_a?(Net::HTTPOK)
+      rescue => e
+        logger.error("Bad request #{url.to_s} (#{e.class}: #{e.message})")
+        return false
+      rescue Timeout::Error
+        logger.error("#{url.to_s} timeout")
+        return false
+      end
+    end  
+
+    def send_message_to_connections(msg, channels)
+      @connections.each do |connection|
+        send_message_to_connection(connection, msg, channels)
+      end
+    end
+
+    def send_message_to_connection(connection, msg, channels)
+      connection.broadcast(msg) if !channels or channels.empty? or connection.has_channels?(channels)
+    end
+
+    # Queued messages are stored until a timeout is reached which is the
+    # same as the connection timeout. This takes care of messages that
+    # come in between page loads or ones that come in right when you are
+    # clicking off one page and loading the next one.
+    def store_message(msg, channels)
+      self.expire_queued_messages!
+      @messages << { :channels => channels, :message => msg, :timeout => Time.now + options[:timeout] }
+    end
+
+    def expire_queued_messages!
+      @messages.reject! { |message| Time.now > message[:timeout] }
+    end
+
+    def reset_logout_timeout!
+      @logout_timeout = Time.now + options[:timeout]
+    end
+  end
+end

data/lib/juggernaut/message.rb

@@ -0,0 +1,19 @@
+module Juggernaut
+  class Message
+    attr_accessor :id
+    attr_accessor :signature
+    attr_accessor :body
+    attr_reader   :created_at
+    
+    def initialize(id, body, signature)
+     @id         = id
+     @body       = body
+     @signature  = signature
+     @created_at = Time.now
+    end
+    
+    def to_s
+      { :id => @id.to_s, :body => @body, :signature => @signature }.to_json
+    end
+  end
+end

data/lib/juggernaut/miscel.rb

@@ -0,0 +1,27 @@
+module Juggernaut
+  module Miscel
+    def options
+      Juggernaut.options
+    end
+  
+    def options=(ob)
+      Juggernaut.options = ob
+    end
+  
+    def log_path
+      Juggernaut.log_path
+    end
+  
+    def pid_path
+      Juggernaut.pid_path
+    end
+    
+    def config_path
+      Juggernaut.config_path
+    end
+    
+    def logger
+      Juggernaut.logger
+    end
+  end
+end

data/lib/juggernaut/runner.rb

@@ -0,0 +1,224 @@
+require 'optparse'
+require 'yaml'
+require 'erb'
+require 'resolv'
+
+module Juggernaut
+  class Runner
+    include Juggernaut::Miscel
+    
+    class << self
+      def run(argv = ARGV)
+        self.new(argv)
+      end
+    end
+    
+    def initialize(argv = ARGV)
+      self.options = {
+        :host => "0.0.0.0",
+        :port => 5001,
+        :debug => false,
+        :cleanup_timer => 2,
+        :timeout => 10,
+        :store_messages => false
+      }
+      
+      self.options.merge!({
+        :pid_path => pid_path,
+        :log_path => log_path,
+        :config_path => config_path
+      })
+      
+      parse_options(argv)
+      
+      if !File.exists?(config_path)
+        puts "You must generate a config file (juggernaut -g filename.yml)"
+        exit
+      end
+      
+      options.merge!(YAML::load(ERB.new(IO.read(config_path)).result))
+      
+      if options.include?(:kill)
+        kill_pid(options[:kill] || '*')
+      end
+
+      if options[:allowed_ips]
+        options[:allowed_ips] = options[:allowed_ips].collect { |ip| Resolv.getaddress(ip) }
+      end
+      
+      Process.euid = options[:user] if options[:user]
+      Process.egid = options[:group] if options[:group]
+      
+      if !options[:daemonize]
+        start
+      else
+        daemonize
+      end
+    end
+    
+    def start
+      puts "Starting Juggernaut server #{Juggernaut::VERSION} on port: #{options[:port]}..."
+      
+      trap("INT") {
+        stop
+        exit
+      }
+      trap("TERM"){
+        stop
+        exit
+      }
+
+      if options[:descriptor_table_size]
+        EM.epoll
+        new_size = EM.set_descriptor_table_size( options[:descriptor_table_size] )
+        logger.debug "New descriptor-table size is #{new_size}"
+      end
+      
+      EventMachine::run {
+        EventMachine::add_periodic_timer( options[:cleanup_timer] || 2 ) { Juggernaut::Client.send_logouts_after_timeout }
+        EventMachine::start_server(options[:host], options[:port].to_i, Juggernaut::Server)
+        EM.set_effective_user( options[:user] ) if options[:user]
+      }
+    end
+    
+    def stop
+      puts "Stopping Juggernaut server"
+      Juggernaut::Client.send_logouts_to_all_clients
+      EventMachine::stop
+    end
+    
+    def parse_options(argv)
+      OptionParser.new do |opts|
+        opts.summary_width = 25
+        opts.banner = "Juggernaut (#{VERSION})\n\n",
+                      "Usage: juggernaut [-h host] [-p port] [-P file]\n",
+                      "               [-d] [-k port] [-l file] [-e]\n",
+                      "       juggernaut --help\n",
+                      "       juggernaut --version\n"
+        
+        opts.separator ""
+        opts.separator ""; opts.separator "Configuration:"
+        
+        opts.on("-g", "--generate FILE", String, "Generate config file", "(default: #{options[:config_path]})") do |v|
+          options[:config_path] = File.expand_path(v) if v
+          generate_config_file
+        end
+        
+        opts.on("-c", "--config FILE", String, "Path to configuration file.", "(default: #{options[:config_path]})") do |v|
+          options[:config_path] = File.expand_path(v)
+        end
+        
+        opts.separator ""; opts.separator "Network:"
+        
+        opts.on("-h", "--host HOST", String, "Specify host", "(default: #{options[:host]})") do |v|
+          options[:host] = v
+        end
+        
+        opts.on("-p", "--port PORT", Integer, "Specify port", "(default: #{options[:port]})") do |v|
+          options[:port] = v
+        end
+
+        opts.on("-s", "--fdsize SIZE", Integer, "Set the file descriptor size an user epoll() on Linux", "(default: use select() which is limited to 1024 clients)") do |v|
+          options[:descriptor_table_size] = v
+        end
+        
+        opts.separator ""; opts.separator "Daemonization:"
+        
+        opts.on("-P", "--pid FILE", String, "save PID in FILE when using -d option.", "(default: #{options[:pid_path]})") do |v|
+          options[:pid_path] = File.expand_path(v)
+        end
+        
+        opts.on("-d", "--daemon", "Daemonize mode") do |v|
+          options[:daemonize] = v
+        end
+
+        opts.on("-k", "--kill PORT", String, :OPTIONAL, "Kill specified running daemons - leave blank to kill all.") do |v|
+          options[:kill] = v
+        end
+        
+        opts.separator ""; opts.separator "Logging:"
+        
+        opts.on("-l", "--log [FILE]", String, "Path to print debugging information.", "(default: #{options[:log_path]})") do |v|
+          options[:log_path] = File.expand_path(v)
+        end
+        
+        opts.on("-e", "--debug", "Run in debug mode", "(default: #{options[:debug]})") do |v|
+          options[:debug] = v
+        end
+        
+        opts.separator ""; opts.separator "Permissions:"
+        
+        opts.on("-u", "--user USER", Integer, "User to run as") do |user|
+          options[:user] = user
+        end
+
+        opts.on("-G", "--group GROUP", String, "Group to run as") do |group|
+          options[:group] = group
+        end
+        
+        opts.separator ""; opts.separator "Miscellaneous:"
+        
+        opts.on_tail("-?", "--help", "Display this usage information.") do
+          puts "#{opts}\n"
+          exit
+        end
+        
+        opts.on_tail("-v", "--version", "Display version") do |v|
+          puts "Juggernaut #{VERSION}"
+          exit
+        end
+      end.parse!(argv)
+      options
+    end
+    
+    private
+    
+    def generate_config_file
+      if File.exists?(config_path)
+        puts "Config file already exists. You must remove it before generating a new one."
+        exit
+      end
+      puts "Generating config file...."
+      File.open(config_path, 'w+') do |file|
+        file.write DEFAULT_CONFIG_FILE.gsub('your_secret_key_here', Digest::SHA1.hexdigest("--#{Time.now.to_s.split(//).sort_by {rand}.join}--"))
+      end
+      puts "Config file generated at #{config_path}"
+      exit
+    end
+    
+    def store_pid(pid)
+     FileUtils.mkdir_p(File.dirname(pid_path))
+     File.open(pid_path, 'w'){|f| f.write("#{pid}\n")}
+    end
+
+    def kill_pid(k)
+      Dir[options[:pid_path]||File.join(File.dirname(pid_dir), "juggernaut.#{k}.pid")].each do |f|
+        begin
+        puts f
+        pid = IO.read(f).chomp.to_i
+        FileUtils.rm f
+        Process.kill(9, pid)
+        puts "killed PID: #{pid}"
+        rescue => e
+          puts "Failed to kill! #{k}: #{e}"
+        end
+      end
+      exit
+    end
+
+    def daemonize
+     fork do
+       Process.setsid
+       exit if fork
+       store_pid(Process.pid)
+       # Dir.chdir "/" # Mucks up logs
+       File.umask 0000
+       STDIN.reopen "/dev/null"
+       STDOUT.reopen "/dev/null", "a"
+       STDERR.reopen STDOUT
+       start
+     end
+    end
+    
+  end
+end

data/lib/juggernaut/server.rb

@@ -0,0 +1,368 @@
+require 'eventmachine'
+require 'socket'
+require 'json'
+require 'open-uri'
+require 'fileutils'
+require 'digest/sha1'
+
+module Juggernaut
+  class Server < EventMachine::Connection
+    include Juggernaut::Miscel
+    
+    class InvalidRequest < Juggernaut::JuggernautError #:nodoc:
+    end
+
+    class InvalidCommand < Juggernaut::JuggernautError #:nodoc:
+    end
+
+    class CorruptJSON < Juggernaut::JuggernautError #:nodoc:
+    end
+
+    class MalformedBroadcast < Juggernaut::JuggernautError #:nodoc:
+    end
+
+    class MalformedSubscribe < Juggernaut::JuggernautError #:nodoc:
+    end
+
+    class UnauthorisedSubscription < Juggernaut::JuggernautError #:nodoc:
+    end
+
+    class MalformedQuery < Juggernaut::JuggernautError #:nodoc:
+    end
+
+    class UnauthorisedBroadcast < Juggernaut::JuggernautError #:nodoc:
+    end
+
+    class UnauthorisedQuery < Juggernaut::JuggernautError #:nodoc:
+    end
+
+    POLICY_FILE = <<-EOF
+      <cross-domain-policy>
+        <allow-access-from domain="*" to-ports="PORT" />
+      </cross-domain-policy>
+    EOF
+
+    POLICY_REQUEST = "<policy-file-request/>"
+
+    CR              = "\0"
+    
+    attr_reader   :current_msg_id
+    attr_reader   :messages
+    attr_reader   :connected
+    attr_reader   :logout_timeout
+    attr_reader   :status
+    attr_reader   :channels
+    attr_reader   :client
+
+    # EM methods
+    
+    def post_init
+      logger.debug "New client [#{client_ip}]"
+      @client         = nil
+      @channels       = []
+      @current_msg_id = 0
+      @connected      = true
+      @logout_timeout = nil
+      @buffer = ''
+    end
+    
+    # Juggernaut packets are terminated with "\0"
+    # so we need to buffer the data until we find the
+    # terminating "\0"
+    def receive_data(data)
+      @buffer << data
+      @buffer = process_whole_messages(@buffer)
+    end
+    
+    # process any whole messages in the buffer,
+    # and return the new contents of the buffer
+    def process_whole_messages(data)
+      return data if data !~ /\0/ # only process if data contains a \0 char
+      messages = data.split("\0")
+      if data =~ /\0$/
+        data = ''
+      else
+        # remove the last message from the list (because it is incomplete) before processing
+        data = messages.pop
+      end
+      messages.each {|message| process_message(message.strip)}
+      return data
+    end
+    
+    def process_message(ln)
+      logger.debug "Processing message: #{ln}"
+      @request        = nil
+      
+      if ln == POLICY_REQUEST
+        logger.debug "Sending crossdomain file"
+        send_data POLICY_FILE.gsub('PORT', (options[:public_port]||options[:port]).to_s)
+        close_connection_after_writing
+        return
+      end
+      
+      begin
+        @request = JSON.parse(ln) unless ln.empty?
+      rescue
+        raise CorruptJSON, ln
+      end
+      
+      raise InvalidRequest, ln if !@request
+      
+      @request.symbolize_keys!
+      
+      # For debugging
+      @request[:ip] = client_ip
+      
+      @request[:channels] = (@request[:channels] || []).compact.select {|c| !!c && c != '' }.uniq
+      
+      if @request[:client_ids] 
+        @request[:client_ids] = @request[:client_ids].to_a.compact.select {|c| !!c && c != '' }.uniq
+      end
+      
+      case @request[:command].to_sym
+        when :broadcast
+          broadcast_command
+        when :subscribe
+          subscribe_command
+        when :query
+          query_command
+        when :noop
+          noop_command
+      else
+        raise InvalidCommand, @request
+      end
+    
+    rescue JuggernautError => e
+      logger.error("#{e} - #{e.message.inspect}")
+      close_connection
+    # So as to stop em quitting
+    rescue => e
+      logger ? logger.error(e) : puts(e)
+    end
+    
+    def unbind
+      if @client
+        # todo - should be called after timeout?
+        @client.logout_connection_request(@channels)
+        logger.debug "Lost client #{@client.friendly_id}"
+      end
+      mark_dead('Unbind called')
+    end
+    
+    # As far as I'm aware, send_data
+    # never throws an exception
+    def publish(msg)
+      logger.debug "Sending msg: #{msg.to_s} to client #{@request[:client_id]} (session #{@request[:session_id]})"
+      send_data(msg.to_s + CR)
+    end
+    
+    # Connection methods
+    
+    def broadcast(bdy)
+      msg = Juggernaut::Message.new(@current_msg_id += 1, bdy, self.signature)
+      publish(msg)
+    end
+    
+    def mark_dead(reason = "Unknown error")
+      # Once dead, a client never recovers since a reconnection
+      # attempt would hook onto a new em instance. A client
+      # usually dies through an unbind 
+      @connected = false
+      @client.remove_connection(self) if @client
+    end
+    
+    def alive?
+      @connected == true
+    end
+    
+    def has_channels?(channels)
+      channels.each {|channel|
+        return true if has_channel?(channel)
+      }
+      false
+    end
+    
+    def has_channel?(channel)
+      @channels.include?(channel)
+    end
+    
+    def add_channel(chan_name)
+      return if !chan_name or chan_name == ''
+      @channels << chan_name unless has_channel?(chan_name)
+    end
+    
+    def add_channels(chan_names)
+      chan_names.to_a.each do |chan_name|
+        add_channel(chan_name)
+      end
+    end
+    
+    def remove_channel!(chan_name)
+      @channels.delete(chan_name)
+    end
+    
+    def remove_channels!(chan_names)
+      chan_names.to_a.each do |chan_name|
+        remove_channel!(chan_name)
+      end
+    end
+    
+    protected
+    
+      # Commands
+    
+      def broadcast_command
+        raise MalformedBroadcast, @request unless @request[:type]
+
+        raise UnauthorisedBroadcast, @request unless authenticate_broadcast_or_query
+        
+        case @request[:type].to_sym
+          when :to_channels
+            # if channels is a blank array, sends to everybody!
+            broadcast_to_channels(@request[:body], @request[:channels])
+          when :to_clients
+            broadcast_needs :client_ids
+            @request[:client_ids].each do |client_id|
+              # if channels aren't empty, scopes broadcast to clients on those channels
+              broadcast_to_client(@request[:body], client_id, @request[:channels])
+            end
+        else
+          raise MalformedBroadcast, @request
+        end
+      end
+      
+      def query_command
+        raise MalformedQuery, @request unless @request[:type]
+              
+        raise UnauthorisedQuery, @request unless authenticate_broadcast_or_query
+              
+        case @request[:type].to_sym
+          when :remove_channels_from_all_clients
+            query_needs :channels
+            clients = Juggernaut::Client.find_all
+            clients.each {|client| client.remove_channels!(@request[:channels]) }
+          when :remove_channels_from_client
+            query_needs :client_ids, :channels
+            @request[:client_ids].each do |client_id|
+              client = Juggernaut::Client.find_by_id(client_id)
+              client.remove_channels!(@request[:channels]) if client
+            end
+          when :show_channels_for_client
+            query_needs :client_id
+            if client = Juggernaut::Client.find_by_id(@request[:client_id])
+              publish client.channels.to_json
+            else
+              publish nil.to_json
+            end
+          when :show_clients
+            if @request[:client_ids] and @request[:client_ids].any?
+              clients = @request[:client_ids].collect{ |client_id| Client.find_by_id(client_id) }.compact.uniq
+            else
+              clients = Juggernaut::Client.find_all
+            end
+            publish clients.map{|client| client.to_hash}.to_json
+          when :show_client
+            query_needs :client_id
+            publish Juggernaut::Client.find_by_id(@request[:client_id]).to_json
+          when :show_clients_for_channels
+            query_needs :channels
+            publish Juggernaut::Client.find_by_channels(@request[:channels]).to_json
+        else
+          raise MalformedQuery, @request
+        end
+      end
+    
+      def noop_command
+        logger.debug "NOOP"
+      end
+    
+      def subscribe_command
+        logger.debug "SUBSCRIBE: #{@request.inspect}"
+        
+        if channels = @request[:channels]
+          add_channels(channels)
+        end
+        
+        @client = Juggernaut::Client.find_or_create(self, @request)
+        
+        if !@client.subscription_request(@channels)
+          raise UnauthorisedSubscription, @client
+        end
+        
+        if options[:store_messages]
+          @client.send_queued_messages(self)
+        end
+      end
+    
+    private
+    
+      # Different broadcast types
+    
+      def broadcast_to_channels(msg, channels = [])
+        Juggernaut::Client.find_all.each {|client| client.send_message(msg, channels) }
+      end
+      
+      def broadcast_to_client(body, client_id, channels)
+        client = Juggernaut::Client.find_by_id(client_id)
+        client.send_message(body, channels) if client
+      end
+      
+      # Helper methods
+      
+      def broadcast_needs(*args)
+        args.each do |arg|
+          raise MalformedBroadcast, @request unless @request.has_key?(arg)
+        end
+      end
+      
+      def subscribe_needs(*args)
+        args.each do |arg|
+          raise MalformedSubscribe, @request unless @request.has_key?(arg)
+        end
+      end
+      
+      def query_needs(*args)
+        args.each do |arg|
+          raise MalformedQuery, @request unless @request.has_key?(arg)
+        end
+      end
+      
+      def authenticate_broadcast_or_query
+        if options[:allowed_ips]
+          return true if options[:allowed_ips].include?(client_ip)
+        elsif !@request[:secret_key]
+          return true if broadcast_query_request
+        elsif options[:secret_key]
+          return true if @request[:secret_key] == options[:secret_key]
+        end
+        if !options[:allowed_ips] and !options[:secret_key] and !options[:broadcast_query_login_url]
+          return true
+        end
+        false
+      end
+      
+      def broadcast_query_request
+        return false unless options[:broadcast_query_login_url]
+        url = URI.parse(options[:broadcast_query_login_url])
+        params = []
+        params << "client_id=#{@request[:client_id]}" if @request[:client_id]
+        params << "session_id=#{URI.escape(@request[:session_id])}" if @request[:session_id]
+        params << "type=#{@request[:type]}"
+        params << "command=#{@request[:command]}"
+        (@request[:channels] || []).each {|chan| params << "channels[]=#{chan}" }
+        url.query = params.join('&')
+        begin
+          open(url.to_s, "User-Agent" => "Ruby/#{RUBY_VERSION}")
+        rescue Timeout::Error
+          return false
+        rescue
+          return false
+        end
+        true
+      end
+      
+      def client_ip
+        Socket.unpack_sockaddr_in(get_peername)[1] rescue nil
+      end
+  end
+end

data/lib/juggernaut/utils.rb

@@ -0,0 +1,11 @@
+class Hash
+  def symbolize_keys!
+    keys.each do |key|
+      unless key.is_a?(Symbol) || (new_key = key.to_sym).nil?
+        self[new_key] = self[key]
+        delete(key)
+      end
+    end
+    self
+  end
+end

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification 
+name: umka_juggernaut
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Mostafa Ali
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-12-06 00:00:00 +02:00
+default_executable: juggernaut
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: eventmachine
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 55
+        segments: 
+        - 0
+        - 10
+        - 0
+        version: 0.10.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 1
+        - 2
+        version: 1.1.2
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 1
+        - 7
+        - 0
+        version: 1.7.0
+  type: :development
+  version_requirements: *id003
+description: umka has fixed a problem in the maccman's juggernaut gem, and this is just a build for that gem, https://github.com/umka/juggernaut_gem
+email: mostafa.ali@badrit.com
+executables: 
+- juggernaut
+extensions: []
+
+extra_rdoc_files: 
+- Manifest.txt
+- README.txt
+files: 
+- Manifest.txt
+- README.txt
+- Rakefile
+- bin/juggernaut
+- lib/juggernaut.rb
+- lib/juggernaut/client.rb
+- lib/juggernaut/message.rb
+- lib/juggernaut/miscel.rb
+- lib/juggernaut/runner.rb
+- lib/juggernaut/server.rb
+- lib/juggernaut/utils.rb
+has_rdoc: true
+homepage: http://juggernaut.rubyforge.org
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+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: juggernaut
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 2
+summary: "See Plugin README: https://github.com/umka/juggernaut_gem"
+test_files: []
+