JS example 1

this code assumes you want to abort the other requests if any one request fails (via a 404 or 500 response, or times out) , and does not need to evaluate the data response to determine a business logic failure scenario. $.when()

The method will resolve its master Deferred as soon as all the Deferreds resolve, or reject the master Deferred as soon as one of the Deferreds is rejected.

    $.when(fireRequest(1), fireRequest(2),fireRequest(3))
  .then(myAllSuccessfulFunc, oneFailedFunc);

function myAllSuccesfulFunc(req1,req2,req3){
//everything returned a 200.
   alert("these are not the droids you are looking for");
};
function oneFailedFunc(req1,req2,req3){
    //* each req looks like [ "not success", statusText, jqXHR ] */
//feel free to check what failed, but I don't know what you need

   req1[2].abort();
   req2[2].abort();
   req3[2].abort();
};

js example 2

you actually need to parse a successful request for data in the response to see if you should fail the other requests due to logic from the back end.

var stop = 4;
//if you are sure fireRequest(x) returns a good promise object, do this:
callNext(fireRequest(1),1);

function callNext(promise, currentIndex){
   promise.done(function(ajaxArgs){
   var jqXHR = ajaxArgs[2];
//replace this with some logic check that makes sense to your app
   if(/error/.test(jqXHR.responseText)){
    //do something
   }else if(currentIndex <stop){
    callNext(fireRequest(currentIndex+1),currentIndex+1);
   }).fail(function(ajaxArgs){
   //server returned a 404, or a 500, or something not a success.
   });
};

I think the problem is that $.Deferred and the likes are designed for handling async and concurrent procedures, so you will always have to trick them somehow if you want to have them act the way you are describing it.

If you want/need to process your calls one after the other (using AJAX) I'd suggest putting them into an Array and using a simple recursive function to loop through that array until all calls are done or one of them failed.

This would basically work like:

var requests = [
  {
  url : '/serviceA'
  data : myParams4ServiceA
  },
  ...
  {
  url : '/serviceZ'
  data : myParams4ServiceZ
  }
];

Now that you have an Array of AJAX requests you can build a recursive function that will work through them one by one:

function work(){

$.ajax(requests[0]).done(function(data){
  //handle data here
  requests.shift(); //request is done and can be removed from the Array, request[0] will now be the next request in the queue

  if (requests.length){
    work(); //function calls itself again if there's still need for it
  } else {
    // we are done!
  }

}).fail(function(e){
  //call failed -> handle error
});

}

work();

See this fiddle for an example of a successful chain, and this one for a chain that fails.

Another possibility would be setting the AJAX calls to async : false (note that this is deprecated in jQuery 1.8+ : "As of jQuery 1.8, the use of async: false with jqXHR ($.Deferred) is deprecated; you must use the complete/success/error callbacks." which is pointing us back up again), and use a simple $.when().then().fail() chain that you apply to your array of requests like:

$.when.apply($, requests).then(function(){

    $.each(arguments, function(){
        //do stuff with your data
    });

}).fail(function(){

    //handle the error

});

As your calls are blocking now this will also process them in a row. See a fiddle for that as well.