HAPI回复正在发送处理程序之前的后续调用

Question

建立我的第一个HAPI api后端，并遇到奇怪的事情。当我第一次点击一个端点时（GET/api/item/{name}，我可以在控制台看到处理函数正在运行（mongo查询），然后发送回复（有响应插件）如果我用另一个参数再次触发端点，我会看到第一个调用的响应马上就会结束，然后处理函数被触发，而事实上，客户端变得相同。响应从第一个呼叫

而且我什至不知道什么是最有用的，张贴在这里了

这里的大部分入口点的JS（缺少配置环境和温斯顿）：

const Hapi = require('hapi'); 
server = new Hapi.Server(); 

var mongo_connect = 'mongodb://' + options.mongo_creds + options.mongo_host + ':' + options.mongo_port + '/' + options.mongo_db; 
const dbOpts = { 
    url: mongo_connect, 
    settings: { 
     poolSize: options.mongo_pool 
    }, 
    decorate: true 
}; 

server.connection({ port: options.server_port }); 

var routes = require('./routes'); 

if (options.env === "dev") { 
    server.on('response', function (request) { 
     winston.log('verbose', `[launch_api] ${request.info.remoteAddress}: ${request.method.toUpperCase()} ${request.url.path} --> ${request.response.statusCode}`); 
    }); 
} 

server.register({ 
    register: require('hapi-mongodb'), 
    options: dbOpts 
}, function(err) { 
    if (err) { 
     winston.log('error', "[launch_api] Unable to register db pool"); 
     throw err; 
    } 

    server.route(routes); 

    server.start(function(err) { 

     if (err) { 
      throw err; 
     } 
     winston.log('info', `[launch_api] Server running at: ${server.info.port}`); 
    }); 
}); 

条

路线都在路由文件夹中的index.js拉在一起，但每个文件有看起来类似：

'use strict'; 
var controller = require('../controllers/item-controller') 

// Routes for Item 

module.exports = [ 
    { 
     method: 'POST', 
     path: '/api/item', 
     config: controller.create 
    }, 
    { 
     method: 'GET', 
     path: '/api/items', 
     config: controller.fetchAll 
    }, 
    { 
     method: 'GET', 
     path: '/api/item/{name}', 
     config: controller.find 
    } 
]; 

所有控制器看起来像这样（只显示为简洁的查找功能，因为这已经长）

const Boom = require('boom'); 
const Joi = require('joi'); 
const Item = require('../models/item'); 

module.exports = { 
    find: { 
     handler: function(request, reply) { 
      Item.initFromName(request.params.name).then(function(newItem) { 
       if (newItem == null) { 
        reply(Boom.notFound()); 
       } 
       else { 
        reply(newItem); 
       } 
      }, function(err) { 
       reply(Boom.badImplementation()); 
      }); 
     } 
    } 
} 

最后，模型往往遵循这个，呃，模型（同样，切出所有原型的扩展，并且只保持一类的功能在这条航线）

const deferred = require('deferred')() 
const winston = require('winston'); 

const collection_name = "items"; 


var Item = function() { 
    this.name = ""; 
    this.description = ""; 
}; 

// private 

function fillFromDB(obj, record) { 
    obj._id = record._id; 
    obj.name = record.name; 
    obj.description = record.description; 
} 

// Constructor 
module.exports.init = function() { 
    return new Item(); 
}; 

module.exports.initFromName = function(name) { 
    var item = new Item(); 
    const db = server.mongo.db; 
    db.collection(collection_name).findOne({name: name}).then(function(opResult) { 
      winston.log("debug","Item.loadFromName opResult is: " + opResult); 
     if (opResult != undefined) { 
      winston.log("debug","Item.loadFromName opResult json is: " + JSON.stringify(opResult)); 
      fillFromDB(item, opResult); 
      deferred.resolve(item); 
     } 
     else { 
      winston.log("debug","Resolving with null"); 
      deferred.resolve(); 
     } 
    }, function(err) { 
     winston.log("error", "Item.loadFromName mongo error: " + err); 
     deferred.reject(); 
    }); 
    return deferred.promise; 
}; 

所有这一切，如果我用卷曲命名我的端点为而不是，那么我会得到404的预期结果。如果我再与该是出了名打，我仍然得到404

此输入：

$ curl -X GET http://192.168.99.100:3000/api/item/not_here 
{"statusCode":404,"error":"Not Found"} 
$ curl -X GET http://192.168.99.100:3000/api/item/here 
{"statusCode":404,"error":"Not Found"} 

产生此日志：

debug: Item.loadFromName opResult is: null 
debug: Resolving with null 
verbose: [launch_api] 192.168.99.1: GET /api/item/not_here --> 404 
verbose: [launch_api] 192.168.99.1: GET /api/item/here --> 404 
debug: Item.loadFromName opResult is: [object Object] 
debug: Item.loadFromName opResult json is: {"_id":"58b622908ea4d1cee2f46462","name":"here","description":"this item is here"} 

需要注意的是相反的方向工作，太。如果我停止并启动节点，然后用存在的名称命中端点，则所有后续调用将返回相同的对象。我无法弄清楚这个缓存在哪里发生。

Answer 1

问题是延迟对象的全局实例化。不知道我在哪里看到，但这是一个坏主意。

在该模型中，改变第一行只是要求

const deferred = require('deferred'); 

然后，在函数创建递延对象那里。

module.exports.initFromName = function(name) { 
    const defer = deferred(); 
    var item = new Item(); 
    const db = server.mongo.db; 
    db.collection(collection_name).findOne({name: name}).then(function(opResult) { 
      winston.log("debug","Item.loadFromName opResult is: " + opResult); 
     if (opResult != undefined) { 
      winston.log("debug","Item.loadFromName opResult json is: " + JSON.stringify(opResult)); 
      fillFromDB(item, opResult); 
      defer.resolve(item); 
     } 
     else { 
      winston.log("debug","Resolving with null"); 
      defer.resolve(); 
     } 
    }, function(err) { 
     winston.log("error", "Item.loadFromName mongo error: " + err); 
     defer.reject(); 
    }); 
    return defer.promise; 
};