Petar Karan

Configurare VirtualHost su Apache, database MySQL e accesso FTP per un utente con BASH

L’esercizio in bash che propongo stavolta consiste nell’automatizzare la configurazione di un hosting sul nostro server Apache, ovvero la configurazione del VirtualHost, di un nuovo utente e database MySQL e di un accesso FTP.

L’obiettivo è quello di arrivare ad avere uno script utilizzabile nel modo seguente:

sudo ./addhosting.sh -u pippo -d sito-diprova.com --dbadmin root --dbpass passwor

1	sudo ./addhosting.sh -u pippo -d sito-diprova.com --dbadmin root --dbpass passwor

I parametri che vogliamo passare al nostro script sono:

-u: il nome dell’utente che vogliamo creare
-d: il nome del dominio che vogliamo registrare come VirtualHost di Apache
–dbadmin: il nome utente dell’amministratore del database, quello in grado di creare altri utenti all’interno del MySQL
–dbpass: la password del suddetto utente del database MySQL

Questo ci darà occasione per esplorare diverse caratteristiche di bash.

Anzitutto vogliamo acquisire ed elaborare i vari parametri passati al nostro script. Finora abbiamo visto che i parametri possono essere letti usando $# per contare il numero di argomenti, $0 per visualizzare il nome dello script, $1 per prendere il primo parametro, $2 per prendere il secondo e via discorrendo.

Adesso vogliamo prendere un numero indefinito di argomenti e parametrizzarli, vediamo come fare:

while [[ $# -gt 0 ]]
do

	parametro="$1"

	case $parametro in
		-d|--domain)
		dominio="$2"
		shift
		shift
		;;
		-u|--user)
		utente="$2"
		shift
		shift
		;;
		--dbadmin)
		dbadmin="$2"
		shift
		shift
		;;
		--dbpass|--dbpassword)
		dbpass="$2"
		shift
		shift
		;;
		-h|--help)
		aiuto=true
		shift
		;;
		-f|--fix)
		ripristina=true
		shift
		;;
		*)
		shift
		;;
	esac

done

while [[ $# -gt 0 ]]

parametro="$1"

case $parametro in

-d|--domain)

dominio="$2"

shift

;;

-u|--user)

utente="$2"

shift

;;

--dbadmin)

dbadmin="$2"

shift

;;

--dbpass|--dbpassword)

dbpass="$2"

shift

;;

-h|--help)

aiuto=true

shift

;;

-f|--fix)

ripristina=true

shift

;;

shift

;;

esac

done

Usiamo quindi un ciclo while che continuerà ad andare avanti finché il numero di parametri passati allo script non sarà 0. Quindi acquisiamo il primo parametro $1 e lo passiamo ad una variabile chiamata parametro. Utilizziamo adesso un interruttore (case…esac) per cui in base al valore di parametro si attiveranno diverse opzioni.

Ciascuna opzione è scritta nella forma

valore)
...
...
;;

valore)

...

;;

Qui al posto di valore può essere un singolo valore oppure un gruppo diviso da |, nella maniera di valore1|valore2. Al posto dei puntini ci va del codice a piacere che vogliamo attivare in base alla variabile. Il principio, concettualmente, è identico a quello della realizzazione del programma in bash con menu.

Il comando shift, in bash, rimuove gli argomenti passati ad uno script a partire dall’inizio della lista, cioè dal primo argomento. Questo significa che ad ogni ciclo del while non prenderemo il primo argomento, lo controlleremo e poi lo rimuoveremo dall’elenco. Quando si digita due volte shift, si estraggono due parametri.

Viene da se che se l’argomento $1 è, per esempio, uguale a “-d“, allora l’argomento $2 dovrà contenere il nome del dominio e quindi una volta letti li rimuoveremo entrambi.

Se invece l’argomento $1 fosse uguale a “-h” oppure a “–help“, allora visualizzeremmo, senza ulteriori opzioni, una guida allo script. In questo caso dovremmo rimuovere un solo argomento.

Fatto questo cominciamo ad elaborare i parametri acquisiti. Anzitutto controlliamo se sia stato passato un nome utente del database:

call_check_dbadmin() {

	if [[ $dbadmin = "" ]]
	then
		errore "Inserire utente amministratore del database"
	fi

}

call_check_dbadmin() {

if [[ $dbadmin = "" ]]

then

errore "Inserire utente amministratore del database"

}

Se non c’è un nome utente del database chiamiamo una funzione che stampi l’errore:

errore() {

        echo -e "${ROSSO}ERRORE!${NC} $1. Per aiuto usare -h o --help"
	exit

}

errore() {

echo -e "${ROSSO}ERRORE!${NC} $1. Per aiuto usare -h o --help"

exit

}

In questo caso vogliamo usare, visto che possiamo, anche dei colori, e quindi colorare di rosso la parola “ERRORE!”. Per farlo facciamo riferimento all’ANSI escape code.

Quindi possiamo usare le seguenti combinazioni:

Black        0;30     Dark Gray     1;30
Red          0;31     Light Red     1;31
Green        0;32     Light Green   1;32
Brown/Orange 0;33     Yellow        1;33
Blue         0;34     Light Blue    1;34
Purple       0;35     Light Purple  1;35
Cyan         0;36     Light Cyan    1;36
Light Gray   0;37     White         1;37

Black 0;30 Dark Gray 1;30

Red 0;31 Light Red 1;31

Green 0;32 Light Green 1;32

Brown/Orange 0;33 Yellow 1;33

Blue 0;34 Light Blue 1;34

Purple 0;35 Light Purple 1;35

Cyan 0;36 Light Cyan 1;36

Light Gray 0;37 White 1;37

Questo significa che se nella string “ERRORE! C’è un errore” fosse scritto “\033[0;31mERRORE!\033[0m C’è un errore” la stringa verrebbe colorata tutta di rosso, fino al nuovo colore che è, in questo caso, quello nullo predefinito. Ovvero così:

Per comodità vogliamo parametrizzare alcuni colori inserendo, in cima allo script il seguente codice:

GIALLO='\033[1;33m'
ROSSO='\033[0;31m'
CELESTE='\033[1;34m'
NC='\033[0m'

GIALLO='\033[1;33m'

ROSSO='\033[0;31m'

CELESTE='\033[1;34m'

NC='\033[0m'

La variabile NC starebbe per No Color, ovviamente i nomi sono a piacere.

Fatto questo controlliamo se sia stata passata anche la password, se non è stato fatto la richiediamo:

call_check_dbpass() {

	if [[ $dbadmin != "" && $dbpass = "" ]]
	then
		echo -n "$dbadmin password: "
		read -s dbpass
		echo
	fi

}

call_check_dbpass() {

if [[ $dbadmin != "" && $dbpass = "" ]]

then

echo -n "$dbadmin password: "

read -s dbpass

echo

}

Potremmo aggiungere altri controlli (per esempio sul nome del dominio, ecc.) ma per ora tralasciamo ed andiamo a creare la cartella del vhost sotto a /var/www.

www="/var/www/"

call_crea_cartella() {

	mkdir $www$dominio 2>/dev/null || errore "Permesso negato. Eseguire come root"

}

www="/var/www/"

call_crea_cartella() {

mkdir $www$dominio 2>/dev/null || errore "Permesso negato. Eseguire come root"

}

Utilizziamo 2>/dev/null per reindirizzare l’output di un eventuale errore e non mostrarlo a schermo, mentre il connettore || vuol dire che, dati due comandi A e B per cui A || B, se A non va a buon fine, allora esegui B.

Fatto questo creiamo subito l’utente FTP dedicato e la relativa password. In questo esempio do per scontato che abbiamo installato ProFTPd e che sia già stato configurato correttamente sul nostro server:

ftppassword="$(openssl rand -base64 12)"

call_crea_ftp() {

	useradd --shell /bin/false $utente
	chown $utente:www-data $www$dominio
	usermod -d $www$dominio $utente
	echo $utente:$ftppassword | /usr/sbin/chpasswd
	echo "FTP Password: $ftppassword"

}

ftppassword="$(openssl rand -base64 12)"

call_crea_ftp() {

useradd --shell /bin/false $utente

chown $utente:www-data $www$dominio

usermod -d $www$dominio $utente

echo $utente:$ftppassword | /usr/sbin/chpasswd

echo "FTP Password: $ftppassword"

}

Con il primo comando creiamo una password casuale di 12 caratteri.

Creiamo poi un utente chiamato come da argomento e assegniamo, alla cartella creata in precedenza, come proprietario l’utente appena creato e come gruppo www-data (ricordiamoci che sulla cartella deve poter interagire anche Apache). Fatta questa modifica con il comando usermod -d assegniamo la cartella alla home dell’utente. Questo viene fatto per motivi di sicurezza, per cui l’utente che accede al FTP acceda direttamente alla sua “home“, corrispondente anche allo spazio web.

Dopodiché impostiamo la password appena creata come password del nostro utente, ed infine stampiamola a video.

Faccio notare che perché –shell /bin/false non dia problemi, così come la questione della home, è necessario che nel file di configurazione di ProFTPd (/etc/proftpd/proftpd.conf) siano presenti i seguenti parametri così configurati (tipicamente va tolto il cancelletto):

DefaultRoot                     ~
RequireValidShell               off

1 2	DefaultRoot ~ RequireValidShell off

Fatto questo scriviamo il nostro file del VirtualHost:

sites="/etc/apache2/sites-available/"

call_crea_vhost() {

cat << EOF > "${sites}${dominio/./_}.conf"
<VirtualHost *:80>
        ServerName $dominio

        ServerAdmin webmaster@localhost
        DocumentRoot $www$dominio

        ErrorLog \${APACHE_LOG_DIR}/error.log
        CustomLog \${APACHE_LOG_DIR}/access.log combined
</VirtualHost>
EOF

}

sites="/etc/apache2/sites-available/"

call_crea_vhost() {

cat << EOF > "${sites}${dominio/./_}.conf"

ServerName $dominio

ServerAdmin webmaster@localhost

DocumentRoot $www$dominio

ErrorLog \${APACHE_LOG_DIR}/error.log

CustomLog \${APACHE_LOG_DIR}/access.log combined

</VirtualHost>

EOF

}

In questo caso vogliamo creare un file del tipo nomedominio.conf dentro a /etc/apache2/sites-available/, già che ci siamo sostituiamo il . con un _, in modo tale che nomedominio.com diventi nomedominio_com e il nome del file nomedominio_com.conf. Con l’istruzione EOF possiamo scrivere direttamente dentro il file il testo contenuto in mezzo.

Fatto questo ricarichiamo Apache:

call_agg_vhost() {

	a2ensite "${dominio/./_}" 2>/dev/null || errore "Apache non è installato o configurato correttamente."
	service apache2 reload 2>/dev/null

}

call_agg_vhost() {

a2ensite "${dominio/./_}" 2>/dev/null || errore "Apache non è installato o configurato correttamente."

service apache2 reload 2>/dev/null

}

Adesso ci manca solamente il database:

newpassword="$(openssl rand -base64 12)"

call_crea_db() {

	dbname="${dominio/./_}"
	dbname="${dbname/-/_}"
	mysql -u$dbadmin -p$dbpass -e "DROP DATABASE IF EXISTS $dbname" 2>/dev/null
	mysql -u$dbadmin -p$dbpass -e "DROP USER $dbname@localhost" 2>/dev/null
	mysql -u$dbadmin -p$dbpass -e "CREATE DATABASE $dbname" 2>/dev/null
	mysql -u$dbadmin -p$dbpass -e "CREATE USER $dbname@localhost IDENTIFIED BY '$newpassword'" 2>/dev/null
	mysql -u$dbadmin -p$dbpass -e "GRANT ALL PRIVILEGES ON $dbname.* TO $dbname@localhost" 2>/dev/null

}

newpassword="$(openssl rand -base64 12)"

call_crea_db() {

dbname="${dominio/./_}"

dbname="${dbname/-/_}"

mysql -u$dbadmin -p$dbpass -e "DROP DATABASE IF EXISTS $dbname" 2>/dev/null

mysql -u$dbadmin -p$dbpass -e "DROP USER $dbname@localhost" 2>/dev/null

mysql -u$dbadmin -p$dbpass -e "CREATE DATABASE $dbname" 2>/dev/null

mysql -u$dbadmin -p$dbpass -e "CREATE USER $dbname@localhost IDENTIFIED BY '$newpassword'" 2>/dev/null

mysql -u$dbadmin -p$dbpass -e "GRANT ALL PRIVILEGES ON $dbname.* TO $dbname@localhost" 2>/dev/null

}

Anche in questo caso abbiamo creato una password che assoceremo ad un utente chiamato come il database medesimo e che ha accesso solamente dal server locale.

Infine, per testare il tutto (questo certo non sarebbe uno standard opportuno per un vero hosting) creiamo un file index.php nel VirtualHost appena configurato e inseriamo dentro i seguenti parametri:

call_crea_index() {

cat << EOF > "${www}$dominio/index.php"
<?php

        echo "<h1>$dominio under construction</h1>";
        mysqli_connect("localhost", "$dbname", "$newpassword", "$dbname") or die("Errore database");

?>
EOF

}

call_crea_index() {

cat << EOF > "${www}$dominio/index.php"

<?php

echo "<h1>$dominio under construction</h1>";

mysqli_connect("localhost", "$dbname", "$newpassword", "$dbname") or die("Errore database");

EOF

}

Se tutto è andato bene collegandoci al dominio del hosting appena registrato dovremmo veder scritto Nome_Dominio under construction e nessun avviso di Errore database.

Aggiungo anche un’ultima funzione utile per ripristinare il tutto quando si usa il parametro –fix, cancellando quindi il vhost e le relative cartelle:

call_rimuovi() {

	if $ripristina
	then
		a2dissite "${dominio/./_}"
		rm -R $www$dominio 2>/dev/null
		rm "${sites}${dominio/./_}.conf"
	fi

}

call_rimuovi() {

if $ripristina

then

a2dissite "${dominio/./_}"

rm -R $www$dominio 2>/dev/null

rm "${sites}${dominio/./_}.conf"

}

Il codice completo, riorganizzando quanto detto prima, è questo:

#!/bin/bash

# CONFIGURAZIONE SISTEMA
sites="/etc/apache2/sites-available/"
www="/var/www/"

# CODICE DA NON MODIFICARE
GIALLO='\033[1;33m'
ROSSO='\033[0;31m'
CELESTE='\033[1;34m'
NC='\033[0m'
TAB1='\t'
TAB2='\t\t'

aiuto=false
ripristina=false

newpassword="$(openssl rand -base64 12)"
ftppassword="$(openssl rand -base64 12)"

errore() {

        echo -e "${ROSSO}ERRORE!${NC} $1. Per aiuto usare -h o --help"
	exit

}


while [[ $# -gt 0 ]]
do

	parametro="$1"

	case $parametro in
		-d|--domain)
		dominio="$2"
		shift
		shift
		;;
		-u|--user)
		utente="$2"
		shift
		shift
		;;
		--dbadmin)
		dbadmin="$2"
		shift
		shift
		;;
		--dbpass|--dbpassword)
		dbpass="$2"
		shift
		shift
		;;
		-h|--help)
		aiuto=true
		shift
		;;
		-f|--fix)
		ripristina=true
		shift
		;;
		*)
		shift
		;;
	esac

