Comment faire une requête GET asynchrone en PHP?

Je souhaite faire une simple requête GET à un autre script sur un serveur différent. Comment puis-je faire cela?

Dans un cas, j'ai juste besoin de demander un script externe sans avoir besoin d'aucune sortie.

make_request('http://www.externalsite.com/script1.php?variable=45'); //example usage

Dans le second cas, j'ai besoin d'obtenir la sortie texte.

$output = make_request('http://www.externalsite.com/script2.php?variable=45');
echo $output; //string output

Pour être honnête, je ne veux pas jouer avec CURL car ce n'est pas vraiment le travail de CURL. Je ne veux pas non plus utiliser http_get car je n'ai pas les extensions PECL.

Fsockopen fonctionnerait-il? Si tel est le cas, comment faire cela sans lire le contenu du fichier? N'y a-t-il pas d'autre moyen?

Merci a tous

Mettre à jour

J'aurais dû ajouter, dans le premier cas, je ne veux pas attendre que le script retourne quoi que ce soit. Si je comprends bien, file_get_contents () attendra que la page se charge complètement, etc.?

file_get_contents fera ce que tu veux

$output = file_get_contents('http://www.example.com/');
echo $output;

Edit: Une façon de déclencher une demande GET et de revenir immédiatement.

Extrait de http://petewarden.typepad.com/searchbrowser/2008/06/how-to-post-an.html

function curl_post_async($url, $params)
{
    foreach ($params as $key => &$val) {
      if (is_array($val)) $val = implode(',', $val);
        $post_params[] = $key.'='.urlencode($val);
    }
    $post_string = implode('&', $post_params);

    $parts=parse_url($url);

    $fp = fsockopen($parts['host'],
        isset($parts['port'])?$parts['port']:80,
        $errno, $errstr, 30);

    $out = "POST ".$parts['path']." HTTP/1.1\r\n";
    $out.= "Host: ".$parts['host']."\r\n";
    $out.= "Content-Type: application/x-www-form-urlencoded\r\n";
    $out.= "Content-Length: ".strlen($post_string)."\r\n";
    $out.= "Connection: Close\r\n\r\n";
    if (isset($post_string)) $out.= $post_string;

    fwrite($fp, $out);
    fclose($fp);
}

Ce que cela fait est d'ouvrir un socket, de lancer une requête get, et de fermer immédiatement le socket et de revenir.

Voici comment faire fonctionner la réponse de Marquis avec les requêtes POST et GET:

  // $type must equal 'GET' or 'POST'
  function curl_request_async($url, $params, $type='POST')
  {
      foreach ($params as $key => &$val) {
        if (is_array($val)) $val = implode(',', $val);
        $post_params[] = $key.'='.urlencode($val);
      }
      $post_string = implode('&', $post_params);

      $parts=parse_url($url);

      $fp = fsockopen($parts['host'],
          isset($parts['port'])?$parts['port']:80,
          $errno, $errstr, 30);

      // Data goes in the path for a GET request
      if('GET' == $type) $parts['path'] .= '?'.$post_string;

      $out = "$type ".$parts['path']." HTTP/1.1\r\n";
      $out.= "Host: ".$parts['host']."\r\n";
      $out.= "Content-Type: application/x-www-form-urlencoded\r\n";
      $out.= "Content-Length: ".strlen($post_string)."\r\n";
      $out.= "Connection: Close\r\n\r\n";
      // Data goes in the request body for a POST request
      if ('POST' == $type && isset($post_string)) $out.= $post_string;

      fwrite($fp, $out);
      fclose($fp);
  }

En ce qui concerne votre mise à jour, ne pas vouloir attendre le chargement de la page complète - je pense qu'une HEADrequête HTTP est ce que vous recherchez.

get_headers devrait le faire - je pense qu'il ne demande que les en-têtes, donc ne sera pas envoyé le contenu de la page complète.

"PHP / Curl: HEAD Request prend beaucoup de temps sur certains sites" décrit comment faire une HEADrequête en utilisant PHP / Curl

