RubyGems - juggernaut - Versions diffs - 0.5.8 → 2.0.0.beta1 - Mend

juggernaut 0.5.8 → 2.0.0.beta1

Files changed (24) hide show

@@ -1,368 +0,0 @@
-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.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 DELETED

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

data/test/test_client.rb DELETED

@@ -1,176 +0,0 @@
-$:.unshift "../lib"
-require "juggernaut"
-require "test/unit"
-require "shoulda"
-require "mocha"
-class TestClient < Test::Unit::TestCase
-  CONFIG = File.join(File.dirname(__FILE__), "files", "juggernaut.yml")
-  class DummySubscriber; end
-  EXAMPLE_URL = "http://localhost:5000/callbacks/example"
-  SECURE_URL = "https://localhost:5000/callbacks/example"
-  context "Client" do
-    setup do
-      Juggernaut.options = {
-        :logout_connection_url => "http://localhost:5000/callbacks/logout_connection",
-        :logout_url => "http://localhost:5000/callbacks/logout",
-        :subscription_url => "http://localhost:5000/callbacks/subscription"
-      }
-      @s1 = DummySubscriber.new
-      @request = {
-        :client_id => "jonny",
-        :session_id => rand(1_000_000).to_s(16)
-      }
-      @client = Juggernaut::Client.find_or_create(@s1, @request)
-    end
-    teardown do
-      Juggernaut::Client.reset!
-    end
-    should "have correct JSON representation" do
-      assert_nothing_raised do
-        json = {
-          "client_id"  => "jonny",
-          "num_connections" => 1,
-          "session_id" => @request[:session_id]
-        }
-        assert_equal json, JSON.parse(@client.to_json)
-      end
-    end
-    should "return the client based on subscriber's signature" do
-      @s1.stubs(:signature).returns("012345")
-      assert_equal @client, Juggernaut::Client.find_by_signature("012345")
-    end
-    should "return the client based on client ID and channel list" do
-      @client.stubs(:has_channels?).with(%w(a couple of channels)).returns(true)
-      assert_equal @client, Juggernaut::Client.find_by_id_and_channels("jonny", %w(a couple of channels))
-      assert_nil Juggernaut::Client.find_by_id_and_channels("peter", %w(a couple of channels))
-      @client.stubs(:has_channels?).with(%w(something else)).returns(false)
-      assert_nil Juggernaut::Client.find_by_id_and_channels("jonny", %w(something else))
-    end
-    should "automatically be registered, and can unregister" do
-      assert @client.send(:registered?)
-      assert_equal @client, @client.send(:unregister)
-      assert_equal false, @client.send(:registered?)
-    end
-    should "be alive if at least one subscriber is alive" do
-      @s1.stubs(:alive?).returns(true)
-      @s2 = DummySubscriber.new
-      @client.add_new_connection(@s2)
-      @s2.stubs(:alive?).returns(false)
-      assert @client.alive?
-    end
-    should "not be alive if no subscriber is alive" do
-      @s1.stubs(:alive?).returns(false)
-      @s2 = DummySubscriber.new
-      @client.add_new_connection(@s2)
-      @s2.stubs(:alive?).returns(false)
-      assert_equal false, @client.alive?
-    end
-    should "not give up if within the timeout period" do
-      Juggernaut.options[:timeout] = 10
-      @s1.stubs(:alive?).returns(false)
-      @client.send(:reset_logout_timeout!)
-      assert_equal false, @client.give_up?
-    end
-    should "not give up if at least one subscriber is alive" do
-      Juggernaut.options[:timeout] = 0
-      @s1.stubs(:alive?).returns(true)
-      @client.send(:reset_logout_timeout!)
-      assert_equal false, @client.give_up?
-    end
-    should "send logouts after timeout" do
-      Juggernaut.options[:timeout] = 0
-      @s1.stubs(:alive?).returns(false)
-      @client.send(:reset_logout_timeout!)
-      @client.expects(:logout_request).once
-      Juggernaut::Client.send_logouts_after_timeout
-    end
-    %w(subscription logout_connection).each do |type|
-      context "#{type} request" do
-        should "post to the correct URL" do
-          @client.expects(:post_request).with(Juggernaut.options[:"#{type}_url"], %w(master), :timeout => 5).returns(true)
-          assert_equal true, @client.send("#{type}_request", %w(master))
-        end
-        should "not raise exceptions if posting raises an exception" do
-          @client.expects(:post_request).with(Juggernaut.options[:"#{type}_url"], %w(master), :timeout => 5).returns(false)
-          assert_nothing_raised {
-            assert_equal false, @client.send("#{type}_request", %w(master))
-          }
-        end
-      end
-    end
-    context "post to URL" do
-      should "return true when successful" do
-        Net::HTTP.any_instance.
-          expects(:post).
-          with("/callbacks/example", "client_id=jonny&session_id=#{@request[:session_id]}&channels[]=master&channels[]=slave", {"User-Agent" => "Ruby/#{RUBY_VERSION}"}).
-          returns([Net::HTTPOK.new('1.1', '200', 'OK'), ''])
-        assert_equal true, @client.send(:post_request, EXAMPLE_URL, %w(master slave))
-      end
-      should "return false on an internal server error" do
-        Net::HTTP.any_instance.expects(:post).returns([Net::HTTPInternalServerError.new('1.1', '500', 'Internal Server Error'), ''])
-        assert_equal false, @client.send(:post_request, EXAMPLE_URL, %w(master slave))
-      end
-      should "return false when a runtime error is caught" do
-        Net::HTTP.any_instance.expects(:post).raises(RuntimeError)
-        assert_equal false, @client.send(:post_request, EXAMPLE_URL, %w(master slave))
-      end
-      should "return false when callback times out" do
-        Net::HTTP.any_instance.expects(:post).raises(Timeout::Error)
-        assert_equal false, @client.send(:post_request, EXAMPLE_URL, %w(master slave))
-      end
-      context "using a secure URL" do
-        should "return true when successful" do
-          Net::HTTP.any_instance.expects(:post).returns([Net::HTTPOK.new('1.1', '200', 'OK'), ''])
-          Net::HTTP.any_instance.expects(:use_ssl=).with(true).returns(true)
-          assert_equal true, @client.send(:post_request, SECURE_URL, %w(master slave))
-        end
-      end
-    end
-    context "channel list" do
-      should "be the unique list of all channels in the subscribers" do
-        @s1.stubs(:channels).returns(%w(master slave1))
-        @s2 = DummySubscriber.new
-        @s2.stubs(:channels).returns(%w(master slave2))
-        @client.add_new_connection(@s2)
-        assert_same_elements %w(master slave1 slave2), @client.channels
-      end
-    end
-  end
-end