Merge branch 'feature/sale' of http://git.dev.yoho.cn/web/yohobuywap-node into feature/sale

@@ -139,3 +139,4 @@ public/css/*
 public/bundle/*
 public/bundle/*
 .eslintcache
 .eslintcache
 *.log.*
 *.log.*
+nbproject/*

@@ -145,7 +145,7 @@ const getChannelResource = (params) => {
         params.new_device = true; // eslint-disable-line
         params.new_device = true; // eslint-disable-line
     }
     }
 
 
-    return api.get('operations/api/v5/resource/home', sign.apiSign(params)).then(result => {
+    return api.get('operations/api/v5/resource/home', sign.apiSign(params), 300).then(result => {
         if (result && result.code === 200) {
         if (result && result.code === 200) {
             return processFloor(result.data.list);
             return processFloor(result.data.list);
         } else {
         } else {
@@ -162,7 +162,7 @@ const getChannelResource = (params) => {
 const getLeftNav = (choosed) => {
 const getLeftNav = (choosed) => {
     choosed = choosed || 'all';
     choosed = choosed || 'all';
 
 
-    return api.get('operations/api/v6/category/getCategory', sign.apiSign({})).then(result => {
+    return api.get('operations/api/v6/category/getCategory', sign.apiSign({}), 300).then(result => {
         if (result && result.code === 200) {
         if (result && result.code === 200) {
             return processSideBar(result.data, choosed);
             return processSideBar(result.data, choosed);
         } else {
         } else {
@@ -179,7 +179,7 @@ const getLeftNav = (choosed) => {
 exports.getChannelDate = (params) => {
 exports.getChannelDate = (params) => {
     var channelData = {};
     var channelData = {};
 
 
-    return Promise.all([getChannelResource(params), getLeftNav(params.gender)]).then((data) => {
+    return api.all([getChannelResource(params), getLeftNav(params.gender)]).then((data) => {
         channelData.content = data[0]; // 资源位数据
         channelData.content = data[0]; // 资源位数据
         channelData.sideNav = data[1]; // 侧边栏数据
         channelData.sideNav = data[1]; // 侧边栏数据
 
 

@@ -15,6 +15,13 @@ module.exports = {
         api: 'http://192.168.102.207:8080/gateway/', // http://devapi.yoho.cn:58078/ http://testapi.yoho.cn:28078/
         api: 'http://192.168.102.207:8080/gateway/', // http://devapi.yoho.cn:58078/ http://testapi.yoho.cn:28078/
         service: 'http://devapi.yoho.cn:58078/'
         service: 'http://devapi.yoho.cn:58078/'
     },
     },
+    useCache: true,
+    memcache: {
+        master: ['192.168.102.168:12580'],
+        slave: ['192.168.102.168:12580'],
+        session: ['192.168.102.168:12580'],
+        timeout: 5000
+    },
     loggers: {
     loggers: {
         infoFile: {
         infoFile: {
             name: 'info',
             name: 'info',

@@ -7,12 +7,16 @@
 'use strict';
 'use strict';
 
 
 const rp = require('request-promise');
 const rp = require('request-promise');
+const qs = require('querystring');
+const md5 = require('md5');
 const _ = require('lodash');
 const _ = require('lodash');
 const log = require('./logger');
 const log = require('./logger');
-const api = require('../config/common').domains.api;
-const serviceApi = require('../config/common').domains.service;
-const searchApi = require('../config/common').domains.search;
+const cache = require('./cache');
 const Timer = require('./timer');
 const Timer = require('./timer');
+const config = require('../config/common');
+const api = config.domains.api;
+const serviceApi = config.domains.service;
+const searchApi = config.domains.search;
 
 
 
 
 let ApiUrl;
 let ApiUrl;
@@ -24,50 +28,107 @@ class API {
     }
     }
 
 
     /**
     /**
-     * get
-     * @param url String
-     * @param data Obejct
+     * 获取请求 ID
      */
      */
