juggernaut_rails 0.5.9

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/rails.rb

@@ -0,0 +1,25 @@
+require "yaml"
+
+module Juggernaut
+  module Rails
+    class <<self
+      attr_writer :hosts
+      
+      def default_options
+        @default_options ||= {
+          :config_path => File.join(::Rails.root, 'config', 'juggernaut.yml'),
+          :log_path => File.join(::Rails.root, 'log', 'juggernaut.log'),
+          :pid_path => File.join(::Rails.root, 'tmp', 'pids', 'juggernaut.5001.pid')
+        }
+      end
+      
+      def hosts
+        @hosts ||= YAML::load(ERB.new(IO.read("#{::Rails.root}/config/juggernaut_hosts.yml")).result)[:hosts].select {|h| !h[:environment] or h[:environment] == ::Rails.env.to_sym }
+      end
+      
+      def random_host
+        hosts[rand(hosts.length)]        
+      end
+    end
+  end
+end

data/lib/juggernaut/rails/convenience_methods.rb

@@ -0,0 +1,137 @@
+require "socket"
+
+module Juggernaut::Rails
+  module ConvenienceMethods
+    
+    def self.included(base) #:nodoc:
+      #raise "included jugs"
+      base.class_eval do
+        extend ClassMethods
+      end
+    end
+  
+    module ClassMethods
+    
+      def send_to_all(data)
+        fc = {
+          :command   => :broadcast,
+          :body      => data, 
+          :type      => :to_channels,
+          :channels  => []
+        }
+        send_data(fc)
+      end
+    
+      def send_to_channels(data, channels)
+        fc = {
+          :command   => :broadcast,
+          :body      => data, 
+          :type      => :to_channels,
+          :channels  => channels
+        }
+        send_data(fc)
+      end
+      alias send_to_channel send_to_channels
+    
+      def send_to_clients(data, client_ids)
+        fc = {
+          :command    => :broadcast,
+          :body       => data, 
+          :type       => :to_clients,
+          :client_ids => client_ids
+        }
+        send_data(fc)
+      end
+      alias send_to_client send_to_clients
+    
+      def send_to_clients_on_channels(data, client_ids, channels)
+        fc = {
+          :command    => :broadcast,
+          :body       => data, 
+          :type       => :to_clients,
+          :client_ids => client_ids,
+          :channels   => channels
+        }
+        send_data(fc)
+      end
+      alias send_to_clients_on_channel send_to_clients_on_channels
+      alias send_to_client_on_channels send_to_clients_on_channels
+    
+      def remove_channels_from_clients(client_ids, channels)
+        fc = {
+          :command    => :query,
+          :type       => :remove_channels_from_client,
+          :client_ids => client_ids,
+          :channels   => channels
+        }
+        send_data(fc)
+      end
+      alias remove_channel_from_client remove_channels_from_clients
+      alias remove_channels_from_client remove_channels_from_clients
+    
+      def remove_all_channels(channels)
+        fc = {
+          :command    => :query,
+          :type       => :remove_all_channels,
+          :channels   => channels
+        }
+        send_data(fc)
+      end
+    
+      def show_clients
+        fc = {
+          :command  => :query,
+          :type     => :show_clients
+        }
+        send_data(fc, true).flatten
+      end
+    
+      def show_client(client_id)
+        fc = {
+          :command    => :query,
+          :type       => :show_client,
+          :client_id  => client_id
+        }
+        send_data(fc, true).flatten[0]
+      end
+    
+      def show_clients_for_channels(channels)
+        fc = {
+          :command    => :query,
+          :type       => :show_clients_for_channels,
+          :channels   => channels
+        }
+        send_data(fc, true).flatten
+      end
+      alias show_clients_for_channel show_clients_for_channels
+
+      def send_data(hash, response = false)
+        hash[:channels]   = Array(hash[:channels])   if hash[:channels]
+        hash[:client_ids] = Array(hash[:client_ids]) if hash[:client_ids]
+      
+        res = []
+        hosts.each do |address|
+          begin
+            hash[:secret_key] = address[:secret_key] if address[:secret_key]
+          
+            @socket = TCPSocket.new(address[:host], address[:port])
+            # the \0 is to mirror flash
+            @socket.print(hash.to_json + Juggernaut::Server::CR)
+            @socket.flush
+            res << @socket.readline(Juggernaut::Server::CR) if response
+          ensure
+            @socket.close if @socket and !@socket.closed?
+          end
+        end
+        res.collect {|r| ActiveSupport::JSON.decode(r.chomp!(Juggernaut::Server::CR)) } if response
+      end
+    
+    private
+    
+      def hosts
+        Juggernaut::Rails.hosts
+      end
+    
+    end
+  end
+end

