ratarmount-driver

#!/usr/bin/env python3

# NOTE: Copy this script to /usr/libexec/kubernetes/kubelet-plugins/volume/exec/janpf~ratarmount-driver/ratarmount-driver

import json
import logging
from re import S
import subprocess
import sys
from pathlib import Path
from typing import Dict

import click
import ratarmount

sys.stderr = open("/tmp/ratarmount-flexvolume.log", "a")

logging.basicConfig(
    format="%(asctime)s %(levelname)-8s %(message)s",
    level=logging.INFO,
    datefmt="%Y-%m-%d %H:%M:%S",
    filename="/tmp/ratarmount-flexvolume.log",
)


def info(message: dict):
    logging.info(message)
    print(json.dumps(message))


def error(message: dict):
    logging.error(message)
    exit(json.dumps(message))


@click.group()
def cli():
    pass


@cli.command()
def init():
    """
    Initializes the driver. It is called during initialization of masters and nodes.
    - Arguments: none
    - Executed on: master, node
    - Expected output: default JSON
    """
    logging.info("initializing")

    try:
        subprocess.check_output(["fusermount", "-V"])
    except:
        error({"status": "Failure", "message": "ratarmount-flexvol: fusermount not installed"})

    info({"status": "Success", "message": "ratarmount-flexvol: initialized", "capabilities": {"attach": False}})


@cli.command()
@click.argument("mount_dir")
@click.argument("json_str")
def mount(mount_dir: str, json_str: str):
    """
    Mounts a volume to directory.
    This can include anything that is necessary to mount the volume, including attaching the volume to the node, finding the its device, and then mounting the device.
    - Arguments: <mount-dir> <json>
    - Executed on: node
    - Expected output: default JSON
    """
    logging.info(f"{mount_dir}: mounting with {json_str}")

    json_params: Dict[str, str] = json.loads(json_str)
    Path(mount_dir).mkdir(parents=True, exist_ok=True)

    if not "archive" in json_params.keys():
        logging.error(f"{mount_dir}: no archive specified")
        error({"status": "Failure", "message": "ratarmount-flexvol: no tar file to mount specified"})

    if ".." in json_params["archive"]:
        logging.error(f"{mount_dir}: invalid archive specified")
        error({"status": "Failure", "message": "ratarmount-flexvol: invalid archive specified"})

    archives = json_params["archive"].split(";")
    archives = [tar.strip() for tar in archives]
    logging.info(str(archives))

    supported_mounts = ["ceph", "nfs"]
    if sum([f"{mnt}_mount" in json_params for mnt in supported_mounts]) > 1:
        logging.error(f"{mount_dir}: multiple mounts specified")
        error({"status": "Failure", "message": "ratarmount-flexvol: multiple mounts specified (e.g. ceph_mount and nfs_mount)"})
    if sum([f"{mnt}_mount" in json_params for mnt in supported_mounts]) == 0:
        logging.error(f"{mount_dir}: no mount specified")
        error({"status": "Failure", "message": "ratarmount-flexvol: no supported mount specified (e.g. ceph_mount or nfs_mount)"})

    if "ceph_mount" in json_params:
        if ".." in json_params["ceph_mount"]:
            logging.error(f"{mount_dir}: invalid ceph_mount specified")
            error({"status": "Failure", "message": "ratarmount-flexvol: invalid ceph_mount specified"})
        ceph_mount = json_params["ceph_mount"]
        volume_root = Path(mount_dir).parent.parent
        archives = [str(volume_root / "kubernetes.io~cephfs" / ceph_mount / tar) for tar in archives]

    elif "nfs_mount" in json_params:
        if ".." in json_params["nfs_mount"]:
            logging.error(f"{mount_dir}: invalid nfs_mount specified")
            error({"status": "Failure", "message": "ratarmount-flexvol: invalid nfs_mount specified"})
        nfs_mount = json_params["nfs_mount"]
        volume_root = Path(mount_dir).parent.parent
        archives = [str(volume_root / "kubernetes.io~nfs" / nfs_mount / tar) for tar in archives]


    ratarmount_params = ["--fuse", "allow_other"] + ["--parallelization", "2"] + archives + [mount_dir]
    truthy = ["true", "1", "y", "yes"]
    if "recreate-index" in json_params.keys() and json_params["recreate-index"].lower() in truthy:
        ratarmount_params.append("--recreate-index")

    if "recursive" in json_params.keys() and json_params["recursive"].lower() in truthy:
        ratarmount_params.append("--recursive")

    if "debug" in json_params.keys() and json_params["debug"].lower() in truthy:
        ratarmount_params.append("-d 1")

    logging.info(f"{mount_dir}: used ratarmount parameters: {ratarmount_params}")

    try:
        ratarmount.cli(rawArgs=ratarmount_params)
    except Exception as e:
        logging.error(f"{mount_dir}: {e}")
        error({"status": "Failure", "message": f"ratarmount-flexvol: error during mount: {e}"})

    logging.info(f"{mount_dir}: mounted")
    info({"status": "Success", "message": f"ratarmount-flexvol: mounted with {ratarmount_params}"})


@cli.command()
@click.argument("mount_dir")
def unmount(mount_dir: str):
    """
    Unmounts a volume from a directory.
    This can include anything that is necessary to clean up the volume after unmounting, such as detaching the volume from the node.
    - Arguments: <mount-dir>
    - Executed on: node
    - Expected output: default JSON
    """
    logging.info(f"{mount_dir}: unmounting")

    try:
        subprocess.run(["fusermount", "-u", mount_dir], check=True)
    except Exception as e:
        logging.error(f"{mount_dir}: {e}")
        error({"status": "Failure", "message": f"ratarmount-flexvol: error during unmount of {mount_dir}: {e}"})

    try:
        if Path(mount_dir).exists():
            Path(mount_dir).rmdir()
    except:
        logging.error(f"{mount_dir}: still exists after unmount")
        error(
            {
                "status": "Failure",
                "message": f"ratarmount-flexvol: error during unmount: {mount_dir} did not get unmounted",
            }
        )

    logging.info(f"{mount_dir}: unmounted")
    info({"status": "Success", "message": f"ratarmount-flexvol: unmounted {mount_dir}"})


if __name__ == "__main__":
    cli()