node.js - new - Use cancel() dentro de una cadena then creada por promisifyAll

callback to promise bluebird

Question

No estoy seguro si soy lo suficientemente claro con este título, pero supongo que tengo una clase llamada Foo con method1 , method2 y method3 . Prometo sus métodos con promisifyAll .

Luego tengo una cadena entonces y quiero cancelar la operación a la mitad del segundo o primero y luego no se debe llamar.

Leí sobre Cancelación ( http://bluebirdjs.com/docs/api/cancellation.html ) pero no sé cómo implementarlo con promisifyAll.

El código que obtuve más lo que necesito:

var bluebird = require(''bluebird'');
function Foo() { }
Foo.prototype.method1 = function (cb) {};
Foo.prototype.method2 = function (cb) {};
Foo.prototype.method3 = function (cb) {};
var foo = bluebird.promisifyAll(new Foo());
foo.method1Async()
.then(function (r1) {
// cancel then-chain
res.json("Task stopped");
// just stop right here
promises.cancel();
})
.then(function (r2) {
console.log(r2);
}).then(function (r3) {
console.log(r3);
})
.catch(function (er) {
console.log(''Catch!'');
});

¿Cuál es la forma correcta de tener este resultado? Sé que puedo lanzar algo y atraparlo en el método de catch , pero esto supondría un cambio muy grande en mi código real.

Answer 1

Pruebe algo como esto:

var bluebird = require(''bluebird'');
function Foo() { }
Foo.prototype.method1 = function (cb) { cb(null, ''method1''); };
Foo.prototype.method2 = function (cb) { cb(null, ''method2''); };
Foo.prototype.method3 = function (cb) { cb(null, ''method3''); };
var foo = bluebird.promisifyAll(new Foo());
foo.method1Async()
.then(function (r1) {
console.log(''step 1'');
// cancel then-chain
console.log("Task stopped");
// just stop right here
return bluebird.reject(''some reason'');
})
.then(function (r2) {
console.log(''step 2'');
console.log(r2);
}).then(function (r3) {
console.log(''step 3'');
console.log(r3);
})
.catch(function (er) {
console.log(''Catch!'');
console.log(''Error:'', er);
});

En lugar de:

 return bluebird.reject(''some reason'');

puedes usar:

 throw ''some reason'';

y el resultado sería el mismo, pero no quería arrojar errores para poder devolver una promesa rechazada.

Actualización 1

Pero si su intención es ejecutar los 3 métodos en serie, entonces también deberá devolver la siguiente promesa en cada paso con algo como esto:

var bluebird = require(''bluebird'');
function Foo() { }
Foo.prototype.method1 = function (cb) { cb(null, ''method1''); };
Foo.prototype.method2 = function (cb) { cb(null, ''method2''); };
Foo.prototype.method3 = function (cb) { cb(null, ''method3''); };
var foo = bluebird.promisifyAll(new Foo());
foo.method1Async()
.then(function (r1) {
console.log(''step 1'');
console.log(''got value:'', r1);
// cancel? change to true:
var cancel = false;
if (cancel) {
console.log("Task stopped");
return bluebird.reject(''some reason'');
} else {
console.log(''Keep going'');
return foo.method2Async();
}
})
.then(function (r2) {
console.log(''step 2'');
console.log(''got value:'', r2);
return foo.method3Async();
}).then(function (r3) {
console.log(''step 3'');
console.log(''got value:'', r3);
})
.catch(function (er) {
console.log(''Catch!'');
console.log(''Error:'', er);
});

Actualmente el código en su pregunta nunca ejecutará ningún otro método que el primero.

Actualización 2

Otro ejemplo que no llama la última catch para ese caso:

foo.method1Async()
.then(function (r1) {
console.log(''step 1'');
console.log(''got value:'', r1);
// cancel? change to true:
var cancel = true;
if (cancel) {
console.log("Task stopped");
return bluebird.reject(''some reason'');
} else {
console.log(''Keep going'');
return foo.method2Async();
}
})
.then(function (r2) {
console.log(''step 2'');
console.log(''got value:'', r2);
return foo.method3Async();
}).then(function (r3) {
console.log(''step 3'');
console.log(''got value:'', r3);
})
.catch(function (er) {
if (er === ''some reason'') {
return bluebird.resolve(''ok'');
} else {
return bluebird.reject(er);
}
})
.catch(function (er) {
console.log(''Catch!'');
console.log(''Error:'', er);
});

Explicación

Piénselo de esta manera: en código síncrono si tuviera:

r1 = fun1();
r2 = fun2();
r3 = fun3();

entonces la única forma de que fun1 cancele la ejecución de fun2 y fun3 sería lanzar una excepción. Y de manera similar para las promesas, la única forma en que uno de los controladores podría cancelar la ejecución del siguiente controlador es devolver una promesa rechazada. Y al igual que con el código síncrono, la excepción lanzada sería atrapada por el bloque catch , aquí esa promesa rechazada pasaría al controlador catch .

Con el código síncrono, puede tener un try/catch interno que try/catch la excepción y la vuelva a generar si no es la específica que utilizó para cancelar su ejecución. Con las promesas que puede tener un controlador de catch anterior que hace esencialmente lo mismo.

Esto es lo que sucede con el código en la Actualización 2. El motivo de rechazo se compara con algún valor (que es ''some reason'' en ese ejemplo) y si es igual, se devuelve una promesa resuelta y, por lo tanto, no se llama al siguiente controlador de catch . Si no es igual, el motivo de rechazo vuelve a aparecer cuando una promesa rechazada se pasa al siguiente controlador de catch como un error "real" que desea que maneje el último controlador de catch .