Restify verwenden() nach Route endet

Question

I tred "verwenden()" Methode der Restify zu verwenden, um eine generische Fehlerbehandlung zu tun, zum Beispiel

server = restify.createServer({...}); 
server.use(restify.acceptParser(server.acceptable)); 
server.use(restify.queryParser()); 
server.use(restify.bodyParser()); 
... 
app.post('/test/:id', function (req, res, next) {...}) 
server.use(function(err, req, res, next) { 
     logger.error({req: req}, "error processing request"); 

    }); 

aber das letzte .use() -Prozedur nie nach genannt wurde Route beendet Verarbeitung. Es wurde nach Routen "registriert". Ich kann sehen, auf dem Server startet, wurde diese .use() verarbeitet, nachdem meine Routen verarbeitet wurden. Ich bin ziemlich neu zu restifizieren, also meine Frage ist, kann die .user() -Methode verwendet werden, um Handler nach dem Ende der Route anzuwenden. Ich weiß, dass wir nach dem Ereignis nach der Beendigung der Route die Verarbeitung abhören können, aber wir würden gerne sehen, ob wir den Handler .use() verwenden können.

UPDATE: Hier ist eine vereinfachte Version des Codes. Die vor der server.post() registrierten .use() - Methoden wurden aufgerufen, aber nicht die nach server.post() registrierte Methode. Irgendwelche Vorschläge?

var restify = require('restify'); 
var cookieParser = require('restify-cookies'); 
var helmet = require('helmet'); 
var util = require('util'); 
var logger = require('./util/logger'); 


module.exports = function(server){ 
    server.use(restify.acceptParser(server.acceptable)); 
    server.use(restify.queryParser()); 
    server.use(restify.bodyParser()); 

    server.use(helmet.noCache()); 
    server.use(helmet.hidePoweredBy()); 

    server.use(cookieParser.parse); 

    // this .use() method is called when accessing the server.post route below 
    server.use(function(req, res, next) { 
    console.log('BERORE ROUTE'); 
    return next(); 
    }); 

    server.post('/test/:returnId', function (req, res, next) { 
    var err = new restify.errors.InternalServerError('oh noes!'); 
    return next(err); 
    }); 

    // this .use() method is not called when accessing the server.post route above 
    server.use(function(req, res, next) { 
    console.log('Tata...'); 
    return next(); 
    }); 
}; 

Answer 1

Es wäre interessant, den Code in

app.post('/test/:id', function (req, res, next) { 
    // what is happening here? 
}); 

zu sehen, ich denke, Sie next nicht nennen, so dass die nächste Middleware (Logging-Middleware in der use-Anweisung) wird nie aufgerufen. Wenn Sie also next() anrufen, rufen Sie Ihre Middleware an.

Aber vielleicht wäre es in Ihrem Fall besser sein, um einen Fehler zu erhöhen und den Fehler zu behandeln, wie in der restify docs beschrieben:

app.post('/test/:id', function (req, res, next) { 
    // some internal unrecoverable error 
    var err = new restify.errors.InternalServerError('oh noes!'); 
    return next(err); 
}); 

app.on('InternalServer', function (req, res, err, next) { 
    //err.body = 'something is wrong!'; 
    logger.error({req: req}, "error processing request"); // <= from your code 
    return next(); 
}); 

Aber das hängt davon ab, was Sie erreichen wollen und was Sie sind in der tut app.post.

Answer 2

Der Grund, warum Ihr letzter "use" -Handler nie aufgerufen wird, ist, dass er nicht in der Handler-Kette existiert, als die Handler der Route zugewiesen werden. Für jeden Aufruf von "use" fügt restify diesen Handler zu einem Array von Handlern hinzu.

Wenn eine Routenfunktion (get, post, etc.) aufgerufen wird, erstellt restify eine Kette von Handlern, die für diese Route aufgerufen werden. Die Kette der Handler für jede Route besteht aus dem, was Sie für diese Route eingegeben haben, und ist mit allen Handlern, die bisher mit "benutzen" -Aufrufen gefunden wurden, VORGEHOBEN.

Wenn also der Funktionsaufruf server.post verarbeitet wird, ist der Handler "Tata ..." in der Handlerkette noch nicht vorhanden und wird daher nicht vorangestellt. Deshalb werden alle "Benutzungs" -Rufe immer über den Routen platziert.

Um dies zu veranschaulichen, habe ich zwei console.log-Anweisungen innerhalb der server.use-Funktion in restify platziert. Sie können das Chainbuilding mit den Middleware-Handlern sehen (ich nannte Ihre Funktionen "before" und "error_handler", damit sie in der Ausgabe identifiziert werden konnten). Sie können sehen, dass der letzte Aufruf von server.use zu einer Kette führt, die alle Middleware-Handler enthält. Die Handler für die posttestreturnId-Route enthalten jedoch "error_handler" nicht, weil sie zum Zeitpunkt des Aufrufs nicht im Array waren.

Answer 3

Wenn Sie eine Funktion nach anderen Routen ausführen möchten, verwenden Sie nicht server.use(), sondern verwenden Sie den folgenden Code.

// this .use() method is called when accessing the server.post route below 
server.use(function(req, res, next) { 
    console.log('BERORE ROUTE'); 
    return next(); 
}); 

server.post('/test/:returnId', function (req, res, next) { 
    var err = new restify.errors.InternalServerError('oh noes!'); 
    return next(err); 
}); 

server.on('after', function(req, res, next) { 
    console.log('Tata...'); 
    return next(); 
}); 

Wie hier gezeigt http://restify.com/#audit-logging