Master container fixes

Author: frankcorneliusmartin

vantage/node/docker_manager.py

@@ -278,13 +278,9 @@ def get_result(self):
         self.active_tasks.remove(finished_task)
 
         # retrieve results from file        
-        with open(finished_task["output_file"]) as fp:
+        with open(finished_task["output_file"], "rb") as fp:
             results = fp.read()
 
-        import json
-        if results:
-            results = json.loads(results)
-        
         return Result(
             result_id=finished_task["result_id"], 
             logs=log, 

vantage/node/proxy_server.py

@@ -13,6 +13,7 @@
 import requests
 import os
 import logging
+import json
 
 from flask import Flask, request, jsonify
 
@@ -21,6 +22,7 @@
     unpack_bytes_from_transport, 
     prepare_bytes_for_transport
 )
+from vantage.constants import STRING_ENCODING
 from vantage.node.server_io import ClientNodeProtocol
 from vantage.node.encryption import Cryptor
 
@@ -82,7 +84,7 @@ def proxy_task():
     log.debug(f"{n_organizations} organizations, attemping to encrypt")
     encrypted_organizations = []
     for organization in organizations:
-        input_ = organization.get("input", b"")
+        input_ = organization.get("input", {})
         if not input_:
             log.error("No input for organization?!")
             return
@@ -98,6 +100,12 @@ def proxy_task():
 
         public_key = response.json().get("public_key")
 
+        # Simple JSON (only for unencrypted collaborations)
+        if isinstance(input_, dict):
+            input_ = prepare_bytes_for_transport(
+                json.dumps(input_).encode(STRING_ENCODING)
+            )
+
         input_unpacked = unpack_bytes_from_transport(input_)
         encrypted_input = server_io.cryptor.encrypt_bytes_to_base64(
             input_unpacked, public_key)
@@ -142,7 +150,10 @@ def proxy_task_result(id):
             result["result"] = server_io.cryptor.decrypt_bytes_from_base64(
                 result["result"]
             )
-            unencrypted.append(result)
+            result["result"] = prepare_bytes_for_transport(result["result"])
+            unencrypted.append(
+                result
+            )
 
         log.error(unencrypted)
 
@@ -172,9 +183,11 @@ def proxy_results(id):
             headers={'Authorization': auth}
         )
         encrypted_input = response["result"]
-        response["result"] = server_io.cryptor.decrypt_bytes_from_base64(
-            response["result"]
-        )
+        response["result"] = prepare_bytes_for_transport(
+            server_io.cryptor.decrypt_bytes_from_base64(
+                response["result"]
+            )
+        ) 
         log.error(response)
     except Exception as e:
         log.error("Proxyserver was unable to retrieve results! (2)")

vantage/node/server_io.py

@@ -361,8 +361,8 @@ def get_results(self, id=None, state=None, include_task=False,
 
                 except ValueError as e:
                     self.log.warn(
-                        "Could not decrypt input."
-                        "Assuming input was not encrypted"
+                        "Could not decrypt (or unpack in case no encryption "
+                        "is used) input."
                     )
                     self.log.debug(e)
 
@@ -770,27 +770,20 @@ def patch_results(self, id: int, initiator_id: int, result: dict):
                 task. This is required because we want to encrypt the 
                 results specifically for him
             
-            TODO clean, does this actually already work?
-            TODO when encryption is disabled, we do not need to encrypt
-                the results either
             TODO the key `results` is not always presend, for e.g. when
                 only the timestamps are updated
         """
-
         if "result" in result:
             self.log.debug(
                 f"retrieving public key from organization={initiator_id}"
             )
             public_key = self.request(f"organization/{initiator_id}")\
                 .get("public_key")
 
-            self.log.debug(public_key)
+            # self.log.debug(public_key)
 
-            results_unpacked = unpack_bytes_from_transport(
-                result["result"])
-            
             result["result"] = self.cryptor.encrypt_bytes_to_base64(
-                results_unpacked, public_key
+                result["result"], public_key
             )
             self.log.debug("Sending encrypted results to server")