Firefox Sync Server

Attenzione. Questa guida è da considerarsi abbandonata, per via del tempo trascorso dall'ultima verifica. Potrà essere resa obsoleta, previa segnalazione sul forum, se nessuno si propone per l'adozione.

Versioni Compatibili Debian 7 "wheezy"

Introduzione

Firefox, come Iceweasel, permette la sincronizzazione di alcuni contenuti del browser tra più installazioni degli stessi. Tramite Sync Server è possibile sincronizzare Bookmarks, Tabs, Estensioni e altre piccole cose. Mozilla permette la sincronizzazione gratuita su dei loro server. In questa guida installeremo e configureremo un nostro Sync Server che lavorerà sotto Apache ed useremo MySql come database per l' archiviazione (è possibile utilizzare anche SQLite).
In questa guida tratteremo la versione 1.5 del sync-server, la quale funziona con Firefox/Iceweasel 29 e successivi (presenti da Wheezy in poi). Per versioni precedenti rifarsi alla seguente guida

Nella guida supporremo che il computer sul quale andremo ad installare il sync-server avrà IP 192.168.1.50

Prerequisiti

Il sync-server è compatibile con le versioni di Firefox/Iceweasel 29 o maggiori, quindi occorre:

• Installazione funzionante di Firefox/Iceweasel

E, se non volete usare il web-server built-in:

• Apache2 con supporto SSL e mod per WSGI
• Database MySQL
• OpenSSL

Installazione sync-server

Installiamo per prima cosa i pacchetti necessari alla compilazione del sync-server:

# apt-get install python-dev git-core python-virtualenv virtualenv

Successivamente clonare il repository git di Mozilla contenente il sync-server, per fare questo ho deciso di lavorare in /opt:

# cd /opt
# git clone https://github.com/mozilla-services/syncserver
# cd syncserver
# make build

Il comando make build creerà un virtualenv Python in cui verranno successivamente installate tutte le dipendenze richieste dal server.
Terminata la compilazione verrà creata una cartella local/bin in cui è presente il binario pserve, utile a fini di debug poiché permette di lanciare il sync-server sfruttando un web-server built-in.
Per verificare il corretto funzionamento del sync-server sarà sufficiente dare il seguente comando:

# make test

se tutto funziona correttamente verrà restituito a schermo un OK.

Configurazione

La configurazione del sync-server avviene tramite il file syncserver.ini, di seguito un esempio di tale file:

[server:main]
use = egg:Paste#http
host = 0.0.0.0
port = 5000

[app:main]
use = egg:syncserver

[syncserver]
# This must be edited to point to the public URL of your server,
# i.e. the URL as seen by Firefox.
public_url = url_of_server

# This defines the database in which to store all server data.
#sqluri = 

# This is a secret key used for signing authentication tokens.
# It should be long and randomly-generated.
# The following command will give a suitable value on *nix systems:
#
#    head -c 20 /dev/urandom | sha1sum
#
# If not specified then the server will generate a temporary one at startup.
#secret = CHANGE_ME!!!
# Set this to "false" to disable new-user signups on the server.
# Only request by existing accounts will be honoured.
# allow_new_users = false

# Set this to "true" to work around a mismatch between public_url and
# the application URL as seen by python, which can happen in certain reverse-
# proxy hosting setups.  It will overwrite the WSGI environ dict with the
# details from public_url.  This could have security implications if e.g.
# you tell the app that it's on HTTPS but it's really on HTTP, so it should
# only be used as a last resort and after careful checking of server config.
force_wsgi_environ = true

# Uncomment and edit the following to use a local BrowserID verifier
# rather than posting assertions to the mozilla-hosted verifier.
# Audiences should be set to your public_url without a trailing slash.
#[browserid]
#backend = tokenserver.verifiers.LocalVerifier
#audiences = https://localhost:5000

Per prima cosa andremo a modificare il parametro public_url il quale andrà settato su un URL visibile dalla tua rete. In questa prima parte della guida, a scopo di test, supporremo di eseguire il server in locale in una rete di computer con indirizzo del tipo 192.168.1.x.
Apriamo quindi il file con il nostro editor preferito:

# vim /opt/syncserver/syncserver.ini

e modifichiamo la seguente riga inserendo l'url (quindi l' indirizzo IP) del pc che farà da Sync Server:

[syncserver]
public_url = http://192.168.1.50:5000

Abbiamo specificato la porta 5000 perché di default il web-server built-in è attivo su tale porta. Ovviamente se vogliamo eseguire il server su una differente porta basterà specificarlo all'avvio del server modificando di conseguenza la porta nel parametro public_url.

Di default il sync-server utilizza un database in-memory per lo storage dei dati, questo significa che al riavvio del dispositivo tutti i dati memorizzati verranno cancellati. Per questo motivo il sync-server prevede lo storage dei dati tramite database MySql o SQLite accettando qualunque URI database di SQLAlchemy. Per questa parte non specificheremo alcun tipo di database.

Lanciare il server

A questo punto possiamo eseguire il server ed effettuare dei test per verificarne il funzionamento

