poetry-plugin-ivcap 0.4.2__tar.gz → 0.5.1__tar.gz

{poetry_plugin_ivcap-0.4.2 → poetry_plugin_ivcap-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: poetry-plugin-ivcap
-Version: 0.4.2
+Version: 0.5.1
 Summary: A custom Poetry command for IVCAP deployments
 License: MIT
 Author: Max Ott

{poetry_plugin_ivcap-0.4.2 → poetry_plugin_ivcap-0.5.1}/poetry_plugin_ivcap/ivcap.py

@@ -3,6 +3,7 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file. See the AUTHORS file for names of contributors.
 #
+import argparse
 import os
 import re
 import subprocess
@@ -12,6 +13,9 @@ import uuid
 import humanize
 import subprocess
 import requests
+import time
+import json
+
 
 from .constants import DEF_POLICY, PLUGIN_NAME, POLICY_OPT, SERVICE_FILE_OPT, SERVICE_ID_OPT, DEF_IVCAP_BASE_URL
 
@@ -143,28 +147,26 @@ def exec_job(data, args, is_silent, line):
         requests.Response: The response object from the API call.
     """
     # Parse 'args' for run options
+    p = exec_parser()
     if not isinstance(args, list) or len(args) < 1:
-        raise Exception("args must be a list with at least one element")
-    file_name = args[0]
-    timeout = 5 # default timeout
-    if len(args) == 1:
-        pass  # only file_name provided
-    elif len(args) == 3 and args[1] == '--timeout':
-        try:
-            timeout = int(args[2])
-        except ValueError:
-            raise Exception("Timeout value must be an integer")
-    else:
-        raise Exception("args must be [file_name] or [file_name, '--timeout', value]")
-
+        p.error("missing request file name")
+        # raise Exception("args must be a list with at least one element")
+    file_name = args.pop(0)
+    if file_name == "-h" or file_name == "--help":
+        p.print_help()
+        return
+    pa = p.parse_args(args)
+    timeout = 0 if pa.stream else pa.timeout
     # Get access token using ivcap CLI
-    try:
-        token = subprocess.check_output(
-            ["ivcap", "--silent", "context", "get", "access-token", "--refresh-token"],
-            text=True
-        ).strip()
-    except Exception as e:
-        raise RuntimeError(f"Failed to get IVCAP access token: {e}")
+    token = pa.auth_token
+    if not token:
+        try:
+            token = subprocess.check_output(
+                ["ivcap", "--silent", "context", "get", "access-token", "--refresh-token"],
+                text=True
+            ).strip()
+        except Exception as e:
+            raise RuntimeError(f"Failed to get IVCAP access token: {e}")
 
    # Get IVCAP deployment URL
     try:
@@ -202,34 +204,6 @@ def exec_job(data, args, is_silent, line):
     except Exception as e:
         raise RuntimeError(f"Job submission failed: {e}")
 
-    # Handle response according to requirements
-    import time
-    import json
-
-    def handle_response(resp):
-        content_type = resp.headers.get("content-type", "")
-        if resp.status_code >= 300:
-            line(f"<warning>WARNING: Received status code {resp.status_code}</warning>")
-            line(f"<info>Headers: {str(resp.headers)}</info>")
-            line(f"<info>Body: {str(resp.text)}</info>")
-        elif resp.status_code == 200:
-            if "application/json" in content_type:
-                try:
-                    parsed = resp.json()
-                    status = parsed.get("status")
-                    if status and (not status in ["succeeded", "failed", "error"]):
-                        return status
-                    print(json.dumps(parsed, indent=2, sort_keys=True))
-                    return None
-                except Exception as e:
-                    line(f"<warning>Failed to parse JSON response: {e}</warning>")
-                    line(f"<warning>Headers: {str(resp.headers)}</warning>")
-            else:
-                line(f"<info>Headers: {str(resp.headers)}</info>")
-        else:
-            line(f"<warning>Received status code {resp.status_code}</warning>")
-            line(f"<warning>Headers: {str(resp.headers)}</warning>")
-        return "unknown"
 
     if response.status_code == 202:
         try:
@@ -239,36 +213,176 @@ def exec_job(data, args, is_silent, line):
             location = f"{payload.get('location')}"
             job_id = payload.get("job-id")
             retry_later = payload.get("retry-later", 5)
-            if not is_silent:
-                line(f"<debug>Job '{job_id}' accepted, but no result yet. Polling in {retry_later} seconds.</debug>")
-            while True:
-                time.sleep(retry_later)
-                poll_headers = {
-                    "Authorization": f"Bearer {token}"
-                }
-                poll_resp = requests.get(location, headers=poll_headers)
-                if poll_resp.status_code == 202:
-                    try:
-                        poll_payload = poll_resp.json()
-                        location = poll_payload.get("location", location)
-                        retry_later = poll_payload.get("retry-later", retry_later)
-                        if not is_silent:
-                            line(f"<debug>Still processing. Next poll in {retry_later} seconds.</debug>")
-                    except Exception as e:
-                        line(f"<error>Failed to parse polling response: {e}</error>")
-                        break
-                else:
-                    status = handle_response(poll_resp)
-                    if status:
-                        if not is_silent:
-                            line(f"<debug>Status: '{status}'. Next poll in {retry_later} seconds.</debug>")
-                    else:
-                        break
-
         except Exception as e:
             line(f"<error>Failed to handle 202 response: {e}</error>")
+
+        if  pa.stream:
+            stream_result(location, job_id, token, pa, is_silent, line)
+        else:
+            poll_for_result(location, job_id, retry_later, token, is_silent, line)
+
     else:
-        handle_response(response)
+        handle_response(response, line)
+
+def handle_response(resp, line):
+    content_type = resp.headers.get("content-type", "")
+    if resp.status_code >= 300:
+        line(f"<warning>WARNING: Received status code {resp.status_code}</warning>")
+        line(f"<info>Headers: {str(resp.headers)}</info>")
+        line(f"<info>Body: {str(resp.text)}</info>")
+    elif resp.status_code == 200:
+        if "application/json" in content_type:
+            try:
+                parsed = resp.json()
+                status = parsed.get("status")
+                if status and (not status in ["succeeded", "failed", "error"]):
+                    return status
+                print(json.dumps(parsed, indent=2, sort_keys=True))
+                return None
+            except Exception as e:
+                line(f"<warning>Failed to parse JSON response: {e}</warning>")
+                line(f"<warning>Headers: {str(resp.headers)}</warning>")
+        else:
+            line(f"<info>Headers: {str(resp.headers)}</info>")
+    else:
+        line(f"<warning>Received status code {resp.status_code}</warning>")
+        line(f"<warning>Headers: {str(resp.headers)}</warning>")
+    return "unknown"
+
+def poll_for_result(location, job_id, retry_later, token, is_silent, line):
+    if not is_silent:
+        line(f"<debug>Job '{job_id}' accepted, but no result yet. Polling in {retry_later} seconds.</debug>")
+    while True:
+        time.sleep(retry_later)
+        poll_headers = {
+            "Authorization": f"Bearer {token}"
+        }
+        poll_resp = requests.get(location, headers=poll_headers)
+        if poll_resp.status_code == 202:
+            try:
+                poll_payload = poll_resp.json()
+                location = poll_payload.get("location", location)
+                retry_later = poll_payload.get("retry-later", retry_later)
+                if not is_silent:
+                    line(f"<debug>Still processing. Next poll in {retry_later} seconds.</debug>")
+            except Exception as e:
+                line(f"<error>Failed to parse polling response: {e}</error>")
+                break
+        else:
+            status = handle_response(poll_resp, line)
+            if status:
+                if not is_silent:
+                    line(f"<debug>Status: '{status}'. Next poll in {retry_later} seconds.</debug>")
+            else:
+                break
+
+CONNECT_TIMEOUT = 5
+READ_TIMEOUT = 120  # ensure server sends heartbeat within this window
+
+def stream_result(location, job_id, token, pa, is_silent, line):
+    """
+    Stream the result content from the given location using the provided token.
+    """
+    if not is_silent:
+        line(f"<debug>Job '{job_id}' accepted, Waiting for events now.</debug>")
+    headers = {
+        "Authorization": f"Bearer {token}",
+        "Accept": "text/event-stream",
+        "Cache-Control": "no-cache",
+        "Connection": "keep-alive",
+    }
+    url = location + "/events"
+    session = requests.Session()
+    last_event_id = None
+    backoff = 1.0
+    while True:
+        try:
+            if last_event_id:
+                headers["Last-Event-ID"] = last_event_id
+            with session.get(url, stream=True, headers=headers, timeout=(CONNECT_TIMEOUT, READ_TIMEOUT)) as r:
+                r.raise_for_status()
+                # Reset backoff on successful connect
+                backoff = 1.0
+                for row in r.iter_lines(decode_unicode=True, chunk_size=1):
+                    if row is None:
+                        continue
+                    if row.startswith(":"):
+                        # comment/heartbeat
+                        continue
+                    if row.startswith("id:"):
+                        last_event_id = row[3:].strip()
+                        continue
+                    if print_sse_row(row, pa, line):  # raw SSE lines (e.g., "data: {...}", "event: message")
+                        return # done
+
+        except (requests.exceptions.ChunkedEncodingError,
+                requests.exceptions.ConnectionError,
+                requests.exceptions.ReadTimeout) as e:
+            if not is_silent:
+                line(f"<debug>stream error: {e}; reconnecting in {backoff:.1f}s</debug>")
+            time.sleep(backoff)
+            backoff = min(backoff * 2, 30.0)  # cap backoff
+            continue
+        except requests.HTTPError as e:
+            # Non-200 or similar; backoff and retry
+            if not is_silent:
+                line(f"<debug>http error: {e}; reconnecting in {backoff:.1f}s</debug>")
+            time.sleep(backoff)
+            backoff = min(backoff * 2, 60.0)
+        except Exception:
+            line(f"<error>Failed to fetch events: {type(e)} - {e}</error>")
+            break
+
+#     except requests.exceptions.ChunkedEncodingError as ce:
+#         line(f"<error>Chunked encoding error: {ce}</error>")
+#     except Exception as e:
+#         line(f"<error>Failed to fetch events: {type(e)} - {e}</error>")
+
+def print_sse_row(row, pa, line) -> bool:
+    if pa.raw_events:
+        print(row)
+        return False  # continue streaming
+    elif row.startswith("data: "):
+        # JSON data
+        print("----")
+        try:
+            data = json.loads(row[6:])
+            print(json.dumps(data, indent=2, sort_keys=True))
+            return check_if_done(data)
+        except json.JSONDecodeError as e:
+            line(f"<error>Failed to decode JSON: {e}</error>")
+
+
+def check_if_done(data) -> bool:
+    # {
+    #     "Data": {
+    #         "job-urn": "urn:ivcap:job:3e466031-ec8b-44eb-aec6-dc2f8212bec3",
+    #         "status": "succeeded"
+    #     },
+    #     "Type": "ivcap.job.status"
+    # }
+    if "Type" in data and data["Type"] == "ivcap.job.status":
+        if "Data" in data and "status" in data["Data"]:
+            status = data["Data"]["status"]
+            if status in ["succeeded", "failed", "error"]:
+                return True
+    return False  # continue streaming
+
+def exec_parser():
+    p = argparse.ArgumentParser(prog="poetry ivcap job-exec request_file --")
+    p.add_argument("--timeout", type=nonneg_int, default=5, help="[5] seconds; 0 allowed")
+    p.add_argument("--with-result-content", dest="with_result_content", action="store_true",
+                   help="include result content in the response")
+    p.add_argument("--stream", action="store_true", help="stream the result content")
+    p.add_argument("--raw-events", action="store_true", help="print raw SSE events")
+    p.add_argument("--auth-token", help="alternative auth token to use")
+    return p
+
+def nonneg_int(s: str) -> int:
+    v = int(s)
+    if v < 0:
+        raise argparse.ArgumentTypeError("timeout must be >= 0")
+    return v
 
 def get_account_id(data, line, is_silent=False):
     check_ivcap_cmd(line)

{poetry_plugin_ivcap-0.4.2 → poetry_plugin_ivcap-0.5.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "poetry-plugin-ivcap"
-version = "0.4.2"
+version = "0.5.1"
 description = "A custom Poetry command for IVCAP deployments"
 authors = ["Max Ott <max.ott@csiro.au>"]
 license = "MIT"