added a bunch of tests for dependencies

python/mochi/bedrock/test_dependencies.py

@@ -8,6 +8,21 @@ class TestProviderManager(unittest.TestCase):
 
     def setUp(self):
         config = {
+            "margo": {
+                "argobots": {
+                    "pools": [
+                        { "name": "my_pool", "kind": "fifo_wait", "access": "mpmc" }
+                    ],
+                    "xstreams": [
+                        { "name": "my_xstream",
+                          "scheduler": {
+                            "type": "basic_wait",
+                            "pools": ["my_pool"]
+                          }
+                        }
+                    ]
+                }
+            },
             "libraries": {
                 "module_a": "libModuleA.so",
                 "module_b": "libModuleB.so",
@@ -34,6 +49,25 @@ def setUp(self):
                     "name": "my_client_b",
                     "type": "module_b"
                 }
+            ],
+            "abt_io": [
+                {
+                    "name": "my_abt_io",
+                    "pool": "__primary__"
+                }
+            ],
+            "ssg": [
+                {
+                    "name": "my_ssg",
+                    "bootstrap": "init",
+                    "swim": { "disabled": True }
+                }
+            ],
+            "mona": [
+                {
+                    "name": "my_mona",
+                    "pool": "__primary__"
+                }
             ]
         }
         self.server = mbs.Server(address="na+sm", config=config)
@@ -56,7 +90,7 @@ def make_client_params(self, expected_dependencies: dict={}):
     def make_provider_params(self, expected_dependencies: dict={}):
         params = self.make_client_params({})
         params["provider_id"] = 3
-        params["pool"] = "__primary__"
+        params["pool"] = "my_pool"
         params["config"]["expected_provider_dependencies"] = expected_dependencies
         return params
 
@@ -145,6 +179,272 @@ def test_required_dependency(self):
         providers.create(**provider_params)
         self.assertEqual(len(providers), 3)
 
