anyscale 0.24.86__py3-none-any.whl

anyscale/commands/logs_commands.py

@@ -0,0 +1,312 @@
+"""
+This file holds all of the CLI commands for the "anyscale logs" path. Note that
+most of the implementation for this command is in the controller to make the controller
+accessible to the SDK in the future.
+
+TODO (shomilj): Bring the controller to feature parity with the CLI.
+"""
+from datetime import timedelta
+import math
+from typing import Optional
+
+import click
+from rich.console import Console, Group
+from rich.panel import Panel
+from rich.table import Table
+
+from anyscale.cli_logger import BlockLogger
+from anyscale.client.openapi_client.models import LogFilter
+from anyscale.client.openapi_client.models.node_type import NodeType
+from anyscale.controllers.logs_controller import (
+    DEFAULT_PAGE_SIZE,
+    DEFAULT_PARALLELISM,
+    DEFAULT_READ_TIMEOUT,
+    DEFAULT_TIMEOUT,
+    DEFAULT_TTL,
+    LogsController,
+)
+
+
+log = BlockLogger()
+
+# Options to configure core functionality. These are mutually exclusive.
+option_download = click.option(
+    "-d",
+    "--download",
+    is_flag=True,
+    default=False,
+    help="Download logs to the current working directory, or a specified path.",
+)
+option_tail = click.option(
+    "-t", "--tail", type=int, default=-1, help="Read the last N lines of logs."
+)
+
+# The "glob" is an optional argument.
+# e.g. anyscale logs cluster --cluster-id <cluster-id> [GLOB]
+argument_glob = click.argument("glob", type=str, default=None, required=False)
+
+# Options to filter beyond what the subcommand already filters to.
+option_node_ip = click.option(
+    "-ip", "--node-ip", type=str, default=None, help="Filter logs by a node IP."
+)
+option_instance_id = click.option(
+    "--instance-id", type=str, default=None, help="Filter logs by an instance ID."
+)
+option_worker_only = click.option(
+    "--worker-only", is_flag=True, help="Download logs of only the worker nodes."
+)
+option_head_only = click.option(
+    "--head-only", is_flag=True, help="Download logs of only the head node."
+)
+option_unpack_combined_logs = click.option(
+    "--unpack/--no-unpack",
+    default=True,
+    help="Whether to unpack the combined-worker.log after downloading.",
+    hidden=True,
+)
+
+option_ttl = click.option(
+    "--ttl",
+    type=int,
+    default=DEFAULT_TTL,
+    hidden=True,
+    help="TTL in seconds to pass to the service that generates presigned URL's (default: 4h).",
+)
+option_parallelism = click.option(
+    "--parallelism",
+    type=int,
+    default=DEFAULT_PARALLELISM,
+    hidden=True,
+    help="Number of files to download in parallel at a time.",
+)
+
+# ADVANCED: Configure the download behavior, only useful if --download enabled.
+option_download_dir = click.option(
+    "--download-dir", type=str, default=None, help="Directory to download logs into."
+)
+
+
+@click.group(
+    "logs", help="Print or download Ray logs for an Anyscale job, service, or cluster.",
+)
+def log_cli() -> None:
+    pass
+
+
+@log_cli.command(name="cluster", help="Access log files of a cluster.")
+@click.option("--id", type=str, required=True, help="Provide a cluster ID.")
+@option_download
+@option_tail
+@argument_glob
+@option_node_ip
+@option_instance_id
+@option_worker_only
+@option_head_only
+@option_unpack_combined_logs
+@option_download_dir
+@option_ttl
+@option_parallelism
+def anyscale_logs_cluster(  # noqa: PLR0913
+    id: str,  # noqa: A002
+    download: bool,
+    tail: int,
+    # filters
+    glob: Optional[str],
+    node_ip: Optional[str],
+    instance_id: Optional[str],
+    worker_only: bool,
+    head_only: bool,
+    unpack: bool,
+    # list files config
+    ttl: int,
+    # download files config
+    download_dir: Optional[str],
+    parallelism: int,
+) -> None:
+    logs_controller = LogsController()
+    execute_anyscale_logs_cluster(
+        logs_controller=logs_controller,
+        cluster_id=id,
+        download=download,
+        tail=tail,
+        glob=glob,
+        node_ip=node_ip,
+        instance_id=instance_id,
+        worker_only=worker_only,
+        head_only=head_only,
+        unpack=unpack,
+        ttl=ttl,
+        download_dir=download_dir,
+        parallelism=parallelism,
+    )
+
+
+def execute_anyscale_logs_cluster(  # noqa: PLR0913
+    logs_controller: LogsController,
+    cluster_id: str,
+    download: bool,
+    tail: int,
+    glob: Optional[str],
+    node_ip: Optional[str],
+    instance_id: Optional[str],
+    worker_only: bool,
+    head_only: bool,
+    unpack: bool,  # list files config
+    ttl: int,
+    # download files config
+    download_dir: Optional[str],
+    parallelism: int,
+):
+
+    node_type: Optional[NodeType] = None
+    if worker_only and head_only:
+        raise click.ClickException("Cannot specify both --worker-only and --head-only.")
+    if worker_only:
+        node_type = NodeType.WORKER_NODES
+    elif head_only:
+        node_type = NodeType.HEAD_NODE
+
+    filter = LogFilter(  # noqa: A001
+        cluster_id=cluster_id,
+        glob=glob,
+        node_ip=node_ip,
+        instance_id=instance_id,
+        node_type=node_type,
+    )
+
+    if download:
+        logs_controller.download_logs(
+            filter=filter,
+            page_size=DEFAULT_PAGE_SIZE,
+            timeout=timedelta(seconds=DEFAULT_TIMEOUT),
+            read_timeout=timedelta(seconds=DEFAULT_READ_TIMEOUT),
+            ttl_seconds=ttl,
+            download_dir=download_dir,
+            parallelism=parallelism,
+            unpack=unpack,
+        )
+
+    else:
+        # This is for both tailing logs AND for the default behavior (no -t/-d/-f => rendering them in UI).
+        console = Console()
+        log_group = logs_controller.get_log_group(
+            filter=filter,
+            page_size=DEFAULT_PAGE_SIZE,
+            timeout=timedelta(seconds=DEFAULT_TIMEOUT),
+            ttl_seconds=ttl,
+        )
+        if len(log_group.get_files()) == 0:
+            console.print("No results found.")
+        elif len(log_group.get_files()) > 1:
+            console.print(
+                "These are the available log files. To download all files, use --download. To render a specific file, just paste the filename after this command."
+            )
+            click.echo()
+            for session in log_group.get_sessions():
+                click.echo()
+                renderables = []
+
+                for node in session.get_nodes():
+                    table = Table()
+                    table.add_column("File Name", justify="left", style="green")
+                    table.add_column("Size")
+                    for log_file in node.get_files():
+                        table.add_row(
+                            log_file.file_name, convert_size(log_file.get_size()),
+                        )
+                    prefix = (
+                        "Head Node"
+                        if node.node_type == NodeType.HEAD_NODE
+                        else "Worker Node"
+                    )
+                    # TODO (shomilj): When we support GCE, clean this up.
+                    instance_id = (
+                        f"EC2 Instance ID: {node.instance_id}"
+                        if node.instance_id.startswith("i-")
+                        else node.instance_id
+                    )
+                    renderables.append(
+                        Panel(
+                            Group(table),
+                            title=f"{prefix}: {node.node_ip} ({instance_id})",
+                            title_align="left",
+                        )
+                    )
+                group = Group(*renderables)
+                console.print(
+                    Panel(
+                        group,
+                        title=f"Session: {session.session_id}",
+                        title_align="left",
+                        padding=(1, 1),
+                    )
+                )
+
+        else:
+            logs_controller.render_logs(
+                log_group=log_group,
+                parallelism=parallelism,
+                read_timeout=timedelta(seconds=DEFAULT_READ_TIMEOUT),
+                tail=tail,
+            )
+
+        click.echo()
+
+
+@log_cli.command(name="job", help="Access log files of a production job.")
+@click.option("--id", type=str, required=True, help="Provide a production job ID.")
+@option_download
+@option_tail
+@argument_glob
+@option_node_ip
+@option_instance_id
+@option_worker_only
+@option_head_only
+@option_unpack_combined_logs
+@option_download_dir
+@option_ttl
+@option_parallelism
+def anyscale_logs_job(  # noqa: PLR0913
+    id: str,  # noqa: A002
+    download: bool,
+    tail: int,
+    # filters
+    glob: Optional[str],
+    node_ip: Optional[str],
+    instance_id: Optional[str],
+    worker_only: bool,
+    head_only: bool,
+    unpack: bool,
+    # list files config
+    ttl: int,
+    # download files config
+    download_dir: Optional[str],
+    parallelism: int,
+) -> None:
+    logs_controller = LogsController()
+    cluster_id = logs_controller.get_cluster_id_for_last_prodjob_run(prodjob_id=id)
+    execute_anyscale_logs_cluster(
+        logs_controller=logs_controller,
+        cluster_id=cluster_id,
+        download=download,
+        tail=tail,
+        glob=glob,
+        node_ip=node_ip,
+        instance_id=instance_id,
+        worker_only=worker_only,
+        head_only=head_only,
+        unpack=unpack,
+        ttl=ttl,
+        download_dir=download_dir,
+        parallelism=parallelism,
+    )
+
+
+def convert_size(size_bytes):
+    if size_bytes == 0:
+        return "0B"
+    size_name = ("B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB")
+    i = int(math.floor(math.log(size_bytes, 1024)))
+    p = math.pow(1024, i)
+    s = round(size_bytes / p, 2)
+    return f"{s} {size_name[i]}"

