interface stats

.vscode/c_cpp_properties.json

@@ -0,0 +1,17 @@
+{
+    "configurations": [
+        {
+            "name": "Linux",
+            "includePath": [
+                "${workspaceFolder}/**",
+                "/home/ilya/vmngr-development/dev_xml/node_modules/node-addon-api"
+            ],
+            "defines": [],
+            "compilerPath": "/usr/bin/gcc",
+            "cStandard": "c11",
+            "cppStandard": "c++17",
+            "intelliSenseMode": "clang-x64"
+        }
+    ],
+    "version": 4
+}

examples/interface_stats.ts

@@ -0,0 +1,42 @@
+import chalk from "chalk";
+import process from "process";
+
+import libvirt from "../";
+
+(async () => {
+
+    const uri = "qemu+ssh://root@libvirt_dev/system";
+    const hypervisor = new libvirt.Hypervisor({ uri });
+
+    await hypervisor.connectOpen();
+    console.time('s');
+    const hostname = await hypervisor.connectGetHostname();
+    process.stdout.write(`Connected to ${hostname}!\n\n`);
+
+    const activeDomains = await hypervisor.connectListAllDomains(
+        libvirt.ConnectListAllDomainsFlags.ACTIVE);
+    const inactiveDomains = await hypervisor.connectListAllDomains(
+        libvirt.ConnectListAllDomainsFlags.INACTIVE);
+
+    const activeDomainNames = await Promise.all(activeDomains
+        .map((domain) => hypervisor.domainGetName(domain)));
+
+    const inactiveDomainNames = await Promise.all(inactiveDomains
+        .map((domain) => hypervisor.domainGetName(domain)));
+    await hypervisor.connectClose();
+    console.timeEnd('s')
+    process.stdout.write("Active Domains\n");
+    process.stdout.write("--------------\n");
+    for (const name of activeDomainNames) {
+        process.stdout.write(chalk.green(`  ${name}\n`));
+    }
+    process.stdout.write("\n");
+
+    process.stdout.write("Inactive Domains\n");
+    process.stdout.write("-----------------\n");
+    for (const name of inactiveDomainNames) {
+        process.stdout.write(chalk.red(`  ${name}\n`));
+    }
+    process.stdout.write("\n");
+
+})();

examples/list.ts

@@ -9,7 +9,7 @@ import libvirt from "../";
     const hypervisor = new libvirt.Hypervisor({ uri });
 
     await hypervisor.connectOpen();
-
+    console.time('s');
     const hostname = await hypervisor.connectGetHostname();
     process.stdout.write(`Connected to ${hostname}!\n\n`);
 
@@ -24,7 +24,7 @@ import libvirt from "../";
     const inactiveDomainNames = await Promise.all(inactiveDomains
         .map((domain) => hypervisor.domainGetName(domain)));
     await hypervisor.connectClose();
