apt-pkg/acquire.h

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