blog.roxing.net

Installer spip-cli dans devilbox

placido — 2024-10-03T13:49:01Z

Dans le host de devilbox :

nano autostart/install-spip-cli.sh

puis dans le fichier

#!/usr/bin/env bash # SPIP_CLI_PATH='/opt/spip-cli/' if [ -d "${SPIP_CLI_PATH}" ]; then >&2 echo "[Warning], ${SPIP_CLI_PATH} existe déjà, on sort" exit 0 fi mkdir -p ${SPIP_CLI_PATH} cd ${SPIP_CLI_PATH} git clone https://git.spip.net/spip-contrib-outils/spip-cli.git . composer install --no-dev cd bin ln -s $(pwd)/spip /usr/local/bin/ ln -s $(pwd)/spipmu /usr/local/bin/ ln -s $(pwd)/spip_console_autocomplete /etc/bash_completion.d/spip

Bonus :

nano autostart/install-spip-dump.sh

Puis :

#!/usr/bin/env bash # SPIP_DUMP_PATH='/opt/spip-dump/' if [ -d "${SPIP_DUMP_PATH}" ]; then >&2 echo "[Warning], ${SPIP_DUMP_PATH} existe déjà, on sort" exit 0 fi echo 'installation des scripts spip-dump' mkdir -p ${SPIP_DUMP_PATH} cd ${SPIP_DUMP_PATH} curl -fsSL -o spip-import-dump-from-connect.sh https://git.spip.net/-/snippets/12/raw/main/import-dump-from-connect.sh?inline=false curl -fsSL -o spip-export-dump-from-connect.sh https://git.spip.net/-/snippets/11/raw/main/export-dump-from-connect.sh?inline=false chmod +x *.sh ln -s $(pwd)/spip* /usr/local/bin/

[rsync] Exclure un pattern de la synchro par défaut

placido — 2020-04-14T13:23:33Z

rsync n'a pas de fichier de configuration général pour exclure un format de fichiers lors de la synchronation. Pour se dispenser de préciser la règle --exclude="truc" à chaque fois, on a recours à un wrapper dans ~/bin/rsync.

#!/bin/sh # RSYNC wrapper to exclude files by default # https://unix.stackexchange.com/questions/21701/how-can-i-exclude-files-by-default-with-rsync # Set path to the rsync binary RSYNC=/usr/bin/rsync # Look for these exclude files IGNORE_FILES=(~/.rsyncignore ./.gitignore ./.rsyncignore) EXCLUDE_FROM="" for f in ${IGNORE_FILES[@]}; do if [[ -e $f ]]; then EXCLUDE_FROM="$EXCLUDE_FROM --exclude-from=$f " fi done $RSYNC $EXCLUDE_FROM "$@"

Puis dans un fichier /.rsyncignore

# .rsyncignore error_log .DS* cache/* local/* tmp/*

Voir en ligne : Unix & Linux Stack Exchange

Debian9 - Installation apache2 mariadb phpmyadmin & php7

Pierrox — 2017-12-04T21:20:52Z

apt install apache2 php7.0 logrotate mariadb-server phpmyadmin

A l'installation de phpmyadmin laisser le champ vide pour configurer automatiquement les identifiants de connexion à la base de données.

[x] Cocher redémarrer apache2 pour prendre en compte la configuration ;

Puis ajouter "root" en superadmin de phpmyadmin

mysql -uroot mysql -e "SET PASSWORD FOR 'root'@'localhost' = PASSWORD('MonPassRootIci'); update user set plugin='' where user='root'; flush privileges;"

Se connecter sur http://localhost/phpmyadmin

Compresser, découper et envoyer des fichiers volumineux sous Linux

Pierrox — 2016-11-22T09:59:03Z

Xz - Compresser un fichier

Xz est un outil de compression très performant. Pour compresser un gros fichier avec le taux de compression maximal on utilise simplement :

xz -9 gros_fichier

Le fichier de sortie sera nommé gros_fichier.xz

Split - Découper un fichier en plusieurs fichiers de taille définie

Découper le fichier en plusieurs fragments de 1GB (-b bytes) et ajouter un suffixe numérique aux fichiers de sortie (-d )

split -b 1024M -d gros_fichier.xz gros_fichier.xz_part
donnera :