-    get(url, data) {
-
-        let options = {
-            url: `${ApiUrl}${url}`,
-            qs: data,
-            json: true
-        };
+    _getReqId(options) {
+        return md5(`${options.url}?${qs.stringify(options.qs || options.form)}`);
+    }
 
 
+    /**
+     * 调用接口
+     */
+    _requestFromAPI(options, cacheOption, reqId) {
         let timer = new Timer();
         let timer = new Timer();
 
 
         timer.put('getApi');// 统计时间开始
         timer.put('getApi');// 统计时间开始
 
 
-        let ret = rp(options);
-
-        return ret.catch((error)=>{
-            let duration = timer.put('getApi');// 接口返回
-
-            log.error('API GET: %s, parms: %j , durationMs: %d ms error: %s , statusCode: %d',
-                     options.url, options.qs, duration, error.message, error.statusCode);
+        log.info(`get api: ${options.url}?${qs.stringify(options.qs)}`);
+        return rp(options).then((result) => {
+            let duration = timer.put('getApi');// 统计时间结束
+
+            log.info(`get api success: use: ${duration}ms`);
+            if (config.useCache && cacheOption) {
+                reqId = reqId || this._getReqId(options);
+
+                // 数据校验无误，写缓存, 否则返回 Slave 缓存服务器的数据
+                if (result && result.code) {
+                    let cacheTime = _.isNumber(cacheOption) ? cacheOption : 60;
+
+                    cache.set(`apiCache:${reqId}`, result, cacheTime);
+                    cache.setSlave(`apiCache:${reqId}`, result, cacheTime);
+                } else {
+                    return this._requestFromCache(options, true);
+                }
+            }
+            return result;
+        }).catch((error)=>{
+            let duration = timer.put('getApi');// 统计时间结束
+
+            log.error(`get api fail: use: ${duration}ms, statusCode: ${error.statusCode}, error: ${error.message}`);
+
+            // 使用缓存的时候，读取二级缓存
+            if (config.useCache) {
+                return this._requestFromCache(options, true);
+            }
+            return Promise.reject({
+                error: '接口调用失败'
+            });
         });
         });
     }
     }
 
 
     /**
     /**
-     * multi get
-     * @params: urls => Array[Object[url[string], data[object]]]
+     * 读取缓存
+     * @param  {[object]} options
+     * @param  {[boolean]} slave true： 读取二级缓存
+     * @return {[type]}
      */
      */
-    multiGet(urls) {
-        var rps = [];
-
-        _.forEach(urls, function(el) {
-            rps.push(rp({
-                url: `${ApiUrl}${el.url}`,
-                qs: el.data,
-                json: true
-            }));
+    _requestFromCache(options, slave) {
+        let reqId = this._getReqId(options);
+        let getCache = slave ? cache.getFromSlave : cache.get;
+
+        log.info(`get cache: ${reqId}, url: ${options.url}?${qs.stringify(options.qs)}`);
+        return getCache(`apiCache:${reqId}`).then((result) => {
+            if (!_.isNil(result)) {
+                try {
+                    result = JSON.parse(result);
+                } finally {
+                    log.info(slave ? 'get slave cache success' : 'get master cache success');
+                    return result;
+                }
+            }
+
+            if (!slave) {
+                return this._requestFromAPI(options, true, reqId);
+            }
+        }).catch(() => {
+            log.error(slave ? 'get slave cache fail' : 'get master cache fail');
+            if (!slave) {
+                return this._requestFromAPI(options, true, reqId);
+            }
         });
         });
+    }
 
 
-        return Promise.all(rps).then((d) => {
-            return d;
-        });
+    /**
+     * 使用 get 请求获取接口
+     * @param  {[string]} url
+     * @param  {[object]} data
+     * @param  {[bool or number]} cacheOption 使用数字时，数字表示缓存时间
+     * @return {[type]}
+     */
+    get(url, data, cacheOption) {
+        let options = {
+            url: `${ApiUrl}${url}`,
+            qs: data,
+            json: true,
+            timeout: 3000
+        };
+
+        // 从缓存获取数据
+        if (config.useCache && cacheOption) {
+            return this._requestFromCache(options);
+        }
+
+        return this._requestFromAPI(options, cacheOption);
     }
     }
 
 
     /**
     /**
@@ -76,12 +137,22 @@ class API {
      * @param data Obejct
      * @param data Obejct
      */
      */
     post(url, data) {
     post(url, data) {
-        return rp({
+        let options = {
             url: `${ApiUrl}${url}`,
             url: `${ApiUrl}${url}`,
-            method: 'post',
             form: data,
             form: data,
-            json: true
-        });
+            method: 'post',
+            json: true,
+            timeout: 3000
+        };
+
+        return this._requestFromAPI(options);
+    }
+
+    all(list) {
+        if (_.isArray(list)) {
+            return Promise.all(list);
+        }
+        throw Error('the parameters of api all method should be Array!');
     }
     }
 }
 }
 
 

