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

hcs_core/sglib/ez_client.py

@@ -13,16 +13,45 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
-from authlib.integrations.httpx_client import OAuth2Client
+import json
+import logging
+import os
+import sys
+import threading
 from http.client import HTTPResponse
+from typing import Callable, Optional, Type
+
 import httpx
-from typing import Callable
-import logging
-import json
+from authlib.integrations.httpx_client import OAuth2Client
+from pydantic import BaseModel
+
 from hcs_core.ctxp import jsondot
 
 log = logging.getLogger(__name__)
 
+_print_http_error = True
+
+
+def parse(resp: httpx.Response):
+    if not resp.content:
+        return None
+    content_type = resp.headers["Content-Type"]
+    if content_type.startswith("text"):
+        return resp.text
+    if len(resp.content) > 3:
+        try:
+            data = resp.json()
+            if isinstance(data, list):
+                return [jsondot.dotify(obj) for obj in data]
+            elif isinstance(data, dict):
+                return jsondot.dotify(data)
+        except:
+            log.info("--- Fail parsing json. Dump content ---")
+            log.info(resp.content)
+            raise
+    else:
+        return None
+
 
 def _raise_on_4xx_5xx(response: httpx.Response):
     if not response.is_success:
@@ -97,66 +126,135 @@ def on404ReturnNone(func):
         raise
 
 
+def _raise_http_error(e: httpx.HTTPStatusError):
+    if _print_http_error:
+        print(e.response.text, file=sys.stderr)
+    raise e
+
+
 class EzClient:
-    def __init__(self, base_url: str, oauth_client: OAuth2Client = None, lazy_oauth_client: Callable = None) -> None:
+    def __init__(self, base_url: str = None, oauth_client: OAuth2Client = None, lazy_init: Callable = None) -> None:
         # self._client = httpx.Client(base_url=base_url, timeout=30, event_hooks=event_hooks)
-        self._base_url = base_url
-        self._client_impl = oauth_client
-        self._lazy_oauth_client = lazy_oauth_client
+
+        self._client_impl = None
+        self._lazy_init = lazy_init
+        self._lock = threading.Lock()
+
+        if lazy_init:
+            if base_url:
+                raise ValueError("Cannot use both base_url and lazy_init")
+            if oauth_client:
+                raise ValueError("Cannot use both oauth_client and lazy_init")
+        else:
+            if not base_url:
+                raise ValueError("base_url must be provided if lazy_init is not used")
+            if not oauth_client:
+                raise ValueError("oauth_client must be provided if lazy_init is not used")
+            self._init_client(base_url, oauth_client)
+
+    def _init_client(self, base_url: str, client: OAuth2Client):
+        if base_url.endswith("/"):
+            base_url = base_url[:-1]
+        client.base_url = base_url
+        client.timeout = int(os.environ.get("HCS_TIMEOUT", 30))
+        request_hooks = client.event_hooks["request"]
+        response_hooks = client.event_hooks["response"]
+        if _log_request not in request_hooks:
+            request_hooks.append(_log_request)
+        if _log_response not in response_hooks:
+            response_hooks.append(_log_response)
+        if _raise_on_4xx_5xx not in response_hooks:
+            response_hooks.append(_raise_on_4xx_5xx)
+        self._client_impl = client
 
     def _client(self):
-        if not self._client_impl:
-            client = self._lazy_oauth_client()
-            client.base_url = self._base_url
-            client.timeout = 30
-            request_hooks = client.event_hooks["request"]
-            response_hooks = client.event_hooks["response"]
-            if _log_request not in request_hooks:
-                request_hooks.append(_log_request)
-            if _log_response not in response_hooks:
-                response_hooks.append(_log_response)
-            if _raise_on_4xx_5xx not in response_hooks:
-                response_hooks.append(_raise_on_4xx_5xx)
-            self._client_impl = client
-        return self._client_impl
-
-    def post(self, url: str, json: dict = None, text: str = None, files=None, headers: dict = None):
-        resp = self._client().post(url, json=json, content=text, files=files, headers=headers)
-        return _parse_resp(resp)
+        self._lock.acquire()
+        try:
+            if self._lazy_init:
+                base_url, client = self._lazy_init()
+                self._init_client(base_url, client)
+                self._lazy_init = None
+
+            self._client_impl.ensure_token()
+            return self._client_impl
+        finally:
+            self._lock.release()
 
