jschat 0.1.1

data/lib/jschat/server.rb

@@ -0,0 +1,503 @@
+require 'rubygems'
+require 'eventmachine'
+require 'json'
+require 'time'
+require 'socket'
+
+# JsChat libraries
+require 'jschat/errors'
+require 'jschat/flood_protection'
+
+module JsChat
+  STATELESS_TIMEOUT = 60
+
+  class User
+    include JsChat::FloodProtection
+
+    attr_accessor :name, :connection, :rooms, :last_activity,
+                  :identified, :ip, :last_poll
+
+    def initialize(connection)
+      @name = nil
+      @connection = connection
+      @rooms = []
+      @last_activity = Time.now.utc
+      @last_poll = Time.now.utc
+      @identified = false
+      @ip = ''
+    end
+
+    def to_json
+      { 'name' => @name, 'last_activity' => @last_activity }.to_json
+    end
+
+    def name=(name)
+      if @connection and @connection.name_taken? name
+        raise JsChat::Errors::InvalidName.new(:name_taken, 'Name taken')
+      elsif User.valid_name?(name)
+        @identified = true
+        @name = name
+      else
+        raise JsChat::Errors::InvalidName.new(:invalid_name, 'Invalid name')
+      end
+    end
+
+    def self.valid_name?(name)
+      not name.match /[^[:alnum:]._\-\[\]^C]/ and name.size > 0
+    end
+
+    def private_message(message)
+      response = { 'display' => 'message', 'message' => message }
+      @connection.send_response response
+    end
+
+    def change(params)
+      # Valid options for change
+      ['name'].each do |field|
+        if params[field]
+          old_value = send(field)
+          send "#{field}=", params[field]
+          @rooms.each do |room|
+            response = { 'change' => 'user',
+                         'room' => room.name,
+                         'user' => { field => { old_value => params[field] } } }
+            room.change_notice self, response
+            return [field, params[field]]
+          end
+        end
+      end
+    end
+  end
+
+  class Room
+    attr_accessor :name, :users
+
+    def initialize(name)
+      @name = name
+      @users = []
+    end
+
+    def self.valid_name?(name)
+      User.valid_name?(name[1..-1]) and name[0].chr == '#'
+    end
+
+    def self.find(item)
+      @@rooms ||= []
+
+      if item.kind_of? String
+        @@rooms.find { |room| room.name.downcase == item.downcase if room.name }
+      elsif item.kind_of? User
+        @@rooms.find_all { |room| room.users.include? item }
+      end
+    end
+
+    def self.find_or_create(room_name)
+      room = find room_name
+      if room.nil?
+        room = new(room_name)
+        @@rooms << room
+      end
+      room
+    end
+
+    def lastlog(since = nil)
+      { 'display' => 'messages', 'messages' => messages_since(since) }
+    end
+
+    def messages_since(since)
+      if since.nil?
+        @messages
+      else
+        @messages.select { |m| message_time(m) > since }
+      end
+    end
+
+    def message_time(message)
+      if message.has_key? 'display'
+        message[message['display']]['time']
+      elsif message.has_key? 'change'
+        message[message['change']]['time']
+      end
+    end
+
+    def add_to_lastlog(message)
+      @messages ||= []
+      if message
+        if message.has_key? 'display'
+          message[message['display']]['time'] = Time.now.utc
+        elsif message.has_key? 'change'
+          message[message['change']]['time'] = Time.now.utc
+        end
+        @messages.push message
+        @messages = @messages[-100..-1] if @messages.size > 100
+      end
+    end
+
+    def join(user)
+      if @users.include? user
+        Error.new(:already_joined, 'Already in that room')
+      else
+        @users << user
+        user.rooms << self
+        join_notice user
+        { 'display' => 'join', 'join' => { 'user' => user.name, 'room' => @name } }
+      end
+    end
+
+    def part(user)
+      if not @users.include?(user)
+        Error.new(:not_in_room, 'Not in that room')
+      else
+        user.rooms.delete_if { |r| r == self }
+        @users.delete_if { |u| u == user }
+        part_notice user
+        { 'display' => 'part', 'part' => { 'user' => user.name, 'room' => @name } }
+      end
+    end
+
+    def send_message(message)
+      message['room'] = name
+      response = { 'display' => 'message', 'message' => message }
+
+      add_to_lastlog response
+
+      @users.each do |user|
+        user.connection.send_response response
+      end
+    end
+    
+    def member_names
+      @users.collect { |user| user.name }
+    end
+
+    def to_json
+      { 'name' => @name, 'members' => member_names }.to_json
+    end
+
+    def notice(user, message, all = false)
+      add_to_lastlog message
+
+      @users.each do |u|
+        if (u != user and !all) or all
+          u.connection.send_response(message)
+        end
+      end
+    end
+
+    def change_notice(user, response)
+      notice(user, response, true)
+    end
+
+    def join_notice(user)
+      notice(user, { 'display' => 'join_notice', 'join_notice' => { 'user' => user.name, 'room' => @name } })
+    end
+
+    def part_notice(user)
+      notice(user, { 'display' => 'part_notice', 'part_notice' => { 'user' => user.name, 'room' => @name } })
+    end
+
+    def quit_notice(user)
+      notice(user, { 'display' => 'quit_notice', 'quit_notice' => { 'user' => user.name, 'room' => @name } })
+      @users.delete_if { |u| u == user }
+    end
+  end
+
+  # User initially has a nil name
+  def users_with_names
+    @@users.find_all { |u| u.name }
+  end
+
+  def name_taken?(name)
+    users_with_names.find { |user| user.name.downcase == name.downcase }
+  end
+
+  # {"identify":"alex"}
+  def identify(name, ip, options = {})
+    if @user and @user.identified
+      Error.new :already_identified, 'You have already identified'
+    elsif name_taken? name
+      Error.new :name_taken, 'Name already taken'
+    else
+      @user.name = name
+      @user.ip   = ip
+      register_stateless_user if @stateless
+      { 'display' => 'identified', 'identified' => @user }
+    end
+  rescue JsChat::Errors::InvalidName => exception
+    exception
+  end
+
+  def lastlog(room, options = {})
+    room = Room.find room
+    if room and room.users.include? @user
+      room.lastlog
+    else
+      Error.new(:not_in_room, "Please join this room first")
+    end
+  end
+
+  def since(room, options = {})
+    room = Room.find room
+    if room and room.users.include? @user
+      response = room.lastlog(@user.last_poll)
+      @user.last_poll = Time.now.utc
+      response
+    else
+      Error.new(:not_in_room, "Please join this room first")
+    end
+  end
+
+  def ping(message, options = {})
+    if @user and @user.last_poll and Time.now.utc > @user.last_poll
+      time = Time.now.utc
+      { 'pong' => time }
+    else
+      # TODO: HANDLE PING OUTS
+      Error.new(:ping_out, 'Your connection has been lost')
+    end
+  end
+
+  def quit(message, options = {})
+    if @user
+      disconnect_user @user
+    end
+  end
+
+  def room_message(message, options)
+    room = Room.find options['to']
+    if room and room.users.include? @user
+      room.send_message({ 'message' => message, 'user' => @user.name, 'time' => Time.now.utc })
+    else
+      send_response Error.new(:not_in_room, "Please join this room first")
+    end
+  end
+
+  def private_message(message, options)
+    user = users_with_names.find { |u| u.name.downcase == options['to'].downcase }
+    if user
+      # Return the message to the user, and send it to the other person too
+      now = Time.now.utc
+      user.private_message({ 'message' => message, 'user' => @user.name, 'time' => now })
+      @user.private_message({ 'message' => message, 'user' => @user.name, 'time' => now })
+    else
+      Error.new(:not_online, 'User not online')
+    end
+  end
+
+  def send_message(message, options)
+    if options['to'].nil?
+      send_response Error.new(:to_required, 'Please specify who to send the message to or join a channel')
+    elsif options['to'][0].chr == '#'
+      room_message message, options
+    else
+      private_message message, options
+    end
+  end
+
+  def join(room_name, options = {})
+    if Room.valid_name? room_name
+      room = Room.find_or_create(room_name)
+      room.join @user
+    else
+      Error.new(:invalid_room, 'Invalid room name')
+    end
+  end
+
+  def part(room_name, options = {})
+    room = @user.rooms.find { |r| r.name == room_name }
+    if room
+      room.part @user
+    else
+      Error.new(:not_in_room, "You are not in that room")
+    end
+  end
+
+  def names(room_name, options = {})
+    room = Room.find(room_name)
+    if room
+      { 'display' => 'names', 'names' => room.users, 'room' => room.name }
+    else
+      Error.new(:room_not_available, 'No such room')
+    end
+  end
+
+  def new_cookie
+    chars = ("a".."z").to_a + ("1".."9").to_a 
+    Array.new(8, '').collect { chars[rand(chars.size)] }.join
+  end
+
+  def register_stateless_cient
+    @stateless_cookie = new_cookie
+    user = User.new(self)
+    @@stateless_cookies << { :cookie => @stateless_cookie, :user => user }
+    @@users << user
+    { 'cookie' => @stateless_cookie }
+  end
+
+  def current_stateless_client
+    @@stateless_cookies.find { |c| c[:cookie] == @stateless_cookie }
+  end
+
+  def register_stateless_user
+    current_stateless_client[:user] = @user
+  end
+
+  def valid_stateless_user?
+    current_stateless_client 
+  end
+
+  def load_stateless_user
+    if client = current_stateless_client
+      @user = client[:user]
+      @stateless = true
+    else
+      raise JsChat::Errors::InvalidCookie.new(:invalid_cookie, 'Invalid cookie')
+    end
+  end
+
+  def disconnect_lagged_users
+    @@stateless_cookies.delete_if do |cookie|
+      lagged?(cookie[:user].last_poll) ? disconnect_user(cookie[:user]) && true : false
+    end
+  end
+
+  def lagged?(time)
+    Time.now.utc - time > STATELESS_TIMEOUT
+  end
+
+  def unbind
+    return if @stateless
+    disconnect_user(@user)
+    @user = nil
+  end
+
+  def disconnect_user(user)
+    log :info, "Removing a connection"
+    Room.find(user).each do |room|
+      room.quit_notice user
+    end
+
+    @@users.delete_if { |u| u == user }
+  end
+
+  def post_init
+    @@users ||= []
+    @@stateless_cookies ||= []
+    @user = User.new(self)
+    @@users << @user
+  end
+
+  def log(level, message)
+    if Object.const_defined? :ServerConfig and ServerConfig[:logger]
+      if @user
+        message = "#{@user.name} (#{@user.ip}): #{message}"
+      end
+      ServerConfig[:logger].send level, message
+    end
+  end
+
+  def change(change, options = {})
+    if change == 'user'
+      field, value = @user.send :change, options[change]
+      { 'display' => 'notice', 'notice' => "Your #{field} has been changed to: #{value}" }
+    else
+      Error.new(:invalid_request, "Invalid change request")
+    end
+  rescue JsChat::Errors::InvalidName => exception
+    exception
+  end
+
+  def send_response(data)
+    response = ''
+    case data
+      when String
+        response = data
+      when Error
+        response = data.to_json + "\n"
+        log :error, data.message
+      else
+        # Other objects should be safe for to_json
+        response = data.to_json + "\n"
+        log :info, response.strip
+    end
+    
+    send_data response
+  end
+
+  include EM::Protocols::LineText2
+
+  def get_remote_ip
+    Socket.unpack_sockaddr_in(get_peername)[1]
+  end
+
+  def receive_line(data)
+    response = ''
+    disconnect_lagged_users
+
+    if data and data.size > ServerConfig[:max_message_length]
+      raise JsChat::Errors::MessageTooLong.new(:message_too_long, 'Message too long')
+    end
+
+    data.chomp.split("\n").each do |line|
+      # Receive the identify request
+      input = JSON.parse line 
+
+      @user.seen!
+
+      # Unbind when a stateless connection doesn't match the cookie
+      if input.has_key?('cookie')
+        @stateless_cookie = input['cookie']
+        load_stateless_user
+      end
+
+      if input.has_key? 'protocol'
+        if input['protocol'] == 'stateless'
+          @stateless = true
+          response << send_response(register_stateless_cient)
+        end
+      elsif input.has_key? 'identify'
+        input['ip'] ||= get_remote_ip
+        response << send_response(identify(input['identify'], input['ip']))
+      else
+        ['lastlog', 'change', 'send', 'join', 'names', 'part', 'since', 'ping', 'quit'].each do |command|
+          if @user.name.nil?
+            response << send_response(Error.new(:identity_required, "Identify first"))
+            return response
+          end
+
+          if input.has_key? command
+            if command == 'send'
+              @user.last_activity = Time.now.utc
+              message_result = send('send_message', input[command], input)
+              response << message_result if message_result.kind_of? String
+            else
+              result = send_response(send(command, input[command], input))
+              response << result if result.kind_of? String
+            end
+          end
+        end
+      end
+    end
+
+    response
+  rescue JsChat::Errors::StillFlooding
+    ""
+  rescue JsChat::Errors::Flooding => exception
+    send_response exception
+  rescue JsChat::Errors::MessageTooLong => exception
+    send_response exception
+  rescue JsChat::Errors::InvalidCookie => exception
+    send_response exception
+  rescue Exception => exception
+    puts "Data that raised exception: #{exception}"
+    p data
+    print_call_stack
+  end
+
+  def print_call_stack(from = 2, to = 5)
+    puts "Stack:"
+    (from..to).each do |index|
+      puts "\t#{caller[index]}"
+    end  
+  end  
+end

