Petar Karan

[FIFA 20] Giocare utilizzando il controller della PS4 sul PC con DS4Windows

Dopo diverse peripezie sono giunto alla conclusione che per FIFA20 la soluzione migliore sia usare Steam Big Picture per le configurazioni del controller PS4. Qui la spiegazione su come fare.

Origin proprio non ne vuole sapere di rendere compatibili i controller DualShock di PS4 con i propri giochi, quindi bisogna munirsi di soluzioni alternative. Nel caso specifico si può usare DS4Windows. Però anche in questo caso le sorprese non mancano. Se con FIFA 19 basta avviare il programma, con FIFA 20 bisogna anche ricorrere all’opzione Hide DS4 Controller.

Anzitutto scarichiamo l’ultima versione di DS4Windows. Possiamo farlo dalla pagina del progetto ufficiale.

Scarichiamo l’ultima versione e scompattiamola nella posizione che preferiamo.

Troveremo un elenco di file in questo modo:

Se vogliamo possiamo aggiungere, per comodità, il collegamento all’eseguibile nel Menu Start. Per farlo clicchiamo col destro sull’eseguibile e selezioniamo l’opzione Aggiungi a Start.

Fatto tutto questo avviamo DS4Windows.exe.

Se non lo abbiamo ancora configurato partirà l’installazione del ViGEmBus Driver.

Nel mio caso cliccherò sullo Step 1: Installa the ViGEmBus Driver.

A questo punto spostiamoci sulla scheda delle impostazioni e spuntiamo l’opzione Hide DS4 Controller.

E’ possibile che ci appaia un messaggio di questo genere: Warning: Could not open DS4 90:89:5F:94:F3:53 exclusively. You must quit other applications like UWP apps (Netflix), Steam, Uplay, NVIDIA IN-GAME before activating the 'Hide DS4 Controller' option. For more info check https://github.com/Ryochan7/DS4Windows/wiki/Exclusive-Mode-(Hide-DS4-Controller-config-option)-tips-and-issues

Il programma ci sta avvisando, in sostanza, che altri programmi impediscono la disattivazione del controller che Windows vede automaticamente. Finché non lo disattiviamo il gioco vedrà entrambi i controller, sia quello creato dal DS4Windows, che quello installato direttamente su Windows stesso.

In poche parole, sul pannello di controllo, da Pannello di controllo > Hardware e suoni > Dispositivi e stampanti si vedranno 2 controller che in realtà sono uno solo:

Affinché l’operazione vada a buon fine dobbiamo disattivare tali programmi, chiudendo quindi tutte le applicazioni come Steam, Uplay oppure Origin stesso.

Inoltre dobbiamo disattivare anche la Sovrapposizione NVIDIA che utilizza il controller.

Per farlo andiamo su NVIDIA GeForce Experience cliccando col destro sull’icona nel vassoio di sistema:

Andiamo sulle impostazioni cliccando sull’ingranaggio in alto a destra:

Da qui deselezioniamo sovrapposizione di gioco.

A questo punto dovremmo essere in grado di usare tranquillamente il controller della PS4 emulato da DS4Windows.

Nel caso ci fossero problemi su questo ultimo passaggio riavviare il PC e prima di avviare qualunque altro programma far partire DS4Windows.

Se dopo il riavvio il controller continuasse a dare problemi, oppure non fosse accessibile a DS4Windows, andare in Pannello di controllo > Hardware e suoni > Dispositivi e stampanti e cliccare col destro su Wireless Controller selezionando l’opzione Rimuovi dispositivo.

Una volta rimosso staccare il cavo USB dal controller e riattaccarlo, aspettando l’installazione dei driver da parte di Windows.

Stimare budget e fattibilità di una campagna su Facebook (simulatore in Excel)

Link (anche in fondo) al Simulatore campagna pubblicitaria su Facebook (Excel)

Quando si intende fare una campagna pubblicitaria online bisogna tenere conto di diversi fattori, oltre che degli obiettivi per cui la campagna è pensata.

A differenza della pubblicità tradizionale (quella che si potrebbe fare sui giornali, sulla TV oppure sui cartelloni per strada) nelle campagne online è possibile verificare le conversioni prodotte dalla campagna stessa.

Con conversioni si intendono quelle azioni intraprese dagli utenti che hanno visto la pubblicità e per le quali la campagna pubblicitaria era stata pensata. Nel caso di una campagna pubblicitaria finalizzata alla promozione di prodotti, la conversione equivale all’acquisto di un prodotto. La conversione potrebbe essere anche l’iscrizione ad una newsletter, una richiesta di contatto o preventivo ecc.

Il processo di conversione può essere sintetizzato nel seguente schema:

Analizziamo brevemente i singoli passaggi del processo:

