Petar Karan

[owncloud] Installare ownCloud su Ubuntu Server 20.04.1, configurazione VirtualHost, certificato HTTPS e disco dati con LVM

Vediamo come installare ownCloud su un Ubuntu Server 20.04.1. In aggiunta configureremo anche un VirtualHost con un certificato autofirmato, aggiungendo infine un disco in LVM che ospiti i dati di ownCloud.

1. Configurazione server LAMP

Anzitutto configuriamo il server LAMP installando Apache, MariaDB e il PHP 7.4.

Eseguiamo il seguente comando:

sudo apt install -y apache2 libapache2-mod-php mariadb-server php-imagick php-common php-curl php-gd php-imap php-intl php-json php-mbstring php-mysql php-ssh2 php-xml php-zip php-apcu php-redis redis-server bzip2 rsync curl jq inetutils-ping smbclient coreutils php-ldap

1	sudo apt install -y apache2 libapache2-mod-php mariadb-server php-imagick php-common php-curl php-gd php-imap php-intl php-json php-mbstring php-mysql php-ssh2 php-xml php-zip php-apcu php-redis redis-server bzip2 rsync curl jq inetutils-ping smbclient coreutils php-ldap

A questo punto configuriamo il database eseguendo:

sudo mysql_secure_installation

1	sudo mysql_secure_installation

ATTENZIONE! Se si esegue il commando senza sudo verrà chiesta la password dell’utente root e non ci sarà modo di cambiarla, generando l’errore: ERROR 1698 (28000): Access denied for user 'root'@'localhost'

Digitare in sequenza, per le singole domande:

Change the root password? [Y/n] Y

Remove anonymous users? [Y/n] Y

Disallow root login remotely? [Y/n] Y

Remove test database and access to it? [Y/n] Y

Reload privilege tables now? [Y/n] Y

Una volta completata la configurazione di MariaDB il server LAMP e pronto è possiamo procedere con le specifiche configurazioni.

2. Creiamo il certificato di crittografia

Se non lo abbiamo già fatto installiamo openssl. Questo ci servirà per creare un certificato autofirmato, nel caso in cui si disponga già del certificato si può passare al punto successivo.

sudo apt-get install openssl

1	sudo apt-get install openssl

Creiamo la chiave privata e il certificato:

sudo openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout /etc/ssl/private/cloud.local.2020.key -out /etc/ssl/certs/cloud.local.2020.crt

1	sudo openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout /etc/ssl/private/cloud.local.2020.key -out /etc/ssl/certs/cloud.local.2020.crt

Nel caso specifico stiamo dicendo ad openssl:

req sottocomando col quale specifichiamo che vogliamo usare l’X.509 CSR (certificate signing request), un’infrastruttura standard per le chiavi pubbliche utilizzata tipicamente con SSL e TSL
nodes indica ad OpenSSL di non cifrare il certificato con una password, dal momento che verrà utilizzato su Apache che deve potervi accedere liberamente
days specifica la durata di validità del certificato, nel nostro caso 365 giorni
newkey specifica il tipo di chiave privata (RSA 2048) che si vuole generare e il fatto che la si voglia generare assieme al certificato
keyout indica la posizione dove creare la chiave
out indica la posizione dove creare il certificato

Rispondiamo ai quesiti posti da OpenSSL per la configurazione del certificato. Nel mio caso procederò così:

Country Name (2 letter code) [AU]:IT
State or Province Name (full name) [Some-State]:Firenze
Locality Name (eg, city) []:Firenze
Organization Name (eg, company) [Internet Widgits Pty Ltd]:Torregatti Spa
Organizational Unit Name (eg, section) []:Servizi Cloud
Common Name (e.g. server FQDN or YOUR name) []:cloud.local
Email Address []:scrivi@petarkaran.it

I valori sono per lo più arbitrari, l’unica cosa importante è il Common Name, che può essere l’indirizzo IP del server, oppure il dominio a cui sarà associato il certificato.

Configuriamo Apache affinché utilizzi correttamente i certificati SSL:

sudo nano /etc/apache2/conf-available/certificati.conf

1	sudo nano /etc/apache2/conf-available/certificati.conf

Nel file digitiamo:

SSLCipherSuite EECDH+AESGCM:EDH+AESGCM:AES256+EECDH:AES256+EDH
SSLProtocol All -SSLv2 -SSLv3 -TLSv1 -TLSv1.1
SSLHonorCipherOrder On
Header always set X-Frame-Options DENY
Header always set X-Content-Type-Options nosniff
SSLCompression off
SSLUseStapling on
SSLStaplingCache "shmcb:logs/stapling-cache(150000)"
SSLSessionTickets Off

SSLCipherSuite EECDH+AESGCM:EDH+AESGCM:AES256+EECDH:AES256+EDH

SSLProtocol All -SSLv2 -SSLv3 -TLSv1 -TLSv1.1

SSLHonorCipherOrder On

Header always set X-Frame-Options DENY

Header always set X-Content-Type-Options nosniff

SSLCompression off

SSLUseStapling on

SSLStaplingCache "shmcb:logs/stapling-cache(150000)"

SSLSessionTickets Off

Affinché la configurazione funzioni dobbiamo attivare il modulo SSL e il modulo Headers in Apache.

sudo a2enmod ssl
sudo a2enmod headers

1 2	sudo a2enmod ssl sudo a2enmod headers

A questo punto attiviamo la configurazione digitando:

sudo a2enconf certificati

1	sudo a2enconf certificati

Affinché la configurazione sia corretta bisogna riavviare Apache, anche se non è necessario farlo adesso, lo possiamo fare anche dopo.

sudo service apache2 reload

1	sudo service apache2 reload

3. Configuriamo il VirtualHost

