Planet Jabber

Distribuir contenido
Planet Jabber -
Actualizado: hace 3 horas 28 segs

Arnaud Joset: Using sat-pubsub, a great pubsub component

26 November, 2017 - 19:00

In the continuity with the previous post about jp, the following article present sat_pubsub, a XMPP Publish-Subscribe (Pubsub) Service Component, build for the need of the « Salut à Toi » project.

Salut à toi (SàT) is a unique XMPP client. As its official description says, it's a "multipurpose, multi front-end, free (libre) and decentralized communication tool". It has been actively developed by Jérôme Poisson (Goffi) and Adrien Cossa (Souliane) since 2008.

sat_pubsub allows us to use our own up-to-date persistent pubsub service.

This article is composed of several sections

Why sat_pubsub ?

There are three main reasons to use sat_pubsub.

First, the XMPP servers come with variable pubsub support. Using an external component allows users to benefits constant features independent of the XMPP server or provider.

Secondly, sat_pubub is the only free (libre) implementation that support Pubsub MAM (Message Archive Management). It allows one to research a pubsub node. This feature is used to research blog post in the database.

Thirdly, sat_pubsub is used to test new functionalities like the ability to restrict blog post to specific group of contacts (think about circles on Google+). 1.

Let's install it !

This section describes the installation process of sat_pubsub in a python virtualenv. Unfortunately, I have encountered difficulties to install twisted, a dependency of SàT, in a virtualenv with pip because my production machine has no compiler. I managed to avoid the problem by installing python2-twisted (the distribution package) then the virtualenv was created with the option --system-site-packages to give it access to the system packages. Thereafter, it is possible to install sat_tmp, a small python module that monkey patch wokkel, a dependency of sat_pubsub.

$ sudo apt-get install python2-twisted [...] $ hg clone $ cd sat_tmp/ $ virtualenv env -ppython2.7 --system-site-packages $ source env/bin/activate (env)$ python2 install (env)$ cd ../ (env)$ hg clone (env)$ cd sat_pubsub (env)$ python2 install Setup the database

According to the official documentation, we need to create the database and install the SQL schema.

$ sudo -u postgres createuser -d -P `whoami` $ createdb pubsub $ psql pubsub < sat_pubsub/db/pubsub.sql Configure Prosody

In order to use sat_pubsub, we need to declare it in our prosody config file. Once again, the information is available in the documentation. Two files need to be modified:

  • /etc/prosody/prosody.cfg.lua
[...] modules_enabled = { [...] "delegation"; "privilege"; } [...]
  • /etc/prosody/conf.avail/your_domain.cfg.lua

This file defines the domain configuration of your XMPP server.

This is a copy of the configuration for the agayon server. The pubsub component is available at the address The following configuration:

  • enables pubsub MAM,
  • uses the component for microblogging activity,
  • announces the pubsub nodes and items in disco requests,
  • lets the component access the roster and presence informations (used for PEP).
VirtualHost "" enabled = true [...] privileged_entities = { [""] = { roster = "get"; message = "outgoing"; presence = "roster"; }, } delegations = { ["urn:xmpp:mam:1"] = { filtering = {"node"}; jid = ""; }, [""] = { jid = ""; }, [""] = { jid = ""; }, ["https://salut-a-toi/protocol/schema:0"] = { jid = ""; }, ["*"] = { jid = ""; }, } Component "" component_secret = "shared_secret" modules_enabled = {"delegation", "privilege"} Launch (env)$ twistd sat_pubsub --secret=shared_secret --rhost= \ --rport=5347 --backend=pgsql --dbuser=user --dbpass=pass_psql --dbname=pubsub --dbhost=localhost --dbport=5432 Let's use it !

Once prosody is restarted, the component is accessible through any XMPP client. See the following example with jp.

$ jp info disco -c Features: https://salut-a-toi/protocol/schema:0 jabber:iq:version urn:xmpp:mam:1 -- Identities: Salut à Toi pubsub service (pubsub/service) -- Items: [] [, urn:xmpp:microblog:0:comments/4e69cb98-104a-4022-b086-dfe8b9d36eeb]

The following commands are used to create a node, subscribe to it and edit an item (see the previous article).

$ jp pubsub node create -s node_name $ jp pubsub subscribe -s node_name $ jp pubsub edit -s node_name

The default text editor is then opened. It is possible to directly edit a XML file. This command is useful for debugging purpose.

About Agayon XMPP service

All the tests described in this blog are realized on the XMPP service. It is not opened for registration but having this field of experimentation is great to learn, practice and question the potential uses of XMPP. I use it with several accounts, depending on my use:

Most moderns XEPs are enabled in order to provide an up-to-date experience: PEP, Carbon, Stream Management, persistent pubsub, MAM, SRV records over TLS (useful to pass blocking WiFi accesses), etc.

Future of SàT

In a near future, the SàT project will make great announcements about new uses of pubsub. I hope this article will make you want to install sat_pubsub and experiment with nodes, data and notifications.

Stay tuned !

  1. See the following blog post for more information.

Peter Saint-Andre: Joining Mozilla

26 November, 2017 - 00:00
I'm overjoyed to announce that I'm joining Mozilla, makers of the Firefox web browser. I've been using Mozilla software since Milestone 8 of the original browser release in July of 1999, so this feels like coming home. More important, Mozilla's mission of defending the open web is completely consistent with my own commitment to open source and open standards (as demonstrated through my work on Jabber/XMPP and IETF standards for the past 18 years). I have deep respect for what the Mozilla team has accomplished, both architecturally and organizationally, and I'm extremely excited about helping to make Mozilla an even stronger force for good in the world!...

ProcessOne: ejabberd 17.11 – Happy Birthday ejabberd !

23 November, 2017 - 11:09

Happy birthday ejabberd !

Ejabberd has been the leading choice to serve reliable XMPP domains for 15 years, and we are happy to announce yet another great new version of your favorite server.

This version includes great new features from Google Summer of Code, many improvements and a lot of bug fixes. By the way, ejabberd is “Compliance Suite 2018” compatible now (see XEP-0387) !

New features ACME Support

Google Summer of Code 2017 was a big success for ejabberd project. In this context, Konstantinos Kallas contributed support for the “Let’s Encrypt” ACME protocol, which is now part of ejabberd. The code was reviewed and improved by ejabberd team to ensure we meet the same standard of quality you are used to.

The objective of the ACME protocol is to make it possible to automatically obtain trusted certificates, without any human intervention. So, the main functionality of the implementation is acquiring and managing the aforementioned certificates.

All details are available on pull request #1959 on github.

Many thanks to Konstantinos Kallas for contributing this great feature ! Thanks to Evgeny Khramtsov for being the ProcessOne mentor.

Introduce ‘certfiles’ global option

The option is supposed to replace existing options ‘c2s_certfile’, ‘s2s_certfile’ and ‘domain_certfile’. The option accepts a list of file paths (optionally with wildcards “*”) containing either PEM certificates or PEM private keys. At startup, ejabberd sorts the certificates, finds matching private keys and rebuilds full certificates chains which can be used by fast_tls driver.


certfiles: - "/etc/letsencrypt/live/*.pem" - "/etc/letsencrypt/live/*.pem" Allow writing custom modules in own path

In ejabberdctl.cfg, add this parameter to EJABBERD_OPTS

external_beams /path/to/ebin