anyscale/commands/machine_commands.py

@@ -0,0 +1,116 @@
+"""
+This file holds all of the CLI commands for the "anyscale machine" path.
+"""
+from typing import Optional
+
+import click
+import humanize
+from rich import print_json
+import tabulate
+
+from anyscale.commands.util import LegacyAnyscaleCommand
+from anyscale.controllers.machine_controller import MachineController
+
+
+@click.group(
+    "machine", help="Commands to interact with machines in Anyscale.",
+)
+def machine_cli() -> None:
+    pass
+
+
+@machine_cli.command(
+    name="list",
+    help="List machines registered to Anyscale.",
+    cls=LegacyAnyscaleCommand,
+    is_limited_support=True,
+    legacy_prefix="anyscale machine",
+)
+@click.option("--machine-pool-name", type=str, help="Provide a machine pool name.")
+@click.option(
+    "--format",
+    "format_",
+    type=click.Choice(["table", "json"]),
+    default="table",
+    help="The format to return results in.",
+)
+def list_machines(machine_pool_name: str, format_: str,) -> None:
+    machines_controller = MachineController()
+    output = machines_controller.list_machines(machine_pool_name)
+
+    if format_ == "json":
+        rows = []
+        for m in output.machines:
+            rows.append(
+                {
+                    "machine_id": m.machine_id,
+                    "hostname": m.hostname,
+                    "machine_shape": m.machine_shape,
+                    "num_cpus": m.num_cpus,
+                    "num_gpus": m.num_gpus,
+                    "memory": humanize.naturalsize(m.memory_bytes, binary=True),
+                    "connection_state": m.connection_state,
+                    "allocation_state": m.allocation_state,
+                    "cluster_id": m.cluster_id,
+                    "cluster_creator_name": m.cluster_creator_name,
+                    "cluster_name": m.cluster_name,
+                    "anyscale_version": m.anyscale_version,
+                }
+            )
+        print_json(data=rows)
+    elif format_ == "table":
+        table = []
+        columns = [
+            "MACHINE",
+            "HOSTNAME",
+            "SHAPE",
+            "NUM_CPUS",
+            "NUM_GPUS",
+            "MEMORY",
+            "HEALTHY",
+            "STATUS",
+            "OWNER",
+            "CLUSTER ID",
+            "CLUSTER NAME",
+            "ANYSCALE VERSION",
+        ]
+        for m in output.machines:
+            table.append(
+                [
+                    m.machine_id,
+                    m.hostname,
+                    m.machine_shape,
+                    m.num_cpus,
+                    m.num_gpus,
+                    humanize.naturalsize(m.memory_bytes, binary=True),
+                    "Yes" if m.connection_state == "connected" else "No",
+                    m.allocation_state.title(),
+                    m.cluster_creator_name,
+                    m.cluster_id,
+                    m.cluster_name,
+                    m.anyscale_version,
+                ]
+            )
+
+        print(
+            tabulate.tabulate(table, tablefmt="plain", headers=columns, stralign="left")
+        )
+
+
+@machine_cli.command(
+    name="delete",
+    help="Delete a machine from a machine pool.",
+    cls=LegacyAnyscaleCommand,
+    is_limited_support=True,
+    legacy_prefix="anyscale machine",
+)
+@click.option("--machine-id", type=str, help="Provide a machine ID.")
+@click.option("--machine-pool-name", type=str, help="Provide a machine pool name.")
+def delete_machine(machine_id: str, machine_pool_name: Optional[str],) -> None:
+
+    machines_controller = MachineController()
+    machines_controller.delete_machine(
+        machine_id=machine_id, machine_pool_name=machine_pool_name,
+    )
+
+    print(f"Machine {machine_id} has been deleted.")

