apt-pkg/acquire.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: acquire.cc,v 1.35 1999/06/06 06:58:36 jgg Exp $
   4 /* ######################################################################
   5
   6    Acquire - File Acquiration
   7
   8    The core element for the schedual system is the concept of a named
   9    queue. Each queue is unique and each queue has a name derived from the
  10    URI. The degree of paralization can be controled by how the queue
  11    name is derived from the URI.
  12
  13    ##################################################################### */
  14                                                                         /*}}}*/
  15 // Include Files                                                        /*{{{*/
  16 #ifdef __GNUG__
  17 #pragma implementation "apt-pkg/acquire.h"
  18 #endif
  19 #include <apt-pkg/acquire.h>
  20 #include <apt-pkg/acquire-item.h>
  21 #include <apt-pkg/acquire-worker.h>
  22 #include <apt-pkg/configuration.h>
  23 #include <apt-pkg/error.h>
  24 #include <apt-pkg/strutl.h>
  25
  26 #include <dirent.h>
  27 #include <sys/time.h>
  28 #include <errno.h>
  29                                                                         /*}}}*/
  30
  31 // Acquire::pkgAcquire - Constructor                                    /*{{{*/
  32 // ---------------------------------------------------------------------
  33 /* We grab some runtime state from the configuration space */
  34 pkgAcquire::pkgAcquire(pkgAcquireStatus *Log) : Log(Log)
  35 {
  36    Queues = 0;
  37    Configs = 0;
  38    Workers = 0;
  39    ToFetch = 0;
  40    Running = false;
  41
  42    string Mode = _config->Find("Acquire::Queue-Mode","host");
  43    if (strcasecmp(Mode.c_str(),"host") == 0)
  44       QueueMode = QueueHost;
  45    if (strcasecmp(Mode.c_str(),"access") == 0)
  46       QueueMode = QueueAccess;
  47
  48    Debug = _config->FindB("Debug::pkgAcquire",false);
  49 }
  50                                                                         /*}}}*/
  51 // Acquire::~pkgAcquire - Destructor                                    /*{{{*/
  52 // ---------------------------------------------------------------------
  53 /* Free our memory, clean up the queues (destroy the workers) */
  54 pkgAcquire::~pkgAcquire()
  55 {
  56    while (Items.size() != 0)
  57       delete Items[0];
  58
  59    while (Configs != 0)
  60    {
  61       MethodConfig *Jnk = Configs;
  62       Configs = Configs->Next;
  63       delete Jnk;
  64    }
  65
  66    while (Queues != 0)
  67    {
  68       Queue *Jnk = Queues;
  69       Queues = Queues->Next;
  70       delete Jnk;
  71    }
  72 }
  73                                                                         /*}}}*/
  74 // Acquire::Add - Add a new item                                        /*{{{*/
  75 // ---------------------------------------------------------------------
  76 /* This puts an item on the acquire list. This list is mainly for tracking
  77    item status */
  78 void pkgAcquire::Add(Item *Itm)
  79 {
  80    Items.push_back(Itm);
  81 }
  82                                                                         /*}}}*/
  83 // Acquire::Remove - Remove a item                                      /*{{{*/
  84 // ---------------------------------------------------------------------
  85 /* Remove an item from the acquire list. This is usually not used.. */
  86 void pkgAcquire::Remove(Item *Itm)
  87 {
  88    for (vector<Item *>::iterator I = Items.begin(); I < Items.end(); I++)
  89    {
  90       if (*I == Itm)
  91          Items.erase(I);
  92    }
  93 }
  94                                                                         /*}}}*/
  95 // Acquire::Add - Add a worker                                          /*{{{*/
  96 // ---------------------------------------------------------------------
  97 /* A list of workers is kept so that the select loop can direct their FD
  98    usage. */
  99 void pkgAcquire::Add(Worker *Work)
 100 {
 101    Work->NextAcquire = Workers;
 102    Workers = Work;
 103 }
 104                                                                         /*}}}*/
 105 // Acquire::Remove - Remove a worker                                    /*{{{*/
 106 // ---------------------------------------------------------------------
 107 /* A worker has died. This can not be done while the select loop is running
 108    as it would require that RunFds could handling a changing list state and
 109    it cant.. */
 110 void pkgAcquire::Remove(Worker *Work)
 111 {
 112    if (Running == true)
 113       abort();
 114
 115    Worker **I = &Workers;
 116    for (; *I != 0;)
 117    {
 118       if (*I == Work)
 119          *I = (*I)->NextAcquire;
 120       else
 121          I = &(*I)->NextAcquire;
 122    }
 123 }
 124                                                                         /*}}}*/
 125 // Acquire::Enqueue - Queue an URI for fetching                         /*{{{*/
 126 // ---------------------------------------------------------------------
 127 /* This is the entry point for an item. An item calls this function when
 128    it is construction which creates a queue (based on the current queue
 129    mode) and puts the item in that queue. If the system is running then
 130    the queue might be started. */
 131 void pkgAcquire::Enqueue(ItemDesc &Item)
 132 {
 133    // Determine which queue to put the item in
 134    const MethodConfig *Config;
 135    string Name = QueueName(Item.URI,Config);
 136    if (Name.empty() == true)
 137       return;
 138
 139    // Find the queue structure
 140    Queue *I = Queues;
 141    for (; I != 0 && I->Name != Name; I = I->Next);
 142    if (I == 0)
 143    {
 144       I = new Queue(Name,this);
 145       I->Next = Queues;
 146       Queues = I;
 147
 148       if (Running == true)
 149          I->Startup();
 150    }
 151
 152    // See if this is a local only URI
 153    if (Config->LocalOnly == true && Item.Owner->Complete == false)
 154       Item.Owner->Local = true;
 155    Item.Owner->Status = Item::StatIdle;
 156
 157    // Queue it into the named queue
 158    I->Enqueue(Item);
 159    ToFetch++;
 160
 161    // Some trace stuff
 162    if (Debug == true)
 163    {
 164       clog << "Fetching " << Item.URI << endl;
 165       clog << " to " << Item.Owner->DestFile << endl;
 166       clog << " Queue is: " << Name << endl;
 167    }
 168 }
 169                                                                         /*}}}*/
 170 // Acquire::Dequeue - Remove an item from all queues                    /*{{{*/
 171 // ---------------------------------------------------------------------
 172 /* This is called when an item is finished being fetched. It removes it
 173    from all the queues */
 174 void pkgAcquire::Dequeue(Item *Itm)
 175 {
 176    Queue *I = Queues;
 177    bool Res = false;
 178    for (; I != 0; I = I->Next)
 179       Res |= I->Dequeue(Itm);
 180
 181    if (Debug == true)
 182       clog << "Dequeuing " << Itm->DestFile << endl;
 183    if (Res == true)
 184       ToFetch--;
 185 }
 186                                                                         /*}}}*/
 187 // Acquire::QueueName - Return the name of the queue for this URI       /*{{{*/
 188 // ---------------------------------------------------------------------
 189 /* The string returned depends on the configuration settings and the
 190    method parameters. Given something like http://foo.org/bar it can
 191    return http://foo.org or http */
 192 string pkgAcquire::QueueName(string Uri,MethodConfig const *&Config)
 193 {
 194    URI U(Uri);
 195
 196    Config = GetConfig(U.Access);
 197    if (Config == 0)
 198       return string();
 199
 200    /* Single-Instance methods get exactly one queue per URI. This is
 201       also used for the Access queue method  */
 202    if (Config->SingleInstance == true || QueueMode == QueueAccess)
 203        return U.Access;
 204
 205    return U.Access + ':' + U.Host;
 206 }
 207                                                                         /*}}}*/
 208 // Acquire::GetConfig - Fetch the configuration information             /*{{{*/
 209 // ---------------------------------------------------------------------
 210 /* This locates the configuration structure for an access method. If
 211    a config structure cannot be found a Worker will be created to
 212    retrieve it */
 213 pkgAcquire::MethodConfig *pkgAcquire::GetConfig(string Access)
 214 {
 215    // Search for an existing config
 216    MethodConfig *Conf;
 217    for (Conf = Configs; Conf != 0; Conf = Conf->Next)
 218       if (Conf->Access == Access)
 219          return Conf;
 220
 221    // Create the new config class
 222    Conf = new MethodConfig;
 223    Conf->Access = Access;
 224    Conf->Next = Configs;
 225    Configs = Conf;
 226
 227    // Create the worker to fetch the configuration
 228    Worker Work(Conf);
 229    if (Work.Start() == false)
 230       return 0;
 231
 232    return Conf;
 233 }
 234                                                                         /*}}}*/
 235 // Acquire::SetFds - Deal with readable FDs                             /*{{{*/
 236 // ---------------------------------------------------------------------
 237 /* Collect FDs that have activity monitors into the fd sets */
 238 void pkgAcquire::SetFds(int &Fd,fd_set *RSet,fd_set *WSet)
 239 {
 240    for (Worker *I = Workers; I != 0; I = I->NextAcquire)
 241    {
 242       if (I->InReady == true && I->InFd >= 0)
 243       {
 244          if (Fd < I->InFd)
 245             Fd = I->InFd;
 246          FD_SET(I->InFd,RSet);
 247       }
 248       if (I->OutReady == true && I->OutFd >= 0)
 249       {
 250          if (Fd < I->OutFd)
 251             Fd = I->OutFd;
 252          FD_SET(I->OutFd,WSet);
 253       }
 254    }
 255 }
 256                                                                         /*}}}*/
 257 // Acquire::RunFds - Deal with active FDs                               /*{{{*/
 258 // ---------------------------------------------------------------------
 259 /* Dispatch active FDs over to the proper workers. It is very important
 260    that a worker never be erased while this is running! The queue class
 261    should never erase a worker except during shutdown processing. */
 262 void pkgAcquire::RunFds(fd_set *RSet,fd_set *WSet)
 263 {
 264    for (Worker *I = Workers; I != 0; I = I->NextAcquire)
 265    {
 266       if (I->InFd >= 0 && FD_ISSET(I->InFd,RSet) != 0)
 267          I->InFdReady();
 268       if (I->OutFd >= 0 && FD_ISSET(I->OutFd,WSet) != 0)
 269          I->OutFdReady();
 270    }
 271 }
 272                                                                         /*}}}*/
 273 // Acquire::Run - Run the fetch sequence                                /*{{{*/
 274 // ---------------------------------------------------------------------
 275 /* This runs the queues. It manages a select loop for all of the
 276    Worker tasks. The workers interact with the queues and items to
 277    manage the actual fetch. */
 278 bool pkgAcquire::Run()
 279 {
 280    Running = true;
 281
 282    for (Queue *I = Queues; I != 0; I = I->Next)
 283       I->Startup();
 284
 285    if (Log != 0)
 286       Log->Start();
 287
 288    // Run till all things have been acquired
 289    struct timeval tv;
 290    tv.tv_sec = 0;
 291    tv.tv_usec = 500000;
 292    while (ToFetch > 0)
 293    {
 294       fd_set RFds;
 295       fd_set WFds;
 296       int Highest = 0;
 297       FD_ZERO(&RFds);
 298       FD_ZERO(&WFds);
 299       SetFds(Highest,&RFds,&WFds);
 300
 301       int Res;
 302       do
 303       {
 304          Res = select(Highest+1,&RFds,&WFds,0,&tv);
 305       }
 306       while (Res < 0 && errno == EINTR);
 307
 308       if (Res < 0)
 309       {
 310          _error->Errno("select","Select has failed");
 311          break;
 312       }
 313
 314       RunFds(&RFds,&WFds);
 315       if (_error->PendingError() == true)
 316          break;
 317
 318       // Timeout, notify the log class
 319       if (Res == 0 || (Log != 0 && Log->Update == true))
 320       {
 321          tv.tv_usec = 500000;
 322          for (Worker *I = Workers; I != 0; I = I->NextAcquire)
 323             I->Pulse();
 324          if (Log != 0)
 325             Log->Pulse(this);
 326       }
 327    }
 328
 329    if (Log != 0)
 330       Log->Stop();
 331
 332    // Shut down the acquire bits
 333    Running = false;
 334    for (Queue *I = Queues; I != 0; I = I->Next)
 335       I->Shutdown();
 336
 337    // Shut down the items
 338    for (Item **I = Items.begin(); I != Items.end(); I++)
 339       (*I)->Finished();
 340
 341    return !_error->PendingError();
 342 }
 343                                                                         /*}}}*/
 344 // Acquire::Bump - Called when an item is dequeued                      /*{{{*/
 345 // ---------------------------------------------------------------------
 346 /* This routine bumps idle queues in hopes that they will be able to fetch
 347    the dequeued item */
 348 void pkgAcquire::Bump()
 349 {
 350    for (Queue *I = Queues; I != 0; I = I->Next)
 351       I->Bump();
 352 }
 353                                                                         /*}}}*/
 354 // Acquire::WorkerStep - Step to the next worker                        /*{{{*/
 355 // ---------------------------------------------------------------------
 356 /* Not inlined to advoid including acquire-worker.h */
 357 pkgAcquire::Worker *pkgAcquire::WorkerStep(Worker *I)
 358 {
 359    return I->NextAcquire;
 360 };
 361                                                                         /*}}}*/
 362 // Acquire::Clean - Cleans a directory                                  /*{{{*/
 363 // ---------------------------------------------------------------------
 364 /* This is a bit simplistic, it looks at every file in the dir and sees
 365    if it is part of the download set. */
 366 bool pkgAcquire::Clean(string Dir)
 367 {
 368    DIR *D = opendir(Dir.c_str());
 369    if (D == 0)
 370       return _error->Errno("opendir","Unable to read %s",Dir.c_str());
 371
 372    string StartDir = SafeGetCWD();
 373    if (chdir(Dir.c_str()) != 0)
 374    {
 375       closedir(D);
 376       return _error->Errno("chdir","Unable to change to ",Dir.c_str());
 377    }
 378
 379    for (struct dirent *Dir = readdir(D); Dir != 0; Dir = readdir(D))
 380    {
 381       // Skip some files..
 382       if (strcmp(Dir->d_name,"lock") == 0 ||
 383           strcmp(Dir->d_name,"partial") == 0 ||
 384           strcmp(Dir->d_name,".") == 0 ||
 385           strcmp(Dir->d_name,"..") == 0)
 386          continue;
 387
 388       // Look in the get list
 389       vector<Item *>::iterator I = Items.begin();
 390       for (; I != Items.end(); I++)
 391          if (flNotDir((*I)->DestFile) == Dir->d_name)
 392             break;
 393
 394       // Nothing found, nuke it
 395       if (I == Items.end())
 396          unlink(Dir->d_name);
 397    };
 398
 399    chdir(StartDir.c_str());
 400    closedir(D);
 401    return true;
 402 }
 403                                                                         /*}}}*/
 404 // Acquire::TotalNeeded - Number of bytes to fetch                      /*{{{*/
 405 // ---------------------------------------------------------------------
 406 /* This is the total number of bytes needed */
 407 unsigned long pkgAcquire::TotalNeeded()
 408 {
 409    unsigned long Total = 0;
 410    for (pkgAcquire::Item **I = ItemsBegin(); I != ItemsEnd(); I++)
 411       Total += (*I)->FileSize;
 412    return Total;
 413 }
 414                                                                         /*}}}*/
 415 // Acquire::FetchNeeded - Number of bytes needed to get                 /*{{{*/
 416 // ---------------------------------------------------------------------
 417 /* This is the number of bytes that is not local */
 418 unsigned long pkgAcquire::FetchNeeded()
 419 {
 420    unsigned long Total = 0;
 421    for (pkgAcquire::Item **I = ItemsBegin(); I != ItemsEnd(); I++)
 422       if ((*I)->Local == false)
 423          Total += (*I)->FileSize;
 424    return Total;
 425 }
 426                                                                         /*}}}*/
 427 // Acquire::PartialPresent - Number of partial bytes we already have    /*{{{*/
 428 // ---------------------------------------------------------------------
 429 /* This is the number of bytes that is not local */
 430 unsigned long pkgAcquire::PartialPresent()
 431 {
 432    unsigned long Total = 0;
 433    for (pkgAcquire::Item **I = ItemsBegin(); I != ItemsEnd(); I++)
 434       if ((*I)->Local == false)
 435          Total += (*I)->PartialSize;
 436    return Total;
 437 }
 438                                                                         /*}}}*/
 439 // pkgAcquire::UriBegin - Start iterator for the uri list               /*{{{*/
 440 // ---------------------------------------------------------------------
 441 /* */
 442 pkgAcquire::UriIterator pkgAcquire::UriBegin()
 443 {
 444    return UriIterator(Queues);
 445 }
 446                                                                         /*}}}*/
 447 // pkgAcquire::UriEnd - End iterator for the uri list                   /*{{{*/
 448 // ---------------------------------------------------------------------
 449 /* */
 450 pkgAcquire::UriIterator pkgAcquire::UriEnd()
 451 {
 452    return UriIterator(0);
 453 }
 454                                                                         /*}}}*/
 455
 456 // Acquire::MethodConfig::MethodConfig - Constructor                    /*{{{*/
 457 // ---------------------------------------------------------------------
 458 /* */
 459 pkgAcquire::MethodConfig::MethodConfig()
 460 {
 461    SingleInstance = false;
 462    Pipeline = false;
 463    SendConfig = false;
 464    LocalOnly = false;
 465    Next = 0;
 466 }
 467                                                                         /*}}}*/
 468
 469 // Queue::Queue - Constructor                                           /*{{{*/
 470 // ---------------------------------------------------------------------
 471 /* */
 472 pkgAcquire::Queue::Queue(string Name,pkgAcquire *Owner) : Name(Name),
 473             Owner(Owner)
 474 {
 475    Items = 0;
 476    Next = 0;
 477    Workers = 0;
 478    MaxPipeDepth = 1;
 479    PipeDepth = 0;
 480 }
 481                                                                         /*}}}*/
 482 // Queue::~Queue - Destructor                                           /*{{{*/
 483 // ---------------------------------------------------------------------
 484 /* */
 485 pkgAcquire::Queue::~Queue()
 486 {
 487    Shutdown();
 488
 489    while (Items != 0)
 490    {
 491       QItem *Jnk = Items;
 492       Items = Items->Next;
 493       delete Jnk;
 494    }
 495 }
 496                                                                         /*}}}*/
 497 // Queue::Enqueue - Queue an item to the queue                          /*{{{*/
 498 // ---------------------------------------------------------------------
 499 /* */
 500 void pkgAcquire::Queue::Enqueue(ItemDesc &Item)
 501 {
 502    QItem **I = &Items;
 503    for (; *I != 0; I = &(*I)->Next);
 504
 505    // Create a new item
 506    QItem *Itm = new QItem;
 507    *Itm = Item;
 508    Itm->Next = 0;
 509    *I = Itm;
 510
 511    Item.Owner->QueueCounter++;
 512    if (Items->Next == 0)
 513       Cycle();
 514 }
 515                                                                         /*}}}*/
 516 // Queue::Dequeue - Remove an item from the queue                       /*{{{*/
 517 // ---------------------------------------------------------------------
 518 /* We return true if we hit something */
 519 bool pkgAcquire::Queue::Dequeue(Item *Owner)
 520 {
 521    if (Owner->Status == pkgAcquire::Item::StatFetching)
 522       return _error->Error("Tried to dequeue a fetching object");
 523
 524    bool Res = false;
 525
 526    QItem **I = &Items;
 527    for (; *I != 0;)
 528    {
 529       if ((*I)->Owner == Owner)
 530       {
 531          QItem *Jnk= *I;
 532          *I = (*I)->Next;
 533          Owner->QueueCounter--;
 534          delete Jnk;
 535          Res = true;
 536       }
 537       else
 538          I = &(*I)->Next;
 539    }
 540
 541    return Res;
 542 }
 543                                                                         /*}}}*/
 544 // Queue::Startup - Start the worker processes                          /*{{{*/
 545 // ---------------------------------------------------------------------
 546 /* */
 547 bool pkgAcquire::Queue::Startup()
 548 {
 549    Shutdown();
 550
 551    URI U(Name);
 552    pkgAcquire::MethodConfig *Cnf = Owner->GetConfig(U.Access);
 553    if (Cnf == 0)
 554       return false;
 555
 556    Workers = new Worker(this,Cnf,Owner->Log);
 557    Owner->Add(Workers);
 558    if (Workers->Start() == false)
 559       return false;
 560
 561    /* When pipelining we commit 10 items. This needs to change when we
 562       added other source retry to have cycle maintain a pipeline depth
 563       on its own. */
 564    if (Cnf->Pipeline == true)
 565       MaxPipeDepth = 10;
 566    else
 567       MaxPipeDepth = 1;
 568
 569    return Cycle();
 570 }
 571                                                                         /*}}}*/
 572 // Queue::Shutdown - Shutdown the worker processes                      /*{{{*/
 573 // ---------------------------------------------------------------------
 574 /* */
 575 bool pkgAcquire::Queue::Shutdown()
 576 {
 577    // Delete all of the workers
 578    while (Workers != 0)
 579    {
 580       pkgAcquire::Worker *Jnk = Workers;
 581       Workers = Workers->NextQueue;
 582       Owner->Remove(Jnk);
 583       delete Jnk;
 584    }
 585
 586    return true;
 587 }
 588                                                                         /*}}}*/
 589 // Queue::FindItem - Find a URI in the item list                        /*{{{*/
 590 // ---------------------------------------------------------------------
 591 /* */
 592 pkgAcquire::Queue::QItem *pkgAcquire::Queue::FindItem(string URI,pkgAcquire::Worker *Owner)
 593 {
 594    for (QItem *I = Items; I != 0; I = I->Next)
 595       if (I->URI == URI && I->Worker == Owner)
 596          return I;
 597    return 0;
 598 }
 599                                                                         /*}}}*/
 600 // Queue::ItemDone - Item has been completed                            /*{{{*/
 601 // ---------------------------------------------------------------------
 602 /* The worker signals this which causes the item to be removed from the
 603    queue. If this is the last queue instance then it is removed from the
 604    main queue too.*/
 605 bool pkgAcquire::Queue::ItemDone(QItem *Itm)
 606 {
 607    PipeDepth--;
 608    if (Itm->Owner->Status == pkgAcquire::Item::StatFetching)
 609       Itm->Owner->Status = pkgAcquire::Item::StatDone;
 610
 611    if (Itm->Owner->QueueCounter <= 1)
 612       Owner->Dequeue(Itm->Owner);
 613    else
 614    {
 615       Dequeue(Itm->Owner);
 616       Owner->Bump();
 617    }
 618
 619    return Cycle();
 620 }
 621                                                                         /*}}}*/
 622 // Queue::Cycle - Queue new items into the method                       /*{{{*/
 623 // ---------------------------------------------------------------------
 624 /* This locates a new idle item and sends it to the worker. If pipelining
 625    is enabled then it keeps the pipe full. */
 626 bool pkgAcquire::Queue::Cycle()
 627 {
 628    if (Items == 0 || Workers == 0)
 629       return true;
 630
 631    if (PipeDepth < 0)
 632       return _error->Error("Pipedepth failure");
 633
 634    // Look for a queable item
 635    QItem *I = Items;
 636    while (PipeDepth < (signed)MaxPipeDepth)
 637    {
 638       for (; I != 0; I = I->Next)
 639          if (I->Owner->Status == pkgAcquire::Item::StatIdle)
 640             break;
 641
 642       // Nothing to do, queue is idle.
 643       if (I == 0)
 644          return true;
 645
 646       I->Worker = Workers;
 647       I->Owner->Status = pkgAcquire::Item::StatFetching;
 648       PipeDepth++;
 649       if (Workers->QueueItem(I) == false)
 650          return false;
 651    }
 652
 653    return true;
 654 }
 655                                                                         /*}}}*/
 656 // Queue::Bump - Fetch any pending objects if we are idle               /*{{{*/
 657 // ---------------------------------------------------------------------
 658 /* This is called when an item in multiple queues is dequeued */
 659 void pkgAcquire::Queue::Bump()
 660 {
 661    Cycle();
 662 }
 663                                                                         /*}}}*/
 664
 665 // AcquireStatus::pkgAcquireStatus - Constructor                        /*{{{*/
 666 // ---------------------------------------------------------------------
 667 /* */
 668 pkgAcquireStatus::pkgAcquireStatus()
 669 {
 670    Start();
 671 }
 672                                                                         /*}}}*/
 673 // AcquireStatus::Pulse - Called periodically                           /*{{{*/
 674 // ---------------------------------------------------------------------
 675 /* This computes some internal state variables for the derived classes to
 676    use. It generates the current downloaded bytes and total bytes to download
 677    as well as the current CPS estimate. */
 678 void pkgAcquireStatus::Pulse(pkgAcquire *Owner)
 679 {
 680    TotalBytes = 0;
 681    CurrentBytes = 0;
 682    TotalItems = 0;
 683    CurrentItems = 0;
 684
 685    // Compute the total number of bytes to fetch
 686    unsigned int Unknown = 0;
 687    unsigned int Count = 0;
 688    for (pkgAcquire::Item **I = Owner->ItemsBegin(); I != Owner->ItemsEnd();
 689         I++, Count++)
 690    {
 691       TotalItems++;
 692       if ((*I)->Status == pkgAcquire::Item::StatDone)
 693          CurrentItems++;
 694
 695       // Totally ignore local items
 696       if ((*I)->Local == true)
 697          continue;
 698
 699       TotalBytes += (*I)->FileSize;
 700       if ((*I)->Complete == true)
 701          CurrentBytes += (*I)->FileSize;
 702       if ((*I)->FileSize == 0 && (*I)->Complete == false)
 703          Unknown++;
 704    }
 705
 706    // Compute the current completion
 707    unsigned long ResumeSize = 0;
 708    for (pkgAcquire::Worker *I = Owner->WorkersBegin(); I != 0;
 709         I = Owner->WorkerStep(I))
 710       if (I->CurrentItem != 0 && I->CurrentItem->Owner->Complete == false)
 711       {
 712          CurrentBytes += I->CurrentSize;
 713          ResumeSize += I->ResumePoint;
 714
 715          // Files with unknown size always have 100% completion
 716          if (I->CurrentItem->Owner->FileSize == 0 &&
 717              I->CurrentItem->Owner->Complete == false)
 718             TotalBytes += I->CurrentSize;
 719       }
 720
 721    // Normalize the figures and account for unknown size downloads
 722    if (TotalBytes <= 0)
 723       TotalBytes = 1;
 724    if (Unknown == Count)
 725       TotalBytes = Unknown;
 726
 727    // Compute the CPS
 728    struct timeval NewTime;
 729    gettimeofday(&NewTime,0);
 730    if (NewTime.tv_sec - Time.tv_sec == 6 && NewTime.tv_usec > Time.tv_usec ||
 731        NewTime.tv_sec - Time.tv_sec > 6)
 732    {
 733       double Delta = NewTime.tv_sec - Time.tv_sec +
 734                      (NewTime.tv_usec - Time.tv_usec)/1000000.0;
 735
 736       // Compute the CPS value
 737       if (Delta < 0.01)
 738          CurrentCPS = 0;
 739       else
 740          CurrentCPS = ((CurrentBytes - ResumeSize) - LastBytes)/Delta;
 741       LastBytes = CurrentBytes - ResumeSize;
 742       ElapsedTime = (unsigned long)Delta;
 743       Time = NewTime;
 744    }
 745 }
 746                                                                         /*}}}*/
 747 // AcquireStatus::Start - Called when the download is started           /*{{{*/
 748 // ---------------------------------------------------------------------
 749 /* We just reset the counters */
 750 void pkgAcquireStatus::Start()
 751 {
 752    gettimeofday(&Time,0);
 753    gettimeofday(&StartTime,0);
 754    LastBytes = 0;
 755    CurrentCPS = 0;
 756    CurrentBytes = 0;
 757    TotalBytes = 0;
 758    FetchedBytes = 0;
 759    ElapsedTime = 0;
 760    TotalItems = 0;
 761    CurrentItems = 0;
 762 }
 763                                                                         /*}}}*/
 764 // AcquireStatus::Stop - Finished downloading                           /*{{{*/
 765 // ---------------------------------------------------------------------
 766 /* This accurately computes the elapsed time and the total overall CPS. */
 767 void pkgAcquireStatus::Stop()
 768 {
 769    // Compute the CPS and elapsed time
 770    struct timeval NewTime;
 771    gettimeofday(&NewTime,0);
 772
 773    // Compute the delta time with full accuracy
 774    long usdiff = NewTime.tv_usec - StartTime.tv_usec;
 775    long sdiff = NewTime.tv_sec - StartTime.tv_sec;
 776
 777    // Borrow
 778    if (usdiff < 0)
 779    {
 780       usdiff += 1000000;
 781       sdiff--;
 782    }
 783
 784    // Compute the CPS value
 785    if (sdiff == 0 && usdiff == 0)
 786       CurrentCPS = 0;
 787    else
 788       CurrentCPS = FetchedBytes/(sdiff + usdiff/1000000.0);
 789    LastBytes = CurrentBytes;
 790    ElapsedTime = sdiff;
 791 }
 792                                                                         /*}}}*/
 793 // AcquireStatus::Fetched - Called when a byte set has been fetched     /*{{{*/
 794 // ---------------------------------------------------------------------
 795 /* This is used to get accurate final transfer rate reporting. */
 796 void pkgAcquireStatus::Fetched(unsigned long Size,unsigned long Resume)
 797 {
 798    FetchedBytes += Size - Resume;
 799 }
 800                                                                         /*}}}*/