[#87] Configuration of a Mongodb cluster instead of maintaining only a standalone instance

.github/workflows/build.yml

@@ -80,12 +80,6 @@ jobs:
       - name: Runnign integration tests
         run: make integration_tests
 
-      - name: Installing das-cli package
-        run: sudo apt -y install $(find . -name *.deb -type f | head -n 1)
-
-      - name: Runnign integration tests
-        run: make integration_tests
-
   tag:
     needs:
       - integration-tests

CHANGELOG

@@ -33,3 +33,4 @@
 [#73] das-cli python-library version is raising an error
 [#76] Put version number in openfaas docker image name
 [#75] Enable the configuration of a Redis cluster instead of maintaining only a standalone instance
+[#87] Configuration of a Mongodb cluster instead of maintaining only a standalone instance

Makefile

@@ -15,8 +15,8 @@ man_pages:
 
 integration_tests:
 ifdef DAS_CLI_TEST_CLUSTER
-	@bats tests/integration/*.bats --filter-tags 'redis:cluster'
+	@bats tests/integration/*.bats --filter-tags 'cluster'
 endif
 
-	@bats tests/integration/*.bats --filter-tags '!redis:cluster'
+	@bats tests/integration/*.bats --filter-tags '!cluster'
 

src/commands/config/config_cli.py

@@ -1,4 +1,5 @@
 from injector import inject
+from typing import List, Dict
 from common import Settings, StdoutSeverity
 from common import (
     Command,
@@ -8,6 +9,7 @@
     RemoteContextManager,
     get_server_username,
     get_public_ip,
+    get_rand_token,
 )
 
 
@@ -41,7 +43,7 @@ class ConfigSet(Command):
     redis.container_name
         Specifies the name of the Docker container running the Redis server.
 
-    redis.custer
+    redis.cluster
         Indicates whether a Redis cluster is being used (true/false).
 
     redis.nodes
@@ -71,6 +73,24 @@ class ConfigSet(Command):
     mongodb.password
         The password for connecting to the MongoDB server.
 
+    mongodb.cluster
+        Indicates whether a MongoDB cluster is being used (true/false).
+
+    mongodb.cluster_secret_key
+        This key is uploaded to all nodes within the MongoDB cluster. It is used for mutual authentication between nodes, ensuring that only authorized nodes can communicate with each other.
+
+    mongodb.nodes
+        Receives a list of nodes for MongoDB configuration. For a single-node setup, there must be at least one node specified with the default context. For a cluster setup, there must be at least three nodes specified. Additionally, it is necessary to configure an SSH key and utilize this key on each node to ensure SSH connectivity between them. This is essential because Docker communicates between nodes remotely to deploy images with MongoDB. To establish SSH connectivity, generate an SSH key using `ssh-keygen` and add this key to all servers in the cluster. Ensure that port 22 is open on all servers to allow SSH connections.
+
+    mongodb.nodes.[].context
+        The name of the Docker context containing connection information for the remote Docker instances of other nodes.
+
+    mongodb.nodes.[].ip
+        The IP address of the node.
+
+    mongodb.nodes.[].username
+        The username for connecting to the node.
+
 loader.*
     These variables control the Loader settings, responsible for validating and loading meta files into the database, such as:
 
@@ -114,19 +134,52 @@ def _set_config(self, config_dict):
             else:
                 self._settings.set(key, value)
 
-    def _redis_cluster(self, redis_port) -> list:
+    def _build_nodes(self, is_cluster: bool, port: int) -> List[Dict]:
+        nodes = []
+        server_user = get_server_username()
+        current_node = {
+            "context": "default",
+            "ip": "localhost",
+            "username": server_user,
+        }
+
+        if is_cluster:
+            server_public_ip = get_public_ip()
+
+            if server_public_ip is None:
+                raise Exception(
+                    "The server's public ip could not be solved. Make sure it has internet access."
+                )
+
+            current_node["ip"] = server_public_ip
+
+            nodes = self._build_cluster(server_user, port)
+
+        nodes.insert(
+            0,
+            current_node,
+        )
+
+        return nodes
+
+    def _build_cluster(
+        self,
+        username: str,
+        port: int,
+        min_nodes: int = 3,
+    ) -> List[Dict]:
         total_nodes = self.prompt(
-            "Enter the total number of nodes for the redis cluster (>= 3)",
+            f"Enter the total number of nodes for the cluster (>= {min_nodes})",
             hide_input=False,
-            type=IntRange(3),
+            type=IntRange(min_nodes),
         )
 
         servers = []
         for i in range(0, total_nodes - 1):
             server_ip = self.prompt(
                 f"Enter the ip address for the server-{i + 1}",
                 hide_input=False,
-                type=ReachableIpAddress(redis_port),
+                type=ReachableIpAddress(username, port),
             )
             server_username = self.prompt(
                 f"Enter the server username for the server-{i + 1}",
@@ -142,49 +195,30 @@ def _redis_cluster(self, redis_port) -> list:
         remote_context_manager = RemoteContextManager(servers)
         cluster_contexts = remote_context_manager.create_context()
 
-        old_servers = self._settings.get("redis.nodes", [])
-        remote_context_manager.set_servers(old_servers)
-        remote_context_manager.remove_context()
-
         return cluster_contexts
 
-    def _redis_nodes(self, redis_cluster, redis_port) -> list:
-        nodes = []
-        server_user = get_server_username()
-        redis_current_node = {
-            "context": "default",
-            "ip": "localhost",
-            "username": server_user,
-        }
-
-        if redis_cluster:
-            server_public_ip = get_public_ip()
-
-            if server_public_ip is None:
-                raise Exception(
-                    "The server's public ip could not be solved. Make sure it has internet access."
-                )
-
-            redis_current_node["ip"] = server_public_ip
+    def _destroy_contexts(self, servers: List[Dict]):
+        remote_context_manager = RemoteContextManager(servers)
+        remote_context_manager.remove_context()
 
-            nodes = self._redis_cluster(redis_port)
+    def _redis_nodes(self, redis_cluster, redis_port) -> List[Dict]:
+        redis_nodes = self._build_nodes(redis_cluster, redis_port)
 
-        nodes.insert(
-            0,
-            redis_current_node,
+        self._destroy_contexts(
+            servers=self._settings.get("redis.nodes", []),
         )
 
-        return nodes
+        return redis_nodes
 
-    def _redis(self) -> dict:
+    def _redis(self) -> Dict:
         redis_port = self.prompt(
             "Enter Redis port",
             default=self._settings.get("redis.port", 6379),
             type=int,
         )
         cluster_default_value = "yes" if self._settings.get("redis.cluster") else "no"
         redis_cluster = self.prompt(
-            "Is it a redis cluster? (yes/no) ",
+            "Is it a Redis cluster? (yes/no) ",
             hide_input=False,
             default=cluster_default_value,
             type=bool,
@@ -197,6 +231,15 @@ def _redis(self) -> dict:
             "redis.nodes": lambda: self._redis_nodes(redis_cluster, redis_port),
         }
 
+    def _mongodb_nodes(self, mongodb_cluster, mongodb_port) -> List[Dict]:
+        mongodb_nodes = self._build_nodes(mongodb_cluster, mongodb_port)
+
+        self._destroy_contexts(
+            servers=self._settings.get("mongodb.nodes", []),
+        )
+
+        return mongodb_nodes
+
     def _mongodb(self) -> dict:
         mongodb_port = self.prompt(
             "Enter MongoDB port",
@@ -212,11 +255,28 @@ def _mongodb(self) -> dict:
             # hide_input=True, # When hide_input is set I cannot set the answers based on a text file making impossible to test this command
             default=self._settings.get("mongodb.password", "admin"),
         )
+        cluster_default_value = "yes" if self._settings.get("mongodb.cluster") else "no"
+        is_mongodb_cluster = self.prompt(
+            "Is it a MongoDB cluster? (yes/no) ",
+            hide_input=False,
+            default=cluster_default_value,
+            type=bool,
+        )
+        cluster_secret_key = self._settings.get(
+            "mongodb.cluster_secret_key",
+            get_rand_token(num_bytes=15),
+        )
         return {
             "mongodb.port": mongodb_port,
             "mongodb.container_name": f"das-cli-mongodb-{mongodb_port}",
             "mongodb.username": mongodb_username,
             "mongodb.password": mongodb_password,
+            "mongodb.cluster": is_mongodb_cluster,
+            "mongodb.nodes": lambda: self._mongodb_nodes(
+                is_mongodb_cluster,
+                mongodb_port,
+            ),
+            "mongodb.cluster_secret_key": cluster_secret_key,
         }
 
     def _loader(self) -> dict: