Merge pull request #222 from poissoncorp/RDBC-844

RDBC-844 Implement database settings operations

Author: poissoncorp

ravendb/serverwide/operations/common.py

@@ -371,6 +371,10 @@ class DatabaseSettings:
     def __init__(self, settings: Dict[str, str] = None):
         self.settings = settings
 
+    @classmethod
+    def from_json(cls, json_dict: Dict) -> DatabaseSettings:
+        return cls(json_dict["Settings"])
+
 
 class ReorderDatabaseMembersOperation(VoidServerOperation):
     class Parameters:

ravendb/serverwide/operations/configuration.py

@@ -1,16 +1,17 @@
 from __future__ import annotations
 
 import json
-from typing import Optional, List, TYPE_CHECKING
+from typing import Optional, List, TYPE_CHECKING, Dict
 
 import requests
 
 from ravendb import ServerNode
+from ravendb.documents.operations.definitions import MaintenanceOperation, VoidMaintenanceOperation
 from ravendb.documents.operations.ongoing_tasks import OngoingTaskType
 from ravendb.http.raven_command import RavenCommand, VoidRavenCommand
 from ravendb.http.topology import RaftCommand
 from ravendb.documents.operations.backups.settings import PeriodicBackupConfiguration
-from ravendb.serverwide.operations.common import ServerOperation, T, VoidServerOperation
+from ravendb.serverwide.operations.common import ServerOperation, T, VoidServerOperation, DatabaseSettings
 from ravendb.serverwide.operations.ongoing_tasks import IServerWideTask, ServerWideTaskResponse
 from ravendb.tools.utils import Utils
 from ravendb.util.util import RaftIdGenerator
@@ -163,3 +164,72 @@ def get_raft_unique_request_id(self) -> str:
         def create_request(self, node: ServerNode) -> requests.Request:
             url = f"{node.url}/admin/configuration/server-wide/task?type={self._type.value}&name={Utils.quote_key(self._name)}"
             return requests.Request(method="DELETE", url=url)
+
+
+class GetDatabaseSettingsOperation(MaintenanceOperation[DatabaseSettings]):
+    def __init__(self, database_name: str = None):
+        if database_name is None:
+            raise ValueError("Database name cannot be None")
+        self._database_name = database_name
+
+    def get_command(self, conventions: "DocumentConventions") -> "RavenCommand[DatabaseSettings]":
+        return self.GetDatabaseSettingsCommand(self._database_name)
+
+    class GetDatabaseSettingsCommand(RavenCommand[DatabaseSettings]):
+        def __init__(self, database_name: str = None):
+            super().__init__(DatabaseSettings)
+
+            if database_name is None:
+                raise ValueError("Database name cannot be None")
+
+            self._database_name = database_name
+
+        def is_read_request(self) -> bool:
+            return False
+
+        def create_request(self, node: ServerNode) -> requests.Request:
+            url = f"{node.url}/databases/{self._database_name}/admin/record"
+            return requests.Request(method="GET", url=url)
+
+        def set_response(self, response: Optional[str], from_cache: bool) -> None:
+            if response is None:
+                self.result = None
+                return
+
+            self.result = DatabaseSettings.from_json(json.loads(response))
+
+
+class PutDatabaseSettingsOperation(VoidMaintenanceOperation):
+    def __init__(self, database_name: str, configuration_settings: Dict[str, str]):
+        if database_name is None:
+            raise ValueError("Database name cannot be None")
+        self._database_name = database_name
+
+        if configuration_settings is None:
+            raise ValueError("Configuration settings cannot be None")
+        self._configuration_settings = configuration_settings
+
+    def get_command(self, conventions: "DocumentConventions") -> "VoidRavenCommand":
+        return self.PutDatabaseSettingsCommand(self._configuration_settings, self._database_name)
+
+    class PutDatabaseSettingsCommand(VoidRavenCommand, RaftCommand):
+        def __init__(self, configuration_settings: Dict[str, str], database_name: str):
+            super().__init__()
+            if database_name is None:
+                raise ValueError("Database name cannot be None.")
+            self._database_name = database_name
+
+            if configuration_settings is None:
+                raise ValueError("Configuration settings cannot be None.")
+            self._configuration_settings = configuration_settings
+
+        def is_read_request(self) -> bool:
+            return False
+
+        def get_raft_unique_request_id(self) -> str:
+            return RaftIdGenerator.new_id()
+
+        def create_request(self, node: ServerNode) -> requests.Request:
+            url = f"{node.url}/databases/{self._database_name}/admin/configuration/settings"
+
+            return requests.Request(method="PUT", url=url, data=self._configuration_settings)

ravendb/tests/jvm_migrated_tests/client_tests/test_database_settings_operation.py

@@ -0,0 +1,49 @@
+from typing import Dict
+
+from ravendb.serverwide.operations.common import DatabaseSettings
+
+from ravendb import DocumentStore
+from ravendb.documents.operations.server_misc import ToggleDatabasesStateOperation
+from ravendb.serverwide.operations.configuration import GetDatabaseSettingsOperation, PutDatabaseSettingsOperation
+from ravendb.tests.test_base import TestBase
+
+
+class TestDatabaseSettingsOperation(TestBase):
+    def test_check_if_configuration_settings_is_empty(self):
+        self.check_if_values_got_saved(self.store, {})
+
+    def test_change_single_setting_key_on_server(self):
+        name = "Storage.PrefetchResetThresholdInGb"
+        value = "10"
+
+        settings = {name: value}
+        self.put_configuration_settings(self.store, settings)
+        self.check_if_values_got_saved(self.store, settings)
+
+    def test_change_multiple_settings_keys_on_server(self):
+        settings = {
+            "Storage.PrefetchResetThresholdInGb": "10",
+            "Storage.TimeToSyncAfterFlushInSec": "35",
+            "Tombstones.CleanupIntervalInMin": "10",
+        }
+
+        self.put_configuration_settings(self.store, settings)
+        self.check_if_values_got_saved(self.store, settings)
+
+    @staticmethod
+    def put_configuration_settings(store: DocumentStore, settings: Dict[str, str]) -> None:
+        store.maintenance.send(PutDatabaseSettingsOperation(store.database, settings))
+        store.maintenance.server.send(ToggleDatabasesStateOperation(store.database, True))
+        store.maintenance.server.send(ToggleDatabasesStateOperation(store.database, False))
+
+    def check_if_values_got_saved(self, store: DocumentStore, data: Dict[str, str]):
+        settings = self.get_configuration_settings(store)
+        for key, value in data.items():
+            configuration_value = settings.settings.get(key)
+            self.assertIsNotNone(configuration_value)
+            self.assertEqual(configuration_value, value)
+
+    def get_configuration_settings(self, store: DocumentStore) -> DatabaseSettings:
+        settings = store.maintenance.send(GetDatabaseSettingsOperation(store.database))
+        self.assertIsNotNone(settings)
+        return settings