Komodo / komodo-center-httpget-x

Browse Code »

Commit cd4feda874d40350602bf6821c4d9bef6e0d8bed

Authored by Adhidarma Hadiwinoto 4 years ago

1 parent 05d016dd09

Exists in master and in 1 other branch

APISERVER and MATRIX

Showing 11 changed files with 132 additions and 3 deletions Inline Diff

config.sample.json
index.js
lib/apiserver/index.js
lib/apiserver/routers/matrix.js
lib/apiserver/valid-apikey.js
lib/core-callback/index.js
lib/core-callback/sender.js
lib/matrix.js
lib/middlewares/common.js
lib/partner-listener/index.js
lib/partner-listener/routers/topup.js

config.sample.json

Diff comments View file @ cd4feda

 {
     "name": "HTTPGETX",
     "# core_url": "Silahkan diisi dengan core url, bisa dikosongkan jika ingin membaca dari main config komodo",
     "core_url": "",
     "listener": {
         "partner": {
             "trust_proxy": ["loopback", "linklocal"],
             "port": 25614
         },
         "core": {
             "port": 25615
+        },
+        "apiserver": {
+            "port": 25617,
+            "apikey": "PLEASE_CHANGE_ME"
         }
     },
     "callback_sender": {
         "http_timeout_ms": 30000,
         "sleep_before_retry_ms": 10000,
         "max_retry": 10
     },
     "# cluster": "Isi dengan boolean atau angka jumlah anak yang akan dibuat. Jika diisi boolean true, jumlah anak akan dihitung otomatis",
     "cluster": false
 }

index.js

Diff comments View file @ cd4feda

 process.chdir(__dirname);
 const fs = require('fs');
 const numCPUs = require('os').cpus().length;
 fs.writeFileSync('pid.txt', process.pid.toString());
 const config = require('komodo-sdk/config');
 global.KOMODO_LOG_LABEL = `KOMODO-CENTER@${config.name || 'HTTPGETX'}`;
 process.title = global.KOMODO_LOG_LABEL;
 const cluster = require('cluster');
 const logger = require('komodo-sdk/logger');
 if (config.cluster && cluster.isMaster) {
     const numberOfChildren = config.cluster === true ? numCPUs + 1 : config.cluster;
     logger.info('Running on cluster mode', {
         masterPid: process.pid,
         numberOfChildren,
     });
     for (let i = 0; i < numberOfChildren; i += 1) {
         cluster.fork();
     }
 } else {
     if (config.cluster) {
         logger.info(`Worker ${process.pid} started`);
     }
     // eslint-disable-next-line global-require
+    require('./lib/apiserver');
+    // eslint-disable-next-line global-require
     require('./lib/core-callback');
     // eslint-disable-next-line global-require
     require('./lib/partner-listener');
 }

lib/apiserver/index.js

Diff comments View file @ cd4feda

File was created	1	const MODULE_NAME = 'APISERVER';
	2
	3	const express = require('express');
	4	const config = require('komodo-sdk/config');
	5	const logger = require('komodo-sdk/logger');
	6
	7	const validApikey = require('./valid-apikey');
	8
	9	const middlewareCommon = require('../middlewares/common');
	10	const routerMatrix = require('./routers/matrix');
	11
	12	const app = express();
	13
	14	app.use((req, res, next) => {
	15	res.locals.httpgetx_subsystem = MODULE_NAME;
	16	next();
	17	});
	18
	19	const apikeyChecker = (req, res, next) => {
	20	if (validApikey(req.params.apikey)) {
	21	next();
	22	} else {
	23	res.status(403).end('Invalid APIKEY');
	24	}
	25	};
	26
	27	app.use(middlewareCommon);
	28
	29	app.use('/apikey/:apikey', apikeyChecker);
	30	app.use('/apikey/:apikey/matrix', routerMatrix);
	31
	32	app.use((req, res) => {
	33	const { xid } = res.locals;
	34	res.status(404).end(`KOMODO-HTTP-GET-X CENTER (APISERVER).\n404: Method not found.\n\nXID: ${xid}.\n`);
	35	});
	36
	37	const listenPort = config.listener && config.listener.apiserver && config.listener.apiserver.port;
	38	if (
	39	listenPort
	40	&& config.listener && config.listener.apiserver && config.listener.apiserver.apikey
	41	) {
	42	app.listen(listenPort, () => {
	43	logger.info(`${MODULE_NAME} FAEE1E47: Listening`, { port: listenPort });
	44	});
	45	} else {
	46	logger.info(`${MODULE_NAME}: Disabled because of missing configuration`);
	47	}
	48

lib/apiserver/routers/matrix.js

Diff comments View file @ cd4feda

