* added a callback to pkgMarkUsed() so that frontend can extend the root-set of the...

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

diff --git a/apt-pkg/acquire.h b/apt-pkg/acquire.h
index b728d21339daa493ea88b2d962eae82bd7dfc78f..27bb3d363a985b588c5d199d8c15371d919590eb 100644 (file)
--- a/apt-pkg/acquire.h
+++ b/apt-pkg/acquire.h
@@ -1,6 +1,6 @@
 // -*- mode: cpp; mode: fold -*-
 // Description                                                         /*{{{*/
 // -*- mode: cpp; mode: fold -*-
 // Description                                                         /*{{{*/

-// $Id: acquire.h,v 1.1 1998/10/15 06:59:59 jgg Exp $
+// $Id: acquire.h,v 1.29.2.1 2003/12/24 23:09:17 mdz Exp $

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


@@ -35,10 +35,17 @@
 #include <vector>
 #include <string>
 
 #include <vector>
 #include <string>
 

+using std::vector;
+using std::string;
+

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

+#include <sys/time.h>
+#include <unistd.h>
+
+class pkgAcquireStatus;

 class pkgAcquire
 {   
    public:
 class pkgAcquire
 {   
    public:


@@ -47,51 +54,231 @@ class pkgAcquire
    class Queue;
    class Worker;
    struct MethodConfig;
    class Queue;
    class Worker;
    struct MethodConfig;

-   friend Item;
+   struct ItemDesc;
+   friend class Item;
+   friend class Queue;
+
+   typedef vector<Item *>::iterator ItemIterator;
+   typedef vector<Item *>::const_iterator ItemCIterator;

    
    protected:
    
    
    protected:
    

+   // List of items to fetch

    vector<Item *> Items;
    vector<Item *> Items;

+   
+   // List of active queues and fetched method configuration parameters

    Queue *Queues;
    Queue *Queues;

+   Worker *Workers;

    MethodConfig *Configs;
    MethodConfig *Configs;

+   pkgAcquireStatus *Log;
+   unsigned long ToFetch;
+
+   // Configurable parameters for the schedular
+   enum {QueueHost,QueueAccess} QueueMode;
+   bool Debug;
+   bool Running;

    
    void Add(Item *Item);
    void Remove(Item *Item);
    
    void Add(Item *Item);
    void Remove(Item *Item);

-   void Enqueue(Item *Item,string URI);
+   void Add(Worker *Work);
+   void Remove(Worker *Work);
+   
+   void Enqueue(ItemDesc &Item);
+   void Dequeue(Item *Item);
+   string QueueName(string URI,MethodConfig const *&Config);
+
+   // FDSET managers for derived classes
+   virtual void SetFds(int &Fd,fd_set *RSet,fd_set *WSet);
+   virtual void RunFds(fd_set *RSet,fd_set *WSet);   
+
+   // A queue calls this when it dequeues an item
+   void Bump();

    
    public:
    
    public:

+
+   MethodConfig *GetConfig(string Access);
+
+   enum RunResult {Continue,Failed,Cancelled};
+
+   RunResult Run(int PulseIntervall=500000);
+   void Shutdown();
+   
+   // Simple iteration mechanism
+   inline Worker *WorkersBegin() {return Workers;};
+   Worker *WorkerStep(Worker *I);
+   inline ItemIterator ItemsBegin() {return Items.begin();};
+   inline ItemIterator ItemsEnd() {return Items.end();};

    
    

-   pkgAcquire();
-   ~pkgAcquire();
+   // Iterate over queued Item URIs
+   class UriIterator;
+   UriIterator UriBegin();
+   UriIterator UriEnd();
+   
+   // Cleans out the download dir
+   bool Clean(string Dir);
+
+   // Returns the size of the total download set
+   double TotalNeeded();
+   double FetchNeeded();
+   double PartialPresent();
+
+   pkgAcquire(pkgAcquireStatus *Log = 0);
+   virtual ~pkgAcquire();
+};
+
+// Description of an Item+URI
+struct pkgAcquire::ItemDesc
+{
+   string URI;
+   string Description;
+   string ShortDesc;
+   Item *Owner;

 };
 
 // List of possible items queued for download.
 class pkgAcquire::Queue
 {
 };
 
 // List of possible items queued for download.
 class pkgAcquire::Queue
 {

-   friend pkgAcquire;
+   friend class pkgAcquire;
+   friend class pkgAcquire::UriIterator;
+   friend class pkgAcquire::Worker;

    Queue *Next;
    
    protected:
    Queue *Next;
    
    protected:

+
+   // Queued item
+   struct QItem : pkgAcquire::ItemDesc
+   {
+      QItem *Next;      
+      pkgAcquire::Worker *Worker;
+      
+      void operator =(pkgAcquire::ItemDesc const &I)
+      {
+        URI = I.URI;
+        Description = I.Description;
+        ShortDesc = I.ShortDesc;
+        Owner = I.Owner;
+      };
+   };

    
    

-   string Access;
-   string URIMatch;
+   // Name of the queue
+   string Name;
+
+   // Items queued into this queue
+   QItem *Items;
+   pkgAcquire::Worker *Workers;
+   pkgAcquire *Owner;
+   signed long PipeDepth;
+   unsigned long MaxPipeDepth;

    
    

-   vector<Item *> Items;
+   public:
+   
+   // Put an item into this queue
+   void Enqueue(ItemDesc &Item);
+   bool Dequeue(Item *Owner);
+
+   // Find a Queued item
+   QItem *FindItem(string URI,pkgAcquire::Worker *Owner);
+   bool ItemStart(QItem *Itm,unsigned long Size);
+   bool ItemDone(QItem *Itm);
+   
+   bool Startup();
+   bool Shutdown(bool Final);
+   bool Cycle();
+   void Bump();
+   
+   Queue(string Name,pkgAcquire *Owner);
+   ~Queue();
+};
+
+class pkgAcquire::UriIterator
+{
+   pkgAcquire::Queue *CurQ;
+   pkgAcquire::Queue::QItem *CurItem;

    
    public:
    
    public:

+   
+   // Advance to the next item
+   inline void operator ++() {operator ++();};
+   void operator ++(int)
+   {
+      CurItem = CurItem->Next;
+      while (CurItem == 0 && CurQ != 0)
+      {
+        CurItem = CurQ->Items;
+        CurQ = CurQ->Next;
+      }
+   };
+   
+   // Accessors
+   inline pkgAcquire::ItemDesc const *operator ->() const {return CurItem;};
+   inline bool operator !=(UriIterator const &rhs) const {return rhs.CurQ != CurQ || rhs.CurItem != CurItem;};
+   inline bool operator ==(UriIterator const &rhs) const {return rhs.CurQ == CurQ && rhs.CurItem == CurItem;};
+   
+   UriIterator(pkgAcquire::Queue *Q) : CurQ(Q), CurItem(0)
+   {
+      while (CurItem == 0 && CurQ != 0)
+      {
+        CurItem = CurQ->Items;
+        CurQ = CurQ->Next;
+      }
+   }   

 };
 
 // Configuration information from each method
 struct pkgAcquire::MethodConfig
 {
 };
 
 // Configuration information from each method
 struct pkgAcquire::MethodConfig
 {

+   MethodConfig *Next;
+   

    string Access;
 
    string Version;
    bool SingleInstance;
    string Access;
 
    string Version;
    bool SingleInstance;

-   bool PreScan;
+   bool Pipeline;
+   bool SendConfig;
+   bool LocalOnly;
+   bool NeedsCleanup;
+   bool Removable;

    
    MethodConfig();
    
    MethodConfig();

-   ~MethodConfig();
+};
+
+class pkgAcquireStatus
+{
+   protected:
+   
+   struct timeval Time;
+   struct timeval StartTime;
+   double LastBytes;
+   double CurrentCPS;
+   double CurrentBytes;
+   double TotalBytes;
+   double FetchedBytes;
+   unsigned long ElapsedTime;
+   unsigned long TotalItems;
+   unsigned long CurrentItems;
+   
+   public:
+
+   bool Update;
+   bool MorePulses;
+      
+   // Called by items when they have finished a real download
+   virtual void Fetched(unsigned long Size,unsigned long ResumePoint);
+   
+   // Called to change media
+   virtual bool MediaChange(string Media,string Drive) = 0;
+   
+   // Each of these is called by the workers when an event occures
+   virtual void IMSHit(pkgAcquire::ItemDesc &/*Itm*/) {};
+   virtual void Fetch(pkgAcquire::ItemDesc &/*Itm*/) {};
+   virtual void Done(pkgAcquire::ItemDesc &/*Itm*/) {};
+   virtual void Fail(pkgAcquire::ItemDesc &/*Itm*/) {};
+   virtual bool Pulse(pkgAcquire *Owner); // returns false on user cancel
+   virtual void Start();
+   virtual void Stop();
+   
+   pkgAcquireStatus();
+   virtual ~pkgAcquireStatus() {};

 };
 
 #endif
 };
 
 #endif