The Ignite Realtime community is pleased to announce the release of Openfire 4.8.3. This release contains an important fix for thread lock situation described with OF-2845 . If you have noticed clients getting logged out or unable to connect with Openfire 4.8.1 or 4.8.2, please do try this release and report in the community forums if your issue is persisting.

The changelog denotes a few other issues addressed with this release. You can find download artifacts available with the following sha256sum values.

b86bf8c01ede9cb2ae4f43dfd2f49239d9af2d73f650c7c2d52e5a936035e520  openfire-4.8.3-1.noarch.rpm
3f6da6c89ce701d974f6a1afe5ac0245f7112c5d165934eb1a85a749a1f040e2  openfire_4.8.3_all.deb
4fce60210033216556881fd9c988bea3ce30c0ed845f4dec3d4284ee835e8208  openfire_4_8_3.dmg
28b64c144001b0f6fb6eb4705d0bb1a92581774369378196182b8d35237b83be  openfire_4_8_3.exe
43d3b042357a5c975785f3f223490e3dd18b1f499c206be6cd0857172cc005fc  openfire_4_8_3.tar.gz
a09752fbe1226724d466028036fc65d31fe88e60a0efb27a87f1e10ab100fbb1  openfire_4_8_3_x64.exe
5c0638f150ccb61471b4b5152743b6d18cbe008473f454ed0091a13d7b80cb85  openfire_4_8_3.zip

For those of you curious, here are the 4.8.2 artifact download statistics (released 8 days ago)

Thanks for your interest and usage of Openfire.

For other release announcements and news follow us on Mastodon or X

1 post - 1 participant

Read full topic

I will comment on an interesting article from Meredith Whittaker and Joshua Lund breaking down the cost of running a large-scale messaging platform.

It estimates that the cost to operate Signal messaging will reach 50 million dollars per year in 2025.

Privacy is Priceless, but Signal is Expensive

As of the end of 2023, the cost breakdown for running a large messaging platform like Signal was as follows:

• Storage: $1.3 million per year (9.3%). It is interesting to note that Signal does not store message history on the server. Message history is stored on the client.
• Servers: $2.9 million per year (20.7%). Cost of cloud servers to support the messaging service.
• Registration Fees: $6 million per year (42.9%). This is the cost required to validate phone numbers and perform other validations.
• Total Bandwidth: $2.8 million per year (20.0%).
• Additional Services: $700,000 per year (5.0%). Uptime monitoring, outage alerts, redundant capacity for disaster recovery purposes, maintenance contracts, etc.

Infrastructure Costs (as of November 2023): Approximately $14 million per year, to support between 40 and 50 million monthly active users.

And this is just for the infrastructure costs ! You need to add all the associated costs to operate an organization employing more than 50 people.

This article is interesting on several accounts:

• If you want to run a messaging platform at scale, we can help you with that, but be sure to properly assess your operating costs as well. Ensure your ambition aligns with your business model.
• This also shows the impact of the centralized approach vs a federated model . With a centralized model, the organization running the platform has to assume all the costs for operating the platform. In a federated model like XMPP, the costs can be split across the whole network.

The technical design of a messaging service significantly impacts the operational costs of the platform. Therefore, it’s crucial to make business model and technical choices simultaneously and be flexible to adapt to platform growth, as they are two sides of the same coin. Aligning these decisions ensures that both financial sustainability and technical feasibility are achieved.

The post Breaking Down the Costs of Large Messaging Services first appeared on ProcessOne .

We’re in the midst of some rapid technological changes (AI, IoT, machine learning etc) and businesses are facing new obstacles. There is now a demand to balance company time and budgets amid all day-to-day responsibilities. Because of this, outsourcing services have become a strategic move for many.

Let’s look into how Erlang and Elixir programming languages help with business outsourcing. We’ll discuss their expertise in security, scalability and flexibility and how they support business goals.

Understanding the importance of outsourcing

Before we get into its benefits, it’s important to understand the growing importance of outsourcing tech for businesses. Gartner describes outsourcing as a way to “deliver IT-enabled processes, application services, and infrastructure solutions for business outcomes.”

