windows node support

windows node support for smb/iscsi (csi-proxy)
better logging
support (for testing) generating volume_id from name
wait for chown/chmod jobs to complete (freenas)
general improvement to smb behavior throughout

Signed-off-by: Travis Glenn Hansen <travisghansen@yahoo.com>

src/utils/csi_proxy_client.js

@@ -0,0 +1,257 @@
+const _ = require("lodash");
+const grpc = require("./grpc").grpc;
+const protoLoader = require("@grpc/proto-loader");
+
+const PROTO_BASE_PATH = __dirname + "/../../csi_proxy_proto";
+
+/**
+ * leave connection null as by default the named pipe is derrived
+ */
+const DEFAULT_SERVICES = {
+  filesystem: { version: "v1", connection: null },
+  disk: { version: "v1", connection: null },
+  volume: { version: "v1", connection: null },
+  smb: { version: "v1", connection: null },
+  system: { version: "v1alpha1", connection: null },
+  iscsi: { version: "v1alpha2", connection: null },
+};
+
+function capitalize(s) {
+  return s && s[0].toUpperCase() + s.slice(1);
+}
+
+class CsiProxyClient {
+  constructor(options = {}) {
+    this.clients = {};
+
+    // initialize all clients
+    const services = Object.assign(
+      {},
+      DEFAULT_SERVICES,
+      options.services || {}
+    );
+
+    const pipePrefix = options.pipe_prefix || "csi-proxy";
+
+    for (const serviceName in services) {
+      const service = services[serviceName];
+      const serviceVersion =
+        service.version || DEFAULT_SERVICES[serviceName].version;
+      const serviceConnection =
+        service.connection ||
+        `\\\\.\\\\pipe\\\\${pipePrefix}-${serviceName}-${serviceVersion}`;
+
+      const PROTO_PATH = `/${PROTO_BASE_PATH}/${serviceName}/${serviceVersion}/api.proto`;
+      const packageDefinition = protoLoader.loadSync(PROTO_PATH, {
+        keepCase: true,
+        longs: String,
+        enums: String,
+        defaults: true,
+        oneofs: true,
+        includeDirs: [__dirname + "/../csi_proxy_proto"],
+      });
+      const protoDescriptor = grpc.loadPackageDefinition(packageDefinition);
+      const serviceInstance = new protoDescriptor[serviceVersion][
+        capitalize(serviceName)
+      ](serviceConnection, grpc.credentials.createInsecure());
+      this.clients[serviceName] = serviceInstance;
+    }
+  }
+
+  async executeRPC(serviceName, methodName, options = {}) {
+    function rescursivePathFixer(obj) {
+      for (const k in obj) {
+        if (typeof obj[k] == "object" && obj[k] !== null) {
+          rescursivePathFixer(obj[k]);
+        } else {
+          if (k.includes("path")) {
+            obj[k] = obj[k].replaceAll("/", "\\");
+          }
+        }
+      }
+    }
+
+    rescursivePathFixer(options);
+
+    const cleansedOptions = JSON.parse(JSON.stringify(options));
+    // This function handles arrays and objects
+    function recursiveCleanse(obj) {
+      for (const k in obj) {
+        if (typeof obj[k] == "object" && obj[k] !== null) {
+          recursiveCleanse(obj[k]);
+        } else {
+          if (
+            k.includes("secret") ||
+            k.includes("username") ||
+            k.includes("password")
+          ) {
+            obj[k] = "redacted";
+          }
+        }
+      }
+    }
+    recursiveCleanse(cleansedOptions);
+
+    console.log(
+      "csi-proxy request %s/%s - data: %j",
+      capitalize(serviceName),
+      methodName,
+      cleansedOptions
+    );
+
+    return new Promise((resolve, reject) => {
+      const functionRef = this.clients[serviceName.toLowerCase()][methodName];
+      if (!functionRef) {
+        reject(
+          new Error(
+            `missing method ${methodName} on service ${capitalize(serviceName)}`
+          )
+        );
+        return;
+      }
+
+      this.clients[serviceName.toLowerCase()][methodName](
+        options,
+        (error, data) => {
+          console.log(
+            "csi-proxy response %s/%s - error: %j, data: %j",
+            capitalize(serviceName),
+            methodName,
+            error,
+            data
+          );
+
+          if (error) {
+            reject(error);
+          }
+
+          resolve(data);
+        }
+      );
+    });
+  }
+
+  /**
+   * Returns a disk_number if the target has 0 or 1 disks
+   *
+   * @param {*} target_portal
+   * @param {*} iqn
+   * @returns
+   */
+  async getDiskNumberFromIscsiTarget(target_portal, iqn) {
+    let result;
+
+    if (typeof target_portal != "object") {
+      target_portal = {
+        target_address: target_portal.split(":")[0],
+        target_port: target_portal.split(":")[1] || 3260,
+      };
+    }
+
+    // get device
+    try {
+      result = await this.executeRPC("iscsi", "GetTargetDisks", {
+        target_portal,
+        iqn,
+      });
+    } catch (e) {
+      let details = _.get(e, "details", "");
+      if (!details.includes("ObjectNotFound")) {
+        throw e;
+      }
+    }
+
+    let diskIds = _.get(result, "diskIDs", []);
+    if (diskIds.length > 1) {
+      throw new Error(
+        `${diskIds.length} disks on the target, no way to know which is the relevant disk`
+      );
+    }
+
+    return diskIds[0];
+  }
+
+  /**
+   * Returns a volume_id if the disk has 0 or 1 volumes
+   *
+   * @param {*} disk_number
+   * @returns
+   */
+  async getVolumeIdFromDiskNumber(disk_number) {
+    let result;
+
+    if (disk_number == 0 || disk_number > 0) {
+      result = await this.executeRPC("volume", "ListVolumesOnDisk", {
+        disk_number,
+      });
+
+      let volume_ids = _.get(result, "volume_ids", []);
+      /**
+       * the 1st partition is a sort of system partion and is ""
+       * usually around 15MB in size
+       */
+      volume_ids = volume_ids.filter((item) => {
+        return Boolean(item);
+      });
+
+      if (volume_ids.length > 1) {
+        throw new Error(
+          `${volume_ids.length} volumes on the disk, no way to know which is the relevant volume`
+        );
+      }
+
+      // ok of null/undefined
+      return volume_ids[0];
+    }
+  }
+
+  /**
+   * Return a volume_id if the target and disk both have 0 or 1 entries
+   *
+   * @param {*} target_portal
+   * @param {*} iqn
+   * @returns
+   */
+  async getVolumeIdFromIscsiTarget(target_portal, iqn) {
+    const disk_number = await this.getDiskNumberFromIscsiTarget(...arguments);
+    return await this.getVolumeIdFromDiskNumber(disk_number);
+  }
+
+  async FilesystemPathExists(path) {
+    let result;
+    try {
+      result = await this.executeRPC("filesystem", "PathExists", {
+        path,
+      });
+
+      return result.exists;
+    } catch (e) {
+      let details = _.get(e, "details", "");
+      if (details.includes("not an absolute Windows path")) {
+        return false;
+      } else {
+        throw e;
+      }
+    }
+  }
+
+  async FilesystemIsSymlink(path) {
+    let result;
+    try {
+      result = await this.executeRPC("filesystem", "IsSymlink", {
+        path,
+      });
+
+      return result.is_symlink;
+    } catch (e) {
+      let details = _.get(e, "details", "");
+      if (details.includes("not an absolute Windows path")) {
+        return false;
+      } else {
+        throw e;
+      }
+    }
+  }
+}
+
+module.exports.CsiProxyClient = CsiProxyClient;