HTTP messages are the foundation of web development.

Standardizzare questo aspetto è importantissimo poiché i messaggi Http sono le fondamenta dello sviluppo web. I browser ed i client come cURL inviano richieste Http al server che fornisce un’adeguata risposta Http.

Di seguito analizzeremo le interfacce proposte dal PSR-7 che rappresentano astrazioni dei messaggi Http e degli elementi che li compongono. Per il significato delle parole chiave presenti nell’articolo si rimanda alle note dell’articolo sul PSR-1.

Http Request

Iniziamo esaminando il contenuto di una Http Request.

POST /path HTTP/1.1
Host: example.com

foo=bar&baz=bat

La prima riga, detta “request line”, contiene il metodo della richiesta Http, il target della richiesta Http, solitamente una URI assoluta o un percorso sul server web, la versione del protocollo Http utilizzato. A questo seguono una o più intestazioni Http, una riga vuota ed il corpo del messaggio.

Http Response

Esaminiamo ora il contenuto di una Http Response.

HTTP/1.1 200 OK
Content-Type: text/plain

This is the response body

La prima riga di una Http Response, detta “status line”, contiene la versione del protocollo Http, il codice di stato Http ed una descrizione comprensibile del codice di stato. Come per il messaggio di richiesta, questa riga è seguita da una o più intestazioni Http, una riga vuota ed il corpo del messaggio.

PSR-7: specifiche

Messaggi Http

Un messaggio Http è una richiesta da un client ad un server o una risposta da un server ad un client. PSR-7 definisce le rispettive interfacce per i messaggi Http: Psr\Http\Message\RequestInterface e Psr\Http\Message\ResponseInterface.

Entrambe estendono Psr\Http\Message\MessageInterface.
Mentre <a href="#MessageInterface">Psr\Http\Message\MessageInterface</a> PUÒ essere implementato direttamente, gli implementatori DOVREBBERO implementare Psr\Http\Message\RequestInterface e Psr\Http\Message\ResponseInterface.
Per migliorare la lettura dell’articolo, da qui in avanti verrà omesso il namespace Psr\Http\Message per riferirsi a queste interfacce.

HTTP Headers

Nomi case-insensitive nei campi di intestazione.

I messaggi Http possono includere vari campi nell’intestazione (header) senza distinzione tra maiuscole e minuscole. Allo stesso modo dovranno essere recuperate dalle classi che implementano <strong><em><a href="#MessageInterface">MessageInterface</a></em></strong>.
Ad esempio, il recupero dell’intestazione foo restituirà lo stesso risultato del recupero dell’intestazione FoO. Allo stesso modo, l’impostazione dell’intestazione Foo sovrascriverà qualsiasi valore di intestazione foo precedentemente impostato.

$message = $message->withHeader('foo', 'bar');

echo $message->getHeaderLine('foo');
// Outputs: bar

echo $message->getHeaderLine('FOO');
// Outputs: bar

$message = $message->withHeader('fOO', 'baz');

echo $message->getHeaderLine('foo');
// Outputs: baz

Nonostante le intestazioni possano essere recuperate senza distinzione tra maiuscole e minuscole, il case originale DEVE essere rispettato nell’implementazione, in particolar modo quando viene recuperato con getHeaders(). Questo perché applicazioni Http non conformi possono dipendere da un determinato caso.

Campi di intestazione con valori multipli

Per gestire campi di intestazione con più valori e fornire una migliore flessibilità nella gestione, le intestazioni possono essere recuperate da un’istanza di <strong><em>MessageInterface</em></strong> come array o stringa. Nel primo caso useremo <strong>getHeader()</strong>, nel secondo <strong>getHeaderLine()</strong>.

$message = $message
    ->withHeader('foo', 'bar')
    ->withAddedHeader('foo', 'baz');

$header = $message->getHeaderLine('foo');
// $header contiene: 'bar,baz'

$header = $message->getHeader('foo');
// ['bar', 'baz']

Da notare che non tutti i valori di intestazione possono essere concatenati con la virgola (es: Set-Cookie). In questo caso gli utilizzatori DOVREBBERO usare metodo getHeader() per recuperare tali intestazioni multivalore.

Intestazione “Host”

Nelle richieste, l’intestazione Host riporta l’host dell’URI, nonché l’host utilizzato per stabilire la connessione Tcp. Le specifiche del protocollo Http consentono però all’intestazione Host di differire da entrambi. Le implementazioni, se non viene fornita alcuna intestazione Host, DEVONO tentare di impostarla da un URI predefinito .

<strong>RequestInterface :: withUri (UriInterface $uri, $preserveHost = false)</strong>, per impostazione predefinita, sostituirà l’intestazione Host della richiesta restituita con quella dell’oggetto di tipo <strong>UriInterface</strong> passatogli. Per mantenere il valore originale basterà passare true al secondo argomento ($preservHost). Ciò manterrà invariata l’intestazione Host a patto che il messaggio ne contenga una.

Questa tabella mostra cosa restituirà getHeaderLin('Host') per una richiesta restituita da withUri() con l’argomento $preservHost impostato su true in varie richieste iniziali e URI.

1. Valore dell’intestazione host prima dell’operazione.
2. Componente host dell’URI composto nella richiesta prima dell’operazione.
3. Componente host dell’URI settato tramite withUri().

Streams

I messaggi Http sono costituiti da una riga iniziale, alcune intestazioni ed un corpo che può essere anche molto grande. Rappresentare il body di un messaggio come una stringa potrebbe consumare molta memoria fino a precludere la possibiltà di lavorare con body di grandi dimensioni. <strong>StreamInterface</strong> viene utilizzato proprio per nascondere i dettagli di implementazione quando un flusso di dati viene letto o scritto. Per le situazioni in cui una stringa sarebbe un’implementazione del messaggio appropriata, è possibile utilizzare flussi incorporati come php://memory e php://temp.

StreamInterface espone diversi metodi che consentono di leggere, scrivere e scorrere gli stream in modo efficace.

Gli stram espongono le loro capacità utilizzando tre metodi: isReadable(), <strong>isWritable()</strong> e <strong>isSeekable()</strong>. Gli oggetti che vogliono utilizzare uno stream possono utilizzare questi metodi per determinare se è in grado di soddisfare determinati requisiti.

Ogni istanza di uno stream avrà diverse funzionalità: può essere di sola lettura, di sola scrittura o di lettura/scrittura. Può consentire un accesso casuale arbitrario (ricerca in avanti o indietro in qualsiasi posizione) o solo accesso sequenziale come nel caso di socket, pipe, o callback-based stream.

Infine, StreamInterface definisce un metodo __toString() per recuperare o inviare l’intero contenuto del corpo in una sola volta.

A differenza delle interfacce di Request e Response, StreamInterface interagisce con gli stream che, per loro natura, possono mutare durante il loro utilizzo. La raccomandazione di Php-Fig è di utilizzare flussi di sola lettura per le richieste lato server e le risposte lato client.

Target della richiesta ed URI

Secondo lo standard RFC 7230 i messaggi di richiesta contengono uno dei seguenti tipi di “target”:

• origin-form: costituito da percorso e, se presente, stringa della query. È solitamente definito come un URL relativo. I messaggi trasmessi via Tcp sono tipicamente di tipo origin-form; i dati di scheme e authority sono presenti tramite variabili CGI.
• absolute-form: costituito da scheme, authority (“[user-info@]host[:port]”, dove gli elementi tra parentesi sono facoltativi), percorso (se presente), stringa della query (se presente) e fragment ( se presente). È solitamente definito come un URI assoluto ed è l’unico che consente di specificare una URI come descritto nel RFC 3986. Questo modulo è comunemente usato quando si effettuano richieste ai proxy Http
• authority-form: costituito dalla sola authority. È solitamente utilizzato nelle CONNECT Request per stabilire una connessione tra un client Http e un server proxy.
• asterisk-form: costituito unicamente dalla stringa asterisco ( ” * ” ). È solitamente utilizzato con il metodo OPTIONS per determinare le capacità generali di un server web.

Oltre a questi target di richiesta, c’è spesso un “URL effettivo” che è separato dal target di richiesta. L’URL effettivo non viene trasmesso all’interno di un messaggio Http, ma viene utilizzato per determinare il protocollo (http / https), la porta e l’host-name per effettuare la richiesta.

L’URL effettivo è rappresentato da <strong>UriInterface</strong>. UriInterface rappresenta gli URI Http e Https fornendo i metodi per interagire con le varie parti dell’URI evitendo un’analisi ripetuta dell’URI. Specifica inoltre un metodo __toString() per rappresentare la URI come stringa.

Quando si recupera la destinazione della richiesta con <strong>getRequestTarget()</strong>, per impostazione predefinita questo metodo utilizzerà l’oggetto URI ed estrarrà tutti i componenti necessari per costruire l’origin-form che è il request-target più comune.

Se si desidera utilizzare uno degli altri tre tipi di target o se l’utente desidera sovrascrivere esplicitamente il target della richiesta si utilizzerà il metodo <strong>withRequestTarget()</strong>. La chiamata a questo metodo non influisce sull’URI, poiché viene restituito da <strong>getUri()</strong>.

Ad esempio, un utente potrebbe voler effettuare una richiesta in formato asterisco a un server:

$request = $request
    ->withMethod('OPTIONS')
    ->withRequestTarget('*')
    ->withUri(new Uri('https://example.org/'));

L’esempio creerebbe questo tipo di richiesta Http:

OPZIONI * HTTP / 1.1

Il client Http sarà poi in grado di utilizzare l’URL effettivo (getUri()) per determinare il protocollo, l’host-name e la porta Tcp.

Un client Http DEVE ignorare i valori di <strong>Uri::getPath()</strong> e <strong>Uri::getQuery()</strong> ed utilizzare il valore restituito da <strong>getRequestTarget()</strong> che concatena questi due valori.

I client che scelgono di non implementare 1 o più dei 4 request-target form, DEVONO comunque utilizzare <strong>getRequestTarget()</strong>. Questi client DEVONO rifiutare request-target che non supportano e NON DEVONO utilizzare i valori di <strong>getUri()</strong>.

<strong>RequestInterface</strong> fornisce metodi per recuperare il target della richiesta o creare una nuova istanza specificando il target. Per impostazione predefinita, se non viene specificato il request-target, <strong>getRequestTarget()</strong> restituirà l’origin-form della URI composta o ” / ” se non è stata composta una URI. withRequestTarget($requestTarget) crea una nuova istanza con il request-target specificato ed è utile per creare connessioni verso un server.

Richieste Server-side

• <strong>RequestInterface</strong> permette di rappresentare un messaggio di richiesta Http, ma le richieste lato server side richiedono un’attenzione particolare. I processi server-side devono tener conto della Common Gateway Interface (CGI) e dell’interazione di PHP con essa attraverso le sue via Server API (SAPI) . PHP ci fornisce una semplificazione per la gestione degli input attraverso variabili superglobali:
• <strong>$_COOKIE</strong>: deserializza e fornisce un accesso ai cookie Http.
• <strong>$_GET</strong>: deserializza e fornisce un accesso agli argomenti della query string.
• $_POST: deserializza e fornisce un accesso per i parametri inviati tramite. Post Http. Può essere considerato il risultato dell’analisi del message body.
• $_FILES: fornisce metadati relativi ai caricamenti dei file.
• $_SERVER: fornisce l’accesso alle variabili d’ambiente CGI / SAPI che includono il metodo di richiesta, lo schema di richiesta, l’URI della richiesta e le intestazioni.

ServerRequestInterface estende RequestInterface per fornire un’astrazione su questi variabili superglobali riducendo l’accoppiamento.

La richiesta server-side fornisce una proprietà aggiuntiva, gli “attributi”, che consentono di esaminare, scompore e cercare match in modo da interpretare la richiesta in base alle specifiche necessità nell’applicativo.

Upload dei file

<strong>ServerRequestInterface</strong> specifica un metodo per recuperare una rappresentazione dei file caricati attraverso una struttura normalizzata in cui ogni elemento è un’istanza di <strong>UploadedFileInterface</strong>.

$_FILES ha alcuni problemi noti, ad esempio se si tenta di inviare da un form molteplici file attraverso campi di input aventi name “files”, l’array risultante verrà così rappresentato da PHP:

array(
    'files' => array(
        'name' => array(
            0 => 'file0.txt',
            1 => 'file1.html',
        ),
        'type' => array(
            0 => 'text/plain',
            1 => 'text/html',
        ),
        /* etc. */
    ),
)

Mentre ci si aspetterebbe una rappresentazione di questo tipo:

array(
    'files' => array(
        0 => array(
            'name' => 'file0.txt',
            'type' => 'text/plain',
            /* etc. */
        ),
        1 => array(
            'name' => 'file1.html',
            'type' => 'text/html',
            /* etc. */
        ),
    ),
)

Gli utilizzatori devono conoscere quindi i dettagli dell’implementazione nel linguaggio PHP e scrivere il codice per interpretare correttamente i dati di un determinato caricamento.

In alcuni casi poi $_FILES non viene popolato con i dati relativi ai file caricati:

• Quando il metodo Http non è POST.
• Quando si esegue una unit test.
• Quando si opera in un ambiente non SAPI come ad esempio ReactPHP.

In questi casi si dovranno utilizzare approcci diversi, ad esempio:

• Un processo potrebbe analizzare il message body per scoprire i file caricati.
• Negli scenari di unit test, gli sviluppatori devono essere in grado di bloccare e/o simulare i metadati di caricamento del file per convalidare e verificare i diversi scenari.

<strong>getUploadedFiles()</strong> fornisce una struttura normalizzata e l’implementazione dovrebbe:

• Aggregare tutte le informazioni per un determinato caricamento di file e usarle per popolare un’istanza <strong>Psr\Http\Message\UploadedFileInterface</strong>.
• Ricreare la struttura ad albero inviata in cui ogni foglia rappresenti un’istanza di <strong>Psr\Http\Message\UploadedFileInterface</strong> appropriata.
• La struttura ad albero dovrebbe seguire la struttura dei nomi in cui sono stati inviati i file.

Vediamo un esempio con un singolo campo di input con un “name semplice”:

<input type="file" name="avatar" />

In questo caso, la struttura di $ _FILES sarebbe:

array(
    'avatar' => array(
        'tmp_name' => 'phpUxcOty',
        'name' => 'my-avatar.png',
        'size' => 90996,
        'type' => 'image/png',
        'error' => 0,
    ),
)

Mentre la forma normalizzata restituita da getUploadedFiles() potrebbe essere:

array(
    'avatar' => /* UploadedFileInterface instance */
)

Vediamo invece un caso di campo di input che utilizza crea un array nell’attributo nome:

<input type="file" name="my-form[details][avatar]" />

In questo caso il contenuto di $_FILES sarà

array (
    'my-form' => array (
        'name' => array (
            'details' => array (
                'avatar' => 'my-avatar.png',
            ),
        ),
        'type' => array (
            'details' => array (
                'avatar' => 'image/png',
            ),
        ),
        'tmp_name' => array (
            'details' => array (
                'avatar' => 'phpmFLrzD',
            ),
        ),
        'error' => array (
            'details' => array (
                'avatar' => 0,
            ),
        ),
        'size' => array (
            'details' => array (
                'avatar' => 90996,
            ),
        ),
    ),
)

E l’albero corrispondente restituito da getUploadedFiles() dovrebbe essere:

array(
    'my-form' => array(
        'details' => array(
            'avatar' => /* UploadedFileInterface instance */
        ),
    ),
)

Vediamo ora il caso di un array di file:

Upload an avatar: <input type="file" name="my-form[details][avatars][]" />
Upload an avatar: <input type="file" name="my-form[details][avatars][]" />

Ecco cosa conterrà $_FILES:

array (
    'my-form' => array (
        'name' => array (
            'details' => array (
                'avatar' => array (
                    0 => 'my-avatar.png',
                    1 => 'my-avatar2.png',
                    2 => 'my-avatar3.png',
                ),
            ),
        ),
        'type' => array (
            'details' => array (
                'avatar' => array (
                    0 => 'image/png',
                    1 => 'image/png',
                    2 => 'image/png',
                ),
            ),
        ),
        'tmp_name' => array (
            'details' => array (
                'avatar' => array (
                    0 => 'phpmFLrzD',
                    1 => 'phpV2pBil',
                    2 => 'php8RUG8v',
                ),
            ),
        ),
        'error' => array (
            'details' => array (
                'avatar' => array (
                    0 => 0,
                    1 => 0,
                    2 => 0,
                ),
            ),
        ),
        'size' => array (
            'details' => array (
                'avatar' => array (
                    0 => 90996,
                    1 => 90996,
                    3 => 90996,
                ),
            ),
        ),
    ),
)

L’array sopra riportato corrisponderebbe alla seguente struttura restituita da <strong>getUploadedFiles()</strong>:

array(
    'my-form' => array(
        'details' => array(
            'avatars' => array(
                0 => /* UploadedFileInterface instance */,
                1 => /* UploadedFileInterface instance */,
                2 => /* UploadedFileInterface instance */,
            ),
        ),
    ),
)

Per accedere all’elemento [1]:

$request->getUploadedFiles()['my-form']['details']['avatars'][1];

Seguendo il nostro esempio avremo:

$file0 = $request->getUploadedFiles()['files'][0];
$file1 = $request->getUploadedFiles()['files'][1];

printf(
    "Received the files %s and %s",
    $file0->getClientFilename(),
    $file1->getClientFilename()
);

Poiché le inforazioni sui file caricati, oltre che da $_FILES, possono derivare da altri elementi della richiesta, è presente il metodo <strong>withUploadedFiles()</strong> che consente di delegare la normalizzazione ad un altro processo.

Lo standard PSR-7 considera anche le implementazioni in ambienti non SAPI. Pertanto, UploadedFileInterface fornisce metodi per garantire che le operazioni funzionino indipendentemente dall’ambiente. In particolare:

• moveTo($targetPath) viene fornito come alternativa sicura e consigliata per richiamare move_uploaded_file() sul file di caricamento temporaneo. Le implementazioni rileveranno il corretto funzionamento da utilizzare in base all’ambiente.
• <strong>getStream()</strong> restituirà un’istanza StreamInterface. In ambienti non SAPI, una possibilità proposta è quella di eseguire il parsing dei file caricati nello stream php://temp.

Ad esempio:

// Move a file to an upload directory
$filename = sprintf(
    '%s.%s',
    create_uuid(),
    pathinfo($file0->getClientFilename(), PATHINFO_EXTENSION)
);
$file0->moveTo(DATA_DIR . '/' . $filename);

// Stream a file to Amazon S3.
// Assume $s3wrapper is a PHP stream that will write to S3, and that
// Psr7StreamWrapper is a class that will decorate a StreamInterface as a PHP
// StreamWrapper.
$stream = new Psr7StreamWrapper($file1->getStream());
stream_copy_to_stream($stream, $s3wrapper);

PSR-7: Interfacce

Psr\Http\Message\MessageInterface

interface MessageInterface {
    /**
     * Recupera la versione del protocollo HTTP (Es: "1.1", "1.0")
     *
     * @return string HTTP protocol version.
     */
    public function getProtocolVersion();

    /**
     * Restituisce un'istanza con una specifica versione del protocollo HTTP
     *
     * @param string $version HTTP protocol version
     * @return static
     */
    public function withProtocolVersion($version);

    /**
     * Recupera tutti i valori di intestazione del messaggio
     *
     * @return string[][] Returns an associative array of the message's headers.
     */
    public function getHeaders();

    /**
     * Verifica se esiste un'intestazione in base al nome senza distinzione tra maiuscole e minuscole.
     *
     * @param string $name Case-insensitive header field name.
     * @return bool
     */
    public function hasHeader($name);

    /**
     * Recupera un valore di intestazione del messaggio in base al nome senza distinzione tra maiuscole e minuscole.
     *
     * @param string $name Case-insensitive header field name.
     * @return string[] An array of string values as provided for the given header.
     */
    public function getHeader($name);

    /**
     * Recupera una stringa separata da virgole dei valori per una singola intestazione.
     *
     * @param string $name Case-insensitive header field name.
     * @return string A string of values as provided for the given header concatenated together using a comma.
     */
    public function getHeaderLine($name);

    /**
     * Restituisce un'istanza sostituendo il valore dell'intestazione specificata.
     *
     * @param string $name Case-insensitive header field name.
     * @param string|string[] $value Header value(s).
     * @return static
     * @throws \InvalidArgumentException for invalid header names or values.
     */
    public function withHeader($name, $value);

    /**
     * Restituisce un'istanza appendendo un valore al campo di intestazione specificato.
     *
     * @param string $name Case-insensitive header field name to add.
     * @param string|string[] $value Header value(s).
     * @return static
     * @throws \InvalidArgumentException for invalid header names or values.
     */
    public function withAddedHeader($name, $value);

