mpsd-software.py

    list_of_microarchs_candidates = os.listdir(release_base_dir)
    list_of_microarchs = [
        x for x in list_of_microarchs_candidates if x not in black_listed_files
    ]
    logging.debug(f"{list_of_microarchs=}")

    toolchain_map = {}
    for microarch in list_of_microarchs:
        # get a list of all the toolchains in the microarch
        possible_toolchains = (release_base_dir / microarch).glob(
            "lmod/Core/toolchains/*.lua"
        )
        # append toolchain which is the name of the file without the .lua extension
        toolchain_map[microarch] = [toolchain.stem for toolchain in possible_toolchains]

    logging.debug(f"{toolchain_map=}")

    # pretty print the toolchain map key as the heading
    # and the value as the list of toolchains
    plog.info(
        f"Toolchains installed in the {mpsd_release=} for each Microarchitecture:"
    )
    for microarch, toolchains in toolchain_map.items():
        plog.info(f"- {microarch}: \n \t {toolchains}")
    return toolchain_map


def main():
    """Execute main entry point."""
    parser = argparse.ArgumentParser(description=about_tool)
    parser.add_argument(
        "--log",
        "-l",
        dest="loglevel",
        choices=["warning", "info", "debug"],
        required=False,
        default="warning",
        help="Set the log level",
    )

    subparsers = parser.add_subparsers(
        dest="action", title="actions", description="valid actions", required=True
    )
    subparsers.required = True
    list_of_cmds = [
        ("available", "Show toolchains available"),
        ("prepare", "Prepare the environment for installation on the disk"),
        ("install", "Install a software environment"),
        ("reinstall", "Reinstall a software environment"),
        ("remove", "Remove a software environment or toolchains from an environment"),
        ("start-new", "Start a new software environment version"),
        ("status", "Show the status of the software environment"),
    ]
    for cmd, help_text in list_of_cmds:
        subp = subparsers.add_parser(cmd, help=help_text)

        if cmd == "start-new":
            subp.add_argument(
                "--from-release",
                dest="from_release",
                type=str,
                required=True,
                help="Release version to start from",
            )
            subp.add_argument(
                "--to-release",
                dest="to_release",
                type=str,
                required=True,
                help="Release version to create",
            )

        else:
            subp.add_argument(
                "release",
                type=str,
                help="Release version to prepare, install, reinstall or remove",
            )
            if cmd in ["install", "reinstall", "remove"]:
                # "install" command needs additional documentation
                tool_chain_help = (
                    f"Pass a list of toolchains to command {cmd}. "
                    "Use '--toolchains ALL' to "
                    f"{cmd} all toolchains. If '--toolchain' is not "
                    "specified, list available toolchains for the release "
                    "(after environment has been prepared if not done yet)."
                )

                subp.add_argument(
                    "--toolchains",  # first option defines attribute
                    # name `args.toolchains` in `args = parser_args()`
                    "--toolchain",  # allow singular as alternative
                    # (-> creates attribute `args.toolchains` if used)
                    type=str,
                    dest="toolchains",
                    nargs="+",
                    default="NONE",
                    help=tool_chain_help,
                )
                subp.add_argument(
                    "--enable-build-cache",
                    action="store_true",
                    help=(
                        "Enable Spack build cache. Useful for reinstallation but "
                        "consumes time and disk space."
                    ),
                )
    # Carry out the action
    args = parser.parse_args()

    # target dir is the place where this script exists. the
    root_dir = Path(os.path.dirname(os.path.realpath(__file__)))

    set_up_logging(
        args.loglevel,
        get_installer_log_file_path(args.release, args.action, root_dir),
    )

    # Check the command and run related function
    if args.action == "remove":
        remove_environment(args.release, args.toolchains, root_dir)
    elif args.action == "start-new":
        start_new_environment(args.from_release, args.to_release, root_dir)
    elif args.action == "install":
        install_environment(
            args.release, args.toolchains, root_dir, False, args.enable_build_cache
        )
    elif args.action == "status":
        _ = environment_status(args.release, root_dir)
    elif args.action == "prepare":
        prepare_environment(args.release, root_dir)
    elif args.action == "available":
        get_available_toolchains(args.release)
    else:
        message = (
            f"No known action found ({args.action=}). Should probably never happen."
        )
        logging.error(message)
        raise NotImplementedError(message)


if __name__ == "__main__":
    main()