hcs-cli 0.1.320__py3-none-any.whl → 0.1.322__py3-none-any.whl

hcs_cli/__init__.py

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

hcs_cli/cmds/api.py

@@ -3,8 +3,7 @@ import sys
 
 import click
 from hcs_core.ctxp import CtxpException, profile
-from hcs_core.sglib.client_util import hdc_service_client, is_regional_service, regional_service_client
-from hcs_core.util.query_util import PageRequest
+from hcs_cli.service import api as hcs_api
 
 
 def _has_stdin_data():
@@ -143,12 +142,10 @@ def api(
     if not path.startswith("/"):
         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 :]
-    if is_regional_service(service_path):
-        client = regional_service_client(service_path, region=region)
+    if region or hdc:
+        handler = hcs_api.with_context(hdc=hdc, region=region)
     else:
-        client = hdc_service_client(service_path, hdc=hdc)
+        handler = hcs_api
 
     if header:
         headers = {h.split(":")[0].strip(): h.split(":")[1].strip() for h in header}
@@ -158,28 +155,13 @@ def api(
     # print( f"{method} {api_path} text={raw_data} json={json_data}" )
 
     if method == "GET":
-        if all_pages:
-
-            def _get_page(query_string):
-                url = api_path
-                if url.find("?") > 0:
-                    url += "&" + query_string
-                else:
-                    url += "?" + query_string
-                ret = client.get(url)
-                return ret
-
-            response = PageRequest(_get_page, size=100, limit=0).get()
-        else:
-            response = client.get(api_path, headers=headers, raise_on_404=raise_on_404)
+        return handler.get(path, headers=headers, all_pages=all_pages, raise_on_404=raise_on_404)
     elif method == "POST":
-        response = client.post(api_path, text=raw_data, json=json_data, headers=headers)
+        return handler.post(path, headers=headers, text=raw_data, json=json_data)
     elif method == "PUT":
-        response = client.put(api_path, text=raw_data, json=json_data, headers=headers)
+        return handler.put(path, headers=headers, text=raw_data, json=json_data)
     elif method == "DELETE":
-        response = client.delete(api_path, headers=headers, raise_on_404=raise_on_404)
+        return handler.delete(path, headers=headers, raise_on_404=raise_on_404)
     elif method == "PATCH":
-        response = client.patch(api_path, text=raw_data, json=json_data, headers=headers)
-    else:
-        raise click.UsageError(f"Unsupported HTTP method: {method}")
-    return response
+        return handler.patch(path, headers=headers, text=raw_data, json=json_data)
+    raise click.UsageError(f"Unsupported HTTP method: {method}")

hcs_cli/cmds/clouddriver/{summary.py → service.py}

@@ -15,10 +15,17 @@ limitations under the License.
 
 import click
 
-from hcs_cli.service.clouddriver import provider
+from hcs_cli.service import clouddriver as cd
 
 
 @click.command()
-def summary(**kwargs):
-    """Get summary"""
-    return provider.summary()
+@click.argument("name", type=str, required=True)
+def action(name: str, **kwargs):
+    """Get perform an action"""
+    return cd.action(name, kwargs)
+
+
+@click.command()
+def health(**kwargs):
+    """Get health"""
+    return cd.health()

hcs_cli/cmds/dev/fs/provided_files/mqtt-secret.yaml

@@ -75,7 +75,7 @@ stringData:
     JcSvTMU2HOuQ/q6vFZq3PRbvroMeXlw2WJrqO3vu04SZwYiP8dcrlHTXQJh+Mp9T
     mQ==
     -----END CERTIFICATE-----
-    mqtt.ca-key: |-
+  mqtt.ca-key: |-
     -----BEGIN PRIVATE KEY-----
     MIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQDUNJx2Cf0noNHc
     DXB9AFPSFMkkpwxb0wtqaCLiB7v5zkF7CVBl5LnecVk7CM8bJY62H90Lv8Zv/2sl
@@ -104,7 +104,7 @@ stringData:
     boPQ+RK1VKj5UFkUKz5LiohLmCBEQ7sh1HBS2Vje8MFtg0P138sRlbMCvdAEARTZ
     uQfAKLns7QFf9W1C60AVAQ==
     -----END PRIVATE KEY-----
-    mqtt.client-cert: |-
+  mqtt.client-cert: |-
     -----BEGIN CERTIFICATE-----
     MIIFKDCCAxCgAwIBAgIFALjj4O4wDQYJKoZIhvcNAQELBQAwdTELMAkGA1UEBhMC
     VVMxCzAJBgNVBAgMAkNBMR8wHQYDVQQKDBZIb3Jpem9uIENsb3VkIFNlcnZpY2Vz
@@ -204,7 +204,7 @@ stringData:
     JcSvTMU2HOuQ/q6vFZq3PRbvroMeXlw2WJrqO3vu04SZwYiP8dcrlHTXQJh+Mp9T
     mQ==
     -----END CERTIFICATE-----
-    mqtt.client-key: |-
+  mqtt.client-key: |-
     -----BEGIN PRIVATE KEY-----
     MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQC40aC4pyy0+++D
     kD1cPRsMWO4ANZ8L4LaaHcg/e/1NbiExd/QlZESNJnnIyD29qY1h9WGEVDHtInsl

hcs_cli/cmds/hoc/stats.py

@@ -1,6 +1,8 @@
 import click
-import time
+import datetime
 import json
+import time
+
 from hcs_cli.service.hoc import diagnostic
 from hcs_cli.service import tsctl
 
@@ -22,25 +24,49 @@ def aggregate_connects(from_: int, to: int, wait: bool, verbose: bool):
         return "", 1
 
     if wait:
-        print("Waiting for task to complete...")
-        totalWaitTime = 0
-        while True:
-            time.sleep(10)
-            taskStatus = tsctl.task.lastlog(result.namespace, result.group, result.taskKey)
-            if "state" in taskStatus and taskStatus.state == "Error":
-                print(f"Task is in {taskStatus.state} state - {taskStatus.error} ")
-                print(json.dumps(taskStatus, indent=2))
-                break
-            if "state" in taskStatus and taskStatus.state == "Success":
-                print("Task completed successfully.")
-                print(json.dumps(taskStatus, indent=2))
-                break
-            if ("state" in taskStatus and taskStatus.state == "") or "state" not in taskStatus:
-                print("Task is still in progress...")
-                totalWaitTime += 10
-                if totalWaitTime >= 600:
-                    print("Waited for 10 minutes, exiting.")
-                    break
-                continue
+        wait_for_task(result)
+
+
+@click.command(name="stats-aggregate-connects-day-before")
+@click.option("--wait", type=bool, required=False, is_flag=True, default=False)
+@click.option("--verbose", type=bool, required=False, is_flag=True, default=False)
+def aggregate_connects_day_before(wait: bool, verbose: bool):
+    dt = datetime.datetime.utcnow().replace(hour=0, minute=0, second=0, microsecond=0)
+    dt_2_days_ago = dt - datetime.timedelta(days=2)
+    dt_1_day_ago = dt - datetime.timedelta(days=1)
+
+    print(f"Aggregating connect events from {dt_2_days_ago} to {dt_1_day_ago}")
+    from_ = int(dt_2_days_ago.timestamp())
+    to = int(dt_1_day_ago.timestamp())
+    payload = {"from": from_, "to": to}
+    result = diagnostic.aggregateConnects(payload, verbose=verbose)
+    click.echo(result)
+    if not result:
+        return "", 1
+    if wait:
+        wait_for_task(result)
+
+
+def wait_for_task(result: dict):
+    print("Waiting for task to complete...")
+    totalWaitTime = 0
+    while True:
+        time.sleep(10)
+        taskStatus = tsctl.task.lastlog(result.namespace, result.group, result.taskKey)
+        if "state" in taskStatus and taskStatus.state == "Error":
+            print(f"Task is in {taskStatus.state} state - {taskStatus.error} ")
             print(json.dumps(taskStatus, indent=2))
             break
+        if "state" in taskStatus and taskStatus.state == "Success":
+            print("Task completed successfully.")
+            print(json.dumps(taskStatus, indent=2))
+            break
+        if ("state" in taskStatus and taskStatus.state == "") or "state" not in taskStatus:
+            print("Task is still in progress...")
+            totalWaitTime += 10
+            if totalWaitTime >= 600:
+                print("Waited for 10 minutes, exiting.")
+                break
+            continue
+        print(json.dumps(taskStatus, indent=2))
+        break

hcs_cli/cmds/scm/template.py

@@ -37,11 +37,15 @@ def template(id: str, org: str, **kwargs):
     if not plan:
         return None, 1
 
-    template = hcs.template.get(org_id=org_id, id=id)
+    template_data = hcs.template.get(org_id=org_id, id=id)
 
-    plan["meta"]["maxCapacity"] = template["sparePolicy"]["limit"]
+    plan["meta"]["maxCapacity"] = template_data["sparePolicy"]["limit"]
     calendar = plan["calendar"]
     for key in calendar:
         calendar[key]["calculatedCapacity"] = calendar[key]["idealCapacity"]
         calendar[key]["idealCapacity"] = calendar[key]["forecastCapacity"]
-    edit_plan(plan, template["name"])
+
+    # fetch usage data for the usage chart
+    usage = hcs.scm.template_usage(org_id, id)
+
+    edit_plan(plan, template_data["name"], usage)

hcs_cli/cmds/task.py

@@ -17,6 +17,7 @@ import click
 import hcs_core.sglib.cli_options as cli
 import yumako
 from hcs_core.ctxp import CtxpException, recent, util
+from datetime import datetime
 
 from hcs_cli.service import task
 
@@ -222,6 +223,7 @@ def use(namespace: str, group: str, smart_path: str, reset: bool, **kwargs):
     required=False,
     help="Filter tasks by state, for one-time tasks only. Comma separated values. E.g. Init,Running,Canceled,Error,Success",
 )
