xpk 0.0.1__py3-none-any.whl

xpk/parser/job.py

@@ -0,0 +1,147 @@
+"""
+Copyright 2024 Google LLC
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+     https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+import argparse
+from ..commands.job import job_info, job_list, job_cancel
+
+from .common import add_shared_arguments
+from .validators import name_type
+
+
+def set_job_parser(job_parser: argparse.ArgumentParser):
+  job_subcommands = job_parser.add_subparsers(
+      title='job subcommands',
+      dest='xpk_job_subcommands',
+      help=(
+          'These are commands related to job management. Look at help for'
+          ' specific subcommands for more details.'
+      ),
+  )
+  set_job_info_parser(
+      job_info_parser=job_subcommands.add_parser(
+          'info', help='Show information about specified job.'
+      )
+  )
+  set_job_list_parser(
+      job_list_parser=job_subcommands.add_parser('ls', help='List jobs.')
+  )
+  set_job_cancel_parser(
+      job_cancel_parser=job_subcommands.add_parser(
+          'cancel', help='Cancel job execution.'
+      )
+  )
+
+
+def set_job_info_parser(job_info_parser: argparse.ArgumentParser):
+  job_info_required_arguments = job_info_parser.add_argument_group(
+      'Required arguments',
+      'The basic information required to identify the job.',
+  )
+  job_info_optional_arguments = job_info_parser.add_argument_group(
+      'Optional Arguments', 'Arguments optional for job info.'
+  )
+
+  ### Required arguments
+  job_info_required_arguments.add_argument(
+      '--cluster',
+      type=name_type,
+      default=None,
+      help='The name of the cluster to info jobs on.',
+      required=True,
+  )
+
+  job_info_optional_arguments.add_argument(
+      '--kind-cluster',
+      type=bool,
+      action=argparse.BooleanOptionalAction,
+      default=False,
+      help='Apply command to a local test cluster.',
+  )
+  job_info_required_arguments.add_argument(
+      'name',
+      type=str,
+      default=None,
+      help='Name of the job.',
+  )
+  job_info_parser.set_defaults(func=job_info)
+  add_shared_arguments(job_info_parser)
+
+
+def set_job_list_parser(job_list_parser: argparse.ArgumentParser):
+  job_list_required_arguments = job_list_parser.add_argument_group(
+      'Required Arguments',
+      'Arguments required for job list.',
+  )
+  job_list_optional_arguments = job_list_parser.add_argument_group(
+      'Optional Arguments', 'Arguments optional for job list.'
+  )
+
+  ### Required arguments
+  job_list_required_arguments.add_argument(
+      '--cluster',
+      type=name_type,
+      default=None,
+      help='The name of the cluster to list jobs on.',
+      required=True,
+  )
+
+  job_list_optional_arguments.add_argument(
+      '--kind-cluster',
+      type=bool,
+      action=argparse.BooleanOptionalAction,
+      default=False,
+      help='Apply command to a local test cluster.',
+  )
+
+  job_list_parser.set_defaults(func=job_list)
+  add_shared_arguments(job_list_optional_arguments)
+
+
+def set_job_cancel_parser(job_cancel_parser: argparse.ArgumentParser):
+  job_cancel_required_arguments = job_cancel_parser.add_argument_group(
+      'Required Arguments',
+      'Arguments required for job cancel.',
+  )
+  job_cancel_optional_arguments = job_cancel_parser.add_argument_group(
+      'Optional Arguments', 'Arguments optional for job cancel.'
+  )
+
+  job_cancel_required_arguments.add_argument(
+      'name',
+      type=str,
+      default=None,
+      help='The name of the job to be cancelled.',
+      nargs='+',
+  )
+
+  job_cancel_required_arguments.add_argument(
+      '--cluster',
+      type=name_type,
+      default=None,
+      help='The name of the cluster to delete the job on.',
+      required=True,
+  )
+
+  job_cancel_optional_arguments.add_argument(
+      '--kind-cluster',
+      type=bool,
+      action=argparse.BooleanOptionalAction,
+      default=False,
+      help='Apply command to a local test cluster.',
+  )
+
+  job_cancel_parser.set_defaults(func=job_cancel)
+  add_shared_arguments(job_cancel_optional_arguments)

xpk/parser/kind.py

@@ -0,0 +1,95 @@
+"""
+Copyright 2024 Google LLC
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+     https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+from ..commands.kind import (
+    cluster_create,
+    cluster_delete,
+    cluster_list,
+)
+from .common import add_global_arguments
+from .validators import name_type
+
+
+def set_kind_parser(kind_parser):
+  cluster_subcommands = kind_parser.add_subparsers(
+      title='kind subcommands',
+      dest='xpk_kind_subcommands',
+      help=(
+          'These are commands related to kind management. Look at help for'
+          ' specific subcommands for more details.'
+      ),
+  )
+
+  ### "cluster create" command parser ###
+  cluster_create_parser = cluster_subcommands.add_parser(
+      'create', help='Create local clusters.'
+  )
+
+  ### Optional Arguments
+  cluster_create_parser.add_argument(
+      '--cluster',
+      type=name_type,
+      default='kind',
+      help=(
+          'The name of the cluster. Will be used as the prefix for internal'
+          ' objects in the cluster.'
+      ),
+      required=False,
+  )
+
+  cluster_create_parser.add_argument(
+      '--k8s-version',
+      type=str,
+      default='',
+      help='The Kubernetes version of the cluster.',
+      required=False,
+  )
+
+  add_global_arguments(cluster_create_parser)
+  cluster_create_parser.set_defaults(func=cluster_create)
+
+  ### "cluster delete" command parser ###
+  cluster_delete_parser = cluster_subcommands.add_parser(
+      'delete',
+      help='Delete cloud clusters.',
+  )
+
+  cluster_delete_required_arguments = cluster_delete_parser.add_argument_group(
+      'Required Arguments',
+      'Arguments required for cluster delete.',
+  )
+
+  ### Required arguments
+  cluster_delete_required_arguments.add_argument(
+      '--cluster',
+      type=name_type,
+      default=None,
+      help='The name of the cluster to be deleted.',
+      required=True,
+  )
+
+  ### Optional Arguments
+  add_global_arguments(cluster_delete_parser)
+  cluster_delete_parser.set_defaults(func=cluster_delete)
+
+  # "cluster list" command parser.
+  cluster_list_parser = cluster_subcommands.add_parser(
+      'list', help='List cloud clusters.'
+  )
+
+  ### Optional Arguments
+  add_global_arguments(cluster_list_parser)
+  cluster_list_parser.set_defaults(func=cluster_list)

