zeromq

There are many people working on interesting things around ØMQ. Here we collect ideas, works in progress, and projects by the ØMQ community. Feel free to add topics that interest you or that you're working on, using ØMQ. Stick to the format of other entries, and add your entry at the top. Thanks to Matt Weinstein for the sketch.

Rpclib (Python)

Ready to test, by Burak Arslan | 21 Mar 2012

Rpclib is a general purpose RPC framework for Python. Rpclib comes with the implementations of popular transport, protocol and interface document standards along with an easy-to-use API that lets you build on existing functionality. It also nicely integrates with frameworks like twisted. It currently supports ZeroMQ as a transport in a both client and server setting, using REQ/REP sockets. Soap, HttpRpc, JsonObject, XmlObject are some of the supported protocols.

Process Manager

In Development, by John Skaller | 2012

Tools to launch and manage processes, driven by the need to actually test the 0MQ Guide examples to ensure that they compile and run as expected automatically, so the testing can be included in a background script.

Discussion Process Manager

Cocaine Distributed Application Server

In Development, by Andrey Sibiryov and Rim Zaidullin | 2011 - 2012

Cocaine is a fast and lightweight open source platform providing tools and infrastructure components to build your own PaaS cloud. One of the core components is multi-language (you can easily write your own language binding) event-driven (also, you can easily write your own event drivers) task-based distributed application server built on top of ZeroMQ transport and MessagePack serialization library. Yeah, it is cool.

ZmqMessage C++ library

Ready to test, by Phorm, Inc. | 2011

If your sense of beauty is not happy with code like

zmq::message_t reply1(hello.size());
memcpy(static_cast<char*>(reply1.data()), hello.data(), hello.size());
zmq::message_t reply2(world.size());
memcpy(static_cast<char*>(reply2.data()), world.data(), world.size());
s.send(reply1,ZMQ_SNDMORE);
s.send(reply2);

reply << hello << world << ZmqMessage::Flush;

gevent-zeromq - ZeroMQ compatibility library for gevent (Python)

Ready to test, by Travis Cline | 29 July 2011

Combine fast, cheap green threads in Python via gevent and ZeroMQ's power gevent-zeromq.

Rsyslog ZeroMQ Input / Output Plugins

Ready to test, by Aggregate Knowledge | 26 May 2011

Aggregate Knowledge has released ZeroMQ Rsyslog Plugins open source. These plugins allow rsyslog to receive and send data over zmq push / pull sockets (pub/sub coming soon).

Objective C ZMQ Socket Helper (wrapper over czmq zmsg class)

Ready to test, by Michael Zaccari | 17 May 2011

I wrote this simple Objective C wrapper to help manage sockets within an Objective C class. This uses the zmsg class provided by iMatix. I hope this helps anyone who is looking for examples of using ZeroMQ with Objective C.

Salt (Python)

Ready to test, by Thomas S Hatch | 29 April 2011

Salt is a distributed remote execution system used to execute commands and query data. Salt is meant to solve the problem of managing large sets of servers. It was developed in order to bring the best solutions found in the world of remote execution together and make them better, faster and more malleable. Salt is a great example of secure pub-sub over ZeroMQ, and scales to hundreds or thousands of servers.

EM-ZeroMQ (Ruby)

Ready to test, by Andrew Cholakian | 5 Feb 2011

EM-ZeroMQ Is a low-level interface to ZeroMQ sockets that hooks into the reactor loop of Ruby's EventMachine library. This requires 2.1.x+ versions of ZeroMQ, as it requires ZMQ_FD support to hook into EventMachine's select/epoll loop.

Evented interface to ZeroMQ sockets (Lua)

Ready to test, by Robert G. Jakabosky | 24 Dec 2010

lua-handlers is a lua wrapper of lua-zmq & lua-ev that provides an evented interface to ZeroMQ sockets. It allows you to send & recv messages on many ZeroMQ, TCP & UDP sockets at the same time.

Zeromqt (Qt)

Pre-alpha, by Steve Atkins

Zeromqt integrates ZeroMQ (version 2.1.0 and later) into the Qt event loop, mapping ZeroMQ message events onto Qt signals. It also provides an API that is more "Qt-like" than the native ZeroMQ C or C++ APIs, allowing messages to be handled as QByteArrays and providing classes that are similar in style to QAbstractSocket.

nzmqt (Qt) - A lightweight C++ Qt binding for ZeroMQ

Ready to test, by Johann Duscher

nzmqt is a re-implementation of Zeromqt which integrates ZeroMQ into Qt's event loop. However, nzmqt builds upon ZeroMQ's official C++ binding, cleanly places code into a separate namespace, adds multi-part message support, and not only works with PUB-SUB protocol, but also with REQ-REP and PUSH-PULL protocol. Included samples show those protocols in action, together with exception handling in Qt. Furthermore, the source code is officially released under the corporate-friendly BSD license.

C++ wrapper of zmq::poll

Ready to test, by Radu Braniste | 25 Aug 2010

Why another wrapper? The usual idiom used when writing zmq::poll based code is based on a block of if_conditions, testing for the occurrence of one event or the other. This might be error prone and hard to maintain in the long run. And this is where the wrapper comes handy: it separates poll functionality from actions and state (4 different ways to do it) and provides the boiler plate of zmq::poll functionality. Hope you'll find it useful!