A questo punto configuriamo il nostro VirtualHost, immaginiamo che il nostro ownCloud debba trovarsi all’indirizzo cloud.local. (nel caso specifico da http://cloud.local e https://cloud.local)

Creiamo anzitutto due cartelle in /var/www, una per i file, una per i dati ed una per i log, entrambe sottocartelle di cloud.local, nella maniera seguente.

sudo mkdir -p /var/www/cloud.local/httpdocs
sudo mkdir -p /var/www/cloud.local/logs
sudo mkdir -p /var/www/cloud.local/dati

sudo mkdir -p /var/www/cloud.local/httpdocs

sudo mkdir -p /var/www/cloud.local/logs

sudo mkdir -p /var/www/cloud.local/dati

Grazie all’argomento -p creiamo l’intero percorso anche se non esiste.

A questo punto procediamo con la creazione del file del VirtualHost vero e proprio.

sudo nano /etc/apache2/sites-available/cloud.local.conf

1	sudo nano /etc/apache2/sites-available/cloud.local.conf

Nel file inseriamo le seguenti istruzioni.

<VirtualHost *:80>

        ServerName cloud.local
        ServerAlias www.cloud.local

        DocumentRoot /var/www/cloud.local/httpdocs

        ErrorLog /var/www/cloud.local/logs/error.log
        CustomLog /var/www/cloud.local/logs/access.log combined

        Redirect permanent "/" "https://cloud.local/"

</VirtualHost>

<IfModule mod_ssl.c>
        <VirtualHost *:443>

                ServerName cloud.local
                ServerAlias www.cloud.local

                DocumentRoot /var/www/cloud.local/httpdocs

                ErrorLog /var/www/cloud.local/logs/error.log
                CustomLog /var/www/cloud.local/logs/access.log combined

                SSLEngine on

                SSLCertificateFile      /etc/ssl/certs/cloud.local.2020.crt
                SSLCertificateKeyFile   /etc/ssl/private/cloud.local.2020.key

                <FilesMatch "\.(cgi|shtml|phtml|php)$">
                        SSLOptions +StdEnvVars
                </FilesMatch>
                <Directory /usr/lib/cgi-bin>
                        SSLOptions +StdEnvVars
                </Directory>

        </VirtualHost>
</IfModule>

<Directory /var/www/cloud.local/httpdocs/>
        Options +FollowSymlinks -Indexes
        AllowOverride All

        <IfModule mod_dav.c>
                Dav off
        </IfModule>

        SetEnv HOME /var/www/cloud.local/httpdocs
        SetEnv HTTP_HOME /var/www/cloud.local/httpdocs
</Directory>

ServerName cloud.local

ServerAlias www.cloud.local

DocumentRoot /var/www/cloud.local/httpdocs

ErrorLog /var/www/cloud.local/logs/error.log

CustomLog /var/www/cloud.local/logs/access.log combined

Redirect permanent "/" "https://cloud.local/"

</VirtualHost>

ServerName cloud.local

ServerAlias www.cloud.local

DocumentRoot /var/www/cloud.local/httpdocs

ErrorLog /var/www/cloud.local/logs/error.log

CustomLog /var/www/cloud.local/logs/access.log combined

SSLEngine on

SSLCertificateFile /etc/ssl/certs/cloud.local.2020.crt

SSLCertificateKeyFile /etc/ssl/private/cloud.local.2020.key

SSLOptions +StdEnvVars

</FilesMatch>

SSLOptions +StdEnvVars

</Directory>

</VirtualHost>

</IfModule>

Options +FollowSymlinks -Indexes

AllowOverride All

Dav off

</IfModule>

SetEnv HOME /var/www/cloud.local/httpdocs

SetEnv HTTP_HOME /var/www/cloud.local/httpdocs

</Directory>

In questo modo forziamo il redirect sul HTTPS e abilitiamo il certificato creato in precedenza.

A questo punto riavviamo apache:

sudo service apache2 restart

1	sudo service apache2 restart

4. Creazione partizione per i dati con LVM

Aggiungiamo al nostro server un disco aggiuntivo a creiamo un nuovo disco logico con LVM. Per ulteriori approfondimenti sulla procedura rimando all’articolo LVM, gestore logico dei volumi su Ubuntu [per pinguini alle prime armi]

Anzitutto vediamo i dischi dei quali disponiamo con:

sudo fdisk -l

1	sudo fdisk -l

Nel mio caso (sto utilizzando VirtualBox per l’esempio con 2 dischi da 10GB ciascuno):

Il disco che utilizzerò è /dev/sdb. Procediamo quindi a preparare il disco:

sudo fdisk /dev/sdb

1	sudo fdisk /dev/sdb

Su fdisk digitiamo in ordine:

n per creare una nuova partizione
p per una partizione primaria
1 numero di partizione
INVIO per confermare il primo settore di default 2048
INVIO per confermare l’ultimo settore
t per modificare la partizione
8e per impostare Linux LVM
w per scrivere e salvare il tutto

Utilizzando sudo fdisk -l dovremmo vedere qualcosa di simile:

Creiamo un volume fisico digitando:

sudo pvcreate /dev/sdb1

1	sudo pvcreate /dev/sdb1

Creiamo un gruppo di volumi chiamato dati-cloud digitando:

sudo vgcreate dati-cloud /dev/sdb1

1	sudo vgcreate dati-cloud /dev/sdb1

Creiamo sopra il volume logico dati:

sudo lvcreate -l 100%FREE -n dati dati-cloud

1	sudo lvcreate -l 100%FREE -n dati dati-cloud

Formattiamo il volume in ext4.

sudo mkfs -t ext4 /dev/dati-cloud/dati

1	sudo mkfs -t ext4 /dev/dati-cloud/dati

A questo punto montiamo il nuovo volume logico sulla cartella /var/www/cloud.local/dati

sudo mount /dev/dati-cloud/dati /var/www/cloud.local/dati

1	sudo mount /dev/dati-cloud/dati /var/www/cloud.local/dati

Siccome vogliamo che il disco sia montato in modo permanente, modifichiamo /etc/fstab.

sudo nano /etc/fstab

1	sudo nano /etc/fstab

In fondo al file aggiungiamo la seguente riga:

/dev/dati-cloud/dati /var/www/cloud.local/dati ext4 rw,defaults 0 0

1	/dev/dati-cloud/dati /var/www/cloud.local/dati ext4 rw,defaults 0 0

In questo modo al riavvio del server il volume logico verrà caricato automaticamente.

5. Creiamo un database per ownCloud

ownCloud necessita di un database per funzionare, pertanto creiamone uno nuovo all’interno di MariaDB.

Entriamo in MariaDB/MySQL:

sudo mysql -u root

1	sudo mysql -u root

Una volta dentro creiamo un nuovo database chiamato cloud_db:

CREATE DATABASE cloud_db;

1	CREATE DATABASE cloud_db;

Creiamo anche un utente per il database appena creato, che potrà accedere esclusivamente da locale (agli scopi dell’esercizio metterò una password banale):

CREATE USER 'cloud_user'@'localhost' IDENTIFIED BY 'password123';
GRANT ALL PRIVILEGES ON cloud_db.* TO 'cloud_user'@'localhost';
FLUSH PRIVILEGES;

CREATE USER 'cloud_user'@'localhost' IDENTIFIED BY 'password123';

GRANT ALL PRIVILEGES ON cloud_db.* TO 'cloud_user'@'localhost';

FLUSH PRIVILEGES;

6. Installazione ownCloud

Scarichiamo ownCloud nella cartella httpdocs. Da qui possiamo scegliere da dove scaricarlo.

sudo wget https://download.owncloud.org/community/owncloud-complete-20200731.zip

1	sudo wget https://download.owncloud.org/community/owncloud-complete-20200731.zip

Se non abbiamo installato unzip facciamolo:

sudo apt-get install unzip

1	sudo apt-get install unzip

A questo punto estraiamo il file zip.

sudo unzip owncloud-complete-20200731.zip

1	sudo unzip owncloud-complete-20200731.zip

Spostiamo i file dalla cartella owncloud creata dall’unzip, nella radice del virtualhost.

sudo rm owncloud-complete-20200731.zip
sudo mv owncloud/* .
sudo mv owncloud/.* .
sudo rm -r owncloud/

sudo rm owncloud-complete-20200731.zip

sudo mv owncloud/* .

sudo mv owncloud/.* .

sudo rm -r owncloud/

In questo modo rimuoviamo anche la cartella aggiuntiva ed il file zip.

Assegniamo adesso l’utente apache a tutta la cartella ed i file creati.

sudo chown -R www-data:www-data /var/www/cloud.local/

1	sudo chown -R www-data:www-data /var/www/cloud.local/

Infine abilitiamo la configurazione e riavviamo apache:

sudo a2ensite cloud.local
sudo service apache2 restart

1 2	sudo a2ensite cloud.local sudo service apache2 restart

Se tutto è andato bene potremo aprire ownCloud all’indirizzo https://cloud.local/

Inseriamo i parametri nella maniera seguente (utilizzando quelli creati):

Scegliamo un utente ed una password
Per la cartella dati impostiamo la cartella creata all’inizio
Inseriamo i dati del database configurati in precedenza:

Una volta fatto tutto possiamo premere su TERMINA CONFIGURAZIONE.

Se tutto è andato bene vedremo una schermata come la seguente:

Fatto tutto questo possiamo accedere al sistema. Spostandoci su Impostazioni > Generali, potremmo notare delle notifiche come le seguenti:

Apportiamo quindi ancora un paio di modifiche per aggiustare il tutto correttamente.

Anzitutto configuriamo correttamente il crontab affinché esegua gli script di ownCloud.

Digitiamo:

sudo crontab -u www-data -e

1	sudo crontab -u www-data -e

Se è la prima volta che lo apriamo ci chiederà quale editor preferiamo utilizzare, io scelgo 1 per nano.

Aggiungiamo la seguente riga:

*/15  *  *  *  * /var/www/cloud.local/httpdocs/occ system:cron

1	/15 * * * /var/www/cloud.local/httpdocs/occ system:cron

Salviamo con CTRL+O e usciamo.

Nelle suddette impostazioni di ownCloud selezioniamo come meccanismo di aggiornamento Cron.

Spostiamoci nella nostra cartella di installazione con:

cd /var/www/cloud.local/httpdocs/

1	cd /var/www/cloud.local/httpdocs/

Eseguiamo i seguenti comandi:

sudo -u www-data ./occ config:system:set memcache.local --value '\OC\Memcache\APCu'
sudo -u www-data ./occ config:system:set memcache.locking --value '\OC\Memcache\Redis'
sudo -u www-data ./occ config:system:set redis --value '{"host": "127.0.0.1", "port": "6379"}' --type json

sudo -u www-data ./occ config:system:set memcache.local --value '\OC\Memcache\APCu'

sudo -u www-data ./occ config:system:set memcache.locking --value '\OC\Memcache\Redis'

sudo -u www-data ./occ config:system:set redis --value '{"host": "127.0.0.1", "port": "6379"}' --type json

L’utilizzo di sudo -u www-data è necessario perché l’esecuzione deve essere effettuata da Apache. Eseguendolo senza sudo lo faremmo usando il nostro utente, con sudo come root. In entrambi i casi non andrebbe bene.

Per risolvere l’avviso di HTTP "Strict-Transport-Security" dobbiamo aggiungere a <VirtualHost *:443> le seguenti tre righe:

<IfModule mod_headers.c>
        Header always set Strict-Transport-Security "max-age=15552000; includeSubDomains"
</IfModule>

Header always set Strict-Transport-Security "max-age=15552000; includeSubDomains"

</IfModule>

Il file definitivo del virtualhost sarà come il seguente:

<VirtualHost *:80>

        ServerName cloud.local
        ServerAlias www.cloud.local

        DocumentRoot /var/www/cloud.local/httpdocs

        ErrorLog /var/www/cloud.local/logs/error.log
        CustomLog /var/www/cloud.local/logs/access.log combined

        Redirect permanent "/" "https://cloud.local/"

</VirtualHost>

<IfModule mod_ssl.c>
        <VirtualHost *:443>

                ServerName cloud.local
                ServerAlias www.cloud.local

                DocumentRoot /var/www/cloud.local/httpdocs

                ErrorLog /var/www/cloud.local/logs/error.log
                CustomLog /var/www/cloud.local/logs/access.log combined

                SSLEngine on

                SSLCertificateFile      /etc/ssl/certs/cloud.local.2020.crt
                SSLCertificateKeyFile   /etc/ssl/private/cloud.local.2020.key

                <FilesMatch "\.(cgi|shtml|phtml|php)$">
                        SSLOptions +StdEnvVars
                </FilesMatch>
                <Directory /usr/lib/cgi-bin>
                        SSLOptions +StdEnvVars
                </Directory>

                <IfModule mod_headers.c>
                        Header always set Strict-Transport-Security "max-age=15552000; includeSubDomains"
                </IfModule>

        </VirtualHost>
</IfModule>

<Directory /var/www/cloud.local/httpdocs/>
        Options +FollowSymlinks
        AllowOverride All

        <IfModule mod_dav.c>
                Dav off
        </IfModule>

        SetEnv HOME /var/www/cloud.local/httpdocs
        SetEnv HTTP_HOME /var/www/cloud.local/httpdocs
</Directory>

ServerName cloud.local

ServerAlias www.cloud.local

DocumentRoot /var/www/cloud.local/httpdocs

ErrorLog /var/www/cloud.local/logs/error.log

CustomLog /var/www/cloud.local/logs/access.log combined

Redirect permanent "/" "https://cloud.local/"

</VirtualHost>

ServerName cloud.local

ServerAlias www.cloud.local

DocumentRoot /var/www/cloud.local/httpdocs

ErrorLog /var/www/cloud.local/logs/error.log

CustomLog /var/www/cloud.local/logs/access.log combined

SSLEngine on

SSLCertificateFile /etc/ssl/certs/cloud.local.2020.crt

SSLCertificateKeyFile /etc/ssl/private/cloud.local.2020.key

SSLOptions +StdEnvVars

</FilesMatch>

SSLOptions +StdEnvVars

</Directory>

Header always set Strict-Transport-Security "max-age=15552000; includeSubDomains"

</IfModule>

</VirtualHost>

</IfModule>

Options +FollowSymlinks

AllowOverride All

Dav off

</IfModule>

SetEnv HOME /var/www/cloud.local/httpdocs

SetEnv HTTP_HOME /var/www/cloud.local/httpdocs

</Directory>

Riavviamo ancora una volta apache.

sudo service apache2 restart

1	sudo service apache2 restart

A questo punto è tutto pronto e possiamo cominciare ad usare ownCloud.

[FIFA21] La connessione con l’avversario si è interrotta

Problema: Quando a FIFA21 si cerca di giocare con un amico online non sembra possibile stabilire una connessione e dopo poco compare il messaggio “La connessione con l’avversario si è interrotta“

Soluzione: Assicurarsi che il router abbia abilitata l’opzione UPnP, in alternativa aprire tutte le porte necessarie sul firewall, infine provare a riavviare la connessione con il gioco aperto (questo farà sì che nel gioco venga ripristinata la connessione)

Premetto che resto convinto che la cosa dipenda quasi esclusivamente dai server EA, e che spesso sia sufficiente provare diverse volte con ostinazione. Vediamo comunque le possibili soluzioni da adottare nel dettaglio.

1. Attivare UPnP sul router

Anzitutto accedere al router. Di solito per individuarlo è sufficiente premere WIN+R e digitare cmd nella finestra di Esegui.

Nel Prompt dei comandi digitare poi ipconfig e premere INVIO. Apparirà un risultato simile al seguente:

Nel mio caso vedo che il mio computer si trova all’indirizzo 192.168.1.76, mentre il router (che si trova di solito sul gateway) è all’indirizzo 192.168.1.254

L’indirizzo dei router domestici di solito si trova su: 192.168.1.1, 192.168.0.1, 192.168.1.254, 192.168.0.254

Una volta individuato l’indirizzo corretto digitarlo nel browser (per esempio Chrome) nella barra dell’indirizzo.

Accedere con nome utente e password, in base al router che si ha a disposizione.

Individuare le impostazioni di rete, oppure le impostazioni avanzate del router. Di solito in tale posizione si trova la configurazione per l’UPnP.

Nel caso di un MediaAccess di Technicolor (il router in dotazione con la fibra di FastWeb, nel mio specifico caso il modello è il MediaAccess FGA2130FWB) l’opzione si trova sotto Avanzate > Configurazione semplificata delle porte

Assicurarsi che l’UPnP sia attivo nella maniera seguente:

Faccio notare che, su questo modello di router, dovreste poter già notare il tunneling aperto per FIFA21.

Se l’opzione è attiva non è necessario aprire le porte (o almeno non dovrebbe esserlo). Si può comunque tentare se il problema persiste.

2. Aprire le porte necessarie sul firewall

L’altra soluzione papabile è quella di aprire le opportune porte sul firewall del router. Accedendo al router sempre secondo la procedura precedente, abilitare le seguenti porte in base alla console di gioco (io ho FIFA21 sul PC con Steam, ma riporto anche le altre configurazioni)

	TCP	UDP
PC	3569,8080,9946,9988,10000-20000,42124	3659,9000-9999
PlayStation 4	1935,3478-3480,3659,10000-10099,42127	3074,3478-3479,3659,6000
Steam	3569,8080,9946,9988,10000-20000,27015-27030,27036-27037,42124	3659,4380,9000-9999,27000-27031,27036
Xbox One	3074,3659	88,500,3074,3544,3659,4500
Xbox Series X	3074,3659	88,500,3074,3544,3659,4500
PlaySation 5	1935,3478-3480,3659,10000-10099,42127	3074,3478-3479,3659,6000

Dalla mia esperienza dovrebbe essere comunque sufficiente l’UPnP.

3. Ripristinare la connessione durante il gioco

Nonostante l’UPnP attivo correttamente e le porte configurate sul firewall il gioco potrebbe lo stesso non partire (dando il solito errore di prima). In tal caso procedere nella maniera seguente.

Avviare il gioco
Mentre il gioco è avviato premere ALT+TAB per tornare su windows (oppure il tasto WIN), senza però spegnere il gioco
Una volta su Windows aprire il Panello di Controllo (su Windows 10 basta cercarlo nella ricerca)
Andare su Rete e Internet
Selezionare Centro connessioni di rete e condivisione
Sulla sinistra selezionare Modifica impostazioni scheda
Identificare la propria scheda di rete, potrebbe essere quella wireless oppure ethernet, in base alla connessione e cliccarci sopra col destro
Mentre il gioco è acceso cliccare su Disabilita
Tornare al gioco, a questo punto dovrebbe comparire un avviso che ci informa che ci siamo disconnessi dal server EA
Usando ALT+TAB tornare nuovamente sul desktop
Cliccare nuovamente sulla connessione col destro e scegliere abilita
Tornare nel gioco e provare a collegarsi online (ci verrà detto che sta venendo effettuata la connessione)

La procedura di disconnessione dovrebbe ripristinare la connessione col server EA. Questo passaggio sembra l’unico in grado di consentire effettivamente la connessione con l’avversario.

Conclusione

Nella mia configurazione non ho inserito le porte sul firewall, ma ho lasciato solamente attivo l’UPnP. Ciononostante avviare una partita online con un amico è pressoché impossibile al primo colpo. Dopo il primo errore di solito provo la procedura per ripristinare la connessione come al punto 3, e a quel punto il gioco online parte. In ogni caso il mio consiglio è di riprovare più volte, spesso dopo quei 20 minuti buoni di tentativi, di solito ripristinando più volte la connessione, il gioco alla fine decide che si può giocare online con un amico.

[FIFA21] Giocare da Steam, utilizzando il controller della PS4

Con mia grande soddisfazione FIFA21 è finalmente uscito anche per Steam. Ma funzionerà tutto bene, lontano dalle assurdità di Origin?

Se state usando un controller DualShock4 per PS4, è molto probabile che il gioco parta senza vedere il controller.

Per risolvere la cosa procediamo nella maniera seguente.

1. Dall’elenco dei giochi su Steam individuiamo EA SPORTS™ FIFA 21 e clicchiamoci sopra col destro. Andiamo su Gestisci > Sfoglia i file locali

2. Dalla cartella di installazione di FIFA21 andiamo su FIFASetup

3. Individuiamo il file config.ini e modifichiamolo con un editor di testo (per esempio Notepad)

4. Modifichiamo il file aggiungendo in fondo AUTO_LAUNCH = 1 e lasciando tutto il resto inalterato.

LAUNCH_EXE = fifa21.exe
SETTING_FOLDER = 'FIFA 21'
AUTO_LAUNCH = 1

LAUNCH_EXE = fifa21.exe

SETTING_FOLDER = 'FIFA 21'

AUTO_LAUNCH = 1

Una volta apportata la modifica salviamo il file.

Fatto questo avviamo Steam Big Picture e da dentro a SBP avviamo FIFA21, tenendo il controller DS4 collegato (nella mia configurazione ho il controller collegato al PC tramite cavo USB).

Per avviare Steam Big Picture è sufficiente cliccare sull’apposita icona in alto a destra su Steam.

Se abbiamo fatto tutto correttamente possiamo giocare a FIFA21 con il controller DualShock della PS4.

[javascript] Uncaught TypeError: Cannot read property ‘msie’ of undefined

Dalla versione jQuery 1.9 alcune funzionalità sono state deprecate, tra le quali anche quella di $.browser. Questo pò produrre errori come: Uncaught TypeError: Cannot read property 'msie' of undefined

Per risolvere il problema è sufficiente aggiungere la seguente istruzione dopo aver importato jQuery:

jQuery.browser = {};
(function () {
    jQuery.browser.msie = false;
    jQuery.browser.version = 0;
    if (navigator.userAgent.match(/MSIE ([0-9]+)\./)) {
        jQuery.browser.msie = true;
        jQuery.browser.version = RegExp.$1;
    }
})();

jQuery.browser = {};

(function () {

jQuery.browser.msie = false;

jQuery.browser.version = 0;

if (navigator.userAgent.match(/MSIE ([0-9]+)\./)) {

jQuery.browser.msie = true;

jQuery.browser.version = RegExp.$1;

}

})();

[ubuntu] Load balancer su Ubuntu Server 20.04.1 con Apache e Pound

In questa guida vedremo come configurare un load balancer utilizzando Pound su Ubuntu Server 20.04.1.

Pound è un software opensource sviluppato principalmente come reverse proxy e application firewall, utilizzato spesso per realizzare load balancer. Tra le caratteristiche salienti ci sono la capacità di rilevare lo stato di un server di backend, la possibilità di tradurre richieste in HTTPS su HTTP e un forte accento sulla sicurezza. Quando un server di backend non è raggiungibile Pound è in grado di rilevarlo, scegliendo tra gli altri server accessibili secondo criteri predefiniti a distribuzione casuale. Il tutto avviene tenendo traccia delle sessioni attive, che tipicamente permangono verso il medesimo server di backend di partenza.

La struttura che andremo a realizzare assomiglierà alla seguente:

Detto questo installiamo Ubuntu Server su tutte e tre le macchine e configuriamo opportunamente gli indirizzi di rete.

1. Configurazione rete

Questa operazione dovrà essere ripetuta in modo uguale su tutte le macchine. Procediamo con la prima. Prima di andare avanti vediamo la configurazione che vogliamo avere.

Creeremo una rete 192.168.0.0/24 nella quale le tre macchine saranno configurate nella maniera seguente:

load-balancer-server            192.168.0.5
webserver-1                     192.168.0.6
webserver-2                     192.168.0.7

load-balancer-server 192.168.0.5

webserver-1 192.168.0.6

webserver-2 192.168.0.7

Per visualizzare la configurazione di rete corrente (comincio dalla prima macchina) digitiamo

ip a

ip a

Comparirà qualcosa di simile:

Nel mio caso sto utilizzando una macchina virtuale con VirtualBox e la scheda di rete è enp0s3. Tipicamente al suo posto si trova eth1. L’indirizzo configurato dal DHCP è il 192.168.0.4.

La configurazione di rete si trova in /etc/netplan

Per vedere tutti i file di configurazione presenti digitiamo:

ls /etc/netplan

1	ls /etc/netplan

dovremmo vedere un file tipo 00-installer-config.yaml

Creiamone un backup del file digitando:

sudo cp /etc/netplan/00-installer-config.yaml /etc/netplan/00-installer-config.yaml.bck

1	sudo cp /etc/netplan/00-installer-config.yaml /etc/netplan/00-installer-config.yaml.bck

Adesso andiamo a modificare il file, bisogna fare attenzione all’identazione, che prevede 2 spazi vuoti per ciascuna sottosezione. Digitiamo:

sudo nano /etc/netplan/00-installer-config.yaml

1	sudo nano /etc/netplan/00-installer-config.yaml

Il file originale dovrebbe contenere qualcosa di simile:

# This is the network config written by 'subiquity'
network:
  ethernets:
    enp0s3:
      dhcp4: true
  version: 2

# This is the network config written by 'subiquity'

network:

ethernets:

enp0s3:

dhcp4: true

version: 2

Modifichiamolo nella maniera seguente:

# This is the network config written by 'subiquity'
network:
  ethernets:
    enp0s3:
      dhcp4: no
      addresses: [192.168.0.5/24]
      gateway4: 192.168.0.1
      nameservers:
        addresses: [8.8.8.8, 8.8.4.4]
  version: 2

# This is the network config written by 'subiquity'

network:

ethernets:

enp0s3:

dhcp4: no

addresses: [192.168.0.5/24]

gateway4: 192.168.0.1

nameservers:

addresses: [8.8.8.8, 8.8.4.4]

version: 2

Il mio gateway è il 192.168.0.1, per scoprirlo tramite DHCP possiamo digitare ip r

Una volta modificata la configurazione salviamo il file e testiamola digitando:

sudo netplan try

1	sudo netplan try

Se va tutto bene possiamo applicare la modifica, digitando:

sudo netplan apply

1	sudo netplan apply

Verifichiamo infine la configurazione con:

ip a

ip a

Se tutto è andato bene vedremo qualcosa del genere:

Se dovessimo cambiare il nome della macchina possiamo digitare:

sudo hostnamectl set-hostname webserver-1

1	sudo hostnamectl set-hostname webserver-1

Per assegnare alla macchina il nome webserver-1. Una volta modificato il nome sarà sufficiente riavviare.

2. Installazione di Pound

Adesso procediamo ad installare Pound su load-balancer-server. Per farlo digitiamo:

sudo apt-get install pound

1	sudo apt-get install pound

Per configurare Pound procediamo a modificare il file /etc/pound/pound.cfg. Digitiamo quindi:

sudo nano /etc/pound/pound.cfg

1	sudo nano /etc/pound/pound.cfg

Troveremo di default una struttura simile alla seguente nel file:

ListenHTTP
        Address 127.0.0.1
        Port    8080

        ## allow PUT and DELETE also (by default only GET, POST and HEAD)?:
        xHTTP           1

        Service
                BackEnd
                        Address 127.0.0.1
                        Port    80
                End
        End
End

ListenHTTP

Address 127.0.0.1

Port 8080

## allow PUT and DELETE also (by default only GET, POST and HEAD)?:

xHTTP 1

Service

BackEnd

Address 127.0.0.1

Port 80

End

Questo significa che Pound è in ascolto sulla porta 8080 e utilizza come servizio un server di backend sempre all’indirizzo locale (qui si suppone si sia installato apache sul medesimo server). Adesso i servizi possono essere definiti in modo globale oppure relativamente ad uno specifico listener. In questo caso sono definiti all’interno di un listener. Ogni servizio ha dentro i server di backend ai quali può essere data una priorità. La priorità di predefinito è impostata su 5, i valori possibili sono da 1 a 9.

Riorganizziamo il nostro file di configurazione per ottenere il seguente risultato:

## Minimal sample pound.cfg
##
## see pound(8) for details

######################################################################
## global options:

User            "www-data"
Group           "www-data"
#RootJail       "/chroot/pound"

## Logging: (goes to syslog by default)
##      0       no logging
##      1       normal
##      2       extended
##      3       Apache-style (common log format)
LogLevel        3 # <-- impostiamo il log level a 3

## check backend every X secs:
Alive           30

## use hardware-accelleration card supported by openssl(1):
#SSLEngine      "<hw>"

# poundctl control socket
Control "/var/run/pound/poundctl.socket"


######################################################################
## listen, redirect and ... to:

## redirect all requests on port 8080 ("ListenHTTP") to the local webserver (see "Service" below):
ListenHTTP
        Address 127.0.0.1
        Port    80 # <-- cambiamo la porta da 8080 su 80

        ## allow PUT and DELETE also (by default only GET, POST and HEAD)?:
        #xHTTP          1 # <-- commentiamo questa riga
End

# configuriamo anche l'ascolto sul HTTPs, lasciamo commentato se non abbiamo il certificato
#ListenHTTPS
#        Address 127.0.0.1
#        Port 443
#        Cert "/etc/ssl/pound.pem"
#End

Service
        BackEnd
                Address 192.168.0.6
                Port 80
        End

        BackEnd
                Address 192.168.0.7
                Port 80
                Priority 5
        End
End

## Minimal sample pound.cfg

## see pound(8) for details

######################################################################

## global options:

User "www-data"

Group "www-data"

#RootJail "/chroot/pound"

## Logging: (goes to syslog by default)

## 0 no logging

## 1 normal

## 2 extended

## 3 Apache-style (common log format)

LogLevel 3 # <-- impostiamo il log level a 3

## check backend every X secs:

Alive 30

## use hardware-accelleration card supported by openssl(1):

#SSLEngine "<hw>"

# poundctl control socket

Control "/var/run/pound/poundctl.socket"

######################################################################

## listen, redirect and ... to:

## redirect all requests on port 8080 ("ListenHTTP") to the local webserver (see "Service" below):

ListenHTTP

Address 127.0.0.1

Port 80 # <-- cambiamo la porta da 8080 su 80

## allow PUT and DELETE also (by default only GET, POST and HEAD)?:

#xHTTP 1 # <-- commentiamo questa riga

End

# configuriamo anche l'ascolto sul HTTPs, lasciamo commentato se non abbiamo il certificato

#ListenHTTPS

# Address 127.0.0.1

# Port 443

# Cert "/etc/ssl/pound.pem"

#End

Service

BackEnd

Address 192.168.0.6

Port 80

End

BackEnd

Address 192.168.0.7

Port 80

Priority 5

End

Se volessimo configurare dei servizi di emergenza, anziché usare il TAG BackEnd potremmo utilizzare Emergency. Tutto il resto rimarrebbe identico. Un server di emergenza interverrebbe solo qualora tutti gli altri backend fallissero.

Salviamo il file e modifichiamo il meccanismo di startup digitando:

sudo nano /etc/default/pound

1	sudo nano /etc/default/pound

Modifichiamo il file nella maniera seguente:

# Defaults for pound initscript
# sourced by /etc/init.d/pound
# installed at /etc/default/pound by the maintainer scripts

# prevent startup with default configuration
# set the below varible to 1 in order to allow pound to start
startup=1

# Defaults for pound initscript

# sourced by /etc/init.d/pound

# installed at /etc/default/pound by the maintainer scripts

# prevent startup with default configuration

# set the below varible to 1 in order to allow pound to start

startup=1

A questo punto riavviamo Pound. Digitiamo:

sudo service pound restart

1	sudo service pound restart

3. Installazione di Apache sui backend

Sui server di backend sarà sufficiente installare Apache, senza ulteriori configurazioni. Ricordiamoci che Pound, anche se interrogato in HTTPS si connetterà ai server di backend in HTTP.

Per farlo digitiamo semplicemente:

sudo apt-get install apache2

1	sudo apt-get install apache2

Una volta installato Apache modifichiamo l’output predefinito del webserver. Per farlo cancelliamo il file originale e creiamone uno nuovo.

sudo rm /var/www/html/index.html
sudo nano /var/www/html/index.html

1 2	sudo rm /var/www/html/index.html sudo nano /var/www/html/index.html

In questo caso ci scriverò dentro il nome del WebServer, per esempio:

Ciao dal WebServer1

1	Ciao dal WebServer1

Configuriamo ora il backend affinché effettui il log per le richieste X-Forwarded-For.

Anzitutto abilitiamo l’estensione remoteip di apache.

sudo a2enmod remoteip

1	sudo a2enmod remoteip

Modifichiamo il file di configurazione digitando:

sudo nano /etc/apache2/apache2.conf

1	sudo nano /etc/apache2/apache2.conf

Modifichiamo il seguente paragrafo del file:

#
# The following directives define some format nicknames for use with
# a CustomLog directive.
#
# These deviate from the Common Log Format definitions in that they use %O
# (the actual bytes sent including headers) instead of %b (the size of the
# requested file), because the latter makes it impossible to detect partial
# requests.
#
# Note that the use of %{X-Forwarded-For}i instead of %h is not recommended.
# Use mod_remoteip instead.
#
RemoteIPHeader X-Forwarded-For
RemoteIPInternalProxy 192.168.0.5
LogFormat "%v:%p %h %l %u %t \"%r\" %>s %O \"%{Referer}i\" \"%{User-Agent}i\"" vhost_combined
LogFormat "%h %l %u %t \"%r\" %>s %O \"%{Referer}i\" \"%{User-Agent}i\"" combined
LogFormat "%h %l %u %t \"%r\" %>s %O" common
LogFormat "%{Referer}i -> %U" referer
LogFormat "%{User-agent}i" agent

# The following directives define some format nicknames for use with

# a CustomLog directive.

# These deviate from the Common Log Format definitions in that they use %O

# (the actual bytes sent including headers) instead of %b (the size of the

# requested file), because the latter makes it impossible to detect partial

# requests.

# Note that the use of %{X-Forwarded-For}i instead of %h is not recommended.

# Use mod_remoteip instead.

RemoteIPHeader X-Forwarded-For

RemoteIPInternalProxy 192.168.0.5

LogFormat "%v:%p %h %l %u %t \"%r\" %>s %O \"%{Referer}i\" \"%{User-Agent}i\"" vhost_combined

LogFormat "%h %l %u %t \"%r\" %>s %O \"%{Referer}i\" \"%{User-Agent}i\"" combined

LogFormat "%h %l %u %t \"%r\" %>s %O" common

LogFormat "%{Referer}i -> %U" referer

LogFormat "%{User-agent}i" agent

Faccio notare che l’IP 192.168.0.5 è quello della macchina col Pound.

Riavviamo Apache:

sudo service apache2 restart

1	sudo service apache2 restart

Ripetiamo questa procedura su ogni backend.

4. Prova di funzionamento

A questo punto colleghiamoci al nostro server con Pound, nel mio caso si trova all’indirizzo http://192.168.56.1/

Aggiornando più volte la pagina vedremo comparire, in modo casuale, la risposta del webserver-1 oppure del webserver-2

Oppure:

[PHP] Classe in PHP per autenticazione utenti con LDAP

Immaginiamo di avere un server Windows con dominio chiamato torregatti.local. Possiamo effettuare l’autenticazione tramite PHP utilizzando il metodo LDAP (Lightweight Directory Access Protocol).

Anzitutto assicuriamoci di avere attiva la libreria LDAP all’interno del PHP.

Su Linux possiamo installare la libreria, per esempio con Ubuntu digitiamo:

apt-get install php-ldap

1	apt-get install php-ldap

Mentre su Windows, per esempio usando XAMPP, sarà sufficiente attivare l’estensione nel file php.ini, rimuovendo il commento alla seguente riga:

;extension=php_ldap.dll

1	;extension=php_ldap.dll

Che diventerà quindi:

extension=php_ldap.dll

1	extension=php_ldap.dll

Fatto questo possiamo creare una classe che si occupi del processo di login.

Prima di procedere vediamo il minimo indispensabile per effettuare il processo:

$conn = ldap_connect("ldap://192.168.56.1", 389 );

if( $conn ) {
	
	ldap_set_option($conn, LDAP_OPT_PROTOCOL_VERSION, 3);
	ldap_set_option($conn, LDAP_OPT_REFERRALS, 0);
	
	$bind = @ldap_bind($conn, "TORREGATTI\\ADMINISTRATOR", "Password123");
	
	if( $bind ) {
		ldap_close( $conn );
		echo "connesso!";
	} else {
		die("Errore autenticazione");
	}

} else {
	die("Errore di connessione");
}

$conn = ldap_connect("ldap://192.168.56.1", 389 );

if( $conn ) {

ldap_set_option($conn, LDAP_OPT_PROTOCOL_VERSION, 3);

ldap_set_option($conn, LDAP_OPT_REFERRALS, 0);

$bind = @ldap_bind($conn, "TORREGATTI\\ADMINISTRATOR", "Password123");

if( $bind ) {

ldap_close( $conn );

echo "connesso!";

} else {

die("Errore autenticazione");

}

} else {

die("Errore di connessione");

}

In questo caso stiamo entrando con l’utente amministratore TORREGATTI\ADMINISTRATOR che ha per password Password123

Ricordiamoci che nel nostro esempio il dominio è torregatti.local e il server si trova sull’indirizzo 192.168.56.1. Ci stiamo collegando con una connessione non sicura, usando il protocollo ldap anziché ldaps (richiederebbe la porta 636).

Possiamo creare una classe che effettui tutto il processo di login e ci permetta di verificare l’autenticazione mediante i cookie, nella maniera seguente:

class LDAPLogin {
	
	private $server;
	private $username;
	private $password;
	private $ssl;
	private $key;
	
	const ERR_NO_ERROR = 0x0;
	const ERR_CONNECTION = 0x1;
	const ERR_PROTOCOL = 0x2;
	const ERR_REFERRALS = 0x3;
	const ERR_SERVER = 0x4;
	const ERR_USERNAME = 0x5;
	const ERR_AUTH = 0x6;
	const ERR_KEY = 0x7;
	
	private $status = 0x0;
	private $cookie_username = "ldap_username";
	private $cookie_hash = "ldap_hash";
	private $cookie_expire = 30;
	
	function __construct( $server = NULL, $user = NULL, $pass = NULL , $ssl = false , $key = null ) {
		$this->setServer( $server );
		$this->setUsername( $user );
		$this->setPassword( $pass );
		$this->setSSL( $ssl );
		$this->setKey( $key );
	}
	
	function setCookies( $username , $hash , $expire ) {
		$this->cookie_username = $username;
		$this->cookie_hash = $hash;
		$this->cookie_expire = $expire;
	}
	
	function setServer( $server ) {
		$this->server = $server;
		return $this;
	}
	
	function setUsername( $username ) {
		$this->username = $username;
		return $this;
	}
	
	function setPassword( $password ) {
		$this->password = $password;
		return $this;
	}
	
	function setSSL( $ssl = true ) {
		$this->ssl = $ssl;
		return $this;
	}
	
	function setKey( $key ) {
		$this->key = $key;
		return $this;
	}
	
	function authenticate() {
		
		if( !$this->server ) $this->status = self::ERR_SERVER;
		if( !$this->username ) $this->status = self::ERR_USERNAME;
		if( !$this->key ) $this->status = self::ERR_KEY;
		
		if( $this->status == self::ERR_NO_ERROR ) {
			
			$connString = ($this->ssl?"ldaps":"ldap") . "://" . $this->server;
			$connPort = $this->ssl ? 636 : 389;
			
			$conn = ldap_connect( $connString , $connPort );
			
			if( $conn ) {
				
				ldap_set_option($conn, LDAP_OPT_PROTOCOL_VERSION, 3) or $this->status = self::ERR_PROTOCOL;
				ldap_set_option($conn, LDAP_OPT_REFERRALS, 0) or $this->status = self::ERR_REFERRALS;
				
				if( $this->status == self::ERR_NO_ERROR ) {
					
					$bind = @ldap_bind($conn, $this->username, $this->password);
				
					if( $bind ) {
						
						ldap_close( $conn );
						
						setcookie( $this->cookie_username , $this->username , time() + 3600 * 24 * $this->cookie_expire );
						
						setcookie( $this->cookie_hash , hash("sha512",$this->username . $this->key) , time() + 3600 * 24 * $this->cookie_expire );
						
					} else {
						
						$this->status = self::ERR_AUTH;
						
					}
	
				}
				
			} else {
				$this->status = self::ERR_CONNECTION;
			}
		
		}
		
		return $this;
		
	}
	
	function getError() {
		return $this->status;
	}
	
	function isAuth() {
		return $_COOKIE[$this->cookie_hash] == hash("sha512",$_COOKIE[$this->cookie_username] . $this->key);
	}
	
	function logout() {
		setcookie( $this->cookie_username , NULL , 0 );
		setcookie( $this->cookie_hash , NULL , 0 );
		return $this;
	}
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

class LDAPLogin {

private $server;

private $username;

private $password;

private $ssl;

private $key;

const ERR_NO_ERROR = 0x0;

const ERR_CONNECTION = 0x1;

const ERR_PROTOCOL = 0x2;

const ERR_REFERRALS = 0x3;

const ERR_SERVER = 0x4;

const ERR_USERNAME = 0x5;

const ERR_AUTH = 0x6;

const ERR_KEY = 0x7;

private $status = 0x0;

private $cookie_username = "ldap_username";

private $cookie_hash = "ldap_hash";

private $cookie_expire = 30;

function __construct( $server = NULL, $user = NULL, $pass = NULL , $ssl = false , $key = null ) {

$this->setServer( $server );

$this->setUsername( $user );

$this->setPassword( $pass );

$this->setSSL( $ssl );

$this->setKey( $key );

}

function setCookies( $username , $hash , $expire ) {

$this->cookie_username = $username;

$this->cookie_hash = $hash;

$this->cookie_expire = $expire;

}

function setServer( $server ) {

$this->server = $server;

return $this;

}

function setUsername( $username ) {

$this->username = $username;

return $this;

}

function setPassword( $password ) {

$this->password = $password;

return $this;

}

function setSSL( $ssl = true ) {

$this->ssl = $ssl;

return $this;

}

function setKey( $key ) {

$this->key = $key;

return $this;

}

function authenticate() {

if( !$this->server ) $this->status = self::ERR_SERVER;

if( !$this->username ) $this->status = self::ERR_USERNAME;

if( !$this->key ) $this->status = self::ERR_KEY;

if( $this->status == self::ERR_NO_ERROR ) {

$connString = ($this->ssl?"ldaps":"ldap") . "://" . $this->server;

$connPort = $this->ssl ? 636 : 389;

$conn = ldap_connect( $connString , $connPort );

if( $conn ) {

ldap_set_option($conn, LDAP_OPT_PROTOCOL_VERSION, 3) or $this->status = self::ERR_PROTOCOL;

ldap_set_option($conn, LDAP_OPT_REFERRALS, 0) or $this->status = self::ERR_REFERRALS;

if( $this->status == self::ERR_NO_ERROR ) {

$bind = @ldap_bind($conn, $this->username, $this->password);

if( $bind ) {

ldap_close( $conn );

setcookie( $this->cookie_username , $this->username , time() + 3600 * 24 * $this->cookie_expire );

setcookie( $this->cookie_hash , hash("sha512",$this->username . $this->key) , time() + 3600 * 24 * $this->cookie_expire );

} else {

$this->status = self::ERR_AUTH;

}

} else {

$this->status = self::ERR_CONNECTION;

}

return $this;

}

function getError() {

return $this->status;

}

function isAuth() {

return $_COOKIE[$this->cookie_hash] == hash("sha512",$_COOKIE[$this->cookie_username] . $this->key);

}

function logout() {

setcookie( $this->cookie_username , NULL , 0 );

setcookie( $this->cookie_hash , NULL , 0 );

return $this;

}

Per effettuare il login sarà sufficiente configurare la classe nella maniera seguente:

$ldap = (new LDAPLogin( "192.168.56.1" , "TORREGATTI\\ADMINISTRATOR" , "Password123" ))
		->setKey("0bb74b7aa9cadf13d2c05332744ebc8ee5b09ef9a53cb67ea0b3adabde4f598b");
		
if( $ldap->authenticate()->getError() == LDAPLogin::ERR_NO_ERROR ) {
	// autenticazione avvenuta
}

$ldap = (new LDAPLogin( "192.168.56.1" , "TORREGATTI\\ADMINISTRATOR" , "Password123" ))

->setKey("0bb74b7aa9cadf13d2c05332744ebc8ee5b09ef9a53cb67ea0b3adabde4f598b");

if( $ldap->authenticate()->getError() == LDAPLogin::ERR_NO_ERROR ) {

// autenticazione avvenuta

}

Abbiamo aggiunto una nostra chiave casuale e segreta che verrà utilizzata per la costruzione del hash nei cookie.

Per verificare che l’utente sia autenticato, una volta terminato il processo di login, sarà sufficiente richiamare:

if( $ldap->isAuth() ) {
	// ok, utente autenticato
}

if( $ldap->isAuth() ) {

// ok, utente autenticato

}

Per effettuare il logout sarà sufficiente richiamare:

$ldap->logout();

1	$ldap->logout();

E’ molto probabile che l’inserimento di username e password lo si voglia fare dopo aver costruito l’oggetto per l’autenticazione LDAP, in tal caso si potrebbe procedere nella maniera seguente:

$ldap = (new LDAPLogin("192.168.56.1"))->setKey("0bb74b7aa9cadf13d2c05332744ebc8ee5b09ef9a53cb67ea0b3adabde4f598b");

$ldap->setUsername( "TORREGATTI\\ADMINISTRATOR" )->setPassword( "Password123" );
		
if( $ldap->authenticate()->getError() == LDAPLogin::ERR_NO_ERROR ) {
	echo "autenticazione avvenuta!";
}

$ldap = (new LDAPLogin("192.168.56.1"))->setKey("0bb74b7aa9cadf13d2c05332744ebc8ee5b09ef9a53cb67ea0b3adabde4f598b");

$ldap->setUsername( "TORREGATTI\\ADMINISTRATOR" )->setPassword( "Password123" );

if( $ldap->authenticate()->getError() == LDAPLogin::ERR_NO_ERROR ) {

echo "autenticazione avvenuta!";

}

Con il metodo getError() è possibile verificare gli altri eventuali errori durante il processo di autenticazione, sfruttando le costanti della classe.

[ubuntu] Liberare spazio sulla radice quando è installato Plesk

Problema: con un’installazione di Plesk non sembra esserci spazio sufficiente sul disco per eseguire installazioni ed aggiornamenti con apt-get, oppure effettuare operazioni di database, come per esempio l’esportazione (si ottiene un errore mysqldump: Got errno 28 on write)

Il problema dipende tipicamente dalla mancanza di spazio sul disco. Una possibile soluzione l’abbiamo già vista in Liberare spazio su Ubuntu con errore apt-get “No space left on device”

Un’altra operazione che conviene fare è svuotare i file temporanei creati da Plesk che possono occupare anche diversi GB. Per farlo eseguiamo i seguenti comandi sul terminale:

find /tmp -type f -mtime +14 -exec rm {} \;
find /var/tmp -type f -mtime +14 -exec rm {} \;

1 2	find /tmp -type f -mtime +14 -exec rm {} \; find /var/tmp -type f -mtime +14 -exec rm {} \;

Questo cancellerà i file temporanei più vecchi di 14 giorni. Se tale operazione non fosse sufficiente procediamo ad eliminare tutti i file temporanei:

rm -rf /usr/local/psa/PMM/tmp/*
rm -rf /usr/local/psa/tmp/*

1 2	rm -rf /usr/local/psa/PMM/tmp/* rm -rf /usr/local/psa/tmp/*

Se neanche questo bastasse possiamo cercare i file per dimensione, digitando:

find / -size +100M -ls

1	find / -size +100M -ls

In questo caso cerchiamo file più grandi di 100MB. Controlliamo l’elenco dei file e valutiamo se possiamo eliminarne alcuni (tipicamente i file *.BAK del MySQL possono essere eliminati senza problemi)

[PowerShell] Esempio di script per inviare un messaggio a diversi computer sulla rete tramite PowerShell

Ecco un esempio di script in PowerShell per inviare un messaggio a tutti i computer Windows all’interno di una rete.

Anzitutto creiamo un file invia_messaggio.ps1 nella posizione che preferiamo. Clicchiamo sopra col destro e scegliamo la voce Modifica per modificare il file con PowerShell ISE.

Inseriamo all’interno il seguente codice:

$computers = @()
$sessione = "*"
while( $true ) {
    Write-Host "-- menu opzioni --" -ForegroundColor Red
    Write-Host "0. Esci"
    Write-Host "1. Aggiungi computer"
    Write-Host "2. Invia messaggio"
    Write-Host "3. Reimposta computer"
    Write-Host "4. Mostra computer"
    $opzione = Read-Host "Scelta"
    if( $opzione -eq 0 ) {
        Write-Host "Ciao!"
        break
    }
    if( $opzione -eq 1 ) {
        $computers += Read-Host "Nome computer"
    }
    if( $opzione -eq 2 ) {
        $messaggio = Read-Host "Messaggio"
        foreach( $computer in $computers ) {
            msg $sessione /server:$computer $messaggio
        }
        Write-Host "Messaggio inviato" -ForegroundColor Green
    }
    if( $opzione -eq 3 ) {
        $computers.Clear()
        Write-Host "Elenco computer cancellato" -ForegroundColor Red
    }
    if( $opzione -eq 4 ) {
        Write-Host "Elenco computer" -ForegroundColor Yellow
        $computers
    }
}

$computers = @()

$sessione = "*"

while( $true ) {

Write-Host "-- menu opzioni --" -ForegroundColor Red

Write-Host "0. Esci"

Write-Host "1. Aggiungi computer"

Write-Host "2. Invia messaggio"

Write-Host "3. Reimposta computer"

Write-Host "4. Mostra computer"

$opzione = Read-Host "Scelta"

if( $opzione -eq 0 ) {

Write-Host "Ciao!"

break

}

if( $opzione -eq 1 ) {

$computers += Read-Host "Nome computer"

}

if( $opzione -eq 2 ) {

$messaggio = Read-Host "Messaggio"

foreach( $computer in $computers ) {

msg $sessione /server:$computer $messaggio

}

Write-Host "Messaggio inviato" -ForegroundColor Green

}

if( $opzione -eq 3 ) {

$computers.Clear()

Write-Host "Elenco computer cancellato" -ForegroundColor Red

}

if( $opzione -eq 4 ) {

Write-Host "Elenco computer" -ForegroundColor Yellow

$computers

}

Per inviare un messaggio sarà sufficiente aggiungere i nomi dei computer all’interno della rete.

[python] Semplice esercizio su TensorFlow e il riconoscimento delle immagini nel gioco del Tris (Machine Learning)

Vogliamo realizzare un semplice programma in Python che sfrutti il riconoscimento delle immagini mediante TensorFlow e machine learning.

Il programma consentirà all’utente di pescare il risultato di una partita a Tris, da una cartella di immagini come la seguente:

Selezionando una partita il programma ci dirà chi ritiene che sia il vincitore e mostrerà lo schema della partita che ha dedotto a partire dall’immagine che gli abbiamo passato, nella maniera seguente:

1. Configurazione iniziale e librerie utilizzate

Per affrontare l’esercizio in questione abbiamo bisogno di alcune librerie. Il progetto verrà sviluppato in Python 3.7.

Possiamo installare le opportune librerie utilizzando PIP, nel caso specifico avremo bisogno delle seguenti installazioni:

pip install Pillow
pip install numpy
pip install tensorflow
pip install matplotlib

pip install Pillow

pip install numpy

pip install tensorflow

pip install matplotlib

Creiamo un file elaboratore.py nel quale svilupperemo l’intero programma. All’inizio inseriamo le seguenti istruzioni di importazione:

from __future__ import absolute_import, division, print_function, unicode_literals

from PIL import Image
import numpy as np
import os

import tensorflow as tf
from tensorflow import keras
import matplotlib.pyplot as plt

from __future__ import absolute_import, division, print_function, unicode_literals

from PIL import Image

import numpy as np

import os

import tensorflow as tf

from tensorflow import keras

import matplotlib.pyplot as plt

Faccio notare che la prima istruzione from __future__ import absolute_import, division, print_function, unicode_literals deve trovarsi all’inizio e non è una vera e propria importazione. Si tratta di una configurazione sul funzionamento di Python, che importa “funzionalità future” dal modulo fittizio __future__. E’ un modo per rendere disponibili, nella versione attuale, funzionalità previste in versioni successive, ma che ancora non sono state ufficialmente implementate.

Nel nostro caso specifico questa importazione non è essenziale (stiamo già lavorando in Python 3.7 e la funzione print non è più uno statement, bensì una funzione appunto, ecc), ma la possiamo lasciare per rendere compatibile il programma anche con versioni precedenti.

Detto questo procediamo allo sviluppo del necessario.

2. Dati iniziali

Per sviluppare il gioco utilizzeremo i seguenti set di dati (qui l’allegato da cui scaricarli):

Set delle immagini per l’addestramento del modello, ricaveremo le immagini da un’unica grande immagine originale chiamata training.jpg (questa è un’immagine contenente 144 disegni, metà sono O e l’altra metà sono X, disegnate a mano sul computer, ciascun elemento è grande 100×100 px, per un totale di 1200×1200 px, ovvero 12 righe x 12 colonne)
Piccolo set di immagini di test nel file test.jpg (solita dimensione 100×100 px per ciascuna immagine, per un totale di 4×4 = 16 elementi)
Archivio con 10 partite giocate a Tris di cui conosciamo il risultato e vogliamo farlo riconoscere al computer

3. Struttura del programma

Vogliamo creare 3 classi che si occuperanno di diversi aspetti del programma:

ElaboraImmagini – con questa classe elaboreremo le immagini di test, di addestramento e delle singole partite. In tutti e tre i casi si tratta di suddividere un’immagine originale in immagini più piccole; nei primi due casi, quello di test e addestramento, salveremo le immagini in una cartella da cui leggerle successivamente, mentre nel terzo caso, quello delle immagini che compongono una partita, salveremo il risultato in un vettore
CreaDBImmagini – con questa classe vogliamo elaborare le immagini di test e di addestramento salvate nelle rispettive cartelle, ottenendo dei vettori contenenti le immagini medesime e un elenco di output (o etichette) associati a ciascuna immagine
GiocoTris – la vera e propria classe che si occuperà dello sviluppo del gioco, preparando il modello di apprendimento, salvandolo e valutando il punteggio su ciascuna partita che verrà passata dal giocatore

Infine metteremo tutto in un semplice ciclo while che permetterà all’utente di scegliere un’immagine dall’elenco di quelle disponibili e farla analizzare.

4. Elaboriamo le immagini di addestramento e test

Creiamo una classe nella maniera seguente (nel codice ho inserito il commento sui singoli passaggi):

class ElaboraImmagini:

    # al costruttore della classe passiamo i seguenti argomenti:
    # orig: file dell'immagine originale da elaborare, per esempio training.jpg oppure gioco_0.jpg
    # dest: cartella di destinazione nella quale salvare le immagini ritagliate dall'immagine originale
    # n: dimensione del lato del quadrato dell'immagine, 12 per training.jpg, oppure 3 per l'immagine di gioco_0.jpg, praticamente il numero di colonne della griglia
    # w: dimensione di ciascuna cella della griglia in px, ogni immagine estratta avra' tale dimensione, per esempio 100 per immagini di 100x100px
    # returnList: se vogliamo che il risultato, ovvero le immagini ritagliate, anziche' essere salvato in una cartella, venga restituito in una lista
    def __init__(s, orig, dest = None, n = 12, w = 100, returnList = False):
        # impostiamo alcune proprieta' private della classe
        s.__return = returnList
        s.__lista = [] # questo sara' l'eventuale elenco delle immagini
        # preleviamo il percorso assoluto sul quale si trova l'immagine di origine
        s.__orig = os.path.abspath(orig)
        # se non vogliamo una lista, creiamo il percorso di salvataggio delle immagini
        #a tale scopo prendiamo la cartella dell'immagine sorgente e ad essa accodiamo la cartella di destinazione
        if not s.__return: s.__dest = os.path.dirname(s.__orig) + "\\" + dest

        # se non vogliamo una lista
        if not s.__return:
            # allora dovremo salvare le immagini in una cartella
            # se la cartella di destinazione non esiste
            if not os.path.exists(s.__dest):
                # allora la creiamo
                os.makedirs(s.__dest)

        # salviamo i valori in prorieta' private
        s.__n = n
        s.__w = w

        # elaboriamo le immagini
        s.elabora()

    # per elaborare le immagini dobbiamo ritagliarle da quella originale
    # creiamo dunque un metodo per ritagliare le immagini, passando per argomento le coordinate (coor) di ritaglio
    # per coordinate si intendono xi, yi e xf, yf di ciascun quadrato di ritaglio (vedere l'articolo per maggiori informazioni)
    def ritaglia(s, coor, i):
        # leggiamo l'immagine con PIL
        img = Image.open(s.__orig)
        # ritagliamo l'immagine secondo le coordinate passate
        cropped = img.crop(coor)
        # se non vogliamo una lista, allora salviamo l'immagine nella destinazione prescelta
        if not s.__return: cropped.save(s.__dest + "\\img_" + str(i) + ".jpg")
        # altrimenti restituiamo l'immagine come array di NumPy
        else: return np.asarray(cropped)

    # con questo metodo elaboriamo l'immagine, chiamando ritaglia() per ciascuna cella della griglia
    def elabora(s):
        # per ciascuna riga
        for i in range(s.__n):
            #per ciascuna colonna
            for j in range(s.__n):
                # esegui ritaglia passando le coordinate calcolate e il numero progressivo dell'immagine
                img = s.ritaglia( ( j*s.__w , i*s.__w , (j+1) *s.__w , (i+1) * s.__w ) , i * s.__n + j )
                # aggiungi l'immagine alla lista delle immagini che si potranno eventualmente restituire
                s.__lista.append(img)

    # preleviamo la lista delle immagini elaborate
    def get(s):
        # convertiamo la lista in un array di NumPy
        return np.array(s.__lista)

class ElaboraImmagini:

# al costruttore della classe passiamo i seguenti argomenti:

# orig: file dell'immagine originale da elaborare, per esempio training.jpg oppure gioco_0.jpg

# dest: cartella di destinazione nella quale salvare le immagini ritagliate dall'immagine originale

# n: dimensione del lato del quadrato dell'immagine, 12 per training.jpg, oppure 3 per l'immagine di gioco_0.jpg, praticamente il numero di colonne della griglia

# w: dimensione di ciascuna cella della griglia in px, ogni immagine estratta avra' tale dimensione, per esempio 100 per immagini di 100x100px

# returnList: se vogliamo che il risultato, ovvero le immagini ritagliate, anziche' essere salvato in una cartella, venga restituito in una lista

def __init__(s, orig, dest = None, n = 12, w = 100, returnList = False):

# impostiamo alcune proprieta' private della classe

s.__return = returnList

s.__lista = [] # questo sara' l'eventuale elenco delle immagini

# preleviamo il percorso assoluto sul quale si trova l'immagine di origine

s.__orig = os.path.abspath(orig)

# se non vogliamo una lista, creiamo il percorso di salvataggio delle immagini

#a tale scopo prendiamo la cartella dell'immagine sorgente e ad essa accodiamo la cartella di destinazione

if not s.__return: s.__dest = os.path.dirname(s.__orig) + "\\" + dest

# se non vogliamo una lista

if not s.__return:

# allora dovremo salvare le immagini in una cartella

# se la cartella di destinazione non esiste

if not os.path.exists(s.__dest):

# allora la creiamo

os.makedirs(s.__dest)

# salviamo i valori in prorieta' private

s.__n = n

s.__w = w

# elaboriamo le immagini

s.elabora()

# per elaborare le immagini dobbiamo ritagliarle da quella originale

# creiamo dunque un metodo per ritagliare le immagini, passando per argomento le coordinate (coor) di ritaglio

# per coordinate si intendono xi, yi e xf, yf di ciascun quadrato di ritaglio (vedere l'articolo per maggiori informazioni)

def ritaglia(s, coor, i):

# leggiamo l'immagine con PIL

img = Image.open(s.__orig)

# ritagliamo l'immagine secondo le coordinate passate

cropped = img.crop(coor)

# se non vogliamo una lista, allora salviamo l'immagine nella destinazione prescelta

if not s.__return: cropped.save(s.__dest + "\\img_" + str(i) + ".jpg")

# altrimenti restituiamo l'immagine come array di NumPy

else: return np.asarray(cropped)

# con questo metodo elaboriamo l'immagine, chiamando ritaglia() per ciascuna cella della griglia

def elabora(s):

# per ciascuna riga

for i in range(s.__n):

#per ciascuna colonna

for j in range(s.__n):

# esegui ritaglia passando le coordinate calcolate e il numero progressivo dell'immagine

img = s.ritaglia( ( j*s.__w , i*s.__w , (j+1) *s.__w , (i+1) * s.__w ) , i * s.__n + j )

# aggiungi l'immagine alla lista delle immagini che si potranno eventualmente restituire

s.__lista.append(img)

# preleviamo la lista delle immagini elaborate

def get(s):

# convertiamo la lista in un array di NumPy

return np.array(s.__lista)

Il metodo ritaglia(s, coor, i) accetta coordinate in (x,y) sull’immagine, le x rappresentano le “colonne”, mentre le y rappresentano le “righe”, nella maniera seguente:

La prima immagine verrà ritagliata con coordinate (0, 0, 100, 100), la seconda con (100, 0, 200, 100) ecc.

Possiamo subito elaborare le immagini di addestramento e di test aggiungendo le seguenti due righe di codice:

ElaboraImmagini("training.jpg","TRAINING",12,100)
ElaboraImmagini("test.jpg","TEST",4,100)

1 2	ElaboraImmagini("training.jpg","TRAINING",12,100) ElaboraImmagini("test.jpg","TEST",4,100)

5. Preleviamo le immagini di addestramento e test, associandoci gli opportuni output

Adesso vogliamo creare la classe che ci consentirà di prelevare le immagini, inserendole in un vettore, ed associare a ciascuna immagine nel vettore l’opportuno output.

Ogni immagine può rappresentare o una O oppure un X, a queste due “etichette” vogliamo associare un valore numerico, che nel mio caso sarà 0 per la O e 1 per la X.

Il comportamento che ci aspettiamo sarà il seguente: train_img, train_desc = CreaDBImmagini(...).get()

train_img conterrà i valori RGB per ciascuna immagine, in una lista di immagini così codificate. Ciascuna immagine è una griglia di pixel, per esempio un’immagine di 3×3 px diventerebbe una matrice di questo tipo [[1,2,3],[4,5,6],[7,8,9]]. I pixel in realtà non sono numerati in questo modo, ma ciascun pixel ha un valore RGB da 0 a 255, per ciascun colore. Quindi se il primo pixel fosse completamente nero al posto dell’1 avremmo [0,0,0], una lista con 3 zeri. Se fosse completamente bianco avremmo [255,255,255], se fosse rosso avremmo [255,0,0] ecc. Questo significa che l’immagine del nostro esempio avrebbe una rappresentazione tridimensionale 3x3x3 diventando così per esempio: [[[0,0,0],[0,0,0],[0,0,0]],[[0,0,0],[255,255,255],[0,0,0]],[[0,0,0],[0,0,0],[0,0,0]]]. In questo caso il pixel centrale, quello che abbiamo numerato come 5, sarebbe bianco e gli altri tutti neri. Se avessimo 100 di queste immagini, avremmo un oggetto di dimensione 100x3x3x3. Ovvero una lista di 100 elementi, di cui ciascun elemento è questa lista, di liste di liste, rappresentante la singola immagine.

train_desc è invece una semplice lista monodimensionale, se avessimo 100 immagini questa sarebbe una lista di 100 elementi. Ogni elemento descrive l’immagine, nel nostro caso se l’immagine corrispondente in train_img fosse una O allora avremo uno 0, nel caso di una X avremo un 1. Sarà quindi una lista tipo [0,1,1,0,0,....]. In questo esempio vorrebbe dire che le immagini in train_img rappresentano in ordine: O, X, X, O, O, ecc.

Tutti gli altri commenti sono nel codice:

class CreaDBImmagini:

    # creiamo delle costanti a livello di classe, che ci permettano di definire l'input tipo nel costruttore
    # e quindi il tipo di immagini che vogliamo tirare fuori, questo e' importante solo ai fini della creazione
    # delle etichette
    TEST = 0
    TRAINING = 1

    # il costruttore accetta 2 argomenti:
    # path: il percorso da cui leggere le immagini
    # tipo: il tipo di etichette da creare in associazione
    def __init__(s, path, tipo = 0):
        s.__path = path
        s.__immagini = []
        s.__descrizioni = []
        s.__tipo = tipo

        s.elabora()

    # elaboriamo le immagini
    def elabora(s):
        # per ogni elemento nella cartella
        for f in os.listdir(s.__path):
            # se si tratta di un file
            if os.path.isfile(s.__path + "\\" + f):
                # leggiamo il file dell'immagine aprendolo con PIL
                img = Image.open(s.__path + "\\" + f)
                # trasformiamo i dati dell'immagine in un array contenente i valori RGB dell'immagine stessa
                bimg = np.asarray(img)
                # aggiungiamo l'immagine all'elenco delle immagini
                s.__immagini.append(bimg)
                # otteniamo il numero dell'immagine, questo lo abbiamo per costruzione dalla precedente classe ElaboraImmagini
                numero = int(f.replace("img_","").replace(".jpg",""))
                # se l'immagine e' del gruppo di test
                if s.__tipo == s.TEST:
                    # siccome le immagini di test sono alternate, tipo O, X, O, X ecc, vuol dire che posso distinguerle
                    # come pari e dispari, quindi i pari saranno 0 e i dispari 1, rispettivamente O e X
                    s.__descrizioni.append( int(numero % 2) )
                # se l'immagine e' del gruppo di addestramento
                if s.__tipo == s.TRAINING:
                    # siccome le immagini di addestramento sono divise a meta', la prima meta' sono O e la seconda sono X
                    # allora sara' sufficiente dividere per la meta' del totale e arrotondare per difetto
                    s.__descrizioni.append( int(np.floor(numero / 72)) )

    # restituisci i due vettori come array di NumPy
    def get(s):
        return (np.array(s.__immagini) , np.array(s.__descrizioni))

class CreaDBImmagini:

# creiamo delle costanti a livello di classe, che ci permettano di definire l'input tipo nel costruttore

# e quindi il tipo di immagini che vogliamo tirare fuori, questo e' importante solo ai fini della creazione

# delle etichette

TEST = 0

TRAINING = 1

# il costruttore accetta 2 argomenti:

# path: il percorso da cui leggere le immagini

# tipo: il tipo di etichette da creare in associazione

def __init__(s, path, tipo = 0):

s.__path = path

s.__immagini = []

s.__descrizioni = []

s.__tipo = tipo

s.elabora()

# elaboriamo le immagini

def elabora(s):

# per ogni elemento nella cartella

for f in os.listdir(s.__path):

# se si tratta di un file

if os.path.isfile(s.__path + "\\" + f):

# leggiamo il file dell'immagine aprendolo con PIL

img = Image.open(s.__path + "\\" + f)

# trasformiamo i dati dell'immagine in un array contenente i valori RGB dell'immagine stessa

bimg = np.asarray(img)

# aggiungiamo l'immagine all'elenco delle immagini

s.__immagini.append(bimg)

# otteniamo il numero dell'immagine, questo lo abbiamo per costruzione dalla precedente classe ElaboraImmagini

numero = int(f.replace("img_","").replace(".jpg",""))

# se l'immagine e' del gruppo di test

if s.__tipo == s.TEST:

# siccome le immagini di test sono alternate, tipo O, X, O, X ecc, vuol dire che posso distinguerle

# come pari e dispari, quindi i pari saranno 0 e i dispari 1, rispettivamente O e X

s.__descrizioni.append( int(numero % 2) )

# se l'immagine e' del gruppo di addestramento

if s.__tipo == s.TRAINING:

# siccome le immagini di addestramento sono divise a meta', la prima meta' sono O e la seconda sono X

# allora sara' sufficiente dividere per la meta' del totale e arrotondare per difetto

s.__descrizioni.append( int(np.floor(numero / 72)) )

# restituisci i due vettori come array di NumPy

def get(s):

return (np.array(s.__immagini) , np.array(s.__descrizioni))

6. Sviluppiamo la classe di gioco

A questo punto sviluppiamo la classe di gioco integrando le precedenti classi.

class GiocoTris:

    # prendiamo come argomenti:
    # orig: cartella dove sono contenuti tutti i giochi
    # train: cartella dove si trovano le immagini di addestramento
    # test: cartella dove si trovano le immagini di test
    # nome_modello: nome della cartella nella quale verra' salvato il modello calcolato
    def __init__(s, orig = "GIOCHI", train = "TRAINING", test = "TEST", nome_modello = "gioco_del_tris"):
        s.__orig = orig
        s.__train = train
        s.__test = test
        s.__nome_modello = nome_modello
        s.__modello = None
        # leggiamo l'elenco dei file nella cartella orig, solo se sono dei file, e teniamoli come partite possibili
        s.__partite = [f for f in os.listdir(orig) if os.path.isfile(orig + "\\" + f)]

        # se il modello salvato esiste (ovvero se esiste la cartella)
        if os.path.exists(s.__nome_modello):
            # caricare il modello salvato
            s.__modello = keras.models.load_model(s.__nome_modello)
            
    #restituisce la lista dei file delle partite
    def getGiochi(s):
        return s.__partite

    # prepara il modello
    def prepara(s):

        # prepara il modello se il modello non esiste, ovvero non e' stato caricato
        if s.__modello is None:

            # preleva le immagini di addestramento e le relative descrizioni, ossia gli output noti
            train_img, train_desc = CreaDBImmagini(s.__train,CreaDBImmagini.TRAINING).get()

            # prepara il modello
            s.__modello = keras.Sequential([
                keras.layers.Flatten(input_shape=(100, 100, 3)),
                keras.layers.Dense(128, activation='relu'),
                keras.layers.Dense(2, activation='softmax')
            ])

            # compila il modello
            s.__modello.compile(optimizer="adam",
                  loss='sparse_categorical_crossentropy',
                  metrics=['accuracy'])

            # allena il modello con le immagini scelte in precedenza
            s.__modello.fit(train_img, train_desc, epochs=20)            

            # salva il modello
            s.__modello.save(s.__nome_modello)

    # valuta accuratezza del modello con immagini di test
    def getAccuracy(s):

        # preleva immagini e output di test
        test_img, test_desc = CreaDBImmagini(s.__test,CreaDBImmagini.TEST).get()

        # calcola le perdite e l'accuratezza sulle immagini di test
        s.__test_loss, s.__test_acc = s.__modello.evaluate(test_img, test_desc, verbose=0)
        
        return s.__test_acc

    # valuta uno specifico gioco, scelto come posizione tra le partite possibili
    def getImmagine(s, pos):
        # elabora l'immagine del gioco compiuto
        gioco = ElaboraImmagini(orig = s.__orig + "\\" + s.__partite[pos], n = 3, w = 100, returnList = True).get()

        # predici i risultati in termini percentuali
        previsione = s.__modello.predict(gioco)
        # prepara l'output reinterpretato
        s.__risultato = []
        # per ciascun valore delle previsioni
        for p in previsione:
            # se i valori sono vicini per un parametro arbitrario di confidenza, allora la casella e' vuota
            # per esempio se i valori sono 51% e 49%
            if abs(p[0]-p[1]) < 0.1: v = 0
            # se il primo valore supera il secondo allora abbiamo uno O
            elif p[0] > p[1]: v = 1
            # altrimenti abbiamo una X
            else: v = 2
            # aggiungi il valore al risultato
            s.__risultato.append(v)
        # ottieni il vincitore
        vincitore = s.getVincitore( s.__risultato )
        # restituisci il vincitore
        return vincitore

    # calcola il vincitore
    def getVincitore(s,vect):
        for i in range(0,9,3):
            if vect[i] == vect[i+1] == vect[i+2] and vect[i] != 0: return vect[i]
        for i in range(3):
            if vect[i] == vect[i+3] == vect[i+6] and vect[i] != 0: return vect[i]
        if (vect[0] == vect[4] == vect[8] and vect[0] != 0) or (vect[2] == vect[4] == vect[6] and vect[2] != 0): return vect[4]

    # mostra la griglia di gioco
    def stampaGioco(s):
        symb = ["-","O","X"]
        for k, r in enumerate(s.__risultato):
            if k > 0 and not k % 3: print()
            print(symb[r],end=" ")
        print()

100

101

102

103

class GiocoTris:

# prendiamo come argomenti:

# orig: cartella dove sono contenuti tutti i giochi

# train: cartella dove si trovano le immagini di addestramento

# test: cartella dove si trovano le immagini di test

# nome_modello: nome della cartella nella quale verra' salvato il modello calcolato

def __init__(s, orig = "GIOCHI", train = "TRAINING", test = "TEST", nome_modello = "gioco_del_tris"):

s.__orig = orig

s.__train = train

s.__test = test

s.__nome_modello = nome_modello

s.__modello = None

# leggiamo l'elenco dei file nella cartella orig, solo se sono dei file, e teniamoli come partite possibili

s.__partite = [f for f in os.listdir(orig) if os.path.isfile(orig + "\\" + f)]

# se il modello salvato esiste (ovvero se esiste la cartella)

if os.path.exists(s.__nome_modello):

# caricare il modello salvato

s.__modello = keras.models.load_model(s.__nome_modello)

#restituisce la lista dei file delle partite

def getGiochi(s):

return s.__partite

# prepara il modello

def prepara(s):

# prepara il modello se il modello non esiste, ovvero non e' stato caricato

if s.__modello is None:

# preleva le immagini di addestramento e le relative descrizioni, ossia gli output noti

train_img, train_desc = CreaDBImmagini(s.__train,CreaDBImmagini.TRAINING).get()

# prepara il modello

s.__modello = keras.Sequential([

keras.layers.Flatten(input_shape=(100, 100, 3)),

keras.layers.Dense(128, activation='relu'),

keras.layers.Dense(2, activation='softmax')

])

# compila il modello

s.__modello.compile(optimizer="adam",

loss='sparse_categorical_crossentropy',

metrics=['accuracy'])

# allena il modello con le immagini scelte in precedenza

s.__modello.fit(train_img, train_desc, epochs=20)

# salva il modello

s.__modello.save(s.__nome_modello)

# valuta accuratezza del modello con immagini di test

def getAccuracy(s):

# preleva immagini e output di test

test_img, test_desc = CreaDBImmagini(s.__test,CreaDBImmagini.TEST).get()

# calcola le perdite e l'accuratezza sulle immagini di test

s.__test_loss, s.__test_acc = s.__modello.evaluate(test_img, test_desc, verbose=0)

return s.__test_acc

# valuta uno specifico gioco, scelto come posizione tra le partite possibili

def getImmagine(s, pos):

# elabora l'immagine del gioco compiuto

gioco = ElaboraImmagini(orig = s.__orig + "\\" + s.__partite[pos], n = 3, w = 100, returnList = True).get()

# predici i risultati in termini percentuali

previsione = s.__modello.predict(gioco)

# prepara l'output reinterpretato

s.__risultato = []

# per ciascun valore delle previsioni

for p in previsione:

# se i valori sono vicini per un parametro arbitrario di confidenza, allora la casella e' vuota

# per esempio se i valori sono 51% e 49%

if abs(p[0]-p[1]) < 0.1: v = 0

# se il primo valore supera il secondo allora abbiamo uno O

elif p[0] > p[1]: v = 1

# altrimenti abbiamo una X

else: v = 2

# aggiungi il valore al risultato

s.__risultato.append(v)

# ottieni il vincitore

vincitore = s.getVincitore( s.__risultato )

# restituisci il vincitore

return vincitore

# calcola il vincitore

def getVincitore(s,vect):

for i in range(0,9,3):

if vect[i] == vect[i+1] == vect[i+2] and vect[i] != 0: return vect[i]

for i in range(3):

if vect[i] == vect[i+3] == vect[i+6] and vect[i] != 0: return vect[i]

if (vect[0] == vect[4] == vect[8] and vect[0] != 0) or (vect[2] == vect[4] == vect[6] and vect[2] != 0): return vect[4]

# mostra la griglia di gioco

def stampaGioco(s):

symb = ["-","O","X"]

for k, r in enumerate(s.__risultato):

if k > 0 and not k % 3: print()

print(symb[r],end=" ")

print()

Anche su questo facciamo un paio di appunti. Quando calcoliamo le previsioni con previsione = s.__modello.predict(gioco) otteniamo una lista di liste di probabilità. Ogni sub-lista contiene tante probabilità quanti sono i neuroni (o nodi) impostati nell’ultimo layer del modello. Nel nostro caso all’istruzione keras.layers.Dense(2, activation='softmax') abbiamo impostato 2 neuroni, quindi il vettore di previsione conterrà un elenco di liste del tipo [p1, p2], dove p1 e p2 sono le probabilità dell’output 0 e dell’output 1 (che ricordiamoci corrispondono a O e a X, rispettivamente). Il risultato di previsione sarà qualcosa del tipo [[1. 0.],[0.51 0.49], [0. 1.]]. Nel caso specifico vorrebbe dire che secondo il ML la prima immagina è una O, poi uno spazio vuoto, poi una X. Per quanto riguarda l’uso di softmax e relu fare riferimento a questa pagina.

Per i dettagli sull’optimizer Adam fare riferimento a questa pagina.

Il calcolo della griglia di vittoria è molto semplice, perché abbiamo un vettore lineare e non una matrice (o griglia vera e propria). In questo caso una partita come quella del gioco_1.jpg sarà rappresentata da una lista di 0, 1 e 2, in questo modo (dove 0 = vuoto, 1 = O, 2 = X): [2, 2, 1, 2, 1, 0, 2, 1, 1]

Quando il primo valore è diverso da 0, quindi da vuoto, basta controllare che a distanza di 3 siano uguali, come qui: [2, 2, 1, 2, 1, 0, 2, 1, 1]

In questo modo stiamo controllando le colonne.

Per controllare le righe basta verificare le triplette, così: [2, 2, 1, 2, 1, 0, 2, 1, 1]

7. Chiudiamo il programma

Infine costruiamo il ciclo while per poter far usare il programma:

gt = GiocoTris(orig = "GIOCHI", train = "TRAINING", test = "TEST", nome_modello = "gioco_del_tris")
gt.prepara()

while True:

    print("-- gioco del tris --")
    print('Test accuracy:', gt.getAccuracy())
    print("scegli la partita (-1 esci):")
    for k, n in enumerate(gt.getGiochi()):
        print("{0}. gioco {0}".format(k))
    print("> ",end="")
    partita = int(input())

    if partita == -1: break

    if partita >= 0 and partita <= 9:
        vincitore = gt.getImmagine( partita )
        if vincitore == 1: print("Ha vinto O")
        elif vincitore == 2: print("Ha vinto X")
        else: print("Nessun vincitore")

        gt.stampaGioco()

gt = GiocoTris(orig = "GIOCHI", train = "TRAINING", test = "TEST", nome_modello = "gioco_del_tris")

gt.prepara()

while True:

print("-- gioco del tris --")

print('Test accuracy:', gt.getAccuracy())

print("scegli la partita (-1 esci):")

for k, n in enumerate(gt.getGiochi()):

print("{0}. gioco {0}".format(k))

print("> ",end="")

partita = int(input())

if partita == -1: break

if partita >= 0 and partita <= 9:

vincitore = gt.getImmagine( partita )

if vincitore == 1: print("Ha vinto O")

elif vincitore == 2: print("Ha vinto X")

else: print("Nessun vincitore")

gt.stampaGioco()

Per completezza riporto di seguito l’intero codice di programmazione:

from __future__ import absolute_import, division, print_function, unicode_literals

from PIL import Image
import numpy as np
import os

import tensorflow as tf
from tensorflow import keras
import matplotlib.pyplot as plt

class ElaboraImmagini:

    # al costruttore della classe passiamo i seguenti argomenti:
    # orig: file dell'immagine originale da elaborare, per esempio training.jpg oppure gioco_0.jpg
    # dest: cartella di destinazione nella quale salvare le immagini ritagliate dall'immagine originale
    # n: dimensione del lato del quadrato dell'immagine, 12 per training.jpg, oppure 3 per l'immagine di gioco_0.jpg, praticamente il numero di colonne della griglia
    # w: dimensione di ciascuna cella della griglia in px, ogni immagine estratta avra' tale dimensione, per esempio 100 per immagini di 100x100px
    # returnList: se vogliamo che il risultato, ovvero le immagini ritagliate, anziche' essere salvato in una cartella, venga restituito in una lista
    def __init__(s, orig, dest = None, n = 12, w = 100, returnList = False):
        # impostiamo alcune proprieta' private della classe
        s.__return = returnList
        s.__lista = [] # questo sara' l'eventuale elenco delle immagini
        # preleviamo il percorso assoluto sul quale si trova l'immagine di origine
        s.__orig = os.path.abspath(orig)
        # se non vogliamo una lista, creiamo il percorso di salvataggio delle immagini
        #a tale scopo prendiamo la cartella dell'immagine sorgente e ad essa accodiamo la cartella di destinazione
        if not s.__return: s.__dest = os.path.dirname(s.__orig) + "\\" + dest

        # se non vogliamo una lista
        if not s.__return:
            # allora dovremo salvare le immagini in una cartella
            # se la cartella di destinazione non esiste
            if not os.path.exists(s.__dest):
                # allora la creiamo
                os.makedirs(s.__dest)

        # salviamo i valori in prorieta' private
        s.__n = n
        s.__w = w

        # elaboriamo le immagini
        s.elabora()

    # per elaborare le immagini dobbiamo ritagliarle da quella originale
    # creiamo dunque un metodo per ritagliare le immagini, passando per argomento le coordinate (coor) di ritaglio
    # per coordinate si intendono xi, yi e xf, yf di ciascun quadrato di ritaglio (vedere l'articolo per maggiori informazioni)
    def ritaglia(s, coor, i):
        # leggiamo l'immagine con PIL
        img = Image.open(s.__orig)
        # ritagliamo l'immagine secondo le coordinate passate
        cropped = img.crop(coor)
        # se non vogliamo una lista, allora salviamo l'immagine nella destinazione prescelta
        if not s.__return: cropped.save(s.__dest + "\\img_" + str(i) + ".jpg")
        # altrimenti restituiamo l'immagine come array di NumPy
        else: return np.asarray(cropped)

    # con questo metodo elaboriamo l'immagine, chiamando ritaglia() per ciascuna cella della griglia
    def elabora(s):
        # per ciascuna riga
        for i in range(s.__n):
            #per ciascuna colonna
            for j in range(s.__n):
                # esegui ritaglia passando le coordinate calcolate e il numero progressivo dell'immagine
                img = s.ritaglia( ( j*s.__w , i*s.__w , (j+1) *s.__w , (i+1) * s.__w ) , i * s.__n + j )
                # aggiungi l'immagine alla lista delle immagini che si potranno eventualmente restituire
                s.__lista.append(img)

    # preleviamo la lista delle immagini elaborate
    def get(s):
        # convertiamo la lista in un array di NumPy
        return np.array(s.__lista)

class CreaDBImmagini:

    # creiamo delle costanti a livello di classe, che ci permettano di definire l'input tipo nel costruttore
    # e quindi il tipo di immagini che vogliamo tirare fuori, questo e' importante solo ai fini della creazione
    # delle etichette
    TEST = 0
    TRAINING = 1

    # il costruttore accetta 2 argomenti:
    # path: il percorso da cui leggere le immagini
    # tipo: il tipo di etichette da creare in associazione
    def __init__(s, path, tipo = 0):
        s.__path = path
        s.__immagini = []
        s.__descrizioni = []
        s.__tipo = tipo

        s.elabora()

    # elaboriamo le immagini
    def elabora(s):
        # per ogni elemento nella cartella
        for f in os.listdir(s.__path):
            # se si tratta di un file
            if os.path.isfile(s.__path + "\\" + f):
                # leggiamo il file dell'immagine aprendolo con PIL
                img = Image.open(s.__path + "\\" + f)
                # trasformiamo i dati dell'immagine in un array contenente i valori RGB dell'immagine stessa
                bimg = np.asarray(img)
                # aggiungiamo l'immagine all'elenco delle immagini
                s.__immagini.append(bimg)
                # otteniamo il numero dell'immagine, questo lo abbiamo per costruzione dalla precedente classe ElaboraImmagini
                numero = int(f.replace("img_","").replace(".jpg",""))
                # se l'immagine e' del gruppo di test
                if s.__tipo == s.TEST:
                    # siccome le immagini di test sono alternate, tipo O, X, O, X ecc, vuol dire che posso distinguerle
                    # come pari e dispari, quindi i pari saranno 0 e i dispari 1, rispettivamente O e X
                    s.__descrizioni.append( int(numero % 2) )
                # se l'immagine e' del gruppo di addestramento
                if s.__tipo == s.TRAINING:
                    # siccome le immagini di addestramento sono divise a meta', la prima meta' sono O e la seconda sono X
                    # allora sara' sufficiente dividere per la meta' del totale e arrotondare per difetto
                    s.__descrizioni.append( int(np.floor(numero / 72)) )

    # restituisci i due vettori come array di NumPy
    def get(s):
        return (np.array(s.__immagini) , np.array(s.__descrizioni))

class GiocoTris:

    # prendiamo come argomenti:
    # orig: cartella dove sono contenuti tutti i giochi
    # train: cartella dove si trovano le immagini di addestramento
    # test: cartella dove si trovano le immagini di test
    # nome_modello: nome della cartella nella quale verra' salvato il modello calcolato
    def __init__(s, orig = "GIOCHI", train = "TRAINING", test = "TEST", nome_modello = "gioco_del_tris"):
        s.__orig = orig
        s.__train = train
        s.__test = test
        s.__nome_modello = nome_modello
        s.__modello = None
        # leggiamo l'elenco dei file nella cartella orig, solo se sono dei file, e teniamoli come partite possibili
        s.__partite = [f for f in os.listdir(orig) if os.path.isfile(orig + "\\" + f)]

        # se il modello salvato esiste (ovvero se esiste la cartella)
        if os.path.exists(s.__nome_modello):
            # caricare il modello salvato
            s.__modello = keras.models.load_model(s.__nome_modello)
            
    #restituisce la lista dei file delle partite
    def getGiochi(s):
        return s.__partite

    # prepara il modello
    def prepara(s):

        # prepara il modello se il modello non esiste, ovvero non e' stato caricato
        if s.__modello is None:

            # preleva le immagini di addestramento e le relative descrizioni, ossia gli output noti
            train_img, train_desc = CreaDBImmagini(s.__train,CreaDBImmagini.TRAINING).get()

            # prepara il modello
            s.__modello = keras.Sequential([
                keras.layers.Flatten(input_shape=(100, 100, 3)),
                keras.layers.Dense(128, activation='relu'),
                keras.layers.Dense(2, activation='softmax')
            ])

            # compila il modello
            s.__modello.compile(optimizer="adam",
                  loss='sparse_categorical_crossentropy',
                  metrics=['accuracy'])

            # allena il modello con le immagini scelte in precedenza
            s.__modello.fit(train_img, train_desc, epochs=20)            

            # salva il modello
            s.__modello.save(s.__nome_modello)

    # valuta accuratezza del modello con immagini di test
    def getAccuracy(s):

        # preleva immagini e output di test
        test_img, test_desc = CreaDBImmagini(s.__test,CreaDBImmagini.TEST).get()

        # calcola le perdite e l'accuratezza sulle immagini di test
        s.__test_loss, s.__test_acc = s.__modello.evaluate(test_img, test_desc, verbose=0)
        
        return s.__test_acc

    # valuta uno specifico gioco, scelto come posizione tra le partite possibili
    def getImmagine(s, pos):
        # elabora l'immagine del gioco compiuto
        gioco = ElaboraImmagini(orig = s.__orig + "\\" + s.__partite[pos], n = 3, w = 100, returnList = True).get()

        # predici i risultati in termini percentuali
        previsione = s.__modello.predict(gioco)
        # prepara l'output reinterpretato
        s.__risultato = []
        # per ciascun valore delle previsioni
        for p in previsione:
            # se i valori sono vicini per un parametro arbitrario di confidenza, allora la casella e' vuota
            # per esempio se i valori sono 51% e 49%
            if abs(p[0]-p[1]) < 0.1: v = 0
            # se il primo valore supera il secondo allora abbiamo uno O
            elif p[0] > p[1]: v = 1
            # altrimenti abbiamo una X
            else: v = 2
            # aggiungi il valore al risultato
            s.__risultato.append(v)
        # ottieni il vincitore
        vincitore = s.getVincitore( s.__risultato )
        # restituisci il vincitore
        return vincitore

    # calcola il vincitore
    def getVincitore(s,vect):
        for i in range(0,9,3):
            if vect[i] == vect[i+1] == vect[i+2] and vect[i] != 0: return vect[i]
        for i in range(3):
            if vect[i] == vect[i+3] == vect[i+6] and vect[i] != 0: return vect[i]
        if (vect[0] == vect[4] == vect[8] and vect[0] != 0) or (vect[2] == vect[4] == vect[6] and vect[2] != 0): return vect[4]

    # mostra la griglia di gioco
    def stampaGioco(s):
        symb = ["-","O","X"]
        for k, r in enumerate(s.__risultato):
            if k > 0 and not k % 3: print()
            print(symb[r],end=" ")
        print()


ElaboraImmagini("training.jpg","TRAINING",12,100)
ElaboraImmagini("test.jpg","TEST",4,100)


gt = GiocoTris(orig = "GIOCHI", train = "TRAINING", test = "TEST", nome_modello = "gioco_del_tris")
gt.prepara()

while True:

    print("-- gioco del tris --")
    print('Test accuracy:', gt.getAccuracy())
    print("scegli la partita (-1 esci):")
    for k, n in enumerate(gt.getGiochi()):
        print("{0}. gioco {0}".format(k))
    print("> ",end="")
    partita = int(input())

    if partita == -1: break

    if partita >= 0 and partita <= 9:
        vincitore = gt.getImmagine( partita )
        if vincitore == 1: print("Ha vinto O")
        elif vincitore == 2: print("Ha vinto X")
        else: print("Nessun vincitore")

        gt.stampaGioco()

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

from __future__ import absolute_import, division, print_function, unicode_literals

from PIL import Image

import numpy as np

import os

import tensorflow as tf

from tensorflow import keras

import matplotlib.pyplot as plt

class ElaboraImmagini:

# al costruttore della classe passiamo i seguenti argomenti:

# orig: file dell'immagine originale da elaborare, per esempio training.jpg oppure gioco_0.jpg

# dest: cartella di destinazione nella quale salvare le immagini ritagliate dall'immagine originale

# n: dimensione del lato del quadrato dell'immagine, 12 per training.jpg, oppure 3 per l'immagine di gioco_0.jpg, praticamente il numero di colonne della griglia

# w: dimensione di ciascuna cella della griglia in px, ogni immagine estratta avra' tale dimensione, per esempio 100 per immagini di 100x100px

# returnList: se vogliamo che il risultato, ovvero le immagini ritagliate, anziche' essere salvato in una cartella, venga restituito in una lista

def __init__(s, orig, dest = None, n = 12, w = 100, returnList = False):

# impostiamo alcune proprieta' private della classe

s.__return = returnList

s.__lista = [] # questo sara' l'eventuale elenco delle immagini

# preleviamo il percorso assoluto sul quale si trova l'immagine di origine

s.__orig = os.path.abspath(orig)

# se non vogliamo una lista, creiamo il percorso di salvataggio delle immagini

#a tale scopo prendiamo la cartella dell'immagine sorgente e ad essa accodiamo la cartella di destinazione

if not s.__return: s.__dest = os.path.dirname(s.__orig) + "\\" + dest

# se non vogliamo una lista

if not s.__return:

# allora dovremo salvare le immagini in una cartella

# se la cartella di destinazione non esiste

if not os.path.exists(s.__dest):

# allora la creiamo

os.makedirs(s.__dest)

# salviamo i valori in prorieta' private

s.__n = n

s.__w = w

# elaboriamo le immagini

s.elabora()

# per elaborare le immagini dobbiamo ritagliarle da quella originale

# creiamo dunque un metodo per ritagliare le immagini, passando per argomento le coordinate (coor) di ritaglio

# per coordinate si intendono xi, yi e xf, yf di ciascun quadrato di ritaglio (vedere l'articolo per maggiori informazioni)

def ritaglia(s, coor, i):

# leggiamo l'immagine con PIL

img = Image.open(s.__orig)

# ritagliamo l'immagine secondo le coordinate passate

cropped = img.crop(coor)

# se non vogliamo una lista, allora salviamo l'immagine nella destinazione prescelta

if not s.__return: cropped.save(s.__dest + "\\img_" + str(i) + ".jpg")

# altrimenti restituiamo l'immagine come array di NumPy

else: return np.asarray(cropped)

# con questo metodo elaboriamo l'immagine, chiamando ritaglia() per ciascuna cella della griglia

def elabora(s):

# per ciascuna riga

for i in range(s.__n):

#per ciascuna colonna

for j in range(s.__n):

# esegui ritaglia passando le coordinate calcolate e il numero progressivo dell'immagine

img = s.ritaglia( ( j*s.__w , i*s.__w , (j+1) *s.__w , (i+1) * s.__w ) , i * s.__n + j )

# aggiungi l'immagine alla lista delle immagini che si potranno eventualmente restituire

s.__lista.append(img)

# preleviamo la lista delle immagini elaborate

def get(s):

# convertiamo la lista in un array di NumPy

return np.array(s.__lista)

class CreaDBImmagini:

# creiamo delle costanti a livello di classe, che ci permettano di definire l'input tipo nel costruttore

# e quindi il tipo di immagini che vogliamo tirare fuori, questo e' importante solo ai fini della creazione

# delle etichette

TEST = 0

TRAINING = 1

# il costruttore accetta 2 argomenti:

# path: il percorso da cui leggere le immagini

# tipo: il tipo di etichette da creare in associazione

def __init__(s, path, tipo = 0):

s.__path = path

s.__immagini = []

s.__descrizioni = []

s.__tipo = tipo

s.elabora()

# elaboriamo le immagini

def elabora(s):

# per ogni elemento nella cartella

for f in os.listdir(s.__path):

# se si tratta di un file

if os.path.isfile(s.__path + "\\" + f):

# leggiamo il file dell'immagine aprendolo con PIL

img = Image.open(s.__path + "\\" + f)

# trasformiamo i dati dell'immagine in un array contenente i valori RGB dell'immagine stessa

bimg = np.asarray(img)

# aggiungiamo l'immagine all'elenco delle immagini

s.__immagini.append(bimg)

# otteniamo il numero dell'immagine, questo lo abbiamo per costruzione dalla precedente classe ElaboraImmagini

numero = int(f.replace("img_","").replace(".jpg",""))

# se l'immagine e' del gruppo di test

if s.__tipo == s.TEST:

# siccome le immagini di test sono alternate, tipo O, X, O, X ecc, vuol dire che posso distinguerle

# come pari e dispari, quindi i pari saranno 0 e i dispari 1, rispettivamente O e X

s.__descrizioni.append( int(numero % 2) )

# se l'immagine e' del gruppo di addestramento

if s.__tipo == s.TRAINING:

# siccome le immagini di addestramento sono divise a meta', la prima meta' sono O e la seconda sono X

# allora sara' sufficiente dividere per la meta' del totale e arrotondare per difetto

s.__descrizioni.append( int(np.floor(numero / 72)) )

# restituisci i due vettori come array di NumPy

def get(s):

return (np.array(s.__immagini) , np.array(s.__descrizioni))

class GiocoTris:

# prendiamo come argomenti:

# orig: cartella dove sono contenuti tutti i giochi

# train: cartella dove si trovano le immagini di addestramento

# test: cartella dove si trovano le immagini di test

# nome_modello: nome della cartella nella quale verra' salvato il modello calcolato

def __init__(s, orig = "GIOCHI", train = "TRAINING", test = "TEST", nome_modello = "gioco_del_tris"):

s.__orig = orig

s.__train = train

s.__test = test

s.__nome_modello = nome_modello

s.__modello = None

# leggiamo l'elenco dei file nella cartella orig, solo se sono dei file, e teniamoli come partite possibili

s.__partite = [f for f in os.listdir(orig) if os.path.isfile(orig + "\\" + f)]

# se il modello salvato esiste (ovvero se esiste la cartella)

if os.path.exists(s.__nome_modello):

# caricare il modello salvato

s.__modello = keras.models.load_model(s.__nome_modello)

#restituisce la lista dei file delle partite

def getGiochi(s):

return s.__partite

# prepara il modello

def prepara(s):

# prepara il modello se il modello non esiste, ovvero non e' stato caricato

if s.__modello is None:

# preleva le immagini di addestramento e le relative descrizioni, ossia gli output noti

train_img, train_desc = CreaDBImmagini(s.__train,CreaDBImmagini.TRAINING).get()

# prepara il modello

s.__modello = keras.Sequential([

keras.layers.Flatten(input_shape=(100, 100, 3)),

keras.layers.Dense(128, activation='relu'),

keras.layers.Dense(2, activation='softmax')

])

# compila il modello

s.__modello.compile(optimizer="adam",

loss='sparse_categorical_crossentropy',

metrics=['accuracy'])

# allena il modello con le immagini scelte in precedenza

s.__modello.fit(train_img, train_desc, epochs=20)

# salva il modello

s.__modello.save(s.__nome_modello)

# valuta accuratezza del modello con immagini di test

def getAccuracy(s):

# preleva immagini e output di test

test_img, test_desc = CreaDBImmagini(s.__test,CreaDBImmagini.TEST).get()

# calcola le perdite e l'accuratezza sulle immagini di test

s.__test_loss, s.__test_acc = s.__modello.evaluate(test_img, test_desc, verbose=0)

return s.__test_acc

# valuta uno specifico gioco, scelto come posizione tra le partite possibili

def getImmagine(s, pos):

# elabora l'immagine del gioco compiuto

gioco = ElaboraImmagini(orig = s.__orig + "\\" + s.__partite[pos], n = 3, w = 100, returnList = True).get()

# predici i risultati in termini percentuali

previsione = s.__modello.predict(gioco)

# prepara l'output reinterpretato

s.__risultato = []

# per ciascun valore delle previsioni

for p in previsione:

# se i valori sono vicini per un parametro arbitrario di confidenza, allora la casella e' vuota

# per esempio se i valori sono 51% e 49%

if abs(p[0]-p[1]) < 0.1: v = 0

# se il primo valore supera il secondo allora abbiamo uno O

elif p[0] > p[1]: v = 1

# altrimenti abbiamo una X

else: v = 2

# aggiungi il valore al risultato

s.__risultato.append(v)

# ottieni il vincitore

vincitore = s.getVincitore( s.__risultato )

# restituisci il vincitore

return vincitore

# calcola il vincitore

def getVincitore(s,vect):

for i in range(0,9,3):

if vect[i] == vect[i+1] == vect[i+2] and vect[i] != 0: return vect[i]

for i in range(3):

if vect[i] == vect[i+3] == vect[i+6] and vect[i] != 0: return vect[i]

if (vect[0] == vect[4] == vect[8] and vect[0] != 0) or (vect[2] == vect[4] == vect[6] and vect[2] != 0): return vect[4]

# mostra la griglia di gioco

def stampaGioco(s):

symb = ["-","O","X"]

for k, r in enumerate(s.__risultato):

if k > 0 and not k % 3: print()

print(symb[r],end=" ")

print()

ElaboraImmagini("training.jpg","TRAINING",12,100)

ElaboraImmagini("test.jpg","TEST",4,100)

gt = GiocoTris(orig = "GIOCHI", train = "TRAINING", test = "TEST", nome_modello = "gioco_del_tris")

gt.prepara()

while True:

print("-- gioco del tris --")

print('Test accuracy:', gt.getAccuracy())

print("scegli la partita (-1 esci):")

for k, n in enumerate(gt.getGiochi()):

print("{0}. gioco {0}".format(k))

print("> ",end="")

partita = int(input())

if partita == -1: break

if partita >= 0 and partita <= 9:

vincitore = gt.getImmagine( partita )

if vincitore == 1: print("Ha vinto O")

elif vincitore == 2: print("Ha vinto X")

else: print("Nessun vincitore")

gt.stampaGioco()

[python] Esercizio su funzioni ricorsive e calcolo del percorso minore possibile

Immaginiamo di avere la seguente situazione: su una griglia rettangolare abbiamo due punti, A e B e vogliamo calcolare il minore percorso possibile per arrivare da A a B, evitando degli ostacoli. Da una cella all’altra ci si può spostare solamente in verticale ed orizzontale.

Possiamo schematizzare il problema in qualcosa di simile.

Anzitutto impostiamo le variabili necessarie:

n = 10 # numero di colonne
m = 10 # numero di righe
x = 10 # numero di ostacoli
pi = [] # punto di partenza
pf = [] # punto di arrivo
percorsi = [] # tutti i percorsi possibili
minlen = 0 # lunghezza trovata

n = 10 # numero di colonne

m = 10 # numero di righe

x = 10 # numero di ostacoli

pi = [] # punto di partenza

pf = [] # punto di arrivo

percorsi = [] # tutti i percorsi possibili

minlen = 0 # lunghezza trovata

In particolare faccio notare che terremo tutti i percorsi in una lista percorsi = [] e vogliamo anche tenere traccia della minima lunghezza trovata con minlen. Questo accorgimento, come vedremo successivamente, ci servirà per ridurre notevolmente la quantità di calcoli da dover effettuare, eliminando tutti i percorsi che via via dovessero rivelarsi più lunghi del minimo percorso trovato (fino a quel momento).

A questo punto generiamo la matrice del mondo:

mtrx = [["-" for c in range(m)] for r in range(n)]

1	mtrx = [["-" for c in range(m)] for r in range(n)]

Adesso scriviamo la funzione per popolare il mondo di blocchi, le X del disegno precedente. Per farlo utilizzeremo la libreria random, per cui ricordiamoci di importarla all’inizio con import random

def blocchi():
    t = 0
    while t < x:
        tc = random.randint(0, m-1)
        tr = random.randint(0, n-1)
        if mtrx[tr][tc] != "X":
            mtrx[tr][tc] = "X"
            t += 1

def blocchi():

t = 0

while t < x:

tc = random.randint(0, m-1)

tr = random.randint(0, n-1)

if mtrx[tr][tc] != "X":

mtrx[tr][tc] = "X"

t += 1

Utilizziamo random.randint per generare una posizione casuale su righe e colonne per i blocchi, verifichiamo che tale punto non sia già occupato da un blocco, in tal caso procediamo ad aggiungerlo.

In modo analogo creiamo un metodo che aggiunga la posizione iniziale A e quella finale B, registrandole nelle rispettive variabili.

def inizio():
    global pi, pf
    t = 0
    while t < 2:
        tc = random.randint(0, m-1)
        tr = random.randint(0, n-1)
        if mtrx[tr][tc] == "-":
            if t == 0:
                mtrx[tr][tc] = "A"
                pi = [tr,tc]
            else:
                mtrx[tr][tc] = "B"
                pf = [tr,tc]
            t += 1

def inizio():

global pi, pf

t = 0

while t < 2:

tc = random.randint(0, m-1)

tr = random.randint(0, n-1)

if mtrx[tr][tc] == "-":

if t == 0:

mtrx[tr][tc] = "A"

pi = [tr,tc]

else:

mtrx[tr][tc] = "B"

pf = [tr,tc]

t += 1

Per trovare il percorso procediamo nella maniera seguente:

def trova(si,percorso=[]):
    # usiamo minlen come variabile globale
    global minlen
    # se la posizione corrente rientra nella matrice, allora procediamo
    if si[0] >= 0 and si[0] < n and si[1] >= 0 and si[1] < m:
        # se la posizione non e' occupata da un blocco e non e' gia' presente nel percorso procediamo
        if mtrx[si[0]][si[1]] != "X" and si not in percorso:
            # aggiungiamo la posizione
            percorso.append(si)
            # se il percorso supera la minima lunghezza trovata e tale lunghezza e' maggiore di 0, interrompiamo la ricorsione
            if len(percorso) > minlen and minlen > 0: return
            # se la posizione e' occupata dalla B allora abbiamo trovato la fine
            if mtrx[si[0]][si[1]] == "B":
                # se la lunghezza del percorso trovato e' minore della minore trovata
                # fino a quel momento, oppure la minore lunghezza e' a 0, aggiorniamo la lunghezza minore
                if len(percorso) < minlen or minlen == 0: minlen = len(percorso)
                #aggiungiamo il percorso ai percorsi trovati
                percorsi.append([]+percorso)
            #altrimenti eseguiamo la funzione sulle caselle circostanti
            else:
                trova([si[0]-1,si[1]],[]+percorso)
                trova([si[0]+1,si[1]],[]+percorso)
                trova([si[0],si[1]-1],[]+percorso)
                trova([si[0],si[1]+1],[]+percorso)

def trova(si,percorso=[]):

# usiamo minlen come variabile globale

global minlen

# se la posizione corrente rientra nella matrice, allora procediamo

if si[0] >= 0 and si[0] < n and si[1] >= 0 and si[1] < m:

# se la posizione non e' occupata da un blocco e non e' gia' presente nel percorso procediamo

if mtrx[si[0]][si[1]] != "X" and si not in percorso:

# aggiungiamo la posizione

percorso.append(si)

# se il percorso supera la minima lunghezza trovata e tale lunghezza e' maggiore di 0, interrompiamo la ricorsione

if len(percorso) > minlen and minlen > 0: return

# se la posizione e' occupata dalla B allora abbiamo trovato la fine

if mtrx[si[0]][si[1]] == "B":

# se la lunghezza del percorso trovato e' minore della minore trovata

# fino a quel momento, oppure la minore lunghezza e' a 0, aggiorniamo la lunghezza minore

if len(percorso) < minlen or minlen == 0: minlen = len(percorso)

#aggiungiamo il percorso ai percorsi trovati

percorsi.append([]+percorso)

#altrimenti eseguiamo la funzione sulle caselle circostanti

else:

trova([si[0]-1,si[1]],[]+percorso)

trova([si[0]+1,si[1]],[]+percorso)

trova([si[0],si[1]-1],[]+percorso)

trova([si[0],si[1]+1],[]+percorso)

Faccio notare una peculiarità, legata al modo in cui Python tratta le liste. Per passare il percorso attuale, copiandolo, alla funzione medesima, dobbiamo usare un piccolo trucco scrivendo []+percorso. In questo modo evitiamo che il percorso sia passato per riferimento, forzando il programma a crearne una copia.

Fatto tutto questo aggiungiamo un metodo per la stampa della matrice:

def stampa():
    for r in mtrx:
        for c in r:
            print(c,end="")
        print()

def stampa():

for r in mtrx:

for c in r:

print(c,end="")

print()

E un metodo per prendere uno dei percorsi più corti calcolati (ricordiamoci che potrebbero esserci più percorsi):

def elabora():
    for p in percorsi:
        if len(p) == minlen:
            for c in p:
                if c != pi and c != pf:
                   mtrx[c[0]][c[1]] = "o"
            print(p)
            break

def elabora():

for p in percorsi:

if len(p) == minlen:

for c in p:

if c != pi and c != pf:

mtrx[c[0]][c[1]] = "o"

print(p)

break

Infine uniamo tutto quanto insieme, importando anche la libreria temporale con import time per valutare la velocità di elaborazione.

ti = time.time()

blocchi()
inizio()

print("mappa senza percorso")
stampa()

trova(pi,[])

print("mappa con percorso")
elabora()
stampa()
print("percorsi trovati %d" % len(percorsi))

tf = time.time()

print("tempo di calcolo: %.2f s" % (tf - ti))

ti = time.time()

blocchi()

inizio()

print("mappa senza percorso")

stampa()

trova(pi,[])

print("mappa con percorso")

elabora()

stampa()

print("percorsi trovati %d" % len(percorsi))

tf = time.time()

print("tempo di calcolo: %.2f s" % (tf - ti))

Di seguito il codice completo:

import random
import time

n = 10 # numero di colonne
m = 10 # numero di righe
x = 10 # numero di ostacoli
pi = [] # punto di partenza
pf = [] # punto di arrivo
percorsi = [] # tutti i percorsi possibili
minlen = 0 # lunghezza trovata

mtrx = [["-" for c in range(m)] for r in range(n)]

def blocchi():
    t = 0
    while t < x:
        tc = random.randint(0, m-1)
        tr = random.randint(0, n-1)
        if mtrx[tr][tc] != "X":
            mtrx[tr][tc] = "X"
            t += 1

def inizio():
    global pi, pf
    t = 0
    while t < 2:
        tc = random.randint(0, m-1)
        tr = random.randint(0, n-1)
        if mtrx[tr][tc] == "-":
            if t == 0:
                mtrx[tr][tc] = "A"
                pi = [tr,tc]
            else:
                mtrx[tr][tc] = "B"
                pf = [tr,tc]
            t += 1

def stampa():
    for r in mtrx:
        for c in r:
            print(c,end="")
        print()

def trova(si,percorso=[]):
    # usiamo minlen come variabile globale
    global minlen
    # se la posizione corrente rientra nella matrice, allora procediamo
    if si[0] >= 0 and si[0] < n and si[1] >= 0 and si[1] < m:
        # se la posizione non e' occupata da un blocco e non e' gia' presente nel percorso procediamo
        if mtrx[si[0]][si[1]] != "X" and si not in percorso:
            # aggiungiamo la posizione
            percorso.append(si)
            # se il percorso supera la minima lunghezza trovata e tale lunghezza e' maggiore di 0, interrompiamo la ricorsione
            if len(percorso) > minlen and minlen > 0: return
            # se la posizione e' occupata dalla B allora abbiamo trovato la fine
            if mtrx[si[0]][si[1]] == "B":
                # se la lunghezza del percorso trovato e' minore della minore trovata
                # fino a quel momento, oppure la minore lunghezza e' a 0, aggiorniamo la lunghezza minore
                if len(percorso) < minlen or minlen == 0: minlen = len(percorso)
                #aggiungiamo il percorso ai percorsi trovati
                percorsi.append([]+percorso)
            #altrimenti eseguiamo la funzione sulle caselle circostanti
            else:
                trova([si[0]-1,si[1]],[]+percorso)
                trova([si[0]+1,si[1]],[]+percorso)
                trova([si[0],si[1]-1],[]+percorso)
                trova([si[0],si[1]+1],[]+percorso)

def elabora():
    for p in percorsi:
        if len(p) == minlen:
            for c in p:
                if c != pi and c != pf:
                   mtrx[c[0]][c[1]] = "o"
            print(p)
            break
    
ti = time.time()

blocchi()
inizio()

print("mappa senza percorso")
stampa()

trova(pi,[])

print("mappa con percorso")
elabora()
stampa()
print("percorsi trovati %d" % len(percorsi))

tf = time.time()

print("tempo di calcolo: %.2f s" % (tf - ti))

import random

import time

n = 10 # numero di colonne

m = 10 # numero di righe

x = 10 # numero di ostacoli

pi = [] # punto di partenza

pf = [] # punto di arrivo

percorsi = [] # tutti i percorsi possibili

minlen = 0 # lunghezza trovata

mtrx = [["-" for c in range(m)] for r in range(n)]

def blocchi():

t = 0

while t < x:

tc = random.randint(0, m-1)

tr = random.randint(0, n-1)

if mtrx[tr][tc] != "X":

mtrx[tr][tc] = "X"

t += 1

def inizio():

global pi, pf

t = 0

while t < 2:

tc = random.randint(0, m-1)

tr = random.randint(0, n-1)

if mtrx[tr][tc] == "-":

if t == 0:

mtrx[tr][tc] = "A"

pi = [tr,tc]

else:

mtrx[tr][tc] = "B"

pf = [tr,tc]

t += 1

def stampa():

for r in mtrx:

for c in r:

print(c,end="")

print()

def trova(si,percorso=[]):

# usiamo minlen come variabile globale

global minlen

# se la posizione corrente rientra nella matrice, allora procediamo

if si[0] >= 0 and si[0] < n and si[1] >= 0 and si[1] < m:

# se la posizione non e' occupata da un blocco e non e' gia' presente nel percorso procediamo

if mtrx[si[0]][si[1]] != "X" and si not in percorso:

# aggiungiamo la posizione

percorso.append(si)

# se il percorso supera la minima lunghezza trovata e tale lunghezza e' maggiore di 0, interrompiamo la ricorsione

if len(percorso) > minlen and minlen > 0: return

# se la posizione e' occupata dalla B allora abbiamo trovato la fine

if mtrx[si[0]][si[1]] == "B":

# se la lunghezza del percorso trovato e' minore della minore trovata

# fino a quel momento, oppure la minore lunghezza e' a 0, aggiorniamo la lunghezza minore

if len(percorso) < minlen or minlen == 0: minlen = len(percorso)

#aggiungiamo il percorso ai percorsi trovati

percorsi.append([]+percorso)

#altrimenti eseguiamo la funzione sulle caselle circostanti

else:

trova([si[0]-1,si[1]],[]+percorso)

trova([si[0]+1,si[1]],[]+percorso)

trova([si[0],si[1]-1],[]+percorso)

trova([si[0],si[1]+1],[]+percorso)

def elabora():

for p in percorsi:

if len(p) == minlen:

for c in p:

if c != pi and c != pf:

mtrx[c[0]][c[1]] = "o"

print(p)

break

ti = time.time()

blocchi()

inizio()

print("mappa senza percorso")

stampa()

trova(pi,[])

print("mappa con percorso")

elabora()

stampa()

print("percorsi trovati %d" % len(percorsi))

tf = time.time()

print("tempo di calcolo: %.2f s" % (tf - ti))

L’output finale darà qualcosa di simile a questo: