hcs-cli 0.1.337__tar.gz → 0.1.339__tar.gz

{hcs_cli-0.1.337 → hcs_cli-0.1.339}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hcs-cli
-Version: 0.1.337
+Version: 0.1.339
 Summary: Horizon Cloud Service CLI.
 Project-URL: Homepage, https://github.com/euc-eng/hcs-cli
 Project-URL: Bug Tracker, https://github.com/euc-eng/hcs-cli/issues
@@ -14,7 +14,7 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.9
-Requires-Dist: hcs-core>=0.1.337
+Requires-Dist: hcs-core>=0.1.339
 Requires-Dist: inquirerpy>=0.3.4
 Requires-Dist: matplotlib>=3.8.0
 Requires-Dist: paho-mqtt>=2.1.0

{hcs_cli-0.1.337 → hcs_cli-0.1.339}/hcs_cli/__init__.py

@@ -1,3 +1,3 @@
-__version__ = "0.1.337"
+__version__ = "0.1.339"
 
 from . import service as service  # noqa: F401

{hcs_cli-0.1.337 → hcs_cli-0.1.339}/hcs_cli/cmds/api.py

@@ -1,5 +1,6 @@
 import json
 import sys
+from typing import Optional
 
 import click
 from hcs_core.ctxp import CtxpException, profile
@@ -70,6 +71,18 @@ def _handle_data_input(data_arg, json_arg):
     return raw_data, json_data
 
 
+def _build_headers(header: list, content_type: Optional[str]) -> Optional[dict]:
+    headers: dict[str, str] = {}
+    for h in header:
+        name, sep, value = h.partition(":")
+        if not sep:
+            raise click.UsageError(f"Invalid header format (expected 'Header-Name: value'): {h!r}")
+        headers[name.strip()] = value.strip()
+    if content_type:
+        headers["Content-Type"] = content_type
+    return headers or None
+
+
 @click.command()
 @click.option("--put", is_flag=True, default=False, help="Perform HTTP PUT.")
 @click.option("--post", "-p", is_flag=True, default=False, help="Perform HTTP POST.")
