Remove the manager and implement decentralized cluster architecture

.github/workflows/build-lint-test-and-upload.yml

@@ -186,7 +186,6 @@ jobs:
         mv target/release/modelardb$SUFFIX modelardb_$RUST_TRIPLE/modelardb$SUFFIX
         mv target/release/modelardbb$SUFFIX modelardb_$RUST_TRIPLE/modelardbb$SUFFIX
         mv target/release/modelardbd$SUFFIX modelardb_$RUST_TRIPLE/modelardbd$SUFFIX
-        mv target/release/modelardbm$SUFFIX modelardb_$RUST_TRIPLE/modelardbm$SUFFIX
 
     # Upload Binaries.
     - name: Artifact Upload

Dockerfile

@@ -14,7 +14,7 @@
 
 FROM rust:latest
 
-ARG BUILD_PROFILE=dev
+ARG BUILD_PROFILE=release
 
 WORKDIR /usr/src/app
 
@@ -24,4 +24,4 @@ RUN apt-get update && apt-get install -y protobuf-compiler
 
 RUN cargo build --profile $BUILD_PROFILE
 
-CMD ["target/debug/modelardbd", "edge", "data"]
+CMD ["target/release/modelardbd", "edge", "data"]

crates/modelardb_embedded/bindings/python/docs/index.rst

@@ -26,7 +26,6 @@ API
    api/modelardb
    api/error_bound
    api/ffi_array
-   api/node
    api/operations
    api/table
 

crates/modelardb_embedded/bindings/python/modelardb/__init__.py

@@ -16,9 +16,9 @@
 
 from .error_bound import AbsoluteErrorBound, RelativeErrorBound
 from .ffi_array import FFIArray
-from .node import Server, Manager
 from .operations import (
     Aggregate,
+    ModelarDBType,
     Operations,
     open_memory,
     open_local,

crates/modelardb_embedded/bindings/python/modelardb/operations.py

@@ -12,7 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import os
 import sys
 import platform
 import warnings
@@ -26,12 +25,20 @@
 from pyarrow import MapArray, RecordBatch, Schema, StringArray
 from pyarrow.cffi import ffi
 
-from .node import Server, Manager
 from .error_bound import AbsoluteErrorBound
 from .table import NormalTable, TimeSeriesTable
 from .ffi_array import FFIArray
 
 
+class ModelarDBType(Enum):
+    """Different types of ModelarDB instances that the Operations API can interact with."""
+
+    SingleEdge = 0
+    ClusterEdge = 1
+    ClusterCloud = 2
+    DataFolder = 3
+
+
 class Aggregate(Enum):
     """Aggregate operations supported by :meth:`Operations.read`."""
 
@@ -120,12 +127,15 @@ def __find_library(build: str) -> str:
                                                 char* access_key_ptr,
                                                 char* container_name_ptr);
 
-            void* modelardb_embedded_connect(char* node_url_ptr,
-                                             bool is_server_node);
+            void* modelardb_embedded_connect(char* url_ptr);
 
             int modelardb_embedded_close(void* maybe_operations_ptr,
                                          bool is_data_folder);
 
+            int modelardb_embedded_modelardb_type(void* maybe_operations_ptr,
+                                                  bool is_data_folder,
+                                                  int* modelardb_type_ptr);
+
             int modelardb_embedded_create(void* maybe_operations_ptr,
                                           bool is_data_folder,
                                           char* table_name_ptr,
@@ -322,19 +332,17 @@ def open_azure(cls, account_name: str, access_key: str, container_name: str):
         return self
 
     @classmethod
-    def connect(cls, node: Server | Manager):
+    def connect(cls, url: str):
         """Create a connection to an :obj:`Operations` node.
 
-        :param node: The ModelarDB node to connect to.
-        :type node: Server | Manager
+        :param url: The URL of the ModelarDB node to connect to.
+        :type url: str
         """
         self: Operations = cls()
 
-        node_url_ptr = ffi.new("char[]", bytes(node.url, "UTF-8"))
+        url_ptr = ffi.new("char[]", bytes(url, "UTF-8"))
 
-        self.__operations_ptr = self.__library.modelardb_embedded_connect(
-            node_url_ptr, isinstance(node, Server)
-        )
+        self.__operations_ptr = self.__library.modelardb_embedded_connect(url_ptr)
         self.__is_data_folder = False
 
         if self.__operations_ptr == ffi.NULL:
@@ -349,6 +357,23 @@ def __del__(self):
         )
         self.__check_return_code_and_raise_error(return_code)
 
+    def modelardb_type(self) -> ModelarDBType:
+        """Returns the type of the ModelarDB instance that :obj:`Operations` is connected to.
+
+        :return: The type of the ModelarDB instance.
+        :rtype: ModelarDBType
+        """
+        modelardb_type_int_ffi = ffi.new("int*")
+
+        return_code = self.__library.modelardb_embedded_modelardb_type(
+            self.__operations_ptr,
+            self.__is_data_folder,
+            modelardb_type_int_ffi
+        )
+        self.__check_return_code_and_raise_error(return_code)
+
+        return ModelarDBType(modelardb_type_int_ffi[0])
+
     def create(self, table_name: str, table_type: NormalTable | TimeSeriesTable):
         """Creates a table with `table_name`, `schema`, and `error_bounds`.
 
@@ -847,10 +872,10 @@ def open_azure(account_name: str, access_key: str, container_name: str) -> Opera
     return Operations.open_azure(account_name, access_key, container_name)
 
 
-def connect(node: Server | Manager) -> Operations:
+def connect(url: str) -> Operations:
     """Create a connection to an :obj:`Operations` node.
 
