apt-pkg/acquire.h

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: acquire.h,v 1.11 1998/11/12 04:10:55 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);
  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    // Cleans out the download dir
 103    bool Clean(string Dir);
 104
 105    pkgAcquire(pkgAcquireStatus *Log = 0);
 106    ~pkgAcquire();
 107 };
 108
 109 // Description of an Item+URI
 110 struct pkgAcquire::ItemDesc
 111 {
 112    string URI;
 113    string Description;
 114    string ShortDesc;
 115    Item *Owner;
 116 };
 117
 118 // List of possible items queued for download.
 119 class pkgAcquire::Queue
 120 {
 121    friend pkgAcquire;
 122    Queue *Next;
 123
 124    protected:
 125
 126    // Queued item
 127    struct QItem : pkgAcquire::ItemDesc
 128    {
 129       QItem *Next;
 130       pkgAcquire::Worker *Worker;
 131
 132       void operator =(pkgAcquire::ItemDesc const &I)
 133       {
 134          URI = I.URI;
 135          Description = I.Description;
 136          ShortDesc = I.ShortDesc;
 137          Owner = I.Owner;
 138       };
 139    };
 140
 141    // Name of the queue
 142    string Name;
 143
 144    // Items queued into this queue
 145    QItem *Items;
 146    pkgAcquire::Worker *Workers;
 147    pkgAcquire *Owner;
 148
 149    public:
 150
 151    // Put an item into this queue
 152    void Enqueue(ItemDesc &Item);
 153    bool Dequeue(Item *Owner);
 154
 155    // Find a Queued item
 156    QItem *FindItem(string URI,pkgAcquire::Worker *Owner);
 157    bool ItemStart(QItem *Itm,unsigned long Size);
 158    bool ItemDone(QItem *Itm);
 159
 160    bool Startup();
 161    bool Shutdown();
 162    bool Cycle();
 163    void Bump();
 164
 165    Queue(string Name,pkgAcquire *Owner);
 166    ~Queue();
 167 };
 168
 169 // Configuration information from each method
 170 struct pkgAcquire::MethodConfig
 171 {
 172    MethodConfig *Next;
 173
 174    string Access;
 175
 176    string Version;
 177    bool SingleInstance;
 178    bool PreScan;
 179    bool Pipeline;
 180    bool SendConfig;
 181
 182    MethodConfig();
 183 };
 184
 185 class pkgAcquireStatus
 186 {
 187    protected:
 188
 189    struct timeval Time;
 190    struct timeval StartTime;
 191    unsigned long LastBytes;
 192    double CurrentCPS;
 193    unsigned long CurrentBytes;
 194    unsigned long TotalBytes;
 195    unsigned long FetchedBytes;
 196    unsigned long ElapsedTime;
 197
 198    public:
 199
 200    bool Update;
 201
 202    // Called by items when they have finished a real download
 203    virtual void Fetched(unsigned long Size,unsigned long ResumePoint);
 204
 205    // Each of these is called by the workers when an event occures
 206    virtual void IMSHit(pkgAcquire::ItemDesc &Itm) {};
 207    virtual void Fetch(pkgAcquire::ItemDesc &Itm) {};
 208    virtual void Done(pkgAcquire::ItemDesc &Itm) {};
 209    virtual void Fail(pkgAcquire::ItemDesc &Itm) {};
 210    virtual void Pulse(pkgAcquire *Owner);
 211    virtual void Start();
 212    virtual void Stop();
 213
 214    pkgAcquireStatus();
 215    virtual ~pkgAcquireStatus() {};
 216 };
 217
 218 #endif