RabbitChat
A Chat-Server/Chat-System based on AMQP protocol(RabbitMQ) + AMQP Python Client(PIKA) + Websockets(SockJS) + Async Python Server(Tornado)
Install / Use
/learn @anirbanroydas/RabbitChatREADME
rabbitChat
A Chat-Server/Chat-System based on AMQP protocol(RabbitMQ Message Broker) written in python using Tornado and RabbitMQ.
Documentation
Link : http://rabbitchat.readthedocs.io/en/latest/index.html
Project Home Page
Link : https://pypi.python.org/pypi/rabbitChat
Details
:Author: Anirban Roy Das :Email: anirban.nick@gmail.com :Copyright(C): 2017, Anirban Roy Das anirban.nick@gmail.com
Check rabbitChat/LICENSE file for full Copyright notice.
Overview
rabbitChat is a very simple Chat Server which can be set up locally to chat in your LAN. It supports both Public Chat among all participants connected simultaneously at a particular time and also Private Chat betweent those individual participants.
It uses the AMQP <https://www.amqp.org/>_ protocol to implement the real time message passing system. AMQP is implemented in many languages and in many softwares, once of such is RabbitMQ <https://www.rabbitmq.com/>_ , which is a message broker implementing the AMQP <https://www.amqp.org/>_ protocol.
The connection is created using the sockjs <https://github.com/sockjs/sockjs-client>_ protocol. SockJS is implemented in many languages, primarily in Javascript to talk to the servers in real time, which tries to create a duplex bi-directional connection between the Client(browser) and the Server. Ther server should also implement the sockjs protocol. Thus using the sockjs-tornado <https://github.com/MrJoes/sockjs-tornado>_ library which exposes the sockjs protocol in Tornado <http://www.tornadoweb.org/>_ server.
It first tries to create a Websocket <https://en.wikipedia.org/wiki/WebSocket>_ connection, and if it fails then it fallbacks to other transport mechanisms, such as Ajax, long polling, etc. After the connection is established, the tornado server**(sockjs-tornado)** connects to rabbitMQ via AMQP protocol using the AMQP Python Client Library, Pika <https://pypi.python.org/pypi/pika>_.
Thus the connection is web-browser to tornado to rabbitMQ and vice versa.
Technical Specs
:sockjs-client: Advanced Websocket Javascript Client
:Tornado: Async Python Web Library + Web Server
:sockjs-tornado: SockJS websocket server implementation for Tornado
:AMQP: Advance Message Queuing Protocol used in Message Oriented Middleware
:pika: AMQP Python Client Library
:RabbitMQ: A Message Broker implementing AMQP
:pytest: Python testing library and test runner with awesome test discobery
:pytest-flask: Pytest plugin for flask apps, to test fask apps using pytest library.
:Uber's Test-Double: Test Double library for python, a good alternative to the mock <https://github.com/testing-cabal/mock>_ library
:Jenkins (Optional): A Self-hosted CI server
:Travis-CI (Optional): A hosted CI server free for open-source projecs
:Docker: A containerization tool for better devops
Features
- Public chat
- Shows who joined and who left
- Shows number of people online
- Shows who is typing and who is not
- Join/Leave chat room features
- Microservice
- Testing using Docker and Docker Compose
- CI servers like Jenkins, Travis-CI
Installation
There are two types of Installation. One using rabbitChat as a binary by installaing from pip and running the application in the local machine directly. Another method is running the application from Docker. Hence another set of installation steps for the Docker use case.
[Docker Method] Prerequisite (Optional)
To safegurad secret and confidential data leakage via your git commits to public github repo, check ``git-secrets``.
This `git secrets <https://github.com/awslabs/git-secrets>`_ project helps in preventing secrete leakage by mistake.
[Docker Method] Dependencies
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1. Docker
2. Make (Makefile)
See, there are so many technologies used mentioned in the tech specs and yet the dependencies are just two. This is the power of Docker.
[Docker Method] Install
~~~~~~~~~~~~~~~~~~~~~~~~
* **Step 1 - Install Docker**
Follow my another github project, where everything related to DevOps and scripts are mentioned along with setting up a development environemt to use Docker is mentioned.
* Project: https://github.com/anirbanroydas/DevOps
* Go to setup directory and follow the setup instructions for your own platform, linux/macos
* **Step 2 - Install Make**
::
# (Mac Os)
$ brew install automake
# (Ubuntu)
$ sudo apt-get update
$ sudo apt-get install make
* **Step 3 - Install Dependencies**
Install the following dependencies on your local development machine which will be used in various scripts.
1. openssl
2. ssh-keygen
3. openssh
[Standalone Binary Method] Prerequisites
- python 2.7+
- tornado
- sockjs-tornado
- sockjs-client
- pika
- rabbitMQ
[Standalone Binary Method] Install
::
$ pip install rabbitChat
If above dependencies do not get installed by the above command, then use the below steps to install them one by one.
**Step 1 - Install pip**
Follow the below methods for installing pip. One of them may help you to install pip in your system.
* **Method 1 -** https://pip.pypa.io/en/stable/installing/
* **Method 2 -** http://ask.xmodulo.com/install-pip-linux.html
* **Method 3 -** If you installed python on MAC OS X via ``brew install python``, then **pip** is already installed along with python.
**Step 2 - Install tornado**
::
$ pip install tornado
**Step 3 - Install sockjs-tornado**
::
$ pip install sockjs-tornado
**Step 4 - Install pika**
::
$ pip install pika
**Step 5 - Install RabbitMQ**
* *For* ``Mac`` *Users*
1. Brew Install RabbitMQ
::
$ brew install rabbitmq
2. Configure RabbitMq, follow this `link <https://www.rabbitmq.com/install-homebrew.html>`_, this `one <https://www.rabbitmq.com/install-standalone-mac.html>`_ and `this <https://www.rabbitmq.com/configure.html>`_.
* *For* ``Ubuntu/Linux`` *Users*
1. Enable RabbitMQ application repository
::
$ echo "deb http://www.rabbitmq.com/debian/ testing main" >> /etc/apt/sources.list
2. Add the verification key for the package
::
$ wget -o http://www.rabbitmq.com/rabbitmq-signing-key-public.asc | sudo apt-key add -
3. Update the sources with our new addition from above
::
$ apt-get update
4. And finally, download and install RabbitMQ
::
$ sudo apt-get install rabbitmq-server
5. Configure RabbitMQ, follow this `link <http://www.rabbitmq.com/install-debian.html>`_, this `one <https://www.rabbitmq.com/configure.html>`_ and `this <https://www.digitalocean.com/community/tutorials/how-to-install-and-manage-rabbitmq>`_.
CI Setup
---------
If you are using the project in a CI setup (like travis, jenkins), then, on every push to github, you can set up your travis build or jenkins pipeline. Travis will use the ``.travis.yml`` file and Jenknis will use the ``Jenkinsfile`` to do their jobs. Now, in case you are using Travis, then run the Travis specific setup commands and for Jenkins run the Jenkins specific setup commands first. You can also use both to compare between there performance.
The setup keys read the values from a ``.env`` file which has all the environment variables exported. But you will notice an example ``env`` file and not a ``.env`` file. Make sure to copy the ``env`` file to ``.env`` and **change/modify** the actual variables with your real values.
The ``.env`` files are not commited to git since they are mentioned in the ``.gitignore`` file to prevent any leakage of confidential data.
After you run the setup commands, you will be presented with a number of secure keys. Copy those to your config files before proceeding.
**NOTE:** This is a one time setup.
**NOTE:** Check the setup scripts inside the ``scripts/`` directory to understand what are the environment variables whose encrypted keys are provided.
**NOTE:** Don't forget to **Copy** the secure keys to your ``.travis.yml`` or ``Jenkinsfile``
**NOTE:** If you don't want to do the copy of ``env`` to ``.env`` file and change the variable values in ``.env`` with your real values then you can just edit the ``travis-setup.sh`` or ``jenknis-setup.sh`` script and update the values their directly. The scripts are in the ``scripts/`` project level directory.
**IMPORTANT:** You have to run the ``travis-setup.sh`` script or the ``jenkins-setup.sh`` script in your local machine before deploying to remote server.
Travis Setup
~~~~~~~~~~~~~~~~~
These steps will encrypt your environment variables to secure your confidential data like api keys, docker based keys, deploy specific keys.
::
$ make travis-setup
Jenkins Setup
~~~~~~~~~~~~~~~~~~~
These steps will encrypt your environment variables to secure your confidential data like api keys, docker based keys, deploy specific keys.
::
$ make jenkins-setup
Usage
-----
There are two types of Usage. One using rabbitChat as a binary by installaing from pip and running the application in the local machine directly. Another method is running the application from Docker. Hence another set of usage steps for the Docker use case.
[Docker Method]
~~~~~~~~~~~~~~~~
After having installed the above dependencies, and ran the **Optional** (If not using any CI Server) or **Required** (If using any CI Server) **CI Setup** Step, then just run the following commands to use it:
You can run and test the app in your local development machine or you can run and test directly in a remote machine. You can also run and test in a production environment.
[Docker Method] Run
~~~~~~~~~~~~~~~~~~~~
The below commands will start