Impressioni: le volte che la pubblicità viene mostrata, se la pubblicità viene mostrata 30.000 volte allora si avranno 30.000 impressioni. Le impressioni sono sempre maggiori o uguali al pubblico raggiunto. Un pubblico di 20.000 persone potrebbe generare 30.000 impressioni. Questo vorrebbe dire che in media ogni persona raggiunta ha visto la pubblicità 1,5 volte. Questo valore viene chiamato anche frequenza.
Visite (o click): il numero di persone che, dopo aver visto la pubblicità, decidono di interagire con essa (o più semplicemente cliccano sull’inserzione). Il rapporto tra quelli che vedono la pubblicità e quelli che decidono di cliccare si chiama CTR (Click-through rate, in italiano “percentuale di click”). In generale come CTR medio si prende, in assenza di ulteriori dati statistici, un valore del 1%. Un CTR del 2% può essere già considerato ottimo. Questo valore dipende ovviamente anche dal messaggio pubblicitario stesso e da altri elementi. Un CTR molto elevato non è garanzia di alcun tipo di successo; significa solamente che le persone cliccano frequentemente sulla pubblicità. Un messaggio pubblicitario fuorviante potrebbe produrre un CTR molto elevato, che non corrisponde poi ad alcuna conversione significativa. Inoltre ad ogni click, in una campagna online, è associato un CPC (costo per click), ovvero quanto spendiamo per ogni click ottenuto. Se il CPC fosse di 0,50€ vorrebbe dire che per ogni click pendiamo 0,50€.
Leads: sono semplicemente dei potenziali acquirenti, persone interessate al prodotto, che ancora non hanno deciso di acquistare il prodotto stesso. Un lead potrebbe “condurre” (di qui il nome) anche altri eventuali clienti all’acquisto del prodotto, tramite per esempio il passaparola, sebbene egli stesso poi non effettui alcun acquisto. E’ importante tenere conto dei lead solo dal punto di vista concettuale; significa che dobbiamo pensare la nostra campagna in modo che le pagine ad essa dedicata (le landing page) suggeriscano oppure consentano all’utente di lasciare i propri dati di contatto o memorizzare la pagina, per poter essere contattato successivamente o recuperare facilmente l’accesso al prodotto. Dal punto di vista statistico del processo di conversione i lead possono essere ignorati.
Acquisti: sotto il termine acquisto si intende qui la finalizzazione della conversione, cioè quell’azione per cui la campagna è stata pensata. Nella maggior parte dei casi si tratta appunto dell’acquisto di un prodotto, ma potrebbe anche trattarsi di una richiesta di contatto, una donazione, un’iscrizione ad una newsletter o un gruppo, ecc. Il rapporto tra il numero di visitatori e il numero di acquisti, ovvero conversioni, viene chiamato tasso di conversione. Se per esempio ottengo 200 visite dalla campagna (click) e ne conseguono 2 acquisti, il tasso di conversione sarà del 1%. In media il tasso di conversione, in mancanza di ulteriori dati statistici a disposizione, oscilla tra il 1% e il 3%. Il tasso di conversione è anche chiamato CVR o CR (conversion rate)

Appurato tutto questo vediamo come valutare una campagna pubblicitaria su Facebook.

Anzitutto procuriamoci dei dati statistici sull’andamento del mercato, a tale proposito utilizzerò quelli pubblicati da WordStream: Facebook Ad Benchmarks for YOUR Industry [2019]

A titolo di esempio immaginiamo di voler fare una campagna pubblicitaria per vendere dei prodotti casalinghi (vasi, piatti, accessori, complementi d’arredo).

WordStream ci informa che il mercato (Home & Garden) di riferimento ha i seguenti valori:

CTR 0,71%

CPC 2,78$ = 2,50€

CVR 7,02%

Da questi valori possiamo calcolare il costo di una singola conversione (CPA, costo per azione o cost per action) nel modo seguente:

$CPA=\frac{1}{CVR}*CPC=\frac{CPC}{CVR}$

Nel nostro caso specifico avremmo quindi:

$CPA=\frac{2,50}{0,0702}=35,61$

Questo significa che per vendere 1 prodotto tramite la pubblicità dobbiamo spendere 35,61€

Questo è il valore più importante da tenere in considerazione. In generale si stima che il budget destinabile ad una campagna pubblicitaria rispetto al valore dell’evento (o dei prodotti che si intendono vendere) si dovrebbe aggirare entro il 12% di quest’ultimo.

Questa proprietà può essere estesa ai singoli prodotti, per cui se un prodotto viene venduto a 100€, il massimo che possiamo spendere in pubblicità per venderlo non dovrebbe superare i 12€. Naturalmente questo valore varia notevolmente da prodotto a prodotto e dai margini che abbiamo sul valore dei prodotti stessi.

Esempio: se intendiamo vendere delle camere di albergo mediante una campagna pubblicitaria, dobbiamo tener conto del fatto che sulle OTA le percentuali che vengono prelevate per la vendita si aggirano dal 15% al 18%. Questo significa che possiamo valutare la nostra campagna prendendo il 15% o il 18% come valore di riferimento. Se quindi una camera costa 80€ a notte possiamo spendere fino a 12€ o 14,40€ per cercare di venderla tramite una campagna pubblicitaria. Se la campagna pubblicitaria richiedesse una cifra superiore per venderla potremmo valutare se fare la campagna per la vendita di pacchetti vacanze (più notti per più persone) oppure rinunciare e affidarci alle OTA. Se per esempio il CPA fosse di 33€, vorrebbe dire che dovremmo vendere servizi (camere) ad almeno 183,33€ (nel nostro caso dovremmo proporre, nella pubblicità, non la singola notte, quanto prenotazioni da almeno 3 notti, dove 3 x 80€ = 240€).

Detto questo abbiamo capito quindi che attraverso una campagna online dobbiamo cercare di vendere prodotti per almeno 296,75€.

Dal momento che vendere casalinghi a questo prezzo non è facile (per proseguire sulla nostra ipotesi), dobbiamo valutare che tipo di offerta promuovere attraverso la campagna. Alcune idee potrebbero essere:

Incentivare una spesa di almeno 300€ (spedizioni gratuite, sconti, promozioni future, ecc)
Aggregare i prodotti in pacchetti (vendere per esempio set dello stesso prodotto o set preconfezionati di prodotti pronti all’uso)
Cambiare pubblico di destinazione (cambiare cioè il target; anziché vendere ai privati, potremmo indirizzare la campagna ad altri rivenditori, oppure ad albergatori che vogliono comprare set del medesimo prodotto per arredare diverse stanze nello stesso modo ecc.)

Attenzione! Resta il fatto che non possiamo sperare di vendere efficacemente prodotti che hanno un valore inferiore, per esempio un vaso da 20€, laddove la spesa per ottenere la vendita è di 35,61€.

Da questo si deduce un altro fatto importante: le campagne online non sono adatte alla vendita di qualsiasi prodotto.

Per facilitare questo tipo di calcoli ho realizzato un piccolo simulatore in Excel, che ci permette anche di tenere conto di ulteriori dati statistici, quali la dimensione del pubblico, il costo di gestione della campagna, la frequenza di visualizzazione della campagna ecc.

Immettendo i dati di poco prima otterremmo qualcosa di simile a questo:

Nella mia ipotesi ho immaginato una campagna da 5€ al giorno, per una durata totale di 10 giorni ed un pubblico di 10.000 persone. Il valore dei prodotti è di 20€. Il calcolatore mi dirà chiaramente che la campagna non è sostenibile.

