Various documentation fixes and additions.
[quix0rs-apt-p2p.git] / apt_dht / AptPackages.py
1 #
2 # Copyright (C) 2002 Manuel Estrada Sainz <ranty@debian.org>
3 # Copyright (C) 2008 Cameron Dale <camrdale@gmail.com>
4 #
5 # This library is free software; you can redistribute it and/or
6 # modify it under the terms of version 2.1 of the GNU General Public
7 # License as published by the Free Software Foundation.
8 #
9 # This library is distributed in the hope that it will be useful,
10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12 # General Public License for more details.
13 #
14 # You should have received a copy of the GNU General Public
15 # License along with this library; if not, write to the Free Software
16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17
18 """Manage a mirror's index files.
19
20 @type TRACKED_FILES: C{list} of C{string}
21 @var TRACKED_FILES: the file names of files that contain index information
22 """
23
24 # Disable the FutureWarning from the apt module
25 import warnings
26 warnings.simplefilter("ignore", FutureWarning)
27
28 import os, shelve
29 from random import choice
30 from shutil import rmtree
31 from copy import deepcopy
32 from UserDict import DictMixin
33
34 from twisted.internet import threads, defer, reactor
35 from twisted.python import log
36 from twisted.python.filepath import FilePath
37 from twisted.trial import unittest
38
39 import apt_pkg, apt_inst
40 from apt import OpProgress
41 from debian_bundle import deb822
42
43 from Hash import HashObject
44
45 apt_pkg.init()
46
47 TRACKED_FILES = ['release', 'sources', 'packages']
48
49 class PackageFileList(DictMixin):
50     """Manages a list of index files belonging to a mirror.
51     
52     @type cache_dir: L{twisted.python.filepath.FilePath}
53     @ivar cache_dir: the directory to use for storing all files
54     @type packages: C{shelve dictionary}
55     @ivar packages: the files tracked for this mirror
56     """
57     
58     def __init__(self, cache_dir):
59         """Initialize the list by opening the dictionary."""
60         self.cache_dir = cache_dir
61         self.cache_dir.restat(False)
62         if not self.cache_dir.exists():
63             self.cache_dir.makedirs()
64         self.packages = None
65         self.open()
66
67     def open(self):
68         """Open the persistent dictionary of files for this mirror."""
69         if self.packages is None:
70             self.packages = shelve.open(self.cache_dir.child('packages.db').path)
71
72     def close(self):
73         """Close the persistent dictionary."""
74         if self.packages is not None:
75             self.packages.close()
76
77     def update_file(self, cache_path, file_path):
78         """Check if an updated file needs to be tracked.
79
80         Called from the mirror manager when files get updated so we can update our
81         fake lists and sources.list.
82         
83         @type cache_path: C{string}
84         @param cache_path: the location of the file within the mirror
85         @type file_path: L{twisted.python.filepath.FilePath}
86         @param file_path: The location of the file in the file system
87         @rtype: C{boolean}
88         @return: whether the file is an index file
89         """
90         filename = cache_path.split('/')[-1]
91         if filename.lower() in TRACKED_FILES:
92             log.msg("Registering package file: "+cache_path)
93             self.packages[cache_path] = file_path
94             return True
95         return False
96
97     def check_files(self):
98         """Check all files in the database to remove any that don't exist."""
99         files = self.packages.keys()
100         for f in files:
101             self.packages[f].restat(False)
102             if not self.packages[f].exists():
103                 log.msg("File in packages database has been deleted: "+f)
104                 del self.packages[f]
105
106     #{ Dictionary interface details
107     def __getitem__(self, key): return self.packages[key]
108     def __setitem__(self, key, item): self.packages[key] = item
109     def __delitem__(self, key): del self.packages[key]
110     def keys(self): return self.packages.keys()
111
112 class AptPackages:
113     """Answers queries about packages available from a mirror.
114     
115     Uses the python-apt tools to parse and provide information about the
116     files that are available on a single mirror.
117     
118     @ivar DEFAULT_APT_CONFIG: the default configuration parameters to use for apt
119     @ivar essential_dirs: directories that must be created for apt to work
120     @ivar essential_files: files that must be created for apt to work
121     @type cache_dir: L{twisted.python.filepath.FilePath}
122     @ivar cache_dir: the directory to use for storing all files
123     @type unload_delay: C{int}
124     @ivar unload_delay: the time to wait before unloading the apt cache
125     @ivar apt_config: the configuration parameters to use for apt
126     @type packages: L{PackageFileList}
127     @ivar packages: the persistent storage of tracked apt index files
128     @type loaded: C{boolean}
129     @ivar loaded: whether the apt cache is currently loaded
130     @type loading: L{twisted.internet.defer.Deferred}
131     @ivar loading: if the cache is currently being loaded, this will be
132         called when it is loaded, otherwise it is None
133     @type unload_later: L{twisted.internet.interfaces.IDelayedCall}
134     @ivar unload_later: the delayed call to unload the apt cache
135     @type indexrecords: C{dictionary}
136     @ivar indexrecords: the hashes of index files for the mirror, keys are
137         mirror directories, values are dictionaries with keys the path to the
138         index file in the mirror directory and values are dictionaries with
139         keys the hash type and values the hash
140     @type cache: C{apt_pkg.GetCache()}
141     @ivar cache: the apt cache of the mirror
142     @type records: C{apt_pkg.GetPkgRecords()}
143     @ivar records: the apt package records for all binary packages in a mirror
144     @type srcrecords: C{apt_pkg.GetPkgSrcRecords}
145     @ivar srcrecords: the apt package records for all source packages in a mirror
146     """
147
148     DEFAULT_APT_CONFIG = {
149         #'APT' : '',
150         #'APT::Architecture' : 'i386',  # Commented so the machine's config will set this
151         #'APT::Default-Release' : 'unstable',
152         'Dir':'.', # /
153         'Dir::State' : 'apt/', # var/lib/apt/
154         'Dir::State::Lists': 'lists/', # lists/
155         #'Dir::State::cdroms' : 'cdroms.list',
156         'Dir::State::userstatus' : 'status.user',
157         'Dir::State::status': 'dpkg/status', # '/var/lib/dpkg/status'
158         'Dir::Cache' : '.apt/cache/', # var/cache/apt/
159         #'Dir::Cache::archives' : 'archives/',
160         'Dir::Cache::srcpkgcache' : 'srcpkgcache.bin',
161         'Dir::Cache::pkgcache' : 'pkgcache.bin',
162         'Dir::Etc' : 'apt/etc/', # etc/apt/
163         'Dir::Etc::sourcelist' : 'sources.list',
164         'Dir::Etc::vendorlist' : 'vendors.list',
165         'Dir::Etc::vendorparts' : 'vendors.list.d',
166         #'Dir::Etc::main' : 'apt.conf',
167         #'Dir::Etc::parts' : 'apt.conf.d',
168         #'Dir::Etc::preferences' : 'preferences',
169         'Dir::Bin' : '',
170         #'Dir::Bin::methods' : '', #'/usr/lib/apt/methods'
171         'Dir::Bin::dpkg' : '/usr/bin/dpkg',
172         #'DPkg' : '',
173         #'DPkg::Pre-Install-Pkgs' : '',
174         #'DPkg::Tools' : '',
175         #'DPkg::Tools::Options' : '',
176         #'DPkg::Tools::Options::/usr/bin/apt-listchanges' : '',
177         #'DPkg::Tools::Options::/usr/bin/apt-listchanges::Version' : '2',
178         #'DPkg::Post-Invoke' : '',
179         }
180     essential_dirs = ('apt', 'apt/cache', 'apt/dpkg', 'apt/etc', 'apt/lists',
181                       'apt/lists/partial')
182     essential_files = ('apt/dpkg/status', 'apt/etc/sources.list',)
183         
184     def __init__(self, cache_dir, unload_delay):
185         """Construct a new packages manager.
186
187         @param cache_dir: directory to use to store files for this mirror
188         """
189         self.cache_dir = cache_dir
190         self.unload_delay = unload_delay
191         self.apt_config = deepcopy(self.DEFAULT_APT_CONFIG)
192
193         # Create the necessary files and directories for apt
194         for dir in self.essential_dirs:
195             path = self.cache_dir.preauthChild(dir)
196             if not path.exists():
197                 path.makedirs()
198         for file in self.essential_files:
199             path = self.cache_dir.preauthChild(file)
200             if not path.exists():
201                 path.touch()
202                 
203         self.apt_config['Dir'] = self.cache_dir.path
204         self.apt_config['Dir::State::status'] = self.cache_dir.preauthChild(self.apt_config['Dir::State']).preauthChild(self.apt_config['Dir::State::status']).path
205         self.packages = PackageFileList(cache_dir)
206         self.loaded = False
207         self.loading = None
208         self.unload_later = None
209         
210     def __del__(self):
211         self.cleanup()
212         self.packages.close()
213         
214     def addRelease(self, cache_path, file_path):
215         """Add a Release file's info to the list of index files.
216         
217         Dirty hack until python-apt supports apt-pkg/indexrecords.h
218         (see Bug #456141)
219         """
220         self.indexrecords[cache_path] = {}
221
222         read_packages = False
223         f = file_path.open('r')
224         
225         # Use python-debian routines to parse the file for hashes
226         rel = deb822.Release(f, fields = ['MD5Sum', 'SHA1', 'SHA256'])
227         for hash_type in rel:
228             for file in rel[hash_type]:
229                 self.indexrecords[cache_path].setdefault(file['name'], {})[hash_type.upper()] = (file[hash_type], file['size'])
230             
231         f.close()
232
233     def file_updated(self, cache_path, file_path):
234         """A file in the mirror has changed or been added.
235         
236         If this affects us, unload our apt database.
237         @see: L{PackageFileList.update_file}
238         """
239         if self.packages.update_file(cache_path, file_path):
240             self.unload()
241
242     def load(self):
243         """Make sure the package cache is initialized and loaded."""
244         # Reset the pending unload call
245         if self.unload_later and self.unload_later.active():
246             self.unload_later.reset(self.unload_delay)
247         else:
248             self.unload_later = reactor.callLater(self.unload_delay, self.unload)
249             
250         # Make sure it's not already being loaded
251         if self.loading is None:
252             log.msg('Loading the packages cache')
253             self.loading = threads.deferToThread(self._load)
254             self.loading.addCallback(self.doneLoading)
255         return self.loading
256         
257     def doneLoading(self, loadResult):
258         """Cache is loaded."""
259         self.loading = None
260         # Must pass on the result for the next callback
261         return loadResult
262         
263     def _load(self):
264         """Regenerates the fake configuration and loads the packages caches."""
265         if self.loaded: return True
266         
267         # Modify the default configuration to create the fake one.
268         apt_pkg.InitSystem()
269         self.cache_dir.preauthChild(self.apt_config['Dir::State']
270                      ).preauthChild(self.apt_config['Dir::State::Lists']).remove()
271         self.cache_dir.preauthChild(self.apt_config['Dir::State']
272                      ).preauthChild(self.apt_config['Dir::State::Lists']
273                      ).child('partial').makedirs()
274         sources_file = self.cache_dir.preauthChild(self.apt_config['Dir::Etc']
275                                ).preauthChild(self.apt_config['Dir::Etc::sourcelist'])
276         sources = sources_file.open('w')
277         sources_count = 0
278         deb_src_added = False
279         self.packages.check_files()
280         self.indexrecords = {}
281         
282         # Create an entry in sources.list for each needed index file
283         for f in self.packages:
284             # we should probably clear old entries from self.packages and
285             # take into account the recorded mtime as optimization
286             file = self.packages[f]
287             if f.split('/')[-1] == "Release":
288                 self.addRelease(f, file)
289             fake_uri='http://apt-dht'+f
290             fake_dirname = '/'.join(fake_uri.split('/')[:-1])
291             if f.endswith('Sources'):
292                 deb_src_added = True
293                 source_line='deb-src '+fake_dirname+'/ /'
294             else:
295                 source_line='deb '+fake_dirname+'/ /'
296             listpath = self.cache_dir.preauthChild(self.apt_config['Dir::State']
297                                     ).preauthChild(self.apt_config['Dir::State::Lists']
298                                     ).child(apt_pkg.URItoFileName(fake_uri))
299             sources.write(source_line+'\n')
300             log.msg("Sources line: " + source_line)
301             sources_count = sources_count + 1
302
303             if listpath.exists():
304                 #we should empty the directory instead
305                 listpath.remove()
306             os.symlink(file.path, listpath.path)
307         sources.close()
308
309         if sources_count == 0:
310             log.msg("No Packages files available for %s backend"%(self.cache_dir.path))
311             return False
312
313         log.msg("Loading Packages database for "+self.cache_dir.path)
314         for key, value in self.apt_config.items():
315             apt_pkg.Config[key] = value
316
317         self.cache = apt_pkg.GetCache(OpProgress())
318         self.records = apt_pkg.GetPkgRecords(self.cache)
319         if deb_src_added:
320             self.srcrecords = apt_pkg.GetPkgSrcRecords()
321         else:
322             self.srcrecords = None
323
324         self.loaded = True
325         return True
326
327     def unload(self):
328         """Tries to make the packages server quit."""
329         if self.unload_later and self.unload_later.active():
330             self.unload_later.cancel()
331         self.unload_later = None
332         if self.loaded:
333             log.msg('Unloading the packages cache')
334             # This should save memory
335             del self.cache
336             del self.records
337             del self.srcrecords
338             del self.indexrecords
339             self.loaded = False
340
341     def cleanup(self):
342         """Cleanup and close any loaded caches."""
343         self.unload()
344         self.packages.close()
345         
346     def findHash(self, path):
347         """Find the hash for a given path in this mirror.
348         
349         @type path: C{string}
350         @param path: the path within the mirror of the file to lookup
351         @rtype: L{twisted.internet.defer.Deferred}
352         @return: a deferred so it can make sure the cache is loaded first
353         """
354         d = defer.Deferred()
355
356         deferLoad = self.load()
357         deferLoad.addCallback(self._findHash, path, d)
358         deferLoad.addErrback(self._findHash_error, path, d)
359         
360         return d
361
362     def _findHash_error(self, failure, path, d):
363         """An error occurred, return an empty hash."""
364         log.msg('An error occurred while looking up a hash for: %s' % path)
365         log.err(failure)
366         d.callback(HashObject())
367         return failure
368
369     def _findHash(self, loadResult, path, d):
370         """Search the records for the hash of a path.
371         
372         @type loadResult: C{boolean}
373         @param loadResult: whether apt's cache was successfully loaded
374         @type path: C{string}
375         @param path: the path within the mirror of the file to lookup
376         @type d: L{twisted.internet.defer.Deferred}
377         @param d: the deferred to callback with the result
378         """
379         if not loadResult:
380             d.callback(HashObject())
381             return loadResult
382         
383         h = HashObject()
384         
385         # First look for the path in the cache of index files
386         for release in self.indexrecords:
387             if path.startswith(release[:-7]):
388                 for indexFile in self.indexrecords[release]:
389                     if release[:-7] + indexFile == path:
390                         h.setFromIndexRecord(self.indexrecords[release][indexFile])
391                         d.callback(h)
392                         return loadResult
393         
394         package = path.split('/')[-1].split('_')[0]
395
396         # Check the binary packages
397         try:
398             for version in self.cache[package].VersionList:
399                 size = version.Size
400                 for verFile in version.FileList:
401                     if self.records.Lookup(verFile):
402                         if '/' + self.records.FileName == path:
403                             h.setFromPkgRecord(self.records, size)
404                             d.callback(h)
405                             return loadResult
406         except KeyError:
407             pass
408
409         # Check the source packages' files
410         if self.srcrecords:
411             self.srcrecords.Restart()
412             if self.srcrecords.Lookup(package):
413                 for f in self.srcrecords.Files:
414                     if path == '/' + f[2]:
415                         h.setFromSrcRecord(f)
416                         d.callback(h)
417                         return loadResult
418         
419         d.callback(h)
420         
421         # Have to pass the returned loadResult on in case other calls to this function are pending.
422         return loadResult
423
424 class TestAptPackages(unittest.TestCase):
425     """Unit tests for the AptPackages cache."""
426     
427     pending_calls = []
428     client = None
429     timeout = 10
430     packagesFile = ''
431     sourcesFile = ''
432     releaseFile = ''
433     
434     def setUp(self):
435         """Initializes the cache with files found in the traditional apt location."""
436         self.client = AptPackages(FilePath('/tmp/.apt-dht'), 300)
437     
438         # Find the largest index files that are for 'main'
439         self.packagesFile = os.popen('ls -Sr /var/lib/apt/lists/ | grep -E "_main_.*Packages$" | tail -n 1').read().rstrip('\n')
440         self.sourcesFile = os.popen('ls -Sr /var/lib/apt/lists/ | grep -E "_main_.*Sources$" | tail -n 1').read().rstrip('\n')
441         
442         # Find the Release file corresponding to the found Packages file
443         for f in os.walk('/var/lib/apt/lists').next()[2]:
444             if f[-7:] == "Release" and self.packagesFile.startswith(f[:-7]):
445                 self.releaseFile = f
446                 break
447
448         # Add all the found files to the PackageFileList
449         self.client.file_updated(self.releaseFile[self.releaseFile.find('_dists_'):].replace('_','/'), 
450                                  FilePath('/var/lib/apt/lists/' + self.releaseFile))
451         self.client.file_updated(self.packagesFile[self.packagesFile.find('_dists_'):].replace('_','/'), 
452                                  FilePath('/var/lib/apt/lists/' + self.packagesFile))
453         self.client.file_updated(self.sourcesFile[self.sourcesFile.find('_dists_'):].replace('_','/'), 
454                                  FilePath('/var/lib/apt/lists/' + self.sourcesFile))
455     
456     def test_pkg_hash(self):
457         """Tests loading the binary package records cache."""
458         self.client._load()
459
460         self.client.records.Lookup(self.client.cache['dpkg'].VersionList[0].FileList[0])
461         
462         pkg_hash = os.popen('grep -A 30 -E "^Package: dpkg$" ' + 
463                             '/var/lib/apt/lists/' + self.packagesFile + 
464                             ' | grep -E "^SHA1:" | head -n 1' + 
465                             ' | cut -d\  -f 2').read().rstrip('\n')
466
467         self.failUnless(self.client.records.SHA1Hash == pkg_hash, 
468                         "Hashes don't match: %s != %s" % (self.client.records.SHA1Hash, pkg_hash))
469
470     def test_src_hash(self):
471         """Tests loading the source package records cache."""
472         self.client._load()
473
474         self.client.srcrecords.Lookup('dpkg')
475
476         src_hashes = os.popen('grep -A 20 -E "^Package: dpkg$" ' + 
477                             '/var/lib/apt/lists/' + self.sourcesFile + 
478                             ' | grep -A 4 -E "^Files:" | grep -E "^ " ' + 
479                             ' | cut -d\  -f 2').read().split('\n')[:-1]
480
481         for f in self.client.srcrecords.Files:
482             self.failUnless(f[0] in src_hashes, "Couldn't find %s in: %r" % (f[0], src_hashes))
483
484     def test_index_hash(self):
485         """Tests loading the cache of index file information."""
486         self.client._load()
487
488         indexhash = self.client.indexrecords[self.releaseFile[self.releaseFile.find('_dists_'):].replace('_','/')]['main/binary-i386/Packages.bz2']['SHA1'][0]
489
490         idx_hash = os.popen('grep -A 3000 -E "^SHA1:" ' + 
491                             '/var/lib/apt/lists/' + self.releaseFile + 
492                             ' | grep -E " main/binary-i386/Packages.bz2$"'
493                             ' | head -n 1 | cut -d\  -f 2').read().rstrip('\n')
494
495         self.failUnless(indexhash == idx_hash, "Hashes don't match: %s != %s" % (indexhash, idx_hash))
496
497     def verifyHash(self, found_hash, path, true_hash):
498         self.failUnless(found_hash.hexexpected() == true_hash, 
499                     "%s hashes don't match: %s != %s" % (path, found_hash.hexexpected(), true_hash))
500
501     def test_findIndexHash(self):
502         """Tests finding the hash of a single index file."""
503         lastDefer = defer.Deferred()
504         
505         idx_hash = os.popen('grep -A 3000 -E "^SHA1:" ' + 
506                             '/var/lib/apt/lists/' + self.releaseFile + 
507                             ' | grep -E " main/binary-i386/Packages.bz2$"'
508                             ' | head -n 1 | cut -d\  -f 2').read().rstrip('\n')
509         idx_path = '/' + self.releaseFile[self.releaseFile.find('_dists_')+1:].replace('_','/')[:-7] + 'main/binary-i386/Packages.bz2'
510
511         d = self.client.findHash(idx_path)
512         d.addCallback(self.verifyHash, idx_path, idx_hash)
513
514         d.addBoth(lastDefer.callback)
515         return lastDefer
516
517     def test_findPkgHash(self):
518         """Tests finding the hash of a single binary package."""
519         lastDefer = defer.Deferred()
520         
521         pkg_hash = os.popen('grep -A 30 -E "^Package: dpkg$" ' + 
522                             '/var/lib/apt/lists/' + self.packagesFile + 
523                             ' | grep -E "^SHA1:" | head -n 1' + 
524                             ' | cut -d\  -f 2').read().rstrip('\n')
525         pkg_path = '/' + os.popen('grep -A 30 -E "^Package: dpkg$" ' + 
526                             '/var/lib/apt/lists/' + self.packagesFile + 
527                             ' | grep -E "^Filename:" | head -n 1' + 
528                             ' | cut -d\  -f 2').read().rstrip('\n')
529
530         d = self.client.findHash(pkg_path)
531         d.addCallback(self.verifyHash, pkg_path, pkg_hash)
532
533         d.addBoth(lastDefer.callback)
534         return lastDefer
535
536     def test_findSrcHash(self):
537         """Tests finding the hash of a single source package."""
538         lastDefer = defer.Deferred()
539         
540         src_dir = '/' + os.popen('grep -A 30 -E "^Package: dpkg$" ' + 
541                             '/var/lib/apt/lists/' + self.sourcesFile + 
542                             ' | grep -E "^Directory:" | head -n 1' + 
543                             ' | cut -d\  -f 2').read().rstrip('\n')
544         src_hashes = os.popen('grep -A 20 -E "^Package: dpkg$" ' + 
545                             '/var/lib/apt/lists/' + self.sourcesFile + 
546                             ' | grep -A 4 -E "^Files:" | grep -E "^ " ' + 
547                             ' | cut -d\  -f 2').read().split('\n')[:-1]
548         src_paths = os.popen('grep -A 20 -E "^Package: dpkg$" ' + 
549                             '/var/lib/apt/lists/' + self.sourcesFile + 
550                             ' | grep -A 4 -E "^Files:" | grep -E "^ " ' + 
551                             ' | cut -d\  -f 4').read().split('\n')[:-1]
552
553         i = choice(range(len(src_hashes)))
554         d = self.client.findHash(src_dir + '/' + src_paths[i])
555         d.addCallback(self.verifyHash, src_dir + '/' + src_paths[i], src_hashes[i])
556             
557         d.addBoth(lastDefer.callback)
558         return lastDefer
559
560     def test_multipleFindHash(self):
561         """Tests finding the hash of an index file, binary package, source package, and another index file."""
562         lastDefer = defer.Deferred()
563         
564         # Lookup a Packages.bz2 file
565         idx_hash = os.popen('grep -A 3000 -E "^SHA1:" ' + 
566                             '/var/lib/apt/lists/' + self.releaseFile + 
567                             ' | grep -E " main/binary-i386/Packages.bz2$"'
568                             ' | head -n 1 | cut -d\  -f 2').read().rstrip('\n')
569         idx_path = '/' + self.releaseFile[self.releaseFile.find('_dists_')+1:].replace('_','/')[:-7] + 'main/binary-i386/Packages.bz2'
570
571         d = self.client.findHash(idx_path)
572         d.addCallback(self.verifyHash, idx_path, idx_hash)
573
574         # Lookup the binary 'dpkg' package
575         pkg_hash = os.popen('grep -A 30 -E "^Package: dpkg$" ' + 
576                             '/var/lib/apt/lists/' + self.packagesFile + 
577                             ' | grep -E "^SHA1:" | head -n 1' + 
578                             ' | cut -d\  -f 2').read().rstrip('\n')
579         pkg_path = '/' + os.popen('grep -A 30 -E "^Package: dpkg$" ' + 
580                             '/var/lib/apt/lists/' + self.packagesFile + 
581                             ' | grep -E "^Filename:" | head -n 1' + 
582                             ' | cut -d\  -f 2').read().rstrip('\n')
583
584         d = self.client.findHash(pkg_path)
585         d.addCallback(self.verifyHash, pkg_path, pkg_hash)
586
587         # Lookup the source 'dpkg' package
588         src_dir = '/' + os.popen('grep -A 30 -E "^Package: dpkg$" ' + 
589                             '/var/lib/apt/lists/' + self.sourcesFile + 
590                             ' | grep -E "^Directory:" | head -n 1' + 
591                             ' | cut -d\  -f 2').read().rstrip('\n')
592         src_hashes = os.popen('grep -A 20 -E "^Package: dpkg$" ' + 
593                             '/var/lib/apt/lists/' + self.sourcesFile + 
594                             ' | grep -A 4 -E "^Files:" | grep -E "^ " ' + 
595                             ' | cut -d\  -f 2').read().split('\n')[:-1]
596         src_paths = os.popen('grep -A 20 -E "^Package: dpkg$" ' + 
597                             '/var/lib/apt/lists/' + self.sourcesFile + 
598                             ' | grep -A 4 -E "^Files:" | grep -E "^ " ' + 
599                             ' | cut -d\  -f 4').read().split('\n')[:-1]
600
601         for i in range(len(src_hashes)):
602             d = self.client.findHash(src_dir + '/' + src_paths[i])
603             d.addCallback(self.verifyHash, src_dir + '/' + src_paths[i], src_hashes[i])
604             
605         # Lookup a Sources.bz2 file
606         idx_hash = os.popen('grep -A 3000 -E "^SHA1:" ' + 
607                             '/var/lib/apt/lists/' + self.releaseFile + 
608                             ' | grep -E " main/source/Sources.bz2$"'
609                             ' | head -n 1 | cut -d\  -f 2').read().rstrip('\n')
610         idx_path = '/' + self.releaseFile[self.releaseFile.find('_dists_')+1:].replace('_','/')[:-7] + 'main/source/Sources.bz2'
611
612         d = self.client.findHash(idx_path)
613         d.addCallback(self.verifyHash, idx_path, idx_hash)
614
615         d.addBoth(lastDefer.callback)
616         return lastDefer
617
618     def tearDown(self):
619         for p in self.pending_calls:
620             if p.active():
621                 p.cancel()
622         self.pending_calls = []
623         self.client.cleanup()
624         self.client = None