    /**
     * Restituisce un'istanza eliminando l'intestazione specificata.
     *
     * @param string $name Case-insensitive header field name to remove.
     * @return static
     */
    public function withoutHeader($name);

    /**
     * Ottiene il corpo del messaggio.
     *
     * @return StreamInterface Returns the body as a stream.
     */
    public function getBody();

    /**
     * Restituisce un'istanza con il corpo del messaggio specificato.
     *   
     * @param StreamInterface $body Body.
     * @return static
     * @throws \InvalidArgumentException When the body is not valid.
     */
    public function withBody(StreamInterface $body);
}

L'articolo PSR-7 Http Message: standard php per Request e Response. sembra essere il primo su Cesare Bordi | Innovation Manager & Back-end Developer.

Guida comandi linux

L'articolo Guida ai comandi Linux più utilizzati da Terminale sembra essere il primo su Cesare Bordi | Innovation Manager & Back-end Developer.

Cosa sono i namespaces in php?

What are namespaces? In the broadest definition namespaces are a way of encapsulating items.

I namespaces, introdotti in PHP 5.3 e migliorati in PHP 7, permettono di raggruppare classi, interfacce, funzioni e costanti per evitare ambiguità di denominazione. In questo modo potremo far coesistere classi con lo stesso nome “incapsulate” in namespace differenti esattamente come avviene per file con lo stesso nome posti in cartelle diverse del filesystem. La possibilità di creare una gerarchizzazione (sub-namespace) fornisce una chiara indicazione sull’organizzazione delle risorse del nostro applicativo. Ad esempio, assegnando i namespaces Framework\Core\Main ad un file contenente una classe e Framework\Core\Main\Libs ad un altro contenente un’altra classe con il medesimo nome, è facilmente intuibile come la prima si riferisca alle funzionalità di base del nostro ipotetico framework e l’altra sia presente in una libreria secondaria.

Pur essendo forte l’analaogia con il filesystem non sussite alcuna relazione diretta fra un namespace ed il percorso dei file .php. E’ però intuitivo utilizzare questa analogia per creare vincoli convenzionali e sfruttarli nella pratica dell’autoloading la cui implementazione più diffusa è sintetizzata nello standard PSR-4 che approfondirò in un altro articolo.

Namespaces: vantaggi di utilizzo

• Risolvono il problema di omonimia di classi, interfacce, funzioni e costanti tra il codice scritto dallo sviluppatore, quello integrato in librerire di terze parti e quello nativo di Php.
• Facilitano lo sviluppo di codice ordinato, organizzato ed “eloquente”.
• Migliorano la leggibilità e la scrittura del codice permettendo di utilizzare degli alias nel momento in cui la precisa ed inevitabile lunghezza del namespace non fosse necessaria.

Namespaces: dichiarazione

Compresi i vantaggi del loro utilizzo vediamo come utilizzare i namespaces iniziando dalla loro dichiarazione attraverso l’apposita keyword <strong>namespace</strong>.
Uno script che faccia uso di namespaces deve dichiararlo all’inizio del listato fatta eccezione per i commenti ed eventuali istruzioni declare.

<?php
declare(encoding='UTF-8');

// Dichiaro il namespace...
namespace Framework\Core\Main;

Attenzione!

• I namespaces non possono contenere keywords del linguaggio php.
  Framework\Core\<s>Class</s>
• I namespaces non possono iniziare con un numero.
  Framework\Core\<s>1Class</s>
