initial commit

validator/db/archiver.cpp

@@ -0,0 +1,147 @@
+/*
+    This file is part of TON Blockchain Library.
+
+    TON Blockchain Library is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation, either version 2 of the License, or
+    (at your option) any later version.
+
+    TON Blockchain Library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with TON Blockchain Library.  If not, see <http://www.gnu.org/licenses/>.
+
+    Copyright 2017-2019 Telegram Systems LLP
+*/
+#include "archiver.hpp"
+#include "rootdb.hpp"
+#include "ton/ton-tl.hpp"
+
+namespace ton {
+
+namespace validator {
+
+BlockArchiver::BlockArchiver(BlockIdExt block_id, td::actor::ActorId<RootDb> root_db,
+                             td::actor::ActorId<FileDb> file_db, td::actor::ActorId<FileDb> archive_db,
+                             td::Promise<td::Unit> promise)
+    : block_id_(block_id), root_db_(root_db), file_db_(file_db), archive_db_(archive_db), promise_(std::move(promise)) {
+}
+
+void BlockArchiver::start_up() {
+  auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<BlockHandle> R) {
+    R.ensure();
+    td::actor::send_closure(SelfId, &BlockArchiver::got_block_handle, R.move_as_ok());
+  });
+  td::actor::send_closure(root_db_, &RootDb::get_block_handle_external, block_id_, false, std::move(P));
+}
+
+void BlockArchiver::got_block_handle(BlockHandle handle) {
+  handle_ = std::move(handle);
+  if (handle_->moved_to_storage()) {
+    finish_query();
+    return;
+  }
+
+  if (!handle_->is_applied() && !handle_->is_archived()) {
+    // no need for this block
+    // probably this block not in final chain
+    // this will eventually delete all associated data
+    written_block_data();
+    return;
+  }
+
+  if (!handle_->inited_proof()) {
+    written_proof();
+    return;
+  }
+
+  auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<td::BufferSlice> R) {
+    R.ensure();
+    td::actor::send_closure(SelfId, &BlockArchiver::got_proof, R.move_as_ok());
+  });
+  td::actor::send_closure(file_db_, &FileDb::load_file, FileDb::RefId{fileref::Proof{block_id_}}, std::move(P));
+}
+
+void BlockArchiver::got_proof(td::BufferSlice data) {
+  auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<FileHash> R) {
+    R.ensure();
+    td::actor::send_closure(SelfId, &BlockArchiver::written_proof);
+  });
+  td::actor::send_closure(archive_db_, &FileDb::store_file, FileDb::RefId{fileref::Proof{block_id_}}, std::move(data),
+                          std::move(P));
+}
+
+void BlockArchiver::written_proof() {
+  if (!handle_->inited_proof_link()) {
+    written_proof_link();
+    return;
+  }
+
+  auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<td::BufferSlice> R) {
+    R.ensure();
+    td::actor::send_closure(SelfId, &BlockArchiver::got_proof_link, R.move_as_ok());
+  });
+  td::actor::send_closure(file_db_, &FileDb::load_file, FileDb::RefId{fileref::ProofLink{block_id_}}, std::move(P));
+}
+
+void BlockArchiver::got_proof_link(td::BufferSlice data) {
+  auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<FileHash> R) {
+    R.ensure();
+    td::actor::send_closure(SelfId, &BlockArchiver::written_proof_link);
+  });
+  td::actor::send_closure(archive_db_, &FileDb::store_file, FileDb::RefId{fileref::ProofLink{block_id_}},
+                          std::move(data), std::move(P));
+}
+
+void BlockArchiver::written_proof_link() {
+  if (!handle_->received()) {
+    written_block_data();
+    return;
+  }
+  auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<td::BufferSlice> R) {
+    R.ensure();
+    td::actor::send_closure(SelfId, &BlockArchiver::got_block_data, R.move_as_ok());
+  });
+  td::actor::send_closure(file_db_, &FileDb::load_file, FileDb::RefId{fileref::Block{block_id_}}, std::move(P));
+}
+
+void BlockArchiver::got_block_data(td::BufferSlice data) {
+  auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<FileHash> R) {
+    R.ensure();
+    td::actor::send_closure(SelfId, &BlockArchiver::written_block_data);
+  });
+  td::actor::send_closure(archive_db_, &FileDb::store_file, FileDb::RefId{fileref::Block{block_id_}}, std::move(data),
+                          std::move(P));
+}
+
+void BlockArchiver::written_block_data() {
+  handle_->set_moved_to_storage();
+
+  auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<td::Unit> R) {
+    R.ensure();
+    td::actor::send_closure(SelfId, &BlockArchiver::finish_query);
+  });
+  td::actor::send_closure(root_db_, &RootDb::store_block_handle, handle_, std::move(P));
+}
+
+void BlockArchiver::finish_query() {
+  if (promise_) {
+    promise_.set_value(td::Unit());
+  }
+  stop();
+}
+
+void BlockArchiver::abort_query(td::Status reason) {
+  if (promise_) {
+    VLOG(VALIDATOR_WARNING) << "failed to archive block " << block_id_ << ": " << reason;
+    promise_.set_error(std::move(reason));
+  }
+  stop();
+}
+
+}  // namespace validator
+
+}  // namespace ton