feat: 초기 프로젝트 설정 및 룰.md 파일 추가
This commit is contained in:
766
api.hyungi.net/node_modules/systeminformation/lib/docker.js
generated
vendored
Normal file
766
api.hyungi.net/node_modules/systeminformation/lib/docker.js
generated
vendored
Normal file
@@ -0,0 +1,766 @@
|
||||
'use strict';
|
||||
// @ts-check
|
||||
// ==================================================================================
|
||||
// docker.js
|
||||
// ----------------------------------------------------------------------------------
|
||||
// Description: System Information - library
|
||||
// for Node.js
|
||||
// Copyright: (c) 2014 - 2025
|
||||
// Author: Sebastian Hildebrandt
|
||||
// ----------------------------------------------------------------------------------
|
||||
// License: MIT
|
||||
// ==================================================================================
|
||||
// 13. Docker
|
||||
// ----------------------------------------------------------------------------------
|
||||
|
||||
const util = require('./util');
|
||||
const DockerSocket = require('./dockerSocket');
|
||||
|
||||
let _platform = process.platform;
|
||||
const _windows = (_platform === 'win32');
|
||||
|
||||
let _docker_container_stats = {};
|
||||
let _docker_socket;
|
||||
let _docker_last_read = 0;
|
||||
|
||||
|
||||
// --------------------------
|
||||
// get containers (parameter all: get also inactive/exited containers)
|
||||
|
||||
function dockerInfo(callback) {
|
||||
return new Promise((resolve) => {
|
||||
process.nextTick(() => {
|
||||
if (!_docker_socket) {
|
||||
_docker_socket = new DockerSocket();
|
||||
}
|
||||
const result = {};
|
||||
|
||||
_docker_socket.getInfo((data) => {
|
||||
result.id = data.ID;
|
||||
result.containers = data.Containers;
|
||||
result.containersRunning = data.ContainersRunning;
|
||||
result.containersPaused = data.ContainersPaused;
|
||||
result.containersStopped = data.ContainersStopped;
|
||||
result.images = data.Images;
|
||||
result.driver = data.Driver;
|
||||
result.memoryLimit = data.MemoryLimit;
|
||||
result.swapLimit = data.SwapLimit;
|
||||
result.kernelMemory = data.KernelMemory;
|
||||
result.cpuCfsPeriod = data.CpuCfsPeriod;
|
||||
result.cpuCfsQuota = data.CpuCfsQuota;
|
||||
result.cpuShares = data.CPUShares;
|
||||
result.cpuSet = data.CPUSet;
|
||||
result.ipv4Forwarding = data.IPv4Forwarding;
|
||||
result.bridgeNfIptables = data.BridgeNfIptables;
|
||||
result.bridgeNfIp6tables = data.BridgeNfIp6tables;
|
||||
result.debug = data.Debug;
|
||||
result.nfd = data.NFd;
|
||||
result.oomKillDisable = data.OomKillDisable;
|
||||
result.ngoroutines = data.NGoroutines;
|
||||
result.systemTime = data.SystemTime;
|
||||
result.loggingDriver = data.LoggingDriver;
|
||||
result.cgroupDriver = data.CgroupDriver;
|
||||
result.nEventsListener = data.NEventsListener;
|
||||
result.kernelVersion = data.KernelVersion;
|
||||
result.operatingSystem = data.OperatingSystem;
|
||||
result.osType = data.OSType;
|
||||
result.architecture = data.Architecture;
|
||||
result.ncpu = data.NCPU;
|
||||
result.memTotal = data.MemTotal;
|
||||
result.dockerRootDir = data.DockerRootDir;
|
||||
result.httpProxy = data.HttpProxy;
|
||||
result.httpsProxy = data.HttpsProxy;
|
||||
result.noProxy = data.NoProxy;
|
||||
result.name = data.Name;
|
||||
result.labels = data.Labels;
|
||||
result.experimentalBuild = data.ExperimentalBuild;
|
||||
result.serverVersion = data.ServerVersion;
|
||||
result.clusterStore = data.ClusterStore;
|
||||
result.clusterAdvertise = data.ClusterAdvertise;
|
||||
result.defaultRuntime = data.DefaultRuntime;
|
||||
result.liveRestoreEnabled = data.LiveRestoreEnabled;
|
||||
result.isolation = data.Isolation;
|
||||
result.initBinary = data.InitBinary;
|
||||
result.productLicense = data.ProductLicense;
|
||||
if (callback) { callback(result); }
|
||||
resolve(result);
|
||||
});
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
exports.dockerInfo = dockerInfo;
|
||||
|
||||
function dockerImages(all, callback) {
|
||||
|
||||
// fallback - if only callback is given
|
||||
if (util.isFunction(all) && !callback) {
|
||||
callback = all;
|
||||
all = false;
|
||||
}
|
||||
if (typeof all === 'string' && all === 'true') {
|
||||
all = true;
|
||||
}
|
||||
if (typeof all !== 'boolean' && all !== undefined) {
|
||||
all = false;
|
||||
}
|
||||
|
||||
all = all || false;
|
||||
let result = [];
|
||||
return new Promise((resolve) => {
|
||||
process.nextTick(() => {
|
||||
if (!_docker_socket) {
|
||||
_docker_socket = new DockerSocket();
|
||||
}
|
||||
const workload = [];
|
||||
|
||||
_docker_socket.listImages(all, data => {
|
||||
let dockerImages = {};
|
||||
try {
|
||||
dockerImages = data;
|
||||
if (dockerImages && Object.prototype.toString.call(dockerImages) === '[object Array]' && dockerImages.length > 0) {
|
||||
|
||||
dockerImages.forEach(function (element) {
|
||||
|
||||
if (element.Names && Object.prototype.toString.call(element.Names) === '[object Array]' && element.Names.length > 0) {
|
||||
element.Name = element.Names[0].replace(/^\/|\/$/g, '');
|
||||
}
|
||||
workload.push(dockerImagesInspect(element.Id.trim(), element));
|
||||
});
|
||||
if (workload.length) {
|
||||
Promise.all(
|
||||
workload
|
||||
).then((data) => {
|
||||
if (callback) { callback(data); }
|
||||
resolve(data);
|
||||
});
|
||||
} else {
|
||||
if (callback) { callback(result); }
|
||||
resolve(result);
|
||||
}
|
||||
} else {
|
||||
if (callback) { callback(result); }
|
||||
resolve(result);
|
||||
}
|
||||
} catch (err) {
|
||||
if (callback) { callback(result); }
|
||||
resolve(result);
|
||||
}
|
||||
});
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
// --------------------------
|
||||
// container inspect (for one container)
|
||||
|
||||
function dockerImagesInspect(imageID, payload) {
|
||||
return new Promise((resolve) => {
|
||||
process.nextTick(() => {
|
||||
imageID = imageID || '';
|
||||
if (typeof imageID !== 'string') {
|
||||
return resolve();
|
||||
}
|
||||
const imageIDSanitized = (util.isPrototypePolluted() ? '' : util.sanitizeShellString(imageID, true)).trim();
|
||||
if (imageIDSanitized) {
|
||||
|
||||
if (!_docker_socket) {
|
||||
_docker_socket = new DockerSocket();
|
||||
}
|
||||
|
||||
_docker_socket.inspectImage(imageIDSanitized.trim(), data => {
|
||||
try {
|
||||
resolve({
|
||||
id: payload.Id,
|
||||
container: data.Container,
|
||||
comment: data.Comment,
|
||||
os: data.Os,
|
||||
architecture: data.Architecture,
|
||||
parent: data.Parent,
|
||||
dockerVersion: data.DockerVersion,
|
||||
size: data.Size,
|
||||
sharedSize: payload.SharedSize,
|
||||
virtualSize: data.VirtualSize,
|
||||
author: data.Author,
|
||||
created: data.Created ? Math.round(new Date(data.Created).getTime() / 1000) : 0,
|
||||
containerConfig: data.ContainerConfig ? data.ContainerConfig : {},
|
||||
graphDriver: data.GraphDriver ? data.GraphDriver : {},
|
||||
repoDigests: data.RepoDigests ? data.RepoDigests : {},
|
||||
repoTags: data.RepoTags ? data.RepoTags : {},
|
||||
config: data.Config ? data.Config : {},
|
||||
rootFS: data.RootFS ? data.RootFS : {},
|
||||
});
|
||||
} catch (err) {
|
||||
resolve();
|
||||
}
|
||||
});
|
||||
} else {
|
||||
resolve();
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
exports.dockerImages = dockerImages;
|
||||
|
||||
function dockerContainers(all, callback) {
|
||||
|
||||
function inContainers(containers, id) {
|
||||
let filtered = containers.filter(obj => {
|
||||
/**
|
||||
* @namespace
|
||||
* @property {string} Id
|
||||
*/
|
||||
return (obj.Id && (obj.Id === id));
|
||||
});
|
||||
return (filtered.length > 0);
|
||||
}
|
||||
|
||||
// fallback - if only callback is given
|
||||
if (util.isFunction(all) && !callback) {
|
||||
callback = all;
|
||||
all = false;
|
||||
}
|
||||
if (typeof all === 'string' && all === 'true') {
|
||||
all = true;
|
||||
}
|
||||
if (typeof all !== 'boolean' && all !== undefined) {
|
||||
all = false;
|
||||
}
|
||||
|
||||
all = all || false;
|
||||
let result = [];
|
||||
return new Promise((resolve) => {
|
||||
process.nextTick(() => {
|
||||
if (!_docker_socket) {
|
||||
_docker_socket = new DockerSocket();
|
||||
}
|
||||
const workload = [];
|
||||
|
||||
_docker_socket.listContainers(all, data => {
|
||||
let docker_containers = {};
|
||||
try {
|
||||
docker_containers = data;
|
||||
if (docker_containers && Object.prototype.toString.call(docker_containers) === '[object Array]' && docker_containers.length > 0) {
|
||||
// GC in _docker_container_stats
|
||||
for (let key in _docker_container_stats) {
|
||||
if ({}.hasOwnProperty.call(_docker_container_stats, key)) {
|
||||
if (!inContainers(docker_containers, key)) { delete _docker_container_stats[key]; }
|
||||
}
|
||||
}
|
||||
|
||||
docker_containers.forEach(function (element) {
|
||||
|
||||
if (element.Names && Object.prototype.toString.call(element.Names) === '[object Array]' && element.Names.length > 0) {
|
||||
element.Name = element.Names[0].replace(/^\/|\/$/g, '');
|
||||
}
|
||||
workload.push(dockerContainerInspect(element.Id.trim(), element));
|
||||
});
|
||||
if (workload.length) {
|
||||
Promise.all(
|
||||
workload
|
||||
).then((data) => {
|
||||
if (callback) { callback(data); }
|
||||
resolve(data);
|
||||
});
|
||||
} else {
|
||||
if (callback) { callback(result); }
|
||||
resolve(result);
|
||||
}
|
||||
} else {
|
||||
if (callback) { callback(result); }
|
||||
resolve(result);
|
||||
}
|
||||
} catch (err) {
|
||||
// GC in _docker_container_stats
|
||||
for (let key in _docker_container_stats) {
|
||||
if ({}.hasOwnProperty.call(_docker_container_stats, key)) {
|
||||
if (!inContainers(docker_containers, key)) { delete _docker_container_stats[key]; }
|
||||
}
|
||||
}
|
||||
if (callback) { callback(result); }
|
||||
resolve(result);
|
||||
}
|
||||
});
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
// --------------------------
|
||||
// container inspect (for one container)
|
||||
|
||||
function dockerContainerInspect(containerID, payload) {
|
||||
return new Promise((resolve) => {
|
||||
process.nextTick(() => {
|
||||
containerID = containerID || '';
|
||||
if (typeof containerID !== 'string') {
|
||||
return resolve();
|
||||
}
|
||||
const containerIdSanitized = (util.isPrototypePolluted() ? '' : util.sanitizeShellString(containerID, true)).trim();
|
||||
if (containerIdSanitized) {
|
||||
|
||||
if (!_docker_socket) {
|
||||
_docker_socket = new DockerSocket();
|
||||
}
|
||||
|
||||
_docker_socket.getInspect(containerIdSanitized.trim(), data => {
|
||||
try {
|
||||
resolve({
|
||||
id: payload.Id,
|
||||
name: payload.Name,
|
||||
image: payload.Image,
|
||||
imageID: payload.ImageID,
|
||||
command: payload.Command,
|
||||
created: payload.Created,
|
||||
started: data.State && data.State.StartedAt ? Math.round(new Date(data.State.StartedAt).getTime() / 1000) : 0,
|
||||
finished: data.State && data.State.FinishedAt && !data.State.FinishedAt.startsWith('0001-01-01') ? Math.round(new Date(data.State.FinishedAt).getTime() / 1000) : 0,
|
||||
createdAt: data.Created ? data.Created : '',
|
||||
startedAt: data.State && data.State.StartedAt ? data.State.StartedAt : '',
|
||||
finishedAt: data.State && data.State.FinishedAt && !data.State.FinishedAt.startsWith('0001-01-01') ? data.State.FinishedAt : '',
|
||||
state: payload.State,
|
||||
restartCount: data.RestartCount || 0,
|
||||
platform: data.Platform || '',
|
||||
driver: data.Driver || '',
|
||||
ports: payload.Ports,
|
||||
mounts: payload.Mounts,
|
||||
// hostconfig: payload.HostConfig,
|
||||
// network: payload.NetworkSettings
|
||||
});
|
||||
} catch (err) {
|
||||
resolve();
|
||||
}
|
||||
});
|
||||
} else {
|
||||
resolve();
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
exports.dockerContainers = dockerContainers;
|
||||
|
||||
// --------------------------
|
||||
// helper functions for calculation of docker stats
|
||||
|
||||
function docker_calcCPUPercent(cpu_stats, precpu_stats) {
|
||||
/**
|
||||
* @namespace
|
||||
* @property {object} cpu_usage
|
||||
* @property {number} cpu_usage.total_usage
|
||||
* @property {number} system_cpu_usage
|
||||
* @property {object} cpu_usage
|
||||
* @property {Array} cpu_usage.percpu_usage
|
||||
*/
|
||||
|
||||
if (!_windows) {
|
||||
let cpuPercent = 0.0;
|
||||
// calculate the change for the cpu usage of the container in between readings
|
||||
let cpuDelta = cpu_stats.cpu_usage.total_usage - precpu_stats.cpu_usage.total_usage;
|
||||
// calculate the change for the entire system between readings
|
||||
let systemDelta = cpu_stats.system_cpu_usage - precpu_stats.system_cpu_usage;
|
||||
|
||||
if (systemDelta > 0.0 && cpuDelta > 0.0) {
|
||||
// calculate the change for the cpu usage of the container in between readings
|
||||
if (precpu_stats.online_cpus) {
|
||||
cpuPercent = (cpuDelta / systemDelta) * precpu_stats.online_cpus * 100.0;
|
||||
}
|
||||
else {
|
||||
cpuPercent = (cpuDelta / systemDelta) * cpu_stats.cpu_usage.percpu_usage.length * 100.0;
|
||||
}
|
||||
}
|
||||
|
||||
return cpuPercent;
|
||||
} else {
|
||||
let nanoSecNow = util.nanoSeconds();
|
||||
let cpuPercent = 0.0;
|
||||
if (_docker_last_read > 0) {
|
||||
let possIntervals = (nanoSecNow - _docker_last_read); // / 100 * os.cpus().length;
|
||||
let intervalsUsed = cpu_stats.cpu_usage.total_usage - precpu_stats.cpu_usage.total_usage;
|
||||
if (possIntervals > 0) {
|
||||
cpuPercent = 100.0 * intervalsUsed / possIntervals;
|
||||
}
|
||||
}
|
||||
_docker_last_read = nanoSecNow;
|
||||
return cpuPercent;
|
||||
}
|
||||
}
|
||||
|
||||
function docker_calcNetworkIO(networks) {
|
||||
let rx;
|
||||
let wx;
|
||||
for (let key in networks) {
|
||||
// skip loop if the property is from prototype
|
||||
if (!{}.hasOwnProperty.call(networks, key)) { continue; }
|
||||
|
||||
/**
|
||||
* @namespace
|
||||
* @property {number} rx_bytes
|
||||
* @property {number} tx_bytes
|
||||
*/
|
||||
let obj = networks[key];
|
||||
rx = +obj.rx_bytes;
|
||||
wx = +obj.tx_bytes;
|
||||
}
|
||||
return {
|
||||
rx,
|
||||
wx
|
||||
};
|
||||
}
|
||||
|
||||
function docker_calcBlockIO(blkio_stats) {
|
||||
let result = {
|
||||
r: 0,
|
||||
w: 0
|
||||
};
|
||||
|
||||
/**
|
||||
* @namespace
|
||||
* @property {Array} io_service_bytes_recursive
|
||||
*/
|
||||
if (blkio_stats && blkio_stats.io_service_bytes_recursive && Object.prototype.toString.call(blkio_stats.io_service_bytes_recursive) === '[object Array]' && blkio_stats.io_service_bytes_recursive.length > 0) {
|
||||
blkio_stats.io_service_bytes_recursive.forEach(function (element) {
|
||||
/**
|
||||
* @namespace
|
||||
* @property {string} op
|
||||
* @property {number} value
|
||||
*/
|
||||
|
||||
if (element.op && element.op.toLowerCase() === 'read' && element.value) {
|
||||
result.r += element.value;
|
||||
}
|
||||
if (element.op && element.op.toLowerCase() === 'write' && element.value) {
|
||||
result.w += element.value;
|
||||
}
|
||||
});
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
function dockerContainerStats(containerIDs, callback) {
|
||||
|
||||
let containerArray = [];
|
||||
return new Promise((resolve) => {
|
||||
process.nextTick(() => {
|
||||
|
||||
// fallback - if only callback is given
|
||||
if (util.isFunction(containerIDs) && !callback) {
|
||||
callback = containerIDs;
|
||||
containerArray = ['*'];
|
||||
} else {
|
||||
containerIDs = containerIDs || '*';
|
||||
if (typeof containerIDs !== 'string') {
|
||||
if (callback) { callback([]); }
|
||||
return resolve([]);
|
||||
}
|
||||
let containerIDsSanitized = '';
|
||||
try {
|
||||
containerIDsSanitized.__proto__.toLowerCase = util.stringToLower;
|
||||
containerIDsSanitized.__proto__.replace = util.stringReplace;
|
||||
containerIDsSanitized.__proto__.toString = util.stringToString;
|
||||
containerIDsSanitized.__proto__.substr = util.stringSubstr;
|
||||
containerIDsSanitized.__proto__.substring = util.stringSubstring;
|
||||
containerIDsSanitized.__proto__.trim = util.stringTrim;
|
||||
containerIDsSanitized.__proto__.startsWith = util.stringStartWith;
|
||||
} catch (e) {
|
||||
Object.setPrototypeOf(containerIDsSanitized, util.stringObj);
|
||||
}
|
||||
|
||||
containerIDsSanitized = containerIDs;
|
||||
containerIDsSanitized = containerIDsSanitized.trim();
|
||||
if (containerIDsSanitized !== '*') {
|
||||
containerIDsSanitized = '';
|
||||
const s = (util.isPrototypePolluted() ? '' : util.sanitizeShellString(containerIDs, true)).trim();
|
||||
const l = util.mathMin(s.length, 2000);
|
||||
for (let i = 0; i <= l; i++) {
|
||||
if (s[i] !== undefined) {
|
||||
s[i].__proto__.toLowerCase = util.stringToLower;
|
||||
const sl = s[i].toLowerCase();
|
||||
if (sl && sl[0] && !sl[1]) {
|
||||
containerIDsSanitized = containerIDsSanitized + sl[0];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
containerIDsSanitized = containerIDsSanitized.trim().toLowerCase().replace(/,+/g, '|');
|
||||
containerArray = containerIDsSanitized.split('|');
|
||||
}
|
||||
|
||||
const result = [];
|
||||
|
||||
const workload = [];
|
||||
if (containerArray.length && containerArray[0].trim() === '*') {
|
||||
containerArray = [];
|
||||
dockerContainers().then(allContainers => {
|
||||
for (let container of allContainers) {
|
||||
containerArray.push(container.id.substring(0, 12));
|
||||
}
|
||||
if (containerArray.length) {
|
||||
dockerContainerStats(containerArray.join(',')).then(result => {
|
||||
if (callback) { callback(result); }
|
||||
resolve(result);
|
||||
});
|
||||
} else {
|
||||
if (callback) { callback(result); }
|
||||
resolve(result);
|
||||
}
|
||||
});
|
||||
} else {
|
||||
for (let containerID of containerArray) {
|
||||
workload.push(dockerContainerStatsSingle(containerID.trim()));
|
||||
}
|
||||
if (workload.length) {
|
||||
Promise.all(
|
||||
workload
|
||||
).then((data) => {
|
||||
if (callback) { callback(data); }
|
||||
resolve(data);
|
||||
});
|
||||
} else {
|
||||
if (callback) { callback(result); }
|
||||
resolve(result);
|
||||
}
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
// --------------------------
|
||||
// container stats (for one container)
|
||||
|
||||
function dockerContainerStatsSingle(containerID) {
|
||||
containerID = containerID || '';
|
||||
let result = {
|
||||
id: containerID,
|
||||
memUsage: 0,
|
||||
memLimit: 0,
|
||||
memPercent: 0,
|
||||
cpuPercent: 0,
|
||||
pids: 0,
|
||||
netIO: {
|
||||
rx: 0,
|
||||
wx: 0
|
||||
},
|
||||
blockIO: {
|
||||
r: 0,
|
||||
w: 0
|
||||
},
|
||||
restartCount: 0,
|
||||
cpuStats: {},
|
||||
precpuStats: {},
|
||||
memoryStats: {},
|
||||
networks: {},
|
||||
};
|
||||
return new Promise((resolve) => {
|
||||
process.nextTick(() => {
|
||||
if (containerID) {
|
||||
|
||||
if (!_docker_socket) {
|
||||
_docker_socket = new DockerSocket();
|
||||
}
|
||||
|
||||
_docker_socket.getInspect(containerID, dataInspect => {
|
||||
try {
|
||||
_docker_socket.getStats(containerID, data => {
|
||||
try {
|
||||
let stats = data;
|
||||
if (!stats.message) {
|
||||
if (data.id) { result.id = data.id; }
|
||||
result.memUsage = (stats.memory_stats && stats.memory_stats.usage ? stats.memory_stats.usage : 0);
|
||||
result.memLimit = (stats.memory_stats && stats.memory_stats.limit ? stats.memory_stats.limit : 0);
|
||||
result.memPercent = (stats.memory_stats && stats.memory_stats.usage && stats.memory_stats.limit ? stats.memory_stats.usage / stats.memory_stats.limit * 100.0 : 0);
|
||||
result.cpuPercent = (stats.cpu_stats && stats.precpu_stats ? docker_calcCPUPercent(stats.cpu_stats, stats.precpu_stats) : 0);
|
||||
result.pids = (stats.pids_stats && stats.pids_stats.current ? stats.pids_stats.current : 0);
|
||||
result.restartCount = (dataInspect.RestartCount ? dataInspect.RestartCount : 0);
|
||||
if (stats.networks) { result.netIO = docker_calcNetworkIO(stats.networks); }
|
||||
if (stats.blkio_stats) { result.blockIO = docker_calcBlockIO(stats.blkio_stats); }
|
||||
result.cpuStats = (stats.cpu_stats ? stats.cpu_stats : {});
|
||||
result.precpuStats = (stats.precpu_stats ? stats.precpu_stats : {});
|
||||
result.memoryStats = (stats.memory_stats ? stats.memory_stats : {});
|
||||
result.networks = (stats.networks ? stats.networks : {});
|
||||
}
|
||||
} catch (err) {
|
||||
util.noop();
|
||||
}
|
||||
// }
|
||||
resolve(result);
|
||||
});
|
||||
} catch (err) {
|
||||
util.noop();
|
||||
}
|
||||
});
|
||||
} else {
|
||||
resolve(result);
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
exports.dockerContainerStats = dockerContainerStats;
|
||||
|
||||
// --------------------------
|
||||
// container processes (for one container)
|
||||
|
||||
function dockerContainerProcesses(containerID, callback) {
|
||||
let result = [];
|
||||
return new Promise((resolve) => {
|
||||
process.nextTick(() => {
|
||||
containerID = containerID || '';
|
||||
if (typeof containerID !== 'string') {
|
||||
return resolve(result);
|
||||
}
|
||||
const containerIdSanitized = (util.isPrototypePolluted() ? '' : util.sanitizeShellString(containerID, true)).trim();
|
||||
|
||||
if (containerIdSanitized) {
|
||||
|
||||
if (!_docker_socket) {
|
||||
_docker_socket = new DockerSocket();
|
||||
}
|
||||
|
||||
_docker_socket.getProcesses(containerIdSanitized, data => {
|
||||
/**
|
||||
* @namespace
|
||||
* @property {Array} Titles
|
||||
* @property {Array} Processes
|
||||
**/
|
||||
try {
|
||||
if (data && data.Titles && data.Processes) {
|
||||
let titles = data.Titles.map(function (value) {
|
||||
return value.toUpperCase();
|
||||
});
|
||||
let pos_pid = titles.indexOf('PID');
|
||||
let pos_ppid = titles.indexOf('PPID');
|
||||
let pos_pgid = titles.indexOf('PGID');
|
||||
let pos_vsz = titles.indexOf('VSZ');
|
||||
let pos_time = titles.indexOf('TIME');
|
||||
let pos_elapsed = titles.indexOf('ELAPSED');
|
||||
let pos_ni = titles.indexOf('NI');
|
||||
let pos_ruser = titles.indexOf('RUSER');
|
||||
let pos_user = titles.indexOf('USER');
|
||||
let pos_rgroup = titles.indexOf('RGROUP');
|
||||
let pos_group = titles.indexOf('GROUP');
|
||||
let pos_stat = titles.indexOf('STAT');
|
||||
let pos_rss = titles.indexOf('RSS');
|
||||
let pos_command = titles.indexOf('COMMAND');
|
||||
|
||||
data.Processes.forEach(process => {
|
||||
result.push({
|
||||
pidHost: (pos_pid >= 0 ? process[pos_pid] : ''),
|
||||
ppid: (pos_ppid >= 0 ? process[pos_ppid] : ''),
|
||||
pgid: (pos_pgid >= 0 ? process[pos_pgid] : ''),
|
||||
user: (pos_user >= 0 ? process[pos_user] : ''),
|
||||
ruser: (pos_ruser >= 0 ? process[pos_ruser] : ''),
|
||||
group: (pos_group >= 0 ? process[pos_group] : ''),
|
||||
rgroup: (pos_rgroup >= 0 ? process[pos_rgroup] : ''),
|
||||
stat: (pos_stat >= 0 ? process[pos_stat] : ''),
|
||||
time: (pos_time >= 0 ? process[pos_time] : ''),
|
||||
elapsed: (pos_elapsed >= 0 ? process[pos_elapsed] : ''),
|
||||
nice: (pos_ni >= 0 ? process[pos_ni] : ''),
|
||||
rss: (pos_rss >= 0 ? process[pos_rss] : ''),
|
||||
vsz: (pos_vsz >= 0 ? process[pos_vsz] : ''),
|
||||
command: (pos_command >= 0 ? process[pos_command] : '')
|
||||
});
|
||||
});
|
||||
}
|
||||
} catch (err) {
|
||||
util.noop();
|
||||
}
|
||||
if (callback) { callback(result); }
|
||||
resolve(result);
|
||||
});
|
||||
} else {
|
||||
if (callback) { callback(result); }
|
||||
resolve(result);
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
exports.dockerContainerProcesses = dockerContainerProcesses;
|
||||
|
||||
function dockerVolumes(callback) {
|
||||
|
||||
let result = [];
|
||||
return new Promise((resolve) => {
|
||||
process.nextTick(() => {
|
||||
if (!_docker_socket) {
|
||||
_docker_socket = new DockerSocket();
|
||||
}
|
||||
_docker_socket.listVolumes((data) => {
|
||||
let dockerVolumes = {};
|
||||
try {
|
||||
dockerVolumes = data;
|
||||
if (dockerVolumes && dockerVolumes.Volumes && Object.prototype.toString.call(dockerVolumes.Volumes) === '[object Array]' && dockerVolumes.Volumes.length > 0) {
|
||||
|
||||
dockerVolumes.Volumes.forEach(function (element) {
|
||||
|
||||
result.push({
|
||||
name: element.Name,
|
||||
driver: element.Driver,
|
||||
labels: element.Labels,
|
||||
mountpoint: element.Mountpoint,
|
||||
options: element.Options,
|
||||
scope: element.Scope,
|
||||
created: element.CreatedAt ? Math.round(new Date(element.CreatedAt).getTime() / 1000) : 0,
|
||||
});
|
||||
});
|
||||
if (callback) { callback(result); }
|
||||
resolve(result);
|
||||
} else {
|
||||
if (callback) { callback(result); }
|
||||
resolve(result);
|
||||
}
|
||||
} catch (err) {
|
||||
if (callback) { callback(result); }
|
||||
resolve(result);
|
||||
}
|
||||
});
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
exports.dockerVolumes = dockerVolumes;
|
||||
|
||||
function dockerAll(callback) {
|
||||
return new Promise((resolve) => {
|
||||
process.nextTick(() => {
|
||||
dockerContainers(true).then(result => {
|
||||
if (result && Object.prototype.toString.call(result) === '[object Array]' && result.length > 0) {
|
||||
let l = result.length;
|
||||
result.forEach(function (element) {
|
||||
dockerContainerStats(element.id).then((res) => {
|
||||
// include stats in array
|
||||
element.memUsage = res[0].memUsage;
|
||||
element.memLimit = res[0].memLimit;
|
||||
element.memPercent = res[0].memPercent;
|
||||
element.cpuPercent = res[0].cpuPercent;
|
||||
element.pids = res[0].pids;
|
||||
element.netIO = res[0].netIO;
|
||||
element.blockIO = res[0].blockIO;
|
||||
element.cpuStats = res[0].cpuStats;
|
||||
element.precpuStats = res[0].precpuStats;
|
||||
element.memoryStats = res[0].memoryStats;
|
||||
element.networks = res[0].networks;
|
||||
|
||||
dockerContainerProcesses(element.id).then(processes => {
|
||||
element.processes = processes;
|
||||
|
||||
l -= 1;
|
||||
if (l === 0) {
|
||||
if (callback) { callback(result); }
|
||||
resolve(result);
|
||||
}
|
||||
});
|
||||
// all done??
|
||||
});
|
||||
});
|
||||
} else {
|
||||
if (callback) { callback(result); }
|
||||
resolve(result);
|
||||
}
|
||||
});
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
exports.dockerAll = dockerAll;
|
||||
Reference in New Issue
Block a user