xpk/parser/run.py

@@ -0,0 +1,47 @@
+"""
+Copyright 2025 Google LLC
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+     https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+from ..commands.run import run
+from .common import (
+    add_shared_arguments,
+    add_slurm_arguments,
+    add_cluster_arguments,
+    add_kind_cluster_arguments,
+)
+
+
+def set_run_parser(run_parser):
+  run_required_arguments = run_parser.add_argument_group(
+      'Required Arguments', 'Arguments required for `run`.'
+  )
+  run_optional_arguments = run_parser.add_argument_group(
+      'Optional Arguments', 'Arguments optional for `run`.'
+  )
+
+  run_required_arguments.add_argument('script', help='script with task to run')
+  run_optional_arguments.add_argument(
+      '--timeout',
+      type=int,
+      default=None,
+      help='Amount of time to wait for job in seconds',
+      required=False,
+  )
+
+  add_cluster_arguments(run_optional_arguments)
+  add_kind_cluster_arguments(run_optional_arguments)
+  add_slurm_arguments(run_optional_arguments)
+  add_shared_arguments(run_parser)
+  run_parser.set_defaults(func=run)

xpk/parser/shell.py

@@ -0,0 +1,59 @@
+"""
+Copyright 2024 Google LLC
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+     https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+from ..commands.shell import shell, shell_stop
+from .common import (
+    add_shared_arguments,
+    add_cluster_arguments,
+    add_kind_cluster_arguments,
+)
+import argparse
+
+
+def set_shell_parser(shell_parser: argparse.ArgumentParser) -> None:
+  shell_optional_arguments = shell_parser.add_argument_group(
+      'Optional Arguments', 'Arguments optional for shell.'
+  )
+  add_shared_arguments(shell_optional_arguments)
+  shell_parser.set_defaults(func=shell)
+
+  add_cluster_arguments(shell_optional_arguments)
+  add_kind_cluster_arguments(shell_optional_arguments)
+
+  shell_subcommands = shell_parser.add_subparsers(
+      title='shell subcommands',
+      dest='xpk_shell_subcommands',
+      help=(
+          'These are commands related to interactive shell. Look at help for'
+          ' specific subcommands for more details.'
+      ),
+  )
+
+  set_shell_stop_parser(
+      shell_stop_parser=shell_subcommands.add_parser(
+          name='stop', help='Stop the running shell.'
+      )
+  )
+
+
+def set_shell_stop_parser(shell_stop_parser: argparse.ArgumentParser):
+  shell_stop_optional_arguments = shell_stop_parser.add_argument_group(
+      'Optional Arguments', 'Arguments optional for shell stop.'
+  )
+  add_shared_arguments(shell_stop_optional_arguments)
+  shell_stop_parser.set_defaults(func=shell_stop)
+  add_cluster_arguments(shell_stop_parser)
+  add_kind_cluster_arguments(shell_stop_optional_arguments)