data/lib/juggernaut/rails/helpers.rb

@@ -0,0 +1,27 @@
+module Juggernaut # :nodoc:
+  module Rails
+    module Helpers
+
+      def juggernaut(options = {})
+        random_host = Juggernaut::Rails.random_host
+        options = {
+          :host                 => (random_host[:public_host] || random_host[:host]),
+          :port                 => (random_host[:public_port] || random_host[:port]),
+          :width                => '0px',
+          :height               => '0px',
+          :session_id           => request.session_options[:id],
+          :swf_address          => "/juggernaut/juggernaut.swf",
+          :ei_swf_address       => "/juggernaut/expressinstall.swf",
+          :flash_version        => 8,
+          :flash_color          => "#fff",
+          :swf_name             => "juggernaut_flash",
+          :bridge_name          => "juggernaut",
+          :debug                => (RAILS_ENV == 'development'),
+          :reconnect_attempts   => 3,
+          :reconnect_intervals  => 3
+        }.merge(options)
+        javascript_tag "new Juggernaut(#{options.to_json});"
+      end
+    end
+  end
+end

data/lib/juggernaut/rails/render_extension.rb

@@ -0,0 +1,77 @@
+module Juggernaut::Rails
+  module RenderExtension
+    def self.included(base)
+      base.send :include, InstanceMethods
+    end
+
+    module InstanceMethods
+      # We can't protect these as ActionMailer complains
+
+      def render_with_juggernaut(options = nil, extra_options = {}, &block)
+        if options == :juggernaut or (options.is_a?(Hash) and options[:juggernaut])
+          begin
+            if @template.respond_to?(:_evaluate_assigns_and_ivars, true)
+              @template.send(:_evaluate_assigns_and_ivars)
+            else
+              @template.send(:evaluate_assigns)
+            end
+        
+            generator = ActionView::Helpers::PrototypeHelper::JavaScriptGenerator.new(@template, &block)            
+            render_for_juggernaut(generator.to_s, options.is_a?(Hash) ? options[:juggernaut] : nil)
+          ensure
+            erase_render_results
+            reset_variables_added_to_assigns
+          end
+        else
+          render_without_juggernaut(options, extra_options, &block)
+        end
+      end
+
+      def render_juggernaut(*args)
+        juggernaut_options = args.last.is_a?(Hash) ? args.pop : {}
+        render_for_juggernaut(render_to_string(*args), juggernaut_options)
+      end
+
+      def render_for_juggernaut(data, options = {})
+        if !options or !options.is_a?(Hash)
+          return Juggernaut.send_to_all(data)
+        end
+    
+        case options[:type]
+          when :send_to_all
+            Juggernaut.send_to_all(data)
+          when :send_to_channels
+            juggernaut_needs options, :channels
+            Juggernaut.send_to_channels(data, options[:channels])
+          when :send_to_channel
+            juggernaut_needs options, :channel
+            Juggernaut.send_to_channel(data, options[:channel])
+          when :send_to_client
+            juggernaut_needs options, :client_id
+            Juggernaut.send_to_client(data, options[:client_id])
+          when :send_to_clients
+            juggernaut_needs options, :client_ids
+            Juggernaut.send_to_clients(data, options[:client_ids])
+          when :send_to_client_on_channel
+            juggernaut_needs options, :client_id, :channel
+            Juggernaut.send_to_clients_on_channel(data, options[:client_id], options[:channel])
+          when :send_to_clients_on_channel
+            juggernaut_needs options, :client_ids, :channel
+            Juggernaut.send_to_clients_on_channel(data, options[:client_ids], options[:channel])
+          when :send_to_client_on_channels
+            juggernaut_needs options, :client_ids, :channels
+            Juggernaut.send_to_clients_on_channel(data, options[:client_id], options[:channels])
+          when :send_to_clients_on_channels
+            juggernaut_needs options, :client_ids, :channels
+            Juggernaut.send_to_clients_on_channel(data, options[:client_ids], options[:channels])
+        end
+      end
+
+      def juggernaut_needs(options, *args)
+        args.each do |a|
+          raise "You must specify #{a}" unless options[a]
+        end
+      end
+    end
+  end
+end

