Planet Jabber

November 21, 2017

Erlang Solutions

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

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 1.1.1.1, and MongooseIM to 2.2.2.2.

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 2.2.2.2/myxmpp.com and MongooseICE to 1.1.1.1. 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.

Configuration

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", "myxmpp.com"] }.

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: movie@myxmpp.com and phone@myxmpp.com, for RaspberryPi and the Android phone respectively. In order to do that, type:

$REPO/_build/prod/rel/mongooseim/bin/mongooseimctl register phone myxmpp.com xmpp_password
$REPO/_build/prod/rel/mongooseim/bin/mongooseimctl register movie myxmpp.com 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=1.1.1.1" -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 inaka.com.mangosta.videostream 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 (phone@myxmpp.com), the password (xmpp_password) and the server address (2.2.2.2 or myxmpp.com 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 https://github.com/esl/ice_demo.git
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: "movie@myxmpp.com",
  password: "xmpp_password",
  host: "myxmpp.com",
  turn_addr: "1.1.1.1:3784"
  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 “movie@myxmpp.com” 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]https://drive.google.com/file/d/0B48g-HBQ5xpxeVlUSks2bVRlLTQ/view) (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.

Participate!

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

November 21, 2017 11:51

November 17, 2017

Ignite Realtime Blog

Openfire 4.2.0 Beta Release

@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  openfire_4_2_0_beta.zip
b380d386c2f3b4007dc9755648c579b984b52389  openfire_src_4_2_0_beta.tar.gz
f814b17f00084ef904959b3241044cf63981ece4  openfire_src_4_2_0_beta.zip

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: 9

Participants: 6

Read full topic

by @akrherz daryl herzmann at November 17, 2017 16:13

November 16, 2017

Erlang Solutions

How to set up Push Notifications with MongoosePush

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).

mod_push_service_mongoosepush

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 README.md. 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 mypubsub.com 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='pubsub.mypubsub.com'
    id='create1'>
  <pubsub xmlns='http://jabber.org/protocol/pubsub'>
    <create node='punsub_node_for_my_private_iphone' type='push'/>
  </pubsub>
</iq>

The pubsub.mypubsub.com 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 pubsub.mypubsub.com) 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 mychat.com 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='pubsub.mypubsub.com' node='punsub_node_for_my_private_iphone'>
    <x xmlns='jabber:x:data' type='submit'>
      <field var='FORM_TYPE'><value>http://jabber.org/protocol/pubsub#publish-options</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 pubsub.mypubsub.com 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='pubsub.mypubsub.com' 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.

Participate!

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

November 16, 2017 17:09

November 15, 2017

Daniel Pocock

Linking hackerspaces with OpenDHT and Ring

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.

by Daniel.Pocock at November 15, 2017 19:57

Fanout Blog

High scalability with Fanout and Fastly

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!

fanout-fastly

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.

...

by justin at November 15, 2017 01:58

November 10, 2017

ProcessOne

DotGo 2017: Go for Real Time Streaming Architectures

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:

by Mickaël Rémond at November 10, 2017 14:21

November 09, 2017

Alexander Gnauck

Introducing MatriX vNext

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 = "server.com",
};

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: https://www.nuget.org/packages/Matrix.vNext

by gnauck at November 09, 2017 11:24

Peter Saint-Andre

Songs of Zarathustra: First Draft

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:...

November 09, 2017 00:00

November 02, 2017

ProcessOne

Real-time Stack Issue #5

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

Resin.io 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.

by Marek Foss at November 02, 2017 17:38

Erlang Solutions

MongooseIM 2.1.0: stronger platform for better chat experience

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: https://mongooseim.readthedocs.io/en/latest/

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.

Future-proof

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:

  1. https://github.com/esl/MongoosePush
  2. https://github.com/esl/MongooseICE

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: http://tide.erlang-solutions.com/public

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.

Roadmap

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.

Participate!

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

November 02, 2017 15:21

October 28, 2017

Arnaud Joset

JP, a powerful command line interface for Salut-à-Toi

Salut à toi 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. Today, I will focus on the use of "JP", a command-line interface. It can be used to send or receive files directly from a shell, pipe commands to or from XMPP, use XMPP easily in a script and of course play with pubsub nodes.

The following article describes uses of JP. Several of them are availabled in the trunk version of Salut-à-Toi.

Introduction

JP can be used to launch complexes commands in script, for debugging purpose or to explore XMPP services. JP is the command line interface and it connect to the daemon Salut-à-Toi (SàT). You can share the session between the front-ends:

  • JP of course.
  • Primitivus as a console front-end.
  • Livervia, a web based front-end.
  • Sententia an Emacs front-end (WIP).
  • Cagou an original mobile XMPP client based on SàT (WIP).

If you want to send a file easily, discover which services are available on a server, send messages in your scripts, manage your xmpp account, control video player, edit your blog post with your favorite editor, pipe streams, manage your pubsub nodes etc, JP is for you!

Usage

JP can be used as a command line tools or in a small shell environment.

First, we need to configure and launch the daemon sat.

$ sat

Your default profile will be connected. If you have no profile, JP can be used to create one.

$ jp profile create -j my_jid@example.org  -x mypassword profile_name
$ jp profile connect -p profile_name

Your password is saved in the sat settings. You can connect automatically with the option -c. It should be noted that SàT defines a default profile. It can be bypassed with the option -p. 1

$ echo "test message" | jp message send recipient@example.org -p profile_name -c

You can obtain help about a command with the option -h.

$ jp pubsub -h
usage: jp pubsub [-h]
                 {get,delete,edit,subscribe,unsubscribe,subscriptions,node,affiliations,search,hook,uri}
                 ...

positional arguments:
  {get,delete,edit,subscribe,unsubscribe,subscriptions,node,affiliations,search,hook,uri}
    get                 get pubsub item(s)
    delete              delete an item
    edit                edit an existing or new pubsub item
    subscribe           subscribe to a node
    unsubscribe         unsubscribe from a node
    subscriptions       retrieve all subscriptions on a service
    node                node handling
    affiliations        retrieve all affiliations on a service
    search              search items corresponding to filters
    hook                trigger action on Pubsub notifications
    uri                 build URI

optional arguments:
  -h, --help            show this help message and exit

JP is a Swiss army knife. Let's discover its possibilities through a few examples.

Examples

$ jp -h
usage: jp [-h] [--version]
          {file,input,uri,message,event,info,account,param,debug,ad-hoc,ticket,invitation,profile,shell,avatar,pipe,pubsub,bookmarks,roster,identity,blog}
          ...

This software is a command line tool for XMPP.
Get the latest version at http://salut-a-toi.org

optional arguments:
  -h, --help            show this help message and exit
  --version             show programʼs version number and exit

Available commands:
  {file,input,uri,message,event,info,account,param,debug,ad-hoc,ticket,invitation,profile,shell,avatar,pipe,pubsub,bookmarks,roster,identity,blog}
    file                File sending/receiving
    input               launch command with external input
    uri                 XMPP URI parsing/generation
    message             messages handling
    event               event management
    info                Get various pieces of information on entities
    account             XMPP account management
    param               Save/load parameters template
    debug               debugging tools
    ad-hoc              Ad-hoc commands
    ticket              tickets handling
    invitation          invitation of user(s) without XMPP account
    profile             profile commands
    shell               launch jp in shell (REPL) mode
    avatar              avatar uploading/retrieving
    pipe                stream piping through XMPP
    pubsub              PubSub nodes/items management
    bookmarks           manage bookmarks
    roster              Manage an entityʼs roster
    identity            identity management
    blog                blog/microblog management

Send a message

$ echo "Hello World" > filetest
$ jp message send recipient@example.org < filetest

or

$ echo "test  jp" | jp message send recipient@example.org

Send files

The following command allows to send the file file.txt to recipient@example.org.

$ jp file send file.txt recipient@example.org

Receive files

The following command allows to receive a file in the /tmp directory.

$ jp file receive -p agayon --path /tmp

Get information about a server

$ jp info version agayon.be
Client name: Prosody
Client version: 0.10.0
Operating System: Linux

Get disco information

Query a Server

$ jp info disco agayon.be
Features

