Checked the size of partial files #33705

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

diff --git a/apt-pkg/acquire.cc b/apt-pkg/acquire.cc
index 353e2f69877f57792188c1e3fc2203eebd522792..2e8a05e2cec6965de074691acb89011bab1c9479 100644 (file)
--- a/apt-pkg/acquire.cc
+++ b/apt-pkg/acquire.cc
@@ -1,6 +1,6 @@
 // -*- mode: cpp; mode: fold -*-
 // Description                                                         /*{{{*/
 // -*- mode: cpp; mode: fold -*-
 // Description                                                         /*{{{*/

-// $Id: acquire.cc,v 1.16 1998/11/14 01:39:45 jgg Exp $
+// $Id: acquire.cc,v 1.31 1999/03/27 03:02:38 jgg Exp $

 /* ######################################################################
 
    Acquire - File Acquiration
 /* ######################################################################
 
    Acquire - File Acquiration


@@ -21,10 +21,11 @@
 #include <apt-pkg/acquire-worker.h>
 #include <apt-pkg/configuration.h>
 #include <apt-pkg/error.h>
 #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 <dirent.h>
 #include <sys/time.h>

+#include <errno.h>

                                                                        /*}}}*/
 
 // Acquire::pkgAcquire - Constructor                                   /*{{{*/
                                                                        /*}}}*/
 
 // Acquire::pkgAcquire - Constructor                                   /*{{{*/


@@ -297,7 +298,13 @@ bool pkgAcquire::Run()
       FD_ZERO(&WFds);
       SetFds(Highest,&RFds,&WFds);
       
       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");
       if (Res < 0)
       {
         _error->Errno("select","Select has failed");


@@ -413,6 +420,34 @@ unsigned long pkgAcquire::FetchNeeded()
    return Total;
 }
                                                                        /*}}}*/
    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                   /*{{{*/
 // ---------------------------------------------------------------------
 
 // Acquire::MethodConfig::MethodConfig - Constructor                   /*{{{*/
 // ---------------------------------------------------------------------


@@ -420,7 +455,6 @@ unsigned long pkgAcquire::FetchNeeded()
 pkgAcquire::MethodConfig::MethodConfig()
 {
    SingleInstance = false;
 pkgAcquire::MethodConfig::MethodConfig()
 {
    SingleInstance = false;

-   PreScan = false;

    Pipeline = false;
    SendConfig = false;
    LocalOnly = false;
    Pipeline = false;
    SendConfig = false;
    LocalOnly = false;


@@ -437,6 +471,8 @@ pkgAcquire::Queue::Queue(string Name,pkgAcquire *Owner) : Name(Name),
    Items = 0;
    Next = 0;
    Workers = 0;
    Items = 0;
    Next = 0;
    Workers = 0;

+   MaxPipeDepth = 1;
+   PipeDepth = 0;

 }
                                                                        /*}}}*/
 // Queue::~Queue - Destructor                                          /*{{{*/
 }
                                                                        /*}}}*/
 // Queue::~Queue - Destructor                                          /*{{{*/


@@ -459,11 +495,14 @@ pkgAcquire::Queue::~Queue()
 /* */
 void pkgAcquire::Queue::Enqueue(ItemDesc &Item)
 {
 /* */
 void pkgAcquire::Queue::Enqueue(ItemDesc &Item)
 {

+   QItem **I = &Items;
+   for (; *I != 0; I = &(*I)->Next);
+   

    // Create a new item
    // Create a new item

-   QItem *I = new QItem;
-   I->Next = Items;
-   Items = I;
-   *I = Item;
+   QItem *Itm = new QItem;
+   *Itm = Item;
+   Itm->Next = 0;
+   *I = Itm;

    
    Item.Owner->QueueCounter++;   
    if (Items->Next == 0)
    
    Item.Owner->QueueCounter++;   
    if (Items->Next == 0)


@@ -472,9 +511,12 @@ void pkgAcquire::Queue::Enqueue(ItemDesc &Item)
                                                                        /*}}}*/
 // Queue::Dequeue - Remove an item from the queue                      /*{{{*/
 // ---------------------------------------------------------------------
                                                                        /*}}}*/
 // 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)
 {
 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;
    bool Res = false;
    
    QItem **I = &Items;


@@ -512,6 +554,14 @@ bool pkgAcquire::Queue::Startup()
    if (Workers->Start() == false)
       return false;
    
    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();
 }
                                                                        /*}}}*/
    return Cycle();
 }
                                                                        /*}}}*/


@@ -532,7 +582,7 @@ bool pkgAcquire::Queue::Shutdown()
    return true;
 }
                                                                        /*}}}*/
    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)
 // ---------------------------------------------------------------------
 /* */
 pkgAcquire::Queue::QItem *pkgAcquire::Queue::FindItem(string URI,pkgAcquire::Worker *Owner)