xpk/parser/storage.py

@@ -0,0 +1,316 @@
+"""
+Copyright 2024 Google LLC
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+     https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+import argparse
+
+from ..commands.storage import (
+    storage_attach,
+    storage_create,
+    storage_delete,
+    storage_detach,
+    storage_list,
+)
+from .common import (
+    add_cluster_arguments,
+    add_kind_cluster_arguments,
+    add_shared_arguments,
+)
+
+
+def set_storage_parser(storage_parser: argparse.ArgumentParser) -> None:
+  storage_subcommands = storage_parser.add_subparsers(
+      title='storage subcommands',
+      dest='xpk_storage_subcommands',
+      help=(
+          'These are commands related to storage management. Look at help for'
+          ' specific subcommands for more details.'
+      ),
+  )
+  add_storage_attach_parser(storage_subcommands)
+  add_storage_list_parser(storage_subcommands)
+  add_storage_detach_parser(storage_subcommands)
+  add_storage_create_parser(storage_subcommands)
+  add_storage_delete_parser(storage_subcommands)
+
+
+def add_storage_attach_parser(
+    storage_subcommands_parser: argparse.ArgumentParser,
+) -> None:
+
+  storage_attach_parser: argparse.ArgumentParser = (
+      storage_subcommands_parser.add_parser(
+          'attach', help='attach XPK Storage.'
+      )
+  )
+  storage_attach_parser.set_defaults(func=storage_attach)
+  req_args = storage_attach_parser.add_argument_group(
+      'Required Arguments',
+      'Arguments required for storage attach.',
+  )
+  add_shared_arguments(req_args)
+  req_args.add_argument(
+      'name',
+      type=str,
+      help='The name of storage',
+  )
+  req_args.add_argument(
+      '--type',
+      type=str,
+      help=(
+          'The type of storage. Currently supported types: ["gcsfuse",'
+          ' "gcpfilestore"]'
+      ),
+      choices=['gcsfuse', 'gcpfilestore'],
+      required=True,
+  )
+  add_cluster_arguments(req_args, required=True)
+  req_args.add_argument(
+      '--auto-mount',
+      type=lambda v: v.lower() == 'true',
+      default=True,
+      required=True,
+      help='If true all workloads will have this storage mounted by default',
+  )
+  req_args.add_argument(
+      '--mount-point',
+      type=str,
+      required=True,
+      help='Path on which a given storage should be mounted for a workload',
+  )
+  req_args.add_argument(
+      '--readonly',
+      type=lambda v: v.lower() == 'true',
+      required=True,
+      help='If true workloads can only read from storage',
+  )
+
+  gcsfuse_args = storage_attach_parser.add_argument_group(
+      'FUSE arguments',
+      'Arguments used when --type=gcsfuse',
+  )
+  gcsfuse_args.add_argument(
+      '--size',
+      type=int,
+      help='The size of the volume to attach in gigabytes.',
+  )
+  gcsfuse_args.add_argument(
+      '--bucket',
+      type=str,
+      help=(
+          '(optional) Name of the bucket. If not set, then the "name" parameter'
+          ' is infered as a bucket name.'
+      ),
+  )
+
+  gcpfilestore_args = storage_attach_parser.add_argument_group(
+      'Filestore arguments',
+      'Arguments used when --type=gcpfilestore',
+  )
+  gcpfilestore_args.add_argument(
+      '--vol',
+      type=str,
+      help='(optional) The name of the volume to create. Default: "default"',
+      default='default',
+  )
+  gcpfilestore_args.add_argument(
+      '--access-mode',
+      type=str,
+      choices=['ReadWriteOnce', 'ReadOnlyMany', 'ReadWriteMany'],
+      help=(
+          '(optional) Access mode of created filestore instance. Default:'
+          ' "ReadWriteMany"'
+      ),
+      default='ReadWriteMany',
+  )
+  gcpfilestore_args.add_argument(
+      '--instance',
+      type=str,
+      help=(
+          '(optional) Name of the filestore instance. If not set, then the'
+          ' "name" parameter is infered as an instance name.'
+      ),
+  )
+
+  opt_args = storage_attach_parser.add_argument_group(
+      'Optional Arguments',
+      'Optional arguments for storage create.',
+  )
+  add_kind_cluster_arguments(opt_args)
+
+
+def add_storage_create_parser(
+    storage_subcommands_parser: argparse.ArgumentParser,
+) -> None:
+  storage_create_parser: argparse.ArgumentParser = (
+      storage_subcommands_parser.add_parser(
+          'create', help='create XPK Storage.'
+      )
+  )
+  storage_create_parser.set_defaults(func=storage_create)
+  req_args = storage_create_parser.add_argument_group(
+      'Required Arguments',
+      'Arguments required for storage create.',
+  )
+  add_shared_arguments(req_args)
+  req_args.add_argument(
+      'name',
+      type=str,
+      help='The name of storage',
+  )
+  req_args.add_argument(
+      '--size',
+      type=str,
+      help=(
+          'The size of the volume to create in gigabytes or terabytes. If no'
+          ' unit is specified, gigabytes are assumed.'
+      ),
+      required=True,
+  )
+
+  req_args.add_argument(
+      '--type',
+      type=str,
+      help='The type of storage. Currently supported types: ["gcpfilestore"]',
+      choices=['gcpfilestore'],
+      required=True,
+  )
+  add_cluster_arguments(req_args, required=True)
+  req_args.add_argument(
+      '--mount-point',
+      type=str,
+      required=True,
+  )
+  req_args.add_argument(
+      '--readonly', type=lambda v: v.lower() == 'true', required=True
+  )
+
+  opt_args = storage_create_parser.add_argument_group(
+      'Optional Arguments',
+      'Optional arguments for storage create.',
+  )
+  opt_args.add_argument(
+      '--instance',
+      type=str,
+      help=(
+          '(optional) Name of the filestore instance. If not set, then the'
+          ' "name" parameter is infered as an instance name.'
+      ),
+  )
+  opt_args.add_argument(
+      '--vol',
+      type=str,
+      help='The name of the volume to create',
+      required=True,
+      default='default',
+  )
+  opt_args.add_argument(
+      '--tier',
+      type=str,
+      help=(
+          'The tier of the filestore to create. Possible values are:'
+          ' [BASIC_HDD, BASIC_SSD, ZONAL, REGIONAL, ENTERPRISE]'
+      ),
+      choices=['BASIC_HDD', 'BASIC_SSD', 'ZONAL', 'REGIONAL', 'ENTERPRISE'],
+      default='REGIONAL',
+  )
+  opt_args.add_argument(
+      '--auto-mount',
+      type=lambda v: v.lower() == 'true',
+      default=True,
+  )
+  opt_args.add_argument(
+      '--access-mode',
+      type=str,
+      choices=['ReadWriteOnce', 'ReadOnlyMany', 'ReadWriteMany'],
+      help='Access mode of created filestore instance',
+      default='ReadWriteMany',
+  )
+
+  add_kind_cluster_arguments(opt_args)
+
+
+def add_storage_list_parser(
+    storage_subcommands_parser: argparse.ArgumentParser,
+):
+  storage_list_parser: argparse.ArgumentParser = (
+      storage_subcommands_parser.add_parser('list', help='List XPK Storages.')
+  )
+  storage_list_parser.set_defaults(func=storage_list)
+  add_shared_arguments(storage_list_parser)
+  req_args = storage_list_parser.add_argument_group(
+      'Required Arguments',
+      'Arguments required for storage list.',
+  )
+  req_args.add_argument(
+      '--cluster',
+      type=str,
+  )
+
+
+def add_storage_detach_parser(
+    storage_subcommands_parser: argparse.ArgumentParser,
+):
+  storage_detach_parser: argparse.ArgumentParser = (
+      storage_subcommands_parser.add_parser(
+          'detach', help='Detach XPK Storage.'
+      )
+  )
+  storage_detach_parser.set_defaults(func=storage_detach)
+  add_shared_arguments(storage_detach_parser)
+
+  req_args = storage_detach_parser.add_argument_group(
+      'Required Arguments',
+      'Arguments required for storage detach.',
+  )
+  req_args.add_argument('name', type=str)
+  add_cluster_arguments(req_args, required=True)
+
+  opt_args = storage_detach_parser.add_argument_group(
+      'Optional Arguments',
+      'Optional arguments for storage delete.',
+  )
+  add_kind_cluster_arguments(opt_args)
+
+
+def add_storage_delete_parser(
+    storage_subcommands_parser: argparse.ArgumentParser,
+):
+  storage_delete_parser: argparse.ArgumentParser = (
+      storage_subcommands_parser.add_parser(
+          'delete', help='Delete XPK Storage.'
+      )
+  )
+  storage_delete_parser.set_defaults(func=storage_delete)
+  add_shared_arguments(storage_delete_parser)
+
+  req_args = storage_delete_parser.add_argument_group(
+      'Required Arguments',
+      'Arguments required for storage delete.',
+  )
+  req_args.add_argument('name', type=str)
+  add_cluster_arguments(req_args, required=True)
+
+  opt_args = storage_delete_parser.add_argument_group(
+      'Optional Arguments',
+      'Optional arguments for storage delete.',
+  )
+  opt_args.add_argument(
+      '--force',
+      '-f',
+      action='store_true',
+      help='Force filestore instance deletion even if it has attached storages',
+  )
+  add_kind_cluster_arguments(opt_args)

xpk/parser/validators.py

@@ -0,0 +1,39 @@
+"""
+Copyright 2024 Google LLC
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+     https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+import argparse
+import os
+import re
+
+
+def name_type(value, pat=re.compile(r'[a-z]([-a-z0-9]*[a-z0-9])?')):
+  """Validate that the name matches the expected pattern."""
+  match = pat.fullmatch(value)
+  if not match or len(match.group(0)) > 40:
+    raise argparse.ArgumentTypeError(
+        'Name must be less than 40 characters and match the pattern'
+        f' `{pat.pattern}`'
+        f' Name is currently {value}'
+    )
+  return value
+
+
+def directory_path_type(value):
+  if not os.path.isdir(value):
+    raise argparse.ArgumentTypeError(
+        f'Directory path is invalid. User provided path was {value}'
+    )
+  return value