JsChat Blog

Twitter Auth, Mongo Logging and Tabs

Wed, 31 Mar 2010 04:28:00 -0400

JsChat now has Twitter Auth, logging with mongodb, and the web interface has tabs for switching between rooms. Twitter auth and mongodb give JsChat persistence.

People can sign in with Twitter, join a set of rooms, then sign in from another computer without appearing to log off JsChat. The user stays online until they’ve been idle for 7 days or they click Quit.

To get these features, install the following gems:

mongo
mongo_ext
twitter_oauth

Then set up an app on Twitter and add your keys to the config file. The config file can be in /etc/jschat/config.json, and should look like this:

{
  "port": 6789,
  "ip": "0.0.0.0",
  "logger": logger,
  "max_message_length": 500,
  "tmp_files": "/tmp/file/path",
  "db_name": "jschat",
  "db_host": "localhost",
  "db_port": 27017,
  "db_username": "",
  "db_password": "",
  "twitter" { "key": "xxx", "secret": "xxx" }
}

All of the options are optional, so leave any out that you don’t need. For example, the one we use on the JsChat server looks like this:

{ 
  "twitter": { "key": "xxx", "secret": "xxx" },
  "db_host": "swan.mongohq.com",
  "db_port": "27080",
  "db_username": "user",
  "db_password": "pass
}

Protocol Changes

Tue, 30 Mar 2010 11:17:28 -0400

The JsChat Protocol has been changed to include a time parameter in all messages. That means the display style messages no longer contain the time, it’s at the top level instead:

{ 'display' => 'message', 'message' => { ... }, 'time' => 'Tue Mar 30 15:17:02 UTC 2010' }

Gem Released

Sun, 21 Mar 2010 13:00:00 -0400

I’ve bundled JsChat into a gem so you can install it with:

gem install jschat

This makes it possible to run JsChat from the command line:

jschat-server - runs the server
jschat-web - runs a web app
jschat-client - runs the console client

I’ve also added config files. They’re in JSON format, and you need to double quote the keys. The default locations are (client) ~/.jschat/config.json and (server) /etc/jschat/config.json.

Stateless Protocol: Complete

Sat, 14 Nov 2009 08:35:43 -0500

JsChat now has a stateless protocol. This means you can register a cookie with the server that will persist a client connection across socket sessions.

The protocol works like this:

Connect to a server and send a JSON string with protocol set to stateless
The server will send back a cookie
On every subsequent request, provide the cookie

Here’s a code example: stateless_example.rb

One of the reasons for doing this is it cuts down the web app’s complexity. The old web app embedded an EventMachine module which maintained connections for each user with the server.

This actually duplicates functionality that is already in the JsChat server, and goes against the grain of the way I intended JsChat to function. The original approach made it difficult to run multiple web app processes (for example, with Passenger).

JsChat is meant to be a very simple protocol that’s easy to implement. The EventMachine session management approach was just a hack I did, reusing code from the console client.

The old web app was 440 lines of code, and it’s now 264.

Stateless Protocol

Fri, 06 Nov 2009 05:49:28 -0500

I’m working on making the JsChat protocol stateless. This means that the web client’s complexity will be greatly reduced in the future.

I’m going to make the stateless mode optional, so clients can connect using sockets or single requests.

Clojure Bot

Wed, 17 Jun 2009 14:57:11 -0400

Here’s an example of a bot written with Clojure: Clojure JsChat Bot. It might not be 100% idiomatic Clojure, but it shows that talking JsChat is simple in Clojure.

Clojure comes bundled with JSON libraries for creating and parsing JSON. The parser returns a PersistentArrayMap: ((parsed-json "message") "message") accesses the message body element of a JsChat message.

JavaScript Bots

Mon, 08 Jun 2009 07:59:28 -0400

I’ve made an example of a JavaScript bot for JsChat. You can run it using Rhino, and it uses Java’s sockets for connections:

$ rlwrap java -jar js.jar Rhino 1.7 release 2 2009 03 22 js> load('bot.js')

Notice how simple the code for interpreting the protocol is. I’ve used the same strategy as the JsChat client and server code, whereby methods are executed based on the hashes returned from the server: JsChat.Responses.Display[json.display]

Kev and his Emotes

Tue, 02 Jun 2009 06:00:03 -0400

Kev originally wanted us to build JsChat about 3 years ago. We haven’t quite implemented his idea yet (which was about monetizing IRC-style chat), but he’s had a lot of ideas and feature suggestions for JsChat so far. One that he was particularly concerned about was emoticons, so I included them on a rainy Sunday afternoon.

I just updated the web app with a command so you can list all of them. Next time you’re in the web app, type /emotes and you’ll get a list of available emoticons.

Passenger/Rack Support

Mon, 01 Jun 2009 14:22:43 -0400

I’ve just checked in Passenger and Rack support with a config.ru sample into the JsChat repo. It should now be easy to get JsChat working with Passenger if you use it on your servers.

I also made message submissions display in realtime in the web app’s chat transcript. This means there’s instant feedback when a message is posted.

JsChat: Polling

Fri, 29 May 2009 04:50:00 -0400

People are repeatedly joining #jschat talking about the merits of polling. Please read this before you do that, or you’re likely to get ignored:

Yes, I know about server-sent events and flash hacks that provide sockets
No, we’re not going to use Juggernaut
JsChat will gradually support native server-sent events (some browsers provide this already)
I used polling because it works on more devices and is cleaner
The web interface is only a small part of the system
Stop to consider the thought that’s been put into other aspects of the web interface

JsChat: Introduction

Wed, 27 May 2009 15:42:24 -0400

JsChat is a protocol for real-time chat based on JSON. This makes it easy to build servers, clients, bots, and web-native applications.

The protocol is currently evolving: JsChat is implemented as a proof of concept as both a web and console client.

Server

The server is written with Ruby and includes unit tests.

Console Client

The console client is meant to be similar to irssi. Typing /help will show available commands. It uses Ncurses and is written with Ruby.

Web Client

The web client must be run alongside a server. The design principles are:

Simple interface
Dynamic features: tab complete, URL autolinking, image URLs display inline, YouTube video URLs automatically display as embedded videos
Portability: only simple Ajax calls are relied on so it will run on most platforms and browsers (iPhone, etc)

Protocol Design

JsChat messages are treated like tuples: a command is provided with one or more pieces of relevant data. The command points to the payload of the message, and other items can be included to aid clients.

Current commands are: display, change
Messages take this format: { ‘display’ => ‘message’, ‘message’ => { ‘to’ => ‘#room’, ‘message’ => ‘This is a message’ }
Time stamps can be included in messages to aid clients

This syntax makes it easy to create classes that interpret the protocol. Consider how simple this would be in JavaScript:

Display = { message: function(message) { ... } } Display[json['display']]

Code

Get the code from my GitHub repository.

Over the next few week, I’ll post here with tutorials and tips on how to install JsChat and manage the server-side daemons. It’s running on jschat.org with Ruby 1.8, Apache and mod_proxy.