Scripts mattermost avancés

Liste complète des utilisateurs, canaux et équipes

La façon la plus simple d'obtenir ces informations semble être de passer via SQL directement:

  mysql --database mattermost -e 'SELECT DISTINCT u.Username, t.DisplayName AS TeamName, c.DisplayName AS ChannelName, cm.SchemeUser AS User, cm.SchemeAdmin AS Admin FROM ChannelMembers AS cm JOIN Channels AS c ON (cm.ChannelId=c.Id) JOIN Users AS u ON (cm.UserId=u.Id) JOIN Teams AS t ON (c.TeamId=t.Id);'

Derniers utilisateurs actifs sur Mattermost

Pour lister les dernières sessions des utilisateurs via MySQL:

cat << EOF | mysql -u root --database mattermost
SELECT
  FROM_UNIXTIME(t1.LastActivityAt/1000,"%Y/%m/%d-%H:%i") AS lastseen,
  tu.Username
FROM Sessions AS t1
LEFT OUTER JOIN Sessions AS t2
  ON t1.UserId = t2.UserId
        AND (t1.LastActivityAt < t2.LastActivityAt
         OR (t1.LastActivityAt = t2.LastActivityAt AND t1.Id < t2.Id))
JOIN Users AS tu ON tu.Id = t1.UserId
WHERE t2.LastActivityAt IS NULL
EOF

Convertir une discussion privée en canal d'une équipe

Le plus sûr pour l'identifier est d'abord de nommer votre discussion privée, ex. ici Discussion specs serveur.

mysql> USE mattermost;
mysql> SELECT c.Id AS ChannelId, u.Id AS UserId, u.UserName AS UserName
       FROM Users AS u
       JOIN ChannelMembers AS cm ON u.Id = cm.UserId
       JOIN Channels AS c ON c.Id = cm.ChannelId
       WHERE c.Header = 'Discussion specs serveur';

choisissez l'utilisateur de la discussion qui sera considéré comme le créateur de la future équipe (ex. uq95bsjuhbdutm8i6atc1gyaew), et repérez l'identifiant du canal (ex. uu36uoikn7d8jrqy6pmpnnyyae).

Puis transformez la discussion en un canal privé de l'équipe Equipe sysadmin:

mysql> UPDATE Channels SET
         TYPE = 'P',
         CreatorId = 'uq95bsjuhbdutm8i6atc1gyaew',
         TeamId = (SELECT Id AS TeamId FROM Teams WHERE DisplayName = 'Equipe sysadmin'),
         Name = 'server-specs',
         DisplayName = 'Specifications serveur'
       WHERE Id = 'uu36uoikn7d8jrqy6pmpnnyyae';

Réduire les images stockées

Cette commande va retrouver toutes les images qui dépassent d'un cadre 1600x1600 pixels et les réduire à cette taille (via imagemagick):

cd /opt/mattermost/data
MS=1600
find . -name '*.jpg' -exec identify -format '%w %h %i\n' {} \; 2>/dev/null |
  awk '$1 > '$MS' || $2 > '$MS' {sub(/^[^ ]* [^ ]* /, ""); print}' |
  tr '\n' '\0' | xargs -0 mogrify -resize "${MS}x${MS}"

Réduire le volume stocké en éliminant les vieux fichiers attachés

En fait, pour éviter de casser la base de donnée, on les remplace par un lien symbolique vers vers un fichier quasiment vide.

#!/bin/bash
OLDESTFILES='-30 days'
EMPTYTARGET='/opt/mattermost/deleted_file.txt'
MAXSIZE='500k'
 
if [[ "$USER" == 'root' ]]; then
	runuser -u mattermost -g mattermost "$0"
	exit
fi
 
echo "Fichier retiré" > "$EMPTYTARGET"
oldestok=$(date --date="$OLDESTFILES" +%s)
 
while IFS= read -r -d $'\0' line; do
	d=${line%%.*}
	if (( $d < $oldestok)); then
		cut -d' ' -f2- <<< "$line"
		fn=$(cut -d' ' -f6- <<< "$line")
		ln -sf "$EMPTYTARGET" "$fn"
	fi
done < <( find /opt/mattermost/data -type f -size "+$MAXSIZE" -path '**/202[0-9]*/**' -printf "%A@ %TY-%Tm-%Td %TH:%TM (%k KO) %p\0" | sort -z )

Comptes Jitsi à partir de comptes Mattermost

Cf. jitsi

Pour créer des utilisateurs jitsi à partir des pseudo des utilisateurs mattermost (le mot de passe est le même pour tout le monde!)