Electricity Monitoring

In progress, by Bob Scott | 23 Aug 2010

I am using ZeroMQ for message passing between small components running on a PlugComputer for 24/7 electricity monitoring. I use the pub-sub pattern for publishing data from the logger and request-reply for a charting client and data server. I chose ZeroMQ for this application because of its ease of use, brokerless design, flexibilty of messaging patterns and transport and large number of language bindings.

zdevices devices project

Ready to test, by iMatix Corporation | 22 August 2010

zdevices is the ZeroMQ devices collection, a repository of device packages written by and for ZeroMQ users. All code is GPLv3 licensed. Includes zdevice/1.0 that starts a built-in device from the command line.

zfl library for C

In progress, by iMatix Corporation | 22 August 2010

zfl is the ZeroMQ Function Library, a library for writing 0MQ devices and applications in C. All code is LGPLv3 licensed. Includes JSON parsing for devices.

dripdrop

In progress, by Andrew Cholakian | 16 August 2010

DripDrop is a Ruby / Javascript framework for building apps quickly using a reactor pattern. ZeroMQ is baked in at the core. It provides a common serialization format (based on BERT or JSON), and lets you seamlessly bridge HTTP, WebSockets, and ZeroMQ using a terse and readable syntax. Essentially, DripDrop exposes a common interface across a large number of protocols, letting you focus on your service, not the implementation details.

JeffMQ

In progress, by Jeff Plaisance | 16 August 2010

JeffMQ is a peer to peer message queue framework. It is built on top of ZeroMQ and uses a queue binding system similar to AMQP. There are no special nodes or single points of failure. Queues can only be accessed from the node they are created on. There is no replication, if the node dies the messages are gone.

0MQ plugin for RabbitMQ

In progress, by Michael Bridgen | 16 August 2010

The purpose of this plugin is to provision ZeroMQ sockets that relay messages into RabbitMQ. Each ZeroMQ socket type is given an idiomatic encoding in the AMQP broker model, which means AMQP clients can interoperate.

ProDataLab

In progress, by ProDataLab | 12 August 2010

ProDataLab is an FBP environment that takes advantage of every possible efficiency in processing data via streams. The intention is to build an extremely flexible, parallel, infinitely scalable, distributed application services system for every type and size of data set — processing, analyzing, learning, plotting and reporting, etc. Fast, efficient ZeroMQ messaging will be used as the core of ProDataLab's communication fabric. ProDataLab will eat extremely large data sets for breakfast.

ZMQMachine (Ruby)

Feature complete, by Chuck Remes | 4 August 2010

ZMQMachine is a Ruby library implementing the well-known reactor pattern using 0mq sockets. The API is heavily influenced by the popular Ruby Eventmachine library. All socket I/O activity is non-blocking. Program logic is implemented via asynchronous callbacks and/or handler classes that conform to a specific API. Documentation is limited, but familiarity with Eventmachine will resolve most questions.

TCP thin streams

Idea, by by Steven McCoy | 2 August 2010

A wide range of Internet-based services that use reliable transport protocols display what we call thin-stream properties. This means that the application sends data with such a low rate that the retransmission mechanisms of the transport protocol are not fully effective. In time-dependent scenarios (like online games, control systems or some sensor networks) where the user experience depends on the data delivery latency, packet loss can be devastating for the service quality. Extreme latencies are caused by TCP's dependency on the arrival of new data from the application to trigger retransmissions effectively through fast retransmit instead of waiting for long timeouts. — LWN.net

Parallel sort

In-progress, by Oliver Smith | 2 August 2010

So, I decided to try and figure out how to implement a parallel sort with ZeroMQ message passing.

Throw-nothing API (C++)

Ready-to-test, by Matt Weinstein | 1 August 2010

I've derived a "throw nothing" version of zmq.hpp. The functions are in namespace zmq::nothrow:: I've posted it up to github at: git://github.com/mjw9100/zmq_nothrow.git. Comments welcome. Best, Matt

Reactor pattern (C++)

Ready to test, by Matt Weinstein | 30 July 2010

Folks, I've submitted a reactor pattern for ØMQ to github at git://github.com/mjw9100/zmq_reactor.git. This pattern allow complex arrangements of sockets to be polled in arbitrary ways. The essential way to use this: 1- Create a bunch of zmq_reactors, 2- Link them in the right order into list, 3- Tell zmq_reactor_poll to poll them.

Async::Worker (C++)

Ready to test, by Oliver Smith | 22 July 2010

What I was looking for was a convenient C++ way of creating work-splitting tasks and work-delegating tasks. Having cut my teeth on ZeroMQ I immediately to making a worker pool system. The result is Async::Worker. It combines concepts from OpenMP and Intel's TBB. On a virtual quad-core machine building with -O0 I see a 35-40% reduction in processing time.

The Mongrel2 Web Server

Ready to test, by Zed Shaw | 22 July 2010

Mongrel2 is the complete redesign of the Mongrel web server to be an application, language, and network architecture agnostic web server. It's written by the original author of Mongrel, and uses the Mongrel HTTP parser, but everything else is new. The goal is to create a web server specifically designed for web applications over serving files.

Comments: 0