get pdiff files from the same mirror as the index

In ad9416611ab83f7799f2dcb4bf7f3ef30e9fe6f8 we fall back to asking the
original mirror (e.g. a redirector) if we do not get the expected
result. This works for the indexes, but patches are a different beast
and much simpler. Adding this fallback code here seems like overkill as
they are usually right along their Index file, so actually forward the
relevant settings to the patch items which fixes pdiff support combined
with a redirector and partial mirrors as in such a situation the pdiff
patches would be 404 and the complete index would be downloaded.

diff --git a/apt-pkg/acquire-item.cc b/apt-pkg/acquire-item.cc
index 154b9a16e8e08e72c3dd9ac34665b608610853c8..6a809a1c68620263b5d32137979aba4436a586a3 100644 (file)
--- a/apt-pkg/acquire-item.cc
+++ b/apt-pkg/acquire-item.cc
@@ -1021,9 +1021,7 @@ bool pkgAcquire::Item::IsRedirectionLoop(std::string const &NewURI)       /*{{{*/
    return false;
 }
                                                                        /*}}}*/
    return false;
 }
                                                                        /*}}}*/

-
-                                                                                                                                               /*}}}*/
-int pkgAcquire::Item::Priority()                               /*{{{*/
+int pkgAcquire::Item::Priority()                                       /*{{{*/

 {
    // Stage 1: Meta indices and diff indices
    // - those need to be fetched first to have progress reporting working
 {
    // Stage 1: Meta indices and diff indices
    // - those need to be fetched first to have progress reporting working


@@ -2039,7 +2037,7 @@ void pkgAcqDiffIndex::QueueOnIMSHit() const                               /*{{{*/
 {
    // list cleanup needs to know that this file as well as the already
    // present index is ours, so we create an empty diff to save it for us
 {
    // list cleanup needs to know that this file as well as the already
    // present index is ours, so we create an empty diff to save it for us

-   new pkgAcqIndexDiffs(Owner, TransactionManager, Target);
+   new pkgAcqIndexDiffs(Owner, TransactionManager, Target, UsedMirror, Target.URI);

 }
                                                                        /*}}}*/
 static bool RemoveFileForBootstrapLinking(bool const Debug, std::string const &For, std::string const &Boot)/*{{{*/
 }
                                                                        /*}}}*/
 static bool RemoveFileForBootstrapLinking(bool const Debug, std::string const &For, std::string const &Boot)/*{{{*/


@@ -2415,14 +2413,26 @@ bool pkgAcqDiffIndex::ParseDiffIndex(string const &IndexDiffFile)       /*{{{*/
       }
    }
 
       }
    }
 

+   std::string indexURI = Desc.URI;
+   auto const byhashidx = indexURI.find("/by-hash/");
+   if (byhashidx != std::string::npos)
+      indexURI = indexURI.substr(0, byhashidx - strlen(".diff"));
+   else
+   {
+      auto end = indexURI.length() - strlen(".diff/Index");
+      if (CurrentCompressionExtension != "uncompressed")
+        end -= (1 + CurrentCompressionExtension.length());
+      indexURI = indexURI.substr(0, end);
+   }
+

    if (pdiff_merge == false)
    if (pdiff_merge == false)

-      new pkgAcqIndexDiffs(Owner, TransactionManager, Target, available_patches);
+      new pkgAcqIndexDiffs(Owner, TransactionManager, Target, UsedMirror, indexURI, available_patches);

    else
    {
       diffs = new std::vector<pkgAcqIndexMergeDiffs*>(available_patches.size());
       for(size_t i = 0; i < available_patches.size(); ++i)
         (*diffs)[i] = new pkgAcqIndexMergeDiffs(Owner, TransactionManager,
    else
    {
       diffs = new std::vector<pkgAcqIndexMergeDiffs*>(available_patches.size());
       for(size_t i = 0; i < available_patches.size(); ++i)
         (*diffs)[i] = new pkgAcqIndexMergeDiffs(Owner, TransactionManager,

-               Target,
+               Target, UsedMirror, indexURI,

               available_patches[i],
               diffs);
    }
               available_patches[i],
               diffs);
    }