+@click.option("--v1", is_flag=True, default=False, required=False, help="Use v1 task API.")
 @click.option("--v1log", is_flag=True, default=False, required=False, help="Fetch last log for v1 tasks.")
 @cli.limit
 @cli.search
@@ -476,7 +478,7 @@ def retrigger(org: str, namespace: str, group: str, smart_path: str, execution_i
     return task.retrigger(org_id, namespace, group, key, execution_id)
 
 
-@task_cmd_group.command()
+@task_cmd_group.command(hidden=True)
 @cli.org_id
 @click.option("--namespace", "-n", type=str, required=False)
 @click.option("--group", "-g", type=str, required=False)
@@ -496,6 +498,51 @@ def resubmit(org: str, namespace: str, group: str, smart_path: str, confirm: boo
     return task.resubmit(org_id, namespace, group, key)
 
 
+@task_cmd_group.command()
+@cli.org_id
+@click.option("--namespace", "-n", type=str, required=False)
+@click.option("--group", "-g", type=str, required=False)
+@click.option(
+    "--reference", "-r", type=str, required=True, help="Reference task to copy parameters from, format: [[<namespace>/]<group>/]<key>."
+)
+@click.option(
+    "--at", type=str, required=False, help="Schedule time, exact time 'YYYY-MM-DD HH:MM:SS', or delta time '1h30m', default is now."
+)
+@click.argument("smart_path", type=str, required=True)
+def duplicate(org: str, namespace: str, group: str, smart_path: str, at: str, **kwargs):
+    """Duplicate an existing task to run once, immediately or at a specific time."""
+    namespace, group, key = _parse_task_param(namespace, group, smart_path)
+    org_id = cli.get_org_id(org)
+    ret = task.get(org_id, namespace, group, key, **kwargs)
+    if not ret:
+        return f"Task {namespace}/{group}/{key} not found.", 1
+
+    # Clone the task
+    new_task = ret.model_copy()
+    new_task.key = None  # Clear the key to let the system generate a new one
+    new_task.log = None  # Clear the log for the new task
+    new_task.meta["_duplicatedFrom"] = key  # Track the source task
+
+    # Handle schedule based on 'at' parameter
+    if at and at.lower() != "now":
+        now_ms = int(datetime.now().timestamp() * 1000)
+        try:
+            # Try to parse as exact time (YYYY-MM-DD HH:MM:SS)
+            scheduled_dt = datetime.strptime(at, "%Y-%m-%d %H:%M:%S")
+            scheduled_ms = int(scheduled_dt.timestamp() * 1000)
+        except ValueError:
+            # Parse as delta time (e.g., 1h30m)
+            delta_seconds = yumako.time.duration(at)
+            scheduled_ms = now_ms + int(delta_seconds * 1000)
+
+        if scheduled_ms > now_ms:
+            new_task.schedule = task.Schedule(initialDelayMs=scheduled_ms)
+        else:
+            new_task.schedule = None  # run immediately
+
+    return task.create(org_id, namespace, new_task)
+
+
 def _parse_task_param(namespace: str, group: str, smart_path: str):
     if smart_path:
         parts = smart_path.split("/")

hcs_cli/payload/lcm/azure-dummy.json

@@ -62,6 +62,7 @@
   "properties": {
     "azureCreateResourceGroup": true,
     "new-task-engine": true,
-    "simulateAgentStatus": "AVAILABLE"
+    "simulateAgentStatus": "AVAILABLE",
+    "countinuousErrorThreshold": 3
   }
 }

hcs_cli/payload/lcm/zero.json

@@ -56,8 +56,9 @@
     }
   },
   "properties": {
-    "new-task-engine": false,
+    "new-task-engine": true,
     "sg-lcm-enforced-provision": true,
-    "autonomous": true
+    "autonomous": true,
+    "countinuousErrorThreshold": 2
   }
 }

