🚀 Introducing ejabberd 24.02: A Huge Release!

ejabberd 24.02 has just been release and well, this is a huge release with 200 commits and more in the libraries. We’ve packed this update with a plethora of new features, significant improvements, and essential bug fixes, all designed to supercharge your messaging infrastructure.


– 🌐 Matrix Federation Unleashed: Imagine seamlessly connecting with Matrix servers – it’s now possible! ejabberd breaks new ground in cross-platform communication, fostering a more interconnected messaging universe. We have still some ground to cover and for that we are waiting for your feedback.
– 🔐 Cutting-Edge Security with TLS 1.3 & SASL2 : In an era where security is paramount, ejabberd steps up its game. With support for TLS 1.3 and advanced SASL2 protocols, we increase the overall security for all platform users.
– 🚀 Performance Enhancements with Bind 2: Faster connection times, especially crucial for mobile network users, thanks to Bind 2 and other performance optimizations.
– 🔄 User gains better control over on their messages: The new support for XEP-0424 : Message Retraction allows users to manage their message history and remove something they posted by mistake.
– 🔧 Optimized server pings by relying on an existing mechanism coming from XEP-0198
– 📈 Streamlined API Versioning: Our refined API versioning means smoother, more flexible integration for your applications.
– 🧩 Enhanced Elixir, Mix and Rebar3 Support

If you upgrade ejabberd from a previous release, please review those changes:

• Update the SQL schema
• Update API commands as explained below, or use API versioning
• Mix or Rebar3 used by default instead of Rebar to compile ejabberd
• Authentication workaround for Converse.js and Strophe.js

A more detailed explanation of those topics and other features:

Matrix federation

ejabberd is now able to federate with Matrix servers. Detailed instructions to setup Matrix federation with ejabberd will be detailed in another post.

Here is a quick summary of the configuration steps:

First, s2s must be enabled on ejabberd. Then define a listener that uses mod_matrix_gw :

listen:
  -
    port: 8448
    module: ejabberd_http
    tls: true
    certfile: "/opt/ejabberd/conf/server.pem"
    request_handlers:
      "/_matrix": mod_matrix_gw

And add mod_matrix_gw in your modules:

modules:
  mod_matrix_gw:
    matrix_domain: "domain.com"
    key_name: "somename"
    key: "yourkeyinbase64"

Support TLS 1.3, Bind 2, SASL2

• RFC 9266 Channel Bindings for TLS 1.3 : This enhances security and reliability.
• XEP-0386: Bind 2 : This is going to reduce the connection time for clients. This is especially important if you are using XMPP to connect from a mobile network.
• XEP-0388: Extensible SASL Profile – SASL2
• XEP-0440: SASL Channel-Binding Type Capability : These updates are aimed at bolstering our authentication mechanisms.
• XEP-0474: SASL SCRAM Downgrade Protection

Support for XEP-0424 Message Retraction

With the new support for XEP-0424: Message Retraction , users of MAM message archiving can control their message archiving, with the ability to ask for deletion.

Support for XEP-0198 pings

If stream management is enabled, let mod_ping trigger XEP-0198 <r/>equests rather than sending XEP-0199 pings. This avoids the overhead of the ping IQ stanzas, which, if stream management is enabled, are accompanied by XEP-0198 elements anyway.

Update the SQL schema

The table archive has a text column named origin_id (see commit 975681 ). You have two methods to update the SQL schema of your existing database:

If using MySQL or PosgreSQL, you can enable the option update_sql_schema and ejabberd will take care to update the SQL schema when needed: add in your ejabberd configuration file the line update_sql_schema: true

If you are using other database, or prefer to update manually the SQL schema:

• MySQL default schema:

ALTER TABLE archive ADD COLUMN origin_id text NOT NULL DEFAULT '';
ALTER TABLE archive ALTER COLUMN origin_id DROP DEFAULT;
CREATE INDEX i_archive_username_origin_id USING BTREE ON archive(username(191), origin_id(191));

• MySQL new schema:

ALTER TABLE archive ADD COLUMN origin_id text NOT NULL DEFAULT '';
ALTER TABLE archive ALTER COLUMN origin_id DROP DEFAULT;
CREATE INDEX i_archive_sh_username_origin_id USING BTREE ON archive(server_host(191), username(191), origin_id(191))

• PostgreSQL default schema:

ALTER TABLE archive ADD COLUMN origin_id text NOT NULL DEFAULT '';
ALTER TABLE archive ALTER COLUMN origin_id DROP DEFAULT;
CREATE INDEX i_archive_username_origin_id ON archive USING btree (username, origin_id);

• PostgreSQL new schema:

ALTER TABLE archive ADD COLUMN origin_id text NOT NULL DEFAULT '';
ALTER TABLE archive ALTER COLUMN origin_id DROP DEFAULT;
CREATE INDEX i_archive_sh_username_origin_id ON archive USING btree (server_host, username, origin_id);

• MSSQL default schema:

ALTER TABLE [dbo].[archive] ADD [origin_id] VARCHAR (250) NOT NULL;
CREATE INDEX [archive_username_origin_id] ON [archive] (username, origin_id)
WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON);

• MSSQL new schema:

ALTER TABLE [dbo].[archive] ADD [origin_id] VARCHAR (250) NOT NULL;
CREATE INDEX [archive_sh_username_origin_id] ON [archive] (server_host, username, origin_id)
WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON);

• SQLite default schema:

ALTER TABLE archive ADD COLUMN origin_id text NOT NULL DEFAULT '';
CREATE INDEX i_archive_username_origin_id ON archive (username, origin_id);

• SQLite new schema:

ALTER TABLE archive ADD COLUMN origin_id text NOT NULL DEFAULT '';
CREATE INDEX i_archive_sh_username_origin_id ON archive (server_host, username, origin_id);

Authentication workaround for Converse.js and Strophe.js

This ejabberd release includes support for XEP-0474: SASL SCRAM Downgrade Protection , and some clients may not support it correctly yet.

If you are using Converse.js 10.1.6 or older, Movim 0.23 Kojima or older, or any other client based in Strophe.js v1.6.2 or older, you may notice that they cannot authenticate correctly to ejabberd.

To solve that problem, either update to newer versions of those programs (if they exist), or you can enable temporarily the option disable_sasl_scram_downgrade_protection in the ejabberd configuration file ejabberd.yml like this:

disable_sasl_scram_downgrade_protection: true

Support for API versioning

Until now, when a new ejabberd release changed some API command (an argument renamed, a result in a different format…), then you had to update your API client to the new API at the same time that you updated ejabberd.

Now the ejabberd API commands can have different versions, by default the most recent one is used, and the API client can specify the API version it supports.

In fact, this feature was implemented seven years ago , included in ejabberd 16.04 , documented in ejabberd Docs: API Versioning … but it was never actually used!

This ejabberd release includes many fixes to get API versioning up to date, and it starts being used by several commands.

Let’s say that ejabberd 23.10 implemented API version 0, and this ejabberd 24.02 adds API version 1. You may want to update your API client to use the new API version 1… or you can continue using API version 0 and delay API update a few weeks or months.

To continue using API version 0:
– if using ejabberdctl, use the switch --version 0 . For example: ejabberdctl --version 0 get_roster admin localhost
– if using mod_http_api, in ejabberd configuration file add v0 to the request_handlers path. For example: /api/v0: mod_http_api

Check the details in ejabberd Docs: API Versioning .

ejabberd commands API version 1

When you want to update your API client to support ejabberd API version 1, those are the changes to take into account:
– Commands with list arguments
– mod_http_api does not name integer and string results
– ejabberdctl with list arguments
– ejabberdctl list results

All those changes are described in the next sections.

Commands with list arguments

Several commands now use list argument instead of a string with separators (different commands used different separators: ; : \\n , ).

The commands improved in API version 1:
– add_rosteritem
– oauth_issue_token
– send_direct_invitation
– srg_create
– subscribe_room
– subscribe_room_many

For example, srg_create in API version 0 took as arguments:

{"group": "group3",
 "host": "myserver.com",
 "label": "Group3",
 "description": "Third group",
 "display": "group1\\ngroup2"}

now in API version 1 the command expects as arguments:

{"group": "group3",
 "host": "myserver.com",
 "label": "Group3",
 "description": "Third group",
 "display": ["group1", "group2"]}

mod_http_api not named results

There was an incoherence in mod_http_api results when they were integer/string and when they were list/tuple/rescode…: the result contained the name, for example:

$ curl -k -X POST -H "Content-type: application/json" -d '{}' "http://localhost:5280/api/get_loglevel/v0"
{"levelatom":"info"}

Staring in API version 1, when result is an integer or a string, it will not contain the result name. This is now coherent with the other result formats (list, tuple, …) which don’t contain the result name either.

Some examples with API version 0 and API version 1:

$ curl -k -X POST -H "Content-type: application/json" -d '{}' "http://localhost:5280/api/get_loglevel/v0"
{"levelatom":"info"}

$ curl -k -X POST -H "Content-type: application/json" -d '{}' "http://localhost:5280/api/get_loglevel"
"info"

$ curl -k -X POST -H "Content-type: application/json" -d '{"name": "registeredusers"}' "http://localhost:5280/api/stats/v0"
{"stat":2}

$ curl -k -X POST -H "Content-type: application/json" -d '{"name": "registeredusers"}' "http://localhost:5280/api/stats"
2

$ curl -k -X POST -H "Content-type: application/json" -d '{"host": "localhost"}' "http://localhost:5280/api/registered_users/v0"
["admin","user1"]

$ curl -k -X POST -H "Content-type: application/json" -d '{"host": "localhost"}' "http://localhost:5280/api/registered_users"
["admin","user1"]

ejabberdctl with list arguments

ejabberdctl now supports list and tuple arguments, like mod_http_api and ejabberd_xmlrpc. This allows ejabberdctl to execute all the existing commands, even some that were impossible until now like create_room_with_opts and set_vcard2_multi .

List elements are separated with , and tuple elements are separated with : .

Relevant commands:
– add_rosteritem
– create_room_with_opts
– oauth_issue_token
– send_direct_invitation
– set_vcard2_multi
– srg_create
– subscribe_room
– subscribe_room_many

Some example uses:

ejabberdctl add_rosteritem user1 localhost testuser7 localhost NickUser77l gr1,gr2,gr3 both
ejabberdctl create_room_with_opts room1 conference.localhost localhost public:false,persistent:true
ejabberdctl subscribe_room_many user1@localhost:User1,admin@localhost:Admin room1@conference.localhost urn:xmpp:mucsub:nodes:messages,u

ejabberdctl list results

Until now, ejabberdctl returned list elements separated with ; . Now in API version 1 list elements are separated with , .

For example, in ejabberd 23.10:

