Question: I want to perform an operation repeatedly, with an increasing timeout between each operation, until it succeeds or a certain amount of time elapses. How do I structure this with promises in Q?

Answer: 
All the answers here are really complicated in my opinion. Kos has the right idea but you can shorten the code by writing more idiomatic promise code:

```
function retry(operation, delay) {
    return operation().catch(function(reason) {
        return Q.delay(delay).then(retry.bind(null, operation, delay * 2));
    });
}

```

And with comments:

```
function retry(operation, delay) {
    return operation(). // run the operation
        catch(function(reason) { // if it fails
            return Q.delay(delay). // delay 
               // retry with more time
               then(retry.bind(null, operation, delay * 2)); 
        });
}

```

If you want to time it out after a certain time (let's say 10 seconds , you can simply do:

```
var promise = retry(operation, 1000).timeout(10000);

```

That functionality is built right into Q, no need to reinvent it :)
My sugesstion would be to use the `bluebird-retry` library

To install

`npm i bluebird-retry`

```
 var Promise = require('bluebird');
 var retry = require('bluebird-retry');
 var count = 0;
function myfunc() {
    console.log('myfunc called ' + (++count) + ' times '+new Date().toISOString());
    return Promise.reject(new Error(''));
}
retry(myfunc,{ max_tries: 5, interval: 5000, backoff: 2 })
    .then(function(result) {
        console.log(result);
    });

```

The above program tries the promise flow 5 times with `interval * backoff` backoff interval between every retry.

Also, should you require to pass any arguments, pass it as `args` which accepts array of arguments. Include it in options section where `max_retries`, `interval` and `backoff` is mentioned.

Here is the official documentation <https://www.npmjs.com/package/bluebird-retry>