done

call_aiuto() {

	if $aiuto
	then
		echo
		echo -e "${TAB1}${ROSSO}GUIDA ALL'UTILIZZO${NC}"
		echo
		echo -e "${TAB1}$0"
		echo
		echo -e "${TAB1}${CELESTE}Comando${NC}"
		echo -e "${TAB1}$0 -d|--domain DomainName -u|--user DomainUser --dbadmin DatabaseRootUser [--dbpass|--dbpassword DatabaseRootPassword] [-f|--fix]"
		echo 
		echo -e "${TAB1}${CELESTE}Parametri${NC}"
		echo -e "${TAB1}${GIALLO}DomainName${NC}${TAB2}nome del dominio che vogliamo creare, per esempio: -d miosito.com"
		echo -e "${TAB1}${GIALLO}DomainUser${NC}${TAB2}nome dell'utente che gestirà il dominio, per esempio: -u mariorossi"
		echo -e "${TAB1}${GIALLO}DatabaseRootUser${NC}${TAB1}nome dell'utente amministratore del database, tipicamente root"
		echo -e "${TAB1}${GIALLO}DatabaseRootPassword${NC}${TAB1}Password dell'utente amministratore del database"
		echo
		exit
	fi

}

call_check_dbadmin() {

	if [[ $dbadmin = "" ]]
	then
		errore "Inserire utente amministratore del database"
	fi

}

call_check_dbpass() {

	if [[ $dbadmin != "" && $dbpass = "" ]]
	then
		echo -n "$dbadmin password: "
		read -s dbpass
		echo
	fi

}

call_crea_cartella() {

	mkdir $www$dominio 2>/dev/null || errore "Permesso negato. Eseguire come root"

}

call_crea_ftp() {

	useradd --shell /bin/false $utente
	chown $utente:www-data $www$dominio
	usermod -d $www$dominio $utente
	echo $utente:$ftppassword | /usr/sbin/chpasswd
	echo "FTP Password: $ftppassword"

}

call_crea_vhost() {

cat << EOF > "${sites}${dominio/./_}.conf"
<VirtualHost *:80>
        ServerName $dominio

        ServerAdmin webmaster@localhost
        DocumentRoot $www$dominio

        ErrorLog \${APACHE_LOG_DIR}/error.log
        CustomLog \${APACHE_LOG_DIR}/access.log combined
</VirtualHost>
EOF

}

call_agg_vhost() {

	a2ensite "${dominio/./_}" 2>/dev/null || errore "Apache non è installato o configurato correttamente."
	service apache2 reload 2>/dev/null

}

call_crea_db() {

	dbname="${dominio/./_}"
	dbname="${dbname/-/_}"
	mysql -u$dbadmin -p$dbpass -e "DROP DATABASE IF EXISTS $dbname" 2>/dev/null
	mysql -u$dbadmin -p$dbpass -e "DROP USER $dbname@localhost" 2>/dev/null
	mysql -u$dbadmin -p$dbpass -e "CREATE DATABASE $dbname" 2>/dev/null
	mysql -u$dbadmin -p$dbpass -e "CREATE USER $dbname@localhost IDENTIFIED BY '$newpassword'" 2>/dev/null
	mysql -u$dbadmin -p$dbpass -e "GRANT ALL PRIVILEGES ON $dbname.* TO $dbname@localhost" 2>/dev/null

}

call_crea_index() {

cat << EOF > "${www}$dominio/index.php"
<?php

        echo "<h1>$dominio under construction</h1>";
        mysqli_connect("localhost", "$dbname", "$newpassword", "$dbname") or die("Errore database");

?>
EOF

}


call_rimuovi() {

	if $ripristina
	then
		a2dissite "${dominio/./_}"
		rm -R $www$dominio 2>/dev/null
		rm "${sites}${dominio/./_}.conf"
	fi

}

call_rimuovi
call_aiuto
call_check_dbadmin
call_check_dbpass
call_crea_cartella
call_crea_vhost
call_agg_vhost
call_crea_db
call_crea_index
call_crea_ftp

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

#!/bin/bash

# CONFIGURAZIONE SISTEMA

sites="/etc/apache2/sites-available/"

www="/var/www/"

# CODICE DA NON MODIFICARE

GIALLO='\033[1;33m'

ROSSO='\033[0;31m'

CELESTE='\033[1;34m'

NC='\033[0m'

TAB1='\t'

TAB2='\t\t'

aiuto=false

ripristina=false

newpassword="$(openssl rand -base64 12)"

ftppassword="$(openssl rand -base64 12)"

errore() {

echo -e "${ROSSO}ERRORE!${NC} $1. Per aiuto usare -h o --help"

exit

}

while [[ $# -gt 0 ]]

parametro="$1"

case $parametro in

-d|--domain)

dominio="$2"

shift

;;

-u|--user)

utente="$2"

shift

;;

--dbadmin)

dbadmin="$2"

shift

;;

--dbpass|--dbpassword)

dbpass="$2"

shift

;;

-h|--help)

aiuto=true

shift

;;

-f|--fix)

ripristina=true

shift

;;

shift

;;

esac

done

call_aiuto() {

if $aiuto

then

echo

echo -e "${TAB1}${ROSSO}GUIDA ALL'UTILIZZO${NC}"

echo

echo -e "${TAB1}$0"

echo

echo -e "${TAB1}${CELESTE}Comando${NC}"

echo -e "${TAB1}$0 -d|--domain DomainName -u|--user DomainUser --dbadmin DatabaseRootUser [--dbpass|--dbpassword DatabaseRootPassword] [-f|--fix]"

echo

echo -e "${TAB1}${CELESTE}Parametri${NC}"

echo -e "${TAB1}${GIALLO}DomainName${NC}${TAB2}nome del dominio che vogliamo creare, per esempio: -d miosito.com"

echo -e "${TAB1}${GIALLO}DomainUser${NC}${TAB2}nome dell'utente che gestirà il dominio, per esempio: -u mariorossi"

echo -e "${TAB1}${GIALLO}DatabaseRootUser${NC}${TAB1}nome dell'utente amministratore del database, tipicamente root"

echo -e "${TAB1}${GIALLO}DatabaseRootPassword${NC}${TAB1}Password dell'utente amministratore del database"

echo

exit

}

call_check_dbadmin() {

if [[ $dbadmin = "" ]]

then

errore "Inserire utente amministratore del database"

}

call_check_dbpass() {

if [[ $dbadmin != "" && $dbpass = "" ]]

then

echo -n "$dbadmin password: "

read -s dbpass

echo

}

call_crea_cartella() {

mkdir $www$dominio 2>/dev/null || errore "Permesso negato. Eseguire come root"

}

call_crea_ftp() {

useradd --shell /bin/false $utente

chown $utente:www-data $www$dominio

usermod -d $www$dominio $utente

echo $utente:$ftppassword | /usr/sbin/chpasswd

echo "FTP Password: $ftppassword"

}

call_crea_vhost() {

cat << EOF > "${sites}${dominio/./_}.conf"

ServerName $dominio

ServerAdmin webmaster@localhost

DocumentRoot $www$dominio

ErrorLog \${APACHE_LOG_DIR}/error.log

CustomLog \${APACHE_LOG_DIR}/access.log combined

</VirtualHost>

EOF

}

call_agg_vhost() {

a2ensite "${dominio/./_}" 2>/dev/null || errore "Apache non è installato o configurato correttamente."

service apache2 reload 2>/dev/null

}