@@ -550,6 +600,10 @@ pkgAcquire::Queue::QItem *pkgAcquire::Queue::FindItem(string URI,pkgAcquire::Wor
    main queue too.*/
 bool pkgAcquire::Queue::ItemDone(QItem *Itm)
 {
    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
    if (Itm->Owner->QueueCounter <= 1)
       Owner->Dequeue(Itm->Owner);
    else


@@ -563,32 +617,44 @@ bool pkgAcquire::Queue::ItemDone(QItem *Itm)
                                                                        /*}}}*/
 // Queue::Cycle - Queue new items into the method                      /*{{{*/
 // ---------------------------------------------------------------------
                                                                        /*}}}*/
 // 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;
 
 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;
    // 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              /*{{{*/
 // ---------------------------------------------------------------------
 }
                                                                        /*}}}*/
 // 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()
 {
 void pkgAcquire::Queue::Bump()
 {

+   Cycle();

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


@@ -609,6 +675,8 @@ void pkgAcquireStatus::Pulse(pkgAcquire *Owner)
 {
    TotalBytes = 0;
    CurrentBytes = 0;
 {
    TotalBytes = 0;
    CurrentBytes = 0;

+   TotalItems = 0;
+   CurrentItems = 0;

    
    // Compute the total number of bytes to fetch
    unsigned int Unknown = 0;
    
    // Compute the total number of bytes to fetch
    unsigned int Unknown = 0;


@@ -616,6 +684,10 @@ void pkgAcquireStatus::Pulse(pkgAcquire *Owner)
    for (pkgAcquire::Item **I = Owner->ItemsBegin(); I != Owner->ItemsEnd(); 
        I++, Count++)
    {
    for (pkgAcquire::Item **I = Owner->ItemsBegin(); I != Owner->ItemsEnd(); 
        I++, Count++)
    {

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

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


@@ -647,24 +719,16 @@ 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)
    {    
    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
       // Compute the CPS value

-      if (sdiff == 0 && usdiff == 0)
+      if (Delta < 0.01)

         CurrentCPS = 0;
       else
         CurrentCPS = 0;
       else

-        CurrentCPS = (CurrentBytes - LastBytes)/(sdiff + usdiff/1000000.0);
+        CurrentCPS = (CurrentBytes - LastBytes)/Delta;

       LastBytes = CurrentBytes;
       LastBytes = CurrentBytes;

-      ElapsedTime = NewTime.tv_sec - StartTime.tv_sec;
+      ElapsedTime = (unsigned long)Delta;

       Time = NewTime;
    }
 }
       Time = NewTime;
    }
 }


@@ -682,6 +746,8 @@ void pkgAcquireStatus::Start()
    TotalBytes = 0;
    FetchedBytes = 0;
    ElapsedTime = 0;
    TotalBytes = 0;
    FetchedBytes = 0;
    ElapsedTime = 0;

+   TotalItems = 0;
+   CurrentItems = 0;

 }
                                                                        /*}}}*/
 // AcquireStatus::Stop - Finished downloading                          /*{{{*/
 }
                                                                        /*}}}*/
 // AcquireStatus::Stop - Finished downloading                          /*{{{*/