Changeset 13879

Timestamp:

Jan 26, 2013, 11:08:51 PM (8 years ago)

Author:

jordan

Message:

(libT) add package-visible API hook for when a block is downloaded. Add unit test to confirm that when the last file finishes downloading, its .part suffix is removed and it's moved from the incomplete to complete dir

Location:

trunk/libtransmission

Files:

• Makefile.am (modified) (2 diffs)
• libtransmission-test.c (modified) (2 diffs)
• libtransmission-test.h (modified) (1 diff)
• move-test.c (added)
• peer-mgr.c (modified) (4 diffs)
• peer-mgr.h (modified) (1 diff)
• rename-test.c (modified) (8 diffs)
• torrent.c (modified) (6 diffs)
• torrent.h (modified) (1 diff)

trunk/libtransmission/Makefile.am

@@ -135 +135 @@
   magnet-test \
   metainfo-test \
+  move-test \
   peer-msgs-test \
   quark-test \
@@ -195 +196 @@
 metainfo_test_LDFLAGS = ${apps_ldflags}
 
+move_test_SOURCES = move-test.c $(TEST_SOURCES)
+move_test_LDADD = ${apps_ldadd}
+move_test_LDFLAGS = ${apps_ldflags}
+
 peer_msgs_test_SOURCES = peer-msgs-test.c $(TEST_SOURCES)
 peer_msgs_test_LDADD = ${apps_ldadd}

trunk/libtransmission/libtransmission-test.c

@@ -3 +3 @@
 
 #include "transmission.h"
+#include "torrent.h"
 #include "libtransmission-test.h"
 
@@ -321 +322 @@
   return tor;
 }
+
+#define verify_and_block_until_done(tor) \
+  do { \
+    tr_torrentVerify (tor); \
+    do { \
+      tr_wait_msec (10); \
+    } while (tor->verifyState != TR_VERIFY_NONE); \
+  } while (0)
+
+
+void
+libtransmission_test_zero_torrent_populate (tr_torrent * tor, bool complete)
+{
+  tr_file_index_t i;
+
+  for (i=0; i<tor->info.fileCount; ++i)
+    {
+      int rv;
+      uint64_t j;
+      FILE * fp;
+      char * path;
+      char * dirname;
+      const tr_file * file = &tor->info.files[i];
+      struct stat sb;
+
+      path = tr_buildPath (tor->currentDir, file->name, NULL);
+      dirname = tr_dirname (path);
+      tr_mkdirp (dirname, 0700);
+      fp = fopen (path, "wb+");
+      for (j=0; j<file->length; ++j)
+        fputc ('\0', fp);
+      fclose (fp);
+
+      tr_free (dirname);
+      tr_free (path);
+
+      path = tr_torrentFindFile (tor, i);
+      assert (path != NULL);
+      rv = stat (path, &sb);
+      assert (rv == 0);
+      tr_free (path);
+    }
+
+  sync ();
+
+  if (!complete)
+    {
+      FILE * fp;
+      char * oldpath = tr_torrentFindFile (tor, 0);
+      char * newpath = tr_strdup_printf ("%s.part", oldpath);
+
+      rename (oldpath, newpath);
+
+      /* invalidate one piece */
+      fp = fopen (newpath, "rb+");
+      fputc ('\1', fp);
+      fclose (fp);
+
+      tr_free (newpath);
+      tr_free (oldpath);
+
+      sync ();
+      verify_and_block_until_done (tor);
+      assert (tr_torrentStat(tor)->leftUntilDone == tor->info.pieceSize);
+    }
+}

trunk/libtransmission/libtransmission-test.h

@@ -78 +78 @@
 
 void libtransmission_test_session_close (void);
+
+void         libtransmission_test_zero_torrent_populate (tr_torrent * tor, bool complete);
 tr_torrent * libtransmission_test_zero_torrent_init (void);
 

trunk/libtransmission/peer-mgr.c

@@ -1559 +1559 @@
 
 static void
-gotBadPiece (Torrent * t, tr_piece_index_t pieceIndex)
-{
-    tr_torrent *   tor = t->tor;
-    const uint32_t byteCount = tr_torPieceCountBytes (tor, pieceIndex);
-
-    tor->corruptCur += byteCount;
-    tor->downloadedCur -= MIN (tor->downloadedCur, byteCount);
-
-    tr_announcerAddBytes (tor, TR_ANN_CORRUPT, byteCount);
-}
-
-static void
 peerSuggestedPiece (Torrent            * t UNUSED,
                     tr_peer            * peer UNUSED,
@@ -1645 +1633 @@
 }
 
-static void tr_peerMgrSetBlame (tr_torrent *, tr_piece_index_t, int);
+static void
+cancelAllRequestsForBlock (struct tr_torrent_peers * t,
+                           tr_block_index_t          block,
+                           tr_peer                 * no_notify)
+{
+  int i;
+  int peerCount;
+  tr_peer ** peers;
+  tr_ptrArray peerArr;
+
+  peerArr = TR_PTR_ARRAY_INIT;
+  getBlockRequestPeers (t, block, &peerArr);
+  peers = (tr_peer **) tr_ptrArrayPeek (&peerArr, &peerCount);
+  for (i=0; i<peerCount; ++i)
+    {
+      tr_peer * p = peers[i];
+
+      if ((p != no_notify) && (p->msgs != NULL))
+        {
+          tr_historyAdd (&p->cancelsSentToPeer, tr_time (), 1);
+          tr_peerMsgsCancel (p->msgs, block);
+        }
+
+      removeRequestFromTables (t, block, p);
+    }
+
+  tr_ptrArrayDestruct (&peerArr, NULL);
+}
+
+void
+tr_peerMgrPieceCompleted (tr_torrent * tor, tr_piece_index_t p)
+{
+  int i;
+  int peerCount;
+  tr_peer ** peers;
+  struct tr_torrent_peers * t = tor->torrentPeers;
+
+  /* notify the peers that we now have this piece */
+  peerCount = tr_ptrArraySize (&t->peers);
+  peers = (tr_peer**) tr_ptrArrayBase (&t->peers);
+  for (i=0; i<peerCount; ++i)
+    tr_peerMsgsHave (peers[i]->msgs, p);
+
+  /* bookkeeping */
+  pieceListRemovePiece (t, p);
+  t->needsCompletenessCheck = true;
+}
 
 static void
@@ -1759 +1793 @@
 
         case TR_PEER_CLIENT_GOT_BLOCK:
-        {
-            tr_torrent * tor = t->tor;
-            tr_block_index_t block = _tr_block (tor, e->pieceIndex, e->offset);
-            int i, peerCount;
-            tr_peer ** peers;
-            tr_ptrArray peerArr = TR_PTR_ARRAY_INIT;
-
-            removeRequestFromTables (t, block, peer);
-            getBlockRequestPeers (t, block, &peerArr);
-            peers = (tr_peer **) tr_ptrArrayPeek (&peerArr, &peerCount);
-
-            /* remove additional block requests and send cancel to peers */
-            for (i=0; i<peerCount; i++) {
-                tr_peer * p = peers[i];
-                assert (p != peer);
-                if (p->msgs) {
-                    tr_historyAdd (&p->cancelsSentToPeer, tr_time (), 1);
-                    tr_peerMsgsCancel (p->msgs, block);
-                }
-                removeRequestFromTables (t, block, p);
-            }
-
-            tr_ptrArrayDestruct (&peerArr, false);
-
-            tr_historyAdd (&peer->blocksSentToClient, tr_time (), 1);
-
-            if (tr_cpBlockIsComplete (&tor->completion, block))
-            {
-                /* we already have this block... */
-                const uint32_t n = tr_torBlockCountBytes (tor, block);
-                tor->downloadedCur -= MIN (tor->downloadedCur, n);
-                tordbg (t, "we have this block already...");
-            }
-            else
-            {
-                tr_cpBlockAdd (&tor->completion, block);
-                pieceListResortPiece (t, pieceListLookup (t, e->pieceIndex));
-                tr_torrentSetDirty (tor);
-
-                if (tr_cpPieceIsComplete (&tor->completion, e->pieceIndex))
-                {
-                    const tr_piece_index_t p = e->pieceIndex;
-                    const bool ok = tr_torrentCheckPiece (tor, p);
-
-                    tordbg (t, "[LAZY] checked just-completed piece %zu", (size_t)p);
-
-                    if (!ok)
-                    {
-                        tr_logAddTorErr (tor, _("Piece %lu, which was just downloaded, failed its checksum test"),
-                                 (unsigned long)p);
-                    }
-
-                    tr_peerMgrSetBlame (tor, p, ok);
-
-                    if (!ok)
-                    {
-                        gotBadPiece (t, p);
-                    }
-                    else
-                    {
-                        int i;
-                        int peerCount;
-                        tr_peer ** peers;
-                        tr_file_index_t fileIndex;
-
-                        /* only add this to downloadedCur if we got it from a peer --
-                         * webseeds shouldn't count against our ratio. As one tracker
-                         * admin put it, "Those pieces are downloaded directly from the
-                         * content distributor, not the peers, it is the tracker's job
-                         * to manage the swarms, not the web server and does not fit
-                         * into the jurisdiction of the tracker." */
-                        if (peer->msgs != NULL) {
-                            const uint32_t n = tr_torPieceCountBytes (tor, p);
-                            tr_announcerAddBytes (tor, TR_ANN_DOWN, n);
-                        }
-
-                        peerCount = tr_ptrArraySize (&t->peers);
-                        peers = (tr_peer**) tr_ptrArrayBase (&t->peers);
-                        for (i=0; i<peerCount; ++i)
-                            tr_peerMsgsHave (peers[i]->msgs, p);
-
-                        for (fileIndex=0; fileIndex<tor->info.fileCount; ++fileIndex) {
-                            const tr_file * file = &tor->info.files[fileIndex];
-                            if ((file->firstPiece <= p) && (p <= file->lastPiece)) {
-                                if (tr_cpFileIsComplete (&tor->completion, fileIndex)) {
-                                    tr_cacheFlushFile (tor->session->cache, tor, fileIndex);
-                                    tr_torrentFileCompleted (tor, fileIndex);
-                                }
-                            }
-                        }
-
-                        pieceListRemovePiece (t, p);
-                    }
-                }
-
-                t->needsCompletenessCheck = true;
-            }
+          {
+            const tr_block_index_t block = _tr_block (t->tor, e->pieceIndex, e->offset);
+            cancelAllRequestsForBlock (t, block, peer);
+            tr_historyAdd (&peer->blocksSentToClient, tr_time(), 1);
+            pieceListResortPiece (t, pieceListLookup (t, e->pieceIndex));
+            tr_torrentGotBlock (t->tor, block);
             break;
-        }
+          }
 
         case TR_PEER_ERROR:
@@ -2232 +2175 @@
 **/
 
-static void
-tr_peerMgrSetBlame (tr_torrent     * tor,
-                    tr_piece_index_t pieceIndex,
-                    int              success)
-{
-    if (!success)
-    {
-        int        peerCount, i;
-        Torrent *  t = tor->torrentPeers;
-        tr_peer ** peers;
-
-        assert (torrentIsLocked (t));
-
-        peers = (tr_peer **) tr_ptrArrayPeek (&t->peers, &peerCount);
-        for (i = 0; i < peerCount; ++i)
+void
+tr_peerMgrGotBadPiece (tr_torrent * tor, tr_piece_index_t pieceIndex)
+{
+  int i;
+  int n;
+  Torrent * t = tor->torrentPeers;
+  const uint32_t byteCount = tr_torPieceCountBytes (tor, pieceIndex);
+
+  for (i=0, n=tr_ptrArraySize(&t->peers); i!=n; ++i)
+    {
+      tr_peer * peer = tr_ptrArrayNth (&t->peers, i);
+
+      if (tr_bitfieldHas (&peer->blame, pieceIndex))
         {
-            tr_peer * peer = peers[i];
-            if (tr_bitfieldHas (&peer->blame, pieceIndex))
-            {
-                tordbg (t, "peer %s contributed to corrupt piece (%d); now has %d strikes",
-                        tr_atomAddrStr (peer->atom),
-                        pieceIndex, (int)peer->strikes + 1);
-                addStrike (t, peer);
-            }
+          tordbg (t, "peer %s contributed to corrupt piece (%d); now has %d strikes",
+                  tr_atomAddrStr(peer->atom), pieceIndex, (int)peer->strikes + 1);
+          addStrike (t, peer);
         }
     }
+
+
+  tr_announcerAddBytes (tor, TR_ANN_CORRUPT, byteCount);
 }
 

trunk/libtransmission/peer-mgr.h

@@ -256 +256 @@
 void tr_peerMgrClearInterest (tr_torrent * tor);
 
+void tr_peerMgrGotBadPiece (tr_torrent * tor, tr_piece_index_t pieceIndex);
+
+void tr_peerMgrPieceCompleted (tr_torrent * tor, tr_piece_index_t pieceIndex);
+ 
+
+
 /* @} */
 

trunk/libtransmission/rename-test.c

@@ -188 +188 @@
   check_have_none (tor, totalSize);
 
-  create_single_file_torrent_contents (tor->downloadDir);
+  create_single_file_torrent_contents (tor->currentDir);
 
   /* sanity check the stats again, now that we've added the file */
@@ -215 +215 @@
   ***/
 
-  tmpstr = tr_buildPath (tor->downloadDir, "hello-world.txt", NULL); 
+  tmpstr = tr_buildPath (tor->currentDir, "hello-world.txt", NULL); 
   check (tr_fileExists (tmpstr, NULL));
   check_streq ("hello-world.txt", tr_torrentName(tor));
@@ -238 +238 @@
   ***/
 
-  tmpstr = tr_buildPath (tor->downloadDir, "foobar", NULL); 
+  tmpstr = tr_buildPath (tor->currentDir, "foobar", NULL); 
   check (tr_fileExists (tmpstr, NULL));
   check_int_eq (0, torrentRenameAndWait (tor, "foobar", "hello-world.txt"));
@@ -334 +334 @@
 
   /* build the local data */
-  create_multifile_torrent_contents (tor->downloadDir);
+  create_multifile_torrent_contents (tor->currentDir);
 
   /* sanity check the (full) stats */
@@ -396 +396 @@
 
   /* remove the directory Felidae/Felinae/Felis/catus */
-  str = tr_buildPath (tor->downloadDir, files[1].name, NULL);
+  str = tr_buildPath (tor->currentDir, files[1].name, NULL);
   remove (str);
   tr_free (str);
-  str = tr_buildPath (tor->downloadDir, files[2].name, NULL);
+  str = tr_buildPath (tor->currentDir, files[2].name, NULL);
   remove (str);
   tmp = tr_dirname (str);
@@ -462 +462 @@
 ***/
 
-static void
-create_zero_torrent_partial_contents (tr_torrent * tor, bool incomplete)
-{
-  tr_file_index_t i;
-
-  for (i=0; i<tor->info.fileCount; ++i)
-    {
-      int rv;
-      uint64_t j;
-      FILE * fp;
-      char * path;
-      char * dirname;
-      const tr_file * file = &tor->info.files[i];
-      struct stat sb;
-
-      path = tr_buildPath (tor->downloadDir, file->name, NULL);
-      dirname = tr_dirname (path);
-      tr_mkdirp (dirname, 0700);
-      fp = fopen (path, "wb+");
-      for (j=0; j<file->length; ++j)
-        fputc ('\0', fp);
-      fclose (fp);
-
-      tr_free (dirname);
-      tr_free (path);
-
-      path = tr_torrentFindFile (tor, i);
-      assert (path != NULL);
-      rv = stat (path, &sb);
-      assert (rv == 0);
-      tr_free (path);
-    }
-
-  sync ();
-  verify_and_block_until_done (tor);
-  assert (tr_torrentStat(tor)->leftUntilDone == 0);
-
-  if (incomplete)
-    {
-      FILE * fp;
-      char * oldpath = tr_torrentFindFile (tor, 0);
-      char * newpath = tr_strdup_printf ("%s.part", oldpath);
-
-      rename (oldpath, newpath);
-
-      /* invalidate one piece */
-      fp = fopen (newpath, "rb+");
-      fputc ('\1', fp);
-      fclose (fp);
-
-      tr_free (newpath);
-      tr_free (oldpath);
-
-      sync ();
-      verify_and_block_until_done (tor);
-      assert (tr_torrentStat(tor)->leftUntilDone == tor->info.pieceSize);
-    }
-}
-
 static int
 test_partial_file (void)
@@ -546 +487 @@
   check_streq ("files-filled-with-zeroes/512",     tor->info.files[2].name);
 
-  create_zero_torrent_partial_contents (tor, true);
+  libtransmission_test_zero_torrent_populate (tor, false);
   fst = tr_torrentFiles (tor, NULL);
   check_int_eq (length[0] - pieceSize, fst[0].bytesCompleted);
@@ -573 +514 @@
   for (i=0; i<3; ++i)
     {
-      char * expected = tr_buildPath (tor->downloadDir, strings[i], NULL);
+      char * expected = tr_buildPath (tor->currentDir, strings[i], NULL);
       char * path = tr_torrentFindFile (tor, i);
       check_streq (expected, path);

trunk/libtransmission/torrent.c

@@ -1329 +1329 @@
 
 static uint64_t
-fileBytesCompleted (const tr_torrent * tor, tr_file_index_t index)
+countFileBytesCompleted (const tr_torrent * tor, tr_file_index_t index)
 {
     uint64_t total = 0;
@@ -1380 +1380 @@
 
     for (i=0; i<n; ++i, ++walk) {
-        const uint64_t b = isSeed ? tor->info.files[i].length : fileBytesCompleted (tor, i);
+        const uint64_t b = isSeed ? tor->info.files[i].length : countFileBytesCompleted (tor, i);
         walk->bytesCompleted = b;
         walk->progress = tor->info.files[i].length > 0 ? ((float)b / tor->info.files[i].length) : 1.0f;
@@ -3001 +3001 @@
 ***/
 
-void
-tr_torrentFileCompleted (tr_torrent * tor, tr_file_index_t fileNum)
+static void
+tr_torrentFileCompleted (tr_torrent * tor, tr_file_index_t fileIndex)
 {
     char * sub;
     const char * base;
     const tr_info * inf = &tor->info;
-    const tr_file * f = &inf->files[fileNum];
+    const tr_file * f = &inf->files[fileIndex];
     tr_piece * p;
     const tr_piece * pend;
@@ -3013 +3013 @@
 
     /* close the file so that we can reopen in read-only mode as needed */
-    tr_fdFileClose (tor->session, tor, fileNum);
+    tr_cacheFlushFile (tor->session->cache, tor, fileIndex);
+    tr_fdFileClose (tor->session, tor, fileIndex);
 
     /* now that the file is complete and closed, we can start watching its
@@ -3023 +3024 @@
      * metadata -- for example, if it had the ".part" suffix appended to
      * it until now -- then rename it to match the one in the metadata */
-    if (tr_torrentFindFile2 (tor, fileNum, &base, &sub, NULL))
+    if (tr_torrentFindFile2 (tor, fileIndex, &base, &sub, NULL))
     {
         if (strcmp (sub, f->name))
@@ -3038 +3039 @@
 
         tr_free (sub);
+    }
+}
+
+static void
+tr_torrentPieceCompleted (tr_torrent * tor, tr_piece_index_t pieceIndex)
+{
+  tr_file_index_t i;
+
+  tr_peerMgrPieceCompleted (tor, pieceIndex);
+
+  /* if this piece completes any file, invoke the fileCompleted func for it */
+  for (i=0; i<tor->info.fileCount; ++i)
+    {
+      const tr_file * file = &tor->info.files[i];
+
+      if ((file->firstPiece <= pieceIndex) && (pieceIndex <= file->lastPiece))
+        if (tr_cpFileIsComplete (&tor->completion, i))
+          tr_torrentFileCompleted (tor, i);
+    }
+}
+
+void
+tr_torrentGotBlock (tr_torrent * tor, tr_block_index_t block)
+{
+  const bool block_is_new = !tr_cpBlockIsComplete (&tor->completion, block);
+
+  if (block_is_new)
+    {
+      tr_piece_index_t p;
+
+      tr_cpBlockAdd (&tor->completion, block);
+      tr_torrentSetDirty (tor);
+
+      p = tr_torBlockPiece (tor, block);
+      if (tr_cpPieceIsComplete (&tor->completion, p))
+        {
+          tr_logAddTorDbg (tor, "[LAZY] checking just-completed piece %zu", (size_t)p);
+
+          if (tr_torrentCheckPiece (tor, p))
+            {
+              tr_torrentPieceCompleted (tor, p);
+            }
+          else
+            {
+              const uint32_t n = tr_torPieceCountBytes (tor, p);
+              tr_logAddTorErr (tor, _("Piece %"PRIu32", which was just downloaded, failed its checksum test"), p);
+              tor->corruptCur += n;
+              tor->downloadedCur -= MIN (tor->downloadedCur, n);
+              tr_peerMgrGotBadPiece (tor, p);
+            }
+        }
+    }
+  else
+    {
+      const uint32_t n = tr_torBlockCountBytes (tor, block);
+      tor->downloadedCur -= MIN (tor->downloadedCur, n);
+      tr_logAddTorDbg (tor, "we have this block already...");
     }
 }

trunk/libtransmission/torrent.h

@@ -383 +383 @@
 
 /**
- * Tell the tr_torrent that one of its files has become complete
+ * Tell the tr_torrent that it's gotten a block
  */
-void tr_torrentFileCompleted (tr_torrent * tor, tr_file_index_t fileNo);
+void tr_torrentGotBlock (tr_torrent * tor, tr_block_index_t blockIndex);
+