call_crea_db() {

dbname="${dominio/./_}"

dbname="${dbname/-/_}"

mysql -u$dbadmin -p$dbpass -e "DROP DATABASE IF EXISTS $dbname" 2>/dev/null

mysql -u$dbadmin -p$dbpass -e "DROP USER $dbname@localhost" 2>/dev/null

mysql -u$dbadmin -p$dbpass -e "CREATE DATABASE $dbname" 2>/dev/null

mysql -u$dbadmin -p$dbpass -e "CREATE USER $dbname@localhost IDENTIFIED BY '$newpassword'" 2>/dev/null

mysql -u$dbadmin -p$dbpass -e "GRANT ALL PRIVILEGES ON $dbname.* TO $dbname@localhost" 2>/dev/null

}

call_crea_index() {

cat << EOF > "${www}$dominio/index.php"

<?php

echo "<h1>$dominio under construction</h1>";

mysqli_connect("localhost", "$dbname", "$newpassword", "$dbname") or die("Errore database");

EOF

}

call_rimuovi() {

if $ripristina

then

a2dissite "${dominio/./_}"

rm -R $www$dominio 2>/dev/null

rm "${sites}${dominio/./_}.conf"

}

call_rimuovi

call_aiuto

call_check_dbadmin

call_check_dbpass

call_crea_cartella

call_crea_vhost

call_agg_vhost

call_crea_db

call_crea_index

call_crea_ftp

Il codice è stato scritto e testato su Ubuntu Server 16.04, con sopra installati Apache, MySQL, PHP, OpenSSL e ProFTPd.

LVM, gestore logico dei volumi su Ubuntu [per pinguini alle prime armi]

Obiettivo: ampliare lo spazio su un disco di Ubuntu, aggiungendo un nuovo hard disk ed estendendo il disco con LVM

Prima di inoltrarci in questa guida sui volumi logici suggerisco di dare un’occhiata, per chi fosse ancora alle prime armi, a questo articolo sull’installazione di Ubuntu con LVM. Questo articolo prosegue sulla medesima configurazione dell’articolo citato, dove si suppone che abbiamo già installato Ubuntu predisponendolo per utilizzare l’LVM.

Quello che faremo sarà aggiungere un nuovo disco da 50 GB e poi aggiungere un altro disco da 20 GB col quale espandere il precedente.

LVM sta per logical volume manager (ovvero gestore logico dei volumi) un meccanismo attraverso il quale Linux può accorpare diversi dischi fisici in un’unico volume logico. E’ qualcosa che assomiglia, e sottolineo che si tratta solo di una somiglianza, alle configurazioni in RAID. L’idea potrebbe essere schematizzata nel modo seguente:

Il concetto di fondo è molto semplice e potremmo riassumerlo nel modo seguente: con due hard disk da 50 GB ciascuno posso creare un’unico “disco logico”, ovvero lo spazio che vede il sistema operativo, da 100 GB e posso continuare ad incrementarlo a piacere in base alle mie esigenze. Noi quindi aggiungeremo un disco 50GB e poi lo estenderemo con uno da 20GB, ottenendo uno spazio complessivo di 70GB.

Le potenzialità del LVM non si esauriscono qui, ma per quello che ci serve sapere in questo momento tanto può bastare.

In questo articolo utilizzerò ancora una volta VirtualBox, dove andrò ad aggiungere, al disco già esistente, puta caso da 50GB un secondo disco sempre da 50GB con il quale estendere la memoria a disposizione del mio sistema operativo.

Per aggiungere un nuovo disco alla mia macchina virtuale è sufficiente spostarsi, da VirtualBox, sulle Impostazioni della macchina virtuale e poi su Archiviazione.

A questo punto, come nell’immagine seguente, ci posizioniamo sul Controller SATA e clicchiamo sull’icona col disco ed il più verde e seguiamo la procedura guidata per aggiungere un secondo disco (da me chiamato DiscoUbuntuEsempio2.vdi) da 50 GB.

Fatto questo avviamo la nostra macchina virtuale come al solito. Inutile dire che se stessimo lavorando su una macchina fisica sarebbe sufficiente aggiungere fisicamente un nuovo hard disk al controller SATA.

Una volta dentro Ubuntu andiamo anzitutto a visualizzare l’elenco dei dischi fisici attualmente configurati.

sudo pvdisplay

1	sudo pvdisplay

Faccio notare che pv sta per phisical volume, ovvero i dischi fisici collegati all’LVM. Il risultato dovrebbe essere qualcosa di simile a questo.

Nel mio caso ho già collegato il secondo disco, ma solo un disco, quello dell’installazione, è configurato all’interno dell’LVM. Il disco nello specifico è /dev/sda5. (per essere precisi il disco è /dev/sda, mentre quello è il puntatore ad una delle “partizioni” — senza entrare troppo nel merito, che in questo momento potrebbe solo confondere le idee, possiamo dire che un singolo disco, sda in questo caso, può essere “visto” dal sistema operativo in diversi modi)

Adesso andiamo a visualizzare invece tutti i dischi collegati alla mia macchina.

sudo fdisk -l

1	sudo fdisk -l

Il risultato sarà esteso perché dovrebbe mostrare anche la RAM e tutti gli altri eventuali dischi e memorie collegati. Nel mio caso ad un certo punto appare:

Faccio notare che abbiamo due dischi, sda, di cui abbiamo parlato poc’anzi, e il nuovo disco sdb che abbiamo aggiunto da poco e che non è partizionato.

A questo punto creiamo una nuova partizione sul disco sdb.

sudo fdisk /dev/sdb

1	sudo fdisk /dev/sdb

Ci verrà chiesto che cosa vogliamo fare. Le opzioni in questo momento sono:

n = nuova partizione
p = partizione primaria
1 = imposta la partizione la prima del disco

Scegliamo n per creare una nuova partizione.

Adesso ci viene chiesto se vogliamo farla primaria (p) o estesa (e). Scegliamo p per farla primaria.

Numero della partizione: 1

Alla domanda sul first sector, primo settore, digitiamo il valore suggerito di default, per me 2048.

Stesso discorso per il last sector, ovvero l’ultimo settore, scegliamo il valore suggerito di default (si può anche premere semplicemente INVIO)

Adesso abbiamo creato il nostro disco da 50GiB (ricordo che secondo il nuovo standard GiB sta per Gibibyte, che equivalgono a 1024 MiB, mentre 1GB equivale a 1000 MB, quindi 1 GiB ≠ 1 GB, inutile dire che per gli irriducibili come il sottoscritto si continuano a chiamare Gigabyte e andare di 1024 in 1024)

Continuando a trovarci su fdisk (che ci chiede un nuovo comando per proseguire o m per la guida), andiamo adesso a modificare il tipo di partizione creata digitando t e premendo INVIO.

t – modifica tipo di partizione
8e – imposta su tipo LVM

Ci verrà chiesto il tipo di partizione e digitiamo 8e.

Se digitiamo L, alla richiesta del tipo di partizione, ci verrà mostrato il seguente elenco:

Se abbiamo fatto tutto bene ci verrà mostrato il seguente messaggio di conferma:

Changed type of partition 'Linux' to 'Linux LVM'.

1	Changed type of partition 'Linux' to 'Linux LVM'.

A questo punto è il momento di scrivere la partizione creta sul disco! Già, non l’abbiamo ancora scritta quindi nessuna di queste modifiche è ancora stata apportata. Le opzioni utili adesso sono:

p = mostra le impostazioni di partizione prima della scrittura
w = scrivi sul disco

Per scrupolo digitiamo p e verifichiamo che sia uscito qualcosa di simile.

Notiamo che sarà creato un puntatore /dev/sdb1 alla nuova partizione che ci accingiamo a creare.

Adesso premiamo w per scrivere tutte le modifiche sul nostro disco (inutile dire che ogni eventuale dato sul disco andrà perso).

Se tutto è andato bene riceveremo un messaggio di conferma come il seguente:

The partition table has been altered.
Calling ioctl() to re-read partition table.
Syncing disks.

The partition table has been altered.

Calling ioctl() to re-read partition table.

Syncing disks.

Adesso dobbiamo creare il nostro volume fisico. Da terminale digitiamo:

sudo pvcreate /dev/sdb1

1	sudo pvcreate /dev/sdb1

Adesso creiamo un nuovo gruppo dei volumi (in questo caso abbiamo un singolo volume) e lo andiamo a chiamare secondo-gruppo (il gruppo esistente, come visto con pvdisplay si chiama ubuntu-vg, il nome è a piacere purché sia una parola singola). Digitiamo:

sudo vgcreate secondo-gruppo /dev/sdb1

1	sudo vgcreate secondo-gruppo /dev/sdb1

Adesso dobbiamo creare soltanto il volume logico e dargli un nome, per esempio spazio-web. Tra poco capirete meglio anche la scelta, intanto procediamo con:

sudo lvcreate -L 10G -n spazio-web secondo-gruppo

1	sudo lvcreate -L 10G -n spazio-web secondo-gruppo

Faccio notare che abbiamo creato così un volume logico di 10GB (passando la dimensione al comando -L 10G) sullo spazio complessivo disponibile di 50GB. Se avessi voluto utilizzare tutto lo spazio anziché passare il comando -L avrei dovuto scrivere

sudo lvcreate -l 100%FREE -n spazio-web secondo-gruppo

1	sudo lvcreate -l 100%FREE -n spazio-web secondo-gruppo

Il motivo per cui scelgo di non usare tutto lo spazio, o per essere più precisi uno dei motivi possibili, potrebbe essere il seguente: questo disco intendo dedicarlo allo spazio web in /var/www montandolo al posto della cartella esistente. Così tutti i siti web ospitati dal mio server si troveranno su un disco separato da quello principale. In questo modo posso anche controllare l’espansione di tali siti, evitando che mi saturino l’intero disco prima che io possa espanderlo. Qualora la dimensione dei siti dovesse raggiungere i 10GB, i loro utenti (che in teoria potrebbero avere degli accessi dedicati allo spazio web, per esempio mediante FTP) non potranno aggiungere altri file, mentre io potrò espandere lo spazio e adoperarmi per aggiungere nuovi hard disk.

Per chiarire questa idea immaginiamo di ospitare sul server il sito web di Mario e quello di Luigi, due persone distinte e che non si conoscono. In tutto i loro siti condividono 10GB in questo momento; immaginiamo adesso che Luigi decida di caricare sul proprio server web 3 file da 9GB. Dopo il primo upload lo spazio sarebbe saturato e Luigi non potrebbe proseguire con il successivo. Questo provocherebbe degli alert (supponendo che io li abbia configurati) all’interno della macchina e mi permetterebbe di intervenire in due modi: anzitutto controllare come mai lo spazio è cresciuto a dismisura in poco tempo, e allo stesso tempo aggiungere magari un altro paio di GB per permettere a Mario di essere comunque operativo e non sentire la saturazione dello spazio condiviso.

Concludiamo tutta l’operazione formattando il nuovo volume logico appena creato:

sudo mkfs -t ext4 /dev/secondo-gruppo/spazio-web

1	sudo mkfs -t ext4 /dev/secondo-gruppo/spazio-web

mkfs sta letteralmente per make filesystem e il comando -t mi permette di scegliere il tipo di file system.

Controlliamo la situazione digitando di nuovo:

sudo pvdisplay

1	sudo pvdisplay

Dovremmo vedere qualcosa di simile a questo:

Questi sono i nostri due volumi fisici. Controlliamo adesso quelli logici digitando:

sudo lvdisplay

1	sudo lvdisplay

Quello che dovrebbe apparirci è la seguente schermata:

In questo caso abbiamo due gruppi distinti di volumi e tre volumi logici. I due gruppi sono ubuntu-vg e secondo-gruppo, mentre i tre volumi logici sono spazio-web, root e swap_1.

Adesso montiamo il volume logico spazio-web sulla cartella /var/www/.

