Petar Karan

[FIFA19] Crash DirectX function Dx12Renderer::waitOnSwapChain

In modo del tutto casuale durante il gioco (a me è successo con FIFA19, ma pare succeda anche con altri giochi tipo Battlefield) tutto si blocca con il seguente DirectX Error:

DirectX function “Dx12Renderer::waitOnSwapChain Gpu timeout detected” failed with DXGI_ERROR_DEVICE_HUNG. DirectX function “Dx12Renderer::waitOnSwapChain Gpu timeout detected” failed with DXGI_ERROR_DEVICE_HUNG. GPU: “”, Driver: 43648. This error is usually caused by the graphics driver crashing; try installing the latest drivers. Also, make sure you have a supported graphics card with at least 1024 MB of VRAM.

Inutile dire come la scheda video abbia 8GB di RAM e i driver siano aggiornati all’ultima versione (nel mio caso driver NVIDIA 436.48). Anche reinstallare i driver non sembra sortire alcun effetto e il problema sembra manifestarsi in modo del tutto casuale (anche se potrebbe essere collegato alla connessione col server, dal momento che ho notato che appare più frequentemente, tanto da rendere il gioco ingiocabile, quando la EA ha problemi coi server).

In ogni caso una soluzione che sembra funzionare consiste nell’apportare una modifica al registro di sistema, aumentando il tempo per il parametro Timeout Detection and Recovery. In pratica Windows tenta di verificare se la scheda video abbia completato o meno una certa operazione entro un tempo consentito (2 secondi); qualora questo non succeda si innesca il meccanismo di errore. Una più dettagliata spiegazione del fenomeno può essere trovata sul supporto Microsoft.

Per cercare di correggere il problema aumentiamo quindi il tempo del TDR nella maniera seguente.

Premiamo Win+R e digitiamo regedit nella finestra Esegui. Premiamo OK e apriamo il Registro di sistema.
Posizioniamoci in Computer\HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\GraphicsDrivers
Nel riquadro sulla destra clicchiamo con il tasto destro del mouse e creiamo una nuova chiave di tipo QWORD (per i computer a 64bit)
Come nome della chiave digitiamo TdrDelay
Clicchiamoci due volte sopra ed inseriamo 10 come valore decimale (altrimenti la lettera a come valore esadecimale) in modo da aumentare il tempo a 10 secondi (possiamo anche aumentare il valore maggiormente nell’eventualità di altri problemi)
Chiudiamo il registro di configurazione e riavviamo il computer, in modo da ricaricare il registro (in teoria sarebbe sufficiente riavviare esplora risorse)

Fatto questo il problema non dovrebbe più presentarsi.

Nel caso che il problema non si fosse ancora risolto possiamo provare a modificare le Impostazioni 3D per il gioco (questo per i possessori di una NVIDIA).

Procediamo nella maniera seguente:

Clicchiamo col destro sul desktop e scegliamo Pannello di controllo NVIDIA
Andiamo su Impostazioni 3D > Gestisci le impostazioni 3D
Apriamo la scheda Impostazioni programma e selezioniamo FIFA 19
Modifichiamo le seguenti voci:
Sincronizzazione verticale: Usa l’impostazione dell’applicazione 3D
Tecnologia monitor: Aggiornamento fisso
Velocità di aggiornamento preferita: La più elevata disponibile
Premiamo sul tasto Applica

Il crash sulle DirectX 12 sembra infatti legato alla tecnologia G-SYNC dei monitor NVIDIA.

[wordpress] Aggiungere un utente amministratore programmaticamente

Per creare un utente amministratore per il nostro sito di WordPress utilizzando solo il codice di programmazione (immaginiamo per esempio di aver dimenticato l’utente principale e non voler fare modifiche sul database, dove per altro sarebbe ancora più facile), è sufficiente procedere nella maniera seguente.

Apriamo il file functions.php che si trova nella cartella del tema, tipicamente in /wp-content/themes/

In fondo al file aggiungiamo il seguente pezzo di codice:

add_action('init', 'aggiungi_nuovo_utente');
function aggiungi_nuovo_utente() {
	// i nostri dati di accesso
	$username = 'nostrousername';
	$password = 'nostrapassword123';
	$email = 'nostra@email.it';
	
	// controlliamo se l'utente esiste
	$user_id = username_exists( $username );
	
	// se l'utente non esiste aggiungiamolo
	if ( !$user_id and email_exists($user_email) == false ) {

		// creiamo il nuovo utente
		$user_id = wp_create_user( $username, $password, $email );

		// prendiamo l'utente appena creato
		$user = get_user_by( 'id', $user_id );

		// rimuoviamo il ruolo di sottoscrittore
		$user->remove_role( 'subscriber' );

		// aggiungiamo il ruolo di amministratore
		$user->add_role( 'administrator' );
	}
}

add_action('init', 'aggiungi_nuovo_utente');

