Changeset 1058

Timestamp:

05/05/08 15:16:26 (4 years ago)

Author:

rakshasa

Message:

* Initial seeding support added. Patch by Josef Drexler.

Location:

trunk

Files:

• libtorrent/src/download/download_main.cc (modified) (4 diffs)
• libtorrent/src/download/download_main.h (modified) (3 diffs)
• libtorrent/src/protocol/Makefile.am (modified) (1 diff)
• libtorrent/src/protocol/handshake.cc (modified) (2 diffs)
• libtorrent/src/protocol/handshake_manager.cc (modified) (1 diff)
• libtorrent/src/protocol/initial_seed.cc (added)
• libtorrent/src/protocol/initial_seed.h (added)
• libtorrent/src/protocol/peer_connection_base.h (modified) (2 diffs)
• libtorrent/src/protocol/peer_connection_leech.cc (modified) (16 diffs)
• libtorrent/src/protocol/peer_connection_leech.h (modified) (2 diffs)
• libtorrent/src/protocol/peer_factory.cc (modified) (1 diff)
• libtorrent/src/protocol/peer_factory.h (modified) (1 diff)
• libtorrent/src/torrent/download.cc (modified) (2 diffs)
• libtorrent/src/torrent/download.h (modified) (1 diff)
• libtorrent/src/torrent/peer/peer_info.cc (modified) (1 diff)
• libtorrent/src/torrent/peer/peer_info.h (modified) (3 diffs)
• libtorrent/src/torrent/peer/peer_list.cc (modified) (1 diff)
• rtorrent/doc/rtorrent.1.xml (modified) (2 diffs)
• rtorrent/src/command_download.cc (modified) (4 diffs)
• rtorrent/src/core/download_factory.cc (modified) (2 diffs)
• rtorrent/src/core/download_list.cc (modified) (1 diff)
• rtorrent/src/ui/element_download_list.cc (modified) (1 diff)

trunk/libtorrent/src/download/download_main.cc

@@ -43 +43 @@
 #include "protocol/extensions.h"
 #include "protocol/handshake_manager.h"
+#include "protocol/initial_seed.h"
 #include "protocol/peer_connection_base.h"
+#include "protocol/peer_factory.h"
 #include "tracker/tracker_manager.h"
+#include "torrent/download.h"
 #include "torrent/exceptions.h"
 #include "torrent/data/file_list.h"
@@ -57 +60 @@
 #include "download_info.h"
 #include "download_main.h"
