WS-641: CARTA 2.0

Changes

carta_envoy

• Updated CARTA command and CARTA path to use appropriate settings for new CARTA 2.0 AppImage

Testing

• Tested on dev
• Updated unit tests

Completes WS-641

apps/cli/executables/pexable/carta_envoy/carta_envoy/connect.py

@@ -27,18 +27,17 @@ class RedisConnect:
     @staticmethod
     def generate_ids() -> dict:
         return {
-            "front_end_id": generate_random_str(),
-            "back_end_id": generate_random_str(),
+            "session_id": generate_random_str(),
             "wrapper_id": generate_random_str(),
             "system_name": generate_random_str(),
         }
 
     def generate_carta_url(self) -> str:
         self.logger.info("Generating CARTA url...")
-        front_end_id = self.generated_ids["front_end_id"]
-        back_end_id = self.generated_ids["back_end_id"]
+        session_id = self.generated_ids["session_id"]
         proxy = self.settings["reverse_proxy"]
-        carta_url = f"https://{proxy}/{front_end_id}/?socketUrl=wss://{proxy}/{back_end_id}/"
+        # carta_url = f"https://{proxy}/{front_end_id}/?socketUrl=wss://{proxy}/{session_id}/"
+        carta_url = f"https://{proxy}/{session_id}/"
         if self.settings["single_image"]:
             carta_url = carta_url + "&file=" + self.settings["image_name"]
 
@@ -73,26 +72,22 @@ class RedisConnect:
 
     def prepare_redis(self) -> dict:
         self.logger.info("Preparing Redis server...")
-        front_end_port = self.get_available_port()
-        back_end_port = self.get_available_port()
+        session_port = self.get_available_port()
         wrapper_port = self.get_available_port()
         carta_url = self.generate_carta_url()
         wrapper_url = self.generate_wrapper_url()
         self.conn = self.connect_to_redis()
         redis_values = self.get_redis_values(
             self.settings["reverse_proxy"],
-            self.generated_ids["front_end_id"],
-            self.generated_ids["back_end_id"],
+            self.generated_ids["session_id"],
             self.generated_ids["wrapper_id"],
-            front_end_port,
-            back_end_port,
+            session_port,
             wrapper_port,
         )
         self.set_redis_values(redis_values, int(self.settings["timeout"]))
 
         return {
-            "front_end_port": front_end_port,
-            "back_end_port": back_end_port,
+            "session_port": session_port,
             "wrapper_port": wrapper_port,
             "carta_url": carta_url,
             "wrapper_url": wrapper_url,
@@ -118,41 +113,38 @@ class RedisConnect:
     def get_redis_values(
         self,
         reverse_proxy_host: str,
-        front_end_id: str,
-        back_end_id: str,
+        session_id: str,
         carta_wrapper_id: str,
-        front_end_port: int,
-        back_end_port: int,
+        session_port: int,
         wrapper_port: int,
     ) -> Dict[str, str]:
         """
-        Get Redis key/value pairs for CARTA front end and back end setup
+        Get Redis key/value pairs for CARTA session setup
 
         :param reverse_proxy_host: Hostname for the reverse proxy
-        :param front_end_id: Random string ID for CARTA front end
-        :param back_end_id: Random string ID for CARTA back end
+        :param session_id: Random string ID for CARTA session
+        :param session_port: Port to run the CARTA session with
         :param carta_wrapper_id: Random string ID for CARTA wrapper
-        :param front_end_port: Port to run the CARTA front end with
-        :param back_end_port: Port to run the CARTA back end with
         :param wrapper_port: Port to run the CARTA wrapper with
         :return: Dictionary of values
         """
         self.logger.info("Determining values for Redis...")
-        service_name = generate_random_str()
-        front_end = f"carta-front-{service_name}"
-        back_end = f"carta-back-{service_name}"
-        carta_wrapper = f"carta-wrapper-{service_name}"
+        front_end = f"carta-front-{session_id}"
+        back_end = f"carta-back-{session_id}"
+        carta_wrapper = f"carta-wrapper-{carta_wrapper_id}"
         hostname = socket.getfqdn()
         values = {
             # FRONT END
-            f"traefik/http/routers/{front_end}/rule": f"Host(`{reverse_proxy_host}`) && PathPrefix(`/{front_end_id}/`)",
+            f"traefik/http/routers/{front_end}/rule": f"Host(`{reverse_proxy_host}`) && PathPrefix(`/{session_id}/`)",
             f"traefik/http/routers/{front_end}/service": front_end,
-            f"traefik/http/services/{front_end}/loadbalancer/servers/0/url": f"http://{hostname}:{front_end_port}/",
+            f"traefik/http/services/{front_end}/loadbalancer/servers/0/url": f"http://{hostname}:{session_port}/",
             f"traefik/http/routers/{front_end}/middlewares/0": "stripPrefixFE@file",
             # BACK END
-            f"traefik/http/routers/{back_end}/rule": f"Host(`{reverse_proxy_host}`) && PathPrefix(`/{back_end_id}/`)",
+            # Both sets of rules are very similar; small difference is with the missing / at end of PathPrefix
+            # This is needed to successfully connect to the web socket because CARTA says so
+            f"traefik/http/routers/{back_end}/rule": f"Host(`{reverse_proxy_host}`) && PathPrefix(`/{session_id}`)",
             f"traefik/http/routers/{back_end}/service": back_end,
-            f"traefik/http/services/{back_end}/loadbalancer/servers/0/url": f"http://{hostname}:{back_end_port}/",
+            f"traefik/http/services/{back_end}/loadbalancer/servers/0/url": f"http://{hostname}:{session_port}/",
             f"traefik/http/routers/{back_end}/middlewares/0": "upgradeWSHeader@file",
             f"traefik/http/routers/{back_end}/middlewares/1": "stripPrefixFE@file",
             # WRAPPER
@@ -162,11 +154,11 @@ class RedisConnect:
             f"traefik/http/routers/{carta_wrapper}/middlewares/0": "stripPrefixFE@file",
         }
 
-        unique_values = self.check_for_duplicate_values(values, front_end_port, back_end_port, wrapper_port)
+        unique_values = self.check_for_duplicate_values(values, session_port, wrapper_port)
         self.redis_values = unique_values
         return unique_values
 
-    def check_for_duplicate_values(self, redis_values: dict, front_port: int, back_port: int, wrapper_port: int):
+    def check_for_duplicate_values(self, redis_values: dict, session_port: int, wrapper_port: int):
         self.logger.info("Checking for duplicate values on server...")
         for key in redis_values:
             if self.conn.get(key):
@@ -174,11 +166,9 @@ class RedisConnect:
                 self.generated_ids = self.generate_ids()
                 new_values = self.get_redis_values(
                     self.settings["reverse_proxy"],
-                    self.generated_ids["front_end_id"],
-                    self.generated_ids["back_end_id"],
+                    self.generated_ids["session_id"],
                     self.generated_ids["wrapper_id"],
-                    front_port,
-                    back_port,
+                    session_port,
                     wrapper_port,
                 )
                 return new_values