<?xml version="1.0" encoding="UTF-8"?>
<!-- EN-Revision: 21829 -->
<!-- Reviewed: no -->
<sect1 id="zend.http.client.advanced">
    <title>Zend_Http_Client - Utilisation avancée</title>

    <sect2 id="zend.http.client.redirections">
        <title>Redirections HTTP</title>

        <para>
            Par défaut, <classname>Zend_Http_Client</classname> gère automatiquement les
            redirections <acronym>HTTP</acronym>, et suivra jusqu'à 5 redirections. Ce comportement peut être modifié
            en changeant le paramètre de configuration "maxredirects".
        </para>

        <para>
            Conformément à la RFC HTTP/1.1, les codes réponse HTTP 301 et 302 doivent être
            traités par le client en envoyant à nouveau la même requête à l'adresse spécifiée - en
            utilisant la même méthode de requête. Cependant, la plupart des clients ne réagissent
            pas correctement et redirige toujours via une requête GET. Par défaut,
            <classname>Zend_Http_Client</classname> agit de même - Lors d'une redirection basée sur
            la réception d'un code 301 ou 302, tous les paramètres GET et POST sont remis à zéro, et
            une requête GET est envoyée à la nouvelle adresse. Ce comportement peut être modifié en
            positionnant le paramètre de configuration "strictredirects" à <constant>TRUE</constant> :
            <example id="zend.http.client.redirections.example-1">
                    <title>Forcer des redirections conformes au RFC 2616 lors de la réception d'un
                    code statut 301 and 302</title>

                    <programlisting language="php"><![CDATA[
// Redirections strictes
$client->setConfig(array('strictredirects' => true)

// Redirections non strictes
$client->setConfig(array('strictredirects' => false)
]]></programlisting>
                </example>
            </para>

        <para>
            Il est toujours possible d'obtenir le nombre de redirections effectuées après
            l'envoi d'une requête en invoquant la méthode getRedirectionsCount().
        </para>
    </sect2>

    <sect2 id="zend.http.client.cookies">
        <title>Ajout de cookies et gestion de leur persistance</title>

        <para>
            <classname>Zend_Http_Client</classname> fournit une interface simple afin
            d'ajouter des cookies à une requête de manière à ce qu'aucune modification directe de
            l'en-tête ne soit nécessaire. Ceci est réalisé via la méthode <methodname>setCookie()</methodname>.
            Cette méthode peut être utilisée de plusieurs manières : <example
                    id="zend.http.client.cookies.example-1">
                    <title>Définition de cookies via setCookie()</title>

                    <programlisting language="php"><![CDATA[
// Simple et facile : en fournissant un nom de cookie et une valeur
$client->setCookie('parfum', 'pépites de chocolat');

// en fournissant directement une chaîne de cookie encodée (nom=valeur)
// Notez que la valeur doit être déjà encodée au format URL
$client->setCookie('parfum=p%C3%A9pites%20de%20chocolat');

// En fournissant un objet Zend_Http_Cookie
$cookie =
    Zend_Http_Cookie::fromString('parfum=p%C3%A9pites%20de%20chocolat');
$client->setCookie($cookie);
]]></programlisting>
                </example> Pour plus d'information sur les objets
            <classname>Zend_Http_Cookie</classname>, voir <xref
            linkend="zend.http.cookies" />.
        </para>

        <para>
            <classname>Zend_Http_Client</classname> permet également la persistance des
            cookies - ce qui permet au client de stocker tous les cookies reçus et transmis, et de
            les retransmettre automatiquement lors des requêtes suivantes. Cela se révèle très utile
            lorsqu'il est nécessaire de s'identifier sur un site donné (et de recevoir ainsi un
            cookie de session) avant de pouvoir envoyer d'autres requêtes. <example
                    id="zend.http.client.cookies.example-2">
                    <title>Activer la persistance des cookies</title>

                    <programlisting language="php"><![CDATA[
// Pour activer la persistance des cookies,
// définissez un Magasin de cookie "Cookie Jar"
$client->setCookieJar();

// Première requête : s'identifier et démarrer une session
$client->setUri('http://exemple.com/login.php');
$client->setParameterPost('user', 'h4x0r');
$client->setParameterPost('password', '1337');
$client->request('POST');

// Le magasin de cookies stocke automatiquement les
// cookies transmis dans la réponse, un cookie de session par exemple

// Maintenant nous pouvons envoyer notre requête suivante
// les cookies stockés seront transmis automatiquement.
$client->setUri('http://exemple.com/lire_actualite_membres.php');
$client->request('GET');
]]></programlisting>
                </example> Pour plus d'information sur la classe
            <classname>Zend_Http_CookieJar</classname>, voir <xref
            linkend="zend.http.cookies.cookiejar" />.
        </para>
    </sect2>

    <sect2 id="zend.http.client.custom_headers">
        <title>Définir des en-têtes personnalisés</title>

        <para>
            Il est possible de définir des en-têtes personnalisés en utilisant la méthode
            <methodname>setHeaders()</methodname>. Cette méthode est très versatile et peut être utilisée de
            diverses manières comme le montre l'exemple suivant : <example
                    id="zend.http.client.custom_headers.example-1">
                    <title>Définir un en-tête personnalisé unique</title>

                    <programlisting language="php"><![CDATA[
// Définition d'un en-tête unique,
// écrasant toute valeur précédemment définie
$client->setHeaders('Host', 'www.exemple.com');

// La même chose d'une autre manière
$client->setHeaders('Host: www.example.com');

// Définition de plusieurs valeurs pour le même en-tête
// (surtout utile pour les en-têtes de cookies)
$client->setHeaders('Cookie', array(
    'PHPSESSID=1234567890abcdef1234567890abcdef',
    'language=fr'
));
]]></programlisting>
                </example>
            </para>

        <para>
            <methodname>setHeader()</methodname> peut aussi être facilement utilisé pour définir des
            en-têtes multiples en un seul appel, en fournissant un tableau d'en-têtes comme
            paramètre unique : <example id="zend.http.client.custom_headers.example-2">
                    <title>Définition de plusieurs en-têtes personnalisés</title>

                    <programlisting language="php"><![CDATA[
// Définition de plusieurs en-têtes,
// écrasant toute valeur précédemment définie
$client->setHeaders(array(
    'Host' => 'www.exemple.com',
    'Accept-encoding' => 'gzip,deflate',
    'X-Powered-By' => 'Zend Framework'));

// Le tableau peut contenir uniquement des valeurs
$client->setHeaders(array(
    'Host: www.exemple.com',
    'Accept-encoding: gzip,deflate',
    'X-Powered-By: Zend Framework'));
]]></programlisting>
                </example>
            </para>
    </sect2>

    <sect2 id="zend.http.client.file_uploads">
        <title>Envoi de fichiers</title>

        <para>
            Il est possible d'envoyer des fichiers au travers d'HTTP en utilisant la méthode
            <code>setFileUpload</code>. Cette méthode attend un nom de fichier comme premier
            paramètre, un nom de formulaire comme second paramètre, et, en option, des données comme
            troisième paramètre. Si le troisième paramètre est <constant>NULL</constant>, la valeur du
            premier paramètre est supposée être un fichier sur le disque dur et
            <classname>Zend_Http_Client</classname> essaiera de lire ce fichier et de l'envoyer.
            Sinon la valeur du premier paramètre sera envoyée comme nom du fichier mais il n'est pas
            nécessaire que le fichier existe sur le disque dur. Le deuxième paramètre est toujours
            requis, et est équivalent à l'attribut "name" d'une balise &lt;input&gt;, si le fichier
            devait être envoyé à partir d'un formulaire HTML. Un quatrième paramètre optionnel
            fournit le type du fichier. S'il n'est pas spécifié et que
            <classname>Zend_Http_Client</classname> lit le fichier à partir du disque dur, la
            fonction mime_content_type sera utilisée pour tenter de définir, si possible, le type du
            fichier. Dans tous les cas, le type MIME par défaut sera 'application/octet-stream'.
            <example id="zend.http.client.file_uploads.example-1">
                    <title>Utilisation de setFileUpload pour envoyer des fichiers</title>

                    <programlisting language="php"><![CDATA[
// Envoi de données arbitraires comme fichier
$texte = 'ceci est un texte ordinaire';
$client->setFileUpload('du_texte.txt', 'upload', $texte, 'text/plain');

// envoi d'un fichier existant
$client->setFileUpload('/tmp/Backup.tar.gz', 'bufile');

// envoi des fichiers
$client->request('POST');
]]></programlisting>
                </example> Dans le premier exemple, la variable $texte est envoyée et sera
            disponible dans <varname>$_FILES['upload']</varname> côté serveur. Dans le second exemple, le
            fichier existant "<filename>/tmp/Backup.tar.gz</filename>" est envoyé au serveur et sera
            disponible dans <varname>$_FILES['bufile']</varname>. Son type sera défini automatiquement si
            possible. Sinon, le type sera défini comme "application/octet-stream".
        </para>

        <note>
            <title>Envoi de fichiers</title>

            <para>
                Lors de l'envoi de fichiers, le type de la requête <acronym>HTTP</acronym> est automatiquement
                défini comme "multipart/form-data". Gardez à l'esprit que vous devez utiliser la
                méthode POST ou la méthode PUT pour envoyer des fichiers. La plupart des serveurs
                ignoreront le corps de la requête si vous utilisez une autre méthode.
            </para>
        </note>
    </sect2>

    <sect2 id="zend.http.client.raw_post_data">
        <title>Envoyer des données brutes via POST</title>

        <para>
            Vous pouvez utiliser <classname>Zend_Http_Client</classname> pour envoyer des
            données brutes via POST en utilisant la méthode <methodname>setRawData()</methodname>. Cette méthode
            accepte deux paramètres : le premier contient les données à transmettre dans le corps de
            la requête. Le deuxième paramètre, optionnel, contient le type des données. Bien que ce
            paramètre soit optionnel, vous devriez normalement le définir avant l'envoi de la
            requête, soit via setRawData() ou via la méthode <methodname>setEncType()</methodname>. <example
                    id="zend.http.client.raw_post_data.example-1">
                    <title>Envoi de données brutes via POST</title>

                    <programlisting language="php"><![CDATA[
$xml = '<book>' .
       '  <title>Islands in the Stream</title>' .
       '  <author>Ernest Hemingway</author>' .
       '  <year>1970</year>' .
       '</book>';

$client->setRawData($xml, 'text/xml')->request('POST');

// Une autre manière de faire la même chose :
$client->setRawData($xml)->setEncType('text/xml')->request('POST');
]]></programlisting>
                </example> Les données seront disponible côté serveur via la variable PHP
            <varname>$HTTP_RAW_POST_DATA</varname> ou via le flux php://input.
        </para>

        <note>
            <title>Utiliser des données brutes POST</title>

            <para>
                Définir des données brutes POST pour une requête écrasera tout autre paramètre
                POST ou envoi de fichiers. Il est recommandé de ne pas utiliser les deux
                conjointement. Gardez à l'esprit que la plupart des serveurs ignoreront le corps de
                la requête si celle-ci n'utilise pas la méthode POST.
            </para>
        </note>
    </sect2>

    <sect2 id="zend.http.client.http_authentication">
        <title>Authentification HTTP</title>

        <para>
            Actuellement, <classname>Zend_Http_Client</classname> propose uniquement
            l'authentification HTTP "basic". Cette fonctionnalité est utilisée via la méthode
            <methodname>setAuth()</methodname>, ou en spécifiant le nom d'utilisateur et le mot
            de passe dans l'URI. La méthode <methodname>setAuth()</methodname> accepte trois
            paramètres : le nom d'utilisateur, le mot
            de passe et un type d'authentification optionnel. Comme mentionné, seule
            l'authentification "basic" est actuellement implémentée (l'ajout de l'authentification
            "digest" est planifié). <example id="zend.http.client.http_authentication.example-1">
                    <title>Définir nom d'utilisateur et mot de passe pour l'authentification
                    HTTP</title>

                    <programlisting language="php"><![CDATA[
// Utilisation de l'authentification 'basic'
$client->setAuth('shahar',
                 'monMotdePasse!',
                 Zend_Http_Client::AUTH_BASIC);

// L'authentification 'basic' étant le comportement par défaut,
// on peut aussi écrire ceci :
$client->setAuth('shahar', 'monMotdePasse!');

// Vous pouvez aussi spécifier le nom d'utilisateur
// et le mot de passe dans l'URI
$client->setUri('http://christer:secret@example.com');
]]></programlisting>
                </example>
            </para>
    </sect2>

    <sect2 id="zend.http.client.multiple_requests">
        <title>Envoyer plusieurs requêtes avec le même client</title>

        <para>
            <classname>Zend_Http_Client</classname> a été également conçu spécifiquement pour
            gérer plusieurs requêtes consécutives avec la même instance. Ceci est utile dans les cas
            ou le script nécessite d'accéder à des données en provenance de divers emplacements ou,
            par exemple, lors de l'accès à des ressources <acronym>HTTP</acronym> nécessitant une authentification
            préalable.
        </para>

        <para>
            Lorsqu'on génère plusieurs requêtes vers le même hôte, il est chaudement
            recommandé d'activer la variable de configuration "keepalive". De cette manière, si le
            serveur supporte le mode de connexion "keep-alive", la connexion au serveur sera fermée
            après l'exécution de toutes les requêtes et la destruction de l'instance. Ceci permet
            d'éviter au serveur d'ouvrir et de fermer de multiples connexions <acronym>TCP</acronym>.
        </para>

        <para>
            Lorsqu'on génère plusieurs requêtes avec le même client, mais qu'on souhaite
            s'assurer que tous les paramètres spécifiques de chacune des requêtes sont effacés, on
            peut utiliser la méthode <methodname>resetParameters()</methodname>. Ceci permet de supprimer tous
            les paramètres GET et POST, le contenu des requêtes et les en-têtes spécifiques de
            manière à ce qu'ils ne soient pas réutilisés lors de la requête suivante.
        </para>

        <note>
            <title>Réinitialiser les paramètres</title>

            <para>
                Notez que les en-têtes spécifiques non liés à la requête ne sont pas réinitialisés
                par défaut quand la méthode <methodname>resetParameters</methodname> est invoquée.
                En fait, seuls les en-têtes "Content-length" et "Content-type" sont supprimés.
                Ceci permet de définir une seule fois les en-têtes comme "Accept-language" ou
                "Accept-encoding".
            </para>

            <para>
                Pour effacer tous les entêtes et toutes les données excepté l'URI et la méthode,
                utilisez <methodname>resetParameters(true)</methodname>.
            </para>
        </note>

        <para>
            Une autre fonctionnalité spécifique aux requêtes consécutives est l'objet Magasin
            de Cookies ("Cookie Jar"). Il permet de sauver automatiquement les cookies définis par
            le serveur lors de la première requête et de les renvoyer de manière transparente lors
            de chacune des requêtes suivantes. Ceci permet, par exemple, de passer une étape
            d'authentification avant d'envoyer d'autres requêtes.
        </para>

        <para>
            Si votre application nécessite une requête d'authentification par utilisateur, et
            que d'autres requêtes peuvent être effectuées via plusieurs scripts différents, il peut
            se révéler pratique de stocker le Magasin de cookies dans la session utilisateur. De
            cette manière, il sera possible de ne s'identifier qu'une seule fois par session.
        </para>

        <example id="zend.http.client.multiple_requests.example-1">
            <title>Exécuter plusieurs requêtes avec un seul client</title>

            <programlisting language="php"><![CDATA[
// D'abord, instancier le client
$client =
    new Zend_Http_Client('http://www.exemple.com/obtientdonnees.php',
                         array('keepalive' => true));

// Disposons-nous du cookie de session ?
if (isset($_SESSION['cookiejar']) &&
    $_SESSION['cookiejar'] instanceof Zend_Http_CookieJar)) {

    $client->setCookieJar($_SESSION['cookiejar']);
} else {
    // Sinon, Identifions-nous et stockons le cookie
    $client->setCookieJar();
    $client->setUri('http://www.exemple.com/connexion.php');
    $client->setParameterPost(array(
        'user' => 'shahar',
        'pass' => 'secret'
    ));
    $client->request(Zend_Http_Client::POST);

    // Maintenant, effaçons les paramètres et définissons l'URI
    // à sa valeur originale (notez que les cookies envoyés par le
    // serveur sont stockés dans le magasin de cookies)
    $client->resetParameters();
    $client->setUri('http://www.exemple.com/obtientdonnees.php');
}

$reponse = $client->request(Zend_Http_Client::GET);

// Stockons les cookies dans la session pour la page suivante
$_SESSION['cookiejar'] = $client->getCookieJar();
]]></programlisting>
        </example>
    </sect2>

    <sect2 id="zend.http.client.streaming">
        <title>Data Streaming</title>
        <para>
            By default, <classname>Zend_Http_Client</classname> accepts and returns data as PHP strings.
            However, in many cases there are big files to be sent or received, thus keeping them
            in memory might be unnecessary or too expensive. For these cases, <classname>Zend_Http_Client</classname>
            supports reading data from files (and in general, PHP streams) and writing data to files (streams).
        </para>
        <para>
            In order to use stream to pass data to <classname>Zend_Http_Client</classname>,
            use <methodname>setRawData()</methodname> method with data argument being stream resource
            (e.g., result of <methodname>fopen()</methodname>).
            <example id="zend.http.client.streaming.example-1">
                <title>Sending file to HTTP server with streaming</title>

                <programlisting language="php"><![CDATA[
$fp = fopen("mybigfile.zip", "r");
$client->setRawData($fp, 'application/zip')->request('PUT');
]]></programlisting>
            </example>
        </para>

        <para>
            Only PUT requests currently support sending streams to HTTP server.
        </para>

        <para>
            In order to receive data from the server as stream, use <methodname>setStream()</methodname>.
            Optional argument specifies the filename where the data will be stored. If the argument is just
            TRUE (default), temporary file will be used and will be deleted once response object is destroyed.
            Setting argument to FALSE disables the streaming functionality.
        </para>

        <para>
            When using streaming, <methodname>request()</methodname> method will return object of class
            <classname>Zend_Http_Client_Response_Stream</classname>, which has two useful methods:
            <methodname>getStreamName()</methodname> will return the name of the file where the response is stored,
            and <methodname>getStream()</methodname> will return stream from which the response could be read.
        </para>

        <para>
            You can either write the response to pre-defined file, or use temporary file for storing it and
            send it out or write it to another file using regular stream functions.
            <example id="zend.http.client.streaming.example-2">
                <title>Receiving file from HTTP server with streaming</title>

                <programlisting language="php"><![CDATA[
$client->setStream(); // will use temp file
$response = $client->request('GET');
// copy file
copy($response->getStreamName(), "my/downloads/file");
// use stream
$fp = fopen("my/downloads/file2", "w");
stream_copy_to_stream($response->getStream(), $fp);
// Also can write to known file
$client->setStream("my/downloads/myfile)->request('GET');
]]></programlisting>
            </example>
        </para>
    </sect2>
</sect1>