apt-pkg/acquire.h

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: acquire.h,v 1.19 1999/01/30 06:07:24 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    bool Run();
  95
  96    // Simple iteration mechanism
  97    inline Worker *WorkersBegin() {return Workers;};
  98    Worker *WorkerStep(Worker *I);
  99    inline Item **ItemsBegin() {return Items.begin();};
 100    inline Item **ItemsEnd() {return Items.end();};
 101
 102    // Iterate over queued Item URIs
 103    class UriIterator;
 104    UriIterator UriBegin();
 105    UriIterator UriEnd();
 106
 107    // Cleans out the download dir
 108    bool Clean(string Dir);
 109
 110    // Returns the size of the total download set
 111    unsigned long TotalNeeded();
 112    unsigned long FetchNeeded();
 113
 114    pkgAcquire(pkgAcquireStatus *Log = 0);
 115    ~pkgAcquire();
 116 };
 117
 118 // Description of an Item+URI
 119 struct pkgAcquire::ItemDesc
 120 {
 121    string URI;
 122    string Description;
 123    string ShortDesc;
 124    Item *Owner;
 125 };
 126
 127 // List of possible items queued for download.
 128 class pkgAcquire::Queue
 129 {
 130    friend pkgAcquire;
 131    friend pkgAcquire::UriIterator;
 132    Queue *Next;
 133
 134    protected:
 135
 136    // Queued item
 137    struct QItem : pkgAcquire::ItemDesc
 138    {
 139       QItem *Next;
 140       pkgAcquire::Worker *Worker;
 141
 142       void operator =(pkgAcquire::ItemDesc const &I)
 143       {
 144          URI = I.URI;
 145          Description = I.Description;
 146          ShortDesc = I.ShortDesc;
 147          Owner = I.Owner;
 148       };
 149    };
 150
 151    // Name of the queue
 152    string Name;
 153
 154    // Items queued into this queue
 155    QItem *Items;
 156    pkgAcquire::Worker *Workers;
 157    pkgAcquire *Owner;
 158    signed long PipeDepth;
 159    unsigned long MaxPipeDepth;
 160
 161    public:
 162
 163    // Put an item into this queue
 164    void Enqueue(ItemDesc &Item);
 165    bool Dequeue(Item *Owner);
 166
 167    // Find a Queued item
 168    QItem *FindItem(string URI,pkgAcquire::Worker *Owner);
 169    bool ItemStart(QItem *Itm,unsigned long Size);
 170    bool ItemDone(QItem *Itm);
 171
 172    bool Startup();
 173    bool Shutdown();
 174    bool Cycle();
 175    void Bump();
 176
 177    Queue(string Name,pkgAcquire *Owner);
 178    ~Queue();
 179 };
 180
 181 class pkgAcquire::UriIterator
 182 {
 183    pkgAcquire::Queue *CurQ;
 184    pkgAcquire::Queue::QItem *CurItem;
 185
 186    public:
 187
 188    // Advance to the next item
 189    inline void operator ++() {operator ++();};
 190    void operator ++(int)
 191    {
 192       CurItem = CurItem->Next;
 193       while (CurItem == 0 && CurQ != 0)
 194       {
 195          CurItem = CurQ->Items;
 196          CurQ = CurQ->Next;
 197       }
 198    };
 199
 200    // Accessors
 201    inline pkgAcquire::ItemDesc const *operator ->() const {return CurItem;};
 202    inline bool operator !=(UriIterator const &rhs) const {return rhs.CurQ != CurQ || rhs.CurItem != CurItem;};
 203    inline bool operator ==(UriIterator const &rhs) const {return rhs.CurQ == CurQ && rhs.CurItem == CurItem;};
 204
 205    UriIterator(pkgAcquire::Queue *Q) : CurQ(Q), CurItem(0)
 206    {
 207       while (CurItem == 0 && CurQ != 0)
 208       {
 209          CurItem = CurQ->Items;
 210          CurQ = CurQ->Next;
 211       }
 212    }
 213 };
 214
 215 // Configuration information from each method
 216 struct pkgAcquire::MethodConfig
 217 {
 218    MethodConfig *Next;
 219
 220    string Access;
 221
 222    string Version;
 223    bool SingleInstance;
 224    bool Pipeline;
 225    bool SendConfig;
 226    bool LocalOnly;
 227
 228    MethodConfig();
 229 };
 230
 231 class pkgAcquireStatus
 232 {
 233    protected:
 234
 235    struct timeval Time;
 236    struct timeval StartTime;
 237    unsigned long LastBytes;
 238    double CurrentCPS;
 239    unsigned long CurrentBytes;
 240    unsigned long TotalBytes;
 241    unsigned long FetchedBytes;
 242    unsigned long ElapsedTime;
 243    unsigned long TotalItems;
 244    unsigned long CurrentItems;
 245
 246    public:
 247
 248    bool Update;
 249
 250    // Called by items when they have finished a real download
 251    virtual void Fetched(unsigned long Size,unsigned long ResumePoint);
 252
 253    // Called to change media
 254    virtual bool MediaChange(string Media,string Drive) = 0;
 255
 256    // Each of these is called by the workers when an event occures
 257    virtual void IMSHit(pkgAcquire::ItemDesc &Itm) {};
 258    virtual void Fetch(pkgAcquire::ItemDesc &Itm) {};
 259    virtual void Done(pkgAcquire::ItemDesc &Itm) {};
 260    virtual void Fail(pkgAcquire::ItemDesc &Itm) {};
 261    virtual void Pulse(pkgAcquire *Owner);
 262    virtual void Start();
 263    virtual void Stop();
 264
 265    pkgAcquireStatus();
 266    virtual ~pkgAcquireStatus() {};
 267 };
 268
 269 #endif