xpk 0.0.1__py3-none-any.whl

xpk/templates/__init__.py

@@ -0,0 +1,15 @@
+"""
+Copyright 2023 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.
+"""

xpk/templates/storage.yaml

@@ -0,0 +1,13 @@
+apiVersion: xpk.x-k8s.io/v1
+kind: Storage
+metadata:
+  name: $NAME
+spec:
+  auto_mount:
+  cluster:
+  manifest:
+  mount_point:
+  readonly:
+  type: $NAME
+  pvc:
+  pv:

xpk/utils/__init__.py

@@ -0,0 +1,15 @@
+"""
+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.
+"""

xpk/utils/console.py

@@ -0,0 +1,55 @@
+"""
+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 sys
+
+
+def xpk_print(*args, **kwargs):
+  """Helper function to print a prefix before function provided args.
+
+  Args:
+    *args: user provided print args.
+    **kwargs: user provided print args.
+  """
+  sys.stdout.write('[XPK] ')
+  print(*args, **kwargs)
+  sys.stdout.flush()
+
+
+def xpk_exit(error_code):
+  """Helper function to exit xpk with an associated error code.
+
+  Args:
+    error_code: If the code provided is zero, then no issues occurred.
+  """
+  if error_code == 0:
+    xpk_print('Exiting XPK cleanly')
+    sys.exit(0)
+  else:
+    xpk_print(f'XPK failed, error code {error_code}')
+    sys.exit(error_code)
+
+
+def get_user_input(input_msg):
+  """Function to get the user input for a prompt.
+
+  Args:
+    input_msg: message to be displayed by the prompt.
+  Returns:
+    True if user enter y or yes at the prompt, False otherwise.
+  """
+  user_input = input(input_msg)
+  return user_input in ('y', 'yes')

xpk/utils/file.py

@@ -0,0 +1,82 @@
+"""
+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 tempfile
+import os
+from .console import xpk_print
+
+
+def make_tmp_files(per_command_name):
+  """Make temporary files for each command.
+
+  Args:
+    per_command_name: list of command names.
+
+  Returns:
+    A list of temporary files for each command.
+  """
+  # Supports removal of spaces from command names before converting to file name.
+  return [
+      tempfile.NamedTemporaryFile(
+          delete=False, prefix=command.replace(' ', '-') + '-'
+      )
+      for command in per_command_name
+  ]
+
+
+def write_tmp_file(payload):
+  """Writes `payload` to a temporary file.
+
+  Args:
+    payload: The string to be written to the file.
+
+  Returns:
+    A file object that was written to.
+  """
+  with tempfile.NamedTemporaryFile(delete=False) as tmp:
+    with open(file=tmp.name, mode='w', encoding='utf=8') as f:
+      f.write(payload)
+      f.flush()
+    return tmp
+
+
+def append_tmp_file(payload, file):
+  """Appends `payload` to an already created file.
+
+  Use `write_temporary_file` to create a file.
+
+  Args:
+    payload: The string to be written to the file.
+    file: The file to append to.
+
+  Returns:
+    A file object that was written to.
+  """
+  with open(file=file.name, mode='a', encoding='utf=8') as f:
+    f.write(payload)
+    f.flush()
+  return file
+
+
+def ensure_directory_exists(directory_path):
+  """Checks if a directory exists and creates it if it doesn't.
+
+  Args:
+    directory_path: The path to the directory.
+  """
+  if not os.path.exists(directory_path):
+    os.makedirs(directory_path)
+    xpk_print(f"Directory '{directory_path}' created successfully.")

xpk/utils/gcs_utils.py

