PHP cURL发送和接收图像客户端/服务器

Question

I have been researching this for a while and have not been find an answer for this.

I have a Client Site making calls to our API Server. What I would like to transfer an image to the Client Site when a special call is made.

I have some code that downloads the image from the server, but this is causing us to make multiple calls forcing us to create all these images in the server that we don't want to keep, even if we delete them afterward.

$originalFileUrl = createImage('createImage', $fileName);
downloadImage($originalFileUrl, $fileDestination);
deleteFileFromServer('deleteImage', $fileName);


function serverCall ($action, $fileName) {

      $serverCall = $SERVER.'/api.php?fileName=' . $fileName . '&action=' . $action;

      ob_start();
      $ch = curl_init();
      $timeout = 5; 

      curl_setopt ($ch, CURLOPT_URL, $serverCall);
      curl_setopt ($ch, CURLOPT_RETURNTRANSFER, 0);
      curl_setopt ($ch, CURLOPT_CONNECTTIMEOUT, $timeout);
      curl_exec($ch);

      $fileContents = ob_get_contents();

      curl_close($ch);
      ob_end_clean();

      return $fileContents;
}

function downloadImage ($originalFileUrl, $fileDestination) {      
      // Starting output buffering
      ob_start();

      // create a new CURL resource
      $ch = curl_init();

      // set URL and other appropriate options
      curl_setopt($ch, CURLOPT_URL, $originalFileUrl);
      curl_setopt($ch, CURLOPT_HEADER, false);
      curl_setopt($ch, CURLOPT_BINARYTRANSFER, true);
      curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

      // set timeouts
      set_time_limit(30);                     // set time in secods for PHP
      curl_setopt($ch, CURLOPT_TIMEOUT, 30);  // and also for CURL

      // open a stream for writing
      $outFile = fopen($fileDestination, 'wb');

      curl_setopt($ch, CURLOPT_FILE, $outFile);

      // grab file from URL
      curl_exec($ch);
      fclose($outFile);

      // close CURL resource, and free up system resources
      curl_close($ch);  
      ob_end_clean();
}

Where $originalFileUrl is the current location of the file, and $fileDestination is the path to where I want my new file to be.

My question is: Can I make a call to a PHP file in the Server that will be in charge of create, transfer and delete the image all in one call rather than doing multiple calls?

Also for multiple reasons ftp the file from the server to the client is not a good option.

Thank you

Answer 1

This will not be a trivial task. However, you should be able to design a successful approach. This won't be the most error-safe method of accomplishing the task, though. You're thinking right now of a HTTP-esque stateless protocol, which is manageable. If the description below doesn't sound good enough, consider another protocol which can maintain a constant bi-directional connection (like an SSH tunnel).

You'd likely suffer data overhead, but that would generally be more than acceptable in order to save multiple calls. To that end, I'd advise creating an XML interface. On the receiving end, your XML would have an element with either a Base64 representation of the image, or possibly a gzipped CDATA implementation. You don't have to stick to any XML standard, but if you do, the PHP XML Parser could help with some of the legwork.

So, to recap, in this model, the server end could receive a set of commands which do what you've called out: move the file into a processing folder, create a Base64 string of the file contents, craft the XMl package, and return it. The client will send a request, and process the response. If the client detects an error, it could retry and the server can still grab the file data from the processing queue.

If error becomes an issue and an open socket isn't a good option (because the coding is difficult), you could also develop a delete-batching system, where you track the files in the processing folder and only delete them on request. But, you'd only make delete requests from the client every once in a while, and possibly not as a part of any particular page with a user experience, but from a cron.