* doc/apt.ent:

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

diff --git a/apt-pkg/acquire.cc b/apt-pkg/acquire.cc
index 0ee7ff44700a51e8a829600a9f1aeec5eadc242f..9478cdfb424aa8d66b88e9e924733472c5ab00e3 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.41 1999/10/18 02:53:05 jgg Exp $
+// $Id: acquire.cc,v 1.50 2004/03/17 05:17:11 mdz Exp $

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


@@ -13,51 +13,84 @@
    ##################################################################### */
                                                                        /*}}}*/
 // Include Files                                                       /*{{{*/
    ##################################################################### */
                                                                        /*}}}*/
 // Include Files                                                       /*{{{*/

-#ifdef __GNUG__
-#pragma implementation "apt-pkg/acquire.h"
-#endif       

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

+#include <apt-pkg/fileutl.h>
+
+#include <apti18n.h>
+
+#include <iostream>
+#include <sstream>
+#include <stdio.h>

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

-#include <sys/stat.h>

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

+using namespace std;
+

 // Acquire::pkgAcquire - Constructor                                   /*{{{*/
 // ---------------------------------------------------------------------
 /* We grab some runtime state from the configuration space */
 // Acquire::pkgAcquire - Constructor                                   /*{{{*/
 // ---------------------------------------------------------------------
 /* We grab some runtime state from the configuration space */

-pkgAcquire::pkgAcquire(pkgAcquireStatus *Log) : Log(Log)
+pkgAcquire::pkgAcquire() : Queues(0), Workers(0), Configs(0), Log(NULL), ToFetch(0),
+                          Debug(_config->FindB("Debug::pkgAcquire",false)),
+                          Running(false), LockFD(-1)

 {
 {

-   Queues = 0;
-   Configs = 0;
-   Workers = 0;
-   ToFetch = 0;
-   Running = false;
-   
-   string Mode = _config->Find("Acquire::Queue-Mode","host");
+   string const Mode = _config->Find("Acquire::Queue-Mode","host");
+   if (strcasecmp(Mode.c_str(),"host") == 0)
+      QueueMode = QueueHost;
+   if (strcasecmp(Mode.c_str(),"access") == 0)
+      QueueMode = QueueAccess;
+}
+pkgAcquire::pkgAcquire(pkgAcquireStatus *Progress) : Queues(0), Workers(0),
+                          Configs(0), Log(Progress), ToFetch(0),
+                          Debug(_config->FindB("Debug::pkgAcquire",false)),
+                          Running(false), LockFD(-1)
+{
+   string const Mode = _config->Find("Acquire::Queue-Mode","host");

    if (strcasecmp(Mode.c_str(),"host") == 0)
       QueueMode = QueueHost;
    if (strcasecmp(Mode.c_str(),"access") == 0)
    if (strcasecmp(Mode.c_str(),"host") == 0)
       QueueMode = QueueHost;
    if (strcasecmp(Mode.c_str(),"access") == 0)

-      QueueMode = QueueAccess;   
+      QueueMode = QueueAccess;
+   Setup(Progress, "");
+}
+                                                                       /*}}}*/
+// Acquire::Setup - Delayed Constructor                                        /*{{{*/
+// ---------------------------------------------------------------------
+/* Do everything needed to be a complete Acquire object and report the
+   success (or failure) back so the user knows that something is wrong… */
+bool pkgAcquire::Setup(pkgAcquireStatus *Progress, string const &Lock)
+{
+   Log = Progress;

 
 

-   Debug = _config->FindB("Debug::pkgAcquire",false);
-   
-   // This is really a stupid place for this, but people whine so much..
-   struct stat St;
-   if (stat((_config->FindDir("Dir::State::lists") + "partial/").c_str(),&St) != 0 ||
-       S_ISDIR(St.st_mode) == 0)
-      _error->Error("Lists directory %s/partial is missing",
-                   _config->FindDir("Dir::State::lists").c_str());
-   if (stat((_config->FindDir("Dir::Cache::Archives") + "partial/").c_str(),&St) != 0 ||
-       S_ISDIR(St.st_mode) == 0)
-      _error->Error("Archive directory %s/partial is missing",
-                   _config->FindDir("Dir::Cache::Archives").c_str());
+   // check for existence and possibly create auxiliary directories
+   string const listDir = _config->FindDir("Dir::State::lists");
+   string const partialListDir = listDir + "partial/";
+   string const archivesDir = _config->FindDir("Dir::Cache::Archives");
+   string const partialArchivesDir = archivesDir + "partial/";
+
+   if (CreateAPTDirectoryIfNeeded(_config->FindDir("Dir::State"), partialListDir) == false &&
+       CreateAPTDirectoryIfNeeded(listDir, partialListDir) == false)
+      return _error->Errno("Acquire", _("List directory %spartial is missing."), listDir.c_str());
+
+   if (CreateAPTDirectoryIfNeeded(_config->FindDir("Dir::Cache"), partialArchivesDir) == false &&
+       CreateAPTDirectoryIfNeeded(archivesDir, partialArchivesDir) == false)
+      return _error->Errno("Acquire", _("Archives directory %spartial is missing."), archivesDir.c_str());
+
+   if (Lock.empty() == true || _config->FindB("Debug::NoLocking", false) == true)
+      return true;
+
+   // Lock the directory this acquire object will work in
+   LockFD = GetLock(flCombine(Lock, "lock"));
+   if (LockFD == -1)
+      return _error->Error(_("Unable to lock directory %s"), Lock.c_str());
+
+   return true;

 }
                                                                        /*}}}*/
 // Acquire::~pkgAcquire        - Destructor                                    /*{{{*/
 }
                                                                        /*}}}*/
 // Acquire::~pkgAcquire        - Destructor                                    /*{{{*/


@@ -65,14 +98,17 @@ pkgAcquire::pkgAcquire(pkgAcquireStatus *Log) : Log(Log)
 /* Free our memory, clean up the queues (destroy the workers) */
 pkgAcquire::~pkgAcquire()
 {
 /* Free our memory, clean up the queues (destroy the workers) */
 pkgAcquire::~pkgAcquire()
 {

+   Shutdown();
+
+   if (LockFD != -1)
+      close(LockFD);
+

    while (Configs != 0)
    {
       MethodConfig *Jnk = Configs;
       Configs = Configs->Next;
       delete Jnk;
    }   
    while (Configs != 0)
    {
       MethodConfig *Jnk = Configs;
       Configs = Configs->Next;
       delete Jnk;
    }   

-   
-   Shutdown();

 }
                                                                        /*}}}*/
 // Acquire::Shutdown - Clean out the acquire object                    /*{{{*/
 }
                                                                        /*}}}*/
 // Acquire::Shutdown - Clean out the acquire object                    /*{{{*/


@@ -81,7 +117,11 @@ pkgAcquire::~pkgAcquire()
 void pkgAcquire::Shutdown()
 {
    while (Items.size() != 0)
 void pkgAcquire::Shutdown()
 {
    while (Items.size() != 0)

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

       delete Items[0];
       delete Items[0];

+   }

 
    while (Queues != 0)
    {
 
    while (Queues != 0)
    {


@@ -105,10 +145,17 @@ void pkgAcquire::Add(Item *Itm)
 /* Remove an item from the acquire list. This is usually not used.. */
 void pkgAcquire::Remove(Item *Itm)
 {
 /* Remove an item from the acquire list. This is usually not used.. */
 void pkgAcquire::Remove(Item *Itm)
 {

-   for (vector<Item *>::iterator I = Items.begin(); I < Items.end(); I++)
+   Dequeue(Itm);
+   
+   for (ItemIterator I = Items.begin(); I != Items.end();)

    {
       if (*I == Itm)
    {
       if (*I == Itm)

+      {

         Items.erase(I);
         Items.erase(I);

+        I = Items.begin();
+      }      
+      else 
+        I++;

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


@@ -175,9 +222,9 @@ void pkgAcquire::Enqueue(ItemDesc &Item)
    Item.Owner->Status = Item::StatIdle;
    
    // Queue it into the named queue
    Item.Owner->Status = Item::StatIdle;
    
    // Queue it into the named queue

-   I->Enqueue(Item);
-   ToFetch++;
-         
+   if(I->Enqueue(Item)) 
+      ToFetch++;
+            

    // Some trace stuff
    if (Debug == true)
    {
    // Some trace stuff
    if (Debug == true)
    {


@@ -248,7 +295,11 @@ pkgAcquire::MethodConfig *pkgAcquire::GetConfig(string Access)
    Worker Work(Conf);
    if (Work.Start() == false)
       return 0;
    Worker Work(Conf);
    if (Work.Start() == false)
       return 0;

-   
+
+   /* if a method uses DownloadLimit, we switch to SingleInstance mode */
+   if(_config->FindI("Acquire::"+Access+"::Dl-Limit",0) > 0)
+      Conf->SingleInstance = true;
+    

    return Conf;
 }
                                                                        /*}}}*/
    return Conf;
 }
                                                                        /*}}}*/


@@ -295,7 +346,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. */
 /* 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. */

-pkgAcquire::RunResult pkgAcquire::Run()
+pkgAcquire::RunResult pkgAcquire::Run(int PulseIntervall)

 {
    Running = true;
    
 {
    Running = true;
    


@@ -310,7 +361,7 @@ pkgAcquire::RunResult pkgAcquire::Run()
    // Run till all things have been acquired
    struct timeval tv;
    tv.tv_sec = 0;
    // Run till all things have been acquired
    struct timeval tv;
    tv.tv_sec = 0;

-   tv.tv_usec = 500000; 
+   tv.tv_usec = PulseIntervall; 

    while (ToFetch > 0)
    {
       fd_set RFds;
    while (ToFetch > 0)
    {
       fd_set RFds;


@@ -340,7 +391,7 @@ pkgAcquire::RunResult pkgAcquire::Run()
       // Timeout, notify the log class
       if (Res == 0 || (Log != 0 && Log->Update == true))
       {
       // Timeout, notify the log class
       if (Res == 0 || (Log != 0 && Log->Update == true))
       {

-        tv.tv_usec = 500000;
+        tv.tv_usec = PulseIntervall;

         for (Worker *I = Workers; I != 0; I = I->NextAcquire)
            I->Pulse();
         if (Log != 0 && Log->Pulse(this) == false)
         for (Worker *I = Workers; I != 0; I = I->NextAcquire)
            I->Pulse();
         if (Log != 0 && Log->Pulse(this) == false)


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

-   for (Item **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())


@@ -396,13 +447,13 @@ bool pkgAcquire::Clean(string Dir)
 {
    DIR *D = opendir(Dir.c_str());   
    if (D == 0)
 {
    DIR *D = opendir(Dir.c_str());   
    if (D == 0)

-      return _error->Errno("opendir","Unable to read %s",Dir.c_str());
+      return _error->Errno("opendir",_("Unable to read %s"),Dir.c_str());

    
    string StartDir = SafeGetCWD();
    if (chdir(Dir.c_str()) != 0)
    {
       closedir(D);
    
    string StartDir = SafeGetCWD();
    if (chdir(Dir.c_str()) != 0)
    {
       closedir(D);

-      return _error->Errno("chdir","Unable to change to ",Dir.c_str());
+      return _error->Errno("chdir",_("Unable to change to %s"),Dir.c_str());

    }
    
    for (struct dirent *Dir = readdir(D); Dir != 0; Dir = readdir(D))
    }
    
    for (struct dirent *Dir = readdir(D); Dir != 0; Dir = readdir(D))


@@ -415,7 +466,7 @@ bool pkgAcquire::Clean(string Dir)
         continue;
       
       // Look in the get list
         continue;
       
       // Look in the get list

-      vector<Item *>::iterator I = Items.begin();
+      ItemCIterator I = Items.begin();

       for (; I != Items.end(); I++)
         if (flNotDir((*I)->DestFile) == Dir->d_name)
            break;
       for (; I != Items.end(); I++)
         if (flNotDir((*I)->DestFile) == Dir->d_name)
            break;


@@ -425,18 +476,19 @@ bool pkgAcquire::Clean(string Dir)
         unlink(Dir->d_name);
    };
    
         unlink(Dir->d_name);
    };
    

-   chdir(StartDir.c_str());

    closedir(D);
    closedir(D);

+   if (chdir(StartDir.c_str()) != 0)
+      return _error->Errno("chdir",_("Unable to change to %s"),StartDir.c_str());

    return true;   
 }
                                                                        /*}}}*/
 // Acquire::TotalNeeded - Number of bytes to fetch                     /*{{{*/
 // ---------------------------------------------------------------------
 /* This is the total number of bytes needed */
    return true;   
 }
                                                                        /*}}}*/
 // Acquire::TotalNeeded - Number of bytes to fetch                     /*{{{*/
 // ---------------------------------------------------------------------
 /* This is the total number of bytes needed */

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

 {
 {

-   unsigned long Total = 0;
-   for (pkgAcquire::Item **I = ItemsBegin(); I != ItemsEnd(); I++)
+   unsigned long long Total = 0;
+   for (ItemCIterator I = ItemsBegin(); I != ItemsEnd(); I++)

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


@@ -444,10 +496,10 @@ unsigned 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 pkgAcquire::FetchNeeded()
+unsigned long long pkgAcquire::FetchNeeded()

 {
 {

-   unsigned long Total = 0;
-   for (pkgAcquire::Item **I = ItemsBegin(); I != ItemsEnd(); I++)
+   unsigned long long Total = 0;
+   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;


@@ -456,10 +508,10 @@ unsigned 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 pkgAcquire::PartialPresent()
+unsigned long long pkgAcquire::PartialPresent()

 {
 {

-   unsigned long Total = 0;
-   for (pkgAcquire::Item **I = ItemsBegin(); I != ItemsEnd(); I++)
+  unsigned long long Total = 0;
+   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;


@@ -481,7 +533,6 @@ pkgAcquire::UriIterator pkgAcquire::UriEnd()
    return UriIterator(0);
 }
                                                                        /*}}}*/
    return UriIterator(0);
 }
                                                                        /*}}}*/

-

 // Acquire::MethodConfig::MethodConfig - Constructor                   /*{{{*/
 // ---------------------------------------------------------------------
 /* */
 // Acquire::MethodConfig::MethodConfig - Constructor                   /*{{{*/
 // ---------------------------------------------------------------------
 /* */


@@ -491,10 +542,10 @@ pkgAcquire::MethodConfig::MethodConfig()
    Pipeline = false;
    SendConfig = false;
    LocalOnly = false;
    Pipeline = false;
    SendConfig = false;
    LocalOnly = false;

+   Removable = false;

    Next = 0;
 }
                                                                        /*}}}*/
    Next = 0;
 }
                                                                        /*}}}*/

-

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


@@ -526,11 +577,17 @@ pkgAcquire::Queue::~Queue()
 // Queue::Enqueue - Queue an item to the queue                         /*{{{*/
 // ---------------------------------------------------------------------
 /* */
 // Queue::Enqueue - Queue an item to the queue                         /*{{{*/
 // ---------------------------------------------------------------------
 /* */

-void pkgAcquire::Queue::Enqueue(ItemDesc &Item)
+bool pkgAcquire::Queue::Enqueue(ItemDesc &Item)

 {
    QItem **I = &Items;
 {
    QItem **I = &Items;

-   for (; *I != 0; I = &(*I)->Next);
-   
+   // move to the end of the queue and check for duplicates here
+   for (; *I != 0; I = &(*I)->Next)
+      if (Item.URI == (*I)->URI) 
+      {
+        Item.Owner->Status = Item::StatDone;
+        return false;
+      }
+

    // Create a new item
    QItem *Itm = new QItem;
    *Itm = Item;
    // Create a new item
    QItem *Itm = new QItem;
    *Itm = Item;


@@ -540,6 +597,7 @@ void pkgAcquire::Queue::Enqueue(ItemDesc &Item)
    Item.Owner->QueueCounter++;   
    if (Items->Next == 0)
       Cycle();
    Item.Owner->QueueCounter++;   
    if (Items->Next == 0)
       Cycle();

+   return true;

 }
                                                                        /*}}}*/
 // Queue::Dequeue - Remove an item from the queue                      /*{{{*/
 }
                                                                        /*}}}*/
 // Queue::Dequeue - Remove an item from the queue                      /*{{{*/


@@ -592,7 +650,7 @@ bool pkgAcquire::Queue::Startup()
          added other source retry to have cycle maintain a pipeline depth
          on its own. */
       if (Cnf->Pipeline == true)
          added other source retry to have cycle maintain a pipeline depth
          on its own. */
       if (Cnf->Pipeline == true)

-        MaxPipeDepth = 10;
+        MaxPipeDepth = _config->FindI("Acquire::Max-Pipeline-Depth",10);

       else
         MaxPipeDepth = 1;
    }
       else
         MaxPipeDepth = 1;
    }


@@ -699,11 +757,10 @@ void pkgAcquire::Queue::Bump()
    Cycle();
 }
                                                                        /*}}}*/
    Cycle();
 }
                                                                        /*}}}*/

-

 // AcquireStatus::pkgAcquireStatus - Constructor                       /*{{{*/
 // ---------------------------------------------------------------------
 /* */
 // AcquireStatus::pkgAcquireStatus - Constructor                       /*{{{*/
 // ---------------------------------------------------------------------
 /* */

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

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


@@ -723,7 +780,7 @@ 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::Item **I = Owner->ItemsBegin(); I != Owner->ItemsEnd(); 
+   for (pkgAcquire::ItemCIterator I = Owner->ItemsBegin(); I != Owner->ItemsEnd();

        I++, Count++)
    {
       TotalItems++;
        I++, Count++)
    {
       TotalItems++;


@@ -733,7 +790,7 @@ bool pkgAcquireStatus::Pulse(pkgAcquire *Owner)
       // Totally ignore local items
       if ((*I)->Local == true)
         continue;
       // Totally ignore local items
       if ((*I)->Local == true)
         continue;

-      
+

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


@@ -769,7 +826,7 @@ bool pkgAcquireStatus::Pulse(pkgAcquire *Owner)
    // Compute the CPS
    struct timeval NewTime;
    gettimeofday(&NewTime,0);
    // Compute the CPS
    struct timeval NewTime;
    gettimeofday(&NewTime,0);

-   if (NewTime.tv_sec - Time.tv_sec == 6 && NewTime.tv_usec > Time.tv_usec ||
+   if ((NewTime.tv_sec - Time.tv_sec == 6 && NewTime.tv_usec > Time.tv_usec) ||

        NewTime.tv_sec - Time.tv_sec > 6)
    {    
       double Delta = NewTime.tv_sec - Time.tv_sec + 
        NewTime.tv_sec - Time.tv_sec > 6)
    {    
       double Delta = NewTime.tv_sec - Time.tv_sec + 


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

+   int fd = _config->FindI("APT::Status-Fd",-1);
+   if(fd > 0) 
+   {
+      ostringstream status;
+
+      char msg[200];
+      long i = CurrentItems < TotalItems ? CurrentItems + 1 : CurrentItems;
+      unsigned long ETA =
+        (unsigned long)((TotalBytes - CurrentBytes) / CurrentCPS);
+
+      // only show the ETA if it makes sense
+      if (ETA > 0 && ETA < 172800 /* two days */ )
+        snprintf(msg,sizeof(msg), _("Retrieving file %li of %li (%s remaining)"), i, TotalItems, TimeToStr(ETA).c_str());
+      else
+        snprintf(msg,sizeof(msg), _("Retrieving file %li of %li"), i, TotalItems);
+        
+
+
+      // build the status str
+      status << "dlstatus:" << i
+            << ":"  << (CurrentBytes/float(TotalBytes)*100.0) 
+            << ":" << msg 
+            << endl;
+      write(fd, status.str().c_str(), status.str().size());
+   }
+

    return true;
 }
                                                                        /*}}}*/
    return true;
 }
                                                                        /*}}}*/