@@ -0,0 +1,125 @@
+"""
+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 pathlib import Path
+
+from google.cloud.storage import transfer_manager, Client
+from .console import xpk_print
+
+
+def upload_file_to_gcs(
+    storage_client: Client, bucket_name: str, bucket_path: str, file: str
+):
+  bucket = storage_client.bucket(bucket_name)
+  blob = bucket.blob(bucket_path)
+  blob.upload_from_filename(file)
+
+
+def upload_directory_to_gcs(
+    storage_client: Client,
+    bucket_name: str,
+    bucket_path: str,
+    source_directory: str,
+    workers: int = 8,
+):
+  """Upload every file in a directory, including all files in subdirectories.
+
+  Each blob name is derived from the filename, not including the `directory`
+  parameter itself. For complete control of the blob name for each file (and
+  other aspects of individual blob metadata), use
+  transfer_manager.upload_many() instead.
+  """
+  xpk_print(f"Uploading directory {source_directory} to bucket {bucket_name}")
+  bucket = storage_client.bucket(bucket_name)
+
+  directory_as_path_obj = Path(source_directory)
+  paths = directory_as_path_obj.rglob("*")
+
+  # Filter so the list only includes files, not directories themselves.
+  file_paths = [path for path in paths if path.is_file()]
+
+  # These paths are relative to the current working directory. Next, make them
+  # relative to `directory`
+  relative_paths = [path.relative_to(source_directory) for path in file_paths]
+
+  # Finally, convert them all to strings.
+  string_paths = [str(path) for path in relative_paths]
+
+  xpk_print(f"Found {len(string_paths)} files.")
+  # Start the upload.
+  results = transfer_manager.upload_many_from_filenames(
+      bucket=bucket,
+      filenames=string_paths,
+      source_directory=source_directory,
+      max_workers=workers,
+      blob_name_prefix=bucket_path,
+  )
+
+  for name, result in zip(string_paths, results):
+    # The results list is either `None` or an exception for each filename in
+    # the input list, in order.
+
+    if isinstance(result, Exception):
+      xpk_print(f"Failed to upload {name} due to exception: {result}")
+    else:
+      xpk_print(f"Uploaded {name} to {bucket.name}.")
+
+
+def check_file_exists(
+    storage_client: Client, bucket_name: str, filename: str
+) -> bool:
+  xpk_print(f"Checking if file {filename} exists in bucket: {bucket_name}")
+  bucket = storage_client.get_bucket(bucket_name)
+  is_file: bool = bucket.blob(filename).exists()
+  return is_file
+
+
+def download_bucket_to_dir(
+    storage_client: Client,
+    bucket_name: str,
+    bucket_path: str,
+    destination_directory: str = "",
+    workers: int = 8,
+    max_results: int = 1000,
+):
+  """Download all of the blobs in a bucket, concurrently in a process pool.
+
+  The filename of each blob once downloaded is derived from the blob name and
+  the `destination_directory `parameter. For complete control of the filename
+  of each blob, use transfer_manager.download_many() instead.
+
+  Directories will be created automatically as needed, for instance to
+  accommodate blob names that include slashes.
+  """
+  bucket = storage_client.bucket(bucket_name)
+
+  blob_names = [
+      blob.name
+      for blob in bucket.list_blobs(max_results=max_results, prefix=bucket_path)
+  ]
+
+  results = transfer_manager.download_many_to_path(
+      bucket,
+      blob_names,
+      destination_directory=destination_directory,
+      max_workers=workers,
+  )
+
+  for name, result in zip(blob_names, results):
+    if isinstance(result, Exception):
+      xpk_print(f"Failed to download {name} due to exception: {result}")
+    else:
+      xpk_print(f"Downloaded {name} to {destination_directory + name}.")

xpk/utils/kubectl.py

@@ -0,0 +1,57 @@
+"""
+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 kubernetes.client.exceptions import ApiException
+from kubernetes.dynamic import DynamicClient
+
+from .console import xpk_print
+
+
+def apply_kubectl_manifest(client, manifest):
+  xpk_print('Applying manifest')
+  dynamic_client = DynamicClient(client)
+
+  for obj in manifest:
+    api_version = obj['apiVersion']
+    kind = obj['kind']
+    namespace = obj.get('metadata', {}).get('namespace', 'default')
+
+    api_resource = dynamic_client.resources.get(
+        api_version=api_version, kind=kind
+    )
+
+    try:
+      api_resource.get(name=obj['metadata']['name'], namespace=namespace)
+      api_resource.patch(
+          body=obj,
+          namespace=namespace,
+          name=obj['metadata']['name'],
+          content_type='application/merge-patch+json',
+      )
+      xpk_print(
+          f"Updated {kind} '{obj['metadata']['name']}' in namespace"
+          f" '{namespace}'"
+      )
+
+    except ApiException as e:
+      if e.status == 404:
+        api_resource.create(body=obj, namespace=namespace)
+        xpk_print(
+            f"Applied {kind} '{obj['metadata']['name']}' in namespace"
+            f" '{namespace}'"
+        )
+      else:
+        xpk_print(f'Error applying {kind}: {e}')

