node-manual, dep updates

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

src/driver/factory.js

@@ -5,6 +5,7 @@ const {
 } = require("./zfs-local-ephemeral-inline");
 
 const { ControllerNfsClientDriver } = require("./controller-nfs-client");
+const { NodeManualDriver } = require("./node-manual");
 
 function factory(ctx, options) {
   switch (options.driver) {
@@ -22,6 +23,8 @@ function factory(ctx, options) {
       return new ZfsLocalEphemeralInlineDriver(ctx, options);
     case "nfs-client":
       return new ControllerNfsClientDriver(ctx, options);
+    case "node-manual":
+      return new NodeManualDriver(ctx, options);
     default:
       throw new Error("invalid csi driver: " + options.driver);
   }

src/driver/index.js

@@ -290,12 +290,22 @@ class CsiBaseDriver {
       mount_flags.push("defaults");
     }
 
-    result = await this.assertCapabilities([capability]);
-    if (!result.valid) {
-      throw new GrpcError(
-        grpc.status.INVALID_ARGUMENT,
-        `invalid capability: ${result.message}`
-      );
+    if (call.request.volume_context.provisioner_driver == "node-manual") {
+      result = await this.assertCapabilities([capability], node_attach_driver);
+      if (!result.valid) {
+        throw new GrpcError(
+          grpc.status.INVALID_ARGUMENT,
+          `invalid capability: ${result.message}`
+        );
+      }
+    } else {
+      result = await this.assertCapabilities([capability]);
+      if (!result.valid) {
+        throw new GrpcError(
+          grpc.status.INVALID_ARGUMENT,
+          `invalid capability: ${result.message}`
+        );
+      }
     }
 
     // csi spec stipulates that staging_target_path is a directory even for block mounts

src/driver/node-manual/index.js

@@ -0,0 +1,264 @@
+const { CsiBaseDriver } = require("../index");
+const { GrpcError, grpc } = require("../../utils/grpc");
+
+/**
+ * Driver which only runs the node portion and is meant to be used entirely
+ * with manually created PVs
+ */
+class NodeManualDriver extends CsiBaseDriver {
+  constructor(ctx, options) {
+    super(...arguments);
+
+    options = options || {};
+    options.service = options.service || {};
+    options.service.identity = options.service.identity || {};
+    options.service.controller = options.service.controller || {};
+    options.service.node = options.service.node || {};
+
+    options.service.identity.capabilities =
+      options.service.identity.capabilities || {};
+
+    options.service.controller.capabilities =
+      options.service.controller.capabilities || {};
+
+    options.service.node.capabilities = options.service.node.capabilities || {};
+
+    if (!("service" in options.service.identity.capabilities)) {
+      this.ctx.logger.debug("setting default identity service caps");
+
+      options.service.identity.capabilities.service = [
+        //"UNKNOWN",
+        //"CONTROLLER_SERVICE",
+        //"VOLUME_ACCESSIBILITY_CONSTRAINTS"
+      ];
+    }
+
+    if (!("volume_expansion" in options.service.identity.capabilities)) {
+      this.ctx.logger.debug("setting default identity volume_expansion caps");
+
+      options.service.identity.capabilities.volume_expansion = [
+        //"UNKNOWN",
+        //"ONLINE",
+        //"OFFLINE"
+      ];
+    }
+
+    if (!("rpc" in options.service.controller.capabilities)) {
+      this.ctx.logger.debug("setting default controller caps");
+
+      options.service.controller.capabilities.rpc = [
+        //"UNKNOWN",
+        //"CREATE_DELETE_VOLUME",
+        //"PUBLISH_UNPUBLISH_VOLUME",
+        //"LIST_VOLUMES",
+        //"GET_CAPACITY",
+        //"CREATE_DELETE_SNAPSHOT",
+        //"LIST_SNAPSHOTS",
+        //"CLONE_VOLUME",
+        //"PUBLISH_READONLY",
+        //"EXPAND_VOLUME",
+      ];
+    }
+
+    if (!("rpc" in options.service.node.capabilities)) {
+      this.ctx.logger.debug("setting default node caps");
+
+      options.service.node.capabilities.rpc = [
+        //"UNKNOWN",
+        "STAGE_UNSTAGE_VOLUME",
+        "GET_VOLUME_STATS",
+        //"EXPAND_VOLUME"
+      ];
+    }
+  }
+
+  assertCapabilities(capabilities, node_attach_driver) {
+    this.ctx.logger.verbose("validating capabilities: %j", capabilities);
+
+    let message = null;
+    let driverResourceType;
+    let fs_types = [];
+    //[{"access_mode":{"mode":"SINGLE_NODE_WRITER"},"mount":{"mount_flags":["noatime","_netdev"],"fs_type":"nfs"},"access_type":"mount"}]
+    switch (node_attach_driver) {
+      case "nfs":
+        driverResourceType = "filesystem";
+        fs_types = ["nfs"];
+        break;
+      case "smb":
+        driverResourceType = "filesystem";
+        fs_types = ["cifs"];
+        break;
+      case "iscsi":
+        driverResourceType = "volume";
+        fs_types = ["ext3", "ext4", "ext4dev", "xfs"];
+        break;
+      default:
+        return {
+          valid: false,
+          message: `unknown node_attach_driver: ${node_attach_driver}`,
+        };
+    }
+
+    const valid = capabilities.every((capability) => {
+      switch (driverResourceType) {
+        case "filesystem":
+          if (capability.access_type != "mount") {
+            message = `invalid access_type ${capability.access_type}`;
+            return false;
+          }
+
+          if (
+            capability.mount.fs_type &&
+            !fs_types.includes(capability.mount.fs_type)
+          ) {
+            message = `invalid fs_type ${capability.mount.fs_type}`;
+            return false;
+          }
+
+          if (
+            ![
+              "UNKNOWN",
+              "SINGLE_NODE_WRITER",
+              "SINGLE_NODE_READER_ONLY",
+              "MULTI_NODE_READER_ONLY",
+              "MULTI_NODE_SINGLE_WRITER",
+              "MULTI_NODE_MULTI_WRITER",
+            ].includes(capability.access_mode.mode)
+          ) {
+            message = `invalid access_mode, ${capability.access_mode.mode}`;
+            return false;
+          }
+
+          return true;
+        case "volume":
+          if (capability.access_type == "mount") {
+            if (
+              capability.mount.fs_type &&
+              !fs_types.includes(capability.mount.fs_type)
+            ) {
+              message = `invalid fs_type ${capability.mount.fs_type}`;
+              return false;
+            }
+          }
+
+          if (
+            ![
+              "UNKNOWN",
+              "SINGLE_NODE_WRITER",
+              "SINGLE_NODE_READER_ONLY",
+              "MULTI_NODE_READER_ONLY",
+              "MULTI_NODE_SINGLE_WRITER",
+            ].includes(capability.access_mode.mode)
+          ) {
+            message = `invalid access_mode, ${capability.access_mode.mode}`;
+            return false;
+          }
+
+          return true;
+      }
+    });
+
+    return { valid, message };
+  }
+
+  /**
+   *
+   * @param {*} call
+   */
+  async CreateVolume(call) {
+    throw new GrpcError(
+      grpc.status.UNIMPLEMENTED,
+      `operation not supported by driver`
+    );
+  }
+
+  /**
+   *
+   * @param {*} call
+   */
+  async DeleteVolume(call) {
+    throw new GrpcError(
+      grpc.status.UNIMPLEMENTED,
+      `operation not supported by driver`
+    );
+  }
+
+  /**
+   *
+   * @param {*} call
+   */
+  async ControllerExpandVolume(call) {
+    throw new GrpcError(
+      grpc.status.UNIMPLEMENTED,
+      `operation not supported by driver`
+    );
+  }
+
+  /**
+   *
+   * @param {*} call
+   */
+  async GetCapacity(call) {
+    throw new GrpcError(
+      grpc.status.UNIMPLEMENTED,
+      `operation not supported by driver`
+    );
+  }
+
+  /**
+   *
+   * @param {*} call
+   */
+  async ListVolumes(call) {
+    throw new GrpcError(
+      grpc.status.UNIMPLEMENTED,
+      `operation not supported by driver`
+    );
+  }
+
+  /**
+   *
+   * @param {*} call
+   */
+  async ListSnapshots(call) {
+    throw new GrpcError(
+      grpc.status.UNIMPLEMENTED,
+      `operation not supported by driver`
+    );
+  }
+
+  /**
+   *
+   * @param {*} call
+   */
+  async CreateSnapshot(call) {
+    throw new GrpcError(
+      grpc.status.UNIMPLEMENTED,
+      `operation not supported by driver`
+    );
+  }
+
+  /**
+   *
+   * @param {*} call
+   */
+  async DeleteSnapshot(call) {
+    throw new GrpcError(
+      grpc.status.UNIMPLEMENTED,
+      `operation not supported by driver`
+    );
+  }
+
+  /**
+   *
+   * @param {*} call
+   */
+  async ValidateVolumeCapabilities(call) {
+    throw new GrpcError(
+      grpc.status.UNIMPLEMENTED,
+      `operation not supported by driver`
+    );
+  }
+}
+
+module.exports.NodeManualDriver = NodeManualDriver;