gros_fichier.xz_part01
gros_fichier.xz_part02
gros_fichier.xz_part03
...

Combiner tar + xz-utils + split

A titre d'exemple, le même résultat que précédement, en utilisant conjointement tar et split :

tar -Jcvf - un_repertoire_ou_fichier | split -d -b 1024MB - gros_fichier.tar.xz.

Tmux - Envoyer les fichiers en tâche de fond

Pour envoyer les fichiers vers un serveur, j'utilise scp avec une clef ssh et comme je ne veux pas saturer la connexion j'utilise l'option -l (limit). Dans l'exemple ci-dessous, -l 512 correspond à environ 50ko/s.

scp -i ~/.ssh/ma_clef -l 512 gros_fichier.xz_part* user@host:/home/bob/incoming

C'est bien joli, mais si je fais des transferts à distance, j'aimerais bien lancer la commande en tâche de fond, surtout si l'upload est très long.
Pour ce faire, j'utilise tmux qui permet d'utiliser plusieurs terminaux virtuel que l'on peu détacher ou rattacher au terminal facilement.

tmux new-session -d -s upload 'scp -i ~/.ssh/ma_clef -l 512 gros_fichier.xz_part* user@host:/home/bob/incoming 2> errors.log'

Rattacher le terminal pour voir l'upload en cours : tmux attach
Détacher le terminal avec la combinaison de touches ctrl + b puis d
Grâce à tmux, je peux me déconnecter du shell distant et revenir plus tard...
Un simple tmux a me permettra de consulter l'état d'avancement de l'upload.

Cat - Réassembler les fichiers découpés

Une fois les fichiers transférés, je les réassemble avec un simple cat

cat gros_fichier.xz_part* > gros_fichier.xz

Décompression d'un xz ou d'un tar.xz

Avec tar (-x xtract) :
tar -Jxvf gros_fichier.tar.xz

Avec xz-utils (-d)
xz -d gros_fichier.xz

Voilà.

KeePassX, Openbox et clavier fr_FR

placido — 2016-08-13T11:32:06Z

Pour une obscure raison, la fonctionnalité Auto-Type de KeePassX (v 0.4.3), utilise une disposition de clavier différente que celle définie par le système.

$ localectl status System Locale: LANG=fr_FR.UTF-8 VC Keymap: n/a X11 Layout: fr X11 Model: pc105 X11 Variant: latin9 X11 Options: terminate:ctrl_alt_bksp

Du coup, la saisie auto d'un mot de passe azerty donne qwerty.

Solution : rajouter cette ligne dans ~/.config/openbox/autostart :

setxkbmap fr &

[Debian] Java JRE 8 - Installation et Mises à jour

Pierrox — 2016-04-07T05:00:00Z

Installation de java-package

java-package est un script permettant de générer un paquet # !Debian afin de faciliter l'installation et la mise à jour de l'Environnement d'exécution Java (JRE).

Récupérer java-package et les outils nécessaires à la génération du paquet :

apt-get install java-package build-essential java-common

Récupérer l'archive sur le site d'Oracle ©

Rendez vous sur le site d'Oracle© afin de télécharger les archives.

Bien récupérer les archives en tar.gz sinon le script de génération du paquet ne fonctionnera pas !