Si vous souhaitez déclencher la requête et ne pas retarder du tout le script, il existe plusieurs moyens, de complexité variable.

• Exécutez la requête HTTP en tant que processus d'arrière-plan, php exécutez un processus d'arrière-plan - en gros, vous exécuteriez quelque chose comme "wget -O /dev/null $carefully_escaped_url"- ce sera spécifique à la plate-forme, et vous devez faire très attention à échapper les paramètres à la commande
• Exécuter un script PHP en arrière-plan - - essentiellement la même que la méthode de processus UNIX, mais exécuter un script PHP plutôt qu'une commande shell
• Avoir une "file d'attente de travaux", en utilisant une base de données (ou quelque chose comme beanstalkd qui est probablement exagéré). Vous ajoutez une URL à la file d'attente, et un processus d'arrière-plan ou cron-job vérifie régulièrement les nouveaux travaux et exécute des demandes sur l'URL

Vous ne le faites pas. Bien que PHP offre de nombreuses façons d'appeler une URL, il n'offre pas de support prêt à l'emploi pour effectuer tout type de traitement asynchrone / threadé par cycle de requête / exécution. Toute méthode d'envoi d'une requête pour une URL (ou une instruction SQL, ou un etc.) va attendre une sorte de réponse. Vous aurez besoin d'une sorte de système secondaire fonctionnant sur la machine locale pour y parvenir (google around for "php job queue")

Je vous recommanderais une bibliothèque PHP bien testée: curl-easy

<?php
$request = new cURL\Request('http://www.externalsite.com/script2.php?variable=45');
$request->getOptions()
    ->set(CURLOPT_TIMEOUT, 5)
    ->set(CURLOPT_RETURNTRANSFER, true);

// add callback when the request will be completed
$request->addListener('complete', function (cURL\Event $event) {
    $response = $event->response;
    $content = $response->getContent();
    echo $content;
});

while ($request->socketPerform()) {
    // do anything else when the request is processed
}

Si vous utilisez un environnement Linux, vous pouvez utiliser la commande exec de PHP pour invoquer linux curl. Voici un exemple de code, qui fera une publication HTTP asynchrone.

function _async_http_post($url, $json_string) {
  $run = "curl -X POST -H 'Content-Type: application/json'";
  $run.= " -d '" .$json_string. "' " . "'" . $url . "'";
  $run.= " > /dev/null 2>&1 &";
  exec($run, $output, $exit);
  return $exit == 0;
}

Ce code n'a pas besoin de bibliothèques PHP supplémentaires et il peut terminer la publication http en moins de 10 millisecondes.

function make_request($url, $waitResult=true){
    $cmi = curl_multi_init();

    $curl = curl_init();
    curl_setopt($curl, CURLOPT_URL, $url);
    curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);

    curl_multi_add_handle($cmi, $curl);

    $running = null;
    do {
        curl_multi_exec($cmi, $running);
        sleep(.1);
        if(!$waitResult)
        break;
    } while ($running > 0);
    curl_multi_remove_handle($cmi, $curl);
    if($waitResult){
        $curlInfos = curl_getinfo($curl);
        if((int) $curlInfos['http_code'] == 200){
            curl_multi_close($cmi);
            return curl_multi_getcontent($curl);
        }
    }
    curl_multi_close($cmi);
}

Problème intéressant. Je suppose que vous voulez simplement déclencher un processus ou une action sur l'autre serveur, mais ne vous souciez pas des résultats et que vous voulez que votre script continue. Il y a probablement quelque chose dans cURL qui peut rendre cela possible, mais vous pouvez envisager d'utiliser exec()pour exécuter un autre script sur le serveur qui effectue l'appel si cURL ne peut pas le faire. (En général, les gens veulent les résultats de l'appel de script, donc je ne suis pas sûr que PHP ait la capacité de simplement déclencher le processus.) Avec, exec()vous pouvez exécuter un wgetou même un autre script PHP qui fait la demande avec file_get_conents().

