Planet Jabber

by Jérôme Sautret at December 19, 2024 16:27 · “julbord“

modules:
  mod_http_api:
    default_version: 2

define_macro:
  LOGLEVEL: 4

loglevel: LOGLEVEL

EJABBERD_MACRO_LOGLEVEL=5 make relive

auth_method: &aposEjabberd.Auth.Example&apos

redis_server: "unix:/var/run/redis/redis.socket"

ejabberdctl evacuate_kindly 60 \"The server will stop in one minute.\"

ejabberdctl restart

  -
    port: 5280
    module: ejabberd_http
    request_handlers:
      "/metrics": mod_prometheus

scrape_configs:
  - job_name: "ejabberd"
    static_configs:
      - targets:
          - "ejabberd.domain.com:5280"

scrape_configs:
  - job_name: "ejabberd"
    static_configs:
      - targets:
          - "ejabberd.domain.com:5280"
     metrics_path: /metrics/myvhost.domain.com

 def get_input(path) do
   path
   |> File.read!()
   |> String.split("\n", trim: true)
 end

["3   4", "4   3", "2   5", "1   3", "3   9", "3   3"]

%{
 first_list: [3, 3, 1, 2, 4, 3],
 second_list: [3, 9, 3, 5, 3, 4]
}

 @doc """
 This function takes a list where the elements are strings with two
 components separated by whitespace.

 Example: "3   4"

 It assigns the first element to list one and the second to list two,
 assuming both are numbers.
 """
 def define_separated_lists(input) do
   Enum.reduce(input, %{first_list: [], second_list: []}, fn row, map_with_lists ->
     [elem_first_list, elem_second_list] = String.split(row, "   ")

     %{
       first_list: [String.to_integer(elem_first_list) | map_with_lists.first_list],
       second_list: [String.to_integer(elem_second_list) | map_with_lists.second_list]
     }
   end)
 end

first_sorted_list = Enum.sort(first_list)
   second_sorted_list = Enum.sort(second_list)

   first_sorted_list
   |> Enum.zip_with(second_sorted_list, fn x, y -> abs(x-y) end)
   |> Enum.reduce(0, fn distance, acc -> distance + acc end)

 frequencies_second_list = Enum.frequencies(second_list)

   Enum.reduce(first_list, 0, fn elem, acc ->
     elem * Map.get(frequencies_second_list, elem, 0) + acc
   end)

def get_input(path) do
   path
   |> File.read!()
   |> String.split("\n", trim: true)
   |> Enum.map(&convert_string_to_int_list(&1))
 end

[
   [7, 6, 4, 2, 1],
   [1, 2, 7, 8, 9],
   [9, 7, 6, 2, 1],
   [1, 3, 2, 4, 5],
   [8, 6, 4, 4, 1],
   [1, 3, 6, 7, 9]
]

Enum.filter(levels, &(is_ascending?(&1) || is_descending?(&1)))

defp is_ascending?(list), do: Enum.sort(list) == list
defp is_descending?(list), do: Enum.sort(list, :desc) == list

Enum.filter(levels, &valid_levels_distance?(&1, is_valid))

path
|> get_input()
|> get_sorted_level_lists()
|> get_valid_adjacent_levels()
|> Enum.count()

defp is_a_valid_list?(list),
   do: (is_ascending?(list) || is_descending?(list)) && valid_levels_distance?(list, false)

@spec remove_level_and_validate_list(list(), integer) :: list()
 def remove_level_and_validate_list(level, index) when index == length(level), do: []

 def remove_level_and_validate_list(level, index) do
   new_list = List.delete_at(level, index)

   if is_a_valid_list?(new_list) do
     new_list
   else
     remove_level_and_validate_list(level, index + 1)
   end
 end

 path
   |> get_input()
   |> get_valid_lists_with_bad_levels()
   |> Enum.count()

~r/mul\((\d+),(\d+)\)/

