hcs-cli 0.1.316__tar.gz → 0.1.318__tar.gz

{hcs_cli-0.1.316 → hcs_cli-0.1.318}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hcs-cli
-Version: 0.1.316
+Version: 0.1.318
 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.316
+Requires-Dist: hcs-core>=0.1.318
 Requires-Dist: inquirerpy>=0.3.4
 Requires-Dist: matplotlib>=3.8.0
 Requires-Dist: paho-mqtt>=2.1.0

hcs_cli-0.1.318/hcs_cli/__init__.py

@@ -0,0 +1,3 @@
+__version__ = "0.1.318"
+
+from . import service

{hcs_cli-0.1.316 → hcs_cli-0.1.318}/hcs_cli/cmds/api.py

@@ -134,13 +134,14 @@ def api(
             f"Method {method} does not support request body. Use --data or --json or STDIN only with POST, PUT, or PATCH methods."
         )
 
-    if path.startswith(profile.current().hcs.url):
-        path = path[len(profile.current().hcs.url) :]
+    hcs_url = profile.current().hcs.url
+    if path.startswith(hcs_url):
+        path = path[len(hcs_url) :]
         if not path.startswith("/"):
             path = "/" + path
 
     if not path.startswith("/"):
-        raise click.UsageError("Path must start with a '/'. Please provide a valid context path.")
+        raise click.UsageError("Path must start with a '/'. Please provide a valid context path. Provided path=" + path)
 
     service_path = path.split("/")[1]
     api_path = path[len(service_path) + 1 :]
