* cmdline/apt-mark:
[apt.git] / apt-pkg / acquire.cc
index 734f5e7ab63ddedee4596fec4ae63f94c7199e15..fff1b2b6ad379b28603de987933b4523dc5c3f36 100644 (file)
@@ -1,6 +1,6 @@
 // -*- mode: cpp; mode: fold -*-
 // Description                                                         /*{{{*/
-// $Id: acquire.cc,v 1.36 1999/06/13 05:06:40 jgg Exp $
+// $Id: acquire.cc,v 1.50 2004/03/17 05:17:11 mdz Exp $
 /* ######################################################################
 
    Acquire - File Acquiration
 #include <apt-pkg/error.h>
 #include <apt-pkg/strutl.h>
 
+#include <apti18n.h>
+
+#include <iostream>
+#include <sstream>
+    
 #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 */
@@ -46,6 +54,17 @@ pkgAcquire::pkgAcquire(pkgAcquireStatus *Log) : Log(Log)
       QueueMode = QueueAccess;   
 
    Debug = _config->FindB("Debug::pkgAcquire",false);
+   
+   // This is really a stupid place for this
+   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 %spartial 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 %spartial is missing."),
+                   _config->FindDir("Dir::Cache::Archives").c_str());
 }
                                                                        /*}}}*/
 // Acquire::~pkgAcquire        - Destructor                                    /*{{{*/
@@ -53,15 +72,27 @@ 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];
-
+   Shutdown();
+   
    while (Configs != 0)
    {
       MethodConfig *Jnk = Configs;
       Configs = Configs->Next;
       delete Jnk;
    }   
+}
+                                                                       /*}}}*/
+// Acquire::Shutdown - Clean out the acquire object                    /*{{{*/
+// ---------------------------------------------------------------------
+/* */
+void pkgAcquire::Shutdown()
+{
+   while (Items.size() != 0)
+   {
+      if (Items[0]->Status == Item::StatFetching)
+         Items[0]->Status = Item::StatError;
+      delete Items[0];
+   }
 
    while (Queues != 0)
    {
@@ -85,10 +116,17 @@ void pkgAcquire::Add(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)
+      {
         Items.erase(I);
+        I = Items.begin();
+      }      
+      else 
+        I++;
    }
 }
                                                                        /*}}}*/
@@ -125,7 +163,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)
@@ -228,7 +266,11 @@ pkgAcquire::MethodConfig *pkgAcquire::GetConfig(string Access)
    Worker Work(Conf);
    if (Work.Start() == false)
       return 0;
-   
+
+   /* if a method uses DownloadLimit, we switch to SingleInstance mode */
+   if(_config->FindI("Acquire::"+Access+"::DlLimit",0) > 0)
+      Conf->SingleInstance = true;
+    
    return Conf;
 }
                                                                        /*}}}*/
@@ -275,7 +317,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. */
-pkgAcquire::RunResult pkgAcquire::Run()
+pkgAcquire::RunResult pkgAcquire::Run(int PulseIntervall)
 {
    Running = true;
    
@@ -290,7 +332,7 @@ pkgAcquire::RunResult pkgAcquire::Run()
    // 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;
@@ -320,7 +362,7 @@ pkgAcquire::RunResult pkgAcquire::Run()
       // 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)
@@ -337,11 +379,11 @@ pkgAcquire::RunResult pkgAcquire::Run()
    // Shut down the acquire bits
    Running = false;
    for (Queue *I = Queues; I != 0; I = I->Next)
-      I->Shutdown();
+      I->Shutdown(false);
 
    // Shut down the items
-   for (Item **I = Items.begin(); I != Items.end(); I++)
-      (*I)->Finished();
+   for (ItemIterator I = Items.begin(); I != Items.end(); I++)
+      (*I)->Finished(); 
    
    if (_error->PendingError())
       return Failed;
@@ -376,13 +418,13 @@ bool pkgAcquire::Clean(string Dir)
 {
    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);
-      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))
@@ -395,7 +437,7 @@ bool pkgAcquire::Clean(string Dir)
         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;
@@ -413,10 +455,10 @@ bool pkgAcquire::Clean(string Dir)
 // Acquire::TotalNeeded - Number of bytes to fetch                     /*{{{*/
 // ---------------------------------------------------------------------
 /* This is the total number of bytes needed */
-unsigned long pkgAcquire::TotalNeeded()
+double pkgAcquire::TotalNeeded()
 {
-   unsigned long Total = 0;
-   for (pkgAcquire::Item **I = ItemsBegin(); I != ItemsEnd(); I++)
+   double Total = 0;
+   for (ItemCIterator I = ItemsBegin(); I != ItemsEnd(); I++)
       Total += (*I)->FileSize;
    return Total;
 }
@@ -424,10 +466,10 @@ unsigned long pkgAcquire::TotalNeeded()
 // Acquire::FetchNeeded - Number of bytes needed to get                        /*{{{*/
 // ---------------------------------------------------------------------
 /* This is the number of bytes that is not local */
-unsigned long pkgAcquire::FetchNeeded()
+double pkgAcquire::FetchNeeded()
 {
-   unsigned long Total = 0;
-   for (pkgAcquire::Item **I = ItemsBegin(); I != ItemsEnd(); I++)
+   double Total = 0;
+   for (ItemCIterator I = ItemsBegin(); I != ItemsEnd(); I++)
       if ((*I)->Local == false)
         Total += (*I)->FileSize;
    return Total;
@@ -436,16 +478,16 @@ unsigned long pkgAcquire::FetchNeeded()
 // Acquire::PartialPresent - Number of partial bytes we already have   /*{{{*/
 // ---------------------------------------------------------------------
 /* This is the number of bytes that is not local */
-unsigned long pkgAcquire::PartialPresent()
+double pkgAcquire::PartialPresent()
 {
-   unsigned long Total = 0;
-   for (pkgAcquire::Item **I = ItemsBegin(); I != ItemsEnd(); I++)
+  double Total = 0;
+   for (ItemCIterator I = ItemsBegin(); I != ItemsEnd(); I++)
       if ((*I)->Local == false)
         Total += (*I)->PartialSize;
    return Total;
 }
-                                                                       /*}}}*/
-// pkgAcquire::UriBegin - Start iterator for the uri list              /*{{{*/
+
+// Acquire::UriBegin - Start iterator for the uri list                 /*{{{*/
 // ---------------------------------------------------------------------
 /* */
 pkgAcquire::UriIterator pkgAcquire::UriBegin()
@@ -453,7 +495,7 @@ pkgAcquire::UriIterator pkgAcquire::UriBegin()
    return UriIterator(Queues);
 }
                                                                        /*}}}*/
-// pkgAcquire::UriEnd - End iterator for the uri list                  /*{{{*/
+// Acquire::UriEnd - End iterator for the uri list                     /*{{{*/
 // ---------------------------------------------------------------------
 /* */
 pkgAcquire::UriIterator pkgAcquire::UriEnd()
@@ -471,6 +513,7 @@ pkgAcquire::MethodConfig::MethodConfig()
    Pipeline = false;
    SendConfig = false;
    LocalOnly = false;
+   Removable = false;
    Next = 0;
 }
                                                                        /*}}}*/
@@ -493,7 +536,7 @@ pkgAcquire::Queue::Queue(string Name,pkgAcquire *Owner) : Name(Name),
 /* */
 pkgAcquire::Queue::~Queue()
 {
-   Shutdown();
+   Shutdown(true);
    
    while (Items != 0)
    {
@@ -552,44 +595,53 @@ bool pkgAcquire::Queue::Dequeue(Item *Owner)
                                                                        /*}}}*/
 // Queue::Startup - Start the worker processes                         /*{{{*/
 // ---------------------------------------------------------------------
-/* */
+/* It is possible for this to be called with a pre-existing set of
+   workers. */
 bool pkgAcquire::Queue::Startup()
 {
-   Shutdown();
-   
-   URI U(Name);
-   pkgAcquire::MethodConfig *Cnf = Owner->GetConfig(U.Access);
-   if (Cnf == 0)
-      return false;
-   
-   Workers = new Worker(this,Cnf,Owner->Log);
-   Owner->Add(Workers);
-   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;
+   if (Workers == 0)
+   {
+      URI U(Name);
+      pkgAcquire::MethodConfig *Cnf = Owner->GetConfig(U.Access);
+      if (Cnf == 0)
+        return false;
+      
+      Workers = new Worker(this,Cnf,Owner->Log);
+      Owner->Add(Workers);
+      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();
 }
                                                                        /*}}}*/
 // Queue::Shutdown - Shutdown the worker processes                     /*{{{*/
 // ---------------------------------------------------------------------
-/* */
-bool pkgAcquire::Queue::Shutdown()
+/* If final is true then all workers are eliminated, otherwise only workers
+   that do not need cleanup are removed */
+bool pkgAcquire::Queue::Shutdown(bool Final)
 {
    // Delete all of the workers
-   while (Workers != 0)
+   pkgAcquire::Worker **Cur = &Workers;
+   while (*Cur != 0)
    {
-      pkgAcquire::Worker *Jnk = Workers;
-      Workers = Workers->NextQueue;
-      Owner->Remove(Jnk);
-      delete Jnk;
+      pkgAcquire::Worker *Jnk = *Cur;
+      if (Final == true || Jnk->GetConf()->NeedsCleanup == false)
+      {
+        *Cur = Jnk->NextQueue;
+        Owner->Remove(Jnk);
+        delete Jnk;
+      }
+      else
+        Cur = &(*Cur)->NextQueue;      
    }
    
    return true;
@@ -674,7 +726,7 @@ void pkgAcquire::Queue::Bump()
 // AcquireStatus::pkgAcquireStatus - Constructor                       /*{{{*/
 // ---------------------------------------------------------------------
 /* */
-pkgAcquireStatus::pkgAcquireStatus()
+pkgAcquireStatus::pkgAcquireStatus() : Update(true), MorePulses(false)
 {
    Start();
 }
@@ -694,7 +746,7 @@ bool pkgAcquireStatus::Pulse(pkgAcquire *Owner)
    // 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++;
@@ -704,7 +756,7 @@ bool pkgAcquireStatus::Pulse(pkgAcquire *Owner)
       // Totally ignore local items
       if ((*I)->Local == true)
         continue;
-      
+
       TotalBytes += (*I)->FileSize;
       if ((*I)->Complete == true)
         CurrentBytes += (*I)->FileSize;
@@ -732,6 +784,10 @@ bool pkgAcquireStatus::Pulse(pkgAcquire *Owner)
       TotalBytes = 1;
    if (Unknown == Count)
       TotalBytes = Unknown;
+
+   // Wha?! Is not supposed to happen.
+   if (CurrentBytes > TotalBytes)
+      CurrentBytes = TotalBytes;
    
    // Compute the CPS
    struct timeval NewTime;
@@ -752,6 +808,32 @@ bool pkgAcquireStatus::Pulse(pkgAcquire *Owner)
       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;
 }
                                                                        /*}}}*/
@@ -781,24 +863,16 @@ void pkgAcquireStatus::Stop()
    struct timeval NewTime;
    gettimeofday(&NewTime,0);
    
-   // Compute the delta time with full accuracy
-   long usdiff = NewTime.tv_usec - StartTime.tv_usec;
-   long sdiff = NewTime.tv_sec - StartTime.tv_sec;
+   double Delta = NewTime.tv_sec - StartTime.tv_sec + 
+                  (NewTime.tv_usec - StartTime.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 = FetchedBytes/(sdiff + usdiff/1000000.0);
+      CurrentCPS = FetchedBytes/Delta;
    LastBytes = CurrentBytes;
-   ElapsedTime = sdiff;
+   ElapsedTime = (unsigned int)Delta;
 }
                                                                        /*}}}*/
 // AcquireStatus::Fetched - Called when a byte set has been fetched    /*{{{*/