Method receive_query

runners/proxy/ProxyRunner.cpp:1239–1347

}

void ProxyRunner::receive_query(TcpClient::ConnectionId connection_id, td::BufferSlice query,
                                td::Promise<td::BufferSlice> promise) {
  auto magic = get_tl_magic(query);
  switch (magic) {
    case cocoon_api::client_connectToProxy::ID:
    case cocoon_api::client_authorizeWithProxyShort::ID:
    case cocoon_api::client_authorizeWithProxyLong::ID: {
      auto conn = static_cast<ProxyInboundConnection *>(get_connection(connection_id));
      if (!conn || conn->connection_type() != ProxyInboundConnection::ConnectionType::Client) {
        return promise.set_error(td::Status::Error(ton::ErrorCode::protoviolation, "client connect() from non client"));
      }
      auto client_conn = static_cast<ProxyInboundClientConnection *>(conn);
      client_conn->receive_handshake_query(std::move(query), std::move(promise));
    } break;
    case cocoon_api::client_updatePaymentStatus::ID: {
      auto conn = static_cast<ProxyInboundConnection *>(get_connection(connection_id));
      if (!conn || conn->connection_type() != ProxyInboundConnection::ConnectionType::Client) {
        return promise.set_error(td::Status::Error(ton::ErrorCode::protoviolation, "client request from non client"));
      }
      if (!conn->handshake_is_completed()) {
        return promise.set_error(
            td::Status::Error(ton::ErrorCode::protoviolation, "client request from non-ready connection"));
      }
      promise.set_value(cocoon::serialize_tl_object(
          static_cast<ProxyInboundClientConnection *>(conn)->client_info()->serialize_payment_status(), true));
    } break;
    case cocoon_api::worker_connectToProxy::ID:
    case cocoon_api::worker_compareBalanceWithProxy::ID:
    case cocoon_api::worker_extendedCompareBalanceWithProxy::ID:
    case cocoon_api::worker_proxyHandshakeComplete::ID: {
      auto conn = static_cast<ProxyInboundConnection *>(get_connection(connection_id));
      if (!conn || conn->connection_type() != ProxyInboundConnection::ConnectionType::Worker) {
        return promise.set_error(td::Status::Error(ton::ErrorCode::protoviolation, "worker connect() from non worker"));
      }
      auto worker_conn = static_cast<ProxyInboundWorkerConnection *>(conn);
      worker_conn->receive_handshake_query(std::move(query), std::move(promise));
    } break;
    case cocoon_api::worker_updatePaymentStatus::ID: {
      auto conn = static_cast<ProxyInboundConnection *>(get_connection(connection_id));
      if (!conn || conn->connection_type() != ProxyInboundConnection::ConnectionType::Worker) {
        return promise.set_error(td::Status::Error(ton::ErrorCode::protoviolation, "worker request from non worker"));
      }
      if (!conn->handshake_is_completed()) {
        return promise.set_error(
            td::Status::Error(ton::ErrorCode::protoviolation, "worker request from non-ready connection"));
      }
      promise.set_value(cocoon::serialize_tl_object(
          static_cast<ProxyInboundWorkerConnection *>(conn)->worker_info()->serialize_payment_status(), true));
    } break;
    case cocoon_api::client_getWorkerTypes::ID: {
      auto conn = static_cast<ProxyInboundConnection *>(get_connection(connection_id));
      if (!conn || conn->connection_type() != ProxyInboundConnection::ConnectionType::Client ||
          !conn->handshake_is_completed()) {
        return promise.set_error(td::Status::Error(ton::ErrorCode::protoviolation, "expected client connection"));
      }
      TRY_RESULT_PROMISE(promise, obj, fetch_tl_object<cocoon_api::client_getWorkerTypes>(std::move(query), true));

      std::vector<ton::tl_object_ptr<cocoon_api::client_workerType>> r;