1 // -*- mode: cpp; mode: fold -*-
3 /* ######################################################################
5 Acquire Item - Item to acquire
7 When an item is instantiated it will add it self to the local list in
8 the Owner Acquire class. Derived classes will then call QueueURI to
9 register all the URI's they wish to fetch at the initial moment.
11 Three item classes are provided to provide functionality for
12 downloading of Index, Translation and Packages files.
14 A Archive class is provided for downloading .deb files. It does Hash
15 checking and source location as well as a retry algorithm.
17 ##################################################################### */
19 #ifndef PKGLIB_ACQUIRE_ITEM_H
20 #define PKGLIB_ACQUIRE_ITEM_H
22 #include <apt-pkg/acquire.h>
23 #include <apt-pkg/indexfile.h>
24 #include <apt-pkg/hashes.h>
25 #include <apt-pkg/weakptr.h>
26 #include <apt-pkg/pkgcache.h>
27 #include <apt-pkg/cacheiterators.h>
33 #ifndef APT_8_CLEANER_HEADERS
34 #include <apt-pkg/sourcelist.h>
35 #include <apt-pkg/pkgrecords.h>
38 /** \addtogroup acquire
41 * \file acquire-item.h
46 class pkgAcqMetaClearSig
;
47 class pkgAcqIndexMergeDiffs
;
50 class pkgAcquire::Item
: public WeakPointable
/*{{{*/
51 /** \brief Represents the process by which a pkgAcquire object should
52 * retrieve a file or a collection of files.
54 * By convention, Item subclasses should insert themselves into the
55 * acquire queue when they are created by calling QueueURI(), and
56 * remove themselves by calling Dequeue() when either Done() or
57 * Failed() is invoked. Item objects are also responsible for
58 * notifying the download progress indicator (accessible via
59 * #Owner->Log) of their status.
66 /** \brief The current status of this item. */
69 /** \brief The item is waiting to be downloaded. */
72 /** \brief The item is currently being downloaded. */
75 /** \brief The item has been successfully downloaded. */
78 /** \brief An error was encountered while downloading this
83 /** \brief The item was downloaded but its authenticity could
88 /** \brief The item was could not be downloaded because of
89 * a transient network error (e.g. network down)
91 StatTransientNetworkError
,
94 /** \brief Contains a textual description of the error encountered
95 * if #ItemState is #StatError or #StatAuthError.
97 std::string ErrorText
;
99 /** \brief The size of the object to fetch. */
100 unsigned long long FileSize
;
102 /** \brief How much of the object was already fetched. */
103 unsigned long long PartialSize
;
105 /** \brief If not \b NULL, contains the name of a subprocess that
106 * is operating on this object (for instance, "gzip" or "gpgv").
108 APT_DEPRECATED_MSG("Use the std::string member ActiveSubprocess instead") const char *Mode
;
110 /** \brief contains the name of the subprocess that is operating on this object
111 * (for instance, "gzip", "rred" or "gpgv"). This is obsoleting #Mode from above
112 * as it can manage the lifetime of included string properly. */
113 std::string ActiveSubprocess
;
115 /** \brief A client-supplied unique identifier.
117 * This field is initalized to 0; it is meant to be filled in by
118 * clients that wish to use it to uniquely identify items.
120 * APT progress reporting will store an ID there as shown in "Get:42 …"
124 /** \brief If \b true, the entire object has been successfully fetched.
126 * Subclasses should set this to \b true when appropriate.
130 /** \brief If \b true, the URI of this object is "local".
132 * The only effect of this field is to exclude the object from the
133 * download progress indicator's overall statistics.
137 std::string UsedMirror
;
139 /** \brief The number of fetch queues into which this item has been
142 * There is one queue for each source from which an item could be
147 unsigned int QueueCounter
;
149 /** \brief The number of additional fetch items that are expected
150 * once this item is done.
152 * Some items like pkgAcqMeta{Index,Sig} will queue additional
153 * items. This variable can be set by the methods if it knows
154 * in advance how many items to expect to get a more accurate
157 unsigned int ExpectedAdditionalItems
;
159 /** \brief The name of the file into which the retrieved object
162 std::string DestFile
;
164 /** \brief Invoked by the acquire worker when the object couldn't
167 * This is a branch of the continuation of the fetch process.
169 * \param Message An RFC822-formatted message from the acquire
170 * method describing what went wrong. Use LookupTag() to parse
173 * \param Cnf The method via which the worker tried to fetch this object.
177 virtual void Failed(std::string
const &Message
,pkgAcquire::MethodConfig
const * const Cnf
);
179 /** \brief Invoked by the acquire worker to check if the successfully
180 * fetched object is also the objected we wanted to have.
182 * Note that the object might \e not have been written to
183 * DestFile; check for the presence of an Alt-Filename entry in
184 * Message to find the file to which it was really written.
186 * This is called before Done is called and can prevent it by returning
187 * \b false which will result in Failed being called instead.
189 * You should prefer to use this method over calling Failed() from Done()
190 * as this has e.g. the wrong progress reporting.
192 * \param Message Data from the acquire method. Use LookupTag()
194 * \param Cnf The method via which the object was fetched.
198 virtual bool VerifyDone(std::string
const &Message
,
199 pkgAcquire::MethodConfig
const * const Cnf
);
201 /** \brief Invoked by the acquire worker when the object was
202 * fetched successfully.
204 * Note that the object might \e not have been written to
205 * DestFile; check for the presence of an Alt-Filename entry in
206 * Message to find the file to which it was really written.
208 * Done is often used to switch from one stage of the processing
209 * to the next (e.g. fetching, unpacking, copying). It is one
210 * branch of the continuation of the fetch process.
212 * \param Message Data from the acquire method. Use LookupTag()
214 * \param Hashes The HashSums of the object that was fetched.
215 * \param Cnf The method via which the object was fetched.
219 virtual void Done(std::string
const &Message
, HashStringList
const &Hashes
,
220 pkgAcquire::MethodConfig
const * const Cnf
);
222 /** \brief Invoked when the worker starts to fetch this object.
224 * \param Message RFC822-formatted data from the worker process.
225 * Use LookupTag() to parse it.
227 * \param Hashes The expected hashes of the object being fetched.
231 virtual void Start(std::string
const &Message
, unsigned long long const Size
);
233 /** \brief Custom headers to be sent to the fetch process.
235 * \return a string containing RFC822-style headers that are to be
236 * inserted into the 600 URI Acquire message sent to the fetch
237 * subprocess. The headers are inserted after a newline-less
238 * line, so they should (if nonempty) have a leading newline and
239 * no trailing newline.
241 virtual std::string
Custom600Headers() const;
243 /** \brief A "descriptive" URI-like string.
245 * \return a URI that should be used to describe what is being fetched.
247 virtual std::string
DescURI() const = 0;
248 /** \brief Short item description.
250 * \return a brief description of the object being fetched.
252 virtual std::string
ShortDesc() const;
254 /** \brief Invoked by the worker when the download is completely done. */
255 virtual void Finished();
257 /** \return HashSums the DestFile is supposed to have in this stage */
258 virtual HashStringList
GetExpectedHashes() const = 0;
259 /** \return the 'best' hash for display proposes like --print-uris */
260 std::string
HashSum() const;
262 /** \return if having no hashes is a hard failure or not
264 * Idealy this is always \b true for every subclass, but thanks to
265 * historical grow we don't have hashes for all files in all cases
266 * in all steps, so it is slightly more complicated than it should be.
268 virtual bool HashesRequired() const { return true; }
270 /** \return the acquire process with which this item is associated. */
271 pkgAcquire
*GetOwner() const;
272 pkgAcquire::ItemDesc
&GetItemDesc();
274 /** \return \b true if this object is being fetched from a trusted source. */
275 virtual bool IsTrusted() const;
277 /** \brief Report mirror problem
279 * This allows reporting mirror failures back to a centralized
280 * server. The apt-report-mirror-failure script is called for this
282 * \param FailCode A short failure string that is send
284 APT_DEPRECATED_MSG("Item::Failed does this for you") void ReportMirrorFailure(std::string
const &FailCode
);
286 /** \brief Set the name of the current active subprocess
288 * See also #ActiveSubprocess
290 void SetActiveSubprocess(std::string
const &subprocess
);
292 /** \brief Initialize an item.
294 * Adds the item to the list of items known to the acquire
295 * process, but does not place it into any fetch queues (you must
296 * manually invoke QueueURI() to do so).
298 * \param Owner The new owner of this item.
300 explicit Item(pkgAcquire
* const Owner
);
302 /** \brief Remove this item from its owner's queue by invoking
303 * pkgAcquire::Remove.
308 /** \brief The acquire object with which this item is associated. */
309 pkgAcquire
* const Owner
;
311 /** \brief The item that is currently being downloaded. */
312 pkgAcquire::ItemDesc Desc
;
314 enum RenameOnErrorState
{
324 /** \brief Rename failed file and set error
326 * \param state respresenting the error we encountered
328 bool RenameOnError(RenameOnErrorState
const state
);
330 /** \brief Insert this item into its owner's queue.
332 * The method is designed to check if the request would end
333 * in an IMSHit and if it determines that it would, it isn't
334 * queueing the Item and instead sets it to completion instantly.
336 * \param Item Metadata about this item (its URI and
338 * \return true if the item was inserted, false if IMSHit was detected
340 virtual bool QueueURI(ItemDesc
&Item
);
342 /** \brief Remove this item from its owner's queue. */
345 /** \brief Rename a file without modifying its timestamp.
347 * Many item methods call this as their final action.
349 * \param From The file to be renamed.
351 * \param To The new name of \a From. If \a To exists it will be
352 * overwritten. If \a From and \a To are equal nothing happens.
354 bool Rename(std::string
const &From
, std::string
const &To
);
356 /** \brief Get the full pathname of the final file for the current URI */
357 virtual std::string
GetFinalFilename() const;
362 friend class pkgAcqMetaBase
;
363 friend class pkgAcqMetaClearSig
;
366 class APT_HIDDEN pkgAcqTransactionItem
: public pkgAcquire::Item
/*{{{*/
367 /** \brief baseclass for the indexes files to manage them all together */
371 IndexTarget
const Target
;
372 HashStringList
GetExpectedHashesFor(std::string
const &MetaKey
) const;
374 bool QueueURI(pkgAcquire::ItemDesc
&Item
) APT_OVERRIDE
;
377 /** \brief storge name until a transaction is finished */
378 std::string PartialFile
;
380 /** \brief TransactionManager */
381 pkgAcqMetaClearSig
* const TransactionManager
;
383 enum TransactionStates
{
388 virtual bool TransactionState(TransactionStates
const state
);
390 virtual std::string
DescURI() const APT_OVERRIDE
{ return Target
.URI
; }
391 virtual HashStringList
GetExpectedHashes() const APT_OVERRIDE
;
392 virtual std::string
GetMetaKey() const;
393 virtual bool HashesRequired() const APT_OVERRIDE
;
396 pkgAcqTransactionItem(pkgAcquire
* const Owner
, pkgAcqMetaClearSig
* const TransactionManager
, IndexTarget
const &Target
) APT_NONNULL(2, 3);
397 virtual ~pkgAcqTransactionItem();
399 friend class pkgAcqMetaBase
;
400 friend class pkgAcqMetaClearSig
;
403 class APT_HIDDEN pkgAcqMetaBase
: public pkgAcqTransactionItem
/*{{{*/
404 /** \brief the manager of a transaction */
408 std::vector
<pkgAcqTransactionItem
*> Transaction
;
410 /** \brief If \b true, the index's signature is currently being verified.
414 /** \brief Called when a file is finished being retrieved.
416 * If the file was not downloaded to DestFile, a copy process is
417 * set up to copy it to DestFile; otherwise, Complete is set to \b
418 * true and the file is moved to its final location.
420 * \param Message The message block received from the fetch
423 bool CheckDownloadDone(pkgAcqTransactionItem
* const I
, const std::string
&Message
, HashStringList
const &Hashes
) const;
425 /** \brief Queue the downloaded Signature for verification */
426 void QueueForSignatureVerify(pkgAcqTransactionItem
* const I
, std::string
const &File
, std::string
const &Signature
);
428 virtual std::string
Custom600Headers() const APT_OVERRIDE
;
430 /** \brief Called when authentication succeeded.
432 * Sanity-checks the authenticated file, queues up the individual
433 * index files for download, and saves the signature in the lists
434 * directory next to the authenticated list file.
436 * \param Message The message block received from the fetch
439 bool CheckAuthDone(std::string
const &Message
);
441 /** Check if the current item should fail at this point */
442 bool CheckStopAuthentication(pkgAcquire::Item
* const I
, const std::string
&Message
);
444 /** \brief Check that the release file is a release file for the
445 * correct distribution.
447 * \return \b true if no fatal errors were encountered.
449 bool VerifyVendor(std::string
const &Message
);
451 virtual bool TransactionState(TransactionStates
const state
) APT_OVERRIDE
;
454 // This refers more to the Transaction-Manager than the actual file
456 TransactionStates State
;
459 virtual bool QueueURI(pkgAcquire::ItemDesc
&Item
) APT_OVERRIDE
;
460 virtual HashStringList
GetExpectedHashes() const APT_OVERRIDE
;
461 virtual bool HashesRequired() const APT_OVERRIDE
;
464 void Add(pkgAcqTransactionItem
* const I
);
465 void AbortTransaction();
466 bool TransactionHasError() const;
467 void CommitTransaction();
469 /** \brief Stage (queue) a copy action when the transaction is committed
471 void TransactionStageCopy(pkgAcqTransactionItem
* const I
,
472 const std::string
&From
,
473 const std::string
&To
);
474 /** \brief Stage (queue) a removal action when the transaction is committed
476 void TransactionStageRemoval(pkgAcqTransactionItem
* const I
, const std::string
&FinalFile
);
478 /** \brief Get the full pathname of the final file for the current URI */
479 virtual std::string
GetFinalFilename() const APT_OVERRIDE
;
481 pkgAcqMetaBase(pkgAcquire
* const Owner
, pkgAcqMetaClearSig
* const TransactionManager
,
482 IndexTarget
const &DataTarget
) APT_NONNULL(2, 3);
483 virtual ~pkgAcqMetaBase();
486 /** \brief An item that is responsible for downloading the meta-index {{{
487 * file (i.e., Release) itself and verifying its signature.
489 * Once the download and verification are complete, the downloads of
490 * the individual index files are queued up using pkgAcqDiffIndex.
491 * If the meta-index file had a valid signature, the expected hashsums
492 * of the index files will be the md5sums listed in the meta-index;
493 * otherwise, the expected hashsums will be "" (causing the
494 * authentication of the index files to be bypassed).
496 class APT_HIDDEN pkgAcqMetaIndex
: public pkgAcqMetaBase
500 IndexTarget
const DetachedSigTarget
;
502 /** \brief delayed constructor */
503 void Init(std::string
const &URIDesc
, std::string
const &ShortDesc
);
506 virtual std::string
DescURI() const APT_OVERRIDE
;
508 // Specialized action members
509 virtual void Failed(std::string
const &Message
,pkgAcquire::MethodConfig
const * const Cnf
) APT_OVERRIDE
;
510 virtual void Done(std::string
const &Message
, HashStringList
const &Hashes
,
511 pkgAcquire::MethodConfig
const * const Cnf
) APT_OVERRIDE
;
513 /** \brief Create a new pkgAcqMetaIndex. */
514 pkgAcqMetaIndex(pkgAcquire
* const Owner
, pkgAcqMetaClearSig
* const TransactionManager
,
515 IndexTarget
const &DataTarget
, IndexTarget
const &DetachedSigTarget
) APT_NONNULL(2, 3);
516 virtual ~pkgAcqMetaIndex();
518 friend class pkgAcqMetaSig
;
521 /** \brief An acquire item that downloads the detached signature {{{
522 * of a meta-index (Release) file, then queues up the release
525 * \todo Why protected members?
527 * \sa pkgAcqMetaIndex
529 class APT_HIDDEN pkgAcqMetaSig
: public pkgAcqTransactionItem
533 pkgAcqMetaIndex
* const MetaIndex
;
535 /** \brief The file we use to verify the MetaIndexFile with (not always set!) */
536 std::string MetaIndexFileSignature
;
540 /** \brief Get the full pathname of the final file for the current URI */
541 virtual std::string
GetFinalFilename() const APT_OVERRIDE
;
544 virtual bool HashesRequired() const APT_OVERRIDE
{ return false; }
546 // Specialized action members
547 virtual void Failed(std::string
const &Message
,pkgAcquire::MethodConfig
const * const Cnf
) APT_OVERRIDE
;
548 virtual void Done(std::string
const &Message
, HashStringList
const &Hashes
,
549 pkgAcquire::MethodConfig
const * const Cnf
) APT_OVERRIDE
;
550 virtual std::string
Custom600Headers() const APT_OVERRIDE
;
552 /** \brief Create a new pkgAcqMetaSig. */
553 pkgAcqMetaSig(pkgAcquire
* const Owner
, pkgAcqMetaClearSig
* const TransactionManager
,
554 IndexTarget
const &Target
, pkgAcqMetaIndex
* const MetaIndex
) APT_NONNULL(2, 3, 5);
555 virtual ~pkgAcqMetaSig();
558 /** \brief An item repsonsible for downloading clearsigned metaindexes {{{*/
559 class APT_HIDDEN pkgAcqMetaClearSig
: public pkgAcqMetaIndex
563 IndexTarget
const ClearsignedTarget
;
564 IndexTarget
const DetachedDataTarget
;
567 /** \brief A package-system-specific parser for the meta-index file. */
568 metaIndex
*MetaIndexParser
;
569 metaIndex
*LastMetaIndexParser
;
571 virtual void Failed(std::string
const &Message
,pkgAcquire::MethodConfig
const * const Cnf
) APT_OVERRIDE
;
572 virtual std::string
Custom600Headers() const APT_OVERRIDE
;
573 virtual bool VerifyDone(std::string
const &Message
, pkgAcquire::MethodConfig
const * const Cnf
) APT_OVERRIDE
;
574 virtual void Done(std::string
const &Message
, HashStringList
const &Hashes
,
575 pkgAcquire::MethodConfig
const * const Cnf
) APT_OVERRIDE
;
576 virtual void Finished() APT_OVERRIDE
;
578 /** \brief Starts downloading the individual index files.
580 * \param verify If \b true, only indices whose expected hashsum
581 * can be determined from the meta-index will be downloaded, and
582 * the hashsums of indices will be checked (reporting
583 * #StatAuthError if there is a mismatch). If verify is \b false,
584 * no hashsum checking will be performed.
586 void QueueIndexes(bool const verify
);
588 /** \brief Create a new pkgAcqMetaClearSig. */
589 pkgAcqMetaClearSig(pkgAcquire
* const Owner
,
590 IndexTarget
const &ClearsignedTarget
,
591 IndexTarget
const &DetachedDataTarget
,
592 IndexTarget
const &DetachedSigTarget
,
593 metaIndex
* const MetaIndexParser
);
594 virtual ~pkgAcqMetaClearSig();
597 /** \brief Common base class for all classes that deal with fetching indexes {{{*/
598 class APT_HIDDEN pkgAcqBaseIndex
: public pkgAcqTransactionItem
603 /** \brief Get the full pathname of the final file for the current URI */
604 virtual std::string
GetFinalFilename() const APT_OVERRIDE
;
605 virtual void Failed(std::string
const &Message
,pkgAcquire::MethodConfig
const * const Cnf
) APT_OVERRIDE
;
607 pkgAcqBaseIndex(pkgAcquire
* const Owner
, pkgAcqMetaClearSig
* const TransactionManager
,
608 IndexTarget
const &Target
) APT_NONNULL(2, 3);
609 virtual ~pkgAcqBaseIndex();
612 /** \brief An item that is responsible for fetching an index file of {{{
613 * package list diffs and starting the package list's download.
615 * This item downloads the Index file and parses it, then enqueues
616 * additional downloads of either the individual patches (using
617 * pkgAcqIndexDiffs) or the entire Packages file (using pkgAcqIndex).
619 * \sa pkgAcqIndexDiffs, pkgAcqIndex
621 class APT_HIDDEN pkgAcqDiffIndex
: public pkgAcqBaseIndex
624 std::vector
<pkgAcqIndexMergeDiffs
*> * diffs
;
627 /** \brief If \b true, debugging information will be written to std::clog. */
630 /** \brief A description of the Packages file (stored in
631 * pkgAcquire::ItemDesc::Description).
633 std::string Description
;
635 /** \brief Get the full pathname of the final file for the current URI */
636 virtual std::string
GetFinalFilename() const APT_OVERRIDE
;
638 virtual bool QueueURI(pkgAcquire::ItemDesc
&Item
) APT_OVERRIDE
;
640 virtual bool TransactionState(TransactionStates
const state
) APT_OVERRIDE
;
642 // Specialized action members
643 virtual void Failed(std::string
const &Message
, pkgAcquire::MethodConfig
const * const Cnf
) APT_OVERRIDE
;
644 virtual void Done(std::string
const &Message
, HashStringList
const &Hashes
,
645 pkgAcquire::MethodConfig
const * const Cnf
) APT_OVERRIDE
;
646 virtual std::string
DescURI() const APT_OVERRIDE
{return Target
.URI
+ "Index";};
647 virtual std::string
Custom600Headers() const APT_OVERRIDE
;
648 virtual std::string
GetMetaKey() const APT_OVERRIDE
;
650 /** \brief Parse the Index file for a set of Packages diffs.
652 * Parses the Index file and creates additional download items as
655 * \param IndexDiffFile The name of the Index file.
657 * \return \b true if the Index file was successfully parsed, \b
660 bool ParseDiffIndex(std::string
const &IndexDiffFile
);
662 /** \brief Create a new pkgAcqDiffIndex.
664 * \param Owner The Acquire object that owns this item.
666 * \param URI The URI of the list file to download.
668 * \param URIDesc A long description of the list file to download.
670 * \param ShortDesc A short description of the list file to download.
672 pkgAcqDiffIndex(pkgAcquire
* const Owner
, pkgAcqMetaClearSig
* const TransactionManager
,
673 IndexTarget
const &Target
) APT_NONNULL(2, 3);
674 virtual ~pkgAcqDiffIndex();
676 APT_HIDDEN
void QueueOnIMSHit() const;
679 struct APT_HIDDEN DiffInfo
{ /*{{{*/
680 /** The filename of the diff. */
683 /** The hashes of the file after the diff is applied */
684 HashStringList result_hashes
;
686 /** The hashes of the diff */
687 HashStringList patch_hashes
;
689 /** The hashes of the compressed diff */
690 HashStringList download_hashes
;
693 /** \brief An item that is responsible for fetching client-merge patches {{{
694 * that need to be applied to a given package index file.
696 * Instead of downloading and applying each patch one by one like its
697 * sister #pkgAcqIndexDiffs this class will download all patches at once
698 * and call rred with all the patches downloaded once. Rred will then
699 * merge and apply them in one go, which should be a lot faster – but is
700 * incompatible with server-based merges of patches like reprepro can do.
702 * \sa pkgAcqDiffIndex, pkgAcqIndex
704 class APT_HIDDEN pkgAcqIndexMergeDiffs
: public pkgAcqBaseIndex
710 /** \brief If \b true, debugging output will be written to
715 /** \brief description of the file being downloaded. */
716 std::string Description
;
718 /** \brief information about the current patch */
719 struct DiffInfo
const patch
;
721 /** \brief list of all download items for the patches */
722 std::vector
<pkgAcqIndexMergeDiffs
*> const * const allPatches
;
724 /** The current status of this patch. */
727 /** \brief The diff is currently being fetched. */
730 /** \brief The diff is currently being applied. */
733 /** \brief the work with this diff is done */
736 /** \brief something bad happened and fallback was triggered */
741 /** \brief Called when the patch file failed to be downloaded.
743 * This method will fall back to downloading the whole index file
744 * outright; its arguments are ignored.
746 virtual void Failed(std::string
const &Message
,pkgAcquire::MethodConfig
const * const Cnf
) APT_OVERRIDE
;
747 virtual void Done(std::string
const &Message
, HashStringList
const &Hashes
,
748 pkgAcquire::MethodConfig
const * const Cnf
) APT_OVERRIDE
;
749 virtual std::string
Custom600Headers() const APT_OVERRIDE
;
750 virtual std::string
DescURI() const APT_OVERRIDE
{return Target
.URI
+ "Index";};
751 virtual HashStringList
GetExpectedHashes() const APT_OVERRIDE
;
752 virtual bool HashesRequired() const APT_OVERRIDE
;
754 /** \brief Create an index merge-diff item.
756 * \param Owner The pkgAcquire object that owns this item.
758 * \param URI The URI of the package index file being
761 * \param URIDesc A long description of this item.
763 * \param ShortDesc A brief description of this item.
765 * \param patch contains infos about the patch this item is supposed
766 * to download which were read from the index
768 * \param allPatches contains all related items so that each item can
769 * check if it was the last one to complete the download step
771 pkgAcqIndexMergeDiffs(pkgAcquire
* const Owner
, pkgAcqMetaClearSig
* const TransactionManager
,
772 IndexTarget
const &Target
, DiffInfo
const &patch
,
773 std::vector
<pkgAcqIndexMergeDiffs
*> const * const allPatches
) APT_NONNULL(2, 3, 6);
774 virtual ~pkgAcqIndexMergeDiffs();
777 /** \brief An item that is responsible for fetching server-merge patches {{{
778 * that need to be applied to a given package index file.
780 * After downloading and applying a single patch, this item will
781 * enqueue a new pkgAcqIndexDiffs to download and apply the remaining
782 * patches. If no patch can be found that applies to an intermediate
783 * file or if one of the patches cannot be downloaded, falls back to
784 * downloading the entire package index file using pkgAcqIndex.
786 * \sa pkgAcqDiffIndex, pkgAcqIndex
788 class APT_HIDDEN pkgAcqIndexDiffs
: public pkgAcqBaseIndex
794 /** \brief Queue up the next diff download.
796 * Search for the next available diff that applies to the file
797 * that currently exists on disk, and enqueue it by calling
800 * \return \b true if an applicable diff was found, \b false
803 APT_HIDDEN
bool QueueNextDiff();
805 /** \brief Handle tasks that must be performed after the item
806 * finishes downloading.
808 * Dequeues the item and checks the resulting file's hashsums
809 * against ExpectedHashes after the last patch was applied.
810 * There is no need to check the md5/sha1 after a "normal"
811 * patch because QueueNextDiff() will check the sha1 later.
813 * \param allDone If \b true, the file was entirely reconstructed,
814 * and its md5sum is verified.
816 APT_HIDDEN
void Finish(bool const allDone
=false);
820 /** \brief If \b true, debugging output will be written to
825 /** A description of the file being downloaded. */
826 std::string Description
;
828 /** The patches that remain to be downloaded, including the patch
829 * being downloaded right now. This list should be ordered so
830 * that each diff appears before any diff that depends on it.
832 * \todo These are indexed by sha1sum; why not use some sort of
833 * dictionary instead of relying on ordering and stripping them
836 std::vector
<DiffInfo
> available_patches
;
838 /** The current status of this patch. */
841 /** \brief The diff is currently being fetched. */
844 /** \brief The diff is currently being applied. */
850 /** \brief Called when the patch file failed to be downloaded.
852 * This method will fall back to downloading the whole index file
853 * outright; its arguments are ignored.
855 virtual void Failed(std::string
const &Message
,pkgAcquire::MethodConfig
const * const Cnf
) APT_OVERRIDE
;
857 virtual void Done(std::string
const &Message
, HashStringList
const &Hashes
,
858 pkgAcquire::MethodConfig
const * const Cnf
) APT_OVERRIDE
;
859 virtual std::string
Custom600Headers() const APT_OVERRIDE
;
860 virtual std::string
DescURI() const APT_OVERRIDE
{return Target
.URI
+ "IndexDiffs";};
861 virtual HashStringList
GetExpectedHashes() const APT_OVERRIDE
;
862 virtual bool HashesRequired() const APT_OVERRIDE
;
864 /** \brief Create an index diff item.
866 * After filling in its basic fields, this invokes Finish(true) if
867 * \a diffs is empty, or QueueNextDiff() otherwise.
869 * \param Owner The pkgAcquire object that owns this item.
871 * \param URI The URI of the package index file being
874 * \param URIDesc A long description of this item.
876 * \param ShortDesc A brief description of this item.
878 * \param diffs The remaining diffs from the index of diffs. They
879 * should be ordered so that each diff appears before any diff
880 * that depends on it.
882 pkgAcqIndexDiffs(pkgAcquire
* const Owner
, pkgAcqMetaClearSig
* const TransactionManager
,
883 IndexTarget
const &Target
,
884 std::vector
<DiffInfo
> const &diffs
=std::vector
<DiffInfo
>()) APT_NONNULL(2, 3);
885 virtual ~pkgAcqIndexDiffs();
888 /** \brief An acquire item that is responsible for fetching an index {{{
889 * file (e.g., Packages or Sources).
891 * \sa pkgAcqDiffIndex, pkgAcqIndexDiffs, pkgAcqIndexTrans
893 * \todo Why does pkgAcqIndex have protected members?
895 class APT_HIDDEN pkgAcqIndex
: public pkgAcqBaseIndex
901 /** \brief The stages the method goes through
903 * The method first downloads the indexfile, then its decompressed (or
904 * copied) and verified
908 STAGE_DECOMPRESS_AND_VERIFY
,
912 /** \brief Handle what needs to be done when the download is done */
913 void StageDownloadDone(std::string
const &Message
);
915 /** \brief Handle what needs to be done when the decompression/copy is
918 void StageDecompressDone();
920 /** \brief If \b set, this partially downloaded file will be
921 * removed when the download completes.
923 std::string EraseFileName
;
925 /** \brief The compression-related file extensions that are being
926 * added to the downloaded file one by one if first fails (e.g., "gz bz2").
928 std::string CompressionExtensions
;
930 /** \brief The actual compression extension currently used */
931 std::string CurrentCompressionExtension
;
933 /** \brief Do the changes needed to fetch via AptByHash (if needed) */
934 void InitByHashIfNeeded();
936 /** \brief Get the full pathname of the final file for the current URI */
937 virtual std::string
GetFinalFilename() const APT_OVERRIDE
;
939 virtual bool TransactionState(TransactionStates
const state
) APT_OVERRIDE
;
942 // Specialized action members
943 virtual void Failed(std::string
const &Message
,pkgAcquire::MethodConfig
const * const Cnf
) APT_OVERRIDE
;
944 virtual void Done(std::string
const &Message
, HashStringList
const &Hashes
,
945 pkgAcquire::MethodConfig
const * const Cnf
) APT_OVERRIDE
;
946 virtual std::string
Custom600Headers() const APT_OVERRIDE
;
947 virtual std::string
DescURI() const APT_OVERRIDE
{return Desc
.URI
;};
948 virtual std::string
GetMetaKey() const APT_OVERRIDE
;
950 pkgAcqIndex(pkgAcquire
* const Owner
, pkgAcqMetaClearSig
* const TransactionManager
,
951 IndexTarget
const &Target
) APT_NONNULL(2, 3);
952 virtual ~pkgAcqIndex();
955 APT_HIDDEN
void Init(std::string
const &URI
, std::string
const &URIDesc
,
956 std::string
const &ShortDesc
);
959 /** \brief An item that is responsible for fetching a package file. {{{
961 * If the package file already exists in the cache, nothing will be
964 class pkgAcqArchive
: public pkgAcquire::Item
969 HashStringList ExpectedHashes
;
972 /** \brief The package version being fetched. */
973 pkgCache::VerIterator Version
;
975 /** \brief The list of sources from which to pick archives to
976 * download this package from.
978 pkgSourceList
*Sources
;
980 /** \brief A package records object, used to look up the file
981 * corresponding to each version of the package.
985 /** \brief A location in which the actual filename of the package
988 std::string
&StoreFilename
;
990 /** \brief The next file for this version to try to download. */
991 pkgCache::VerFileIterator Vf
;
993 /** \brief How many (more) times to try to find a new source from
994 * which to download this package version if it fails.
996 * Set from Acquire::Retries.
998 unsigned int Retries
;
1000 /** \brief \b true if this version file is being downloaded from a
1005 /** \brief Queue up the next available file for this version. */
1008 /** \brief Get the full pathname of the final file for the current URI */
1009 virtual std::string
GetFinalFilename() const APT_OVERRIDE
;
1013 virtual void Failed(std::string
const &Message
,pkgAcquire::MethodConfig
const * const Cnf
) APT_OVERRIDE
;
1014 virtual void Done(std::string
const &Message
, HashStringList
const &Hashes
,
1015 pkgAcquire::MethodConfig
const * const Cnf
) APT_OVERRIDE
;
1016 virtual std::string
DescURI() const APT_OVERRIDE
;
1017 virtual std::string
ShortDesc() const APT_OVERRIDE
;
1018 virtual void Finished() APT_OVERRIDE
;
1019 virtual bool IsTrusted() const APT_OVERRIDE
;
1020 virtual HashStringList
GetExpectedHashes() const APT_OVERRIDE
;
1021 virtual bool HashesRequired() const APT_OVERRIDE
;
1023 /** \brief Create a new pkgAcqArchive.
1025 * \param Owner The pkgAcquire object with which this item is
1028 * \param Sources The sources from which to download version
1031 * \param Recs A package records object, used to look up the file
1032 * corresponding to each version of the package.
1034 * \param Version The package version to download.
1036 * \param[out] StoreFilename A location in which the actual filename of
1037 * the package should be stored. It will be set to a guessed
1038 * basename in the constructor, and filled in with a fully
1039 * qualified filename once the download finishes.
1041 pkgAcqArchive(pkgAcquire
* const Owner
,pkgSourceList
* const Sources
,
1042 pkgRecords
* const Recs
,pkgCache::VerIterator
const &Version
,
1043 std::string
&StoreFilename
);
1044 virtual ~pkgAcqArchive();
1047 /** \brief Retrieve the changelog for the given version {{{
1049 * Downloads the changelog to a temporary file it will also remove again
1050 * while it is deconstructed or downloads it to a named location.
1052 class pkgAcqChangelog
: public pkgAcquire::Item
1056 std::string TemporaryDirectory
;
1057 std::string
const SrcName
;
1058 std::string
const SrcVersion
;
1061 // we will never have hashes for changelogs.
1062 // If you need verified ones, download the deb and extract the changelog.
1063 virtual HashStringList
GetExpectedHashes() const APT_OVERRIDE
{ return HashStringList(); }
1064 virtual bool HashesRequired() const APT_OVERRIDE
{ return false; }
1066 // Specialized action members
1067 virtual void Failed(std::string
const &Message
,pkgAcquire::MethodConfig
const * const Cnf
) APT_OVERRIDE
;
1068 virtual void Done(std::string
const &Message
, HashStringList
const &CalcHashes
,
1069 pkgAcquire::MethodConfig
const * const Cnf
) APT_OVERRIDE
;
1070 virtual std::string
DescURI() const APT_OVERRIDE
{return Desc
.URI
;};
1072 /** returns the URI to the changelog of this version
1074 * @param Ver is the version to get the changelog for
1075 * @return the URI which will be used to acquire the changelog
1077 static std::string
URI(pkgCache::VerIterator
const &Ver
);
1079 /** returns the URI to the changelog of this version
1081 * \param Rls is the Release file the package comes from
1082 * \param Component in which the package resides, can be empty
1083 * \param SrcName is the source package name
1084 * \param SrcVersion is the source package version
1085 * @return the URI which will be used to acquire the changelog
1087 static std::string
URI(pkgCache::RlsFileIterator
const &Rls
,
1088 char const * const Component
, char const * const SrcName
,
1089 char const * const SrcVersion
);
1091 /** returns the URI to the changelog of this version
1093 * \param Template URI where @CHANGEPATH@ has to be filled in
1094 * \param Component in which the package resides, can be empty
1095 * \param SrcName is the source package name
1096 * \param SrcVersion is the source package version
1097 * @return the URI which will be used to acquire the changelog
1099 static std::string
URI(std::string
const &Template
,
1100 char const * const Component
, char const * const SrcName
,
1101 char const * const SrcVersion
);
1103 /** returns the URI template for this release file
1105 * \param Rls is a Release file
1106 * @return the URI template to use for this release file
1108 static std::string
URITemplate(pkgCache::RlsFileIterator
const &Rls
);
1110 /** \brief Create a new pkgAcqChangelog object.
1112 * \param Owner The pkgAcquire object with which this object is
1114 * \param Ver is the version to get the changelog for
1115 * \param DestDir The directory the file should be downloaded into.
1116 * Will be an autocreated (and cleaned up) temporary directory if not set.
1117 * \param DestFilename The filename the file should have in #DestDir
1118 * Defaults to sourcepackagename.changelog if not set.
1120 pkgAcqChangelog(pkgAcquire
* const Owner
, pkgCache::VerIterator
const &Ver
,
1121 std::string
const &DestDir
="", std::string
const &DestFilename
="");
1123 /** \brief Create a new pkgAcqChangelog object.
1125 * \param Owner The pkgAcquire object with which this object is
1127 * \param Rls is the Release file the package comes from
1128 * \param Component in which the package resides, can be empty
1129 * \param SrcName is the source package name
1130 * \param SrcVersion is the source package version
1131 * \param DestDir The directory the file should be downloaded into.
1132 * Will be an autocreated (and cleaned up) temporary directory if not set.
1133 * \param DestFilename The filename the file should have in #DestDir
1134 * Defaults to sourcepackagename.changelog if not set.
1136 pkgAcqChangelog(pkgAcquire
* const Owner
, pkgCache::RlsFileIterator
const &Rls
,
1137 char const * const Component
, char const * const SrcName
, char const * const SrcVersion
,
1138 std::string
const &DestDir
="", std::string
const &DestFilename
="");
1140 /** \brief Create a new pkgAcqChangelog object.
1142 * \param Owner The pkgAcquire object with which this object is
1144 * \param URI is to be used to get the changelog
1145 * \param SrcName is the source package name
1146 * \param SrcVersion is the source package version
1147 * \param DestDir The directory the file should be downloaded into.
1148 * Will be an autocreated (and cleaned up) temporary directory if not set.
1149 * \param DestFilename The filename the file should have in #DestDir
1150 * Defaults to sourcepackagename.changelog if not set.
1152 pkgAcqChangelog(pkgAcquire
* const Owner
, std::string
const &URI
,
1153 char const * const SrcName
, char const * const SrcVersion
,
1154 std::string
const &DestDir
="", std::string
const &DestFilename
="");
1156 virtual ~pkgAcqChangelog();
1159 APT_HIDDEN
void Init(std::string
const &DestDir
, std::string
const &DestFilename
);
1162 /** \brief Retrieve an arbitrary file to the current directory. {{{
1164 * The file is retrieved even if it is accessed via a URL type that
1165 * normally is a NOP, such as "file". If the download fails, the
1166 * partial file is renamed to get a ".FAILED" extension.
1168 class pkgAcqFile
: public pkgAcquire::Item
1172 /** \brief How many times to retry the download, set from
1175 unsigned int Retries
;
1177 /** \brief Should this file be considered a index file */
1180 HashStringList
const ExpectedHashes
;
1182 virtual HashStringList
GetExpectedHashes() const APT_OVERRIDE
;
1183 virtual bool HashesRequired() const APT_OVERRIDE
;
1185 // Specialized action members
1186 virtual void Failed(std::string
const &Message
,pkgAcquire::MethodConfig
const * const Cnf
) APT_OVERRIDE
;
1187 virtual void Done(std::string
const &Message
, HashStringList
const &CalcHashes
,
1188 pkgAcquire::MethodConfig
const * const Cnf
) APT_OVERRIDE
;
1189 virtual std::string
DescURI() const APT_OVERRIDE
{return Desc
.URI
;};
1190 virtual std::string
Custom600Headers() const APT_OVERRIDE
;
1192 /** \brief Create a new pkgAcqFile object.
1194 * \param Owner The pkgAcquire object with which this object is
1197 * \param URI The URI to download.
1199 * \param Hashes The hashsums of the file to download, if they are known;
1200 * otherwise empty list.
1202 * \param Size The size of the file to download, if it is known;
1205 * \param Desc A description of the file being downloaded.
1207 * \param ShortDesc A brief description of the file being
1210 * \param DestDir The directory the file should be downloaded into.
1212 * \param DestFilename The filename+path the file is downloaded to.
1214 * \param IsIndexFile The file is considered a IndexFile and cache-control
1215 * headers like "cache-control: max-age=0" are send
1217 * If DestFilename is empty, download to DestDir/\<basename\> if
1218 * DestDir is non-empty, $CWD/\<basename\> otherwise. If
1219 * DestFilename is NOT empty, DestDir is ignored and DestFilename
1220 * is the absolute name to which the file should be downloaded.
1223 pkgAcqFile(pkgAcquire
* const Owner
, std::string
const &URI
, HashStringList
const &Hashes
, unsigned long long const Size
,
1224 std::string
const &Desc
, std::string
const &ShortDesc
,
1225 std::string
const &DestDir
="", std::string
const &DestFilename
="",
1226 bool const IsIndexFile
=false);
1227 virtual ~pkgAcqFile();