apt-pkg/acquire.h

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: acquire.h,v 1.21 1999/06/13 05:06:40 jgg Exp $
   4 /* ######################################################################
   5
   6    Acquire - File Acquiration
   7
   8    This module contians the Acquire system. It is responsible for bringing
   9    files into the local pathname space. It deals with URIs for files and
  10    URI handlers responsible for downloading or finding the URIs.
  11
  12    Each file to download is represented by an Acquire::Item class subclassed
  13    into a specialization. The Item class can add itself to several URI
  14    acquire queues each prioritized by the download scheduler. When the
  15    system is run the proper URI handlers are spawned and the the acquire
  16    queues are fed into the handlers by the schedular until the queues are
  17    empty. This allows for an Item to be downloaded from an alternate source
  18    if the first try turns out to fail. It also alows concurrent downloading
  19    of multiple items from multiple sources as well as dynamic balancing
  20    of load between the sources.
  21
  22    Schedualing of downloads is done on a first ask first get basis. This
  23    preserves the order of the download as much as possible. And means the
  24    fastest source will tend to process the largest number of files.
  25
  26    Internal methods and queues for performing gzip decompression,
  27    md5sum hashing and file copying are provided to allow items to apply
  28    a number of transformations to the data files they are working with.
  29
  30    ##################################################################### */
  31                                                                         /*}}}*/
  32 #ifndef PKGLIB_ACQUIRE_H
  33 #define PKGLIB_ACQUIRE_H
  34
  35 #include <vector>
  36 #include <string>
  37
  38 #ifdef __GNUG__
  39 #pragma interface "apt-pkg/acquire.h"
  40 #endif
  41
  42 #include <sys/time.h>
  43 #include <unistd.h>
  44
  45 class pkgAcquireStatus;
  46 class pkgAcquire
  47 {
  48    public:
  49
  50    class Item;
  51    class Queue;
  52    class Worker;
  53    struct MethodConfig;
  54    struct ItemDesc;
  55    friend Item;
  56    friend Queue;
  57
  58    protected:
  59
  60    // List of items to fetch
  61    vector<Item *> Items;
  62
  63    // List of active queues and fetched method configuration parameters
  64    Queue *Queues;
  65    Worker *Workers;
  66    MethodConfig *Configs;
  67    pkgAcquireStatus *Log;
  68    unsigned long ToFetch;
  69
  70    // Configurable parameters for the schedular
  71    enum {QueueHost,QueueAccess} QueueMode;
  72    bool Debug;
  73    bool Running;
  74
  75    void Add(Item *Item);
  76    void Remove(Item *Item);
  77    void Add(Worker *Work);
  78    void Remove(Worker *Work);
  79
  80    void Enqueue(ItemDesc &Item);
  81    void Dequeue(Item *Item);
  82    string QueueName(string URI,MethodConfig const *&Config);
  83
  84    // FDSET managers for derived classes
  85    void SetFds(int &Fd,fd_set *RSet,fd_set *WSet);
  86    void RunFds(fd_set *RSet,fd_set *WSet);
  87
  88    // A queue calls this when it dequeues an item
  89    void Bump();
  90
  91    public:
  92
  93    MethodConfig *GetConfig(string Access);
  94
  95    enum RunResult {Continue,Failed,Cancelled};
  96
  97    RunResult Run();
  98
  99    // Simple iteration mechanism
 100    inline Worker *WorkersBegin() {return Workers;};
 101    Worker *WorkerStep(Worker *I);
 102    inline Item **ItemsBegin() {return Items.begin();};
 103    inline Item **ItemsEnd() {return Items.end();};
 104
 105    // Iterate over queued Item URIs
 106    class UriIterator;
 107    UriIterator UriBegin();
 108    UriIterator UriEnd();
 109
 110    // Cleans out the download dir
 111    bool Clean(string Dir);
 112
 113    // Returns the size of the total download set
 114    unsigned long TotalNeeded();
 115    unsigned long FetchNeeded();
 116    unsigned long PartialPresent();
 117
 118    pkgAcquire(pkgAcquireStatus *Log = 0);
 119    ~pkgAcquire();
 120 };
 121
 122 // Description of an Item+URI
 123 struct pkgAcquire::ItemDesc
 124 {
 125    string URI;
 126    string Description;
 127    string ShortDesc;
 128    Item *Owner;
 129 };
 130
 131 // List of possible items queued for download.
 132 class pkgAcquire::Queue
 133 {
 134    friend pkgAcquire;
 135    friend pkgAcquire::UriIterator;
 136    Queue *Next;
 137
 138    protected:
 139
 140    // Queued item
 141    struct QItem : pkgAcquire::ItemDesc
 142    {
 143       QItem *Next;
 144       pkgAcquire::Worker *Worker;
 145
 146       void operator =(pkgAcquire::ItemDesc const &I)
 147       {
 148          URI = I.URI;
 149          Description = I.Description;
 150          ShortDesc = I.ShortDesc;
 151          Owner = I.Owner;
 152       };
 153    };
 154
 155    // Name of the queue
 156    string Name;
 157
 158    // Items queued into this queue
 159    QItem *Items;
 160    pkgAcquire::Worker *Workers;
 161    pkgAcquire *Owner;
 162    signed long PipeDepth;
 163    unsigned long MaxPipeDepth;
 164
 165    public:
 166
 167    // Put an item into this queue
 168    void Enqueue(ItemDesc &Item);
 169    bool Dequeue(Item *Owner);
 170
 171    // Find a Queued item
 172    QItem *FindItem(string URI,pkgAcquire::Worker *Owner);
 173    bool ItemStart(QItem *Itm,unsigned long Size);
 174    bool ItemDone(QItem *Itm);
 175
 176    bool Startup();
 177    bool Shutdown();
 178    bool Cycle();
 179    void Bump();
 180
 181    Queue(string Name,pkgAcquire *Owner);
 182    ~Queue();
 183 };
 184
 185 class pkgAcquire::UriIterator
 186 {
 187    pkgAcquire::Queue *CurQ;
 188    pkgAcquire::Queue::QItem *CurItem;
 189
 190    public:
 191
 192    // Advance to the next item
 193    inline void operator ++() {operator ++();};
 194    void operator ++(int)
 195    {
 196       CurItem = CurItem->Next;
 197       while (CurItem == 0 && CurQ != 0)
 198       {
 199          CurItem = CurQ->Items;
 200          CurQ = CurQ->Next;
 201       }
 202    };
 203
 204    // Accessors
 205    inline pkgAcquire::ItemDesc const *operator ->() const {return CurItem;};
 206    inline bool operator !=(UriIterator const &rhs) const {return rhs.CurQ != CurQ || rhs.CurItem != CurItem;};
 207    inline bool operator ==(UriIterator const &rhs) const {return rhs.CurQ == CurQ && rhs.CurItem == CurItem;};
 208
 209    UriIterator(pkgAcquire::Queue *Q) : CurQ(Q), CurItem(0)
 210    {
 211       while (CurItem == 0 && CurQ != 0)
 212       {
 213          CurItem = CurQ->Items;
 214          CurQ = CurQ->Next;
 215       }
 216    }
 217 };
 218
 219 // Configuration information from each method
 220 struct pkgAcquire::MethodConfig
 221 {
 222    MethodConfig *Next;
 223
 224    string Access;
 225
 226    string Version;
 227    bool SingleInstance;
 228    bool Pipeline;
 229    bool SendConfig;
 230    bool LocalOnly;
 231
 232    MethodConfig();
 233 };
 234
 235 class pkgAcquireStatus
 236 {
 237    protected:
 238
 239    struct timeval Time;
 240    struct timeval StartTime;
 241    unsigned long LastBytes;
 242    double CurrentCPS;
 243    unsigned long CurrentBytes;
 244    unsigned long TotalBytes;
 245    unsigned long FetchedBytes;
 246    unsigned long ElapsedTime;
 247    unsigned long TotalItems;
 248    unsigned long CurrentItems;
 249
 250    public:
 251
 252    bool Update;
 253
 254    // Called by items when they have finished a real download
 255    virtual void Fetched(unsigned long Size,unsigned long ResumePoint);
 256
 257    // Called to change media
 258    virtual bool MediaChange(string Media,string Drive) = 0;
 259
 260    // Each of these is called by the workers when an event occures
 261    virtual void IMSHit(pkgAcquire::ItemDesc &Itm) {};
 262    virtual void Fetch(pkgAcquire::ItemDesc &Itm) {};
 263    virtual void Done(pkgAcquire::ItemDesc &Itm) {};
 264    virtual void Fail(pkgAcquire::ItemDesc &Itm) {};
 265    virtual bool Pulse(pkgAcquire *Owner); // returns false on user cancel
 266    virtual void Start();
 267    virtual void Stop();
 268
 269    pkgAcquireStatus();
 270    virtual ~pkgAcquireStatus() {};
 271 };
 272
 273 #endif