# local/bin/pserve syncserver.ini

se otteniamo

Starting server in PID 29951.
serving on 0.0.0.0:5000 view at http://127.0.0.1:5000

Un simile messaggio significa che il server è funzionante ed in ascolto sulla porta 5000 del proprio computer.

Configurare Firefox/Iceweasel

Come accennato in precedenza per poter dire a Firefox/Iceweasel di connettersi al proprio sync-server è necessario modificare la voce services.sync.tokenServerURI in about:config cambiando l' url del server di sincronizzazione con l' indirizzo del server nella propria subnet. Nel nostro caso quindi sarà necessario cambiare l'url nel seguente modo:

services.sync.tokenServerURI: http://192.168.1.50:5000/token/1.0/sync/1.5

Per verificare il funzionamento del server sarà sufficiente andare all' indirizzo http://192.168.1.50:5000/ e vedere se compare la scritta it works!
A questo punto sarà sufficiente creare un account di sincronizzazione andando su Preferences e successivamente sul tab Sync. Se già si dispone di un account di sincronizzazione sarà sufficiente effettuare il login, altrimenti creeremo un nuovo account e successivamente effettuiamo il login. Eseguiamo il login con lo stesso account su un altra installazione di Firefox/Iceweasel, modificando anche in questo caso il parametro services.sync.tokenServerURI e controlliamo se effettivamente avviene la sincronizzazione degli oggetti selezionati nella tab Sync delle preferenze di Firefox/Iceweasel

Sync-server dietro ad Apache2

Il web-server built-in del sync-server è utile per effettuare test sul sistema oppure se utilizzato in situazioni molto ristrette, ad esempio sincronizzando solo i computer di una rete locale.
Se vogliamo utilizzare il sync-server accedendoci dall'esterno oppure condividendolo tra più utenti è consigliato far girare il server di sincronizzazione sotto ad un'istanza di un web-server come Apache2. I motivi possono essere molti, uno dei più importanti è il poter utilizzare il protocollo SSL per rendere sicure le connessioni tra client e server, un altro motivo è la possibilità di sostenere più facilmente un numero elevato di connessioni.
Nel seguito della guida supporremo che il web-server sia accessibile tramite un nome dominio valido, noi utilizzeremo, a titolo esplicativo, ffsync.example.ext. Supporremo anche che sul web-server sia attivo e configurato il modulo SSL.

Configurazione Apache2

Il sync-server ed Apache2 potranno comunicare tra di loro tramite il protocollo WSGI, quindi per prima cosa sarà necessario abilitare il modulo WSGI di Apache2:

# a2enmod wsgi

e quindi riavviare il server Apache2

# service apache2 restart

A questo punto è necessario generare un certificato SSL per il dominio che servirà il sync-server:

# openssl req -new -x509 -days 365 -nodes -out /etc/apache2/ssl/ffsync.pem -keyout /etc/apache2/ssl/ffsync.pem

dove alla voce:

Common Name (e.g. server FQDN or YOUR name) []:

dovremo scrivere il nome dominio che useremo per contattare il server, nel nostro caso quindi ffsync.example.ext.

A questo punto dobbiamo creare un VirtualHost per dire ad Apache2 come comportarsi alla richesta del dominio scelto.
Per Debian 7 (Wheezy) creiamo un nuovo file in /etc/apache2/sites-available/ con un nome utile a ricordarci di cosa tratta:

# touch /etc/apache2/sites-available/syncserver

e quindi utilizzando il proprio editor di testo preferito creiamo il file di configurazione del nuovo VirtualHost:

<Directory /opt/syncserver>
  Order deny,allow
  Allow from all
</Directory>
 
<VirtualHost *:443>
  ServerName ffsync.example.ext
  DocumentRoot /opt/syncserver
 
  SSLEngine on
  SSLCertificateFile /etc/apache2/ssl/ffsync.pem
  SSLCertificateKeyFile /etc/apache2/ssl/ffsync.pem
 
  WSGIProcessGroup sync
  WSGIDaemonProcess sync user=ffsync group=ffsync processes=2 threads=25 python-path=/opt/syncserver/local/lib/python2.7/site-packages/
  WSGIPassAuthorization On
  WSGIScriptAlias / /opt/syncserver/syncserver.wsgi
  CustomLog /var/log/apache2/ffsync.example.ext-access.log combined
  ErrorLog  /var/log/apache2/ffsync.example.ext-error.log
</VirtualHost>

Dove ovviamente andremo a modificare il percorso alla directory del sync-server se non installata nella stessa path utilizzata nella guida nei campi DocumentRoot e <Directory /path/to/syncserver>.
La direttiva WSGIDaemonProcess andrà modificata a seconda di cosa abbiamo fatto; nel caso del parametro python-path dobbiamo sostituire alla path scritta quella utilizzata nella proria installazione del sync-server. Per quanto riguarda invece i parametri user e group, successivamente vedremo che saranno riferiti all' utente e gruppo della directory /opt/syncserver.
Anche la direttiva WSGIScriptAlias andrà cambiata in caso di differente directory di installazione.