def get_valid_mul_instructions(section) do
   regex_valid_multi = ~r/mul\((\d+),(\d+)\)/
   Regex.scan(regex_valid_multi, section, capture: :all_but_first)
 end

[["2", "4"], ["5", "5"], ["11", "8"], ["8", "5"]]

Enum.reduce(correct_instructions, 0, fn [x, y] = _mul, acc ->
     String.to_integer(x) * String.to_integer(y) + acc
   end)

def remove_invalid_blocks(section) do
   regex = ~r/(don't[(][)]|do[(][)])/
   String.split(section, regex, include_captures: true)
 end

[
 "xmul(2,4)&mul[3,7]!^",
 "don't()",
 "_mul(5,5)+mul(32,64](mul(11,8)un",
 "do()",
 "?mul(8,5))",
 "don't()",
 "mul(2,3)"
]

 path
   |> get_input()
   |> remove_invalid_blocks()
   |> get_valid_mul_instructions()
   |> sum_multiplication_results()

%{
 {0, 0} => "M", {0, 1} => "M", {0, 2} => "M",
 {1, 0} => "M", {1, 1} => "S", {1, 2} => "A",
 {2, 0} => "A", {2, 1} => "M", {2, 2} => "X",
}

path
   |> File.read!()
   |> String.split("\n", trim: true)
   |> Enum.with_index(fn element, index ->        get_coordinate_format({element, index}) end)

word = String.graphemes("XMAS")

Enum.filter(input, fn {_coordinate, value} -> value == character end)

character = “M”

 [
   {{0, 4}, "X"},
   {{9, 5}, "X"},
   {{8, 5}, "X"}
 ]

[
   {row, colum + 1},
   {row, colum - 1},
   {row + 1, colum},
   {row - 1, colum},
   {row - 1, colum + 1},
   {row - 1, colum - 1},
   {row + 1, colum + 1},
   {row + 1, colum - 1}
 ]

Enum.reduce(coordinates, 0, fn {coord, _elem}, occurrences ->
     check_coordinate(coord, word, input) + occurrences
   end)

Enum.filter(input, fn {_coordinate, value} -> value == character end)

character = “A”

def valid_x_mas({row, column} = _coordinate, input) do
   top_left = input[{row - 1, column - 1}]
   top_right = input[{row - 1, column + 1}]
   bottom_left = input[{row + 1, column - 1}]
   bottom_right = input[{row + 1, column + 1}]

   cond do
     top_left == "M" && bottom_left == "M" && top_right == "S" && bottom_right == "S" -> 1
     top_left == "M" && bottom_left == "S" && top_right == "M" && bottom_right == "S" -> 1
     top_left == "S" && bottom_left == "S" && top_right == "M" && bottom_right == "M" -> 1
     top_left == "S" && bottom_left == "M" && top_right == "S" && bottom_right == "M" -> 1
     true -> 0
   end
 end

[[listen.http]]
  port = 9090
  transport.num_acceptors = 10

  [[listen.http.handlers.mongoose_prometheus_handler]]
    host = "_"
    path = "/metrics"

(...)

[instrumentation.prometheus]

[instrumentation.log]

[[instrumentation.exometer.report.graphite]]
  interval = 60_000
  prefix = "mim"
  host = "influxdb1"

mkdir ejabberd-setup && cd ejabberd-setup
touch docker-compose.yml
mkdir conf
touch conf/ejabberd.yml
mkdir database
mkdir logs

ejabberd-setup/
├── conf
│   └── ejabberd.yml
├── database
├── docker-compose.yml
└── logs

sudo chown -R 9000:9000 database
sudo chown -R 9000:9000 logs

services:
  ejabberd:
    image: ejabberd/ecs:latest
    container_name: ejabberd
    ports:
      - "5222:5222"  # XMPP Client
      - "5280:5280"  # Web Admin Interface, optional
    volumes:
      - ./database:/home/ejabberd/database
      - ./ejabberd.yml:/home/ejabberd/conf/ejabberd.yml
      - ./logs:/home/ejabberd/logs
    restart: unless-stopped

loglevel: 4
hosts:
- "localhost"

acl:
  admin:
    user:
      - "admin@localhost"

access_rules:
  local:
    allow: all

listen
  -
    port: 5222
    module: ejabberd_c2s

  -
    port: 5280                       # optional
    module: ejabberd_http            # optional
    request_handlers:                # optional
      "/admin": ejabberd_web_admin   # optional

$ docker exec -it ejabberd bin/ejabberdctl register admin localhost very_secret_password
> User admin@localhost successfully registered

services:
  ejabberd:
    image: ejabberd/ecs:latest
    container_name: ejabberd
    ports:
      - "5222:5222"  # XMPP Client
      - "5280:5280"  # Web Admin Interface, optional
    volumes:
      - ./database:/home/ejabberd/database
      - ./ejabberd.yml:/home/ejabberd/conf/ejabberd.yml
      - ./logs:/home/ejabberd/logs
    restart: unless-stopped

  watchtower:
    image: containrrr/watchtower
    container_name: watchtower
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    environment:
      - WATCHTOWER_POLL_INTERVAL=3600 # Sets how often Watchtower checks for updates (in seconds).
      - WATCHTOWER_CLEANUP=true # Ensures old images are cleaned up after updating.
    restart: unless-stopped

8c489503f24e35003e2930873037950a4a08bc276be1338b6a0928db0f0eb37d  openfire-4.9.1-1.noarch.rpm
1e80a119c4e1d0b57d79aa83cbdbccf138a1dc8a4086ac10ae851dec4f78742d  openfire_4.9.1_all.deb
69a946dacd5e4f515aa4d935c05978b5a60279119379bcfe0df477023e7a6f05  openfire_4_9_1.dmg
c4d7b15ab6814086ce5e8a1d6b243a442b8743a21282a1a4c5b7d615f9e52638  openfire_4_9_1.exe
d9f0dd50600ee726802bba8bc8415bf9f0f427be54933e6c987cef7cca012bb4  openfire_4_9_1.tar.gz
de45aaf1ad01235f2b812db5127af7d3dc4bc63984a9e4852f1f3d5332df7659  openfire_4_9_1_x64.exe
89b61cbdab265981fad4ab4562066222a2c3a9a68f83b6597ab2cb5609b2b1d7  openfire_4_9_1.zip

...
2024-10-22 13:47:05.424 [info] Creating Mnesia disc_only table &aposoauth_token&apos
2024-10-22 13:47:05.427 [info] Creating Mnesia disc table &aposoauth_client&apos
2024-10-22 13:47:05.455 [info] Waiting for Mnesia synchronization to complete
2024-10-22 13:47:05.591 [info] ejabberd 24.10 is started in the node :ejabberd@localhost in 1.93s
2024-10-22 13:47:05.606 [info] Elixir 1.16.3 (compiled with Erlang/OTP 26)
2024-10-22 13:47:05.606 [info] Erlang/OTP 26 [erts-14.2.5.4] [source] [64-bit] [smp:4:4] [ds:4:4:10] [async-threads:1] [jit:ns]

2024-10-22 13:47:05.608 [info] Start accepting TCP connections at 127.0.0.1:7777 for :mod_proxy65_stream
2024-10-22 13:47:05.608 [info] Start accepting UDP connections at [::]:3478 for :ejabberd_stun
2024-10-22 13:47:05.608 [info] Start accepting TCP connections at [::]:1883 for :mod_mqtt
2024-10-22 13:47:05.608 [info] Start accepting TCP connections at [::]:5280 for :ejabberd_http
...

Solution	Legacy: mongoose_metrics	New: mongoose_instrument
Intended use	Metrics	Metrics, logs, distributed tracing, alarms, …
Coupling with handlers	Tight: hardcoded Exometer logic, one metric update per function call	Loose: events separated from configurable handlers
Supported handlers	Exometer is hardcoded	Exometer, Prometheus, Log
Events identified by	Exometer metric name (a list)	Event name, Labels (key-value map)
Event value	Single-dimensional numerical value	Multi-dimensional measurements with metadata
Consistency checks	None – it is up to the implementer to verify that the correct metric is created and updated	Prometheus HTTP endpoint, legacy GraphQL / CLI / REST for Exometer
API	GraphQL / CLI and REST	Prometheus HTTP endpoint,legacy GraphQL / CLI / REST for Exometer

Automation Across Business Processes	Machine learning automates key business functions, from marketing to manufacturing, boosting yield by up to 30%, reducing scrap, and cutting testing costs. This frees employees from more creative, strategic tasks.
Efficient Predictive Maintenance	ML helps manufacturing predict equipment failures, reducing downtime and extending machinery lifespan, ensuring operational continuity.
Enhanced Customer Experience and Accurate Sales Forecasts	Retailers use machine learning to analyse consumer behaviour, accurately forecast demand, and personalise offers, greatly improving customer experience.
Data-Driven Decision-Making	ML algorithms quickly extract insights from data, enabling faster, more informed decision-making and helping businesses develop effective strategies.
Error Reduction	By automating tasks, machine learning reduces human error, so employees to focus on complex tasks, significantly minimising mistakes.
Increased Operational Efficiency	Automation and error reduction from ML lead to efficiency gains. AI systems like chatbots boost productivity by up to 54%, operating 24/7 without fatigue.
Enhanced Decision-Making	ML processes large data sets swiftly, turning information into objective, data-driven decisions, removing human bias and improving trend analysis.
Addressing Complex Business Issues	Machine learning tackles complex challenges by streamlining operations and boosting performance, enhancing productivity and scalability.

Planet Jabber

December 19, 2024

XEP-0484: Fast Authentication Streamlining Tokens

Deprecation schedule for Erlang/OTP older than 25.0

Commands API v3

Improvements in commands

Use non-standard STUN port

Disable the systemd watchdog by default

Define macro as environment variable

Elixir modules for authentication

Redis now supports Unix Domain Socket

New evacuate_kindly command

Acknowledgments

Improvements in ejabberd Business Edition

Prometheus support

Fix

ChangeLog

Miscelanea

Commands API

Documentation

WebAdmin

Full Changelog

ejabberd 24.12 download & feedback

December 18, 2024

JMP at SeaGL

Cheogram Android in Amazon Appstore

New features in Cheogram Android

Cheogram Android

eSIM Adapter Launch

Engaging with the Community

Addressing Challenges

Holiday Support Schedule

Looking Ahead

December 13, 2024

Changelog

Download

December 10, 2024

About Erik

So tell us about yourself and your role at Erlang Solutions.

What has been a professional highlight of yours in 2024?

What professional and personal achievements are you looking forward to achieving in 2025?

Do you have any festive traditions that you’re looking forward to this holiday season?

Final thoughts

December 09, 2024

Changelog

Download

December 05, 2024

XSF Announcements

XMPP Summit 27 & FOSDEM 2025

XSF Fiscal Hosting Projects

XMPP Events

XMPP Articles

XMPP Software News

XMPP Clients and Applications

XMPP Servers

XMPP Libraries & Tools

Extensions and specifications

Proposed

New

Deferred

Updated

Last Call

Stable

Deprecated

Rejected

Spread the news

Subscribe to the monthly XMPP newsletter

Newsletter Contributors & Translations

Help us to build the newsletter

Unsubscribe from the XMPP Newsletter

License

December 04, 2024

Welcome to Advent of Code 2024!

Day 1: Historian Hysteria

Part 1

Part 2

Day 2: Red-Nosed Reports

Part 1

Part 2

Day 3: Mull It Over

New `evacuate_kindly` command

2.2: The `docker-compose.yml` file

2.3: The `ejabberd.yml` file