Commit | Line | Data |
---|---|---|
0118833a AL |
1 | // -*- mode: cpp; mode: fold -*- |
2 | // Description /*{{{*/ | |
aa0e1101 | 3 | // $Id: acquire.cc,v 1.35 1999/06/06 06:58:36 jgg Exp $ |
0118833a AL |
4 | /* ###################################################################### |
5 | ||
6 | Acquire - File Acquiration | |
7 | ||
0a8a80e5 AL |
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 | ||
0118833a AL |
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> | |
0a8a80e5 AL |
22 | #include <apt-pkg/configuration.h> |
23 | #include <apt-pkg/error.h> | |
cdcc6d34 | 24 | #include <apt-pkg/strutl.h> |
8267fe24 | 25 | |
7a7fa5f0 | 26 | #include <dirent.h> |
8267fe24 | 27 | #include <sys/time.h> |
524f8105 | 28 | #include <errno.h> |
0118833a AL |
29 | /*}}}*/ |
30 | ||
31 | // Acquire::pkgAcquire - Constructor /*{{{*/ | |
32 | // --------------------------------------------------------------------- | |
93bf083d | 33 | /* We grab some runtime state from the configuration space */ |
8267fe24 | 34 | pkgAcquire::pkgAcquire(pkgAcquireStatus *Log) : Log(Log) |
0118833a AL |
35 | { |
36 | Queues = 0; | |
37 | Configs = 0; | |
0a8a80e5 AL |
38 | Workers = 0; |
39 | ToFetch = 0; | |
8b89e57f | 40 | Running = false; |
0a8a80e5 AL |
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); | |
0118833a AL |
49 | } |
50 | /*}}}*/ | |
51 | // Acquire::~pkgAcquire - Destructor /*{{{*/ | |
52 | // --------------------------------------------------------------------- | |
93bf083d | 53 | /* Free our memory, clean up the queues (destroy the workers) */ |
0118833a AL |
54 | pkgAcquire::~pkgAcquire() |
55 | { | |
56 | while (Items.size() != 0) | |
57 | delete Items[0]; | |
3b5421b4 AL |
58 | |
59 | while (Configs != 0) | |
60 | { | |
61 | MethodConfig *Jnk = Configs; | |
62 | Configs = Configs->Next; | |
63 | delete Jnk; | |
64 | } | |
0a8a80e5 AL |
65 | |
66 | while (Queues != 0) | |
67 | { | |
68 | Queue *Jnk = Queues; | |
69 | Queues = Queues->Next; | |
70 | delete Jnk; | |
71 | } | |
0118833a AL |
72 | } |
73 | /*}}}*/ | |
74 | // Acquire::Add - Add a new item /*{{{*/ | |
75 | // --------------------------------------------------------------------- | |
93bf083d AL |
76 | /* This puts an item on the acquire list. This list is mainly for tracking |
77 | item status */ | |
0118833a AL |
78 | void pkgAcquire::Add(Item *Itm) |
79 | { | |
80 | Items.push_back(Itm); | |
81 | } | |
82 | /*}}}*/ | |
83 | // Acquire::Remove - Remove a item /*{{{*/ | |
84 | // --------------------------------------------------------------------- | |
93bf083d | 85 | /* Remove an item from the acquire list. This is usually not used.. */ |
0118833a AL |
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); | |
8267fe24 | 92 | } |
0118833a AL |
93 | } |
94 | /*}}}*/ | |
0a8a80e5 AL |
95 | // Acquire::Add - Add a worker /*{{{*/ |
96 | // --------------------------------------------------------------------- | |
93bf083d AL |
97 | /* A list of workers is kept so that the select loop can direct their FD |
98 | usage. */ | |
0a8a80e5 AL |
99 | void pkgAcquire::Add(Worker *Work) |
100 | { | |
101 | Work->NextAcquire = Workers; | |
102 | Workers = Work; | |
103 | } | |
104 | /*}}}*/ | |
105 | // Acquire::Remove - Remove a worker /*{{{*/ | |
106 | // --------------------------------------------------------------------- | |
93bf083d AL |
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.. */ | |
0a8a80e5 AL |
110 | void pkgAcquire::Remove(Worker *Work) |
111 | { | |
93bf083d AL |
112 | if (Running == true) |
113 | abort(); | |
114 | ||
0a8a80e5 AL |
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 | /*}}}*/ | |
0118833a AL |
125 | // Acquire::Enqueue - Queue an URI for fetching /*{{{*/ |
126 | // --------------------------------------------------------------------- | |
93bf083d AL |
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. */ | |
8267fe24 | 131 | void pkgAcquire::Enqueue(ItemDesc &Item) |
0118833a | 132 | { |
0a8a80e5 | 133 | // Determine which queue to put the item in |
e331f6ed AL |
134 | const MethodConfig *Config; |
135 | string Name = QueueName(Item.URI,Config); | |
0a8a80e5 AL |
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; | |
93bf083d AL |
147 | |
148 | if (Running == true) | |
149 | I->Startup(); | |
0a8a80e5 | 150 | } |
bfd22fc0 | 151 | |
e331f6ed AL |
152 | // See if this is a local only URI |
153 | if (Config->LocalOnly == true && Item.Owner->Complete == false) | |
154 | Item.Owner->Local = true; | |
8267fe24 | 155 | Item.Owner->Status = Item::StatIdle; |
0a8a80e5 AL |
156 | |
157 | // Queue it into the named queue | |
8267fe24 | 158 | I->Enqueue(Item); |
0a8a80e5 | 159 | ToFetch++; |
93bf083d | 160 | |
0a8a80e5 AL |
161 | // Some trace stuff |
162 | if (Debug == true) | |
163 | { | |
8267fe24 AL |
164 | clog << "Fetching " << Item.URI << endl; |
165 | clog << " to " << Item.Owner->DestFile << endl; | |
e331f6ed | 166 | clog << " Queue is: " << Name << endl; |
0a8a80e5 | 167 | } |
3b5421b4 AL |
168 | } |
169 | /*}}}*/ | |
0a8a80e5 | 170 | // Acquire::Dequeue - Remove an item from all queues /*{{{*/ |
3b5421b4 | 171 | // --------------------------------------------------------------------- |
93bf083d AL |
172 | /* This is called when an item is finished being fetched. It removes it |
173 | from all the queues */ | |
0a8a80e5 AL |
174 | void pkgAcquire::Dequeue(Item *Itm) |
175 | { | |
176 | Queue *I = Queues; | |
bfd22fc0 | 177 | bool Res = false; |
0a8a80e5 | 178 | for (; I != 0; I = I->Next) |
bfd22fc0 | 179 | Res |= I->Dequeue(Itm); |
93bf083d AL |
180 | |
181 | if (Debug == true) | |
182 | clog << "Dequeuing " << Itm->DestFile << endl; | |
bfd22fc0 AL |
183 | if (Res == true) |
184 | ToFetch--; | |
0a8a80e5 AL |
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 */ | |
e331f6ed | 192 | string pkgAcquire::QueueName(string Uri,MethodConfig const *&Config) |
3b5421b4 | 193 | { |
93bf083d AL |
194 | URI U(Uri); |
195 | ||
e331f6ed | 196 | Config = GetConfig(U.Access); |
0a8a80e5 AL |
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) | |
b98f2859 | 203 | return U.Access; |
93bf083d AL |
204 | |
205 | return U.Access + ':' + U.Host; | |
0118833a AL |
206 | } |
207 | /*}}}*/ | |
3b5421b4 AL |
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 */ | |
0a8a80e5 | 213 | pkgAcquire::MethodConfig *pkgAcquire::GetConfig(string Access) |
3b5421b4 AL |
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; | |
0118833a | 226 | |
3b5421b4 AL |
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 | /*}}}*/ | |
0a8a80e5 AL |
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 | // --------------------------------------------------------------------- | |
93bf083d AL |
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. */ | |
0a8a80e5 AL |
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 | { | |
8b89e57f AL |
280 | Running = true; |
281 | ||
0a8a80e5 AL |
282 | for (Queue *I = Queues; I != 0; I = I->Next) |
283 | I->Startup(); | |
284 | ||
b98f2859 AL |
285 | if (Log != 0) |
286 | Log->Start(); | |
287 | ||
0a8a80e5 | 288 | // Run till all things have been acquired |
8267fe24 AL |
289 | struct timeval tv; |
290 | tv.tv_sec = 0; | |
291 | tv.tv_usec = 500000; | |
0a8a80e5 AL |
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 | ||
b0db36b1 AL |
301 | int Res; |
302 | do | |
303 | { | |
304 | Res = select(Highest+1,&RFds,&WFds,0,&tv); | |
305 | } | |
306 | while (Res < 0 && errno == EINTR); | |
307 | ||
8267fe24 | 308 | if (Res < 0) |
8b89e57f | 309 | { |
8267fe24 AL |
310 | _error->Errno("select","Select has failed"); |
311 | break; | |
8b89e57f | 312 | } |
93bf083d | 313 | |
0a8a80e5 | 314 | RunFds(&RFds,&WFds); |
93bf083d AL |
315 | if (_error->PendingError() == true) |
316 | break; | |
8267fe24 AL |
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 | } | |
0a8a80e5 | 327 | } |
be4401bf | 328 | |
b98f2859 AL |
329 | if (Log != 0) |
330 | Log->Stop(); | |
331 | ||
be4401bf AL |
332 | // Shut down the acquire bits |
333 | Running = false; | |
0a8a80e5 AL |
334 | for (Queue *I = Queues; I != 0; I = I->Next) |
335 | I->Shutdown(); | |
336 | ||
ab559b35 AL |
337 | // Shut down the items |
338 | for (Item **I = Items.begin(); I != Items.end(); I++) | |
339 | (*I)->Finished(); | |
340 | ||
0919e3f9 | 341 | return !_error->PendingError(); |
93bf083d AL |
342 | } |
343 | /*}}}*/ | |
be4401bf | 344 | // Acquire::Bump - Called when an item is dequeued /*{{{*/ |
93bf083d AL |
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 | { | |
be4401bf AL |
350 | for (Queue *I = Queues; I != 0; I = I->Next) |
351 | I->Bump(); | |
0a8a80e5 AL |
352 | } |
353 | /*}}}*/ | |
8267fe24 AL |
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 | /*}}}*/ | |
a6568219 | 362 | // Acquire::Clean - Cleans a directory /*{{{*/ |
7a7fa5f0 AL |
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 | /*}}}*/ | |
a6568219 AL |
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 | /*}}}*/ | |
6b1ff003 AL |
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 | /*}}}*/ | |
f7a08e33 AL |
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 | /*}}}*/ | |
0a8a80e5 | 455 | |
e331f6ed AL |
456 | // Acquire::MethodConfig::MethodConfig - Constructor /*{{{*/ |
457 | // --------------------------------------------------------------------- | |
458 | /* */ | |
459 | pkgAcquire::MethodConfig::MethodConfig() | |
460 | { | |
461 | SingleInstance = false; | |
e331f6ed AL |
462 | Pipeline = false; |
463 | SendConfig = false; | |
464 | LocalOnly = false; | |
465 | Next = 0; | |
466 | } | |
467 | /*}}}*/ | |
468 | ||
0a8a80e5 AL |
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; | |
b185acc2 AL |
478 | MaxPipeDepth = 1; |
479 | PipeDepth = 0; | |
0a8a80e5 AL |
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 | /* */ | |
8267fe24 | 500 | void pkgAcquire::Queue::Enqueue(ItemDesc &Item) |
0a8a80e5 | 501 | { |
7a1b1f8b AL |
502 | QItem **I = &Items; |
503 | for (; *I != 0; I = &(*I)->Next); | |
504 | ||
0a8a80e5 | 505 | // Create a new item |
7a1b1f8b AL |
506 | QItem *Itm = new QItem; |
507 | *Itm = Item; | |
508 | Itm->Next = 0; | |
509 | *I = Itm; | |
0a8a80e5 | 510 | |
8267fe24 | 511 | Item.Owner->QueueCounter++; |
93bf083d AL |
512 | if (Items->Next == 0) |
513 | Cycle(); | |
0a8a80e5 AL |
514 | } |
515 | /*}}}*/ | |
c88edf1d | 516 | // Queue::Dequeue - Remove an item from the queue /*{{{*/ |
0a8a80e5 | 517 | // --------------------------------------------------------------------- |
b185acc2 | 518 | /* We return true if we hit something */ |
bfd22fc0 | 519 | bool pkgAcquire::Queue::Dequeue(Item *Owner) |
0a8a80e5 | 520 | { |
b185acc2 AL |
521 | if (Owner->Status == pkgAcquire::Item::StatFetching) |
522 | return _error->Error("Tried to dequeue a fetching object"); | |
523 | ||
bfd22fc0 AL |
524 | bool Res = false; |
525 | ||
0a8a80e5 AL |
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; | |
bfd22fc0 | 535 | Res = true; |
0a8a80e5 AL |
536 | } |
537 | else | |
538 | I = &(*I)->Next; | |
539 | } | |
bfd22fc0 AL |
540 | |
541 | return Res; | |
0a8a80e5 AL |
542 | } |
543 | /*}}}*/ | |
544 | // Queue::Startup - Start the worker processes /*{{{*/ | |
545 | // --------------------------------------------------------------------- | |
546 | /* */ | |
547 | bool pkgAcquire::Queue::Startup() | |
548 | { | |
549 | Shutdown(); | |
550 | ||
93bf083d AL |
551 | URI U(Name); |
552 | pkgAcquire::MethodConfig *Cnf = Owner->GetConfig(U.Access); | |
0a8a80e5 AL |
553 | if (Cnf == 0) |
554 | return false; | |
555 | ||
8267fe24 | 556 | Workers = new Worker(this,Cnf,Owner->Log); |
0a8a80e5 AL |
557 | Owner->Add(Workers); |
558 | if (Workers->Start() == false) | |
559 | return false; | |
0a8a80e5 | 560 | |
5cb5d8dc AL |
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) | |
b185acc2 AL |
565 | MaxPipeDepth = 10; |
566 | else | |
567 | MaxPipeDepth = 1; | |
5cb5d8dc | 568 | |
93bf083d | 569 | return Cycle(); |
0a8a80e5 AL |
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; | |
3b5421b4 AL |
587 | } |
588 | /*}}}*/ | |
7d8afa39 | 589 | // Queue::FindItem - Find a URI in the item list /*{{{*/ |
c88edf1d AL |
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 | |
93bf083d AL |
603 | queue. If this is the last queue instance then it is removed from the |
604 | main queue too.*/ | |
c88edf1d AL |
605 | bool pkgAcquire::Queue::ItemDone(QItem *Itm) |
606 | { | |
b185acc2 | 607 | PipeDepth--; |
db890fdb AL |
608 | if (Itm->Owner->Status == pkgAcquire::Item::StatFetching) |
609 | Itm->Owner->Status = pkgAcquire::Item::StatDone; | |
610 | ||
93bf083d AL |
611 | if (Itm->Owner->QueueCounter <= 1) |
612 | Owner->Dequeue(Itm->Owner); | |
613 | else | |
614 | { | |
615 | Dequeue(Itm->Owner); | |
616 | Owner->Bump(); | |
617 | } | |
c88edf1d | 618 | |
93bf083d AL |
619 | return Cycle(); |
620 | } | |
621 | /*}}}*/ | |
622 | // Queue::Cycle - Queue new items into the method /*{{{*/ | |
623 | // --------------------------------------------------------------------- | |
b185acc2 AL |
624 | /* This locates a new idle item and sends it to the worker. If pipelining |
625 | is enabled then it keeps the pipe full. */ | |
93bf083d AL |
626 | bool pkgAcquire::Queue::Cycle() |
627 | { | |
628 | if (Items == 0 || Workers == 0) | |
c88edf1d AL |
629 | return true; |
630 | ||
e7432370 AL |
631 | if (PipeDepth < 0) |
632 | return _error->Error("Pipedepth failure"); | |
633 | ||
93bf083d AL |
634 | // Look for a queable item |
635 | QItem *I = Items; | |
e7432370 | 636 | while (PipeDepth < (signed)MaxPipeDepth) |
b185acc2 AL |
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; | |
e7432370 | 648 | PipeDepth++; |
b185acc2 AL |
649 | if (Workers->QueueItem(I) == false) |
650 | return false; | |
651 | } | |
93bf083d | 652 | |
b185acc2 | 653 | return true; |
c88edf1d AL |
654 | } |
655 | /*}}}*/ | |
be4401bf AL |
656 | // Queue::Bump - Fetch any pending objects if we are idle /*{{{*/ |
657 | // --------------------------------------------------------------------- | |
b185acc2 | 658 | /* This is called when an item in multiple queues is dequeued */ |
be4401bf AL |
659 | void pkgAcquire::Queue::Bump() |
660 | { | |
b185acc2 | 661 | Cycle(); |
be4401bf AL |
662 | } |
663 | /*}}}*/ | |
b98f2859 AL |
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; | |
d568ed2d AL |
682 | TotalItems = 0; |
683 | CurrentItems = 0; | |
b98f2859 AL |
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 | { | |
d568ed2d AL |
691 | TotalItems++; |
692 | if ((*I)->Status == pkgAcquire::Item::StatDone) | |
693 | CurrentItems++; | |
694 | ||
a6568219 AL |
695 | // Totally ignore local items |
696 | if ((*I)->Local == true) | |
697 | continue; | |
698 | ||
b98f2859 AL |
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 | |
aa0e1101 | 707 | unsigned long ResumeSize = 0; |
b98f2859 AL |
708 | for (pkgAcquire::Worker *I = Owner->WorkersBegin(); I != 0; |
709 | I = Owner->WorkerStep(I)) | |
710 | if (I->CurrentItem != 0 && I->CurrentItem->Owner->Complete == false) | |
aa0e1101 AL |
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 | ||
b98f2859 AL |
721 | // Normalize the figures and account for unknown size downloads |
722 | if (TotalBytes <= 0) | |
723 | TotalBytes = 1; | |
724 | if (Unknown == Count) | |
725 | TotalBytes = Unknown; | |
b98f2859 AL |
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 | { | |
f17ac097 AL |
733 | double Delta = NewTime.tv_sec - Time.tv_sec + |
734 | (NewTime.tv_usec - Time.tv_usec)/1000000.0; | |
b98f2859 | 735 | |
b98f2859 | 736 | // Compute the CPS value |
f17ac097 | 737 | if (Delta < 0.01) |
e331f6ed AL |
738 | CurrentCPS = 0; |
739 | else | |
aa0e1101 AL |
740 | CurrentCPS = ((CurrentBytes - ResumeSize) - LastBytes)/Delta; |
741 | LastBytes = CurrentBytes - ResumeSize; | |
6d5dd02a | 742 | ElapsedTime = (unsigned long)Delta; |
b98f2859 AL |
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; | |
d568ed2d AL |
760 | TotalItems = 0; |
761 | CurrentItems = 0; | |
b98f2859 AL |
762 | } |
763 | /*}}}*/ | |
a6568219 | 764 | // AcquireStatus::Stop - Finished downloading /*{{{*/ |
b98f2859 AL |
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 | } | |
e331f6ed | 783 | |
b98f2859 | 784 | // Compute the CPS value |
e331f6ed AL |
785 | if (sdiff == 0 && usdiff == 0) |
786 | CurrentCPS = 0; | |
787 | else | |
788 | CurrentCPS = FetchedBytes/(sdiff + usdiff/1000000.0); | |
b98f2859 AL |
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) | |
93274b8d | 797 | { |
b98f2859 AL |
798 | FetchedBytes += Size - Resume; |
799 | } | |
800 | /*}}}*/ |