Se cambiassi il valore dei prodotti a 300€ otterrei il seguente risultato:

Se adesso provassi ad aumentare il budget giornaliero, portandolo a 60€ al giorno, otterrei di nuovo una campagna fuori dai parametri preimpostati.

Questo perché raggiungendo la saturazione del pubblico (ricordiamoci che sto ipotizzando un pubblico di 10.000 individui) aumenterei la frequenza di visualizzazione che, secondo quanto suggerito da Facebook stesso, non dovrebbe superare i 2 punti. Più è alta la frequenza e più la campagna è onerosa.

E’ altrettanto vero che anche con un budget di 10€ al giorno ed un costo di gestione della campagna (quello che pago a chi la configura e gestisce) di 150€, la campagna resta non fattibile.

Per chiunque volesse cimentarsi in questo genere di simulazioni metto a disposizione il simulatore in Excel utilizzato qui sopra:

Simulatore Facebook Ads

Il simulatore è stato realizzato per il Corso di Social Media Marketing della Mummu Academy di Firenze.

[c#] Creare una classe per stampare con i font installati nella stampante

L’obiettivo è quello di inviare del testo alla stampante utilizzando i font nativi al suo interno e la libreria gdi32.dll di Windows. Questa volta integreremo tutto in una semplice applicazione in C#.

Anzitutto creiamo un semplice form con una TextBox chiamata txtTesto ed un Button chiamato btnStampa.

Aggiungiamo poi una nuova classe che estenda la classe System.Drawing.Printing.PrintDocument

class Stampante : System.Drawing.Printing.PrintDocument
{
    public Stampante() : base()
    {
            
    }
}

1

2

3

4

5

6

7

class Stampante : System.Drawing.Printing.PrintDocument

{

public Stampante() : base()

{

}

Per usare la classe anzitutto dobbiamo implementare alcuni metodi e creare i corrispondenti per le funzioni della libreria GDI32.

A tale scopo utilizzeremo l’istruzione [DllImport("gdi32.dll")] prima delle specifiche definizioni.

Le funzioni che dobbiamo implementare sono rispettivamente: CreateFont, SelectObject, DrawText, DeleteObject

Per maggiori riferimenti alle singole funzioni consiglio di visionare il sito Pinvoke.net

Detto tutto questo costruiamo la classe nel modo seguente:

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;

namespace EsempioStampante
{
    class Stampante : System.Drawing.Printing.PrintDocument
    {
        private float testX, testY, testW, testH;
        private String testTesto;
        private String fontString;
        private int dimensione;

        public Stampante() : base()
        {
            
        }

        public Stampante(String testo, String font, String size, String x, String y, String w, String h) : base()
        {
            testTesto = testo;
            fontString = font;
            dimensione = Convert.ToInt32(size);
            testX = Convert.ToSingle(x);
            testY = Convert.ToSingle(y);
            testW = Convert.ToSingle(w);
            testH = Convert.ToSingle(h);
        }

        protected override void OnBeginPrint(System.Drawing.Printing.PrintEventArgs e)
        {
            base.OnBeginPrint(e);

        }

        [DllImport("gdi32.dll")]
        static extern IntPtr CreateFont(int nHeight, int nWidth, int nEscapement,
           int nOrientation, int fnWeight, uint fdwItalic, uint fdwUnderline, uint
           fdwStrikeOut, uint fdwCharSet, uint fdwOutputPrecision, uint
           fdwClipPrecision, uint fdwQuality, uint fdwPitchAndFamily, string lpszFace);

        [DllImport("gdi32.dll", EntryPoint = "SelectObject")]
        public static extern IntPtr SelectObject([In] IntPtr hdc, [In] IntPtr hgdiobj);

        [StructLayout(LayoutKind.Sequential)]
        public struct DRAWTEXTPARAMS
        {
            public uint cbSize;
            public int iTabLength;
            public int iLeftMargin;
            public int iRightMargin;
            public uint uiLengthDrawn;
        }

        private struct RectStr
        {
            public int Left, Top, Right, Bottom;
            public RectStr(Rectangle r)
            {
                this.Left = r.Left;
                this.Top = r.Top;
                this.Bottom = r.Bottom;
                this.Right = r.Right;
            }
        }

        [DllImport("user32.dll")]
        static extern int DrawText(IntPtr hDC, string lpString, int nCount, ref RectStr lpRect, uint uFormat);

        [DllImport("gdi32.dll", EntryPoint = "DeleteObject")]
        [return: MarshalAs(UnmanagedType.Bool)]
        public static extern bool DeleteObject([In] IntPtr hObject);

        protected override void OnPrintPage(System.Drawing.Printing.PrintPageEventArgs e)
        {
            base.OnPrintPage(e);
            
            IntPtr hdc = e.Graphics.GetHdc();
            IntPtr hfEPC = CreateFont(dimensione, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, fontString);
            IntPtr hSostituto = SelectObject(hdc, hfEPC);
            RectStr r = new RectStr(new Rectangle((int)testX, (int)testY, (int)testW, (int)testH));
            Int32 testo = DrawText(hdc, testTesto, testTesto.Length, ref r, 0);
            SelectObject(hdc, hSostituto);
            DeleteObject(hfEPC);
            e.Graphics.ReleaseHdc(hdc);

        }
    }
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

using System;

using System.Collections.Generic;

using System.Drawing;

using System.Linq;

using System.Runtime.InteropServices;

using System.Text;

using System.Threading.Tasks;

namespace EsempioStampante

{

class Stampante : System.Drawing.Printing.PrintDocument

{

private float testX, testY, testW, testH;

private String testTesto;

private String fontString;

private int dimensione;

public Stampante() : base()

{

}

public Stampante(String testo, String font, String size, String x, String y, String w, String h) : base()

{

testTesto = testo;

fontString = font;

dimensione = Convert.ToInt32(size);

testX = Convert.ToSingle(x);

testY = Convert.ToSingle(y);

testW = Convert.ToSingle(w);

testH = Convert.ToSingle(h);

}

protected override void OnBeginPrint(System.Drawing.Printing.PrintEventArgs e)

{

base.OnBeginPrint(e);

}

[DllImport("gdi32.dll")]

static extern IntPtr CreateFont(int nHeight, int nWidth, int nEscapement,

int nOrientation, int fnWeight, uint fdwItalic, uint fdwUnderline, uint

fdwStrikeOut, uint fdwCharSet, uint fdwOutputPrecision, uint

fdwClipPrecision, uint fdwQuality, uint fdwPitchAndFamily, string lpszFace);

[DllImport("gdi32.dll", EntryPoint = "SelectObject")]

public static extern IntPtr SelectObject([In] IntPtr hdc, [In] IntPtr hgdiobj);

[StructLayout(LayoutKind.Sequential)]

public struct DRAWTEXTPARAMS

{

public uint cbSize;

public int iTabLength;

public int iLeftMargin;

public int iRightMargin;

public uint uiLengthDrawn;

}

private struct RectStr

{

public int Left, Top, Right, Bottom;

public RectStr(Rectangle r)

{

this.Left = r.Left;

this.Top = r.Top;

this.Bottom = r.Bottom;

this.Right = r.Right;

}

[DllImport("user32.dll")]

static extern int DrawText(IntPtr hDC, string lpString, int nCount, ref RectStr lpRect, uint uFormat);

[DllImport("gdi32.dll", EntryPoint = "DeleteObject")]

[return: MarshalAs(UnmanagedType.Bool)]

public static extern bool DeleteObject([In] IntPtr hObject);

protected override void OnPrintPage(System.Drawing.Printing.PrintPageEventArgs e)

{

base.OnPrintPage(e);

IntPtr hdc = e.Graphics.GetHdc();

IntPtr hfEPC = CreateFont(dimensione, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, fontString);

IntPtr hSostituto = SelectObject(hdc, hfEPC);

RectStr r = new RectStr(new Rectangle((int)testX, (int)testY, (int)testW, (int)testH));

Int32 testo = DrawText(hdc, testTesto, testTesto.Length, ref r, 0);

SelectObject(hdc, hSostituto);

DeleteObject(hfEPC);

e.Graphics.ReleaseHdc(hdc);

}

Eseguiamo il test della funzione nel form principale:

namespace EsempioStampante
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void BtnStampa_Click(object sender, EventArgs e)
        {
            Stampante stampante = new Stampante(txtTesto.Text, "Courier New", "140", "50", "50", "2500", "200");
            stampante.Print();
        }
    }
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

namespace EsempioStampante

{

public partial class Form1 : Form

{

public Form1()

{

InitializeComponent();

}

private void BtnStampa_Click(object sender, EventArgs e)

{

Stampante stampante = new Stampante(txtTesto.Text, "Courier New", "140", "50", "50", "2500", "200");

stampante.Print();

}

In questo modo stamperemo attraverso la stampante predefinita.

Nel mio caso una stampante Samsung M2070, che riconosce come font “Courier New“.

[python] Utilizzare Python su Apache (configurazione con XAMPP)

Anzitutto assicuriamoci di avere Python installato sul nostro computer. Nel mio esempio procederò con l’installazione su Windows, ma anche nel caso di un server Linux la procedura è pressoché la medesima.

1. Individuiamo la cartella di installazione di Python

Nel mio caso l’eseguibile di Python si trova in D:/Python27/python.exe

Appuntiamoci questo valore perché ci servirà per dopo.

2. Configuriamo Apache modificando il file httpd.conf

Utilizzando XAMPP è sufficiente aprire il pannello di controllo e recarsi su Apache > Config > Apache (httpd.conf)

3. Aggiungiamo il handler per gli script cgi

In fondo al file di configurazione aggiungiamo le seguenti due righe per attivare la gestione degli script cgi

AddHandler cgi-script .py
ScriptInterpreterSource Registry-Strict

1 2	AddHandler cgi-script .py ScriptInterpreterSource Registry-Strict

In questo modo permettiamo ad apache di interpretare i file con estensione .py come script eseguibili mediante applicazioni interne al computer.

4. Aggiungiamo index.py alle pagine di default

Esattamente per quello che succede per index.htm oppure index.php, vogliamo che anche index.py venga letta come pagina predefinita di una cartella. (potremmo metterne anche altre a piacere)

Per farlo modifichiamo sempre il file httpd.conf che abbiamo aperto prima. Identifichiamo il punto dove c’è scritto <IfModule dir_module> e modifichiamo la configurazione nel modo seguente, aggiungendo index.py all’elenco

<IfModule dir_module>
    DirectoryIndex index.php index.pl index.cgi index.asp index.shtml index.html index.htm \
                   default.php default.pl default.cgi default.asp default.shtml default.html default.htm \
                   home.php home.pl home.cgi home.asp home.shtml home.html home.htm index.py
</IfModule>

1

2

3

4

5

DirectoryIndex index.php index.pl index.cgi index.asp index.shtml index.html index.htm \

default.php default.pl default.cgi default.asp default.shtml default.html default.htm \

home.php home.pl home.cgi home.asp home.shtml home.html home.htm index.py

</IfModule>

5. Riavviamo apache

Che lo si stia facendo su XAMPP, oppure su un server LAMP, a questo punto riavviamo Apache, banalmente premendo Stop e Start in sequenza.

6. Creiamo la prima pagina in Python

Dentro la cartella htdocs creiamo una cartella a piacere, che allo scopo di questo esempio io chiamerò python.

Dentro la cartella creiamo un file chiamato index.py con dentro le seguenti istruzioni:

#!D:/Python27/python.exe
print("Content-Type: text/html\n")

print ("Ciao mondo!")

1

2

3

4

#!D:/Python27/python.exe

print("Content-Type: text/html\n")

print ("Ciao mondo!")

Ricordiamoci l’indirizzo preso all’inizio al punto 1. Il percorso di installazione di Python andrà incluso in ciascun file. Inoltre è essenziale il primo print, che permette al browser di interpretare il contenuto come una pagina html.

Le prime 2 righe dovranno essere presenti in ogni pagina che si occuperà dell’output.

7. Esempio di una pagina semplice

Ovviamente dovremo aggiungere tutti gli opportuni tag del HTML, cosa che potremmo fare in questo modo:

#!D:/Python27/python.exe
print("Content-Type: text/html\n")


pagina = """
<!DOCTYPE html>
<html>

    <head>
        <title>Pagina in Python</title>
    </head>

    <body>

        <h1>Ciao mondo!</h1>

    </body>

</html>
"""

print pagina

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

#!D:/Python27/python.exe

print("Content-Type: text/html\n")

pagina = """

<!DOCTYPE html>

<html>

<head>

<title>Pagina in Python</title>

</head>

<body>

<h1>Ciao mondo!</h1>

</body>

</html>

"""

print pagina

8. Raccogliere i dati da POST e GET

Infine vediamo come raccogliere i dati dai due metodi principali con i quali l’utente può interagire con la nostra pagina web, il get e il post.

Per farlo importiamo anzitutto la libreria CGI aggiungendo in cima al file, dopo il percorso all’eseguibile di Python, import cgi

Avremo bisogno anche di gestire eventuali errori che se no non verranno mostrati nell’output. Per farlo importiamo anche cgitb aggiungendo le seguenti due righe:

import cgitb
cgitb.enable()

1 2	import cgitb cgitb.enable()

L’intestazione del nostra file diventerà:

#!D:/Python27/python.exe
import cgi
import cgitb
cgitb.enable()

print("Content-Type: text/html\n")

1

2

3

4

5

6

#!D:/Python27/python.exe

import cgi

import cgitb

cgitb.enable()

print("Content-Type: text/html\n")

A questo punto per raccogliere i dati, sia da POST che da GET utilizziamo l’istruzione dati = cgi.FieldStorage()

Modifichiamo tutta la pagina per funzionare con un piccolo form che utilizzi entrambi i metodi:

#!D:/Python27/python.exe
import cgi
import cgitb
cgitb.enable()

print("Content-Type: text/html\n")

extra = ""

dati = cgi.FieldStorage()

if "dati_form" in dati:
    if dati["dati_form"].value == "1":
        extra = "<h1>valore: " + dati["valore"].value + "</h1>";

pagina = """
<!DOCTYPE html>
<html>

    <head>
        <title>Pagina in Python</title>
    </head>

    <body>

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

        """+extra+"""

    </body>

</html>
"""

print pagina

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

#!D:/Python27/python.exe

import cgi

import cgitb

cgitb.enable()

print("Content-Type: text/html\n")

extra = ""

dati = cgi.FieldStorage()

if "dati_form" in dati:

if dati["dati_form"].value == "1":

extra = "<h1>valore: " + dati["valore"].value + "</h1>";

pagina = """

<!DOCTYPE html>

<html>

<head>

<title>Pagina in Python</title>

</head>

<body>

Valore: <input type="text" value="" name="valore">

</form>

"""+extra+"""

</body>

</html>

"""

print pagina

Faccio notare che se si cerca di chiamare la pagina http://127.0.0.1/python/?dati_form=1 si incorrerà in un errore come il seguente (senza la suddetta libreria avremmo visualizzato una pagina bianca):

Questo perché la chiave valore non è definita all’interno del contenitore dati.

Aggiungiamo quindi un controllo nel modo seguente:

#!D:/Python27/python.exe
import cgi
import cgitb
cgitb.enable()

print("Content-Type: text/html\n")

extra = ""

dati = cgi.FieldStorage()

if "dati_form" in dati:
    if dati["dati_form"].value == "1" and "valore" in dati:
        extra = "<h1>valore: " + dati["valore"].value + "</h1>";

pagina = """
<!DOCTYPE html>
<html>

    <head>
        <title>Pagina in Python</title>
    </head>

    <body>

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

        """+extra+"""

    </body>

</html>
"""

print pagina

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

#!D:/Python27/python.exe

import cgi

import cgitb

cgitb.enable()

print("Content-Type: text/html\n")

extra = ""

dati = cgi.FieldStorage()

if "dati_form" in dati:

if dati["dati_form"].value == "1" and "valore" in dati:

extra = "<h1>valore: " + dati["valore"].value + "</h1>";

pagina = """

<!DOCTYPE html>

<html>

<head>

<title>Pagina in Python</title>

</head>

<body>

Valore: <input type="text" value="" name="valore">

</form>

"""+extra+"""

</body>

</html>

"""

print pagina

[bash] Script per reimpostare i permessi della cartella system su Plesk

Oggi mi sono trovato di fronte al problema di reimpostare tutti i permessi sulla cartella /var/www/vhosts/system/ appartenente a Plesk.

Nel caso specifico esiste un articolo di riferimento della guida di Plesk su come reimpostare i permessi e quali dovrebbero essere quelli corretti. Per l’articolo originale vedere: How to restore default permissions in the virtual host directory on Linux?

Nell’articolo è possibile trovare anche un file bash che però non reimposta i permessi sulla cartella system.

Allora ne ho realizzato uno mio, seguendo lo schema dei permessi illustrato nell’articolo medesimo:

# ls -la /var/www/vhosts/system/example.com
total 24
drwx--x--x 6 root psaserv 4096 Jan 5 13:14 .
drwxr-xr-x 7 root root 4096 Jan 5 13:14 ..
drwxr-x--- 2 root psaserv 4096 Jan 5 13:15 conf
drwxr-xr-x 2 root root 4096 Jan 5 13:14 etc
drwx------ 2 psaadm root 4096 Jan 5 13:15 logs
dr-xr-x--- 6 root psaserv 4096 Jan 5 13:14 statistics

1

2

3

4

5

6

7

8

# ls -la /var/www/vhosts/system/example.com

total 24

drwx--x--x 6 root psaserv 4096 Jan 5 13:14 .

drwxr-xr-x 7 root root 4096 Jan 5 13:14 ..

drwxr-x--- 2 root psaserv 4096 Jan 5 13:15 conf

drwxr-xr-x 2 root root 4096 Jan 5 13:14 etc

drwx------ 2 psaadm root 4096 Jan 5 13:15 logs

dr-xr-x--- 6 root psaserv 4096 Jan 5 13:14 statistics

Il codice in bash è il seguente:

#!/bin/bash

#cartella di destinazione
cartella="/var/www/vhosts/system/"

for c in $(ls "$cartella"); do
        if [ -d "$cartella$c" ]
        then
                echo "imposto $cartella$c"
                chown root:psaserv "$cartella$c"
                chown root:psaserv "$cartella$c/conf"
                chown root:root "$cartella$c/etc"
                chown psaadm:root "$cartella$c/logs"
                chown root:psaserv "$cartella$c/statistics"
                chown root:psaserv "$cartella$c/pd"
        fi
done

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

#!/bin/bash

#cartella di destinazione

cartella="/var/www/vhosts/system/"

for c in $(ls "$cartella"); do

if [ -d "$cartella$c" ]

then

echo "imposto $cartella$c"

chown root:psaserv "$cartella$c"

chown root:psaserv "$cartella$c/conf"

chown root:root "$cartella$c/etc"

chown psaadm:root "$cartella$c/logs"

chown root:psaserv "$cartella$c/statistics"

chown root:psaserv "$cartella$c/pd"

fi

done

[wordpress] Problema video Revolution Slider 6 con Uncaught TypeError: Cannot read property ‘x’ of undefined

Problema: inserendo in Revolution Slider 6 delle slide con video in HTML5 (file mp4 nel caso particolare) lo slider non riesce ad avviarsi e provoca un loop infinito di errori nella console javascript.

Soluzione: l’errore dipende probabilmente da un altro plugin che provoca incompatibilità nel codice. Nel mio caso specifico l’errore era provocato da Enlighter – Customizable Syntax Highlighter. Disattivando il plugin lo slider torna a funzionare.

Nel caso specifico l’errore che si presenta è il seguente.

Uncaught TypeError: Cannot read property 'x' of undefined
at HTMLVideoElement.computePosition (mootools-core-yc.js?ver=3.10.0:4)
at HTMLVideoElement.setPosition (mootools-core-yc.js?ver=3.10.0:4)
at Object.R (revolution.tools.min.js?ver=6.0:46)
at Object.i._initProps (revolution.tools.min.js?ver=6.0:46)
at Object.i._init (revolution.tools.min.js?ver=6.0:46)
at Object.i.render (revolution.tools.min.js?ver=6.0:46)
at Object.i.render (revolution.tools.min.js?ver=6.0:46)
at Object.E._updateRoot.H.render (revolution.tools.min.js?ver=6.0:46)
at Object.i.dispatchEvent (revolution.tools.min.js?ver=6.0:45)
at s (revolution.tools.min.js?ver=6.0:45)

Oltre a cercare di correggere il file revolution.tools.min.js, cosa che sconsiglio caldamente, conviene verificare quali altri plugin stiano utilizzando mootools, perché probabilmente ci sono delle incompatibilità.

Disattivando il plugin in questione lo slider torna a funzionare correttamente.

[php] Modificare programmaticamente i prezzi nel carrello di WooCommerce su WordPress

Immaginiamo di voler modificare i prezzi dei prodotti su WooCommerce una volta che sono stati inseriti nel carrello. Nel mio esempio voglio aggiungere uno sconto del 50% su un prodotto quando vengono comprati almeno 2 prodotti dello stesso tipo.

Per fare questo anzitutto voglio calcolare quanto verrebbe il costo di un singolo prodotto affinché la somma di tutti i prodotti, dello stesso tipo, risulti tale che 1 solo dei prodotti sia scontato al 50%.

Ammettiamo che n sia il numero di prodotti (n ≥ 2), s lo sconto (nel mio caso 50%) e x il prezzo di ciascun prodotto. Avremo

$n*x=x*s+(n-1)*x$

$x = x*(s+n-1)/n$

Stabilito questo usiamo il hook per WooCommerce woocommerce_before_calculate_totals inserendo il nostro calcolo per ultimo (dopo tutti gli eventuali plugin).

La base del codice che vogliamo usare è la seguente:

add_action( 'woocommerce_before_calculate_totals', 'modifica_prezzi', 1000, 1);
function modifica_prezzi( $cart ) {

    // Questo è necessario per WC 3.0+
    if ( is_admin() && ! defined( 'DOING_AJAX' ) )
        return;

    // Evitiamo chiamate ripetute del hook
    if ( did_action( 'woocommerce_before_calculate_totals' ) >= 2 )
        return;

    // Controlliamo tutti i prodotti nel carrello
    foreach ( $cart->get_cart() as $prodotto ) {
	// TODO calcoli sul prezzo
    }
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

add_action( 'woocommerce_before_calculate_totals', 'modifica_prezzi', 1000, 1);

function modifica_prezzi( $cart ) {

// Questo è necessario per WC 3.0+

if ( is_admin() && ! defined( 'DOING_AJAX' ) )

return;

// Evitiamo chiamate ripetute del hook

if ( did_action( 'woocommerce_before_calculate_totals' ) >= 2 )

return;

// Controlliamo tutti i prodotti nel carrello

foreach ( $cart->get_cart() as $prodotto ) {

// TODO calcoli sul prezzo

}

Questa funzione può essere inserita dentro functions.php del nostro tema.

Detto questo dobbiamo anche prendere in considerazione che sul prezzo finale del prodotto potrebbero incidere ulteriori parametri (derivati magari da altri plugin) che potrebbero variare il prezzo. Per ovviare a questo problema legherò il hook alla fine di tutte le altre eventuali operazioni (da qui il valore 1000 nell’ordinamento di esecuzione del hook) e calcolerò il prezzo a partire da quello base, applicando poi il modificatore che sarebbe risultato prima del mio sconto.

La nuova funzione sarà la seguente:

add_action( 'woocommerce_before_calculate_totals', 'modifica_prezzi', 1000, 1);
function modifica_prezzi( $cart ) {

    // Questo è necessario per WC 3.0+
    if ( is_admin() && ! defined( 'DOING_AJAX' ) )
        return;

    // Evitiamo chiamate ripetute del hook
    if ( did_action( 'woocommerce_before_calculate_totals' ) >= 2 )
        return;

    // Controlliamo tutti i prodotti nel carrello
    foreach ( $cart->get_cart() as $prodotto ) {
		if( $prodotto['quantity'] >= 2 ) {
			$prezzo_prodotto = get_post_meta($prodotto['product_id'] , '_price', true);
			$prezzo_attuale = $prodotto['data']->get_price();
			$prezzo_extra = $prezzo_attuale - $prezzo_prodotto;
			$prezzo_scontato = $prezzo_prodotto * (0.5+$prodotto['quantity']-1)/$prodotto['quantity'] + $prezzo_extra;
			$prodotto['data']->set_price( $prezzo_scontato );
		}
    }
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

add_action( 'woocommerce_before_calculate_totals', 'modifica_prezzi', 1000, 1);

function modifica_prezzi( $cart ) {

// Questo è necessario per WC 3.0+

if ( is_admin() && ! defined( 'DOING_AJAX' ) )

return;

// Evitiamo chiamate ripetute del hook

if ( did_action( 'woocommerce_before_calculate_totals' ) >= 2 )

return;

// Controlliamo tutti i prodotti nel carrello

foreach ( $cart->get_cart() as $prodotto ) {

if( $prodotto['quantity'] >= 2 ) {

$prezzo_prodotto = get_post_meta($prodotto['product_id'] , '_price', true);

$prezzo_attuale = $prodotto['data']->get_price();

$prezzo_extra = $prezzo_attuale - $prezzo_prodotto;

$prezzo_scontato = $prezzo_prodotto * (0.5+$prodotto['quantity']-1)/$prodotto['quantity'] + $prezzo_extra;

$prodotto['data']->set_price( $prezzo_scontato );

}

Volendo calcolare il valore scontato al 50% al parametro p ho inserito il valore 0.5.

In questo modo calcoliamo il prezzo finale che dovrebbe avere ciascun prodotto, affinché risulti che la somma dei prodotti sia la somma di un prodotto scontato al 50% e di tutti gli altri a prezzo pieno (compresi gli eventuali modificatori).

[android] Macchina virtuale AVD estremamente lenta a partire e nell’esecuzione

Problema: la macchina virtuale AVD (Android Virtual Device) è estremamente lenta sia nell’avvio che durante l’esecuzione

Soluzione: Installare Intel x86 Emulator Accelerator (HAXM) dall’SDK Manager e utilizzare l’opzione Host GPU.

Apriamo anzitutto l’SDK Manager e dalla sezione Extras assicuriamoci che sia installato il pacchetto Intel x86 Emulator Accelerator (HAXM installer). Se non lo fosse installiamolo.

Quando poi configuriamo la macchina virtuale assicuriamoci di impostare la CPU su Intel Atom (x86) e spuntare l’opzione Use Host GPU.

[apache] Utilizzare ApacheBench per testare le performance del nostro server Apache

Anzitutto installiamo ApacheBench se non lo abbiamo già fatto, eseguendo il comando:

sudo apt-get install apache2-utils

1	sudo apt-get install apache2-utils

Normalmente Apache viene eseguito sulla porta 80 (http) e 443 (https), ma queste porte possono cambiare, come, per esempio, nel caso di una configurazione combinata con nGinx. Per scoprire su quali porte si trova Apache è sufficiente digitare da terminale:

netstat -anp | grep apache

1	netstat -anp \| grep apache

Dovremmo vedere un output simile a questo:

In questo caso testiamo apache sulle porte 7080 e 7081.

Per lanciare il test digitiamo:

ab -n 500000 -c 500 -s 3600 http://localhost:7080/

1	ab -n 500000 -c 500 -s 3600 http://localhost:7080/

Questo eseguirà 500.000 richieste a pacchetti di 500 richieste per volta (richieste concorrenti). Il parametro -s 3600 imposta il timeout per l’esecuzione su 3600 secondi, mentre il valore predefinito è di 30 secondi.

Otterremo un risultato simile a questo:

Questo significa che per rispondere a 500.000 richieste al tasso di 500 richieste per volta, il server ha impiegato in tutto 25,163 secondi. Il tempo medio per ogni chiamata (500 richieste concorrenti) è di 25,163 millisecondi. Il tempo medio per ogni singola richiesta concorrente è quindi di 0,050 ms, dove 25,163ms / 500 = 0,050326 ms.

Adesso possiamo provare ad aumentare il carico sul server aumentando il numero di richieste concorrenti.

ab -n 500000 -c 1000 -s 3600 http://localhost:7080/

1	ab -n 500000 -c 1000 -s 3600 http://localhost:7080/

Il risultato sarà simile a questo:

Vediamo come il tempo per singola richiesta concorrente è passato da 0,050 ms a 0,660 ms. Il numero di richieste concorrenti è aumentato di 2 volte, mentre il tempo di risposta è aumentato di 13,2 volte.

Se proviamo ad eseguire invece 5.000 richieste concorrenti digitando:

ab -n 500000 -c 5000 -s 3600 http://localhost:7080/

1	ab -n 500000 -c 5000 -s 3600 http://localhost:7080/

Otterremo il seguente errore:

socket: Too many open files (24)

Questo significa che abbiamo superato il massimo numero di file aperti contemporaneamente e consentiti dal sistema. Tale configurazione dipende dalle configurazioni di sicurezza del sistema ed è modificabile in /etc/security/limits.conf

Digitiamo:

sudo nano /etc/security/limits.conf

1	sudo nano /etc/security/limits.conf

Dentro il file possiamo stabilire i singoli servizi quali limiti avranno, per aumentare il limite di tutti i servizi possiamo aggiungere in fondo al file:

* soft nofile 65536 
* hard nofile 65536

1 2	* soft nofile 65536 * hard nofile 65536

Questo imposterà il limite al massimo valore consentito.

Se volessimo impostare il limite a 5000 file contemporanei dovremmo digitare ovviamente 5000.

Lo stesso risultato si può ottenere con:

ulimit -n 5000

1	ulimit -n 5000

Il comando non renderà la modifica persistente e al prossimo riavvio il valore tornerà a quello predefinito.

A questo punto possiamo ritentare il benchmark con:

ab -n 500000 -c 4000 -s 3600 http://localhost:7080/

1	ab -n 500000 -c 4000 -s 3600 http://localhost:7080/

Attenzione ad eseguirlo al netto del limite possibile, perché è probabile che si raggiunga la saturazione per via di altri file aperti quando si è prossimi al limite.

[mysql] Aumentare le performance del database MySQL

Questo esempio è sviluppato su un server Ubuntu con le seguenti caratteristiche:

32GB di RAM @2133 MHz, CPU Intel Xeon E3-1270v6 – quad core, 3,8GHz, 500GB disco SSD.

Le caratteristiche del server sono importanti, quanto il carico di lavoro che si intende sostenere per ottenere una giusta configurazione.

Prima di procedere oltre valutiamo anche lo stato iniziale del server ed eventualmente monitoriamo il carico di lavoro, per capire quanto margine abbiamo per le operazioni di calibrazione. A tale scopo ci saranno utili 2 programmi di Ubuntu.

Anzitutto usiamo htop per verificare l’uso di risorse della nostra macchina.

Se non dovessimo averlo installo eseguiamo:

sudo apt-get install htop

1	sudo apt-get install htop

Eseguendo htop da terminale dovremmo vedere una situazione simile a questa:

In questo caso possiamo notare che il server è scarico (in questo preciso momento).

Altro strumento che voglio utilizzare è mysqltuner. Questo ci permetterà di monitorare la situazione del server MySQL. Prima di lanciarlo è utile lasciare il server operativo per un tempo sufficiente (si parla di giorni o settimane, dipende dalla variabilità nell’utilizzo).

Se non disponiamo di mysqltuner installiamolo eseguendo:

sudo apt-get install mysqltuner

1	sudo apt-get install mysqltuner

Una volta eseguito, digitando semplicemente:

mysqltuner

1	mysqltuner

Vedremo un output con diverse statistiche e in fondo un elenco di raccomandazioni simile a questo:

A questo punto procediamo a modificare il file /etc/mysql/my.cnf impostando nuovi parametri (e poi provandoli).

Digitiamo dunque:

sudo nano /etc/mysql/my.cnf

1	sudo nano /etc/mysql/my.cnf

Andiamo ad impostare i seguenti parametri, di cui ne analizziamo alcuni:

innodb_buffer_pool_size

Questo parametro ci permette di impostare il pool del buffer. Il valore deve essere un multiplo del parametro innodb_buffer_pool_chunk_size moltiplicato per il parametro innodb_buffer_pool_instances. Il valore predefinito di innodb_buffer_pool_chunk_size è di 128MB, mentre innodb_buffer_pool_instances è impostato su 16.

Questo significa che un valore di 8GB per innodb_buffer_pool_size va bene, perché 8GB = 8192MB da cui 8192MB / ( 16 * 128MB ) = 4 (un numero intero).

Invece un valore di 15GB non andrebbe bene, perché 15GB = 15360MB da cui 15360MB / ( 16 * 128MB ) = 7,5 (un numero decimale).

query_cache_size

Il MySQL può tenere in cache le query già utilizzate, aumentando così notevolmente la velocità di esecuzione e le performance.

Anzitutto verifichiamo che la cache sia abilitata usando il commando:

SHOW VARIABLES LIKE 'have_query_cache';

1	SHOW VARIABLES LIKE 'have_query_cache';

Dopodiché possiamo impostare le seguenti variabili:

query_cache_size=2G
query_cache_limit=128M
query_cache_type=1

1

2

3

query_cache_size=2G

query_cache_limit=128M

query_cache_type=1

Le specifiche dimensioni dipendono dalla nostra disponibilità di RAM sul server.

max_connections

Questo parametro ci permette di stabilire il numero massimo di connessioni. Il valore predefinito è 150. Aumentando questo valore aumenterà il consumo di RAM.

Attenzione! Durante queste configurazioni assicuriamoci che la stima di memoria utilizzata da parte di mysqltuner non superi la massima memoria disponibile nel sistema, come in questo caso:

Entrambi i valori dovrebbero risultare OK, come nel seguente esempio:

Per fare una stima in anticipo sulle prestazioni possiamo usare il MySQL Calculator su questo indirizzo.

La precedente stima si ottiene sulla seguente configurazione di parametri:

innodb_buffer_pool_size=8G
innodb_buffer_pool_instances=8
query_cache_size=2G
query_cache_limit=128M
query_cache_type=1
max_connections=150
max_allowed_packet=512M
tmp_table_size=512M
max_heap_table_size=512M
thread_cache_size = 16K
table_cache = 1K
table_definition_cache = 4K
open_files_limit = 3K
key_buffer = 64M
long_query_time = 10
join_buffer_size=64M

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

innodb_buffer_pool_size=8G

innodb_buffer_pool_instances=8

query_cache_size=2G

query_cache_limit=128M

query_cache_type=1

max_connections=150

max_allowed_packet=512M

tmp_table_size=512M

max_heap_table_size=512M

thread_cache_size = 16K

table_cache = 1K

table_definition_cache = 4K

open_files_limit = 3K

key_buffer = 64M

long_query_time = 10

join_buffer_size=64M

Aumentando i valori naturalmente si aumenterà la quantità di risorse potenzialmente consumate dal database.

Una volta finite le modifiche al file my.cnf riavviamo il servizio MySQL digitando:

sudo service mysql restart

1	sudo service mysql restart

Come ultima operazione ottimizziamo il database, lanciando il seguente commando:

mysqlcheck -uadmin --optimize --all-databases

1	mysqlcheck -uadmin --optimize --all-databases

Se stiamo usando Plesk possiamo anche usare:

MYSQL_PWD=`cat /etc/psa/.psa.shadow` mysqlcheck -uadmin --optimize --all-databases

1	MYSQL_PWD=`cat /etc/psa/.psa.shadow` mysqlcheck -uadmin --optimize --all-databases

In questo modo la password dell’utente admin del database verrà prelevata dal file di configurazione di Plesk.

Fatto tutto questo monitoriamo il sistema e apportiamo eventuali correzioni.