opengris-scaler 1.12.8__tar.gz → 1.12.9__tar.gz

{opengris_scaler-1.12.8 → opengris_scaler-1.12.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: opengris-scaler
-Version: 1.12.8
+Version: 1.12.9
 Summary: OpenGRIS Scaler Distribution Framework
 Author-Email: Citi <opensource@citi.com>
 License: Apache 2.0

{opengris_scaler-1.12.8 → opengris_scaler-1.12.9}/scaler/object_storage/object_storage_server.cpp

@@ -29,7 +29,8 @@ void ObjectStorageServer::run(
     ObjectStorageServer::Identity identity,
     std::string log_level,
     std::string log_format,
-    std::vector<std::string> log_paths)
+    std::vector<std::string> log_paths,
+    std::function<bool()> running)
 {
     _logger = scaler::ymq::Logger(log_format, std::move(log_paths), scaler::ymq::Logger::stringToLogLevel(log_level));
 
@@ -44,7 +45,7 @@ void ObjectStorageServer::run(
 
         _logger.log(scaler::ymq::Logger::LoggingLevel::info, "ObjectStorageServer: started");
 
-        processRequests();
+        processRequests(running);
 
         _ioContext.removeIOSocket(_ioSocket);
     } catch (const std::exception& e) {
@@ -117,7 +118,7 @@ void ObjectStorageServer::closeServerReadyFds()
     }
 }
 
-void ObjectStorageServer::processRequests()
+void ObjectStorageServer::processRequests(std::function<bool()> running)
 {
     using namespace std::chrono_literals;
     Identity lastMessageIdentity;
@@ -134,7 +135,13 @@ void ObjectStorageServer::processRequests()
                 }
             });
 
-            auto maybeMessage = ymq::syncRecvMessage(_ioSocket);
+            auto maybeMessageFuture = ymq::futureRecvMessage(_ioSocket);
+            while (maybeMessageFuture.wait_for(100ms) == std::future_status::timeout) {
+                if (!running()) {
+                    return;
+                }
+            }
+            auto maybeMessage = maybeMessageFuture.get();
 
             if (!maybeMessage) {
                 auto error = maybeMessage.error();

{opengris_scaler-1.12.8 → opengris_scaler-1.12.9}/scaler/object_storage/object_storage_server.h

@@ -35,7 +35,8 @@ public:
         Identity identity                  = "ObjectStorageServer",
         std::string log_level              = "INFO",
         std::string log_format             = "%(levelname)s: %(message)s",
-        std::vector<std::string> log_paths = {"/dev/stdout"});
+        std::vector<std::string> log_paths = {"/dev/stdout"},
+        std::function<bool()> running      = []() { return true; });
 
     void waitUntilReady();
 
@@ -78,7 +79,7 @@ private:
 
     void closeServerReadyFds();
 
-    void processRequests();
+    void processRequests(std::function<bool()> stopCondition);
 
     void processSetRequest(std::shared_ptr<Client> client, std::pair<ObjectRequestHeader, Bytes> request);
 

{opengris_scaler-1.12.8 → opengris_scaler-1.12.9}/scaler/object_storage/pymod_object_storage_server.cpp

@@ -1,6 +1,8 @@
 #define PY_SSIZE_T_CLEAN
 #include <Python.h>
+#include <pyerrors.h>
 
+#include "scaler/io/ymq/pymod_ymq/gil.h"
 #include "scaler/object_storage/object_storage_server.h"
 
 extern "C" {
@@ -52,10 +54,19 @@ static PyObject* PyObjectStorageServerRun(PyObject* self, PyObject* args)
         logging_paths.push_back(PyUnicode_AsUTF8(path_obj));
     }
 
+    auto running = []() -> bool {
+        AcquireGIL gil;
+        (void)gil;
+        return PyErr_CheckSignals() == 0;
+    };
+
     ((PyObjectStorageServer*)self)
-        ->server.run(addr, std::to_string(port), identity, log_level, log_format, std::move(logging_paths));
+        ->server.run(
+            addr, std::to_string(port), identity, log_level, log_format, std::move(logging_paths), std::move(running));
 
-    Py_RETURN_NONE;
+    // TODO: Ideally, run should return a bool and we return failure with nullptr.
+    return nullptr;
+    // Py_RETURN_NONE;
 }
 
 static PyObject* PyObjectStorageServerWaitUntilReady(PyObject* self, [[maybe_unused]] PyObject* args)

opengris_scaler-1.12.9/scaler/version.txt

@@ -0,0 +1 @@
+1.12.9

opengris_scaler-1.12.9/tests/test_cluster_config.py

