Hapi.js Socket.io Redis Chat Example
A basic chat application built with Hapi.js Socket.io and Redis Publish/Subscribe
Try it: https://hapi-chat.herokuapp.com/
Why?
Node.js Chat Apps are practically the "Hello World" of real-time apps.
If you Google for
"node.js chat example"
you will see thousands of results! But ... 90% of the examples use Express.js,
95% use MongoDB to store data/messages and 100% have zero tests.
So, this example is for the the people who prefer to have examples
that are fully explained (including tests).
As with all our examples we have a suite of tests.
What?
Real-Time
Chat is an integral part of any communications system.
Building a (basic) chat system is easy with Socket.io.
This example app shows you how to use Socket.io with Hapi.js and Redis for a
Horizontally Scalable
chat capable of hundrededs of thousands of concurrent clients.
How?
We are using the following components to build our chat app:
- Hapi.js (node.js web framework) - If you haven't used Hapi.js before,
checkout our introductory tutorial: https://github.com/dwyl/learn-hapi
- Socket.io (WebSockets with fallback for older clients) - If you're
new to Socket.io see: http://socket.io/get-started/chat/ - Redis (high performance message storage and publish/subscribe) - If you
or anyone on your team are completely new to Redis,
check out: https://github.com/dwyl/learn-redis
Why Redis?
Socket.io only handles distributing messages, if people disconnect
from the chat they will miss any subsequent messages and
when anyone connects there will see no history ...
so we need a place to store messages for retrieval.
Top 3 reasons why Redis is the clear choice for storing chat messages.
- Speed - Redis is much faster than MongoDB,
CouchDB or PostgreSQL - Simple - pushing messages onto a list (set) is the simplest
possible way to store a chat history. Given that we can store up to
512Mb per chat and stream chat history to new clients
(low http overhead) its an incredibly simple setup! - Scalable Publish/Subscribe ("pattern") means we can scale out
(add more node.js/socket.io servers when you need to serve more clients)
Redis can already handle an order of magnitude more than
other NoSQL Databases, so your most likely "bottleneck" is node (nuts, hey!?)
Publish / Subscribe ...?
The Publish Subscribe "Pattern" is (still) the simple_st_
way of scaling software applications. If you are new to this idea,
see: https://en.wikipedia.org/wiki/Publish%E2%80%93subscribe_pattern
Mobile First
Given the simplicity of the UI, the chat app is mobile-first by default.
If anyone has time to Pull Request a few CSS media
queries to make the UI even better on mobile devices,
we would massively appreciate the contribution!
Returning Visitor
We use cookies to store the person's name on the client. If the person
clears cookies (or uses private browsing / incognito mode) they will be asked
for their name each time they open the chat window. (this is pretty standard).
How Many Recent Messages Should we Cache?
At present we are caching all the messages in Redis.
But a less RAM-hungry way to scale the app would be to store only
the 50-100 most recent chat messages in Redis (RAM) and the remaining
history in a cheaper on-disk storage e.g. ElasticSearch
(which would also enable searchability)
Data Model
Data Model we have used is incredibly simple.
It translates to an array of objects:
var chat = [
'{"m":"Hi everyone!","t":1436263590869,"n":"Steve"}',
'{"m":"Hi Steve! Welcome to Hapi Chat!","t":1436263599489,"n":"Foxy"}',
'{"m":"Hapi Chat lets you chat with your friends!","t":1436263613141,"n":"Oprah"}',
'{"m":"Cool! How does it scale?","t":1436263620853,"n":"Steve"}',
'{"m":"Funny you should ask! It scales nicely because it uses Hapi.js and Redis!","t":1436263639989,"n":"Chroma"}',
'{"m":"Sweet! ","t":1436263645610,"n":"Steve"}',
'{"m":"Hello","t":1436264664835,"n":"Timmy"}',
'{"m":"Hi!","t":1436267152379,"n":"Timmy"}',
'{"m":"lkjlkjlk","t":1436270948402,"n":"dd"}',
'{"m":"Big fan of the little notifications at the top when a person joins","t":1436273109909,"n":"iteles"}'
]
We use single letters for field keys:
- m for message.
- n for name of the person who wrote the message
- t for timestamp the message was received by the
node server (to avoid time-zone issues);
Run it! (it's easy!)
Locally (on your own machine)
Try running the app! (Its as easy as 1, 2, 3!)
1. Clone the Repository
git clone https://github.com/dwyl/hapi-socketio-redis-chat-example.git
cd hapi-socketio-redis-chat-example
2. Install Redis (if you don't already have it!)
If you haven't already got an instance of Redis running on your machine,
Our Redis tutorial has instructions:
3. Install the Dependencies and Start the Server
Install the dependencies and start the app with:
npm install && npm start
Now visit: http://127.0.0.1:8000 (in your browser)
Running the Tests (Locally)
To successfully run the tests you need to have an environment variable
for RedisCloud (this is because we like to know that our code works
on both "local" and in a "production" environment...)
E.g:
export REDISCLOUD_URL=redis://rediscloud:yourpassword@pub-redis-12345.eu-west-1-2.1.ec2.garantiadata.com:12345
Given that our tests include checks for RedisCloud, you will need to have
internet access to run them ...
Running the Elm version
At dwyl we really like Elm
and Tachyons
and they're part of our
core technology stack,
so as well as the standard Javascript/HTML/CSS front end we've made one
in Elm so you can see what goes into a chat app in Elm as well.
You'll need
Elm installed on your machine
to run it so make sure you have that.
If you've never done Elm before we recommend starting with our
learn-elm-architecture
tutorial, and then moving onto learn-elm,
and once you're done with them come here and check out how the chat app works!
To run the Elm version go into your terminal and run:
npm run start-elm
this script runs elm-make when it runs, so will prompt you to install all
of the elm-stuff when you first run it, then go to localhost:8000/elm
(make sure you're not running the server already!).
If you're interested in the code go into elm/src/Main.elm,
it's commented all the way through so that you can understand everything.
(if anything is unclear,
let us know!)
We also have tests!
npm run test-elm
Elm doesn't currently have a coverage tool but we try to make sure all
of our logic is tested. If you haven't tested your Elm code before,
start now!
Heroku (deploying to Heroku)
Are you new to deploying apps to Heroku?
(Message us we can talk/walk you through it...!)
Background Reading
- Matt Harrison has basic example, but no tests (bad habits ...):
http://matt-harrison.com/using-hapi-js-with-socket-io - Scalability: https://en.wikipedia.org/wiki/Scalability#Horizontal_and_vertical_scaling
- Difference between scaling horizontally and vertically for databases:
http://stackoverflow.com/questions/11707879/difference-between-scaling-horizontally-and-vertically-for-databases - Using Pub/Sub for Asynchronous Communication:
http://www.rediscookbook.org/pubsub_for_asynchronous_communication.html - How to use Redis PUBLISH/SUBSCRIBE with Node.js to notify clients when data values change? http://stackoverflow.com/questions/4441798/how-to-use-redis-publish-subscribe-with-nodejs-to-notify-clients-when-data-value (_don't you love it when someone else has aready asked/answered your questions...?)
- node_redis pub/sub example: https://github.com/mranney/node_redis/blob/master/examples/pub_sub.js
- Redis PubSub example using express (no tests!): https://github.com/rajaraodv/redispubsub