$ ejabberdctl get_roster admin localhost
jan@localhost jan   none    subscribe       group1;group2
tom@localhost tom   none    subscribe       group3

Since this ejabberd release, using API version 1:

$ ejabberdctl get_roster admin localhost
jan@localhost jan   none    subscribe       group1,group2
tom@localhost tom   none    subscribe       group3

it is still possible to get the results in the old syntax, using API version 0:

$ ejabberdctl --version 0 get_roster admin localhost
jan@localhost jan   none    subscribe       group1;group2
tom@localhost tom   none    subscribe       group3

ejabberdctl help improved

ejabberd supports around 200 administrative commands, and probably you consult them in the ejabberd Docs -> API Reference page, where all the commands documentation is perfectly displayed…

The ejabberdctl command-line script already allowed to consult the commands documentation, consulting in real-time your ejabberd server to show you exactly the commands that are available. But it lacked some details about the commands. That has been improved, and now ejabberdctl shows all the information, including arguments description, examples and version notes.

For example, the connected_users_vhost command documentation as seen in the ejabberd Docs site is equivalently visible using ejabberdctl :

$ ejabberdctl help connected_users_vhost
  Command Name: connected_users_vhost

  Arguments: host::binary : Server name

  Result: connected_users_vhost::[ sessions::string ]

  Example: ejabberdctl connected_users_vhost "myexample.com"
           user1@myserver.com/tka
           user2@localhost/tka

  Tags: session

  Module: mod_admin_extra

  Description: Get the list of established sessions in a vhost

Experimental support for Erlang/OTP 27

Erlang/OTP 27.0-rc1 was recently released, and ejabberd can be compiled with it. If you are developing or experimenting with ejabberd, it would be great if you can use Erlang/OTP 27 and report any problems you find. For production servers, it’s recommended to stick with Erlang/OTP 26.2 or any previous version.

In this sense, the rebar and rebar3 binaries included with ejabberd are also updated: now they support from Erlang 24 to Erlang 27. If you want to use older Erlang versions from 20 to 23, there are compatible binaries available in git: rebar from ejabberd 21.12 and rebar3 from ejabberd 21.12 .

Of course, if you have rebar or rebar3 already installed in your system, it’s preferable if you use those ones, because probably they will be perfectly compatible with whatever erlang version you have installed.

Installers and ejabberd container image

The binary installers now include the recent and stable Erlang/OTP 26.2.2 and Elixir 1.16.1. Many other dependencies were updated in the installers, the most notable is OpenSSL that has jumped to version 3.2.1.

The ejabberd container image and the ecs container image have gotten all those version updates, and also Alpine is updated to 3.19.

By the way, this container image already had support to run commands when the container starts … And now you can setup the commands to allow them fail, by prepending the character ! .

Summary of compilation methods

When compiling ejabberd from source code, you may have noticed there are a lot of possibilities. Let’s take an overview before digging in the new improvements:

• Tools to manage the dependencies and compilation:
  • Rebar : it is nowadays very obsolete, but still does the job of compiling ejabberd
  • Rebar3 : the successor of Rebar, with many improvements and plugins, supports hex.pm and Elixir compilation
  • Mix : included with the Elixir programming language , supports hex.pm, and erlang compilation
• Installation methods:
  • make install : copies the files to the system
  • make prod : prepares a self-contained OTP production release in _build/prod/ , and generates a tar.gz file. This was previously named make rel
  • make dev : prepares quickly an OTP development release in _build/dev/
  • make relive : prepares the barely minimum in _build/relive/ to run ejabberd and starts it
• Start scripts and alternatives:
  • ejabberdctl with erlang shell: start / foreground / live
  • ejabberdctl with elixir shell: iexlive
  • ejabberd console / start (this script is generated by rebar3 or mix, and does not support ejabberdctl configurable options)

For example:
– the CI dynamic tests use rebar3 , and Runtime tries to test all the possible combinations
– ejabberd binary installers are built using: mix + make prod
– container images are built using: mix + make prod too, and started with ejabberdctl foreground

Several combinations didn’t work correctly until now and have been fixed, for example:
– mix + make relive
– mix + make prod/dev + ejabberdctl iexlive
– mix + make install + ejabberdctl start/foregorund/live
– make uninstall buggy has an experimental alternative: make uninstall-rel
– rebar + make prod with Erlang 26

Use Mix or Rebar3 by default instead of Rebar to compile ejabberd

ejabberd uses Rebar to manage dependencies and compilation since ejabberd 13.10 4d8f770 . However, that tool is obsolete and unmaintained since years ago, because there is a complete replacement:

Rebar3 is supported by ejabberd since 20.12 0fc1aea . Among other benefits, this allows to download dependencies from hex.pm and cache them in your system instead of downloading them from git every time, and allows to compile Elixir files and Elixir dependencies.

In fact, ejabberd can be compiled using mix (a tool included with the Elixir programming language ) since ejabberd 15.04 ea8db99 (with improvements in ejabberd 21.07 4c5641a )

For those reasons, the tool selection performed by ./configure will now be:
– If --with-rebar=rebar3 but Rebar3 not found installed in the system, use the rebar3 binary included with ejabberd
– Use the program specified in option: --with-rebar=/path/to/bin
– If none is specified, use the system mix
– If Elixir not found, use the system rebar3
– If Rebar3 not found, use the rebar3 binary included with ejabberd

Removed Elixir support in Rebar