-    def get(self, url: str, raise_on_404: bool = False):
+    def post(
+        self,
+        url: str,
+        json: dict = None,
+        text: str = None,
+        files=None,
+        headers: dict = None,
+        type: Optional[Type[BaseModel]] = None,
+        timeout: float = 30.0,
+    ):
+        # import json as jsonlib
+        # print("->", self._client().base_url, url, jsonlib.dumps(json, indent=4))
         try:
-            resp = self._client().get(url)
-            return _parse_resp(resp)
+            resp = self._client().post(url, json=json, content=text, files=files, headers=headers, timeout=timeout)
+        except httpx.HTTPStatusError as e:
+            _raise_http_error(e)
+        data = _parse_resp(resp)
+        if data and type:
+            try:
+                return type.model_validate(data)
+            except:
+                log.info("--- Fail converting model. Dump content ---")
+                log.info(data)
+                raise
+        return data
+
+    def get(self, url: str, headers: dict = None, raise_on_404: bool = False, type: Optional[Type[BaseModel]] = None):
+        try:
+            # print("->", self._client().base_url, url)
+            resp = self._client().get(url, headers=headers)
+            data = _parse_resp(resp)
+            if data and type:
+                try:
+                    return type.model_validate(data)
+                except:
+                    log.info("--- Fail converting model. Dump content ---")
+                    log.info(data)
+                    raise
+            return data
         except httpx.HTTPStatusError as e:
             if _is_404(e):
                 if raise_on_404:
-                    raise e
+                    _raise_http_error(e)
                 else:
                     pass
             else:
-                raise
+                _raise_http_error(e)
 
-    def patch(self, url: str, json: dict):
-        resp = self._client().patch(url, json=json)
-        return _parse_resp(resp)
+    def patch(self, url: str, json: dict = None, text=None, headers: dict = None):
+        try:
+            resp = self._client().patch(url, json=json, content=text, headers=headers)
+            return _parse_resp(resp)
+        except httpx.HTTPStatusError as e:
+            _raise_http_error(e)
+            raise
 
-    def delete(self, url: str, raise_on_404: bool = False):
+    def delete(self, url: str, headers: dict = None, raise_on_404: bool = False):
         try:
-            resp = self._client().delete(url)
+            resp = self._client().delete(url, headers=headers)
             return _parse_resp(resp)
         except httpx.HTTPStatusError as e:
             if _is_404(e):
                 if raise_on_404:
-                    raise
+                    _raise_http_error(e)
                 else:
                     pass
             else:
-                raise
+                _raise_http_error(e)
 
-    def put(self, url: str, json: dict):
-        resp = self._client().put(url, json=json)
-        return _parse_resp(resp)
+    def put(self, url: str, json: dict = None, text=None, headers: dict = None):
+        try:
+            resp = self._client().put(url, json=json, content=text, headers=headers)
+            return _parse_resp(resp)
+        except httpx.HTTPStatusError as e:
+            _raise_http_error(e)
 
     def close(self):
         self._client().close()

hcs_core/sglib/hcs_client.py

@@ -13,15 +13,9 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
-from hcs_core.ctxp import profile
-from .ez_client import EzClient
 from . import auth as auth
+from .ez_client import EzClient
 
 
-def hcs_client(url: str) -> EzClient:
-    if not url:
-        url = profile.current().hcs.url
-    if url.endswith("/"):
-        url = url[:-1]
-
-    return EzClient(url, lazy_oauth_client=auth.oauth_client)
+def hcs_client(url: str, custom_auth: dict = None) -> EzClient:
+    return EzClient(base_url=url, oauth_client=auth.oauth_client(custom_auth))

hcs_core/sglib/init.py