#!/bin/bash
set -e
 
# Common password in jitsi:
PASS=${1-utok2mi}
HOW="Username"  # "Email" serait illégal en tant que Jabber username
 
cd /root/docker-jitsi-meet
echo "SELECT $HOW FROM Users;" |
  mysql -N -u root --database mattermost | grep -v 'surveybot' | while read PSEUDO; do
echo
  echo "Setting account for $PSEUDO"
  docker-compose exec prosody /bin/bash -c "prosodyctl --config /config/prosody.cfg.lua register '$PSEUDO' meet.jitsi '$PASS'"
  break
done

Gotify pour des notifications "push" sur Android

Installation de gotify et service web GET associé

Installer gotify en version docker sur le serveur, que l'on peut tester avec un serveur web déjà en place ainsi en redirigeant un port non standard (ex. 888) vers le port 80 standard du service dans le docker.

docker run -p 888:80 --name gotify -v /var/gotify/data:/app/data gotify/server

Vérifier qu'on peut y accéder depuis à ce port en HTTP.

Dans l'interface, on crée un utilisateur (nom et mot de passe), et une fois loggué sous cet utilisateur, on crée une "Application" (étiquetée Mattermost). Cela vous donne un Token qui permet d'envoyer des notification aux utilisateurs qui se sont loggués dans l'application Gotify Android. Bien comprendre qu'un token d'application n'enverra de notifications qu'à l'utilisateur qui a crée ce token! Il n'y a pas de mécanisme d'envoi simultané à plusieurs utilisateurs.

On bride ensuite gotify en localhost en modifiant le fichier /etc/gotify/config.yml, entrée listenaddr: "127.0.0.1" (et port 80).

docker stop gotify
focker rm gotify
docker run -d -p 888:80 --restart unless-stopped --name gotify -v /var/gotify/data:/app/data gotify/server

Configurer push.mondomaine.com géré par Nginx et avec son certificat letsencrypt (cf certbot).

On utilise la définition fournie par gotify pour nginx, à laquelle on a ajouté une section de proxy pour recoder une demande de notification GET en POST:

Puis ajouter une section dans nginx:

upstream gotify {
  # Set the port to the one you are using in gotify
  server 127.0.0.1:888;
}

server {

  # Here goes your domain / subdomain
  server_name push.yaknou.com;

  location /notify {
	# Recode incoming GET as gotify POST expectation
	#  curl 'http://127.0.0.1:888/message?token=GOTIFYAPPTOKEN' -F "title=whatever" -F "message=somemore"
        set $token    $arg_token;
        set $title    $arg_title;
        set $message  $arg_message;
        set $priority $arg_priority;
        proxy_method POST;
        proxy_set_header Content-Type "application/x-www-form-urlencoded";
        proxy_set_body 'title=$token&message=$message&priority=$priority';
        proxy_pass http://gotify/message?token=$token;
        set $args '';
  }

  location / {
      # We set up the reverse proxy
      proxy_pass         http://gotify;
      proxy_http_version 1.1;

      # Ensuring it can use websockets
      proxy_set_header   Upgrade $http_upgrade;
      proxy_set_header   Connection "upgrade";
      proxy_set_header   X-Real-IP $remote_addr;
      proxy_set_header   X-Forwarded-For $proxy_add_x_forwarded_for;
      proxy_set_header   X-Forwarded-Proto http;
      proxy_redirect     http:// $scheme://;

      # The proxy must preserve the host because gotify verifies the host with the origin
      # for WebSocket connections
      proxy_set_header   Host $http_host;

      # These sets the timeout so that the websocket can stay alive
      proxy_connect_timeout   7m;
      proxy_send_timeout      7m;
      proxy_read_timeout      7m;
    }

    listen 443 ssl; # managed by Certbot
    ssl_certificate /etc/letsencrypt/live/visio.yaknou.com/fullchain.pem; # managed by Certbot
    ssl_certificate_key /etc/letsencrypt/live/visio.yaknou.com/privkey.pem; # managed by Certbot
    include /etc/letsencrypt/options-ssl-nginx.conf; # managed by Certbot
    ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem; # managed by Certbot
}

server {
    if ($host = push.yaknou.com) {
        return 301 https://$host$request_uri;
    } # managed by Certbot

    server_name push.yaknou.com ;
    listen 80;
    return 404; # managed by Certbot
}

Ainsi on peut maintenant déclencher une notification push Android via une requete web HTTPS GET:

https://push.mondomaine.com/notify?token=A973Z75XvGbyEUU&message=booom&title=topmoumoute&priority=9