def test_mark_uploaded_unkown_dist(self): self.make_unuploaded() cl = Changelog() v = Version("0.1-1") cl.new_block( package='package', version=Version('0.1-1'), distributions='UNRELEASED', urgency='low', author='James Westby <*****@*****.**>', date='Thu, 3 Aug 2006 19:16:22 +0100', ) cl.add_change('') cl.add_change(' * Initial packaging.') cl.add_change('') f = open('debian/changelog', 'wb') try: cl.write_to_open_file(f) finally: f.close() self.wt.commit("two") self.run_bzr_error([ "The changelog still targets 'UNRELEASED', so " "apparently hasn't been uploaded." ], "mark-uploaded")
def test_find_previous_upload_ubuntu(self): cl = self.make_changelog([("0.1-1", "lucid"), ("0.1-2", "lucid")]) self.assertEqual(Version("0.1-1"), changelog_find_previous_upload(cl)) cl = self.make_changelog([("0.1-1", "lucid"), ("0.1-1.1", "unstable"), ("0.1-2", "maverick")]) self.requireFeature(DistroInfoFeature) self.assertEqual(Version("0.1-1"), changelog_find_previous_upload(cl))
def test_find_previous_upload_debian(self): cl = self.make_changelog([("0.1-1", "unstable"), ("0.1-2", "unstable")]) self.assertEqual(Version("0.1-1"), _find_previous_upload(cl)) cl = self.make_changelog([("0.1-1", "unstable"), ("0.1-1.1", "stable-security"), ("0.1-2", "unstable")]) self.assertEqual(Version("0.1-1"), _find_previous_upload(cl))
def drop_obsolete_maintscript_entries( editor, should_remove: Callable[[str, Version], bool] ) -> List[Tuple[int, str, Version]]: """Drop obsolete entries from a maintscript file. Args: editor: editor to use to access the maintscript should_remove: callable to check whether a package/version tuple is obsolete Returns: list of tuples with index, package, version of entries that were removed """ remove: List[Tuple[int, str, Version]] = [] comments = [] entries_removed = [] for i, entry in enumerate(list(editor.lines)): if isinstance(entry, str): comments.append((i, None, None)) continue prior_version = getattr(entry, "prior_version", None) if prior_version is not None: if should_remove(entry.package, Version(prior_version)): remove.extend(comments) remove.append((i, entry.package, Version(prior_version))) entries_removed.append(i) comments = [] removed = [] for i, pkg, version in reversed(remove): removed.append(editor.lines[i]) del editor.lines[i] return entries_removed
def test__upstream_version_data(self): ubup_o, debp_n, _ubuu, _debu = self._setup_debian_upstream_newer() vdata = MP._upstream_version_data(debp_n.branch, debp_n.last_revision()) self.assertEquals(vdata[0], Version('1.10')) vdata = MP._upstream_version_data(ubup_o.branch, ubup_o.last_revision()) self.assertEquals(vdata[0], Version('1.2'))
def test_tarball_name(self): self.assertEqual(tarball_name("package", "0.1", None), "package_0.1.orig.tar.gz") self.assertEqual(tarball_name("package", Version("0.1"), None), "package_0.1.orig.tar.gz") self.assertEqual(tarball_name("package", Version("0.1"), None, format='bz2'), "package_0.1.orig.tar.bz2") self.assertEqual(tarball_name("package", Version("0.1"), None, format='xz'), "package_0.1.orig.tar.xz") self.assertEqual(tarball_name("package", Version("0.1"), "la", format='xz'), "package_0.1.orig-la.tar.xz")
def fetch_tarballs(self, package, version, target_dir, components=None): v = Version(version) v.epoch = None prefix = '%s_%s.orig' % (package, v) ret = [] for entry in os.scandir(self.path): if entry.name.startswith(prefix): component = (entry.name[len(prefix):].split('.')[0] or None) shutil.copy(entry.path, target_dir) if components is None or component in components: ret.append(os.path.join(target_dir, entry.name)) if ret: return ret raise PackageVersionNotPresent(package, version, self)
def test_import_upstream_with_branch_prior_tarball(self): self.make_upstream_tarball() upstreamtree = self.make_upstream_tree() tree = self.make_workingdir() # XXX: refactor: make this an API call - running blackbox in test prep # is ugly. self.run_bzr([ 'import-upstream', self.upstream_version, "../%s" % self.upstream_tarball_name, '../upstream' ], working_dir='working') new_version = Version('0.2-1') self.make_upstream_tarball(new_version.upstream_version) upstream_parent = self.make_upstream_change(upstreamtree) self.run_bzr([ 'import-upstream', new_version.upstream_version, "../%s" % self._upstream_tarball_name( self.package_name, new_version.upstream_version), '../upstream' ], working_dir='working') tree.lock_read() self.addCleanup(tree.unlock) self.assertFalse(tree.has_changes()) revtree = self.assertHasImportArtifacts(tree, new_version.upstream_version) self.assertUpstreamContentAndFileIdFromTree(revtree, upstreamtree) # Check parents: we want # [previous_import, upstream_parent] to reflect that the 'branch' is # the tarball branch aka upstream branch [ugh], and then a merge in # from upstream so that cherrypicks do the right thing. tags = tree.branch.tags self.assertEqual([ tags.lookup_tag(self.upstream_tag(self.upstream_version)), upstreamtree.branch.last_revision() ], revtree.get_parent_ids())
def changelog(dpath, ctx, env): change = ctx.get('message', 'Autogenerated by py2dsp v{}'.format(VERSION)) version = ctx['debian_version'] distribution = ctx.get('distribution', 'UNRELEASED') fpath = join(dpath, 'debian', 'changelog') if exists(fpath): with open(fpath, encoding='utf-8') as fp: line = fp.readline() if ctx['version'] in line or 'UNRELEASED' in line: log.debug('changelog doesn\'t need an update') return else: yield from execute([ 'dch', '--force-distribution', '--distribution', distribution, '--newversion', version, '-m', change ], cwd=dpath) return now = datetime.utcnow() changelog = Changelog() changelog.new_block(package=ctx['src_name'], version=Version(version), distributions=distribution, urgency='low', author=ctx['creator'], date=now.strftime('%a, %d %b %Y %H:%M:%S +0000')) changelog.add_change('') changelog.add_change(' * {}'.format(change)) changelog.add_change('') with open(fpath, 'w', encoding='utf-8') as fp: changelog.write_to_open_file(fp) return True
def get_recent_versions(self, package: str, since_version: Optional[Version] = None): versions = [] tags = self.upstream_branch.tags.get_tag_dict() with self.upstream_branch.repository.lock_read(): graph = self.upstream_branch.repository.get_graph() if since_version is not None: try: since_revision = self.version_as_revision( package, since_version) except PackageVersionNotPresent: raise PreviousVersionTagMissing(package, since_version) else: since_revision = None for tag, revision in tags.items(): version = upstream_tag_to_version(tag, package) if version is None: continue mangled_version = debianize_upstream_version(version, package) self.upstream_revision_map[mangled_version] = 'tag:%s' % tag if since_version is not None and mangled_version <= since_version: continue if since_revision and not graph.is_ancestor( since_revision, revision): continue versions.append((version, mangled_version)) return sorted(versions, key=lambda v: Version(v[1]))
def test_dget_missing_target(self): builder = SourcePackageBuilder("package", Version("0.1-1")) builder.add_upstream_file("foo") builder.add_default_control() builder.build() self.assertRaises(bzr_errors.NotADirectory, dget, self.get_url(builder.dsc_name()), 'target')
def get_newest_option(opts): latest_version = None latest_option = None for version, option in opts.items(): # If option is not complete, skip if 'kernel' not in option or 'initrd' not in option: continue # If this option is newer, store this option and continue if latest_version is None or Version(version) > Version( latest_version): latest_version = version latest_option = option return latest_option, latest_version
def package_version(upstream_version, distribution_name, epoch=None): """Determine the package version for a new upstream. :param upstream_version: Upstream version string :param distribution_name: Distribution the package is for :param epoch: Optional epoch """ assert isinstance(upstream_version, str), \ "upstream_version should be a str, not %s" % str( type(upstream_version)) if distribution_name == "ubuntu": ret = Version("%s-0ubuntu1" % upstream_version) else: ret = Version("%s-1" % upstream_version) ret.epoch = epoch return ret
def test_dget_missing_dsc(self): builder = SourcePackageBuilder("package", Version("0.1-1")) builder.add_upstream_file("foo") builder.add_default_control() # No builder.build() self.build_tree(["target/"]) self.assertRaises(bzr_errors.NoSuchFile, dget, self.get_url(builder.dsc_name()), 'target')
def conflict_obsolete(latest_version: Version, kind: str, req_version: Version): req_version = Version(req_version) if kind == "<<": return latest_version >= req_version elif kind in ("<=", "="): return latest_version > req_version return False
def increment_version(v: Version) -> None: """Increment a version number. For native packages, increment the main version number. For other packages, increment the debian revision. Args: v: Version to increment (modified in place) """ if v.debian_revision is not None: v.debian_revision = re.sub( "\\d+$", lambda x: str(int(x.group()) + 1), v.debian_revision ) else: v.upstream_version = re.sub( "\\d+$", lambda x: str(int(x.group()) + 1), v.upstream_version )
def test_default(self): # Upstream source code and a non-native package -> NORMAL tree = self.make_branch_and_tree('.') self.assertEquals( BUILD_TYPE_NORMAL, guess_build_type(tree, Version("1.0-1"), contains_upstream_source=True))
def test_empty(self): # Empty tree and a non-native package -> NORMAL tree = self.make_branch_and_tree('.') self.assertEquals( BUILD_TYPE_NORMAL, guess_build_type(tree, Version("1.0-1"), contains_upstream_source=None))
def test_prev_version_native(self): # Native package version -> NATIVE tree = self.make_branch_and_tree('.') self.assertEquals( BUILD_TYPE_NATIVE, guess_build_type(tree, Version("1.0"), contains_upstream_source=True))
def depends_obsolete(latest_version: Version, kind: str, req_version: Version): req_version = Version(req_version) if kind == ">=": return latest_version >= req_version elif kind == ">>": return latest_version > req_version elif kind == "=": return False return False
def test_no_upstream_source(self): # No upstream source code and a non-native package -> MERGE tree = self.make_branch_and_tree('.') tree.mkdir("debian") self.assertEquals( BUILD_TYPE_MERGE, guess_build_type(tree, Version("1.0-1"), contains_upstream_source=False))
def test_dget_transport(self): builder = SourcePackageBuilder("package", Version("0.1-1")) builder.add_upstream_file("foo") builder.add_default_control() builder.build() self.build_tree(["target/"]) dget(self.get_url(builder.dsc_name()), 'target') self.assertPathExists(os.path.join("target", builder.dsc_name())) self.assertPathExists(os.path.join("target", builder.tar_name())) self.assertPathExists(os.path.join("target", builder.diff_name()))
def make_unuploaded(self): self.wt = self.make_branch_and_tree('.') self.build_tree(['debian/']) cl = Changelog() v = Version("0.1-1") cl.new_block(package='package', version=Version('0.1-1'), distributions='unstable', urgency='low', author='James Westby <*****@*****.**>', date='Thu, 3 Aug 2006 19:16:22 +0100', ) cl.add_change(''); cl.add_change(' * Initial packaging.'); cl.add_change(''); with open('debian/changelog', 'w') as f: cl.write_to_open_file(f) self.wt.add(["debian/", "debian/changelog"]) self.wt.commit("one")
def get_recent_versions(self, package, since_version=None): versions = {} for source in self._sources: for unmangled, mangled in source.get_recent_versions( package, since_version): versions[mangled] = unmangled return [ (u, m) for (m, u) in sorted(versions.items(), key=lambda v: Version(v[0])) ]
def tree_set_changelog_version(tree: WorkingTree, build_version: Version, subpath: str) -> None: cl_path = osutils.pathjoin(subpath, "debian/changelog") with tree.get_file(cl_path) as f: cl = Changelog(f) if Version(str(cl.version) + "~") > build_version: return cl.version = build_version with open(tree.abspath(cl_path), "w") as f: cl.write_to_open_file(f)
def test_inconsistent(self): # If version string and source format disagree on whether the package is native, # raise an exception. tree = self.make_branch_and_tree('.') self.writeVersionFile(tree, "3.0 (native)") e = self.assertRaises(InconsistentSourceFormatError, guess_build_type, tree, Version("1.0-1"), True) self.assertEquals( "Inconsistency between source format and version: version is not native, " "format is native.", str(e))
def extract(self): tempdir = self.exit_stack.enter_context(tempfile.TemporaryDirectory()) dsc_filename = os.path.abspath(self.dsc_path) proc = subprocess.Popen("dpkg-source --skip-debianization -x %s" % (dsc_filename, ), shell=True, cwd=tempdir, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, preexec_fn=subprocess_setup) (stdout, _) = proc.communicate() assert proc.returncode == 0, "dpkg-source -x failed, output:\n%s" % \ (stdout,) name = self.dsc['Source'] version = Version(self.dsc['Version']) self.extracted_debianised = os.path.join( tempdir, "%s-%s" % (name, str(version.upstream_version))) self.extracted_upstream = self.extracted_debianised + ".orig" os.rename(self.extracted_debianised, self.extracted_upstream) proc = subprocess.Popen("dpkg-source -x %s" % (dsc_filename, ), shell=True, cwd=tempdir, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, preexec_fn=subprocess_setup) (stdout, _) = proc.communicate() assert proc.returncode == 0, "dpkg-source -x failed, output:\n%s" % \ (stdout,) # Check that there are no unreadable files extracted. subprocess.call([ "find", self.extracted_upstream, "-perm", "0000", "-exec", "chmod", "644", "{}", ";" ]) subprocess.call([ "find", self.extracted_debianised, "-perm", "0000", "-exec", "chmod", "644", "{}", ";" ]) for part in self.dsc['files']: if part['name'].startswith("%s_%s.orig" % (name, str(version.upstream_version))): self.upstream_tarballs.append( (os.path.abspath( os.path.join(osutils.dirname(self.dsc_path), part['name'])), component_from_orig_tarball( part['name'], name, str(version.upstream_version)), str(part['md5sum']))) elif (part['name'].endswith(".debian.tar.gz") or part['name'].endswith(".debian.tar.bz2") or part['name'].endswith(".debian.tar.xz")): self.unextracted_debian_md5 = str(part['md5sum']) assert self.upstream_tarballs is not None, \ "Can't handle non gz|bz2|xz tarballs yet" assert self.unextracted_debian_md5 is not None, \ "Can't handle non gz|bz2|xz tarballs yet"
def test_add_new(self): tree = self.make_branch_and_tree(".") tree.lock_write() self.addCleanup(tree.unlock) tree.mkdir("debian") changelog_add_new_version(tree, "1.0", "sid", None, "somepkg") # changelog_add_new_version will version the changelog if it was created cl = Changelog(open('debian/changelog')) self.assertEquals(cl._blocks[0].package, "somepkg") self.assertEquals(cl._blocks[0].distributions, "UNRELEASED") self.assertEquals(cl._blocks[0].version, Version("1.0-1")) self.assertEquals([], list(tree.filter_unversioned_files(["debian/changelog"])))
def test_distill_tarball_exists(self): wt = self.make_branch_and_tree(".") wt.lock_read() self.addCleanup(wt.unlock) name = "package" version = Version("0.1-1") self.make_tarball(name, version) sd = MergeModeDistiller( wt, '', _SimpleUpstreamProvider(name, version.upstream_version, ".")) sd.distill('target/foo') self.assertPathExists( 'target/%s_%s.orig.tar.gz' % (name, version.upstream_version)) self.assertPathExists('target/foo/a')
async def _package_version(package: str, release: str) -> Optional[Version]: from .udd import connect_udd_mirror try: async with await connect_udd_mirror() as conn: version = await conn.fetchval( "select version from packages where package = $1 and release = $2", package, release) except asyncio.TimeoutError: raise UddTimeout() if version is not None: return Version(version) return None