Setting up a local web server on OS X

The 2018 World Cup is fast approaching, with national sides making their final preparations ahead of this summer’s tournament.

We now know the groups after December’s draw. England have been put together with Belgium, Tunisia and Panama in Group G.

Gareth Southgate’s side were not among the top seeds, meaning they featured in pot two during the proceedings.

And with England’s route now mapped out, Southgate will be able to ramp up preparations for the 2018 tournament. 2018 World cup, football News ,Gaming ,Betscore ,Casino …..Sports.vin


Copia e backup di database tra host

Ci sono vari modi per esportare database di mongodb da un server all altro, me quello che ho trovato più semplice da usare è il seguente:
Connettersi al server sorgente:

ssh sourceserver.com

Eseguire i seguenti comandi dalla home:

mkdir dumps
mongodump --host 127.0.0.1 --port 27017 --db databaseName --out dumps

Adesso nella cartella dumps troverete una cartella chiamata “databaseName” che a sua volta contiene vari file corrispondenti a tutte le collection che si trovano nel db appena copiato.

In seguito connettersi al server destinazione:

ssh destinationserver.com

Eseguire i seguenti comandi dalla home:

mkdir dumps
cd dumps
mkdir databaseName
scp user@sourceserver.com:~/dumps/databasName/* databaseName/
mongorestore --host 127.0.0.1 --port 27017 databaseName

Questo è tutto. Dopo queste operazioni dovreste trovare il nuovo db in mongo.
Per verificare:

mongo
show dbs
use databaseName
show collections

Nel caso riceveste il seguente errore:
Failed global initialization: BadValue Invalid or no user locale set. Please ensure LANG and/or LC_* environment variables are set correctly.

Inserire:

export LC_ALL="en_US.UTF-8"

Per rispristinare un unica collection dal backup:
Dalla cartella dumps

mongorestore --host 127.0.0.1 --db databaseName --collection collName databaseName/collName.bson

Fine


Node Pattern: Asynchronous Loops

Un tipo di problematica ricorrente in node.js riguarda chiamate di funzioni non bloccanti (asincrone) in un ciclo, e dove il risultato dovrà essere utilizzato nel codice chiamante tramite una callback.

Facciamo il seguente esempio:

function load_album_list (callback) {
    fs.readdir("albums",
        function (err, files) {
            if (err) {
                return callback(err);
            }
            var only_dirs = [];
            for (var i = 0; i < files.length; i++) {
                fs.stat("albums/" + files[i],
                    function (err, stats) {
                        if (stats.isDirectory()) {
                            only_dirs.push(files[i]);
                        }
                    });
            }
            callback(null, only_dirs);
        });
}

Se si esegue il codice illustrato sopra si ottiene il seguente valore:
{“error”:null,”data”:{“albums”:[]}}

Il motivo è molto semplice:
Dopo l’avvio di tutte queste funzioni non bloccante, si esce dal ciclo e si chiama la callback passata come parametro. Poiché node.js è single threaded, nessuna delle funzioni fs.stat avrà avuto la possibilità di essere eseguite e chiamare le loro callback, così only_dirs è vuoto quando utilizzato.

Vi sono vari modi per risolvere questo problema.
Quello più immediato fa uso di contatori nel ciclo, ma non è molto elegante, ed è potenzialmente rischioso.
Una soluzione più elegante utilizza funzioni ricorsive con il seguente formato:

function iterator (i) {
    if( i < array.length ) {
        async_work( function(){
            iterator( i + 1 )
        })
    } else {
        callback(results);
    }
}
iterator(0)

Si può ulteriormente migliorare questo codice utilizzando una funzione anonima denominata al fine di non ingombrare lo scope con nomi di funzioni inutili al resto del codice:

(function iterator (i) {
    if( i < array.length ) {
        async_work( function(){
            iterator( i + 1 )
        })
    } else {
        callback(results);
    }
})(0);

Quindi potremmo riscrivere il codice precedente come segue:

function load_album_list (callback) {
    fs.readdir("albums",
        function (err, files) {
            if (err) {
                return callback(err);
            }
            var only_dirs = [];
            ( function iterator(index) {
                if (index == files.length) {
                    return callback(null, only_dirs);
                }
                fs.stat("albums/" + files[index],
                    function (err, stats) {
                        if (err) {
                            return callback(err);
                        }
                        if (stats.isDirectory()) {
                            only_dirs.push(files[index]);
                        }
                        iterator(index + 1)
                    }
                );
            })(0);
        }
    );
}

Ubuntu server chez nous (parte II)

Aggiungere utenti

Procedura:

adduser exampleuser
usermod -a -G sudo exampleuser
logout
ssh exampleuser@123.456.78.90

Utilizzare l’autenticazione

Procedura:

  1. Generare sulla propria macchina una coppia chiave pubblica-privata con il comando:
               ssh-keygen
             
  2. Seguire le istruzioni del wizard che compare e creare le chiavi ssh sul proprio computer. Per utilizzare le chiavi senza passphrase basta lasciare vuoto quando richiesto.
    Verranno creati due file in ~/.ssh: id_rsa e id_rsa.pub. La chiave pubblica è id_rsa.pub – Questo file dovrà essere caricato sul server. L’altro file è la chiave privata, da non condividere con nessuno!
  3. Caricare la propria chiave pubblica sul server:
               	scp ~/.ssh/id_rsa.pub example_user@123.456.78.90:
             
  4. Creare una directory .ssh nella propria home e spostare lì la propria chiave pubblica modificando il nome in authorized_keys:
               	mkdir .ssh
                    mv id_rsa.pub .ssh/authorized_keys
             
  5. Modificare i permessi della propria chiave pubblica:
               chown -R example_user:example_user .ssh
               chmod 700 .ssh
               chmod 600 .ssh/authorized_keys
             

Disabilitare l’autenticazione tramite password e il login dell’utente root

Procedura:

  1. Aprire il file di configurazione di ssh:
    sudo nano /etc/ssh/sshd_config
             
  2. modificare le seguenti opzioni:
    PasswordAuthentication no
    PermitRootLogin no
             
  3. Restartare ssh:
    sudo service ssh restart
             

Ubuntu server chez nous (parte I)

Queste sono le configurazioni di base che ci piacciono di più:

Impostare l’hostname

Modificare /etc/hostname

echo "un bel nome altisonante di filosofo o di divinità greca" > /etc/hostname
hostname -F /etc/hostname

Se esistesse, bisogna editare il file /etc/default/dhcpcd e commentare la direttiva SET_HOSTNAME:

Parte del file /etc/default/dhcpcd

#SET_HOSTNAME='yes'

Modificare /etc/hosts

Essendo alla prima connessione ssh non c’è bisogno di sudo quindi

nano /etc/hosts

Inserire le seguenti righe avendo l’accortezza di sostituire “zeus” con l’hostname scelto

127.0.0.1 localhost.localdomain localhost 
12.34.56.78 zeus.example.com zeus 
2600:3c01::a123:b456:c789:d012 zeus.example.com zeus

Impostare la timezone

dpkg-reconfigure tzdata

Controllare data e ora

data

Aggiornare il software

apt-get update
apt-get upgrade --show-upgraded

response.end(“Welcome!\n”);

Ciao a tutti,

questo è il blog di sviluppo della cooperativa Yes I Code. Nel tempo speriamo che diventi un buon posto in italiano dove discutere di codice e trovare qualche pattern di soluzione ai problemi quotidiani degli sviluppatori.

Buon Divertimento!