@@ -155,6 +156,7 @@ def api(
         headers = None
 
     # print( f"{method} {api_path} text={raw_data} json={json_data}" )
+
     if method == "GET":
         if all_pages:
 

{hcs_cli-0.1.316 → hcs_cli-0.1.318}/hcs_cli/cmds/debug/start.py

@@ -52,7 +52,7 @@ def start(service: str, skip: bool, force: bool, **kwargs):
 
 def pod_forwarding(pod_id):
     print("Start forwarding pod")
-    pod_forwarding_command = f"kubectl port-forward {pod_id} 10762:10762"
+    pod_forwarding_command = f"kubectl port-forward {pod_id} 5005:5005"
     global _forwarding_process
     _forwarding_process = subprocess.Popen(shlex.split(pod_forwarding_command), stdout=subprocess.PIPE, stderr=subprocess.PIPE)
     print("Started forwarding pod. pid:", _forwarding_process.pid)
@@ -60,7 +60,7 @@ def pod_forwarding(pod_id):
 
 def run_with_debug(pod_id):
 
-    run_app_command = f"kubectl exec -it {pod_id} -c app -- /bin/bash -c 'java -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=10762 -jar app.jar'"
+    run_app_command = f"kubectl exec -it {pod_id} -c app -- /bin/bash -c 'java -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005 -jar app.jar'"
 
     # Execute the command
     process = subprocess.Popen(shlex.split(run_app_command), stdout=subprocess.PIPE, stderr=subprocess.PIPE)

{hcs_cli-0.1.316 → hcs_cli-0.1.318}/hcs_cli/cmds/dev/fs/helper/license_info.py

@@ -74,18 +74,42 @@ def createLicenseFeatures():
     log.trivial("Creating license features record for csp org id {}".format(org_id))
     client_id = os.environ.get("CSP_LICENSE_SVC_CLIENT_ID")
     client_secret = os.environ.get("CSP_LICENSE_SVC_CLIENT_SECRET")
-    if not client_id:
-        print("Using admin service credentials from current profile...")  # which has service permission
-        client_id = current_profile.override["admin"]["client-id"]
-        client_secret = current_profile.override["admin"]["client-secret"]
-    client = hcs_client(
-        current_profile.hcs.url,
-        {
-            "url": current_profile.csp.url,
-            "client_id": client_id,
-            "client_secret": client_secret,
-        },
-    )
+    while True:
+        if client_id:
+            log.trivial("Using credentials from env CSP_LICENSE_SVC_CLIENT_ID")
+            break
+        override = current_profile.override
+        if override:
+            license_service_override = current_profile.override.get("license-features")
+            if license_service_override:
+                log.trivial("Using license-features service override from current profile...")
+                client_id = license_service_override["client-id"]
+                client_secret = license_service_override["client-secret"]
+                break
+
+            admin_override = current_profile.override.get("admin")
+            if admin_override:
+                log.trivial("Using admin service override from current profile...")
+                client_id = current_profile.override["admin"]["client-id"]
+                client_secret = current_profile.override["admin"]["client-secret"]
+                break
+
+        log.warn("No admin override found in current profile. Using default credentials.")
+        client_id = None
+        break
+
+    if client_id:
+        client = hcs_client(
+            current_profile.hcs.url,
+            {
+                "url": current_profile.csp.url,
+                "client_id": client_id,
+                "client_secret": client_secret,
+            },
+        )
+    else:
+        # default profile
+        client = hcs_client(url=current_profile.hcs.url, custom_auth=current_profile.csp)
     response_data = client.post("/license-features/v1/licenses", json=data)
     log.good(f"Successfully created license-features: {response_data}")
 

{hcs_cli-0.1.316 → hcs_cli-0.1.318}/hcs_cli/cmds/dev/onboard.py

@@ -1,3 +1,4 @@
+import os
 from time import sleep, time
 
 import click
@@ -8,7 +9,6 @@ from InquirerPy import inquirer
 from InquirerPy.base import Choice
 
 import hcs_cli.cmds.dev.util.github_helper as github_helper
-from hcs_cli.cmds.dev.fs.init import _retrieve_config_from_nightly_repo
 from hcs_cli.cmds.dev.util.log import fail
 from hcs_cli.support.exec_util import run_cli
 
@@ -125,6 +125,40 @@ def delete(all: bool, org: str):
     click.echo("Reset complete.")
 
 
+@onboard.command()
+@cli.org_id
+def init_org(org):
+    """[Global admin] Init HCS org (org, location, and license)."""
+    org_id = cli.get_org_id(org)
+    proceed = click.confirm("This only works with non-prod stack. Continue?")
+    if not proceed:
+        return "", 1
+    proceed = click.confirm("This operation requires that the current profile has global admin privileges. Continue?")
+    if not proceed:
+        return "", 1
+    proceed = click.confirm(f"Target org: {org_id}")
+    if not proceed:
+        return "", 1
+    _ensure_org_initialized(org_id, critical=True)
+
+
+def _ensure_org_initialized(org_id, critical=False):
+    os.environ["ORG_ID"] = org_id
+    try:
+        from hcs_cli.cmds.dev.fs.init import _create_license_info, _create_org_details, _create_org_location_mapping
+
+        _create_org_details()
+        _create_org_location_mapping()
+        _create_license_info()
+    except Exception as e:
+        if critical:
+            click.secho(f"Error initializing org: {e}", fg="bright_red")
+        else:
+            click.secho(
+                f"Error initializing org: {e}. If you have already initialized the org, you can ignore this warning.", fg="bright_yellow"
+            )
+
+
 def _delete_express_onboarding_deployment(org_id: str):
     deployment = run_cli(f"hcs api /deployment-orchestrator/v1/deployments?org_id={org_id}", output_json=True)
     if not deployment:

hcs_cli-0.1.318/hcs_cli/cmds/inventory/assign.py

@@ -0,0 +1,145 @@
+"""
+Copyright 2023-2023 VMware Inc.
+SPDX-License-Identifier: Apache-2.0
+
+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
+    http://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 json
+import sys
+import uuid
+
+import click
+import hcs_core.sglib.cli_options as cli
+
+from hcs_cli.service import admin, auth, inventory, lcm, portal
+from hcs_cli.support.param_util import parse_vm_path
+
+
+@click.command()
+@cli.org_id
+@click.argument("vm_path", type=str, required=False)
+def assign(org: str, vm_path: str):
+    """Assign user to VM"""
+    org_id = cli.get_org_id(org)
+    template_id, vm_id = parse_vm_path(vm_path)
+
+    template = admin.template.get(template_id, org_id)
+    if template:
+        edge_id = template["edgeDeploymentId"]
+    else:
+        # try with lcm
+        template = lcm.template.get(template_id, org_id)
+        edge_id = template["edgeGateway"]["id"]
+    if not template:
+        return "Template not found: " + template_id, 1
+    payload = {
+        "id": "dspec1",
+        "userId": "user1",
+        "clientId": "client-1",
+        "entitlementId": "entitlement-1",
+        "templateIds": [template_id],
+        "allocationPolicy": "ANY",
+        "sessionType": "DESKTOP",
+        "username": "user1",
+        "userPrincipalName": "aduser1@vmwhorizon.com",
+        "userSid": "S-1-5-21-2502306595",
+        "orgId": org_id,
+        "location": template["location"],
+        "vmId": vm_id,
+        "templateType": template["templateType"],
+        "resume": True,
+        "clientSessionId": "client-uuid-1",
+    }
+    # print(json.dumps(payload, indent=4))
+    inventory.assignV2(payload)
+
+    # payload_manual_session = {
+    #     "templateId": "string",
+    #     "vmId": "string",
+    #     "userId": "string",
+    #     "agentSessionGuid": "string",
+    #     "agentSessionId": "string",
+    #     "agentStaticSessionGuid": "string",
+    #     "sessionType": "DESKTOP",
+    #     "templateType": "FLOATING",
+    #     "clientId": "string",
+    #     "sessionStatus": "string",
+    #     "lastAssignedTime": "2025-12-16T20:56:08.988Z",
+    #     "lastLoginTime": "2025-12-16T20:56:08.988Z",
+    #     "lastStatusUpdateTime": "2025-12-16T20:56:08.988Z",
+    #     "username": "string",
+    #     "userPrincipalName": "string",
+    #     "userSid": "string",
+    #     "entitlementId": "string",
+    #     "orgId": "string",
+    #     "location": "string",
+    #     "clientSessionId": "UUID string",
+    #     "agentErrorCode": "AGENT_ERR_FAILURE",
+    #     "staticCloudSessionId": "UUID string",
+    #     "hibernated": true,
+    #     "id": 0,
+    #     "dspecId": "string"
+    # }
+    payload_update = {
+        "id": "dspec1",
+        "agentSessionGuid": "agent-session-guid-1",
+        "agentSessionId": "agent-session-1",
+        "agentStaticSessionGuid": "agent-static-session-guid-1",
+        "sessionStatus": "string",
+        "vmId": vm_id,
+        "edgeId": edge_id,
+        "agentErrorCode": "",
+    }
+    return inventory.update_session(org_id=org_id, template_id=template_id, payload=payload_update)
+
+
+@click.command()
+@cli.org_id
+@click.option("-pg", "--pool-group", type=str, required=True)
+@click.option("-p", "--pool", type=str, required=True)
+@click.option("-n", "--num-users", type=str, required=True)
+def bulk_assign(org: str, pool_group: str, pool: str, num_users: int):
+    """Assign  multiple users to VMs"""
+    org_id = cli.get_org_id(org)
+    pg = portal.pool.get(pool_group, org_id)
+    payload = {
+        "id": "",
+        "userId": "",
+        "entitlementId": pool_group,
+        "templateIds": [pool],
+        "allocationPolicy": "ANY",
+        "sessionType": "DESKTOP",
+        "username": "",
+        "userPrincipalName": "",
+        "userSid": "",
+        "orgId": org_id,
+        "location": "US",
+        "templateType": pg["templateType"],
+        "resume": True,
+    }
+    users = auth.admin.search.users(org_id, {}, -1)
+
+    num_users = int(num_users)
+    if num_users > len(users["users"]):
+        print(f'max available users in AD = {len(users["users"])}, set -n less than {len(users["users"])}')
+        return
+    fu = users["users"][:num_users]
+    dspecs = []
+    for user in fu:
+        payload["id"] = str(uuid.uuid4())
+        payload["userId"] = user["id"]
+        payload["username"] = user["userName"]
+        payload["userPrincipalName"] = user["userPrincipalName"]
+        payload["userSid"] = user["userSid"]
+        inventory.session.assignV2(payload)
+        dspecs.append(payload["id"])
+    print(f"created following dspecs - {dspecs}")

hcs_cli-0.1.318/hcs_cli/cmds/inventory/deassign.py

@@ -0,0 +1,64 @@
+"""
+Copyright 2023-2023 VMware Inc.
+SPDX-License-Identifier: Apache-2.0
+
+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
+    http://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 json
+import sys
+
+import click
+import hcs_core.sglib.cli_options as cli
+
+from hcs_cli.service import admin, inventory, lcm
+from hcs_cli.support.param_util import parse_vm_path
+
+
+@click.command()
+@cli.org_id
+@click.argument("vm_path", type=str, required=False)
+def deassign(org: str, vm_path: str):
+    """Assign user to VM"""
+    org_id = cli.get_org_id(org)
+    template_id, vm_id = parse_vm_path(vm_path)
+    sessions = inventory.sessions(template_id, vm_id, cli.get_org_id(org))
+
+    template = admin.template.get(template_id, cli.get_org_id(org))
+    if template:
+        edge_deployment_id = template["edgeDeploymentId"]
+    else:
+        # try with lcm
+        template = lcm.template.get(template_id, cli.get_org_id(org))
+        if not template:
+            return "Template not found: " + template_id, 1
+        edge_deployment_id = template["edgeGateway"]["id"]
+
+    all_ret = []
+    for session in sessions:
+        payload = {
+            "vmHubName": template["hdc"]["vmHub"]["name"],
+            "edgeDeploymentId": edge_deployment_id,
+            "vmId": vm_id,
+            "entitlementId": session.get("entitlementId"),
+            "agentSessionGuid": session.get("agentSessionGuid"),
+            "agentSessionId": session.get("agentSessionId"),
+            "agentStaticSessionGuid": session.get("agentStaticSessionGuid"),
+            "id": session.get("dspecId"),
+            "userId": session.get("userId"),
+            "type": session.get("sessionType"),
+        }
+        ret = inventory.deassign(template_id=template_id, org_id=org_id, payload=payload)
+        all_ret.append(ret)
+
+    if len(all_ret) == 1:
+        return all_ret[0]
+    return all_ret

hcs_cli-0.1.318/hcs_cli/cmds/inventory/logoff.py

@@ -0,0 +1,110 @@
+"""
+Copyright 2023-2023 VMware Inc.
+SPDX-License-Identifier: Apache-2.0
+
+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
+    http://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 click
+import hcs_core.sglib.cli_options as cli
+
+from hcs_cli.service import admin, inventory, lcm
+from hcs_cli.support.param_util import parse_vm_path
+
+
+@click.command()
+@cli.org_id
+@click.argument("vm_path", type=str, required=False)
+def logoff(org: str, vm_path: str):
+    """Logoff all sessions on the vm.
+
+    Example: hcs inventory logoff template_id/vm_id
+    """
+
+    org_id = cli.get_org_id(org)
+    template_id, vm_id = parse_vm_path(vm_path)
+    sessions = inventory.sessions(template_id, vm_id, cli.get_org_id(org))
+    if not sessions:
+        return
+    # [
+    #     {
+    #         "templateId": null,
+    #         "vmId": "expool000",
+    #         "userId": "c12b884b-c813-4f73-81f5-df2052de9bc6",
+    #         "agentSessionGuid": null,
+    #         "agentSessionId": null,
+    #         "agentStaticSessionGuid": null,
+    #         "sessionType": "DESKTOP",
+    #         "templateType": "FLOATING",
+    #         "clientId": null,
+    #         "sessionStatus": "ASSIGNED",
+    #         "lastAssignedTime": "2025-12-16T18:55:45.078+00:00",
+    #         "lastLoginTime": null,
+    #         "lastStatusUpdateTime": "2025-12-16T18:55:45.078+00:00",
+    #         "username": "u1ad1",
+    #         "userPrincipalName": "u1ad1@horizonv2dev2.local",
+    #         "userSid": "S-1-5-21-1840667356-2516272024-4034330832-1104",
+    #         "releaseSessionOnDeassign": false,
+    #         "entitlementId": "6941a2bfe79a1b9cef167ad2",
+    #         "orgId": "7c4f9042-6119-45b6-93f5-24f1a80e2c62",
+    #         "location": null,
+    #         "clientSessionId": null,
+    #         "agentErrorCode": "",
+    #         "staticCloudSessionId": "dc907d57-85d8-478e-9d0c-028c1acd87f2",
+    #         "hibernated": null,
+    #         "id": null,
+    #         "dspecId": "5722ff4a-7e75-4248-89e9-741d8a7ae91c"
+    #     }
+    # ]
+
+    template = admin.template.get(template_id, cli.get_org_id(org))
+    if template:
+        edge_deployment_id = template["edgeDeploymentId"]
+    else:
+        # try with lcm
+        template = lcm.template.get(template_id, cli.get_org_id(org))
+        if not template:
+            return "Template not found: " + template_id, 1
+        edge_deployment_id = template["edgeGateway"]["id"]
+
+    all_ret = []
+    for session in sessions:
+        logoff_payload_v1 = {
+            "edgeDeploymentId": edge_deployment_id,
+            "vmId": vm_id,
+            "userId": session.get("userId"),
+            "entitlementId": session.get("entitlementId"),
+            "vmHubName": template["hdc"]["vmHub"]["name"],
+            "sessionType": session.get("sessionType"),
+        }
+        ret1 = inventory.logoff(template_id=template_id, org_id=org_id, payload=logoff_payload_v1)
+        # print("PAYLOADv1: ", logoff_payload_v1)
+        # print("RETv1: ", ret1)
+        all_ret.append(ret1)
+
+        logoff_payload_v2 = [
+            {
+                "agentSessionGuid": session.get("agentSessionGuid"),
+                "userId": session.get("userId"),
+                "sessionType": session.get("sessionType"),
+                "vmHubName": template["hdc"]["vmHub"]["name"],
+                "edgeDeploymentId": edge_deployment_id,
+                "vmId": vm_id,
+                "dspecId": session.get("dspecId"),
+                "dtemplateId": template_id,
+            }
+        ]
+        ret2 = inventory.logoffV2(org_id=org_id, payload=logoff_payload_v2)
+        # print("PAYLOADv2: ", logoff_payload_v2)
+        # print("RETv2: ", ret2)
+        all_ret.append(ret2)
+
+    return all_ret

{hcs_cli-0.1.316 → hcs_cli-0.1.318}/hcs_cli/cmds/inventory/session.py

@@ -16,7 +16,7 @@ limitations under the License.
 import click
 import hcs_core.sglib.cli_options as cli
 
-from hcs_cli.service import inventory
+from hcs_cli.service import admin, inventory
 from hcs_cli.support.param_util import parse_vm_path
 
 
@@ -27,7 +27,7 @@ def session():
 
 @session.command()
 @cli.org_id
-@click.argument("vm_path", type=str, required=True)
+@click.argument("vm_path", type=str, required=False)
 def list(org: str, vm_path: str):
     """List sessions"""
     template, vm = parse_vm_path(vm_path)

{hcs_cli-0.1.316 → hcs_cli-0.1.318}/hcs_cli/cmds/scm/operator.py

@@ -60,8 +60,8 @@ def _print_error(text: str):
 
 def _print_human_readable_log(d: TaskModel):
     ret = d.log
-    time_started = ret.time_started
-    time_completed = ret.time_completed
+    time_started = ret.timeStarted
+    time_completed = ret.timeCompleted
 
     if time_completed:
         delta = timedelta(milliseconds=time_completed - time_started)

hcs_cli-0.1.318/hcs_cli/cmds/template/expand.py

@@ -0,0 +1,65 @@
+"""
+Copyright 2023-2023 VMware Inc.
+SPDX-License-Identifier: Apache-2.0
+
+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
+    http://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 click
+import hcs_core.sglib.cli_options as cli
+import hcs_core.util.duration as duration
+from hcs_core.ctxp import recent
+
+import hcs_cli.service.admin as admin
+
+
+@click.command(hidden=True)
+@click.option(
+    "--number",
+    "-n",
+    type=int,
+    required=False,
+    default=1,
+    help="Number of VMs to expand. Use negative number to shrink.",
+)
+@click.argument("template_id", type=str, required=False)
+@cli.org_id
+@cli.wait
+def expand(number: int, template_id: str, org: str, wait: str, **kwargs):
+    """Update an existing template"""
+
+    org_id = cli.get_org_id(org)
+
+    template_id = recent.require("template", template_id)
+    template = admin.template.get(template_id, org_id)
+
+    if not template:
+        return "Template not found: " + template_id
+
+    spare_policy = template.get("sparePolicy", {})
+    patch = {
+        "sparePolicy": {
+            "min": spare_policy.get("min", 0) + number,
+            "max": spare_policy.get("max", 0) + number,
+            "limit": spare_policy.get("limit", 0) + number,
+        }
+    }
+    if patch["sparePolicy"]["min"] < 0:
+        patch["sparePolicy"]["min"] = 0
+    if patch["sparePolicy"]["max"] < 0:
+        patch["sparePolicy"]["max"] = 0
+    if patch["sparePolicy"]["limit"] < 0:
+        patch["sparePolicy"]["limit"] = 0
+
+    ret = admin.template.update(template_id, org_id, patch)
+    if wait != "0":
+        ret = admin.template.wait_for_ready(template_id, org_id, duration.to_seconds(wait))
+    return ret