Fixed quoting bug

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

diff --git a/apt-pkg/acquire.cc b/apt-pkg/acquire.cc
index 9a546c7e204d829b9455665e6b1437ee0c454492..ab60d1b47a9bbcec7a9346034faa4883d3b43940 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.15 1998/11/13 07:08:54 jgg Exp $
+// $Id: acquire.cc,v 1.23 1998/12/11 07:20:32 jgg Exp $

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


@@ -130,7 +130,8 @@ void pkgAcquire::Remove(Worker *Work)
 void pkgAcquire::Enqueue(ItemDesc &Item)
 {
    // Determine which queue to put the item in
 void pkgAcquire::Enqueue(ItemDesc &Item)
 {
    // Determine which queue to put the item in

-   string Name = QueueName(Item.URI);
+   const MethodConfig *Config;
+   string Name = QueueName(Item.URI,Config);

    if (Name.empty() == true)
       return;
 
    if (Name.empty() == true)
       return;
 


@@ -147,6 +148,9 @@ void pkgAcquire::Enqueue(ItemDesc &Item)
         I->Startup();
    }
 
         I->Startup();
    }
 

+   // See if this is a local only URI
+   if (Config->LocalOnly == true && Item.Owner->Complete == false)
+      Item.Owner->Local = true;

    Item.Owner->Status = Item::StatIdle;
    
    // Queue it into the named queue
    Item.Owner->Status = Item::StatIdle;
    
    // Queue it into the named queue


@@ -158,7 +162,7 @@ void pkgAcquire::Enqueue(ItemDesc &Item)
    {
       clog << "Fetching " << Item.URI << endl;
       clog << " to " << Item.Owner->DestFile << endl;
    {
       clog << "Fetching " << Item.URI << endl;
       clog << " to " << Item.Owner->DestFile << endl;

-      clog << " Queue is: " << QueueName(Item.URI) << endl;
+      clog << " Queue is: " << Name << endl;

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


@@ -184,11 +188,11 @@ void pkgAcquire::Dequeue(Item *Itm)
 /* The string returned depends on the configuration settings and the
    method parameters. Given something like http://foo.org/bar it can
    return http://foo.org or http */
 /* The string returned depends on the configuration settings and the
    method parameters. Given something like http://foo.org/bar it can
    return http://foo.org or http */

-string pkgAcquire::QueueName(string Uri)
+string pkgAcquire::QueueName(string Uri,MethodConfig const *&Config)

 {
    URI U(Uri);
    
 {
    URI U(Uri);
    

-   const MethodConfig *Config = GetConfig(U.Access);
+   Config = GetConfig(U.Access);

    if (Config == 0)
       return string();
    
    if (Config == 0)
       return string();
    


@@ -386,18 +390,6 @@ bool pkgAcquire::Clean(string Dir)
    return true;   
 }
                                                                        /*}}}*/
    return true;   
 }
                                                                        /*}}}*/

-// Acquire::MethodConfig::MethodConfig - Constructor                   /*{{{*/
-// ---------------------------------------------------------------------
-/* */
-pkgAcquire::MethodConfig::MethodConfig()
-{
-   SingleInstance = false;
-   PreScan = false;
-   Pipeline = false;
-   SendConfig = false;
-   Next = 0;
-}
-                                                                       /*}}}*/

 // 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 */


@@ -422,6 +414,19 @@ unsigned long pkgAcquire::FetchNeeded()
 }
                                                                        /*}}}*/
 
 }
                                                                        /*}}}*/
 

+// Acquire::MethodConfig::MethodConfig - Constructor                   /*{{{*/
+// ---------------------------------------------------------------------
+/* */
+pkgAcquire::MethodConfig::MethodConfig()
+{
+   SingleInstance = false;
+   Pipeline = false;
+   SendConfig = false;
+   LocalOnly = false;
+   Next = 0;
+}
+                                                                       /*}}}*/
+

 // Queue::Queue - Constructor                                          /*{{{*/
 // ---------------------------------------------------------------------
 /* */
 // Queue::Queue - Constructor                                          /*{{{*/
 // ---------------------------------------------------------------------
 /* */


@@ -431,6 +436,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                                          /*{{{*/


@@ -453,11 +460,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)


@@ -466,9 +476,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;


@@ -506,6 +519,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();
 }
                                                                        /*}}}*/


@@ -544,6 +565,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


@@ -557,32 +582,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();

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


@@ -603,6 +640,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;


@@ -610,6 +649,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;


@@ -653,7 +696,10 @@ void pkgAcquireStatus::Pulse(pkgAcquire *Owner)
       }
             
       // Compute the CPS value
       }
             
       // Compute the CPS value

-      CurrentCPS = (CurrentBytes - LastBytes)/(sdiff + usdiff/1000000.0);
+      if (sdiff == 0 && usdiff == 0)
+        CurrentCPS = 0;
+      else
+        CurrentCPS = (CurrentBytes - LastBytes)/(sdiff + usdiff/1000000.0);

       LastBytes = CurrentBytes;
       ElapsedTime = NewTime.tv_sec - StartTime.tv_sec;
       Time = NewTime;
       LastBytes = CurrentBytes;
       ElapsedTime = NewTime.tv_sec - StartTime.tv_sec;
       Time = NewTime;


@@ -673,6 +719,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                          /*{{{*/


@@ -694,9 +742,12 @@ void pkgAcquireStatus::Stop()
       usdiff += 1000000;
       sdiff--;
    }
       usdiff += 1000000;
       sdiff--;
    }

-   
+

    // Compute the CPS value
    // Compute the CPS value

-   CurrentCPS = FetchedBytes/(sdiff + usdiff/1000000.0);
+   if (sdiff == 0 && usdiff == 0)
+      CurrentCPS = 0;
+   else
+      CurrentCPS = FetchedBytes/(sdiff + usdiff/1000000.0);

    LastBytes = CurrentBytes;
    ElapsedTime = sdiff;
 }
    LastBytes = CurrentBytes;
    ElapsedTime = sdiff;
 }