php open an asynchronous request and allow client to check if the request has finished

Question

I am trying to create an asynchronous request via php that will allow me to check on the status(complete or still running), the request will take about 6-20 minutes to complete. I need the code to be system independent and maintain the request headers agent id(as this is used in authenticating my users), so I'm thinking I could do something along the lines of the second answer to this question.

the problem is that I don't see a way of communicating with the server to verify that the operation had completed once the request was fired off. Is there some easy way to do this? (I can not predict the effects of the event, aka values might or might not change as a result of it)

Answer 1

so Christian Davénpost on this page inspired my solution to my own problem which is as follows:

if(array_key_exists('async', $_GET)){
   //short-task spawns the child(fakeLongTask())
   testing::curl_request_async();
}else{
    //short task, aka child task
    testing::fakeLongTask();
}

class testing{
    /**
     * asynch trigger a event(parent/short Task)
     */
    public static function curl_request_async(){
        //set file path to a unique file name for you...maybe consider using tmp type functionality
            $file = 'C:\\filepath\\logFile.txt';
        $fp = curl_init('http://localhost/testing.php?file='.$file);
            //send the request off
        curl_exec($fp);
            //because I am not sure that the socket is closed when it interperets the header, and because its a best practice
        curl_close($fp);

        while(file_exists($file)){
            echo 'we are waiting because the process is still going and the lock is still imposed.<br />'.PHP_EOL;
            sleep(3);
        }
    }

    /**
     * this is to mimic a long task that we might be running.
     * basic setup is clear the buffer, set the raw header to the close value to let the browser
     * know that the request has 'finished' so it can return to the calling function after the output is sent.
     * specify the size of the information being sent as this is required for the header. Then send the buffer and start
     * processing asynchronously
     * 
     * child/long/orphaned Task
     */
    public static function fakeLongTask(){
        //clear the buffer
        while(ob_get_level()){
             ob_end_clean();
        }
        //specify that this is a non-persistant connection
        header('Connection: close');
        //if the user kills the script ignore there request and keep on, nice feature to avoid early termination
        ignore_user_abort(true);
        ob_start();
        //if you need to send any information to the user specify that here
        $size = ob_get_length();
        header("Content-Length: $size");
        //since flush might not get everything we must do a 'power flush'
        ob_end_flush();
        flush();
        //from this point on the original function that had the curl op in it will continue and this will also continue on asynchronously
        //create the new file(this is our only way to communicate to the parent script as this function is now running rouge.
        $file = $_GET['file'];
        $fileHandle = fopen($file, 'w') or die('');
        fclose($fileHandle);
        //now that we have our file lets do our process, or in this case just stall for 10 seconds
        sleep(10);
        //we are done with our task delete the file
        unlink($file);
    }
}