Ton

full-node-master.cpp
475 строк · 21.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 "td/utils/SharedSlice.h"
20
#include "full-node-master.hpp"
21
#include "full-node-shard-queries.hpp"
22

23
#include "ton/ton-shard.h"
24
#include "ton/ton-tl.hpp"
25

26
#include "adnl/utils.hpp"
27

28
#include "common/delay.h"
29

30
#include "auto/tl/lite_api.h"
31
#include "tl-utils/lite-utils.hpp"
32

33
namespace ton {
34

35
namespace validator {
36

37
namespace fullnode {
38

39
void FullNodeMasterImpl::process_query(adnl::AdnlNodeIdShort src, ton_api::tonNode_getNextBlockDescription &query,
40
                                       td::Promise<td::BufferSlice> promise) {
41
  auto P = td::PromiseCreator::lambda([promise = std::move(promise)](td::Result<BlockHandle> R) mutable {
42
    if (R.is_error()) {
43
      auto x = create_serialize_tl_object<ton_api::tonNode_blockDescriptionEmpty>();
44
      promise.set_value(std::move(x));
45
    } else {
46
      auto B = R.move_as_ok();
47
      if (!B->received() || !B->inited_proof()) {
48
        auto x = create_serialize_tl_object<ton_api::tonNode_blockDescriptionEmpty>();
49
        promise.set_value(std::move(x));
50
      } else {
51
        auto x = create_serialize_tl_object<ton_api::tonNode_blockDescription>(create_tl_block_id(B->id()));
52
        promise.set_value(std::move(x));
53
      }
54
    }
55
  });
56
  td::actor::send_closure(validator_manager_, &ValidatorManagerInterface::get_next_block,
57
                          create_block_id(query.prev_block_), std::move(P));
58
}
59

60
void FullNodeMasterImpl::process_query(adnl::AdnlNodeIdShort src, ton_api::tonNode_prepareBlock &query,
61
                                       td::Promise<td::BufferSlice> promise) {
62
  auto P = td::PromiseCreator::lambda([promise = std::move(promise)](td::Result<BlockHandle> R) mutable {
63
    if (R.is_error()) {
64
      auto x = create_serialize_tl_object<ton_api::tonNode_notFound>();
65
      promise.set_value(std::move(x));
66
    } else {
67
      auto B = R.move_as_ok();
68
      if (!B->received()) {
69
        auto x = create_serialize_tl_object<ton_api::tonNode_notFound>();
70
        promise.set_value(std::move(x));
71
      } else {
72
        auto x = create_serialize_tl_object<ton_api::tonNode_prepared>();
73
        promise.set_value(std::move(x));
74
      }
75
    }
76
  });
77
  td::actor::send_closure(validator_manager_, &ValidatorManagerInterface::get_block_handle,
78
                          create_block_id(query.block_), false, std::move(P));
79
}
80

81
void FullNodeMasterImpl::process_query(adnl::AdnlNodeIdShort src, ton_api::tonNode_downloadBlock &query,
82
                                       td::Promise<td::BufferSlice> promise) {
83
  auto P = td::PromiseCreator::lambda([validator_manager = validator_manager_,
84
                                       promise = std::move(promise)](td::Result<BlockHandle> R) mutable {
85
    if (R.is_error()) {
86
      promise.set_error(td::Status::Error(ErrorCode::protoviolation, "unknown block"));
87
    } else {
88
      auto B = R.move_as_ok();
89
      if (!B->received()) {
90
        promise.set_error(td::Status::Error(ErrorCode::protoviolation, "unknown block"));
91
      } else {
92
        td::actor::send_closure(validator_manager, &ValidatorManagerInterface::get_block_data, B, std::move(promise));
93
      }
94
    }
95
  });
96
  td::actor::send_closure(validator_manager_, &ValidatorManagerInterface::get_block_handle,
97
                          create_block_id(query.block_), false, std::move(P));
98
}
99

100
void FullNodeMasterImpl::process_query(adnl::AdnlNodeIdShort src, ton_api::tonNode_downloadBlockFull &query,
101
                                       td::Promise<td::BufferSlice> promise) {
102
  td::actor::create_actor<BlockFullSender>("sender", ton::create_block_id(query.block_), false, validator_manager_,
103
                                           std::move(promise))
104
      .release();
105
}
106

107
void FullNodeMasterImpl::process_query(adnl::AdnlNodeIdShort src, ton_api::tonNode_downloadNextBlockFull &query,
108
                                       td::Promise<td::BufferSlice> promise) {
109
  td::actor::create_actor<BlockFullSender>("sender", ton::create_block_id(query.prev_block_), true, validator_manager_,
110
                                           std::move(promise))
111
      .release();
112
}
113

114
void FullNodeMasterImpl::process_query(adnl::AdnlNodeIdShort src, ton_api::tonNode_prepareBlockProof &query,
115
                                       td::Promise<td::BufferSlice> promise) {
116
  if (query.block_->seqno_ == 0) {
117
    promise.set_error(td::Status::Error(ErrorCode::protoviolation, "cannot download proof for zero state"));
118
    return;
119
  }
120
  auto P = td::PromiseCreator::lambda([allow_partial = query.allow_partial_, promise = std::move(promise),
121
                                       validator_manager = validator_manager_](td::Result<BlockHandle> R) mutable {
122
    if (R.is_error()) {
123
      auto x = create_serialize_tl_object<ton_api::tonNode_preparedProofEmpty>();
124
      promise.set_value(std::move(x));
125
      return;
126
    } else {
127
      auto handle = R.move_as_ok();
128
      if (!handle || (!handle->inited_proof() && (!allow_partial || !handle->inited_proof_link()))) {
129
        auto x = create_serialize_tl_object<ton_api::tonNode_preparedProofEmpty>();
130
        promise.set_value(std::move(x));
131
        return;
132
      }
133
      if (handle->inited_proof() && handle->id().is_masterchain()) {
134
        auto x = create_serialize_tl_object<ton_api::tonNode_preparedProof>();
135
        promise.set_value(std::move(x));
136
      } else {
137
        auto x = create_serialize_tl_object<ton_api::tonNode_preparedProofLink>();
138
        promise.set_value(std::move(x));
139
      }
140
    }
141
  });
142

143
  td::actor::send_closure(validator_manager_, &ValidatorManagerInterface::get_block_handle,
144
                          create_block_id(query.block_), false, std::move(P));
145
}
146

147
void FullNodeMasterImpl::process_query(adnl::AdnlNodeIdShort src, ton_api::tonNode_prepareKeyBlockProof &query,
148
                                       td::Promise<td::BufferSlice> promise) {
149
  if (query.block_->seqno_ == 0) {
150
    promise.set_error(td::Status::Error(ErrorCode::protoviolation, "cannot download proof for zero state"));
151
    return;
152
  }
153
  auto P = td::PromiseCreator::lambda(
154
      [allow_partial = query.allow_partial_, promise = std::move(promise)](td::Result<td::BufferSlice> R) mutable {
155
        if (R.is_error()) {
156
          auto x = create_serialize_tl_object<ton_api::tonNode_preparedProofEmpty>();
157
          promise.set_value(std::move(x));
158
        } else if (allow_partial) {
159
          auto x = create_serialize_tl_object<ton_api::tonNode_preparedProofLink>();
160
          promise.set_value(std::move(x));
161
        } else {
162
          auto x = create_serialize_tl_object<ton_api::tonNode_preparedProof>();
163
          promise.set_value(std::move(x));
164
        }
165
      });
166

167
  if (query.allow_partial_) {
168
    td::actor::send_closure(validator_manager_, &ValidatorManagerInterface::get_key_block_proof_link,
169
                            create_block_id(query.block_), std::move(P));
170
  } else {
171
    td::actor::send_closure(validator_manager_, &ValidatorManagerInterface::get_key_block_proof,
172
                            create_block_id(query.block_), std::move(P));
173
  }
174
}
175

176
void FullNodeMasterImpl::process_query(adnl::AdnlNodeIdShort src, ton_api::tonNode_downloadBlockProof &query,
177
                                       td::Promise<td::BufferSlice> promise) {
178
  auto P = td::PromiseCreator::lambda(
179
      [promise = std::move(promise), validator_manager = validator_manager_](td::Result<BlockHandle> R) mutable {
180
        if (R.is_error()) {
181
          promise.set_error(td::Status::Error(ErrorCode::protoviolation, "unknown block proof"));
182
          return;
183
        } else {
184
          auto handle = R.move_as_ok();
185
          if (!handle || !handle->inited_proof()) {
186
            promise.set_error(td::Status::Error(ErrorCode::protoviolation, "unknown block proof"));
187
            return;
188
          }
189

190
          td::actor::send_closure(validator_manager, &ValidatorManagerInterface::get_block_proof, handle,
191
                                  std::move(promise));
192
        }
193
      });
194

195
  td::actor::send_closure(validator_manager_, &ValidatorManagerInterface::get_block_handle,
196
                          create_block_id(query.block_), false, std::move(P));
197
}
198

199
void FullNodeMasterImpl::process_query(adnl::AdnlNodeIdShort src, ton_api::tonNode_downloadBlockProofLink &query,
200
                                       td::Promise<td::BufferSlice> promise) {
201
  auto P = td::PromiseCreator::lambda(
202
      [promise = std::move(promise), validator_manager = validator_manager_](td::Result<BlockHandle> R) mutable {
203
        if (R.is_error()) {
204
          promise.set_error(td::Status::Error(ErrorCode::protoviolation, "unknown block proof"));
205
          return;
206
        } else {
207
          auto handle = R.move_as_ok();
208
          if (!handle || !handle->inited_proof_link()) {
209
            promise.set_error(td::Status::Error(ErrorCode::protoviolation, "unknown block proof"));
210
            return;
211
          }
212

213
          td::actor::send_closure(validator_manager, &ValidatorManagerInterface::get_block_proof_link, handle,
214
                                  std::move(promise));
215
        }
216
      });
217

218
  td::actor::send_closure(validator_manager_, &ValidatorManagerInterface::get_block_handle,
219
                          create_block_id(query.block_), false, std::move(P));
220
}
221

222
void FullNodeMasterImpl::process_query(adnl::AdnlNodeIdShort src, ton_api::tonNode_downloadKeyBlockProof &query,
223
                                       td::Promise<td::BufferSlice> promise) {
224
  if (query.block_->seqno_ == 0) {
225
    promise.set_error(td::Status::Error(ErrorCode::protoviolation, "cannot download proof for zero state"));
226
    return;
227
  }
228
  auto P = td::PromiseCreator::lambda([promise = std::move(promise)](td::Result<td::BufferSlice> R) mutable {
229
    if (R.is_error()) {
230
      promise.set_error(td::Status::Error(ErrorCode::protoviolation, "unknown block proof"));
231
    } else {
232
      promise.set_value(R.move_as_ok());
233
    }
234
  });
235

236
  td::actor::send_closure(validator_manager_, &ValidatorManagerInterface::get_key_block_proof,
237
                          create_block_id(query.block_), std::move(P));
238
}
239

240
void FullNodeMasterImpl::process_query(adnl::AdnlNodeIdShort src, ton_api::tonNode_downloadKeyBlockProofLink &query,
241
                                       td::Promise<td::BufferSlice> promise) {
242
  if (query.block_->seqno_ == 0) {
243
    promise.set_error(td::Status::Error(ErrorCode::protoviolation, "cannot download proof for zero state"));
244
    return;
245
  }
246
  auto P = td::PromiseCreator::lambda([promise = std::move(promise)](td::Result<td::BufferSlice> R) mutable {
247
    if (R.is_error()) {
248
      promise.set_error(td::Status::Error(ErrorCode::protoviolation, "unknown block proof"));
249
    } else {
250
      promise.set_value(R.move_as_ok());
251
    }
252
  });
253

254
  td::actor::send_closure(validator_manager_, &ValidatorManagerInterface::get_key_block_proof_link,
255
                          create_block_id(query.block_), std::move(P));
256
}
257

258
void FullNodeMasterImpl::process_query(adnl::AdnlNodeIdShort src, ton_api::tonNode_prepareZeroState &query,
259
                                       td::Promise<td::BufferSlice> promise) {
260
  auto P =
261
      td::PromiseCreator::lambda([SelfId = actor_id(this), promise = std::move(promise)](td::Result<bool> R) mutable {
262
        if (R.is_error() || !R.move_as_ok()) {
263
          auto x = create_serialize_tl_object<ton_api::tonNode_notFoundState>();
264
          promise.set_value(std::move(x));
265
          return;
266
        }
267

268
        auto x = create_serialize_tl_object<ton_api::tonNode_preparedState>();
269
        promise.set_value(std::move(x));
270
      });
271
  auto block_id = create_block_id(query.block_);
272
  td::actor::send_closure(validator_manager_, &ValidatorManagerInterface::check_zero_state_exists, block_id,
273
                          std::move(P));
274
}
275

276
void FullNodeMasterImpl::process_query(adnl::AdnlNodeIdShort src, ton_api::tonNode_preparePersistentState &query,
277
                                       td::Promise<td::BufferSlice> promise) {
278
  auto P =
279
      td::PromiseCreator::lambda([SelfId = actor_id(this), promise = std::move(promise)](td::Result<bool> R) mutable {
280
        if (R.is_error() || !R.move_as_ok()) {
281
          auto x = create_serialize_tl_object<ton_api::tonNode_notFoundState>();
282
          promise.set_value(std::move(x));
283
          return;
284
        }
285

286
        auto x = create_serialize_tl_object<ton_api::tonNode_preparedState>();
287
        promise.set_value(std::move(x));
288
      });
289
  auto block_id = create_block_id(query.block_);
290
  auto masterchain_block_id = create_block_id(query.masterchain_block_);
291
  td::actor::send_closure(validator_manager_, &ValidatorManagerInterface::check_persistent_state_exists, block_id,
292
                          masterchain_block_id, std::move(P));
293
}
294

295
void FullNodeMasterImpl::process_query(adnl::AdnlNodeIdShort src, ton_api::tonNode_getNextKeyBlockIds &query,
296
                                       td::Promise<td::BufferSlice> promise) {
297
  auto cnt = static_cast<td::uint32>(query.max_size_);
298
  if (cnt > 8) {
299
    cnt = 8;
300
  }
301
  auto P =
302
      td::PromiseCreator::lambda([promise = std::move(promise), cnt](td::Result<std::vector<BlockIdExt>> R) mutable {
303
        if (R.is_error()) {
304
          LOG(WARNING) << "getnextkey: " << R.move_as_error();
305
          auto x = create_serialize_tl_object<ton_api::tonNode_keyBlocks>(
306
              std::vector<tl_object_ptr<ton_api::tonNode_blockIdExt>>{}, false, true);
307
          promise.set_value(std::move(x));
308
          return;
309
        }
310
        auto res = R.move_as_ok();
311
        std::vector<tl_object_ptr<ton_api::tonNode_blockIdExt>> v;
312
        for (auto &b : res) {
313
          v.emplace_back(create_tl_block_id(b));
314
        }
315
        auto x = create_serialize_tl_object<ton_api::tonNode_keyBlocks>(std::move(v), res.size() < cnt, false);
316
        promise.set_value(std::move(x));
317
      });
318
  auto block_id = create_block_id(query.block_);
319
  td::actor::send_closure(validator_manager_, &ValidatorManagerInterface::get_next_key_blocks, block_id, cnt,
320
                          std::move(P));
321
}
322

323
void FullNodeMasterImpl::process_query(adnl::AdnlNodeIdShort src, ton_api::tonNode_downloadZeroState &query,
324
                                       td::Promise<td::BufferSlice> promise) {
325
  auto P = td::PromiseCreator::lambda(
326
      [SelfId = actor_id(this), promise = std::move(promise)](td::Result<td::BufferSlice> R) mutable {
327
        if (R.is_error()) {
328
          promise.set_error(R.move_as_error_prefix("failed to get state from db: "));
329
          return;
330
        }
331

332
        promise.set_value(R.move_as_ok());
333
      });
334
  auto block_id = create_block_id(query.block_);
335
  td::actor::send_closure(validator_manager_, &ValidatorManagerInterface::get_zero_state, block_id, std::move(P));
336
}
337

338
void FullNodeMasterImpl::process_query(adnl::AdnlNodeIdShort src, ton_api::tonNode_downloadPersistentState &query,
339
                                       td::Promise<td::BufferSlice> promise) {
340
  auto P = td::PromiseCreator::lambda(
341
      [SelfId = actor_id(this), promise = std::move(promise)](td::Result<td::BufferSlice> R) mutable {
342
        if (R.is_error()) {
343
          promise.set_error(R.move_as_error_prefix("failed to get state from db: "));
344
          return;
345
        }
346

347
        promise.set_value(R.move_as_ok());
348
      });
349
  auto block_id = create_block_id(query.block_);
350
  auto masterchain_block_id = create_block_id(query.masterchain_block_);
351
  td::actor::send_closure(validator_manager_, &ValidatorManagerInterface::get_persistent_state, block_id,
352
                          masterchain_block_id, std::move(P));
353
}
354

355
void FullNodeMasterImpl::process_query(adnl::AdnlNodeIdShort src, ton_api::tonNode_downloadPersistentStateSlice &query,
356
                                       td::Promise<td::BufferSlice> promise) {
357
  auto P = td::PromiseCreator::lambda(
358
      [SelfId = actor_id(this), promise = std::move(promise)](td::Result<td::BufferSlice> R) mutable {
359
        if (R.is_error()) {
360
          promise.set_error(R.move_as_error_prefix("failed to get state from db: "));
361
          return;
362
        }
363

364
        promise.set_value(R.move_as_ok());
365
      });
366
  auto block_id = create_block_id(query.block_);
367
  auto masterchain_block_id = create_block_id(query.masterchain_block_);
368
  td::actor::send_closure(validator_manager_, &ValidatorManagerInterface::get_persistent_state_slice, block_id,
369
                          masterchain_block_id, query.offset_, query.max_size_, std::move(P));
370
}
371

372
void FullNodeMasterImpl::process_query(adnl::AdnlNodeIdShort src, ton_api::tonNode_getCapabilities &query,
373
                                       td::Promise<td::BufferSlice> promise) {
374
  promise.set_value(create_serialize_tl_object<ton_api::tonNode_capabilities>(proto_version(), proto_capabilities()));
375
}
376

377
void FullNodeMasterImpl::process_query(adnl::AdnlNodeIdShort src, ton_api::tonNode_getArchiveInfo &query,
378
                                       td::Promise<td::BufferSlice> promise) {
379
  auto P = td::PromiseCreator::lambda(
380
      [SelfId = actor_id(this), promise = std::move(promise)](td::Result<td::uint64> R) mutable {
381
        if (R.is_error()) {
382
          promise.set_value(create_serialize_tl_object<ton_api::tonNode_archiveNotFound>());
383
        } else {
384
          promise.set_value(create_serialize_tl_object<ton_api::tonNode_archiveInfo>(R.move_as_ok()));
385
        }
386
      });
387
  td::actor::send_closure(validator_manager_, &ValidatorManagerInterface::get_archive_id, query.masterchain_seqno_,
388
                          std::move(P));
389
}
390

391
void FullNodeMasterImpl::process_query(adnl::AdnlNodeIdShort src, ton_api::tonNode_getArchiveSlice &query,
392
                                       td::Promise<td::BufferSlice> promise) {
393
  td::actor::send_closure(validator_manager_, &ValidatorManagerInterface::get_archive_slice, query.archive_id_,
394
                          query.offset_, query.max_size_, std::move(promise));
395
}
396

397
void FullNodeMasterImpl::process_query(adnl::AdnlNodeIdShort src, ton_api::tonNode_slave_sendExtMessage &query,
398
                                       td::Promise<td::BufferSlice> promise) {
399
  td::actor::send_closure(
400
      validator_manager_, &ValidatorManagerInterface::run_ext_query,
401
      create_serialize_tl_object<lite_api::liteServer_query>(
402
          create_serialize_tl_object<lite_api::liteServer_sendMessage>(std::move(query.message_->data_))),
403
      [&](td::Result<td::BufferSlice>) {});
404
  promise.set_value(create_serialize_tl_object<ton_api::tonNode_success>());
405
}
406

407
void FullNodeMasterImpl::receive_query(adnl::AdnlNodeIdShort src, td::BufferSlice query,
408
                                       td::Promise<td::BufferSlice> promise) {
409
  auto BX = fetch_tl_prefix<ton_api::tonNode_query>(query, true);
410
  if (BX.is_error()) {
411
    promise.set_error(td::Status::Error(ErrorCode::protoviolation, "cannot parse tonnode query"));
412
    return;
413
  }
414
  auto B = fetch_tl_object<ton_api::Function>(std::move(query), true);
415
  if (B.is_error()) {
416
    promise.set_error(td::Status::Error(ErrorCode::protoviolation, "cannot parse tonnode query"));
417
    return;
418
  }
419
  ton_api::downcast_call(*B.move_as_ok().get(), [&](auto &obj) { this->process_query(src, obj, std::move(promise)); });
420
}
421

422
void FullNodeMasterImpl::start_up() {
423
  class Cb : public adnl::Adnl::Callback {
424
   public:
425
    Cb(td::actor::ActorId<FullNodeMasterImpl> id) : id_(std::move(id)) {
426
    }
427
    void receive_message(adnl::AdnlNodeIdShort src, adnl::AdnlNodeIdShort dst, td::BufferSlice data) override {
428
    }
429
    void receive_query(adnl::AdnlNodeIdShort src, adnl::AdnlNodeIdShort dst, td::BufferSlice data,
430
                       td::Promise<td::BufferSlice> promise) override {
431
      td::actor::send_closure(id_, &FullNodeMasterImpl::receive_query, src, std::move(data), std::move(promise));
432
    }
433

434
   private:
435
    td::actor::ActorId<FullNodeMasterImpl> id_;
436
  };
437

438
  td::actor::send_closure(adnl_, &adnl::Adnl::subscribe, adnl_id_,
439
                          adnl::Adnl::int_to_bytestring(ton_api::tonNode_query::ID),
440
                          std::make_unique<Cb>(actor_id(this)));
441

442
  auto P =
443
      td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<td::actor::ActorOwn<adnl::AdnlExtServer>> R) {
444
        R.ensure();
445
        R.move_as_ok().release();
446
      });
447
  td::actor::send_closure(adnl_, &adnl::Adnl::create_ext_server, std::vector<adnl::AdnlNodeIdShort>{adnl_id_},
448
                          std::vector<td::uint16>{port_}, std::move(P));
449
}
450

451
FullNodeMasterImpl::FullNodeMasterImpl(adnl::AdnlNodeIdShort adnl_id, td::uint16 port, FileHash zero_state_file_hash,
452
                                       td::actor::ActorId<keyring::Keyring> keyring,
453
                                       td::actor::ActorId<adnl::Adnl> adnl,
454
                                       td::actor::ActorId<ValidatorManagerInterface> validator_manager)
455
    : adnl_id_(adnl_id)
456
    , port_(port)
457
    , zero_state_file_hash_(zero_state_file_hash)
458
    , keyring_(keyring)
459
    , adnl_(adnl)
460
    , validator_manager_(validator_manager) {
461
}
462

463
td::actor::ActorOwn<FullNodeMaster> FullNodeMaster::create(
464
    adnl::AdnlNodeIdShort adnl_id, td::uint16 port, FileHash zero_state_file_hash,
465
    td::actor::ActorId<keyring::Keyring> keyring, td::actor::ActorId<adnl::Adnl> adnl,
466
    td::actor::ActorId<ValidatorManagerInterface> validator_manager) {
467
  return td::actor::create_actor<FullNodeMasterImpl>("tonnode", adnl_id, port, zero_state_file_hash, keyring, adnl,
468
                                                     validator_manager);
469
}
470

471
}  // namespace fullnode
472

473
}  // namespace validator
474

475
}  // namespace ton
476
Ton

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