@@ -0,0 +1,17 @@
+import atexit
+import logging
+
+log = logging.getLogger(__name__)
+_sg_client = None
+
+
+# Work around issue:
+# http11.py, line 211, in close: AttributeError: 'NoneType' object has no attribute 'CLOSED'
+def _on_exit():
+    if _sg_client:
+        _sg_client.close()
+
+    log.info("Exit")
+
+
+atexit.register(_on_exit)

hcs_core/sglib/login_support.py

@@ -16,17 +16,16 @@ limitations under the License.
 # nanw @ 2023
 # PKCE with authlib: https://docs.authlib.org/en/latest/specs/rfc7636.html
 
+import logging
+import platform
+import secrets
 import threading
-import time
-from typing import Callable
 import webbrowser
-import secrets
-import logging
-from hcs_core.util.scheduler import ThreadPoolScheduler
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from urllib.parse import parse_qs, urlparse
+
 from authlib.integrations.httpx_client import OAuth2Client
 from authlib.oauth2.rfc7636 import create_s256_code_challenge
-from http.server import BaseHTTPRequestHandler, HTTPServer
-from urllib.parse import urlparse, parse_qs
 
 log = logging.getLogger(__name__)
 
@@ -35,10 +34,12 @@ _callback_url = "/hcs-cli/oauth/callback"
 
 _public_client_ids = {
     "production": "ldjmWbBAUcSB1w3HSbzoYcdKoloYFqT2dWK",
+    # "production": "WbvEYXK4abljPJUuY2zODLpOaX5ddH2uhMX",    #collie mobile
     "staging": "BbwHlgWt0vFwPUZMJTb5IKltynXjDmb46IO",
 }
 
 _auth_code_event = threading.Event()
+_auth_code_event.value = None
 _state = None
 
 _auth_success_html = """
@@ -62,10 +63,10 @@ _auth_success_html = """
     </style>
 </head>
 <body>
-    <h3>You have successfully logged into VMware Horizon Cloud Service.</h3>
+    <h3>You have successfully logged into Omnissa Horizon Cloud Service.</h3>
     <p>You can close this window, and return to the terminal.</p>
     <br/>
-    <p><a href="https://github.com/euc-eng/hcs-cli">HCS CLI</a> is in beta phase. <a href="https://github.com/euc-eng/hcs-cli/blob/main/doc/hcs-cli-cheatsheet.md">Cheatsheet</a>:</p>
+    <p><a href="https://github.com/euc-eng/hcs-cli/blob/dev/README.md">HCS CLI</a> is in tech preview. <a href="https://github.com/euc-eng/hcs-cli/blob/main/doc/hcs-cli-cheatsheet.md">Cheatsheet</a>:</p>
     <code>
     # To get the login details: <br/>
     hcs login -d <br/><br/>
@@ -167,9 +168,18 @@ def do_oauth2_pkce(csp_url: str, client_id: str, org_id: str):
     webbrowser.open(authorization_url, new=0, autoraise=True)
 
     try:
-        _auth_code_event.wait()
-    except:
-        log.info("Aborted")
+        # On Windows, wait() without timeout doesn't respond to CTRL+C properly
+        # Use a polling loop with timeout to allow KeyboardInterrupt to be caught
+        if platform.system() == "Windows":
+            while not _auth_code_event.wait(timeout=0.5):
+                pass  # Keep waiting until the event is set
+        else:
+            _auth_code_event.wait()
+    except KeyboardInterrupt:
+        log.info("Aborted by user")
+        return
+    except Exception as e:
+        log.error(f"Login error: {e}")
         return
     # Once the user is redirected back to your app with an authorization code, exchange it for an access token
     authorization_code = _auth_code_event.value
@@ -206,77 +216,6 @@ def login_via_browser(csp_url: str, org_id: str):
     return do_oauth2_pkce(csp_url, client_id, org_id)
 
 
