added dockerInfo()

lib/docker.js

@@ -27,6 +27,69 @@ 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 dockerContainers(all, callback) {
 

lib/dockerSocket.js

@@ -19,6 +19,42 @@ const socketPath = isWin ? '//./pipe/docker_engine' : '/var/run/docker.sock';
 
 class DockerSocket {
 
+  getInfo(callback) {
+    try {
+
+      let socket = net.createConnection({ path: socketPath });
+      let alldata = '';
+      let data;
+
+      socket.on('connect', () => {
+        socket.write('GET http:/info HTTP/1.0\r\n\r\n');
+      });
+
+      socket.on('data', data => {
+        alldata = alldata + data.toString();
+      });
+
+      socket.on('error', () => {
+        socket = false;
+        callback({});
+      });
+
+      socket.on('end', () => {
+        let startbody = alldata.indexOf('\r\n\r\n');
+        alldata = alldata.substring(startbody + 4);
+        socket = false;
+        try {
+          data = JSON.parse(alldata);
+          callback(data);
+        } catch (err) {
+          callback({});
+        }
+      });
+    } catch (err) {
+      callback({});
+    }
+  }
+
   listContainers(all, callback) {
     try {
 

lib/index.d.ts

@@ -420,6 +420,55 @@ export namespace Systeminformation {
 
   // 8. Docker
 
+  interface DockerInfoData {
+    ID: string;
+    Containers: number;
+    ContainersRunning: number;
+    ContainersPaused: number;
+    ContainersStopped: number;
+    Images: number;
+    Driver: string;
+    MemoryLimit: boolean;
+    SwapLimit: boolean;
+    KernelMemory: boolean;
+    CpuCfsPeriod: boolean;
+    CpuCfsQuota: boolean;
+    CPUShares: boolean;
+    CPUSet: boolean;
+    IPv4Forwarding: boolean;
+    BridgeNfIptables: boolean;
+    BridgeNfIp6tables: boolean;
+    Debug: boolean;
+    NFd: number;
+    OomKillDisable: boolean;
+    NGoroutines: number;
+    SystemTime: string;
+    LoggingDriver: string;
+    CgroupDriver: string;
+    NEventsListener: number;
+    KernelVersion: string;
+    OperatingSystem: string;
+    OSType: string;
+    Architecture: string;
+    NCPU: number;
+    MemTotal: number;
+    DockerRootDir: string;
+    HttpProxy: string;
+    HttpsProxy: string;
+    NoProxy: string;
+    Name: string;
+    Labels: string[];
+    ExperimentalBuild: boolean;
+    ServerVersion: string;
+    ClusterStore: string;
+    ClusterAdvertise: string;
+    DefaultRuntime: string;
+    LiveRestoreEnabled: boolean;
+    Isolation: string;
+    InitBinary: string;
+    ProductLicense: string;
+  }
+
   interface DockerContainerData {
     id: string;
     name: string;
@@ -537,7 +586,7 @@ export function processes(cb?: (data: Systeminformation.ProcessesData) => any):
 export function processLoad(processName: string, cb?: (data: Systeminformation.ProcessesProcessLoadData) => any): Promise<Systeminformation.ProcessesProcessLoadData>;
 export function services(serviceName: string, cb?: (data: Systeminformation.ServicesData[]) => any): Promise<Systeminformation.ServicesData[]>;
 
-
+export function dockerInfo(cb?: (data: Systeminformation.DockerInfoData[]) => any): Promise<Systeminformation.DockerInfoData[]>;
 export function dockerContainers(all?: boolean, cb?: (data: Systeminformation.DockerContainerData[]) => any): Promise<Systeminformation.DockerContainerData[]>;
 export function dockerContainerStats(id?: string, cb?: (data: Systeminformation.DockerContainerStatsData[]) => any): Promise<Systeminformation.DockerContainerStatsData[]>;
 export function dockerContainerProcesses(id?: string, cb?: (data: any) => any): Promise<any>;

lib/index.js

@@ -357,6 +357,7 @@ exports.users = users.users;
 exports.inetChecksite = internet.inetChecksite;
 exports.inetLatency = internet.inetLatency;
 
+exports.dockerInfo = docker.dockerInfo;
 exports.dockerContainers = docker.dockerContainers;
 exports.dockerContainerStats = docker.dockerContainerStats;
 exports.dockerContainerProcesses = docker.dockerContainerProcesses;