hcs-core 0.1.283__py3-none-any.whl → 0.1.316__py3-none-any.whl

hcs_core/ctxp/telemetry.py

@@ -0,0 +1,145 @@
+import json
+import logging
+import sys
+import time
+from datetime import datetime, timezone
+
+import click
+import httpx
+from yumako import env
+
+log = logging.getLogger(__name__)
+
+_record = None
+_enabled = None
+_app_name = ""
+
+
+def disable():
+    global _enabled
+    _enabled = False
+
+
+def _is_disabled():
+    global _enabled
+    if _enabled is None:
+        _enabled = env.bool("HCS_CLI_TELEMETRY", True)
+    return not _enabled
+
+
+def _get_version():
+    try:
+        from importlib.metadata import version
+
+        return version("hcs-cli")
+    except Exception as e:
+        log.debug(f"Failed to get hcs-cli version: {e}")
+        return "unknown"
+
+
+def _get_record():
+    global _record
+    if _record is None:
+        _record = {
+            "@timestamp": datetime.now(timezone.utc).isoformat(timespec="milliseconds"),
+            "app": _app_name,
+            "command": None,
+            "options": [],
+            "return": -1,
+            "error": None,
+            "time_ms": -1,
+            "version": _get_version(),
+            "env": {
+                "python_version": sys.version,
+                "platform": sys.platform,
+                "executable": sys.executable,
+            },
+        }
+    return _record
+
+
+def start(app_name: str = None):
+    if _is_disabled():
+        return
+
+    global _app_name
+    _app_name = app_name
+    _get_record()
+
+
+def update(cmd_path: str, params: dict):
+    if _is_disabled():
+        return
+
+    record = _get_record()
+    record["command"] = cmd_path
+    record["options"] = [k.replace("_", "-") for k, v in params.items() if v]
+
+
+def end(return_code: int = 0, error: Exception = None):
+    if _is_disabled():
+        return
+
+    record = _get_record()
+    if error:
+        if isinstance(error, click.exceptions.Exit):
+            return_code = error.exit_code
+        elif isinstance(error, SystemExit):
+            return_code = error.code
+        else:
+            record["error"] = str(error)
+            if return_code == 0:
+                return_code = 1
+    record["return"] = return_code
+    record["time_ms"] = int((time.time() - datetime.fromisoformat(record["@timestamp"]).timestamp()) * 1000)
+
+    _fix_missing_commands(record)
+    _injest(record)
+    return record
+
+
+def _fix_missing_commands(record):
+    if record["command"]:
+        return
+
+    args = sys.argv[1:]
+
+    # this does not work for all cases, but only as best effort.
+    options_started = False
+    options = record["options"]
+    command = [_app_name]
+    for arg in args:
+        if arg.startswith("-"):
+            options_started = True
+
+        if options_started:
+            if arg.startswith("--"):
+                options.append(arg[2:])
+            elif arg.startswith("-"):
+                options.append(arg[1:])
+            else:
+                # value. For privacy no logging.
+                continue
+        else:
+            command.append(arg)
+
+    record["command"] = " ".join(command)
+
+
+def _injest(doc):
+
+    # print('TELEMETRY end', json.dumps(doc, indent=4), flush=True)
+
+    try:
+        response = httpx.post(
+            "https://collie.omnissa.com/es/hcs-cli/_doc",
+            auth=("append_user", "public"),
+            headers={"Content-Type": "application/json"},
+            content=json.dumps(doc),
+            timeout=4,
+            verify=False,
+        )
+        response.raise_for_status()
+    except Exception as e:
+        log.debug(f"Telemetry ingestion failed: {e}", exc_info=True)
+        return

hcs_core/ctxp/util.py

@@ -13,6 +13,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
+import datetime
 import json
 import os
 import re
@@ -26,6 +27,7 @@ import click
 import httpx
 import questionary
 import yaml
+import yumako
 
 
 class CtxpException(Exception):
@@ -57,6 +59,7 @@ def validate_error_return(reason, return_code):
 def print_output(data: Any, args: dict, file=sys.stdout):
     output = args.get("output", "json")
     fields = args.get("field")
+    exclude_field = args.get("exclude_field")
     ids = args.get("ids", False)
     first = args.get("first", False)
 
@@ -68,20 +71,25 @@ def print_output(data: Any, args: dict, file=sys.stdout):
         try:
             data = _convert_generator(data)
             if first and isinstance(data, list):