Creazione database MySQL

In questa guida abbiamo scelto di utilizzare, come storage delle informazioni da sincronizzare, un database MySQL.

Per prima cosa andremo a creare il database

# mysql -u root -p

quindi, una volta entrati nella shell interattiva di MySQL:

mysql> CREATE DATABASE syncserver;
mysql> GRANT ALL PRIVILEGES ON syncserver.* TO sync IDENTIFIED BY "password";

Il primo comando crea il database syncserver, mentre con il secondo, in un colpo solo, creiamo l' utente sync e gli diamo pieni privilegi su tutto il database. Ovviamente il campo "password" andrà modificato inserendo una password sicura.

Riconfigurazione sync-server

Torniamo a modificare il syncserver.ini per comunicare al sync-server di accettare richieste provenienti dal URL https://ffsync.example.ext e soprattutto per istruirlo ad immagazzinare le informazioni sul nuovo database MySQL appena creato.
Modifichiamo nuovamente la voce public_url nel seguente modo:

[syncserver]
public_url = https://ffsync.example.ext/

e poi decommentiamo la riga relativa al database e inseriamo la path, con la notazione di SQLAlchemy del nostro database:

# This defines the database in which to store all server data.
sqluri = pymysql://sync:password@localhost:3306/syncserver

dove andremo a modificare utente e password con quelli scelti per la propria installazione.

A questo punto creiamo un nuovo utente che avrà come propria cartella home la directory del sync-server

# useradd -d /opt/syncserver/ -l -r -U ffsync -G www-data
# chown -R ffsync:ffsync /opt/syncserver/

È necessario aggiungere il nuovo utente creato al gruppo www-data per far si che il web-server possa interagire con il sync-server.
Tornando alla configurazione del VirtualHost di Apache2, se abbiamo scelto un nome utente differente da quello della guida dovremmo modificare il parametro WSGIDaemonProcess inserendo nome utente e gruppo scelti.

Infine sarà sufficiente abilitare il nuovo VirtualHost e riavviare Apache2 per attivare le nuove configurazioni:

# a2ensite syncserver
# service apache2 restart

Se tutto è stato scritto correttamente il server Apache2 verrà riavviato senza errori.

Riconfigurare Firefox/Iceweasel

Come detto in precedenza sarà ora necessario riconfigurare il proprio browser affinchè utilizzi il nostro server per sincronizzarsi.
Per prima cosa disconnettiamo il browser dall' account di sincronizzazione. Questo è necessario farlo perchè ogni volta che effettuiamo il logout dal nostro account di sincronizzazione Firefox/Iceweasel setta automaticamente la chiave services.sync.tokenServerURI al suo valore di default.

Entriamo in about:config e cerchiamo la chiave services.sync.tokenServerURI e modifichiamo ancora una volta il suo contenuto inserendo l' URL del nostro sync-server:

services.sync.tokenServerURI: https://ffsync.example.ext/token/1.0/sync/1.5

In seguito sarà necessario far accettare il nostro certificato SSL al browser. Andiamo su Preferences -> Advanced -> Certificates, clicchiamo sul bottone View Certificates ed infine sul tab Servers clicchiamo su Add Exception. Inseriamo l' URL del proprio server: https://ffsync.example.ext, verificate che la checkbox Permanently store this exception sia spuntata e quindi clicchiamo su Confirm Security Exception, successivamente andiamo sul tab Authorities cerchiamo il nostro server, clicchiamo su Edit Trust e spuntiamo la casella relativa alla voce This certificate can identify websites chiudiamo tutto e proviamo a navigare con il browser verso il nostro server https://ffsync.example.ext. Se il certificato è stato aggiunto correttamente tra le eccezioni di sicurezza dovremmo semplicemente vedere it works!

Non resta che prendere 2 installazioni di Firefox/Iceweasel ed accedere al proprio account e vedere se i due browser risultano sincronizzati.
É possible verificare se il server funziona consultando i log specifici nei file /var/log/apache2/ffsync.example.ext-access.log e /var/log/apache2/ffsync.example.ext-error.log.

Aggiornare il sync-server

Per mantenere aggiornato il proprio sync-server sarà sufficiente clonare il repository di mozilla periodicamente:

# cd /opt/syncserver
# git stash 
# git pull
# git stash pop
# make build

• il comando git stash serve per tener traccia dei cambiamenti effettuati a file nella directory.
• il comando git pull sincronizza il repository locale (la directory) con quello remoto.
• il comando git stash pop reinserisce le modifiche fatte ai file dopo la sincronizzazione con il repository remoto.
• il comando make build riesegue la compilazione del pacchetto aggiornato.

Approfondimenti

Sito ufficiale

---

Guida scritta da: Frenko 15:11, 16 apr 2015 (CEST)	Debianized 40%
Estesa da:
Verificata da: HAL 9000 13:55, 18 apr 2015 (CEST)
Verificare ed estendere la guida | Cos'è una guida Debianized