http://jabber.org/protocol/commands
http://jabber.org/protocol/disco#info
http://jabber.org/protocol/disco#items
http://jabber.org/protocol/pubsub#publish
jabber:iq:last
jabber:iq:private
jabber:iq:roster
jabber:iq:time
jabber:iq:version
msgoffline
urn:xmpp:blocking
urn:xmpp:carbons:1
urn:xmpp:carbons:2
urn:xmpp:http:upload
urn:xmpp:http:upload:0
urn:xmpp:mam:0
urn:xmpp:ping
urn:xmpp:time
vcard-temp

Identities

┌───────┬──────┬─────────────────┐
│catego │ type │ name            │
├┄┄┄┄┄┄┄┼┄┄┄┄┄┄┼┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┤
│store  │ file │ HTTP File Upload│
│server │ im   │ Prosody         │
│pubsub │ pep  │ Prosody         │
└───────┴──────┴─────────────────┘

Extensions

urn:xmpp:http:upload
    typetext-single
    varmax-file-size
    1048576
urn:xmpp:http:upload:0
    typetext-single
    varmax-file-size
    1048576

Items

┌─────────────────────┬──┬────┐
│entity               │  │ nam│
├┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┼┄┄┼┄┄┄┄┤
│upload.agayon.be     │  │    │
│pubsub.agayon.be     │  │    │
│auth.agayon.be       │  │    │
│proxy.agayon.be      │  │    │
│sat-pubsub.agayon.be │  │    │
│chat.agayon.be       │  │ bot│
└─────────────────────┴──┴────┘

Query an account

$ jp info disco info@agayon.be
Features

http://jabber.org/protocol/pubsub#publish
urn:xmpp:mam:0
urn:xmpp:mam:1
urn:xmpp:mam:2
urn:xmpp:push:0
urn:xmpp:sid:0

Identities

┌────────┬────────────┬─┐
│categor │ type       │ │
├┄┄┄┄┄┄┄┄┼┄┄┄┄┄┄┄┄┄┄┄┄┼┄┤
│pubsub  │ pep        │ │
│account │ registered │ │
└────────┴────────────┴─┘

Manage pubsub nodes

The following examples show how to manage pubsub nodes on the service pubsub.agayon.be.

Create a node

$ jp pubsub node create -s pubsub.agayon.be node_name

Subscribe to a node

$ jp pubsub subscribe -s pubsub.agayon.be node_name

Edit

The edit command allows to edit an item under a node.

$ jp pubsub edit -s pubsub.agayon.be node_name

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

If you want to edit a post without having to edit xml directly, use jp blog edit.

As an example, you can try to edit the following xml file.

<entry xmlns="http://www.w3.org/2005/Atom">
  <author>
    <name>author@example.com</name>
  </author>
  <generator>JP (SàT)</generator>
  <title>I am a pubsub post !</title>
  <content>This is the content of this great post.</content>
</entry>

Once the file is saved, a notification appears in Gajim. For now, the name of the post is a hash.

pubsub post on Gajim

pubsub post on Gajim

Manage your XMPP Blog

It is possible to manage a post with XMPP. It is based on PEP, a simplified version of pubsub. If your server support PEP, JP can help you to manage this blog easily.

Publish a post

First, you need to define your preferred syntax. In this example, I select markdown. This option can also be set in any other frontend (e.g. Primitivus). Whereafter you can edit a new post with the syntax jp blog edit.

$ jp param set Composition Syntax markdown -p agayon
$ jp blog edit

Your favorite editor open and you can edit your blog post with markdown syntax. When you save and close it, another file open. You can edit your settings:

{
    "allow_comments": "true",
}

You can verify the accessibility of your post with the following command:

$ jp blog get 
content: 
Great test !
Make testing great again !
Yuuuuuuge publication.

It is also possible to modify your last blog post simply with jp blog edit --last-item.

Your blog post are also visible on other clients like Movim (see below) and interfaces like Livervia.

Post on movim

Use jp shell:

In order to ease debugging of services, JP comes with a shell interface. You only need to launch jp shell. You can obtain help by typing ?.

$ jp shell
cmd pubsub
pubsub> ?
Shell commands:
Documented commands (type help <topic>):
========================================
cmd    do    help  shell  use_clear  version
debug  exit  quit  use    verbose    whoami 

