X-Git-Url: https://git.saurik.com/apt.git/blobdiff_plain/b0db36b1ac7a93c147888aa98f9431e8bcc7d36e..c98b1307f0e9c1712b8e36b825724966d9d40eec:/apt-pkg/acquire.cc

diff --git a/apt-pkg/acquire.cc b/apt-pkg/acquire.cc
index 80624f9d3..842f2e31a 100644
--- a/apt-pkg/acquire.cc
+++ b/apt-pkg/acquire.cc
@@ -1,6 +1,6 @@
 // -*- mode: cpp; mode: fold -*-
 // Description								/*{{{*/
-// $Id: acquire.cc,v 1.29 1999/03/16 00:43:55 jgg Exp $
+// $Id: acquire.cc,v 1.38 1999/07/30 05:36:52 jgg Exp $
 /* ######################################################################
 
    Acquire - File Acquiration
@@ -25,6 +25,7 @@
 
 #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;
@@ -320,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;
+	 }
       }      
    }   
 
@@ -333,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			/*{{{*/
@@ -419,6 +441,18 @@ 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		/*{{{*/
 // ---------------------------------------------------------------------
 /* */
@@ -658,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;
@@ -687,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;
@@ -713,11 +758,13 @@ void pkgAcquireStatus::Pulse(pkgAcquire *Owner)
       if (Delta < 0.01)
 	 CurrentCPS = 0;
       else
-	 CurrentCPS = (CurrentBytes - LastBytes)/Delta;
-      LastBytes = CurrentBytes;
+	 CurrentCPS = ((CurrentBytes - ResumeSize) - LastBytes)/Delta;
+      LastBytes = CurrentBytes - ResumeSize;
       ElapsedTime = (unsigned long)Delta;
       Time = NewTime;
    }
+
+   return true;
 }
 									/*}}}*/
 // AcquireStatus::Start - Called when the download is started		/*{{{*/