]> git.saurik.com Git - apt.git/blobdiff - apt-pkg/acquire.cc
Added clean install code
[apt.git] / apt-pkg / acquire.cc
index f9691df9c4c27e1691a6ae49e92fd891093c32f3..842f2e31acb74199a6e8626e34ddf457c27c3fcc 100644 (file)
@@ -1,6 +1,6 @@
 // -*- mode: cpp; mode: fold -*-
 // Description                                                         /*{{{*/
-// $Id: acquire.cc,v 1.18 1998/11/23 07:32:19 jgg Exp $
+// $Id: acquire.cc,v 1.38 1999/07/30 05:36:52 jgg Exp $
 /* ######################################################################
 
    Acquire - File Acquiration
 #include <apt-pkg/acquire-worker.h>
 #include <apt-pkg/configuration.h>
 #include <apt-pkg/error.h>
-#include <strutl.h>
+#include <apt-pkg/strutl.h>
 
 #include <dirent.h>
 #include <sys/time.h>
+#include <errno.h>
                                                                        /*}}}*/
 
 // Acquire::pkgAcquire - Constructor                                   /*{{{*/
@@ -52,15 +53,23 @@ pkgAcquire::pkgAcquire(pkgAcquireStatus *Log) : Log(Log)
 /* Free our memory, clean up the queues (destroy the workers) */
 pkgAcquire::~pkgAcquire()
 {
-   while (Items.size() != 0)
-      delete Items[0];
-
    while (Configs != 0)
    {
       MethodConfig *Jnk = Configs;
       Configs = Configs->Next;
       delete Jnk;
    }   
+   
+   Shutdown();
+}
+                                                                       /*}}}*/
+// pkgAcquire::Shutdown - Clean out the acquire object                 /*{{{*/
+// ---------------------------------------------------------------------
+/* */
+void pkgAcquire::Shutdown()
+{
+   while (Items.size() != 0)
+      delete Items[0];
 
    while (Queues != 0)
    {
@@ -124,7 +133,7 @@ void pkgAcquire::Remove(Worker *Work)
 // Acquire::Enqueue - Queue an URI for fetching                                /*{{{*/
 // ---------------------------------------------------------------------
 /* This is the entry point for an item. An item calls this function when
-   it is construction which creates a queue (based on the current queue
+   it is constructed which creates a queue (based on the current queue
    mode) and puts the item in that queue. If the system is running then
    the queue might be started. */
 void pkgAcquire::Enqueue(ItemDesc &Item)
@@ -274,7 +283,7 @@ void pkgAcquire::RunFds(fd_set *RSet,fd_set *WSet)
 /* This runs the queues. It manages a select loop for all of the
    Worker tasks. The workers interact with the queues and items to
    manage the actual fetch. */
-bool pkgAcquire::Run()
+pkgAcquire::RunResult pkgAcquire::Run()
 {
    Running = true;
    
@@ -284,6 +293,8 @@ bool pkgAcquire::Run()
    if (Log != 0)
       Log->Start();
    
+   bool WasCancelled = false;
+
    // Run till all things have been acquired
    struct timeval tv;
    tv.tv_sec = 0;
@@ -297,7 +308,13 @@ bool pkgAcquire::Run()
       FD_ZERO(&WFds);
       SetFds(Highest,&RFds,&WFds);
       
-      int Res = select(Highest+1,&RFds,&WFds,0,&tv);
+      int Res;
+      do
+      {
+        Res = select(Highest+1,&RFds,&WFds,0,&tv);
+      }
+      while (Res < 0 && errno == EINTR);
+      
       if (Res < 0)
       {
         _error->Errno("select","Select has failed");
@@ -314,8 +331,11 @@ bool pkgAcquire::Run()
         tv.tv_usec = 500000;
         for (Worker *I = Workers; I != 0; I = I->NextAcquire)
            I->Pulse();
-        if (Log != 0)
-           Log->Pulse(this);
+        if (Log != 0 && Log->Pulse(this) == false)
+        {
+           WasCancelled = true;
+           break;
+        }
       }      
    }   
 
@@ -327,7 +347,15 @@ bool pkgAcquire::Run()
    for (Queue *I = Queues; I != 0; I = I->Next)
       I->Shutdown();
 
-   return !_error->PendingError();
+   // Shut down the items
+   for (Item **I = Items.begin(); I != Items.end(); I++)
+      (*I)->Finished();
+   
+   if (_error->PendingError())
+      return Failed;
+   if (WasCancelled)
+      return Cancelled;
+   return Continue;
 }
                                                                        /*}}}*/
 // Acquire::Bump - Called when an item is dequeued                     /*{{{*/
@@ -413,6 +441,34 @@ unsigned long pkgAcquire::FetchNeeded()
    return Total;
 }
                                                                        /*}}}*/
+// Acquire::PartialPresent - Number of partial bytes we already have   /*{{{*/
+// ---------------------------------------------------------------------
+/* This is the number of bytes that is not local */
+unsigned long pkgAcquire::PartialPresent()
+{
+   unsigned long Total = 0;
+   for (pkgAcquire::Item **I = ItemsBegin(); I != ItemsEnd(); I++)
+      if ((*I)->Local == false)
+        Total += (*I)->PartialSize;
+   return Total;
+}
+                                                                       /*}}}*/
+// pkgAcquire::UriBegin - Start iterator for the uri list              /*{{{*/
+// ---------------------------------------------------------------------
+/* */
+pkgAcquire::UriIterator pkgAcquire::UriBegin()
+{
+   return UriIterator(Queues);
+}
+                                                                       /*}}}*/
+// pkgAcquire::UriEnd - End iterator for the uri list                  /*{{{*/
+// ---------------------------------------------------------------------
+/* */
+pkgAcquire::UriIterator pkgAcquire::UriEnd()
+{
+   return UriIterator(0);
+}
+                                                                       /*}}}*/
 
 // Acquire::MethodConfig::MethodConfig - Constructor                   /*{{{*/
 // ---------------------------------------------------------------------
@@ -420,7 +476,6 @@ unsigned long pkgAcquire::FetchNeeded()
 pkgAcquire::MethodConfig::MethodConfig()
 {
    SingleInstance = false;
-   PreScan = false;
    Pipeline = false;
    SendConfig = false;
    LocalOnly = false;
@@ -437,6 +492,8 @@ pkgAcquire::Queue::Queue(string Name,pkgAcquire *Owner) : Name(Name),
    Items = 0;
    Next = 0;
    Workers = 0;
+   MaxPipeDepth = 1;
+   PipeDepth = 0;
 }
                                                                        /*}}}*/
 // Queue::~Queue - Destructor                                          /*{{{*/
@@ -475,9 +532,12 @@ void pkgAcquire::Queue::Enqueue(ItemDesc &Item)
                                                                        /*}}}*/
 // Queue::Dequeue - Remove an item from the queue                      /*{{{*/
 // ---------------------------------------------------------------------
-/* We return true if we hit something*/
+/* We return true if we hit something */
 bool pkgAcquire::Queue::Dequeue(Item *Owner)
 {
+   if (Owner->Status == pkgAcquire::Item::StatFetching)
+      return _error->Error("Tried to dequeue a fetching object");
+       
    bool Res = false;
    
    QItem **I = &Items;
@@ -515,6 +575,14 @@ bool pkgAcquire::Queue::Startup()
    if (Workers->Start() == false)
       return false;
    
+   /* When pipelining we commit 10 items. This needs to change when we
+      added other source retry to have cycle maintain a pipeline depth
+      on its own. */
+   if (Cnf->Pipeline == true)
+      MaxPipeDepth = 10;
+   else
+      MaxPipeDepth = 1;
+   
    return Cycle();
 }
                                                                        /*}}}*/
@@ -535,7 +603,7 @@ bool pkgAcquire::Queue::Shutdown()
    return true;
 }
                                                                        /*}}}*/
-// Queue::Finditem - Find a URI in the item list                       /*{{{*/
+// Queue::FindItem - Find a URI in the item list                       /*{{{*/
 // ---------------------------------------------------------------------
 /* */
 pkgAcquire::Queue::QItem *pkgAcquire::Queue::FindItem(string URI,pkgAcquire::Worker *Owner)
