CODEWITHSUNDEEP
javascriptphp
Deadweight
Deadweight

Reputation: 137

Multiple HTTP Request to a Single File

Currently, I am attempting to call a single PHP file named 'sniffer.php'. I am doing this async using javascript to a PHP file. The issue that I am currently having is that in the PHP code I added a sleep function to randomly (to act like a page is loading). The issue with that is two or more functions call that page it still waits until one of the pages finishes first then stops starts the other request. EG: One sleeps for 5 seconds and the other sleeps for 6 seconds. The first one completes in 5 seconds and the next one finishes at 11 seconds. What I am looking for is the one finishes in 5 seconds and the next finishes the one second after. I am not sure if it's just 'sleep' causing the issue or if the file is 'locked' because of the sleep.

Thanks for any help/feedback.

My PHP File looks like this:

$c = rand(2,10);
sleep($c);
$html .= $c;
echo json_encode(array('html'=>$html,'status'=>1));
exit;

My javascript class looks like this:

var path = '/';

var polling = {
    add : function(name, obj) {
        this[name] = new xAjax(obj);
        return this;
    }
};

function xAjax(options) {

    var consti = {
    };
    var defaults = {
        url: path + 'sniffer.php',
        method: 'POST',
        responseType: 'json',
        async: true,
        timeout: 30000,
        success: function(response) {console.log(response);},
        done: function() {},
        beforeSend: function() {},
        error: function(e) {console.log(e);},
        abort: function() {}
    };
    var settings = Object.assign({}, defaults, options, consti);
    var xhr = null;

    this.run = function() {
        xhr = new XMLHttpRequest();

        settings.beforeSend();
        xhr.responseType = settings.responseType;
        xhr.open(settings.method, settings.url, settings.async);
        xhr.timeout = settings.timeout;
        xhr.onreadystatechange = function() {
            if ( xhr.readyState == XMLHttpRequest.DONE ) {
                if ( xhr.status === 200 ) {
                    settings.success(xhr.response);
                } else {
                    settings.error(xhr.response);
                }
                settings.done();
                xhr = null;
            }
        };
        xhr.send();
        return this;
    };

    this.abort = function() {
        xhr.abort();
        xhr = null;
        settings.abort();
        return this;
    };

    this.isRunning = function() {
        return xhr != null;
    };

    this.set = function(options) {
        settings = Object.assign({}, defaults, options, consti);
        return this;
    };
}

My creation/call to the sniffer.php:

polling.add('x');
polling.x.run();
polling.add('y');
polling.y.run();

Upvotes: 1

Views: 693

Answers (1)

Salketer
Salketer

Reputation: 15711

This is happening because of sessions. It would happen with or without sleep, if the script takes time.

What happens when you start a session? PHP has to make sure the session data is current and that it will not change, it also has to make sure that the data it changes will be available in the next executions.

So if a script tries to open the session while it is open somewhere else, there's a lock, because the first script might very well change the session information still. Once the first script closes the session, the next script can get a hold of it and go on.

You can call session_write_close() to close the session for write, and thus remove the lock. While the session is closed, its value can still be accessed but it will be the value before any subsequent script changed anything (if your second script changes something before first script ends, it will not be known). Also, if you write new data to the session, it will not be saved...

From documentation

Session data is usually stored after your script terminated without the need to call session_write_close(), but as session data is locked to prevent concurrent writes only one script may operate on a session at any time.

Also it seems like you are not the only one:

You can have interesting fun debugging anything with sleep() in it if you have a session still active. For example, a page that makes an ajax request, where the ajax request polls a server-side event (and may not return immediately).

If the ajax function doesn't do session_write_close(), then your outer page will appear to hang, and opening other pages in new tabs will also stall.

Upvotes: 1

Related Questions