-    :param node: The ModelarDB node to connect to.
-    :type node: Server | Manager
+    :param url: The URL of the ModelarDB node to connect to.
+    :type url: str
     """
-    return Operations.connect(node)
+    return Operations.connect(url)

crates/modelardb_embedded/bindings/python/tests/test_operations.py

@@ -20,6 +20,7 @@
 import pyarrow
 from modelardb import (
     Aggregate,
+    ModelarDBType,
     AbsoluteErrorBound,
     TimeSeriesTable,
     NormalTable,
@@ -42,6 +43,12 @@ def test_data_folder_init(self):
             new_data_folder = Operations.open_local(temp_dir)
             self.assertEqual(data_folder.tables(), new_data_folder.tables())
 
+    def test_data_folder_modelardb_type(self):
+        with TemporaryDirectory() as temp_dir:
+            data_folder = Operations.open_local(temp_dir)
+
+            self.assertEqual(data_folder.modelardb_type(), ModelarDBType.DataFolder)
+
     def test_data_folder_create_normal_table(self):
         with TemporaryDirectory() as temp_dir:
             data_folder = Operations.open_local(temp_dir)

crates/modelardb_embedded/src/capi.rs

@@ -45,7 +45,7 @@ use tokio::runtime::Runtime;
 
 use crate::error::{ModelarDbEmbeddedError, Result};
 use crate::operations::Operations;
-use crate::operations::client::{Client, Node};
+use crate::operations::client::Client;
 use crate::operations::data_folder::DataFolderDataSink;
 use crate::record_batch_stream_to_record_batch;
 use crate::{Aggregate, TableType};
@@ -197,29 +197,20 @@ unsafe fn open_azure(
     Ok(data_folder)
 }
 
-/// Creates a [`Client`] that is connected to the Apache Arrow Flight server URL in `node_url_ptr`
+/// Creates a [`Client`] that is connected to the Apache Arrow Flight server URL in `url_ptr`
 /// and returns a pointer to the [`Client`] or a zero-initialized pointer if an error occurs.
-/// Assumes `node_url_ptr` points to a valid C string.
+/// Assumes `url_ptr` points to a valid C string.
 #[unsafe(no_mangle)]
-pub unsafe extern "C" fn modelardb_embedded_connect(
-    node_url_ptr: *const c_char,
-    is_server_node: bool,
-) -> *const c_void {
-    let maybe_client = unsafe { connect(node_url_ptr, is_server_node) };
+pub unsafe extern "C" fn modelardb_embedded_connect(url_ptr: *const c_char) -> *const c_void {
+    let maybe_client = unsafe { connect(url_ptr) };
     set_error_and_return_value_ptr(maybe_client)
 }
 
 /// See documentation for [`modelardb_embedded_connect()`].
-unsafe fn connect(node_url_ptr: *const c_char, is_server_node: bool) -> Result<Client> {
-    let node_url_str = unsafe { c_char_ptr_to_str(node_url_ptr)? };
-
-    let node = if is_server_node {
-        Node::Server(node_url_str.to_owned())
-    } else {
-        Node::Manager(node_url_str.to_owned())
-    };
+unsafe fn connect(url_ptr: *const c_char) -> Result<Client> {
+    let url_str = unsafe { c_char_ptr_to_str(url_ptr)? };
 
-    TOKIO_RUNTIME.block_on(Client::connect(node))
+    TOKIO_RUNTIME.block_on(Client::connect(url_str))
 }
 
 /// Moves the value in `maybe_value` to a [`Box`] and returns a pointer to it if `maybe_value` is
@@ -266,6 +257,37 @@ pub unsafe extern "C" fn modelardb_embedded_close(
     }
 }
 
+/// Returns the ModelarDB type of the [`DataFolder`] or [`Client`] in `maybe_operations_ptr`.
+/// Assumes `maybe_operations_ptr` points to a [`DataFolder`] or [`Client`] and `modelardb_type_ptr`
+/// is a valid pointer to enough memory for a 32-bit signed integer.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn modelardb_embedded_modelardb_type(
+    maybe_operations_ptr: *mut c_void,
+    is_data_folder: bool,
+    modelardb_type_ptr: *mut c_int,
+) -> c_int {
+    let maybe_unit =
+        unsafe { modelardb_type(maybe_operations_ptr, is_data_folder, modelardb_type_ptr) };
+
+    set_error_and_return_code(maybe_unit)
+}
+
+/// See documentation for [`modelardb_embedded_modelardb_type()`].
+unsafe fn modelardb_type(
+    maybe_operations_ptr: *mut c_void,
+    is_data_folder: bool,
+    modelardb_type_ptr: *mut c_int,
+) -> Result<()> {
+    let modelardb = unsafe { c_void_to_operations(maybe_operations_ptr, is_data_folder)? };
+
+    let modelardb_type = TOKIO_RUNTIME.block_on(modelardb.modelardb_type())?;
+    let modelardb_type_int = modelardb_type as i32;
+
+    unsafe { modelardb_type_ptr.write(modelardb_type_int) };
+
+    Ok(())
+}
+
 /// Creates a table with the name in `table_name_ptr`, the schema in `schema_ptr`, and the error
 /// bounds in `error_bounds_ptr` in the [`DataFolder`] or [`Client`] in `maybe_operations_ptr`.
 /// Assumes `maybe_operations_ptr` points to a [`DataFolder`] or [`Client`]; `table_name_ptr` points