@@ -149,10 +162,7 @@ def api(
     else:
         handler = hcs_api
 
-    if header:
-        headers = {h.split(":")[0].strip(): h.split(":")[1].strip() for h in header}
-    else:
-        headers = None
+    headers = _build_headers(header, content_type)
 
     # print( f"{method} {api_path} text={raw_data} json={json_data}" )
 

{hcs_cli-0.1.337 → hcs_cli-0.1.339}/hcs_cli/cmds/debug/start.py

@@ -96,9 +96,37 @@ def _push_jar_to_pod(service: str, pod_id: str):
     jar_files = _get_jar_files_with_keyword("target/", service)
     print("Jar file fetched: ", jar_files)
     jar_file = jar_files[0]
-    push_image_command = f"cat target/{jar_file} | kubectl exec -i {pod_id} -c app -- sh -c 'cat > /app.jar'"
-    print(f"Start pushing {jar_file} to k8s pod {pod_id} ")
-    subprocess.run(push_image_command, capture_output=True, check=True, text=True, shell=True)
+    jar_path = f"target/{jar_file}"
+
+    # Get file size for progress bar
+    file_size = os.path.getsize(jar_path)
+    file_size_mb = file_size / (1024 * 1024)
+
+    print(f"Start pushing {jar_file} ({file_size_mb:.1f} MB) to k8s pod {pod_id}")
+
+    # Start kubectl exec process
+    kubectl_cmd = f"kubectl exec -i {pod_id} -c app -- sh -c 'cat > /app.jar'"
+    process = subprocess.Popen(kubectl_cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
+
+    # Stream file with progress bar
+    chunk_size = 1024 * 1024  # 1MB chunks
+    with open(jar_path, "rb") as f:
+        with click.progressbar(length=file_size, label="Uploading", show_eta=True, show_percent=True) as bar:
+            while True:
+                chunk = f.read(chunk_size)
+                if not chunk:
+                    break
+                process.stdin.write(chunk)
+                bar.update(len(chunk))
+
+    # Close stdin and wait for completion
+    process.stdin.close()
+    process.wait()
+
+    if process.returncode != 0:
+        stderr = process.stderr.read().decode("utf-8")
+        raise Exception(f"Failed to push jar: {stderr}")
+
     print("Push success, starting app.jar")
 
 

{hcs_cli-0.1.337 → hcs_cli-0.1.339}/hcs_cli/cmds/dev/fs/clear.py

@@ -7,7 +7,7 @@ import click
 
 import hcs_cli.cmds.dev.util.log as log
 from hcs_cli.cmds.dev.fs.helper.util import validate_fs_kubeconfig, validate_fs_profile
-from hcs_cli.cmds.dev.fs.init import _resolve_bundled_file_path
+from hcs_cli.cmds.dev.fs.helper.init_steps import resolve_bundled_file_path
 from hcs_cli.support.exec_util import run_cli
 from hcs_core.ctxp import profile
 
@@ -34,9 +34,9 @@ def clear(only_default: bool, **kwargs):
         _delete_all()
 
     os.environ["ORG_ID"] = profile.current().csp.orgId
-    akka_plan_path = _resolve_bundled_file_path("provided_files/akka.plan.yml")
-    azure_plan_path = _resolve_bundled_file_path("provided_files/azure.plan.yml")
-    azsim_plan_path = _resolve_bundled_file_path("provided_files/azsim.plan.yml")
+    akka_plan_path = resolve_bundled_file_path("provided_files/akka.plan.yml")
+    azure_plan_path = resolve_bundled_file_path("provided_files/azure.plan.yml")
+    azsim_plan_path = resolve_bundled_file_path("provided_files/azsim.plan.yml")
     run_cli("hcs plan destroy -f " + akka_plan_path, raise_on_error=False)
     run_cli("hcs plan destroy -f " + azure_plan_path, raise_on_error=False)
     run_cli("hcs plan destroy -f " + azsim_plan_path, raise_on_error=False)

hcs_cli-0.1.339/hcs_cli/cmds/dev/fs/helper/config.py

@@ -0,0 +1,291 @@
+"""
+Feature stack .env config: resolve, generate, and load.
+
+Handles three sources:
+  1. Local .env in cwd
+  2. Generate from nightly-tests repo (includes ORG_ID)
+  3. User-specified file path
+
+Public API:
+  - resolve(env_source, env_file, org_source_key, org_source_value) — CLI/programmatic
+  - resolve_interactive(org_source_key, org_source_value) — interactive prompt
+  - FS_CUSTOMER_ORG_ID — default org for nightly mode
+"""
+
+import os
+import re
+from collections import OrderedDict, defaultdict
+from pathlib import Path
+from typing import Optional
+
+from dotenv import load_dotenv
+from InquirerPy import inquirer
+from InquirerPy.base import Choice
+from prompt_toolkit import prompt
+from prompt_toolkit.completion import PathCompleter
+
+import hcs_cli.cmds.dev.util.github_helper as github_helper
+from hcs_cli.cmds.dev.util import log
+from hcs_cli.cmds.dev.util.log import fail
+
+FS_CUSTOMER_ORG_ID = "517419ab-9bf6-4dde-95ca-1916c6600a40"
+
+
+def resolve(env_source: Optional[str], env_file: Optional[str], org_source_key: str, org_source_value: str):
+    """Resolve and load .env from CLI params. Falls back to interactive if neither specified."""
+    if env_file:
+        os.environ.pop(org_source_key, None)
+        env_path = _from_user_path(env_file)
+    elif env_source == "nightly":
+        os.environ[org_source_key] = org_source_value
+        customer_org = _resolve_customer_org()
+        env_path = _from_nightly_repo(customer_org)
+    elif env_source == "local":
+        os.environ.pop(org_source_key, None)
+        env_path = _from_local()
+    else:
+        env_path = resolve_interactive(org_source_key, org_source_value)
+
+    _load_env_file(env_path)
+
+
+def resolve_interactive(org_source_key: str, org_source_value: str) -> str:
+    """Interactive prompt for env source. Returns resolved path (does NOT load)."""
+    has_local_env = os.path.isfile(".env")
+    choices = []
+    if has_local_env:
+        choices.append(Choice(value="local", enabled=True, name="Load local .env file"))
+
+    choices += [
+        Choice(value="nightly", enabled=True, name="Auto configure from nightly test"),
+        Choice(value="user_specified", enabled=True, name="User provided env file"),
+    ]
+
+    env_choice = inquirer.select(
+        message="Choose how to load your .env file:",
+        choices=choices,
+        instruction="(Use SPACE to toggle, ENTER to confirm)",
+    ).execute()
+
+    if env_choice == "nightly":
+        os.environ[org_source_key] = org_source_value
+        customer_org = _resolve_customer_org()
+        return _from_nightly_repo(customer_org)
+    elif env_choice == "user_specified":
+        os.environ.pop(org_source_key, None)
+        completer = PathCompleter(expanduser=True)
+        env_path_input = prompt("Enter the full path to your .env file: ", completer=completer, default="~/")
+        return _from_user_path(env_path_input)
+    else:
+        os.environ.pop(org_source_key, None)
+        return _from_local()
+
+
+# --- helpers ---
+
+
+def _resolve_customer_org() -> str:
+    """Return customer org ID: from env if set, otherwise prompt with default."""
+    org = os.getenv("ORG_ID")
+    if org:
+        log.info(f"Target customer ORG_ID={org}")
+        return org
+    org = prompt("Enter target ORG_ID: ", default=FS_CUSTOMER_ORG_ID).strip()
+    os.environ["ORG_ID"] = org
+    log.info(f"Target customer ORG_ID={org}")
+    return org
+
+
+# --- source resolvers ---
+
+
+def _from_nightly_repo(customer_org: str) -> str:
+    output_env_file = ".env"
+
+    github_helper.check_ssh_access()
+    with github_helper.repo("git@github.com:euc-eng/horizonv2-sg.nightly-tests.git") as repo:
+        config_data = repo.get("src/test/resources/com/vmware/integration/sg/payloads/onboard/configuration.txt", format="json")
+        config_props = repo.get("src/test/resources/config.properties")
+
+    _write_env_file(config_data, config_props, output_env_file)
+    with open(output_env_file, "a") as f:
+        f.write(f"\nORG_ID={customer_org}\n")
+    _organize_env_file(output_env_file)
+
+    log.good(f".env file created at: {Path(output_env_file).resolve()}")
+    return str(Path(output_env_file).resolve())
+
+
+def _from_local() -> str:
+    return os.path.abspath(".env")
+
+
+def _from_user_path(path: str) -> str:
+    return str(Path(path).expanduser().resolve())
+
+
+# --- loader ---
+
+
+def _load_env_file(env_path: str):
+    env_path = os.path.expanduser(str(env_path))
+    if not _is_valid_env_file(env_path):
+        fail(f"Could not find .env file at {env_path}. Please ensure it follows the template format.")
+    load_dotenv(env_path, override=True)
+    log.good(f"Loaded environment file from {os.path.abspath(env_path)}")
+
+
+def _is_valid_env_file(path):
+    if not os.path.isfile(path):
+        return False
+    if not os.path.basename(path).startswith(".env"):
+        return False
+    try:
+        with open(path, "r") as f:
+            for line in f:
+                if line.strip() == "" or line.strip().startswith("#"):
+                    continue
+                if "=" not in line:
+                    return False
+        return True
+    except Exception:
+        return False
+
+
+# --- env file generation helpers ---
+
+
+def _write_env_file(data, props, env_file):
+    ignore_keys = {
+        "aksUserIdentity",
+        "adServerEndpoint",
+        "signingCaName",
+        "caHostName",
+        "siteName",
+        "domainUser",
+        "domainPassword",
+        "virtualNetwork",
+    }
+    ad_username = data.get("domainUser")
+    ad_password = data.get("domainPassword")
+
+    with open(env_file, "w") as f:
+        for key, value in data.items():
+            if key not in ignore_keys:
+                f.write(f"{_to_env_key(key)}={value}\n")
+        config_block = f"""HCS_CLIENT_ID={props["csp.service.app.client_id"]}
+HCS_CLIENT_SECRET={props["csp.service.app.client_secret"]}
+IDP_TENANT_DOMAIN=test-sanity-domain
+UAG_FQDN=myuag.fqdn
+DESKTOP_SUBNET_CIDR=10.76.0.0/16
+DMZ_SUBNET_CIDR=10.77.0.0/24
+MANAGEMENT_SUBNET_CIDR=10.77.3.0/24
+TENANT_SUBNET=desktop-76
+TENANT_SUBNET_CIDR=10.76.0.0/16
+DESKTOP_RESOURCE_GROUP=horizonv2-sg-dev
+INFRA_RESOURCE_GROUP=horizonv2-sg-dev
+DESKTOP_VNET=horizonv2-sg-dev-vnet
+INFRA_VNET=horizonv2-sg-dev-vnet
+PRIMARY_BIND_USER_NAME={ad_username}
+PRIMARY_BIND_PASSWORD={ad_password}
+AUXILIARY_BIND_USER_NAME={ad_username}
+AUXILIARY_BIND_PASSWORD={ad_password}
+PRIMARY_JOIN_USER_NAME={ad_username}
+PRIMARY_JOIN_PASSWORD={ad_password}
+AUXILIARY_JOIN_USER_NAME={ad_username}
+AUXILIARY_JOIN_PASSWORD={ad_password}
+ENTITLEMENT_USER_1={ad_username}
+ENTITLEMENT_USER_2={ad_username}-2
+IMAGE_USER_NAME={ad_username}
+IMAGE_PASSWORD={ad_password}
+VM_USER_NAME={ad_username}
+VM_PASSWORD={ad_password}
+DEPLOYMENT_ID=az-1
+"""
+        f.write(config_block)
+
+
+def _to_env_key(key):
+    ACRONYMS = {"BIOS", "CIDR"}
+    key_snake = re.sub(r"(?<!^)(?=[A-Z])", "_", key).upper()
+    for acronym in ACRONYMS:
+        key_snake = re.sub(r"_".join(acronym), acronym, key_snake)
+    return key_snake
+
+
+def _organize_env_file(env_file):
+    group_rules = OrderedDict(
+        [
+            ("Credentials (Optional):", ["HCS_CLIENT_ID", "HCS_CLIENT_SECRET"]),
+            ("Identity Provider (IDP) Configuration", ["IDP_USER_NAME", "IDP_PASSWORD", "IDP_TENANT_DOMAIN"]),
+            (
+                "AD Configuration",
+                [
+                    "DNS_DOMAIN_NAME",
+                    "NET_BIOS_NAME",
+                    "PRIMARY_JOIN_USER_NAME",
+                    "PRIMARY_JOIN_PASSWORD",
+                    "AUXILIARY_JOIN_USER_NAME",
+                    "AUXILIARY_JOIN_PASSWORD",
+                    "PRIMARY_BIND_USER_NAME",
+                    "PRIMARY_BIND_PASSWORD",
+                    "AUXILIARY_BIND_USER_NAME",
+                    "AUXILIARY_BIND_PASSWORD",
+                ],
+            ),
+            (
+                "Primary Provider Configuration",
+                ["PROVIDER_LABEL", "SUBSCRIPTION_ID", "DIRECTORY_ID", "APPLICATION_ID", "APPLICATION_KEY", "REGION"],
+            ),
+            ("Resource and Network Configuration", ["DESKTOP_RESOURCE_GROUP", "INFRA_RESOURCE_GROUP", "DESKTOP_VNET", "INFRA_VNET"]),
+            (
+                "Subnet",
+                [
+                    "DMZ_SUBNET",
+                    "DMZ_SUBNET_CIDR",
+                    "DESKTOP_SUBNET",
+                    "DESKTOP_SUBNET_CIDR",
+                    "MANAGEMENT_SUBNET",
+                    "MANAGEMENT_SUBNET_CIDR",
+                    "TENANT_SUBNET",
+                    "TENANT_SUBNET_CIDR",
+                ],
+            ),
+            ("Resource Credentials", ["IMAGE_USER_NAME", "IMAGE_PASSWORD", "VM_USER_NAME", "VM_PASSWORD"]),
+            ("UAG", ["UAG_FQDN"]),
+            ("Entitlement", ["ENTITLEMENT_USER_1", "ENTITLEMENT_USER_2"]),
+            ("Deployment ID", ["DEPLOYMENT_ID"]),
+            ("Org", ["ORG_ID"]),
+        ]
+    )
+
+    with open(env_file, "r") as f:
+        lines = f.readlines()
+
+    env_dict = {line.split("=", 1)[0].strip(): line.split("=", 1)[1].strip() for line in lines if "=" in line and not line.startswith("#")}
+
+    grouped_env = defaultdict(list)
+    ungrouped = []
+
+    for key, value in env_dict.items():
+        found = False
+        for group, keys in group_rules.items():
+            if key in keys:
+                grouped_env[group].append(f"{key}={value}")
+                found = True
+                break
+        if not found:
+            ungrouped.append(f"{key}={value}")
+
+    organized_lines = []
+    for group, items in grouped_env.items():
+        organized_lines.append(f"# {group}")
+        organized_lines.extend(items)
+        organized_lines.append("")
+
+    if ungrouped:
+        organized_lines.append("# Other Variables")
+        organized_lines.extend(ungrouped)
+
+    with open(env_file, "w") as f:
+        f.write("\n".join(organized_lines))