// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
-// $Id: acquire.h,v 1.1 1998/10/15 06:59:59 jgg Exp $
+// $Id: acquire.h,v 1.29.2.1 2003/12/24 23:09:17 mdz Exp $
/* ######################################################################
Acquire - File Acquiration
#include <vector>
#include <string>
+using std::vector;
+using std::string;
+
#ifdef __GNUG__
#pragma interface "apt-pkg/acquire.h"
#endif
+#include <sys/time.h>
+#include <unistd.h>
+
+class pkgAcquireStatus;
class pkgAcquire
{
public:
class Queue;
class Worker;
struct MethodConfig;
- friend Item;
+ struct ItemDesc;
+ friend class Item;
+ friend class Queue;
+
+ typedef vector<Item *>::iterator ItemIterator;
+ typedef vector<Item *>::const_iterator ItemCIterator;
protected:
+ // List of items to fetch
vector<Item *> Items;
+
+ // List of active queues and fetched method configuration parameters
Queue *Queues;
+ Worker *Workers;
MethodConfig *Configs;
+ pkgAcquireStatus *Log;
+ unsigned long ToFetch;
+
+ // Configurable parameters for the schedular
+ enum {QueueHost,QueueAccess} QueueMode;
+ bool Debug;
+ bool Running;
void Add(Item *Item);
void Remove(Item *Item);
- void Enqueue(Item *Item,string URI);
+ void Add(Worker *Work);
+ void Remove(Worker *Work);
+
+ void Enqueue(ItemDesc &Item);
+ void Dequeue(Item *Item);
+ string QueueName(string URI,MethodConfig const *&Config);
+
+ // FDSET managers for derived classes
+ virtual void SetFds(int &Fd,fd_set *RSet,fd_set *WSet);
+ virtual void RunFds(fd_set *RSet,fd_set *WSet);
+
+ // A queue calls this when it dequeues an item
+ void Bump();
public:
+
+ MethodConfig *GetConfig(string Access);
+
+ enum RunResult {Continue,Failed,Cancelled};
+
+ RunResult Run(int PulseIntervall=500000);
+ void Shutdown();
+
+ // Simple iteration mechanism
+ inline Worker *WorkersBegin() {return Workers;};
+ Worker *WorkerStep(Worker *I);
+ inline ItemIterator ItemsBegin() {return Items.begin();};
+ inline ItemIterator ItemsEnd() {return Items.end();};
- pkgAcquire();
- ~pkgAcquire();
+ // Iterate over queued Item URIs
+ class UriIterator;
+ UriIterator UriBegin();
+ UriIterator UriEnd();
+
+ // Cleans out the download dir
+ bool Clean(string Dir);
+
+ // Returns the size of the total download set
+ double TotalNeeded();
+ double FetchNeeded();
+ double PartialPresent();
+
+ pkgAcquire(pkgAcquireStatus *Log = 0);
+ virtual ~pkgAcquire();
+};
+
+// Description of an Item+URI
+struct pkgAcquire::ItemDesc
+{
+ string URI;
+ string Description;
+ string ShortDesc;
+ Item *Owner;
};
// List of possible items queued for download.
class pkgAcquire::Queue
{
- friend pkgAcquire;
+ friend class pkgAcquire;
+ friend class pkgAcquire::UriIterator;
+ friend class pkgAcquire::Worker;
Queue *Next;
protected:
+
+ // Queued item
+ struct QItem : pkgAcquire::ItemDesc
+ {
+ QItem *Next;
+ pkgAcquire::Worker *Worker;
+
+ void operator =(pkgAcquire::ItemDesc const &I)
+ {
+ URI = I.URI;
+ Description = I.Description;
+ ShortDesc = I.ShortDesc;
+ Owner = I.Owner;
+ };
+ };
- string Access;
- string URIMatch;
+ // Name of the queue
+ string Name;
+
+ // Items queued into this queue
+ QItem *Items;
+ pkgAcquire::Worker *Workers;
+ pkgAcquire *Owner;
+ signed long PipeDepth;
+ unsigned long MaxPipeDepth;
- vector<Item *> Items;
+ public:
+
+ // Put an item into this queue
+ void Enqueue(ItemDesc &Item);
+ bool Dequeue(Item *Owner);
+
+ // Find a Queued item
+ QItem *FindItem(string URI,pkgAcquire::Worker *Owner);
+ bool ItemStart(QItem *Itm,unsigned long Size);
+ bool ItemDone(QItem *Itm);
+
+ bool Startup();
+ bool Shutdown(bool Final);
+ bool Cycle();
+ void Bump();
+
+ Queue(string Name,pkgAcquire *Owner);
+ ~Queue();
+};
+
+class pkgAcquire::UriIterator
+{
+ pkgAcquire::Queue *CurQ;
+ pkgAcquire::Queue::QItem *CurItem;
public:
+
+ // Advance to the next item
+ inline void operator ++() {operator ++();};
+ void operator ++(int)
+ {
+ CurItem = CurItem->Next;
+ while (CurItem == 0 && CurQ != 0)
+ {
+ CurItem = CurQ->Items;
+ CurQ = CurQ->Next;
+ }
+ };
+
+ // Accessors
+ inline pkgAcquire::ItemDesc const *operator ->() const {return CurItem;};
+ inline bool operator !=(UriIterator const &rhs) const {return rhs.CurQ != CurQ || rhs.CurItem != CurItem;};
+ inline bool operator ==(UriIterator const &rhs) const {return rhs.CurQ == CurQ && rhs.CurItem == CurItem;};
+
+ UriIterator(pkgAcquire::Queue *Q) : CurQ(Q), CurItem(0)
+ {
+ while (CurItem == 0 && CurQ != 0)
+ {
+ CurItem = CurQ->Items;
+ CurQ = CurQ->Next;
+ }
+ }
};
// Configuration information from each method
struct pkgAcquire::MethodConfig
{
+ MethodConfig *Next;
+
string Access;
string Version;
bool SingleInstance;
- bool PreScan;
+ bool Pipeline;
+ bool SendConfig;
+ bool LocalOnly;
+ bool NeedsCleanup;
+ bool Removable;
MethodConfig();
- ~MethodConfig();
+};
+
+class pkgAcquireStatus
+{
+ protected:
+
+ struct timeval Time;
+ struct timeval StartTime;
+ double LastBytes;
+ double CurrentCPS;
+ double CurrentBytes;
+ double TotalBytes;
+ double FetchedBytes;
+ unsigned long ElapsedTime;
+ unsigned long TotalItems;
+ unsigned long CurrentItems;
+
+ public:
+
+ bool Update;
+ bool MorePulses;
+
+ // Called by items when they have finished a real download
+ virtual void Fetched(unsigned long Size,unsigned long ResumePoint);
+
+ // Called to change media
+ virtual bool MediaChange(string Media,string Drive) = 0;
+
+ // Each of these is called by the workers when an event occures
+ virtual void IMSHit(pkgAcquire::ItemDesc &/*Itm*/) {};
+ virtual void Fetch(pkgAcquire::ItemDesc &/*Itm*/) {};
+ virtual void Done(pkgAcquire::ItemDesc &/*Itm*/) {};
+ virtual void Fail(pkgAcquire::ItemDesc &/*Itm*/) {};
+ virtual bool Pulse(pkgAcquire *Owner); // returns false on user cancel
+ virtual void Start();
+ virtual void Stop();
+
+ pkgAcquireStatus();
+ virtual ~pkgAcquireStatus() {};
};
#endif
projects / apt.git / blobdiff