Attenzione! Montando il volume su uno spazio esistente tutto il contenuto di tale spazio verrà sovrascritto, quindi prima dovremmo copiare dentro il nuovo volume il contenuto attuale. I vecchi dati comunque non andranno persi, semplicemente non saranno più visibili. Per capire bene questo passaggio facciamo la seguente serie di operazioni.

Anzitutto controlliamo il contenuto della cartella /var/www digitando:

ls /var/www

1	ls /var/www

Quello che dovremmo vedere (ricordo che sulla mia macchina ho già configurato altri virtual host e siti) è qualcosa di simile a:

Il contenuto non è tanto importante quanto il fatto che dentro ci sia già qualcosa che vorremmo preservare.

Adesso montiamo su /var/www il volume spazio-web.

sudo mount -t ext4 /dev/secondo-gruppo/spazio-web /var/www

1	sudo mount -t ext4 /dev/secondo-gruppo/spazio-web /var/www

A questo punto controlliamo nuovamente, come prima il contenuto della cartella /var/www

ls /var/www

1	ls /var/www

Il risultato che dovrebbe presentarsi è qualcosa di simile a questo:

Notiamo che non ci sono le cartelle di prima ma solamente una cartella lost+found che si trova anche nella radice (root) del nostro sistema operativo.

Nota: la cartella lost+found esiste su ogni partizione primaria ed ha come scopo quello di collezionare eventuali file danneggiati, perduti o recuperati da fsck (per esempio). Dentro a lost+found possono finire anche file o frammenti di file a seguito di un errore di sistema (es. kernel panic) o un arresto improvviso, oppure per via di inconsistenze del sistema dovute a software o altri generi di errori. In generale quello che si trova dentro a lost+found può essere cancellato perché già eliminato dal sistema o inutile.

A questo punto, a scopo dimostrativo, creiamo dentro la cartella /var/www un file vuoto chiamato file_petar_test.txt con il seguente comando:

sudo touch /var/www/file_petar_test.txt

1	sudo touch /var/www/file_petar_test.txt

Questo lo facciamo per verificare il comportamento di mount (chiaramente non è necessario per una configurazione normale).

Adesso smontiamo la partizione in modo da copiare il contenuto originale di /var/www nella nuova partizione prima di montarla di nuovo:

sudo umount /var/www

1	sudo umount /var/www

Il comando umount smonta la cartella scelta. Effettuando di nuovo un ls sulla cartella /var/www ritroveremo i file precedenti:

Adesso montiamo la partizione (il volume logico) spazio-web su una cartella provvisoria che creeremo dentro a /mnt (la cartella /mnt è pensata per creare dentro le cartelle sulle quali montare volumi aggiuntivi — come è facile immaginare non c’è niente di speciale in tale cartella e il mount può essere effettuato ovunque).

Creiamo quindi la cartella provvisoria con:

sudo mkdir /mnt/cartella_sw

1	sudo mkdir /mnt/cartella_sw

Faccio notare che il nome cartella_sw è totalmente arbitrario, l’unica condizione è che rispetti i criteri per la creazione delle cartelle in generale (sw starebbe nel mio caso per spazio-web).

Montiamo la partizione:

sudo mount -t ext4 /dev/secondo-gruppo/spazio-web /mnt/cartella_sw/

1	sudo mount -t ext4 /dev/secondo-gruppo/spazio-web /mnt/cartella_sw/

A questo punto possiamo copiare il contenuto da /var/www in /mnt/cartella_sw (se controlliamo il contenuto di quest’ultima cartella noteremo il nostro file txt di prova creato in precedenza)

sudo cp -a /var/www/. /mnt/cartella_sw/

1	sudo cp -a /var/www/. /mnt/cartella_sw/

In questo caso usiamo il comando cp per copiare, con il parametro -a gli diciamo di copiare ricorsivamente tutte le cartelle ed i file figli della cartella genitore. E’ importante scrivere /var/www/. (ovvero il percorso con incluso il punto) perché il . rappresenta il contenuto della cartella, stiamo cioè dicendo a cp che non vogliamo copiare anche /var/www, ma soltanto il suo contenuto e tutti i suoi figli.

Controllando con ls il contenuto di /mnt/cartella_sw ci accertiamo di aver copiato tutto ciò che c’era dentro a /var/www, troveremo ovviamente anche il file di prova creato precedentemente e lost+found.

A questo punto possiamo rimontare il volume logico sulla posizione /var/www (ricordiamoci di smontarlo dalla posizione corrente e cancellare la cartella /mnt/cartella_sw, lo facciamo solo per una questione di ordine). In sequenza eseguiamo quindi:

sudo umount /mnt/cartella_sw
sudo mount -t ext4 /dev/secondo-gruppo/spazio-web /var/www
sudo rmdir /mnt/cartella_sw/

sudo umount /mnt/cartella_sw

sudo mount -t ext4 /dev/secondo-gruppo/spazio-web /var/www

sudo rmdir /mnt/cartella_sw/

Controllando il contenuto di /var/www a questo punto dovremmo vedere qualcosa di simile a:

Inutile dire che, in linea di principio, se questa fosse stata un’operazione definitiva, avrei dovuto svuotare il contenuto di /var/www per non occupare inutilmente lo spazio sul disco primario.

A questo punto vediamo alcuni altri comandi utili.

DF, PVS e LVS

Con il comando df (disk free) controlliamo lo spazio sulle partizioni montate.

df -h

df -h

Il risultato dovrebbe essere simile a questo:

Notiamo che il volume logico ubuntu–vg-root (qui il formato è gruppo_volumi-volume_logico) è montato su / (la radice del sistema), mentre secondo–gruppo-spazio–web è montato su /var/www. Ci vengono mostrate anche le percentuali di utilizzo, 1% nel caso di /var/www.

Adesso vediamo le informazioni sui volumi logici utilizzando lvs.

sudo lvs

sudo lvs

Faccio notare che, a differenza di df, questo necessità di permessi di root per essere eseguito.

In questo caso ci vengono mostrate le informazioni su tutti i volumi logici che abbiamo creato, comprese le loro dimensioni.

Utilizziamo adesso pvs per visualizzare i volumi fisici:

sudo pvs

sudo pvs

Quello che otteniamo dovrebbe assomigliare al seguente risultato:

In questo caso vediamo i volumi fisici associati all’LVM, ed in particolare possiamo controllare lo spazio complessivo (PSize) e lo spazio libero (PFree). In particolare notiamo che su sdb1 abbiamo ancora 40GB liberi.

Quindi, riepilogando, abbiamo destinato il volume logico spazio-web, appartenente al gruppo secondo-gruppo, alla cartella /var/www. Il gruppo secondo-gruppo contiene in tutto spazio per 50GB, di cui stiamo usando solo 10GB per il volume logico spazio-web.

Estendere un volume logico

Adesso vogliamo dare altri 20GB allo spazio-web, espandendo quindi /var/www.

Per farlo ci sarà sufficiente utilizzare il comando lvextend:

sudo lvextend -L+20G /dev/secondo-gruppo/spazio-web

1	sudo lvextend -L+20G /dev/secondo-gruppo/spazio-web

Ci verrà data conferma che l’estensione è avvenuta con successo; l’estensione può avvenire finché il gruppo dei volumi a cui appartiene il volume logico dispone di spazio libero (PFree).

Utilizziamo di nuovo df -h per verificare la situazione:

df -h

df -h

E dovremmo vedere qualcosa di simile a questo:

Notiamo che /var/www continua ad essere di 10GB! Questo perché oltre ad estendere il volume logico dobbiamo estendere anche il filesystem. Per farlo ci è sufficiente digitare:

sudo resize2fs /dev/secondo-gruppo/spazio-web

1	sudo resize2fs /dev/secondo-gruppo/spazio-web

Ricontrollando con df -h vediamo che la situazione è diventata come la volevamo all’inizio:

Aggiungere volume fisico al gruppo dei volumi

Aggiungiamo adesso un disco fisico da 20GB al gruppo dei volumi chiamato secondo-gruppo, in modo che lo spazio complessivo passi da 50GB a 70GB.

Per farlo dobbiamo aggiungere naturalmente un nuovo disco, io lo faccio sulla macchina virtuale in questo caso. Verifichiamo i dischi collegati:

sudo fdisk -l

1	sudo fdisk -l

Il nuovo risultato dovrebbe essere simile al seguente:

Notiamo che abbiamo un disco su /dev/sdc da 20GB.

Adesso aggiungiamo il disco al gruppo di volume chiamato secondo-gruppo:

sudo vgextend secondo-gruppo /dev/sdc

1	sudo vgextend secondo-gruppo /dev/sdc

Controlliamo i nostri volumi fisici con:

sudo pvs

sudo pvs

Questo è il nuovo risultato:

Vediamo che su secondo-gruppo abbiamo ancora liberi 40G (la somma degli spazi liberi sui due dischi precedenti), quindi proviamo ad estendere spazio-web di altri 40GB, oltre ai 20GB precedentemente aggiunti. Eseguiamo i seguenti due comandi, come prima:

sudo lvextend -L+40G /dev/secondo-gruppo/spazio-web

1	sudo lvextend -L+40G /dev/secondo-gruppo/spazio-web

Eseguendo questo comando ci viene però detto “Insufficient free space: 10240 extents needed, but only 10238 available“, ci mancano giusto 2 extents (gli extents sono l’equivalente per le LVM dei cluster per i filesystem, entrambi sono le minime unità in cui viene suddiviso lo spazio). Per evitare il problema estendiamo il volume logico su tutto lo spazio disponibile:

sudo lvextend -l +100%FREE /dev/secondo-gruppo/spazio-web

1	sudo lvextend -l +100%FREE /dev/secondo-gruppo/spazio-web

Notiamo come il comando assomigli al medesimo meccanismo, eccetto per il +, con il quale creiamo il volume logico su tutto lo spazio disponibile. Adesso estendiamo il filesystem.

sudo resize2fs /dev/secondo-gruppo/spazio-web

1	sudo resize2fs /dev/secondo-gruppo/spazio-web

Prima di poterlo fare potrebbe esserci richiesto un controllo del filesystem medesimo, visto che lo abbiamo esteso poc’anzi.

sudo e2fsck -f /dev/secondo-gruppo/spazio-web

1	sudo e2fsck -f /dev/secondo-gruppo/spazio-web

In questo modo eseguiamo il controllo e poi effettuiamo di nuovo resize2fs.

A questo punto eseguendo df -h notiamo che /var/www corrisponde a circa 70GB.

OK. Ho barato un po’. Arrivati a questo punto potreste in realtà notare che /var/www non è più collegata al volume logico spazio-web. Questo è successo se avete riavviato il computer per montare il secondo disco aggiuntivo. Per ottenere il risultato precedente è sufficiente montare di nuovo il volume logico, come in precedenza, oppure definire il mount in modo permanente (questo vale per qualunque disco, non solo per i volumi logici).

Montare un disco in modo permanente

Per montare il volume logico in modo permanente, ovvero che rimanga montato dopo ogni riavvio, è necessario modificare il file /etc/fstab.

sudo nano /etc/fstab

1	sudo nano /etc/fstab

Per montare il disco utilizziamo la seguente sintassi:

PERCORSO_VOLUME_LOGICO PUNTO_DI_MOUNT ext4 rw,defaults 0 0

Quindi in fondo al file scriviamo:

/dev/mapper/secondo--gruppo-spazio--web /var/www ext4 rw,defaults 0 0

1	/dev/mapper/secondo--gruppo-spazio--web /var/www ext4 rw,defaults 0 0

