Rework TransactionID stuff

[apt.git] / apt-pkg / acquire.cc

diff --git a/apt-pkg/acquire.cc b/apt-pkg/acquire.cc
index 2064abc5031d8005b8af2dcae02819c5f4171f51..33afd8f1f8ffc37aee1b760ece99f07317bfe22a 100644 (file)
--- a/apt-pkg/acquire.cc
+++ b/apt-pkg/acquire.cc
@@ -5,14 +5,16 @@
 
    Acquire - File Acquiration
 
 
    Acquire - File Acquiration
 

-   The core element for the schedual system is the concept of a named
+   The core element for the schedule system is the concept of a named

    queue. Each queue is unique and each queue has a name derived from the
    queue. Each queue is unique and each queue has a name derived from the

-   URI. The degree of paralization can be controled by how the queue
+   URI. The degree of paralization can be controlled by how the queue

    name is derived from the URI.
    
    ##################################################################### */
                                                                        /*}}}*/
 // Include Files                                                       /*{{{*/
    name is derived from the URI.
    
    ##################################################################### */
                                                                        /*}}}*/
 // Include Files                                                       /*{{{*/

+#include <config.h>
+

 #include <apt-pkg/acquire.h>
 #include <apt-pkg/acquire-item.h>
 #include <apt-pkg/acquire-worker.h>
 #include <apt-pkg/acquire.h>
 #include <apt-pkg/acquire-item.h>
 #include <apt-pkg/acquire-worker.h>


@@ -21,15 +23,23 @@
 #include <apt-pkg/strutl.h>
 #include <apt-pkg/fileutl.h>
 
 #include <apt-pkg/strutl.h>
 #include <apt-pkg/fileutl.h>
 

-#include <apti18n.h>
-
+#include <string>
+#include <vector>

 #include <iostream>
 #include <sstream>
 #include <stdio.h>
 #include <iostream>
 #include <sstream>
 #include <stdio.h>

+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <iomanip>

 
 #include <dirent.h>
 #include <sys/time.h>
 
 #include <dirent.h>
 #include <sys/time.h>

+#include <sys/select.h>

 #include <errno.h>
 #include <errno.h>

+#include <sys/stat.h>
+
+#include <apti18n.h>

                                                                        /*}}}*/
 
 using namespace std;
                                                                        /*}}}*/
 
 using namespace std;


@@ -116,7 +126,7 @@ pkgAcquire::~pkgAcquire()
 /* */
 void pkgAcquire::Shutdown()
 {
 /* */
 void pkgAcquire::Shutdown()
 {

-   while (Items.size() != 0)
+   while (Items.empty() == false)

    {
       if (Items[0]->Status == Item::StatFetching)
          Items[0]->Status = Item::StatError;
    {
       if (Items[0]->Status == Item::StatFetching)
          Items[0]->Status = Item::StatError;


@@ -155,10 +165,78 @@ void pkgAcquire::Remove(Item *Itm)
         I = Items.begin();
       }      
       else 
         I = Items.begin();
       }      
       else 

-        I++;
+        ++I;
+   }
+}
+                                                                       /*}}}*/
+// Acquire::AbortTransaction - Remove a transaction                    /*{{{*/
+void pkgAcquire::AbortTransaction(unsigned long TransactionID)
+{
+   if(_config->FindB("Debug::Acquire::Transaction", false) == true)
+      std::clog << "AbortTransaction: " << TransactionID << std::endl;
+
+   std::vector<Item*> Transaction;
+   for (ItemIterator I = Items.begin(); I != Items.end(); ++I)
+      if((*I)->TransactionID == TransactionID)
+         Transaction.push_back(*I);
+   
+   for (std::vector<Item*>::iterator I = Transaction.begin();
+        I != Transaction.end(); ++I)
+   {
+      if(_config->FindB("Debug::Acquire::Transaction", false) == true)
+         std::clog << "  Cancel: " << (*I)->DestFile << std::endl;
+      //Dequeue(*I);
+      (*I)->Status = pkgAcquire::Item::StatError;
+   }
+}
+                                                                       /*}}}*/
+bool pkgAcquire::TransactionHasError(unsigned long TransactionID)
+{
+   std::vector<Item*> Transaction;
+   for (ItemIterator I = Items.begin(); I != Items.end(); ++I)
+      if((*I)->TransactionID == TransactionID)
+         if((*I)->Status == pkgAcquire::Item::StatError ||
+            (*I)->Status == pkgAcquire::Item::StatAuthError)
+            return true;
+
+   return false;
+}
+// Acquire::CommitTransaction - Commit a transaction                   /*{{{*/
+void pkgAcquire::CommitTransaction(unsigned long TransactionID)
+{
+   if(_config->FindB("Debug::Acquire::Transaction", false) == true)
+      std::clog << "CommitTransaction: " << TransactionID << std::endl;
+
+   std::vector<Item*> Transaction;
+   for (ItemIterator I = Items.begin(); I != Items.end(); ++I)
+      if((*I)->TransactionID == TransactionID)
+         Transaction.push_back(*I);
+   
+   // move new files into place *and* remove files that are not
+   // part of the transaction but are still on disk
+   for (std::vector<Item*>::iterator I = Transaction.begin();
+        I != Transaction.end(); ++I)
+   {
+      if((*I)->PartialFile != "")
+      {
+         if(_config->FindB("Debug::Acquire::Transaction", false) == true)
+            std::clog << "mv " 
+                      << (*I)->PartialFile << " -> " 
+                      <<  (*I)->DestFile << std::endl;
+         Rename((*I)->PartialFile, (*I)->DestFile);
+         chmod((*I)->DestFile.c_str(),0644);
+      } else {
+         if(_config->FindB("Debug::Acquire::Transaction", false) == true)
+            std::clog << "rm " 
+                      <<  (*I)->DestFile << std::endl;
+         unlink((*I)->DestFile.c_str());
+      }
+      // mark that this transaction is finished
+      (*I)->TransactionID = 0;

    }
 }
                                                                        /*}}}*/
    }
 }
                                                                        /*}}}*/

+

 // Acquire::Add - Add a worker                                         /*{{{*/
 // ---------------------------------------------------------------------
 /* A list of workers is kept so that the select loop can direct their FD
 // Acquire::Add - Add a worker                                         /*{{{*/
 // ---------------------------------------------------------------------
 /* A list of workers is kept so that the select loop can direct their FD


@@ -173,7 +251,7 @@ void pkgAcquire::Add(Worker *Work)
 // ---------------------------------------------------------------------
 /* A worker has died. This can not be done while the select loop is running
    as it would require that RunFds could handling a changing list state and
 // ---------------------------------------------------------------------
 /* A worker has died. This can not be done while the select loop is running
    as it would require that RunFds could handling a changing list state and

-   it cant.. */
+   it can't.. */

 void pkgAcquire::Remove(Worker *Work)
 {
    if (Running == true)
 void pkgAcquire::Remove(Worker *Work)
 {
    if (Running == true)


@@ -242,11 +320,19 @@ void pkgAcquire::Dequeue(Item *Itm)
 {
    Queue *I = Queues;
    bool Res = false;
 {
    Queue *I = Queues;
    bool Res = false;

-   for (; I != 0; I = I->Next)
-      Res |= I->Dequeue(Itm);
-   

    if (Debug == true)
       clog << "Dequeuing " << Itm->DestFile << endl;
    if (Debug == true)
       clog << "Dequeuing " << Itm->DestFile << endl;

+
+   for (; I != 0; I = I->Next)
+   {
+      if (I->Dequeue(Itm))
+      {
+         Res = true;
+        if (Debug == true)
+           clog << "Dequeued from " << I->Name << endl;
+      }
+   }
+

    if (Res == true)
       ToFetch--;
 }
    if (Res == true)
       ToFetch--;
 }


@@ -267,9 +353,30 @@ string pkgAcquire::QueueName(string Uri,MethodConfig const *&Config)
    /* Single-Instance methods get exactly one queue per URI. This is
       also used for the Access queue method  */
    if (Config->SingleInstance == true || QueueMode == QueueAccess)
    /* Single-Instance methods get exactly one queue per URI. This is
       also used for the Access queue method  */
    if (Config->SingleInstance == true || QueueMode == QueueAccess)

-       return U.Access;
+      return U.Access;
+
+   string AccessSchema = U.Access + ':',
+       FullQueueName = AccessSchema + U.Host;
+   unsigned int Instances = 0, SchemaLength = AccessSchema.length();
+
+   Queue *I = Queues;
+   for (; I != 0; I = I->Next) {
+      // if the queue already exists, re-use it
+      if (I->Name == FullQueueName)
+        return FullQueueName;
+
+      if (I->Name.compare(0, SchemaLength, AccessSchema) == 0)
+        Instances++;
+   }
+
+   if (Debug) {
+      clog << "Found " << Instances << " instances of " << U.Access << endl;
+   }
+
+   if (Instances >= (unsigned int)_config->FindI("Acquire::QueueHost::Limit",10))
+      return U.Access;

 
 

-   return U.Access + ':' + U.Host;
+   return FullQueueName;

 }
                                                                        /*}}}*/
 // Acquire::GetConfig - Fetch the configuration information            /*{{{*/
 }
                                                                        /*}}}*/
 // Acquire::GetConfig - Fetch the configuration information            /*{{{*/


