673 lines
17 KiB
JavaScript
673 lines
17 KiB
JavaScript
const { CsiBaseDriver } = require("../index");
|
|
const { GrpcError, grpc } = require("../../utils/grpc");
|
|
const cp = require("child_process");
|
|
const { Mount } = require("../../utils/mount");
|
|
|
|
/**
|
|
* Crude nfs-client driver which simply creates directories to be mounted
|
|
* and uses rsync for cloning/snapshots
|
|
*/
|
|
class ControllerClientCommonDriver 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) {
|
|
const driver = this;
|
|
this.ctx.logger.verbose("validating capabilities: %j", capabilities);
|
|
|
|
let message = null;
|
|
let fs_types = driver.getFsTypes();
|
|
//[{"access_mode":{"mode":"SINGLE_NODE_WRITER"},"mount":{"mount_flags":["noatime","_netdev"],"fs_type":"nfs"},"access_type":"mount"}]
|
|
const valid = capabilities.every((capability) => {
|
|
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;
|
|
});
|
|
|
|
return { valid, message };
|
|
}
|
|
// share paths
|
|
getShareBasePath() {
|
|
let config_key = this.getConfigKey();
|
|
let path = this.options[config_key].shareBasePath;
|
|
if (!path) {
|
|
throw new GrpcError(
|
|
grpc.status.FAILED_PRECONDITION,
|
|
`invalid configuration: missing shareBasePath`
|
|
);
|
|
}
|
|
|
|
path = path.replace(/\/$/, "");
|
|
if (!path) {
|
|
throw new GrpcError(
|
|
grpc.status.FAILED_PRECONDITION,
|
|
`invalid configuration: missing shareBasePath`
|
|
);
|
|
}
|
|
|
|
return path;
|
|
}
|
|
|
|
// controller paths
|
|
getControllerBasePath() {
|
|
let config_key = this.getConfigKey();
|
|
let path = this.options[config_key].controllerBasePath;
|
|
if (!path) {
|
|
throw new GrpcError(
|
|
grpc.status.FAILED_PRECONDITION,
|
|
`invalid configuration: missing controllerBasePath`
|
|
);
|
|
}
|
|
|
|
path = path.replace(/\/$/, "");
|
|
if (!path) {
|
|
throw new GrpcError(
|
|
grpc.status.FAILED_PRECONDITION,
|
|
`invalid configuration: missing controllerBasePath`
|
|
);
|
|
}
|
|
|
|
return path;
|
|
}
|
|
|
|
// path helpers
|
|
getVolumeExtraPath() {
|
|
return "/v";
|
|
}
|
|
|
|
getSnapshotExtraPath() {
|
|
return "/s";
|
|
}
|
|
|
|
getShareVolumeBasePath() {
|
|
return this.getShareBasePath() + this.getVolumeExtraPath();
|
|
}
|
|
|
|
getShareSnapshotBasePath() {
|
|
return this.getShareBasePath() + this.getSnapshotExtraPath();
|
|
}
|
|
|
|
getShareVolumePath(volume_id) {
|
|
return this.getShareVolumeBasePath() + "/" + volume_id;
|
|
}
|
|
|
|
getShareSnapshotPath(snapshot_id) {
|
|
return this.getShareSnapshotBasePath() + "/" + snapshot_id;
|
|
}
|
|
|
|
getControllerVolumeBasePath() {
|
|
return this.getControllerBasePath() + this.getVolumeExtraPath();
|
|
}
|
|
|
|
getControllerSnapshotBasePath() {
|
|
return this.getControllerBasePath() + this.getSnapshotExtraPath();
|
|
}
|
|
|
|
getControllerVolumePath(volume_id) {
|
|
return this.getControllerVolumeBasePath() + "/" + volume_id;
|
|
}
|
|
|
|
getControllerSnapshotPath(snapshot_id) {
|
|
return this.getControllerSnapshotBasePath() + "/" + snapshot_id;
|
|
}
|
|
|
|
exec(command, args, options = {}) {
|
|
args = args || [];
|
|
|
|
let timeout;
|
|
let stdout = "";
|
|
let stderr = "";
|
|
|
|
if (options.sudo) {
|
|
args.unshift(command);
|
|
command = "sudo";
|
|
}
|
|
console.log("executing command: %s %s", command, args.join(" "));
|
|
const child = cp.spawn(command, args, options);
|
|
|
|
let didTimeout = false;
|
|
if (options && options.timeout) {
|
|
timeout = setTimeout(() => {
|
|
didTimeout = true;
|
|
child.kill(options.killSignal || "SIGTERM");
|
|
}, options.timeout);
|
|
}
|
|
|
|
return new Promise((resolve, reject) => {
|
|
child.stdout.on("data", function (data) {
|
|
stdout = stdout + data;
|
|
});
|
|
|
|
child.stderr.on("data", function (data) {
|
|
stderr = stderr + data;
|
|
});
|
|
|
|
child.on("close", function (code) {
|
|
const result = { code, stdout, stderr };
|
|
if (timeout) {
|
|
clearTimeout(timeout);
|
|
}
|
|
if (code) {
|
|
reject(result);
|
|
} else {
|
|
resolve(result);
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
stripTrailingSlash(s) {
|
|
if (s.length > 1) {
|
|
return s.replace(/\/$/, "");
|
|
}
|
|
|
|
return s;
|
|
}
|
|
|
|
stripLeadingSlash(s) {
|
|
if (s.length > 1) {
|
|
return s.replace(/^\/+/, "");
|
|
}
|
|
|
|
return s;
|
|
}
|
|
|
|
async cloneDir(source_path, target_path) {
|
|
await this.exec("mkdir", ["-p", target_path]);
|
|
|
|
/**
|
|
* trailing / is important
|
|
* rsync -a /mnt/storage/s/foo/ /mnt/storage/v/PVC-111/
|
|
*/
|
|
await this.exec("rsync", [
|
|
"-a",
|
|
this.stripTrailingSlash(source_path) + "/",
|
|
this.stripTrailingSlash(target_path) + "/",
|
|
]);
|
|
}
|
|
|
|
async getAvailableSpaceAtPath(path) {
|
|
//df --output=avail /mnt/storage/
|
|
// Avail
|
|
//1481334328
|
|
|
|
const response = await this.exec("df", ["--output=avail", path]);
|
|
|
|
return response.stdout.split("\n")[1].trim();
|
|
}
|
|
|
|
async deleteDir(path) {
|
|
await this.exec("rm", ["-rf", path]);
|
|
|
|
return;
|
|
|
|
/**
|
|
* trailing / is important
|
|
* rsync -a /mnt/storage/s/foo/ /mnt/storage/v/PVC-111/
|
|
*/
|
|
await this.exec("rsync", [
|
|
"-a",
|
|
"--delete",
|
|
this.stripTrailingSlash(empty_path) + "/",
|
|
this.stripTrailingSlash(path) + "/",
|
|
]);
|
|
}
|
|
|
|
/**
|
|
* Create a volume doing in essence the following:
|
|
* 1. create directory
|
|
*
|
|
* Should return 2 parameters
|
|
* 1. `server` - host/ip of the nfs server
|
|
* 2. `share` - path of the mount shared
|
|
*
|
|
* @param {*} call
|
|
*/
|
|
async CreateVolume(call) {
|
|
const driver = this;
|
|
|
|
let config_key = this.getConfigKey();
|
|
let name = call.request.name;
|
|
let volume_content_source = call.request.volume_content_source;
|
|
|
|
if (!name) {
|
|
throw new GrpcError(
|
|
grpc.status.INVALID_ARGUMENT,
|
|
`volume name is required`
|
|
);
|
|
}
|
|
|
|
if (call.request.volume_capabilities) {
|
|
const result = this.assertCapabilities(call.request.volume_capabilities);
|
|
if (result.valid !== true) {
|
|
throw new GrpcError(grpc.status.INVALID_ARGUMENT, result.message);
|
|
}
|
|
}
|
|
|
|
if (
|
|
call.request.capacity_range.required_bytes > 0 &&
|
|
call.request.capacity_range.limit_bytes > 0 &&
|
|
call.request.capacity_range.required_bytes >
|
|
call.request.capacity_range.limit_bytes
|
|
) {
|
|
throw new GrpcError(
|
|
grpc.status.OUT_OF_RANGE,
|
|
`required_bytes is greather than limit_bytes`
|
|
);
|
|
}
|
|
|
|
let capacity_bytes =
|
|
call.request.capacity_range.required_bytes ||
|
|
call.request.capacity_range.limit_bytes;
|
|
|
|
if (!capacity_bytes) {
|
|
//should never happen, value must be set
|
|
throw new GrpcError(
|
|
grpc.status.INVALID_ARGUMENT,
|
|
`volume capacity is required (either required_bytes or limit_bytes)`
|
|
);
|
|
}
|
|
|
|
// ensure *actual* capacity is not greater than limit
|
|
if (
|
|
call.request.capacity_range.limit_bytes &&
|
|
call.request.capacity_range.limit_bytes > 0 &&
|
|
capacity_bytes > call.request.capacity_range.limit_bytes
|
|
) {
|
|
throw new GrpcError(
|
|
grpc.status.OUT_OF_RANGE,
|
|
`required volume capacity is greater than limit`
|
|
);
|
|
}
|
|
|
|
const volume_path = driver.getControllerVolumePath(name);
|
|
|
|
let response;
|
|
let source_path;
|
|
//let volume_content_source_snapshot_id;
|
|
//let volume_content_source_volume_id;
|
|
|
|
// create target dir
|
|
response = await driver.exec("mkdir", ["-p", volume_path]);
|
|
|
|
// create dataset
|
|
if (volume_content_source) {
|
|
switch (volume_content_source.type) {
|
|
// must be available when adverstising CREATE_DELETE_SNAPSHOT
|
|
// simply clone
|
|
case "snapshot":
|
|
source_path = driver.getControllerSnapshotPath(
|
|
volume_content_source.snapshot.snapshot_id
|
|
);
|
|
break;
|
|
// must be available when adverstising CLONE_VOLUME
|
|
// create snapshot first, then clone
|
|
case "volume":
|
|
source_path = driver.getControllerVolumePath(
|
|
volume_content_source.volume.volume_id
|
|
);
|
|
break;
|
|
default:
|
|
throw new GrpcError(
|
|
grpc.status.INVALID_ARGUMENT,
|
|
`invalid volume_content_source type: ${volume_content_source.type}`
|
|
);
|
|
break;
|
|
}
|
|
|
|
driver.ctx.logger.debug("controller source path: %s", source_path);
|
|
response = await driver.cloneDir(source_path, volume_path);
|
|
}
|
|
|
|
// set mode
|
|
if (this.options[config_key].dirPermissionsMode) {
|
|
driver.ctx.logger.verbose(
|
|
"setting dir mode to: %s on dir: %s",
|
|
this.options[config_key].dirPermissionsMode,
|
|
volume_path
|
|
);
|
|
response = await driver.exec("chmod", [
|
|
this.options[config_key].dirPermissionsMode,
|
|
volume_path,
|
|
]);
|
|
}
|
|
|
|
// set ownership
|
|
if (
|
|
this.options[config_key].dirPermissionsUser ||
|
|
this.options[config_key].dirPermissionsGroup
|
|
) {
|
|
driver.ctx.logger.verbose(
|
|
"setting ownership to: %s:%s on dir: %s",
|
|
this.options[config_key].dirPermissionsUser,
|
|
this.options[config_key].dirPermissionsGroup,
|
|
volume_path
|
|
);
|
|
response = await driver.exec("chown", [
|
|
(this.options[config_key].dirPermissionsUser
|
|
? this.options[config_key].dirPermissionsUser
|
|
: "") +
|
|
":" +
|
|
(this.options[config_key].dirPermissionsGroup
|
|
? this.options[config_key].dirPermissionsGroup
|
|
: ""),
|
|
volume_path,
|
|
]);
|
|
}
|
|
|
|
let volume_context = driver.getVolumeContext(name);
|
|
|
|
volume_context["provisioner_driver"] = driver.options.driver;
|
|
if (driver.options.instance_id) {
|
|
volume_context["provisioner_driver_instance_id"] =
|
|
driver.options.instance_id;
|
|
}
|
|
|
|
const res = {
|
|
volume: {
|
|
volume_id: name,
|
|
//capacity_bytes: capacity_bytes, // kubernetes currently pukes if capacity is returned as 0
|
|
capacity_bytes: 0,
|
|
content_source: volume_content_source,
|
|
volume_context,
|
|
},
|
|
};
|
|
|
|
return res;
|
|
}
|
|
|
|
/**
|
|
* Delete a volume
|
|
*
|
|
* Deleting a volume consists of the following steps:
|
|
* 1. delete directory
|
|
*
|
|
* @param {*} call
|
|
*/
|
|
async DeleteVolume(call) {
|
|
const driver = this;
|
|
|
|
let name = call.request.volume_id;
|
|
|
|
if (!name) {
|
|
throw new GrpcError(
|
|
grpc.status.INVALID_ARGUMENT,
|
|
`volume_id is required`
|
|
);
|
|
}
|
|
|
|
const volume_path = driver.getControllerVolumePath(name);
|
|
await driver.deleteDir(volume_path);
|
|
|
|
return {};
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param {*} call
|
|
*/
|
|
async ControllerExpandVolume(call) {
|
|
throw new GrpcError(
|
|
grpc.status.UNIMPLEMENTED,
|
|
`operation not supported by driver`
|
|
);
|
|
}
|
|
|
|
/**
|
|
* TODO: consider volume_capabilities?
|
|
*
|
|
* @param {*} call
|
|
*/
|
|
async GetCapacity(call) {
|
|
// really capacity is not used at all with nfs in this fashion, so no reason to enable
|
|
// here even though it is technically feasible.
|
|
throw new GrpcError(
|
|
grpc.status.UNIMPLEMENTED,
|
|
`operation not supported by driver`
|
|
);
|
|
|
|
const driver = this;
|
|
|
|
if (call.request.volume_capabilities) {
|
|
const result = this.assertCapabilities(call.request.volume_capabilities);
|
|
|
|
if (result.valid !== true) {
|
|
return { available_capacity: 0 };
|
|
}
|
|
}
|
|
|
|
const available_capacity = await driver.getAvailableSpaceAtPath(
|
|
driver.getControllerBasePath()
|
|
);
|
|
return { available_capacity };
|
|
}
|
|
|
|
/**
|
|
*
|
|
* TODO: check capability to ensure not asking about block volumes
|
|
*
|
|
* @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) {
|
|
const driver = this;
|
|
|
|
// both these are required
|
|
let source_volume_id = call.request.source_volume_id;
|
|
let name = call.request.name;
|
|
|
|
if (!source_volume_id) {
|
|
throw new GrpcError(
|
|
grpc.status.INVALID_ARGUMENT,
|
|
`snapshot source_volume_id is required`
|
|
);
|
|
}
|
|
|
|
if (!name) {
|
|
throw new GrpcError(
|
|
grpc.status.INVALID_ARGUMENT,
|
|
`snapshot name is required`
|
|
);
|
|
}
|
|
|
|
driver.ctx.logger.verbose("requested snapshot name: %s", name);
|
|
|
|
let invalid_chars;
|
|
invalid_chars = name.match(/[^a-z0-9_\-:.+]+/gi);
|
|
if (invalid_chars) {
|
|
invalid_chars = String.prototype.concat(
|
|
...new Set(invalid_chars.join(""))
|
|
);
|
|
throw new GrpcError(
|
|
grpc.status.INVALID_ARGUMENT,
|
|
`snapshot name contains invalid characters: ${invalid_chars}`
|
|
);
|
|
}
|
|
|
|
// https://stackoverflow.com/questions/32106243/regex-to-remove-all-non-alpha-numeric-and-replace-spaces-with/32106277
|
|
name = name.replace(/[^a-z0-9_\-:.+]+/gi, "");
|
|
|
|
driver.ctx.logger.verbose("cleansed snapshot name: %s", name);
|
|
|
|
const snapshot_id = `${source_volume_id}-${name}`;
|
|
const volume_path = driver.getControllerVolumePath(source_volume_id);
|
|
const snapshot_path = driver.getControllerSnapshotPath(snapshot_id);
|
|
|
|
await driver.cloneDir(volume_path, snapshot_path);
|
|
|
|
return {
|
|
snapshot: {
|
|
/**
|
|
* The purpose of this field is to give CO guidance on how much space
|
|
* is needed to create a volume from this snapshot.
|
|
*/
|
|
size_bytes: 0,
|
|
snapshot_id,
|
|
source_volume_id: source_volume_id,
|
|
//https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/timestamp.proto
|
|
creation_time: {
|
|
seconds: Math.round(new Date().getTime() / 1000),
|
|
nanos: 0,
|
|
},
|
|
ready_to_use: true,
|
|
},
|
|
};
|
|
}
|
|
|
|
/**
|
|
* In addition, if clones have been created from a snapshot, then they must
|
|
* be destroyed before the snapshot can be destroyed.
|
|
*
|
|
* @param {*} call
|
|
*/
|
|
async DeleteSnapshot(call) {
|
|
const driver = this;
|
|
|
|
const snapshot_id = call.request.snapshot_id;
|
|
|
|
if (!snapshot_id) {
|
|
throw new GrpcError(
|
|
grpc.status.INVALID_ARGUMENT,
|
|
`snapshot_id is required`
|
|
);
|
|
}
|
|
|
|
const snapshot_path = driver.getControllerSnapshotPath(snapshot_id);
|
|
await driver.deleteDir(snapshot_path);
|
|
|
|
return {};
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param {*} call
|
|
*/
|
|
async ValidateVolumeCapabilities(call) {
|
|
const driver = this;
|
|
const result = this.assertCapabilities(call.request.volume_capabilities);
|
|
|
|
if (result.valid !== true) {
|
|
return { message: result.message };
|
|
}
|
|
|
|
return {
|
|
confirmed: {
|
|
volume_context: call.request.volume_context,
|
|
volume_capabilities: call.request.volume_capabilities, // TODO: this is a bit crude, should return *ALL* capabilities, not just what was requested
|
|
parameters: call.request.parameters,
|
|
},
|
|
};
|
|
}
|
|
}
|
|
|
|
module.exports.ControllerClientCommonDriver = ControllerClientCommonDriver;
|