Faccio notare che /dev/mapper/secondo–gruppo-spazio–web è il percorso che ci viene dato da df -h

Salviamo e riavviamo la macchina per verificare se va tutto bene. ATTENZIONE! Prestate moltissima attenzione alla sintassi, un qualche errore potrebbe bloccare l’avvio del sistema e costringerci ad intervenire in modalità di ripristino. La soluzione sarebbe comunque semplice, basterebbe rimuovere l’ultima riga aggiunta a fstab.

Se tutto è andato a dovere eseguendo df -h vedremo /dev/mapper/secondo–gruppo-spazio–web montata su /var/www

Inviare comando POST a script in PHP mediante BASH

Per un po’ di svago pomeridiano propongo oggi un veloce esercizio che unisca bash e PHP. Quello che vogliamo fare è creare uno script che da console ci chieda quali dati inviare mediante POST ad una pagina in PHP, che poi li utilizzerà per conto proprio.

Anzitutto costruiamo una pagina PHP opportunamente posizionata nel nostro webserver come la seguente:

<?php

        if( $_POST['invia'] ) {
                file_put_contents("dati.txt",$_POST['valore']."<br>",FILE_APPEND);
        }

        echo file_get_contents("dati.txt");

?>
<form action="" method="post">
        <input type="text" name="valore" value="" />
        <input type="submit" name="invia" valore="invia" />
</form>

<?php

if( $_POST['invia'] ) {

file_put_contents("dati.txt",$_POST['valore']."<br>",FILE_APPEND);

}

echo file_get_contents("dati.txt");

</form>

In questo modo la pagina riceverà dei dati dal form e li scriverà nel file dati.txt, poi leggerà il file dati.txt e lo stamperà a schermo prima del form. Inutile dire che si tratta di una pagina a scopo di prova e sarebbe assolutamente inopportuno utilizzare un simile meccanismo online.

Adesso vediamo come creare il nostro script in bash:

#!/bin/bash

echo -en "dato da inviare: "
read dato

curl -s --data "valore=$dato&invia=invia" http://localhost/test/index.php > /dev/null

echo "il dato '$dato' è stato inviato correttamente"

#!/bin/bash

echo -en "dato da inviare: "

read dato

curl -s --data "valore=$dato&invia=invia" http://localhost/test/index.php > /dev/null

echo "il dato '$dato' è stato inviato correttamente"

Ricordo che per creare il file bash, nella posizione che desideriamo sarà sufficiente digitare qualcosa come:

sudo nano ./posttophp.sh

1	sudo nano ./posttophp.sh

Una volta creato ed inseriti tutti i dati ricordiamoci di dargli i permessi necessari perché possa essere seguito:

sudo chmod a+x posttophp.sh

1	sudo chmod a+x posttophp.sh

Faccio notare che il nostro file in PHP si chiama index.php e si trova su un percorso raggiungibile da http://localhost/test/index.php

Eseguendo il file in bash dovremmo vedere qualcosa di simile sulla nostra console:

Save Editor FF8

Di recente ho riscoperto la mia passione per Final Fantasy 8 grazie alla versione remastered di Steam. In realtà volevo rigiocare alla mia vecchia copia da PC, ma poi ho scoperto che non era più possibile installarla su computer a 64-bit (qualcuno suggeriva un’installazione in modalità provvisoria, per poi dover però correggere ben altri problemi!). Così mi sono messo alla ricerca di una soluzione ed ho scoperto che su Steam c’era una versione aggiornata e funzionante anche su Windows 10!

Vecchia copia da PC! Notare l’offerta per “internet gratis” con i vecchi modem 56k.

Adesso non starò ad approfondire i dettagli su questo gioco che amo profondamente (sì ok, quando ci giocai avevo anche una cotta per quel turbodisfattista di Squall), ma quando un gioco gira su PC inevitabilmente viene da chiedersi se ci sarà anche qualche modo meschino per crackarlo o modificarlo a proprio piacimento.

Ed ho scoperto che c’è! Ebbene sì, esiste già un programma perfettamente funzionante per modificare i file di salvataggio del gioco.

Il programma si chiama Hyne (1.9.2), ed è possibile scaricarlo in diverse versioni da Github.

Da quello che ho potuto testare funziona anche sulla versione Steam, e non appena finisco il gioco non mancherò di divertirmi con un po’ di OP.

Il programma è molto intuitivo ed offre una configurazione dettagliata tramite interfacce grafiche dedicate.

Una volta aperto il salvataggio (i salvataggi di Steam si trovano di predefinito nella cartella Documenti %USERPROFILE%\Documents\Square Enix\FINAL FANTASY VIII Steam\user_XXXXXX) ci si presenterà una schermata simile alla precedente, dove potremo selezionare il salvataggio che ci interessa.

Seguiranno una serie di schermate dalle quali sarà possibile modificare nei più piccoli dettagli le caratteristiche del gioco (io devo ancora giungere al garden di Galbadia)

Una volta fatto è sufficiente salvare il file. Consiglio naturalmente di tenere una copia di backup del file originale, per ogni evenienza.

Fonte: Hyne

Interrogare foglio di Excel con SQL in VBA

Obiettivo: interrogare e filtrare il contenuto di un foglio excel come se fosse una tabella di un database SQL

Prepariamo anzitutto un file Excel creando un foglio con dei dati come quelli di seguito:

Questo foglio lo chiamiamo DATI. Faccio notare che nella prima riga ho inserito le intestazioni della nostra tabella.

In un secondo foglio andiamo a creare un pulsante che richiamerà un form. L’idea sarebbe quella di creare un metodo di inserimento che guidi l’utente e gli permetta di filtrare una vasta base dati, eseguendo anche dei comandi di ricerca. Il risultato sarà il seguente:

Se proviamo a cercare qualcosa, per esempio “Mar” l’elenco dovrà essere filtrato e otterremo il risultato seguente:

Fatte queste premesse vediamo come realizzare l’interrogazione del foglio mediante VBA (sorvolo sull’elementare creazione del form).

Anzitutto creiamo una Sub che caricherà i valori nella combobox (cmbSeleziona) e nella listbox (lbSeleziona).

Private Sub LoadSelect(Optional ByVal nome As String = "")

    Dim conn As ADODB.Connection
    Dim rs As ADODB.Recordset
    Dim strFileName As String
    Dim ConnectionString As String
    
    strFileName = ThisWorkbook.FullName
    
    ConnectionString = "Provider=Microsoft.ACE.OLEDB.12.0;Data Source=" _
    & strFileName & ";Extended Properties=""Excel 12.0 xml;HDR=YES;IMEX=1;Readonly=True"";"
    
    Set conn = CreateObject("ADODB.Connection")
    Set rs = CreateObject("ADODB.Recordset")
    
    conn.Open ConnectionString
    
    Dim query As String
    
    If nome <> "" Then
        query = "SELECT * FROM [DATI$A:C] WHERE Nome LIKE '%" & nome & "%'"
    Else
        query = "SELECT * FROM [DATI$A:C]"
    End If
    
    rs.Open query, conn
    
    cmbSeleziona.Clear
    lbSelezione.Clear
    
    pos = 0
    
    If Not rs.EOF Then
        Do
            
            cmbSeleziona.AddItem rs(1) & " [" & rs(2) & "]", pos
            cmbSeleziona.List(pos, 1) = rs(0)
            
            lbSelezione.AddItem rs(1) & " [" & rs(2) & "]", pos
            lbSelezione.List(pos, 1) = rs(0)
            
            pos = pos + 1
            rs.MoveNext
        Loop Until rs.EOF
    End If
    
    rs.Close
    
    conn.Close

End Sub

Private Sub LoadSelect(Optional ByVal nome As String = "")

Dim conn As ADODB.Connection

Dim rs As ADODB.Recordset

Dim strFileName As String

Dim ConnectionString As String

strFileName = ThisWorkbook.FullName

ConnectionString = "Provider=Microsoft.ACE.OLEDB.12.0;Data Source=" _

& strFileName & ";Extended Properties=""Excel 12.0 xml;HDR=YES;IMEX=1;Readonly=True"";"

Set conn = CreateObject("ADODB.Connection")

Set rs = CreateObject("ADODB.Recordset")

conn.Open ConnectionString

Dim query As String

If nome <> "" Then

query = "SELECT * FROM [DATI$A:C] WHERE Nome LIKE '%" & nome & "%'"

Else

query = "SELECT * FROM [DATI$A:C]"

End If

rs.Open query, conn

cmbSeleziona.Clear

lbSelezione.Clear

pos = 0

If Not rs.EOF Then

cmbSeleziona.AddItem rs(1) & " [" & rs(2) & "]", pos

cmbSeleziona.List(pos, 1) = rs(0)

lbSelezione.AddItem rs(1) & " [" & rs(2) & "]", pos

lbSelezione.List(pos, 1) = rs(0)

pos = pos + 1

rs.MoveNext

Loop Until rs.EOF

End If

rs.Close

conn.Close

End Sub

Faccio notare che in questo caso la query filtra solamente i valori in base al Nome, inoltre il parametro nome può essere passato in via opzionale, permettendo quindi anche di visualizzare tutti i campi se non c’è nessun nome da filtrare.

Ricordiamoci che per poter eseguire la connessione ADO abbiamo bisogno di importare l’opportuna libreria dai riferimenti.

A questo punto completiamo il nostro codice aggiungendo:

Private Sub txtCerca_Change()

    LoadSelect txtCerca.Text

End Sub

Private Sub UserForm_Initialize()

    LoadSelect

End Sub

Private Sub txtCerca_Change()

LoadSelect txtCerca.Text

End Sub

Private Sub UserForm_Initialize()

LoadSelect

End Sub

In questo modo ad ogni modifica (change) di txtCerca, che è la textbox di ricerca in cima al form, verrà interrogato il nostro foglio per produrre un risultato.

Il medesimo metodo LoadSelect, questa volta senza argomenti, lo aggiungiamo anche all’avvio del form, per caricare il contenuto completo senza filtri.

Qui è possibile scaricare il file creato con Excel 2016.

Creare un programma con menu e opzioni di scelta in bash

Per gli esercizi dedicati a bash ne propongo uno rielaborato da me qualche mese fa per un corso.

Obiettivo: creare un semplice programma in bash che mostri un menu a schermo e ci permetta di fare delle scelte; in particolare mostrare un elenco di alunni e voti, aggiungere nomi di alunni e relativi voti, svuotare il “database” (in questo caso nient’altro che un file di testo) ed uscire dal programma

#!/bin/bash

#qui salviamo i dati
ELENCO="./alunni.dat"

show_menu() {

        echo
        echo
        echo "-- Elenco studenti --"
        echo "1. Mostra"
        echo "2. Aggiungi"
        echo "3. Svuota"
        echo "q. ESCI"
        echo -en "> "

}

do_menu() {

        i=-1
        while [ "$i" != "q" ]; do
                show_menu
                read i
                i=`echo $i | tr '[A-Z]' '[a-z]'`
                case "$i" in
                        "1")
                        mostra
                        ;;
                        "2")
                        aggiungi
                        ;;
                        "3")
                        svuota
                        ;;
                        "q")
                        echo "Addio, e grazie per tutto il pesce!"
                        exit 0
                        ;;
                        *)
                        echo "Uhm... non ho capito..."
                        ;;
                esac
        done

}

mostra() {
        #elenchiamo tutti gli elementi
        grep -i "" $ELENCO | while read i; do
                echo "$i" | tr ':' '\t'
        done
}