@@ -2492,8 +2502,9 @@ pkgAcqDiffIndex::~pkgAcqDiffIndex()
 pkgAcqIndexDiffs::pkgAcqIndexDiffs(pkgAcquire * const Owner,
                                    pkgAcqMetaClearSig * const TransactionManager,
                                    IndexTarget const &Target,
 pkgAcqIndexDiffs::pkgAcqIndexDiffs(pkgAcquire * const Owner,
                                    pkgAcqMetaClearSig * const TransactionManager,
                                    IndexTarget const &Target,

+                                  std::string const &indexUsedMirror, std::string const &indexURI,

                                   vector<DiffInfo> const &diffs)
                                   vector<DiffInfo> const &diffs)

-   : pkgAcqBaseIndex(Owner, TransactionManager, Target), d(NULL),
+   : pkgAcqBaseIndex(Owner, TransactionManager, Target), indexURI(indexURI),

      available_patches(diffs)
 {
    DestFile = GetKeepCompressedFileName(GetPartialFileNameFromURI(Target.URI), Target);
      available_patches(diffs)
 {
    DestFile = GetKeepCompressedFileName(GetPartialFileNameFromURI(Target.URI), Target);


@@ -2504,6 +2515,12 @@ pkgAcqIndexDiffs::pkgAcqIndexDiffs(pkgAcquire * const Owner,
    Description = Target.Description;
    Desc.ShortDesc = Target.ShortDesc;
 
    Description = Target.Description;
    Desc.ShortDesc = Target.ShortDesc;
 

+   UsedMirror = indexUsedMirror;
+   if (UsedMirror == "DIRECT")
+      UsedMirror.clear();
+   else if (UsedMirror.empty() == false && Description.find(" ") != string::npos)
+      Description.replace(0, Description.find(" "), UsedMirror);
+

    if(available_patches.empty() == true)
    {
       // we are done (yeah!), check hashes against the final file
    if(available_patches.empty() == true)
    {
       // we are done (yeah!), check hashes against the final file


@@ -2618,7 +2635,7 @@ bool pkgAcqIndexDiffs::QueueNextDiff()                                    /*{{{*/
    }
 
    // queue the right diff
    }
 
    // queue the right diff

-   Desc.URI = Target.URI + ".diff/" + available_patches[0].file + ".gz";
+   Desc.URI = indexURI + ".diff/" + available_patches[0].file + ".gz";

    Desc.Description = Description + " " + available_patches[0].file + string(".pdiff");
    DestFile = GetKeepCompressedFileName(GetPartialFileNameFromURI(Target.URI + ".diff/" + available_patches[0].file), Target);
 
    Desc.Description = Description + " " + available_patches[0].file + string(".pdiff");
    DestFile = GetKeepCompressedFileName(GetPartialFileNameFromURI(Target.URI + ".diff/" + available_patches[0].file), Target);
 


@@ -2671,7 +2688,7 @@ void pkgAcqIndexDiffs::Done(string const &Message, HashStringList const &Hashes,
         // see if there is more to download
         if(available_patches.empty() == false)
         {
         // see if there is more to download
         if(available_patches.empty() == false)
         {

-           new pkgAcqIndexDiffs(Owner, TransactionManager, Target, available_patches);
+           new pkgAcqIndexDiffs(Owner, TransactionManager, Target, UsedMirror, indexURI, available_patches);

            Finish();
         } else {
            DestFile = PatchedFile;
            Finish();
         } else {
            DestFile = PatchedFile;


@@ -2700,19 +2717,26 @@ pkgAcqIndexDiffs::~pkgAcqIndexDiffs() {}
 pkgAcqIndexMergeDiffs::pkgAcqIndexMergeDiffs(pkgAcquire * const Owner,
                                              pkgAcqMetaClearSig * const TransactionManager,
                                              IndexTarget const &Target,
 pkgAcqIndexMergeDiffs::pkgAcqIndexMergeDiffs(pkgAcquire * const Owner,
                                              pkgAcqMetaClearSig * const TransactionManager,
                                              IndexTarget const &Target,

+                                            std::string const &indexUsedMirror, std::string const &indexURI,

                                              DiffInfo const &patch,
                                              std::vector<pkgAcqIndexMergeDiffs*> const * const allPatches)
                                              DiffInfo const &patch,
                                              std::vector<pkgAcqIndexMergeDiffs*> const * const allPatches)

-  : pkgAcqBaseIndex(Owner, TransactionManager, Target), d(NULL),
-     patch(patch), allPatches(allPatches), State(StateFetchDiff)
+  : pkgAcqBaseIndex(Owner, TransactionManager, Target), indexURI(indexURI),
+    patch(patch), allPatches(allPatches), State(StateFetchDiff)

 {
    Debug = _config->FindB("Debug::pkgAcquire::Diffs",false);
 
 {
    Debug = _config->FindB("Debug::pkgAcquire::Diffs",false);
 

-   Desc.Owner = this;

    Description = Target.Description;
    Description = Target.Description;

+   UsedMirror = indexUsedMirror;
+   if (UsedMirror == "DIRECT")
+      UsedMirror.clear();
+   else if (UsedMirror.empty() == false && Description.find(" ") != string::npos)
+      Description.replace(0, Description.find(" "), UsedMirror);
+
+   Desc.Owner = this;

    Desc.ShortDesc = Target.ShortDesc;
    Desc.ShortDesc = Target.ShortDesc;

-   Desc.URI = Target.URI + ".diff/" + patch.file + ".gz";
+   Desc.URI = indexURI + ".diff/" + patch.file + ".gz";

    Desc.Description = Description + " " + patch.file + ".pdiff";
    Desc.Description = Description + " " + patch.file + ".pdiff";

-   DestFile = GetPartialFileNameFromURI(Desc.URI);
+   DestFile = GetPartialFileNameFromURI(Target.URI + ".diff/" + patch.file + ".gz");

 
    if(Debug)
       std::clog << "pkgAcqIndexMergeDiffs: " << Desc.URI << std::endl;
 
    if(Debug)
       std::clog << "pkgAcqIndexMergeDiffs: " << Desc.URI << std::endl;

diff --git a/apt-pkg/acquire-item.h b/apt-pkg/acquire-item.h
index 26e1a192245a164e4403c753be5f247f3e3230c3..8be8801bf1687e44ff14816f9800e33267c78290 100644 (file)
--- a/apt-pkg/acquire-item.h
+++ b/apt-pkg/acquire-item.h
@@ -779,7 +779,7 @@ struct APT_HIDDEN DiffInfo {                                                /*{{{*/
  */
 class APT_HIDDEN pkgAcqIndexMergeDiffs : public pkgAcqBaseIndex
 {
  */
 class APT_HIDDEN pkgAcqIndexMergeDiffs : public pkgAcqBaseIndex
 {

-   void * const d;
+   std::string const indexURI;

 
    protected:
 
 
    protected:
 


@@ -830,23 +830,19 @@ class APT_HIDDEN pkgAcqIndexMergeDiffs : public pkgAcqBaseIndex
    /** \brief Create an index merge-diff item.
     *
     *  \param Owner The pkgAcquire object that owns this item.
    /** \brief Create an index merge-diff item.
     *
     *  \param Owner The pkgAcquire object that owns this item.

-    *
-    *  \param URI The URI of the package index file being
-    *  reconstructed.
-    *
-    *  \param URIDesc A long description of this item.
-    *
-    *  \param ShortDesc A brief description of this item.
-    *
+    *  \param TransactionManager responsible for this item
+    *  \param Target we intend to built via pdiff patching
+    *  \param baseURI is the URI used for the Index, but stripped down to Target
+    *  \param DiffInfo of the patch in question

     *  \param patch contains infos about the patch this item is supposed
     *  to download which were read from the index
     *  \param patch contains infos about the patch this item is supposed
     *  to download which were read from the index

-    *

     *  \param allPatches contains all related items so that each item can
     *  check if it was the last one to complete the download step
     */
    pkgAcqIndexMergeDiffs(pkgAcquire * const Owner, pkgAcqMetaClearSig * const TransactionManager,
     *  \param allPatches contains all related items so that each item can
     *  check if it was the last one to complete the download step
     */
    pkgAcqIndexMergeDiffs(pkgAcquire * const Owner, pkgAcqMetaClearSig * const TransactionManager,

-                         IndexTarget const &Target, DiffInfo const &patch,
-                         std::vector<pkgAcqIndexMergeDiffs*> const * const allPatches) APT_NONNULL(2, 3, 6);
+                        IndexTarget const &Target, std::string const &indexUsedMirror,
+                        std::string const &indexURI, DiffInfo const &patch,
+                         std::vector<pkgAcqIndexMergeDiffs*> const * const allPatches) APT_NONNULL(2, 3, 8);

    virtual ~pkgAcqIndexMergeDiffs();
 };
                                                                        /*}}}*/
    virtual ~pkgAcqIndexMergeDiffs();
 };
                                                                        /*}}}*/


@@ -863,7 +859,7 @@ class APT_HIDDEN pkgAcqIndexMergeDiffs : public pkgAcqBaseIndex
  */
 class APT_HIDDEN pkgAcqIndexDiffs : public pkgAcqBaseIndex
 {
  */
 class APT_HIDDEN pkgAcqIndexDiffs : public pkgAcqBaseIndex
 {

-   void * const d;
+   std::string const indexURI;

 
    private:
 
 
    private:
 


@@ -943,20 +939,16 @@ class APT_HIDDEN pkgAcqIndexDiffs : public pkgAcqBaseIndex
     *  \a diffs is empty, or QueueNextDiff() otherwise.
     *
     *  \param Owner The pkgAcquire object that owns this item.
     *  \a diffs is empty, or QueueNextDiff() otherwise.
     *
     *  \param Owner The pkgAcquire object that owns this item.

-    *
-    *  \param URI The URI of the package index file being
-    *  reconstructed.
-    *
-    *  \param URIDesc A long description of this item.
-    *
-    *  \param ShortDesc A brief description of this item.
-    *
+    *  \param TransactionManager responsible for this item
+    *  \param Target we want to built via pdiff patching
+    *  \param baseURI is the URI used for the Index, but stripped down to Target

     *  \param diffs The remaining diffs from the index of diffs.  They
     *  should be ordered so that each diff appears before any diff
     *  that depends on it.
     */
    pkgAcqIndexDiffs(pkgAcquire * const Owner, pkgAcqMetaClearSig * const TransactionManager,
                     IndexTarget const &Target,
     *  \param diffs The remaining diffs from the index of diffs.  They
     *  should be ordered so that each diff appears before any diff
     *  that depends on it.
     */
    pkgAcqIndexDiffs(pkgAcquire * const Owner, pkgAcqMetaClearSig * const TransactionManager,
                     IndexTarget const &Target,

+                   std::string const &indexUsedMirror, std::string const &indexURI,

                    std::vector<DiffInfo> const &diffs=std::vector<DiffInfo>()) APT_NONNULL(2, 3);
    virtual ~pkgAcqIndexDiffs();
 };
                    std::vector<DiffInfo> const &diffs=std::vector<DiffInfo>()) APT_NONNULL(2, 3);
    virtual ~pkgAcqIndexDiffs();
 };

diff --git a/apt-pkg/acquire.cc b/apt-pkg/acquire.cc
index 2ad6bc47f91c3a846ce658faeaab84acd37eda6c..9ceb507f6a3aebf90b9fb6735b1b6398c53baabf 100644 (file)
--- a/apt-pkg/acquire.cc
+++ b/apt-pkg/acquire.cc
@@ -1154,7 +1154,7 @@ APT_PURE unsigned long long pkgAcquire::Queue::QItem::GetMaximumSize() const      /*{
    return Maximum;
 }
                                                                        /*}}}*/
    return Maximum;
 }
                                                                        /*}}}*/

-APT_PURE int pkgAcquire::Queue::QItem::GetPriority() const     /*{{{*/
+APT_PURE int pkgAcquire::Queue::QItem::GetPriority() const             /*{{{*/

 {
    int Priority = 0;
    for (auto const &O: Owners)
 {
    int Priority = 0;
    for (auto const &O: Owners)