-
+    console.timeEnd('s')
     process.stdout.write("Active Domains\n");
     process.stdout.write("--------------\n");
     for (const name of activeDomainNames) {

src/domain.h

@@ -44,6 +44,7 @@ class Domain : public Napi::ObjectWrap<Domain> {
     friend class DomainRebootWorker;
     friend class DomainRestoreWorker;
     friend class DomainGetXMLDescWorker;
+    friend class DomainInterfaceStatsWorker;
 };
 
 #endif  // SRC_DOMAIN_H_

src/hypervisor-domain.cc

@@ -4,7 +4,6 @@
  * This file is part of the vmngr/libvirt project and is subject to the MIT
  * license as in the LICENSE file in the project root.
  */
-
 #include "src/hypervisor.h"
 #include "src/worker.h"
 #include "src/domain.h"
@@ -812,3 +811,81 @@ Napi::Value Hypervisor::DomainGetXMLDesc(const Napi::CallbackInfo& info) {
 
     return deferred.Promise();
 }
+
+/******************************************************************************
+ * DomainInterfaceStats                                                       *
+ ******************************************************************************/
+class DomainInterfaceStatsWorker : public Worker {
+ public:
+    DomainInterfaceStatsWorker(
+        Napi::Function const& callback,
+        Napi::Promise::Deferred deferred,
+        Hypervisor* hypervisor,
+        Domain* domain,
+        std::string device)
+        : Worker(callback, deferred, hypervisor),
+         domain(domain), device(device) {}
+
+    void Execute(void) override {
+        int ret = virDomainInterfaceStats(domain->domainPtr,
+                    device.c_str(), &ifstats, size_t(0));
+        if (ret < 0) SetVirError();
+    }
+
+    void OnOK(void) override {
+        Napi::HandleScope scope(Env());
+
+        Napi::Object info = Napi::Object::New(Env());
+
+        info.Set("rx_bytes", Napi::Number::New(Env(), ifstats.rx_bytes));
+        info.Set("rx_packets", Napi::Number::New(Env(), ifstats.rx_packets));
+        info.Set("rx_errs", Napi::Number::New(Env(), ifstats.rx_errs));
+        info.Set("rx_drop", Napi::Number::New(Env(), ifstats.rx_drop));
+        info.Set("tx_bytes", Napi::Number::New(Env(), ifstats.tx_bytes));
+        info.Set("tx_packets", Napi::Number::New(Env(), ifstats.tx_packets));
+        info.Set("tx_errs", Napi::Number::New(Env(), ifstats.tx_errs));
+        info.Set("tx_drop", Napi::Number::New(Env(), ifstats.tx_drop));
+
+        deferred.Resolve(info);
+        Callback().Call({});
+    }
+
+ private:
+    Domain* domain;
+    std::string device;
+    virDomainInterfaceStatsStruct ifstats;
+};
+
+Napi::Value Hypervisor::DomainInterfaceStats(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    Napi::HandleScope scope(env);
+
+    Napi::Function callback = Napi::Function::New(env, dummyCallback);
+    Napi::Promise::Deferred deferred = Napi::Promise::Deferred::New(env);
+
+    if (info.Length() <= 0 || !info[0].IsObject()) {
+        deferred.Reject(Napi::String::New(env, "Expected an object."));
+        return deferred.Promise();
+    }
+
+    if (info.Length() == 1) {
+        deferred.Reject(Napi::String::New(env, "Expected a domain ptr."));
+        return deferred.Promise();
+    } else if (info.Length() == 2 && !info[1].IsString()) {
+        deferred.Reject(Napi::String::New(env,
+        "Expected a interface device name at 2nd arg."));
+        return deferred.Promise();
+    }
+
+    Domain* domain = Napi::ObjectWrap<Domain>::Unwrap(
+        info[0].As<Napi::Object>());
+
+    std::string device = info[1].As<Napi::String>().Utf8Value();
+
+    DomainInterfaceStatsWorker* worker =
+        new DomainInterfaceStatsWorker(callback, deferred, this,
+        domain, device);
+    worker->Queue();
+
+    return deferred.Promise();
+}

src/hypervisor.cc

@@ -38,6 +38,8 @@ Napi::Object Hypervisor::Init(Napi::Env env, Napi::Object exports) {
         InstanceMethod("domainReboot", &Hypervisor::DomainReboot),
         InstanceMethod("domainRestore", &Hypervisor::DomainRestore),
         InstanceMethod("domainGetXMLDesc", &Hypervisor::DomainGetXMLDesc),
+        InstanceMethod("domainInterfaceStats",
+            &Hypervisor::DomainInterfaceStats),
 
         InstanceMethod("nodeGetInfo", &Hypervisor::NodeGetInfo)
     });

src/hypervisor.h

@@ -39,6 +39,7 @@ class DomainCreateWorker;
 class DomainShutdownWorker;
 class DomainRebootWorker;
 class DomainGetXMLDescWorker;
+class DomainInterfaceStatsWorker;
 
 class NodeGetInfoWorker;
 
@@ -70,6 +71,7 @@ class Hypervisor : public Napi::ObjectWrap<Hypervisor> {
     Napi::Value DomainReboot(const Napi::CallbackInfo& info);
     Napi::Value DomainRestore(const Napi::CallbackInfo& info);
     Napi::Value DomainGetXMLDesc(const Napi::CallbackInfo& info);
+    Napi::Value DomainInterfaceStats(const Napi::CallbackInfo& info);
 
     Napi::Value NodeGetInfo(const Napi::CallbackInfo& info);
 
@@ -101,6 +103,7 @@ class Hypervisor : public Napi::ObjectWrap<Hypervisor> {
     friend class DomainShutdownWorker;
     friend class DomainRebootWorker;
     friend class DomainGetXMLDescWorker;
+    friend class DomainInterfaceStatsWorker;
 
     friend class NodeGetInfoWorker;
 };