aggiungi() {

        #aggiungi un elemento
        echo "Ti chiederemo 2 dati:"
        echo "  - nome, voto"
        echo
        echo -en "Nome: "
        read nome
        echo -en "Voto: "
        read voto
        echo "${nome}:${voto}" >> $ELENCO

}

conferma() {

        echo -en "$@"
        read risp
        risp=`echo $risp | tr '[a-z]' '[A-Z]'`
        if [ "$risp" == "Y" ]; then
                return 0
        else
                return 1
        fi

}

svuota() {

        conferma "Vuoi cancellare tutti gli studenti? (Y/N) "
        if [ "$?" -eq "0" ]; then
                echo -n "" > $ELENCO
        else
                echo "CANCELLAZIONE ANNULLATA"
        fi

}

do_menu

#!/bin/bash

#qui salviamo i dati

ELENCO="./alunni.dat"

show_menu() {

echo

echo "-- Elenco studenti --"

echo "1. Mostra"

echo "2. Aggiungi"

echo "3. Svuota"

echo "q. ESCI"

echo -en "> "

}

do_menu() {

i=-1

while [ "$i" != "q" ]; do

show_menu

read i

i=`echo $i | tr '[A-Z]' '[a-z]'`

case "$i" in

"1")

mostra

;;

"2")

aggiungi

;;

"3")

svuota

;;

"q")

echo "Addio, e grazie per tutto il pesce!"

exit 0

;;

echo "Uhm... non ho capito..."

;;

esac

done

}

mostra() {

#elenchiamo tutti gli elementi

grep -i "" $ELENCO | while read i; do

echo "$i" | tr ':' '\t'

done

}

aggiungi() {

#aggiungi un elemento

echo "Ti chiederemo 2 dati:"

echo " - nome, voto"

echo

echo -en "Nome: "

read nome

echo -en "Voto: "

read voto

echo "${nome}:${voto}" >> $ELENCO

}

conferma() {

echo -en "$@"

read risp

risp=`echo $risp | tr '[a-z]' '[A-Z]'`

if [ "$risp" == "Y" ]; then

return 0

else

return 1

}

svuota() {

conferma "Vuoi cancellare tutti gli studenti? (Y/N) "

if [ "$?" -eq "0" ]; then

echo -n "" > $ELENCO

else

echo "CANCELLAZIONE ANNULLATA"

}

do_menu

Nel nome delle funzioni non c’è niente di speciale, in particolare nelle funzioni showmenu e do_menu che ho chiamato così solo per abitudine, avendolo imparato a mia volta da script in inglese (potremmo dire anche scopiazzato!).

Commentiamo adesso i punti salienti del codice:

Riga 6: show_menu non fa niente di speciale, stampa semplicemente a video una serie di scritte usando echo (quando si usa echo senza una stringa a seguire si ottiene un semplice accapo); l’unico punto veramente interessante è alla riga 15 dove con echo -en ci prepariamo ad acquisire un valore in input. Questo valore in input in realtà viene acquisito dal read nella funzione successiva (riga 24).

Nel caso specifico echo -en vuol dire che passiamo alla funzione echo due parametri

-n evita di aggiungere newline alla fine della stringa, ovvero non manda accapo

-e interpreta eventuali backslash

Per capire meglio come funziona proviamo a scrivere nel terminale le seguenti righe

echo -en "\tmetti il nome"

1	echo -en "\tmetti il nome"

Questo comando darà in output il seguente risultato

        metti il tuo nome

1	metti il tuo nome

Il cursore si troverà in attesa alla fine della stringa ed i caratteri \t saranno trasformati in tabulazione.

Se invece scriviamo:

echo -n "\tmetti il nome"

1	echo -n "\tmetti il nome"

Verrà stampato a video:

\tmetti il tuo nome

1	\tmetti il tuo nome

Senza alcuna tabulazione.

Riga 22: cominciamo un ciclo while finché la variabile $i non sarà uguale a “q”.

Riga 24: leggiamo l’input dopo aver lanciato, alla riga precedente show_menu; l’input verrà letto nella variabile $i; dopo aver acquisito $i trasformiamo eventuali maiuscole in minuscole, in modo che sia premendo Q che q si possa uscire dal programma (questo non è ovviamente necessario, ma lo facciamo a titolo di esercizio).

A questo punto usiamo case per verificare la scelta in $i; in caso di qualsiasi scelta fuorché quelle elencate (riga 40) verrà mostrato un messaggio, qui scherzosamente sdubbiato.

Alla riga 36 invece, quando $i è uguale a “q” eseguiamo l’uscita dal programma con un saluto.

A questo punto costruiamo i metodi elencati dentro case.

Riga 48: il metodo mostra fa semplicemente il grep del contenuto del file e poi lo passa ad un ciclo while che legge ogni riga in $i. Il contenuto del file $ELENCO sarà scritto nel modo seguente:

Mario:10
Luigi:9
Anna:7

Ovvero un elenco di nomi separati da : dai voti; uno per riga. Quindi leggendo il file in righe sostituiamo ad ogni : una tabulazione in modo da stamparli a video uno sotto l’altro e con una tabulazione tra nome e voto.

Riga 55: creiamo il metodo per aggiungere nomi e voti; anche qui l’operazione è molto semplice e giochiamo un po’ con gli echo, per ottenere un’interfaccia da terminale decente. Alla riga 65 assembliamo i valori raccolti nelle precedenti due variabili in una singola stringa di testo che scriviamo sul file $ELENCO.

Riga 82: qui svuotiamo l’elenco degli studenti salvati in $ELENCO, semplicemente cancellando il contenuto dell’intero file. Notiamo qui l’uso diverso di >> e >. Il primo appende alla fine del file il contenuto, mentre > sostituisce l’intero contenuto. In questo caso lo sostituisce con una stringa vuota.

Riga 85: qui usiamo il comando $? per prendere l’output dell’ultimo metodo utilizzato, nel caso specifico il metodo conferma (riga 69). Il metodo conferma scrive a video una stringa presa da $@; la variabile $@ prende la lista di tutti gli argomenti passati al metodo, un po’ come fanno $0, $1 ecc per i singoli argomenti; in questo caso significa semplicemente che li prendiamo tutti. Il metodo legge la risposta e la trasforma tutta in maiuscole, in modo tale che Y e y equivalgano entrambi ad una conferma. Se la risposta è tale la funzione restituisce 0, altrimenti 1. Utilizzando $? controlliamo questo valore restituito e se fa 0 allora cancelliamo tutti i dati, se fa 1 annulliamo la cancellazione.

Riga 93: lanciamo l’intero programma.

Riferimenti utili: base di programmazione in BASH

Verificare integrità file in bash

Presupposto: immaginiamo di avere una cartella sorgente di file e una cartella dove li abbiamo copiati, per esempio durante un backup o solo per sicurezza; a tale proposito rimando all’esercizio precedente di copia dei file in bash

Obiettivo: adesso vogliamo controllare che i file in destinazione siano identici ai file nella copia di sicurezza; un primo modo elementare potrebbe essere quello di confrontare la dimensione dei file, però questo non ci garantisce l’effettiva integrità e che nella medesima dimensione non ci siano in realtà contenuti differenti; un approccio migliore sarebbe quello di confrontare gli hash dei file di origine con quelli della copia. Attenzione però! Perché non dobbiamo solo confrontare i file esistenti, ma verificare anche la presenza di nuovi file o di file mancanti.

Vediamo quindi come scrivere questa procedura in BASH.

#!/bin/bash

#impostazione cartelle
source="./elementi"
dest="./bck"

#contiamo anzitutto le cartelle di backup
#eseguiremo poi il controllo sull'ultimo backup
#confrontandolo con la cartella sorgente
tot=-1

for el in $dest*; do
        if [ -d "$el" ]
        then
                tot=$((tot+1))
        fi
done

