pot-js/lib/Connection/getInfoVerbose.js

Process management module

'use strict';

Object.defineProperty(exports, "__esModule", {
	value: true
});

var _pidusage = require('pidusage');

var _pidusage2 = _interopRequireDefault(_pidusage);

var _potLogger = require('pot-logger');

var _filesize = require('filesize');

var _filesize2 = _interopRequireDefault(_filesize);

var _os = require('os');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }

const assign = Object.assign;


const parseMemoryUsage = state => {
	const memoryUsage = state.memoryUsage;
	const used = memoryUsage.used,
	      total = memoryUsage.total;


	if (isNaN(used) || isNaN(total)) {
		assign(memoryUsage, {
			value: '-',
			percent: '-',
			styled: '-'
		});
	} else {
		const styledUsed = (0, _filesize2.default)(used);
		const value = used / total * 100;
		const percent = `${value.toFixed(2)}%`;
		assign(memoryUsage, {
			value,
			percent,
			styled: `${styledUsed} (${percent})`
		});
	}
	return state;
};

const parseCpuUsage = state => {
	const cpuUsage = state.cpuUsage;
	const value = cpuUsage.value;

	cpuUsage.percent = isNaN(value) ? '-' : `${value}%`;
	cpuUsage.styled = cpuUsage.percent;
	return state;
};

const startedLocal = state => {
	state.monitor.startedLocal = new Date(state.monitor.started).toLocaleString();
	return state;
};

exports.default = (() => {
	var _ref = _asyncToGenerator(function* (state) {
		if (!state) {
			return;
		}

		const exportState = function exportState() {
			let usages = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

			Object.assign(state, {
				memoryUsage: {
					used: NaN,
					total: NaN
				},
				cpuUsage: {
					value: NaN
				}
			}, usages);
			parseMemoryUsage(state);
			parseCpuUsage(state);
			startedLocal(state);
			return state;
		};

		const pid = state.pid;

		if (!pid) {
			return exportState();
		}

		try {
			const pidState = yield (0, _pidusage2.default)(pid);
			const memory = pidState.memory,
			      cpu = pidState.cpu;

			const total = (0, _os.totalmem)();
			return exportState({
				memoryUsage: {
					used: memory,
					total
				},
				cpuUsage: { value: cpu }
			});
		} catch (err) {
			_potLogger.logger.error(err.message);
			_potLogger.logger.debug(err);
			return exportState();
		}
	});

	function handleInfoVerbose(_x) {
		return _ref.apply(this, arguments);
	}

	return handleInfoVerbose;
})();