Petar Karan

[php] Interroghiamo un database MySQL su cluster mediante il PHP

Obiettivo: anzitutto creiamo una classe per mediare la connessione MySQL (con o senza cluster è indifferente) e testiamo il cluster MySQL creato nell’esercizio precedente

Per realizzare il nostro scopo avviamo un server apache sulla nostra macchina host, dove abbiamo già avviato 3 macchine virtuali che costituiscono il nostro MySQL Cluster.

Per avviare il server apache mi avvarrò di XAMPP.

Inoltre prima di procedere devo inoltrare la porta 3306 verso il MySQL Cluster Manager che ho configurato in precedenza. Per farlo mi è sufficiente spostarmi in File ⇒ Preferenze ⇒ Rete

Selezioniamo la nostra Rete NAT corrispondente al cluster che abbiamo realizzato e andiamo a configurare l’inoltro delle porte, per ottenere qualcosa di simile a questo:

A questo punto andiamo nel nostro PHP. Creiamo anzitutto un file /inc/MySQLDb.php contenente il seguente codice:

class MySQLdb {

	private $mysql = NULL;

	function __construct($cfg = NULL) {
	
		if( $cfg != NULL ) {
			
			$this->config($cfg['dbname'],$cfg['dbhost'],$cfg['dbuser'],$cfg['dbport'],$cfg['dbpass']);
			
			$this->connect_db();
			
		}
	
	}
	
	function __destruct() {
	
		$this->close_db();
	
	}
	
	function config( $dbname, $dbhost, $dbuser, $dbport, $dbpass ) {
	
		$this->dbname = $dbname;
		$this->dbhost = $dbhost;
		$this->dbuser = $dbuser;
		$this->dbport = $dbport;
		$this->dbpass = $dbpass;
	
	}
	
	function select_db($dbname = NULL) {
	
		$this->mysql->select_db($dbname ? $dbname : $this->dbname);
	
	}
	
	function connect_db() {
	
		if( $this->mysql == NULL ) {
		
			$this->mysql = new mysqli($this->dbhost, $this->dbuser, $this->dbpass);
			$this->select_db();
			$this->errorHandler();
		
		}
	
	}
	
	function close_db() {
	
		if( $this->mysql != NULL ) {
		
			$this->mysql->close();
			$this->mysql = NULL;
		
		}
	
	}
	
	function errorHandler() {
	
		if( $this->mysql->connect_errno ) {
		
			printf( "Connect failed: %s\n", $this->mysql->connect_error );
			die();
			
		}
	
	}
	
	function clean( $val ) {
		return $this->mysql->real_escape_string($val);
	}
	
	function in( $query ) {
	
		$status = $this->mysql->query( $query );
		
		if( $this->mysql->insert_id ) 
			return $this->mysql->insert_id;
		else 
			return $status;
	
	}
	
	function out( $query , $autoReduce = true ) {
	
		$result = $this->mysql->query( $query );
			
		if( !is_object($result) )
			return array();
		
		while ($linea = $result->fetch_assoc()) {
		
			$i = $i !== NULL ? $i + 1 : 0;
			
			foreach( $linea as $key => $value ) {
				$dati[$i][$key] = $value;
			}
			
		}
		
		$result->close();
		
		if( count($dati) == 1 && $autoReduce )
			return $dati[0];
		
		return $dati;
	
	}


}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