@@ -0,0 +1,49 @@
+import os
+import tempfile
+import unittest
+from argparse import Namespace
+
+from scaler.config.loader import load_config
+from scaler.config.section.cluster import ClusterConfig
+
+
+class TestClusterConfig(unittest.TestCase):
+    """Tests for the ClusterConfig class."""
+
+    def setUp(self):
+        self.temp_dir = tempfile.TemporaryDirectory()
+        self.config_path = os.path.join(self.temp_dir.name, "cluster.toml")
+        with open(self.config_path, "w") as f:
+            f.write(
+                """
+scheduler_address = "tcp://127.0.0.1:5555"
+num_of_workers = 2
+worker_names = "w1,w2"
+"""
+            )
+
+    def tearDown(self):
+        self.temp_dir.cleanup()
+
+    def test_load_from_toml_only(self):
+        """Test loading ClusterConfig from a flat TOML file."""
+        config = load_config(ClusterConfig, self.config_path, Namespace())
+        self.assertEqual(str(config.scheduler_address), "tcp://127.0.0.1:5555")
+        self.assertEqual(config.num_of_workers, 2)
+        self.assertEqual(config.worker_names.names, ["w1", "w2"])
+
+    def test_command_line_overrides_toml(self):
+        """Test that argparse args correctly override TOML values for ClusterConfig."""
+        worker_list = [f"worker_{i}" for i in range(20)]
+        args = Namespace(num_of_workers=20, worker_names=",".join(worker_list), heartbeat_interval_seconds=99)
+
+        config = load_config(ClusterConfig, self.config_path, args)
+
+        self.assertEqual(config.num_of_workers, 20)
+        self.assertEqual(config.worker_names.names, worker_list)
+        self.assertEqual(config.heartbeat_interval_seconds, 99)
+        self.assertEqual(str(config.scheduler_address), "tcp://127.0.0.1:5555")
+
+
+if __name__ == "__main__":
+    unittest.main()

opengris_scaler-1.12.9/tests/test_config_types.py

@@ -0,0 +1,50 @@
+import unittest
+
+from scaler.config.types.worker import WorkerCapabilities, WorkerNames
+from scaler.config.types.zmq import ZMQConfig
+
+
+class TestConfigTypes(unittest.TestCase):
+    """Tests for individual ConfigType helper classes."""
+
+    def test_zmq_config_validation(self):
+        """Test ZMQConfig.from_string raises ValueError for malformed strings."""
+        with self.assertRaises(ValueError):
+            ZMQConfig.from_string("this-is-not-a-valid-address")
+        with self.assertRaises(ValueError):
+            ZMQConfig.from_string("tcp://127.0.0.1")
+        with self.assertRaises(ValueError):
+            ZMQConfig.from_string("badprotocol://127.0.0.1:1234")
+
+        cfg = ZMQConfig.from_string("ipc://a-valid-path")
+        self.assertEqual(cfg.host, "a-valid-path")
+
+    def test_worker_names_config_value(self):
+        """Test the WorkerNames ConfigType class."""
+        wn = WorkerNames.from_string(" worker1 , worker2 ")
+        self.assertEqual(wn.names, ["worker1", "worker2"])
+        self.assertEqual(str(wn), "worker1,worker2")
+        self.assertEqual(len(wn), 2)
+        wn_empty = WorkerNames.from_string("")
+        self.assertEqual(wn_empty.names, [])
+
+    def test_worker_capabilities_config_value(self):
+        """Test the WorkerCapabilities ConfigType class."""
+        wc = WorkerCapabilities.from_string(" gpu=2, linux ")
+        self.assertEqual(wc.capabilities, {"gpu": 2, "linux": -1})
+        self.assertIn("gpu=2", str(wc))
+        self.assertIn("linux", str(wc))
+
+    def test_worker_capabilities_invalid_input(self):
+        """Test that WorkerCapabilities raises an error for non-integer values."""
+        with self.assertRaises(ValueError):
+            WorkerCapabilities.from_string("gpu=two")
+
+    def test_worker_capabilities_invalid_value_in_string(self):
+        """Test that WorkerCapabilities.from_string raises a helpful ValueError for non-integer values."""
+        with self.assertRaisesRegex(ValueError, "Expected an integer, but got 'MostPowerful'"):
+            WorkerCapabilities.from_string("linux,cpu=MostPowerful")
+
+
+if __name__ == "__main__":
+    unittest.main()

opengris_scaler-1.12.8/tests/test_config.py → opengris_scaler-1.12.9/tests/test_scheduler_config.py

@@ -3,58 +3,13 @@ import tempfile
 import unittest
 from argparse import Namespace
 
-from scaler.config.section.cluster import ClusterConfig
+from scaler.config import defaults
 from scaler.config.loader import load_config
 from scaler.config.section.scheduler import SchedulerConfig
 from scaler.config.types.object_storage_server import ObjectStorageConfig
-from scaler.config.types.worker import WorkerCapabilities, WorkerNames
-from scaler.config.types.zmq import ZMQConfig
-from scaler.config import defaults
 from scaler.scheduler.allocate_policy.allocate_policy import AllocatePolicy
 
 
-class TestConfigTypes(unittest.TestCase):
-    """Tests for individual ConfigType helper classes."""
-
-    def test_zmq_config_validation(self):
-        """Test ZMQConfig.from_string raises ValueError for malformed strings."""
-        with self.assertRaises(ValueError):
-            ZMQConfig.from_string("this-is-not-a-valid-address")
-        with self.assertRaises(ValueError):
-            ZMQConfig.from_string("tcp://127.0.0.1")
-        with self.assertRaises(ValueError):
-            ZMQConfig.from_string("badprotocol://127.0.0.1:1234")
-
-        cfg = ZMQConfig.from_string("ipc://a-valid-path")
-        self.assertEqual(cfg.host, "a-valid-path")
-
-    def test_worker_names_config_value(self):
-        """Test the WorkerNames ConfigType class."""
-        wn = WorkerNames.from_string(" worker1 , worker2 ")
-        self.assertEqual(wn.names, ["worker1", "worker2"])
-        self.assertEqual(str(wn), "worker1,worker2")
-        self.assertEqual(len(wn), 2)
-        wn_empty = WorkerNames.from_string("")
-        self.assertEqual(wn_empty.names, [])
-
-    def test_worker_capabilities_config_value(self):
-        """Test the WorkerCapabilities ConfigType class."""
-        wc = WorkerCapabilities.from_string(" gpu=2, linux ")
-        self.assertEqual(wc.capabilities, {"gpu": 2, "linux": -1})
-        self.assertIn("gpu=2", str(wc))
-        self.assertIn("linux", str(wc))
-
-    def test_worker_capabilities_invalid_input(self):
-        """Test that WorkerCapabilities raises an error for non-integer values."""
-        with self.assertRaises(ValueError):
-            WorkerCapabilities.from_string("gpu=two")
-
-    def test_worker_capabilities_invalid_value_in_string(self):
-        """Test that WorkerCapabilities.from_string raises a helpful ValueError for non-integer values."""
-        with self.assertRaisesRegex(ValueError, "Expected an integer, but got 'MostPowerful'"):
-            WorkerCapabilities.from_string("linux,cpu=MostPowerful")
-
-
 class TestSchedulerConfig(unittest.TestCase):
     """Tests for the SchedulerConfig class."""
 
@@ -136,44 +91,5 @@ allocate_policy = "even"
         self.assertEqual(config.logging_paths, ("/var/log/scaler.log", "/dev/stdout"))
 
 
-class TestClusterConfig(unittest.TestCase):
-    """Tests for the ClusterConfig class."""
-
-    def setUp(self):
-        self.temp_dir = tempfile.TemporaryDirectory()
-        self.config_path = os.path.join(self.temp_dir.name, "cluster.toml")
-        with open(self.config_path, "w") as f:
-            f.write(
-                """
-scheduler_address = "tcp://127.0.0.1:5555"
-# FIX: Changed num_of_workers to match the number of worker_names
-num_of_workers = 2
-worker_names = "w1,w2"
-"""
-            )
-
-    def tearDown(self):
-        self.temp_dir.cleanup()
-
-    def test_load_from_toml_only(self):
-        """Test loading ClusterConfig from a flat TOML file."""
-        config = load_config(ClusterConfig, self.config_path, Namespace())
-        self.assertEqual(str(config.scheduler_address), "tcp://127.0.0.1:5555")
-        self.assertEqual(config.num_of_workers, 2)
-        self.assertEqual(config.worker_names.names, ["w1", "w2"])
-
-    def test_command_line_overrides_toml(self):
-        """Test that argparse args correctly override TOML values for ClusterConfig."""
-        worker_list = [f"worker_{i}" for i in range(20)]
-        args = Namespace(num_of_workers=20, worker_names=",".join(worker_list), heartbeat_interval_seconds=99)
-
-        config = load_config(ClusterConfig, self.config_path, args)
-
-        self.assertEqual(config.num_of_workers, 20)
-        self.assertEqual(config.worker_names.names, worker_list)
-        self.assertEqual(config.heartbeat_interval_seconds, 99)
-        self.assertEqual(str(config.scheduler_address), "tcp://127.0.0.1:5555")
-
-
 if __name__ == "__main__":
     unittest.main()

opengris_scaler-1.12.8/scaler/version.txt

@@ -1 +0,0 @@
-1.12.8