Rewire `FileStorManager` config

10 files changed, 81 insertions, 58 deletions

diff --git a/storage/src/tests/bucketdb/bucketmanagertest.cpp b/storage/src/tests/bucketdb/bucketmanagertest.cpp
index 52ac6f7dba1..7a2c22553f7 100644
--- a/storage/src/tests/bucketdb/bucketmanagertest.cpp
+++ b/storage/src/tests/bucketdb/bucketmanagertest.cpp
@@ -158,7 +158,9 @@ void BucketManagerTest::setupTestEnvironment(bool fakePersistenceLayer, bool noD
         _bottom = bottom.get();
         _top->push_back(std::move(bottom));
     } else {
-        auto bottom = std::make_unique<FileStorManager>(config::ConfigUri(config.getConfigId()),
+        using vespa::config::content::StorFilestorConfig;
+        auto filestor_cfg = config_from<StorFilestorConfig>(config_uri);
+        auto bottom = std::make_unique<FileStorManager>(*filestor_cfg,
                                                         _node->getPersistenceProvider(), _node->getComponentRegister(),
                                                         *_node, _node->get_host_info());
         _top->push_back(std::move(bottom));
diff --git a/storage/src/tests/persistence/common/filestortestfixture.cpp b/storage/src/tests/persistence/common/filestortestfixture.cpp
index c989acd5228..74d34fb0f50 100644
--- a/storage/src/tests/persistence/common/filestortestfixture.cpp
+++ b/storage/src/tests/persistence/common/filestortestfixture.cpp
@@ -1,15 +1,17 @@
 // Copyright Vespa.ai. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
 
-#include <vespa/storage/persistence/messages.h>
-#include <vespa/storage/persistence/filestorage/filestormanager.h>
-#include <vespa/storageapi/message/bucket.h>
-#include <vespa/persistence/dummyimpl/dummypersistence.h>
+#include <tests/common/testhelper.h>
 #include <tests/persistence/common/filestortestfixture.h>
-#include <vespa/document/repo/documenttyperepo.h>
+#include <vespa/config/helper/configgetter.hpp>
 #include <vespa/document/fieldset/fieldsets.h>
+#include <vespa/document/repo/documenttyperepo.h>
 #include <vespa/document/test/make_document_bucket.h>
-#include <vespa/vdslib/state/clusterstate.h>
+#include <vespa/persistence/dummyimpl/dummypersistence.h>
 #include <vespa/persistence/spi/test.h>
+#include <vespa/storage/persistence/filestorage/filestormanager.h>
+#include <vespa/storage/persistence/messages.h>
+#include <vespa/storageapi/message/bucket.h>
+#include <vespa/vdslib/state/clusterstate.h>
 #include <sstream>
 
 using storage::spi::test::makeSpiBucket;
@@ -73,7 +75,9 @@ FileStorTestFixture::TestFileStorComponents::TestFileStorComponents(
       manager(nullptr)
 {
     injector.inject(top);
-    auto fsm = std::make_unique<FileStorManager>(config::ConfigUri(fixture._config->getConfigId()), fixture._node->getPersistenceProvider(),
+    using vespa::config::content::StorFilestorConfig;
+    auto config = config_from<StorFilestorConfig>(config::ConfigUri(fixture._config->getConfigId()));
+    auto fsm = std::make_unique<FileStorManager>(*config, fixture._node->getPersistenceProvider(),
                                                  fixture._node->getComponentRegister(), *fixture._node, fixture._node->get_host_info());
     manager = fsm.get();
     top.push_back(std::move(fsm));
diff --git a/storage/src/tests/persistence/filestorage/filestormanagertest.cpp b/storage/src/tests/persistence/filestorage/filestormanagertest.cpp
index b09febce408..586863251c9 100644
--- a/storage/src/tests/persistence/filestorage/filestormanagertest.cpp
+++ b/storage/src/tests/persistence/filestorage/filestormanagertest.cpp
@@ -5,6 +5,7 @@
 #include <tests/common/teststorageapp.h>
 #include <tests/persistence/filestorage/forwardingmessagesender.h>
 #include <vespa/config/common/exceptions.h>
+#include <vespa/config/helper/configgetter.hpp>
 #include <vespa/document/fieldset/fieldsets.h>
 #include <vespa/document/repo/documenttyperepo.h>
 #include <vespa/document/select/parser.h>
@@ -223,8 +224,10 @@ struct TestFileStorComponents {
     explicit TestFileStorComponents(FileStorTestBase& test, bool use_small_config = false)
         : manager(nullptr)
     {
-        auto fsm = std::make_unique<FileStorManager>(config::ConfigUri((use_small_config ? test.smallConfig : test.config)->getConfigId()),
-                                                     test._node->getPersistenceProvider(),
+        using vespa::config::content::StorFilestorConfig;
+        auto config_uri = config::ConfigUri((use_small_config ? test.smallConfig : test.config)->getConfigId());
+        auto config = config_from<StorFilestorConfig>(config_uri);
+        auto fsm = std::make_unique<FileStorManager>(*config, test._node->getPersistenceProvider(),
                                                      test._node->getComponentRegister(), *test._node, test._node->get_host_info());
         manager = fsm.get();
         top.push_back(std::move(fsm));
diff --git a/storage/src/tests/visiting/visitormanagertest.cpp b/storage/src/tests/visiting/visitormanagertest.cpp
index d4047bc9a72..4fb857f9e67 100644
--- a/storage/src/tests/visiting/visitormanagertest.cpp
+++ b/storage/src/tests/visiting/visitormanagertest.cpp
@@ -98,7 +98,9 @@ VisitorManagerTest::initializeTest(bool defer_manager_thread_start)
                                                defer_manager_thread_start);
     _manager = vm.get();
     _top->push_back(std::move(vm));
-    _top->push_back(std::make_unique<FileStorManager>(config::ConfigUri(config.getConfigId()), _node->getPersistenceProvider(),
+    using vespa::config::content::StorFilestorConfig;
+    auto filestor_cfg = config_from<StorFilestorConfig>(config::ConfigUri(config.getConfigId()));
+    _top->push_back(std::make_unique<FileStorManager>(*filestor_cfg, _node->getPersistenceProvider(),
                                                       _node->getComponentRegister(), *_node, _node->get_host_info()));
     _manager->setTimeBetweenTicks(10);
     _top->open();
diff --git a/storage/src/vespa/storage/persistence/filestorage/filestormanager.cpp b/storage/src/vespa/storage/persistence/filestorage/filestormanager.cpp
index 97be1a510c4..6c49fcd0878 100644
--- a/storage/src/vespa/storage/persistence/filestorage/filestormanager.cpp
+++ b/storage/src/vespa/storage/persistence/filestorage/filestormanager.cpp
@@ -62,7 +62,7 @@ private:
 }
 
 FileStorManager::
-FileStorManager(const config::ConfigUri & configUri, spi::PersistenceProvider& provider,
+FileStorManager(const StorFilestorConfig& bootstrap_config, spi::PersistenceProvider& provider,
                 ServiceLayerComponentRegister& compReg, DoneInitializeHandler& init_handler,
                 HostInfo& hostInfoReporterRegistrar)
     : StorageLinkQueued("File store manager", compReg),
@@ -75,7 +75,6 @@ FileStorManager(const config::ConfigUri & configUri, spi::PersistenceProvider& p
       _persistenceHandlers(),
       _threads(),
       _bucketOwnershipNotifier(std::make_unique<BucketOwnershipNotifier>(_component, *this)),
-      _configFetcher(std::make_unique<config::ConfigFetcher>(configUri.getContext())),
       _use_async_message_handling_on_schedule(false),
       _metrics(std::make_unique<FileStorMetrics>()),
       _filestorHandler(),
@@ -85,8 +84,7 @@ FileStorManager(const config::ConfigUri & configUri, spi::PersistenceProvider& p
       _host_info_reporter(_component.getStateUpdater()),
       _resource_usage_listener_registration(provider.register_resource_usage_listener(_host_info_reporter))
 {
-    _configFetcher->subscribe(configUri.getConfigId(), this);
-    _configFetcher->start();
+    on_configure(bootstrap_config);
     _component.registerMetric(*_metrics);
     _component.registerStatusPage(*this);
     _component.getStateUpdater().addStateListener(*this);
@@ -207,19 +205,19 @@ FileStorManager::getThreadLocalHandler() {
 }
 
 void
-FileStorManager::configure(std::unique_ptr<StorFilestorConfig> config)
+FileStorManager::on_configure(const StorFilestorConfig& config)
 {
     // If true, this is not the first configure.
     const bool liveUpdate = ! _threads.empty();
 
-    _use_async_message_handling_on_schedule = config->useAsyncMessageHandlingOnSchedule;
-    _host_info_reporter.set_noise_level(config->resourceUsageReporterNoiseLevel);
-    const bool use_dynamic_throttling = ((config->asyncOperationThrottlerType  == StorFilestorConfig::AsyncOperationThrottlerType::DYNAMIC) ||
-                                         (config->asyncOperationThrottler.type == StorFilestorConfig::AsyncOperationThrottler::Type::DYNAMIC));
-    const bool throttle_merge_feed_ops = config->asyncOperationThrottler.throttleIndividualMergeFeedOps;
+    _use_async_message_handling_on_schedule = config.useAsyncMessageHandlingOnSchedule;
+    _host_info_reporter.set_noise_level(config.resourceUsageReporterNoiseLevel);
+    const bool use_dynamic_throttling = ((config.asyncOperationThrottlerType  == StorFilestorConfig::AsyncOperationThrottlerType::DYNAMIC) ||
+                                         (config.asyncOperationThrottler.type == StorFilestorConfig::AsyncOperationThrottler::Type::DYNAMIC));
+    const bool throttle_merge_feed_ops = config.asyncOperationThrottler.throttleIndividualMergeFeedOps;
 
     if (!liveUpdate) {
-        _config = std::move(config);
+        _config = std::make_unique<StorFilestorConfig>(config);
         uint32_t numThreads = std::max(1, _config->numThreads);
         uint32_t numStripes = std::max(1u, numThreads / 2);
         _metrics->initDiskMetrics(numStripes, computeAllPossibleHandlerThreads(*_config));
@@ -240,7 +238,7 @@ FileStorManager::configure(std::unique_ptr<StorFilestorConfig> config)
         _bucketExecutorRegistration = _provider->register_executor(std::make_shared<BucketExecutorWrapper>(*this));
     } else {
         assert(_filestorHandler);
-        auto updated_dyn_throttle_params = dynamic_throttle_params_from_config(*config, _threads.size());
+        auto updated_dyn_throttle_params = dynamic_throttle_params_from_config(config, _threads.size());
         _filestorHandler->reconfigure_dynamic_throttler(updated_dyn_throttle_params);
     }
     // TODO remove once desired dynamic throttling behavior is set in stone
@@ -828,8 +826,6 @@ void FileStorManager::onClose()
     LOG(debug, "Start closing");
     _bucketExecutorRegistration.reset();
     _resource_usage_listener_registration.reset();
-    // Avoid getting config during shutdown
-    _configFetcher->close();
     LOG(debug, "Closed _configFetcher.");
     _filestorHandler->close();
     LOG(debug, "Closed _filestorHandler.");
diff --git a/storage/src/vespa/storage/persistence/filestorage/filestormanager.h b/storage/src/vespa/storage/persistence/filestorage/filestormanager.h
index 68491ab1e38..96cff8dfeee 100644
--- a/storage/src/vespa/storage/persistence/filestorage/filestormanager.h
+++ b/storage/src/vespa/storage/persistence/filestorage/filestormanager.h
@@ -1,10 +1,4 @@
 // Copyright Vespa.ai. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
-/**
- * @class storage::FileStorManager
- * @ingroup filestorage
- *
- * @version $Id$
- */
 
 #pragma once
 
@@ -42,7 +36,6 @@ namespace spi { struct PersistenceProvider; }
 
 class ContentBucketSpace;
 struct FileStorManagerTest;
-class ReadBucketList;
 class BucketOwnershipNotifier;
 class AbortBucketOperationsCommand;
 struct DoneInitializeHandler;
@@ -54,10 +47,11 @@ class ProviderErrorWrapper;
 class FileStorManager : public StorageLinkQueued,
                         public framework::HtmlStatusReporter,
                         public StateListener,
-                        private config::IFetcherCallback<vespa::config::content::StorFilestorConfig>,
                         public MessageSender,
                         public spi::BucketExecutor
 {
+    using StorFilestorConfig = vespa::config::content::StorFilestorConfig;
+
     ServiceLayerComponentRegister             & _compReg;
     ServiceLayerComponent                       _component;
     std::unique_ptr<spi::PersistenceProvider>   _provider;
@@ -69,7 +63,6 @@ class FileStorManager : public StorageLinkQueued,
     std::unique_ptr<BucketOwnershipNotifier>         _bucketOwnershipNotifier;
 
     std::unique_ptr<vespa::config::content::StorFilestorConfig> _config;
-    std::unique_ptr<config::ConfigFetcher> _configFetcher;
     bool                  _use_async_message_handling_on_schedule;
     std::shared_ptr<FileStorMetrics> _metrics;
     std::unique_ptr<FileStorHandler> _filestorHandler;
@@ -82,7 +75,7 @@ class FileStorManager : public StorageLinkQueued,
     std::unique_ptr<vespalib::IDestructorCallback> _resource_usage_listener_registration;
 
 public:
-    FileStorManager(const config::ConfigUri &, spi::PersistenceProvider&,
+    FileStorManager(const StorFilestorConfig&, spi::PersistenceProvider&,
                     ServiceLayerComponentRegister&, DoneInitializeHandler&, HostInfo&);
     FileStorManager(const FileStorManager &) = delete;
     FileStorManager& operator=(const FileStorManager &) = delete;
@@ -118,8 +111,9 @@ public:
 
     const FileStorMetrics& get_metrics() const { return *_metrics; }
 
+    void on_configure(const vespa::config::content::StorFilestorConfig& config);
+
 private:
-    void configure(std::unique_ptr<vespa::config::content::StorFilestorConfig> config) override;
     PersistenceHandler & createRegisteredHandler(const ServiceLayerComponent & component);
     VESPA_DLL_LOCAL PersistenceHandler & getThreadLocalHandler();
 
diff --git a/storage/src/vespa/storage/storageserver/servicelayernode.cpp b/storage/src/vespa/storage/storageserver/servicelayernode.cpp
index b6e87c1bb59..f494840ca13 100644
--- a/storage/src/vespa/storage/storageserver/servicelayernode.cpp
+++ b/storage/src/vespa/storage/storageserver/servicelayernode.cpp
@@ -43,6 +43,7 @@ ServiceLayerNode::ServiceLayerNode(const config::ConfigUri & configUri,
       _externalVisitors(externalVisitors),
       _persistence_bootstrap_config(std::move(bootstrap_configs.persistence_cfg)),
       _visitor_bootstrap_config(std::move(bootstrap_configs.visitor_cfg)),
+      _filestor_bootstrap_config(std::move(bootstrap_configs.filestor_cfg)),
       _bouncer(nullptr),
       _bucket_manager(nullptr),
       _changed_bucket_ownership_handler(nullptr),
@@ -188,7 +189,8 @@ ServiceLayerNode::createChain(IStorageChainBuilder &builder)
     _modified_bucket_checker = bucket_checker.get();
     builder.add(std::move(bucket_checker));
     auto state_manager = releaseStateManager();
-    auto filstor_manager = std::make_unique<FileStorManager>(_configUri, _persistenceProvider, _context.getComponentRegister(),
+    auto filstor_manager = std::make_unique<FileStorManager>(*_filestor_bootstrap_config, _persistenceProvider,
+                                                             _context.getComponentRegister(),
                                                              getDoneInitializeHandler(), state_manager->getHostInfo());
     _fileStorManager = filstor_manager.get();
     builder.add(std::move(filstor_manager));
@@ -227,6 +229,12 @@ ServiceLayerNode::on_configure(const StorVisitorConfig& config)
     _visitor_manager->on_configure(config);
 }
 
+void
+ServiceLayerNode::on_configure(const StorFilestorConfig& config)
+{
+    assert(_fileStorManager);
+    _fileStorManager->on_configure(config);
+}
 
 ResumeGuard
 ServiceLayerNode::pause()
diff --git a/storage/src/vespa/storage/storageserver/servicelayernode.h b/storage/src/vespa/storage/storageserver/servicelayernode.h
index 078d179795f..ae39bb0805e 100644
--- a/storage/src/vespa/storage/storageserver/servicelayernode.h
+++ b/storage/src/vespa/storage/storageserver/servicelayernode.h
@@ -7,6 +7,7 @@
 #include "storagenode.h"
 #include "vespa/vespalib/util/jsonstream.h"
 #include <vespa/config-persistence.h>
+#include <vespa/config-stor-filestor.h>
 #include <vespa/storage/common/nodestateupdater.h>
 #include <vespa/storage/common/visitorfactory.h>
 #include <vespa/storage/visiting/config-stor-visitor.h>
@@ -31,30 +32,33 @@ class ServiceLayerNode
 
 {
 public:
-    using PersistenceConfig = vespa::config::content::PersistenceConfig;
-    using StorVisitorConfig = vespa::config::content::core::StorVisitorConfig;
+    using PersistenceConfig  = vespa::config::content::PersistenceConfig;
+    using StorVisitorConfig  = vespa::config::content::core::StorVisitorConfig;
+    using StorFilestorConfig = vespa::config::content::StorFilestorConfig;
 private:
-    ServiceLayerNodeContext&           _context;
-    spi::PersistenceProvider&          _persistenceProvider;
-    VisitorFactory::Map                _externalVisitors;
-    std::unique_ptr<PersistenceConfig> _persistence_bootstrap_config;
-    std::unique_ptr<StorVisitorConfig> _visitor_bootstrap_config;
-    Bouncer*                           _bouncer;
-    BucketManager*                     _bucket_manager;
-    ChangedBucketOwnershipHandler*     _changed_bucket_ownership_handler;
-    FileStorManager*                   _fileStorManager;
-    MergeThrottler*                    _merge_throttler;
-    VisitorManager*                    _visitor_manager;
-    ModifiedBucketChecker*             _modified_bucket_checker;
-    bool                               _init_has_been_called;
+    ServiceLayerNodeContext&            _context;
+    spi::PersistenceProvider&           _persistenceProvider;
+    VisitorFactory::Map                 _externalVisitors;
+    std::unique_ptr<PersistenceConfig>  _persistence_bootstrap_config;
+    std::unique_ptr<StorVisitorConfig>  _visitor_bootstrap_config;
+    std::unique_ptr<StorFilestorConfig> _filestor_bootstrap_config;
+    Bouncer*                            _bouncer;
+    BucketManager*                      _bucket_manager;
+    ChangedBucketOwnershipHandler*      _changed_bucket_ownership_handler;
+    FileStorManager*                    _fileStorManager;
+    MergeThrottler*                     _merge_throttler;
+    VisitorManager*                     _visitor_manager;
+    ModifiedBucketChecker*              _modified_bucket_checker;
+    bool                                _init_has_been_called;
 
 public:
     using UP = std::unique_ptr<ServiceLayerNode>;
 
     struct ServiceLayerBootstrapConfigs {
         BootstrapConfigs storage_bootstrap_configs;
-        std::unique_ptr<PersistenceConfig> persistence_cfg;
-        std::unique_ptr<StorVisitorConfig> visitor_cfg;
+        std::unique_ptr<PersistenceConfig>  persistence_cfg;
+        std::unique_ptr<StorVisitorConfig>  visitor_cfg;
+        std::unique_ptr<StorFilestorConfig> filestor_cfg;
 
         ServiceLayerBootstrapConfigs();
         ~ServiceLayerBootstrapConfigs();
@@ -77,6 +81,7 @@ public:
     void on_configure(const StorServerConfig& config);
     void on_configure(const PersistenceConfig& config);
     void on_configure(const StorVisitorConfig& config);
+    void on_configure(const StorFilestorConfig& config);
 
     const lib::NodeType& getNodeType() const override { return lib::NodeType::STORAGE; }
 
diff --git a/storageserver/src/vespa/storageserver/app/servicelayerprocess.cpp b/storageserver/src/vespa/storageserver/app/servicelayerprocess.cpp
index f43ec574806..bb284bfc108 100644
--- a/storageserver/src/vespa/storageserver/app/servicelayerprocess.cpp
+++ b/storageserver/src/vespa/storageserver/app/servicelayerprocess.cpp
@@ -36,6 +36,7 @@ ServiceLayerProcess::ServiceLayerProcess(const config::ConfigUri& configUri)
       _externalVisitors(),
       _persistence_cfg_handle(),
       _visitor_cfg_handle(),
+      _filestor_cfg_handle(),
       _node(),
       _storage_chain_builder(),
       _context(std::make_unique<framework::defaultimplementation::RealClock>(),
@@ -57,6 +58,7 @@ ServiceLayerProcess::setupConfig(vespalib::duration subscribe_timeout)
 {
     _persistence_cfg_handle = _configSubscriber.subscribe<PersistenceConfig>(_configUri.getConfigId(), subscribe_timeout);
     _visitor_cfg_handle     = _configSubscriber.subscribe<StorVisitorConfig>(_configUri.getConfigId(), subscribe_timeout);
+    _filestor_cfg_handle    = _configSubscriber.subscribe<StorFilestorConfig>(_configUri.getConfigId(), subscribe_timeout);
     // We reuse the StorServerConfig subscription from the parent Process
     Process::setupConfig(subscribe_timeout);
 }
@@ -74,6 +76,9 @@ ServiceLayerProcess::updateConfig()
     if (_visitor_cfg_handle->isChanged()) {
         _node->on_configure(*_visitor_cfg_handle->getConfig());
     }
+    if (_filestor_cfg_handle->isChanged()) {
+        _node->on_configure(*_filestor_cfg_handle->getConfig());
+    }
 }
 
 bool
@@ -99,6 +104,7 @@ ServiceLayerProcess::createNode()
     sbc.storage_bootstrap_configs = std::move(bc);
     sbc.persistence_cfg = _persistence_cfg_handle->getConfig();
     sbc.visitor_cfg     = _visitor_cfg_handle->getConfig();
+    sbc.filestor_cfg    = _filestor_cfg_handle->getConfig();
 
     _node = std::make_unique<ServiceLayerNode>(_configUri, _context, std::move(sbc), *this, getProvider(), _externalVisitors);
     if (_storage_chain_builder) {
diff --git a/storageserver/src/vespa/storageserver/app/servicelayerprocess.h b/storageserver/src/vespa/storageserver/app/servicelayerprocess.h
index d91c66be266..dcc56f373c4 100644
--- a/storageserver/src/vespa/storageserver/app/servicelayerprocess.h
+++ b/storageserver/src/vespa/storageserver/app/servicelayerprocess.h
@@ -3,6 +3,7 @@
 
 #include "process.h"
 #include <vespa/config-persistence.h>
+#include <vespa/config-stor-filestor.h>
 #include <vespa/storage/common/visitorfactory.h>
 #include <vespa/storage/storageserver/servicelayernodecontext.h>
 #include <vespa/storage/visiting/config-stor-visitor.h>
@@ -20,11 +21,13 @@ class ServiceLayerProcess : public Process {
 protected:
     VisitorFactory::Map _externalVisitors;
 private:
-    using PersistenceConfig = vespa::config::content::PersistenceConfig;
-    using StorVisitorConfig = vespa::config::content::core::StorVisitorConfig;
+    using PersistenceConfig  = vespa::config::content::PersistenceConfig;
+    using StorVisitorConfig  = vespa::config::content::core::StorVisitorConfig;
+    using StorFilestorConfig = vespa::config::content::StorFilestorConfig;
 
-    std::unique_ptr<config::ConfigHandle<PersistenceConfig>> _persistence_cfg_handle;
-    std::unique_ptr<config::ConfigHandle<StorVisitorConfig>> _visitor_cfg_handle;
+    std::unique_ptr<config::ConfigHandle<PersistenceConfig>>  _persistence_cfg_handle;
+    std::unique_ptr<config::ConfigHandle<StorVisitorConfig>>  _visitor_cfg_handle;
+    std::unique_ptr<config::ConfigHandle<StorFilestorConfig>> _filestor_cfg_handle;
 
     std::unique_ptr<ServiceLayerNode> _node;
     std::unique_ptr<IStorageChainBuilder> _storage_chain_builder;