juggernaut 0.5.8 → 2.0.0.beta1

data/Manifest.txt

@@ -1,11 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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/bin/juggernaut

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

data/lib/juggernaut/client.rb

@@ -1,263 +0,0 @@
-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_json
-      {
-        :client_id  => @id, 
-        :num_connections => @connections.size,
-        :session_id => @session_id
-      }.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

@@ -1,19 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,219 +0,0 @@
-require 'optparse'
-require 'yaml'
-require 'erb'
-
-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
-      
-      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