web_socket_chat_server 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 908c10e8b6e1d6907c83b755b5698882957ecd97
+  data.tar.gz: 2b8c2ff2b5beb46cc2bb995c36901193b25b5e94
+SHA512:
+  metadata.gz: a1cebe92b3d42bfdaae20a4c8f47f5f33cb544e0009fe16eb0a38269a05b2ef13ed05f83db39d38f5d7a0fc33ab442313106338208370282e40473607dd184ad
+  data.tar.gz: 8b410fa05463db45710a2676f0e653df42dec982b8e04f05a8b7690e62fe29e6eebac47c72a9ffd0cd45715e68e736127649387c879d26728d0954e737080527

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in web_socket_chat_server.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Jone Samra
+
+MIT License
+
+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/README.md

@@ -0,0 +1,87 @@
+# WebSocketChatServer
+
+A wrapper class for em-websocket (https://github.com/igrigorik/em-websocket) implementing a custom chat server protocol.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'web_socket_chat_server'
+```
+
+And then execute:
+
+$ bundle
+
+Or install it yourself as:
+
+$ gem install web_socket_chat_server
+
+## Usage
+
+An example on how to run the server:
+
+```ruby
+require "web_socket_chat_server.rb"
+
+admin1 = WebSocketChatServer::ChatUser.new(:username => "admin", :password => "secret")
+admin2 = WebSocketChatServer::ChatUser.new(:username => "admin2", :password => "secret2")
+admins = []
+admins << admin1
+admins << admin2
+
+chat = WebSocketChatServer::ChatServer.new(:host=> "0.0.0.0", :port => "8080", :admins => admins)
+
+chat.start_server do |response|
+puts response
+end
+
+['TERM', 'INT'].each do |signal|
+trap(signal){ 
+chat.stop_server()
+}
+end
+
+wait = gets
+```
+
+The code above creates an array consisting of two admins (ChatUser objects) and passes them to initialize(). The server will listen on IP 0.0.0.0 and the port 8080 (Required parameters). 
+
+By running the code above, you do not need to do any other things. The class takes care of the of itself by handling the connections and the logic of the server’s custom protocol. You still though have the opportunity to print out the commands generated by the server by passing a block to the start_server() function as it has been done above.
+
+On the client side, use the HTML WebSocket API to connect to the server. An example on a fully working Chat client will be attached to this repo (CHAT_CLIENT_EXAMPLE). 
+
+To explain how to connect to the server briefly:
+
+You have to pass the query parameters username & password to the socket client when connecting. 
+
+On successful connection, you can send a JSON hash of the format {command: ”…”, data: ”…}
+
+### Available commands are:
+{command: ”chat_message”, data: ”your message”}
+
+{command: ”private_message”, data: {to_user:  ”chuck_norris”, message: ”Private message”}}
+
+{command: ”ban_user”, data: ”chuck_norris”}
+
+
+The server will respond with a JSON hash of the format {command: ”…”, data: ”…”, information: ”…”}
+
+### Available responses are:
+{command: ”failed_connection”, data: nil, information: ”Some details”}
+
+{command: ”successful_connection”, data: array_of_connected_users, information: ”Some details”}
+
+{command: ”new_connection”, data: username, information: ”A new connected user”}
+
+{command: ”chat_message”, data: {from_user: ”chuck_norris”, message: ”The message”}, information: ”Some details.”}
+
+{command: ”ban_user”, data: TRUE or FALSE, information: ”Some details.”}
+
+{command: ”private_message”, data: {from_user: ”chuck_norris”, message: ”The message”}, information: ”Some details.”}
+
+{command: ”system_information”, data: ”Issue”, information: ”Some details.”}
+
+{command: ”user_disconnected”, data: ”username”, information: ”Some details.”}
+

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/lib/web_socket_chat_server/version.rb

@@ -0,0 +1,3 @@
+module WebSocketChatServer
+  VERSION = "0.0.1"
+end

data/lib/web_socket_chat_server.rb

@@ -0,0 +1,414 @@
+require 'socket'
+require "em-websocket"
+require "json"
+module WebSocketChatServer
+
+# A wrapper class for em-websocket (https://github.com/igrigorik/em-websocket) implementing a custom chat server protocol. 
+
+class ChatServer
+	# An array of string containing the banned usernames. 
+	attr_accessor :banned_usernames
+
+	# The max number of allowed client connections. 
+	attr_accessor :max_connections
+	
+	# An array of ChatUser objects representing the admins of the chat.
+	attr_reader :admins
+	
+	# A hash containing the connected users. The key contains of the user's username and the value is a ChatUser object.
+	attr_reader :connected_users
+	
+	# The host address.
+	attr_reader :host 
+	
+	# The socket port to be used.
+	attr_reader :port
+
+	# The class initializer
+	# ==== args
+	# * +:server+ (Required) - The host of the chat server to run on.
+	# * +:port+ (Required) - The port of the server.
+	# * +:max_connections+ (Optional) - The max client connections allowed. If not passed, the default is 100.
+	# * +:secure+ (Optional) - In case of using Secure Servers, pass true as allowed by em-websocket (https://github.com/igrigorik/em-websocket#secure-server).
+	# * +:tls-options+ (Optional) - The TLS options as allowed by em-websocket (https://github.com/igrigorik/em-websocket#secure-server). 
+	# * +:secure_proxy+ (Optional) - When ruinng behind a SSL proxy (https://github.com/igrigorik/em-websocket#running-behind-an-ssl-proxyterminator-like-stunnel).
+	# * +:admins+ (Optional) - In order to have admins (for banning users). Pass an array of ChatUser objects to this key. The ChatUser object contains of username and password attributes. The username must consist of at least 3 alphanumeric characters. The password must at least consist of 6 alphanumeric characters. 
+	def initialize(args = {:host => "0.0.0.0", :port => 8080})
+		raise ArgumentError, "The :host parameter is required" unless args.has_key?(:host)
+		raise ArgumentError, "The :port parameter is required" unless args.has_key?(:port)
+		raise ArgumentError, "The port value is not valid" unless valid_port?( args[:port])
+		@max_connections = args[:max_connections].to_s.to_i
+		@max_connections = 100 if @max_connections == 0
+		@host = args[:host]
+		@port = args[:port]
+		@server_started = false
+		@admins = []
+		@banned_usernames = []
+		@connected_users = Hash.new
+		
+		@server_options = Hash.new
+		@server_options[:host] = @host
+		@server_options[:port] = @port.to_i
+		@server_options[:secure] = args[:secure] if args.has_key?(:secure)
+		@server_options[:tls_options] = args[:tls_options] if args.has_key?(:tls_options)
+		@server_options[:secure_proxy] = args[:secure_proxy] if args.has_key?(:secure_proxy)
+
+
+		if args.has_key?(:admins)
+			if args[:admins].class == Array
+				args[:admins].each { |chat_user|
+					if chat_user.class == ChatUser
+						raise RuntimeError, "The admin's username has to be at least 3 alphanumeric characters, and the password at least 6 alphanumeric characters" unless user_credentials_valid?(chat_user.username, chat_user.password)
+						@admins << chat_user unless @admins.include?(chat_user)
+					end
+				}
+			end
+		end
+	end
+
+	# To start the server, call this method. It will return true if successful, false if it is already started. Otherwise, RuntimeError will be raised on errors. If giving a <b>block</b>, A hash <b>{command: "...", data: "...", information: "..."}</b> is yield. 
+	def start_server()
+		return false if @server_started
+
+		begin
+			Thread.new {run_server() do |response|
+				yield response if block_given?
+			end
+		}
+	rescue Exception => e
+		@server_started = false
+		raise RuntimeError, e.message
+	end
+
+	until @server_started
+		next
+	end
+
+	@server_started
+end
+
+	# To stop the server, call this method. True if the server is stopped, false if it is already stopped. Otherwise, RuntimeError is raised on errors. 
+	def stop_server()
+		return false unless @server_started
+		@server_started = false
+		@banned_usernames.clear if @banned_usernames.count > 0
+		@admins.clear if @admins.count > 0
+		@connected_users.clear if @connected_users.count > 0
+		begin
+			EM::WebSocket.stop()	
+		rescue Exception => e
+			raise RuntimeError, e.message 
+		end
+		true
+	end
+
+	# Returns true if the server is started, otherwise false. 
+	def started?()
+		@server_started
+	end
+
+	private
+	# This method will fire the eventmachine and the containing em-socket. 
+	def run_server()
+		@server_started = true
+
+		EM.run do
+			EM::WebSocket.run(@server_options) do |ws|
+				ws.onopen { |handshake|
+					begin
+						response = nil
+						if (@connected_users.count + 1) > @max_connections
+							response = create_response_json("failed_connection", nil, "The max connections limit is reached.")
+							yield response if block_given?
+							ws.send(response)
+							ws.close
+							break
+						end
+
+						username = handshake.query["username"]
+						password = handshake.query["password"]
+						client_ip = Socket.unpack_sockaddr_in(ws.get_peername)[1]
+						user = ChatUser.new({:username => username, :password => password, :ip => client_ip})
+
+						if username.nil? || password.nil?
+							response = create_response_json("failed_connection", nil, "The username & password have to be passed in the query string.")
+							yield response if block_given?
+							ws.send(response)
+							ws.close
+							break
+						end 
+
+						if admin_credentials_invalid?(username, password)
+							response = create_response_json("failed_connection", nil, "Invalid credentials.")
+							yield response if block_given?
+							ws.send(response)
+							ws.close
+							break
+						end
+
+						if user_credentials_valid?(username, password) == false 
+							response = create_response_json("failed_connection", nil, "Invalid user creadentials. The username has to be at least 3 alphanumeric characters, and the password at least 6 alphanumeric characters.")
+							yield response if block_given?
+							ws.send(response)
+							ws.close
+							break
+						end
+
+						if user_banned?(user)
+							response = create_response_json("failed_connection", nil, "The user is banned")
+							yield response if block_given?
+							ws.send(response)
+							ws.close
+							break
+						end
+
+						number_of_tries = 0
+						while user_exists?(user)
+							number_of_tries = number_of_tries + 1
+							user.username = user.username + Random.rand(1..9999).to_s
+
+							if number_of_tries > 15 
+								response = create_response_json("failed_connection", nil, "The username exists already.")
+								yield response if block_given?
+								ws.send(response)
+								ws.close
+								break
+							end
+						end
+						
+						user.connection = ws
+
+						response = create_response_json("successful_connection", connected_users_to_array, "Connection accepted")
+						yield response if block_given?
+						ws.send(response)
+
+						@connected_users[user.username] = user
+						response = create_response_json("new_connection", user.username, "A new user is connected.")
+						yield response if block_given?
+						broadcast_message(response)
+					end while false
+				}
+				ws.onmessage { |msg|
+					json_data = nil
+					command = ""
+					data = ""
+					user = nil
+					begin
+						user = get_user_by_connection(ws)
+
+						if user.nil?
+							ws.close
+							break
+						end
+
+						begin
+							json_data = JSON.parse(msg)
+							command = json_data["command"]
+							data = json_data["data"]
+						rescue
+							break
+						end
+
+						case command
+						when "chat_message"
+							break if data == ""
+							response = create_response_json("chat_message", {"from_user" => user.username, "message" => data}, "A chat message.")
+							yield response if block_given?
+							broadcast_message(response)
+							break
+
+						when "ban_user"
+							break if data == ""
+							unless user_admin?(user)
+								ws.close
+								break
+							end
+
+							user_to_ban = get_user_by_username(data)
+							if user_to_ban.nil?
+								response = create_response_json("ban_user", false, "The user to ban did not exist.")
+								yield response if block_given?
+								ws.send(response)
+								break
+							end
+
+							if user_admin?(user_to_ban)
+								response = create_response_json("ban_user", false, "An admin user can not be banned.")
+								yield response if block_given?
+								ws.send(response)
+								break
+							end
+
+							@banned_usernames << user_to_ban.username
+							response = create_response_json("ban_user", true, "The user #{user_to_ban.username} has been banned.")
+							yield response if block_given?
+							ws.send(response)
+							user_to_ban.connection.close
+							break
+
+						when "private_message"
+							break unless data.is_a? Hash
+							break if data["to_user"].nil?
+							break if data["message"].nil?
+
+							user_to_receive = get_user_by_username(data["to_user"])
+							break if user_to_receive.nil?
+
+							response = create_response_json("private_message", {"from_user" => user.username, "message" => data["message"]}, "A private message.")
+							yield response if block_given?
+							user_to_receive.connection.send(response)
+							break
+
+						else
+							ws.send(create_response_json("system_information", "Unknown command", "Please make sure that you are sending the right command."))
+							ws.close
+							break
+						end
+					end while false
+				}
+				ws.onclose {
+					begin
+						break unless @server_started
+						deleted = nil
+						@connected_users.values.each do |u|
+							if u.connection == ws
+								name = u.username
+								deleted =  @connected_users.delete(name)
+								response = create_response_json("user_disconnected", deleted.username, "The user is diconnected.")
+								yield response if block_given?
+								broadcast_message(response)
+								break unless deleted.nil?
+							end
+						end
+					end while false
+				}
+				ws.onerror { |e|
+
+					unless e.kind_of?(EM::WebSocket::WebSocketError)
+						ws.close
+					end
+
+				}
+			end
+		end
+	end
+
+	# This method is used privately. It will check if the passwed username belongs to an admin and that the password matches. 
+	def admin_credentials_invalid?(username = "", password = "")
+		@admins.each do |admin|
+			return true if admin.username == username && admin.password != password
+		end
+
+		false
+	end
+
+	# This method is used privately to check if the username and password are valid. The username has to be at least 3 alphanumeric characters and the password 6 alphanumeric characters. 
+	# It returns true if the credentials are valid, otherwise false. 
+	def user_credentials_valid?(username = "", password = "")
+		return false if /\A\p{Alnum}{3,}\Z/.match(username).nil?
+		return false if /\A\p{Alnum}{6,}\Z/.match(password).nil?
+
+		true
+	end
+
+	# Returns true if the port number is valid. 
+	def valid_port?(value)
+		return false if /\A[0-9]{1,6}\Z/.match(value).nil?
+		true
+	end
+
+	# Returns true if the user is banned. 
+	def user_banned?(user)
+		if user.class == ChatUser 
+			return @banned_usernames.include?(user.username)
+		end
+
+		@banned_usernames.include?(user)
+	end
+
+	# Returns true if the username is already added to the connected users. 
+	def user_exists?(user)
+		@connected_users.include?(user.username)
+	end
+
+	# Returns true is the user is admin. 
+	def user_admin?(user)
+		@admins.include?(user)
+	end
+
+	# Sends text/json to the connected clients. 
+	def broadcast_message(message)
+		return false if @connected_users.count == 0
+
+		@connected_users.values.each do |u|
+			begin
+				u.connection.send(message) unless u.connection.nil?
+			rescue
+				next
+			end
+		end
+	end
+
+	# Returns the ChatUser object bound to the socket connection. 
+	def get_user_by_connection(connection)
+		return nil if @connected_users.count == 0
+		@connected_users.values.each do |user|
+			return user if user.connection == connection
+		end
+
+		nil
+	end
+
+	# Returns the ChatUser object by the username. 
+	def get_user_by_username(username)
+		@connected_users[username]
+	end
+
+	# Creates the json object to be sent to the clients.
+	def create_response_json(command = "", data = nil, message = "")
+		{"command" => command, "data" => data, "information" => message}.to_json
+	end
+
+	def connected_users_to_array()
+		usernames = []
+		@connected_users.values.each do |u|
+			usernames << u.username
+		end
+
+		usernames
+	end
+
+end
+
+
+class ChatUser
+	attr_accessor :username, :password, :connection, :ip
+	def initialize(args = {})
+		raise RuntimeError, "The username is not given" unless args.has_key?(:username)
+		raise RuntimeError, "The password is not given" unless args.has_key?(:password)
+
+		@connection = nil
+		@connection = args[:connection] if args.has_key?(:connection)
+		@ip = args[:ip] if args.has_key?(:ip)
+		@username = args[:username]
+		@password = args[:password]
+	end
+
+	def admin?()
+		@is_admin
+	end
+
+	def ==(object)
+		return false unless object.class == ChatUser
+		return username == object.username
+	end
+
+	def to_json(options = {})
+		{"user" => @username}.to_json
+	end
+
+end
+
+end
+
+

data/web_socket_chat_server.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib/', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'web_socket_chat_server/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "web_socket_chat_server"
+  spec.version       = WebSocketChatServer::VERSION
+  spec.authors       = ["Jone Samra"]
+  spec.email         = ["jonemob@gmail.com"]
+  spec.summary       = %q{A wrapper class for em-websocket (https://github.com/igrigorik/em-websocket) implementing a custom chat server protocol.}
+  spec.description   = %q{For more details, please read the documentation at http://abulewis.com/doc/WebSocketChatServer.html}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+  spec.required_ruby_version = ">= 2.0.0"
+
+  spec.add_runtime_dependency "em-websocket", "~> 0.5.1"
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: web_socket_chat_server
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Jone Samra
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-08-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: em-websocket
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.1
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: For more details, please read the documentation at http://abulewis.com/doc/WebSocketChatServer.html
+email:
+- jonemob@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/web_socket_chat_server.rb
+- lib/web_socket_chat_server/version.rb
+- web_socket_chat_server.gemspec
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: A wrapper class for em-websocket (https://github.com/igrigorik/em-websocket)
+  implementing a custom chat server protocol.
+test_files: []