FaciLinux

Guide Facili per Linux

Ultimamente mi è capitato di dover lavorare con file di testo generati da script powershell, in particolare dall'utility Out-File.

Il problema che ho trovato è stato nell'encoding del file generato da Powershell, che nel mio caso era UTF16-Little Endian, un encoding che mal si sposa con le utility di parsing dei file della bash.

Per scoprire con quale encoding ci stiamo confrontando, ci viene in aiuto il comando file; infatti Out-File supporta parecchi encoding in output (https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.utility/out-file?view=powershell-6#parameters), quindi nel caso questa guida è da aggiustare con l'encoding che fa al caso vostro.

Il primo passo, come detto, è scoprire con quale encoding si ha a che fare:

[user@pc ~]$ file -i output_powershell.txt 
output_powershell.txt: text/plain; charset=utf-16le

La desiderata è di ottenere un file in UTF8, con i carriage return di linux, ed ecco come fare:

iconv -f UTF-16LE -t UTF8 output_powershell.txt | dos2unix > converted_output.txt

In caso manchi l'utiliy dos2unix è possibile installarla con il proprio gestore di pacchetti; per Arch ad esempio il comando è

sudo pacman -Su dos2unix

Il nostro file convertito è ora un ottimo candidato per passare sotto altri strumenti di parsing.

Buon lavoro!

Gli utenti di Gnome e KDE possono godere di azioni di crittazione/decrittazione di file direttamente dai rispettivi filemanager, cliccando con il tasto destro del mouse sul file interessato.
Thunar, il FileManager di Xfce, non presenta questa funzionalità integrata ma, grazie alle “Azioni personalizzate”, è possibile estenderne il comportamento; vediamo come fare.

Prerequisiti

Innanzitutto è necessario installare i pacchetti necessari; per Debian/Ubuntu il comando da dare è:

user@debby:~$ sudo apt install seahorse seahorse-nautilus seahorse-daemon

Seahorse è un’interfaccia grafica per gestire le chiavi GPG negli ambienti Gnome/Gtk, mentre del pacchetto seahorse-nautilus ci serve il binario seahorse-tool, come vedremo più avanti.

Azione personalizzata “Cifra..”

  • Aprire Thunar e selezionare il menu Modifica > Imposta azioni personalizzate, quindi:
  • Premere sul pulsante +
  • Nel campo Nome inserire “Cifra…”
  • Nel campo Descrizione inserire “cifra con GPG”
  • Nel campo Comando inserire “seahorse-tool -e %F”
  • Selezionare un’icona a proprio piacimento
  • Nel tab “Condizioni di visibilità” selezionare tutte le tipologie di file, escludendo le cartelle e come “Schema del file” mantenere il predefinito “*” Dato che un video vale più di mille parole, ecco qui sotto il riepilogo di quanto fatto: Azione personalizzata "Cifra..."

Azione personalizzata “Decifra..”

  • Aprire Thunar e selezionare il menu Modifica > Imposta azioni personalizzate, quindi:
  • Premere sul pulsante +
  • Nel campo Nome inserire “Decifra…”
  • Nel campo Descrizione inserire “decifra con GPG”
  • Nel campo Comando inserire “seahorse-tool -d %f”
  • Selezionare un’icona a proprio piacimento
  • Nel tab “Condizioni di visibilità” selezionare solo “Altri file” e come “Schema del file” impostare “.gpg;.pgp” Anche in questo caso ecco qui sotto il riepilogo a video di quanto fatto: enter image description here

XBrowserSync è un progetto (e un servizio) opensource che permette di svincolarsi dai sync più o meno proprietari offerti dai maggiori browser e vendor.

La via semplice

Il modo più semplice di usare xBrowserSync è quello di installare l'addon per Firefox o Chrome/Chromium direttamente dai rispettivi market, scegliere uno dei server ufficiali di xbrowsersync e iniziare la sincronizzazione, creando un nuovo syncID.

I dati vengono crittografati all'origine, e trasmessi via https. Altri browser/dispositivi possono venire agganciati utilizzando il syncID e la password associata.

Android?

Il team del progetto ha creato anche un'app per Android, scaricabile sia dal Play Store sia con F-Droid

La via Difficile

Ovvero, creiamo un'istanza privata di xbrowsersync!

Essendo un progetto opensource e free è naturalmente possibile installare un'istanza server privata di XBrowserSync su un proprio server.

Ecco come fare utilizzando un'istanza VPS (di quelle a basso costo offerte da molti gestori cloud).

Per quanto non coperto da questa guida rimando all'ottimo readme presente sul github del progetto a questo indirizzo: https://github.com/nodesource/distributions/blob/master/README.md

Prerequisiti

Per funzionare, XBrowserSync necessita di nodejs e MongoDB.

Per installare mongodb su server Debian/Ubuntu è sufficiente il comando

sudo apt install mongodb

Per NodeJS è invece necessario aggiungere un repository esterno, seguendo la guida presente sul sito del progetto: https://github.com/nodesource/distributions/blob/master/README.md

Installazione del servizio

Il primo passo è clonare il repository GIT di xbrowsersync all'interno del server VPS; consiglio di creare una directory xbrowsersync all'interno di /opt:

sudo mkdir /opt/xbrowsersync

Spostiamoci all'interno della directory appena creata e cloniamo il repository

cd /opt/xbrowsersync
git clone https://github.com/xbrowsersync/api.git

Ora installiamo e compiliamo il pacchetto

npm install --unsafe-perm

Configurazione di MongoDB

Apriamo la shell di mongodb con il comando

mongo

Ora creiamo e configuriamo il database per xbrowsersync (NB. sostituire PASSWORD con una password a propria scelta)

use admin
db.createUser({ user: "xbrowsersyncdb", pwd: "PASSWORD", roles: [ { role: "readWrite", db: "xbrowsersync" }, { role: "readWrite", db: "xbrowsersynctest" } ] })
use xbrowsersync
db.newsynclogs.createIndex( { "expiresAt": 1 }, { expireAfterSeconds: 0 } )
db.newsynclogs.createIndex({ "ipAddress": 1 })

Usciamo dalla mongo shell con il comando

exit

Opzionale: otteniamo un FQDN per il nostro server VPS

È possibile puntare il servizio di XBrowserSync usando direttamente l'indirizzo IP del server VPS, ma avreste particolari rogne volendo sfruttare l'HTTPS (raccomandato) e volendo usare in contemporanea anche il client per Android. Infatti, il client per Android non permetterebbe la sincronizzazione (non avendo un FQDN dovreste usare un certificato self-signed, con tutti i problemi di importazione e riconoscimento di tali certificati in Android.

Per fortuna è possibile risolvere alla radice tali problemi, utilizzando servizi gratuiti messi a disposizione online. DuckDNS è un servizio online di DynamicDNS assolutamente gratuito, che permette di registrare domini di terzo livello del tipo dominio.duckdns.org.

Il nostro VPS avrà un IP fisso, quindi possiamo registrare il dominio di terzo livello che vogliamo (in questa guida myxbsync.duckdns.org) e scordarci le problematiche di aggiornamento dell'IP.

Opzionale: otteniamo un certificato valido per il nostro dominio

Dopo aver registrato il nostro nome DNS dobbiamo ottenere un certificato valido.

SSLforFree permette, sempre gratuitamente, di ottenere un certificato (valido 90 giorni e aggiornabile all'infinito). Rimando alle chiare guide del sito per la generazione del certificato; consiglio di registrarsi al sito per gestire i rinnovi con facilità.

Dopo aver ottenuto i certificati, copiamoli sul nostro server VPS e scompattiamo lo zip in una directory, appositamente creata, in /etc/ssl/web.

Configurazione di XBrowserSync

Il servizio si configura in un unico file json, da parire con l'editor preferito e collocato in /opt/xbrowsersync/api/config/settings.default.json I campi da modificare per il database sono:

"name": "xbrowsersync",
"username": "xbrowsersyncdb",
"password": "PASSWORD",

Per il logging valorizzare come segue il capo path per log

"path": "/var/log/xBrowserSync/api.log",

Opzionale: per HTTPS valorizzare come segue i campi sotto server

"https": {
      "certPath": "/etc/ssl/web/certificate.crt",
      "enabled": true,
      "keyPath": "/etc/ssl/web/private.key"
    },

Opzionale: modificare il campo message in status

"message": "Benvenuto nel mio xBorwserSync privato",

Sistemazione permessi e path

Creiamo il path dove verranno salvati i file di log

sudo mkdir /var/log/xBrowserSync

Ora sistemiamo i permessi; faremo girare il servizio con l'utente fittizzio (di sistema) nobody

sudo chown -R nobody:nogroup /var/log/xBrowserSync
sudo chown -R nobody:nogroup /opt/xbrowsersync

Creazione eseguibile di avvio

Creiamo un nuovo file (come root) con il nostro editor preferito in /usr/bin con questo contenuto:

#!/bin/bash

export NODE_EXTRA_CA_CERTS=/etc/ssl/web/ca_bundle.crt
/usr/bin/node /opt/xbrowsersync/api/dist/api.js

NB la riga NODE_EXTRA_CA_CERTS è da mettere solo se si è seguita la guida per l'abilitazione dell'https con i certificaticreati con FreeSSL

Salviamo il file come xbrowsersync e rendiamolo eseguibile

sudo chmod +x /usr/bin/xbroswersync

Creazione e abilitazione del demone systemd

Creiamo un servizio systemd per l'avvio/spegnimento del servizio; creiamo il file /etc/systemd/system/xbrowsersync.service con il nostro editor preferito, con questo contenuto:

[Unit]
Description=XBrowserSync Service

[Service]
ExecStart=/usr/bin/xbrowsersync 
Restart=always
User=nobody
# Note Debian/Ubuntu uses 'nogroup', RHEL/Fedora uses 'nobody'
Group=nogroup
Environment=PATH=/usr/bin:/usr/local/bin
Environment=NODE_ENV=production
WorkingDirectory=/opt/xbrowsersync/api

[Install]
WantedBy=multi-user.target

Facciamo rileggere a systemd i file di configurazione con il comando:

sudo systemctl daemon-reload

Ora abilitiamo e facciamo partire il servizio di XBrowserSync:

sudo systemctl enable xbrowsersync
sudo systemctl start xbrowsersync

A questo punto è possibile contattare il proprio servizio privato di sync dall'indirizzo http ( o https) del proprio server VPS sulla porta 8080. Per il nostro esempio, l'indirizzo divenda quindi: https://myxbsync.duckdns.org:8080

Restrizione d'uso

Il servizio, di default, accetta nuovi account di sync da chiunque ne conosca l'indirizzo; se vogliamo mantenere il nostro xbrowsersync ad uso privato, dopo aver aggiunto i synID desiderati, possiamo fermare il servizio e modificare il file json di configurazione, nella sezione status, impostando a false la direttiva allowNewSyncs:

"allowNewSyncs": false,

Quindi riavviare il servizio. A questo punto, gli utenti con un syncID valido potranno continuare a utilizzare il servizio, ma non saranno accettati nuovi utenti.

È possibile installare le guest additions di VirtualBox anche su macchine linux di tipo "server", che tipicamente non montano una GUI?

La risposta a questa domanda è molto semplice, ed è sì.

In questa guida prenderemo ad esempio una vm server con installato Debian.

Fase Preliminare

NB Tutti i comandi dati da terminale in questa guida sono da eseguire con utente root

Prima di tutto occorre accedere in console alla vm, e installare tutti i pacchetti necessari alla corretta installazione delle Guest Additions; da root quindi diamo il seguente comando:

apt update && apt upgrade && apt install gcc make perl linux-headers-$(uname -r)

Ora siamo pronti per installare le Guest Additions; dal menu di VirtualBox selezioniamo la voce "Dispositivi > Inserisci l'immagine del CD delle Guest Additions".

Il CD è ora inserito, smontato, all'interno del server.

Copia dei file e installazione

Montiamo il cd delle Guest Additions con il seguente comando:

mount /dev/cdrom /mnt

Ora copiamo il file relativo alla Guest Additions per sistemi Linux all'interno della home di root:

cp /mnt/VBoxLinuxAdditions.run ~

Ora eseguiamo l'installazione delle Guest Additions, utilizzando il flag -nox11 (per consentire l'installazione da console non grafica) e l'opzione install:

/root/VBoxLinuxAdditions.run --nox11 install

Il comando produrrà un output simile a questo:

Verifying archive integrity... All good.
Uncompressing VirtualBox 6.0.4 Guest Additions for Linux........
VirtualBox Guest Additions installer
Removing installed version 6.0.4 of VirtualBox Guest Additions...
update-initramfs: Generating /boot/initrd.img-4.9.0-9-amd64
root@debian-9:~# /root/VBoxLinuxAdditions.run --nox11 install
Verifying archive integrity... All good.
Uncompressing VirtualBox 6.0.4 Guest Additions for Linux........
VirtualBox Guest Additions installer
Copying additional installer modules ...
Installing additional modules ...
VirtualBox Guest Additions: Building the VirtualBox Guest Additions kernel 
modules.  This may take a while.
VirtualBox Guest Additions: To build modules for other installed kernels, run
VirtualBox Guest Additions:   /sbin/rcvboxadd quicksetup <version>
VirtualBox Guest Additions: Building the modules for kernel 4.9.0-9-amd64.
update-initramfs: Generating /boot/initrd.img-4.9.0-9-amd64
VirtualBox Guest Additions: Running kernel modules will not be replaced until 
the system is restarted
VirtualBox Guest Additions: Starting.

Se è andato tutto liscio le Guest Additions sono ora installate sulla VM.

Verifica È possibile verificare, aprendo un terminale sull'host che esegue VirtualBox, se le guest additions sono installate su una VM. Il comando da dare è:

vboxmanage showvminfo "Nome VM"

sostituiendo "Nome VM" con la label o l'UUID della VM di cui si vogliono ottenere le informazioni.

NB È possibile ottenere la lista delle label e degli UUD delle VM con il comando vboxmanage list vms

L'output del comando conterrà qualcosa di questo genere:

Additions run level:         2
Additions version            6.0.4 r128413

Guest Facilities:

Facility "VirtualBox Base Driver": active/running (last update: 2019/06/06 14:29:09 UTC)
Facility "VirtualBox System Service": active/running (last update: 2019/06/06 14:29:33 UTC)
Facility "Seamless Mode": not active (last update: 2019/06/06 14:29:09 UTC)
Facility "Graphics Mode": not active (last update: 2019/06/06 14:29:09 UTC)

Rimozione delle Guest Additions

Per rimuovere le Guest Additions è sufficiente lanciare il comando:

/root/VBoxLinuxAdditions.run --nox11 uninstall

Installazione su altre distribuzioni GNU/Linux

Questa guida porta ad esempio l'installazione delle guest additions su una VM Debian; la guida può funzionare anche per sistemi derivati (o imparentati...), come Ubuntu e LinuxMint.

Per sistemi diversi l'elenco delle dipendenze da installare nei prerequisiti potrebbe essere diverso; ad esempio, nei sistemi RedHat, Fedora, CentOS, il pacchetto linux-headers viene nominato come kernel-devel.

Generalmente lo script di installazione delle Guest Additions è piuttosto evoluto, quindi se manca una dipendenza l'installazione fallirà, suggerendovi i passi da seguire per le dipendenze mancanti.

NAT forwarding in VirtualBox

- Posted in VM by

Grazie a VirtualBox è possibile creare velocemente delle VM sulla propria workstation, per finalità di sviluppo e test. Supponiamo di voler provare l'ultima versione di un CMS senza impattare su servizi in produzione; è possibile creare al volo una macchina virtuale con un server Apache a bordo e installare il CMS per test e sviluppo. Le VM in VirtualBox vengono generalmente impostate con un indirizzo NAT interno, il che significa che - nel nostro esempio - il web server di test che gira sulla guest vm non sarà raggiungibile dal browser della nostra workstation. Ciò, a meno di impostare una regola di inoltro. Ecco come fare, e soprattutto ecco come farlo da linea di comando.

VBoxManage

vboxmanage è il coltellino svizzero che ci servirà per tutte le operazioni di questa guida; apriamo quindi un terminale e digitiamo:

vboxmanage list vms

Nel mio caso il comando riporta questa lista:

vboxmanage list vms
"W10" {5c7b69f8-e1a9-4799-8f4c-2e33e08339ea}
"LinuxMint19.1" {fb9c380e-eecb-446a-ac80-3c61f0cd8d6c}
"OpenMandriva 4" {33e112cc-65b1-4465-bb98-2b696add9942}
"Debian 9.8" {9816d8a6-0110-4c81-8c38-921e68e72a3c}
"NuTyX" {0982b040-2bbe-4574-86d0-d04aa033d31b}
"OpenSuse" {a3da54bf-3573-4b3d-b52c-0dcf759b0f2a}
"Debian5.0" {1cae2c0b-50ad-40c0-af52-668d6bbbae8a}

La VM su cui gira il web server è "Debian 9.8". Per avviarla basta dare il seguente comando:

vboxmanage startvm "Debian 9.8"

Scoprire l'indirizzo IP della VM

Una volta che la VM sarà partita è necessario scoprire quale sia il suo indirizzo IP, necessario per impostare la regola di forward. Anche in questo caso il tool vboxmanage ci viene in aiuto; è possibile infatti scoprire tutte le informazioni di una vm con il comando vboxmanage guestproperty enumerate "Nome VM". Nel caso di esempio il comando diventa:

vboxmanage guestproperty enumerate "Debian 9.8"

con il seguente output (NB la parte non necessaria è stata rimossa):

Name: /VirtualBox/GuestInfo/Net/0/V4/IP, value: 10.0.2.15

ATTENZIONE: perché il comando di enumerate funzioni occorre che sulla VM siano installate le guest additions

Creaimo una regola di port forwarding

Le regole di port forwarding si creano con il comando vboxmanage controlvm e l'opzione natpf. Dal comando di enumerate precedente abbiamo i seguenti dati:

  • numero della scheda di rete (ricavabile da /VirtualBox/GuestInfo/Net/0/V4/IP ), che va incrementato di 1 per il successivo comando
  • indirizzo ip

Sulla macchina di test sta girando un server Apache, in ascolto sulla porta 80; con questo comando abilitiamo una regola di port-forwarding dal nome "Regola1" della porta 80 della VM sulla porta 8080 di localhost (ovvero 127.0.0.1) della workstation

vboxmanage controlvm "Debian 9.8" natpf1 "Regola1",tcp,127.0.0.1,8080,10.0.2.15,80

NB l'opzione natpf deve essere seguita dal numero della scheda di rete su cui impostare la regola. Nell'esempio la scheda è la prima (di quattro massime impostabili su un VM), quindi il comando diventa natpf1; se si dovesse impostare una regola sulla seconda scheda il comando diventerebbe natpf2 e così via.

Verifica

È possibile verificare lo stato delle regole impostate sia direttamente, ovvero aprendo un browser all'indirizzo http://127.0.0.1:8080

verifica diretta sia indirettamente, ovvero controllando l'output del comando

vboxmanage showvminfo "Debian 9.8"

Nel caso dell'esempio riportato qui sopra, nell'output del comando compaiono le righe:

NIC 1 Rule(0):   name = Regola1, protocol = tcp, host ip = 127.0.0.1, host port = 8080, guest ip = 10.0.2.15, guest port = 80

che confermano l'applicazione della regola impostata.

balena Etcher

- Posted in tools by

Etcher (balenaEtcher) è una applicazione per scrivere i file immagine su schede SD.

Qui a balena abbiamo migliaia di utenti che lavorano con le nostre istruzioni di avvio e fino a poco tempo fa eravamo imbarazzati riguardo ai passaggi che comportavano il flashing di una scheda SD. C'era un modo differente per Mac / Windows / Linux e diversi passaggi manuali e soggetti a errori lungo la strada.
Con nostra sorpresa non c'era niente là fuori che si adattasse ai nostri bisogni. Così abbiamo creato Etcher, un'app flash card SD che è semplice per gli utenti finali, estensibile per gli sviluppatori e funziona su qualsiasi piattaforma.

Quindi Etcher è stato sviluppato per soddisfare esigenze particolari : “masterizzare” su periferiche SD in maniera semplice per gli utenti finali, estensibile per gli sviluppatori e che deve funzionare su qualsiasi piattaforma.

E’ sviluppato da balena e concesso in licenza Apache License 2.0.
Etcher è stato sviluppato utilizzando il framework Electron e supporta Windows, macOS e Linux.

Va notato che balenaEtcher utilizza servizi di monitoraggio al momento dell’utilizzo (Google Analytics e Mixpanel), anche quando la casella di controllo ‘Invia dati di utilizzo anonimo’ è spuntata.

Home Page: https://www.balena.io/etcher/ GitHub: https://github.com/balena-io/etcher

Normalmente zip è installato.
È possibile eseguire il comando seguente per installare zip e unzip. Se non è già installato, verrà installato ora.

sudo apt install zip unzip

La sintassi per l'utilizzo del comando zip è piuttosto semplice.

zip [option] output_file_name input1 input2

Se l'unico scopo è creare un file zip da un gruppo di file e directory, il comando è il seguente:

zip -r output_file.zip file1 folder1

L'opzione -r attiverà la ricorsione nelle directory e comprimerà anche i contenuti di queste.
L'estensione .zip nei file di output è facoltativa poiché .zip viene aggiunto per impostazione predefinita.

Esempio

$ zip -r test.zip a.txt d/
  adding: a.txt (deflated 34%)
  adding: d/ (stored 0%)
  adding: d/b.txt (deflated 34%)

Premessa

Stop !!!

Generale

Ctrl+, Impostazioni
Ctrl+Shift+P Attiva/Disattiva il linea comandi
Ctrl+Alt+R Ricarica Atom
Ctrl+Shift+M Attiva/Disattiva l'anteprima Markdown
Ctrl+Shift+I Attiva/Disattiva gli strumenti sviluppatore di Chrome
Ctrl+. Attiva/Disattiva il Key Binding Resolver

Files e cartelle

Ctrl+N Nuovo file
Ctrl+Shift+N Nuova finestra
Ctrl+O Apri file
Ctrl+P Apri file con ricerca
Ctrl+Shift+O Apri cartella
Ctrl+ S Salva
Ctrl+ Shift + S Salva come
Ctrl+Tab
Ctrl+PGUP
Vai al tab successivo nel riquadro attivo
Ctrl+Shift+Tab
Ctrl+PGDN
Vai al tab precedente nel riquadro attivo
Alt+[1-9] Vai al tab
Ctrl+ W Chiudi tab

Linee

Ctrl+G Vai alla linea
Ctrl+L Seleziona linea
Ctrl+Shift+D Duplica linea
Ctrl+Shift+K Elimina linea
Ctrl+/ Sposta la linea su/giù
Ctrl+/ Attiva/Disattiva una linea di commento

Parole e caratteri

Alt+/ Vai alla parola precedente/successiva
Alt+Shift+B/F Seleziona fino all'inizio/fine della parola
Shift+/ Seleziona carattere per carattere

Trova e sostituisci

Ctrl+F Trova nel file corrente
Ctrl+Shift+F Trova nel progetto
F3 Trova successivo
Shift+F3 Trova precedente
Ctrl+Enter Sostituisci tutto

Vista

Ctrl++/- Aumenta/diminuisci la dimensione del testo
Ctrl+0 Resetta la dimensione del testo
F11 Attiva/Disattiva lo schermo intero

Vista ad albero

Ctrl+K Ctrl+B
Ctrl+\
Attiva/Disattiva il riquadro vista ad albero
A Aggiungi file
Shift + A Aggiungi cartella

Riquadri

Ctrl+K /// Dividi il riquadro sopra/sotto/sinistra/destra
Ctrl+K Ctrl+/// Vai con focus al riquadro sopra/sotto/sinistra/destra
Ctrl+K Ctrl+W Chiudi il riquadro

Telegram URL caching

- Posted in scripting by

Nello sviluppo di un bot di Telegram ho avuto la necessità di caricare le immagini gif animate dei radar meteo dell'ARPAV, che vengono aggiornate con una certa frequenza.

In una prima versione le immagini venivano scaricate in locale e poi caricate su Telegram.

Leggendo la documentazione delle API Telegram del metodo "sendDocument"

File to send. Pass a file_id as String to send a file that exists on the Telegram servers (recommended), pass an HTTP URL as a String for Telegram to get a file from the Internet, or upload a new one using multipart/form-data.

volevo velocizzare la risposta del bot alla richiesta del client sfruttando la possibilità di far eseguire ai server Telegram il download dell'immagine.

Il metodo funziona, ma mi sono scontrato con un problema: le immagini non erano aggiornate, ma si riferivano ad anni indietro.

Telegram risulta fare il caching degli URL che vengono inviati e non c'è modo automatico per scatenarne un aggiornamento.
Ciò è dovuto probabilmente alla funzonalità di "Link Preview" (quando viene scritto un URL in una chat Telegram genera una preview) e si ripercuote anche sull'invio di documenti e immagini.
Altri riferimenti a questo comportamento sono documentati qui e qui anche se non ho trovato una documentazione ufficiale.

Per aggirare il problema ho seguito una soluzioneproposta in una delle due discussioni:
generare un URL variabile nel tempo che venga poi rediretto all'URL dell'immagine.

Su un server http (ad es. example.com) viene creato un file rd.php

<?php
header("Location: http://original.url.com/image.jpg");
die();
?>

e una directory /get/ nella quale viene posizionato questo file .htaccess

RewriteEngine on
RewriteRule ^(.*)$ http://example.com/rd.php

In questo modo ogni URL del tipo http://example.com/get/qualsiasicosa
viene riscritto come http://example.com/rd.php
e quindi viene rediretto all'URL http://original.url.com/image.jpg dell'immagine che deve essere caricata.

Poichè qualsiasicosa deve variare nel tempo il candidato ideale è una qualche forma di timestamp.

Questa configurazione è stata fatta utilizzando il servizio di hosting gratuito Altervista.

Riprendiamo l'articolo "Scaricare un mp3 da un video di Youtube da linea di comando".
E se si volesse normalizzare il volume di un file audio scaricato da YouTube?
In realtà l'audio di YouTube viene già in qualche modo normalizzato e l'unica elaborazione con un certo senso sarebbe quella di alzarne il volume ossia una normalizzazione di picco.

Normalizzazione di un file audio

Il processo di normalizzazione dell'audio è l'applicazione di una quantità costante di guadagno a una registrazione audio per portare l'ampiezza a un livello target. Poiché la stessa quantità di guadagno viene applicata all'intera registrazione, il rapporto segnale-rumore e la dinamica relativa rimangono invariati.

Esistono due principali tipi di normalizzazione audio:

  • peak normalization o normalizzazione del picco che regola la registrazione in base al livello di segnale più alto presente nella registrazione
  • loudness normalization o normalizzazione del volume che regola la registrazione in base al volume percepito

Peak normalization

In questo tipo di normalizzazione il guadagno viene modificato per portare il più alto valore dei singoli campionamenti PCM o il picco del segnale analogico a un dato livello (solitamente 0 dBFS, il livello più alto consentito in un sistema digitale).

Poiché cerca solo il livello più alto, questo tipo di normalizzazione non tiene conto del volume apparente dell'audio.

Loudness normalization

Un altro tipo di normalizzazione si basa sulla misurazione del volume. Il guadagno viene modificato per portare l'ampiezza media a un livello target. Questa media può essere una semplice misurazione della potenza media (come il valore RMS) oppure può essere una misura del volume percepito dall'uomo (come l' EBU R128).

Normalizzazione a riga di comando

Per normalizzare un file audio a riga di comando in Linux possiamo usare ffmpeg-normalize

ffmpeg-normalize

La pagina web di riferimento è https://github.com/slhck/ffmpeg-normalize

Prerequisiti per l'installazione sono: - python 2.7 o 3 - ffmpeg v3.1 o successivi

Per installarlo utilizzare questo comando

pip3 install ffmpeg-normalize

Alcuni esempi

  • normalizzare (EBU R128) un file mp3 (è necessario specificare encoder e output)
    ffmpeg-normalize input.mp3 -c:a libmp3lame -b:a 320k -o output.mp3
  • normalizzare (peak normalization) un file mp3
    ffmpeg-normalize input.mp3 --normalization-type peak --target-level 0 -c:a libmp3lame -b:a 320k -o output.mp3 ffmpeg-normalize input.mp3 -nt peak -t 0 -c:a libmp3lame -b:a 320k -o output.mp3

Integrazione con youtube-dl

Per integrare la normalizzazione audio con youtube-dl si usa lo switch --exec

Per es. una normalizzazione EBU R128

youtube-dl -i --extract-audio --audio-format mp3 --audio-quality 0 https://www.youtube.com/watch?v=xymjDyGIvQ4 --exec 'ffmpeg-normalize {} -c:a libmp3lame -b:a 320k -o output.mp3 && rm {} && mv output.mp3 {}'

Per es. una normalizzazione peak

youtube-dl -i --extract-audio --audio-format mp3 --audio-quality 0 https://www.youtube.com/watch?v=xymjDyGIvQ4 --exec 'ffmpeg-normalize {} --normalization-type peak --target-level 0 -c:a libmp3lame -b:a 320k -o output.mp3 && rm {} && mv output.mp3 {}'

Come già detto l'audio di YouTube viene già normalizzato e una normalizzazione EBU R128 potrebbe risultare controproducente.

Esempio

Scarichiamo una traccia audio da YouTube e la rinominiamo orig.mp3

youtube-dl -i --extract-audio --audio-format mp3 --audio-quality 0 https://www.youtube.com/watch?v=xymjDyGIvQ4 --exec 'mv {} orig.mp3'

e analizziamone il volume

$ ffmpeg -i orig.mp3 -filter:a volumedetect -f null /dev/null

[Parsed_volumedetect_0 @ 0x55a943b5e2c0] n_samples: 20695734
[Parsed_volumedetect_0 @ 0x55a943b5e2c0] mean_volume: -15.7 dB
[Parsed_volumedetect_0 @ 0x55a943b5e2c0] max_volume: -3.0 dB
[Parsed_volumedetect_0 @ 0x55a943b5e2c0] histogram_2db: 1
[Parsed_volumedetect_0 @ 0x55a943b5e2c0] histogram_3db: 18
[Parsed_volumedetect_0 @ 0x55a943b5e2c0] histogram_4db: 1696
[Parsed_volumedetect_0 @ 0x55a943b5e2c0] histogram_5db: 76023

Ora applichiamo una normalizzazione EBU R128

ffmpeg-normalize orig.mp3 -c:a libmp3lame -b:a 320k -o ebur128.mp3

e poi una peak con volume target 0 db

ffmpeg-normalize orig.mp3 --normalization-type peak --target-level 0 -c:a libmp3lame -b:a 320k -o peak0.mp3

Ora analizziamo il volume dei due file normalizzati

$ ffmpeg -i ebur128.mp3 -filter:a volumedetect -f null /dev/null

[Parsed_volumedetect_0 @ 0x555d11c94780] n_samples: 20695734
[Parsed_volumedetect_0 @ 0x555d11c94780] mean_volume: -24.4 dB
[Parsed_volumedetect_0 @ 0x555d11c94780] max_volume: -10.1 dB
[Parsed_volumedetect_0 @ 0x555d11c94780] histogram_10db: 382
[Parsed_volumedetect_0 @ 0x555d11c94780] histogram_11db: 2813
[Parsed_volumedetect_0 @ 0x555d11c94780] histogram_12db: 6570
[Parsed_volumedetect_0 @ 0x555d11c94780] histogram_13db: 31148

$ ffmpeg -i peak0.mp3 -filter:a volumedetect -f null /dev/null

[Parsed_volumedetect_0 @ 0x5636f8793780] n_samples: 20695734
[Parsed_volumedetect_0 @ 0x5636f8793780] mean_volume: -12.7 dB
[Parsed_volumedetect_0 @ 0x5636f8793780] max_volume: -0.0 dB
[Parsed_volumedetect_0 @ 0x5636f8793780] histogram_0db: 16
[Parsed_volumedetect_0 @ 0x5636f8793780] histogram_1db: 1741
[Parsed_volumedetect_0 @ 0x5636f8793780] histogram_2db: 76022

Come si può vedere l'audio normalizzato EBU R128 risulta più basso di volume dell'originale

Risorse:
https://github.com/slhck/ffmpeg-normalize http://www.audiosonica.com/it/recensioni/post/16881/Loudness_e_sua_normalizzazione