XMPP & AMQP
Asynchronous, Event-Driven Messaging

Technologies

XMPP
Extensible Messaging and Presence Protocol
Core of Jabber IM technology
http://xmpp.org
AMQP
Advanced Message Queuing Protocol
An Open Standard for Messaging Middleware
http://amqp.org

Services
RabbitMQ
http://rabbitmq.com
ejabberd
http://jabber.im

Libraries
tmm1-amqp
http://github.com/tmm1/amqp
xmpp4r-simple
http://github.com/blaine/xmpp4r-simple

AMQP

Purpose

Message
Process 1 Process 2

? Message
Process 1 Process 2

Cross-Process Messaging
DRb (and Rinda)
HTTP
MySQL
PStore
AMQP

Cross-Process Messaging
Ruby only
DRb (and Rinda)
client
HTTP & server
artificial
MySQL solution
naive
PStore
AMQP

Cross-Process Messaging
AMQP
designed for multiprocess
messaging with a generic,
extensible protocol

A Message Is
an object of communication
Any type of transmission,
including marshaled Ruby objects
(in JSON, for instance)

Messages
# essentially Base64.encode(m.to_json)
require 'json'
# message = {\"name\" => \"Bob\"}
payload = [message.to_json].pack(\"m*\")

Messages
# essentially JSON.parse(Base64.decode(p))
require 'json'
# payload = \"eyJuYW1lIjoiQm9iIn0=\"
message = JSON.load(payload.unpack(\"m*\").first)

Usage

Libraries
require 'rubygems'
gem \"eventmachine\", \"0.12.2\"
gem \"tmm1-amqp\", \"0.6.0\"
require 'mq'

Queueing Messages
EM.run do
mq = MQ.new
q = mq.queue('noises')
q.publish('moo')
end

Queueing Messages (simplified)
EM.run do
MQ.new.queue('noises').publish('moo')
end

Subscribing to Queues
EM.run do
MQ.new.queue('noises').subscribe do |msg|
puts msg
end
end

Full Example
mq = MQ.new
q = mq.queue('noises')
q.subscribe do |msg|
puts \"Got: %s\" % msg.inspect
end
q.publish('moo')

Starting the EventMachine Reactor
# required
Thread.new{ EM.run{} }
# optional for clean shutdown
%w(INT TERM).each{ |sig|
old = trap(sig){
EM.stop
old.call if old.respond_to? :call
}
}

QUEUE MESSAGE!
Process 1 Process 1
Msg
NOTIFY
SUBSCRIBER!
RabbitMQ
Msg Msg
SUBSCRIBE Msg
TO QUEUE!
Process 2 Process 2

XMPP

Purpose

Message
Machine 1 Machine 2

?
Message
Machine 1 Machine 2

XMPP
Message
Message
Delivery
Machine 1 Machine 2
Identity Identity
Persistent
Connections
Presence
(State)
Rosters
(Friends)

Usage

Libraries
require 'rubygems'
gem \"eventmachine\", \"0.12.2\"
gem \"xmpp4r-simple\", \"0.8.8\"
require 'xmpp4r-simple'

Logging On
client =
Jabber::Simple.new(\"test@example.com\", \"password\")

Sending Messages
client.deliver(\"test@example.net\", \"OH HAI\")

Receiving Messages
client.received_messages do |msg|
puts \"From: %s\" % msg.from.to_s
puts msg.body
puts
end

Handling Status Updates
client.presence_updates do |jid, presence, msg|
puts \"%s is now %s (%s)\" %
[jid.to_s, presence, message]
end

XMPP+AMQP

Event-Driven Architecture

Purpose

AMQP XMPP
Process
queue
Msg
1 Machine Machine
message
1 2..n
subscriber AMQP
notified RabbitMQ
Process
Process
2 XMPP
3..n
message ejabberd
message
sent delivered

Similarities
AMQP RabbitMQ XMPP ejabberd
Erlang Ruby libraries
asynchronous standardized
local/remote extensible
clusterable
offline message queue

Differences
AMQP RabbitMQ XMPP ejabberd
binary transfer XML transfer
faster slower
push/pull push
no presence presence
subscribers members/rosters
message fidelity persistent conn.

Usage

Rails Plugin
require 'json'
require 'mq'
Thread.new{ EM.run{} }
class Foo
# queues message to be handed to external process
def self.queue(message)
payload = [message.to_json].pack(“m*”)
MQ.new.queue('messages').publish(payload)
end
end

Background Process/Task
require 'mq'
require 'xmpp4r-simple'
Thread.new{ EM.run{} }
class Foo
# redirect payload to recipient for processing
def self.run
@client ||=
Jabber::Simple.new(\"test@example.com\", \"password\")
MQ.new.queue('messages').subscribe do |payload|
@client.deliver(@recipient, payload)
end
end
end

External Process
require 'json'
require 'xmpp4r-simple'
class Foo
# periodically checks for and handles any messages
def self.run
@client ||=
Jabber::Simple.new(\"test@example.com\", \"password\")
EM.add_periodic_timer(3) do
@client.received_messages do |msg|
payload = msg.body
message = JSON.load(payload.unpack(\"m*\").first)
# do something with message
end
end
end
end

Summary

use whichever you prefer and meets
your needs
use existing solution, don’t write what
you don’t have to
don’t be afraid to combine them
have fun, experiment, fuck up