function aggiungi_nuovo_utente() {

// i nostri dati di accesso

$username = 'nostrousername';

$password = 'nostrapassword123';

$email = 'nostra@email.it';

// controlliamo se l'utente esiste

$user_id = username_exists( $username );

// se l'utente non esiste aggiungiamolo

if ( !$user_id and email_exists($user_email) == false ) {

// creiamo il nuovo utente

$user_id = wp_create_user( $username, $password, $email );

// prendiamo l'utente appena creato

$user = get_user_by( 'id', $user_id );

// rimuoviamo il ruolo di sottoscrittore

$user->remove_role( 'subscriber' );

// aggiungiamo il ruolo di amministratore

$user->add_role( 'administrator' );

}

A questo punto eseguiamo una qualunque pagina del sito, per esempio la home page, ed il gioco è fatto. 🙂

[risolto] Su Chrome appare una banda nera in alto che impedisce di cliccare sulle schede o sui pulsanti della finestra

Problema: Su Windows 10, utilizzando due monitor, su Chrome appare una banda nera in alto che impedisce di cliccare sulle schede, sul menu delle opzioni oppure sui pulsanti della finestra.

Soluzione: Aprire il task manager premendo ALT+CTRL+CANC e andando su Gestione Attività, andare in Dettagli e trovare il processo dwm.exe. Terminare il processo. Il processo dovrebbe riavviarsi da solo, risolvendo il problema.

Più nel dettaglio sembra che si tratti di un bug, già noto dalla seconda metà del 2018, di Windows 10. Nel caso specifico il problema si presenta nella maniera seguente:

Lì dove dovrebbero esserci le schede ed i pulsanti della finestra c’è solo una striscia nera. Il problema si presenta solamente a schermo intero e su un singolo monitor.

Riducendo la finestra, oppure aprendola a schermo intero su un altro monitor, il problema non sembra presentarsi. Dei due o più monitor non c’è uno “preferito” dal problema, avviene in modo casuale su qualunque. L’unica soluzione possibile sembra il riavvio del sistema.

Un’altra soluzione suggerita da Microsoft è quella di disabilitare l’accelerazione hardware in Chrome, ma questo non sembra incidere in alcun modo sulla questione, tanto più che io l’avevo disattivata da principio e la cosa è iniziata a succedere diverso tempo dopo.

In sostanza sembra che al momento, a meno che non correggano questo errore con qualche nuovo aggiornamento, l’unica soluzione concreta, a parte il riavvio, sia quella di terminare il processo dwm.exe (Desktop Windows Manager). Una volta terminato, il processo si riavvierà da solo e il problema non dovrebbe presentarsi, almeno per un po’.

[woocommerce] Nascondere gli attributi senza alcuna variante attiva

In WooCommerce è possibile creare prodotti con diverse varianti. Immaginiamo di avere una situazione come la seguente:

In questo caso la prima variante di colore non è disponibile in alcuna taglia e se la proviamo a selezionare ci compare un avviso che ci dice che non c’è alcun prodotto selezionabile. Per evitare che il cliente debba testare tutte le combinazioni inutilmente WooCommerce, sotto a 10 variazioni per prodotto, tende a nascondere automaticamente le combinazioni inesistenti.

Quando però, come in questo caso, il numero di variazioni aumenta per motivi di prestazioni l’opzione non è attiva. Per aumentare tale limite basta aggiungere a functions.php nel nostro tema le seguenti righe di codice:

function custom_wc_ajax_variation_threshold( $qty, $product ) {
    return 500;
}

add_filter( 'woocommerce_ajax_variation_threshold', 'custom_wc_ajax_variation_threshold', 10, 2 );

function custom_wc_ajax_variation_threshold( $qty, $product ) {

return 500;

}

add_filter( 'woocommerce_ajax_variation_threshold', 'custom_wc_ajax_variation_threshold', 10, 2 );

A questo punto vedremo un risultato come il seguente (abbiamo impostato il limite a 500):

Si può notare come il primo colore, assieme ad altri, è automaticamente sparito.

[python] Recuperare i messaggi cancellati definitivamente da un file *.pst di Outlook

Outlook salva tutto il contenuto dell’account di posta dentro ad un file *.pst che viene trattato similmente ad uno spazio sul disco. Questo significa che quando un messaggio viene cancellato definitivamente (per esempio svuotando il cestino oppure cancellandolo con SHFIT+CANC) in realtà non viene rimosso definitivamente dal file, ma ne rimane traccia finché un nuovo messaggio non andrà a sovrascriverlo. Questa non è una spiegazione perfettamente accurata, ma è quanto ci serve sapere allo scopo.

Per recuperare un messaggio cancellato definitivamente è anzitutto importante non scaricare o inviare nuovi messaggi, non fare cioè alcuna operazione che potrebbe modificare il file *.pst.

Detto questo possiamo tentare di recuperare i dati modificando alcuni byte del file *.pst e utilizzando il programma Scanpst.exe fornito assieme ad Office. Dalla versione Microsoft Office 2016 il programma è eseguibile anche tramite linea di comando.

Vediamo quindi come creare un programma in python che ci permetta di effettuare le due operazioni recuperando quindi i messaggi.

Prima di procedere creiamo una copia del file *.pst per non provocare altri danni.

Quello che dobbiamo fare ora è modificare, mettendoli per esempio a 0, i primi 13 byte a partire dalla 7^ posizione nel file *.pst in questione. Questo farà sì che Scanpst.exe identifichi il file come corrotto e cerchi di recuperare i messaggi perduti. Usando un editor esadecimale, tipo Hex Edit, dovremmo vedere una situazione come la seguente.

Quelli che vogliamo mettere a 0 sono i byte evidenziati. Io lo farò usando python. Creiamo un vettore di byte a zero nel modo seguente:

byte_vuoti = bytes(13)

1	byte_vuoti = bytes(13)

Questo produrrà un vettore di byte che possiamo visualizzare con print( byte_vuoti )

Scriviamo il pezzo di codice necessario per modificare il file *.pst

file_pst = "Outlook.pst"
byte_vuoti = bytes(13)

fp = open( file_pst , "r+b" )
fp.seek(7)
fp.write( byte_vuoti )
fp.close()

file_pst = "Outlook.pst"

byte_vuoti = bytes(13)

fp = open( file_pst , "r+b" )

fp.seek(7)

fp.write( byte_vuoti )

fp.close()

Con fp.seek(7) ci posizioniamo sull’ottavo byte, e poi scriviamo i 13 byte a 0 dalla posizione acquisita.

Adesso passiamo il file a Scanpst.exe, potremmo farlo anche a mano, ma nel mio esempio lo farò tramite linea di comando.

Modifichiamo il codice soprastante nel modo seguente:

import os

dir_path = os.path.dirname(os.path.realpath(__file__))
file_pst = dir_path + "\\Outlook.pst"
byte_vuoti = bytes(13)
scanpst = "C:\\Program Files (x86)\\Microsoft Office\\root\\Office16\\SCANPST.EXE"
cmd = "\"%s\" -backupfile \"%s.bck\" -force -file \"%s\" -silent" % (scanpst,file_pst,file_pst)

fp = open( file_pst , "r+b" )
fp.seek(7)
fp.write( byte_vuoti )
fp.close()

output = os.popen(cmd).read()
print(output)
print("Fatto!")

import os

dir_path = os.path.dirname(os.path.realpath(__file__))

file_pst = dir_path + "\\Outlook.pst"

byte_vuoti = bytes(13)

scanpst = "C:\\Program Files (x86)\\Microsoft Office\\root\\Office16\\SCANPST.EXE"

cmd = "\"%s\" -backupfile \"%s.bck\" -force -file \"%s\" -silent" % (scanpst,file_pst,file_pst)

fp = open( file_pst , "r+b" )

fp.seek(7)

fp.write( byte_vuoti )

fp.close()

output = os.popen(cmd).read()

print(output)

print("Fatto!")

Per maggiori dettagli sui parametri da passare a Scanpst.exe rimando alla pagina ufficiale sul sito della Microsoft: Lo strumento Manutenzione Posta in arrivo (Scanpst.exe) può eseguire controlli multipli in Outlook 2016

Con os.path.dirname(os.path.realpath(__file__)) prendiamo la posizione del programma in python, laddove io suppongo che il file Outlook si trovi nella medesima cartella del programma. Inutile dire che file_pst = dir_path + "\\Outlook.pst" dipende dalla posizione del file *.pst che potremmo passare anche con il percorso diretto.

Con la riga scanpst = "C:\\Program Files (x86)\\Microsoft Office\\root\\Office16\\SCANPST.EXE" prendiamo la posizione del file Scanpst.exe che nel mio caso ha quel percorso. Anche questo dipende dalla nostra specifica installazione di Office. Ricordiamoci che questo procedimento è valido solo per le versioni di Office 2016 e successive.

Infine con output = os.popen(cmd).read() mettiamo il programma in attesa finché non verrà completata l’esecuzione del comando. (verrà scritto Fatto!)

Alla fine, se tutto è andato bene, dovremmo vedere qualcosa di questo genere nella cartella del file:

Per visualizzare di nuovo il contenuto del file *.pst è sufficiente collegarlo tra i File dati di Outlook.

[apps script] Inviare tramite Gmail un’email con allegato da Drive

Questo esempio è la prosecuzione di quanto già visto in [apps script] Inviare tramite Gmail un’email ad un elenco di contatti in Spreadsheet

Voglio apportare solo una piccola modifica al codice per inviare un allegato salvato su Google Drive a tutti i soggetti nella lista. Per i riferimenti di programmazione rimando alla pagina della guida ufficiale.

Per prelevare un file da Google Drive dobbiamo anzitutto ottenere il suo riferimento univoco. Per farlo ci sono diversi modi, nel mio esempio utilizzerò un file pdf come questo qua. Anzitutto lo carico su Drive e poi cliccandoci sopra col destro scelgo Anteprima.

Dal menu in alto a destra seleziono Apri in un’altra finestra.

A questo punto nella barra dell’indirizzo vedrò qualcosa come https://drive.google.com/file/d/1234567890abcdefghijklmnopqrstuvwxyz/view

Copio il codice alfanumerico che ho evidenziato in rosso, che è l’identificativo univoco per ciascun file. Una volta copiato vado a modificare il mio codice nel modo seguente.

function InviaEmailAllaLista() {
  
  var foglio = SpreadsheetApp.getActiveSheet();
  var indirizzi = foglio.getRange("A:A").getValues();
  var oggetti = foglio.getRange("B:B").getValues();
  var messaggi = foglio.getRange("C:C").getValues();
  
  var riga = 1;
  
  while( true ) {
   
    if( indirizzi[riga] == "" ) {
      break;
    }
    
    var file = DriveApp.getFileById('1234567890abcdefghijklmnopqrstuvwxyz');
    GmailApp.sendEmail(indirizzi[riga], oggetti[riga], messaggi[riga], {
      attachments: [file.getAs(MimeType.PDF)],
      name: 'File di prova'
    });
    
    riga++;
    
  }
  
  Browser.msgBox("Tutte le email sono state inviate!");
  
}

function InviaEmailAllaLista() {

var foglio = SpreadsheetApp.getActiveSheet();

var indirizzi = foglio.getRange("A:A").getValues();

var oggetti = foglio.getRange("B:B").getValues();

var messaggi = foglio.getRange("C:C").getValues();

var riga = 1;

while( true ) {

if( indirizzi[riga] == "" ) {

break;

}

var file = DriveApp.getFileById('1234567890abcdefghijklmnopqrstuvwxyz');

GmailApp.sendEmail(indirizzi[riga], oggetti[riga], messaggi[riga], {

attachments: [file.getAs(MimeType.PDF)],

name: 'File di prova'

});

riga++;

}

Browser.msgBox("Tutte le email sono state inviate!");

}

In particolare con la prima istruzione aggiunta prelevo il file da Drive, cosa che richiederà dei permessi aggiuntivi.

var file = DriveApp.getFileById('1234567890abcdefghijklmnopqrstuvwxyz');

1	var file = DriveApp.getFileById('1234567890abcdefghijklmnopqrstuvwxyz');

Mentre con file.getAs(MimeType.PDF) creo il blob del file in formato PDF.

Fatto questo il mio nuovo script invia un’email a ciascun membro della lista con allegato il suddetto file.

[python] Esercizio su wxPython e PyOpenGL per disegnare un poligono dato il numero di lati

Quello che voglio realizzare oggi è un semplice programma in Python 2.7, con interfaccia grafica e che permetta di disegnare un poligono regolare dato il numero di lati. In questo esercizio vedremo quindi due cose:

L’utilizzo di wxPython per creare un rudimentale programma con interfaccia grafica
L’utilizzo di PyOpenGL per disegnare dentro ad un canvas una figura geometrica

Il programma che andremo a creare avrà alla fine questo aspetto, con uno spazio per inserire il numero di lati ed un canvas su cui disegnare:

Anzitutto assicuriamoci di disporre di entrambe le librerie, per farlo installiamole con pip eseguendo i seguenti due comandi da terminale:

pip install wxPython
pip install PyOpenGL

1 2	pip install wxPython pip install PyOpenGL

Una volta installate le librerie possiamo cominciare a creare il nostro programma.

Per prima cosa creiamo una classe per la nostra applicazione, utilizzando wx.Frame e avviando la finestra principale. Il codice di cui avremo bisogno sarà il seguente:

import wx

class Applicazione(wx.Frame):
    def __init__(s, parent, title):
        wx.Frame.__init__(s, parent, title=title, size=(800,600))

        s.Show(True)


if __name__ == "__main__":

    app = wx.App(False)
    frame = Applicazione(None, "Disegnatore")
    app.MainLoop()

import wx

class Applicazione(wx.Frame):

def __init__(s, parent, title):

wx.Frame.__init__(s, parent, title=title, size=(800,600))

s.Show(True)

if __name__ == "__main__":

app = wx.App(False)

frame = Applicazione(None, "Disegnatore")

app.MainLoop()

In questo modo creiamo una finestra di dimensione 800 x 600 px con titolo Disegnatore. La nostra applicazione è un’estensione di wx.Frame, laddove un Frame è una finestra le cui dimensioni e posizione possono essere modificate dall’utente (insomma la classica finestra in Windows). Inoltre essa può contenere una barra del titolo, dei menu, dello stato e degli strumenti.

Con wx.App avviamo invece l’applicazione vera e propria, questa classe ci serve per lanciare il contenitore principale dell’applicazione e passiamo come argomento False (che sarebbe così anche di predefinito) per non reindirizzare lo sys.stdout e lo sys.stderr. Per maggiori informazioni rimando alla guida ufficiale su App.

A questo punto voglio aggiungere la casella di testo e il pulsante per impostare il numero di lati. Per farlo dobbiamo usare un wx.Panel, che sostanzialmente è il contenitore degli elementi di controllo e si trova tipicamente dentro un Frame. Per maggiori informazioni leggere qui su Panel.

Modifico quindi il codice nella maniera seguente:

import wx

class Applicazione(wx.Frame):
    def __init__(s, parent, title):
        wx.Frame.__init__(s, parent, title=title, size=(800,600))

        # aggiungo un panel alla classe
        s.panel = wx.Panel(s)

        # dopo il panel aggiungo i pulsanti
        s.aggPulsanti()

        s.Show(True)

    def aggPulsanti(s):

        # casella di testo
        s.testo = wx.TextCtrl(s.panel, pos=(5, 7))
        # pulsante
        s.pulsante = wx.Button(s.panel, label="Calcola", pos=(120,5))


if __name__ == "__main__":

    app = wx.App(False)
    frame = Applicazione(None, "Disegnatore")
    app.MainLoop()

import wx

class Applicazione(wx.Frame):

def __init__(s, parent, title):

wx.Frame.__init__(s, parent, title=title, size=(800,600))

# aggiungo un panel alla classe

s.panel = wx.Panel(s)

# dopo il panel aggiungo i pulsanti

s.aggPulsanti()

s.Show(True)

def aggPulsanti(s):

# casella di testo

s.testo = wx.TextCtrl(s.panel, pos=(5, 7))

# pulsante

s.pulsante = wx.Button(s.panel, label="Calcola", pos=(120,5))

if __name__ == "__main__":

app = wx.App(False)

frame = Applicazione(None, "Disegnatore")

app.MainLoop()

E’ molto importante che il Panel venga istanziato prima del metodo aggPulsanti che poi aggiunge elementi al Panel. Arrivati a questo punto lanciamo il nostro programma e verifichiamo che abbia il seguente aspetto.

A questo punto è l’ora di aggiungere anche il Canvas che ci permetterà di mostrare grafica in OpenGL. Per farlo includiamo anzitutto le librerie necessarie:

from wx.glcanvas import GLCanvas
from OpenGL.GLU import *
from OpenGL.GL import *

from wx.glcanvas import GLCanvas

from OpenGL.GLU import *

from OpenGL.GL import *

Modifichiamo poi il codice nel modo seguente:

import wx
from wx.glcanvas import GLCanvas
from OpenGL.GLU import *
from OpenGL.GL import *

class Applicazione(wx.Frame):
    def __init__(s, parent, title):
        wx.Frame.__init__(s, parent, title=title, size=(800,600))

        # aggiungo un panel alla classe
        s.panel = wx.Panel(s)

        # dopo il panel aggiungo i pulsanti
        s.aggPulsanti()

        # stabiliamo le dimensioni del canvas
        s.width = 770
        s.height = 500

        # aggiungiamo il canvas, anche esso sul panel
        s.aggCanvas()

        s.Show(True)

    def aggPulsanti(s):

        # casella di testo
        s.testo = wx.TextCtrl(s.panel, pos=(5, 7))
        # pulsante
        s.pulsante = wx.Button(s.panel, label="Calcola", pos=(120,5))

    def aggCanvas(s):
        gl_canvas_attribs = [wx.glcanvas.WX_GL_RGBA,
                             wx.glcanvas.WX_GL_DOUBLEBUFFER,
                             wx.glcanvas.WX_GL_DEPTH_SIZE, 16]

        s.canvas = wx.glcanvas.GLCanvas(s.panel, attribList=gl_canvas_attribs, pos=(5,50))
        s.context = wx.glcanvas.GLContext(s.canvas)
        s.canvas.SetSize((s.width,s.height))


if __name__ == "__main__":

    app = wx.App(False)
    frame = Applicazione(None, "Disegnatore")
    app.MainLoop()

import wx

from wx.glcanvas import GLCanvas

from OpenGL.GLU import *

from OpenGL.GL import *

class Applicazione(wx.Frame):

def __init__(s, parent, title):

wx.Frame.__init__(s, parent, title=title, size=(800,600))

# aggiungo un panel alla classe

s.panel = wx.Panel(s)

# dopo il panel aggiungo i pulsanti

s.aggPulsanti()

# stabiliamo le dimensioni del canvas

s.width = 770

s.height = 500

# aggiungiamo il canvas, anche esso sul panel

s.aggCanvas()

s.Show(True)

def aggPulsanti(s):

# casella di testo

s.testo = wx.TextCtrl(s.panel, pos=(5, 7))

# pulsante

s.pulsante = wx.Button(s.panel, label="Calcola", pos=(120,5))

def aggCanvas(s):

gl_canvas_attribs = [wx.glcanvas.WX_GL_RGBA,

wx.glcanvas.WX_GL_DOUBLEBUFFER,

wx.glcanvas.WX_GL_DEPTH_SIZE, 16]

s.canvas = wx.glcanvas.GLCanvas(s.panel, attribList=gl_canvas_attribs, pos=(5,50))

s.context = wx.glcanvas.GLContext(s.canvas)

s.canvas.SetSize((s.width,s.height))

if __name__ == "__main__":

app = wx.App(False)

frame = Applicazione(None, "Disegnatore")

app.MainLoop()

E’ importante stabilire le dimensioni del canvas in due variabili s.width e s.height per delle correzioni che apporteremo successivamente, per ora prendiamola per buona così.

A questo punto inizializziamo il canvas aggiungendo le seguenti istruzioni:

import wx
from wx.glcanvas import GLCanvas
from OpenGL.GLU import *
from OpenGL.GL import *

class Applicazione(wx.Frame):
    def __init__(s, parent, title):
        wx.Frame.__init__(s, parent, title=title, size=(800,600))

        # aggiungo un panel alla classe
        s.panel = wx.Panel(s)

        # dopo il panel aggiungo i pulsanti
        s.aggPulsanti()

        # stabiliamo le dimensioni del canvas
        s.width = 770
        s.height = 500

        # aggiungiamo il controllo di inizializzazione del canvas
        s.glInizializzato = False

        # aggiungiamo il canvas, anche esso sul panel
        s.aggCanvas()

        s.Show(True)

    def aggPulsanti(s):

        # casella di testo
        s.testo = wx.TextCtrl(s.panel, pos=(5, 7))
        # pulsante
        s.pulsante = wx.Button(s.panel, label="Calcola", pos=(120,5))

    def aggCanvas(s):
        gl_canvas_attribs = [wx.glcanvas.WX_GL_RGBA,
                             wx.glcanvas.WX_GL_DOUBLEBUFFER,
                             wx.glcanvas.WX_GL_DEPTH_SIZE, 16]

        s.canvas = wx.glcanvas.GLCanvas(s.panel, attribList=gl_canvas_attribs, pos=(5,50))
        s.context = wx.glcanvas.GLContext(s.canvas)
        s.canvas.SetSize((s.width,s.height))
        # aggiungiamo un collegamento all'evento paint con un metodo onPaint
        # costruito nella nostra classe
        s.canvas.Bind(wx.EVT_PAINT, s.onPaint)

    # metodo onPaint
    def onPaint(s,evt):
        s.canvas.SetCurrent(s.context)
        # verifichiamo se il canvas sia stato o meno inizializzato
        if not s.glInizializzato: s.initGL()
        s.onDraw()

    # inizializziamo il canvas
    def initGL(s):
        if s.glInizializzato:
            return
        s.glInizializzato = True
        # impostiamo il colore dello sfondo
        glClearColor(1, 1, 1, 1)

    # creiamo il metodo onDraw
    def onDraw(s, *args, **kwargs):
        glClear(GL_COLOR_BUFFER_BIT)

        s.SwapBuffers()

    # ripulisci il buffer
    def SwapBuffers(s):
        s.canvas.SwapBuffers()


if __name__ == "__main__":

    app = wx.App(False)
    frame = Applicazione(None, "Disegnatore")
    app.MainLoop()

import wx

from wx.glcanvas import GLCanvas

from OpenGL.GLU import *

from OpenGL.GL import *

class Applicazione(wx.Frame):

def __init__(s, parent, title):

wx.Frame.__init__(s, parent, title=title, size=(800,600))

# aggiungo un panel alla classe

s.panel = wx.Panel(s)

# dopo il panel aggiungo i pulsanti

s.aggPulsanti()

# stabiliamo le dimensioni del canvas

s.width = 770

s.height = 500

# aggiungiamo il controllo di inizializzazione del canvas

s.glInizializzato = False

# aggiungiamo il canvas, anche esso sul panel

s.aggCanvas()

s.Show(True)

def aggPulsanti(s):

# casella di testo

s.testo = wx.TextCtrl(s.panel, pos=(5, 7))

# pulsante

s.pulsante = wx.Button(s.panel, label="Calcola", pos=(120,5))

def aggCanvas(s):

gl_canvas_attribs = [wx.glcanvas.WX_GL_RGBA,

wx.glcanvas.WX_GL_DOUBLEBUFFER,

wx.glcanvas.WX_GL_DEPTH_SIZE, 16]

s.canvas = wx.glcanvas.GLCanvas(s.panel, attribList=gl_canvas_attribs, pos=(5,50))

s.context = wx.glcanvas.GLContext(s.canvas)

s.canvas.SetSize((s.width,s.height))

# aggiungiamo un collegamento all'evento paint con un metodo onPaint

# costruito nella nostra classe

s.canvas.Bind(wx.EVT_PAINT, s.onPaint)

# metodo onPaint

def onPaint(s,evt):

s.canvas.SetCurrent(s.context)

# verifichiamo se il canvas sia stato o meno inizializzato

if not s.glInizializzato: s.initGL()

s.onDraw()

# inizializziamo il canvas

def initGL(s):

if s.glInizializzato:

return

s.glInizializzato = True

# impostiamo il colore dello sfondo

glClearColor(1, 1, 1, 1)

# creiamo il metodo onDraw

def onDraw(s, *args, **kwargs):

glClear(GL_COLOR_BUFFER_BIT)

s.SwapBuffers()

# ripulisci il buffer

def SwapBuffers(s):

s.canvas.SwapBuffers()

if __name__ == "__main__":

app = wx.App(False)

frame = Applicazione(None, "Disegnatore")

app.MainLoop()

Faccio notare che il metodo glClearColor(1, 1, 1, 1) imposta il colore dello sfondo su bianco, mentre il metodo glClearColor(0, 0, 0, 1) lo imposta su nero. I primi tre parametri sono i valori di RGB da 0 a 1.

Siamo arrivati a buon punto e siamo praticamente pronti a disegnare il nostro poligono. Il nostro riferimento è uno spazio cartesiano con gli assi che attraversano a metà il canvas e il punto (0, 0) al centro del canvas stesso. Un poligono regolare ha tanti vertici quanti i lati e ogni vertice poggia su una circonferenza di raggio r.

Questo significa che un angolo α che passa da un vertice all’altro è dato dalla seguente equazione:

$\alpha = 2 * \pi / n$

Dove n è il numero di lati (o vertici) del poligono. Traduciamo questa formula in Python nel modo seguente:

angolo_lato = 2.0*math.pi/s.n

1	angolo_lato = 2.0*math.pi/s.n

Avremo bisogno della libreria math che importiamo con:

import math

1	import math

L’angolo di partenza è arbitrario, però per far sì che il lato superiore del poligono sia parallelo all’asse delle ascisse voglio prendere come angolo di partenza:

$\beta = \pi / 2 - \pi / n$

Quindi la nostra formula sarà:

angolo_partenza = math.pi/2.0 - math.pi/s.n

1	angolo_partenza = math.pi/2.0 - math.pi/s.n

Attenzione ad inserire i numeri con almeno una cifra decimale, anche se zero, per assicurarci che Python esegua tutti i calcoli con valori decimali e non tronchi ad interi.

Infine vogliamo definire un raggio fisso per i nostri poligoni, per farlo userò come riferimento l’apotema a (anche se sarebbe sufficienti lato e raggio) nel modo seguente:

$apotema = 0.5$

$lato = apotema * ( 2.0 * \tan( \pi / n ) )$

$raggio = \sqrt{ (lato/2)^2+apotema^2 }$

Il primo vertice avrà quindi coordinate:

$( raggio * \cos( \beta ) , raggio * \sin( \beta ) )$

Il secondo vertice sarà:

$( raggio * \cos( \beta + \alpha ) , raggio * \sin( \beta + \alpha ) )$

Il terzo vertice sarà:

$( raggio * \cos( \beta + 2 * \alpha ) , raggio * \sin( \beta + 2 * \alpha ) )$

E così via.

Traduciamo il tutto nel seguente metodo:

    def calcolaPoligono(s):
        apotema = 0.5
        
        angolo_partenza = math.pi/2.0 - math.pi/s.n
        angolo_lato = 2.0*math.pi/s.n
        lato = apotema * ( 2 * math.tan(math.pi / s.n) )
        raggio = math.sqrt((lato/2.0)**2+apotema**2)
        
        s.vertici = []
        for a in range(s.n):
            s.vertici.append([raggio*math.cos(angolo_partenza+a*angolo_lato),
                              raggio*math.sin(angolo_partenza+a*angolo_lato)])

def calcolaPoligono(s):

apotema = 0.5

angolo_partenza = math.pi/2.0 - math.pi/s.n

angolo_lato = 2.0*math.pi/s.n

lato = apotema * ( 2 * math.tan(math.pi / s.n) )

raggio = math.sqrt((lato/2.0)**2+apotema**2)

s.vertici = []

for a in range(s.n):

s.vertici.append([raggio*math.cos(angolo_partenza+a*angolo_lato),

raggio*math.sin(angolo_partenza+a*angolo_lato)])

Spostiamoci sul metodo onDraw e modifichiamolo nel modo seguente:

    def onDraw(s, *args, **kwargs):
        glClear(GL_COLOR_BUFFER_BIT)

        s.calcolaPoligono()

        glBegin(GL_POLYGON)
        glColor3f(1, 0.0, 0.0)
        for v in s.vertici:
            glVertex(v[0], v[1])
        glEnd()

        s.SwapBuffers()

def onDraw(s, *args, **kwargs):

glClear(GL_COLOR_BUFFER_BIT)

s.calcolaPoligono()

glBegin(GL_POLYGON)

glColor3f(1, 0.0, 0.0)

for v in s.vertici:

glVertex(v[0], v[1])

glEnd()

s.SwapBuffers()

Nel costruttore __init__ della classe aggiungiamo una variabile s.n per il numero di lati, subito dopo le dimensioni del canvas, nel modo seguente:

        # stabiliamo le dimensioni del canvas
        s.width = 770
        s.height = 500
        #numero di lati
        s.n = 5

# stabiliamo le dimensioni del canvas

s.width = 770

s.height = 500

#numero di lati

s.n = 5

Se abbiamo fatto tutto correttamente dovremmo vedere qualcosa come questo:

Notiamo subito che il pentagono è deformato ed inoltre manca la possibilità di definire una dimensione a piacere.

Anzitutto occupiamoci della deformazione, essa dipende dal fatto che il canvas ha una dimensione fissa di 1 x 1, che poi viene ripartita in parti decimali. Quindi tale dimensione si adatta poi alle proporzioni del canvas. Per ottenere un pentagono regolare anzitutto dobbiamo introdurre un fattore correttivo, che nel nostro caso sarà dato da:

s.ratio = 1.0 * s.height / s.width

1	s.ratio = 1.0 * s.height / s.width

Aggiungiamo la variabile subito dopo larghezza e altezza impostate in __init__.

Modifichiamo il metodo per disegnare il poligono nel modo seguente:

    def calcolaPoligono(s):
        apotema = 0.5
        
        angolo_partenza = math.pi/2.0 - math.pi/s.n
        angolo_lato = 2.0*math.pi/s.n
        lato = apotema * ( 2 * math.tan(math.pi / s.n) )
        raggio = math.sqrt((lato/2.0)**2+apotema**2)
        
        s.vertici = []
        for a in range(s.n):
            s.vertici.append([s.ratio*raggio*math.cos(angolo_partenza+a*angolo_lato),
                              raggio*math.sin(angolo_partenza+a*angolo_lato)])

def calcolaPoligono(s):

apotema = 0.5

angolo_partenza = math.pi/2.0 - math.pi/s.n

angolo_lato = 2.0*math.pi/s.n

lato = apotema * ( 2 * math.tan(math.pi / s.n) )

raggio = math.sqrt((lato/2.0)**2+apotema**2)

s.vertici = []

for a in range(s.n):

s.vertici.append([s.ratio*raggio*math.cos(angolo_partenza+a*angolo_lato),

raggio*math.sin(angolo_partenza+a*angolo_lato)])

Adesso il poligono risulta regolare:

Infine attribuiamo un valore personalizzato al numero di lati s.n del poligono. Aggiungiamo i seguenti due metodi alla nostra classe:

    def btn_calcola(s,event):
        valore = s.testo.GetValue()
        if s.verificaIntero(valore):
            s.n = int(valore)
            s.Refresh()
            s.Update()
        else:
            wx.MessageBox(message="Inserire un valore intero da 3 a n",
                          caption="Errore!",
                          style=wx.OK | wx.ICON_ERROR)

    def verificaIntero(s,val):
        try:
            v = int(val)
            if v < 3: return False
            return True
        except ValueError:
            return False

def btn_calcola(s,event):

valore = s.testo.GetValue()

if s.verificaIntero(valore):

s.n = int(valore)

s.Refresh()

s.Update()

else:

wx.MessageBox(message="Inserire un valore intero da 3 a n",

caption="Errore!",

style=wx.OK | wx.ICON_ERROR)

def verificaIntero(s,val):

try:

v = int(val)

if v < 3: return False

return True

except ValueError:

return False

E dove abbiamo istanziato s.pulsante aggiungiamo:

s.pulsante.Bind(wx.EVT_BUTTON, s.btn_calcola)

1	s.pulsante.Bind(wx.EVT_BUTTON, s.btn_calcola)

In questo modo colleghiamo il metodo s.btn_calcola all’evento wx.EVT_BUTTON che corrisponde alla pressione del pulsante. Con il metodo verificaIntero controlliamo se il valore passato dall’utente sia intero. Se non è intero mostriamo, grazie a wx.MessageBox, un messaggio a video con notifica di errore.

Se abbiamo fatto tutto correttamente otterremo il seguente codice finale:

import wx
from wx.glcanvas import GLCanvas
from OpenGL.GLU import *
from OpenGL.GL import *
import math

class Applicazione(wx.Frame):
    def __init__(s, parent, title):
        wx.Frame.__init__(s, parent, title=title, size=(800,600))

        # aggiungo un panel alla classe
        s.panel = wx.Panel(s)

        # dopo il panel aggiungo i pulsanti
        s.aggPulsanti()

        # stabiliamo le dimensioni del canvas
        s.width = 770
        s.height = 500
        s.ratio = 1.0 * s.height / s.width
        #numero di lati
        s.n = 5

        # aggiungiamo il controllo di inizializzazione del canvas
        s.glInizializzato = False

        # aggiungiamo il canvas, anche esso sul panel
        s.aggCanvas()

        s.Show(True)

    def aggPulsanti(s):

        # casella di testo
        s.testo = wx.TextCtrl(s.panel, pos=(5, 7))
        # pulsante
        s.pulsante = wx.Button(s.panel, label="Calcola", pos=(120,5))
        s.pulsante.Bind(wx.EVT_BUTTON, s.btn_calcola)

    def aggCanvas(s):
        gl_canvas_attribs = [wx.glcanvas.WX_GL_RGBA,
                             wx.glcanvas.WX_GL_DOUBLEBUFFER,
                             wx.glcanvas.WX_GL_DEPTH_SIZE, 16]

        s.canvas = wx.glcanvas.GLCanvas(s.panel, attribList=gl_canvas_attribs, pos=(5,50))
        s.context = wx.glcanvas.GLContext(s.canvas)
        s.canvas.SetSize((s.width,s.height))
        # aggiungiamo un collegamento all'evento paint con un metodo onPaint
        # costruito nella nostra classe
        s.canvas.Bind(wx.EVT_PAINT, s.onPaint)

    # metodo onPaint
    def onPaint(s,evt):
        s.canvas.SetCurrent(s.context)
        # verifichiamo se il canvas sia stato o meno inizializzato
        if not s.glInizializzato: s.initGL()
        s.onDraw()

    # inizializziamo il canvas
    def initGL(s):
        if s.glInizializzato:
            return
        s.glInizializzato = True
        # impostiamo il colore dello sfondo
        glClearColor(1, 1, 1, 1)

    # creiamo il metodo onDraw
    def onDraw(s, *args, **kwargs):
        glClear(GL_COLOR_BUFFER_BIT)

        s.calcolaPoligono()

        glBegin(GL_POLYGON)
        glColor3f(1, 0.0, 0.0)
        for v in s.vertici:
            glVertex(v[0], v[1])
        glEnd()

        s.SwapBuffers()

    # ripulisci il buffer
    def SwapBuffers(s):
        s.canvas.SwapBuffers()

    def calcolaPoligono(s):
        apotema = 0.5
        
        angolo_partenza = math.pi/2.0 - math.pi/s.n
        angolo_lato = 2.0*math.pi/s.n
        lato = apotema * ( 2 * math.tan(math.pi / s.n) )
        raggio = math.sqrt((lato/2.0)**2+apotema**2)
        
        s.vertici = []
        for a in range(s.n):
            s.vertici.append([s.ratio*raggio*math.cos(angolo_partenza+a*angolo_lato),
                              raggio*math.sin(angolo_partenza+a*angolo_lato)])

    def btn_calcola(s,event):
        valore = s.testo.GetValue()
        if s.verificaIntero(valore):
            s.n = int(valore)
            s.Refresh()
            s.Update()
        else:
            wx.MessageBox(message="Inserire un valore intero da 3 a n",
                          caption="Errore!",
                          style=wx.OK | wx.ICON_ERROR)

    def verificaIntero(s,val):
        try:
            v = int(val)
            if v < 3: return False
            return True
        except ValueError:
            return False


if __name__ == "__main__":

    app = wx.App(False)
    frame = Applicazione(None, "Disegnatore")
    app.MainLoop()

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

import wx

from wx.glcanvas import GLCanvas

from OpenGL.GLU import *

from OpenGL.GL import *

import math

class Applicazione(wx.Frame):

def __init__(s, parent, title):

wx.Frame.__init__(s, parent, title=title, size=(800,600))

# aggiungo un panel alla classe

s.panel = wx.Panel(s)

# dopo il panel aggiungo i pulsanti

s.aggPulsanti()

# stabiliamo le dimensioni del canvas

s.width = 770

s.height = 500

s.ratio = 1.0 * s.height / s.width

#numero di lati

s.n = 5

# aggiungiamo il controllo di inizializzazione del canvas

s.glInizializzato = False

# aggiungiamo il canvas, anche esso sul panel

s.aggCanvas()

s.Show(True)

def aggPulsanti(s):

# casella di testo

s.testo = wx.TextCtrl(s.panel, pos=(5, 7))

# pulsante

s.pulsante = wx.Button(s.panel, label="Calcola", pos=(120,5))

s.pulsante.Bind(wx.EVT_BUTTON, s.btn_calcola)

def aggCanvas(s):

gl_canvas_attribs = [wx.glcanvas.WX_GL_RGBA,

wx.glcanvas.WX_GL_DOUBLEBUFFER,

wx.glcanvas.WX_GL_DEPTH_SIZE, 16]

s.canvas = wx.glcanvas.GLCanvas(s.panel, attribList=gl_canvas_attribs, pos=(5,50))

s.context = wx.glcanvas.GLContext(s.canvas)

s.canvas.SetSize((s.width,s.height))

# aggiungiamo un collegamento all'evento paint con un metodo onPaint

# costruito nella nostra classe

s.canvas.Bind(wx.EVT_PAINT, s.onPaint)

# metodo onPaint

def onPaint(s,evt):

s.canvas.SetCurrent(s.context)

# verifichiamo se il canvas sia stato o meno inizializzato

if not s.glInizializzato: s.initGL()

s.onDraw()

# inizializziamo il canvas

def initGL(s):

if s.glInizializzato:

return

s.glInizializzato = True

# impostiamo il colore dello sfondo

glClearColor(1, 1, 1, 1)

# creiamo il metodo onDraw

def onDraw(s, *args, **kwargs):

glClear(GL_COLOR_BUFFER_BIT)

s.calcolaPoligono()

glBegin(GL_POLYGON)

glColor3f(1, 0.0, 0.0)

for v in s.vertici:

glVertex(v[0], v[1])

glEnd()

s.SwapBuffers()

# ripulisci il buffer

def SwapBuffers(s):

s.canvas.SwapBuffers()

def calcolaPoligono(s):

apotema = 0.5

angolo_partenza = math.pi/2.0 - math.pi/s.n

angolo_lato = 2.0*math.pi/s.n

lato = apotema * ( 2 * math.tan(math.pi / s.n) )

raggio = math.sqrt((lato/2.0)**2+apotema**2)

s.vertici = []

for a in range(s.n):

s.vertici.append([s.ratio*raggio*math.cos(angolo_partenza+a*angolo_lato),

raggio*math.sin(angolo_partenza+a*angolo_lato)])

def btn_calcola(s,event):

valore = s.testo.GetValue()

if s.verificaIntero(valore):

s.n = int(valore)

s.Refresh()

s.Update()

else:

wx.MessageBox(message="Inserire un valore intero da 3 a n",

caption="Errore!",

style=wx.OK | wx.ICON_ERROR)

def verificaIntero(s,val):

try:

v = int(val)

if v < 3: return False

return True

except ValueError:

return False

if __name__ == "__main__":

app = wx.App(False)

frame = Applicazione(None, "Disegnatore")

app.MainLoop()

Se lo eseguiamo abbiamo il nostro programma che ci permetterà di disegnare qualunque poligono regolare:

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

Problema: Quando si cerca di giocare una partita online con un altro giocatore amico dopo l’invito ed una breve attesa appare il messaggio “La connessione con l’avversario si è interrotta“.

Soluzione: Una possibile soluzione consiste nel disabilitare il protocollo IPv6 e attivare l’UPnP sul router ed infine riavviare il gioco

Premetto che come ISP ho Fastweb e la soluzione è stata testata sul router in dotazione e Windows 10. Procediamo nel modo seguente.

Cerchiamo il Pannello di controllo nel menu principale:

Andiamo su Rete e Internet:

Poi su Centro connessioni di rete e condivisione

Clicchiamo su Modifica impostazioni scheda nel menu sulla sinistra.

Individuiamo la nostra scheda di rete, nel mio caso Ethernet, e clicchiamo col destro, poi spostiamoci su Proprietà e clicchiamo.

Cerchiamo la voce Protocollo Internet versione 6 (TCP/IPv6) e togliamo la spunta.

Per precauzione impostiamo il DNS sui Google DNS spostandoci su Protocollo Internet versione 4 (TCP/IPv4), selezioniamolo (ma attenzione a NON TOGLIERE la spunta) e poi clicchiamo su Proprietà.

Impostiamo il DNS su 8.8.8.8 e 8.8.4.4

Premiamo OK su tutto quanto.

Adesso controlliamo che sul router sia attivo l’UPnP. Nel caso del router Fastweb andiamo su Home > Casella degli strumenti > Condivisione giochi e applicazioni

Verifichiamo che l’UPnP sia attivo nel modo seguente:

Su un router Netgear D6300 l’opzione si trova tra le impostazioni avanzate:

E dev’essere impostata nel modo seguente:

Fatte tutte queste belle cose riavviamo la connessione cliccando su Disabilita

E poi di nuovo Abilita sulla scheda di rete.

Adesso riavviamo il gioco. Fatto tutto questo il problema dovrebbe essersi risolto e potremo tornare a giocare.

In caso di altri problemi suggerisco anche l’articolo ufficiale Risoluzione dei problemi per connessione per PC

Jordan Pickford, uno dei miei giocatori preferiti, oltre che portiere dell’Everton

Installazione Ubuntu 18.04.2 LTS webserver pronto all’uso [per esordienti totali]

Abbiamo già visto come installare Ubuntu 16.04.2 LTS e predisporlo per fare da webserver. Stavolta voglio ripetere la procedura, utilizzando però l’ultima distribuzione a lungo termine ovvero Ubuntu 18.04.2 LTS.

Come al solito eseguiremo l’operazione utilizzando VirtualBox. Per chi lo volesse installare su una macchina fisica la procedura sarebbe comunque analoga.

1. Configurazione Ubuntu Server 18.04.2 LTS

Anzitutto procuriamoci la ISO dal sito ufficiale.

Selezioniamo la seguente configurazione e premiamo download.

A questo punto cominciamo a creare la macchina virtuale sulla quale faremo girare il nostro webserver. Dentro VirtualBox premiamo CTRL+N. Si avvierà la seguente schermata che prepariamo nel modo seguente:

Premiamo su Successivo. Ci verrà chiesto quanta RAM intendiamo assegnare, mettiamo almeno 1024MB (ossia 1GB).

Procediamo e scegliamo di creare un nuovo disco fisso virtuale.

Proseguiamo selezionando VDI e per lo spazio diciamo Allocato dinamicamente (questo vuol dire che il disco virtuale non occuperà immediatamente tutto lo spazio assegnato, ma solo via via che il sistema operativo ne avrà bisogno).

Lasciamo 10 GB di spazio.

A questo punto avviamo la macchina virtuale.e ci verrà chiesto di selezionare un disco di avvio. Se fosse stata una macchina fisica si sarebbe trattato del supporto di installazione, per esempio un CD oppure una penna USB. Nel nostro caso clicchiamo sulla cartellina gialla e andiamo a selezionare il file ISO che abbiamo scaricato in precedenza dal sito ufficiale.

Se abbiamo fatto tutto correttamente dovremmo vedere qualcosa di simile:

Premiamo su Avvia.

A questo punto inizierà il caricamento del programma di installazione finché non ci si presenterà la schermata dove scegliere la lingua.

Selezioniamo inglese. A quanto pare ancora non lo hanno tradotto in italiano.

Premiamo il tasto INVIO.

Usando le frecce direzionali, nella schermata successiva, posizioniamoci sui menu a tendina della lingua e premendo INVIO apriamolo. Selezioniamo la tastiera italiana e premiamo di nuovo INVIO. A questo punto torniamo, premendo la freccia verso il basso, su [Done].

Alla prossima schermata premiamo nuovamente INVIO.

A questo punto ci verrà chiesto come vogliamo configurare la scheda di rete. Se stiamo usando una macchina virtuale come VirtualBox la scheda di rete sarà identificata dal dispositivo enp0s3 (normalmente sarebbe eth0, eth1, ecc…). Premiamo nuovamente INVIO.

Alla richiesta di configurare il proxy lasciamo tutto così com’è e premiamo di nuovo INVIO.

Selezioniamo il mirror predefinito per le repository di Ubuntu premendo semplicemente INVIO.

Nella prossima schermata scegliamo come formattare il disco. In questo esempio voglio utilizzare LVM per la gestione dei dischi, quindi mi sposto sulla seconda voce e premo nuovamente INVIO.

Per maggiori approfondimenti sull’utilizzo del LVM suggerisco questo articolo.

Selezioniamo il disco da partizionare, che è anche l’unico disco di cui disponiamo in questo momento.

Arrivati a questo punto possiamo verificare l’intera configurazione ed apportare, eventualmente, delle modifiche. Nel nostro caso lasciamo tutto tale e quale e procediamo premendo INVIO.

Ci chiederà se siamo sicuri di proseguire. Proseguiamo 🙂

Adesso compiliamo i campi con il nostro nome, il nome del server, lo username e la password. Memorizziamo questi dati perché ne avremo bisogno per accedere al server una volta pronto.

Alla schermata successiva selezioniamo la casella di Installa OpenSSH server premendo la barra spaziatrice. Spostiamoci poi con le frecce su Done e proseguiamo premendo INVIO.

Nella schermata successiva spostiamoci immediatamente su Done premendo il tasto della tabulazione e poi di nuovo INVIO.

A questo punto inizierà l’installazione, non ci resta che aspettare pazientemente che finisca.

Quando sarà tutto finito ci troveremo di fronte ad una schermata come questa, dove ci viene chiesto di riavviare. Premiamo INVIO e riavviamo il sistema.

Poco dopo ci verrà chiesto di rimuovere il dispositivo di installazione. Premiamo semplicemente INVIO e aspettiamo.

ATTENZIONE: Normalmente ci si dovrebbe trovare di fronte alla seguente schermata:

ma operazioni in differita su questa ultima versione di Ubuntu fanno sì che si sovrappongano degli output oltre la schermata di login. Se compare qualcosa di simile a questo è sufficiente premere INVIO per avere accesso alla schermata di login.

A questo punto effettuiamo il login con le credenziali che abbiamo creato in precedenza.

Una volta dentro il sistema digitiamo ifconfig e dovremmo vedere un risultato simile a questo.

Come possiamo notare il server si trova sull’indirizzo 10.0.2.15 che è l’indirizzo automatico assegnato dalla rete virtuale NAT di VirtualBox alla macchina virtuale.

Quello che vogliamo fare adesso è creare una nostra rete NAT personalizzata sulla quale spostare il server. VirtualBox ci permette infatti di creare una rete interna che, rispetto al nostro computer host, sarà raggiungibile all’indirizzo 192.168.56.1. Tale indirizzo sarà, rispetto al server, l’indirizzo esterno con il quale la rete virtuale nella quale si trova il server si affaccerà alla rete nella quale si trova il computer host.

Andiamo perciò sul panello di controllo di VirtualBox, spostiamoci su File > Preferenze (raggiungibile anche premendo CTRL+G).

Spostiamoci su Rete e poi premiamo il pulsante con la scheda di rete e il simbolo più verde . Questo aggiungerà una nuova rete virtuale chiamata NatNetwork (nel mio caso ci sono già altre reti configurate). Restando su NatNetwork premiamo il terzo pulsante a destra con il simbolo dell’ingranaggio .

Impostiamo la rete nel modo seguente scegliendo come ID di rete 10.0.2.0/24:

Con l’IP Calculator possiamo testare i dettagli della rete, ma per quello che ci interessa avremo 254 host dal 10.0.2.1 al 10.0.2.254.

Premiamo OK e spostiamoci nelle impostazioni della nostra macchina virtuale.

Andiamo su Rete e impostiamo come tipo di rete Rete con NAT e il nome Rete Ubuntu, che abbiamo creato prima.

A questo punto torniamo dentro la nostra macchina virtuale e aggiorniamo lo stato della connessione di rete.

Per farlo digitiamo: sudo netplan apply

Digitiamo ifconfig e verifichiamo l’IP al quale è connesso adesso il nostro server. Nel mio caso è sempre 10.0.2.15

Adesso torniamo nelle Preferenze > Rete e andiamo ad impostare l’inoltro delle porte sulla rete che abbiamo creato.

Dal momento che vogliamo testare il server web con Apache e usare l’SSH per connetterci, dobbiamo inoltrare le porte 80, 443 e la 22. Per aggiungere nuove regole di inoltro premiamo sul tasto col più verde e compiliamo l’elenco nel modo seguente.

L’indirizzo 192.168.56.1 rappresenta l’indirizzo della scheda di rete virtuale creata da VirtualHost, con la quale possiamo collegarci dal nostro PC alla rete virtuale creata poc’anzi. Fatto tutto questo diamo OK a tutto e proviamo a collegarci alla nostra macchina utilizzando Putty.

Se abbiamo fatto tutto a dovere adesso la macchina dentro la rete NAT virtuale è raggiungibile dall’indirizzo esterno 192.168.56.1.

Configuriamo Putty e premiamo Open.

Se tutto è andato bene ci verrà chiesto di acquisire la chiave per la connessione. Diciamo di sì:

A questo punto entriamo dentro il sistema usando Putty.

Procediamo con l’installazione di Apache e degli altri componenti del server LAMP.

2. Installazione e configurazione Apache

Per installare Apache anzitutto aggiorniamo la repository di Ubuntu digitando:

sudo apt-get update

1	sudo apt-get update

Quando finisce l’operazione procediamo installando Apache e digitiamo:

sudo apt-get install apache2

1	sudo apt-get install apache2

Se tutto è andato bene possiamo andare all’indirizzo http://192.168.56.1/ e verificare che si veda una pagina come la seguente:

Questa è la pagina default del nostro server Apache. La possiamo anche modificare andando nella cartella /var/www/html che è la root default del server.

Proviamo a farlo digitando:

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

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

Dentro Putty dovremmo vedere qualcosa come questo:

A questo punto usciamo dall’editor nano premendo CTRL+X e poi rimuoviamo il file e mettiamone uno nuovo digitando.

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

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

Dentro il file scriviamo semplicemente:

E salviamo premendo CTRL+O. Premiamo INVIO per confermare e CTRL+X per uscire.

Tornando su http://192.168.56.1/ dovremmo vedere qualcosa di analogo a questo:

3. Installazione e configurazione MySQL

Per installare il database MySQL digitiamo:

sudo apt install mysql-server

1	sudo apt install mysql-server

Premiamo Y alla richiesta di conferma dell’installazione e poi aspettiamo che sia ultimata. Una volta completata digitiamo:

sudo mysql_secure_installation

1	sudo mysql_secure_installation

Questo avvierà una procedura di configurazione del nostro database, durante la quale ci verranno richieste diverse cose. Alle varie domande rispondiamo rispettivamente:

Press y|Y for Yes, any other key for No: Y

Please enter 0 = LOW, 1 = MEDIUM and 2 = STRONG: 2

(dove: STRONG Length >= 8, numeric, mixed case, special characters and dictionary file)

New password: )9@JZ21@pam)KUfB)2hc{n[vrK?BAeTU (questo è un esempio di password che possiamo mettere, questa password ha una qualità di 187bit e una lunghezza di 32 caratteri)

Se la passowrd è buona ci verrà detto qualcosa come:

Estimated strength of the password: 100

Proseguiamo:

Do you wish to continue with the password provided?(Press y|Y for Yes, any other key for No) : Y

Remove anonymous users? (Press y|Y for Yes, any other key for No) : Y

Disallow root login remotely? (Press y|Y for Yes, any other key for No) : Y

Remove test database and access to it? (Press y|Y for Yes, any other key for No) : Y

Reload privilege tables now? (Press y|Y for Yes, any other key for No) : Y

Fatto questo il database è pronto per l’utilizzo.

4. Installazione e configurazione PHP

Procediamo installando il PHP e digitando:

sudo apt install php libapache2-mod-php php-mysql

1	sudo apt install php libapache2-mod-php php-mysql

Confermiamo sempre con Y quando ci viene richiesto.

Una volta finito verifichiamo che sotto Apache le pagine index.php siano configurate come pagine predefinite:

sudo nano /etc/apache2/mods-enabled/dir.conf

1	sudo nano /etc/apache2/mods-enabled/dir.conf

Se tutto va bene vedremo qualcosa come:

Notiamo la presenza di index.php quindi possiamo procedere tranquillamente.

Per concludere riavviamo il server Apache.

sudo service apache2 restart

1	sudo service apache2 restart

5. Ulteriori configurazioni

A questo punto dovremmo fare ancora qualche implementazione, configurando alcune cose come:

Sistemare il Firewall
Mettere in sicurezza Apache
Configurare fail2ban ed altri eventuali servizi

Io procederò con un esempio su come configurare un nuovo VirtualHost e installarci sopra WordPress.

6. Configurazione VirtualHost e installazione WordPress

Quello che vogliamo fare adesso è aggiungere un dominio al nostro server, affinché alla richiesta di un sito web su tale dominio esso risponde.

In poche parole voglio aggiungere il sito torregatti.com al mio server. Per farlo dobbiamo aggiungere un host virtuale. (qui un esempio della solita procedura)

Per farlo voglio creare, dentro a /var/www/ una cartella dedicata al dominio e poi aggiungerlo ai VirtualHost di Apache.

Procediamo quindi nel modo seguente creando anzitutto la suddetta cartella che, per motivi di ordine, chiamerò come il dominio:

sudo mkdir /var/www/torregatti.com

1	sudo mkdir /var/www/torregatti.com

Adesso assegniamo la cartella ad Apache modificando i permessi e digitando:

sudo chown www-data:www-data /var/www/torregatti.com

1	sudo chown www-data:www-data /var/www/torregatti.com

Aggiungiamo il VirtualHost in sites-available copiando un modello esistente:

cd /etc/apache2/sites-available/
sudo cp 000-default.conf torregatti.com.conf
sudo nano torregatti.com.conf

cd /etc/apache2/sites-available/

sudo cp 000-default.conf torregatti.com.conf

sudo nano torregatti.com.conf

Modifichiamo il file che abbiamo appena copiato ed aperto fino ad ottenere qualcosa di simile:

<VirtualHost *:80>
        ServerName torregatti.com
        ServerAlias www.torregatti.com

        ServerAdmin webmaster@localhost
        DocumentRoot /var/www/torregatti.com

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

ServerName torregatti.com

ServerAlias www.torregatti.com

ServerAdmin webmaster@localhost

DocumentRoot /var/www/torregatti.com

ErrorLog ${APACHE_LOG_DIR}/error.log

CustomLog ${APACHE_LOG_DIR}/access.log combined

</VirtualHost>

In questo modo il nostro server risponderà sia al dominio torregatti.com che al sottodominio www.torregatti.com

Salviamo con CTRL+O e confermiamo premendo INVIO.

Abilitiamo il host digitando:

sudo a2ensite torregatti.com.conf

1	sudo a2ensite torregatti.com.conf

Ricarichiamo Apache digitando:

sudo service apache2 reload

1	sudo service apache2 reload

A questo punto possiamo testare la nostra configurazione da dentro Windows modificando il file hosts in C:\Windows\System32\drivers\etc\ impostandolo nel modo seguente:

# Copyright (c) 1993-2009 Microsoft Corp.
#
# This is a sample HOSTS file used by Microsoft TCP/IP for Windows.
#
# This file contains the mappings of IP addresses to host names. Each
# entry should be kept on an individual line. The IP address should
# be placed in the first column followed by the corresponding host name.
# The IP address and the host name should be separated by at least one
# space.
#
# Additionally, comments (such as these) may be inserted on individual
# lines or following the machine name denoted by a '#' symbol.
#
# For example:
#
#      102.54.94.97     rhino.acme.com          # source server
#       38.25.63.10     x.acme.com              # x client host

# localhost name resolution is handled within DNS itself.
#	127.0.0.1       localhost
#	::1             localhost

192.168.56.1 torregatti.com

# This is a sample HOSTS file used by Microsoft TCP/IP for Windows.

# This file contains the mappings of IP addresses to host names. Each

# entry should be kept on an individual line. The IP address should

# be placed in the first column followed by the corresponding host name.

# The IP address and the host name should be separated by at least one

# space.

# Additionally, comments (such as these) may be inserted on individual

# lines or following the machine name denoted by a '#' symbol.

# For example:

# 102.54.94.97 rhino.acme.com # source server

# 38.25.63.10 x.acme.com # x client host

# localhost name resolution is handled within DNS itself.

# 127.0.0.1 localhost

# ::1 localhost

192.168.56.1 torregatti.com

Salviamo e verifichiamo dal browser che il risultato sia simile a questo:

7. Installazione e configurazione di WordPress

Adesso voglio concludere installando WordPress sul nostro nuovo dominio appena creato.

Anzitutto spostiamoci dentro la cartella del dominio e scarichiamo WordPress digitando i seguenti comandi:

cd /var/www/torregatti.com/
sudo wget https://it.wordpress.org/latest-it_IT.zip

1 2	cd /var/www/torregatti.com/ sudo wget https://it.wordpress.org/latest-it_IT.zip

Installiamo zip e scompattiamo il pacchetto:

sudo apt-get install zip
sudo unzip latest-it_IT.zip

1 2	sudo apt-get install zip sudo unzip latest-it_IT.zip

Spostiamo tutti i file da dentro la cartella wordpress alla radice del dominio digitando:

sudo mv wordpress/* .

1	sudo mv wordpress/* .

Rimuoviamo la cartella wordpress:

sudo rmdir wordpress

1	sudo rmdir wordpress

Assegniamo tutti i file ad Apache, altrimenti avremo problemi durante l’utilizzo del portale (per esempio nel caricamento delle immagini).

sudo chown -R www-data:www-data .

1	sudo chown -R www-data:www-data .

Creiamo ora un database con utente per la torregatti.com

Accediamo al database digitando:

sudo mysql -u root

1	sudo mysql -u root

Creiamo un nuovo database digitando:

CREATE DATABASE torregatti_com;

1	CREATE DATABASE torregatti_com;

Creiamo un utente per il database e diamogli tutti i privilegi.

CREATE USER 'torregatti'@'localhost' IDENTIFIED BY 'HGOqXovUhyZJ4}08}eg-lAiOM])}@lYt';
GRANT ALL PRIVILEGES ON torregatti_com.* TO 'torregatti'@'localhost';
FLUSH PRIVILEGES;

CREATE USER 'torregatti'@'localhost' IDENTIFIED BY 'HGOqXovUhyZJ4}08}eg-lAiOM])}@lYt';

GRANT ALL PRIVILEGES ON torregatti_com.* TO 'torregatti'@'localhost';

FLUSH PRIVILEGES;

A questo punto andando su http://torregatti.com dovremmo vedere l’installazione di WordPress.

Completiamo tutti i dati che abbiamo già configurato:

Completiamo l’installazione seguendo le istruzioni a video ed abbiamo finito.

[python] Esercizio su utilizzo di socket e database

Proviamo a realizzare questo semplice esercizio: vorrei avere un server ed un client che possano comunicare tramite socket, in modo tale che il client possa richiedere al server dei dati, il server preleverà tali dati da un database MySQL e li invierà al client.

Lo schema dell’esercizio è approssimativamente questo:

Per svolgere l’esercizio utilizzerò un database con una tabella clienti costruita nel modo seguente:

--
-- Struttura della tabella `clienti`
--

CREATE TABLE `clienti` (
  `id` int(255) NOT NULL,
  `nome` varchar(100) NOT NULL,
  `indirizzo` varchar(1024) NOT NULL,
  `telefono` varchar(100) NOT NULL,
  `agente` int(255) NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=latin1;

--
-- Dump dei dati per la tabella `clienti`
--

INSERT INTO `clienti` (`id`, `nome`, `indirizzo`, `telefono`, `agente`) VALUES
(1, 'Mario Rossi', 'Via Roma 1', '00569865', 3),
(2, 'Luigi Verdi', 'Via Milano 12', '00495233', 3),
(3, 'Gianni Bianchi', 'Via Genova 123', '00683581', 3),
(4, 'Chiara Rossi', 'Via Pescara 54', '00401299', 2),
(5, 'Luisa Neri', 'Via Ottima 77', '00279150', 3),
(6, 'Giovanni Celesti', 'Via Belli 16', '00515977', 2),
(7, 'Marco Bruni', 'Via Neri 10', '00161097', 3),
(8, 'Sergio Sereni', 'Via Savona 15', '00121871', 2),
(9, 'Paolo Lumi', 'Via Novara 19', '00554018', 3),
(10, 'Paola Neri', 'Via Padova 199', '00249472', 3),
(11, 'Pietro Chiari', 'Via Pietra 290', '00600550', 2),
(12, 'Fabio Rossi', 'Via Venezia 2', '00270185', 2),
(13, 'Giuseppe Blandi', 'Via Napoli 8', '00462208', 3),
(14, 'Aldo Valdi', 'Via Vesuvio 200', '00572389', 2),
(15, 'Piero Storni', 'Via Otranto 9', '00278110', 3),
(16, 'Luigi L\'Avigno', 'Via Dell\'Altro', '055123456', 3),
(17, 'Luigi L\'Avigno', 'Via Dell\'Altro', '055123456', 3);

--
-- Indici per le tabelle scaricate
--

--
-- Indici per le tabelle `clienti`
--
ALTER TABLE `clienti`
  ADD PRIMARY KEY (`id`);

--
-- AUTO_INCREMENT per le tabelle scaricate
--

--
-- AUTO_INCREMENT per la tabella `clienti`
--
ALTER TABLE `clienti`
  MODIFY `id` int(255) NOT NULL AUTO_INCREMENT, AUTO_INCREMENT=18;COMMIT;

-- Struttura della tabella `clienti`

CREATE TABLE `clienti` (

`id` int(255) NOT NULL,

`nome` varchar(100) NOT NULL,

`indirizzo` varchar(1024) NOT NULL,

`telefono` varchar(100) NOT NULL,

`agente` int(255) NOT NULL

) ENGINE=InnoDB DEFAULT CHARSET=latin1;

-- Dump dei dati per la tabella `clienti`

INSERT INTO `clienti` (`id`, `nome`, `indirizzo`, `telefono`, `agente`) VALUES

(1, 'Mario Rossi', 'Via Roma 1', '00569865', 3),

(2, 'Luigi Verdi', 'Via Milano 12', '00495233', 3),

(3, 'Gianni Bianchi', 'Via Genova 123', '00683581', 3),

(4, 'Chiara Rossi', 'Via Pescara 54', '00401299', 2),

(5, 'Luisa Neri', 'Via Ottima 77', '00279150', 3),

(6, 'Giovanni Celesti', 'Via Belli 16', '00515977', 2),

(7, 'Marco Bruni', 'Via Neri 10', '00161097', 3),

(8, 'Sergio Sereni', 'Via Savona 15', '00121871', 2),

(9, 'Paolo Lumi', 'Via Novara 19', '00554018', 3),

(10, 'Paola Neri', 'Via Padova 199', '00249472', 3),

(11, 'Pietro Chiari', 'Via Pietra 290', '00600550', 2),

(12, 'Fabio Rossi', 'Via Venezia 2', '00270185', 2),

(13, 'Giuseppe Blandi', 'Via Napoli 8', '00462208', 3),

(14, 'Aldo Valdi', 'Via Vesuvio 200', '00572389', 2),

(15, 'Piero Storni', 'Via Otranto 9', '00278110', 3),

(16, 'Luigi L\'Avigno', 'Via Dell\'Altro', '055123456', 3),

(17, 'Luigi L\'Avigno', 'Via Dell\'Altro', '055123456', 3);

-- Indici per le tabelle scaricate

-- Indici per le tabelle `clienti`

ALTER TABLE `clienti`

ADD PRIMARY KEY (`id`);

-- AUTO_INCREMENT per le tabelle scaricate

-- AUTO_INCREMENT per la tabella `clienti`

ALTER TABLE `clienti`

MODIFY `id` int(255) NOT NULL AUTO_INCREMENT, AUTO_INCREMENT=18;COMMIT;

In aggiunta utilizzerò una classe MySQLdb personalizzata, sviluppata nel modo seguente e messa nel file database.py:

import mysql.connector

class MySQLdb():

    def __init__(s,dbhost,dbuser,dbpass,dbname):
        s.__dbhost = dbhost
        s.__dbuser = dbuser
        s.__dbpass = dbpass
        s.__dbname = dbname
        s.__db = None

        s.connect()

    def connect(s):
        s.__db = mysql.connector.connect(
            host = s.__dbhost,
            user = s.__dbuser,
            passwd = s.__dbpass,
            database = s.__dbname
            )

    def In(s,sql,*vals):
        cursor = s.__db.cursor()
        cursor.execute(sql,vals)
        s.__db.commit()
        return cursor.lastrowid

    def Out(s,sql,*vals):
        cursor = s.__db.cursor(dictionary=True)
        cursor.execute(sql,vals)
        result = cursor.fetchall()
        return result

    def __del__(s):
        s.__db.close()

import mysql.connector

class MySQLdb():

def __init__(s,dbhost,dbuser,dbpass,dbname):

s.__dbhost = dbhost

s.__dbuser = dbuser

s.__dbpass = dbpass

s.__dbname = dbname

s.__db = None

s.connect()

def connect(s):

s.__db = mysql.connector.connect(

host = s.__dbhost,

user = s.__dbuser,

passwd = s.__dbpass,

database = s.__dbname

)

def In(s,sql,*vals):

cursor = s.__db.cursor()

cursor.execute(sql,vals)

s.__db.commit()

return cursor.lastrowid

def Out(s,sql,*vals):

cursor = s.__db.cursor(dictionary=True)

cursor.execute(sql,vals)

result = cursor.fetchall()

return result

def __del__(s):

s.__db.close()

La cartella dell’intero progetto sarà organizzata nella maniera seguente:

client.py
librerie
└── database.py
└── __init__.py
server.py

Fatte queste premesse andiamo anzitutto a creare il nostro file server.py. Nel codice ho inserito i commenti ai vari passaggi:

from librerie.database import MySQLdb
import socket

#indirizzo di connessione
HOST = '127.0.0.1'
PORT = 8100

#con questa funzione estraiamo i dati
def estrai_dati():
    #colleghiamoci al database
    mysql = MySQLdb("localhost","root","","torregatti")
    #leggiamo tutti i clienti
    clienti = mysql.Out("SELECT * FROM clienti")
    #impostiamo una variabile, che alla fine restituiremo, su vuoto
    risultato = ""
    #leggiamo tutti i clienti
    for c in clienti:
        #aggiungiamo ciascun cliente ad una stringa
        risultato += "%s\t%s\t\t%s\n" % (c["id"],c["nome"],c["telefono"])
    return risultato

#creiamo la connessione al socket
#con AF_INET usiamo il protocollo TCP/IPv4
#SOCK_STREAM tipo di socket, l'unico veramente utile con SOCK_DGRAM
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#mettiamoci in ascolto sull'indirizzo locale e la porta scelta
s.bind((HOST, PORT))
s.listen(1) # 1 = numero massimo di connessioni in coda

#avviamo il ciclo di ascolto e chiamata
print "server avviato..."
while True:

    #mettiamo in attesa di connessione
    conn, addr = s.accept()
    #per avviare la lettura ci aspettiamo il codice LEGGI7711
    #non usiamo il ciclo while visto che il codice non supera i 1024Byte
    codice = conn.recv(1024)
    #se il codice e' giusto inviamo i dati del db
    if codice == "LEGGI7711":
        print "invio dati a", addr
        conn.sendall(estrai_dati())
    conn.close()
    #in caso di codice = CHIUDI chiudiamo il server
    if codice == "CHIUDI":
        print "chiudo server..."
        break

s.close()
print "server chiuso"

from librerie.database import MySQLdb

import socket

#indirizzo di connessione

HOST = '127.0.0.1'

PORT = 8100

#con questa funzione estraiamo i dati

def estrai_dati():

#colleghiamoci al database

mysql = MySQLdb("localhost","root","","torregatti")

#leggiamo tutti i clienti

clienti = mysql.Out("SELECT * FROM clienti")

#impostiamo una variabile, che alla fine restituiremo, su vuoto

risultato = ""

#leggiamo tutti i clienti

for c in clienti:

#aggiungiamo ciascun cliente ad una stringa

risultato += "%s\t%s\t\t%s\n" % (c["id"],c["nome"],c["telefono"])

return risultato

#creiamo la connessione al socket

#con AF_INET usiamo il protocollo TCP/IPv4

#SOCK_STREAM tipo di socket, l'unico veramente utile con SOCK_DGRAM

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

#mettiamoci in ascolto sull'indirizzo locale e la porta scelta

s.bind((HOST, PORT))

s.listen(1) # 1 = numero massimo di connessioni in coda

#avviamo il ciclo di ascolto e chiamata

print "server avviato..."

while True:

#mettiamo in attesa di connessione

conn, addr = s.accept()

#per avviare la lettura ci aspettiamo il codice LEGGI7711

#non usiamo il ciclo while visto che il codice non supera i 1024Byte

codice = conn.recv(1024)

#se il codice e' giusto inviamo i dati del db

if codice == "LEGGI7711":

print "invio dati a", addr

conn.sendall(estrai_dati())

conn.close()

#in caso di codice = CHIUDI chiudiamo il server

if codice == "CHIUDI":

print "chiudo server..."

break

s.close()

print "server chiuso"

Adesso è il momento del client.py.

import socket

#indirizzo di connessione, lo stesso del server
HOST = '127.0.0.1'
PORT = 8100

#dichiaro alcune variabili che potro' usare dopo
#nel menu di scelta, senza dover scrivere le opzioni da le virgolette
s = S = True
n = N = False
esci = -1
chiudi = -2

#iniziamo il ciclo di programma
while True:

    #controlliamo che non ci siano errori
    try:
        print "Leggi? (s/n/esci/chiudi): ",
        scelta = input()

        if scelta == esci: break

        if scelta:
            #colleghiamoci al socket
            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            s.connect((HOST,PORT))
            # INVIO IL CODICE AL SERVER
            s.sendall("LEGGI7711")
            #leggiamo qello che ci restituisce
            data = s.recv(1024)
            s.close()

            print data
        else:
            print "Lettura saltata"

        if scelta == chiudi:
            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            s.connect((HOST,PORT))
            # INVIO IL RICHIESTA CHIUSURA SERVER
            s.sendall("CHIUDI")
            s.close()

    #in caso di lettera o carattere non codificato
    except NameError:
        print "Opzione non valida"
    #in caso di pressione di invio
    except SyntaxError:
        print "Opzione non valida"

import socket

#indirizzo di connessione, lo stesso del server

HOST = '127.0.0.1'

PORT = 8100

#dichiaro alcune variabili che potro' usare dopo

#nel menu di scelta, senza dover scrivere le opzioni da le virgolette

s = S = True

n = N = False

esci = -1

chiudi = -2

#iniziamo il ciclo di programma

while True:

#controlliamo che non ci siano errori

try:

print "Leggi? (s/n/esci/chiudi): ",

scelta = input()

if scelta == esci: break

if scelta:

#colleghiamoci al socket

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

s.connect((HOST,PORT))

# INVIO IL CODICE AL SERVER

s.sendall("LEGGI7711")

#leggiamo qello che ci restituisce

data = s.recv(1024)

s.close()

print data

else:

print "Lettura saltata"

if scelta == chiudi:

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

s.connect((HOST,PORT))

# INVIO IL RICHIESTA CHIUSURA SERVER

s.sendall("CHIUDI")

s.close()

#in caso di lettera o carattere non codificato

except NameError:

print "Opzione non valida"

#in caso di pressione di invio

except SyntaxError:

print "Opzione non valida"

I risultati che dovremmo vedere sono rispettivamente:

1. Per il server vedo quando è stato avviato, da dove e da quale porta

2. Sul client vedo l’elenco presente sul database.