Support for Elixir 1.1 was added as a dependency in commit 01e1f67 to ejabberd 15.02 . This allowed to compile Elixir files. But since Elixir 1.4.5 (released Jun 22, 2017) it isn’t possible to get Elixir as a dependency… it’s nowadays a standalone program. For that reason, support to download old Elixir 1.4.4 as a dependency has been removed.

When Elixir support is required, better simply install Elixir and use mix as build tool:

./configure --with-rebar=mix

Or install Elixir and use the experimental Rebar3 support to compile Elixir files and dependencies:

./configure --with-rebar=rebar3 --enable-elixir

Added Elixir support in Rebar3

It is now possible to compile ejabberd using Rebar3 and support Elixir compilation. This compiles the Elixir files included in ejabberd’s lib/ path. There’s also support to get dependencies written in Elixir, and it’s possible to build OTP releases including Elixir support.

It is necessary to have Elixir installed in the system, and configure the compilation using --enable-elixir . For example:

apt-get install erlang erlang-dev elixir
git clone https://github.com/processone/ejabberd.git ejabberd
cd ejabberd
./autogen.sh
./configure --with-rebar=rebar3 --enable-elixir
make
make dev
_build/dev/rel/ejabberd/bin/ejabberdctl iexlive

Elixir versions supported

Elixir 1.10.3 is the minimum supported, but:
– Elixir 1.10.3 or higher is required to build an OTP release with make prod or make dev
– Elixir 1.11.4 or higher is required to build an OTP release if using Erlang/OTP 24 or higher
– Elixir 1.11.0 or higher is required to use make relive
– Elixir 1.13.4 with Erlang/OTP 23.0 are the lowest versions tested by Runtime

For all those reasons, if you want to use Elixir, it is highly recommended to use Elixir 1.13.4 or higher with Erlang/OTP 23.0 or higher.

make rel is renamed to make prod

When ejabberd started to use Rebar2 build tool, that tool could create an OTP release, and the target in Makefile.in was conveniently named make rel .

However, newer tools like Rebar3 and Elixir’s Mix support creating different types of releases: production, development, … In this sense, our make rel target is nowadays more properly named make prod .

For backwards compatibility, make rel redirects to make prod .

New make install-rel and make uninstall-rel

This is an alternative method to install ejabberd in the system, based in the OTP release process. It should produce exactly the same results than the existing make install .

The benefits of make install-rel over the existing method:
– this uses OTP release code from rebar/rebar3/mix, and consequently requires less code in our Makefile.in
– make uninstall-rel correctly deletes all the library files

This is still experimental, and it would be great if you are able to test it and report any problem; eventually this method could replace the existing one.

Just for curiosity:
– ejabberd 13.03-beta1 got support for make uninstall was added
– ejabberd 13.10 introduced Rebar build tool and code got more modular
– ejabberd 15.10 started to use the OTP directory structure for ‘make install’ , and this broke make uninstall

Acknowledgments

We would like to thank the contributions to the source code, documentation, and translation provided for this release by:

• Holger Weiß for the support XEP-0198 pings and XEP-0425 fixes
• Mr. EddX , updated the Bulgarian translation
• Sketch6580 , updated the Chinese translation
• Jan Aschenbrenner , updated the Czech translation
• Ranforingus , updated the Dutch translation
• Ermete Melchiorre , updated the Italian translation
• Mako N , updated the Japanese translation
• Silvério Santos , updated the Portuguese translation
• Олександр Кревський , updated the Ukrainian translation

And also to all the people contributing in the ejabberd chatroom, issue tracker…

Improvements in ejabberd Business Edition

Customers of the ejabberd Business Edition , in addition to all those improvements and bugfixes, also get:

Push

• Fix clock issue when signing Apple push JWT tokens
• Share Apple push JWT tokens between nodes in cluster
• Increase allowed certificates chain depth in GCM requests
• Use x:oob data as source for image delivered in pushes
• Process only https urls in oob as images in pushes
• Fix jid in disable push iq generated by GCM and Webhook service
• Add better logging for TooManyProviderTokenUpdated error
• Make get_push_logs command generate better error if mod_push_logger not available
• Add command get_push_logs that can be used to retrieve info about recent pushes and errors reported by push services
• Add support for webpush protocol for sending pushes to safari/chrome/firefox browsers

MAM

• Expand mod_mam_http_access API to also accept range of messages

MUC

• Update mod_muc_state_query to fix subject_author room state field
• Fix encoding of config xdata in mod_muc_state_query

PubSub

• Allow pubsub node owner to overwrite items published by other persons (p1db)

ChangeLog

This is a more detailed list of changes in this ejabberd release:

Core

• Added Matrix gateway in mod_matrix_gw
• Support SASL2 and Bind2
• Support tls-server-end-point channel binding and sasl2 codec
• Support tls-exporter channel binding
• Support XEP-0474: SASL SCRAM Downgrade Protection
• Fix presenting features and returning results of inline bind2 elements
• disable_sasl_scram_downgrade_protection : New option to disable XEP-0474
• negotiation_timeout : Increase default value from 30s to 2m
• mod_carboncopy: Teach how to interact with bind2 inline requests

Other