-def create_oauth_client(
-    oauth_token: dict, csp_url: str, fn_on_new_oauth_token: Callable = None, fn_custom_refresh: Callable = None
-):
-    client_id = identify_client_id(csp_url)
-
-    if not fn_custom_refresh and client_id:
-        client = OAuth2Client(
-            client_id=client_id,
-            client_secret="",  # Required by CSP auth
-            token=oauth_token,
-            token_endpoint=csp_url + "/csp/gateway/am/api/auth/token",
-            token_endpoint_auth_method="client_secret_basic",
-            update_token=fn_on_new_oauth_token,
-        )
-    else:
-        # This is the case for production today, no csp-oauth-app yet,
-        # and auth with API token case.
-        client = OAuth2Client(
-            # client_id=client_id,
-            # client_secret="",  # Required by CSP auth
-            token=oauth_token,
-            # token_endpoint=csp_url + "/csp/gateway/am/api/auth/token",
-            # token_endpoint_auth_method="client_secret_basic",
-            # update_token=fn_on_new_oauth_token,
-        )
-        # start our own token refresh timer. Refresh using provided method
-        if oauth_token and fn_on_new_oauth_token:
-            _register_custom_refresher(client, oauth_token, fn_on_new_oauth_token, fn_custom_refresh)
-        else:
-            # not even initialized.
-            pass
-    return client
-
-
-_scheduler: ThreadPoolScheduler = None
-
-
-def _register_custom_refresher(
-    client: OAuth2Client, oauth_token, fn_on_new_oauth_token: Callable, fn_custom_refresh: Callable
-):
-    global _scheduler
-    if not _scheduler:
-        _scheduler = ThreadPoolScheduler()
-
-    def get_refresh_delay(token):
-        return token["expires_at"] - time.time() - 30
-
-    def refresh_impl():
-        if client.is_closed:
-            return
-        new_token = fn_custom_refresh()
-        client.token = new_token
-        fn_on_new_oauth_token(new_token)
-        delay = get_refresh_delay(new_token)
-        _scheduler.submit(refresh_impl, delay)
-
-    delay = get_refresh_delay(oauth_token)
-    _scheduler.submit(refresh_impl, delay)
-
-
-def refresh_oauth_token(old_oauth_token: dict, csp_url: str):
-    with create_oauth_client(old_oauth_token, csp_url) as client:
-        token_endpoint = csp_url + "/csp/gateway/am/api/auth/token"
-        new_token = client.refresh_token(token_endpoint)
-        if not new_token:
-            raise Exception("CSP auth refresh failed.")
-        if "cspErrorCode" in new_token:
-            raise Exception(f"CSP auth failed: {new_token.get('message')}")
-    return new_token
-
-
 # def _test():
 #     import jwt
 #     import json

hcs_core/sglib/payload_util.py

@@ -1,7 +1,9 @@
 import json
+
 import yaml
-from .cli_options import get_org_id
+
 from ..ctxp import CtxpException
+from .cli_options import get_org_id
 
 
 def get_payload_with_defaults(file_arg, org: str):

hcs_core/sglib/requtil.py

@@ -0,0 +1,38 @@
+import logging
+
+import httpx
+
+from hcs_core.ctxp import jsondot
+
+log = logging.getLogger(__name__)
+
+
+def parse(resp: httpx.Response):
+    if not resp.content:
+        return None
+    content_type = resp.headers["Content-Type"]
+    if content_type.startswith("text"):
+        return resp.text
+    if len(resp.content) > 3:
+        try:
+            data = resp.json()
+            if isinstance(data, list):
+                return [jsondot.dotify(obj) for obj in data]
+            elif isinstance(data, dict):
+                return jsondot.dotify(data)
+        except:
+            log.info("--- Fail parsing json. Dump content ---")
+            log.info(resp.content)
+            raise
+    else:
+        return None
+
+
+def on404ReturnNone(func):
+    try:
+        resp = func()
+        return parse(resp)
+    except httpx.HTTPStatusError as e:
+        if e.response.status_code == 404:
+            return None
+        raise

hcs_core/sglib/utils.py