• E’ possibile, ma altamente sconsigliato, dichiarare più namespaces nello stesso file utilizzando le parentesi graffe.
  <?php<br /><em><strong>Framework\Core\Main</strong></em> { // codice }<br /><em><strong>Framework\Core\Libs</strong></em> { // codice }

Php Namespaces: dalla teoria alla pratica

Immaginiamo di creare ed includere due file php contenenti la dichiarazione di una classe denominata nello stesso modo (Es: MyClass). Una volta in esecuzione otterremmo questo errore:
<strong>Fatal error</strong>: Cannot declare class MyClass, because the name is already in use

Aggiungiamo ora ai due file una dichiarazione namespace…

<?php // File 1: /Framework/Core/Main/MyClass.php

namespace Framework\Core\Main;

Class MyClass {
    public function __construct() {
        echo '<p>MAIN: MyClass ready!</p>';
    }
}

<?php // File 2: /Framework/Core/Main/Libs/MyClass.php

namespace Framework\Core\Main\Libs;

Class MyClass {
    public function __construct() {
        echo '<p>LIBS: MyClass ready!</p>';
    }
}

Creiamo ora il file principale ex01.php che li includerà e tenterà di creare un oggetto.

<?php // File: /ex01.php

// Includo i file
require_once('Framework/Core/Main/MyClass.php');
require_once('Framework/Core/Main/Libs/MyClass.php');

// Creo l'oggetto
$objOne = New MyClass();

Mandandolo in esecuzione ci troveremo davanti ancora un errore…
<strong>Fatal error</strong>: Uncaught Error: Class 'MyClass' not found in...

Questo si verifica poichè le nostre due classi “MyClass” sono assegnate ai rispettivi namespaces, mentre il nostro file principale non ha alcun namespace specificato e si riferisce quindi a quello globale in cui la classe MyClass() non è definita.

Namespaces: tipi di riferimento

Sappiamo definire i namespaces, ma per richiamarli correttamente dobbiamo conoscere quali sono i tipi di riferimento che possiamo utilizzare e che nuovamente hanno una forte analogia con i percorsi dei filesystem:

• Unqualified name (nomi non qualificati): si riferiscono solo al namespace corrente. È come cercare un fille nella cartella in cui ci si trova.
  MyClass()
• Qualified name (nomi qualificati): paragonabile al percorso relativo di un file.
  Main\Libs\MyClass()
• Fully-qualified name (nomi completamente qualificati): inizia sempre con un backslash iniziale ed è paragonabile ad un percorso assoluto. È il modo più sicuro anche se più verboso.
  \Framework\Core\Main\Libs\MyClass()

Unqualified name – Nel file principale (ex02.php) dichiariamo lo stesso namespace di uno dei due file contenenti la dichiarazione di MyClass() che vorremmo richiare, ad esempio Libs: Framework\Core\Main\Libs. Ecco finalmente il primo risultato positivo!

<?php // File: /ex02.php

// Dichiaro il namespace
namespace Framework\Core\Main\Libs;

// Includo i file
require_once('Framework/Core/Main/MyClass.php');
require_once('Framework/Core/Main/Libs/MyClass.php');

// UNQUALIFIED NAME...
$objOne = New MyClass();

Qualified name – Nel file principale (ex03.php) dichiariamo un namespace più generico Framework\Core ed utilizzamo nomi qualificati per riferirci ad entrambe le nostre classi ed ottenere i relativi oggetti.

<?php
// File: /ex03.php

// Dichiaro il namespace
namespace Framework\Core;

require_once('Framework/Core/Main/MyClass.php');
require_once('Framework/Core/Main/Libs/MyClass.php');

// QUALIFIED NAME...
$objOneMain = New Main\MyClass();
$objOneLib = New Main\Libs\MyClass();

Nota: una volta dichiarato un namespace, per riferirsi al contesto globale è necessario anteporre il backslash.

Fully-qualified name – Nel file principale (ex04.php) omettiamo il namespace, ma utilizziamo un nome completamente qualificato per riferirci alle due classi.

<?php // File: /ex04.php

// Includo i file
require_once('Framework/Core/Main/MyClass.php');
require_once('Framework/Core/Main/Libs/MyClass.php');

// FULLY-QUALIFIED NAME...
$objOneMain = New \Framework\Core\Main\MyClass();
$objOneLib = New \Framework\Core\Main\Libs\MyClass();

Php Namespaces: importazione e aliasing tramite l’operatore “use”

Una caratteristica importante dei namespaces è la possibilità di essere importati e di creare degli alias per renderne più pratico l’utilizzo vista la loro “eloquenza”. Queste funzioni trovano un parallelismo nella capictà dei filesystem di creare link simbolici a file o cartelle.
A tale scopo Php mette a disposizione la keyword <strong>use</strong> con la quale è possibile eseguire i seguenti tipi di seguenti tipi di importazione/aliasing:

• nomi di classi o interfacce (use Name\Space\ClassName),
• nomi di classi o interfacce globali (use DateTime)
• namespaces (use Name\Space\For\...)
• nomi di funzioni (use function Name\Space\FunctionName)
• nomi di costanti (use const Name\Space\CONSTANT).

E’ possibile importare anche più elementi nello stesso file purché non si generino delle ambiguità, in tal caso si potrà ricorrere agli alias.

Applichiamo use al nostro scenario di esempio (ex05.php) per importare i namespaces comuni alla due classi e sintetizzarli in “Main”.

<?php // File: /ex05.php

use Framework\Core\Main as Main;

// Includo i file
require_once('Framework/Core/Main/MyClass.php');
require_once('Framework/Core/Main/Libs/MyClass.php');

// QUALIFIED NAME...
$objOneMain = New Main\MyClass();
$objOneLib = New Main\Libs\MyClass();

Nell’esempio seguente (ex06.php) utilizziamo use per superare l’ambiguita dei nomi delle classi e creare un alias dei namespaces.

<?php // File: /ex06.php

use Framework\Core\Main\MyClass as MainMy;
use Framework\Core\Main\Libs\MyClass as LibsMy;

// Includo i file
require_once('Framework/Core/Main/MyClass.php');
require_once('Framework/Core/Main/Libs/MyClass.php');

// UNQUALIFIED NAME...
$objOneMain = New MainMy();
$objOneLib = New LibsMy();

Direi sia tutto! Qui trovate i file di esempio visti nella lezione e se l’articolo è stato utile… condividilo!

L'articolo Php Namespaces sembra essere il primo su Cesare Bordi | Innovation Manager & Back-end Developer.

Scenario: dobbiamo convertire lato server un’immagine RGB in CMYK

Problema: letta la scarna documentazione di Imagemagick sulla refernece di Php ci imbattiamo in un annoso problema: l’immagine ottenuta è in negativo!!!

Soluzione: dopo aver letto post su post sui soliti siti senza riuscire a trovare una soluzione e grazie al supporto di Giacomarco, ecco svelato il mistero.

Se si deve convertire un’immagine occorre usare transformimagecolorspace, mentre se si sta generando un’immagine ex-novo allora si deve utilizzare transformimagecolorspace:

$image->transformimagecolorspace(Imagick::COLORSPACE_CMYK);

Se invece si sta creando un’immagine ex-novo allora si deve utilizzare setImageColorSpace

$image->setImageColorSpace(Imagick::COLORSPACE_CMYK);

Ecco un esempio:

$image = new Imagick();
$image->readImage(rgb.jpg);
$image->transformimagecolorspace(Imagick::COLORSPACE_CMYK);
$image->profileImage('icc', file_get_contents(/path/CoatedFOGRA27.icc'));
$image->writeImage(cmyk.rgb);

Per gli amici in lingua inglese: [SOLVED] imagemagick convert image RGB to CMYK!

L'articolo Conversione immagine: Imagemagick RGB to CMYK in PHP sembra essere il primo su Cesare Bordi | Innovation Manager & Back-end Developer.

Credo che qualsiasi programmatore si sia trovato nella condizione di dover cercare un determinato valore di un campo ricorrente in molteplici record per sostituirlo con uno diverso.

Diciamo ad esempio di voler sostituire in una tabella di dati anagrafici il termine “maschio” con “M” nel campo “genere”.

Problema: come fare quindi per eseguire un “cerca e sostituisci” in massa su tutti i record interessati della tabella MySql?

Soluzione: detto fatto, basta sfruttare l’apposita string function REPLACE di MySQL opportunatamente combinata con un UPDATE:

UPDATE `nomeTabella` SET `nomeCampo` = REPLACE(`nomeCampo`, ‘cosaTrovare‘, ‘cosaSostituire‘);

Se l’applichiamo al nostro esempio otterremo:

UPDATE `Anagrafica` SET `genere` = REPLACE(`genere`, 'maschio', 'M');

L'articolo MySql: cerca e sostituisci in una query per web developer sembra essere il primo su Cesare Bordi | Innovation Manager & Back-end Developer.

Per fare questo dovremo utilizzare il protocollo HTTPS che abbina il comune HTTP ad un ulteriore protocollo di crittografia asimmetrica.
HTTPS è infatti l’acronimo di HyperText Transfer Protocol over Secure Socket Layer.
Questo sistema di sicurezza è stato pensato proprio per evitare che attraverso tecniche di man in the middle un malintenzionato possa fare sniffing dei dati scambiati bidirezionalmente fra server e client.

Problema: se “tirar su” un server LAMP è ormai alla portata di tutti i web developer grazie alle molte distribuzioni out of the box, abilitare l’https è già un’operazione più specificatamente sistemistica, ma ugualmente attuabile in pochi minuti.

Spiegazione: su Ubuntu Server, così come in molte altre distribuzioni, il modulo SSL è già presente nell’installazione base di Apache.
Bisogna solo attivarlo con il seguente comando che abilita anche la porta 443 di default per l’https.

sudo a2enmod ssl

Dovremo quindi predisporre una cartella in cui generare i nostri certificati di sicurezza. Consiglio di creare una sottocartella dentro a quella di apache.

Nel caso di Ubunti dovremo lanciare il comando

sudo mkdir /etc/apache2/ssl

In altre distribuzioni come centOS la sottocartella può essere creata con i comando

sudo mkdir /etc/httpd/ssl

Per ottenere chiave privata e certificato utilizzeremo openssl attraverso il seguente comando, riportando i percorsi corretti, scegliendo la crittografia RSA a 2048 bit e una validità di 365 giorni.

sudo openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout /etc/apache2/ssl/apache.key -out /etc/apache2/ssl/apache.crt

Nel caso openssl non fosse presente, si può installare mediante il seguente comando su Ubuntu (o analoghi su altre distro)

apt-get install openssl

La procedura di creazione dei certificati pone alcune domande alle quali si può rispondere abbastanza liberamente, es:

Country Name (2 letter code) [AU]:IT
State or Province Name (full name) [Some-State]:Modena
Locality Name (eg, city) []:Modena
Organization Name (eg, company) [Internet Widgits Pty Ltd]:communicationBox
Organizational Unit Name (eg, section) []:Development
Common Name (e.g. server FQDN or YOUR name) []:NomeMioServer
Email Address []:maimaildiriferimento@dominio.it

A questo punto il grosso del lavoro è fatto, non resta che settare i virtual host per indicare di sfruttare la cominicazione sicura sulla porta 443 e chiave e certificato appena creati.

Nella cartella /etc/apache2/sites-available/ è solitamente già presente un file di esempio denominato default-ssl.conf che possiamo modificare o utilizzare come modello per creare il nostro file:

sudo nano /etc/apache2/sites-available/default-ssl.conf

<VirtualHost *:80>
        ServerAdmin webmaster@localhost

        DocumentRoot /var/www/html
        <Directory />
                Options FollowSymLinks
                AllowOverride All
        </Directory>
        <Directory /var/www/>
                Options -Indexes +FollowSymLinks +MultiViews
                AllowOverride All
                Order allow,deny
                allow from all
        </Directory>

        ScriptAlias /cgi-bin/ /usr/lib/cgi-bin/
        <Directory "/usr/lib/cgi-bin">
                AllowOverride None
                Options +ExecCGI -MultiViews +SymLinksIfOwnerMatch
                Order allow,deny
                Allow from all
        </Directory>

        ErrorLog ${APACHE_LOG_DIR}/error.log

        # Possible values include: debug, info, notice, warn, error, crit,
        # alert, emerg.
        LogLevel warn

        CustomLog ${APACHE_LOG_DIR}/access.log combined

        Alias /doc/ "/usr/share/doc/"
        <Directory "/usr/share/doc/">
                Options MultiViews FollowSymLinks
                AllowOverride None
                Order deny,allow
                Deny from all
                Allow from 127.0.0.0/255.0.0.0 ::1/128
        </Directory>

</VirtualHost>

Ora la configurazione è terminata, dobbiamo abilitare come di consueto il virtual host:

sudo a2ensite default-ssl.conf

Infine riavviamo il servizio per rendere effettive le modifiche:

sudo service apache2 restart

Ora, sincerandosi che il firewall della nostra connessione consenta il traffico sulla porta 443, puntiamo sull’ip del server, o sul dominio impostato nel virtualhost, ad esempio https://123.123.123.123.
Comparirà un avviso che ci avverte che il certificato non è attendibile, questo è normale in quanto lo abbiamo autogenerato e non acquistato da un ente certificatore. Basterà procedere “accettando i rischi” per navigare in maniera sicura. Naturalmente, per siti o app pubbliche, è vivamente consigliato l’acquisto di un certificato verificato per non “spaventare” l’utente con questo avviso.

L'articolo Sicurezza: abilitare HTTPS in Apache2 su Ubuntu server sembra essere il primo su Cesare Bordi | Innovation Manager & Back-end Developer.

Il codice proposto dallo stesso WordPress che solitamente si utilizza per abilitare il rewriting e far così scomparire dalla url “index.php” è il seguente:

<IfModule mod_rewrite.c>
RewriteEngine On
RewriteBase /
RewriteRule ^index\.php$ - [L]
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule . /index.php [L]
</IfModule>

Questa regola eseguirà il rewrite di ogni percorso della url sott’intendendo la presenza di /index.php

Problema: può però essere necessario escludere una cartella (o più) da questa regola generale per caricare ad esempio file che devono essere accessibili attraverso un link diretto o script di varia utilità.

Soluzione: è possibile modificare la regola in modo da segnalare una directory (o più) che faccia eccezione rispetto alla regola generale attraverso la seguente istruzione:

RewriteCond %{REQUEST_URI} !^/(Cartella1|Cartella2|Cartella3).*$

Ecco come apparirà il blocco di codice completo:

<IfModule mod_rewrite.c>
RewriteEngine On
RewriteBase /
RewriteRule ^index.php$ - [L]
RewriteCond %{REQUEST_URI} !^/(Cartella1|Cartella2|Cartella3).*$
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule . /index.php [L]
</IfModule>

L'articolo WordPress: escludere una cartella dal rewriting url di Apache sembra essere il primo su Cesare Bordi | Innovation Manager & Back-end Developer.

Ora, calcolare l’età sembra banale, ma non lo è.
Non basta fare la differenza fra l’anno attuale e quello di nascita, bisogna tener conto anche del mese, del giorno e del formato di data che, nel caso di facebook è mm/dd/aaaa.

Ho quindi realizzato una pratica funzione javascript per calcolare l’età che finirà nella mia personale collezione!
L’unico argomento  richiesto dalla funzione è una data di nascita, in qualsiasi formato.

function calcAge (birthday) {
    birthday = new Date(birthday);
    today     = new Date();

    var years = (today.getFullYear() - birthday.getFullYear());

    if (today.getMonth() < birthday.getMonth() || 
        today.getMonth() == birthday.getMonth() && today.getDate() < birthday.getDate()) {
        years--;
    }

    return years;
}

L'articolo Javascript: come calcolare l’età sembra essere il primo su Cesare Bordi | Innovation Manager & Back-end Developer.

Visualizzando la pagina web scatta una breve animazione che farebbe pensare all’utilizzo di due immagini PNG a 24bit con ombre in trasparenza animate con transition CSS3.

L’ispezione del codice sorgente mette invece in evidenza una tecnica di ottimizzazione grafica volta alla riduzione delle dimensioni dei file che sfrutta 4 tag <figure>  ai quali vengono assegnati via CSS “leggère” immagini JPG: due rappresentano i tablet, due le rispettive ombre.

A questo punto mi sarei aspettato di vedere l’alone bianco proprio come accaduto su Firefox, ma visualizzando il sito con Safari questo non accade… come hanno fatto a scontornare le immagini? Semplice (mica tanto), attraverso l’apposita regola css3 mask-image che sfrutta un file vettoria SVG, anch’esso leggerissimo, come maschera. Per approfondimenti rimando a questo articolo.

Il sistema è ingegnoso ed il risparmio in termini di Kb è davvero notevole, di contro la sua realizzazione è piuttosto dispendiosa in termini di tempo di realizzazione ed evidentemente ha qualche problema di compatibilità con Firefox. Devo però ammettere che su un’altra postazione Firefox rispondeva correttamente.

Spero che questa tecnica possa tornare utile a qualche collega web developer!
Sotto un dettaglio del codice sorgente ispezionato:

L'articolo CSS mask-image per JPG con effetto PNG sembra essere il primo su Cesare Bordi | Innovation Manager & Back-end Developer.