xpk/utils/network.py

@@ -0,0 +1,168 @@
+"""
+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 ipaddress
+import socket
+import requests
+from .console import xpk_print
+
+# Retrives machine's external IP address
+ip_resolver_url = "http://api.ipify.org"
+all_IPs_cidr = "0.0.0.0/0"
+
+
+def get_current_machine_ip(external_ip=True):
+  """
+  Gets the IP address of the current machine.
+
+  Args:
+    external: If True (default), retrieves the external IP address.
+              If False, retrieves the internal IP address.
+
+  Returns:
+    The IP address as a string.
+  """
+
+  try:
+    if external_ip:
+      # Get external IP address
+      response = requests.get(ip_resolver_url, timeout=30)
+      return 0, response.text
+    else:
+      # Get internal IP address
+      hostname = socket.gethostname()
+      return 0, socket.gethostbyname(hostname)
+  except (requests.exceptions.RequestException, socket.gaierror) as e:
+    xpk_print(f"Error getting IP address: {e}")
+    return 1, None
+
+
+def is_ip_in_any_network(ip_address, cidrs):
+  """
+  Checks if an IP address is within any of the provided CIDR ranges.
+
+  Args:
+    ip_address: The IP address to check (as a string).
+    cidrs: A list of CIDR strings.
+
+  Returns:
+    True if the IP address is found in any of the CIDRs, False otherwise.
+  """
+
+  try:
+    if not are_cidrs_valid(cidrs):
+      return False
+
+    if cidrs is None:
+      return False
+
+    current_ip = ipaddress.ip_address(ip_address)
+    for cidr in cidrs:
+      network = ipaddress.ip_network(cidr)
+      if current_ip in network:
+        return True
+  except ValueError as e:
+    xpk_print(f"Error: {e}")
+    return False
+  return False
+
+
+def is_current_machine_in_any_network(cidrs, external_ip=True):
+  """
+  Checks if the current machine's IP address is within any of the provided CIDR ranges.
+
+  Args:
+    cidrs: A list of CIDR strings.
+    external_ip: If True (default), checks the external IP. If False, checks the internal IP.
+
+  Returns:
+    True if the IP address is found in any of the CIDRs, False otherwise.
+  """
+  if not are_cidrs_valid(cidrs):
+    return 1, False
+
+  if cidrs is None:
+    return 0, False
+
+  return_code, ip_address = get_current_machine_ip(external_ip)
+  if return_code > 0:
+    return return_code, False
+  else:
+    return return_code, is_ip_in_any_network(ip_address, cidrs)
+
+
+def add_current_machine_to_networks(cidrs, external_ip=True):
+  """
+  Adds the current machine's IP address to the list of CIDRs if it's not already present.
+
+  Args:
+    cidrs: A list of CIDR strings.
+    external_ip: If True, uses the external IP. If False (default), uses the internal IP.
+
+  Returns:
+    The updated list of CIDRs with the current machine's IP added (if necessary).
+  """
+  if not are_cidrs_valid(cidrs):
+    return 1, None
+
+  return_code, ip_address = get_current_machine_ip(external_ip)
+  if return_code > 0:
+    return return_code, None
+
+  if not is_ip_in_any_network(ip_address, cidrs):
+    cidrs.append(f"{ip_address}/32")
+
+  return 0, cidrs
+
+
+def is_cidr_valid(cidr):
+  """
+  Validates a CIDR string.
+
+  Args:
+    cidr: The CIDR string to validate.
+
+  Returns:
+    True if the CIDR string is valid, False otherwise.
+  """
+  try:
+    ipaddress.ip_network(cidr)
+    return True
+  except ValueError:
+    return False
+
+
+def are_cidrs_valid(cidrs):
+  """
+  Validates a list of CIDR strings.
+
+  Args:
+    cidrs: A list of CIDR strings to validate.
+
+  Returns:
+    True if all CIDR strings in the list are valid, False otherwise.
+  """
+  if cidrs is None:
+    return True
+
+  all_cidrs_are_valid = True
+
+  for cidr in cidrs:
+    if not is_cidr_valid(cidr):
+      all_cidrs_are_valid = False
+      xpk_print(f"Error: the string '{cidr}' is not a valid CIDR.")
+
+  return all_cidrs_are_valid

xpk/utils/objects.py

@@ -0,0 +1,88 @@
+"""
+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 hashlib
+from .console import xpk_print
+
+
+def chunks(lst: list, n: int):
+  """Return a list of n-sized chunks from lst.
+
+  Args:
+    lst: input list to get chunks from.
+    n: size of each chunk.
+
+  Returns:
+    List of n-sized chunks for lst.
+  """
+  return [lst[i : i + n] for i in range(0, len(lst), n)]
+
+
+def get_value_from_map(
+    key: str, map_to_search: dict, verbose: bool = True
+) -> tuple[int, str | None]:
+  """Helper function to get value from a map if the key exists.
+
+  Args:
+    key: The key to look for in the map
+    map_to_search: The map to look in for the value
+
+  Returns:
+    Tuple of int, str where
+    int is the return code
+    str is the value if found
+  """
+  value = map_to_search.get(key)
+  if value:
+    return 0, value
+  else:
+    if verbose:
+      xpk_print(
+          f'Unable to find key: {key} in map: {map_to_search}.'
+          f'The map has the following keys: {map_to_search.keys()}'
+      )
+    return 1, value
+
+
+def is_text_true(text: str) -> bool:
+  return text.strip().lower() == 'true'
+
+
+def hash_string(input_string: str, length: int | None = None):
+  """
+  Generates a hash of a string using characters 0-9 and a-z.
+
+  Args:
+    input_string: The string to hash.
+    length: The desired length of the hash (optional).
+            If not provided, or less than 0, the full SHA256 hash is returned.
+
+  Returns:
+    A hash string of the specified length or the full SHA256 hash,
+    using characters 0-9 and a-z.
+  """
+  hash_value = int(hashlib.sha256(input_string.encode()).hexdigest(), 16)
+
+  if length is None or length < 0:
+    length = 64  # Use the full length of the SHA256 hash
+
+  charset = '0123456789abcdefghijklmnopqrstuvwxyz'
+  result = ''
+  while hash_value > 0 and len(result) < length:
+    hash_value, index = divmod(hash_value, 36)  # Get quotient and remainder
+    result = charset[index] + result
+
+  return result.zfill(length).lower()  # Pad with zeros if necessary

xpk/utils/templates.py

@@ -0,0 +1,28 @@
+"""
+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.
+"""
+
+import os
+
+import ruamel.yaml
+
+yaml = ruamel.yaml.YAML()
+
+
+def load(path: str) -> dict:
+  template_path = os.path.dirname(__file__) + path
+  with open(template_path, "r", encoding="utf-8") as file:
+    data: dict = yaml.load(file)
+  return data