apt-pkg/acquire.h

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