Ton

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 "get-next-key-blocks.hpp"
20
#include "download-proof.hpp"
21
#include "ton/ton-tl.hpp"
22
#include "adnl/utils.hpp"
23
#include "ton/ton-shard.h"
24
#include "td/utils/overloaded.h"
25
#include "ton/ton-io.hpp"
26
#include "full-node.h"
27

28
namespace ton {
29

30
namespace validator {
31

32
namespace fullnode {
33

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

56
void GetNextKeyBlocks::abort_query(td::Status reason) {
57
  if (promise_) {
58
    if (reason.code() == ErrorCode::notready || reason.code() == ErrorCode::timeout) {
59
      VLOG(FULL_NODE_DEBUG) << "failed to download proof " << block_id_ << "from " << download_from_ << ": " << reason;
60
    } else {
61
      VLOG(FULL_NODE_NOTICE) << "failed to download proof " << block_id_ << " from " << download_from_ << ": "
62
                             << reason;
63
    }
64
    if (res_.size() > 0) {
65
      promise_.set_value(std::move(res_));
66
    } else {
67
      promise_.set_error(std::move(reason));
68
    }
69
  }
70
  stop();
71
}
72

73
void GetNextKeyBlocks::alarm() {
74
  abort_query(td::Status::Error(ErrorCode::timeout, "timeout"));
75
}
76

77
void GetNextKeyBlocks::finish_query() {
78
  if (promise_) {
79
    promise_.set_value(std::move(res_));
80
  }
81
  stop();
82
}
83

84
void GetNextKeyBlocks::start_up() {
85
  alarm_timestamp() = timeout_;
86

87
  auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<std::unique_ptr<DownloadToken>> R) {
88
    if (R.is_error()) {
89
      td::actor::send_closure(SelfId, &GetNextKeyBlocks::abort_query,
90
                              R.move_as_error_prefix("failed to get download token: "));
91
    } else {
92
      td::actor::send_closure(SelfId, &GetNextKeyBlocks::got_download_token, R.move_as_ok());
93
    }
94
  });
95
  td::actor::send_closure(validator_manager_, &ValidatorManagerInterface::get_download_token, 1, priority_, timeout_,
96
                          std::move(P));
97
}
98

99
void GetNextKeyBlocks::got_download_token(std::unique_ptr<DownloadToken> token) {
100
  token_ = std::move(token);
101

102
  if (download_from_.is_zero() && client_.empty()) {
103
    auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<std::vector<adnl::AdnlNodeIdShort>> R) {
104
      if (R.is_error()) {
105
        td::actor::send_closure(SelfId, &GetNextKeyBlocks::abort_query, R.move_as_error());
106
      } else {
107
        auto vec = R.move_as_ok();
108
        if (vec.size() == 0) {
109
          td::actor::send_closure(SelfId, &GetNextKeyBlocks::abort_query,
110
                                  td::Status::Error(ErrorCode::notready, "no nodes"));
111
        } else {
112
          td::actor::send_closure(SelfId, &GetNextKeyBlocks::got_node_to_download, vec[0]);
113
        }
114
      }
115
    });
116

117
    td::actor::send_closure(overlays_, &overlay::Overlays::get_overlay_random_peers, local_id_, overlay_id_, 1,
118
                            std::move(P));
119
  } else {
120
    got_node_to_download(download_from_);
121
  }
122
}
123

124
void GetNextKeyBlocks::got_node_to_download(adnl::AdnlNodeIdShort node) {
125
  download_from_ = node;
126
  VLOG(FULL_NODE_DEBUG) << "downloading proof for " << block_id_;
127

128
  auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<td::BufferSlice> R) mutable {
129
    if (R.is_error()) {
130
      td::actor::send_closure(SelfId, &GetNextKeyBlocks::abort_query, R.move_as_error());
131
    } else {
132
      td::actor::send_closure(SelfId, &GetNextKeyBlocks::got_result, R.move_as_ok());
133
    }
134
  });