+/**
+ * 缓存封装
+ * 前期使用 memcache, 写方法的时候考虑一下如何转换为 redis
+ * @author bikai kai.bi@yoho.cn
+ * @date 2016/05/16
+ */
+
+'use strict';
+const Promise = require('bluebird');
+const Memcached = require('memcached');
+const _ = require('lodash');
+const log = require('./logger');
+const config = require('../config/common');
+
+let master = new Memcached(config.memcache.master, config.memcache);
+let slave = new Memcached(config.memcache.slave, config.memcache);
+
+master = Promise.promisifyAll(master);
+slave = Promise.promisifyAll(slave);
+
+/**
+ * 获取缓存
+ * @param  {[string]} key 键
+ * @return {[type]}
+ */
+exports.get = (key) => {
+    if (_.isString(key)) {
+        return master.getAsync(key);
+    }
+
+    return Promise.resolve();
+};
+
+/**
+ * 批量获取缓存
+ * @param  {[array]} list 字符串数组
+ * @return {[type]}
+ */
+exports.getMulti = (list) => {
+    if (_.isArray(list)) {
+        return master.getMultiAsync(list);
+    }
+    return Promise.resolve();
+};
+
+/**
+ * 获取缓存(从 Slave 服务器)
+ * @param  {[string]} key 键
+ * @return {[type]}
+ */
+exports.getFromSlave = (key) => {
+    if (_.isString(key)) {
+        return slave.getAsync(key);
+    }
+    return Promise.resolve();
+};
+
+/**
+ * 批量获取缓存(从 Slave 服务器)
+ * @param  {[array]} list 字符串数组
+ * @return {[type]}
+ */
+exports.getMultiFromSlave = (list) => {
+    if (_.isArray(list)) {
+        return slave.getMultiAsync(list);
+    }
+    return Promise.resolve();
+};
+
+/**
+ * 写缓存
+ * @param  {[type]} key 键
+ * @param  {[type]} value 值
+ * @param  {[type]} lifetime 生命周期
+ * @return {[type]}
+ */
+exports.set = (key, value, lifetime) => {
+    lifetime = lifetime || 86400;
+
+    log.info(`write cache: ${key}`);
+    if (_.isObject(value)) {
+        value = JSON.stringify(value);
+    }
+
+    if (_.isString(key)) {
+        return master.setAsync(key, value, lifetime);
+    }
+    return Promise.resolve();
+};
+
+/**
+ * 写缓存(到 Slave 服务器)
+ * @param  {[type]} key 键
+ * @param  {[type]} value 值
+ * @param  {[type]} lifetime 生命周期
+ * @return {[type]}
+ */
+exports.setSlave = (key, value, lifetime) => {
+    lifetime = lifetime || 86400;
+
+    if (_.isObject(value)) {
+        value = JSON.stringify(value);
+    }
+
+    if (_.isString(key)) {
+        return slave.setAsync(key, value, lifetime);
+    }
+    return Promise.resolve();
+};
+
+/**
+ * 删除缓存
+ * @param  {[string]} key 键
+ * @return {[type]}
+ */
+exports.del = (key) => {
+    if (_.isString(key)) {
+        return master.delAsync(key);
+    }
+    return Promise.resolve();
+};

@@ -30,6 +30,7 @@
   },
   },
   "license": "MIT",
   "license": "MIT",
   "dependencies": {
   "dependencies": {
+    "bluebird": "^3.3.5",
     "body-parser": "^1.15.0",
     "body-parser": "^1.15.0",
     "cookie-parser": "^1.4.1",
     "cookie-parser": "^1.4.1",
     "express": "^4.13.1",
     "express": "^4.13.1",
@@ -37,6 +38,7 @@
     "influxdb-winston": "^1.0.1",
     "influxdb-winston": "^1.0.1",
     "lodash": "^4.12.0",
     "lodash": "^4.12.0",
     "md5": "^2.1.0",
     "md5": "^2.1.0",
+    "memcached": "^2.2.1",
     "morgan": "^1.7.0",
     "morgan": "^1.7.0",
     "oneapm": "^1.2.20",
     "oneapm": "^1.2.20",
     "request-promise": "^3.0.0",
     "request-promise": "^3.0.0",