On peux également récupérer les archives via WGET ou CURL (Et passer outre l'acceptation de la licence...)

Exemple de commande CURL pour récupérer java 8.77 32BIT via le terminal

curl -v -j -k -L -H "Cookie: oraclelicense=accept-securebackup-cookie" http://download.oracle.com/otn-pub/java/jdk/8u77-b03/jre-8u77-linux-i586.tar.gz > jre-8u77-linux-i586.tar.gz

Exemple de Commande WGET pour récupérer java 8.77 64BIT via le terminal

 wget --no-check-certificate --no-cookies --header "Cookie: oraclelicense=accept-securebackup-cookie" http://download.oracle.com/otn-pub/java/jdk/8u77-b03/jre-8u77-linux-x64.tar.gz

Générer le paquet java JRE 8 pour votre distribution Debian

une fois l'archive téléchargée il suffit d'exécuter le script make-jpkg sous l'identifiant utilisateur :

fakeroot make-jpkg jre-8u77-linux-i586.tar.gz

qui devrait démarrer ainsi :

Detected Debian build architecture: i386 Detected Debian GNU type: i586-linux-gnu Detected product: Java(TM) Runtime Environment (JRE) Standard Edition, Version 8 Update 77 Oracle(TM) Is this correct [Y/n]: y <- Checking free diskspace: done. In the next step, the binary file will be extracted. Probably a license agreement will be displayed. Please read this agreement carefully. If you do not agree to the displayed license terms, the package will not be built. Press [Return] to continue: Testing extracted archive... okay.

Une fois le script terminé l'installation du nouveau paquet se fait via la commande dpkg :

dpkg -i oracle-java8-jre_8u77_i386.deb

Et voilà ! L'environnement d'exécution java et désormais opérationnel !

Voir en ligne : Téléchagement Java sur le site d'Oracle©.

La procédure reste la même pour l'installation de Java SE Development Kit 8u77 seul les liens et noms de fichiers sont à remplacer.

LXC Debian Jessie

Pierrox — 2015-09-05T21:54:48Z

Installation de LXC

apt-get install lxc lxctl

Création d'un container

lxc-create -n NomContainer -t debian

– -n nom du container
– -t template de l'OS à utiliser

Bien noter le mot de passe root qui s'affichera à la fin de la création du container lxc.

Configuration du réseau sur l'hôte

Il y a plusieurs façons de configurer le réseau, pour ma part je préfère créer un (ou plusieurs) sous-réseaux pour mes containers qui seront "natter" par la machine hôte.
Pour illustrer, on pourrait dire que les sous-réseaux sont cloisonnés à l'intérieur de l'hôte qui fera office de pare-feu vers l'extérieur.

Autoriser "l'ip forwarding"

nano /etc/sysctl.conf net.ipv4.ip_forward=1

Recharger la configuration du système pour prendre en compte la modification.

sysctl -p

Configurer l'interface qui servira de bridge

La paquet bridge-utils est nécessaire, il est normalement installé en dépendance de lxc, au cas ou :

apt-get install bridge-utils

Paramétrage de /etc/network/interfaces

# The loopback network interface auto lo iface lo inet loopback # Configuration du Bridge pour le sous réseau virtualisé auto br0 iface br0 inet static address 192.168.100.254 netmask 255.255.255.0 bridge_ports none

Redémarrer le service réseau afin de prendre en compte la nouvelle interface br0

service networking restart

Vérifier que l'interface réseau est bien présente :
ifconfig devrait renvoyer quelque chose comme ça

br0 Link encap:Ethernet HWaddr 22:ce:06:00:1d:7f inet adr:192.168.100.254 Bcast:192.168.100.255 Masque:255.255.255.0 UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1 RX packets:0 errors:0 dropped:0 overruns:0 frame:0 TX packets:24 errors:0 dropped:0 overruns:0 carrier:0 collisions:0 lg file transmission:0 RX bytes:0 (0.0 B) TX bytes:3915 (3.8 KiB)

Activer le partage de connexion internet pour les containers LXC :

On va donner l'accès internet aux containers LXC à travers wlan0 (On verra comment automatiser ça sur un hôte au profil itinérant qui se connecte sur des interfaces diverses et variées : wlan0 eth0 usb0... )

iptables -t nat -F POSTROUTING iptables -t nat -A POSTROUTING -o wlan0 -j MASQUERADE

Configuration du réseau sur les containers LXC

Attention ! il ne s'agit pas de paramétrer le réseau à l'intérieur du container mais d'éditer un fichier de configuration qui se chargera de configurer le réseau au démarrage de celui-ci.

Par défaut, Debian installe les nouveaux containers dans /var/lib/lxc ; ce dossier contient tous les containers créés, qui eux-même contiennent des fichiers de logs, de configs et le dossier rootfs qui comme son nom l'indique, correspond à la racine du système virtualisé ( / ).

Afin de configurer le réseau sur notre container LXC, nous allons éditer son fichier de config /var/lib/lxc/NomContainer
Extrait de la configuration réseau d'un container /var/lib/lxc/NomContainer/config

lxc.network.type = veth lxc.network.name = veth0 lxc.network.flags = up lxc.network.link = br0 lxc.network.veth.pair = veth0 lxc.network.ipv4 = 192.168.100.1/24 lxc.network.ipv4.gateway = 192.168.100.254

Démarrage du container et test du réseau

lxc-start -n NomContainer -d

– -n nom du container
– -d en mode daemon

La commande pour contrôler si notre container LXC est bien démarré :

lxc-ls -f

Devrait retourner

NAME STATE IPV4 IPV6 AUTOSTART --------------------------------------------------------- NomContainer RUNNING 192.168.100.1 - NO

Sur l'hôte un petit ping 192.168.100.1 devrait retourner :

PING 192.168.100.1 (192.168.100.1) 56(84) bytes of data. 64 bytes from 192.168.100.1: icmp_seq=1 ttl=64 time=0.087 ms

On va se connecter directement au container LXC

lxc-console -n NomContainer

Se connecter au container, j'espère que vous avez bien noté le mot de passe root lors de sa création sinon vous pouvez toujours consulter l'article dédié au changement de mot de passe root d'un container LXC.
Une fois connecté, on va tester l'accès internet en utilisant apt pour installer ping afin de "pinguer" la machine hôte :

root@NomContainer:~#apt-get install inetutils-ping Les NOUVEAUX paquets suivants seront installés : inetutils-ping (...) Paramétrage de inetutils-ping (2:1.9.2.39.3a460-3) .. root@NomContainer:~#ping 192.168.100.254 PING 192.168.100.254 (192.168.100.254): 56 data bytes 64 bytes from 192.168.100.254: icmp_seq=0 ttl=64 time=0,163 ms 64 bytes from 192.168.100.254: icmp_seq=1 ttl=64 time=0,163 ms

Et voilà, Juste ça marche !

Pour quitter un container, utilisez la combinaison de touche ctrl+a puis q

youtube-dl + vlcopen

placido — 2015-04-07T19:52:19Z

Vous le savez comme moi, flash c'est le mal. Et voici LA solution qui vous fera franchir le pas d'un bannissement (espérons permanent) du vil greffon sans pour autant faire une croix sur les vidéos des plateformes d'hébergement (youtube, dailymotion, vimeo, etc).

Cela consiste en l'emploi coordonné de deux scripts qui vont vous permettre de lire directement une vidéo distante dans votre lecteur habituel (VLC, mplayer ou autre).

1) Installation de youtube-dl

