def list_versions(self, projectname=None):
if projectname is None:
projectname = self.projectname
try:
return self.stage.list_versions(projectname)
except UpstreamError as e:
abort(self.request, 502, str(e))
def getstage(self, user, index):
stage = self.model.getstage(user, index)
if not stage:
abort(self.request, 404,
"The stage %s/%s could not be found." % (user, index))
stage.__acl__ = StageACL(stage, self.restrict_modify).__acl__
return stage
def verified_project(self):
name = self.project
try:
if not self.stage.has_project(name):
abort(self.request, 404, "The project %s does not exist." %(name))
except UpstreamError as e:
abort(self.request, 502, str(e))
return name
def list_versions(self, project=None):
if project is None:
project = self.project
try:
res = self.stage.list_versions(project)
except UpstreamError as e:
abort(self.request, 502, str(e))
if not res and not self.stage.has_project(project):
abort(self.request, 404, "no project %r" % (project))
return res
def json_info_view(context, request):
baseurl = URL(request.application_url).asdir()
version = context.stage.get_latest_version(context.project, stable=True)
info = get_mutable_deepcopy(
context.stage.get_versiondata(context.project, version))
if not info:
abort(request, 404, 'no info found')
info.pop("+elinks", None)
result = dict(info=info, releases={})
for release in context.stage.get_releaselinks(context.project):
result["releases"].setdefault(release.version, []).append(
dict(url=baseurl.joinpath(release.relpath).url))
return result
def filtered_list_all(self):
stage = self.context.stage
try:
stage_results = list(stage.op_sro("list_projects_perstage"))
except stage.UpstreamError as e:
threadlog.error(e.msg)
abort(self.request, 502, e.msg)
releasefilter = set(get_release_filter(stage))
results = []
for stage, names in stage_results:
filtered_names = releasefilter.intersection(names)
results.append((stage, filtered_names))
# at this point we are sure we can produce the data without
# depending on remote networks
return Response(body=b"".join(self._simple_list_all(stage, results)))
def callback(self, username, request):
# Username arg is ignored. Unfortunately _get_credentials winds up
# getting called twice when authenticated_userid is called. Avoiding
# that, however, winds up duplicating logic from the superclass.
credentials = self._get_credentials(request)
if credentials:
status, auth_user = self.auth.get_auth_status(credentials)
request.log.debug("got auth status %r for user %r" % (status, auth_user))
if status == "ok":
return []
elif status == "nouser":
abort(request, 404, "user %r does not exist" % auth_user)
elif status == "expired":
abort_authenticate(request, msg="auth expired for %r" % auth_user)
raise ValueError("Unknown authentication status: %s" % status)
def callback(self, username, request):
# Username arg is ignored. Unfortunately _get_credentials winds up
# getting called twice when authenticated_userid is called. Avoiding
# that, however, winds up duplicating logic from the superclass.
credentials = self._get_credentials(request)
if credentials:
status, auth_user = self.auth.get_auth_status(credentials)
request.log.debug("got auth status %r for user %r" %
(status, auth_user))
if status == "ok":
return []
elif status == "nouser":
abort(request, 404, "user %r does not exist" % auth_user)
elif status == "expired":
abort_authenticate(request,
msg="auth expired for %r" % auth_user)
raise ValueError("Unknown authentication status: %s" % status)
def filtered_list_project(self):
request = self.request
abort_if_invalid_project(request, request.matchdict["project"])
project = self.context.project
# we only serve absolute links so we don't care about the route's slash
stage = self.context.stage
releasefilter = get_release_filter(stage).get(project)
if releasefilter is None:
abort(self.request, 404, "The project %s does not exist." %(project))
try:
links = stage.get_simplelinks(project, sorted_links=False)
except stage.UpstreamError as e:
threadlog.error(e.msg)
abort(request, 502, e.msg)
result = []
for key, url in links:
parts = splitext_archive(key)[0].split('-')
for index in range(1, len(parts)):
name = normalize_name('-'.join(parts[:index]))
if name == project:
version = '-'.join(parts[index:])
break
else:
continue
if version in releasefilter:
result.append((key, url))
if not result:
self.request.context.verified_project # access will trigger 404 if not found
# we don't need the extra stuff on the simple page for pip
embed_form = False
blocked_index = None
response = Response(body=b"".join(self._simple_list_project(
stage, project, result, embed_form, blocked_index)))
if stage.ixconfig['type'] == 'mirror':
serial = stage.key_projsimplelinks(project).get().get("serial")
if serial > 0:
response.headers[str("X-PYPI-LAST-SERIAL")] = str(serial)
return response
def get_versiondata(self, projectname=None, version=None, perstage=False):
if projectname is None:
projectname = self.projectname # raises 404 if not found
if version is None:
version = self.version
if perstage:
get = self.stage.get_versiondata_perstage
msg = " on stage %r" % (self.index,)
else:
get = self.stage.get_versiondata
msg = ""
try:
verdata = get(projectname, version)
except UpstreamError as e:
abort(self.request, 502, str(e))
if not verdata:
abort(
self.request, 404, "The version %s of project %s does not exist%s." % (self.version, projectname, msg)
)
return verdata
def projectname(self):
name = self.stage.get_projectname(self.name)
if name is None:
raise abort(self.request, 404, "The project %s does not exist." % self.name)
if self.request.method == "GET" and name != self.name:
new_matchdict = dict(self.request.matchdict)
new_matchdict["name"] = name
route_name = self.request.matched_route.name
url = self.request.route_url(route_name, **new_matchdict)
redirect(url)
return name
def get_versiondata(self, project=None, version=None, perstage=False):
if project is None:
project = self.project
if version is None:
version = self.version
if perstage:
get = self.stage.get_versiondata_perstage
msg = " on stage %r" %(self.index,)
else:
get = self.stage.get_versiondata
msg = ""
try:
verdata = get(project, version)
except UpstreamError as e:
abort(self.request, 502, str(e))
if not verdata:
abort(self.request, 404,
"The version %s of project %s does not exist%s." %
(self.version, project, msg))
return verdata
def getstage(self, user, index):
stage = self.model.getstage(user, index)
if not stage:
abort(self.request, 404, "The stage %s/%s could not be found." % (user, index))
stage.__acl__ = StageACL(stage, self.restrict_modify).__acl__
return stage
def user(self):
user = self.model.get_user(self.username)
if not user:
abort(self.request, 404, "no user %r" % self.username)
return user
def getstage(self, user, index):
stage = self.model.getstage(user, index)
if not stage:
abort(self.request, 404,
"The stage %s/%s could not be found." % (user, index))
return stage
def user(self):
user = self.model.get_user(self.username)
if not user:
abort(self.request, 404, "no user %r" % self.username)
return user
def getstage(self, user, index):
stage = self.model.getstage(user, index)
if not stage:
abort(self.request, 404, "no stage %s/%s" % (user, index))
return stage
def getstage(self, user, index):
stage = self.model.getstage(user, index)
if not stage:
abort(self.request, 404, "no stage %s/%s" % (user, index))
return stage