@@ -553,6 +621,10 @@ pkgAcquire::Queue::QItem *pkgAcquire::Queue::FindItem(string URI,pkgAcquire::Wor
    main queue too.*/
 bool pkgAcquire::Queue::ItemDone(QItem *Itm)
 {
+   PipeDepth--;
+   if (Itm->Owner->Status == pkgAcquire::Item::StatFetching)
+      Itm->Owner->Status = pkgAcquire::Item::StatDone;
+   
    if (Itm->Owner->QueueCounter <= 1)
       Owner->Dequeue(Itm->Owner);
    else
@@ -566,32 +638,44 @@ bool pkgAcquire::Queue::ItemDone(QItem *Itm)
                                                                        /*}}}*/
 // Queue::Cycle - Queue new items into the method                      /*{{{*/
 // ---------------------------------------------------------------------
-/* This locates a new idle item and sends it to the worker */
+/* This locates a new idle item and sends it to the worker. If pipelining
+   is enabled then it keeps the pipe full. */
 bool pkgAcquire::Queue::Cycle()
 {
    if (Items == 0 || Workers == 0)
       return true;
 
+   if (PipeDepth < 0)
+      return _error->Error("Pipedepth failure");
+                          
    // Look for a queable item
    QItem *I = Items;
-   for (; I != 0; I = I->Next)
-      if (I->Owner->Status == pkgAcquire::Item::StatIdle)
-        break;
-
-   // Nothing to do, queue is idle.
-   if (I == 0)
-      return true;
+   while (PipeDepth < (signed)MaxPipeDepth)
+   {
+      for (; I != 0; I = I->Next)
+        if (I->Owner->Status == pkgAcquire::Item::StatIdle)
+           break;
+      
+      // Nothing to do, queue is idle.
+      if (I == 0)
+        return true;
+      
+      I->Worker = Workers;
+      I->Owner->Status = pkgAcquire::Item::StatFetching;
+      PipeDepth++;
+      if (Workers->QueueItem(I) == false)
+        return false;
+   }
    
-   I->Worker = Workers;
-   I->Owner->Status = pkgAcquire::Item::StatFetching;
-   return Workers->QueueItem(I);
+   return true;
 }
                                                                        /*}}}*/
 // Queue::Bump - Fetch any pending objects if we are idle              /*{{{*/
 // ---------------------------------------------------------------------
-/* */
+/* This is called when an item in multiple queues is dequeued */
 void pkgAcquire::Queue::Bump()
 {
+   Cycle();
 }
                                                                        /*}}}*/
 
@@ -608,7 +692,7 @@ pkgAcquireStatus::pkgAcquireStatus()
 /* This computes some internal state variables for the derived classes to
    use. It generates the current downloaded bytes and total bytes to download
    as well as the current CPS estimate. */
-void pkgAcquireStatus::Pulse(pkgAcquire *Owner)
+bool pkgAcquireStatus::Pulse(pkgAcquire *Owner)
 {
    TotalBytes = 0;
    CurrentBytes = 0;
@@ -637,18 +721,29 @@ void pkgAcquireStatus::Pulse(pkgAcquire *Owner)
    }
    
    // Compute the current completion
+   unsigned 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;
-      
+        ResumeSize += I->ResumePoint;
+        
+        // Files with unknown size always have 100% completion
+        if (I->CurrentItem->Owner->FileSize == 0 && 
+            I->CurrentItem->Owner->Complete == false)
+           TotalBytes += I->CurrentSize;
+      }
+   
    // Normalize the figures and account for unknown size downloads
    if (TotalBytes <= 0)
       TotalBytes = 1;
    if (Unknown == Count)
       TotalBytes = Unknown;
-   else
-      TotalBytes += TotalBytes/(Count - Unknown)*Unknown;
+
+   // Wha?! Is not supposed to happen.
+   if (CurrentBytes > TotalBytes)
+      CurrentBytes = TotalBytes;
    
    // Compute the CPS
    struct timeval NewTime;
@@ -656,26 +751,20 @@ void pkgAcquireStatus::Pulse(pkgAcquire *Owner)
    if (NewTime.tv_sec - Time.tv_sec == 6 && NewTime.tv_usec > Time.tv_usec ||
        NewTime.tv_sec - Time.tv_sec > 6)
    {    
-      // Compute the delta time with full accuracy
-      long usdiff = NewTime.tv_usec - Time.tv_usec;
-      long sdiff = NewTime.tv_sec - Time.tv_sec;
+      double Delta = NewTime.tv_sec - Time.tv_sec + 
+                    (NewTime.tv_usec - Time.tv_usec)/1000000.0;
       
-      // Borrow
-      if (usdiff < 0)
-      {         
-        usdiff += 1000000;
-        sdiff--;
-      }
-            
       // Compute the CPS value
-      if (sdiff == 0 && usdiff == 0)
+      if (Delta < 0.01)
         CurrentCPS = 0;
       else
-        CurrentCPS = (CurrentBytes - LastBytes)/(sdiff + usdiff/1000000.0);
-      LastBytes = CurrentBytes;
-      ElapsedTime = NewTime.tv_sec - StartTime.tv_sec;
+        CurrentCPS = ((CurrentBytes - ResumeSize) - LastBytes)/Delta;
+      LastBytes = CurrentBytes - ResumeSize;
+      ElapsedTime = (unsigned long)Delta;
       Time = NewTime;
    }
+
+   return true;
 }
                                                                        /*}}}*/
 // AcquireStatus::Start - Called when the download is started          /*{{{*/