data/lib/juggernaut/rails/tasks.rb

@@ -0,0 +1,66 @@
+require 'escape'
+
+namespace :juggernaut do
+  desc "Install the Juggernaut js and swf files into your Rails application."
+  task :install => :environment do    
+    require 'fileutils'
+    
+    here = File.join(File.dirname(__FILE__), '../../../')
+    there = ::Rails.root
+
+    FileUtils.mkdir_p("#{there}/public/javascripts/juggernaut/")
+    FileUtils.mkdir_p("#{there}/public/juggernaut/")
+
+    puts "Installing Juggernaut..."
+    FileUtils.cp("#{here}/media/swfobject.js", "#{there}/public/javascripts/juggernaut/")
+    FileUtils.cp("#{here}/media/juggernaut.js", "#{there}/public/javascripts/juggernaut/")
+    FileUtils.cp("#{here}/media/juggernaut.swf", "#{there}/public/juggernaut/")
+    FileUtils.cp("#{here}/media/expressinstall.swf", "#{there}/public/juggernaut/")
+
+    FileUtils.cp("#{here}/media/juggernaut.yml",       "#{there}/config/") unless File.exist?("#{there}/config/juggernaut.yml")
+    FileUtils.cp("#{here}/media/juggernaut_hosts.yml", "#{there}/config/") unless File.exist?("#{there}/config/juggernaut_hosts.yml")
+    puts "Juggernaut has been successfully installed."
+    puts
+    puts "Please refer to the readme file #{File.expand_path(here)}/README"    
+  end
+
+  namespace :install do
+    desc "Install the Juggernaut jQuery JavaScript files into your Rails application."
+    task :jquery => :environment do
+      require 'fileutils'
+      
+      here = File.join(File.dirname(__FILE__), '../../../')
+      there = ::Rails.root
+      
+      FileUtils.cp("#{here}/media/jquerynaut.js", "#{there}/public/javascripts/juggernaut/")
+      FileUtils.cp("#{here}/media/json.js", "#{there}/public/javascripts/juggernaut/")
+      puts "Installed the Juggernaut jQuery JavaScript files to public/javascripts/juggernaut/"
+    end
+  end
+  
+  desc 'Compile the juggernaut flash file'
+  task :compile_flash do
+    `mtasc -version 8 -header 1:1:1 -main -swf media/juggernaut.swf media/juggernaut.as`
+  end
+  
+  desc "Start the Juggernaut server"
+  task 'start' => :environment do
+    run_juggernaut('-d')
+  end
+
+  desc "Stop the Juggernaut server"
+  task 'stop' => :environment do
+    run_juggernaut('-k')
+  end
+  
+  def run_juggernaut(extra_options=[])
+    defaults = Juggernaut::Rails.default_options
+    extra_options = [extra_options] unless extra_options.is_a?(Array)
+    extra_options << '-e' if Rails.env.development?
+    FileUtils.cd(Rails.root) do
+      command = ['juggernaut', '-c', defaults[:config_path], '-P', defaults[:pid_path], '-l', defaults[:log_path]] + extra_options
+      ENV['RAILS_ENV'] = Rails.env.to_s
+      system(Escape.shell_command(command))
+    end
+  end
+end

data/lib/juggernaut/runner.rb

@@ -0,0 +1,221 @@
+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 or rake juggernaut:install)"
+        exit
+      end
+      
+      config_options = YAML::load(ERB.new(IO.read(config_path)).result)
+      config_options = config_options[ENV['RAILS_ENV']] if config_options.has_key?(ENV['RAILS_ENV'])
+      options.merge!(config_options)
+      
+      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