Action commands:
positional arguments:
  {get,delete,edit,subscribe,unsubscribe,subscriptions,node,affiliations,search,hook,uri}
    get                 get pubsub item(s)
    delete              delete an item
    edit                edit an existing or new pubsub item
    subscribe           subscribe to a node
    unsubscribe         unsubscribe from a node
    subscriptions       retrieve all subscriptions on a service
    node                node handling
    affiliations        retrieve all affiliations on a service
    search              search items corresponding to filters
    hook                trigger action on Pubsub notifications
    uri                 build URI

Select a command

> cmd pubsub
pubsub> use node urn:xmpp:microblog:0

Navigate into commands

> cmd bookmarks/list
bookmarks/list> -c
... CMD result
bookmarks/list> cmd ..
bookmarks> cmd
>

Example: List bookmarks

$  jp shell
> cmd bookmarks
bookmarks> cmd list
bookmarks/list> ?
Shell commands:
Documented commands (type help <topic>):
========================================
cmd    do    help  shell  use_clear  version
debug  exit  quit  use    verbose    whoami 

Action commands:
optional arguments:
  -h, --help            show this help message and exit
  -p PROFILE, --profile PROFILE
                        Use PROFILE profile key (default: @DEFAULT@)
  --pwd PASSWORD        Password used to connect profile, if necessary
  -c, --connect         Connect the profile before doing anything else
  -l {all,local,private,pubsub}, --location {all,local,private,pubsub}
                        storage location (default: all)
  -t {muc,url}, --type {muc,url}
                        bookmarks type (default: muc)
bookmarks/list> -t muc
private:
    Movim [movim@conference.movim.eu] (*)
    Archlinux - blah blah [archlinux-fr@chat.jabberfr.org]
    bot [bot@chat.agayon.be] (*)

Example: get disco information

> cmd info
info> use pubsub.agayon.be 
info> use jid pubsub.agayon.be 
info> disco
Features

http://jabber.org/protocol/disco#info
http://jabber.org/protocol/disco#items
http://jabber.org/protocol/pubsub
http://jabber.org/protocol/pubsub#create-nodes
http://jabber.org/protocol/pubsub#delete-items
http://jabber.org/protocol/pubsub#delete-nodes
http://jabber.org/protocol/pubsub#instant-nodes
http://jabber.org/protocol/pubsub#item-ids
http://jabber.org/protocol/pubsub#publish
http://jabber.org/protocol/pubsub#publisher-affiliation
http://jabber.org/protocol/pubsub#purge-nodes
http://jabber.org/protocol/pubsub#retract-items
http://jabber.org/protocol/pubsub#retrieve-items
http://jabber.org/protocol/pubsub#retrieve-subscriptions
http://jabber.org/protocol/pubsub#subscribe

Identities

┌───────┬─────────┬───────────────────────┐
│catego │ type    │ name                  │
├┄┄┄┄┄┄┄┼┄┄┄┄┄┄┄┄┄┼┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┤
│pubsub │ service │ Prosody PubSub Service│
└───────┴─────────┴───────────────────────┘

More

Some alternatives

SleekXMPP

SleekXMPP is a xmpp python library. It provide two examples of pubsub clients. The first, pubsub_client.py can create nodes and the second one, pubsub_events.py, can manage events.

./pubsub_client.py -j jid --passwword=passwd pubsub.agayon.be create node_name

Gajim

Gajim is a great desktop client. It can be used to post on pubsub nodes too.

pubsub post on Gajim

Movim

Movim is a social network platform based on XMPP. It massively use pubsub to allow users to interact.

Conclusions

Salut-à-Toi is a great XMPP client. JP, its command-line interface, is a powerful tool. It can be useful to debug services, pubsub nodes and play with 'social' capacities of XMPP. It is actively developed and new features are coming. We will be soon able to make todolist or fill a bug ticket on a XMPP based system.

Links

  1. It is possible to use jp profile modify to set the default profile.

by Arnaud at October 28, 2017 14:00

October 24, 2017

Erlang Solutions

Getting started with WombatOAM

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.

Prerequisites

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:

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

