How to handle for loop with promises conditionally - node.js

Question

I am still trying to find a way to handle promises in a loop conditionally with the ability to break out of the loop.
Here is a short example
return new Promise(function (resolve, reject) {
if (ipAddresses.length > 0) {
let currentServer, agentOptions;
for (let i = 0; i < ipAddresses.length; i++) {
currentServer = ipAddresses[i];
agentOptions = {
};
// We need to block here
let isReachable = NetworkUtils.checkIfReachable(agentOptions, ip);
if (isReachable) {
resolve(currentServer);
// Break out of the loop
return currentServer;
}
else {
// Continue looping and trying to find a working server
}
}
reject(new Error("No working servers found"));
}
else {
resolve(new Error("No servers ips provided"));
}
})
The problem is that I don't need to run all requests in parallel lie Promise.all or async.foreach, but I rather need to call each promise sequentually and if condition is true I need to break out the loop and do not make any further requests as far as I have found a reachable server.
Please suggest what is the correct way to handle this use case. I have been searching for a long time, but still haven't found any good solution.
Thanks
EDIT
Sorry, yeah NetworkUntils.checkIfReachable() returns promise

Answer 1

Assuming NetworkUntils.checkIfReachable() is actually asynchronous (which is the only context in which this question makes sense and seems likely in nodejs) and assuming that NetworkUntils.checkIfReachable() returns a promise or can easily be changed to return a promise, then you can do the following:
findFirstReachableServer(ipAddresses) {
if (!ipAddresses || !ipAddresses.length) {
return Promise.reject(new Error("No servers ips provided"));
}
let agentOptions = {...};
let index = 0;
function next() {
if (index < ipAddresses.length) {
let ipAddress = ipAddresses[index++];
return NetworkUtils.checkIfReachable(agentOptions, ipAddress).then(function(isReachable) {
if (!isReachable) {
return next();
} else {
return ipAddress;
}
})
} else {
return new Error("No working servers found");
}
}
return Promise.resolve().then(next);
}
This function returns a promise that resolves with the ipAddress if a reachable one was found. It rejects if either no addresses were passed in, no reachable address was found or if NetworkUtils.checkIfReachable() rejects for any internal reason.
Note, to run non-blocking async operations in sequence, you can't use a normal for loop because each individual operation won't block so the for loop won't wait for them (it will just run to completion before any operations have finished). As such, you have to use a different method of sequencing. There are lots of different ways to do that. Since you don't necessarily want to run the entire sequence, I've chosen a manual sequencing where you control whether the next iteration is called or not.

Answer 2

Given you tagged the question async-await, using that is not a bad idea indeed:
async function findWorkingServer(ipAddresses) {
if (ipAddresses.length > 0) {
for (const currentServer of ipAddresses) {
const agentOptions = { … };
const isReachable = await NetworkUtils.checkIfReachable(agentOptions, ip);
// We do "block" here ^^^^^
if (isReachable) {
return currentServer;
}
}
throw new Error("No working servers found");
} else {
return new Error("No servers ips provided"); // I think you meant to `throw` here
}
}