Sous GNU-Linux, la méthode que je trouve la plus simple est de passer par le gestionnaire d'environnement python pip.

sudo apt-get install python-pip
sudo pip install youtube-dl

Veillez à mettre à jour l'application de temps en temps, car les plugins de gestion par plateforme sont nombreux et les modifications fréquentes.

sudo pip install -U youtube-dl

2) Lancement illico grâce à vlcopen.sh

youtude-dl est un super logiciel, efficace dans bien des situations, mais son utilisation en ligne de commande s'avère à la longue un peu rédhibitoire pour une utilisation en tant que simple utilisateur.

D'où le recours à un second script, mis à disposition par swarminglogic,qui va apporter un peu de souplesse d'utilisation et ouvrir la vidéo encore plus vite que si vous y aviez accédée directement depuis la page youtube, grâce à un raccourci clavier.

#!/bin/bash if [ $# -eq 1 ] ; then path=$1
else clipboard=$(xclip -selection clipboard -o) if [ $(<<<$clipboard grep -P "^http") ] ; then path=$clipboard else if [ -t 1 ] ; then echo "Bad clipboard path: $clipboard" >&2 else notify-send "Bad clipboard path: $clipboard" fi exit 1 fi
fi #$1 processid, $2 tempdir $3 logfile
function cleanup { echo "-------------------------------------------" echo "Cleaning up" kill -9 $1 &> /dev/null if [ -n "$2" ] ; then rm $2/* ; fi if [ -n "$2" ] ; then rmdir $2 ; fi if [ -n "$3" ] ; then rm $3 ; fi
} echo "Opening $path"
tmpvlcopen=/tmp/vlcopen/
[ ! -d $tmpvlcopen ] && mkdir $tmpvlcopen
tmpdir=$(mktemp -d --tmpdir=$tmpvlcopen) # If the tmpdir path doesn't include "/tmp/vlcopen" something went bad!
if [ "${tmpdir/$tmpvlcopen}" = "$tmpdir" ] ; then echo "Aborting: failed to create proper temporary directories" >&2 exit 1
fi cd $tmpdir
echo "Temporary directory: $tmpdir"
echo "Getting video: $path"
downloadlog=$(tempfile)
(youtube-dl --restrict-filenames --no-part "$path" &> $downloadlog)&
processId=$!
echo "ProcessID: $processId"
echo "Waiting for file creation" count=0
while [ $(ls -1 | wc -l) -eq 0 ] ; do # check if process is done. if ! kill -0 $processId &>/dev/null ; then if [ -t 1 ] ; then echo "-------------------------------------------">&2 echo "Error: youtube-dl finished without output." >&2 echo "Error: Bad URL?" >&2 echo "---------------- Download Log -------------">&2 cat $downloadlog >&2 else notify-send "Bad URL: $path $(cat $downloadlog)" fi cleanup $processId "$tmpdir" "$downloadlog" exit 0 fi sleep 0.5 ((count++)) if [ $count -eq 20 ] ; then if [ -t 1 ] ; then echo "Timed out" >&2 else notify-send "Timed out" fi exit 0 fi
done sleep 0.1
echo "Opening file: $(ls -1 | head -n 1)"
vlc "$(ls -1 | head -n 1)" &>/dev/null
cleanup $processId "$tmpdir" "$downloadlog"

Ce script se comporte comme une capsule pour youtube-dl. Il va analyser le contenu du presse-papier, et s'il détecte une url prise en charge, va créer un répertoire temporaire, y télécharger la vidéo, l'ouvrir avec VLC après quelques instants et supprimer automatiquement tous les fichiers temporaires à la fermeture.

Il suffit d'enregistrer le script (sous le nom vlcopen.sh par exemple) dans un répertoire inclus dans votre $PATH, le rendre exécutable (chmod +x vlcopen.sh) et d'associer un raccourci clavier à son exécution.

Typiquement sous openbox, j'ai rajouté une section comme suit à mon rc.xml.

<keybind key="W-y"> <action name="Execute"> <startupnotify> <enabled>true</enabled> <name>vlcopen</name> </startupnotify> <command>vlcopen.sh</command> </action>
</keybind>

Dès lors, dans les faits, lorsque je veux regarder une vidéo, je fais un clic-droit > copier l'url de la page soit sur la page courante, soit sur le lien à analyser, puis super + y (oui j'ai choisi y pour "youtube" mais à vous d'adapter au besoin), et voilà !

Seul bémol, si la vidéo est longue et que vous êtes impatient, vous ne pourrez pas avancer directement la lecture à un point qui n'a pas encore été téléchargé.

Voir en ligne : github.com/swarminglogic

PCmanFM + sftp/smb/ssh

2015-03-19T03:30:55Z

Si, comme moi, vous vous êtes demandé pourquoi votre navigateur de fichier léger n'arrivait pas à parcourir votre réseau sftp / smb / ssh / ftp dans votre environnement léger (fluxbox) c'est certainement du à votre façon de lancer pcmanfm :)
dbus-launch pcmanfm

- billets / debian, linux

Synchroniser un clavier apple aluminium bluetooth en dual boot (OS X - Gnu/Linux)

placido — 2015-03-18T01:40:01Z

Dans le cadre d'une installation en dual boot MAC OS / Debian, il peut s'avérer fastidieux de synchroniser ses périphériques bluetooth avec un identifiant commun entre les systèmes.

La marche à suivre consiste à opérer la synchronisation sous OS X, puis booter sous GNU/Linux, monter la partition OS X, par exemple :
sudo mount -t hfsplus /dev/sda2 /media/OSX/

Puis à exécuter ce script [1] :

#!/bin/sh # sync-bt-os.sh cd /var/lib/bluetooth for i in *; do cd "$i" plutil -i /media/OSX/private/var/root/Library/Preferences/blued.plist -o /dev/stdout | perl -0777 -MMIME::Base64 -ne 's|\s||g; $s = $_; while ($s =~ m|<key>(..-..-..-..-..-..)</key><data>(.*?)</data>|g) { $mac = uc($1); $key = uc(unpack("H*",reverse decode_base64($2))); $mac =~ s/-/:/g; $pinlength = 6; $pinlength = 4 if $mac eq "C4:2C:03:A0:C7:20"; print "$mac $key 0 $pinlength\n"; }' | tee linkkeys cd .. done service bluetooth restart

[1] Il vous faudra probablement installer le paquet plutil, via apt par exemple.