data/test/server_test.rb

@@ -0,0 +1,175 @@
+require 'test_helper'
+
+class TestJsChat < Test::Unit::TestCase
+  include JsChatHelpers
+
+  def setup
+    @jschat = JsChatMock.new
+    @jschat.post_init
+  end
+
+  def teardown
+    @jschat.reset
+  end
+
+  def test_identify
+    response = JSON.parse @jschat.receive_line({ 'identify' => 'alex' }.to_json)
+    assert_equal 'identified', response['display']
+  end
+
+  def test_invalid_identify
+    response = JSON.parse @jschat.receive_line({ 'identify' => '@lex' }.to_json)
+    assert_equal JsChat::Errors::Codes.invert[:invalid_name], response['error']['code']
+  end
+
+  def test_identify_twice_fails
+    identify_as 'alex'
+    result = JSON.parse identify_as('alex')
+    assert_equal 106, result['error']['code']
+  end
+
+  def test_ensure_nicks_are_longer_than_0
+    result = JSON.parse identify_as('')
+    assert result['error']
+  end
+
+  def test_ensure_nicks_are_unique
+    identify_as 'alex'
+
+    # Obvious duplicate
+    result = identify_as 'alex'
+    assert result['error']
+
+    # Case
+    result = identify_as 'Alex'
+    assert result['error']
+  end
+
+  def test_invalid_room_name
+    identify_as 'bob'
+    response = JSON.parse @jschat.receive_line({ 'join' => 'oublinet' }.to_json)
+    assert_equal 'Invalid room name', response['error']['message']
+  end
+
+  def test_join
+    identify_as 'bob'
+    expected = { 'display' => 'join', 'join' => { 'user' => 'bob', 'room' => '#oublinet' } }.to_json + "\n"
+    assert_equal expected, @jschat.receive_line({ 'join' => '#oublinet' }.to_json)
+  end
+
+  def test_join_without_identifying
+    response = JSON.parse @jschat.receive_line({ 'join' => '#oublinet' }.to_json)
+    assert response['error']
+  end
+
+  def test_join_more_than_once
+    identify_as 'bob'
+
+    expected = { 'display' => 'error', 'error' => { 'message' => 'Already in that room' } }.to_json + "\n"
+    @jschat.receive_line({ 'join' => '#oublinet' }.to_json)
+    response = JSON.parse @jschat.receive_line({ 'join' => '#oublinet' }.to_json)
+    assert_equal JsChat::Errors::Codes.invert[:already_joined], response['error']['code']
+  end
+
+  def test_names
+    identify_as 'nick', '#oublinet'
+
+    # Add a user
+    @jschat.add_user 'alex', '#oublinet'
+
+    response = JSON.parse(@jschat.receive_line({ 'names' => '#oublinet' }.to_json))
+    assert response['names']
+  end
+
+  def test_valid_names
+    user = JsChat::User.new nil
+    ['alex*', "alex\n"].each do |name|
+      assert_raises JsChat::Errors::InvalidName do
+        user.name = name
+      end
+    end
+  end
+
+  def test_message_not_in_room
+    identify_as 'nick', '#oublinet'
+    @jschat.add_user 'alex', '#oublinet'
+    response = JSON.parse @jschat.receive_line({ 'send' => 'hello', 'to' => '#merk' }.to_json)
+    assert_equal 'Please join this room first', response['error']['message']
+  end
+
+  def test_message
+    identify_as 'nick', '#oublinet'
+    @jschat.add_user 'alex', '#oublinet'
+    assert @jschat.receive_line({ 'send' => 'hello', 'to' => '#oublinet' }.to_json)
+  end
+
+  def test_message_ignores_case
+    identify_as 'nick', '#oublinet'
+    @jschat.add_user 'alex', '#oublinet'
+    response = @jschat.receive_line({ 'send' => 'hello', 'to' => '#Oublinet' }.to_json)
+    assert response
+  end
+
+  def test_part
+    identify_as 'nick', '#oublinet'
+    @jschat.add_user 'alex', '#oublinet'
+    response = JSON.parse @jschat.receive_line({ 'part' => '#oublinet'}.to_json)
+    assert_equal '#oublinet', response['part']['room']
+  end
+
+  def test_private_message
+    identify_as 'nick'
+    @jschat.add_user 'alex', '#oublinet'
+    response = JSON.parse @jschat.receive_line({ 'send' => 'hello', 'to' => 'alex' }.to_json)
+    assert_equal 'hello', response['message']['message']
+  end
+
+  def test_private_message_ignores_case
+    identify_as 'nick'
+    @jschat.add_user 'alex', '#oublinet'
+    response = JSON.parse @jschat.receive_line({ 'send' => 'hello', 'to' => 'Alex' }.to_json)
+    assert_equal 'hello', response['message']['message']
+  end
+
+  def test_log_request
+    identify_as 'nick', '#oublinet'
+    @jschat.receive_line({ 'send' => 'hello', 'to' => '#oublinet' }.to_json)
+    response = JSON.parse @jschat.receive_line({ 'lastlog' => '#oublinet' }.to_json)
+    assert_equal 'hello', response['messages'].last['message']['message']
+  end
+
+  def test_name_change
+    identify_as 'nick', '#oublinet'
+    @jschat.add_user 'alex', '#oublinet'
+    response = JSON.parse @jschat.receive_line({ 'change' => 'user', 'user' => { 'name' => 'bob' }}.to_json)
+    assert_equal 'notice', response['display']
+  end
+
+  def test_name_change_duplicate
+    identify_as 'nick', '#oublinet'
+    @jschat.add_user 'alex', '#oublinet'
+    response = JSON.parse @jschat.receive_line({ 'change' => 'user', 'user' => { 'name' => 'alex' }}.to_json)
+    assert_equal 'error', response['display']
+  end
+
+  def test_max_message_length
+    identify_as 'nick', '#oublinet'
+    response = JSON.parse @jschat.receive_line({ 'send' => 'a' * 1000, 'to' => '#oublinet' }.to_json)
+    assert response['error']
+  end
+
+  def test_flood_protection
+    identify_as 'nick', '#oublinet'
+    response = ''
+    # simulate a flood and extract the error response
+    (1..50).detect do
+      response = @jschat.receive_line({ 'send' => 'a' * 10, 'to' => '#oublinet' }.to_json)
+      response.match /error/
+    end
+    response = JSON.parse response
+    assert response['error']
+    assert_match /wait a few seconds/i, response['error']['message']
+  end
+
+end
+

data/test/stateless_test.rb

@@ -0,0 +1,33 @@
+require 'test_helper'
+
+class TestJsChat < Test::Unit::TestCase
+  include JsChatHelpers
+
+  def setup
+    @jschat = JsChatMock.new
+    @jschat.post_init
+    @cookie = get_cookie 
+  end
+
+  def test_identify
+    response = send_to_jschat({ 'identify' => 'alex', 'cookie' => @cookie })
+    assert_equal 'identified', response['display']
+  end
+
+  def test_join
+    response = identify_as 'alex2', '#jschat'
+    assert JSON.parse(response)['join']
+  end
+
+  def test_message
+    response = identify_as 'nick', '#jschat'
+    assert send_to_jschat({ 'cookie' => @cookie, 'send' => 'hello', 'to' => '#jschat' }, false)
+  end
+
+  private
+
+    def get_cookie
+      JSON.parse(@jschat.receive_line({ 'protocol' => 'stateless' }.to_json))['cookie']
+    end
+
+end