def do_upgrade(xom): tw = py.io.TerminalWriter() serverdir = xom.config.serverdir exportdir = serverdir + "-export" if exportdir.check(): tw.line("removing exportdir: %s" % exportdir) exportdir.remove() newdir = serverdir + "-import" script = sys.argv[0] def rel(p): return py.path.local().bestrelpath(p) state_version = xom.get_state_version() tw.sep("-", "exporting to %s" % rel(exportdir)) if Version(state_version) > Version(server_version): fatal("%s has state version %s which is newer than what we " "can handle (%s)" % (xom.config.serverdir, state_version, server_version)) elif Version(state_version) < Version(server_version): tw.line("creating server venv %s ..." % state_version) tmpdir = py.path.local.make_numbered_dir("devpi-upgrade") venv = create_server_venv(tw, state_version, tmpdir) tw.line("server venv %s created: %s" % (server_version, tmpdir)) venv.check_call([ "devpi-server", "--serverdir", str(serverdir), "--export", str(exportdir) ]) else: #tw.sep("-", "creating venv" % rel(exportdir)) subprocess.check_call([ sys.executable, script, "--serverdir", str(serverdir), "--export", str(exportdir) ]) tw.sep("-", "importing from %s" % rel(exportdir)) tw.line("importing into server version: %s" % server_version) subprocess.check_call([ sys.executable, script, "--serverdir", str(newdir), "--import", str(exportdir) ]) tw.sep("-", "replacing serverstate") backup_dir = serverdir + "-backup" if backup_dir.check(): tw.line("backup dir exists, not creating backup", bold=True) else: tw.line("moving serverstate to backupdir: %s" % (backup_dir), bold=True) serverdir.move(backup_dir) if serverdir.check(): tw.line("removing serverstate: %s" % (serverdir)) serverdir.remove() tw.line("copying new serverstate to serverdir", bold=True) newdir.move(serverdir) serverdir.join(".serverversion").read() tw.line("cleanup: removing exportdir: %s" % exportdir) tw.line("have fun serving the new state :)") exportdir.remove()
def check_compatible_version(xom): args = xom.config.args if args.upgrade_state or args.export: return state_version = xom.get_state_version() if Version(server_version) != Version(state_version): fatal("Incompatible state: server %s cannot run serverdir " "%s created by %s. " % (server_version, xom.config.serverdir, state_version))
def getnewestversion(self, pkgname): best = None for link in self.links: basename = URL(link.url).basename name, version = splitbasename(basename)[:2] ver = Version(version) if name == pkgname: if best is None or ver > best[0]: best = ver, link return best and best[1] or None
def filter_latest(path_pkginfo): name_version_path = {} for archivepath, pkginfo in path_pkginfo.items(): name = pkginfo.name iversion = Version(pkginfo.version) data = name_version_path.get(name) if data is None or data[0] < iversion: name_version_path[name] = (iversion, pkginfo, archivepath) retval = {} for x in name_version_path.values(): retval[x[2]] = x[1] return retval
def getnewestversion(self, pkgname): """ returns newest applicable version of package """ req = next(pkg_resources.parse_requirements(pkgname)) best = None for link in self.links: basename = URL(link.url).basename name, version = splitbasename(basename)[:2] ver = Version(version) if name in (req.project_name, pkgname) and version in req: if best is None or ver > best[0]: best = ver, link return best and best[1] or None
def check_compatible_version(xom): args = xom.config.args if args.export: return state_version = xom.get_state_version() if server_version != state_version: state_ver = tuple(state_version.split(".")) server_ver = tuple(server_version.split(".")) incompatible = (state_ver[:1] != server_ver[:1] or Version(state_version) < Version("2.2.dev0")) if incompatible: fatal("Incompatible state: server %s cannot run serverdir " "%s created by %s.\n" "Use --export from older version, then --import with newer " "version." % (server_version, xom.config.serverdir, state_version)) xom.set_state_version(server_version) tw = py.io.TerminalWriter(sys.stderr) tw.line("minor version upgrade: setting serverstate to %s from %s" % (server_version, state_version), bold=True)
def test_normalization_merge(self, caplog, impexp): mapp = impexp.import_testdata('normalization_merge') with mapp.xom.keyfs.transaction(write=False): stage = mapp.xom.model.getstage('root/dev') links = sorted(stage.get_releaselinks("hello.pkg"), key=lambda x: Version(x.version)) assert len(links) == 2 assert links[0].project == "hello-pkg" assert links[1].project == "hello-pkg" assert links[0].version == "1.0" assert links[1].version == "1.1" link = stage.get_link_from_entrypath(links[0].entrypath) assert link.entry.file_get_content() == b"content1" link = stage.get_link_from_entrypath(links[1].entrypath) assert link.entry.file_get_content() == b"content2"
def compute_global_projectname_normalization(self): self.tw.line("computing global projectname normalization map") norm2maxversion = {} # compute latest normname version across all stages for user in self.xom.model.get_userlist(): userconfig = user.get() for indexname in userconfig.get("indexes", []): stage = self.xom.model.getstage(user.name, indexname) names = stage.list_projectnames_perstage() for name in names: # pypi names take precedence for defining the realname if stage.name == "root/pypi": version = Version("999999.99999") version.realname = name norm2maxversion[normalize_name(name)] = version continue versions = stage.list_versions_perstage(name) if versions: maxver = None for ver in versions: version = Version(ver) verdata = stage.get_versiondata(name, ver) version.realname = verdata.get("name", name) if maxver is None or version > maxver: maxver = version if not maxver: continue norm = normalize_name(name) normver = norm2maxversion.setdefault(norm, maxver) if maxver > normver: norm2maxversion[norm] = maxver # determine real name of a project self.norm2name = norm2name = {} for norm, maxver in norm2maxversion.items(): norm2name[norm] = maxver.realname
def test_version(): ver1 = Version("1.0") ver2 = Version("1.1") assert max([ver1, ver2]) == ver2
def version_get(context, request): """ Show version for the precise stage, ignores inheritance. """ context = ContextWrapper(context) name = context.verified_project stage = context.stage version = context.version if version == 'latest' and context._versions: version = context._versions[0] elif version == 'stable' and context._stable_versions: version = context._stable_versions[0] try: verdata = context.get_versiondata(version=version, perstage=True) except stage.UpstreamError as e: log.error(e.msg) raise HTTPBadGateway(e.msg) infos = [] skipped_keys = frozenset( ("description", "home_page", "name", "summary", "version")) for key, value in sorted(verdata.items()): if key in skipped_keys or key.startswith('+'): continue if isinstance(value, seq_types): if not len(value): continue value = html.ul([html.li(x) for x in value]).unicode() else: if not value: continue value = py.xml.escape(value) infos.append((py.xml.escape(key), value)) show_toxresults = (stage.ixconfig['type'] != 'mirror') linkstore = stage.get_linkstore_perstage(name, version) files = get_files_info(request, linkstore, show_toxresults) docs = get_docs_info(request, stage, linkstore) home_page = verdata.get("home_page") nav_links = [] if docs: nav_links.append(dict(title="Documentation", url=docs['url'])) if home_page: nav_links.append(dict(title="Homepage", url=home_page)) nav_links.append( dict(title="Simple index", url=request.route_url("/{user}/{index}/+simple/{project}", user=context.username, index=context.index, project=context.project))) if hasattr(stage, 'get_mirror_whitelist_info'): whitelist_info = stage.get_mirror_whitelist_info(name) else: whitelist_info = dict(has_mirror_base=stage.has_mirror_base(name), blocked_by_mirror_whitelist=False) if whitelist_info['has_mirror_base']: for base in reversed(list(stage.sro())): if base.ixconfig["type"] != "mirror": continue mirror_web_url_fmt = base.ixconfig.get("mirror_web_url_fmt") if not mirror_web_url_fmt: continue nav_links.append( dict(title="%s page" % base.ixconfig.get("title", "Mirror"), url=mirror_web_url_fmt.format(name=name))) cmp_version = Version(version) if context._stable_versions: stable_version = Version(context._stable_versions[0]) url = request.route_url("/{user}/{index}/{project}/{version}", user=context.username, index=context.index, project=context.project, version='stable') if cmp_version.is_prerelease(): nav_links.append( dict(title="Stable version available", css_class="warning", url=url)) elif stable_version != cmp_version: nav_links.append( dict(title="Newer version available", css_class="severe", url=url)) return dict(title="%s/: %s-%s metadata and description" % (stage.name, name, version), content=get_description(stage, name, version), summary=verdata.get("summary"), nav_links=nav_links, infos=infos, metadata_list_fields=frozenset( py.xml.escape(x) for x in getattr(stage, 'metadata_list_fields', ())), files=files, blocked_by_mirror_whitelist=whitelist_info[ 'blocked_by_mirror_whitelist'], show_toxresults=show_toxresults, make_toxresults_url=functools.partial(request.route_url, "toxresults", user=context.username, index=context.index, project=context.project, version=context.version), make_toxresult_url=functools.partial(request.route_url, "toxresult", user=context.username, index=context.index, project=context.project, version=context.version))