Revert "Process adnl query errors"

This reverts commit 1869a25062.

adnl/adnl-message.cpp

@@ -46,9 +46,6 @@ AdnlMessage::AdnlMessage(tl_object_ptr<ton_api::adnl_Message> message) {
           [&](ton_api::adnl_message_part &msg) {
             message_ = adnlmessage::AdnlMessagePart{msg.hash_, static_cast<td::uint32>(msg.total_size_),
                                                     static_cast<td::uint32>(msg.offset_), std::move(msg.data_)};
-          },
-          [&](ton_api::adnl_message_queryError &msg) {
-            message_ = adnlmessage::AdnlMessageQueryError{msg.query_id_};
           }));
 }
 

adnl/adnl-message.h

@@ -170,24 +170,6 @@ class AdnlMessageAnswer {
   td::BufferSlice data_;
 };
 
-class AdnlMessageQueryError {
- public:
-  explicit AdnlMessageQueryError(AdnlQueryId query_id) : query_id_(query_id) {
-  }
-  const auto &query_id() const {
-    return query_id_;
-  }
-  td::uint32 size() const {
-    return 36;
-  }
-  tl_object_ptr<ton_api::adnl_Message> tl() const {
-    return create_tl_object<ton_api::adnl_message_queryError>(query_id_);
-  }
-
- private:
-  AdnlQueryId query_id_;
-};
-
 class AdnlMessagePart {
  public:
   AdnlMessagePart(td::Bits256 hash, td::uint32 total_size, td::uint32 offset, td::BufferSlice data)
@@ -238,8 +220,7 @@ class AdnlMessage {
  private:
   td::Variant<Empty, adnlmessage::AdnlMessageCreateChannel, adnlmessage::AdnlMessageConfirmChannel,
               adnlmessage::AdnlMessageCustom, adnlmessage::AdnlMessageNop, adnlmessage::AdnlMessageReinit,
-              adnlmessage::AdnlMessageQuery, adnlmessage::AdnlMessageAnswer, adnlmessage::AdnlMessagePart,
+              adnlmessage::AdnlMessageQuery, adnlmessage::AdnlMessageAnswer, adnlmessage::AdnlMessagePart>
-              adnlmessage::AdnlMessageQueryError>
       message_{Empty{}};
 
  public:

adnl/adnl-peer.cpp

@@ -536,14 +536,10 @@ void AdnlPeerPairImpl::process_message(const adnlmessage::AdnlMessageQuery &mess
                                        flags = static_cast<td::uint32>(0)](td::Result<td::BufferSlice> R) {
     if (R.is_error()) {
       LOG(WARNING) << "failed to answer query: " << R.move_as_error();
-      td::actor::send_closure(SelfId, &AdnlPeerPairImpl::send_message,
-                              OutboundAdnlMessage{adnlmessage::AdnlMessageQueryError{query_id}, flags});
     } else {
       auto data = R.move_as_ok();
       if (data.size() > Adnl::huge_packet_max_size()) {
         LOG(WARNING) << "dropping too big answer query: size=" << data.size();
-        td::actor::send_closure(SelfId, &AdnlPeerPairImpl::send_message,
-                                OutboundAdnlMessage{adnlmessage::AdnlMessageQueryError{query_id}, flags});
       } else {
         td::actor::send_closure(SelfId, &AdnlPeerPairImpl::send_message,
                                 OutboundAdnlMessage{adnlmessage::AdnlMessageAnswer{query_id, std::move(data)}, flags});
@@ -625,18 +621,6 @@ void AdnlPeerPairImpl::process_message(const adnlmessage::AdnlMessagePart &messa
   }
 }
 
-void AdnlPeerPairImpl::process_message(const adnlmessage::AdnlMessageQueryError &message) {
-  auto Q = out_queries_.find(message.query_id());
-
-  if (Q == out_queries_.end()) {
-    VLOG(ADNL_NOTICE) << this << ": dropping IN query error: unknown query id " << message.query_id();
-    return;
-  }
-
-  td::actor::send_closure_later(Q->second, &AdnlQuery::set_error, td::Status::Error("adnl query rejected"));
-  out_queries_.erase(Q);
-}
-
 void AdnlPeerPairImpl::delete_query(AdnlQueryId id) {
   auto Q = out_queries_.find(id);
 

adnl/adnl-peer.hpp

@@ -104,7 +104,6 @@ class AdnlPeerPairImpl : public AdnlPeerPair {
   void process_message(const adnlmessage::AdnlMessageQuery &message);
   void process_message(const adnlmessage::AdnlMessageAnswer &message);
   void process_message(const adnlmessage::AdnlMessagePart &message);
-  void process_message(const adnlmessage::AdnlMessageQueryError &message);
   void process_message(const AdnlMessage::Empty &message) {
     UNREACHABLE();
   }

rldp/rldp-in.hpp

@@ -78,8 +78,6 @@ class RldpIn : public RldpImpl {
                      td::uint64 max_answer_size) override;
   void answer_query(adnl::AdnlNodeIdShort src, adnl::AdnlNodeIdShort dst, td::Timestamp timeout,
                     adnl::AdnlQueryId query_id, TransferId transfer_id, td::BufferSlice data);
-  void reject_query(adnl::AdnlNodeIdShort src, adnl::AdnlNodeIdShort dst, td::Timestamp timeout,
-                    adnl::AdnlQueryId query_id, TransferId transfer_id);
 
   void alarm_query(adnl::AdnlQueryId query_id, TransferId transfer_id);
 
@@ -95,8 +93,6 @@ class RldpIn : public RldpImpl {
                        ton_api::rldp_query &message);
   void process_message(adnl::AdnlNodeIdShort source, adnl::AdnlNodeIdShort local_id, TransferId transfer_id,
                        ton_api::rldp_answer &message);
-  void process_message(adnl::AdnlNodeIdShort source, adnl::AdnlNodeIdShort local_id, TransferId transfer_id,
-                       ton_api::rldp_queryError &message);
   void receive_message(adnl::AdnlNodeIdShort source, adnl::AdnlNodeIdShort local_id, TransferId transfer_id,
                        td::BufferSlice data);
 

rldp/rldp.cpp

@@ -87,13 +87,6 @@ void RldpIn::answer_query(adnl::AdnlNodeIdShort src, adnl::AdnlNodeIdShort dst,
   transfer(src, dst, timeout, std::move(B), transfer_id);
 }
 
-void RldpIn::reject_query(adnl::AdnlNodeIdShort src, adnl::AdnlNodeIdShort dst, td::Timestamp timeout,
-                          adnl::AdnlQueryId query_id, TransferId transfer_id) {
-  auto B = serialize_tl_object(create_tl_object<ton_api::rldp_queryError>(query_id), true);
-
-  transfer(src, dst, timeout, std::move(B), transfer_id);
-}
-
 void RldpIn::alarm_query(adnl::AdnlQueryId query_id, TransferId transfer_id) {
   queries_.erase(query_id);
   max_size_.erase(transfer_id);
@@ -206,16 +199,12 @@ void RldpIn::process_message(adnl::AdnlNodeIdShort source, adnl::AdnlNodeIdShort
       auto data = R.move_as_ok();
       if (data.size() > max_answer_size) {
         VLOG(RLDP_NOTICE) << "rldp query failed: answer too big";
-        td::actor::send_closure(SelfId, &RldpIn::reject_query, local_id, source, timeout, query_id,
-                                transfer_id ^ TransferId::ones());
       } else {
         td::actor::send_closure(SelfId, &RldpIn::answer_query, local_id, source, timeout, query_id,
                                 transfer_id ^ TransferId::ones(), std::move(data));
       }
     } else {
       VLOG(RLDP_NOTICE) << "rldp query failed: " << R.move_as_error();
-      td::actor::send_closure(SelfId, &RldpIn::reject_query, local_id, source, timeout, query_id,
-                              transfer_id ^ TransferId::ones());
     }
   });
   VLOG(RLDP_DEBUG) << "delivering rldp query";
@@ -234,17 +223,6 @@ void RldpIn::process_message(adnl::AdnlNodeIdShort source, adnl::AdnlNodeIdShort
   }
 }
 
-void RldpIn::process_message(adnl::AdnlNodeIdShort source, adnl::AdnlNodeIdShort local_id, TransferId transfer_id,
-                             ton_api::rldp_queryError &message) {
-  auto it = queries_.find(message.query_id_);
-  if (it != queries_.end()) {
-    td::actor::send_closure(it->second, &adnl::AdnlQuery::set_error, td::Status::Error("adnl query rejected"));
-    queries_.erase(it);
-  } else {
-    VLOG(RLDP_INFO) << "received reject to unknown query " << message.query_id_;
-  }
-}
-
 void RldpIn::transfer_completed(TransferId transfer_id) {
   senders_.erase(transfer_id);
   VLOG(RLDP_DEBUG) << "rldp: completed transfer " << transfer_id << "; " << senders_.size() << " out transfer pending ";

rldp2/rldp-in.hpp

@@ -76,8 +76,6 @@ class RldpIn : public RldpImpl {
                      td::uint64 max_answer_size) override;
   void answer_query(adnl::AdnlNodeIdShort src, adnl::AdnlNodeIdShort dst, td::Timestamp timeout,
                     adnl::AdnlQueryId query_id, TransferId transfer_id, td::BufferSlice data);
-  void reject_query(adnl::AdnlNodeIdShort src, adnl::AdnlNodeIdShort dst, td::Timestamp timeout,
-                    adnl::AdnlQueryId query_id, TransferId transfer_id);
 
   void receive_message_part(adnl::AdnlNodeIdShort source, adnl::AdnlNodeIdShort local_id, td::BufferSlice data);
 
@@ -87,8 +85,6 @@ class RldpIn : public RldpImpl {
                        ton_api::rldp_query &message);
   void process_message(adnl::AdnlNodeIdShort source, adnl::AdnlNodeIdShort local_id, TransferId transfer_id,
                        ton_api::rldp_answer &message);
-  void process_message(adnl::AdnlNodeIdShort source, adnl::AdnlNodeIdShort local_id, TransferId transfer_id,
-                       ton_api::rldp_queryError &message);
   void receive_message(adnl::AdnlNodeIdShort source, adnl::AdnlNodeIdShort local_id, TransferId transfer_id,
                        td::Result<td::BufferSlice> data);
 

rldp2/rldp.cpp

@@ -121,13 +121,6 @@ void RldpIn::answer_query(adnl::AdnlNodeIdShort src, adnl::AdnlNodeIdShort dst,
   send_closure(create_connection(src, dst), &RldpConnectionActor::send, transfer_id, std::move(B), timeout);
 }
 
-void RldpIn::reject_query(adnl::AdnlNodeIdShort src, adnl::AdnlNodeIdShort dst, td::Timestamp timeout,
-                          adnl::AdnlQueryId query_id, TransferId transfer_id) {
-  auto B = serialize_tl_object(create_tl_object<ton_api::rldp_queryError>(query_id), true);
-
-  send_closure(create_connection(src, dst), &RldpConnectionActor::send, transfer_id, std::move(B), timeout);
-}
-
 void RldpIn::receive_message_part(adnl::AdnlNodeIdShort source, adnl::AdnlNodeIdShort local_id, td::BufferSlice data) {
   send_closure(create_connection(local_id, source), &RldpConnectionActor::receive_raw, std::move(data));
 }
@@ -187,16 +180,12 @@ void RldpIn::process_message(adnl::AdnlNodeIdShort source, adnl::AdnlNodeIdShort
       auto data = R.move_as_ok();
       if (data.size() > max_answer_size) {
         VLOG(RLDP_NOTICE) << "rldp query failed: answer too big";
-        td::actor::send_closure(SelfId, &RldpIn::reject_query, local_id, source, timeout, query_id,
-                                transfer_id ^ TransferId::ones());
       } else {
         td::actor::send_closure(SelfId, &RldpIn::answer_query, local_id, source, timeout, query_id,
                                 transfer_id ^ TransferId::ones(), std::move(data));
       }
     } else {
       VLOG(RLDP_NOTICE) << "rldp query failed: " << R.move_as_error();
-      td::actor::send_closure(SelfId, &RldpIn::reject_query, local_id, source, timeout, query_id,
-                              transfer_id ^ TransferId::ones());
     }
   });
   VLOG(RLDP_DEBUG) << "delivering rldp query";
@@ -215,17 +204,6 @@ void RldpIn::process_message(adnl::AdnlNodeIdShort source, adnl::AdnlNodeIdShort
   }
 }
 
-void RldpIn::process_message(adnl::AdnlNodeIdShort source, adnl::AdnlNodeIdShort local_id, TransferId transfer_id,
-                             ton_api::rldp_queryError &message) {
-  auto it = queries_.find(transfer_id);
-  if (it != queries_.end()) {
-    it->second.set_error(td::Status::Error("rejected"));
-    queries_.erase(it);
-  } else {
-    VLOG(RLDP_INFO) << "received reject to unknown query " << message.query_id_;
-  }
-}
-
 void RldpIn::on_sent(TransferId transfer_id, td::Result<td::Unit> state) {
   //TODO: completed transfer
 }

tl/generate/scheme/ton_api.tl

@@ -137,7 +137,6 @@ adnl.message.reinit date:int = adnl.Message;
 
 adnl.message.query query_id:int256 query:bytes = adnl.Message;
 adnl.message.answer query_id:int256 answer:bytes = adnl.Message;
-adnl.message.queryError query_id:int256 = adnl.Message;
 
 adnl.message.part hash:int256 total_size:int offset:int data:bytes = adnl.Message;
 
@@ -163,7 +162,6 @@ rldp.complete transfer_id:int256 part:int = rldp.MessagePart;
 rldp.message id:int256 data:bytes = rldp.Message;
 rldp.query query_id:int256 max_answer_size:long timeout:int data:bytes = rldp.Message;
 rldp.answer query_id:int256 data:bytes = rldp.Message;
-rldp.queryError query_id:int256 = rldp.Message;
 
 
 ---functions---