def make_unpacked_source(self): """Create an unpacked source tree in a branch. Return the working tree""" tree = self.make_branch_and_tree('.') cl_file = 'debian/changelog' source_files = ['debian/'] + [cl_file] self.build_tree(source_files) c = self.make_changelog() with open(cl_file, 'w') as f: c.write_to_open_file(f) tree.add(source_files) source = Deb822() source['Source'] = self.package_name binary = Deb822() binary['Package'] = self.package_name binary['Architecture'] = 'all' with open('debian/control', 'wb') as f: source.dump(f) f.write(b'\n') binary.dump(f) tree.add('debian/control') self.build_tree(['debian/test-file']) tree.add('debian/test-file') return tree
def generate_control_file(self): dsc = Dsc() build_deps = [] packages = OrderedDict() self.installs = {} self.symlinks = {} for item in self.generate_control_content(): log.debug(repr(item)) if isinstance(item, SourceControl): for key, value in item.items(): key = '-'.join([k.capitalize() for k in key.split('_')]) if key == 'Description': value = value.strip() \ .replace('\n\n', '\n.\n') \ .replace('\n', '\n ') dsc[key] = value elif isinstance(item, BuildDependency): build_deps.append(item.dependency) elif isinstance(item, Package): control = Deb822() for key, value in item._asdict().items(): key = '-'.join([k.capitalize() for k in key.split('_')]) if key == 'Description': value = value.strip() \ .replace('\n\n', '\n.\n') \ .replace('\n', '\n ') control[key] = value packages[item.package] = (control, [], []) self.installs[item.package] = [] self.symlinks[item.package] = [] elif isinstance(item, Dependency): packages[item.package][1].append(item.dependency) elif isinstance(item, Provide): packages[item.package][2].append(item.provide) elif isinstance(item, Symlink): self.symlinks[item.package].append((item.dest, item.src)) elif isinstance(item, FastBuild): if self.fast_build is None: self.fast_build = item.possible else: self.fast_build = self.fast_build and item.possible else: raise NotImplementedError( 'Got unexcepted action item' ' on control generation {!r}'.format(item)) if self.installs: build_deps.append('dh-exec') with open(self.debian_file('control'), 'wb') as control_file: dsc['Build-Depends'] = ', '.join(build_deps) dsc.dump(control_file) for control, deps, provides in packages.values(): if deps: control['Depends'] = ', '.join(deps) if provides: control['Provides'] = ', '.join(provides) control_file.write(b'\n') control.dump(control_file)
def main(): module = AnsibleModule( argument_spec={ 'path': {'type': 'path', 'required': True} } ) if not HAS_DEB_PKG_TOOLS: module.fail_json(msg='The deb_pkg_tools is required for this module') with open(module.params['path']) as f: paragraphs = list(Deb822.iter_paragraphs(f)) return_data = { 'sources': {}, 'packages': {} } for paragraph in paragraphs: data = control.parse_control_fields(paragraph) package = data.get('Package') source = data.get('Source') key = 'packages' if package else 'sources' return_data[key][package or source] = item = {} for field in control.DEPENDS_LIKE_FIELDS: item[field] = list(getattr(data.get(field), 'names', [])) for field in data: if field in control.DEPENDS_LIKE_FIELDS: continue item[field] = data.get(field) module.exit_json(**return_data)
def listBin(self, arch, component, idrel, name): """ Return an iterator over packages. arch, component and relese can all be either None, meaning no restriction, a string or number (in case of idrel), or an iterable. """ (sqlj, sqlw, sqlparams) = makeQuery(arch, component, idrel, name) sql = 'SELECT b.*,rel.Codename AS release, r.component, r.Filename ' \ + sqlj \ + ' JOIN releases rel on r.idrel = rel.id ' \ + sqlw \ + ' ORDER BY rel.Codename, r.component, b.name, b.Architecture' logger.debug("Query for list = %s", sql) self.dbc.execute(sql, sqlparams) while True: r = self.dbc.fetchone() if r is None: return # make a dict from the query in the usual way p = collections.defaultdict(lambda: '', zip(r.keys(), r)) # update with keys from control file p.update(Deb822(p['control'])) del p['control'] p['shortdesc'] = (p['Description'].partition('\n'))[0] yield p
def test_control_field_parsing(self): deb822_package = Deb822([ 'Package: python-py2deb', 'Depends: python-deb-pkg-tools, python-pip, python-pip-accel', 'Installed-Size: 42' ]) parsed_info = parse_control_fields(deb822_package) self.assertEqual( parsed_info, { 'Package': 'python-py2deb', 'Depends': RelationshipSet(Relationship(name=u'python-deb-pkg-tools'), Relationship(name=u'python-pip'), Relationship(name=u'python-pip-accel')), 'Installed-Size': 42 }) # Test backwards compatibility with the old interface where `Depends' # like fields were represented as a list of strings (shallow parsed). parsed_info['Depends'] = [unicode(r) for r in parsed_info['Depends']] self.assertEqual(unparse_control_fields(parsed_info), deb822_package) # Test compatibility with fields like `Depends' containing a string. parsed_info['Depends'] = deb822_package['Depends'] self.assertEqual(unparse_control_fields(parsed_info), deb822_package)
async def add_to_cache(url: URLObject): package = app.registry.get_or_create(url) if package.status == Status.UNSEEN: package_archive = await app.http.get(url) if not package_archive.status == 200: return fileobj = io.BytesIO(await package_archive.read()) fileobj.seek(0) untarred = tarfile.open(fileobj=fileobj, mode="r:*") meta = {} try: for f in untarred.getmembers(): if f.name.endswith("DESCRIPTION"): logger.debug(f"add_to_cache:found {f.name}") meta = Deb822( untarred.extractfile(f).read().decode("utf8")) logger.debug(meta) package.name = meta.get("Package") package.version = meta.get("Version") if meta.get("NeedsCompilation") == "yes": temp_dir = tempfile.mkdtemp() untarred.extractall(temp_dir) package.fs_path = pathlib.Path(temp_dir) / meta.get("Package") package.status = Status.TOBUILD await app.compile_queue.put(package) else: package.status = Status.NONBINARY finally: untarred.close() fileobj.close()
def update(self, repo): repo_dict = dict([(str(k), str(v)) for (k, v) in repo.items()]) repo_dict['id'] = repo.id self.repos822[:] = [ repo822 if repo822['id'] != repo.id else Deb822(repo_dict) for repo822 in self.repos822 ]
def handle(self, *args, **options): if not args: raise CommandError("Require a tag, e.g. sid, wheezy, squeeze, etc...") tag = args[0] filenames = args[1:] if not tag.isalpha() or not tag.islower(): raise CommandError("First argument must be tag, e.g. sid, wheezy, squeeze, etc...") self.session = db.get_db_session() # self.session.bind.echo=False self.descr_text_map = {} self.descr_map = {} self.stats = defaultdict(int) for file in filenames: self.stderr.write('Processing %s\n' % file) f = self._open(file) for para in Deb822.iter_paragraphs(f): if 'Description-en' in para: self._handle_translation_en(para) if 'Version' in para: try: self._handle_packages(tag, para) except Exception, e: self.stdout.write("Problem processing %r\n%s\n" % (para, e)) self.session.commit()
def apt_get_source_package(name: str) -> Deb822: """Get source package metadata. Args: name: Name of the source package Returns: A `Deb822` object """ import apt_pkg apt_pkg.init() try: sources = apt_pkg.SourceRecords() except apt_pkg.Error as e: if e.args[0] == ( "E:You must put some 'deb-src' URIs in your sources.list"): raise NoAptSources() raise by_version: Dict[str, Deb822] = {} while sources.lookup(name): by_version[sources.version] = sources.record # type: ignore if len(by_version) == 0: raise NoSuchPackage(name) # Try the latest version version = sorted(by_version, key=Version)[-1] return Deb822(by_version[version])
def test_control_field_merging(self): """Test the merging of control file fields.""" defaults = Deb822(['Package: python-py2deb', 'Depends: python-deb-pkg-tools', 'Architecture: all']) # The field names of the dictionary with overrides are lower case on # purpose; control file merging should work properly regardless of # field name casing. overrides = Deb822(dict(version='1.0', depends='python-pip, python-pip-accel', architecture='amd64')) assert merge_control_fields(defaults, overrides) == \ Deb822(['Package: python-py2deb', 'Version: 1.0', 'Depends: python-deb-pkg-tools, python-pip, python-pip-accel', 'Architecture: amd64'])
def get_newqueue_available(package, timeout, dists=None, http_proxy=None, arch='i386'): if dists is None: dists = ('unstable (new queue)', ) try: page = open_url(NEWQUEUE_URL, http_proxy, timeout) except NoNetwork: return {} except urllib.error.HTTPError as x: print("Warning:", x, file=sys.stderr) return {} if not page: return {} versions = {} # iter over the entries, one paragraph at a time for para in Deb822.iter_paragraphs(page): if para['Source'] == package: k = para['Distribution'] + ' (' + para['Queue'] + ')' # in case of multiple versions, choose the bigger versions[k] = max(para['Version'].split()) return versions
def handle(self, *args, **options): if len(args) != 3: raise CommandError( "Requires a language, a tag and an output filename") lang = args[0] tag = args[1] filename = args[2] f = open(filename, "w") session = db.get_db_session() session.bind.echo = False output = False for trans, descr, descr_tag in session.query(ddtp.Translation, ddtp.Description, ddtp.DescriptionTag). \ filter(ddtp.Translation.description_id == ddtp.Description.description_id). \ filter(ddtp.Description.description_id == ddtp.DescriptionTag.description_id). \ filter(ddtp.Translation.language == lang). \ filter(ddtp.DescriptionTag.date_end >= date.today()-timedelta(days=7)). \ filter(ddtp.DescriptionTag.tag == tag). \ order_by(ddtp.Description.package). \ yield_per(100): trans_para = Deb822() trans_para['Package'] = descr.package trans_para['Description-md5'] = descr.description_md5 trans_para['Description-%s' % lang] = trans.translation # Minor nagic here: the translation has an extra newline here, # which we use to seperate the paragraphs f.write(trans_para.dump().encode('utf-8')) output = True if not output: self.stderr.write("WARNING: No output for tag %r, language %r\n" % (tag, lang))
def check_4_4_1(): # Check that there is only one Vcs field. vcs_fields = [] with open('debian/control') as f: source = next(Deb822.iter_paragraphs(f)) for name in source: if name.lower() == 'vcs-browser': continue if name.lower().startswith('vcs-'): vcs_fields.append(name) if len(vcs_fields) > 1: raise UpgradeCheckFailure( "5.6.26", "package has more than one Vcs-<type> field") # Check that Files entries don't refer to directories. # They must be wildcards *in* the directories. try: with open('debian/copyright', 'r') as f: copyright = Copyright(f, strict=False) for para in copyright.all_files_paragraphs(): for glob in para.files: if os.path.isdir(glob): raise UpgradeCheckFailure( "copyright-format", "Wildcards are required to match the contents of " "directories") except FileNotFoundError: pass except NotMachineReadableError: pass
def getBinFromDb(db, pckid): """ Get a binary package from a database """ pdict = db.getbinary(pckid) pdict['cdict'] = Deb822(pdict['control']) return BinPackageDb(**pdict)
def removesrc(self, path, components=None): # pylint: disable=undefined-variable for p in Deb822.iter_paragraphs(file(path)): if 'Source' in p: self._removesrc(p['Source'], self.repo_attr.codename, components)
def new_build(): metadata = request.files['metadata'] buildinfo = request.files['buildinfo'] source = None version = None for paragraph in Deb822.iter_paragraphs(buildinfo): for item in paragraph.items(): if item[0] == 'Source': source = item[1] if item[0] == 'Version': version = item[1] buildinfo.seek(0) id = uuid.uuid4() pkg = db.get_or_create(Package, name=source) ver = db.get_or_create(Version, version=version, package=pkg) db.get_or_create(LinkMetadata, version=ver, text=metadata.read(), uuid=id) db.get_or_create(Buildinfo, version=ver, text=buildinfo.read(), uuid=id) db.session.commit() j = { "type": "inclusion", "package": source, "version": source, "linkmetadata": metadata.read(), "buildinfo": buildinfo.read() } try: node = append(j) except: return {"status": "Could not append"}, 400 return {"status": "ok", "node": node.to_json()}, 200 return
def update_control(): """Update the debian control file. """ from debian.deb822 import Deb822, PkgRelation f = open('debian/control', 'r') iter = Deb822.iter_paragraphs(f) source = iter.next() def update_deps(control, field, package, min_version): bdi = PkgRelation.parse_relations(control[field]) update_relation(bdi, package, ">=", "%d.%d.%d~" % min_version) control[field] = PkgRelation.str(bdi) talloc_version = find_version(os.path.join(tree, "lib/talloc/wscript")) eq_config = LibraryEquivalents('debian/library-equivalents') min_talloc_version = eq_config.find_oldest_compatible("talloc", talloc_version) update_deps(source, "Build-Depends", "libtalloc-dev", min_talloc_version) update_deps(source, "Build-Depends", "python-talloc-dev", min_talloc_version) o = open("debian/control", "w+") source.dump(o) for binary in iter: o.write("\n") binary.dump(o) o.close()
def test_control_field_parsing(self): """Test the parsing of control file fields.""" deb822_package = Deb822([ 'Package: python-py2deb', 'Depends: python-deb-pkg-tools, python-pip, python-pip-accel', 'Installed-Size: 42' ]) parsed_info = parse_control_fields(deb822_package) assert parsed_info == { 'Package': 'python-py2deb', 'Depends': RelationshipSet(Relationship(name=u'python-deb-pkg-tools'), Relationship(name=u'python-pip'), Relationship(name=u'python-pip-accel')), 'Installed-Size': 42 } # Test backwards compatibility with the old interface where `Depends' # like fields were represented as a list of strings (shallow parsed). parsed_info['Depends'] = [text_type(r) for r in parsed_info['Depends']] assert unparse_control_fields(parsed_info) == deb822_package # Test compatibility with fields like `Depends' containing a string. parsed_info['Depends'] = deb822_package['Depends'] assert unparse_control_fields(parsed_info) == deb822_package
def parse_info(self, docfile): '''This function reads a doc-base registry file. We use the sectionedfile object to get the individual sections from the file, and rfc822 object to parse them.''' with open(docfile, 'rb') as fp: part_iter = Deb822.iter_paragraphs(fp) header = next(part_iter) self.title = header["Title"] if "Author" in header: self.author = header["Author"] if "Abstract" in header: self.abstract = self._parse_abstract(header["Abstract"]) if "Section" in header: self.section = header["Section"] for part in part_iter: if "Format" not in part: continue format = part["Format"].lower() if "Index" in part: self.docs[format] = part["Index"] else: self.docs[format] = part["Files"]
def _remove(self, path, codename, component): os.environ['GNUPGHOME'] = "/var/cache/elbe/gnupg" for p in Deb822.iter_paragraphs(file(path)): if 'Source' in p: self._removesrc(p['Source'], codename, component) elif 'Package' in p: self._removedeb(p['Package'], codename, component)
def test_repository_creation(self, preserve=False): """Test the creation of trivial repositories.""" if SKIP_SLOW_TESTS: return self.skipTest("skipping slow tests") with Context() as finalizers: config_dir = tempfile.mkdtemp() repo_dir = tempfile.mkdtemp() if not preserve: finalizers.register(shutil.rmtree, config_dir) finalizers.register(shutil.rmtree, repo_dir) from deb_pkg_tools import config config.user_config_directory = config_dir with open(os.path.join(config_dir, config.repo_config_file), 'w') as handle: handle.write('[test]\n') handle.write('directory = %s\n' % repo_dir) handle.write('release-origin = %s\n' % TEST_REPO_ORIGIN) self.test_package_building(repo_dir) update_repository( repo_dir, release_fields=dict(description=TEST_REPO_DESCRIPTION), cache=self.package_cache) assert os.path.isfile(os.path.join(repo_dir, 'Packages')) assert os.path.isfile(os.path.join(repo_dir, 'Packages.gz')) assert os.path.isfile(os.path.join(repo_dir, 'Release')) with open(os.path.join(repo_dir, 'Release')) as handle: fields = Deb822(handle) assert fields['Origin'] == TEST_REPO_ORIGIN assert fields['Description'] == TEST_REPO_DESCRIPTION if not apt_supports_trusted_option(): assert os.path.isfile(os.path.join(repo_dir, 'Release.gpg')) return repo_dir
def read(self): if not self.manage_repos: log.debug("Skipping read due to manage_repos setting: %s" % self.path) return with open(self.path, "r") as f: for repo822 in Deb822.iter_paragraphs(f, shared_storage=False): self.repos822.append(repo822)
def debcontrol(self): """ Return the debian/control as a Deb822 (a Debian-specific dict-like class) object. For a string representation of debian/control try .get_content('control') """ return Deb822(self.get_content(CONTROL_FILE))
def deb822_from_string(string): """ Create a :class:`debian.deb822.Deb822` object from a string. :param string: The string containing the control fields to parse. :returns: A :class:`debian.deb822.Deb822` object. """ return Deb822(StringIO(textwrap.dedent(string).strip()))
def test_upgrade(self, mock_package_install_hooks): with self.run_in_subprocess("click_get_frameworks_dir") as (enter, preloads): enter() os.environ["TEST_QUIET"] = "1" path = self.make_fake_package( control_fields={ "Package": "test-package", "Version": "1.1", "Architecture": "all", "Maintainer": "Foo Bar <*****@*****.**>", "Description": "test", "Click-Version": "0.2", }, manifest={ "name": "test-package", "version": "1.1", "framework": "ubuntu-sdk-13.10", }, control_scripts={"preinst": static_preinst}, data_files={"foo": None}) root = os.path.join(self.temp_dir, "root") package_dir = os.path.join(root, "test-package") inst_dir = os.path.join(package_dir, "current") os.makedirs(os.path.join(package_dir, "1.0")) os.symlink("1.0", inst_dir) db = Click.DB() db.add(root) installer = ClickInstaller(db) self._setup_frameworks(preloads, frameworks=["ubuntu-sdk-13.10"]) with mock_quiet_subprocess_call(): installer.install(path) self.assertCountEqual([".click", "test-package"], os.listdir(root)) self.assertCountEqual(["1.1", "current"], os.listdir(package_dir)) self.assertTrue(os.path.islink(inst_dir)) self.assertEqual("1.1", os.readlink(inst_dir)) self.assertCountEqual([".click", "foo"], os.listdir(inst_dir)) status_path = os.path.join(inst_dir, ".click", "status") with open(status_path) as status_file: # .readlines() avoids the need for a python-apt backport to # Ubuntu 12.04 LTS. status = list(Deb822.iter_paragraphs(status_file.readlines())) self.assertEqual(1, len(status)) self.assertEqual( { "Package": "test-package", "Status": "install ok installed", "Version": "1.1", "Architecture": "all", "Maintainer": "Foo Bar <*****@*****.**>", "Description": "test", "Click-Version": "0.2", }, status[0]) mock_package_install_hooks.assert_called_once_with(db, "test-package", "1.0", "1.1", user_name=None)
def _read_module_attributes_from_source_package(module): # type: (BaseModule) -> umc.UMC_Module umc_module_definition_file = os.path.join(module['abs_path_to_src_pkg'], 'debian', '{}{}'.format(module['module_name'], UMC_MODULES)) with open(umc_module_definition_file, 'r') as fd: def_file = fd.read() attributes = Deb822(def_file) attributes = dict((k, [v]) for k, v in attributes.items()) # simulate dh_ucs.parseRfc822 behaviour return attributes
def load_control_file(control_file): """ Load a control file and return the parsed control fields. :param control_file: The filename of the control file to load (a string). :returns: A dictionary created by :func:`parse_control_fields()`. """ with open(control_file) as handle: return parse_control_fields(Deb822(handle))
def _remove(self, path, codename, component): for p in Deb822.iter_paragraphs(file(path)): if 'Source' in p: self._removesrc(p['Source'], codename) elif 'Package' in p: self._removedeb(p['Package'], codename) elif 'Binary' in p: for pp in p['Binary'].split(): self._removedeb(pp, codename)
def get_changes_file(changes_file_url): if changes_file_url is not None: changes_text = urllib.request.urlopen(changes_file_url).read() changes_dict = Deb822(changes_text) else: return if 'Launchpad-Bugs-Fixed' in changes_dict.keys(): bugnum = changes_dict['Launchpad-Bugs-Fixed'] return bugnum.split(' ') # This can be a string which has many entries
def _remove(self, path, codename, components=None): # pylint: disable=undefined-variable for p in Deb822.iter_paragraphs(file(path)): if 'Source' in p: self._removesrc(p['Source'], codename, components) elif 'Package' in p: self._removedeb(p['Package'], codename, components) elif 'Binary' in p: for pp in p['Binary'].split(): self._removedeb(pp, codename, components)
def update_control(): """Update the debian control file. """ from debian.deb822 import Deb822, PkgRelation f = open('debian/control', 'rb') iter = Deb822.iter_paragraphs(f.readlines()) for i in iter: source = i break def update_deps(control, field, package, min_version, epoch=None): bdi = PkgRelation.parse_relations(control[field]) if epoch is not None: epoch = "%d:" % epoch else: epoch = "" update_relation(bdi, package, ">=", epoch + "%d.%d.%d~" % min_version) control[field] = PkgRelation.str(bdi) tdb_version = find_version(os.path.join(tree, "lib/tdb/wscript")) talloc_version = find_version(os.path.join(tree, "lib/talloc/wscript")) ldb_version = find_version(os.path.join(tree, "lib/ldb/wscript")) tevent_version = find_version(os.path.join(tree, "lib/tevent/wscript")) eq_config = LibraryEquivalents('debian/library-equivalents') min_tdb_version = eq_config.find_oldest_compatible("tdb", tdb_version) min_talloc_version = eq_config.find_oldest_compatible("talloc", talloc_version) min_ldb_version = eq_config.find_oldest_compatible("ldb", ldb_version) min_tevent_version = eq_config.find_oldest_compatible("tevent", tevent_version) update_deps(source, "Build-Depends", "libtdb-dev", min_tdb_version) update_deps(source, "Build-Depends", "python-tdb", min_tdb_version) update_deps(source, "Build-Depends", "libtalloc-dev", min_talloc_version) update_deps(source, "Build-Depends", "python-talloc-dev", min_talloc_version) update_deps(source, "Build-Depends", "libldb-dev", min_ldb_version, 1) update_deps(source, "Build-Depends", "python-ldb-dev", min_ldb_version, 1) update_deps(source, "Build-Depends", "python-ldb", min_ldb_version, 1) update_deps(source, "Build-Depends", "libtevent-dev", min_tevent_version) with open("debian/control", "wb+") as o: for i in source.keys(): if i == "Build-Depends": value=",\n ".join(source[i].split(', ')) else: value=source[i] o.write(("%s: %s\n" % (i, value)).encode('UTF-8')) for binary in iter: o.write(b"\n") binary.dump(o)
def update_control(): """Update the debian control file. """ from debian.deb822 import Deb822, PkgRelation f = open('debian/control', 'r') iter = Deb822.iter_paragraphs(f) source = iter.next() def update_deps(control, field, package, min_version, epoch=None): bdi = PkgRelation.parse_relations(control[field]) if epoch is not None: epoch = "%d:" % epoch else: epoch = "" update_relation(bdi, package, ">=", epoch + "%d.%d.%d~" % min_version) control[field] = PkgRelation.str(bdi) tdb_version = find_version(os.path.join(tree, "lib/tdb/wscript")) talloc_version = find_version(os.path.join(tree, "lib/talloc/wscript")) ldb_version = find_version(os.path.join(tree, "lib/ldb/wscript")) tevent_version = find_version(os.path.join(tree, "lib/tevent/wscript")) eq_config = LibraryEquivalents('debian/library-equivalents') min_tdb_version = eq_config.find_oldest_compatible("tdb", tdb_version) min_talloc_version = eq_config.find_oldest_compatible("talloc", talloc_version) min_ldb_version = eq_config.find_oldest_compatible("ldb", ldb_version) min_tevent_version = eq_config.find_oldest_compatible("tevent", tevent_version) update_deps(source, "Build-Depends", "libtdb-dev", min_tdb_version) update_deps(source, "Build-Depends", "python-tdb", min_tdb_version) update_deps(source, "Build-Depends", "libtalloc-dev", min_talloc_version) update_deps(source, "Build-Depends", "python-talloc-dev", min_talloc_version) update_deps(source, "Build-Depends", "libldb-dev", min_ldb_version, 1) update_deps(source, "Build-Depends", "python-ldb-dev", min_ldb_version, 1) update_deps(source, "Build-Depends", "python-ldb", min_ldb_version, 1) update_deps(source, "Build-Depends", "libtevent-dev", min_tevent_version) o = open("debian/control", "w+") try: source.dump(o) for binary in iter: o.write("\n") binary.dump(o) finally: o.close()
def _remove(self, path, codename, component): for p in Deb822.iter_paragraphs(file(path)): if 'Source' in p: self._removesrc(p['Source'], codename) elif 'Package' in p: self._removedeb(p['Package'], codename)
def read(self): with open(self.path, 'r') as f: for repo822 in Deb822.iter_paragraphs(f, shared_storage=False): self.repos822.append(repo822)
if dists is None: dists = ('unstable (new queue)', ) try: page = open_url(NEWQUEUE_URL, http_proxy, timeout) except NoNetwork: return {} except urllib2.HTTPError, x: print >> sys.stderr, "Warning:", x return {} if not page: return {} versions = {} # iter over the entries, one paragraph at a time for para in Deb822.iter_paragraphs(page): if para['Source'] == package: k = para['Distribution'] + ' (' + para['Queue'] + ')' versions[k] = para['Version'] return versions def get_incoming_version(package, timeout, http_proxy=None, arch='i386'): try: page = open_url(INCOMING_URL, http_proxy, timeout) except NoNetwork: return None except urllib2.HTTPError, x: print >> sys.stderr, "Warning:", x return None if not page:
def removesrc(self, path, component="main"): for p in Deb822.iter_paragraphs(file(path)): if 'Source' in p: self._removesrc(p['Source'], self.repo_attr.codename)