class MySQLdb {

private $mysql = NULL;

function __construct($cfg = NULL) {

if( $cfg != NULL ) {

$this->config($cfg['dbname'],$cfg['dbhost'],$cfg['dbuser'],$cfg['dbport'],$cfg['dbpass']);

$this->connect_db();

}

function __destruct() {

$this->close_db();

}

function config( $dbname, $dbhost, $dbuser, $dbport, $dbpass ) {

$this->dbname = $dbname;

$this->dbhost = $dbhost;

$this->dbuser = $dbuser;

$this->dbport = $dbport;

$this->dbpass = $dbpass;

}

function select_db($dbname = NULL) {

$this->mysql->select_db($dbname ? $dbname : $this->dbname);

}

function connect_db() {

if( $this->mysql == NULL ) {

$this->mysql = new mysqli($this->dbhost, $this->dbuser, $this->dbpass);

$this->select_db();

$this->errorHandler();

}

function close_db() {

if( $this->mysql != NULL ) {

$this->mysql->close();

$this->mysql = NULL;

}

function errorHandler() {

if( $this->mysql->connect_errno ) {

printf( "Connect failed: %s\n", $this->mysql->connect_error );

die();

}

function clean( $val ) {

return $this->mysql->real_escape_string($val);

}

function in( $query ) {

$status = $this->mysql->query( $query );

if( $this->mysql->insert_id )

return $this->mysql->insert_id;

else

return $status;

}

function out( $query , $autoReduce = true ) {

$result = $this->mysql->query( $query );

if( !is_object($result) )

return array();

while ($linea = $result->fetch_assoc()) {

$i = $i !== NULL ? $i + 1 : 0;

foreach( $linea as $key => $value ) {

$dati[$i][$key] = $value;

}

$result->close();

if( count($dati) == 1 && $autoReduce )

return $dati[0];

return $dati;

}

Andiamo adesso a creare il nostro file index.php:

<?php

	include("inc/MySQLDb.php");
	
	$mysql = new MySQLdb(array(
		"dbname" => "cluster_test",
		"dbhost" => "192.168.56.1",
		"dbuser" => "root",
		"dbpass" => "password",
		"dbport" => 3306
	));
	
	$utenti = $mysql->out("SELECT * FROM cluster_test",false);
	
	print_r( $utenti );


?>

<?php

include("inc/MySQLDb.php");

$mysql = new MySQLdb(array(

"dbname" => "cluster_test",

"dbhost" => "192.168.56.1",

"dbuser" => "root",

"dbpass" => "password",

"dbport" => 3306

));

$utenti = $mysql->out("SELECT * FROM cluster_test",false);

print_r( $utenti );

Eseguendo la pagina index.php è molto probabile incorrere nel seguente output di errori:

Warning: mysqli::__construct(): MySQL server has gone away in D:\xampp\htdocs\tests\mysqlcluster\inc\MySQLDb.php on line 45

Warning: mysqli::__construct(): Error while reading greeting packet. PID=2612 in D:\xampp\htdocs\tests\mysqlcluster\inc\MySQLDb.php on line 45

Warning: mysqli::__construct(): (HY000/2006): MySQL server has gone away in D:\xampp\htdocs\tests\mysqlcluster\inc\MySQLDb.php on line 45

Warning: mysqli::select_db(): Couldn't fetch mysqli in D:\xampp\htdocs\tests\mysqlcluster\inc\MySQLDb.php on line 37
Connect failed: MySQL server has gone away 
Warning: mysqli::close(): Couldn't fetch mysqli in D:\xampp\htdocs\tests\mysqlcluster\inc\MySQLDb.php on line 57

Warning: mysqli::__construct(): MySQL server has gone away in D:\xampp\htdocs\tests\mysqlcluster\inc\MySQLDb.php on line 45

Warning: mysqli::__construct(): Error while reading greeting packet. PID=2612 in D:\xampp\htdocs\tests\mysqlcluster\inc\MySQLDb.php on line 45

Warning: mysqli::__construct(): (HY000/2006): MySQL server has gone away in D:\xampp\htdocs\tests\mysqlcluster\inc\MySQLDb.php on line 45

Warning: mysqli::select_db(): Couldn't fetch mysqli in D:\xampp\htdocs\tests\mysqlcluster\inc\MySQLDb.php on line 37

Connect failed: MySQL server has gone away

Warning: mysqli::close(): Couldn't fetch mysqli in D:\xampp\htdocs\tests\mysqlcluster\inc\MySQLDb.php on line 57

Questo tipo di errore può dipendere o dal fatto che stiamo richiedendo una query troppo grossa, oppure perché il nostro Server MySQL non è predisposto per accettare le connessioni dall’esterno.

Per risolvere il problema procediamo nel modo seguente.

Anzitutto creiamo un utente apposito con il quale ci collegheremo dall’esterno (nel mio caso gli garantirò tutti i permessi possibili su tutti i database, ovviamente andrebbe limitato ad uno specifico database).

Accediamo al mysql sul nostro cluster manager digitando:

mysql -u root -p

1	mysql -u root -p

Inseriamo la password di root e poi eseguiamo le seguenti due query per creare l’utente zelda:

GRANT ALL PRIVILEGES ON *.* TO 'zelda'@'192.168.56.1' IDENTIFIED BY 'password' WITH GRANT OPTION;
FLUSH PRIVILEGES;

1 2	GRANT ALL PRIVILEGES ON . TO 'zelda'@'192.168.56.1' IDENTIFIED BY 'password' WITH GRANT OPTION; FLUSH PRIVILEGES;

Faccio notare che con ‘zelda’@’192.168.56.1′ garantiamo l’accesso all’utente zelda dall’indirizzo 192.168.56.1 che è l’indirizzo esterno della nostra rete NAT su Virtual Box.

Digitiamo exit per uscire e andiamo a modificare il file di configurazione del mysql:

sudo nano /etc/mysql/mysql.conf.d/mysqld.cnf

1	sudo nano /etc/mysql/mysql.conf.d/mysqld.cnf

Cerchiamo la voce bind-address e commentiamola in modo che risulti in questo modo:

[mysqld]
pid-file        = /var/run/mysqld/mysqld.pid
socket          = /var/run/mysqld/mysqld.sock
datadir         = /var/lib/mysql
log-error       = /var/log/mysql/error.log
# By default we only accept connections from localhost
#bind-address   = 127.0.0.1
# Disabling symbolic-links is recommended to prevent assorted security risks
symbolic-links=0

[mysqld]

pid-file = /var/run/mysqld/mysqld.pid

socket = /var/run/mysqld/mysqld.sock

datadir = /var/lib/mysql

log-error = /var/log/mysql/error.log

# By default we only accept connections from localhost

#bind-address = 127.0.0.1

# Disabling symbolic-links is recommended to prevent assorted security risks

symbolic-links=0

Infine modifichiamo anche il file /etc/mysql/my.cnf

sudo nano /etc/mysql/my.cnf

1	sudo nano /etc/mysql/my.cnf

Inseriamo in fondo max_allowed_packet=16M in modo tale che il file risulti così

[mysqld]
ndbcluster
max_allowed_packet=16M

[mysqld]

ndbcluster

max_allowed_packet=16M

Quest’ultima modifica è di solito sufficiente per correggere il precedente errore, se dovesse ripresentarsi possiamo alzare ancora questo valore.

Fatto tutto questo riavviamo il servizio mysql digitando:

sudo service mysql restart

1	sudo service mysql restart

Se abbiamo fatto tutto bene non ci saranno errori.

A questo punto modifichiamo il file index.php di sopra perché appaia in questo modo:

<?php

	error_reporting(E_ALL & ~E_NOTICE);

	include("inc/MySQLDb.php");
	
	$mysql = new MySQLdb(array(
		"dbname" => "cluster_test",
		"dbhost" => "192.168.56.1",
		"dbuser" => "zelda",
		"dbpass" => "password",
		"dbport" => 3306
	));
	
	$utenti = $mysql->out("SELECT * FROM cluster_test",false);
	
	print_r( $utenti );


?>

<?php

error_reporting(E_ALL & ~E_NOTICE);

include("inc/MySQLDb.php");

$mysql = new MySQLdb(array(

"dbname" => "cluster_test",

"dbhost" => "192.168.56.1",

"dbuser" => "zelda",

"dbpass" => "password",

"dbport" => 3306

));

$utenti = $mysql->out("SELECT * FROM cluster_test",false);

print_r( $utenti );

Eseguendo la pagina dovremmo vedere qualcosa di simile a questo:

Questo significa che è tutto andato correttamente. A questo punto divertiamoci ad inserire qualche altro utente e generare una tabella con HTML corretto. Modifichiamo il file PHP come segue:

<?php

	error_reporting(E_ALL & ~E_NOTICE);

	include("inc/MySQLDb.php");
	
	// connettiamoci al database
	$mysql = new MySQLdb(array(
		"dbname" => "cluster_test",
		"dbhost" => "192.168.56.1",
		"dbuser" => "zelda",
		"dbpass" => "password",
		"dbport" => 3306
	));
	
	// inseriamo un nuovo nominativo
	$mysql->in("INSERT INTO cluster_test (nome,cognome) VALUES('Luigi','Verdi')");
	
	// leggiamo tutti gli utenti
	$utenti = $mysql->out("SELECT * FROM cluster_test",false);


?>
<html>

	<head>
		<title>Esempio Cluster MySQL e PHP</title>
	</head>
	
	<body>
	
		<table border="1">
		
			<thead>
				<tr>
					<th>Nome</th>
					<th>Cognome</th>
				</tr>
			</thead>
			
			<tbody>
				<?php foreach( $utenti as $k => $v ) { ?>
				<tr>
					<td><?php echo $v['nome'] ?></td>
					<td><?php echo $v['cognome'] ?></td>
				</tr>
				<? } ?>
			</tbody>
			
		</table>
		
	</body>

</html>

<?php

error_reporting(E_ALL & ~E_NOTICE);

include("inc/MySQLDb.php");

// connettiamoci al database

$mysql = new MySQLdb(array(

"dbname" => "cluster_test",

"dbhost" => "192.168.56.1",

"dbuser" => "zelda",

"dbpass" => "password",

"dbport" => 3306

));

// inseriamo un nuovo nominativo

$mysql->in("INSERT INTO cluster_test (nome,cognome) VALUES('Luigi','Verdi')");

// leggiamo tutti gli utenti

$utenti = $mysql->out("SELECT * FROM cluster_test",false);

<html>

<head>

<title>Esempio Cluster MySQL e PHP</title>

</head>

<body>

<thead>

<tr>

<th>Cognome</th>

</tr>

</thead>

<tbody>

<?php foreach( $utenti as $k => $v ) { ?>

<tr>

</tr>

<? } ?>

</tbody>

</table>

</body>

</html>

Il risultato, aggiornando la pagina, dovrebbe essere simile a questo:

Infine facciamo una prova per caricare di dati il nostro cluster.

Modifichiamo il file index.php alterando la parte dell’inserimento degli utenti come segue:

	// inseriamo un nuovo nominativo
	for( $i = 0; $i < 10000; $i++ )
		$mysql->in("INSERT INTO cluster_test (nome,cognome) VALUES('Luigi$i','Verdi$i')");

// inseriamo un nuovo nominativo

for( $i = 0; $i < 10000; $i++ )

$mysql->in("INSERT INTO cluster_test (nome,cognome) VALUES('Luigi$i','Verdi$i')");

Prima di aggiornare la pagina andiamo nel nostro cluster manager e digitiamo:

ndb_mgm -e 'ALL REPORT MEMORYUSAGE'

1	ndb_mgm -e 'ALL REPORT MEMORYUSAGE'

Quello che dovremmo vedere sarà un risultato simile a questo:

Inserendo 10.000 record, con il precedente script, dovremmo vedere questa “importante” differenza:

Recensione disonesta su Noctis in Tekken 7

Me n’ero quasi dimenticato che ci sarebbe stato, quando finalmente, lo scorso 20 marzo, al cast di Tekken 7 si è aggiunto anche Noctis da Final Fantasy XV. Questa naturalmente non potrà che essere una recensione disonesta, dal momento che si fondono insieme due delle mie saghe preferite.

Noctis fa letteralmente il botto. E’ una specie di sintesi perfetta tra Jun, Hwoarang e Kazumi (miei combattenti preferiti). Similmente a Jun, ha alcune perfette aperture dall’alto (uf+3, u+2), mentre con Kazumi condivide quelle dal basso che rompono veramente un sacco le scatole (df+2) e la possibilità di raggiungere l’avversario a distanza (f,f+2). Comunque niente di assurdo tipo il raggio di Devil Kazuya o Devil Jin. Con Hworang non condivide tanto i calci, quanto alcune semplicissime pressioni di tasti che si trasformano in velocissime combo (Blitz Rush con 2,2,2,2,2) e alcuni sgambetti (d+4, combinabile in d+4,1,1+2), oltre che la velocità. A parte questi piccoli apprezzamenti squisitamente personali (Jun è stata in assoluto il mio personaggio preferito dell’intera saga), l’intero set di mosse è molto coreografico e bello da vedere, per quanto di per se solo alcuni colpi siano veramente devastanti (diciamo che vige la regola dei tanti piccoli colpi ben assestati).

Molti si sono lamentati che non c’entri molto con Tekken, anche se sinceramente non sono d’accordo (sebbene ammetto di essere molto di parte); in questo ultimo capitolo si schiera nella risma dei personaggi dotati di armi alla Alisa e Yoshimitsu, e coniuga alla perfezione molto caratteristiche dei personaggi maschili (tipicamente colpi forti e lenti) con quelli dei personaggi femminili (colpi deboli, ma veloci). Personalmente lo trovo un mix perfetto.

Inoltre, a differenza degli ultimissimi DLC, non ci sono mosse poco tekkenose, tipo combinazioni b,f o semicerchi in stile Akuma, per quanto mi renda conto che quelle sono necessariamente derivative dai giochi originali. A tal proposito potrei citare il caso di Kazumi, personaggio comunque originale, della quale uno dei linker migliori si esegue premendo b,f (per esempio il Tiger Demon’s Gate, b,f,2,1,4), che trovo abbastanza scomodo (sarà anche per via del tipo di joystick, ma tant’è).

L’unica pecca vera è la scarsità di costumi, che mi ha lasciato un poco deluso, mentre per Geese, Eliza ed Akuma (che ok, non è un DLC, ma è comunque un personaggio esterno) le possibilità di personalizzazione equivalgono a quelle dei personaggi regolari.

Insomma se siete appassionati come il sottoscritto di entrambe le saghe questo non ve lo potete proprio perdere.

Infine segnalo un ottimo video di combo che ho trovato su youtube e sul quale mi sto ancora esercitando, per tutti quelli che volessero approfondire.

[ubuntu] Creare cluster MySQL

Obiettivo: creare un cluster MySQL, ovvero un server MySQL distribuito, utilizzando 3 macchine con Ubuntu, 1 per il gestore del server e 2 per i nodi

Anche questa volta, come negli altri esempi, mi avvarrò di VirtualBox, per emulare il gruppo di server. Ovviamente la procedura è valida anche su macchina fisiche oppure utilizzando un altro tipo di macchine virtuali. La struttura che andremo a creare sarà la seguente:

1. Preparazione di Ubuntu su VirtualBox

Anzitutto scarichiamo ed installiamo VirtualBox dal sito ufficiale.

Quello che voglio creare, prima di cominciare con la configurazione del cluster, sono 3 macchine con sopra Ubuntu perfettamente identiche. Sottolineo il fatto che non sia necessario che siano identiche, ma solo che su tutte e tre sia configurato correttamente il MySQL.

Cominciamo configurando la prima macchina virtuale per metterci sopra Ubuntu.

Come parametri di configurazione, nella procedura guidata, scegliamo:

Versione: Ubuntu (64-bit)
Dimensione memoria: 1024MB
Disco virtuale: 10GB
Tipo di disco: VDI
Tipo allocazione: dinamica

Una volta creata la macchina virtuale facciamo partire ed inseriamo la ISO per l’installazione che abbiamo scaricato dal sito ufficiale di Ubuntu. Ricordo di scaricare la versione Ubuntu Server 64-bit.

Per questo esempio utilizzerò la versione 16.04.2 di Ubuntu Server.

Avviamo normalmente l’installazione, per chi non l’avesse mai fatto suggerisco di seguire la prima parte di: Installazione Ubuntu webserver pronto all’uso [per esordienti totali]

L’unica differenza è che non installeremo il server apache al momento in cui ci verrà richiesto.

Come nome del host mettiamo ubuntu-mysql-manager (si tratta comunque di un nome a piacere):

Ad un certo punto dell’installazione ci verrà proposto quanto segue:

Assicuriamoci di aver selezionato solamente le voci della figura precedente, per selezionarle muoviamoci con le frecce direzionali e spuntiamo le voci premendo SPAZIO. Con la tabulazione spostiamoci su Continua e premiamo INVIO dopo aver selezionato le voci correttamente.

Una volta completata l’installazione riavviamo la macchina virtuale ed entriamo con il nome utente che abbiamo creato.

A questo punto spegniamo la macchina virtuale digitando:

sudo shutdown -t now

1	sudo shutdown -t now

Prima di procedere vogliamo creare una rete NAT interna sulla quale testare le nostre macchine. Per farlo utilizziamo le impostazioni di virtual box andando su File ⇒ Preferenze (oppure premendo CTRL+G dal panello di controllo di virtual box). A questo punto spostiamoci su Rete nel modo seguente e scegliamo di aggiungere una nuova rete.

Una volta creata la nuova rete dovremmo vedere comparire una voce NatNetwork come nell’immagine seguente:

Una volta selezionata clicchiamo sul pulsante per modificarla ed impostiamola nel modo seguente:

Faccio notare che l’impostazione della rete è arbitraria e a nostra scelta, quella predefinita parte sulla configurazione 10.0.2.0/24 che ho modificato nella classica rete domestica col 192.168.0.0/24 a titolo di esercizio. Questo significa che avremo a disposizione 254 host dal 192.16.0.1 al 192.16.0.254.

Diamogli OK e andiamo nelle impostazioni della macchina virtuale mettendo nella configurazione di rete la rete appena creata, in maniera seguente:

Riavviamo la macchina virtuale e colleghiamoci in SSH effettuando l’inoltro delle porte.

Per farlo, una volta partita la macchina virtuale, digitiamo:

ifconfig

ifconfig

Il risultato dovrebbe essere qualcosa di simile a questo:

Nel mio caso noto che la macchina virtuale, di quello che diventerà il manager, si trova all’indirizzo 192.168.0.5 distribuito dal DHCP. Tornando su File ⇒ Preferenze andiamo sulla rete creata prima e apriamo le configurazioni, poi clicchiamo su Inoltro delle porte e aggiungiamo la seguente regola:

Diamo OK. Adesso possiamo collegarci in SSH dalla nostra macchina host (detto banalmente: dal nostro PC che ospita le macchine virtuali) usando l’indirizzo 192.168.56.1 porta 22.

Fatta questa bella impostazione possiamo passare al passaggio successivo.

2. Installazione MySQL sul primo Nodo

Anzitutto installiamo il cluster su tutti i nostri nodi, nello specifico lo installiamo sulla macchina appena creata che poi duplicheremo opportunamente. Per l’installazione possiamo seguire i passaggi indicati sul sito ufficiale, oppure scaricare dalla pagina ufficiale i file .deb necessari.

Io utilizzerò la repository APT, ma prima di cominciare installiamo le dipendenze necessarie al funzionamento del cluster:

sudo apt-get install python-paramiko libclass-methodmaker-perl libaio1

1	sudo apt-get install python-paramiko libclass-methodmaker-perl libaio1

A questo punto dobbiamo installare la MySQL APT Repository sul nostro sistema. Per farlo ci è sufficiente scaricare il file di installazione dal sito ufficiale andando qui. Nello specifico digitiamo:

wget https://dev.mysql.com/get/mysql-apt-config_0.8.9-1_all.deb

1	wget https://dev.mysql.com/get/mysql-apt-config_0.8.9-1_all.deb

Una volta scaricato il file procediamo all’installazione:

sudo dpkg -i mysql-apt-config_0.8.9-1_all.deb

1	sudo dpkg -i mysql-apt-config_0.8.9-1_all.deb

A questo punto ci verrà chiesto che cosa intendiamo configurare e scegliamo la voce MySQL Server & Cluster:

Ci verrà chiesta la versione che intendiamo installare e selezioniamo mysql-cluster-7.6:

A questo punto torniamo alla schermata precedente e selezioniamo OK:

A questo punto non ci rimane che installare il componente base per tutti i nodi digitando:

sudo apt-get update
sudo apt-get install mysql-cluster-community-server

1 2	sudo apt-get update sudo apt-get install mysql-cluster-community-server

L’update ci serve per aggiornare la repository dopo le recenti modifiche, altrimenti è probabile che sia impossibile trovare mysql-cluster-community-server.

Ad un certo punto ci verrà chiesto di impostare una password per l’utente root del database, impostiamo una password e segniamocela da qualche parte. Ricordo che l’utente root non è quello del sistema, ma del database.

A questo punto abbiamo preparato un nodo.

Replicheremo questo nodo per altre due volte, designando un singolo nodo come manager del cluster.

3. Replica dei nodi

Per replicare i nodi possiamo decidere di creare un’immagine del nostro sistema che reinstalleremo a piacere, oppure, visto che stiamo usando VirtualBox di duplicare le macchine virtuali. Quindi spegniamo la nostra macchina e creiamone una copia.

Per farlo ci è sufficiente cliccare sulla macchina virtuale e selezionare Clona…

A questo punto ci verrà mostrata una schermata delle opzioni da configurare nel modo seguente:

Spuntiamo l’inizializzazione di un nuovo indirizzo MAC (visto che vogliamo usare le macchine insieme) e diamo un nome alla nuova macchina, nel mio caso Ubuntu MySQL Nodo 1.

Ripetiamo la medesima operazione per creare un Ubuntu MySQL Nodo 2.

A questo punto sistemiamo la nostra rete per poter accedere alle macchine virtuali. Per farlo assegniamo a tutte le macchine un indirizzo IP statico, modifichiamo opportunamente i nomi e configuriamo il file hosts in modo tale che possano vedersi le une con le altre. La configurazione finale sarà così:

Cominciamo con Ubuntu MySQL Manager.

Usando ifconfig verifichiamo che la nostra macchina si trovi all’indirizzo 192.168.0.5. Scopriamo il nostro gateway digitando:

route -n

route -n

Il risultato dovrebbe assomigliare a qualcosa di simile:

Tabella di routing IP del kernel
Destination     Gateway         Genmask         Flags Metric Ref    Use Iface
0.0.0.0         192.168.0.1     0.0.0.0         UG    0      0        0 enp0s3
192.168.0.0     0.0.0.0         255.255.255.0   U     0      0        0 enp0s3

Tabella di routing IP del kernel

Destination Gateway Genmask Flags Metric Ref Use Iface

0.0.0.0 192.168.0.1 0.0.0.0 UG 0 0 0 enp0s3

192.168.0.0 0.0.0.0 255.255.255.0 U 0 0 0 enp0s3

Il gateway è quindi 192.168.0.1, ricordiamoci che la nostra rete è stata impostata con netmask /24 ovvero 255.255.255.0

Impostiamo quindi tale indirizzo come indirizzo statico, usando le informazioni che abbiamo raccolto.

sudo nano /etc/network/interfaces

1	sudo nano /etc/network/interfaces

Modifichiamo il file interfaces affinché abbia il seguente contenuto:

# This file describes the network interfaces available on your system
# and how to activate them. For more information, see interfaces(5).

source /etc/network/interfaces.d/*

# The loopback network interface
auto lo
iface lo inet loopback

# The primary network interface
auto enp0s3
iface enp0s3 inet static
address 192.168.0.5
netmask 255.255.255.0
gateway 192.168.0.1
dns-nameservers 8.8.8.8

# This file describes the network interfaces available on your system

# and how to activate them. For more information, see interfaces(5).

source /etc/network/interfaces.d/*

# The loopback network interface

auto lo

iface lo inet loopback

# The primary network interface

auto enp0s3

iface enp0s3 inet static

address 192.168.0.5

netmask 255.255.255.0

gateway 192.168.0.1

dns-nameservers 8.8.8.8

Faccio notare che per il DNS utilizziamo il DNS di Google all’indirizzo 8.8.8.8.

A questo punto riavviamo la scheda di rete digitando:

sudo ifdown enp0s3 && sudo ifup enp0s3

1	sudo ifdown enp0s3 && sudo ifup enp0s3

Faccio notare che la nostra interfaccia di rete è enp0s3, mentre in una classica configurazione fisica probabilmente sarebbe eth1.

Fatto questo modifichiamo il file hosts inserendo gli host stabiliti all’inizio:

192.168.0.5     manager.mysql.cluster
192.168.0.6     nodo1.mysql.cluster
192.168.0.7     nodo2.mysql.cluster

192.168.0.5 manager.mysql.cluster

192.168.0.6 nodo1.mysql.cluster

192.168.0.7 nodo2.mysql.cluster

Il file alla fine dovrebbe risultare qualcosa di simile a questo:

127.0.0.1       localhost
127.0.1.1       ubuntu-mysql-manager

192.168.0.5     manager.mysql.cluster
192.168.0.6     nodo1.mysql.cluster
192.168.0.7     nodo2.mysql.cluster

# The following lines are desirable for IPv6 capable hosts
::1     localhost ip6-localhost ip6-loopback
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters

127.0.0.1 localhost

127.0.1.1 ubuntu-mysql-manager

192.168.0.5 manager.mysql.cluster

192.168.0.6 nodo1.mysql.cluster

192.168.0.7 nodo2.mysql.cluster

# The following lines are desirable for IPv6 capable hosts

::1 localhost ip6-localhost ip6-loopback

ff02::1 ip6-allnodes

ff02::2 ip6-allrouters

Salviamo il tutto, spegniamo la macchina (onde evitare conflitti, dal momento che sono tutte duplicate) e spostiamoci sul prossimo nodo.

Configurazione Ubuntu MySQL Nodo 1

Prima di procedere soffermiamoci un attimo a configurare le porte per l’inoltro sulla scheda di virtual box, ottenendo una configurazione simile a questa:

In questo modo collegandoci su porte diverse dell’interfaccia esterna potremo accedere, mediante SSH, alle specifiche macchine virtuali.

Una volta avviato il secondo nodo è molto probabile, essendo la prima macchina sull’indirizzo 192.168.0.5, che questo si trovi sull’indirizzo 192.168.0.6. Se facciamo tutto in questo ordine ci risparmiamo qualche piccolo lavoretto extra nella riassegnazione degli indirizzi. Colleghiamoci quindi al nostro nodo 1 (se usate Putty potete collegarvi al 192.168.56.1:23) e modifichiamo la scheda di rete con l’indirizzo statico, come abbiamo fatto prima.

sudo nano /etc/network/interfaces

1	sudo nano /etc/network/interfaces

Il risultato sarà simile a questo:

# This file describes the network interfaces available on your system
# and how to activate them. For more information, see interfaces(5).

source /etc/network/interfaces.d/*

# The loopback network interface
auto lo
iface lo inet loopback

# The primary network interface
auto enp0s3
iface enp0s3 inet static
address 192.168.0.6
netmask 255.255.255.0
gateway 192.168.0.1
dns-nameservers 8.8.8.8

# This file describes the network interfaces available on your system

# and how to activate them. For more information, see interfaces(5).

source /etc/network/interfaces.d/*

# The loopback network interface

auto lo

iface lo inet loopback

# The primary network interface

auto enp0s3

iface enp0s3 inet static

address 192.168.0.6

netmask 255.255.255.0

gateway 192.168.0.1

dns-nameservers 8.8.8.8

Modifichiamo il file hosts:

sudo nano /etc/hosts

1	sudo nano /etc/hosts

Aggiungiamo le righe di prima:

192.168.0.5     manager.mysql.cluster
192.168.0.6     nodo1.mysql.cluster
192.168.0.7     nodo2.mysql.cluster

192.168.0.5 manager.mysql.cluster

192.168.0.6 nodo1.mysql.cluster

192.168.0.7 nodo2.mysql.cluster

E notiamo che abbiamo ancora ubuntu-mysql-manager come riferimento interno. Rinominiamolo in ubuntu-mysql-nodo1. Il file hosts alla fine risulterà così:

127.0.0.1       localhost
127.0.1.1       ubuntu-mysql-nodo1

192.168.0.5     manager.mysql.cluster
192.168.0.6     nodo1.mysql.cluster
192.168.0.7     nodo2.mysql.cluster

# The following lines are desirable for IPv6 capable hosts
::1     localhost ip6-localhost ip6-loopback
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters

127.0.0.1 localhost

127.0.1.1 ubuntu-mysql-nodo1

192.168.0.5 manager.mysql.cluster

192.168.0.6 nodo1.mysql.cluster

192.168.0.7 nodo2.mysql.cluster

# The following lines are desirable for IPv6 capable hosts

::1 localhost ip6-localhost ip6-loopback

ff02::1 ip6-allnodes

ff02::2 ip6-allrouters

Infine modifichiamo il hostname digitando:

sudo nano /etc/hostname

1	sudo nano /etc/hostname

Anche qui dentro sostituiamo il nome di poco fa con quello nuovo, ovvero ubuntu-mysql-nodo1.

Fatto tutto questo spegniamo la macchina e passiamo al secondo nodo.

Configurazione Ubuntu MySQL Nodo 2

A questo punto dovrebbe essere tutto semplice, basta replicare quanto fatto per il nodo 1.

Il file /etc/network/interfaces avrà quindi il seguente aspetto:

# This file describes the network interfaces available on your system
# and how to activate them. For more information, see interfaces(5).

source /etc/network/interfaces.d/*

# The loopback network interface
auto lo
iface lo inet loopback

# The primary network interface
auto enp0s3
iface enp0s3 inet static
address 192.168.0.7
netmask 255.255.255.0
gateway 192.168.0.1
dns-nameservers 8.8.8.8

# This file describes the network interfaces available on your system

# and how to activate them. For more information, see interfaces(5).

source /etc/network/interfaces.d/*

# The loopback network interface

auto lo

iface lo inet loopback

# The primary network interface

auto enp0s3

iface enp0s3 inet static

address 192.168.0.7

netmask 255.255.255.0

gateway 192.168.0.1

dns-nameservers 8.8.8.8

Il file /etc/hosts apparirà così:

127.0.0.1       localhost
127.0.1.1       ubuntu-mysql-nodo2

192.168.0.5     manager.mysql.cluster
192.168.0.6     nodo1.mysql.cluster
192.168.0.7     nodo2.mysql.cluster

# The following lines are desirable for IPv6 capable hosts
::1     localhost ip6-localhost ip6-loopback
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters

127.0.0.1 localhost

127.0.1.1 ubuntu-mysql-nodo2

192.168.0.5 manager.mysql.cluster

192.168.0.6 nodo1.mysql.cluster

192.168.0.7 nodo2.mysql.cluster

# The following lines are desirable for IPv6 capable hosts

::1 localhost ip6-localhost ip6-loopback

ff02::1 ip6-allnodes

ff02::2 ip6-allrouters

Mentre il file /etc/hostname conterrà una sola riga:

ubuntu-mysql-nodo2

1	ubuntu-mysql-nodo2

A questo punto anche il secondo nodo è pronto e possiamo spegnere la macchina.

4. Installazione del MySQL Cluster Manager

Adesso riavviamo il nostro cluster manager e avviamo l’installazione del software manager:

sudo apt-get install mysql-cluster-community-management-server

1	sudo apt-get install mysql-cluster-community-management-server

Una volta installato andiamo a creare la seguente cartella nella quale metteremo il file di configurazione:

sudo mkdir /var/lib/mysql-cluster

1	sudo mkdir /var/lib/mysql-cluster

Creiamo dentro un file chiamato config.ini:

sudo nano /var/lib/mysql-cluster/config.ini

1	sudo nano /var/lib/mysql-cluster/config.ini

A questo punto procediamo alla configurazione nel modo seguente:

[ndbd default]
# opzioni che interesseranno tutti i nodi
NoOfReplicas=2          # numero di repliche
DataMemory=80M          # quantità di memoria allocata per l'archivazione dei dati
IndexMemory=18M         # quantità di memoria allocata per l'indicizzazione dei dati
ServerPort=2202         # porta di connessione, non è necessario impostarla, la metto qui a titolo di esercizio

[ndb_mgmd]
# configurazione del manager
HostName=manager.mysql.cluster  # oppure ci possiamo mettere l'indirizzo ip, nel nostro caso sarebbe 192.168.0.5
DataDir=/var/lib/mysql-cluster  # cartella che conterrà i file LOG dei nodi

[ndbd]
# opzioni nodo 1
HostName=nodo1.mysql.cluster
NodeId=2
DataDir=/usr/local/mysql/data

[ndbd]
# opzioni nodo 2
HostName=nodo2.mysql.cluster
NodeId=3
DataDir=/usr/local/mysql/data

[mysqld]
#questa è la posizione dove si troverà il daemon del MySQL, il processo in esecuzione insomma
HostName=manager.mysql.cluster

[ndbd default]

# opzioni che interesseranno tutti i nodi

NoOfReplicas=2 # numero di repliche

DataMemory=80M # quantità di memoria allocata per l'archivazione dei dati

IndexMemory=18M # quantità di memoria allocata per l'indicizzazione dei dati

ServerPort=2202 # porta di connessione, non è necessario impostarla, la metto qui a titolo di esercizio

[ndb_mgmd]

# configurazione del manager

HostName=manager.mysql.cluster # oppure ci possiamo mettere l'indirizzo ip, nel nostro caso sarebbe 192.168.0.5

DataDir=/var/lib/mysql-cluster # cartella che conterrà i file LOG dei nodi

[ndbd]

# opzioni nodo 1

HostName=nodo1.mysql.cluster

NodeId=2

DataDir=/usr/local/mysql/data

[ndbd]

# opzioni nodo 2

HostName=nodo2.mysql.cluster

NodeId=3

DataDir=/usr/local/mysql/data

[mysqld]

#questa è la posizione dove si troverà il daemon del MySQL, il processo in esecuzione insomma

HostName=manager.mysql.cluster

Ho inserito i commenti ai singoli parametri nel file stesso in modo da rendere più agevole la consultazione. I parametri in cima non sono di per se necessari, ma li mettiamo a scopo didattico per tenere presente che eventualmente li potremo modificare in base alle nostre esigenze.

Per finire installiamo il mysql-server, dal momento che abbiamo detto che il daemon del MySQL si troverà sulla medesima macchina del menager. Digitiamo:

sudo apt-get install mysql-server

1	sudo apt-get install mysql-server

Fatto.

5. Configurazione dei nodi

Adesso avviamo i nostri due nodi e configuriamoli nella maniera seguente (io qui configurerò il primo nodo, la stessa cosa va fatta sul secondo).

Anzitutto installiamo il programma per ciascun nodo digitando:

sudo apt-get install mysql-cluster-community-data-node

1	sudo apt-get install mysql-cluster-community-data-node

Quindi digitiamo:

sudo nano /etc/mysql/my.cnf

1	sudo nano /etc/mysql/my.cnf

Dentro al file scriviamo:

[mysqld]
ndbcluster

[mysql_cluster]
ndb-connectstring=manager.mysql.cluster

[mysqld]

ndbcluster

[mysql_cluster]

ndb-connectstring=manager.mysql.cluster

In questo modo collegheremo il nodo al cluster, demandando la gestione del servizio al cluster medesimo.

6. Avvio del cluster

Ora che abbiamo configurato sia il manager che gli altri nodi possiamo procedere all’avvio del nostro cluster.

Spostiamoci sul manager e digitiamo:

sudo ndb_mgmd -f /var/lib/mysql-cluster/config.ini

1	sudo ndb_mgmd -f /var/lib/mysql-cluster/config.ini

Questo avvierà il cluster sul manager importando il file di configurazione. Affinché si avvii automaticamente ad ogni riavvio modifichiamo il file di avvio nel seguente modo.

Anzitutto abilitiamo i servizi locali digitando:

sudo systemctl enable rc-local.service

1	sudo systemctl enable rc-local.service

E modifichiamo il file:

sudo nano /etc/rc.local

1	sudo nano /etc/rc.local

Inserendo, prima di exit 0, il precedente comando (questo sarà l’aspetto complessivo del file):

#!/bin/sh -e
#
# rc.local
#
# This script is executed at the end of each multiuser runlevel.
# Make sure that the script will "exit 0" on success or any other
# value on error.
#
# In order to enable or disable this script just change the execution
# bits.
#
# By default this script does nothing.

ndb_mgmd -f /var/lib/mysql-cluster/config.ini
exit 0

#!/bin/sh -e

# rc.local

# This script is executed at the end of each multiuser runlevel.

# Make sure that the script will "exit 0" on success or any other

# value on error.

# In order to enable or disable this script just change the execution

# bits.

# By default this script does nothing.

ndb_mgmd -f /var/lib/mysql-cluster/config.ini

exit 0

Adesso spostiamoci sui singoli nodi e per ciascun nodo digitiamo:

sudo mkdir -p /usr/local/mysql/data

1	sudo mkdir -p /usr/local/mysql/data

In questo modo creeremo la cartella per l’allocazione dei dati necessaria al nodo (con il comando -p diciamo ad mkdir di creare l’intero percorso).

Dopodiché avviamo il nodo digitando:

sudo ndbd

sudo ndbd

Affinché anche tutto ciò parta all’avvio digitiamo:

sudo systemctl enable rc-local.service

1	sudo systemctl enable rc-local.service

E poi ancora:

sudo nano /etc/rc.local

1	sudo nano /etc/rc.local

Modifichiamo il file affinché appaia in questo modo:

#!/bin/sh -e
#
# rc.local
#
# This script is executed at the end of each multiuser runlevel.
# Make sure that the script will "exit 0" on success or any other
# value on error.
#
# In order to enable or disable this script just change the execution
# bits.
#
# By default this script does nothing.

ndbd
exit 0

#!/bin/sh -e

# rc.local

# This script is executed at the end of each multiuser runlevel.

# Make sure that the script will "exit 0" on success or any other

# value on error.

# In order to enable or disable this script just change the execution

# bits.

# By default this script does nothing.

ndbd

exit 0

Riavviamo il tutto.

7. Verifichiamo il funzionamento del cluster

A questo punto possiamo verificare il funzionamento del cluster spostandoci sul nostro manager e digitando:

ndb_mgm

ndb_mgm

Entrando nel terminale del ndb_ngm digitiamo:

SHOW

SHOW

Quello che dovremmo vedere sarà qualcosa di simile a questo:

Se tutto è andato bene questo sarà il risultato. Qualora uno dei nodi non fosse raggiungibile, oppure non fosse possibile collegarsi al daemon ci verrebbe segnalato esplicitamente.

Per uscire dal manager è sufficiente digitare exit e premere invio.

Come ultima operazione proviamo a creare una tabella sul nostro cluster.

8. Creiamo una tabella sul cluster

Accediamo anzitutto al mysql digitando nel manager:

mysql -u root -p

1	mysql -u root -p

Questo ci permetterà di accedere con l’utente root del database e ci verrà chiesta la password a schermo.

Anche qui possiamo fare una seconda verifica di quello che ci è già noto:

Infatti se tutto è andato bene ci verrà dato il benvenuto con la versione del MySQL Cluster Community Server.

A questo punto creiamo il nostro database di prova digitando:

CREATE DATABASE cluster_test;

1	CREATE DATABASE cluster_test;

Inseriamo nel database cluster_test la nostra tabella di prova:

USE cluster_test;
CREATE TABLE cluster_test (nome VARCHAR(20), cognome VARCHAR(20)) ENGINE=ndbcluster;

1 2	USE cluster_test; CREATE TABLE cluster_test (nome VARCHAR(20), cognome VARCHAR(20)) ENGINE=ndbcluster;

ATTENZIONE! E’ molto importante che l’engine sia impostato su ndbcluster, affinché la tabella lavori e sia distribuita sul cluster.

Inseriamo dei valori di prova:

INSERT INTO cluster_test (nome,cognome) VALUES('mario','rossi');

1	INSERT INTO cluster_test (nome,cognome) VALUES('mario','rossi');

Adesso proviamo ad interrogare la tabella digitando:

SELECT * FROM cluster_test;

1	SELECT * FROM cluster_test;

Il risultato dovrebbe essere questo:

Fatto, abbiamo il nostro cluster perfettamente funzionante e pronto all’uso.

[ubuntu] Installare Google PageSpeed Insights su server Apache

Su PageSpeed Insights Google mette a disposizione un utile strumento per verificare la velocità del proprio sito web, assieme a diversi parametri di ottimizzazione. Inutile dire che si tratta anzitutto di uno strumento di panoramica, che ci consente di verificare determinate caratteristiche tecniche del sito, che non devono essere per forza tutte soddisfatte (a volte è semplicemente impossibile, come quando segnala tra i javascript da ottimizzare quelli di Google Analytics stesso).

Vediamo come installarlo sul nostro server (come al solito nell’esempio utilizzo un Ubuntu Server 16.04).

Anzitutto apriamo il terminale e scarichiamo il file di installazione:

wget https://dl-ssl.google.com/dl/linux/direct/mod-pagespeed-stable_current_amd64.deb

1	wget https://dl-ssl.google.com/dl/linux/direct/mod-pagespeed-stable_current_amd64.deb

Questo comando scaricherà un file mod-pagespeed-stable_current_amd64.deb nella cartella che abbiamo selezionato.

Installiamo il pacchetto con:

sudo dpkg -i mod-pagespeed-*.deb

1	sudo dpkg -i mod-pagespeed-*.deb

A questo punto eseguiamo il controllo di tutte le dipendenze dei pacchetti installati con:

apt-get -f install

1	apt-get -f install

Se tutto è andato a dovere riavviamo apache.

sudo service apache2 restart

1	sudo service apache2 restart

Per attivare PageSpeed sarà sufficiente aggiungere, nella configurazione del virtual host, oppure in un file .htaccess l’istruzione:

ModPagespeed on

1	ModPagespeed on

Maggiori informazioni sui parametri di configurazione si trovano sul sito ufficiale.

[windows server] Spostare la cartella dei file di aggiornamento di WSUS

Obiettivo: spostare la cartella di archiviazione degli aggiornamenti di WSUS in una nuova posizione

Tipicamente i file di aggiornamento gestiti dal server WSUS si trovano nella posizione C:\Comsys WSUS.

Per cambiare tale cartella è sufficiente trovare il programma wsusutil.exe ed effettuare lo spostamento nel modo in cui segue:

WIN+R per aprire ESEGUI e digitare CMD per aprire il prompt dei comandi
Spostarsi nella cartella di wsusutil.exe tipicamente dovrebbe trovarsi in C:\Program Files\Update Services\Tools
Digitare quindi CD C:\Program Files\Update Services\Tools
Creare quindi la nuova cartella di destinazione dei file di aggiornamento, per esempio su un disco F creando una cartella F:\WSUS
Digitare quindi wsusutil.exe movecontent F:\WSUS F:\move.log
Questo comando avvierà lo spostamento dei file dalla posizione attuale a quella nuova

[c#] Creare una classe base generica con tipo aperto

Immaginiamo di voler creare in C# una classe generica che possa gestire dei tipi aperti, un po’ come succede per le liste. Per esercizio vogliamo creare una classe chiamata Materie che accetti diverse classi come tipo di materia gestito, per esempio una classe Matematica. L’oggetto che vogliamo creare sarà di questo tipo:

Materie<Matematica> m = new Materie<Matematica>();

1	Materie<Matematica> m = new Materie<Matematica>();

A questo punto vogliamo avere un metodo per aggiungere dei voti per gli studenti della data materia, nel modo seguente:

m.addVoto(new Matematica("Mario",10));

1	m.addVoto(new Matematica("Mario",10));

E infine vogliamo poter estrarre, dal nostro oggetto m, una media dei voti, passandogli una funzione che si occuperà di definire il meccanismo di estrazione del voto dall’oggetto generico sul tipo aperto.

Per cui creiamo anzitutto la classe Matematica:

class Matematica
{
    public string corso;
    public int voto;

    public Matematica(string c, int v)
    {
        corso = c;
        voto = v;
    }
}

class Matematica

{

public string corso;

public int voto;

public Matematica(string c, int v)

{

corso = c;

voto = v;

}

E poi creiamo la classe Materie:

class Materie<T>
{
    List<T> voti = new List<T>();

    public void addVoto(T voto)
    {
        voti.Add(voto);
    }

    public double getMediaVoti(Func<T,double> funzioneMedia)
    {
        double media = 0;

        if( voti.Count > 0 )
        {

            foreach (T voto in voti)
            {
                media += funzioneMedia(voto);
            }

            media /= voti.Count;

        }

        return media;
    }
}

class Materie<T>

{

List<T> voti = new List<T>();

public void addVoto(T voto)

{

voti.Add(voto);

}

public double getMediaVoti(Func<T,double> funzioneMedia)

{

double media = 0;

if( voti.Count > 0 )

{

foreach (T voto in voti)

{

media += funzioneMedia(voto);

}

media /= voti.Count;

}

return media;

}

Faccio notare che il metodo getMediaVoti accetta come argomento un metodo generico che prenda che abbia come argomento il tipo aperto T e come restituzione un double (supponiamo che volendo calcolare dei voti essi dovranno essere comunque ricondotti a double).

Uniamo il tutto nel modo seguente:

class Program
{
    static void Main(string[] args)
    {
        Materie<Matematica> m = new Materie<Matematica>();

        m.addVoto(new Matematica("Mario",10));
        m.addVoto(new Matematica("Luigi", 8));
        m.addVoto(new Matematica("Luisa", 9));

        double media = m.getMediaVoti(calcolaMedia);

        Console.WriteLine("media {0}",media);
        Console.ReadLine();

    }

    static double calcolaMedia(Matematica m)
    {
        return m.voto;
    }
}

class Program

{

static void Main(string[] args)

{

Materie<Matematica> m = new Materie<Matematica>();

m.addVoto(new Matematica("Mario",10));

m.addVoto(new Matematica("Luigi", 8));

m.addVoto(new Matematica("Luisa", 9));

double media = m.getMediaVoti(calcolaMedia);

Console.WriteLine("media {0}",media);

Console.ReadLine();

}

static double calcolaMedia(Matematica m)

{

return m.voto;

}

In questo caso l’oggetto m si comporta in modo analogo ad una lista, permettendo l’aggiunta di n elementi del tipo T, nel nostro caso Matematica. Dal momento che noi non conosciamo i specifici parametri e metodi di T chiediamo, per calcolare la media, che ci venga passata una funzione a cui sarà delegata l’estrazione dei voti come double dall’oggetto aperto di tipo T, tale metodo è calcolaMedia che accetta come argomento un oggetto di tipo Matematica.

[python] Radiazione di Hawking e tempo che impiega un buco nero ad evaporare

In memoria di Stephen Hawking propongo un modesto esercizio in Python per calcolare il tempo di evaporazione di un buco nero, secondo la radiazione di Hawking.

In questo caso utilizzeremo le librerie scipy e numpy di Python.

Il mio esempio sarà fatto sotto Windows. Anzitutto installiamo quindi le librerie necessarie utilizzando pip, nella PowerShell digitiamo:

python -m pip install --user numpy scipy matplotlib ipython jupyter pandas sympy nose

1	python -m pip install --user numpy scipy matplotlib ipython jupyter pandas sympy nose

Una volta fatto avviamo un nuovo progetto in python e andiamo anzitutto a calcolare la suddetta formula. L’equazione di evaporazione di un buco nero, che si trovasse in una condizione ideale (ovvero nessuna aggiunta di energia, quindi ipoteticamente in un universo completamente vuoto e senza radiazione di fondo) è la seguente:

$t_{ev} = \frac{5120 \pi G^2 M_0^3}{\hbar c^4}$

Per scriverla in Python digitiamo:

from scipy import constants

M0 = 1.98892 * 10**30
Tev = (5120 * constants.pi * constants.G ** 2 * M0 ** 3 )/( constants.hbar * constants.c ** 4 )

print( Tev )

from scipy import constants

M0 = 1.98892 * 10**30

Tev = (5120 * constants.pi * constants.G ** 2 * M0 ** 3 )/( constants.hbar * constants.c ** 4 )

print( Tev )

Faccio notare che da scipy importiamo le costanti fisiche e matematiche che possiamo utilizzare secondo la seguente tabella.

M0 è l’ipotetica massa iniziale di un buco nero di massa solare, nello specifico di $1,98892 * 10^{30} kg$ .

Il risultato dovrebbe essere:

6.617525584671073e+74

1	6.617525584671073e+74

Il risultato è in secondi, possiamo convertirlo in miliardi di anni digitando:

print( Tev / (3600*24*365 * 10**9) )

1	print( Tev / (360024365 * 10**9) )

Il risultato è qualcosa come $2 * 10^{58}$ miliardi di anni, molto più dell’attuale vita dell’universo stimata attorno ai 13 miliardi di anni.

Adesso proviamo ad inserire l’equazione in un grafico, dove vogliamo confrontare vari tipi di buco nero in base alla massa ed il tempo di evaporazione.

Per farlo anzitutto convertiamo la nostra precedente equazione in una funzione digitando:

def HawkingTev(Mass):
    Tev = (5120 * constants.pi * constants.G ** 2 * Mass ** 3 )/( constants.hbar * constants.c ** 4 )
    return Tev

def HawkingTev(Mass):

Tev = (5120 * constants.pi * constants.G ** 2 * Mass ** 3 )/( constants.hbar * constants.c ** 4 )

return Tev

Ricordiamoci che il risultato della funzione è in secondi. A questo punto prepariamo i valori del nostro asse x, che saranno le masse di diversi buchi neri. Prendiamo 100 valori tra 0 e 10³⁰.

X = np.linspace(0, 10**30,100, endpoint=True)

1	X = np.linspace(0, 10**30,100, endpoint=True)

Sull’asse Y calcoliamo i corrispondenti valori:

Y = HawkingTev(X)

1	Y = HawkingTev(X)

Adesso impacchettiamo tutto in un grafico generato con matplotlib.

from scipy import constants
import numpy as np
import matplotlib.pyplot as plt

def HawkingTev(Mass):
    Tev = (5120 * constants.pi * constants.G ** 2 * Mass ** 3 )/( constants.hbar * constants.c ** 4 )
    return Tev

X = np.linspace(0, 10**30,100, endpoint=True)
Y = HawkingTev(X)

plt.plot(X, Y)
plt.title('Tempo evaporazione buco nero')
plt.ylabel('s')
plt.xlabel('kg')

plt.show()

from scipy import constants

import numpy as np

import matplotlib.pyplot as plt

def HawkingTev(Mass):

Tev = (5120 * constants.pi * constants.G ** 2 * Mass ** 3 )/( constants.hbar * constants.c ** 4 )

return Tev

X = np.linspace(0, 10**30,100, endpoint=True)

Y = HawkingTev(X)

plt.plot(X, Y)

plt.title('Tempo evaporazione buco nero')

plt.ylabel('s')

plt.xlabel('kg')

plt.show()

Il risultato sarà qualcosa di simile a questo:

[c#] Esempio di programma elementare da console

Oggi propongo un piccolo esercizio in C# per chiunque volesse avvicinarsi a questo fantastico linguaggio di programmazione.

Obiettivo: realizzare un programma elementare da console che permetta di inserire degli atleti, con nomi e punteggi, visualizzarli a monitor, rimuoverli e stampare la media dei loro punteggi.

Per programmare con C# è sufficiente disporre di Visual Studio 2017. (la Community edition sarà più che sufficiente, basterà scegliere C# tra i pacchetti da installare)

Una volta installato avviamo un nuovo progetto andando su File ⇒ Nuovo ⇒ Progetto…

A questo punto comparirà una finestra che ci permetterà di scegliere che tipo di progetto vogliamo realizzare. Nel nostro caso applicazione per Console.

In fondo diamo un nome a piacere al nostro progetto, io lo chiamerà EsempioAtleti, e prendiamo nota della posizione dove verrà salvato (tipicamente nella cartella che abbiamo scelto, in fase di installazione, come cartella predefinita per i progetti).

Se abbiamo fatto tutto correttamente dovremmo ritrovarci con aperto il file Program.cs con dentro un contenuto simile a questo:

namespace EsempioAtleti
{
    class Program
    {
        static void Main(string[] args)
        {
           
            
        }

    }
}

namespace EsempioAtleti

{

class Program

{

static void Main(string[] args)

{

}

Il metodo Main è quello che verrà eseguito automaticamente all’avvio dell’intero programma. Per fare una primissima prova e prendere leggermente confidenza con il programma possiamo digitare quanto segue:

namespace EsempioAtleti
{
    class Program
    {
        static void Main(string[] args)
        {
           
            Console.WriteLine("Ciao, Mondo!");
            Console.ReadLine();

        }

    }
}

namespace EsempioAtleti

{

class Program

{

static void Main(string[] args)

{

Console.WriteLine("Ciao, Mondo!");

Console.ReadLine();

}

Avviamo il programma premendo F5 (oppure il tasto avvia con la freccia verde). Quello che vedremo sarà un prompt dei comandi con scritto “Ciao, Mondo!” ed il cursore in attesa di input. Se premiamo invio il prompt si chiuderà. Questo lo abbiamo ottenuto con la riga di codice Console.ReadLine(), senza la quale il programma terminerebbe immediatamente. In questo modo invece si mette in attesa di un nostro input, ricevuto il quale chiude tutto quanto.

Adesso cominciamo a creare un paio di classi, necessarie al nostro progetto. Per aggiungere una nuova classe è sufficiente cliccare col destro sul progetto nella finestra di esplorazione, selezionare Aggiungi ⇒ Classe.

Creeremo due classi, chiamate rispettivamente Atleti ed Atleta. La classe Atleti gestirà un gruppo di oggetti singoli di tipo Atleta. Vediamo anzitutto come sarà composta la classe Atleta:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace EsempioAtleti
{
    class Atleta
    {
        private String nome;
        private Int32 punteggio;

        public String Nome
        {
            set
            {
                nome = value;
            }
            get
            {
                return nome;
            }
        }

        public Int32 Punti
        {
            set
            {
                punteggio = value;
            }
            get
            {
                return punteggio;
            }
        }

        public Atleta(String n, Int32 p)
        {
            Nome = n;
            Punti = p;
        }

        public Atleta()
        {

        }
    }
}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace EsempioAtleti

{

class Atleta

{

private String nome;

private Int32 punteggio;

public String Nome

{

set

{

nome = value;

}

get

{

return nome;

}

public Int32 Punti

{

set

{

punteggio = value;

}

get

{

return punteggio;

}

public Atleta(String n, Int32 p)

{

Nome = n;

Punti = p;

}

public Atleta()

{

}

Notiamo come la classe Atleta possieda due proprietà, chiamate anche variabili, ovvero nome e punteggio, entrambe private. Essendo private non sono accessibili dall’esterno dell’oggetto, ma solo internamente. Perciò creiamo anche dei getter e setter, ovvero dei metodi che ci permettano di modificare ed interrogare le suddette proprietà; questi “metodi” appaiono come delle proprietà a loro volta, secondo lo stile di C#, e nel nostro caso sono state chiamate Nome e Punti. Faccio notare come ho chiamato Nome con la maiuscola, rispetto alla proprietà privata nome, ma nell’assegnazione di tale nomenclatura non c’è niente di speciale. Tant’è che a punteggio ho associato Punti. Diciamo che l’uso comune prevederebbe di chiamare il getter/setter Punteggio, ma non è obbligatorio.

Abbiamo inoltre creato un costruttore che accetta una stringa ed un intero che assegna a Nome e Punti, il che ci permetterà di creare degli oggetti di tipo Atleta senza dover per forza assegnare separatamente le due proprietà.

A questo punto creiamo una classe chiamata Atleti, che conterrà una lista di oggetto di tipo Atleta ed un paio di metodi per gestirli.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace EsempioAtleti
{
    class Atleti
    {
        public delegate void NuovoAtleta(object sender, object param);
        public event NuovoAtleta onNuovoAtleta;

        List<Atleta> atleti = new List<Atleta>();

        public Atleti()
        {

        }

        private void raiseNuovoAtleta()
        {
            object param = new object();
            this.onNuovoAtleta(this, param);
        }

        public void addAtleta(Atleta a)
        {
            atleti.Add(a);
            raiseNuovoAtleta();
        }

        public List<Atleta> getAtleti()
        {
            return atleti;
        }

        public double getMedia()
        {
            double media = 0;
            if (atleti.Count > 0)
            {
                foreach (Atleta a in atleti)
                {
                    media += a.Punti;
                }
                media /= atleti.Count;
            }
            return media;
        }

        public void removeAtleta(int pos)
        {
            atleti.Remove(atleti[pos]);
        }

    }
}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace EsempioAtleti

{

class Atleti

{

public delegate void NuovoAtleta(object sender, object param);

public event NuovoAtleta onNuovoAtleta;

List<Atleta> atleti = new List<Atleta>();

public Atleti()

{

}

private void raiseNuovoAtleta()

{

object param = new object();

this.onNuovoAtleta(this, param);

}

public void addAtleta(Atleta a)

{

atleti.Add(a);

raiseNuovoAtleta();

}

public List<Atleta> getAtleti()

{

return atleti;

}

public double getMedia()

{

double media = 0;

if (atleti.Count > 0)

{

foreach (Atleta a in atleti)

{

media += a.Punti;

}

media /= atleti.Count;

}

return media;

}

public void removeAtleta(int pos)

{

atleti.Remove(atleti[pos]);

}

Vediamo i punti salienti di questa seconda classe. Anzitutto abbiamo creato una lista di oggetti di tipo Atleta:

List<Atleta> atleti = new List<Atleta>();

1	List<Atleta> atleti = new List<Atleta>();

Questa è una proprietà privata della classe, quindi per poter aggiungere nuovi oggetti alla lista creiamo un metodo apposito:

public void addAtleta(Atleta a)
{
    atleti.Add(a);
    raiseNuovoAtleta();
}

public void addAtleta(Atleta a)

{

atleti.Add(a);

raiseNuovoAtleta();

}

Il metodo accetta un argomento di tipo Atleta, chiamato a. Poi esegue il metodo .Add() sulla lista di oggetti di tipo Atleta, aggiungendo in fondo alla lista l’ultimo oggetto. Inoltre chiama anche un “evento” personalizzato, nello specifico il metodo raiseNuovoAtleta();

Questo metodo fa parte della seguente definizione:

public delegate void NuovoAtleta(object sender, object param);
public event NuovoAtleta onNuovoAtleta;

private void raiseNuovoAtleta()
{
    object param = new object();
    this.onNuovoAtleta(this, param);
}

public delegate void NuovoAtleta(object sender, object param);

public event NuovoAtleta onNuovoAtleta;

private void raiseNuovoAtleta()

{

object param = new object();

this.onNuovoAtleta(this, param);

}

Con questo piccolo trucchetto creiamo un evento personalizzato sulla nostra classe, cioè diamo la possibilità di aggiungere dei metodi all’oggetto, una volta creato, che saranno richiamati all’accadere dell’evento specifico.

Cerchiamo di capire meglio questa cosa.

Immaginiamo di voler aggiungere delle funzioni specifiche ad ogni volta che viene aggiunto un nuovo atleta. L’oggetto creato da Atleti potrebbe essere il seguente:

static Atleti a = new Atleti();

1	static Atleti a = new Atleti();

Adesso immaginiamo di voler far sì che, ogni volta che viene aggiunto un nuovo atleta, con il seguente metodo:

Atleta tmp = new Atleta("Mario Rossi",10);
a.addAtleta(tmp);

1 2	Atleta tmp = new Atleta("Mario Rossi",10); a.addAtleta(tmp);

Venga anche richiamato un metodo personalizzato, creato fuori dalla classe, che esegua delle operazioni. Nel nostro caso manda un banale messaggio a schermo:

private static void atletaAggiunto(object sender, object param)
{
    Console.WriteLine("Evento atleta aggiunto!");
}

private static void atletaAggiunto(object sender, object param)

{

Console.WriteLine("Evento atleta aggiunto!");

}

Faccio notare che gli argomenti di questo metodo personalizzato sono i medesimi, per tipo, del metodo delegato creato nella classe Atleti:

public delegate void NuovoAtleta(object sender, object param);

1	public delegate void NuovoAtleta(object sender, object param);

Per aggiungere tale metodo a quelli dell’evento creato sarà sufficiente scrivere:

a.onNuovoAtleta += atletaAggiunto;

1	a.onNuovoAtleta += atletaAggiunto;

Il metodo atletaAggiunto verrà richiamato dall’oggetto, assieme ad ogni altro eventuale metodo aggiunto, dal metodo raiseNuovoAtleta.

Finalizziamo il tutto costruendo la parte del Main del nostro programmino:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace EsempioAtleti
{
    class Program
    {
        static Atleti a = new Atleti();

        static void Main(string[] args)
        {
           
            a.onNuovoAtleta += atletaAggiunto;

            String scelta;

            while (true)
            {

                Console.Write("-- MENU OPZIONI --\n1.Aggiungi\n2.Rimuovi\n3.Stampa\n4.Media\n0.Esci\n> ");
                scelta = Console.ReadLine();

                if (scelta == "0") break;

                if (scelta == "1") aggiungi();

                if (scelta == "2") rimuovi();

                if (scelta == "3") stampa();

                if (scelta == "4") media();

            }

        }

        static void aggiungi()
        {
            Atleta tmp = new Atleta();

            Console.WriteLine("Aggiungi atleta");

            Console.Write("Nome: ");
            tmp.Nome = Console.ReadLine();

            Console.Write("Punteggio: ");
            tmp.Punti = Convert.ToInt32(Console.ReadLine());

            a.addAtleta(tmp);
        }

        static void rimuovi()
        {
            Console.WriteLine("Rimuovi atleta");
            Console.Write("ID: ");
            a.removeAtleta(Convert.ToInt32(Console.ReadLine()));
        }

        static void stampa()
        {
            Console.WriteLine("Elenco atleti");

            int id = 0;
            foreach (Atleta t in a.getAtleti())
            {
                Console.WriteLine("{0} {1} {2}",id++,t.Nome,t.Punti);
            }
        }

        static void media()
        {
            Console.WriteLine("Il punteggio medio è: {0}",a.getMedia());
        }

        private static void atletaAggiunto(object sender, object param)
        {
            Console.WriteLine("Evento atleta aggiunto!");
        }
    }
}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace EsempioAtleti

{

class Program

{

static Atleti a = new Atleti();

static void Main(string[] args)

{

a.onNuovoAtleta += atletaAggiunto;

String scelta;

while (true)

{

Console.Write("-- MENU OPZIONI --\n1.Aggiungi\n2.Rimuovi\n3.Stampa\n4.Media\n0.Esci\n> ");

scelta = Console.ReadLine();

if (scelta == "0") break;

if (scelta == "1") aggiungi();

if (scelta == "2") rimuovi();

if (scelta == "3") stampa();

if (scelta == "4") media();

}

static void aggiungi()

{

Atleta tmp = new Atleta();

Console.WriteLine("Aggiungi atleta");

Console.Write("Nome: ");

tmp.Nome = Console.ReadLine();

Console.Write("Punteggio: ");

tmp.Punti = Convert.ToInt32(Console.ReadLine());

a.addAtleta(tmp);

}

static void rimuovi()

{

Console.WriteLine("Rimuovi atleta");

Console.Write("ID: ");

a.removeAtleta(Convert.ToInt32(Console.ReadLine()));

}

static void stampa()

{

Console.WriteLine("Elenco atleti");

int id = 0;

foreach (Atleta t in a.getAtleti())

{

Console.WriteLine("{0} {1} {2}",id++,t.Nome,t.Punti);

}

static void media()

{

Console.WriteLine("Il punteggio medio è: {0}",a.getMedia());

}

private static void atletaAggiunto(object sender, object param)

{

Console.WriteLine("Evento atleta aggiunto!");

}

Una volta lanciato il risultato a video dovrebbe essere il seguente.

Da qui è possibile scaricare il progetto in visual studio: EsempioAtleti

Hash SHA256: BE81F3861195A817919DF4EF6938FC2DAB89D0E64A989BA21F41E1A45BB23841

[vba] Classe per interrogare in SQL un foglio excel

Obiettivo: creare una classe per poter interrogare tramite query SQL un foglio excel, leggendo e scrivendo i dati come se lavorassimo con tabelle SQL

Questo esercizio riprende il punto direttamente da questo precedente: Interrogare foglio di Excel con SQL in VBA

Dopo aver visto come poter interrogare con query SQL un foglio excel, vediamo come creare una classe ad hoc che ci permetta di leggere e scrivere i dati mediante query SQL. Per farlo anzitutto aggiungiamo una nuova classe:

Premendo ALT+F11 apriamo l’editor Visual Basic, ci posizioniamo su un qualunque punto del progetto a sinistra e clicchiamo col destro (per esempio su Form), poi scegliamo Inserisci ⇒ Modulo classe. A questo punto verrà creata una nuova classe. Per rinominarla è sufficiente selezionarla e poi spostarsi nel riquadro delle proprietà.

A questo punto incolliamo dentro la classe appena creata (tenendo presente poi il nome scelto) il seguente codice:

' funzione in input per il database, restituisce un vettore variant di dimensione n x m, dove
' n è il numero di righe lette e m il numero di colonne per riga
Public Function dbout(ByVal query As String) As Variant

    Dim conn As ADODB.Connection
    Dim rs As ADODB.Recordset
    Dim strFileName As String
    Dim ConnectionString As String
    Dim pos As Integer
    
    ' creiamo il vettore con il risultato
    Dim result() As Variant
    
    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
        
    rs.Open query, conn
    
    ' adesso dobbiamo anzitutto contare la dimensione del risultato
    righe = 0
    colonne = 0
    
    If Not rs.EOF Then
        Do
            righe = righe + 1
            colonne = rs.Fields.Count
            rs.MoveNext
        Loop Until rs.EOF
    End If
    
    ' riposizioniamo il recordset alla partenza
    rs.MoveFirst
    
    ' ridimensioniamo il vettore risultato sulle righe e colonne appena contate
    ReDim result(righe, colonne)
    
    ' leggiamo tutti i dati ed inseriamoli nel vettore
    righe = 0
    If Not rs.EOF Then
        Do
            For j = 0 To rs.Fields.Count - 1
                result(righe, j) = rs(j)
            Next j
            righe = righe + 1
            rs.MoveNext
        Loop Until rs.EOF
    End If
    
    rs.Close
    
    conn.Close
    
    ' restituiamo il vettore
    dbout = result

End Function

' questo metodo accetta in input la query e la esegue sul foglio prescelto
Public Function dbin(ByVal query 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;"";"
    
    Set conn = CreateObject("ADODB.Connection")
    
    conn.Open ConnectionString
    
    ' eseguiamo la query
    conn.Execute query
    
    conn.Close

End Function

' funzione in input per il database, restituisce un vettore variant di dimensione n x m, dove

' n è il numero di righe lette e m il numero di colonne per riga

Public Function dbout(ByVal query As String) As Variant

Dim conn As ADODB.Connection

Dim rs As ADODB.Recordset

Dim strFileName As String

Dim ConnectionString As String

Dim pos As Integer

' creiamo il vettore con il risultato

Dim result() As Variant

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

rs.Open query, conn

' adesso dobbiamo anzitutto contare la dimensione del risultato

righe = 0

colonne = 0

If Not rs.EOF Then

righe = righe + 1

colonne = rs.Fields.Count

rs.MoveNext

Loop Until rs.EOF

End If

' riposizioniamo il recordset alla partenza

rs.MoveFirst

' ridimensioniamo il vettore risultato sulle righe e colonne appena contate

ReDim result(righe, colonne)

' leggiamo tutti i dati ed inseriamoli nel vettore

righe = 0

If Not rs.EOF Then

For j = 0 To rs.Fields.Count - 1

result(righe, j) = rs(j)

Next j

righe = righe + 1

rs.MoveNext

Loop Until rs.EOF

End If

rs.Close

conn.Close

' restituiamo il vettore

dbout = result

End Function

' questo metodo accetta in input la query e la esegue sul foglio prescelto

Public Function dbin(ByVal query 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;"";"

Set conn = CreateObject("ADODB.Connection")

conn.Open ConnectionString

' eseguiamo la query

conn.Execute query

conn.Close

End Function

Faccio notare come nel metodo dbout dobbiamo fare un’operazione un po’ superflua in apparenza, ovvero contare prima le righe e le colonne, per poi ridimensionare il vettore result. Questa operazione è necessaria perché ReDim, in VBA, non permette di ridimensionare l’intera matrice (vettore di vettori), ma solo l’ultima dimensione. Quindi, per esempio, result(4,10) potrebbe diventare result(4,20), ma non result(5,10) oppure result(5,20). Un’alternativa sarebbe quella di creare una funzione che trasponga il vettore e lo modifichi, ritrasponendolo di nuovo, ma dal punto di vista del calcolo credo sarebbe molto più oneroso che fare così.

Fatto questo potremo utilizzare la nostra nuova classe nella maniera seguente.

' inserimento
Dim query As String
query = "INSERT INTO [DATI$] (ID,Nome,Città) Values (1,'Mario','Palermo')"
Dim db As New DbSQL
db.dbin query

' lettura
query = "SELECT * FROM [DATI$A:C]"
Dim db As New DbSQL
Dim righe As Variant
righe = db.dbout(query)
For i = 0 To UBound(righe, 1) - 1
    Debuig.Print righe(i, 1) ' 1 = prima colonna, 2 = seconda colonna, ecc.
Next i

' inserimento

Dim query As String

query = "INSERT INTO [DATI$] (ID,Nome,Città) Values (1,'Mario','Palermo')"

Dim db As New DbSQL

db.dbin query

' lettura

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

Dim db As New DbSQL

Dim righe As Variant

righe = db.dbout(query)

For i = 0 To UBound(righe, 1) - 1

Debuig.Print righe(i, 1) ' 1 = prima colonna, 2 = seconda colonna, ecc.

Next i

Una volta creata la classe può essere esportata, oppure importata nel modo seguente:

Per chi volesse è possibile scaricare la classe già pronta cliccando qui: DbSQL.zip

Hash MD5: A2A18A42BB11AEA86DF1AB4F547B4414

La classe è stata testata su Excel 2016.

[bash] Disegnare fiocco di neve su terminale

Approfittando della giornata innevata e di un po’ di relax ecco un piccolo esercizio in bash per “disegnare” su terminale utilizzando semplicemente spazi e cancelletti (#).

Anzitutto creiamo una serie di funzioni che ci consentano di disegnare come se si stesse lavorando su un piano cartesiano. A tale proposito cerchiamo di disegnare una parabola con la seguente funzione:

$y=x^2-5$

Prima di proseguire installiamo il basic calculator, che ci permetterà di effettuare calcoli matematici elementari in bash (non è indispensabile, né l’unico modo, ma per quello che vogliamo fare dovrebbe essere sufficiente):

sudo apt-get install bc

1	sudo apt-get install bc

Una volta installato creiamo un file parabola.sh

sudo nano parabola.sh

1	sudo nano parabola.sh

Ed inseriamo dentro il seguente codice:

#!/bin/bash
# puliamo il terminale
clear

# stabiliamo il centro degli assi cartesiani
Cx=30
Cy=30

# disegna in posizione x, y accetta due parametri
disegna() {

        # moltiplichiamo la x per 2 per compensare la dimensione 
        # dei font del terminale
        X=$(($Cx*2+$1*2))
        Y=$(($Cy-$2))
        Xmax=$(($Cx*4))
        Ymax=$(($Cy*2))
        # stampiamo a video nella posizione x, y 
        # un carattere asterisco * se si trova entro i limiti del grafico
        if [ $X -ge 0 ] && [ $X -le $Xmax ] && [ $Y -ge 0 ] && [ $Y -le $Ymax ]; then
                echo -ne "\e[${Y};${X}H${3}"
        fi
}
echo
echo
echo

# disegniamo per primo l'asse y, in modo che eventuali punti
# sovrascrivano i simboli dell'asse
for((y=-$Cy; y<$Cy; y++)); do
        disegna 0 $y "."
done

# percorriamo adesso tutti i valori interi di x
for((x=-$Cx; x<$Cx; x++)); do
        dx=$(($x))

        #calcoliamo y = x*x - 5
        dy=$(($x*$x-5))

        # già che ci siamo disegniamo l'asse x
        disegna $dx 0 "."

        # disegniamo la funzione
        disegna $dx $dy "#"
done

# aggiungiamo degli spazi alla fine
for((i=0; i<$Cy; i++)); do
        echo
done

#!/bin/bash

# puliamo il terminale

clear

# stabiliamo il centro degli assi cartesiani

Cx=30

Cy=30

# disegna in posizione x, y accetta due parametri

disegna() {

# moltiplichiamo la x per 2 per compensare la dimensione

# dei font del terminale

X=$(($Cx*2+$1*2))

Y=$(($Cy-$2))

Xmax=$(($Cx*4))

Ymax=$(($Cy*2))

# stampiamo a video nella posizione x, y

# un carattere asterisco * se si trova entro i limiti del grafico

if [ $X -ge 0 ] && [ $X -le $Xmax ] && [ $Y -ge 0 ] && [ $Y -le $Ymax ]; then

echo -ne "\e[${Y};${X}H${3}"

}

echo

# disegniamo per primo l'asse y, in modo che eventuali punti

# sovrascrivano i simboli dell'asse

for((y=-$Cy; y<$Cy; y++)); do

disegna 0 $y "."

done

# percorriamo adesso tutti i valori interi di x

for((x=-$Cx; x<$Cx; x++)); do

dx=$(($x))

#calcoliamo y = x*x - 5

dy=$(($x*$x-5))

# già che ci siamo disegniamo l'asse x

disegna $dx 0 "."

# disegniamo la funzione

disegna $dx $dy "#"

done

# aggiungiamo degli spazi alla fine

for((i=0; i<$Cy; i++)); do

echo

done

Ricordiamoci di rendere lo script eseguibile digitando:

sudo chmod a+x parabola.sh

1	sudo chmod a+x parabola.sh

Ed eseguiamolo:

./parabola.sh

1	./parabola.sh

Il risultato di questa operazione dovrebbe dare qualcosa di simile a questo:

Faccio notare che la funzione disegna accetta come terzo parametro il tipo di carattere che vorremo utilizzare.

Adesso che abbiamo verificato che il disegno sul piano cartesiano funziona possiamo scrivere la serie di istruzioni necessarie a generare il nostro simpatico fiocco di neve. Le funzioni matematiche necessarie le ho prese da qui: Snowflake Math.

Inutile dire che si potrebbero usare moltissime altre funzioni, oppure divertirci con un calcolo frattale. Notiamo però che il disegno accetterà solo valore naturali interi, quindi il risultato sarà comunque un po’ impreciso. Infatti non possiamo aumentare la densità di caratteri sul terminale, potendo così apprezzare altri dettagli. Lo script sarà dunque questo:

#!/bin/bash

clear

# stabiliamo il centro degli assi cartesiani per il
# disegno della funzione neve
Cx=30
Cy=30

# disegna in posizione x, y
# accetta due parametri
disegna() {

	# moltiplichiamo la x per 2 per compensare
	# la dimensione dei font del terminale
	X=$(($Cx*2+$1*2))
	Y=$(($Cy-$2))
	Xmax=$(($Cx*4))
	Ymax=$(($Cy*2))

	# stampiamo a video nella posizione x, y
	# un carattere asterisco * se si trova entro
	# i limiti del grafico
	if [ $X -ge 0 ] && [ $X -le $Xmax ] && [ $Y -ge 0 ] && [ $Y -le $Ymax ]; then
		echo -ne "\e[${Y};${X}H#"
	fi

}

# equazione, 	x, 	min, 	max
# 1		2	3	4
fiocco() {

	if [ $2 -ge $3 ] && [ $2 -le $4 ]; then
		dy=0
                dy=$(bc -l <<< $1)
                dy=${dy%%.*}
		if [ -z "${dy// }" ]; then
			dy=0
		fi
                disegna $2 $dy
        fi

}

echo
echo
echo

for((y=-$Cy; y<$Cy; y++)); do
	dy=$(($y))

	if [ $y -ge -3 ] && [ $y -le 0 ]; then
                dx=-21
		disegna $dx $dy
        fi

done

for((x=-$Cx; x<$Cx; x++)); do
	dx=$(($x))

        fiocco "-7/4*($x-3)+8" $x -1 3 # 1
        fiocco "3/2*($x-3)+8" $x 3 5 # 2
        fiocco "-8/5*($x-5)+11" $x 0 5 # 3
        fiocco "19" $x 0 3 # 4
        fiocco "-5/3*($x-6)+14" $x 3 6 # 5
        fiocco "5/3*($x-6)+14" $x 6 9 # 6
        fiocco "-1/2*($x-9)+19" $x 9 11 # 7
        fiocco "5/3*($x-11)+18" $x 8 11 # 8
        fiocco "13" $x 8 15 # 9
        fiocco "3/2*($x-13)+10" $x 13 15 # 10
        fiocco "10" $x 7 13 # 11
        fiocco "3/2*($x-5)+7" $x 5 7 # 12
        fiocco "7" $x 5 12 # 13
        fiocco "6/3*($x-9)+1" $x 9 12 # 14
        fiocco "1" $x 9 12 # 15	
	fiocco "7/4*($x-16)+8" $x 12 16 # 16
        fiocco "-2/2*($x-8)+16" $x 16 18 # 17
        fiocco "5/3*($x-15)+1" $x 15 18 # 18
        fiocco "1" $x 15 21 # 19
        fiocco "21" $x -2 1 # 20
        fiocco "-2" $x 16 21 # 21
        fiocco "-5/3*($x-16)-2" $x 16 19 # 22
        fiocco "1/3*($x-19)-7" $x 16 19 # 23
        fiocco "-6/3*($x-16)-8" $x 13 16 # 24
        fiocco "-2" $x 9 13 # 25
        fiocco "-6/4*($x-9)-2" $x 9 13 # 26
        fiocco "-8" $x 5 13 # 27
        fiocco "-3/3*($x-5)+8" $x 5 8 # 28
        fiocco "-11" $x 8 14 # 29
        fiocco "-3/2*($x-14)-11" $x 14 16 # 30
        fiocco "-14" $x 9 16 # 31
        fiocco "-4/3*($x-9)-14" $x 9 12 # 32
        fiocco "$x-12+18" $x 10 12 # 33
        fiocco "-7/3*($x-7)-13" $x 7 10 # 34
        fiocco "7/3*($x-7)-13" $x 4 7 # 35
        fiocco "-20" $x 2 4 # 36
        fiocco "7/3*($x-5)-13" $x 2 5 # 37
        fiocco "-6/2*($x-3)-7" $x 3 5 # 38
        fiocco "9/3*($x-3)-7" $x 0 3 # 39
        fiocco "-6/4*($x+4)-10" $x 9 13 # 40
        fiocco "3*($x+4)-10" $x -5 -4 # 41
        fiocco "-6/3*($x+5)-13" $x -5 -2 # 42
        fiocco "3/2*($x+2)-19" $x -4 -2 # 43
        fiocco "-6/3*($x+7)-16" $x -7 -4 # 44
        fiocco "5/2*($x+7)-16" $x -9 -7 # 45
        fiocco "-1/2*($x+11)-20" $x -11 -9 # 46
        fiocco "5/2*($x+9)-15" $x -11 -9 # 47
        fiocco "-15" $x -14 -9 # 48
        fiocco "-3*($x+15)-12" $x -15 -14 # 49
        fiocco "-12" $x -15 -8 # 50
        fiocco "4/3*($x+5)-8" $x -8 -5 # 51
        fiocco "-1/8*($x+13)-7" $x -13 -5 # 52
        fiocco "4/3*($x+10)-3" $x -13 -10 # 53
        fiocco "-3" $x -13 -10 # 54
        fiocco "4/3*($x+13)-3" $x -16 -13 # 55
        fiocco "-7" $x -19 -16 # 56
        fiocco "4/3*($x+16)-3" $x -19 -16 # 57
        fiocco "-3" $x -21 -16 # 58
        fiocco "0" $x -21 -16 # 59
        fiocco "-5/3*($x+19)+5" $x -19 -16 # 60
        fiocco "2/4*($x+19)+5" $x -19 -15 # 61
        fiocco "-7/4*($x+15)+7" $x -15 -11 # 62
        fiocco "0" $x -11 -7 # 63
        fiocco "-6/4*($x+13)+6" $x -13 -9 # 64
        fiocco "6" $x -13 -6 # 65
        fiocco "-4/2*($x+6)+6" $x -8 -6 # 66
        fiocco "1/8*($x+16)+9" $x -16 -8 # 67
        fiocco "3*($x+16)+9" $x -16 -15 # 68
        fiocco "12" $x -15 -9 # 69
        fiocco "-5/3*($x+9)+12" $x -12 -9 # 70
        fiocco "$x+29" $x -12 -10 # 71
        fiocco "-5/3*($x+7)+14" $x -10 -7 # 72
        fiocco "6/2*($x+7)+14" $x -7 -5 # 73
        fiocco "-3/2*($x+3)+17" $x -5 -3 # 74
        fiocco "6/3*($x+6)+11" $x -6 -3 # 75
        fiocco "-3/2*($x+4)+8" $x -6 -4 # 76
        fiocco "7/3*($x+4)+8" $x -4 -1 # 77
        fiocco "-4/3*($x-2)+5" $x -1 2 # 78
        fiocco "3/2*($x-2)+5" $x 0 -2 # 79
        fiocco "-3/3*($x+3)+5" $x -3 0 # 80
        fiocco "4/2*($x+3)+5" $x -3 -1 # 81
        fiocco "-3/2*($x+2)+1" $x -4 -2 # 82
        fiocco "1/5*($x+2)+1" $x -7 -2 # 83
        fiocco "-3/2*($x+9)+3" $x -9 -7 # 84
        fiocco "1/5*($x+4)+4" $x -9 -4 # 85
        fiocco "4/2*($x-4)+4" $x 2 4 # 86
        fiocco "4" $x 4 7 # 87
        fiocco "3*($x-7)+4" $x 6 7 # 88
        fiocco "1/4*($x-6)+1" $x 2 6 # 89
        fiocco "-2" $x 2 6 # 90
        fiocco "-3/2*($x-6)-2" $x 6 8 # 91
        fiocco "-5" $x 4 8 # 92
        fiocco "-3/2*($x-2)-2" $x 2 -4 # 93
        fiocco "2*($x-2)-7" $x 0 2 # 94
        fiocco "4/2*($x+2)-7" $x -2 0 # 95
        fiocco "-2*($x+2)-7" $x -2 0 # 96
        fiocco "-2*($x-2)-7" $x 0 2 # 97
        fiocco "3*($x+3)-3" $x -4 -3 # 98
        fiocco "-6" $x -8 -4 # 99
        fiocco "3*($x+7)-3" $x -8 -7 # 100
        fiocco "-3" $x -7 -3 # 101

done

for((i=0; i<$Cy; i++)); do
	echo
done

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

#!/bin/bash

clear

# stabiliamo il centro degli assi cartesiani per il

# disegno della funzione neve

Cx=30

Cy=30

# disegna in posizione x, y

# accetta due parametri

disegna() {

# moltiplichiamo la x per 2 per compensare

# la dimensione dei font del terminale

X=$(($Cx*2+$1*2))

Y=$(($Cy-$2))

Xmax=$(($Cx*4))

Ymax=$(($Cy*2))

# stampiamo a video nella posizione x, y

# un carattere asterisco * se si trova entro

# i limiti del grafico

if [ $X -ge 0 ] && [ $X -le $Xmax ] && [ $Y -ge 0 ] && [ $Y -le $Ymax ]; then

echo -ne "\e[${Y};${X}H#"

}

# equazione, x, min, max

# 1 2 3 4

fiocco() {

if [ $2 -ge $3 ] && [ $2 -le $4 ]; then

dy=0

dy=$(bc -l <<< $1)

dy=${dy%%.*}

if [ -z "${dy// }" ]; then

dy=0

disegna $2 $dy

}

echo

for((y=-$Cy; y<$Cy; y++)); do

dy=$(($y))

if [ $y -ge -3 ] && [ $y -le 0 ]; then

dx=-21

disegna $dx $dy

done

for((x=-$Cx; x<$Cx; x++)); do

dx=$(($x))

fiocco "-7/4*($x-3)+8" $x -1 3 # 1

fiocco "3/2*($x-3)+8" $x 3 5 # 2

fiocco "-8/5*($x-5)+11" $x 0 5 # 3

fiocco "19" $x 0 3 # 4

fiocco "-5/3*($x-6)+14" $x 3 6 # 5

fiocco "5/3*($x-6)+14" $x 6 9 # 6

fiocco "-1/2*($x-9)+19" $x 9 11 # 7

fiocco "5/3*($x-11)+18" $x 8 11 # 8

fiocco "13" $x 8 15 # 9

fiocco "3/2*($x-13)+10" $x 13 15 # 10

fiocco "10" $x 7 13 # 11

fiocco "3/2*($x-5)+7" $x 5 7 # 12

fiocco "7" $x 5 12 # 13

fiocco "6/3*($x-9)+1" $x 9 12 # 14

fiocco "1" $x 9 12 # 15

fiocco "7/4*($x-16)+8" $x 12 16 # 16

fiocco "-2/2*($x-8)+16" $x 16 18 # 17

fiocco "5/3*($x-15)+1" $x 15 18 # 18

fiocco "1" $x 15 21 # 19

fiocco "21" $x -2 1 # 20

fiocco "-2" $x 16 21 # 21

fiocco "-5/3*($x-16)-2" $x 16 19 # 22

fiocco "1/3*($x-19)-7" $x 16 19 # 23

fiocco "-6/3*($x-16)-8" $x 13 16 # 24

fiocco "-2" $x 9 13 # 25

fiocco "-6/4*($x-9)-2" $x 9 13 # 26

fiocco "-8" $x 5 13 # 27

fiocco "-3/3*($x-5)+8" $x 5 8 # 28

fiocco "-11" $x 8 14 # 29

fiocco "-3/2*($x-14)-11" $x 14 16 # 30

fiocco "-14" $x 9 16 # 31

fiocco "-4/3*($x-9)-14" $x 9 12 # 32

fiocco "$x-12+18" $x 10 12 # 33

fiocco "-7/3*($x-7)-13" $x 7 10 # 34

fiocco "7/3*($x-7)-13" $x 4 7 # 35

fiocco "-20" $x 2 4 # 36

fiocco "7/3*($x-5)-13" $x 2 5 # 37

fiocco "-6/2*($x-3)-7" $x 3 5 # 38

fiocco "9/3*($x-3)-7" $x 0 3 # 39

fiocco "-6/4*($x+4)-10" $x 9 13 # 40

fiocco "3*($x+4)-10" $x -5 -4 # 41

fiocco "-6/3*($x+5)-13" $x -5 -2 # 42

fiocco "3/2*($x+2)-19" $x -4 -2 # 43

fiocco "-6/3*($x+7)-16" $x -7 -4 # 44

fiocco "5/2*($x+7)-16" $x -9 -7 # 45

fiocco "-1/2*($x+11)-20" $x -11 -9 # 46

fiocco "5/2*($x+9)-15" $x -11 -9 # 47

fiocco "-15" $x -14 -9 # 48

fiocco "-3*($x+15)-12" $x -15 -14 # 49

fiocco "-12" $x -15 -8 # 50

fiocco "4/3*($x+5)-8" $x -8 -5 # 51

fiocco "-1/8*($x+13)-7" $x -13 -5 # 52

fiocco "4/3*($x+10)-3" $x -13 -10 # 53

fiocco "-3" $x -13 -10 # 54

fiocco "4/3*($x+13)-3" $x -16 -13 # 55

fiocco "-7" $x -19 -16 # 56

fiocco "4/3*($x+16)-3" $x -19 -16 # 57

fiocco "-3" $x -21 -16 # 58

fiocco "0" $x -21 -16 # 59

fiocco "-5/3*($x+19)+5" $x -19 -16 # 60

fiocco "2/4*($x+19)+5" $x -19 -15 # 61

fiocco "-7/4*($x+15)+7" $x -15 -11 # 62

fiocco "0" $x -11 -7 # 63

fiocco "-6/4*($x+13)+6" $x -13 -9 # 64

fiocco "6" $x -13 -6 # 65

fiocco "-4/2*($x+6)+6" $x -8 -6 # 66

fiocco "1/8*($x+16)+9" $x -16 -8 # 67

fiocco "3*($x+16)+9" $x -16 -15 # 68

fiocco "12" $x -15 -9 # 69

fiocco "-5/3*($x+9)+12" $x -12 -9 # 70

fiocco "$x+29" $x -12 -10 # 71

fiocco "-5/3*($x+7)+14" $x -10 -7 # 72

fiocco "6/2*($x+7)+14" $x -7 -5 # 73

fiocco "-3/2*($x+3)+17" $x -5 -3 # 74

fiocco "6/3*($x+6)+11" $x -6 -3 # 75

fiocco "-3/2*($x+4)+8" $x -6 -4 # 76

fiocco "7/3*($x+4)+8" $x -4 -1 # 77

fiocco "-4/3*($x-2)+5" $x -1 2 # 78

fiocco "3/2*($x-2)+5" $x 0 -2 # 79

fiocco "-3/3*($x+3)+5" $x -3 0 # 80

fiocco "4/2*($x+3)+5" $x -3 -1 # 81

fiocco "-3/2*($x+2)+1" $x -4 -2 # 82

fiocco "1/5*($x+2)+1" $x -7 -2 # 83

fiocco "-3/2*($x+9)+3" $x -9 -7 # 84

fiocco "1/5*($x+4)+4" $x -9 -4 # 85

fiocco "4/2*($x-4)+4" $x 2 4 # 86

fiocco "4" $x 4 7 # 87

fiocco "3*($x-7)+4" $x 6 7 # 88

fiocco "1/4*($x-6)+1" $x 2 6 # 89

fiocco "-2" $x 2 6 # 90

fiocco "-3/2*($x-6)-2" $x 6 8 # 91

fiocco "-5" $x 4 8 # 92

fiocco "-3/2*($x-2)-2" $x 2 -4 # 93

fiocco "2*($x-2)-7" $x 0 2 # 94

fiocco "4/2*($x+2)-7" $x -2 0 # 95

fiocco "-2*($x+2)-7" $x -2 0 # 96

fiocco "-2*($x-2)-7" $x 0 2 # 97

fiocco "3*($x+3)-3" $x -4 -3 # 98

fiocco "-6" $x -8 -4 # 99

fiocco "3*($x+7)-3" $x -8 -7 # 100

fiocco "-3" $x -7 -3 # 101

done

for((i=0; i<$Cy; i++)); do

echo

done

Il risultato dovrebbe essere qualcosa di simile a questo:

Non è bellissimo, ma è quello che stavamo cercando di fare. Perfezionando le equazioni probabilmente si può ottenere di meglio.