Vous feriez mieux d'envisager d'utiliser Message Queues au lieu des méthodes conseillées. Je suis sûr que ce sera une meilleure solution, même si cela nécessite un peu plus de travail que l'envoi d'une simple demande.

laissez-moi vous montrer mon chemin :)

nécessite que nodejs soit installé sur le serveur

(mon serveur envoie 1000 https get request ne prend que 2 secondes)

url.php:

<?
$urls = array_fill(0, 100, 'http://google.com/blank.html');

function execinbackground($cmd) { 
    if (substr(php_uname(), 0, 7) == "Windows"){ 
        pclose(popen("start /B ". $cmd, "r"));  
    } 
    else { 
        exec($cmd . " > /dev/null &");   
    } 
} 
fwite(fopen("urls.txt","w"),implode("\n",$urls);
execinbackground("nodejs urlscript.js urls.txt");
// { do your work while get requests being executed.. }
?>

urlscript.js>

var https = require('https');
var url = require('url');
var http = require('http');
var fs = require('fs');
var dosya = process.argv[2];
var logdosya = 'log.txt';
var count=0;
http.globalAgent.maxSockets = 300;
https.globalAgent.maxSockets = 300;

setTimeout(timeout,100000); // maximum execution time (in ms)

function trim(string) {
    return string.replace(/^\s*|\s*$/g, '')
}

fs.readFile(process.argv[2], 'utf8', function (err, data) {
    if (err) {
        throw err;
    }
    parcala(data);
});

function parcala(data) {
    var data = data.split("\n");
    count=''+data.length+'-'+data[1];
    data.forEach(function (d) {
        req(trim(d));
    });
    /*
    fs.unlink(dosya, function d() {
        console.log('<%s> file deleted', dosya);
    });
    */
}


function req(link) {
    var linkinfo = url.parse(link);
    if (linkinfo.protocol == 'https:') {
        var options = {
        host: linkinfo.host,
        port: 443,
        path: linkinfo.path,
        method: 'GET'
    };
https.get(options, function(res) {res.on('data', function(d) {});}).on('error', function(e) {console.error(e);});
    } else {
    var options = {
        host: linkinfo.host,
        port: 80,
        path: linkinfo.path,
        method: 'GET'
    };        
http.get(options, function(res) {res.on('data', function(d) {});}).on('error', function(e) {console.error(e);});
    }
}


process.on('exit', onExit);

function onExit() {
    log();
}

function timeout()
{
console.log("i am too far gone");process.exit();
}

function log() 
{
    var fd = fs.openSync(logdosya, 'a+');
    fs.writeSync(fd, dosya + '-'+count+'\n');
    fs.closeSync(fd);
}

Pour moi, la question sur la demande GET asynchrone est apparue parce que j'ai rencontré une situation où je dois faire des centaines de demandes , obtenir et traiter des données de résultat à chaque demande et que chaque demande prend des millisecondes significatives d'exécution, ce qui conduit à des minutes (!) De exécution totale avec simplefile_get_contents .

Dans ce cas, c'était un commentaire très utile de w_haigh sur php.net sur la fonction http://php.net/manual/en/function.curl-multi-init.php

Alors, voici ma version améliorée et nettoyée de faire beaucoup de demandes simultanément. Pour mon cas, c'est équivalent à la manière "asynchrone". Peut-être que cela aide quelqu'un!

// Build the multi-curl handle, adding both $ch
$mh = curl_multi_init();

// Build the individual requests, but do not execute them
$chs = [];
$chs['ID0001'] = curl_init('http://webservice.example.com/?method=say&word=Hello');
$chs['ID0002'] = curl_init('http://webservice.example.com/?method=say&word=World');
// $chs[] = ...
foreach ($chs as $ch) {
    curl_setopt_array($ch, [
        CURLOPT_RETURNTRANSFER => true,  // Return requested content as string
        CURLOPT_HEADER => false,         // Don't save returned headers to result
        CURLOPT_CONNECTTIMEOUT => 10,    // Max seconds wait for connect
        CURLOPT_TIMEOUT => 20,           // Max seconds on all of request
        CURLOPT_USERAGENT => 'Robot YetAnotherRobo 1.0',
    ]);

    // Well, with a little more of code you can use POST queries too
    // Also, useful options above can be  CURLOPT_SSL_VERIFYHOST => 0  
    // and  CURLOPT_SSL_VERIFYPEER => false ...

    // Add every $ch to the multi-curl handle
    curl_multi_add_handle($mh, $ch);
}

// Execute all of queries simultaneously, and continue when ALL OF THEM are complete
$running = null;
do {
    curl_multi_exec($mh, $running);
} while ($running);

// Close the handles
foreach ($chs as $ch) {
    curl_multi_remove_handle($mh, $ch);
}
curl_multi_close($mh);

// All of our requests are done, we can now access the results
// With a help of ids we can understand what response was given
// on every concrete our request
$responses = [];
foreach ($chs as $id => $ch) {
    $responses[$id] = curl_multi_getcontent($ch);
    curl_close($ch);
}
unset($chs); // Finita, no more need any curls :-)

print_r($responses); // output results

Il est facile de réécrire ceci pour gérer POST ou d'autres types de requêtes HTTP (S) ou toute combinaison de celles-ci. Et le support des cookies, les redirections, http-auth, etc.

Essayer:

//Your Code here
$pid = pcntl_fork();
if ($pid == -1) {
     die('could not fork');
}
else if ($pid)
{
echo("Bye")  
}
else
{
     //Do Post Processing
}

Cela ne fonctionnera PAS comme un module Apache, vous devez utiliser CGI.

J'ai trouvé ce lien intéressant pour faire un traitement asynchrone (get request).

askapache

De plus, vous pouvez effectuer un traitement asynchrone en utilisant une file d'attente de messages comme par exemple beanstalkd.

Voici une adaptation de la réponse acceptée pour effectuer une simple requête GET.

Une chose à noter si le serveur effectue une réécriture d'url, cela ne fonctionnera pas. Vous devrez utiliser un client http plus complet.

  /**
   * Performs an async get request (doesn't wait for response)
   * Note: One limitation of this approach is it will not work if server does any URL rewriting
   */
  function async_get($url)
  {
      $parts=parse_url($url);

      $fp = fsockopen($parts['host'],
          isset($parts['port'])?$parts['port']:80,
          $errno, $errstr, 30);

      $out = "GET ".$parts['path']." HTTP/1.1\r\n";
      $out.= "Host: ".$parts['host']."\r\n";
      $out.= "Connection: Close\r\n\r\n";
      fwrite($fp, $out);
      fclose($fp);
  }

Juste quelques corrections sur les scripts postés ci-dessus. Ce qui suit fonctionne pour moi

function curl_request_async($url, $params, $type='GET')
    {
        $post_params = array();
        foreach ($params as $key => &$val) {
            if (is_array($val)) $val = implode(',', $val);
            $post_params[] = $key.'='.urlencode($val);
        }
        $post_string = implode('&', $post_params);

        $parts=parse_url($url);
        echo print_r($parts, TRUE);
        $fp = fsockopen($parts['host'],
            (isset($parts['scheme']) && $parts['scheme'] == 'https')? 443 : 80,
            $errno, $errstr, 30);

        $out = "$type ".$parts['path'] . (isset($parts['query']) ? '?'.$parts['query'] : '') ." HTTP/1.1\r\n";
        $out.= "Host: ".$parts['host']."\r\n";
        $out.= "Content-Type: application/x-www-form-urlencoded\r\n";
        $out.= "Content-Length: ".strlen($post_string)."\r\n";
        $out.= "Connection: Close\r\n\r\n";
        // Data goes in the request body for a POST request
        if ('POST' == $type && isset($post_string)) $out.= $post_string;
        fwrite($fp, $out);
        fclose($fp);
    }

Personne ne semble mentionner Guzzle , qui est un client HTTP PHP qui facilite l'envoi de requêtes HTTP. Cela peut fonctionner avec ou sans Curl. Il peut envoyer des requêtes synchrones et asynchrones.

$client = new GuzzleHttp\Client();
$promise = $client->requestAsync('GET', 'http://httpbin.org/get');
$promise->then(
    function (ResponseInterface $res) {
        echo $res->getStatusCode() . "\n";
    },
    function (RequestException $e) {
        echo $e->getMessage() . "\n";
        echo $e->getRequest()->getMethod();
    }
);

Sur la base de ce fil, j'ai fait ceci pour mon projet codeigniter. Cela fonctionne très bien. Vous pouvez faire traiter n'importe quelle fonction en arrière-plan.

Un contrôleur qui accepte les appels asynchrones.

class Daemon extends CI_Controller
{
    // Remember to disable CI's csrf-checks for this controller

    function index( )
    {
        ignore_user_abort( 1 );
        try
        {
            if ( strcmp( $_SERVER['REMOTE_ADDR'], $_SERVER['SERVER_ADDR'] ) != 0 && !in_array( $_SERVER['REMOTE_ADDR'], $this->config->item( 'proxy_ips' ) ) )
            {
                log_message( "error", "Daemon called from untrusted IP-address: " . $_SERVER['REMOTE_ADDR'] );
                show_404( '/daemon' );
                return;
            }

            $this->load->library( 'encrypt' );
            $params = unserialize( urldecode( $this->encrypt->decode( $_POST['data'] ) ) );
            unset( $_POST );
            $model = array_shift( $params );
            $method = array_shift( $params );
            $this->load->model( $model );
            if ( call_user_func_array( array( $this->$model, $method ), $params ) === FALSE )
            {
                log_message( "error", "Daemon could not call: " . $model . "::" . $method . "()" );
            }
        }
        catch(Exception $e)
        {
            log_message( "error", "Daemon has error: " . $e->getMessage( ) . $e->getFile( ) . $e->getLine( ) );
        }
    }
}

Et une bibliothèque qui fait les appels asynchrones

class Daemon
{
    public function execute_background( /* model, method, params */ )
    {
        $ci = &get_instance( );
        // The callback URL (its ourselves)
        $parts = parse_url( $ci->config->item( 'base_url' ) . "/daemon" );
        if ( strcmp( $parts['scheme'], 'https' ) == 0 )
        {
            $port = 443;
            $host = "ssl://" . $parts['host'];
        }
        else 
        {
            $port = 80;
            $host = $parts['host'];
        }
        if ( ( $fp = fsockopen( $host, isset( $parts['port'] ) ? $parts['port'] : $port, $errno, $errstr, 30 ) ) === FALSE )
        {
            throw new Exception( "Internal server error: background process could not be started" );
        }
        $ci->load->library( 'encrypt' );
        $post_string = "data=" . urlencode( $ci->encrypt->encode( serialize( func_get_args( ) ) ) );
        $out = "POST " . $parts['path'] . " HTTP/1.1\r\n";
        $out .= "Host: " . $host . "\r\n";
        $out .= "Content-Type: application/x-www-form-urlencoded\r\n";
        $out .= "Content-Length: " . strlen( $post_string ) . "\r\n";
        $out .= "Connection: Close\r\n\r\n";
        $out .= $post_string;
        fwrite( $fp, $out );
        fclose( $fp );
    }
}

Cette méthode peut être appelée pour traiter n'importe quel model :: method () dans le 'background'. Il utilise des arguments variables.

$this->load->library('daemon');
$this->daemon->execute_background( 'model', 'method', $arg1, $arg2, ... );

Suggestion: formatez une page HTML FRAMESET qui contient, disons, 9 cadres à l'intérieur. Chaque cadre obtiendra une "instance" différente de votre page myapp.php. Il y aura 9 threads différents en cours d'exécution sur le serveur Web, en parallèle.

Pour PHP5.5 +, mpyw / co est la solution ultime. Cela fonctionne comme si c'était tj / co en JavaScript.

Exemple

Supposons que vous souhaitiez télécharger les avatars de plusieurs utilisateurs GitHub spécifiés. Les étapes suivantes sont requises pour chaque utilisateur.

1. Obtenez le contenu de http://github.com/mpyw (GET HTML)
2. Trouvez <img class="avatar" src="...">et demandez (GET IMAGE)

---: En attente de ma réponse
... : En attente d'une autre réponse dans des flux parallèles

De nombreux curl_multiscripts basés célèbres nous fournissent déjà les flux suivants.

        /-----------GET HTML\  /--GET IMAGE.........\
       /                     \/                      \ 
[Start] GET HTML..............----------------GET IMAGE [Finish]
       \                     /\                      /
        \-----GET HTML....../  \-----GET IMAGE....../

Cependant, ce n'est pas assez efficace. Voulez-vous réduire les temps d'attente inutiles ...?

        /-----------GET HTML--GET IMAGE\
       /                                \            
[Start] GET HTML----------------GET IMAGE [Finish]
       \                                /
        \-----GET HTML-----GET IMAGE.../

Oui, c'est très simple avec mpyw / co. Pour plus de détails, visitez la page du référentiel.

Voici ma propre fonction PHP lorsque je fais un POST sur une URL spécifique de n'importe quelle page ...

Exemple: * utilisation de ma fonction ...

<?php
    parse_str("[email protected]&subject=this is just a test");
    $_POST['email']=$email;
    $_POST['subject']=$subject;
    echo HTTP_Post("http://example.com/mail.php",$_POST);***

    exit;
?>
<?php
    /*********HTTP POST using FSOCKOPEN **************/
    // by ArbZ

    function HTTP_Post($URL,$data, $referrer="") {

    // parsing the given URL
    $URL_Info=parse_url($URL);

    // Building referrer
    if($referrer=="") // if not given use this script as referrer
      $referrer=$_SERVER["SCRIPT_URI"];

    // making string from $data
    foreach($data as $key=>$value)
      $values[]="$key=".urlencode($value);
    $data_string=implode("&",$values);

    // Find out which port is needed - if not given use standard (=80)
    if(!isset($URL_Info["port"]))
      $URL_Info["port"]=80;

    // building POST-request: HTTP_HEADERs
    $request.="POST ".$URL_Info["path"]." HTTP/1.1\n";
    $request.="Host: ".$URL_Info["host"]."\n";
    $request.="Referer: $referer\n";
    $request.="Content-type: application/x-www-form-urlencoded\n";
    $request.="Content-length: ".strlen($data_string)."\n";
    $request.="Connection: close\n";
    $request.="\n";
    $request.=$data_string."\n";

    $fp = fsockopen($URL_Info["host"],$URL_Info["port"]);
    fputs($fp, $request);
    while(!feof($fp)) {
        $result .= fgets($fp, 128);
    }
    fclose($fp); //$eco = nl2br();

    function getTextBetweenTags($string, $tagname) {
        $pattern = "/<$tagname ?.*>(.*)<\/$tagname>/";
        preg_match($pattern, $string, $matches);
        return $matches[1]; }
    //STORE THE FETCHED CONTENTS to a VARIABLE, because its way better and fast...
    $str = $result;
    $txt = getTextBetweenTags($str, "span"); $eco = $txt;  $result = explode("&",$result);
    return $result[1];
<span style=background-color:LightYellow;color:blue>".trim($_GET['em'])."</span>
</pre> "; 
}
</pre>

Essayez ce code ...

$chu = curl_init();

curl_setopt($chu, CURLOPT_URL, 'http://www.myapp.com/test.php?someprm=xyz');

curl_setopt($chu, CURLOPT_FRESH_CONNECT, true);
curl_setopt($chu, CURLOPT_TIMEOUT, 1);

curl_exec($chu);
curl_close($chu);

N'oubliez pas d'activer l'extension php CURL.

Cela fonctionne bien pour moi, malheureusement, vous ne pouvez pas récupérer la réponse de votre demande:

<?php
header("http://mahwebsite.net/myapp.php?var=dsafs");
?>

Cela fonctionne très vite, pas besoin de sockets TCP bruts :)