+    def test_dependency_on_pool(self):
+        providers = self.server.providers
+        self.assertEqual(len(providers), 2)
+        clients = self.server.clients
+        self.assertEqual(len(clients), 2)
+
+        # Try creating a client without the required dependency
+        client_params = self.make_client_params([
+            {"name": "dep1", "type": "pool", "is_required": True}])
+        with self.assertRaises(mbs.BedrockException):
+            clients.create(**client_params)
+
+        # Try creating a client with the required dependency
+        client_params["dependencies"] = {"dep1": "my_pool"}
+        clients.create(**client_params)
+        self.assertEqual(len(clients), 3)
+
+        # Try creating a provider without the required dependency
+        provider_params = self.make_provider_params([
+            {"name": "dep1", "type": "pool", "is_required": True}])
+        with self.assertRaises(mbs.BedrockException):
+            providers.create(**provider_params)
+
+        # Try creating a provider with the required dependency
+        provider_params["dependencies"] = {"dep1": "my_pool"}
+        providers.create(**provider_params)
+        self.assertEqual(len(providers), 3)
+
+    def test_dependency_on_xstream(self):
+        providers = self.server.providers
+        self.assertEqual(len(providers), 2)
+        clients = self.server.clients
+        self.assertEqual(len(clients), 2)
+
+        # Try creating a client without the required dependency
+        client_params = self.make_client_params([
+            {"name": "dep1", "type": "xstream", "is_required": True}])
+        with self.assertRaises(mbs.BedrockException):
+            clients.create(**client_params)
+
+        # Try creating a client with the required dependency
+        client_params["dependencies"] = {"dep1": "my_xstream"}
+        clients.create(**client_params)
+        self.assertEqual(len(clients), 3)
+
+        # Try creating a provider without the required dependency
+        provider_params = self.make_provider_params([
+            {"name": "dep1", "type": "xstream", "is_required": True}])
+        with self.assertRaises(mbs.BedrockException):
+            providers.create(**provider_params)
+
+        # Try creating a provider with the required dependency
+        provider_params["dependencies"] = {"dep1": "my_xstream"}
+        providers.create(**provider_params)
+        self.assertEqual(len(providers), 3)
+
+    def test_dependency_on_abt_io(self):
+        providers = self.server.providers
+        self.assertEqual(len(providers), 2)
+        clients = self.server.clients
+        self.assertEqual(len(clients), 2)
+
+        # Try creating a client without the required dependency
+        client_params = self.make_client_params([
+            {"name": "dep1", "type": "abt_io", "is_required": True}])
+        with self.assertRaises(mbs.BedrockException):
+            clients.create(**client_params)
+
+        # Try creating a client with the required dependency
+        client_params["dependencies"] = {"dep1": "my_abt_io"}
+        clients.create(**client_params)
+        self.assertEqual(len(clients), 3)
+
+        # Try creating a provider without the required dependency
+        provider_params = self.make_provider_params([
+            {"name": "dep1", "type": "abt_io", "is_required": True}])
+        with self.assertRaises(mbs.BedrockException):
+            providers.create(**provider_params)
+
+        # Try creating a provider with the required dependency
+        provider_params["dependencies"] = {"dep1": "my_abt_io"}
+        providers.create(**provider_params)
+        self.assertEqual(len(providers), 3)
+
+    def test_dependency_on_ssg(self):
+        providers = self.server.providers
+        self.assertEqual(len(providers), 2)
+        clients = self.server.clients
+        self.assertEqual(len(clients), 2)
+
+        # Try creating a client without the required dependency
+        client_params = self.make_client_params([
+            {"name": "dep1", "type": "ssg", "is_required": True}])
+        with self.assertRaises(mbs.BedrockException):
+            clients.create(**client_params)
+
+        # Try creating a client with the required dependency
+        client_params["dependencies"] = {"dep1": "my_ssg"}
+        clients.create(**client_params)
+        self.assertEqual(len(clients), 3)
+
+        # Try creating a provider without the required dependency
+        provider_params = self.make_provider_params([
+            {"name": "dep1", "type": "ssg", "is_required": True}])
+        with self.assertRaises(mbs.BedrockException):
+            providers.create(**provider_params)
+
+        # Try creating a provider with the required dependency
+        provider_params["dependencies"] = {"dep1": "my_ssg"}
+        providers.create(**provider_params)
+        self.assertEqual(len(providers), 3)
+
+    def test_dependency_on_mona(self):
+        providers = self.server.providers
+        self.assertEqual(len(providers), 2)
+        clients = self.server.clients
+        self.assertEqual(len(clients), 2)
+
+        # Try creating a client without the required dependency
+        client_params = self.make_client_params([
+            {"name": "dep1", "type": "mona", "is_required": True}])
+        with self.assertRaises(mbs.BedrockException):
+            clients.create(**client_params)
+
+        # Try creating a client with the required dependency
+        client_params["dependencies"] = {"dep1": "my_mona"}
+        clients.create(**client_params)
+        self.assertEqual(len(clients), 3)
+
+        # Try creating a provider without the required dependency
+        provider_params = self.make_provider_params([
+            {"name": "dep1", "type": "mona", "is_required": True}])
+        with self.assertRaises(mbs.BedrockException):
+            providers.create(**provider_params)
+
+        # Try creating a provider with the required dependency
+        provider_params["dependencies"] = {"dep1": "my_mona"}
+        providers.create(**provider_params)
+        self.assertEqual(len(providers), 3)
+
+    def test_dependency_on_client(self):
+        providers = self.server.providers
+        self.assertEqual(len(providers), 2)
+        clients = self.server.clients
+        self.assertEqual(len(clients), 2)
+
+        # Try creating a client without the required dependency
+        client_params = self.make_client_params([
+            {"name": "dep1", "type": "module_a",
+             "is_required": True, "kind": "client"}])
+        with self.assertRaises(mbs.BedrockException):
+            clients.create(**client_params)
+
+        # Try creating a client with the required dependency
+        client_params["dependencies"] = {"dep1": "my_client_a"}
+        clients.create(**client_params)
+        self.assertEqual(len(clients), 3)
+
+        # Try creating a provider without the required dependency
+        provider_params = self.make_provider_params([
+            {"name": "dep1", "type": "module_a",
+             "is_required": True, "kind": "client"}])
+        with self.assertRaises(mbs.BedrockException):
+            providers.create(**provider_params)
+
+        # Try creating a provider with the required dependency
+        provider_params["dependencies"] = {"dep1": "my_client_a"}
+        providers.create(**provider_params)
+        self.assertEqual(len(providers), 3)
+
+    def test_dependency_on_client(self):
+        providers = self.server.providers
+        self.assertEqual(len(providers), 2)
+        clients = self.server.clients
+        self.assertEqual(len(clients), 2)
+
+        # Try creating a client without the required dependency
+        client_params = self.make_client_params([
+            {"name": "dep1", "type": "module_a",
+             "is_required": True, "kind": "provider"}])
+        with self.assertRaises(mbs.BedrockException):
+            clients.create(**client_params)
+
+        # Try creating a client with the required dependency
+        client_params["dependencies"] = {"dep1": "my_provider_a"}
+        clients.create(**client_params)
+        self.assertEqual(len(clients), 3)
+
+        # Try creating a provider without the required dependency
+        provider_params = self.make_provider_params([
+            {"name": "dep1", "type": "module_a",
+             "is_required": True, "kind": "provider"}])
+        with self.assertRaises(mbs.BedrockException):
+            providers.create(**provider_params)
+
+        # Try creating a provider with the required dependency
+        provider_params["dependencies"] = {"dep1": "my_provider_a"}
+        providers.create(**provider_params)
+        self.assertEqual(len(providers), 3)
+
+    def test_dependency_on_ph_with_id_and_address(self):
+        providers = self.server.providers
+        self.assertEqual(len(providers), 2)
+        clients = self.server.clients
+        self.assertEqual(len(clients), 2)
+
+        # Get the address of this process to use instead of "local"
+        address = str(self.server.margo.engine.address)
+
+        # Try creating a client without the required dependency
+        client_params = self.make_client_params([
+            {"name": "dep1", "type": "module_a",
+             "is_required": True, "kind": "provider_handle"}])
+        with self.assertRaises(mbs.BedrockException):
+            clients.create(**client_params)
+
+        # Try creating a client with the required dependency
+        client_params["dependencies"] = {"dep1": f"module_a:1@{address}"}
+        clients.create(**client_params)
+        self.assertEqual(len(clients), 3)
+
+        # Try creating a provider without the required dependency
+        provider_params = self.make_provider_params([
+            {"name": "dep1", "type": "module_a",
+             "is_required": True, "kind": "provider_handle"}])
+        with self.assertRaises(mbs.BedrockException):
+            providers.create(**provider_params)
+
+        # Try creating a provider with the required dependency
+        provider_params["dependencies"] = {"dep1": f"module_a:1@{address}"}
+        providers.create(**provider_params)
+        self.assertEqual(len(providers), 3)
+
+    def test_dependency_on_ph_with_ssg(self):
+        providers = self.server.providers
+        self.assertEqual(len(providers), 2)
+        clients = self.server.clients
+        self.assertEqual(len(clients), 2)
+
+        # Get the address of this process to use instead of "local"
+        address = "ssg://my_ssg/0"
+
+        # Try creating a client without the required dependency
+        client_params = self.make_client_params([
+            {"name": "dep1", "type": "module_a",
+             "is_required": True, "kind": "provider_handle"}])
+        with self.assertRaises(mbs.BedrockException):
+            clients.create(**client_params)
+
+        # Try creating a client with the required dependency
+        client_params["dependencies"] = {"dep1": f"module_a:1@{address}"}
+        clients.create(**client_params)
+        self.assertEqual(len(clients), 3)
+
+        # Try creating a provider without the required dependency
+        provider_params = self.make_provider_params([
+            {"name": "dep1", "type": "module_a",
+             "is_required": True, "kind": "provider_handle"}])
+        with self.assertRaises(mbs.BedrockException):
+            providers.create(**provider_params)
+
+        # Try creating a provider with the required dependency
+        provider_params["dependencies"] = {"dep1": f"module_a:1@{address}"}
+        providers.create(**provider_params)
+        self.assertEqual(len(providers), 3)
+
 
 if __name__ == '__main__':
     unittest.main()

src/DependencyFinder.cpp

@@ -58,6 +58,15 @@ std::shared_ptr<NamedDependency> DependencyFinder::find(
         if (resolved) { *resolved = spec; }
         return pool;
 
+    } else if (type == "xstream") { // Argobots xstream
+
+        auto xstream = MargoManager(self->m_margo_context).getXstream(spec);
+        if (!xstream) {
+            throw Exception("Could not find xstream with name \"{}\"", spec);
+        }
+        if (resolved) { *resolved = spec; }
+        return xstream;
+
     } else if (type == "abt_io") { // ABTIO instance
 
         auto abtio_manager_impl = self->m_abtio_context.lock();
@@ -98,7 +107,7 @@ std::shared_ptr<NamedDependency> DependencyFinder::find(
     } else if (kind == BEDROCK_KIND_CLIENT) {
 
         auto client = findClient(type, spec);
-        if (client) { *resolved = client->getName(); }
+        if (client && resolved) { *resolved = client->getName(); }
         return client;
 
     } else if (kind == BEDROCK_KIND_PROVIDER) {