// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
-// $Id: acquire.h,v 1.3 1998/10/22 04:56:44 jgg Exp $
+// $Id: acquire.h,v 1.29 2001/05/22 04:17:18 jgg 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;
- friend Queue;
+ struct ItemDesc;
+ friend class Item;
+ friend class Queue;
+
+ typedef vector<Item *>::iterator ItemIterator;
+ typedef vector<Item *>::const_iterator ItemCIterator;
protected:
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 Add(Worker *Work);
void Remove(Worker *Work);
- void Enqueue(Item *Item,string URI,string Description);
+ void Enqueue(ItemDesc &Item);
void Dequeue(Item *Item);
- string QueueName(string URI);
+ string QueueName(string URI,MethodConfig const *&Config);
// FDSET managers for derived classes
- void SetFds(int &Fd,fd_set *RSet,fd_set *WSet);
- void RunFds(fd_set *RSet,fd_set *WSet);
+ 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);
- bool Run();
+
+ enum RunResult {Continue,Failed,Cancelled};
+
+ RunResult Run();
+ 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
+ struct QItem : pkgAcquire::ItemDesc
{
- QItem *Next;
+ QItem *Next;
+ pkgAcquire::Worker *Worker;
- string URI;
- string Description;
- Item *Owner;
- };
+ void operator =(pkgAcquire::ItemDesc const &I)
+ {
+ URI = I.URI;
+ Description = I.Description;
+ ShortDesc = I.ShortDesc;
+ Owner = I.Owner;
+ };
+ };
// Name of the queue
string Name;
QItem *Items;
pkgAcquire::Worker *Workers;
pkgAcquire *Owner;
+ signed long PipeDepth;
+ unsigned long MaxPipeDepth;
public:
// Put an item into this queue
- void Enqueue(Item *Owner,string URI,string Description);
- void Dequeue(Item *Owner);
+ 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 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
{
string Version;
bool SingleInstance;
- bool PreScan;
bool Pipeline;
bool SendConfig;
+ bool LocalOnly;
+ bool NeedsCleanup;
+ bool Removable;
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