@@ -411,7 +518,7 @@ pkgAcquire::RunResult pkgAcquire::Run(int PulseIntervall)
       I->Shutdown(false);
 
    // Shut down the items
       I->Shutdown(false);
 
    // Shut down the items

-   for (ItemIterator I = Items.begin(); I != Items.end(); I++)
+   for (ItemIterator I = Items.begin(); I != Items.end(); ++I)

       (*I)->Finished(); 
    
    if (_error->PendingError())
       (*I)->Finished(); 
    
    if (_error->PendingError())


@@ -437,7 +544,7 @@ void pkgAcquire::Bump()
 pkgAcquire::Worker *pkgAcquire::WorkerStep(Worker *I)
 {
    return I->NextAcquire;
 pkgAcquire::Worker *pkgAcquire::WorkerStep(Worker *I)
 {
    return I->NextAcquire;

-};
+}

                                                                        /*}}}*/
 // Acquire::Clean - Cleans a directory                                 /*{{{*/
 // ---------------------------------------------------------------------
                                                                        /*}}}*/
 // Acquire::Clean - Cleans a directory                                 /*{{{*/
 // ---------------------------------------------------------------------


@@ -445,6 +552,13 @@ pkgAcquire::Worker *pkgAcquire::WorkerStep(Worker *I)
    if it is part of the download set. */
 bool pkgAcquire::Clean(string Dir)
 {
    if it is part of the download set. */
 bool pkgAcquire::Clean(string Dir)
 {

+   // non-existing directories are by definition clean…
+   if (DirectoryExists(Dir) == false)
+      return true;
+
+   if(Dir == "/")
+      return _error->Error(_("Clean of %s is not supported"), Dir.c_str());
+

    DIR *D = opendir(Dir.c_str());   
    if (D == 0)
       return _error->Errno("opendir",_("Unable to read %s"),Dir.c_str());
    DIR *D = opendir(Dir.c_str());   
    if (D == 0)
       return _error->Errno("opendir",_("Unable to read %s"),Dir.c_str());


@@ -467,7 +581,7 @@ bool pkgAcquire::Clean(string Dir)
       
       // Look in the get list
       ItemCIterator I = Items.begin();
       
       // Look in the get list
       ItemCIterator I = Items.begin();

-      for (; I != Items.end(); I++)
+      for (; I != Items.end(); ++I)

         if (flNotDir((*I)->DestFile) == Dir->d_name)
            break;
       
         if (flNotDir((*I)->DestFile) == Dir->d_name)
            break;
       


@@ -485,10 +599,10 @@ bool pkgAcquire::Clean(string Dir)
 // Acquire::TotalNeeded - Number of bytes to fetch                     /*{{{*/
 // ---------------------------------------------------------------------
 /* This is the total number of bytes needed */
 // Acquire::TotalNeeded - Number of bytes to fetch                     /*{{{*/
 // ---------------------------------------------------------------------
 /* This is the total number of bytes needed */

-unsigned long long pkgAcquire::TotalNeeded()
+APT_PURE unsigned long long pkgAcquire::TotalNeeded()

 {
    unsigned long long Total = 0;
 {
    unsigned long long Total = 0;

-   for (ItemCIterator I = ItemsBegin(); I != ItemsEnd(); I++)
+   for (ItemCIterator I = ItemsBegin(); I != ItemsEnd(); ++I)

       Total += (*I)->FileSize;
    return Total;
 }
       Total += (*I)->FileSize;
    return Total;
 }


@@ -496,10 +610,10 @@ unsigned long long pkgAcquire::TotalNeeded()
 // Acquire::FetchNeeded - Number of bytes needed to get                        /*{{{*/
 // ---------------------------------------------------------------------
 /* This is the number of bytes that is not local */
 // Acquire::FetchNeeded - Number of bytes needed to get                        /*{{{*/
 // ---------------------------------------------------------------------
 /* This is the number of bytes that is not local */

-unsigned long long pkgAcquire::FetchNeeded()
+APT_PURE unsigned long long pkgAcquire::FetchNeeded()

 {
    unsigned long long Total = 0;
 {
    unsigned long long Total = 0;

-   for (ItemCIterator I = ItemsBegin(); I != ItemsEnd(); I++)
+   for (ItemCIterator I = ItemsBegin(); I != ItemsEnd(); ++I)

       if ((*I)->Local == false)
         Total += (*I)->FileSize;
    return Total;
       if ((*I)->Local == false)
         Total += (*I)->FileSize;
    return Total;


@@ -508,10 +622,10 @@ unsigned long long pkgAcquire::FetchNeeded()
 // Acquire::PartialPresent - Number of partial bytes we already have   /*{{{*/
 // ---------------------------------------------------------------------
 /* This is the number of bytes that is not local */
 // Acquire::PartialPresent - Number of partial bytes we already have   /*{{{*/
 // ---------------------------------------------------------------------
 /* This is the number of bytes that is not local */

-unsigned long long pkgAcquire::PartialPresent()
+APT_PURE unsigned long long pkgAcquire::PartialPresent()

 {
   unsigned long long Total = 0;
 {
   unsigned long long Total = 0;

-   for (ItemCIterator I = ItemsBegin(); I != ItemsEnd(); I++)
+   for (ItemCIterator I = ItemsBegin(); I != ItemsEnd(); ++I)

       if ((*I)->Local == false)
         Total += (*I)->PartialSize;
    return Total;
       if ((*I)->Local == false)
         Total += (*I)->PartialSize;
    return Total;


@@ -760,7 +874,7 @@ void pkgAcquire::Queue::Bump()
 // AcquireStatus::pkgAcquireStatus - Constructor                       /*{{{*/
 // ---------------------------------------------------------------------
 /* */
 // AcquireStatus::pkgAcquireStatus - Constructor                       /*{{{*/
 // ---------------------------------------------------------------------
 /* */

-pkgAcquireStatus::pkgAcquireStatus() : Update(true), MorePulses(false)
+pkgAcquireStatus::pkgAcquireStatus() : d(NULL), Update(true), MorePulses(false)

 {
    Start();
 }
 {
    Start();
 }


@@ -780,28 +894,38 @@ bool pkgAcquireStatus::Pulse(pkgAcquire *Owner)
    // Compute the total number of bytes to fetch
    unsigned int Unknown = 0;
    unsigned int Count = 0;
    // Compute the total number of bytes to fetch
    unsigned int Unknown = 0;
    unsigned int Count = 0;

-   for (pkgAcquire::ItemCIterator I = Owner->ItemsBegin(); I != Owner->ItemsEnd();
-       I++, Count++)
+   bool UnfetchedReleaseFiles = false;
+   for (pkgAcquire::ItemCIterator I = Owner->ItemsBegin(); 
+        I != Owner->ItemsEnd();
+       ++I, ++Count)

    {
       TotalItems++;
       if ((*I)->Status == pkgAcquire::Item::StatDone)
    {
       TotalItems++;
       if ((*I)->Status == pkgAcquire::Item::StatDone)

-        CurrentItems++;
+        ++CurrentItems;

       
       // Totally ignore local items
       if ((*I)->Local == true)
         continue;
 
       
       // Totally ignore local items
       if ((*I)->Local == true)
         continue;
 

+      // see if the method tells us to expect more
+      TotalItems += (*I)->ExpectedAdditionalItems;
+
+      // check if there are unfetched Release files
+      if ((*I)->Complete == false && (*I)->ExpectedAdditionalItems > 0)
+         UnfetchedReleaseFiles = true;
+

       TotalBytes += (*I)->FileSize;
       if ((*I)->Complete == true)
         CurrentBytes += (*I)->FileSize;
       if ((*I)->FileSize == 0 && (*I)->Complete == false)
       TotalBytes += (*I)->FileSize;
       if ((*I)->Complete == true)
         CurrentBytes += (*I)->FileSize;
       if ((*I)->FileSize == 0 && (*I)->Complete == false)

-        Unknown++;
+        ++Unknown;

    }
    
    // Compute the current completion
    unsigned long long ResumeSize = 0;
    for (pkgAcquire::Worker *I = Owner->WorkersBegin(); I != 0;
        I = Owner->WorkerStep(I))
    }
    
    // Compute the current completion
    unsigned long long ResumeSize = 0;
    for (pkgAcquire::Worker *I = Owner->WorkersBegin(); I != 0;
        I = Owner->WorkerStep(I))

+   {

       if (I->CurrentItem != 0 && I->CurrentItem->Owner->Complete == false)
       {
         CurrentBytes += I->CurrentSize;
       if (I->CurrentItem != 0 && I->CurrentItem->Owner->Complete == false)
       {
         CurrentBytes += I->CurrentSize;


@@ -812,6 +936,7 @@ bool pkgAcquireStatus::Pulse(pkgAcquire *Owner)
             I->CurrentItem->Owner->Complete == false)
            TotalBytes += I->CurrentSize;
       }
             I->CurrentItem->Owner->Complete == false)
            TotalBytes += I->CurrentSize;
       }

+   }

    
    // Normalize the figures and account for unknown size downloads
    if (TotalBytes <= 0)
    
    // Normalize the figures and account for unknown size downloads
    if (TotalBytes <= 0)


@@ -822,6 +947,12 @@ bool pkgAcquireStatus::Pulse(pkgAcquire *Owner)
    // Wha?! Is not supposed to happen.
    if (CurrentBytes > TotalBytes)
       CurrentBytes = TotalBytes;
    // Wha?! Is not supposed to happen.
    if (CurrentBytes > TotalBytes)
       CurrentBytes = TotalBytes;

+
+   // debug
+   if (_config->FindB("Debug::acquire::progress", false) == true)
+      std::clog << " Bytes: " 
+                << SizeToStr(CurrentBytes) << " / " << SizeToStr(TotalBytes) 
+                << std::endl;

    
    // Compute the CPS
    struct timeval NewTime;
    
    // Compute the CPS
    struct timeval NewTime;


@@ -842,6 +973,14 @@ bool pkgAcquireStatus::Pulse(pkgAcquire *Owner)
       Time = NewTime;
    }
 
       Time = NewTime;
    }
 

+   // calculate the percentage, if we have too little data assume 1%
+   if (TotalBytes > 0 && UnfetchedReleaseFiles)
+      Percent = 0;
+   else 
+      // use both files and bytes because bytes can be unreliable
+      Percent = (0.8 * (CurrentBytes/float(TotalBytes)*100.0) + 
+                 0.2 * (CurrentItems/float(TotalItems)*100.0));
+

    int fd = _config->FindI("APT::Status-Fd",-1);
    if(fd > 0) 
    {
    int fd = _config->FindI("APT::Status-Fd",-1);
    if(fd > 0) 
    {


@@ -849,7 +988,9 @@ bool pkgAcquireStatus::Pulse(pkgAcquire *Owner)
 
       char msg[200];
       long i = CurrentItems < TotalItems ? CurrentItems + 1 : CurrentItems;
 
       char msg[200];
       long i = CurrentItems < TotalItems ? CurrentItems + 1 : CurrentItems;

-      unsigned long long const ETA = (TotalBytes - CurrentBytes) / CurrentCPS;
+      unsigned long long ETA = 0;
+      if(CurrentCPS > 0)
+         ETA = (TotalBytes - CurrentBytes) / CurrentCPS;

 
       // only show the ETA if it makes sense
       if (ETA > 0 && ETA < 172800 /* two days */ )
 
       // only show the ETA if it makes sense
       if (ETA > 0 && ETA < 172800 /* two days */ )


@@ -857,14 +998,14 @@ bool pkgAcquireStatus::Pulse(pkgAcquire *Owner)
       else
         snprintf(msg,sizeof(msg), _("Retrieving file %li of %li"), i, TotalItems);
         
       else
         snprintf(msg,sizeof(msg), _("Retrieving file %li of %li"), i, TotalItems);
         

-
-

       // build the status str
       status << "dlstatus:" << i
       // build the status str
       status << "dlstatus:" << i

-            << ":"  << (CurrentBytes/float(TotalBytes)*100.0) 
-            << ":" << msg 
-            << endl;
-      write(fd, status.str().c_str(), status.str().size());
+             << ":"  << std::setprecision(3) << Percent
+             << ":" << msg 
+             << endl;
+
+      std::string const dlstatus = status.str();
+      FileFd::Write(fd, dlstatus.c_str(), dlstatus.size());

    }
 
    return true;
    }
 
    return true;