File was created	1	const express = require('express');
	2
	3	const os = require('os');
	4	const matrix = require('../../matrix');
	5
	6	const router = express.Router();
	7	module.exports = router;
	8
	9	const pageIndex = (req, res) => {
	10	matrix.uptime = process.uptime();
	11	matrix.loadavg = os.loadavg();
	12	matrix.workdir = process.cwd;
	13	matrix.memory_usage = process.memoryUsage();
	14
	15	res.json(matrix);
	16	};
	17
	18	router.all('/', pageIndex);
	19

lib/apiserver/valid-apikey.js

Diff comments View file @ cd4feda

File was created	1	const config = require('komodo-sdk/config');
	2
	3	module.exports = (apikey) => apikey
	4	&& apikey === (
	5	config.listener && config.listener.apiserver && config.listener.apiserver.apikey
	6	);
	7

lib/core-callback/index.js

Diff comments View file @ cd4feda

 const MODULE_NAME = 'CORE-CALLBACK';
 const DEFAULT_LISTENER_FROM_CORE = 25613;
 const express = require('express');
 const config = require('komodo-sdk/config');
 const logger = require('komodo-sdk/logger');
 const middlewareCommon = require('../middlewares/common');
 const sender = require('./sender');
+const matrix = require('../matrix');
 const app = express();
 app.use(express.json({ extended: true }));
 app.use(express.urlencoded({ extended: true }));
 app.use((req, res, next) => {
     res.locals.httpgetx_subsystem = MODULE_NAME;
     next();
 });
 app.use(middlewareCommon);
 app.use((req, res) => {
+    matrix.messages_from_core += 1;
     res.end('OK');
     sender(req.query, res.locals.xid);
 });
 const port = (config.listener && config.listener.core && config.listener.core.port)
     || DEFAULT_LISTENER_FROM_CORE;
 app.listen(port, () => {
     logger.info(`${MODULE_NAME} 0375DC4E: Listen from CORE callback on port ${port}`);
 }).on('error', (e) => {
     logger.error(`${MODULE_NAME} A90E42D5: Can not listen CORE callback on port ${port}. ${e.toString()}`);
     process.exit(1);
 });

lib/core-callback/sender.js

Diff comments View file @ cd4feda

 const MODULE_NAME = 'CORE-CALLBACK.SENDER';
 const axios = require('axios').default;
 const config = require('komodo-sdk/config');
 const logger = require('komodo-sdk/logger');
+const matrix = require('../matrix');
 const HTTP_TIMEOUT = Number(
     config.callback_sender && config.callback_sender.http_timeout_ms,
 ) || 30 * 1000;
 const SLEEP_BEFORE_RETRY_MS = Number(
     config.callback_sender && config.callback_sender.sleep_before_retry_ms,
 ) || 10 * 1000;
 const MAX_RETRY = Number(
     config.callback_sender && config.callback_sender.max_retry,
 ) || 10;
 logger.verbose(`${MODULE_NAME} 848B9104: Initialized`, {
     HTTP_TIMEOUT,
     SLEEP_BEFORE_RETRY_MS,
     MAX_RETRY,
 });
 const axiosHeaders = {
     'Content-Type': 'application/json',
     'User-Agent': 'KOMODO-HTTPGETX callback sender',
 };
 const sleep = require('../sleep');
 const urlConcatQs = require('../url-concat-qs');
 const sender = async (data, xid, retry) => {
     if (!data.reverse_url) {
         logger.verbose(`${MODULE_NAME} C4FF18FB: Ignoring missing reverse url`, {
             xid,
             dataFromCore: data,
         });
         return;
     }
     const params = {
         httpgetx_xid: xid,
         command: data.command,
         request_id: data.request_id && data.request_id.toString(),
         transaction_id: data.transaction_id && data.transaction_id.toString(),
         transaction_date: data.transaction_date,
         store_name: data.store_name,
         terminal_name: data.terminal_name,
         product_name: data.product_name,
         destination: data.destination,
         rc: data.rc,
         sn: data.sn || undefined,
         amount: Number(data.amount) || undefined,
         ending_balance: Number(data.ending_balance) || undefined,
         message: data.message,
         bill_count: Number(data.bill_count) || undefined,
         bill_amount: Number(data.bill_amount) || undefined,
         fee_per_bill: Number(data.fee) || undefined,
         fee_total: Number(data.fee_total) || undefined,
         bill_detail: data.bill_detail || undefined,
     };
     if (data.command === 'INQUIRY' && data.amount_to_charge) {
         params.amount_to_charge = data.amount_to_charge;
     }
     const isPostpaid = ['INQUIRY', 'PAY'].indexOf(data.command) >= 0;
     const isHttpPost = isPostpaid;
     const endpointUrl = isHttpPost ? data.reverse_url : urlConcatQs(data.reverse_url, params);
     logger.info(`${MODULE_NAME} 8B6A4CEC: Sending to PARTNER`, {
         xid,
         retry,
         isPostpaid,
         isHttpPost,
         endpointUrl,
     });
     try {
         const response = isHttpPost
             ? await axios.post(data.reverse_url, params, {
                 timeout: HTTP_TIMEOUT,
                 headers: axiosHeaders,
             })
             : await axios.get(data.reverse_url, {
                 params,
                 timeout: HTTP_TIMEOUT,
                 headers: axiosHeaders,
             });
+        matrix.callback_sender.message_sent += 1;
+        if (isPostpaid) {
+            matrix.callback_sender.message_sent_using_post_method += 1;
+        } else {
+            matrix.callback_sender.message_sent_using_get_method += 1;
+        }
         logger.info(`${MODULE_NAME} 3641FBD7: Has been sent to PARTNER successfully`, {
             xid,
             retry,
             httpStatus: response.status,
             responseBody: response && response.data,
         });
     } catch (e) {
+        matrix.callback_sender.message_sent_failed += 1;
         logger.warn(`${MODULE_NAME} A1EC9E70: Failed on sending to PARTNER`, {
             xid,
             retry,
             maxRetry: MAX_RETRY,
             errCode: e.code,
             errMessage: e.message,
             reverseUrl: data.reverse_url,
             endpointUrl,
             httpStatus: e.response && e.response.status,
             responseBody: e.response && e.response.data,
         });
         if ((retry || 0) < MAX_RETRY) {
             await sleep(SLEEP_BEFORE_RETRY_MS);
             logger.verbose(`${MODULE_NAME} D8958695: Going to retry sending CORE-CALLBACK TO PARTNER`, {
                 xid, sleepTime: SLEEP_BEFORE_RETRY_MS,
             });
             sender(data, xid, (retry || 0) + 1);
         }
     }
 };
 module.exports = sender;