The ./upgrade.sh 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 upgrade.sh 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 ./upgrade.sh

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

The upgrade.sh 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.sh # start Wombat
./stop.sh # stop Wombat

Keep in mind that the upgrade.sh 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

WombatOAM’s Topology page, illustrating the + buttons

2. Enter the following:


Add a new node pop-up

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

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

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!

October 24, 2017 15:15

October 19, 2017

Fanout Blog

Examining Mature APIs (Slack, Stripe, Box)

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.

...

by daniel at October 19, 2017 14:32

Daniel Pocock

FOSDEM 2018 Real-Time Communications Call for Participation

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 https://fosdem.org/submit

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 (http://planet.freertc.org) contact planet@freertc.org
XMPP Planet Jabber (http://planet.jabber.org) contact ralphm@ik.nu
SIP Planet SIP (http://planet.sip5060.net) contact planet@sip5060.net
SIP (Español) Planet SIP-es (http://planet.sip5060.net/es/) contact planet@sip5060.net

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.

Contact

For any private queries, contact us directly using the address fosdem-rtc-admin@freertc.org and for any other queries please ask on the Free-RTC mailing list.

The dev-room administration team:

by Daniel.Pocock at October 19, 2017 08:33

October 17, 2017

ProcessOne

Real-time Enterprise Issue #4

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.

by Marek Foss at October 17, 2017 14:02

Real-time Stack Issue #4

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.

by Marek Foss at October 17, 2017 13:59

October 12, 2017

Erlang Solutions

Messaging feature sets and their benefits

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, Rocket.chat, 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.

October 12, 2017 14:59

Tigase Blog

Tigase XMPP Server v7.1.2 Released!

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

by Daniel at October 12, 2017 01:51

October 08, 2017

Peter Saint-Andre

Ultra-Short Poems

Reading a book on Matsuo Bashō has renewed my interest in ultra-short poems. The best-known form here is haiku, which in Japanese consists of three sections of 5, 7, and 5 syllables each. The most famous haiku is probably this one written by Bashō in 1686:...

October 08, 2017 00:00

October 05, 2017

Fanout Blog

Dev-centric API pricing is the future

As folks who power realtime APIs, we’re always interested in broader trends in what is referred to as the “API Economy.” In the last couple of years, we (and everyone else) have seen the proliferation of APIs skyrocket. ProgrammableWeb indexes over 18,412 APIs. Even Walgreens has an API.

This has generally been a good thing for developers who want to build new technology. Instead of having to build your app from scratch, you can assemble distributed processes for everything from payments to messaging that are built and scaled by specialists, leaving you with more time to focus on your unique functionality. There are APIs and “as-a-services” (we’re one of them), for almost everything you can imagine – and this means developers are implementing more APIs in a single project than ever before.

...

by daniel at October 05, 2017 19:52

Erlang Solutions

Master your pirate metrics, AARRR

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

Instant messaging or chat is a constantly self-reinventing universe. In this article we focus on businesses who are building chat apps and apps with chat. From early stage startups to big corporates, it is always good to remind and always be conscious of some the basics of business, and how the interlinking and mechanics of social and messaging allows you to accelerate growth and consolidate your sustainability.

Master your pirate metrics, AARRR

Pirate metrics are business KPIs for product or service marketing, sales and more generally product management. It is a big funnel of quantitative data telling the story of your customers’ journey. This data describes different stages of your relationship with the client: Acquisition, Activation, Retention, Revenue, Referral. Together these pirate metrics add up to a famous pirate battle cry - “AARRR”.

What are the metrics behind AARRR?

  • Acquisition: people who come to your product or service
  • Activation: people who actually do something with your product or service
  • Retention: people who continue to use your product or service regularly
  • Revenue: people who pay
  • Referral: people who talk (positively, hopefully) about your product or service!

More precisely, it is a set of critical engine parts of your growth machine. Each single value of these five metrics is important for your measure, so that you better understand your customer journey, and can optimise it.

The ratio of conversions for each step is also very important. But don’t lose sight of the bigger picture; it helps you identify what you are good at, and where to improve.

Going deeper, next we will focus on the organic aspects of Instant Messaging: Acquisition, Retention, Referral. We will not cover Activation, because it mostly belongs to your onboarding, neither will we cover Revenue because it mostly belongs to your business model. However, it is clear that Activation and Revenue are not fully disconnected from Acquisition, Retention, and Referral.

Here is how to boost the triplet “Acquisition, Retention, Referral”.

Features for Acquisition and traction

There are a number of generic chat features available that appeal to your potential users and thus contribute to Acquisition. One-to-one chat or interpersonal messaging obviously comes to mind first. Then group chat is definitely contributing a lot to your traction, as it is more fun and collaboration for users, the generation Slack/HipChat and their dozens of followers showed that massive enthusiasm and need. And finally, social networking is taking all of that to the super next level.

Then you can consider secondary features, such as presence, status, availability, profiles, avatars, and contact management, including blocking. There are even more features, such as typing notifications, last message correction, sent/received/read receipts, pictures/sounds/video/location messaging, archiving, mentions, stickers/emojis, integrations, chatbots, full-text search, the stories craze, and of course end-to-end encryption.

Let’s not look too deep into all the features on offer for now, you should focus on creating your own subset, based on your customer demand, and the problems you are trying to solve. Your unique custom features will be your differentiators.

Warning: carefully craft and tailor key distinctive features for your audience. Do not use ALL the commodity features. The goal is to avoid feature factories, making your app look like blinking Christmas decorations. “It seems that perfection is attained not when there is nothing more to add, but when there is nothing more to remove.” (Terre des hommes, Antoine de Saint-Exupéry, 1939)

Activities for Retention and engagement

Here you will use mechanics that will not add friction, nor will you focus on the features that “just add value” for individuals. You will focus on conversation (re)activators, such as chatbots, integrations, group chat and social chat (natural user feature, not marketing features to synthetically force the use of the app).

These “wake up” conversations are to be considered in the perspective of the user. These simple tricks allow you to re-capture a significant ratio of dormant users, and greatly improve user engagement with your app.

Warning: be careful of notification fatigue, and information overload. Of course you cannot control your audience’s activity. So be wise in buffering, aggregation, and re-activation. “A wealth of information creates a poverty of attention.” (Designing Organizations for an Information-Rich World, Herbert Alexander Simon, 1971)

FOMO for Referral and going viral

A highly interconnected community will naturally, organically pull the missing people in, and bring more nodes and interconnections into the network. This relies on a very simple psychology trick: FOMO (or the Fear Of Missing Out). If a group or community is almost fully present on your app, having fun with all the content and interactions, then the elements that are still outside this circle will be magnetically attracted.

Warning: do not expect virality to spontaneously generate. The ecosystem will grow starting with much seeding effort. This is why you need to focus on two major tasks: capture a niche first in order to jump into another one, and ignite a viral wildfire on social media using best practices, i.e. prioritising micro-influencers. “A referral is the key to the door of resistance.” (Bo Bennett)

Each one of the organic triplet “Acquisition+Retention+Referral” feeds each other:

  • Acquisition+Retention: an app user seeing new friends joining in will engage and explore even more with the network
  • Acquisition+Referral: virality reduces your cost of acquisition
  • Retention+Referral: missing elements of an active and consistent group or community will be invited to join in

Interested in learning more about the power of social messaging and how to successfuly expand your app engagement? Read the full article: Boost your engine of growth with chat and social value by Nicolas Vérité and get practical advices on how to combine the forces of chat and social to increase the network value of your product.

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.

October 05, 2017 15:56

Ignite Realtime Blog

Openfire 4.1.6 Release

@akrherz wrote:

The Ignite Realtime Community is proud to announce the 4.1.6 release of Openfire. This release signifies our continuing effort to produce stable 4.1 series releases while work continues on the next major release. A changelog denoting 16 resolved issues is available and you can download the release builds from our website.

Important to know: Openfire now automatically installs the service. On the last step of the installer you will have an option whether to start it or not (it will also open the browser pointing to Admin Console, if you chose to start it). You shouldn't run the launcher, if the service is started. Documentation is updated accordingly. If you already have older service running, stop it before upgrading. You don't have to do this when upgrading from 4.1.5 and with later versions. It should stop the service automatically.

The following table denotes release artifact sha1sums and some github download statistics for the 4.1.5 release of that particular file.

OS sha1sum Filename Version 4.1.5 Downloads
Linux RPM (32bit JRE) f05e664e8c71c87e9d22f9e4d9ee49fc70ac2ade openfire-4.1.6-1.i686.rpm 2,473
Linux RPM (No JRE) 23936a3e9131d72febe18e52d8778f4f27e14a21 openfire-4.1.6-1.noarch.rpm 2,463
Linux RPM (64bit JRE) c52c74de7661f894395287a3119dd39d217f7726 openfire-4.1.6-1.x86_64.rpm 12,027
Linux .deb f37349708220c7c3e3fb577088b9d0b995494a9f openfire_4.1.6_all.deb 18,206
Mac OS b0315762aab005bd4d9b6cf28fe86b897f35a236 openfire_4_1_6.dmg 4,095
Windows EXE (32bit, No JRE) 228ab4fb6a95679a98995f6751d7bfb6831d48e3 openfire_4_1_6.exe 49,948
Windows EXE (32bit JRE) 09ed1261cd485414ab4bdb080324ea8f2484b784 openfire_4_1_6_bundledJRE.exe n/a
Windows EXE (64bit, No JRE) 726e3b4a70e04532540b6ffdf3702d03f17e34c1 openfire_4_1_6_x64.exe n/a
Windows EXE (64bit JRE) 00bd41e6df267fd87621bd048ed033065103bc65 openfire_4_1_6_bundledJRE_x64.exe n/a
Binary (tar.gz) 8af96d080b92a6575cd07dbbcd07a63371d577fe openfire_4_1_6.tar.gz 6,786
Binary (zip) b46e998302c9860b1150cf0b20e0525f57dcb3b2 openfire_4_1_6.zip 11,241
Source (tar.gz) 032b3bfdbaad71cb61cb5ed921b17f3a4e9694c6 openfire_src_4_1_6.tar.gz 1,399
Source (zip) 4d9fb6e997c220664a9b5cdc8a5764cf62a46c43 openfire_src_4_1_6.zip 5,731

As a reminder, our development of Openfire happens on Github and we have an active MUC development chat hosted at open_chat@conference.igniterealtime.org. We are always looking for more folks to pitch in with testing, fixing bugs, and development of new features. Please consider helping out!

As always, please report any issues in the Community Forums and thanks for using Openfire!

Posts: 5

Participants: 3

Read full topic

by @akrherz daryl herzmann at October 05, 2017 15:39

Peter Saint-Andre

Internationalized RFCs

Ever since the first "Request for Comments" (RFC 1) was published in 1969, the RFC series has been typeset exclusively in ASCII text. It's almost a running joke among technologists and programmers. Yet that is finally changing. The recently-published RFC 8187 marks the first time that RFCs have included Unicode characters and an encoding other than ASCII (i.e., UTF-8). Today, RFCs 8264, 8265, and 8266 take that a step further by using non-ASCII characters in a more thorough-going way; appropriately enough, these three RFCs define revised versions of the PRECIS specifications for the preparation, enforcement, and comparison of internationalized strings in application protocols (thus replacing RFCs 7564, 7613, and 7700, which I authored in 2015). I'm sure many readers never thought they'd see a symbol like ∞ (INFINITY, Unicode code point U+221E) in an RFC, but we did it! Many thanks to the RFC Editor team for making this day possible, and to my co-authors Marc Blanchet and Alexey Melnikov for making this day necessary. ;-)...

October 05, 2017 00:00

October 03, 2017

Tigase Blog

XMPP Meetup Recaps

Recently the XMPP community had has a number of meetups across Europe. Working to improve and expand the scope and visibility of the platform, these meets have been held independently and during other conferences.

by Daniel at October 03, 2017 21:09

October 02, 2017

Prosodical Thoughts

Prosody 0.10.0 released

It's not 1st April, it's 2nd October. Which means the rumours you heard were true. Prosody 0.10.0 is released!

This is the first release of our 0.10 branch. All of our recent releases have been from our stable 0.9 branch, which has served us well since the initial release of 0.9.0 back in 2013.

However time marches on, and we have a long list of new features and modules that we want to share with you.

This release contains over 1500 new commits from many contributors, adding and modifying over 30,000 lines of code.

Features

Carbons

While it has been available in our community modules repository for some time, this release brings official support for Message Carbons (XEP-0280).

This feature allows multiple clients connected to the same account to see the same view of a conversation, making it easy to hop from device-to-device during an ongoing conversation and not worry about missing any messages.

Message Archive Management

Also becoming official is our support for XEP-0313: Message Archive Management.

Like Message Carbons, this feature allows clients to synchronize conversations. However thanks to the server-side archive, it also allows clients that have been offline to "catch up" on conversations that they might have missed. Combined with Message Carbons this provides a complete solution for "every message on every device", which is a key feature expected of modern communication platforms.

Our implementation is flexible, allowing configurable retention times and selecting whether you to store archives in memory, files, an SQL database or anything else that you care to plug into our modular storage API.

Security: Channel binding for SCRAM

Using technological cryptographical wizardry, this new authentication mechanism allows a client to verify that it is speaking to the correct server even if it doesn't recognise the TLS certificate. This is made possible via a feature in the SCRAM authentication protocol that forces the server to prove that it also knows the client's password.

Many thanks to Tobias Markmann for contributing this.

Built-in configuration checker

Prosody now has a very handy utility that attempts to identify common issues with your server setup. This includes checking your config file for syntax errors, but also checks your DNS, certificates and other aspects of your server are looking good.

It's a great first place to check if something isn't working the way you expect.

Metrics support

This release also adds built-in support for gathering metrics about the server operation. Although we've had some community modules capable of measuring various things in previous versions, they were limited by a lack of support in our core code.

The new API is a core part of Prosody, and although it is early days (many more metrics to be added in future releases), the basis is there and module developers are able to start using it today.

Currently the metrics can be aggregated internally, or sent externally to any statsd-compliant server. Other backends are possible via external libraries, for example we have a Datadog integration.

Simplified certificate handling

One of the trickiest parts of setting up a new XMPP service has been setting up certificates. Excluding certificate handling, setting up a new Prosody instance on a Debian/Ubuntu server is as simple as one command (apt install prosody) and editing one line in the config file (change "localhost" to your domain name). But obtaining and configuring the certificates, figuring out whether you need to add in an "intermediate" certificate or not, that was not so simple.

But thankfully new projects like Let's Encrypt and the ACME protocol are solving the problems associated with obtaining and managing certificates.

We have made similar progress in simplifying Prosody's certificate configuration as well. For example, if you use Let's Encrypt, you do not need to add any certificate configuration to Prosody's config file at all! A single command will automatically "import" new/updated certificates for the hosts in your Prosody config file, and instantly activate them in Prosody without a restart.

We expect this new feature to be usable by the large majority of setups. However for those who need a different configuration, the old "manual" method still works to give fine-grained control over the certificate configuration.

Everything you need to know about Prosody's certificate configuration can be found in our documentation.

Lua 5.2 support

Lua 5.2 was a major step in the language's evolution. It has been around for a while, but for a number of reasons (including a desire to stay compatible with LuaJIT), Prosody stuck with Lua 5.1 for a while. But it's time. This release adds initial support for running under Lua 5.2. There may still be some edge cases, so while we encourage people to use Lua 5.2 and report any issues, a stable production server may want to stick with Lua 5.1 for now.

Native websockets

This release also adds official support for websocket connections. Many web clients are already able to take advantage of this, connecting directly to Prosody from Javascript without needing to implement BOSH.

Many thanks to Florian Zeitz for the initial contribution of this module.

Other improvements

Finally, we've made countless other improvements and fixes in this branch. These include support for the newer and simpler, blocking protocol (mod_blocklist), and numerous improvements to our internal APIs for module developers to take advantage of.

Upgrading

If you are upgrading from a previous release, your life will be made easier by reading the release notes!

The Prosody 0.9.x series will continue to be maintained for major bug fixes until at least June 2018.

Download

As usual, download instructions for many platforms can be found on our download page

If you have any questions, comments or other issues with this release, let us know!

by The Prosody Team at October 02, 2017 15:35