• ejabberdctl: Fix startup problem when having set EJABBERD_OPTS and logger options
• ejabberdctl: Set EJABBERD_OPTS back to "" , and use previous flags as example
• eldap: Change logic for eldap tls_verify=soft and false
• eldap: Don’t set fail_if_no_peer_cert for eldap ssl client connections
• Ignore hints when checking for chat states
• mod_mam: Support XEP-0424 Message Retraction
• mod_mam: Fix XEP-0425: Message Moderation with SQL storage
• mod_ping: Support XEP-0198 pings when stream management is enabled
• mod_pubsub: Normalize pubsub max_items node options on read
• mod_pubsub: PEP nodetree: Fix reversed logic in node fixup function
• mod_pubsub: Only care about PEP bookmarks options when creating node from scratch

SQL

• MySQL: Support sha256_password auth plugin
• ejabberd_sql_schema: Use the first unique index as a primary key
• Update SQL schema files for MAM’s XEP-0424
• New option sql_flags : right now only useful to enable mysql_alternative_upsert

Installers and Container

• Container: Add ability to ignore failures in execution of CTL_ON_* commands
• Container: Update to Erlang/OTP 26.2, Elixir 1.16.1 and Alpine 3.19
• Container: Update this custom ejabberdctl to match the main one
• make-binaries: Bump OpenSSL 3.2.1, Erlang/OTP 26.2.2, Elixir 1.16.1
• make-binaries: Bump many dependency versions

Commands API

• print_sql_schema : New command available in ejabberdctl command-line script
• ejabberdctl: Rework temporary node name generation
• ejabberdctl: Print argument description, examples and note in help
• ejabberdctl: Document exclusive ejabberdctl commands like all the others
• Commands: Add a new muc_sub tag to all the relevant commands
• Commands: Improve syntax of many commands documentation
• Commands: Use list arguments in many commands that used separators
• Commands: set_presence : switch priority argument from string to integer
• ejabberd_commands: Add the command API version as a tag vX
• ejabberd_ctl: Add support for list and tuple arguments
• ejabberd_xmlrpc: Fix support for restuple error response
• mod_http_api: When no specific API version is requested, use the latest

Compilation with Rebar3/Elixir/Mix