anyscale/commands/machine_pool_commands.py

@@ -0,0 +1,163 @@
+"""
+This file holds all of the CLI commands for the "anyscale machine-pool" path.
+"""
+
+import click
+import tabulate
+import yaml
+
+from anyscale.commands import command_examples
+from anyscale.commands.util import AnyscaleCommand
+from anyscale.controllers.machine_pool_controller import MachinePoolController
+
+
+@click.group(
+    "machine-pool", help="Commands to interact with machine pools in Anyscale.",
+)
+def machine_pool_cli() -> None:
+    pass
+
+
+@machine_pool_cli.command(
+    name="create",
+    help="Create a machine pool in Anyscale.",
+    cls=AnyscaleCommand,
+    example=command_examples.MACHINE_POOL_CREATE_EXAMPLE,
+    is_beta=True,
+)
+@click.option(
+    "--name",
+    type=str,
+    required=True,
+    help="Provide a machine pool name (must be unique within an organization).",
+)
+@click.option(
+    "--enable-rootless-dataplane-config",
+    type=bool,
+    default=False,
+    required=False,
+    help="Enable the dataplane rootless configuration for nodes running under this machine pool.",
+)
+def create_machine_pool(name: str, enable_rootless_dataplane_config: bool) -> None:
+    machine_pool_controller = MachinePoolController()
+    output = machine_pool_controller.create_machine_pool(
+        machine_pool_name=name,
+        enable_rootless_dataplane_config=enable_rootless_dataplane_config,
+    )
+    print(
+        f"Machine pool {output.machine_pool.machine_pool_name} has been created successfully (ID {output.machine_pool.machine_pool_id})."
+    )
+
+
+@machine_pool_cli.command(
+    name="update",
+    help="Update a machine pool in Anyscale.",
+    cls=AnyscaleCommand,
+    example=command_examples.MACHINE_POOL_UPDATE_EXAMPLE,
+    is_beta=True,
+)
+@click.option("--name", type=str, required=True, help="Provide a machine pool name.")
+@click.option(
+    "--spec-file",
+    type=str,
+    required=True,
+    help="Provide a path to a specification file.",
+)
+def update_machine_pool(name: str, spec_file: str) -> None:
+    machine_pool_controller = MachinePoolController()
+    machine_pool_controller.update_machine_pool(
+        machine_pool_name=name, spec_file=spec_file
+    )
+    print(f"Updated machine pool '{name}'.")
+
+
+@machine_pool_cli.command(
+    name="delete",
+    help="Delete a machine pool in Anyscale.",
+    cls=AnyscaleCommand,
+    example=command_examples.MACHINE_POOL_DELETE_EXAMPLE,
+    is_beta=True,
+)
+@click.option("--name", type=str, required=True, help="Provide a machine pool name.")
+def delete_machine_pool(name: str) -> None:
+    machine_pool_controller = MachinePoolController()
+    machine_pool_controller.delete_machine_pool(machine_pool_name=name)
+    print(f"Deleted machine pool '{name}'.")
+
+
+@machine_pool_cli.command(
+    name="list",
+    help="List machine pools in Anyscale.",
+    cls=AnyscaleCommand,
+    example=command_examples.MACHINE_POOL_LIST_EXAMPLE,
+    is_beta=True,
+)
+@click.option(
+    "--format",
+    "format_",
+    type=str,
+    default="table",
+    required=False,
+    help="Output format (table, yaml).",
+)
+def list_machine_pools(format_: str) -> None:
+    machine_pool_controller = MachinePoolController()
+    result = machine_pool_controller.list_machine_pools()
+
+    if format_ == "table":
+        table = []
+        columns = [
+            "MACHINE POOL",
+            "ID",
+            "Clouds",
+            "Rootless",
+        ]
+        for mp in result.machine_pools:
+            table.append(
+                [
+                    mp.machine_pool_name,
+                    mp.machine_pool_id,
+                    "\n".join(mp.cloud_ids),
+                    mp.enable_rootless_dataplane_config,
+                ]
+            )
+        print(
+            tabulate.tabulate(table, tablefmt="plain", headers=columns, stralign="left")
+        )
+    elif format_ == "yaml":
+        rows = []
+        for mp in result.machine_pools:
+            rows.append(
+                {
+                    "machine_pool_name": mp.machine_pool_name,
+                    "machine_pool_id": mp.machine_pool_id,
+                    "cloud_ids": mp.cloud_ids,
+                    "enable_rootless_dataplane_config": mp.enable_rootless_dataplane_config,
+                    "spec": mp.spec,
+                }
+            )
+        print(yaml.dump(data=rows, width=float("inf")))  # type: ignore
+    else:
+        raise click.ClickException(f"Invalid output format '{format}'.")
+
+
+@machine_pool_cli.command(name="attach", help="Attach a machine pool to a cloud.")
+@click.option("--name", type=str, required=True, help="Provide a machine pool name.")
+@click.option("--cloud", type=str, required=True, help="Provide a cloud name.")
+def attach_machine_pool_to_cloud(name: str, cloud: str) -> None:
+    machine_pool_controller = MachinePoolController()
+    machine_pool_controller.attach_machine_pool_to_cloud(
+        machine_pool_name=name, cloud=cloud
+    )
+    print(f"Attached machine pool '{name}' to cloud '{cloud}'.")
+
+
+@machine_pool_cli.command(name="detach", help="Detach a machine pool from a cloud.")
+@click.option("--name", type=str, required=True, help="Provide a machine pool name.")
+@click.option("--cloud", type=str, required=True, help="Provide a cloud name.")
+def detach_machine_pool_from_cloud(name: str, cloud: str) -> None:
+    machine_pool_controller = MachinePoolController()
+    machine_pool_controller.detach_machine_pool_from_cloud(
+        machine_pool_name=name, cloud=cloud
+    )
+    print(f"Detached machine pool '{name}' from cloud '{cloud}'.")

anyscale/commands/migrate_commands.py

@@ -0,0 +1,84 @@
+import os
+from typing import IO, Optional
+
+import click
+import yaml
+from yaml.loader import SafeLoader
+
+from anyscale.controllers.config_controller import ConfigController
+from anyscale.util import generate_slug
+
+
+@click.group(
+    "migrate",
+    help=(
+        "Manages configurations such as cluster environments and compute configs "
+        "that help you run jobs and clusters on Anyscale."
+    ),
+)
+def migrate_cli() -> None:
+    pass
+
+
+@migrate_cli.command(
+    name="convert",
+    help="Converts a Ray cluster YAML into a cluster environment and compute config.",
+)
+@click.argument("cluster-yaml-file", type=click.File("rb"), required=True)
+@click.option("--cloud", help="Cloud to create compute_config for.", required=False)
+@click.option(
+    "--ml/--no-ml",
+    is_flag=True,
+    default=False,
+    prompt="Need ML base image?",
+    help="Whether to generate a cluster-env that contains ray-ml dependencies",
+)
+@click.option(
+    "--gpu/--no-gpu",
+    is_flag=True,
+    default=False,
+    prompt="Need GPU base image?",
+    help="Whether to generate a cluster-env that contains the required dependencies to utilize a gpu",
+)
+def config_convert(
+    cluster_yaml_file: IO[bytes], cloud: Optional[str], ml: bool, gpu: bool
+) -> None:
+    cluster_yaml = yaml.load(cluster_yaml_file, Loader=SafeLoader)
+    cluster_env, compute_config = ConfigController().convert_cluster_yaml(
+        cloud, cluster_yaml, ml, gpu
+    )
+    with open("cluster-env.yaml", "w") as f:
+        yaml.safe_dump(cluster_env.to_dict(), f)
+    folder_name = os.path.basename(os.getcwd())
+    configs_generated_name = f"{folder_name}-{generate_slug()}"
+    with open("compute-config.yaml", "w") as f:
+        yaml.safe_dump(compute_config.to_dict(), f)
+    print(
+        "\ncluster-env.yaml and compute-config.yaml generated. Modify the either configs if desired "
+        "(note any warnings from above) and then run the following to save the configs to the server:\n\n"
+        f"anyscale config upload-configs cluster-env.yaml compute-config.yaml --name {configs_generated_name}"
+    )
+
+
+@migrate_cli.command(
+    name="upload-configs", help="Uploads both the cluster-env and compute-config.",
+)
+@click.argument("cluster-env-yaml-file", type=click.File("rb"), required=True)
+@click.argument("compute-config-yaml-file", type=click.File("rb"), required=True)
+@click.option(
+    "--name", "-n", help="Name for both configs", required=True,
+)
+def upload_configs(
+    cluster_env_yaml_file: IO[bytes], compute_config_yaml_file: IO[bytes], name: str
+) -> None:
+    cluster_env_yaml = yaml.load(cluster_env_yaml_file, Loader=SafeLoader)
+    compute_config = yaml.load(compute_config_yaml_file, Loader=SafeLoader)
+    ConfigController().create_cluster_env(name, cluster_env_yaml)
+    ConfigController().create_compute_config(name, compute_config, False)
+    print(
+        "Cluster environment and compute config successfully created! To use these configs, either:\n"
+        "1. specify it as an argument in your ray address like so: "
+        f'RAY_ADDRESS="anyscale://?cluster_env={name}:1&cluster_compute={name}"\n'
+        "2. specify it as an argument in your ray.init like so: "
+        f'ray.init(address="anyscale://", cluster_env={name}:1, cluster_compute={name})'
+    )