lib/matrix.js

Diff comments View file @ cd4feda

File was created	1	const os = require('os');
	2	// const config = require('komodo-sdk/config');
	3
	4	module.exports = {
	5	pid: process.pid,
	6	start_time: new Date(),
	7	uptime: process.uptime(),
	8	hostname: os.hostname(),
	9	loadavg: os.loadavg(),
	10	workdir: process.cwd(),
	11	memory_usage: process.memoryUsage(),
	12	messages_from_core: 0,
	13	messages_to_core: 0,
	14	callback_sender: {
	15	message_sent: 0,
	16	message_sent_failed: 0,
	17	message_sent_using_get_method: 0,
	18	message_sent_using_post_method: 0,
	19	},
	20	};
	21

lib/middlewares/common.js

Diff comments View file @ cd4feda

-// const uuidv1 = require('uuid/v1');
+const MODULE_NAME = 'MIDDLEWARES';
+const uuidv1 = require('uuid/v1');
 const uniqid = require('uniqid');
+const config = require('komodo-sdk/config');
 const logger = require('komodo-sdk/logger');
 module.exports = function common(req, res, next) {
     if (req.url.search('/favicon.ico') === 0) {
         res.sendStatus(404);
         return;
     }
-    res.locals.xid = uniqid();
+    res.locals.xid = config.xid_from_uuid ? uuidv1()
+        : uniqid();
     res.locals.x_http_request_ts = new Date();
-    logger.info(`Got request from ${res.locals.httpgetx_subsystem === 'CORE-CALLBACK' ? 'CORE' : 'PARTNER'}`, {
+    logger.info(`${MODULE_NAME}.COMMON B6257542: Got a request`, {
         xid: res.locals.xid,
         pid: process.pid,
+        subsystem: res.locals.httpgetx_subsystem,
         requester_ip: req.ip,
         method: req.method,
         path: req.path,
         url: req.url,
         qs: req.query,
         body: req.body,
     });
     next();
 };

lib/partner-listener/index.js

Diff comments View file @ cd4feda

+const MODULE_NAME = 'PARTNER-LISTENER';
 const DEFAULT_LISTENER_FROM_PARTNER_PORT = 25614;
 const express = require('express');
 const config = require('komodo-sdk/config');
 const logger = require('komodo-sdk/logger');
 const middlewareCommon = require('../middlewares/common');
 const routerInquiry = require('./routers/inquiry');
 const routerPay = require('./routers/pay');
 const routerTopup = require('./routers/topup');
 const routerTrxStatus = require('./routers/trx-status');
 const app = express();
 if (config.partner && config.partner.trust_proxy) {
     app.set('trust proxy', config.partner.trust_proxy);
 }
+app.use((req, res, next) => {
+    res.locals.httpgetx_subsystem = MODULE_NAME;
+    next();
+});
 app.use(express.json({ extended: true }));
 app.use(express.urlencoded({ extended: true }));
 app.use(middlewareCommon);
 app.use('/ping', (req, res) => {
     res.json({
         error: false,
         xid: res.locals.xid,
         from_ip: req.ip,
         ts: new Date(),
         request: {
             method: req.method,
             userAgent: req.get('user-agent'),
             contentType: req.get('content-type'),
             qs: req.query,
             body: req.body,
         },
     });
 });
 app.use('/inquiry', routerInquiry);
 app.use('/pay', routerPay);
 app.use('/topup', routerTopup);
 app.use('/trx-status', routerTrxStatus);
 app.use((req, res) => {
     const { xid } = res.locals;
     res.status(404).end(`KOMODO-HTTP-GET-X CENTER.\n404: Method not found.\n\nXID: ${xid}.\n`);
 });
 app.listen(config.listener.partner.port || DEFAULT_LISTENER_FROM_PARTNER_PORT, () => {
     logger.info(`Listen from partner request on port ${config.listener.partner.port}`);
 }).on('error', (e) => {
     logger.error(`Can not listen request from partner on port ${config.listener.partner.port || DEFAULT_LISTENER_FROM_PARTNER_PORT}. ${e.toString()}`);
     process.exit(1);
 });

lib/partner-listener/routers/topup.js

Diff comments View file @ cd4feda

 const MODULE_NAME = 'PARTNER-LISTENER.ROUTER.TOPUP';
 const express = require('express');
 const config = require('komodo-sdk/config');
 const logger = require('komodo-sdk/logger');
 const coreapi = require('komodo-sdk/coreapi');
 // const coreapi = require('../../coreapi');
+const matrix = require('../../matrix');
 const router = express.Router();
 module.exports = router;
 function onInvalidParameter(missingParameter, req, res) {
     logger.verbose(`${MODULE_NAME} 1536D577: Undefined ${missingParameter} parameter`, {
         xid: res.locals.xid,
         ip: req.ip,
         terminal_name: req.body.terminal_name || req.query.terminal_name,
         request_id: req.body.request_id || req.query.request_id,
         product_name: req.body.product_name || req.query.product_name,
         destination: req.body.destination || req.query.destination,
     });
     res.end('INVALID REQUEST');
 }
 function pagePrerequisite(req, res, next) {
     if (!req.body) req.body = {};
     if (!req.body.terminal_name && !req.query.terminal_name) {
         onInvalidParameter('terminal_name', req, res);
         return;
     }
     if (!req.body.password && !req.query.password) {
         onInvalidParameter('password', req, res);
         return;
     }
     if (!req.body.request_id && !req.query.request_id) {
         onInvalidParameter('request_id', req, res);
         return;
     }
     if (!req.body.product_name && !req.query.product_name) {
         onInvalidParameter('product_name', req, res);
         return;
     }
     if (!req.body.destination && !req.query.destination) {
         onInvalidParameter('destination', req, res);
         return;
     }
     next();
 }
 async function pageIndex(req, res) {
     const { xid } = res.locals;
     const terminalName = `${req.body.terminal_name || req.query.terminal_name}@${req.ip.replace(/^::ffff:/, '')}`;
+    matrix.messages_to_core += 1;
     const [err, coreResponse] = await coreapi({
         xid,
         path: '/prepaid/buy',
         qs: {
             terminal_name: terminalName,
             password: req.body.password || req.query.password,
             request_id: req.body.request_id || req.query.request_id,
             product_name: req.body.product_name || req.query.product_name,
             destination: req.body.destination || req.query.destination,
             origin: config.name || 'HTTPGETX',
             report_ip: config.listener.core.ip || null,
             report_port: config.listener.core.port,
             reverse_url: req.body.reverse_url || req.query.reverse_url || null,
         },
     });
     if (err || !coreResponse) {
         logger.warn(`${MODULE_NAME} 8DEBE15F: ERROR on /prepaid/buy response`, {
             xid,
             err,
             coreResponseTypeof: typeof coreResponse,
             coreResponse,
         });
         res.end('INVALID CORE RESPONSE');
         return;
     }
     logger.verbose(`${MODULE_NAME} 2528A9B4: Got CORE response`, {
         xid,
         coreResponse,
     });
     const responseToPartner = {
         httpgetx_xid: xid,
         request_id: coreResponse.request_id,
         transaction_id: coreResponse.transaction_id,
         transaction_date: coreResponse.transaction_date,
         store_name: coreResponse.store_name,
         terminal_name: coreResponse.terminal_name,
         product_name: coreResponse.product_name,
         destination: coreResponse.destination,
         rc: coreResponse.rc,
         sn: coreResponse.sn || undefined,
         amount: Number(coreResponse.amount) || undefined,
         ending_balance: Number(coreResponse.ending_balance) || undefined,
         message: coreResponse.message,
     };
     res.json(responseToPartner);
 }
 // router.all('/', (req, res) => { res.status(404).end('404: Not implemented yet'); });
 router.get('/', pagePrerequisite, pageIndex);