use separate sender script

Author: shokakucarrier

charon/pkgs/radas_signature_handler.py

@@ -19,12 +19,13 @@
 import os
 import asyncio
 import sys
-import tempfile
+import threading
 import uuid
 from typing import List, Any, Tuple, Callable, Dict
 from charon.config import get_config, RadasConfig
 from charon.pkgs.oras_client import OrasClient
 from proton import SSLDomain, Message, Event
+from proton.utils import BlockingConnection
 from proton.handlers import MessagingHandler
 from proton.reactor import Container
 
@@ -45,7 +46,6 @@ def __init__(self, sign_result_loc: str, request_id: str) -> None:
         self.sign_result_loc = sign_result_loc
         self.request_id = request_id
         self.conn = None
-        self.timer_task = None  
 
     def on_start(self, event: Event) -> None:
         """
@@ -129,39 +129,56 @@ def _process_message(self, msg: Any) -> None:
         logger.info("Number of files pulled: %d, path: %s", len(files), files[0])
 
 
-def sign_in_radas(repo_url: str,
-                  requester: str,
-                  sign_key: str,
-                  result_path: str,
-                  ignore_patterns: List[str],
-                  radas_config: RadasConfig):
+
+class RadasSender(MessagingHandler):
     """
-    This function will be responsible to do the overall controlling of the whole process,
-    like trigger the send and register the receiver, and control the wait and timeout there.
+    This simple sender will send given string massage to UMB message queue to request signing.
+    Attributes:
+        payload (str): payload json string for radas to read,
+        this value construct from the cmd flag
     """
-    logger.debug("params. repo_url: %s, requester: %s, sign_key: %s, result_path: %s,"
-                 "radas_config: %s", repo_url, requester, sign_key, result_path, radas_config)
-    request_id = str(uuid.uuid4())
-    exclude = ignore_patterns if ignore_patterns else []
+    def __init__(self, payload: str):
+        super().__init__()
+        self.payload = payload
+        self.container = None
 
-    payload = {
-        "request_id": request_id,
-        "requested_by": requester,
-        "type": "mrrc",
-        "file_reference": repo_url,
-        "sig_keyname": sign_key,
-        "exclude": exclude
-    }
+    def on_start(self, event):
+        """
+        On start callback
+        """
+        conf = get_config()
+        if not (conf and conf.is_radas_enabled()):
+            sys.exit(1)
 
-    temp_dir = tempfile.mktemp()
-    listener = RadasReceiver(temp_dir, json.dumps(payload))
+        rconf = conf.get_radas_config()
+        if rconf is None:
+            sys.exit(1)
 
-    try:
-        Container(listener).run()
-        logger.info("Successfully sent signing request ID: %s", request_id)
-    finally:
-        if listener.conn and not listener.conn.closed:
-            listener.conn.close()
+        ssl_domain = SSLDomain(SSLDomain.MODE_CLIENT)
+        ssl_domain.set_credentials(
+            rconf.client_ca(),
+            rconf.client_key(),
+            rconf.client_key_password()
+        )
+        ssl_domain.set_trusted_ca_db(rconf.root_ca())
+        ssl_domain.set_peer_authentication(SSLDomain.VERIFY_PEER)
+
+        self.conn = event.container.connect(
+            url = rconf.umb_target(), 
+            ssl_domain=ssl_domain
+        )
+        self.container = event.container
+        self.sender = event.container.create_sender(self.conn, rconf.request_queue())
+
+    def on_sendable(self):
+        """
+        On message able to send callback
+        """
+        request = self.payload
+        msg = Message(body=request)
+        self.sender.send(msg)
+        if self.container:
+            self.container.stop()
 
 
 def generate_radas_sign(top_level: str, sign_result_loc: str) -> Tuple[List[str], List[str]]:
@@ -257,4 +274,34 @@ def sign_in_radas(repo_url: str,
                   result_path: str,
                   ignore_patterns: List[str],
                   radas_config: RadasConfig):
-    logger.info("Start signing for %s", repo_url)
+    """
+    This function will be responsible to do the overall controlling of the whole process,
+    like trigger the send and register the receiver, and control the wait and timeout there.
+    """
+    logger.debug("params. repo_url: %s, requester: %s, sign_key: %s, result_path: %s,"
+                 "radas_config: %s", repo_url, requester, sign_key, result_path, radas_config)
+    request_id = str(uuid.uuid4())
+    exclude = ignore_patterns if ignore_patterns else []
+
+    payload = {
+        "request_id": request_id,
+        "requested_by": requester,
+        "type": "mrrc",
+        "file_reference": repo_url,
+        "sig_keyname": sign_key,
+        "exclude": exclude
+    }
+
+    listener = RadasReceiver(result_path, request_id)
+    sender = RadasSender(json.dumps(payload))
+
+    try:
+        Container(sender).run()
+        logger.info("Successfully sent signing request ID: %s", request_id)
+        Container(listener).run()
+
+    finally:
+        if listener.conn is not None:
+            listener.conn.close()
+        if sender.conn is not None:
+            sender.conn.close()