+#include "download_manager.h"
+#include "download_wrapper.h"
 
 namespace torrent {
@@ -68 +73 @@
   m_chunkStatistics(new ChunkStatistics),
 
+  m_initialSeeding(NULL),
   m_uploadThrottle(NULL),
   m_downloadThrottle(NULL) {
@@ -192 +198 @@
 
   m_slotStopHandshakes(this);
-
   connection_list()->erase_remaining(connection_list()->begin(), ConnectionList::disconnect_available);
 
+  delete m_initialSeeding;
+
   priority_queue_erase(&taskScheduler, &m_taskTrackerRequest);
+}
+
+bool
+DownloadMain::start_initial_seeding() {
+  if (!file_list()->is_done())
+    return false;
+
+  m_initialSeeding = new InitialSeeding(this);
+  return true;
+}
+
+void
+DownloadMain::initial_seeding_done(PeerConnectionBase* pcb) {
+  if (m_initialSeeding == NULL)
+    throw internal_error("DownloadMain::initial_seeding_done called when not initial seeding.");
+
+  // Close all connections but the currently active one (pcb).
+  // That one will be closed by throw close_connection() later.
+  if (m_connectionList->size() > 1) {
+    ConnectionList::iterator itr = std::find(m_connectionList->begin(), m_connectionList->end(), pcb);
+    if (itr == m_connectionList->end())
+      throw internal_error("DownloadMain::initial_seeding_done could not find current connection.");
+
+    std::iter_swap(m_connectionList->begin(), itr);
+    m_connectionList->erase_remaining(m_connectionList->begin() + 1, ConnectionList::disconnect_available);
+  }
+
+  // Switch to normal seeding.
+  DownloadManager::iterator itr = manager->download_manager()->find(m_info);
+  (*itr)->set_connection_type(Download::CONNECTION_SEED);
+  m_connectionList->slot_new_connection(&createPeerConnectionSeed);
+  delete m_initialSeeding;
+  m_initialSeeding = NULL;
+
+  // And close the current connection.
+  throw close_connection();
 }
 

trunk/libtorrent/src/download/download_main.h

@@ -66 +66 @@
 class DownloadInfo;
 class ThrottleList;
+class InitialSeeding;
 
 class DownloadMain {
@@ -95 +96 @@
 
   have_queue_type*    have_queue()                               { return &m_haveQueue; }
+
+  InitialSeeding*     initial_seeding()                          { return m_initialSeeding; }
+  bool                start_initial_seeding();
+  void                initial_seeding_done(PeerConnectionBase* pcb);
 
   ConnectionList*     connection_list()                          { return m_connectionList; }
@@ -158 +163 @@
   Delegator           m_delegator;
   have_queue_type     m_haveQueue;
+  InitialSeeding*     m_initialSeeding;
 
   ConnectionList*     m_connectionList;

trunk/libtorrent/src/protocol/Makefile.am

@@ -11 +11 @@
         handshake_manager.cc \
         handshake_manager.h \
+        initial_seed.cc \
+        initial_seed.h \
         peer_chunks.h \
         peer_connection_base.cc \

trunk/libtorrent/src/protocol/handshake.cc

@@ -527 +527 @@
   // The download is just starting so we're not sending any
   // bitfield. Pretend we wrote it already.
-  if (m_download->file_list()->bitfield()->is_all_unset())
+  if (m_download->file_list()->bitfield()->is_all_unset() || m_download->initial_seeding() != NULL) {
     m_writePos = m_download->file_list()->bitfield()->size_bytes();
-  else
+    m_writeBuffer.write_32(0);
+
+    if (m_encryption.info()->is_encrypted())
+      m_encryption.info()->encrypt(m_writeBuffer.end() - 4, 4);
+
+  } else {
     prepare_bitfield();
+  }
 
   m_state = READ_MESSAGE;
@@ -622 +628 @@
   // bitfield to send, we need to send a keep-alive now.
   if (m_writePos == m_download->file_list()->bitfield()->size_bytes())
-    prepare_post_handshake(m_download->file_list()->bitfield()->is_all_unset());
+    prepare_post_handshake(m_download->file_list()->bitfield()->is_all_unset() || m_download->initial_seeding() != NULL);
 
   if (m_writeDone)

trunk/libtorrent/src/protocol/handshake_manager.cc

@@ -195 +195 @@
       // We need to make libtorrent more selective in the clients it
       // connects to, and to move this somewhere else.
-      (!download->file_list()->is_done() || !handshake->bitfield()->is_all_set()) &&
+      (!download->file_list()->is_done() || !handshake->bitfield()->is_all_set() || download->initial_seeding() != NULL) &&
 
       (pcb = download->connection_list()->insert(handshake->peer_info(),

trunk/libtorrent/src/protocol/peer_connection_base.h

@@ -137 +137 @@
   void                cancel_transfer(BlockTransfer* transfer);
 
+  // Insert into the poll unless we're blocking for throttling etc.
+  void                read_insert_poll_safe();
+  void                write_insert_poll_safe();
+
 protected:
   static const uint32_t extension_must_encrypt = ~uint32_t();
@@ -176 +180 @@
 
   bool                send_pex_message();
-
-  // Insert into the poll unless we're blocking for throttling etc.
-  void                read_insert_poll_safe();
-  void                write_insert_poll_safe();
 
   DownloadMain*       m_download;

trunk/libtorrent/src/protocol/peer_connection_leech.cc

@@ -51 +51 @@
 
 #include "extensions.h"
+#include "initial_seed.h"
 #include "peer_connection_leech.h"
 
@@ -66 +67 @@
 void
 PeerConnection<type>::initialize_custom() {
+  if (type == Download::CONNECTION_INITIAL_SEED) {
+    if (m_download->initial_seeding() == NULL) {
+      // Can't throw close_connection or network_error here, we're still
+      // initializing. So close the socket and let that kill it later.
+      get_fd().close();
+      return;
+    }
+
+    m_download->initial_seeding()->new_peer(this);
+  }
 //   if (m_download->content()->chunks_completed() != 0) {
 //     m_up->write_bitfield(m_download->file_list()->bitfield()->size_bytes());
@@ -78 +89 @@
 void
 PeerConnection<type>::update_interested() {
-  if (type == Download::CONNECTION_SEED)
+  if (type != Download::CONNECTION_LEECH)
     return;
 
@@ -118 +129 @@
   }
 
-  if (type == Download::CONNECTION_SEED)
+  if (type != Download::CONNECTION_LEECH)
     return true;
 
@@ -193 +204 @@
   switch (buf->read_8()) {
   case ProtocolBase::CHOKE:
-    if (type == Download::CONNECTION_SEED)
+    if (type != Download::CONNECTION_LEECH)
       return true;
 
@@ -213 +224 @@
 
   case ProtocolBase::UNCHOKE:
-    if (type == Download::CONNECTION_SEED)
+    if (type != Download::CONNECTION_LEECH)
       return true;
 
@@ -259 +270 @@
 
   case ProtocolBase::PIECE:
-    if (type == Download::CONNECTION_SEED)
+    if (type != Download::CONNECTION_LEECH)
       throw communication_error("Received a piece but the connection is strictly for seeding.");
 
@@ -382 +393 @@
 
       case ProtocolRead::READ_PIECE:
-        if (type == Download::CONNECTION_SEED)
+        if (type != Download::CONNECTION_LEECH)
           return;
 
@@ -402 +413 @@
 
       case ProtocolRead::READ_SKIP_PIECE:
-        if (type == Download::CONNECTION_SEED)
+        if (type != Download::CONNECTION_LEECH)
           return;
 
@@ -490 +501 @@
   // request has been received while uninterested. The problem arises
   // as they send unchoke before receiving interested.
-  if (type != Download::CONNECTION_SEED && m_sendInterested && m_up->can_write_interested()) {
+  if (type == Download::CONNECTION_LEECH && m_sendInterested && m_up->can_write_interested()) {
     m_up->write_interested(m_downInterested);
     m_sendInterested = false;
   }
 
-  if (type != Download::CONNECTION_SEED && m_tryRequest) {
+  if (type == Download::CONNECTION_LEECH && m_tryRequest) {
     if (!(m_tryRequest = !should_request()) &&
         !(m_tryRequest = try_request_pieces()) &&
@@ -509 +520 @@
   DownloadMain::have_queue_type* haveQueue = m_download->have_queue();
 
-  if (type != Download::CONNECTION_SEED && 
+  if (type == Download::CONNECTION_LEECH && 
       !haveQueue->empty() &&
       m_peerChunks.have_timer() <= haveQueue->front().first &&
@@ -523 +534 @@
   }
 
-  while (type != Download::CONNECTION_SEED && !m_peerChunks.cancel_queue()->empty() && m_up->can_write_cancel()) {
+  if (type == Download::CONNECTION_INITIAL_SEED && m_up->can_write_have())
+    offer_chunk();
+
+  while (type == Download::CONNECTION_LEECH && !m_peerChunks.cancel_queue()->empty() && m_up->can_write_cancel()) {
     m_up->write_cancel(m_peerChunks.cancel_queue()->front());
     m_peerChunks.cancel_queue()->pop_front();
@@ -534 +548 @@
   } else if (!m_upChoke.choked() &&
              !m_peerChunks.upload_queue()->empty() &&
-             m_up->can_write_piece()) {
+             m_up->can_write_piece() &&
+             (type != Download::CONNECTION_INITIAL_SEED || should_upload())) {
     write_prepare_piece();
   }
@@ -639 +654 @@
   m_download->chunk_statistics()->received_have_chunk(&m_peerChunks, index, m_download->file_list()->chunk_size());
 
+  if (type == Download::CONNECTION_INITIAL_SEED)
+    m_download->initial_seeding()->chunk_seen(index, this);
+
+  // Disconnect seeds when we are seeding (but not for initial seeding
+  // so that we keep accurate chunk statistics until that is done).
   if (m_peerChunks.bitfield()->is_all_set()) {
-    if (type == Download::CONNECTION_SEED || m_download->file_list()->is_done())
+    if (type == Download::CONNECTION_SEED || 
+        (type != Download::CONNECTION_INITIAL_SEED && m_download->file_list()->is_done()))
       throw close_connection();
 
@@ -646 +667 @@
   }
 
-  if (type == Download::CONNECTION_SEED || m_download->file_list()->is_done())
+  if (type != Download::CONNECTION_LEECH || m_download->file_list()->is_done())
     return;
 
@@ -677 +698 @@
 }
 
-// Explicit instatiation of the member functions and vtable.
+template<>
+void
+PeerConnection<Download::CONNECTION_INITIAL_SEED>::offer_chunk() {
+  // If bytes left to send in this chunk minus bytes about to be sent is zero,
+  // assume the peer will have got the chunk completely. In that case we may
+  // get another one to offer if not enough other peers are interested even
+  // if the peer would otherwise still be blocked.
+  uint32_t bytesLeft = m_data.bytesLeft;
+  if (!m_peerChunks.upload_queue()->empty() && m_peerChunks.upload_queue()->front().index() == m_data.lastIndex)
+    bytesLeft -= m_peerChunks.upload_queue()->front().length();
+
+  uint32_t index = m_download->initial_seeding()->chunk_offer(this, bytesLeft == 0 ? m_data.lastIndex : InitialSeeding::no_offer);
+
+  if (index == InitialSeeding::no_offer || index == m_data.lastIndex)
+    return;
+
+  m_up->write_have(index);
+  m_data.lastIndex = index;
+  m_data.bytesLeft = m_download->file_list()->chunk_index_size(index);
+}
+
+template<>
+bool
+PeerConnection<Download::CONNECTION_INITIAL_SEED>::should_upload() {
+  // For initial seeding, check if chunk is well seeded now, and if so
+  // remove it from the queue to better use our bandwidth on rare chunks.
+  while (!m_peerChunks.upload_queue()->empty() &&
+         !m_download->initial_seeding()->should_upload(m_peerChunks.upload_queue()->front().index()))
+    m_peerChunks.upload_queue()->pop_front();
+
+  // If queue ends up empty, choke peer to let it know that it
+  // shouldn't wait for the cancelled pieces to be sent.
+  if (m_peerChunks.upload_queue()->empty()) {
+    m_download->upload_choke_manager()->set_not_queued(this, &m_upChoke);
+    m_download->upload_choke_manager()->set_queued(this, &m_upChoke);
+
+  // If we're sending the chunk we last offered, adjust bytes left in it.
+  } else if (m_peerChunks.upload_queue()->front().index() == m_data.lastIndex) {
+    m_data.bytesLeft -= m_peerChunks.upload_queue()->front().length();
+
+    if (!m_data.bytesLeft)
+      m_data.lastIndex = InitialSeeding::no_offer;
+  }
+
+  return !m_peerChunks.upload_queue()->empty();
+}
+
+// Explicit instantiation of the member functions and vtable.
 template class PeerConnection<Download::CONNECTION_LEECH>;
 template class PeerConnection<Download::CONNECTION_SEED>;
-
-}
+template class PeerConnection<Download::CONNECTION_INITIAL_SEED>;
+
+}

trunk/libtorrent/src/protocol/peer_connection_leech.h

@@ -44 +44 @@
 namespace torrent {
 
+// Type-specific data.
+template<Download::ConnectionType type> struct PeerConnectionData;
+
+template<> struct PeerConnectionData<Download::CONNECTION_LEECH> { };
+
+template<> struct PeerConnectionData<Download::CONNECTION_SEED> { };
+
+template<> struct PeerConnectionData<Download::CONNECTION_INITIAL_SEED> {
+  PeerConnectionData() : lastIndex(~uint32_t()) { }
+  uint32_t lastIndex;
+  uint32_t bytesLeft;
+};
+
 template<Download::ConnectionType type>
 class PeerConnection : public PeerConnectionBase {
@@ -60 +73 @@
   void                read_have_chunk(uint32_t index);
 
+  void                offer_chunk();
+  bool                should_upload();
+
   inline void         fill_write_buffer();
+
+  PeerConnectionData<type> m_data;
 };
 

trunk/libtorrent/src/protocol/peer_factory.cc

@@ -56 +56 @@
 }
 
+PeerConnectionBase*
+createPeerConnectionInitialSeed(bool encrypted) {
+  PeerConnectionBase* pc = new PeerConnection<Download::CONNECTION_INITIAL_SEED>;
+
+  return pc;
 }
+
+}

trunk/libtorrent/src/protocol/peer_factory.h

@@ -44 +44 @@
 PeerConnectionBase* createPeerConnectionDefault(bool encrypted);
 PeerConnectionBase* createPeerConnectionSeed(bool encrypted);
+PeerConnectionBase* createPeerConnectionInitialSeed(bool encrypted);
 
 }

trunk/libtorrent/src/torrent/download.cc

@@ -107 +107 @@
   file_list()->open(flags & ~FileList::open_no_create);
 
+  if (m_ptr->connection_type() == CONNECTION_INITIAL_SEED) {
+    if (!m_ptr->main()->start_initial_seeding()) 
+      set_connection_type(CONNECTION_SEED);
+  }
+
   m_ptr->main()->start();
   m_ptr->main()->tracker_manager()->set_active(true);
@@ -502 +507 @@
     m_ptr->main()->connection_list()->slot_new_connection(&createPeerConnectionSeed);
     break;
+  case CONNECTION_INITIAL_SEED:
+    if (is_active() && m_ptr->main()->initial_seeding() == NULL)
+      throw input_error("Can't switch to initial seeding: download is active.");
+    m_ptr->main()->connection_list()->slot_new_connection(&createPeerConnectionInitialSeed);
+    break;
   default:
     throw input_error("torrent::Download::set_connection_type(...) received an unknown type.");

trunk/libtorrent/src/torrent/download.h

@@ -181 +181 @@
   typedef enum {
     CONNECTION_LEECH,
-    CONNECTION_SEED
+    CONNECTION_SEED,
+    CONNECTION_INITIAL_SEED,
   } ConnectionType;
 

trunk/libtorrent/src/torrent/peer/peer_info.cc

@@ -70 +70 @@
     throw internal_error("PeerInfo::~PeerInfo() m_transferCounter != 0.");
 
+  if (is_blocked())
+    throw internal_error("PeerInfo::~PeerInfo() peer is blocked.");
+
   delete rak::socket_address::cast_from(m_address);
 }

trunk/libtorrent/src/torrent/peer/peer_info.h

@@ -48 +48 @@
   friend class Handshake;
   friend class HandshakeManager;
+  friend class InitialSeeding;
   friend class PeerList;
   friend class ProtocolExtension;
@@ -54 +55 @@
   static const int flag_incoming  = (1 << 1);
   static const int flag_handshake = (1 << 2);
+  static const int flag_blocked   = (1 << 3);   // For initial seeding.
+  static const int flag_restart   = (1 << 4);
 
   PeerInfo(const sockaddr* address);
@@ -61 +64 @@
   bool                is_incoming() const                   { return m_flags & flag_incoming; }
   bool                is_handshake() const                  { return m_flags & flag_handshake; }
+  bool                is_blocked() const                    { return m_flags & flag_blocked; }
+  bool                is_restart() const                    { return m_flags & flag_restart; }
 
   int                 flags() const                         { return m_flags; }

trunk/libtorrent/src/torrent/peer/peer_list.cc

@@ -307 +307 @@
         itr->second->last_connection() >= timer ||
 
-        (flags & cull_keep_interesting && itr->second->failed_counter() != 0)) {
+        (flags & cull_keep_interesting && 
+         (itr->second->failed_counter() != 0 || itr->second->is_blocked()))) {
       itr++;
       continue;

trunk/rtorrent/doc/rtorrent.1.xml

@@ -155 +155 @@
 Set the 'create/resize queued' flags on all files in a torrent. This
 is necessary if the underlying files in a torrent have been deleted or
-truncates, and thus rtorrent much recreate them.
+truncated, and thus rtorrent must recreate them.
           </para></listitem>
         </varlistentry>
@@ -178 +178 @@
           <listitem><para>
 Call commands or change settings.
+          </para></listitem>
+        </varlistentry>
+
+        <varlistentry>
+          <term>^B</term>
+          <listitem><para>
+Set download to perform initial seeding. Only use when
+you are the first and only seeder so far for the download.
           </para></listitem>
         </varlistentry>

trunk/rtorrent/src/command_download.cc

@@ -170 +170 @@
   else if (name == "seed")
     connType = torrent::Download::CONNECTION_SEED;
+  else if (name == "initial_seed")
+    connType = torrent::Download::CONNECTION_INITIAL_SEED;
   else
     throw torrent::input_error("Unknown peer connection type selected.");
@@ -193 +195 @@
   case torrent::Download::CONNECTION_SEED:
     return "seed";
+  case torrent::Download::CONNECTION_INITIAL_SEED:
+    return "initial_seed";
   default:
     return "unknown";
@@ -493 +497 @@
 
   ADD_CD_STRING_BI("connection_current", std::ptr_fun(&apply_d_connection_type), std::ptr_fun(&retrieve_d_connection_type));
+  ADD_CD_VARIABLE_STRING("connection_leech",      "rtorrent", "connection_leech");
+  ADD_CD_VARIABLE_STRING("connection_seed",       "rtorrent", "connection_seed");
 
   ADD_CD_VALUE_BI("hashing_failed",      std::mem_fun(&core::Download::set_hash_failed), std::mem_fun(&core::Download::is_hash_failed));
@@ -499 +505 @@
   // logging support.
   ADD_CD_STRING_BI("message",            std::mem_fun(&core::Download::set_message), std::mem_fun(&core::Download::message));
-
-  add_copy_to_download("get_connection_leech", "d.get_connection_leech");
-  add_copy_to_download("set_connection_leech", "d.set_connection_leech");
-  add_copy_to_download("get_connection_seed", "d.get_connection_seed");
-  add_copy_to_download("set_connection_seed", "d.set_connection_seed");
 
   ADD_CD_VALUE_MEM_BI("max_file_size", &core::Download::file_list, &torrent::FileList::set_max_file_size, &torrent::FileList::max_file_size);

trunk/rtorrent/src/core/download_factory.cc

@@ -196 +196 @@
   if (!rtorrent->has_key_string("custom5")) rtorrent->insert_key("custom5", std::string());
 
-  // Move to 'rtorrent'.
-  rpc::call_command("d.set_connection_leech", m_variables["connection_leech"], rpc::make_target(download));
-  rpc::call_command("d.set_connection_seed",  m_variables["connection_seed"], rpc::make_target(download));
-
   rpc::call_command("d.set_uploads_max",      rpc::call_command_void("get_max_uploads"), rpc::make_target(download));
   rpc::call_command("d.set_peers_min",        rpc::call_command_void("get_min_peers"), rpc::make_target(download));
@@ -353 +349 @@
 
   rtorrent->insert_preserve_copy("ignore_commands", (int64_t)0);
-}
-
-}
+
+  rtorrent->insert_preserve_type("connection_leech", m_variables["connection_leech"]);
+  rtorrent->insert_preserve_type("connection_seed", m_variables["connection_seed"]);
+}
+
+}

trunk/rtorrent/src/core/download_list.cc

@@ -399 +399 @@
     rpc::call_command("d.set_state_counter", rpc::call_command_value("d.get_state_counter", rpc::make_target(download)), rpc::make_target(download));
 
+    // If initial seeding is complete, don't try it again when restarting.
+    if (download->is_done())
+      rpc::call_command("d.set_connection_seed", rpc::call_command_void("d.get_connection_current", rpc::make_target(download)), rpc::make_target(download));
+
     // Save the state after all the slots, etc have been called so we
     // include the modifications they may make.

trunk/rtorrent/src/ui/element_download_list.cc

@@ -77 +77 @@
                                   "{d.set_ignore_commands=0, print=\"Torrent set to heed commands.\"},"
                                   "{d.set_ignore_commands=1, print=\"Torrent set to ignore commands.\"}");
+  m_bindings['B'-'@']= sigc::bind(sigc::mem_fun(*this, &ElementDownloadList::receive_command),
+                                  "branch=d.is_active=,"
+                                  "{print=\"Cannot enable initial seeding on an active download.\"},"
+                                  "{d.set_connection_seed=initial_seed, print=\"Enabled initial seeding for the selected download.\"}");
 
   m_bindings['U']    = sigc::bind(sigc::mem_fun(*this, &ElementDownloadList::receive_command), "d.delete_tied=; print=\"Cleared tied to file association for the selected download.\"");