[local] Store port information in the cache

Author: mcopik

sebs.py

@@ -457,8 +457,6 @@ def start(benchmark, benchmark_input_size, output, deployments, storage_configur
     # Otherwise we want to clean up as much as possible
     deployment_client.shutdown_storage = False
 
-    deployment_client.config.serialize()
-
     result.serialize(output)
     sebs_client.logging.info(f"Save results to {os.path.abspath(output)}")
 

sebs/cache.py

@@ -59,7 +59,7 @@ def typename() -> str:
 
     def load_config(self):
         with self._lock:
-            for cloud in ["azure", "aws", "gcp", "openwhisk"]:
+            for cloud in ["azure", "aws", "gcp", "openwhisk", "local"]:
                 cloud_config_file = os.path.join(self.cache_dir, "{}.json".format(cloud))
                 if os.path.exists(cloud_config_file):
                     self.cached_config[cloud] = json.load(open(cloud_config_file, "r"))
@@ -86,7 +86,7 @@ def unlock(self):
 
     def shutdown(self):
         if self.config_updated:
-            for cloud in ["azure", "aws", "gcp", "openwhisk"]:
+            for cloud in ["azure", "aws", "gcp", "openwhisk", "local"]:
                 if cloud in self.cached_config:
                     cloud_config_file = os.path.join(self.cache_dir, "{}.json".format(cloud))
                     self.logging.info("Update cached config {}".format(cloud_config_file))

sebs/local/config.py

@@ -34,35 +34,47 @@ def __init__(self, storage_cfg: Optional[MinioConfig] = None):
     def storage_config(self) -> Optional[MinioConfig]:
         return self._storage
 
-    @property
-    def path(self) -> str:
-        return self._path
-
     @property
     def allocated_ports(self) -> set:
         return self._allocated_ports
 
     def serialize(self) -> dict:
         out = {
-            "allocated_ports": list(self._allocated_ports)
+            "allocated_ports": list(self._allocated_ports),
+            "storage": self._storage.serialize()
         }
         return out
 
     @staticmethod
-    def initialize(res: Resources, cfg: dict):
-        pass
+    def initialize(res: Resources, config: dict):
 
-    @staticmethod
-    def deserialize(config: dict, cache: Cache, handlers: LoggingHandlers) -> Resources:
-        ret = LocalResources()
-        ret._path = config["path"]
         # Check for new config
         if "storage" in config:
-            ret._storage = MinioConfig.deserialize(config["storage"])
-            ret.logging.info("Using user-provided configuration of storage for local containers.")
+            res._storage = MinioConfig.deserialize(config["storage"])
+            res.logging.info("Using user-provided configuration of storage for local containers.")
 
         if "allocated_ports" in config:
-            ret._allocated_ports = set(config["allocated_ports"])
+            res._allocated_ports = set(config["allocated_ports"])
+
+    def update_cache(self, cache: Cache):
+        super().update_cache(cache)
+        cache.update_config(val=list(self._allocated_ports), keys=["local", "resources", "allocated_ports"])
+        self._storage.update_cache(["local", "resources", "storage"], cache)
+
+    @staticmethod
+    def deserialize(config: dict, cache: Cache, handlers: LoggingHandlers) -> Resources:
+        ret = LocalResources()
+
+        cached_config = cache.get_config("local")
+        # Load cached values
+        if cached_config and "resources" in cached_config:
+            LocalResources.initialize(ret, cached_config["resources"])
+            ret.logging_handlers = handlers
+            ret.logging.info("Using cached resources for Local")
+        else:
+            # Check for new config
+            ret.logging_handlers = handlers
+            LocalResources.initialize(ret, config)
 
         return ret
 
@@ -104,13 +116,12 @@ def deserialize(config: dict, cache: Cache, handlers: LoggingHandlers) -> Config
         return config_obj
 
     def serialize(self) -> dict:
-        with open(self.resources.path, "r+") as out:
-            config = json.load(out)
-            config["deployment"]["local"].update(self.resources.serialize())
-            out.seek(0)
-            out.write(serialize(config))
-
-        return {}
+        out = {
+            "name": "local",
+            "region": self._region,
+            "resources": self._resources.serialize()
+        }
+        return out
 
     def update_cache(self, cache: Cache):
-        pass
+        self.resources.update_cache(cache)

sebs/local/local.py

@@ -103,12 +103,8 @@ def get_storage(self, replace_existing: bool = False) -> PersistentStorage:
             self.storage.replace_existing = replace_existing
         return self.storage
 
-    """
-        Shut down minio storage instance.
-    """
-
     def shutdown(self):
-        pass
+        super().shutdown()
 
     """
         It would be sufficient to just pack the code and ship it as zip to AWS.