hcs_cli/service/api.py

@@ -0,0 +1,104 @@
+from typing import Optional
+from hcs_core.sglib.client_util import hdc_service_client, is_regional_service, regional_service_client
+from hcs_core.util.query_util import PageRequest
+
+
+def _parse_path(path: str, hdc: str = None, region: str = None):
+    service_path = path.split("/")[1]
+    api_path = path[len(service_path) + 1 :]
+    if is_regional_service(service_path):
+        client = regional_service_client(service_path, region=region)
+    else:
+        client = hdc_service_client(service_path, hdc=hdc)
+    return api_path, client
+
+
+def _get(
+    path: str, headers: Optional[dict] = None, all_pages: bool = False, raise_on_404: bool = False, hdc: str = None, region: str = None
+):
+    api_path, client = _parse_path(path, hdc=hdc, region=region)
+    if all_pages:
+
+        def _get_page(query_string):
+            url = api_path
+            if url.find("?") > 0:
+                url += "&" + query_string
+            else:
+                url += "?" + query_string
+            ret = client.get(url)
+            return ret
+
+        return PageRequest(_get_page, size=100, limit=0).get()
+    else:
+        return client.get(api_path, headers=headers, raise_on_404=raise_on_404)
+
+
+def _post(
+    path: str, headers: Optional[dict] = None, text: Optional[str] = None, json: Optional[dict] = None, hdc: str = None, region: str = None
+):
+    api_path, client = _parse_path(path, hdc=hdc, region=region)
+    return client.post(api_path, text=text, json=json, headers=headers)
+
+
+def _put(
+    path: str, headers: Optional[dict] = None, text: Optional[str] = None, json: Optional[dict] = None, hdc: str = None, region: str = None
+):
+    api_path, client = _parse_path(path, hdc=hdc, region=region)
+    return client.put(api_path, text=text, json=json, headers=headers)
+
+
+def _delete(path: str, headers: Optional[dict] = None, raise_on_404: bool = False, hdc: str = None, region: str = None):
+    api_path, client = _parse_path(path, hdc=hdc, region=region)
+    return client.delete(api_path, headers=headers, raise_on_404=raise_on_404)
+
+
+def _patch(
+    path: str, headers: Optional[dict] = None, text: Optional[str] = None, json: Optional[dict] = None, hdc: str = None, region: str = None
+):
+    api_path, client = _parse_path(path, hdc=hdc, region=region)
+    return client.patch(api_path, text=text, json=json, headers=headers)
+
+
+class APIContext:
+    """Context-aware API wrapper that maintains hdc and region for all requests."""
+
+    def __init__(self, hdc: str = None, region: str = None):
+        self.hdc = hdc
+        self.region = region
+
+    def get(self, path: str, headers: Optional[dict] = None, all_pages: bool = False, raise_on_404: bool = False):
+        return _get(path, headers=headers, all_pages=all_pages, raise_on_404=raise_on_404, hdc=self.hdc, region=self.region)
+
+    def post(self, path: str, headers: Optional[dict] = None, text: Optional[str] = None, json: Optional[dict] = None):
+        return _post(path, headers=headers, text=text, json=json, hdc=self.hdc, region=self.region)
+
+    def put(self, path: str, headers: Optional[dict] = None, text: Optional[str] = None, json: Optional[dict] = None):
+        return _put(path, headers=headers, text=text, json=json, hdc=self.hdc, region=self.region)
+
+    def delete(self, path: str, headers: Optional[dict] = None, raise_on_404: bool = False):
+        return _delete(path, headers=headers, raise_on_404=raise_on_404, hdc=self.hdc, region=self.region)
+
+    def patch(self, path: str, headers: Optional[dict] = None, text: Optional[str] = None, json: Optional[dict] = None):
+        return _patch(path, headers=headers, text=text, json=json, hdc=self.hdc, region=self.region)
+
+
+def with_context(hdc: str = None, region: str = None):
+    """Create a context-aware API wrapper with the specified hdc and region.
+
+    Args:
+        hdc: HDC name for global services
+        region: Region name for regional services
+
+    Returns:
+        APIContext: An object with get(), post(), put(), delete(), patch() methods
+    """
+    return APIContext(hdc=hdc, region=region)
+
+
+_no_context_api = APIContext()
+
+get = _no_context_api.get
+post = _no_context_api.post
+put = _no_context_api.put
+delete = _no_context_api.delete
+patch = _no_context_api.patch

hcs_cli/service/clouddriver/__init__.py

@@ -0,0 +1,2 @@
+from .service import action as action
+from .service import health as health

hcs_cli/service/clouddriver/service.py

@@ -0,0 +1,29 @@
+"""
+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 logging
+
+from hcs_core.sglib.client_util import hdc_service_client
+
+log = logging.getLogger(__name__)
+_client = hdc_service_client("clouddriver")
+
+
+def action(name: str, params: dict):
+    return _client.post(f"/v1/action/{name}", params)
+
+
+def health():
+    return _client.get("/v1/health")

hcs_cli/service/task.py

@@ -205,6 +205,12 @@ def resubmit(org_id: str, namespace: str, group: str, key: str, **kwargs):
     return _tsctl_client.post(url, body)
 
 
+def create(org_id: str, namespace: str, task: TaskModel, **kwargs):
+    url = f"/v1/namespaces/{namespace}/tasks?org_id={org_id}"
+    body = TaskModel.model_dump_json(task)
+    return _tsctl_client.post(url, body)
+
+
 def logs(org_id: str, namespace: str, group: str, key: str, search: str, **kwargs):
     search_parts = []
     if org_id: