Sommario
Introduzione
Può capitare di aver bisogno di eseguire di avviare da una macchina locale l’esecuzione di codice su un’altra macchina.
È il concetto di RPC (Remote Procedure Call).
In questo articolo cercheremo di realizzare una RPC generica scritta in PHP e basata su JSON. Cercheremo, in particolare, di fare in modo che il lato client della RPC veda veramente il lato server come se fosse una classe di oggetti locale, quindi con oggetti che possono essere istanziati e il cui stato può essere modificato nel corso dell’esecuzione.
Per ottenere questo risultato attraverso la rete, utilizzeremo le sessioni HTTP.
Il lato server
Una classe di esempio
Supponiamo di voler usare una semplice classe «lampadina» che risiede su una macchina remota.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
class lamp { public $light; public function __construct($light = false) { $this->light = (boolean) $light; } public function turnOn() { $this->light = true; } public function turnOff() { $this->light = false; } public function status() { return $this->light; } } |
Il server
Con la classe che segue, vogliamo rispondere a diverse chiamate:
Creazione dell’oggetto:
|
1 |
?new=lamp&args[]= |
Richiesta di un metodo:
|
1 |
?method=turnOn&args[]= |
Sia alla creazione che alla richiesta di un metodo, i parametri da passare alla classe vengono raccolti come array.
Queste funzioni sono realizzate dal seguente programma:
|
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 |
<?php /** * Class server * * Programma per l'erogazione di classi remote * * La risposta si articola nei seguenti campi: * - http status code * - buffered output * - content */ header('Content-type: application/json'); session_start(); $classesPath = '../../includes/classServer'; set_include_path(get_include_path() . PATH_SEPARATOR . $classesPath); // Args if (isset($_GET['args'])) $args = (array) $_GET['args']; else $args = array(); ob_start(); // With this request, don't care about previos sessions if (isset($_GET['new'])) { $classFile = (string) $_GET['new'] . '.php'; if (@include_once $classFile) { try { $_SESSION['classFile'] = $classFile; // http://it.php.net/manual/en/function.call-user-func-array.php#74427 $reflectionObj = new ReflectionClass((string) $_GET['new']); $_SESSION['obj'] = serialize($reflectionObj->newInstanceArgs($args)); $header = 'HTTP/1.1 200 OK'; $content = ''; } catch (Exception $e) { // Ouch! $header = 'HTTP/1.1 400 Bad Request'; $content = $e->toArray(); } } else { $header = 'HTTP/1.1 400 Bad Request'; $content = 'Class ' . (string) $_GET['new'] . ' not found.'; } } else if (isset($_GET['method'])) { if (isset($_SESSION['obj']) && isset($_SESSION['classFile'])) { $classFile = $_SESSION['classFile']; if (@include_once $classFile) { if ($obj = unserialize($_SESSION['obj'])) { try { $header = 'HTTP/1.1 200 OK'; $content = call_user_func_array(array($obj, (string) $_GET['method']), $args); $_SESSION['obj'] = serialize($obj); } catch (Exception $e) { $header = 'HTTP/1.1 400 Bad Request'; $content = $e->toArray(); } } else { $header = 'HTTP/1.1 500 Internal Server Error'; $content = 'The requested object is corrupted on the server side.'; } } else { $header = 'HTTP/1.1 500 Internal Server Error'; $content = 'The class filename is corrupted on the server side.'; } } else { $header = 'HTTP/1.1 400 Bad Request'; $content = 'You should instantiate this object first'; } } else { $header = 'HTTP/1.1 200 OK'; $content = <<<INFO A 'new' parameter will create a new object of the 'new' class. 'args' are given to the constructor. A 'method' parameter will call the 'method' of an existing object, with 'args' as arguments. Examples: ?new=mela&args=rosso ?method=setColor&args[]=verde INFO; } $bufferedOutput = ob_get_contents(); ob_end_clean(); header($header); echo json_encode(array( 'Content' => $content, 'bufferedOutput' => $bufferedOutput )); |
La risposta fornita sulla rete è fatta di un header HTTP e due campi.
L’header HTTP ci informa sull’esito della chiamata, distinguendo soprattutto i successi (200) dai fallimenti (tutti gli altri codici).
Il campo content contiene la variabile restituita con return.
Il campo bufferedOutput contiene tutto l’output che potrebbe essere emesso dai metodi della classe (ad esempio con degli echo).
Limiti di questa soluzione
Non tutte le classi possono essere trattate così semplicemente. Il punto delicato è la serializzazione dell’oggetto, che produce la perdita delle proprietà di tipo risorsa.
Non è poco. Le risorse sono quelle attraverso cui apriamo connessioni ai database, leggiamo e scriviamo su file, operiamo connessioni di rete, ecc. (Vedi: PHP, List of Resource Types.)
Se vogliamo utilizzare delle classi che trattano delle risorse, dobbiamo adattarle e arricchirle con metodi __sleep() e __wakeup() (l’esempio del manuale è relativo proprio a questo).
Ancora più ordinato sarebbe richiedere che le classi coinvolte implementino la Serializable Interface e introdurre nel server una verifica con l’operatore instanceof.
Analogamente, se la variabile restituita è un oggetto, la sua trasformazione (con json_encode(), ma lo stesso avverrebbe con qualsiasi sistema di serializzazione) tutti i suoi metodi andranno perduti.
Per ovviare a questo problema, l’unica soluzione è migliorare il server in modo da poter ricostruire l’oggetto serializzato con… un’altra chiamata!
Il lato client
La classe client
La lettura e l’interpretazione del server viene fatto da questa classe:
|
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 94 |
<?php class classClient { /** * cURL resource * * @var resource */ protected $_ch; /** * The URL of the service * * @var string */ protected $_url; /** * Buffered output of the last request * * @var string */ protected $_bufferedOutput; /** * Http query execution * * @param array $qs Query string parts * @return string */ protected function _query($qs) { $url = $this->_url; if (!empty($qs)) $url .= '?' . http_build_query((array) ($qs)); curl_setopt($this->_ch, CURLOPT_URL, (string) $url); $response = json_decode(curl_exec($this->_ch)); $content = $response->Content; $this->_bufferedOutput = $response->bufferedOutput; $info = curl_getinfo($this->_ch); $status = $info['http_code']; if ($status == 200) return $content; else throw new Exception($url . ' - ' . $content, $status); } /** * Constructor * * @param string $url The URL of the service * @param string $className The class to represent * @param array $args Arguments to give to the constructor */ public function __construct($url, $className, $args = array()) { $this->_url = $url; // cURL startup $this->_ch = curl_init(); curl_setopt($this->_ch, CURLOPT_RETURNTRANSFER, 1); $tmpfname = tempnam("/tmp", "COOKIE"); curl_setopt($this->_ch, CURLOPT_COOKIEJAR, $tmpfname); curl_setopt($this->_ch, CURLOPT_COOKIEFILE, $tmpfname); // Query string $qs = array( 'new' => (string) $className, 'args' => (array) $args ); return $this->_query($qs); } public function __call($name, $args) { // Query string $qs = array( 'method' => (string) $name, 'args' => (array) $args ); return $this->_query($qs); } public function bufferedOutput() { return $this->_bufferedOutput; } } |
La classe, ad eccezione del costruttore, si comporterà esattamente come l’oggetto remoto (salvo nei casi elencati tra le limitazioni).
Esempio
|
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 |
<?php /** * Programma di esempio per l'uso di classi remote * */ /* Assicurati che l'include path sia corretto! */ require 'classClient.php'; header('Content-Type: text/plain'); $serverUrl = 'http://inservibile.org/php/classServer.php'; $className = 'lamp'; try { echo 'Creo una lampadina' . PHP_EOL; $lamp = new classClient($serverUrl, $className, array()); echo 'La lampadina è '; echo $lamp->status() ? 'accesa' : 'spenta'; echo PHP_EOL . PHP_EOL; echo 'Accendo la lampadina' . PHP_EOL; $lamp->turnOn(); echo 'La lampadina è '; echo $lamp->status() ? 'accesa' : 'spenta'; echo PHP_EOL . PHP_EOL; echo 'Spengo la lampadina' . PHP_EOL; $lamp->turnOff(); echo 'La lampadina è '; echo $lamp->status() ? 'accesa' : 'spenta'; echo PHP_EOL . PHP_EOL; } catch (Exception $e) { echo $e->getMessage(); } |
Un server pubblico
Chi vuole, può provare un class server (con la sola lampadina) disponibile a: http://inservibile.org/php/classServer.php (attenzione all’header Content-type: application/json )
Eccolo in funzione.
[php snippet=1]
Non fa molto effetto a vederlo… 🙂 ma il testo qui in alto viene costruito utilizzando proprio quel server remoto e il programma dell’esempio.
Conclusioni
Il PHP è stato utilizzato su entrambi i lati solo per questioni di comodo.
Rispettando le logiche di questa soluzione, infatti, possiamo scrivere il codice sui due lati con linguaggi diversi, intendere la soluzione solo come protocollo e concepire questo sistema anche come metodo di scambio di funzionalità tra linguaggi diversi (es. .NET e Java).
Un modello concettuale spesso utilizzato per descrivere le RPC è proprio quello delle classi di oggetti. Ma le soluzioni in voga (REST/JSON, SOAP, ecc.) in realtà esauriscono tutto il processo in un’unica chiamata. Qui invece possiamo utilizzare un web service per simulare davvero l’uso di una classe locale, mentre il codice viene eseguito in un sistema remoto.
Questa logica può essere necessaria per diverse ragioni: perché il codice remoto è sofisticato e affidabile, perché deve essere utilizzato da più macchine client, perché dalla macchina locale si vuole modificare lo stato della macchina remota, perché si vuole realizzare interoperabilità tra linguaggi.
Buon lavoro.