/
Toncoin
/
Ton
GigaCode
beta
ОбзорЦентр заботыВойти

Ton

Форк
0
Ветки: 7Коммиты: 665Теги: 31
Ton
/validator
/net
/
download-block.cpp 
399 строк · 16.7 Кб
1
/*
2
    This file is part of TON Blockchain Library.
3


4
    TON Blockchain Library is free software: you can redistribute it and/or modify
5
    it under the terms of the GNU Lesser General Public License as published by
6
    the Free Software Foundation, either version 2 of the License, or
7
    (at your option) any later version.
8


9
    TON Blockchain Library is distributed in the hope that it will be useful,
10
    but WITHOUT ANY WARRANTY; without even the implied warranty of
11
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12
    GNU Lesser General Public License for more details.
13


14
    You should have received a copy of the GNU Lesser General Public License
15
    along with TON Blockchain Library.  If not, see <http://www.gnu.org/licenses/>.
16


17
    Copyright 2017-2020 Telegram Systems LLP
18
*/
19
#include "download-block.hpp"
20
#include "ton/ton-tl.hpp"
21
#include "adnl/utils.hpp"
22
#include "ton/ton-shard.h"
23
#include "td/utils/overloaded.h"
24
#include "ton/ton-io.hpp"
25
#include "validator/full-node.h"
26


27
namespace ton {
28


29
namespace validator {
30


31
namespace fullnode {
32


33
DownloadBlock::DownloadBlock(BlockIdExt block_id, adnl::AdnlNodeIdShort local_id, overlay::OverlayIdShort overlay_id,
34
                             adnl::AdnlNodeIdShort download_from, td::uint32 priority, td::Timestamp timeout,
35
                             td::actor::ActorId<ValidatorManagerInterface> validator_manager,
36
                             td::actor::ActorId<rldp::Rldp> rldp, td::actor::ActorId<overlay::Overlays> overlays,
37
                             td::actor::ActorId<adnl::Adnl> adnl, td::actor::ActorId<adnl::AdnlExtClient> client,
38
                             td::Promise<ReceivedBlock> promise)
39
    : block_id_(block_id)
40
    , local_id_(local_id)
41
    , overlay_id_(overlay_id)
42
    , download_from_(download_from)
43
    , priority_(priority)
44
    , timeout_(timeout)
45
    , validator_manager_(validator_manager)
46
    , rldp_(rldp)
47
    , overlays_(overlays)
48
    , adnl_(adnl)
49
    , client_(client)
50
    , promise_(std::move(promise))
51
    , block_{block_id, td::BufferSlice()}
52
    , allow_partial_proof_{!block_id_.is_masterchain()} {
53
}
54


55
DownloadBlock::DownloadBlock(BlockIdExt block_id, adnl::AdnlNodeIdShort local_id, overlay::OverlayIdShort overlay_id,
56
                             BlockHandle prev, adnl::AdnlNodeIdShort download_from, td::uint32 priority,
57
                             td::Timestamp timeout, td::actor::ActorId<ValidatorManagerInterface> validator_manager,
58
                             td::actor::ActorId<rldp::Rldp> rldp, td::actor::ActorId<overlay::Overlays> overlays,
59
                             td::actor::ActorId<adnl::Adnl> adnl, td::actor::ActorId<adnl::AdnlExtClient> client,
60
                             td::Promise<ReceivedBlock> promise)
61
    : block_id_(block_id)
62
    , local_id_(local_id)
63
    , overlay_id_(overlay_id)
64
    , prev_(prev)
65
    , download_from_(download_from)
66
    , priority_(priority)
67
    , timeout_(timeout)
68
    , validator_manager_(validator_manager)
69
    , rldp_(rldp)
70
    , overlays_(overlays)
71
    , adnl_(adnl)
72
    , client_(client)
73
    , promise_(std::move(promise))
74
    , block_{block_id, td::BufferSlice()} {
75
}
76


77
void DownloadBlock::abort_query(td::Status reason) {
78
  if (promise_) {
79
    if (reason.code() == ErrorCode::notready || reason.code() == ErrorCode::timeout) {
80
      VLOG(FULL_NODE_DEBUG) << "failed to download block " << block_id_ << "from " << download_from_ << ": " << reason;
81
    } else {
82
      VLOG(FULL_NODE_NOTICE) << "failed to download block " << block_id_ << " from " << download_from_ << ": "
83
                             << reason;
84
    }
85
    promise_.set_error(std::move(reason));
86
  }
87
  stop();
88
}
89


90
void DownloadBlock::alarm() {
91
  abort_query(td::Status::Error(ErrorCode::timeout, "timeout"));
92
}
93


94
void DownloadBlock::finish_query() {
95
  if (promise_) {
96
    promise_.set_value(std::move(block_));
97
  }
98
  stop();
99
}
100


101
void DownloadBlock::start_up() {
102
  alarm_timestamp() = timeout_;
103


104
  auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<BlockHandle> R) {
105
    if (R.is_error()) {
106
      auto S = R.move_as_error();
107
      if (S.code() == ErrorCode::notready) {
108
        td::actor::send_closure(SelfId, &DownloadBlock::got_block_handle, nullptr);
109
      } else {
110
        td::actor::send_closure(SelfId, &DownloadBlock::abort_query, std::move(S));
111
      }
112
    } else {
113
      td::actor::send_closure(SelfId, &DownloadBlock::got_block_handle, R.move_as_ok());
114
    }
115
  });
116


117
  td::actor::send_closure(validator_manager_, &ValidatorManagerInterface::get_block_handle, block_id_, false,
118
                          std::move(P));
119
}
120


121
void DownloadBlock::got_block_handle(BlockHandle handle) {
122
  handle_ = std::move(handle);
123


124
  if (handle_ && (handle_->inited_proof() || (handle_->inited_proof_link() && allow_partial_proof_) || skip_proof_) &&
125
      handle_->received()) {
126
    short_ = true;
127
    got_download_token(nullptr);
128
    return;
129
  }
130


131
  auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<std::unique_ptr<DownloadToken>> R) {
132
    if (R.is_error()) {
133
      td::actor::send_closure(SelfId, &DownloadBlock::abort_query,
134
                              R.move_as_error_prefix("failed to get download token: "));
135
    } else {
136
      td::actor::send_closure(SelfId, &DownloadBlock::got_download_token, R.move_as_ok());
137
    }
138
  });
139
  td::actor::send_closure(validator_manager_, &ValidatorManagerInterface::get_download_token, 1, priority_, timeout_,
140
                          std::move(P));
141
}
142


143
void DownloadBlock::got_download_token(std::unique_ptr<DownloadToken> token) {
144
  token_ = std::move(token);
145


146
  if (download_from_.is_zero() && !short_ && client_.empty()) {
147
    auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<std::vector<adnl::AdnlNodeIdShort>> R) {
148
      if (R.is_error()) {
149
        td::actor::send_closure(SelfId, &DownloadBlock::abort_query, R.move_as_error());
150
      } else {
151
        auto vec = R.move_as_ok();
152
        if (vec.size() == 0) {
153
          td::actor::send_closure(SelfId, &DownloadBlock::abort_query,
154
                                  td::Status::Error(ErrorCode::notready, "no nodes"));
155
        } else {
156
          td::actor::send_closure(SelfId, &DownloadBlock::got_node_to_download, vec[0]);
157
        }
158
      }
159
    });
160


161
    td::actor::send_closure(overlays_, &overlay::Overlays::get_overlay_random_peers, local_id_, overlay_id_, 1,
162
                            std::move(P));
163
  } else {
164
    got_node_to_download(download_from_);
165
  }
166
}
167


168
void DownloadBlock::got_node_to_download(adnl::AdnlNodeIdShort node) {
169
  download_from_ = node;
170
  if (skip_proof_ || (handle_ && (handle_->inited_proof() || (handle_->inited_proof_link() && allow_partial_proof_)))) {
171
    checked_block_proof();
172
    return;
173
  }
174


175
  VLOG(FULL_NODE_DEBUG) << "downloading proof for " << block_id_;
176


177
  CHECK(!short_);
178
  auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<td::BufferSlice> R) mutable {
179
    if (R.is_error()) {
180
      td::actor::send_closure(SelfId, &DownloadBlock::abort_query, R.move_as_error());
181
    } else {
182
      td::actor::send_closure(SelfId, &DownloadBlock::got_block_proof_description, R.move_as_ok());
183
    }
184
  });
185


186
  auto q = create_serialize_tl_object<ton_api::tonNode_prepareBlockProof>(create_tl_block_id(block_id_),
187
                                                                          allow_partial_proof_);
188
  if (client_.empty()) {
189
    td::actor::send_closure(overlays_, &overlay::Overlays::send_query, download_from_, local_id_, overlay_id_,
190
                            "get_prepare", std::move(P), td::Timestamp::in(1.0), std::move(q));
191
  } else {
192
    td::actor::send_closure(client_, &adnl::AdnlExtClient::send_query, "get_prepare",
193
                            create_serialize_tl_object_suffix<ton_api::tonNode_query>(std::move(q)),
194
                            td::Timestamp::in(1.0), std::move(P));
195
  }
196
}
197


198
void DownloadBlock::got_block_proof_description(td::BufferSlice proof_description) {
199
  VLOG(FULL_NODE_DEBUG) << "downloaded proof description for " << block_id_;
200


201
  auto F = fetch_tl_object<ton_api::tonNode_PreparedProof>(std::move(proof_description), true);
202
  if (F.is_error()) {
203
    abort_query(F.move_as_error());
204
    return;
205
  }
206


207
  auto self = this;
208
  ton_api::downcast_call(
209
      *F.move_as_ok().get(),
210
      td::overloaded(
211
          [&](ton_api::tonNode_preparedProof &obj) {
212
            auto P = td::PromiseCreator::lambda([SelfId = actor_id(self)](td::Result<td::BufferSlice> R) {
213
              if (R.is_error()) {
214
                td::actor::send_closure(SelfId, &DownloadBlock::abort_query, R.move_as_error());
215
              } else {
216
                td::actor::send_closure(SelfId, &DownloadBlock::got_block_proof, R.move_as_ok());
217
              }
218
            });
219


220
            auto q = create_serialize_tl_object<ton_api::tonNode_downloadBlockProof>(create_tl_block_id(block_id_));
221
            if (client_.empty()) {
222
              td::actor::send_closure(overlays_, &overlay::Overlays::send_query_via, download_from_, local_id_,
223
                                      overlay_id_, "get_proof", std::move(P), td::Timestamp::in(3.0), std::move(q),
224
                                      FullNode::max_proof_size(), rldp_);
225
            } else {
226
              td::actor::send_closure(client_, &adnl::AdnlExtClient::send_query, "get_proof",
227
                                      create_serialize_tl_object_suffix<ton_api::tonNode_query>(std::move(q)),
228
                                      td::Timestamp::in(3.0), std::move(P));
229
            }
230
          },
231
          [&](ton_api::tonNode_preparedProofLink &obj) {
232
            if (!allow_partial_proof_) {
233
              abort_query(td::Status::Error(ErrorCode::protoviolation, "received partial proof, though did not allow"));
234
              return;
235
            }
236
            auto P = td::PromiseCreator::lambda([SelfId = actor_id(self)](td::Result<td::BufferSlice> R) {
237
              if (R.is_error()) {
238
                td::actor::send_closure(SelfId, &DownloadBlock::abort_query, R.move_as_error());
239
              } else {
240
                td::actor::send_closure(SelfId, &DownloadBlock::got_block_partial_proof, R.move_as_ok());
241
              }
242
            });
243


244
            auto q = create_serialize_tl_object<ton_api::tonNode_downloadBlockProofLink>(create_tl_block_id(block_id_));
245
            if (client_.empty()) {
246
              td::actor::send_closure(overlays_, &overlay::Overlays::send_query_via, download_from_, local_id_,
247
                                      overlay_id_, "get_proof_link", std::move(P), td::Timestamp::in(3.0), std::move(q),
248
                                      FullNode::max_proof_size(), rldp_);
249
            } else {
250
              td::actor::send_closure(client_, &adnl::AdnlExtClient::send_query, "get_proof_link",
251
                                      create_serialize_tl_object_suffix<ton_api::tonNode_query>(std::move(q)),
252
                                      td::Timestamp::in(3.0), std::move(P));
253
            }
254
          },
255
          [&](ton_api::tonNode_preparedProofEmpty &obj) {
256
            abort_query(td::Status::Error(ErrorCode::notready, "proof not found"));
257
          }));
258
}
259


260
void DownloadBlock::got_block_proof(td::BufferSlice proof) {
261
  VLOG(FULL_NODE_DEBUG) << "downloaded proof for " << block_id_;
262


263
  auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<td::Unit> R) {
264
    if (R.is_error()) {
265
      td::actor::send_closure(SelfId, &DownloadBlock::abort_query, R.move_as_error());
266
    } else {
267
      td::actor::send_closure(SelfId, &DownloadBlock::checked_block_proof);
268
    }
269
  });
270


271
  if (!prev_) {
272
    td::actor::send_closure(validator_manager_, &ValidatorManagerInterface::validate_block_proof, block_id_,
273
                            std::move(proof), std::move(P));
274
  } else {
275
    td::actor::send_closure(validator_manager_, &ValidatorManagerInterface::validate_block_is_next_proof, prev_->id(),
276
                            block_id_, std::move(proof), std::move(P));
277
  }
278
}
279


280
void DownloadBlock::got_block_partial_proof(td::BufferSlice proof) {
281
  CHECK(allow_partial_proof_);
282
  CHECK(!prev_);
283


284
  auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<td::Unit> R) {
285
    if (R.is_error()) {
286
      td::actor::send_closure(SelfId, &DownloadBlock::abort_query, R.move_as_error());
287
    } else {
288
      td::actor::send_closure(SelfId, &DownloadBlock::checked_block_proof);
289
    }
290
  });
291


292
  td::actor::send_closure(validator_manager_, &ValidatorManagerInterface::validate_block_proof_link, block_id_,
293
                          std::move(proof), std::move(P));
294
}
295


296
void DownloadBlock::checked_block_proof() {
297
  VLOG(FULL_NODE_DEBUG) << "checked proof for " << block_id_;
298


299
  if (!handle_) {
300
    CHECK(!short_);
301
    auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<BlockHandle> R) {
302
      if (R.is_error()) {
303
        td::actor::send_closure(SelfId, &DownloadBlock::abort_query, R.move_as_error());
304
      } else {
305
        td::actor::send_closure(SelfId, &DownloadBlock::got_block_handle_2, R.move_as_ok());
306
      }
307
    });
308
    td::actor::send_closure(validator_manager_, &ValidatorManagerInterface::get_block_handle, block_id_, true,
309
                            std::move(P));
310
  } else {
311
    got_block_handle_2(handle_);
312
  }
313
}
314


315
void DownloadBlock::got_block_handle_2(BlockHandle handle) {
316
  handle_ = std::move(handle);
317
  LOG_CHECK(skip_proof_ || handle_->inited_proof() || (allow_partial_proof_ && handle_->inited_proof_link()))
318
      << handle_->id() << " allowpartial=" << allow_partial_proof_;
319


320
  if (handle_->received()) {
321
    auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<td::BufferSlice> R) mutable {
322
      if (R.is_error()) {
323
        td::actor::send_closure(SelfId, &DownloadBlock::abort_query, R.move_as_error());
324
      } else {
325
        td::actor::send_closure(SelfId, &DownloadBlock::got_block_data, R.move_as_ok());
326
      }
327
    });
328


329
    td::actor::send_closure(validator_manager_, &ValidatorManagerInterface::get_block_data, handle_, std::move(P));
330
  } else {
331
    CHECK(!short_);
332
    auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<td::BufferSlice> R) mutable {
333
      if (R.is_error()) {
334
        td::actor::send_closure(SelfId, &DownloadBlock::abort_query, R.move_as_error());
335
      } else {
336
        td::actor::send_closure(SelfId, &DownloadBlock::got_block_data_description, R.move_as_ok());
337
      }
338
    });
339


340
    auto q = create_serialize_tl_object<ton_api::tonNode_prepareBlock>(create_tl_block_id(block_id_));
341
    if (client_.empty()) {
342
      td::actor::send_closure(overlays_, &overlay::Overlays::send_query, download_from_, local_id_, overlay_id_,
343
                              "get_prepare_block", std::move(P), td::Timestamp::in(1.0), std::move(q));
344
    } else {
345
      td::actor::send_closure(client_, &adnl::AdnlExtClient::send_query, "get_prepare_block",
346
                              create_serialize_tl_object_suffix<ton_api::tonNode_query>(std::move(q)),
347
                              td::Timestamp::in(1.0), std::move(P));
348
    }
349
  }
350
}
351


352
void DownloadBlock::got_block_data_description(td::BufferSlice data_description) {
353
  VLOG(FULL_NODE_DEBUG) << "downloaded data description for " << block_id_;
354
  auto F = fetch_tl_object<ton_api::tonNode_Prepared>(std::move(data_description), true);
355
  if (F.is_error()) {
356
    abort_query(F.move_as_error());
357
    return;
358
  }
359
  auto f = F.move_as_ok();
360


361
  ton_api::downcast_call(
362
      *f.get(),
363
      td::overloaded(
364
          [&, self = this](ton_api::tonNode_prepared &val) {
365
            auto P = td::PromiseCreator::lambda([SelfId = actor_id(self)](td::Result<td::BufferSlice> R) {
366
              if (R.is_error()) {
367
                td::actor::send_closure(SelfId, &DownloadBlock::abort_query, R.move_as_error());
368
              } else {
369
                td::actor::send_closure(SelfId, &DownloadBlock::got_block_data, R.move_as_ok());
370
              }
371
            });
372


373
            auto q = create_serialize_tl_object<ton_api::tonNode_downloadBlock>(create_tl_block_id(block_id_));
374
            if (client_.empty()) {
375
              td::actor::send_closure(overlays_, &overlay::Overlays::send_query_via, download_from_, local_id_,
376
                                      overlay_id_, "get_block", std::move(P), td::Timestamp::in(15.0), std::move(q),
377
                                      FullNode::max_block_size(), rldp_);
378
            } else {
379
              td::actor::send_closure(client_, &adnl::AdnlExtClient::send_query, "get_block",
380
                                      create_serialize_tl_object_suffix<ton_api::tonNode_query>(std::move(q)),
381
                                      td::Timestamp::in(15.0), std::move(P));
382
            }
383
          },
384
          [&](ton_api::tonNode_notFound &val) {
385
            abort_query(td::Status::Error(ErrorCode::notready, "dst node does not have block"));
386
          }));
387
}
388


389
void DownloadBlock::got_block_data(td::BufferSlice data) {
390
  VLOG(FULL_NODE_DEBUG) << "downloaded data for " << block_id_;
391
  block_.data = std::move(data);
392
  finish_query();
393
}
394


395
}  // namespace fullnode
396


397
}  // namespace validator
398


399
}  // namespace ton
400

Использование cookies

Мы используем файлы cookie в соответствии с Политикой конфиденциальности и Политикой использования cookies.

Нажимая кнопку «Принимаю», Вы даете АО «СберТех» согласие на обработку Ваших персональных данных в целях совершенствования нашего веб-сайта и Сервиса GitVerse, а также повышения удобства их использования.

Запретить использование cookies Вы можете самостоятельно в настройках Вашего браузера.