+                if len(data) == 0:
+                    return
                 data = data[0]
 
             if ids:
                 if fields:
                     raise CtxpException("--ids and --fields should not be used together.")
                 data = _convert_to_id_only(data)
-            elif fields:
-                data = _filter_fields(data, fields)
+            else:
+                if fields:
+                    data = _filter_fields(data, fields)
+                if exclude_field:
+                    data = _exclude_fields(data, exclude_field)
 
             if output is None or output == "json":
                 text = json.dumps(data, default=vars, indent=4)
             elif output == "json-compact":
                 text = json.dumps(data, default=vars)
-            elif output == "yaml":
+            elif output == "yaml" or output == "yml":
                 from . import jsondot
 
                 text = yaml.dump(jsondot.plain(data), sort_keys=False)
@@ -89,7 +97,18 @@ def print_output(data: Any, args: dict, file=sys.stdout):
                 if isinstance(data, list):
                     text = ""
                     for i in data:
-                        line = i if type(i) is str else json.dumps(i)
+                        t = type(i)
+                        if t is str:
+                            line = i
+                        elif isinstance(i, dict):
+                            if len(i) == 0:
+                                continue
+                            if len(i) == 1:
+                                line = str(next(iter(i.values())))
+                            else:
+                                line = json.dumps(i)
+                        else:
+                            line = json.dumps(i)
                         text += line + "\n"
                 elif isinstance(data, dict):
                     text = json.dumps(data, indent=4)
@@ -97,7 +116,7 @@ def print_output(data: Any, args: dict, file=sys.stdout):
                     text = data
                 else:
                     text = json.dumps(data, indent=4)
-            elif output == "table":
+            elif output == "table" or output == "t":
                 formatter = args["format"]
                 text = formatter(data)
             else:
@@ -110,7 +129,7 @@ def print_output(data: Any, args: dict, file=sys.stdout):
 
 
 def print_error(error):
-    critical_errors = [KeyError, TypeError]
+    critical_errors = [KeyError, TypeError, AttributeError, ValueError, IndentationError, ImportError]
     for ex in critical_errors:
         if isinstance(error, ex):
             traceback.print_exception(type(error), error, error.__traceback__, file=sys.stderr)
@@ -157,7 +176,27 @@ def _filter_fields(obj: Any, fields: str):
     return _filter_obj(obj)
 
 
+def _exclude_fields(obj: Any, fields_exclude: str):
+    parts = fields_exclude.split(",")
+
+    def _filter_obj(o):
+        if not isinstance(o, dict):
+            return o
+        for k in list(o.keys()):
+            if k in parts:
+                del o[k]
+        return o
+
+    if isinstance(obj, list):
+        return list(map(_filter_obj, obj))
+    return _filter_obj(obj)
+
+
 def panic(reason: Any = None, code: int = 1):
+    if isinstance(reason, SystemExit):
+        os._exit(reason.code)
+    if isinstance(reason, click.exceptions.Exit):
+        os._exit(reason.exit_code)
     if isinstance(reason, Exception):
         text = error_details(reason)
     else:
@@ -184,7 +223,11 @@ def choose(prompt: str, items: list, fn_get_text: Callable = None, selected=None
         panic(prompt + " ERROR: no item available.")
 
     if fn_get_text is None:
-        fn_get_text = lambda t: str(t)
+
+        def _default_fn_get_text(t):
+            return str(t)
+
+        fn_get_text = _default_fn_get_text
 
     if select_by_default and len(items) == 1:
         ret = items[0]
@@ -223,24 +266,37 @@ def input_array(prompt: str, default: list[str] = None):
     return ret
 
 
-def error_details(e):
-    if isinstance(e, Exception):
-        if isinstance(e, CtxpException):
-            details = str(e)
-        else:
-            details = e.__class__.__name__
-            msg = str(e)
-            if msg:
-                details += ": " + msg
-        cause = e.__cause__
-        if cause and cause != e:
-            details += " | Caused by: " + error_details(cause)
+def error_details(ex):
+    if not isinstance(ex, Exception):
+        return str(ex)
+
+    collector = []
 
+    def _collect_details(e):
+        if isinstance(e, click.ClickException):
+            collector.append(str(e))
+            return
+
+        details = e.__class__.__name__
+        msg = str(e)
+        if msg:
+            details += ": " + msg
         if isinstance(e, httpx.HTTPStatusError):
             details += "\n" + e.response.text
-        return details
-    else:
-        return str(e)
+        collector.append(details)
+
+        cause = e.__cause__
+        if cause and cause != e:
+            _collect_details(cause)
+
+    _collect_details(ex)
+
+    # remove_consecutive_duplicates
+    result = [collector[0]]
+    for item in collector[1:]:
+        if item != result[-1]:
+            result.append(item)
+    return " | Caused by: ".join(result)
 
 
 def avoid_trace_for_ctrl_c():
@@ -309,7 +365,7 @@ def format_table(data: list, fields_mapping: dict, columns_to_sum: list = None):
         table = [[item.get(field) for field in headers] for item in flattened_data]
 
         if columns_to_sum:
-            columns_to_sum_indices = {col: headers.index(col) for col in columns_to_sum}
+            columns_to_sum_indices = {col: headers.index(col) for col in columns_to_sum if col in headers}
             footer = [""] * len(headers)
             footer[0] = "Total"
             for col_name, col_index in columns_to_sum_indices.items():
@@ -319,10 +375,12 @@ def format_table(data: list, fields_mapping: dict, columns_to_sum: list = None):
                     if isinstance(v, str):
                         v = strip_ansi(v)
                         v = int(v)
-                    elif isinstance(v, int):
+                    elif isinstance(v, int) or isinstance(v, float):
                         pass
+                    elif v is None:
+                        continue
                     else:
-                        raise Exception(f"Unexpected cell value type. Type={type(v)}, value={v}")
+                        raise Exception(f"Unexpected cell value type. Type={type(v)}, value={v}, col={col_name}")
                     total += v
                 footer[col_index] = total
             separator = ["-" * len(header) for header in headers]
@@ -331,3 +389,78 @@ def format_table(data: list, fields_mapping: dict, columns_to_sum: list = None):
         traceback.print_exc()
 
     return tabulate(table, headers=headers) + "\n"
+
+
+def colorize(data: dict, name: str, mapping: dict):
+    if os.environ.get("TERM_COLOR") == "0":
+        return
+
+    s = data.get(name)
+    if not s:
+        return
+
+    if isinstance(mapping, dict):
+        c = mapping.get(s)
+        if c:
+            if isinstance(c, str):
+                data[name] = click.style(s, fg=c)
+            elif callable(c):
+                color = c(data)
+                data[name] = click.style(s, fg=color)
+            else:
+                raise Exception(f"Unexpected color type: {type(c)} {c}")
+    elif callable(mapping):
+        c = mapping(s)
+        if c:
+            data[name] = click.style(s, fg=c)
+    else:
+        raise Exception(f"Unexpected mapping type: {type(mapping)} {mapping}")
+
+
+def default_table_formatter(data: Any, mapping: dict = None):
+    if not isinstance(data, list):
+        return data
+
+    def _restrict_readable_length(data: dict, name: str, length: int):
+        text = data.get(name)
+        if not text:
+            return
+        if len(text) > length:
+            data[name] = text[: length - 3] + "..."
+
+    field_mapping = {}
+    for d in data:
+        if "id" in d:
+            field_mapping["id"] = "Id"
+        if "name" in d:
+            field_mapping["name"] = "Name"
+        if "location" in d:
+            field_mapping["location"] = "Location"
+        if "type" in d:
+            field_mapping["type"] = "Type"
+        if "status" in d:
+            field_mapping["status"] = "Status"
+        if "createdAt" in d:
+            d["_createdStale"] = yumako.time.stale(d["createdAt"], datetime.timezone.utc)
+            field_mapping["_createdStale"] = "Created At"
+        if "updatedAt" in d:
+            d["_updatedStale"] = yumako.time.stale(d["updatedAt"], datetime.timezone.utc)
+            field_mapping["_updatedStale"] = "Updated At"
+
+        colorize(
+            d,
+            "status",
+            {
+                "READY": "green",
+                "SUCCESS": "green",
+                "ERROR": "red",
+            },
+        )
+        _restrict_readable_length(d, "name", 60)
+    if mapping:
+        for k, v in mapping.items():
+            if v is None:
+                field_mapping.pop(k, None)
+            else:
+                field_mapping[k] = v
+    return format_table(data, fields_mapping=field_mapping)

hcs_core/plan/__init__.py

@@ -5,6 +5,7 @@ from .core import clear as clear
 from .core import destroy as destroy
 from .core import get_deployment_data as get_deployment_data
 from .core import graph as graph
+from .core import resolve as resolve
 from .helper import PlanException as PlanException
 from .helper import PluginException as PluginException
 from .kop import attach_job_view as attach_job_view

hcs_core/plan/core.py

@@ -1,5 +1,5 @@
 """
-Copyright 2023-2023 VMware Inc.
+Copyright 2025-2025 Omnissa Inc.
 SPDX-License-Identifier: Apache-2.0
 
 Licensed under the Apache License, Version 2.0 (the "License");
@@ -41,19 +41,13 @@ def _prepare_data(data: dict, additional_context: dict, target_resource_name: st
         data.update(additional_context)
     blueprint, pending = process_template(data)
 
-    if (
-        target_resource_name
-        and target_resource_name not in blueprint["resource"]
-        and target_resource_name not in blueprint["runtime"]
-    ):
+    if target_resource_name and target_resource_name not in blueprint["resource"] and target_resource_name not in blueprint["runtime"]:
         raise PlanException("Target resource or runtime not found: " + target_resource_name)
 
     for k, v in pending.items():
         if v.startswith("default.") or v.startswith("var."):
             if not k.find(".conditions."):
-                raise PlanException(
-                    f"Invalid blueprint. Unresolved static references. Variable not found: {v}. Required by {k}"
-                )
+                raise PlanException(f"Invalid blueprint. Unresolved static references. Variable not found: {v}. Required by {k}")
     deployment_id = blueprint["deploymentId"]
     state_file = deployment_id + ".state.yml"
     prev = data_util.load_data_file(state_file, default={})
@@ -93,6 +87,17 @@ def _prepare_data(data: dict, additional_context: dict, target_resource_name: st
 #             return True
 
 
+def resolve(data: dict, additional_context: dict = None, target_resource_name: str = None):
+    blueprint, state, state_file = _prepare_data(data, additional_context, None)
+    if target_resource_name:
+        if target_resource_name in blueprint["resource"]:
+            return blueprint["resource"][target_resource_name]["data"]
+        if target_resource_name in blueprint["runtime"]:
+            return blueprint["runtime"][target_resource_name]["data"]
+        raise PlanException("Target resource or runtime not found: " + target_resource_name)
+    return blueprint
+
+
 def apply(
     data: dict,
     additional_context: dict = None,
@@ -127,7 +132,7 @@ def apply(
         dag.process_blueprint(
             blueprint=blueprint,
             fn_process_node=process_resource_node,
-            continue_on_error=False,
+            fail_fast=True,
             reverse=False,
             concurrency=concurrency,
             target_node_name=target_resource_name,
@@ -249,7 +254,7 @@ def _deploy_res(name, res, state):
             action = handler.decide(res_data, res_state)
 
         if action == actions.skip:
-            kop.skip("Already deployed")
+            kop.skip(_get_res_text(handler, res_state))
             return
 
         if action == actions.recreate:
@@ -280,9 +285,7 @@ def _deploy_res(name, res, state):
             else:
                 new_state = handler.update(res_data, res_state)
         else:
-            raise PlanException(
-                f"Unknown action. This is a problem of the concrete plugin.decide function. Plugin={name}, action={action}"
-            )
+            raise PlanException(f"Unknown action. This is a problem of the concrete plugin.decide function. Plugin={name}, action={action}")
 
         if new_state:
             fn_set_state(new_state)
@@ -524,7 +527,7 @@ def _destroy_res(name, res_node, state, force):
 
 def destroy(
     data,
-    force: bool,
+    fail_fast: bool,
     target_resource_name: str = None,
     include_dependencies: bool = True,
     concurrency: int = 4,
@@ -542,7 +545,7 @@ def destroy(
         if not node:
             return dag.walker.next
 
-        _destroy_res(node_name, node, state, force)
+        _destroy_res(node_name, node, state, fail_fast)
         data_util.save_data_file(state, state_file)
         return dag.walker.next
 
@@ -550,7 +553,7 @@ def destroy(
         dag.process_blueprint(
             blueprint=blueprint,
             fn_process_node=destroy_resource,
-            continue_on_error=force,
+            fail_fast=fail_fast,
             reverse=True,
             concurrency=concurrency,
             target_node_name=target_resource_name,

hcs_core/plan/dag.py

@@ -15,7 +15,6 @@ limitations under the License.
 
 import threading
 import time
-import traceback
 from concurrent.futures import ThreadPoolExecutor
 from copy import deepcopy
 from graphlib import TopologicalSorter
@@ -72,7 +71,7 @@ class DAG:
 def process_blueprint(
     blueprint,
     fn_process_node: Callable,
-    continue_on_error: bool = False,
+    fail_fast: bool = False,
     reverse: bool = False,
     concurrency: int = 3,
     target_node_name: str = None,
@@ -88,7 +87,7 @@ def process_blueprint(
             return walker.next
         return fn_process_node(name)
 
-    return _walkthrough(dag, fn_process_node_impl, continue_on_error, concurrency)
+    return _walkthrough(dag, fn_process_node_impl, fail_fast, concurrency)
 
 
 def _filter_dag_by_target_node(dag: DAG, target_node_name, include_dependencies):
@@ -225,7 +224,7 @@ def _get_provider_id(node_data):
     return provider_type
 
 
-def _walkthrough(dag: DAG, fn_process_node: Callable, continue_on_error: bool, concurrency: int):
+def _walkthrough(dag: DAG, fn_process_node: Callable, fail_fast: bool, concurrency: int):
     topological_sorter = TopologicalSorter(dag.graph)
     topological_sorter.prepare()
     lock = threading.Lock()
@@ -250,10 +249,10 @@ def _walkthrough(dag: DAG, fn_process_node: Callable, continue_on_error: bool, c
         except Exception as e:
             with lock:
                 flags["err"] = e
-                if continue_on_error:
-                    topological_sorter.done(node_id)
-                else:
+                if fail_fast:
                     flag_stop.set()
+                else:
+                    topological_sorter.done(node_id)
         except SystemExit as e:
             with lock:
                 flags["err"] = e
@@ -292,7 +291,7 @@ def _walkthrough(dag: DAG, fn_process_node: Callable, continue_on_error: bool, c
             if flag_stop.is_set():
                 break
             with lock:
-                if not continue_on_error and flags["err"]:
+                if fail_fast and flags["err"]:
                     break
                 read_nodes = topological_sorter.get_ready()
             if not len(read_nodes):

hcs_core/plan/kop.py

@@ -1,5 +1,5 @@
 """
-Copyright 2023-2023 VMware Inc.
+Copyright 2025-2025 Omnissa Inc.
 SPDX-License-Identifier: Apache-2.0
 
 Licensed under the Apache License, Version 2.0 (the "License");
@@ -85,7 +85,8 @@ class KOP:
         self._started = False
         self._closed = False
         job_id = kind + "/" + name
-        _job_view.add(job_id, job_id)
+        if _job_view:
+            _job_view.add(job_id, job_id)
 
     def _job_id(self):
         return self._kind + "/" + self._name
@@ -103,7 +104,8 @@ class KOP:
 
     def id(self, res_id: str):
         self._id = res_id
-        _job_view.update(self._job_id(), res_id)
+        if _job_view:
+            _job_view.update(self._job_id(), res_id)
 
     def start(self, mode: str = None, eta: str = None):
         if self._started:
@@ -114,7 +116,8 @@ class KOP:
             self._mode = mode
         self._started = True
         self._add_log(KopAction.start)
-        _job_view.start(self._job_id(), eta)
+        if _job_view:
+            _job_view.start(self._job_id(), eta)
 
     def _success(self):
         if not self._started:
@@ -125,7 +128,8 @@ class KOP:
             raise KopException("Kop already closed. This is a framework logging issue.")
         self._add_log(KopAction.success)
         self._closed = True
-        _job_view.success(self._job_id())
+        if _job_view:
+            _job_view.success(self._job_id())
 
     def error(self, err):
         if isinstance(err, Exception):
@@ -136,12 +140,14 @@ class KOP:
             details = str(err)
         self._add_log(KopAction.error, details)
         self._closed = True
-        _job_view.error(self._job_id(), details)
+        if _job_view:
+            _job_view.error(self._job_id(), details)
 
     def skip(self, reason):
         self._add_log(KopAction.skip, reason)
         self._closed = True
-        _job_view.skip(self._job_id(), reason)
+        if _job_view:
+            _job_view.skip(self._job_id(), reason)
 
     def _add_log(self, action: str, details: str = None):
         labels = {
@@ -174,6 +180,12 @@ class KOP:
 
         if _job_view == _DummyJobView:
             log.info(msg)
+        elif _job_view is None:
+            # explicitly set by user to disable log
+            pass
+        else:
+            # custom job view
+            pass
         entry = {"name": self._name, "time": int(time.time()), "action": action, "id": self._id}
         if details:
             entry["details"] = details