135
  auto query = create_serialize_tl_object<ton_api::tonNode_getNextKeyBlockIds>(create_tl_block_id(block_id_), limit_);
136
  if (client_.empty()) {
137
    td::actor::send_closure(overlays_, &overlay::Overlays::send_query, download_from_, local_id_, overlay_id_,
138
                            "get_prepare", std::move(P), td::Timestamp::in(1.0), std::move(query));
139
  } else {
140
    td::actor::send_closure(client_, &adnl::AdnlExtClient::send_query, "get_prepare",
141
                            create_serialize_tl_object_suffix<ton_api::tonNode_query>(std::move(query)),
142
                            td::Timestamp::in(1.0), std::move(P));
143
  }
144
}
145

146
void GetNextKeyBlocks::got_result(td::BufferSlice data) {
147
  auto F = fetch_tl_object<ton_api::tonNode_keyBlocks>(std::move(data), true);
148
  if (F.is_error()) {
149
    abort_query(F.move_as_error_prefix("received bad answer: "));
150
    return;
151
  }
152
  auto f = F.move_as_ok();
153
  if (f->error_) {
154
    abort_query(td::Status::Error(ErrorCode::notready, "received answer with error"));
155
    return;
156
  }
157

158
  VLOG(FULL_NODE_DEBUG) << "received " << f->blocks_.size() << " key blocks";
159
  for (auto &x : f->blocks_) {
160
    pending_.push_back(create_block_id(x));
161
  }
162

163
  download_next_proof();
164
}
165

166
void GetNextKeyBlocks::download_next_proof() {
167
  if (!pending_.size()) {
168
    finish_query();
169
    return;
170
  }
171
  auto block_id = pending_[0];
172

173
  auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<td::BufferSlice> R) {
174
    if (R.is_error()) {
175
      td::actor::send_closure(SelfId, &GetNextKeyBlocks::abort_query, R.move_as_error());
176
    } else {
177
      td::actor::send_closure(SelfId, &GetNextKeyBlocks::got_next_proof, R.move_as_ok());
178
    }
179
  });
180

181
  td::actor::create_actor<DownloadProof>("downloadproofreq", block_id, false, true, local_id_, overlay_id_,
182
                                         download_from_, priority_, timeout_, validator_manager_, rldp_, overlays_,
183
                                         adnl_, client_, std::move(P))
184
      .release();
185
}
186

187
void GetNextKeyBlocks::got_next_proof(td::BufferSlice proof) {
188
  auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<td::Unit> R) {
189
    if (R.is_error()) {
190
      td::actor::send_closure(SelfId, &GetNextKeyBlocks::abort_query, R.move_as_error());
191
    } else {
192
      td::actor::send_closure(SelfId, &GetNextKeyBlocks::checked_next_proof);
193
    }
194
  });
195

196
  auto block_id = pending_[0];
197

198
  td::actor::send_closure(validator_manager_, &ValidatorManagerInterface::validate_block_proof_rel, block_id,
199
                          (res_.size() > 0) ? *res_.rbegin() : block_id_, std::move(proof), std::move(P));
200
}
201

202
void GetNextKeyBlocks::checked_next_proof() {
203
  auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<BlockHandle> R) {
204
    R.ensure();
205
    td::actor::send_closure(SelfId, &GetNextKeyBlocks::got_next_block_handle, R.move_as_ok());
206
  });
207
  td::actor::send_closure(validator_manager_, &ValidatorManagerInterface::get_block_handle, pending_[0], false,
208
                          std::move(P));
209
}
210

211
void GetNextKeyBlocks::got_next_block_handle(BlockHandle handle) {
212
  CHECK(handle->inited_is_key_block());
213
  if (!handle->is_key_block()) {
214
    abort_query(td::Status::Error(ErrorCode::protoviolation, "got not key block"));
215
    return;
216
  }
217
  auto block_id = pending_[0];
218
  res_.push_back(block_id);
219
  pending_.erase(pending_.begin());
220
  download_next_proof();
221
}
222

223
}  // namespace fullnode
224

225
}  // namespace validator
226

227
}  // namespace ton
228