Reload validator options when needed

validator-engine/validator-engine.cpp

@@ -1404,7 +1404,7 @@ td::Status ValidatorEngine::load_global_config() {
   return td::Status::OK();
 }
 
-void ValidatorEngine::init_validator_options() {
+void ValidatorEngine::set_shard_check_function() {
   if (!not_all_shards_) {
     validator_options_.write().set_shard_check_function([](ton::ShardIdFull shard) -> bool { return true; });
   } else {
@@ -1711,7 +1711,7 @@ void ValidatorEngine::got_key(ton::PublicKey key) {
 }
 
 void ValidatorEngine::start() {
-  init_validator_options();
+  set_shard_check_function();
   read_config_ = true;
   start_adnl();
 }
@@ -3412,7 +3412,10 @@ void ValidatorEngine::run_control_query(ton::ton_api::engine_validator_addCollat
     promise.set_value(ton::serialize_tl_object(ton::create_tl_object<ton::ton_api::engine_validator_success>(), true));
     return;
   }
+  set_shard_check_function();
   if (!validator_manager_.empty()) {
+    td::actor::send_closure(validator_manager_, &ton::validator::ValidatorManagerInterface::update_options,
+                            validator_options_);
     td::actor::send_closure(validator_manager_, &ton::validator::ValidatorManagerInterface::add_collator,
                             ton::adnl::AdnlNodeIdShort(id), shard);
   }
@@ -3443,8 +3446,19 @@ void ValidatorEngine::run_control_query(ton::ton_api::engine_validator_addShard
     promise.set_value(create_control_query_error(R.move_as_error()));
     return;
   }
+  set_shard_check_function();
+  if (!validator_manager_.empty()) {
+    td::actor::send_closure(validator_manager_, &ton::validator::ValidatorManagerInterface::update_options,
+                            validator_options_);
+  }
+  write_config([promise = std::move(promise)](td::Result<td::Unit> R) mutable {
+    if (R.is_error()) {
+      promise.set_value(create_control_query_error(R.move_as_error()));
+    } else {
       promise.set_value(ton::serialize_tl_object(ton::create_tl_object<ton::ton_api::engine_validator_success>(), true));
     }
+  });
+}
 
 void ValidatorEngine::process_control_query(td::uint16 port, ton::adnl::AdnlNodeIdShort src,
                                             ton::adnl::AdnlNodeIdShort dst, td::BufferSlice data,

validator-engine/validator-engine.hpp

@@ -283,7 +283,7 @@ class ValidatorEngine : public td::actor::Actor {
   void load_empty_local_config(td::Promise<td::Unit> promise);
   void load_local_config(td::Promise<td::Unit> promise);
   void load_config(td::Promise<td::Unit> promise);
-  void init_validator_options();
+  void set_shard_check_function();
 
   void start();
 

validator/manager-disk.hpp

@@ -386,6 +386,10 @@ class ValidatorManagerImpl : public ValidatorManager {
     UNREACHABLE();
   }
 
+  void update_options(td::Ref<ValidatorManagerOptions> opts) override {
+    opts_ = std::move(opts);
+  }
+
  private:
   PublicKeyHash local_id_;
 

validator/manager-hardfork.hpp

@@ -445,6 +445,9 @@ class ValidatorManagerImpl : public ValidatorManager {
   void add_collator(adnl::AdnlNodeIdShort id, ShardIdFull shard) override {
     UNREACHABLE();
   }
+  void update_options(td::Ref<ValidatorManagerOptions> opts) override {
+    opts_ = std::move(opts);
+  }
 
  private:
   td::Ref<ValidatorManagerOptions> opts_;

validator/manager.cpp

@@ -2696,6 +2696,16 @@ void ValidatorManagerImpl::add_collator(adnl::AdnlNodeIdShort id, ShardIdFull sh
   td::actor::send_closure(it->second, &CollatorNode::add_shard, shard);
 }
 
+void ValidatorManagerImpl::update_options(td::Ref<ValidatorManagerOptions> opts) {
+  if (!shard_client_.empty()) {
+    td::actor::send_closure(shard_client_, &ShardClient::update_options, opts);
+  }
+  if (!serializer_.empty()) {
+    td::actor::send_closure(serializer_, &AsyncStateSerializer::update_options, opts);
+  }
+  opts_ = std::move(opts);
+}
+
 td::actor::ActorOwn<ValidatorManagerInterface> ValidatorManagerFactory::create(
     td::Ref<ValidatorManagerOptions> opts, std::string db_root, td::actor::ActorId<keyring::Keyring> keyring,
     td::actor::ActorId<adnl::Adnl> adnl, td::actor::ActorId<rldp::Rldp> rldp,

validator/manager.hpp

@@ -556,6 +556,7 @@ class ValidatorManagerImpl : public ValidatorManager {
   }
 
   void add_collator(adnl::AdnlNodeIdShort id, ShardIdFull shard) override;
+  void update_options(td::Ref<ValidatorManagerOptions> opts) override;
 
  private:
   td::Timestamp resend_shard_blocks_at_;

validator/shard-client.cpp

@@ -331,6 +331,10 @@ void ShardClient::force_update_shard_client_ex(BlockHandle handle, td::Ref<Maste
   applied_all_shards();
 }
 
+void ShardClient::update_options(td::Ref<ValidatorManagerOptions> opts) {
+  opts_ = std::move(opts);
+}
+
 }  // namespace validator
 
 }  // namespace ton

validator/shard-client.hpp

@@ -97,6 +97,8 @@ class ShardClient : public td::actor::Actor {
 
   void force_update_shard_client(BlockHandle handle, td::Promise<td::Unit> promise);
   void force_update_shard_client_ex(BlockHandle handle, td::Ref<MasterchainState> state, td::Promise<td::Unit> promise);
+
+  void update_options(td::Ref<ValidatorManagerOptions> opts);
 };
 
 }  // namespace validator

validator/state-serializer.hpp

@@ -91,6 +91,10 @@ class AsyncStateSerializer : public td::actor::Actor {
   void fail_handler(td::Status reason);
   void fail_handler_cont();
   void success_handler();
+
+  void update_options(td::Ref<ValidatorManagerOptions> opts) {
+    opts_ = std::move(opts);
+  }
 };
 
 }  // namespace validator

validator/validator.h

@@ -228,6 +228,7 @@ class ValidatorManagerInterface : public td::actor::Actor {
       td::Promise<tl_object_ptr<ton_api::engine_validator_validatorSessionsInfo>> promise) = 0;
 
   virtual void add_collator(adnl::AdnlNodeIdShort id, ShardIdFull shard) = 0;
+  virtual void update_options(td::Ref<ValidatorManagerOptions> opts) = 0;
 };
 
 }  // namespace validator