• Fix compilation with Erlang/OTP 27: don’t use the reserved word ‘maybe’
• configure: Fix explanation of --enable-group option ( #4135 )
• Add observer and runtime_tools in releases when --enable-tools
• Update “make translations” to reduce build requirements
• Use Luerl 1.0 for Erlang 20, 1.1.1 for 21-26, and temporary fork for 27
• Makefile: Add install-rel and uninstall-rel
• Makefile: Rename make rel to make prod
• Makefile: Update make edoc to use ExDoc, requires mix
• Makefile: No need to use escript to run rebar|rebar3|mix
• configure: If --with-rebar=rebar3 but rebar3 not system-installed, use local one
• configure: Use Mix or Rebar3 by default instead of Rebar2 to compile ejabberd
• ejabberdctl: Detect problem running iex or etop and show explanation
• Rebar3: Include Elixir files when making a release
• Rebar3: Workaround to fix protocol consolidation
• Rebar3: Add support to compile Elixir dependencies
• Rebar3: Compile explicitly our Elixir files when --enable-elixir
• Rebar3: Provide proper path to iex
• Rebar/Rebar3: Update binaries to work with Erlang/OTP 24-27
• Rebar/Rebar3: Remove Elixir as a rebar dependency
• Rebar3/Mix: If dev profile/environment, enable tools automatically
• Elixir: Fix compiling ejabberd as a dependency ( #4128 )
• Elixir: Fix ejabberdctl start/live when installed
• Elixir: Fix: FORMATTER ERROR: bad return value ( #4087 )
• Elixir: Fix: Couldn’t find file Elixir Hex API
• Mix: Enable stun by default when vars.config not found
• Mix: New option vars_config_path to set path to vars.config ( #4128 )
• Mix: Fix ejabberdctl iexlive problem locating iex in an OTP release

Full Changelog

https://github.com/processone/ejabberd/compare/23.10…24.02

ejabberd 24.02 download & feedback

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

The source package and installers are available in ejabberd Downloads page. To check the *.asc signature files, see How to verify ProcessOne downloads integrity .

For convenience, there are alternative download locations like the ejabberd DEB/RPM Packages Repository and the GitHub Release / Tags .

The ecs container image is available in docker.io/ejabberd/ecs and ghcr.io/processone/ecs . The alternative ejabberd container image is available in ghcr.io/processone/ejabberd .

If you consider that you’ve found a bug, please search or fill a bug report on GitHub Issues .

The post ejabberd 24.02 first appeared on ProcessOne .

What is Elixir: Exploring its Functional Programming Essence

In our latest post, we’ll be exploring Elixir, a robust programming language known for its concurrency and fault-tolerance capabilities. We’ll look at some of Elixir’s syntax, and core features, as well as the Elixir community some resources for beginners and enthusiasts alike.

The birth of Elixir

As the brainchild of José Valim, Elixir is rooted in Valim’s experiences with Ruby on Rails and Erlang. Elixir aimed to tackle the challenges of building scalable and fault-tolerant applications.

Harnessing the power of the Erlang Virtual Machine (VM), Elixir inherits its renowned traits of low latency, distributed computing, and fault tolerance. This foundation empowers developers to create robust systems capable of handling demanding workloads across diverse industries.

Erlang VM and Virtual Machine Process

Elixir’s versatility extends far beyond its roots. With its powerful tooling and ecosystem, Elixir facilitates productivity in various domains, including web development, embedded software, machine learning, data pipelines, and multimedia processing. Its flexibility and efficiency make it an ideal choice for tackling an array of challenges in today’s tech landscape.

Elixir and Erlang: A powerful duo

Elixir, a robust programming language, collaborates closely with Erlang, renowned for building fault-tolerant and distributed systems. Developed by Ericsson in the late 1980s, Erlang initially targeted telecommunications applications, prioritising reliability and uninterrupted service.

A key element driving the synergy between Elixir and Erlang is the BEAM, a virtual environment proficient in executing code written in both languages. Elixir, uniquely, is constructed directly atop the BEAM, inheriting its capacity for highly concurrent and fault-tolerant runtime operations. This integration fosters seamless interoperability between Elixir and Erlang applications, ensuring optimal performance and reliability

Elixir on BEAM

Elixir benefits significantly from Erlang’s robust framework, leveraging its scalability, fault tolerance, and distributed processing capabilities. This makes Elixir a preferred choice in industries where system uptime is paramount. Additionally, Elixir developers gain access to Erlang’s established ecosystem and libraries, simplifying the development of resilient and scalable systems.

It also introduces contemporary syntax and language features, enhancing developer productivity and code expressiveness. This modernisation, combined with Erlang’s robust runtime, empowers developers to navigate the complexities of today’s software landscape confidently, delivering efficient and reliable solutions.

Furthermore, Elixir introduces contemporary syntax and language features, enhancing developer productivity and code expressiveness. This modernisation, combined with Erlang’s robust runtime, empowers developers to navigate today’s complex software landscape with confidence, delivering efficient and reliable solutions.

Elixir and Erlang are a formidable duo, Complementing each other’s strengths to empower developers in crafting dependable, scalable, and fault-tolerant systems with ease and effectiveness.

Elixir’s syntax and language features

Elixir boasts a clean and expressive syntax inspired by Ruby, with a focus on developer productivity and readability. Its language features are designed to promote conciseness and clarity, making it an ideal choice for both beginners and experienced developers alike.

• Concurrency with Erlang processes: Elixir utilises lightweight Erlang processes for concurrency. These processes communicate via message passing, facilitating highly concurrent and fault-tolerant systems.

• Immutable data: Elixir promotes immutability, ensuring that once data is created, it cannot be changed. This simplifies code reasoning and mitigates unexpected side effects.

• Pattern matching : A core feature, pattern matching allows developers to destructure data and match it against predefined patterns, leading to concise and elegant code.

• Functions as first-class entities: Functions can be assigned to variables, passed as arguments, and returned from other functions, enabling powerful abstractions and composition.

• Metaprogramming with macros: Elixir offers metaprogramming capabilities through macros, empowering developers to generate and manipulate code at compile time. This facilitates the creation of domain-specific languages and powerful abstractions.

• Fault Tolerance via Supervision Trees: Elixir adopts Erlang’s “let it crash” philosophy, isolating processes and containing failures. Supervision trees structure and manage process supervision, ensuring robust fault tolerance.

• OTP for scalability and reliability: Elixir includes OTP, providing libraries and best practices for building scalable, fault-tolerant, and distributed systems. OTP features such as gen_servers and supervisors enhance system reliability.

• Comprehensive tooling and documentation: Elixir offers a rich set of tools for development, testing, and deployment. Mix, the build tool, manages dependencies and runs tests, while ExDoc simplifies documentation creation and maintenance.

Understanding functional programming in Elixir

In Elixir, functional programming prioritises pure functions, immutable data, and higher-order functions. It encourages writing code clearly and expressively, treating functions as primary elements that can be passed as arguments or returned as results.

Elixir’s functional programming paradigm supports the development of robust, scalable, and fault-tolerant systems, which makes it an excellent option for creating distributed and concurrent applications.

Robustness :

• Elixir’s functional approach reduces bugs and promotes code clarity.
• Problems are solved in smaller, testable units.

Scalability:

• Elixir’s lightweight processes enable easy concurrency.
• Systems can scale across multiple cores or nodes effortlessly.

Fault Tolerance:

• Elixir’s supervision tree ensures system resilience.
• Failures are isolated and managed, keeping the system running.

Concurrency:

• Elixir’s processes communicate asynchronously.
• Concurrent operations are efficient and responsive.

Distribution:

• Elixir applications can easily scale across multiple nodes.
• Distributed computing is simplified, enabling high availability.

Practical applications of Elixir

Elixir’s versatility and robust features make it a powerful language for developing a wide range of applications across different domains. From web development to distributed systems and embedded devices, Elixir’s concurrency, fault tolerance, and scalability enable developers to build resilient and efficient solutions. Here are some practical applications where Elixir shines:

Web development with Phoenix Framework

Phoenix, Elixir’s web framework, offers high-performance solutions for modern web apps. Leveraging Elixir’s concurrency and fault tolerance, Phoenix scales effortlessly to handle concurrent connections and real-time features.

Elixir Phoenix

Distributed systems and microservices

Elixir’s lightweight processes and distribution support make it ideal for distributed systems and microservices. Its fault-tolerant supervision trees ensure system reliability and scalability across multiple nodes.

Embedded systems and IoT

Elixir’s small footprint and low-latency performance suit embedded systems and IoT. With Nerves, developers can deploy Elixir to devices like Raspberry Pi, ensuring fault tolerance and resilience.

Real-time messaging and chat applications

Elixir’s concurrency and real-time support make it perfect for messaging apps. Libraries like Phoenix Channels enable scalable and fault-tolerant chat systems, handling numerous concurrent users seamlessly.

Financial and e-commerce systems

Elixir’s reliability and scalability are beneficial for financial and e-commerce platforms. Its fault-tolerant supervision ensures uninterrupted processing of transactions. Frameworks like Broadway facilitate scalable data processing for large transaction volumes.

What is Elixir used for: Real-world examples

Elixir, with its powerful features and versatile ecosystem, finds applications in a host of real-world scenarios across different industries:

Discord: Community-driven communication

Discord, serving over 150 million monthly active users, relies on Elixir for seamless voice and text chat experiences in gaming and educational communities.

Pinterest: Scalable backend services

Pinterest, with over 450 million monthly active users, employs Elixir for its backend services, handling millions of user interactions and content updates daily.

Deliveroo: Reliable food delivery services

Deliveroo, operating in over 800 cities globally, employs Elixir for its backend systems, ensuring reliable food delivery services for millions of customers worldwide.

Bleacher Report: Real-time sports updates

Bleacher Report delivers real-time sports updates and news to over 40 million monthly active users, leveraging Elixir for efficient data processing and content delivery.

PepsiCo: Supply chain optimisation

PepsiCo, one of the world’s largest food and beverage companies, uses Elixir to optimise its supply chain operations, ensuring efficient distribution of products across its global network.

Scalable web applications with Elixir

When you’re making mobile or web apps, scalability is key. If your app can’t handle more users, you might lose them. Plus, you could miss out on chances for growth.

Scalability also matters financially. If your app can’t grow smoothly, you’ll end up spending more on infrastructure. That’s where Elixir comes in. It’s a powerful language for building apps that can handle lots of users. Elixir is used in different areas such as gaming and e-commerce.

It’s like combining the best of OCaml and Haskel languages. With strong tools and a helpful community, Elixir is perfect for making apps that can grow with businesses.

Elixir’s ecosystem and community

Elixir’s success isn’t just attributed to its language features, but also to its vibrant ecosystem and supportive community. With a growing collection of libraries, tools, and resources, Elixir’s ecosystem continues to expand, making it easier for developers to build and maintain Elixir applications.

Tools and libraries enhancing Elixir development

Elixir boasts a rich ecosystem of libraries and tools that cover a wide range of functionalities, from web development and database integration to concurrency and distributed computing. The Phoenix web framework, for instance, provides a robust foundation for building scalable and real-time web applications, while Ecto offers a powerful database abstraction layer for interacting with databases in Elixir applications. Other notable libraries include Broadway for building concurrent and fault-tolerant data processing pipelines, and Nerves for developing embedded systems and IoT applications.

The growing community and learning resources

One of Elixir’s greatest strengths is its supportive and inclusive community. From online forums and chat rooms to local meetups and conferences, Elixir enthusiasts have numerous avenues to connect, learn, and collaborate with fellow developers.
The Elixir Forum and the Elixir Slack community are popular online hubs where developers can seek help, share knowledge, and discuss best practices.

Additionally, ElixirConf, the annual conference dedicated to Elixir and Erlang, provides a platform for developers to network, attend talks and workshops, and stay up-to-date with the latest developments in the Elixir ecosystem.

Conclusion

Elixir’s unique blend of concurrency, fault tolerance, and scalability makes it a powerful language for modern application development. Its clean syntax and functional programming principles enhance developer productivity and code maintainability.

Looking ahead, Elixir’s future in software development is promising. With the growing demand for distributed systems and data-intensive applications, Elixir’s strengths position it well for continued growth and innovation.

Supported by an active community and ongoing contributions, Elixir is set to play a significant role in shaping the future of software development. Whether you’re a seasoned developer or new to Elixir, its potential is boundless in the dynamic landscape of software engineering.

Further reading and resources

Books on Elixir

• “ Programming Elixir” by Dave Thomas : This book offers a comprehensive introduction to Elixir, covering its syntax, features, and best practices for building robust applications.
• “Elixir in Action” by Saša Jurić: A practical guide to Elixir programming, covering topics such as concurrency, distributed computing, and building scalable applications.
• “The Little Elixir & OTP Guidebook” by Benjamin Tan Wei Hao: This book provides a gentle introduction to Elixir’s concurrency model and the OTP framework, essential for building fault-tolerant and distributed systems.

Online Tutorials on Elixir

• Elixir School: A free online resource offering interactive lessons and tutorials on Elixir programming, suitable for beginners and experienced developers alike.

The Complete Elixir and Phoenix Bootcamp

Master Functional Programming techniques with Elixir and Phoenix while learning to build compelling web applications!

Community forums and support for Elixir learners

• Elixir Forum : A vibrant online community for Elixir enthusiasts to ask questions, share knowledge, and discuss topics related to Elixir programming and ecosystem.
• Elixir Slack Community: (https://elixir-slackin.herokuapp.com/): Join the Elixir Slack community to connect with fellow developers, ask for help, and engage in discussions on all things Elixir.
• Reddit r/elixir: The Elixir subreddit is a place to share news, articles, and questions about the Elixir programming language and ecosystem.

These resources provide a solid foundation for learning the Elixir programming language and engaging with the vibrant Elixir community. Whether you’re just starting your journey with Elixir or looking to deepen your knowledge, these books, tutorials, and forums offer valuable insights and support along the way.

The post What is Elixir? appeared first on Erlang Solutions .

In this article, we’ll explain why learning Elixir is an ideal way to advance your growth as a developer in 2024. What factors should you consider when deciding to learn a new programming language?

Well, it typically depends on your project or career goals. Ideally, you’d want a language that:

• Is enjoyable and straightforward to use
• Can meet the needs of modern users
• Can offer promising career prospects
• Has an active and supportive community
• Provides a range of useful tools
• Supports full-stack development through frameworks
• Offers easily accessible documentation
• Helps you grow as a programmer

This article will explore how Elixir stacks up against these criteria.

Elixir is fun and easy to use

Elixir is fun and very user-friendly, which is an important long-term consideration. Its syntax bears a striking resemblance to Ruby. It’s clean and intuitive, making coding simple.

When it comes to concepts like pattern matching and immutable data, they become your trusted allies and simplify your work. You’re also surrounded by a supportive and vibrant community, so you’re never alone in your journey. Whether you’re building web apps, handling real-time tasks, or just experimenting, Elixir makes programming enjoyable and straightforward, without any unnecessary complexity.

How Elixir can meet modern usage demands

Elixir’s strength in handling massive spikes in user traffic is unparalleled, thanks to its foundation on the BEAM VM, designed explicitly for concurrency.

BEAM Scheduler

While digital transformation brings about increased pressure on systems to accommodate billions of concurrent users, Elixir stands out as a reliable solution. For those curious about concurrency and its workings, our blog compares the JVM and BEAM VM, offering insightful explanations.

Major players like Pinterest and Bleacher Report have recognised the scalability benefits of Elixir, with Bleacher Report , for instance, reducing its server count from 150 to just 5.

This not only streamlines infrastructure but also enhances performance, allowing them to manage higher traffic volumes with faster response times. The appeal of a language that delivers scalability and fault tolerance is great for navigating the demands of today’s digital landscape.

Elixir’s rewarding career progression

Embarking on a career in Elixir programming promises an exciting journey filled with learning and progress. As the demand for its developers rises, opportunities for growth blossom across various industries. Mastering Elixir’s unique mix of functional programming and concurrency equips developers with sought-after skills applicable to a wide range of projects, from building websites to crafting complex systems. Plus, with more and more companies, big and small, embracing the programming language. As developers dive deeper into Elixir and gain hands-on experience, they pave the way for a rewarding career path filled with growth and success.

When Elixir first emerged, its community was small, as expected with any new technology. But now, it’s thriving! Exciting events like ElixirConf in Europe and the US, EMPEX, Code Elixir LDN, Gig City Elixir, and Meetups worldwide contribute to this vibrant community.

This growth means the language is always evolving with new tools, and there’s always someone ready to offer inspiration or a helping hand when tackling a problem.

Elixir’s range of useful tooling

Tooling makes languages more versatile and tasks easier, saving you from reinventing the wheel each time you tackle a new problem. Elixir comes equipped with a range of robust tools:

• Phoenix LiveView : Enables developers to build real-time, front-end web applications without JavaScript.
• Crawly : Simplifies web crawling and data scraping tasks in Elixir.
• Ecto : A database wrapper and query generator for Elixir, designed for building composable queries and interacting with databases.
• ExUnit : Elixir’s built-in testing framework provides a clean syntax for writing tests and running them in parallel for efficient testing.
• Mix : Elixir’s build tool, which automates tasks such as compiling code, managing dependencies, and running tests.
• Dialyzer : A static analysis tool for identifying type discrepancies and errors in Erlang and Elixir code, helping to catch bugs early in the development process.
• ExDoc : A documentation generator for Elixir projects, which generates HTML documentation from code comments and annotations, making it easy to create and maintain project documentation.

Elixir frameworks allow for full-stack development

Given its scalability performance and its origins in Erlang, it is no surprise that Elixir is a popular backend choice. As mentioned above, Phoenix LiveView has provided an easy, time-efficient and elegant way for Elixir developers to produce front-end applications.
Also, the Nerves framework allows for embedded software development on the hardware end. As a result, this is a language that can be adopted throughout the tech stack. This doesn’t just make it an attractive choice for businesses; it also opens up the door for where the language can take you as a developer.

Elixir’s easily accessible documentation

In a community that values good documentation, sharing what you know is easy. Elixir is all about that – they take their docs seriously, which makes learning the language easy. And it isn’t just about learning – everyone can jump in and help make those docs even better. It’s like a big conversation where everyone’s invited to share and improve together.

Learning Elixir can make you a better programmer in other languages

Many developers transitioning from object-oriented languages have shared their experiences of how learning Elixir has enhanced their programming skills in their main languages. When you dive into a new purely functional programming style like Elixir, it makes you rethink how you code. It’s like shining a light on your programming habits and opening your mind to fresh ways of solving problems. This newfound perspective sticks with you, no matter what language you’re coding in next. And if you’re a Ruby fan– Elixir’s syntax feels like home, making the switch to functional, concurrent programming super smooth.

While everyone has their reasons for picking a programming language, these are some pretty solid reasons to give Elixir a try in 2024 and beyond.

Ready to get started in Elixir?

Getting started is simple.

Begin by visiting the official “Getting Started” page. Additionally, you’ll find a host of free downloadable packages from our team at Erlang Solutions, available for Elixir.

To immerse yourself in the community, ElixirForum is an excellent starting point. You can also explore discussions using the #Elixirlang and #MyElixirStatus hashtags on Twitter.

Curious to learn more about what we do with the Elixir language? Keep exploring!

The post Why Elixir is the Programming Language You Should Learn in 2024 appeared first on Erlang Solutions .