#adesso controlliamo gli elementi
controllo(){
if [ $tot -gt -1 ]
then
        for el in $1/*; do
                if [ -d $el ]
                then
                        controllo $el
                else
                        md5sum "$el" | (
                                while read hash nomefile; do
                                        if [ -f "${nomefile/$source/$dest$tot}" ]
                                        then
                                        md5sum "${nomefile/$source/$dest$tot}" | (
                                                while read hashbck nomefilebck; do
                                                        if [ $hash != $hashbck ]
                                                        then
                                                                echo "$nomefile MODIFICATO"
                                                        fi
                                                done
                                        )
                                        else
                                                echo "${nomefile/$source/$dest$tot} NUOVO"
                                        fi
                                done
                        )
                fi
        done
else
        echo "nessuna cartella backup disponibile"
fi
}

controllo $source

#!/bin/bash

#impostazione cartelle

source="./elementi"

dest="./bck"

#contiamo anzitutto le cartelle di backup

#eseguiremo poi il controllo sull'ultimo backup

#confrontandolo con la cartella sorgente

tot=-1

for el in $dest*; do

if [ -d "$el" ]

then

tot=$((tot+1))

done

#adesso controlliamo gli elementi

controllo(){

if [ $tot -gt -1 ]

then

for el in $1/*; do

if [ -d $el ]

then

controllo $el

else

md5sum "$el" | (

while read hash nomefile; do

if [ -f "${nomefile/$source/$dest$tot}" ]

then

md5sum "${nomefile/$source/$dest$tot}" | (

while read hashbck nomefilebck; do

if [ $hash != $hashbck ]

then

echo "$nomefile MODIFICATO"

done

)

else

echo "${nomefile/$source/$dest$tot} NUOVO"

done

)

done

else

echo "nessuna cartella backup disponibile"

}

controllo $source

Fino alla riga 17 abbiamo ripreso il codice del precedente esercizio, con un’unica differenza: abbiamo impostato la variabile tot su -1.

In questo modo nella parte successiva possiamo verificare se non esiste alcuna cartella di backup; se c’è una cartella è la cartella bck0, per via della costruzione dell’esercizio precedente, e quindi tot sarà uguale a 0.

Dopodiché costruiamo un metodo chiamato controllo che prende in ingresso un unico argomento (intercettato con $1 all’interno del codice) che è la cartella sorgente. Alla riga 52 passiamo la cartella sorgente iniziale, mentre alla riga 26 passiamo la cartella figlia che troviamo in quella di partenza, in modo da ripetere il controllo in modo ricorsivo.

Alla riga 24 controlliamo, tramite l’if, che l’elemento che stiamo controllando sia una cartella. Se lo è passiamo la cartella al metodo controllo, altrimenti verifichiamo i file.

Per verificare il file lanciamo md5sum sul file originale e leggiamo il risultato come due colonne: hash e nomefile.

Il ciclo while in realtà effettua un’unica operazione, per ogni valore controllato verifichiamo anzitutto se esiste o meno all’interno del backup. Se non esiste lanciamo in output il messaggio alla riga 41. Altrimenti lanciamo il comando md5sum sul file nel backup; con lo stesso principio di prima effettuiamo la lettura dell’output mettendo il risultato in altre due variabili, ovvero hashbck e nomefilebck. A questo punto confrontiamo che i due hash siano identici, in caso contrario (!= vuol dire diverso) lanciamo un output, quello della riga 36.

Notiamo che se va tutto bene non viene lanciato alcun output, ma solo in caso di errore.

TODO: In questo controllo manca la verifica che eventuali file presenti nel backup non siano stati cancellati dalla cartella sorgente.

Semplice script di backup (copia di file) in bash

Vediamo creare un elementare sistema di backup in BASH. In questo caso supponiamo di avere, nella posizione in cui viene eseguito il codice, una cartella chiamata elementi, dentro la quale abbiamo tutti i file e le cartelle che desideriamo copiare dentro la destinazione di backup. La destinazione di backup è la medesima dello script (non entro ora nel merito sul buon senso di fare qualcosa di simile) dove verranno create n cartelle consecutive per tutti i backup effettuati. Le cartelle saranno quindi chiamate bck0, bck1 … bckn.

#!/bin/bash

#impostazioni generali
source="./elementi"
dest="./bck"

#contiamo anzitutto le cartelle di backup
#che sono già state create
tot=0

for el in "$dest*"; do
        if [ -d "$el" ]
        then
                tot=$((tot+1))
        fi
done

#facciamo il backup nella nuova cartella
mkdir "$dest$tot/"
cp -a "$source/." "$dest$tot/"

#!/bin/bash

#impostazioni generali

source="./elementi"

dest="./bck"

#contiamo anzitutto le cartelle di backup

#che sono già state create

tot=0

for el in "$dest*"; do

if [ -d "$el" ]

then

tot=$((tot+1))

done

#facciamo il backup nella nuova cartella

mkdir "$dest$tot/"

cp -a "$source/." "$dest$tot/"

Faccio notare che la prima parte dello script, quella con il ciclo for, serve solo a contare il numero di cartelle di backup attualmente esistenti, per poter creare così la cartella successiva. Se non esiste alcuna cartella il contatore rimane a 0 e crea la prima cartella zeresima, chiamata bck0. Quando si usa la seconda volta le cartelle sono 1, la cartella bck0, e quindi la variabile tot assume valore 1. E così via ad ogni passaggio successivo.

Il backup vero e proprio viene effettuato nell’ultima parte del codice (le ultime due righe), dove creiamo la nuova cartella unendo il nome di dest al numero in tot e poi usiamo il comando cp -a (copia ricorsivamente tutti i file e le cartelle).

Labirinto disegnato in PHP

Per gli appassionati di Pathfinder come me capita di fare il master e voler proporre qualche simpatico labirinto ai propri avventurieri. Online si trovano già moltissimi generatori di dungeon, però ho deciso di svagarmi un po’ questo sabato pomeriggio creando uno tutto mio in PHP.

Questo è il risultato (si rigenera ad ogni refresh della pagina):

Vediamo il codice sufficiente per ottenerlo:

<?php

// per evitare eventuali avvisi nell'output jpeg
error_reporting(0);
// diamo qualche secondo di più per generare labirinti più grandi
set_time_limit(120);

class Labirinto {
	
	// dimensione mappa predefinita in larghezza (w) e altezza (h)
	private $w = 800;
	private $h = 800;
	// colore del labirinto
	private $fgcolor = array(255,255,255);
	// colore dello sfondo del labirinto
	private $bgcolor = array(0,0,0);
	// dimensione di ogni quadretto
	private $pixel = 4;
	
	// ingresso nel labirinto come coordinate w, h; oppure x, y
	private $sw = 1;
	private $sh = 0;
	
	// massimo numero di iterazioni per generare un singolo percorso
	private $max = 100000;
	// numero di iterazioni attuali
	private $cont = 0;
	
	// matrice della mappa base con ingresso predefinito, array di array
	private $map = array(array(0,1,0));
	
	// variabile per tenere conto dell'uscita dal labirinto
	// quando viene disegnata un'uscita la variabile diventa TRUE
	private $exit = false;
	
	function __construct() {
		
	}
	
	// impostazione variabili predefinite, larghezza, altezza e dimensione quadretti
	function set($w,$h,$pixel = 4) {
		$this->w = $w;
		$this->h = $h;
		$this->pixel = $pixel;
	}
	
	// genera labirinto
	function get() {
		
		$this->max = $this->w * $this->h;
		
		$this->build();

		$this->draw();
		
	}
	
	// costruisci labirinto
	function build() {
		
		// crea il primo ramo a partire dalla posizione predefinita
		$this->go($this->sw,$this->sh);
		
		// ripassa il labirinto aggiungendo rami aggiuntivi
		// ripetiamo per 4 volte (niente di speciale in questo numero) per migliorare il riempimento
		for( $k = 0; $k < 4; $k++ ) {
			for( $r = 0; $r < $this->h; $r++ ) {
				for( $c = 0; $c < $this->w; $c++ ) {
					
					if( $this->map[$r][$c] ) {
						
						$this->go($c,$r);
						
					}
					
				}
			}
		}
		
	}
	
	// genera un ramo del labirinto
	function go( $w, $h ) {
		
		$dest = -1;
		$try = 0;
		while( true ) {
			
			if( $dest < 0 ) {
				$dest = rand(0,3);
			} else {
				$dest = (++$dest)%4;
			}
			
			$try++;
				
			switch( $dest ) {
				case 0: $dw = $w; $dh = $h-1; break;
				case 1: $dw = $w+1; $dh = $h; break;
				case 2: $dw = $w; $dh = $h+1; break;
				case 3: $dw = $w-1; $dh = $h; break;
			}
			
			
			if( $this->map[$dh][$dw] == 0 && ( ($dw > 0 && $dw < $this->w-1 && $dh > 0 && $dh < $this->h-1) || ($this->exit == false && $dh == $this->h-1)) ) {
				if( $this->check($dw,$dh,1,0,0,0) || $this->check($dw,$dh,0,1,0,0) || $this->check($dw,$dh,0,0,1,0) || $this->check($dw,$dh,0,0,0,1) ) {
					if( $this->ctrl($dw,$dh) ) {
						$this->map[$dh][$dw] = 1;
						$this->cont++;
						if( $this->exit == false && $dh == $this->h-1 ) $this->exit = true;
						if( $this->cont < $this->max ) $this->go($dw,$dh);
						break;
					}
				}
			}
			
			if( $this->check($w,$h,1,1,1,1) ) break;
			if( $this->check($w,$h,0,1,1,1) && $dh == 0 ) break;
			if( $this->check($w,$h,1,1,0,1) && $dh == $this->h-1 ) break;
			if( $this->check($w,$h,1,1,1,0) && $dw == 0 ) break;
			if( $this->check($w,$h,1,0,1,1) && $dw == $this->w-1 ) break;
			
			if( $try > 4 ) break;
		}
		
	}
	
	// verifichiamo la posizione di passaggi di celle esistenti rispetto a quella attuale
	// parametri: width, height, top, right, bottom, left
	// impostiamo quindi su width e height la posizione
	// impostiamo su t, r, b, l i valori a 0 o 1, in base che ci debbano o meno essere delle celle
	function check($w,$h,$t,$r,$b,$l) {
		return $this->map[$h-1][$w] == $t && $this->map[$h][$w+1] == $r && $this->map[$h+1][$w] == $b && $this->map[$h][$w-1] == $l;
	}
	
	// verifichiamo la posizione di celle esistenti in diagonale, secondo lo schema top-left, top-right, bottom-right, bottom-left
	function checkd($w,$h,$tl,$tr,$br,$bl) {
		return $this->map[$h-1][$w-1] == $tl && $this->map[$h-1][$w+1] == $tr && $this->map[$h+1][$w-1] == $br && $this->map[$h+1][$w+1] == $bl;
	}
	
	// controllo aggiunti sullo stato della singola cella, verifichiamo che si possa procedere e non ci siano accanti celle piene
	function ctrl($w,$h) {
		
		$ctrl = true;
		
		$ctrl = $ctrl && !($this->map[$h][$w-1] == 0 && $this->map[$h-1][$w-1] == 1 && $this->map[$h-1][$w] == 0);
		$ctrl = $ctrl && !($this->map[$h-1][$w] == 0 && $this->map[$h-1][$w+1] == 1 && $this->map[$h][$w+1] == 0);
		$ctrl = $ctrl && !($this->map[$h][$w+1] == 0 && $this->map[$h+1][$w+1] == 1 && $this->map[$h+1][$w] == 0);
		$ctrl = $ctrl && !($this->map[$h+1][$w] == 0 && $this->map[$h+1][$w-1] == 1 && $this->map[$h][$w-1] == 0);
		
		return $ctrl;
		
	}
	
	// disegna labirinto su output jpeg
	function draw() {
		
		header("Content-Type: image/png");
		$im = @imagecreate($this->w * $this->pixel, $this->h * $this->pixel) or die("Cannot Initialize new GD image stream");
		$background_color = imagecolorallocate($im, $this->bgcolor[0], $this->bgcolor[1], $this->bgcolor[2]);
		
		$this->map($im);
		
		imagejpeg($im,NULL,100);
		imagedestroy($im);

	}
	
	// prepara la mappa in base ai valori 0 e 1, 0 celle vuote, 1 celle del labirinto
	function map(&$im) {
		
		$fc = @imagecolorallocate($im, $this->fgcolor[0], $this->fgcolor[1], $this->fgcolor[2]); 
		$bc = @imagecolorallocate($im, $this->bgcolor[0], $this->bgcolor[1], $this->bgcolor[2]); 
		
		for( $r = 0; $r < $this->h; $r++ ) {
			for( $c = 0; $c < $this->w; $c++ ) {
				
				for( $ph = 0; $ph < $this->pixel; $ph++ )
					for( $pw = 0; $pw < $this->pixel; $pw++ )
						if( $this->map[$r][$c] ) {
							imagesetpixel($im,$c*$this->pixel+$ph,$r*$this->pixel+$pw,$fc);
						} else {
							imagesetpixel($im,$c*$this->pixel+$ph,$r*$this->pixel+$pw,$bc);
						}
				
			}
		}
		
	}
	
	
}

$lab = new Labirinto();
$lab->set(30,30,16);
$lab->get();

?>

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

<?php

// per evitare eventuali avvisi nell'output jpeg

error_reporting(0);

// diamo qualche secondo di più per generare labirinti più grandi

set_time_limit(120);

class Labirinto {

// dimensione mappa predefinita in larghezza (w) e altezza (h)

private $w = 800;

private $h = 800;

// colore del labirinto

private $fgcolor = array(255,255,255);

// colore dello sfondo del labirinto

private $bgcolor = array(0,0,0);

// dimensione di ogni quadretto

private $pixel = 4;

// ingresso nel labirinto come coordinate w, h; oppure x, y

private $sw = 1;

private $sh = 0;

// massimo numero di iterazioni per generare un singolo percorso

private $max = 100000;

// numero di iterazioni attuali

private $cont = 0;

// matrice della mappa base con ingresso predefinito, array di array

private $map = array(array(0,1,0));

// variabile per tenere conto dell'uscita dal labirinto

// quando viene disegnata un'uscita la variabile diventa TRUE

private $exit = false;

function __construct() {

}

// impostazione variabili predefinite, larghezza, altezza e dimensione quadretti

function set($w,$h,$pixel = 4) {

$this->w = $w;

$this->h = $h;

$this->pixel = $pixel;

}

// genera labirinto

function get() {

$this->max = $this->w * $this->h;

$this->build();

$this->draw();

}

// costruisci labirinto

function build() {

// crea il primo ramo a partire dalla posizione predefinita

$this->go($this->sw,$this->sh);

// ripassa il labirinto aggiungendo rami aggiuntivi

// ripetiamo per 4 volte (niente di speciale in questo numero) per migliorare il riempimento

for( $k = 0; $k < 4; $k++ ) {

for( $r = 0; $r < $this->h; $r++ ) {

for( $c = 0; $c < $this->w; $c++ ) {

if( $this->map[$r][$c] ) {

$this->go($c,$r);

}

// genera un ramo del labirinto

function go( $w, $h ) {

$dest = -1;

$try = 0;

while( true ) {

if( $dest < 0 ) {

$dest = rand(0,3);

} else {

$dest = (++$dest)%4;

}

$try++;

switch( $dest ) {

case 0: $dw = $w; $dh = $h-1; break;

case 1: $dw = $w+1; $dh = $h; break;

case 2: $dw = $w; $dh = $h+1; break;

case 3: $dw = $w-1; $dh = $h; break;

}

if( $this->map[$dh][$dw] == 0 && ( ($dw > 0 && $dw < $this->w-1 && $dh > 0 && $dh < $this->h-1) || ($this->exit == false && $dh == $this->h-1)) ) {

if( $this->check($dw,$dh,1,0,0,0) || $this->check($dw,$dh,0,1,0,0) || $this->check($dw,$dh,0,0,1,0) || $this->check($dw,$dh,0,0,0,1) ) {

if( $this->ctrl($dw,$dh) ) {

$this->map[$dh][$dw] = 1;

$this->cont++;

if( $this->exit == false && $dh == $this->h-1 ) $this->exit = true;

if( $this->cont < $this->max ) $this->go($dw,$dh);

break;

}

if( $this->check($w,$h,1,1,1,1) ) break;

if( $this->check($w,$h,0,1,1,1) && $dh == 0 ) break;

if( $this->check($w,$h,1,1,0,1) && $dh == $this->h-1 ) break;

if( $this->check($w,$h,1,1,1,0) && $dw == 0 ) break;

if( $this->check($w,$h,1,0,1,1) && $dw == $this->w-1 ) break;

if( $try > 4 ) break;

}

// verifichiamo la posizione di passaggi di celle esistenti rispetto a quella attuale

// parametri: width, height, top, right, bottom, left

// impostiamo quindi su width e height la posizione

// impostiamo su t, r, b, l i valori a 0 o 1, in base che ci debbano o meno essere delle celle

function check($w,$h,$t,$r,$b,$l) {

return $this->map[$h-1][$w] == $t && $this->map[$h][$w+1] == $r && $this->map[$h+1][$w] == $b && $this->map[$h][$w-1] == $l;

}

// verifichiamo la posizione di celle esistenti in diagonale, secondo lo schema top-left, top-right, bottom-right, bottom-left

function checkd($w,$h,$tl,$tr,$br,$bl) {

return $this->map[$h-1][$w-1] == $tl && $this->map[$h-1][$w+1] == $tr && $this->map[$h+1][$w-1] == $br && $this->map[$h+1][$w+1] == $bl;

}

// controllo aggiunti sullo stato della singola cella, verifichiamo che si possa procedere e non ci siano accanti celle piene

function ctrl($w,$h) {

$ctrl = true;

$ctrl = $ctrl && !($this->map[$h][$w-1] == 0 && $this->map[$h-1][$w-1] == 1 && $this->map[$h-1][$w] == 0);

$ctrl = $ctrl && !($this->map[$h-1][$w] == 0 && $this->map[$h-1][$w+1] == 1 && $this->map[$h][$w+1] == 0);

$ctrl = $ctrl && !($this->map[$h][$w+1] == 0 && $this->map[$h+1][$w+1] == 1 && $this->map[$h+1][$w] == 0);

$ctrl = $ctrl && !($this->map[$h+1][$w] == 0 && $this->map[$h+1][$w-1] == 1 && $this->map[$h][$w-1] == 0);

return $ctrl;

}

// disegna labirinto su output jpeg

function draw() {

header("Content-Type: image/png");

$im = @imagecreate($this->w * $this->pixel, $this->h * $this->pixel) or die("Cannot Initialize new GD image stream");

$background_color = imagecolorallocate($im, $this->bgcolor[0], $this->bgcolor[1], $this->bgcolor[2]);

$this->map($im);

imagejpeg($im,NULL,100);

imagedestroy($im);

}

// prepara la mappa in base ai valori 0 e 1, 0 celle vuote, 1 celle del labirinto

function map(&$im) {

$fc = @imagecolorallocate($im, $this->fgcolor[0], $this->fgcolor[1], $this->fgcolor[2]);

$bc = @imagecolorallocate($im, $this->bgcolor[0], $this->bgcolor[1], $this->bgcolor[2]);

for( $r = 0; $r < $this->h; $r++ ) {

for( $c = 0; $c < $this->w; $c++ ) {

for( $ph = 0; $ph < $this->pixel; $ph++ )

for( $pw = 0; $pw < $this->pixel; $pw++ )

if( $this->map[$r][$c] ) {

imagesetpixel($im,$c*$this->pixel+$ph,$r*$this->pixel+$pw,$fc);

} else {

imagesetpixel($im,$c*$this->pixel+$ph,$r*$this->pixel+$pw,$bc);

}

$lab = new Labirinto();

$lab->set(30,30,16);

$lab->get();

Le impostazioni nell’esempio sono le medesime per ottenere l’immagine di sopra.

Calcolare IRR (Internal Rate of Return o TIR.COST) in VBA

Problema: la funzione TIR.COST (Tasso Interno di Rendimento) restituisce un unico valore per l’IRR anche quando ce ne è più di uno

Senza discutere sull’interpretazione dell’IRR stesso, immaginiamo di avere i seguenti due scenari di flusso di cassa.

I Scenario

Questo produce un grafico VAN-IRR come quello seguente:

In questo caso abbiamo due valori dell’IRR rispettivamente 15,47% e 33,33%; la funzione TIR.COST restituisce solamente il primo valore.

II Scenario

A questa serie di flussi di cassa corrisponde il seguente grafico:

In questo caso abbiamo due valori dell’IRR rispettivamente 1,99% e 19,65%; la funzione TIR.COST restituisce solamente il secondo valore.

Costruiamo quindi in VBA le funzioni necessarie per effettuare questo calcolo; come già mostrato anche qui utilizzeremo una funzione che restituisca un vettore di valori sotto forma di Variant, in modo da poterli valutare singolarmente (per esempio utilizzando le funzioni MIN e MAX, quando i valori sono solo due, quindi =MIN(IRRX(A1:A10)) oppure =MAX(IRRX(A1:A10))).

La funzione finale si chiama IRRX, quella che utilizzeremo dentro il foglio excel.

Public Function IRRX(ByVal intervallo As Range, Optional ByVal max As Double = 300) As Variant

    Dim n As Integer
    Dim i As Double
    Dim irrs, ris As Variant
    irrs = IRRv1(intervallo, 0.01, max)
    
    ReDim ris(1 To 1)
    
    n = 0
    
    For k = 1 To UBound(irrs)
    
        i = irrs(k)
        
        Dim tmp As Variant
        tmp = IRRv2(intervallo, i - 0.01, i + 0.01)
        n = n + 1
        
        ReDim Preserve ris(1 To n)
        
        ris(n) = tmp
    
    Next k
    
    IRRX = ris

End Function

Private Function IRRv1(ByVal intervallo As Range, Optional ByVal delta As Double = 0.01, Optional ByVal max As Double = 300, Optional ByVal start As Double = 0) As Variant

    Dim irrs As Variant
    Dim VAN, VAN_prec, tir_prec As Double
    Dim anno, nirr As Integer
    
    ReDim irrs(1 To 1)
    
    nirr = 0
    
    For tir = start To max Step delta
        
        VAN = 0
        anno = 0
        
        For Each c In intervallo
        
            VAN = VAN + c.Value / (1 + tir) ^ anno
            
            anno = anno + 1
        
        Next c
        
        If tir > start And VAN_prec * VAN <= 0 Then
            
            nirr = nirr + 1
            
            ReDim Preserve irrs(1 To nirr)
            irrs(nirr) = (tir + tir_prec) / 2
            
        End If
        
        VAN_prec = VAN
        tir_prec = tir
        
    Next tir
    
    IRRv1 = irrs

End Function

Private Function IRRv2(ByVal flusso As Range, ByVal min As Double, ByVal max As Double) As Double

    For i = 0 To 100
    
        tmin = VAN(flusso, min)
        tmax = VAN(flusso, max)
        tavg = VAN(flusso, (max + min) / 2)
        
        If tavg = 0 Then
            Exit For
        End If
        
        If tmin * tavg < 0 Then
            max = (max + min) / 2
        Else
            min = (max + min) / 2
        End If
        
    Next i
    
    IRRv2 = (max + min) / 2

End Function

Private Function VAN(ByVal intervallo As Range, ByVal tir As Double) As Double

    Dim tmp As Double
    Dim anno As Integer
    
    tmp = 0
    anno = 0
    
    For Each c In intervallo
        
        tmp = tmp + c.Value / (1 + tir) ^ anno
        
        anno = anno + 1
    
    Next c
    
    VAN = tmp

End Function

100

101

102

103

104

105

106

107

108

109

110

111

112

113

Public Function IRRX(ByVal intervallo As Range, Optional ByVal max As Double = 300) As Variant

Dim n As Integer

Dim i As Double

Dim irrs, ris As Variant

irrs = IRRv1(intervallo, 0.01, max)

ReDim ris(1 To 1)

n = 0

For k = 1 To UBound(irrs)

i = irrs(k)

Dim tmp As Variant

tmp = IRRv2(intervallo, i - 0.01, i + 0.01)

n = n + 1

ReDim Preserve ris(1 To n)

ris(n) = tmp

Next k

IRRX = ris

End Function

Private Function IRRv1(ByVal intervallo As Range, Optional ByVal delta As Double = 0.01, Optional ByVal max As Double = 300, Optional ByVal start As Double = 0) As Variant

Dim irrs As Variant

Dim VAN, VAN_prec, tir_prec As Double

Dim anno, nirr As Integer

ReDim irrs(1 To 1)

nirr = 0

For tir = start To max Step delta

VAN = 0

anno = 0

For Each c In intervallo

VAN = VAN + c.Value / (1 + tir) ^ anno

anno = anno + 1

Next c

If tir > start And VAN_prec * VAN <= 0 Then

nirr = nirr + 1

ReDim Preserve irrs(1 To nirr)

irrs(nirr) = (tir + tir_prec) / 2

End If

VAN_prec = VAN

tir_prec = tir

Next tir

IRRv1 = irrs

End Function

Private Function IRRv2(ByVal flusso As Range, ByVal min As Double, ByVal max As Double) As Double

For i = 0 To 100

tmin = VAN(flusso, min)

tmax = VAN(flusso, max)

tavg = VAN(flusso, (max + min) / 2)

If tavg = 0 Then

Exit For

End If

If tmin * tavg < 0 Then

max = (max + min) / 2

Else

min = (max + min) / 2

End If

Next i

IRRv2 = (max + min) / 2

End Function

Private Function VAN(ByVal intervallo As Range, ByVal tir As Double) As Double

Dim tmp As Double

Dim anno As Integer

tmp = 0

anno = 0

For Each c In intervallo

tmp = tmp + c.Value / (1 + tir) ^ anno

anno = anno + 1

Next c

VAN = tmp

End Function

Le altre funzioni servono rispettivamente a:

IRRv1 – calcolare in modo approssimativo tutti gli IRR possibili su uno specifico flusso di cassa, con valore massimo per l’IRR al 30.000% (espresso come max = 300), inutile dire come questo valore possa essere impostato anche a molto meno per velocizzare i calcoli; l’IRR qui viene calcolato per ogni punto percentuale con scarti del 1%
IRRv2 – qui calcoliamo, per ogni valore di IRR trovato con la precedente funzione, il valore approssimato mediante iterazione su valori che vanno da IRRv2 ± 1%
VAN – questa funziona calcola semplicemente il VAN sul dato IRR

Testato su Excel 2016.