Then, all beams /path/to/ebin/*.beam will be known by ejabberd_config at startup. This makes ejabberd able to load your own modules. So you can embed ejabberd as a dependency to your Elixir project, or manage your own backend modules, without messing with ejabberd installation.

Use new API for IQ routing

Functions ejabberd_local:route_iq/2,3 are now deprecated: ejabberd_router:route_iq/2,3,4 should be used instead.

Improvements Build with host dependencies

Building ejabberd takes care of runtime dependencies, and some of them are even needed in order to build ejabberd. For several packaging systems, a package is not allowed to handles dependencies by itself. This makes ejabberd hard to package and maintain on these systems.

Configuring ejabberd with option ‘–enable-system-deps’ help to use hosts libraries to build ejabberd, and avoid ejabberd to handle dependencies by itself. This option has been improved to cover most needs and fix pending issues. Packagers should really have a look at this option to simplify packaging when needed.


We are preparing work to improve the PEP implementation in ejabberd. In that regards we already fixed few glitches and improved XEP-0163 coverage.

We also added support of SQL export, to ease migration of your existing PubSub database from Mnesia to an SQL backend.

At last, we fixed the use of historical ‘hometree’ plugin, which now allows to propagate publications in the nodes tree to cover simple needs around nodes hierarchy.


As an experimental feature, if you compile from sources with option ‘–enable-new-sql-schema’, an extra server_host columns will be used in your SQL tables. This feature allows to use the same database for all your vhosts. See ‘ejabberdctl update_sql’ command to update your sql schema in order to try this feature.


If you’re upgrading from a previous version, you must follow the instructions. More details in documentation, see upgrade notes.

Changes Admin
  • Omit “ProtectSystem” option from systemd unit
  • Log warnings for c2s/s2s certfile option
  • Log a message when a user gets registered
  • ejabberdctl: Fix ‘read’ syntax for non-bash shells
  • Fix renew_certificates ejabberdctl command
  • Unregister commands when stopping node only if it’s last one
  • Halt ejabberd if the top supervisor fails to start
  • Avoid badarg error when running get-deps before ./configure has created src/
  • Fix sed invocation that was incompatible with FreeBSD’s sed
  • Fix “make clean && make”
  • Improve –enable-system-deps
  • Install binaries with 755 permissions
  • Install eimp binary with +x attribute
  • Remove find-outdated-deps script, we have better replacement for it
  • Allow export command regardless of the configured db_type
  • Add SQL_INSERT macro and update SQL queries to use server_host field
  • Update SQL archive index to match mysql.sql
  • mod_muc: Use correct table field name in sql query
  • Always strip stanza IDs
  • Announce support for stanza IDs
  • Don’t store from ‘sm_receive_packet’ hook
  • Fix mod_mam reloading
  • Ignore non-message stanzas earlier
  • Improve handling of forked messages
  • Make sure a stanza ID is always added
  • Make sure archived message isn’t bounced
  • Prepare version 0.6.1 of XEP-0313 (MAM) support
  • Properly store subject element
  • Resend presences and history if presence possesses x MUC element
  • Send presence-unavailable when expulsing a participant
  • Add mucsub event for subscribers list changes
  • Optimize muc subscriptions handling
  • Show real jid in mucsub subscription change events
  • Add basic PubSub meta-data support
  • Rewrite pubsub export to sql
  • Cleanup tree requests, rename pubsub_node.type to pubsub_node.plugin
  • Fix select_type race on plugin_init
  • Implement parentnodes seek for hometree
  • Delete cached item on node removal
  • Fix delete item from unregistered user
  • Cleanup pubsub subscriptions quering, fix pep case
  • PEP services must send notifications to the account owner
  • Avoid notification duplicates
  • Add support for SQL storage
  • Add export from Mnesia database to SQL file
  • Don’t store xdata() in Mnesia table
  • Simplify backend interface
  • Mix _xmpp-server and _xmpps-server SRV records (XEP-0368)
  • HTTP: Don’t crash when Host header is missing
  • HTTP fileserver: Accept routes in Host header and map them to vhosts
  • mod_register_web: Better handle mobile devices in CSS
  • mod_stream_mgmt: Improve logging on timeout
  • mod_stream_mgmt: Increase ‘max_ack_queue’ default
  • Updated Catalan, Chinese, Czech, French, Galician, German, Greek, Hebrew, Russian, Spanish translations
  • WebAdmin: Don’t include CSS, javascript and image data directly in the code

As usual, the release is tagged in the Git source code repository on Github.

The source package and binary installers are available at ProcessOne.

If you suspect that you’ve found a bug, please search or fill a bug report on Github.

Erlang Solutions: How to set up MongooseICE (ICE/TURN/STUN server)

21 November, 2017 - 11:51

The new version of our messaging platform, MongooseIM 2.1.0 has been recently released. MongooseIM 2.1.0, as a stronger platform for better chat experience is all about quality and building trust in the consistency and performance of our solution. It introduces tools and improvements making access to MongooseIM features easier.

This tutorial will take you through the details of MongooseICE - help your ops deploy and your devs build a STUN and TURN server for NAT traversal and stream relay. This “How To” will help you keep your infrastructure coherent and perfectly integrated, in order to deliver new features faster and with more confidence over time.

Introduction Who is this document for?

This tutorial presents our TURN/STUN server in action. You get to see how to set up and configure MongooseICE and examine a system utilising its many talents.

Are you in need of an application requiring NAT traversal? Want to see how a TURN and STUN server would handle it? Or maybe you just like to tinker with interesting technologies and experience setting them up first hand?

If that’s the case, this tutorial is for you.

What is the end result of this tutorial?

At the end of the tutorial you will have a working environment with two peers, one sending a live video to another. The peer-to-peer communication will not be obstructed by any NATs that may occur in the background. The live video stream is only an example here - there are many possible use cases for peer-to-peer communication with NAT traversal. We chose to build an example application that shows video streaming, because it’s vivid, catchy and fun.

What do I need to begin?

Before you begin you have to prepare an environment for setting up the components used in this tutorial. Here’s a list of things you’ll need:

  1. One Android phone (or at least an Android emulator). The video player in this tutorial is available only as an Android application.
  2. RaspberryPi or any other device that is able to run Elixir code. Oh, and also has ffmpeg installed. We are going to use use RaspberryPi 3, to give this tutorial a hint of IoT.
  3. At least one machine with a public IPv4 address. It is necessary, because both MongooseIM and MongooseICE servers need to be accessible by all devices that are used in this demo system. You could use a private, local IP address, but then you would need to ensure that your phone and the RaspberryPi are behind some kind of a NAT relative to this IP address.

Note: the demo will probably work without the NAT, but then there is no point in setting up a TURN server.

We are going to use 2 VPS (Virtual Private Server) that are located somewhere far far away, both having public IPv4 address. Let’s say MongooseICE is bound to, and MongooseIM to

General architecture of the environment built with this tutorial

This is the architecture of the system we are building:

As we know by now, MongooseIM is bound to and MongooseICE to We also have a RaspberryPi that is connected to a private network (so is behind some NAT) and an Android phone that is connected to an LTE network and also is behind the carrier’s NAT.

ICE notes

The end result of this tutorial not only uses MongooseICE and [MongooseIM] servers but also uses custom version of Mangosta-Android and [DemoStreamerICE]. Both projects are custom modified and custom made respectively in order to showcase the video streaming using the data relay capabilities provided by MongooseICE. The streaming itself, along with the signalling protocol, were prepared only for the case of this demo and are not a part of the platform. Those components exist only to visualize what can be achieved with MongooseICE and what can be built on top of it.

Setting up MongooseIM (signalling)

The ICE is nothing without signalling. The signalling protocol itself can be designed specifically for the application that is being deployed or can be implemented based on some standards, e.g. Jingle. Here, we chose to implement the simplest signalling possible, i.e. sending relay addresses via XMPP messages. No matter if we decide to go with this approach or with Jingle, we can use the MongooseIM XMPP server as a transport layer for the signalling. In order to enable signalling we need an instance of MongooseIM running with the simplest configuration, since the only thing we need from it is to provide us with means to communicate between two peers.


You can find MongooseIM installation instructions on this page. Once you have cloned the repository and compiled the project, you need to modify the ejabberd.cfg config file (you can find this file at $REPO/_build/prod/rel/mongooseim/etc/ejabberd.cfg, where $REPO is a top-level directory of cloned repo). You can use this configuration file and modify the relevant part:

%%%% ICE DEMO %%%% {hosts, ["localhost", ""] }.

This sets the virtual hostname of the XMPP server, so that you can register users in this domain. After that, you can start MongooseIM with

$REPO/_build/prod/rel/mongooseim/bin/mongooseimctl start Users

After we finish setting up [MongooseIM], we need to register some users. For this demo we need two users: and, for RaspberryPi and the Android phone respectively. In order to do that, type:

$REPO/_build/prod/rel/mongooseim/bin/mongooseimctl register phone xmpp_password $REPO/_build/prod/rel/mongooseim/bin/mongooseimctl register movie xmpp_password

on the machine that has [MongooseIM] installed.

As you can see here, we have created those two users, both with the password xmpp_password for simplicity.

Setting up MongooseICE (TURN/STUN server)

Now, since [MongooseIM] handles the signalling, we need the TURN relay and the STUN server to send peer-to-peer data. For that we are going to use the star of this tutorial - MongooseICE.

How to get and configure

The whole documentation that describes all options and deployment methods, can be found on the project’s github page. Let’s get to it! (this command assumes that we are on the server for MongooseICE and that it has Docker installed):

docker run -it --net=host -e "MONGOOSEICE_UDP_RELAY_IP=" -e "MONGOOSEICE_STUN_SECRET=secret" -e "MONGOOSEICE_UDP_REALM=myrelay" mongooseim/mongooseice:0.4.0

This command starts the MongooseICE server in the Docker container, attaching its virtual network interface to the network interface of the host machine the Docker deamon is running on. There are three important configuration options we have to set via environment variables:

  • MONGOOSEICE_UDP_RELAY_IP - This is the IP address that MongooseICE provides data relay on. This should be set to public IPv4 address.
  • MONGOOSEICE_STUN_SECRET - This is a secret password that TURN clients need to provide to connect to this server.
  • MONGOOSEICE_UDP_REALM - This is just a name for your TURN relay.

And that’s it! MongooseICE is now ready to roll!

Setting up Mangosta-Android How to get and install

The source code of the video-stream-demo-enabled Mangosta-Android can be found on the ice_demo_kt branch. If you want to tinker with it and compile it yourself, you can do that. All you need is Android Studio 2.3+. The compilation is pretty straightforward, so I’m not going to explain it here. If you are interested in how it works, most of the code is in the package. If you don’t want to compile this application from source, you can just install this .apk on your phone and that’s it.

How to configure

Right after you start Mangosta-Android for the first time, you will need to login to your XMPP server. In order to do that, just enter the JID you have created for the phone (, the password (xmpp_password) and the server address ( or if you’ve set up the domain to actually point to this IP address), and then confirm by clicking “Enter”.

After we log in, we can start setting up the connection to the MongooseICE server we set up before. The process is shown on the screenshots below.

Mangosta_ICE_settings Mangosta test ICE connection Mangosta save ICE settings

On the “Configure ICE” screen we have to set up 5 fields:

  1. TURN server address - IPv4 address of our MongooseICE
  2. TURN Server port - since we did not set the port while configuring MongooseICE it uses a default one - 3478
  3. TURN Realm - Realm name we have set via MONGOOSEICE_UDP_REALM variable. In our case it’s “myrelay”.
  4. TURN username - Current version of MongooseICE ignores this, so you may leave it as is.
  5. TURN password - The password that we have set via MONGOOSEICE_STUN_SECRET variable. In our case it’s “secret

And that would be all. Now you can click “TEST CONNECTION” to, well…, test the connection. If everything works, you can “SAVE” the settings. Now your Mangosta-Android is ready to play streamed video, but we still need the source…

Setting up RaspberryPi

Let’s configure the video source now. In our case it will be a RaspberryPi with Elixir and ffmpeg installed running our ICE demo application.

The software

For this demo we provide a simple XMPP client that also is able to send live video stream using ffmpeg whenever other peer asks for it via XMPP. This client is written in Elixir, so we can run it from source quite easily.

How to get and configure

You can get the client’s sources here. For now we only need to run it, so let’s get to it (on our RaspberryPi):

git clone cd ice_demo mix deps.get iex -S mix

After a while we should get into Elixir shell. In order to enable the streamer, we need to start it, providing some configuration options (in the Elixir shell):

opts = [ jid: "", password: "xmpp_password", host: "", turn_addr: "" turn_username: "username", turn_secret: "secret", video_file: "/home/pi/sintel.h264" ] ICEDemo.start_movie(opts)

The first 3 options are all about connecting to the XMPP server - we use “” user that we created earlier. Next 3 options are about connecting to the MongooseICE server. Those are similar to ones we set in Mangosta-Android. The last one points to the video file that will be streamed on request. This file has to be raw, H.264-encoded, video-only file. If you are not sure how to get one, you can just use [this one] (pre-rendered Sintel, OpenBlender project). With this configuration, out RaspberryPi is ready to stream!

[### The end result

Playing the video

Now we finally can get out phone and start streaming the video! In order to do that, we have to click the “New video stream” button as shown on the screenshoots below, enter the JID of the RaspberryPi and confirm with the “Stream!” button.

  1. Mangosta start streaming
  2. Mangosta start streaming
  3. Mangosta start streaming

Hopefully, now you can see the video on your own mobile device.


Share your biggest pain points in your journey through app and business building, so that we can work together on how to solve them efficiently.

  1. Subscribe to our newsletter
  2. Read our “Boost your engine of growth with chat and social value”
  3. Star us on GitHub and follow us on Twitter

Ignite Realtime Blog: Openfire 4.2.0 Beta Release

17 November, 2017 - 16:13

@akrherz wrote:

The Ignite Realtime Community is thrilled to announce the availability of a beta quality release of Openfire 4.2.0. Downloads of release artifacts can be found on our beta release website and a changelog denoting 60 some Jira issues resolved is available as well.

So what has changed with Openfire 4.2? A lot! Some highlights:

  • XEP-0237 Roster Versioning
  • Server to Server (s2s) is more robust
  • The websocket functionality, previously in a plugin, was merged into core
  • The Admin Console now has a Pub-Sub administration interface
  • You can now manually test a Server to Server connection on the Admin Console
  • XEP-0198 Client Resumption is now available
  • A lot of polish and new handy functionality was added to the Admin Console
  • Openfire plugin loading is much more robust

Here is a listing of sha1sum values for the release binaries

f6b69035c848c7555d2710b26efbb6a927e86175 openfire-4.2.0-0.2.beta.i686.rpm 4142b5baf024b603949b64f3896964ed4dcab196 openfire-4.2.0-0.2.beta.noarch.rpm eb6e993e2ea185da235a9039b227a676d96210a0 openfire-4.2.0-0.2.beta.x86_64.rpm ffcf842fd9a64741140bfdde560c952a34db08a9 openfire_4.2.0.beta_all.deb 5077b1283d91e23880148fc9891a18af02fb5c68 openfire_4_2_0_beta_bundledJRE.exe c6108509b29fb8339f444e0b766d212818560465 openfire_4_2_0_beta_bundledJRE_x64.exe 8c68a07c1933754af2042bc5cd76e2545a2bcdd6 openfire_4_2_0_beta.dmg 551015e80cf4a001a6f97deda869cbdde8f7151f openfire_4_2_0_beta.exe aff23069cac31aad0ee902077fd8cd4f85ea3c1f openfire_4_2_0_beta.tar.gz b8255d7d7cd06a35f3bf12cc38d3473aa34669a5 openfire_4_2_0_beta_x64.exe ed53cb92966f8e21e373afcca491dd3e1b70bb7e b380d386c2f3b4007dc9755648c579b984b52389 openfire_src_4_2_0_beta.tar.gz f814b17f00084ef904959b3241044cf63981ece4

Our current intention is for a quick turnaround of this beta into a full release, so please do test it and let us know of troubles you find by either visiting our webchat or creating posts in our Discourse Openfire Dev Forum.

A big thanks goes out to our current developers for doing a lot of work to make this beta release happen. These include @dwd, @guus, @gdt, and others now submitting pull requests to our Github Repository. A special thanks goes to folks at Surevine who have been actively supporting Openfire development.

For those interested in development, here are some current talking points of where development stands.

  • A large whitespace pull request was made against the master-branch, which is now the 4.2.0 beta. The intention of this was to not frustrate all of you that maintain forks of Openfire :), but to make future Openfire contributions easier. The code base should now follow the Editor Config guidelines and so your IDE should be able to focus better on actual code changes and not fixing whitespace issues.
  • At this point, there is not much appetite for an additional 4.1 branch release, but that could of course change. We'd like to get 4.2.0 out the door, then branch master into a 4.2 branch and then focus on moving forward with 4.3 development and stabilizing 4.2 branch with a 4.2.1 release.
  • master branch continues to support building with ant and maven, with Install4j artifacts built from the ant side. We like to consolidate on maven, but work needs to be done in this area. Please consider contributing if you have maven/install4j expertise!

And in closing, please consider helping out with development. The needs are many, but some particular areas of interest are:

  • improving Openfire's LDAP implementation
  • Bringing core functionality like Multi User Chat (MUC) up to current specifications
  • Vastly improving Openfire's automated testing

We are an easy going bunch and I personally love chipping in to help out. We all hang out within the groupchat each day, so stop by! If your organization relies on Openfire, please consider helping out!

Hopefully everybody enjoys the beta release and we can turn around a full release shortly, thanks for reading and your support of Ignite Realtime!

Posts: 14

Participants: 7

Read full topic

Erlang Solutions: How to set up Push Notifications with MongoosePush

16 November, 2017 - 17:09

The new version of our messaging platform, MongooseIM 2.1.0 has been recently released. MongooseIM 2.1.0, as a stronger platform for better chat experience is about quality, accessibility and building trust in the consistency and performance of our solution. It introduces new tools and improvements making access to MongooseIM features easier.

In this tutorial, we will dive deep into the details of MongoosePush - help your ops deploy and your devs build push notifications in your chat system. This “How To” will help you keep your infrastructure coherent and perfectly integrated, in order to deliver new features faster and with more confidence over time.

How to set up Push Notifications with MongoosePush

MongooseIM server supports push notifications using FCM (Firebase Cloud Messaging) and APNS (Apple Push Notification Service) providers. Server side push notification support is fully compliant with XEP-0357 Push Notifications, which defines several components that need to work together in order to provide clients with working push notifications. The following list shows those components as defined in XEP-0357 and MongooseIM components that correspond to those entities:

  1. XMPP Server in MongooseIM is enabled by module mod_push
  2. App Server in MongooseIM is enabled by adding a push node type to mod_pubsub’s configuration
  3. XMPP Push Service is implemented as a MongoosePush application
  4. All these entities have to be enabled and properly configured in order to use push notifications. So let’s get to it, shall we?
Overall component architecture

The components that make push notifications possible in MongooseIM add up to the following architecture:

The diagram lists three domains in total - two for MongooseIM and one for MongoosePush. Note that this separation is not required, all three components can be on the same host with the same domain.

Configuring MongooseIM components

Firstly, let’s configure all the required MongooseIM components, step by step.

mod_push a.k.a. ‘XMPP Server’

The first component that we need to configure in MongooseIM is the mod_push module. This module communicates with XMPP clients directly in order to enable/disable notifications on per-client basis. The mod_push module is very easy to enable - just paste the following to your MongooseIM configuration file:

{mod_push, [ {wpool, [{workers, 100}]} ]}.

And that’s basically it. You have just enabled the push notification support with 100 asynchronous workers that will handle all push notification related work. You can also control the format of the “sender” of the push notification (which ultimately becomes the title of push notification) and filter which messages will trigger the notification. In that case you need to create a plugin module that implements the mod_push_plugin behaviour and enable this plugin as specified in the mod_push documentation.

mod_pubsub with mod_push_service_mongoosepush a.k.a. 'App Server’

The next component to configure consist of two modules:

  1. mod_pubsub with a push node type enabled that will act as a sink for push notifications generated by mod_push
  2. mod_push_service_mongoosepush - a connector to MongoosePush application
mod_pubsub’s push node

According to the XEP-0357 Push Notifications, all notifications generated via the module we have just enabled (i.e. mod_push) have to be send to a push enabled publish-subscribe node. In order to allow clients to allocate such a node, we need to enable it in our mod_pubsub on the MongooseIM server that will communicate with the XMPP Push Service.

The minimal mod_pubsub’s configuration looks as follows:

{mod_pubsub, [ {plugins, [<<"push">>]}} ]}.

Such configuration will enable the mod_pubsub with only one node type available: push. Please note that if you want use mod_pubsub as a 'normal’ publish-subscribe service, you just need to append the <<“push”>> node type to the plugins list. Also, it’s important to note, that the first node type on the plugins list. will be the default one (allocated when the client does not provide a node type in the node create stanza).


This module acts as a bridge between mod_pubsub that receives notifications from mod_push and passes those to MongoosePush which sends them to FCM and/or APNS. To enable this module type in your configuration:

{http_connections, [{mongoose_push_http, [{server, "https://localhost:8443"}] }]}. {mod_push_service_mongoosepush, [ {pool_name, mongoose_push_http} {api_version, "v2"} ]}.

First, we create the HTTP pool for communicating with MongoosePush. Here, we assume that MongoosePush will be available on the localhost on port 8443 which is the default one. Next we enable mod_push_service_mongoosepush. First option is the name of the HTTP pool to use and the second one is the version of MongoosePush’s API (currently only “v2” is supported).

And that’s it, we’ve just completed the entire MongooseIM configuration. All we need to do now is to set up MongoosePush.

Starting MongoosePush

The easiest way to start MongoosePush is using its docker image. But before you can set MongoosePush up, you need a FCM application token and/or an APNS application certificate. You can get the FCM token here and the easiest way of getting an APNS application certificate is by running this script (please note that you need the certificate in pem format). After you get the FCM application token and/or the APNS application certificate, you can prepare to start MongoosePush. Firstly, prepare the following files structure:

If your FCM app token is MY_FCM_SECRET_TOKEN and you have the priv directory with all ceriticates in the current directory, start MongoosePush with the following command:

docker run -v `pwd`/priv:/opt/app/priv \ -e PUSH_FCM_APP_KEY="MY_FCM_SECRET_TOKEN" \ -e PUSH_HTTPS_CERTFILE="/opt/app/priv/ssl/rest_cert.pem" \ -e PUSH_HTTPS_KEYFILE="/opt/app/priv/ssl/rest_key.pem" \ -it --rm mongooseim/mongoose-push:latest

If you don’t want to use either APNS or FCM, you simply need to pass PUSH_APNS_ENABLED=0 or PUSH_FCM_ENABLED=0 respectively as additional env variables in your docker run command. For more advanced options and configuration please refer to “Quick start / Configuring” in MongoosePush’s When your MongoosePush docker is up and running, Push Notifications can be used in your MongooseIM instance.

Using push notifications on client side

There are just a few things the XMPP client application needs to receive the push notifications. See the diagram to examine the process described in this section along with the example notification flow:

Registering with a Push Service provider

Firstly, the client application has to get a device-specific token from the Push Service Provider (FCM or APNS). This process is different, depending on the platform, so please consult your Push Service Provider’s manual to see how to get this token. For example, here you can learn about setting up FCM on Android platform and here you can learn about setting up APNS on iOS platform. After this step, your application shall be able to receive FCM or APNS token - it will be required in the next step of this tutorial.

Setting up an XMPP pubsub node

Please note this first step is specific to the app-server your client application uses. In case of MongooseIM, you just need to allocate (create) a special PubSub node that will act as a gateway for all notifications sent by the XMPP chat server. Without any further ado, let’s configure the PubSub’s push node. In this example is a domain of the MongooseIM server that has mod_pubsub enabled with the push node support. The client sends the following stanza to the server:

<iq type='set' to='' id='create1'> <pubsub xmlns=''> <create node='punsub_node_for_my_private_iphone' type='push'/> </pubsub> </iq>

The will be used as a gateway for all notifications and will pass them through to the APNS and/or FCM.

The most important and only distinction from the standard node creation is the type='push' part of the create element. This denotes that you need a node that will handle your push notifications. Here we create a node called punsub_node_for_my_private_iphone. This node should be unique to the device and you may reuse nodes already created this way.

After this step, you need to have the pubsub host (here and the node name (here: punsub_node_for_my_private_iphone).

Enabling push notifications

The next and the last step is to enable push notifications on the server that handles your messages (and have mod_push enabled). Let’s assume this server**** is available under the domain. To enable push notifications in the simplest configuration, just send the following stanza:

<iq type='set' id='x43'> <enable xmlns='urn:xmpp:push:0' jid='' node='punsub_node_for_my_private_iphone'> <x xmlns='jabber:x:data' type='submit'> <field var='FORM_TYPE'><value></value></field> <field var='service'><value>apns</value></field> <field var='device_id'><value>your_pns_device_token</value></field> <field var='silent'><value>false</value></field> <field var='topic'><value>some_apns_topic</value></field> </x> </enable> </iq>

We have now enabled push notifications to be send to the to the node punsub_node_for_my_private_iphone created in previous paragraph. In publish-options we have passed the service name that we are using (apns or fcm) and the device token (here: your_pns_device_token) that you received from you push notification service provider (as described in Registering with Push Service provider).

Those two options are the only ones required, but there are some others that are optional:

  1. mode - which may be either prod or dev (default to prod). Decides which connection pool type on MongoosePush shall be used. This may be used when APNS on MongoosePush is configured to work with both production and development certificate.
  2. click_action - action to perform when notification is clicked on the device. activity on Android and category on iOS. Please refer to your platform / push notification service provider for more info.
  3. topic - currently only used with APNS. the value is passed to APNS as topic header. For more information please refer to APNS documentation.
  4. silent - if set to true, all notifications will be “silent”. This means that only data payload will be send to push notifications provider with no notification. The data payload will contain all notification fields as defined in XEP-0357.
Disabling push notifications

Disabling push notifications is very simple. Just send the following stanza to your XMPP chat server:

<iq type='set' id='x44'> <disable xmlns='urn:xmpp:push:0' jid='' node='punsub_node_for_my_private_iphone'/> </iq>

You may skip the node='punsub_node_for_my_private_iphone' to globally disable push notifications on all nodes that are registered from your JID. This may be used to disbale push notifications on all your devices.


Share the biggest pain points in your journey through app and business building, so that we can work together on how to solve them efficiently.

  1. Subscribe to our newsletter
  2. Read our “Boost your engine of growth with chat and social value”
  3. Star us on GitHub and follow us on Twitter

Daniel Pocock: Linking hackerspaces with OpenDHT and Ring

15 November, 2017 - 19:57

Francois and Nemen at the FIXME hackerspace (Lausanne) weekly meeting are experimenting with the Ring peer-to-peer softphone:

Francois is using Raspberry Pi and PiCam to develop a telepresence network for hackerspaces (the big screens in the middle of the photo).

The original version of the telepresence solution is using WebRTC. Ring's OpenDHT potentially offers more privacy and resilience.

Fanout Blog: High scalability with Fanout and Fastly

15 November, 2017 - 01:58

Fanout Cloud is for high scale data push. Fastly is for high scale data pull. Many realtime applications need to work with data that is both pushed and pulled, and thus can benefit from using both of these systems in the same application. Fanout and Fastly can even be connected together!

Using Fanout and Fastly in the same application, independently, is pretty straightforward. For example, at initialization time, past content could be retrieved from Fastly, and Fanout Cloud could provide future pushed updates. What does it mean to connect the two systems together though? Read on to find out.


ProcessOne: DotGo 2017: Go for Real Time Streaming Architectures

10 November, 2017 - 14:21

Early this week, I was on stage at DotGo, to share feedback about my experience building realtime streaming architectures in Go.

Here are the slides of my talk:

Alexander Gnauck: Introducing MatriX vNext

9 November, 2017 - 11:24

We are thrilled to announce the next generation of the MatriX XMPP libraries.
15 years elapsed already since we started our first .NET/c# XMPP library agsXMPP with .NET 1.0. Our XMPP libraries and the .NET technologies had many major evolutions over the years.

With the switch to .Net Core we also took the opportunity for a major rewrite and redesign of the codebase. The API for clients, servers and components is not backwards compatible, but all XMPP protocol classes remain the same. Updating existing code bases to MatriX vNext should be pretty straightforward.

Some highlights
  • new software design and more modern API
  • target .Net Core
  • high performance sockets using Azure DotNetty
  • Completly Task based using the TAP pattern (async/await)
  • more Linq extensions
  • Rx (Reactive Extensions)
  • will be open source and available under a dual license (Open Source and commercial)

Here is some demo client code using MatriX vNext:

var xmppClient = new XmppClient { Username = "alex", Password = "secret", XmppDomain = "", }; xmppClient .XmppXElementStream .Where(el => el.OfType<Presence>()) .Subscribe(el => { // Handle incoming presence Debug.WriteLine(el.Cast<Presence>().From); }); xmppClient .XmppXElementStream .Where(el => el.OfType<Message>()) .Subscribe(el => { // Handle incoming messages Debug.WriteLine(el.Cast<Message>().Body); }); xmppClient .XmppXElementStream .Where(el => el.OfType<Iq> && el.Cast<T>().Type == IqType.Get && el.Cast<T>().Query.OfType<Ping>() .Subscribe(el => { // handle and reply to incoming pings var iq = xmppXElement.Cast<T>(); var resIq = Factory.GetElement<T>(); resIq.Id = iq.Id; resIq.To = iq.From; resIq.Type = IqType.Result; await xmppClient.SendAsync(resIq); }); // connect, secure, authenticate and bind await xmppClient.ConnectAsync(); // request roster (contact list) var roster = await xmppClient.RequestRosterAsync(); // send own presence to the server xmppClient.SendPresenceAsync(Show.Chat, "free for Chat");

Releases are available as a Nuget packages here:

Peter Saint-Andre: Songs of Zarathustra: First Draft

9 November, 2017 - 00:00
About eight months ago, even before I published The Upland Farm as the fourth volume in my series on the art of living, I started to read Nietzsche's books for a third time, writing poems for Songs of Zarathustra as I worked my way chronologically from The Birth of Tragedy through Ecce Homo. Last weekend, I completed work on the first draft of this poetry cycle on Nietzsche's philosophy of life, which I plan to publish in early 2018. Before then, I'll read his letters and notebooks (including the ever-controversial collection called "The Will to Power") as well as some of the vast literature on Nietzsche's life and thought, such as:...

ProcessOne: Real-time Stack Issue #5

2 November, 2017 - 17:38

Here are the technology articles we found interesting in Issue #5. You can receive this content in your inbox on the day it’s published by subscribing here.

Using XMPP as a message bus

This highly technical post is focused on the idea of using the XMPP as a generic message bus. Leveraging In-Band Registration, Service Discovery, Ad-hoc Commands and Forms creates a very straightforward, extensible and performant model for building a scalable machine-to-machine (or even user-to-machine) message bus.

OAuth over XMPP

Adventurer’s Codex uses XMPP for it’s real-time features. During development they ran into a couple of interesting challenges with integrating such a mature system with their new-ish web stack, one of which was User Authentication.

Why are IoT developers confused by MQTT and CoAP?

Recently, Exadel encountered an interesting challenge for IoT developers. Because IoT apps have gained so much momentum, there is more and more choice in how to develop them.

Here’s how blockchain will change Internet of Things

Blockchain is becoming a ubiquitous term in the world of technology. The effects of Blockchain technology on Internet of Things are revolutionary. But before we delve deeper into the interconnection of Blockchain and IoT, let’s first briefly understand what blockchain really is.

Why Linux containers matter for the Internet of Things believes Linux containers are the first practical virtualization technology for the embedded world, enabling isolated application failures, efficient updates, and a flexible yet familiar workflow.

Websockets and IoT: Why don’t the two go together?

Srushtika Neelakantam writes “After running around in the realtime tech world for a couple of months since I started working for deepstreamHub, I think a lot of people have many misconceptions about a lot of concepts within this world.”

Review: IoT data logging services with MQTT

The pros and cons from author’s standpoint, along with implementation examples in Lua using a generic MQTT library (from NodeMCU). Most platforms also provide custom libraries or ready-made solutions for Arduino, Raspberry Pi, and others.

Erlang Solutions: MongooseIM 2.1.0: stronger platform for better chat experience

2 November, 2017 - 15:21

A great dilemma for app makers is whether to develop their chat in house, or buy an off-the-shelf solution (“Make-Or-Buy Decision”). Between these extremes the MongooseIM platform provides a flexible set of software components paired with services to fit companies’ specific strategies. It solves the problem of asset building when it comes to chat or instant messaging experiences.

What used to be MongooseIM standalone server has pivoted to a platform with MongooseIM 2.0.x series. We started offering new components (backend/server and frontend/client), on top of which you can quickly and efficiently build your solution. The 2.1.0 release is the next chapter of this story, as we deliver a solid iteration with more components that address even more IT challenges, and stronger than ever code base and documentation.

Executive summary: one significant leap forward

With the version 2.1.0, the MongooseIM platform has climbed one step higher in the ladder:

  1. Code and documentation efforts have produced a better platform for you to build on
  2. The new Push Notifications and STUN/TURN components are delivering stronger consistency in your IT
  3. Our Tide continuous load testing infrastructure guarantees a focus on faster operations

The following versions on the roadmap will offer geo clustering, IoT and chatbots.

A stronger platform, for all MongooseIM code and documentation, for your staff

Techie crowds, like craftsmen and operations teams, have to assess and handle ever increasing complexity. We have built means to fluidify your experience on code, and administration fronts, binding them all with documentation!

Code attention, for better craft and operations**

Code quality, style, and consistency has received a lot of attention: we delivered various improvements, maintenance, refactoring, on top of which we paid technical debt, and obviously added even more tests.

For some highlights, we have:

  1. Achieved Erlang/OTP 20 compatibility,
  2. Added full text search for MAM (Message Archive Management),
  3. Implemented XMPP pipelining,
  4. Delivered Erlang distribution over TLS,
  5. Built accumulators, message metadata for fine-grained inspection and traceability,
  6. Accepted a JSON Web Token authentication contribution,
  7. Improved MAM, MUC light, and our REST APIs.

Benefits: This considerable effort has produced an even more reliable codebase, fit for mature product teams, and for large scale production systems.

Documentation love, for better view and understanding

Our 2.1.x series has seen vast documentation improvements. We have reviewed, maintained, and updated the technical content, the structure, and the phrasings, as well as augmented the graphical content. We have applied the art of craftsmanship to the doc!

As a result, we have greatly improved the overall configuration literature, added some missing pages on some modules, extended existing ones: everything now leads to comprehensive configuration and architecture reference.

Please browse it on:

Figure 1: the MongooseIM platform documentation

Some examples of the most visible outcomes:

Newcomers may follow our three main tutorials (or “HOWTOs”):

  1. Building MongooseIM from source code
  2. Set up MongoosePush
  3. Set up MongooseICE

Developers will love our REST API entries:

  1. Client/frontend REST API
  2. Metrics backend REST API
  3. Administration backend REST API

Sysadmins and devops should like the authentication section revamp:

  1. External authentication
  2. HTTP authentication
  3. JWT authentication
  4. LDAP authentication

Benefits: As a consequence, it is now easier to find and use what you are looking for. All features should be covered and properly documented.


The code is ready to process intensive traffic and the documentation will help you to configure it to do so. We have a stronger basis for longer term improvements, additions, and customisations.

MongoosePush & MongooseICE, for your infrastructure

CTOs and architects constantly looking for more efficient alternatives, please welcome two new components in the MongooseIM platform: MongoosePush and MongooseICE. MongoosePush: flexible push notification architecture MongoosePush is a server sending push notification to APNS (Apple Push Notification Service) and FCM (Firebase Cloud Messaging, by Google). This new component gives you another choice to address iOS (iPhone, iPad) and Android devices (smartphones, tablets).

MongoosePush can be used with the XEP-0357 specification, implemented in the MongooseIM server. It comes as an addition to our existing solutions: the mod_http_notifications module to send push notification to a generic HTTP-based API, and the mod_aws_sns module to send push notifications to Amazon’s AWS SNS (Simple Notification Service).

Benefits: This flexible push notification architecture covers a large range of infrastructure and business needs, with more convenient integration and consistent technology.

MongooseICE: network binary streaming

MongooseICE is a STUN and TURN server. In technical terms, this helps you traverse NATs and relay streams. In simpler terms, it helps you stream voice, video and screen sharing over networks with proxies and firewalls.

Benefits: With the Jingle protocol implemented in the MongooseIM messaging platform, it becomes much easier to add voice and video calls to an instant messaging application.

High-density platform

Both MongoosePush and MongooseICE are coded in the increasingly popular Elixir language, that is based on the same BEAM virtual machines that Erlang uses. They are both published under the same open source Apache 2.0 license. And finally, they both can be used as a standalone server, outside the scope of a MongooseIM platform.

Figure 2: the MongooseIM platform schema of software components

Please check our source code repositories:


Benefits: MongoosePush and MongooseICE contribute to an stronger conversational experience, and provide coherence in your infrastructure, consequently optimising it.

Tide: Continuous Load Testing, for your trust and growth

Founders and business leaders on route to scale and growth can sleep confidently now. Over the last months, we have built a highly valuable component in the MongooseIM platform: our Tide infrastructure and process, for continuous load testing.

Tide for granular, daily load tests

We are testing the performance impact of any code change. Precisely, Tide deploys MongooseIM clusters which are put under high load, by simulating huge amounts of client connections and traffic. It does all this in an automated and continuous way, for each PR and twice every night, like a tide that washes the shore again and again, repeatedly.

Benefits: Every code change is now covered with various tests, which include load tests, so that no negative impact goes undetected.

Visualise the performance evolution over time

Tide is “semi-private” which means that although only MongooseIM team may start custom tests, every MongooseIM pull request on GitHub is load tested, and the results are public to everyone! Go an take a look at all the graphs available on:

Figure 3: performance improvements over time of MongooseIM with Tide

Benefits: Thanks to Tide, we are now able to graph the evolution of the MongooseIM platform’s performance over time.

Ready for high-growth and business scaling

Tide helps us and thus helps you to be confident and in control of the scalability of the system. Once again MongooseIM aspires to lead by example and make way for future breakthroughs.


Let’s briefly examine our plans for the future.

2.1.x production phase

The 2.1.0 version is available immediately, and ready for a production upgrade. Our next release will be version 2.1.1, it will bring bugfixes, optimisations and even more document improvements. In other terms, we will deliver everything that we could not pack in 2.1.0.

3.x preview: planetary scale

Next on the list is the 3.x series in 2018. It will introduce deployments on a planetary scale, with geodistributed clusters. That is an intercontinental architecture that allows services to operate in any region. Clients / apps can connect with low latency to a local cluster, which is interconnected with all other clusters for global routing. It is different than simple federation that offers inter-domain routing: we offer routing within the same unique domain.

This will be released in two phases: 3.0.x series will bring real-time planetary scale, and 3.1.x series will extend it with archive functionality.

4.x anticipation: (re)connect bots and humans

The 4.x series will (re)connect bots and humans through conversational interfaces. We’re hoping to fuel the next great IoT breakthrough as well as help creating the next generation of chatbots.


Share your biggest pain points on your journey to app and business building, so that we can work together on how to solve them efficiently.

We suggest you to:

  1. Subscribe to our newsletter
  2. Read our “Boost your engine of growth with chat and social value”
  3. Star us on GitHub and follow us on Twitter

Erlang Solutions: Getting started with WombatOAM

24 October, 2017 - 15:15

With the release of WombatOAM 3.0.0beta - our operations, monitoring, maintenance, and performance tool for Erlang OTP based systems, I thought it was time to recap how to install WombatOAM. Get a 45 day free trial.


Before installing WombatOAM, ensure that the machine meets the prerequisites. The following is required before installing WombatOAM:

  • - A UNIX operating system (WombatOAM has been tested on Linux and Mac OS X)
  • - The Erlang run-time system, ERTS (R15B03 or later)
  • - OpenSSL and libcrypto (already present on Mac OS X)


Installing WombatOAM

To install WombatOAM on your computer, retrieve the current WombatOAM package and run the installation script. To do this, execute the following commands:

tar xfz wombat-2.9.0.tar.gz
cd wombat-2.9.0
./ # copy the license key into the directory

The ./ command returns the following:

1) [path to old wombat installation]
2) Other
3) Skip upgrade

If you are installing WombatOAM for the first time, enter 3 at the prompt, skipping the upgrade. The script will simply build a release and start WombatOAM for you.

Upgrading WombatOAM

To upgrade an existing installation of a previous version of WombatOAM, open the package for the new version and execute the following command:

1 ./

At the prompt, enter 2 (Other) and follow further prompts to specify the WombatOAM installation to upgrade from and perform the upgrade.

The script will preserve your collected data and custom configuration (in your old rel/wombat/files/wombat.config file).

The WombatOAM web dashboard

To access the web dashboard, go to http://localhost:8080 in your browser. Log in with the user name admin and password admin.

Running WombatOAM

You can start and stop WombatOAM with the following commands, if necessary:

./ # start Wombat
./ # stop Wombat

Keep in mind that the script will start Wombat automatically. To check whether Wombat is actually running, check whether you can access the WombatOAM web dashboard on http://localhost:8080.

Using WombatOAM

To see how WombatOAM handles nodes, you can install the WombatOAM node itself into WombatOAM:

1. Select the Topology tab and click on the button.

WombatOAM’s Topology page, illustrating the + buttons

2. Enter the following:

Add a new node pop-up

3. Click the Add node button. The WombatOAM node should come up in a few seconds. If it doesn’t, check the following log file: rel/wombat/wombat/log/wombat.log

Click Done and you will be redirected to your node’s frontpage. From here, you have an overview of the metrics and active alarms associated with your node.

Node frontpage


Click the Metrics tab, select the node, and then select a metric. For example, click Memory → Process memory. You should see the measurements made on that node.

Process memory metrics for a specific node

Interested in seeing how WombatOAM can give you full visability of your Erlang or Elixir system? Get a 45 day free trial, on us!

Fanout Blog: Examining Mature APIs (Slack, Stripe, Box)

19 October, 2017 - 14:32

In our previous blog post, we discussed the disconnect between API pricing plans where you pay monthly for a set number of calls and regular developer use cases. We think competition will drive new pricing models that are more developer friendly – and a potential approach could be charging for calls based on their business value. Examining webhook events available via API from Stripe, Slack, and Box gives us a forward look into how this could work.


Daniel Pocock: FOSDEM 2018 Real-Time Communications Call for Participation

19 October, 2017 - 08:33

FOSDEM is one of the world's premier meetings of free software developers, with over five thousand people attending each year. FOSDEM 2018 takes place 3-4 February 2018 in Brussels, Belgium.

This email contains information about:

  • Real-Time communications dev-room and lounge,
  • speaking opportunities,
  • volunteering in the dev-room and lounge,
  • related events around FOSDEM, including the XMPP summit,
  • social events (the legendary FOSDEM Beer Night and Saturday night dinners provide endless networking opportunities),
  • the Planet aggregation sites for RTC blogs
Call for participation - Real Time Communications (RTC)

The Real-Time dev-room and Real-Time lounge is about all things involving real-time communication, including: XMPP, SIP, WebRTC, telephony, mobile VoIP, codecs, peer-to-peer, privacy and encryption. The dev-room is a successor to the previous XMPP and telephony dev-rooms. We are looking for speakers for the dev-room and volunteers and participants for the tables in the Real-Time lounge.

The dev-room is only on Sunday, 4 February 2018. The lounge will be present for both days.

To discuss the dev-room and lounge, please join the FSFE-sponsored Free RTC mailing list.

To be kept aware of major developments in Free RTC, without being on the discussion list, please join the Free-RTC Announce list.

Speaking opportunities

Note: if you used FOSDEM Pentabarf before, please use the same account/username

Real-Time Communications dev-room: deadline 23:59 UTC on 30 November. Please use the Pentabarf system to submit a talk proposal for the dev-room. On the "General" tab, please look for the "Track" option and choose "Real Time Communications devroom". Link to talk submission.

Other dev-rooms and lightning talks: some speakers may find their topic is in the scope of more than one dev-room. It is encouraged to apply to more than one dev-room and also consider proposing a lightning talk, but please be kind enough to tell us if you do this by filling out the notes in the form.

You can find the full list of dev-rooms on this page and apply for a lightning talk at

Main track: the deadline for main track presentations is 23:59 UTC 3 November. Leading developers in the Real-Time Communications field are encouraged to consider submitting a presentation to the main track.

First-time speaking?

FOSDEM dev-rooms are a welcoming environment for people who have never given a talk before. Please feel free to contact the dev-room administrators personally if you would like to ask any questions about it.

Submission guidelines

The Pentabarf system will ask for many of the essential details. Please remember to re-use your account from previous years if you have one.

In the "Submission notes", please tell us about:

  • the purpose of your talk
  • any other talk applications (dev-rooms, lightning talks, main track)
  • availability constraints and special needs

You can use HTML and links in your bio, abstract and description.

If you maintain a blog, please consider providing us with the URL of a feed with posts tagged for your RTC-related work.

We will be looking for relevance to the conference and dev-room themes, presentations aimed at developers of free and open source software about RTC-related topics.

Please feel free to suggest a duration between 20 minutes and 55 minutes but note that the final decision on talk durations will be made by the dev-room administrators based on the received proposals. As the two previous dev-rooms have been combined into one, we may decide to give shorter slots than in previous years so that more speakers can participate.

Please note FOSDEM aims to record and live-stream all talks. The CC-BY license is used.

Volunteers needed

To make the dev-room and lounge run successfully, we are looking for volunteers:

  • FOSDEM provides video recording equipment and live streaming, volunteers are needed to assist in this
  • organizing one or more restaurant bookings (dependending upon number of participants) for the evening of Saturday, 4 February
  • participation in the Real-Time lounge
  • helping attract sponsorship funds for the dev-room to pay for the Saturday night dinner and any other expenses
  • circulating this Call for Participation (text version) to other mailing lists
Related events - XMPP and RTC summits

The XMPP Standards Foundation (XSF) has traditionally held a summit in the days before FOSDEM. There is discussion about a similar summit taking place on 2 February 2018. XMPP Summit web site - please join the mailing list for details.

Social events and dinners

The traditional FOSDEM beer night occurs on Friday, 2 February.

On Saturday night, there are usually dinners associated with each of the dev-rooms. Most restaurants in Brussels are not so large so these dinners have space constraints and reservations are essential. Please subscribe to the Free-RTC mailing list for further details about the Saturday night dinner options and how you can register for a seat.

Spread the word and discuss

If you know of any mailing lists where this CfP would be relevant, please forward this email (text version). If this dev-room excites you, please blog or microblog about it, especially if you are submitting a talk.

If you regularly blog about RTC topics, please send details about your blog to the planet site administrators:

Planet site Admin contact All projects Free-RTC Planet ( contact XMPP Planet Jabber ( contact SIP Planet SIP ( contact SIP (Español) Planet SIP-es ( contact

Please also link to the Planet sites from your own blog or web site as this helps everybody in the free real-time communications community.


For any private queries, contact us directly using the address and for any other queries please ask on the Free-RTC mailing list.

The dev-room administration team:

ProcessOne: Real-time Enterprise Issue #4

17 October, 2017 - 14:02

Here are the articles concerning business aspects of real-time enterprise we found interesting in Issue #4. To receive this newsletter straight in your inbox on the day it’s published, subscribe here.

AOL is shutting down AIM, its iconic instant messaging service

AOL is shutting down its instant messaging service. For ’90s kids, AOL Instant Messenger, or AIM, was texting and Facebook and Gchat and Twitter DMs all rolled into one.

Slack valued at $5 billion following massive investment

Slack has secured significant new investment money that’s boosted its valuation to $5.1 billion. The workplace instant-messaging service confirmed Monday it raised $250 million from Japanese firm SoftBank.

WhatsApp runs pilots with businesses in India to monetise its services

Instant messaging platform WhatsApp has outlined its two-pronged approach to help businesses reach out to customers through its service and is running pilots with several mid-sized companies in India, its largest market globally.

China blocks instant messaging service WhatsApp

The Open Observatory of Network Interference (OONI), a global observation network for detecting censorship, surveillance and traffic manipulation, suggested on Monday night that Chinese internet service providers started blocking access to WhatsApp on September 23.

China’s top messaging app is back online in Russia

Back in May, China’s biggest messaging app has been unblocked in Russia. Access to WeChat was restored by Russian authorities nearly a week after the app was taken offline for running afoul of the country’s information laws.

What messaging means for the future of customer care

According to a Facebook-commissioned study by Nielsen, 56% of people surveyed would rather message a business than call customer service, and 67% expect to message businesses even more over the next two years.

What will be the future of messaging apps?

It is the year 2017 and we carry the future with us in our pocket – that is a simple and sleek mobile device. Texting is one of the most common activities that are performed in a smart phone.

ProcessOne: Real-time Stack Issue #4

17 October, 2017 - 13:59

Here are the technology articles we found interesting in Issue #4. You can receive this content in your inbox on the day it’s published by subscribing here.

Let’s encrypt ejabberd

In the days when encryption should be widespread, it certainly would be convenient to be able to create certificates for ejabberd quickly, easily and for free.

Server-to-Server Stream Management Support

Reliability is essential for communication using XMPP. This extension allows to request stanza acknowledgement and quickly resume session. Any messages that were not delivered over previous connection will be retransmitted during session resumption without duplication.

How to configure a universal secure messenger: XMPP + OTR

Generally speaking of the security of instant messengers in isolation from the security of other components of the system is somewhat strange. What’s the use of a secure instant messenger, if your smartphone keyboard immediately sends everything directly to the server of the manufacturer?

XMPP load testing: the ultimate guide

This post will provide a comprehensive step by step guide to load testing a XMPP server with Apache JMeter™. We will cover all the XMPP Sampler features, including connecting and disconnecting, logging in and working with a list of contacts and an online conference.

XMPPFramework for iOS and Mac

An XMPP Framework in Objective-C for the Mac and iOS development community. XMPPFramework provides a core implementation of RFC-3920 (the XMPP standard), along with the tools needed to read & write XML.

Smack library for Android

Smack is an open source, highly modular, easy to use, XMPP client library written in Java for Java SE compatible JVMs and Android.

London’s disadvantaged kids get free tuition via instant messaging

Pupils from disadvantaged backgrounds will be given private tuition for free using instant messaging on their mobile phones. Children from five London schools are taking part in a trial for a new app run by Tutorfair, a philanthropic tutoring agency.

Erlang Solutions: Messaging feature sets and their benefits

12 October, 2017 - 14:59

This is an excerpt from Boost your engine of growth with chat and social value by Nicolas Vérité.

Messaging feature sets and their benefits
  • A lot of features have come and gone over the few generations of messaging.
  • Some of them stick around much longer than others.

Interpersonal assistant chatbots, for a warm welcome

A welcome bot will allow you - among other things - to handhold users through first uses, conducting them through a critical part of the customer journey, avoiding early churn. Also, it will fix a common situation with new apps: the emptiness and solitude. When you install a fresh app it should definitely show anything but the void and blank spaces.

A machinegun, marketing-driven push notifications could fit the companionship gap as well, but these are annoying and intrusive, and sometimes they come with disrupting the experience with the app. This may void user value, consequently, synthetically increasing your vanity metrics for an immediate fall once the shots are fired.

A chatbot has more empathy and emotional triggers due to its location: inside the one-to-one chat. This gives it an air of interpersonal feeling, as opposed to an external and disconnected notification center. A welcome chatbot is in-app automation (client-side or server-side), as it leverages the conversational experience (the vertical timeline). There is no absolute need for any type of AI - your chatbot can be rule-based with quick replies, as it belongs to a properly mapped user experience. Such a chatbot is an opportunity to be fun and warming, as it can establish the users’ first steps, and thus a general “connection” to the experience.

Warning: the experience of a chatbot leads to disappointment sooner or later in the user’s journey. That is especially true if the AI or the decision-tree is not fit for the job. So you have to set the expectations for your users, to prevent or delay that disappointment. “A smile is the universal welcome.” (Max Eastman)

Social, open networks, for higher discovery

Simply put, the social network sector is quite overcrowded, as the major players over there are really huge. The barrier of entry is high… Unless you are bringing a really disruptive innovation, that is proven to be a game changer, and fit for massive adoption. But then it is often a hard sell.

Instead, instant messaging is again booming, mainly thanks to its third generation. There are plenty of players here, and thus it is indeed very hard for a new app to get discovered on the stores, but the market is more accessible to businesses.

Social posting, liking and commenting are features all well known on social apps. Building the same features on top of conversational apps is a trend today, a real trend even if still a bit shy and hardly noticeable. Here is why: it allows users/customers to discover communities, places, and people. It enables browsing, searching, and interaction through all available open and public content. In other words, it indirectly gives humans more opportunities to interconnect with more humans and bots. And as a consequence, this increases their network value. It is about growing your users’ network and own branding, and to engage with their audiences.

Warning: the content inconsistency that you are used to in various apps, whether you refresh or change the device, is a real pain. Be careful about the expectations when people browse to find something. “The only real voyage of discovery consists not in seeking new landscapes but in having new eyes.” (Marcel Proust)

Groupchat, closed networks, for continuous interactions

The groupchat market is still accessible, although massive adoption is clearly observable. A multiplicity of categories and viable niches exist today, and the exploration is not over. Proof of this resides in some big players (Cisco, Microsoft, Google) jumping on the bandwagon, after the huge successes of Slack, HipChat, Mattermost,, Zulip, Matrix, Ring. The model has definitely won hearts, with the numbers following suit. Expect a wave of mergers and acquisitions to follow (Atlassian already bought HipChat).

What is cool and very well understood about those apps, is that they target groups and communities, in other words, they map to organically highly interconnected networks and serve them. Just bring in one team at a time, and retain them all. Third generation IM app makers understand that brings great engagement and retention to their networks. These activities are mainly happening at the workplace, and during the workday. So there is minimal annoyance after work.

The never-ending stream of groupchat messages is much more fluid and rapidly evolving than social content. Partly because the conversational timeline is much more intuitive and easy to use than social hierarchy and weird algorithms (Facebook and Twitter were much harder to grasp for beginners).

Group chats necessitate a far lower number of people in a closed environment to generate the same engagement, as compared to public social streams. That is aimed at deeper and consistent relations, that your users have to maintain over time.

Warning: easing your users’ maintenance of their network is key to consistency. “Success isn’t always about greatness. It’s about consistency. Consistent hard work leads to success. Greatness will come.” (Dwayne Johnson)

A balanced combination leads to a winning alchemy

Mixing together open and closed networks for discovery and engagement is key to users’ network growth. Don’t leave onboarding to the apathetic factory lines and lower the barrier of entry. Just provide a network, with a perceivable and obvious network value, and means to grow it over time. All these elements will contribute to and catalyse the acquisition, the retention, and referral.

An application that is fully loaded with tons of features is quite a clear signal that the makers don’t know what to do, and want to do it all. A carefully crafted feature set, with a strong focus is the path to reach your targets and fix their problems or address their needs.

Anyway, your feature sets always go through the funnel or the filter of adoption, measured by AARRR/pirate metrics. This is the path that is necessary to deliver network value to you user and customer base. “There is no decision that we can make that doesn’t come with some sort of balance or sacrifice.” (Simon Sinek)

For more insights and practical advices on how to find your optimal feature set and increase the network value of your product, read the full article: Boost your engine of growth with chat and social value by Nicolas Vérité.

Subscribe to our newsletter for the latest Instant Messaging news, visit our webpage or contact us directly to discuss your project or simply to ask a question.

Tigase Blog: Tigase XMPP Server v7.1.2 Released!

12 October, 2017 - 01:51

Tigase XMPP Server v7.1.2 has been released! Please review the change notes below to see what has changed since our last release.