@@ -0,0 +1,107 @@
+import os
+import subprocess
+import time
+import zipfile
+
+from hcs_core.ctxp import jsondot
+
+
+def _print_output(text, name):
+    if len(text) == 0:
+        print(name + ": <EMPTY>")
+    else:
+        print(name + ":")
+        lines = text.splitlines()
+        for line in lines:
+            print(">> " + line)
+
+
+def run(cmd, check=True):
+    print("CMD: " + cmd)
+    parts = cmd.split(" ")
+    proc = subprocess.run(
+        parts,
+        shell=False,
+        check=False,
+        text=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        encoding="utf-8",
+    )
+    if check and proc.returncode != 0:
+        _print_output(proc.stdout, "STDOUT")
+        _print_output(proc.stderr, "STDERR")
+        proc.check_returncode()
+    return proc
+
+
+def _run_and_capture_output(cmd):
+    proc = subprocess.run(cmd, shell=True, check=False, text=True, capture_output=True, encoding="utf-8")
+    if proc.returncode != 0:
+        _print_output(proc.stdout, "STDOUT")
+        _print_output(proc.stderr, "STDERR")
+        proc.check_returncode()
+    return proc.stdout.strip()
+
+
+def run_govc_guest_script(script, args):
+    print("Running guest script: " + script + " " + args)
+    cmd = f'govc guest.start {script} "{args} >/tmp/script-out 2>/tmp/script-err"'
+    output = _run_and_capture_output(cmd)
+
+    # wait for the process to finish
+    cmd = f"govc guest.ps -X -x -json -p {output}"
+    output = _run_and_capture_output(cmd)
+    ret = jsondot.parse(output)
+
+    output = _run_and_capture_output("govc guest.download /tmp/script-out -")
+    _print_output(output, "STDOUT")
+    output = _run_and_capture_output("govc guest.download /tmp/script-err -")
+    if len(output) > 0:
+        _print_output(output, "STDERR")
+
+    if ret.ProcessInfo[0].ExitCode != 0:
+        raise Exception("Fail running script: " + script)
+
+
+def waitForVmPowerOff(iPath):
+
+    def current_millis():
+        return int(round(time.time() * 1000))
+
+    start_time = current_millis()
+    while current_millis() - start_time < 5 * 60 * 1000:
+        p = subprocess.run(
+            "govc vm.info -vm.ipath=" + iPath,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            shell=True,
+        )
+        if str(p.stdout).find("poweredOff") > 0:
+            return
+        time.sleep(5)
+    raise Exception("Timeout customization. Check log in deployer VM.")
+
+
+def zipdir(src_dir, target_file):
+    with zipfile.ZipFile(target_file, "w", zipfile.ZIP_DEFLATED) as file:
+        for root, dirs, files in os.walk(src_dir):
+            for name in files:
+                filePath = os.path.join(root, name)
+                arcname = filePath[len(src_dir) :]
+                file.write(filePath, arcname)
+
+
+def dos2unix(file):
+    file = os.path.abspath(file)
+    content = ""
+    outsize = 0
+    with open(file, "rb") as infile:
+        content = infile.read()
+    with open(file, "wb") as output:
+        for line in content.splitlines():
+            outsize += len(line) + 1
+            output.write(line + b"\n")
+    stripped_bytes = len(content) - outsize
+    if stripped_bytes != 0:
+        print("dos2unix: Stripped %s bytes. %s" % (stripped_bytes, file))

hcs_core/util/check_license.py

@@ -13,8 +13,6 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
-#!/usr/bin/env -S python3 -W ignore
-
 import os
 import sys
 

hcs_core/util/duration.py

@@ -14,7 +14,7 @@ limitations under the License.
 """
 
 import re
-from datetime import timedelta, datetime, timezone
+from datetime import datetime, timedelta, timezone
 
 PATTERN = re.compile("^(([0-9]+)D)?(([0-9]+)H)?(([0-9]+)M)?(([0-9]+)S)?$")
 
@@ -116,10 +116,13 @@ def to_utc(dt):
 
 
 def stale(when) -> str:
+    return format_timedelta(from_now(when), True)
+
+
+def from_now(when) -> timedelta:
     when_utc = to_utc(when)
     now_utc = datetime.now().astimezone(timezone.utc)
-    diff = now_utc - when_utc
-    return format_timedelta(diff, True)
+    return now_utc - when_utc
 
 
 def _test():