According to the global Business Process Outsourcing (BPO) market, outsourcing reached $280.64bn in 2023 and is projected to grow 9.6% from 2024 to 2030.

This rise is driven by digital transformation, a focus on cost optimisation, and the increasing demand for specialised services. Companies are focusing more on efficiency and agility for long-term success. Outsourcing provides that much-needed flexibility. They are able to leverage top-tier expertise, without the need for full-time in-house commitment.

Improved compliance and security

All businesses have sensitive data. To manage this, it must be understood that compliance and security go hand in hand. Compliance is all about adhering to standards and regulations within a given sector. These sectors are external laws (regulatory compliance) and internal policies (corporate compliance). Some of the most common include:

External laws:

• General Data Protection Regulation (GDPR) – European Union regulation.
• Payment Card Industry Data Security Standard (PCI DSS) – Global standards for credit card information.
• Health Insurance Portability and Accountability Act (HIPAA) – U.S. law for health data privacy and security.
• Sarbanes-Oxley Act (SOX) – U.S. law for financial reporting and auditing standards for public companies.
• California Consumer Privacy Act (CCPA ) – California state law, improving consumer privacy rights.
• Personal Information Protection Law (PIPL) – Chinese law, regulating the protection of personal information.

Internal policies:

• Data Security Policies – Guidelines to secure sensitive information within organisations.
• IT Security Standards – Standards for maintaining the security of IT systems and networks.
• Access Control Policies – Policies to define access rights to data and systems, based on roles and responsibilities.
• Data Retention and Disposal Policies – Rules that govern the retention and secure disposal of data.
• Incident Response Plans – Procedures for responding to and mitigating data breaches or security incidents.

These are all designed to safeguard organisational data and systems from breaches and misuse.

Leveraging functional programming for enhanced security

An important benefit of Erlang and Elixir and functional languages lies in their flexibility. They focus on code clarity and predictability, which is important for providing enhanced security. So even if your business is operating on the most complex of systems, both languages allow for clear and easy testing. This allows developers to identify and rectify any system vulnerabilities effectively.

Another feature of a functional programming language is immutability, meaning it cannot change once created. For businesses, it ensures that data integrity is maintained, preventing any unauthorised changes to the system.

Encryption support

Both languages excel in handling concurrent connections and processes. This is crucial for environments where multiple devices are needed to communicate simultaneously, without performance bottlenecks.

Erlang and Elixir are equipped with powerful libraries that support industry-standard encryption protocols. It allows developers to implement strong encryption mechanisms quickly and effectively. This safeguards precious business data against unauthorised access and breaches.

Their strengths collectively ensure that business devices can communicate securely and reliably. Business data is supported and protected without compromise. To learn more about encryption support, take a look at our five tips to ensure business security .

Cost management

According to Deloitte , the top reason (70%) for business outsourcing is cost reduction. Outsourcing ensures that you are only paying for the services you need when you need them, leading to cost management and savings.

Businesses are paying external providers to:

• Maintain their systems and carry out required tasks
• Save them money on upfront costs – especially when starting a new business or project.
• Advise on the most cost-effective systems and configure their systems to better suit your needs.

Concerns over training expenses, workspaces, and further equipment are also alleviated, as your team already has the necessary resources to maintain your systems.

Cost-effectiveness in Elixir

Elixir’s expressive syntax and the high developer productivity of Phoenix and LiveView can deliver more with less code, in less time, and with smaller teams. Its modern language features, such as pattern matching and powerful metaprogramming capabilities, enhance developer efficiency and reduce the complexity of codebases. The concurrency model inherited from Erlang allows for efficient handling of many simultaneous tasks, which can lead to cost savings on infrastructure. Also, its vibrant community and extensive libraries allow for rapid development and quick problem-solving. This is another great pro for businesses as it further reduces development time and associated costs.

Cost-effectiveness in Erlang

Erlang’s lightweight process model allows developers to handle numerous simultaneous operations with minimal resource consumption. This leads to significant infrastructure cost savings.

The language’s robust error-handling capabilities and “let it crash” philosophy simplify the development of reliable, self-healing systems, reducing the need for extensive debugging and maintenance efforts. Erlang’s mature ecosystem and extensive libraries also enable developers to quickly implement complex features, decreasing development time and allowing smaller teams to achieve more with less. This overall efficiency translates into lower long-term operational and development costs for businesses.

Specialised Erlang and Elixir expertise

Businesses that outsource their tech stack get value for money in expertise. Outsourcing provides a range of skills and knowledge of a dedicated team.

Expertise is one of the largest benefits of outsourcing your Erlang and Elixir. Erlang in particular has been around for over two decades, so businesses have the added benefit of known reliability and an established reputation.

The rise of Elixir in the programming language space has been impressive, to say the least. It leverages the strengths of the Erlang Virtual Machine (BEAM). So while it hasn’t been around for as long as Erlang, it has inherited the same fault-tolerant, concurrent and distributed computing capabilities.

The expertise of developers alleviates dealing with complex technical issues, resulting in improved operational efficiency, cost savings, and a stronger competitive edge in the market.

Focus on core business activities

Businesses outsource to concentrate on their competencies and strategic initiatives. They are reducing time-consuming tasks, which allows their internal teams to focus on core business activities.

This enhanced focus can lead to higher productivity, improved quality, and scope for accelerated innovation.

Erlang and Elixir support

Here are just some examples of how Erlang and Elixir support business focus:

Scalability and performance

Both languages are designed to handle levels of concurrency with ease. This allows businesses to seamlessly build and maintain applications, in line with increasing demand. It frees up time to focus on growth instead of worrying about the limitations of infrastructure.

For more on the benefits of scalability, you can check out our post on scalable systems.

Fault tolerance

Erlang and Elixir have built-in features for fault tolerance, such as supervision trees and isolated processes. This allows applications built within either language to recover almost from failures. It reduces downtime and allows businesses to run smoothly without manual intervention.

Model of a supervision tree

Rapid development

Elixir in particular shines in this department. Leveraging its productivity on Erlang’s underlying BEAM virtual machine, it provides a much more readable syntax and metaprogramming, allowing for faster development cycles which in turn, enables a faster time to market.

Maintainable code

We have already touched on the functional nature of both Erlang and Elixir. It encourages clear, modular, and maintainable code. This allows businesses to easily update and extend their applications, reducing the risk of bugs and improving the overall long-term maintainability.

Making a case for outsourcing

We’ve shown how utilising Erlang and Elixir can provide a host of strategic advantages for businesses. These languages provide expertise, enhanced security, cost-effective solutions, and scalability that allow businesses to offload day-to-day activities to concentrate on the bigger picture. If you’d like to learn more about how to make the most of your existing Erlang and Elixir tech stack, feel free to drop the team a line .

The post The Strategic Advantage of Outsourcing with Erlang and Elixir appeared first on Erlang Solutions .

Openfire 4.8.2 has landed!

This release addresses a number of issues in the real time collaboration server created by the Ignite Realtime Community that aim to reduce bugs and increase stability and performance.

Interested in getting started? You can download installers of Openfire here . Our documentation contains an upgrade guide that helps you update from an older version.

sha256sum checksum values for the release artifacts are as follows

4c2674fbf00768cf7ca9ccc9a6ef7e4aa693c19d9885ca469771677934634a40  openfire-4.8.2-1.noarch.rpm
76665dc80607516d12f1c8b7b323417e7993d2f87de2e82deeef43dd6a7d9761  openfire_4.8.2_all.deb
75c513db3c7e50fc5c28a7131aecc0c60ad2f858d7f04a9fe5d58a5de118afec  openfire_4_8_2.dmg
d5af1c2012d092c7c1cd9247db4e4d8039f2617adc9f212d75e549eeca0a389a  openfire_4_8_2.exe
4634e5be6314a5348e5e01413864a8ec6a7b3bbe6e2db1c051512c9bd72a199a  openfire_4_8_2.tar.gz
82c5abdf917b8958311f5813960f3b545266d99d0f646eac9dddbaf0ef52c905  openfire_4_8_2_x64.exe
3327bc610af606a2df28a7077f225a68cf2d04d30a4c37592a5d17f5c22e8c07  openfire_4_8_2.zip

If you have any questions, please stop by our community forum or our live groupchat . We are always looking for volunteers interested in helping out with Openfire development!

For other release announcements and news follow us on Mastodon or X .

1 post - 1 participant

Read full topic

Introducing ejabberd 24.06: Deep Work Release!

This new ejabberd 24.06 includes four months of work, close to 200 commits, including several minor improvements in the core ejabberd, and a lot of improvements in the administrative parts of ejabberd, like the WebAdmin and new API commands.

Brief summary

• Webadmin rework
• Improved documentation
• Architecture and API improvements

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

• SQL Schema Changes
• Commands Changed in API v2
• WebAdmin Hook Changes

A more detailed explanation of those topics and other features:

Support for Erlang/OTP 27 and Elixir 1.17

ejabberd support for Erlang/OTP 27.0 has been improved. In this sense, when using Erlang/OTP 27, the jiffy dependency is not needed, as an equivalent feature is already included in OTP.

The lowest supported Erlang/OTP version continues being 20.0, and the recommendation is using 26.3, which is in fact the one included in the binary installers and container images.

Regarding Elixir, the new 1.17 works correctly. The lowest Elixir supported version is 1.10.3… but in order to benefit from all the ejabberd features, it is highly recommended to use Elixir 1.13.4 or higher with Erlang/OTP 23.0 or higher.

SQL schema changes

There are no changes in the SQL schemas in this release.

Notice that ejabberd can take care to update your MySQL, PostgreSQL and SQLite database schema if you enable the update_sql_schema toplevel option.

That feature was introduced for beta-testing in ejabberd 23.10 and announced in the blog post Automatic schema update in ejabberd .

Starting in this ejabberd 24.06, the update_sql_schema feature is considered stable and the option is enabled by default!

UNIX Socket Domain

The sql_server top-level option now accepts the path to a unix socket domain, expressed as "unix:/path/to/socket" , as long as you are using mysql or pgsql in the option sql_type .

Commands changed in API v2

This ejabberd 24.06 release introduces ejabberd Commands API v2. You can continue using API v1; or if you want to update your API client to use APIv2, those are the commands that changed and you may need to update in your client:

Support for banning an account has been improved in API v2:
– ban_account stores the ban information in the account XML private storage, so that command requires mod_private to be enabled
– get_ban_details shows information about the account banning, if any.
– unban_account performs the reverse operation, getting the account to its previous status.

The result value of those two commands was modified to allow their usage in WebAdmin:
– kick_user instead of returning an integer, it returns a restuple.
– rooms_empty_destroy instead of returning a list of rooms that were destroyed, it returns a restuple .

As a side note, this command has been improved, but this change doesn’t affect the API:
– join_cluster has been improved to work not only with the ejabberdctl command line script, but also with any other command frontend ( mod_http_api , ejabberd_xmlrpc , ejabberd_web_admin , …).

New commands

Several new commands have been added, specially useful to generate WebAdmin pages:

• get_roster_count
• get_master
• list_cluster_detailed
• srg_add
• srg_add_displayed
• srg_del_displayed
• srg_get_displayed
• srg_set_info
• join_cluster_here

Improved WebAdmin with commands usage

ejabberd already has around 200 commands to perform many administrative tasks, both to get information about the server and its status, and also to perform operations with side-effects. Those commands have its input and output parameters clearly described, and also documented.

This release includes a set of functions ( make_command/2 and /4 , make_command_raw_value/3 , make_table/2 and /4 ) to use all those commands to generate HTML content in the ejabberd WebAdmin: instead of writing again erlang code to perform those operations and then write code to format it and display as HTML… let’s have some frontend functions to call the command and generate the HTML content. With that new feature, writing content for WebAdmin is much easier if a command for that task already exists.

In this sense, most of the ejabberd WebAdmin pages have been rewritten to use the new make_command feature, many new pages are added using the existing commands. Also a few commands and pages are added to manage Shared Roster Groups.

WebAdmin commands permissions configuration

Most WebAdmin pages use commands to generate the content, and access to those commands can be restricted using the api_permissions toplevel option .

The default ejabberd.yml configuration file already defines "admin access" that allows access from loopback IP address and accounts in the admin ACL to execute all commands except stop and start . So, no changes are required in the default configuration file to use the upgrade WebAdmin pages.

Now ejabberd_web_admin is another valid command frontend that can be specified in the from section. You can define fine-grained restrictions for accounts in WebAdmin, for example:

api_permissions:
  "webadmin commands":
    from:
      - ejabberd_web_admin
    who: admin
    what:
      - "*"
      - "![tag:oauth]"

WebAdmin hook changes

There are several changes in WebAdmin hooks that now provide the whole HTTP request instead of only some of its elements.

You can update your code easily, see:

• webadmin_page_node : instead of Path, Query and Lang, gets Request

  -webadmin_page_node(Acc, Node, Path, Query, Lang) ->
  +webadmin_page_node(Acc, Node, #request{path = Path, q = Query, lang = Lang}) ->
  

• webadmin_page_hostnode : instead of Path, Query and Lang gets Request

  -webadmin_page_hostnode(Acc, Host, Node, Path, Query, Lang) ->
  +webadmin_page_hostnode(Acc, Host, Node, #request{path = Path, q = Query, lang = Lang}) ->
  

• webadmin_user : instead of just the Lang, gets the whole Request

  -webadmin_user(Acc, User, Server, Lang) ->
  +webadmin_user(Acc, User, Server, #request{lang = Lang}) ->
  

• webadmin_menu_hostuser : new hook added:

  +webadmin_menu_hostuser(Acc, Host, Username, Lang) ->
  

• webadmin_page_hostuser : new hook added:

  +webadmin_page_hostuser(Acc, Host, Username, Request) ->
  

internal command tag and any argument/result

During the development of the WebAdmin commands feature, it was noticed the necessity to define some commands that will be used by WebAdmin (or maybe also by other ejabberd code), but should NOT be accessed by command frontends (like ejabberdctl , mod_http_api , ejabberd_xmlrpc ).

Such commands are identified because they have the internal tag.

Those commands can use any arbitrarily-formatted arguments/results, defined as any in the command.

Experimental make format and indent

If you use Emacs with erlang-mode , Vim with some Erlang indenter, VSCode, … they indent erlang code more or less similarly, but sometimes have some minor differences.

The new make format uses https://github.com/AdRoll/rebar3_format to format and indent files, with those restrictions:

• Only formats a file if it contains a line with this string, and formats only starting in that line:

  %% @format-begin
  

• Formatting can be disabled later in the file by adding another line that contains

  %% @format-end
  

• Furthermore, it is later possible to enable formatting again in the same file, in case there is another piece of the file that should be automatically formatted.

Alternatively, it is possible to indent files using Emacs, it also replaces tabs with blankspaces and removes ending spaces. The new make indent indents the lines between:

%% @indent-begin
...
%% @indent-end

New MUC room logging hooks

mod_muc_room now uses hooks instead of function calls to mod_muc_log , see #4191 .

The new hooks available, in case you want to write an ejabberd module that logs MUC room messages:

• muc_log_check_access_log(Acc, Host, From)
• muc_log_get_url(Acc, StateData)
• muc_log_add(Host, Type, Data, RoomJid, Opts)

Support for code automatic update

When running ejabberd in an interactive development shell started using relive , it automatically compiles and reloads the source code when you modify a source code file.

How to use this:

• Compile ejabberd with Rebar3 (or Mix)
• Start ejabberd with make relive
• Edit some ejabberd source code file and save it
• Sync (or ExSync ) will compile and reload it automatically

Rebar3 notes:

• To ensure Sync doesn’t act on dependencies that would produce many garbage log lines, the src_dirs option is used. However, now it only works if the parent directory is named “ejabberd”

• Sync requires at least Erlang/OTP 21, which introduced the new try-catch syntax to retrieve the stacktrace https://www.erlang.org/patches/otp-21.0

Mix note:

• ExSync depends on FileSystem library, which requires inotify-tools, see https://github.com/falood/file_system#system-support

ejabberd Docs now using MkDocs

Several changes in ejabberd source code were done to produce markdown suitable for the new ejabberd Docs site, as announced two months ago: ejabberd Docs now using MkDocs

Acknowledgments

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

• Holger Weiß for several bugfixes
• Sketch6580 , updated the Chinese translation
• Nautilusx , updated the German translation
• Wojciech Teichert , updated the Polish 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:

Pushy.me

• Add support for the Pushy.me notification service for Mobile App

Android Push

• Add support for the new FCMv1 API for Android Push
• Improve errors reporting for wrong options in mod_gcm

Apple Push

• Update support for Apple Push API
• Add support for p12 certificate in mod_applepush
• Add tls_verify option to mod_applepush
• Improve errors reporting for wrong options in mod_applepush

Webpush

• Properly initialize subject in Webpush

Push

• Add new API commands setup_push , get_push_setup and delete_push_setup for managing push setup, with support for Apple Push, Android Push, Pushy.me and Webpush/Webhook

ChangeLog

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

Core

• econf : Add ability to use additional custom errors when parsing options
• ejabberd_logger : Reloading configuration will update logger settings
• gen_mod : Add support to specify a hook global, not vhost-specific
• mod_configure : Retract Get User Password command to update XEP-0133 1.3.0
• mod_conversejs : Simplify support for @HOST@ in default_domain option ( #4167 )
• mod_mam : Document that XEP-0441 is implemented as well
• mod_mam : Update support for XEP-0425 version 0.3.0, keep supporting 0.2.1 ( #4193 )
• mod_matrix_gw : Fix support for @HOST@ in matrix_domain option ( #4167 )
• mod_muc_log : Hide join/leave lines, add method to show them
• mod_muc_log : Support allowpm introduced in 2bd61ab
• mod_muc_room : Use ejabberd hooks instead of function calls to mod_muc_log ( #4191 )
• mod_private : Cope with bookmark decoding errors
• mod_vcard_xupdate : Send hash after avatar get set for first time
• prosody2ejabberd : Handle the approved attribute. As feature isn’t implemented, discard it ( #4188 )

SQL

• update_sql_schema : Enable this option by default
• CI: Don’t load database schema files for mysql and pgsql
• Support Unix Domain Socket with updated p1_pgsql and p1_mysql ( #3716 )
• Fix handling of mqtt_pub table definition from mysql.sql and fix should_update_schema/1 in ejabberd_sql_schema.erl
• Don’t start sql connection pools for unknown hosts
• Add update_primary_key command to sql schema updater
• Fix crash running export2sql when MAM enabled but MUC disabled
• Improve detection of types in odbc

Commands API

• New ban commands use private storage to keep ban information ( #4201 )
• join_cluster_here : New command to join a remote node into our local cluster
• Don’t name integer and string results in API examples ( #4198 )
• get_user_subscriptions : Fix validation of user field in that command
• mod_admin_extra : Handle case when mod_private is not enabled ( #4201 )
• mod_muc_admin : Improve validation of arguments in several commands

Compile

• ejabberdctl : Comment ERTS_VSN variable when not used ( #4194 )
• ejabberdctl : Fix iexlive after make prod when using Elixir
• ejabberdctl : If INET_DIST_INTERFACE is IPv6, set required option ( #4189 )
• ejabberdctl : Make native dynamic node names work when using fully qualified domain names
• rebar.config.script : Support relaxed dependency version ( #4192 )
• rebar.config : Update deps version to rebar3’s relaxed versioning
• rebar.lock : Track file, now that rebar3 uses loose dependency versioning
• configure.ac : When using rebar3, unlock dependencies that are disabled ( #4212 )
• configure.ac : When using rebar3 with old Erlang, unlock some dependencies ( #4213 )
• mix:exs : Move xmpp from included_applications to applications

Dependencies

• Base64url: Use only when using rebar2 and Erlang lower than 24
• Idna: Bump from 6.0.0 to 6.1.1
• Jiffy: Use Json module when Erlang/OTP 27, jiffy with older ones
• Jose: Update to the new 1.11.10 for Erlang/OTP higher than 23
• Luerl: Update to 1.2.0 when OTP same or higher than 20, simplifies commit a09f222
• P1_acme: Update to support Jose 1.11.10 and Ipv6 support ( #4170 )
• P1_acme: Update to use Erlang’s json library instead of jiffy when OTP 27
• Port_compiler: Update to 1.15.0 that supports Erlang/OTP 27.0

Development Help

• .gitignore : Ignore ctags/etags files
• make dialyzer : Add support to run Dialyzer with Mix
• make format|indent : New targets to format and indent source code
• make relive : Add Sync tool with Rebar3, ExSync with Mix
• hook_deps : Use precise name: hooks are added and later deleted, not removed
• hook_deps : Fix to handle FileNo as tuple {FileNumber, CharacterPosition}
• Add support to test also EUnit suite
• Fix code:lib_dir call to work with Erlang/OTP 27.0-rc2
• Set process flags when Erlang/OTP 27 to help debugging
• Test retractions in mam_tests

Documentation

• Add some XEPs support that was forgotten
• Fix documentation links to new URLs generated by MkDocs
• Remove ... in example configuration: it is assumed and reduces verbosity
• Support for version note in modules too
• Mark toplevel options, commands and modules that changed in latest version
• Now modules themselves can have version annotations in note

Installers and Container

• make-binaries: Bump Erlang/OTP to 26.2.5 and Elixir 1.16.3
• make-binaries: Bump OpenSSL to 3.3.1
• make-binaries: Bump Linux-PAM to 1.6.1
• make-binaries: Bump Expat to 2.6.2
• make-binaries: Revert temporarily an OTP commit that breaks MSSQL ( #4178 )
• CONTAINER.md: Invalid CTL_ON_CREATE usage in docker-compose example

WebAdmin

• ejabberd_ctl: Improve parsing of commas in arguments
• ejabberd_ctl: Fix output of UTF-8-encoded binaries
• WebAdmin: Remove webadmin_view for now, as commands allow more fine-grained permissions
• WebAdmin: Unauthorized response: include some text to direct to the logs
• WebAdmin: Improve home page
• WebAdmin: Sort alphabetically the menu items, except the most used ones
• WebAdmin: New login box in the left menu bar
• WebAdmin: Add make_command functions to produce HTML command element
• Document ‘any’ argument and result type, useful for internal commands
• Commands with ‘internal’ tag: don’t list and block execution by frontends
• WebAdmin: Move content to commands; new pages; hook changes; new commands

Full Changelog

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

ejabberd 24.06 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.06 first appeared on ProcessOne .

We have just released version 1.3.0 of the Botz framework for Openfire (the real-time communications server provided by the Ignite Realtime community )!

The Botz library adds to the already rich and extensible Openfire with the ability to create internal user bots.

In this release, compatbility with Openfire 4.8.0 and later has been resolved. Thank you to Sheldon Robinson for helping us fix that!

Download the latest version of the Botz framework from its project page !

For other release announcements and news follow us on Twitter and Mastodon .

1 post - 1 participant

Read full topic

Elixir allows application developers to create very parallel and very complex systems. Tools like Phoenix PubSub and LiveView thrive on this property of the language, making it very easy to develop functionality that requires continuous updates to users and clients.

But one thing that has often frustrated me is how to cleanly design an application to respond to database record updates.

A typical pattern that I’ve used is to have a dedicated function which makes a database change (e.g Shipping.insert_event ). This function can contain a post-update step which sends out, for example, a PubSub broadcast. But this relies on the team using that function consistently. If there are other update functions (e.g. Shipping.insert_delivery ) they also need to do the broadcast.

But the most fool-proof solution would be to have the database update the application whenever there is a change. Not only would this avoid needing to make sure all update functions send out broadcasts, but it also makes sure that the correct actions are taken whenever some external task or application updates the database directly.

While I knew that PostgreSQL had functionality to inform my applications about updates it always seemed intimidating. So I finally decided to figure out how it worked and to make a library! I’d like to introduce EctoWatch which is my attempt to implement this pattern in the simplest way possible.

Why Broadcast Database Updates?

Aside from the obvious case of updating LiveViews, there are a number of things you might want to do in response to record changes:

• redoing a calculation/cache when source information changes
• sending out emails about a change
• sending out webhook requests
• updating a GraphQL subscription

For example, if you insert a new status event for a tracked package, you may want to:

• update any webpages/applications currently tracking the package
• send updates about important events (like the package being delivered)
• recalculate and update the estimated delivery date

Using EctoWatch

EctoWatch allows you to set up watchers in your application’s supervision tree which can track inserts, updates, and deletes on Ecto schemas which are backed by PostgreSQL tables :

{EctoWatch,
  repo: MyApp.Repo,
  pub_sub: MyApp.PubSub,
  watchers: [
    {Accounts.User, :inserted},
    {Accounts.User, :updated},
    {Accounts.User, :deleted},
    {Shipping.Package, :inserted},
    {Shipping.Package, :updated}
  ]}

Then processes can subscribe to the broadcasts sent by the watchers:

EctoWatch.subscribe(Accounts.User, :inserted)
EctoWatch.subscribe(Accounts.User, :updated)
EctoWatch.subscribe(Accounts.User, :deleted)

EctoWatch.subscribe(Shipping.Package, :inserted)
EctoWatch.subscribe(Shipping.Package, :updated)

If your process just needs to get updates about a specific record an ID can be given:

EctoWatch.subscribe(Accounts.Package, :updated, package.id)

Then finally the module that implements your process (LiveView, GenServer, etc…) can handle messages about records:

# LiveView example
def handle_info({:inserted, Accounts.User, id, _}, socket) do
  user = Accounts.get_user(id)
  socket = stream_insert(socket, :users, user)

  {:noreply, socket}
end

def handle_info({:updated, Accounts.User, id, _}, socket) do
  user = Accounts.get_user(id)
  socket = stream_insert(socket, :users, user)

  {:noreply, socket}
end

def handle_info({:deleted, Accounts.User, id, _}, socket) do
  user = Accounts.get_user(id)
  socket = stream_delete(socket, :users, user)

  {:noreply, socket}
end

You can also define which columns trigger messages on updates as well as which values (in addition to the ID) to send with messages. Definitely check out the repo’s README for more details on how to use EctoWatch!

Conclusion

I believe that EctoWatch can be a powerful new way to simplify how we deal with database changes. Allowing a quick configuration of watchers and using simple message passing with Phoenix PubSub, you can separate the concern of making a change from the concern of what happens as a result of the change. This allows your code to be more easily readable and refactorable.

If you’re in need of help with Elixir development, code and architecture reviews, and more then drop us a line .

The post Let Your Database Update You with EctoWatch appeared first on Erlang Solutions .

Earlier today, version 1.11.0 of the REST API plugin for Openfire was released!

The REST API Plugin provides the ability to manage Openfire (the real-time communications server created by the Ignite Realtime community) by sending an REST/HTTP request to the server. This plugin’s functionality is useful for applications that need to administer Openfire outside of the Openfire admin console.

This release mainly addresses compatibility issues with Openfire versions 4.8.0 and later. A big thank you to community member Anckermann for providing the bulk of the fixes!

The updated plugin should become available for download in your Openfire admin console in the course of the next few hours. Alternatively, you can download the plugin directly, from the plugin’s archive page

For other release announcements and news follow us on Mastodon or X

1 post - 1 participant

Read full topic

Gajim 1.9.1 introduces a menu button, adds improvements for Security Labels, and fixes some bugs. Thank you for all your contributions!

What’s New

Since Gajim 1.9.0, you can toggle Gajim’s main menu bar by pressing Ctrl+M . In order to have a proper replacement for when the menu bar is hidden, we added a menu button to the top left, which contains all of the menu bar’s items.

If you are using Security Labels ( XEP-0258 ) with Gajim, you can now correct labels on messages. Overall handling of Security Labels has been improved as well.

Last but not least, Gajim’s database migration has been improved as well.

This release also comes with many bugfixes. Have a look at the changelog for a complete list.

As always, don’t hesitate to contact us at gajim@conference.gajim.org or open an issue on our Gitlab .