[people/jschlag/pbs.git] / src / web / handlers_packages.py

#!/usr/bin/python

import mimetypes
import os.path
import tornado.web

from .handlers_base import BaseHandler

from ..constants import BUFFER_SIZE

class PackageIDDetailHandler(BaseHandler):
	def get(self, id):
		package = self.packages.get_by_id(id)
		if not package:
			return tornado.web.HTTPError(404, "Package not found: %s" % id)

		self.render("package-detail.html", package=package)


class PackageListHandler(BaseHandler):
	def get(self):
		packages = {}

		show = self.get_argument("show", None)
		if show == "all":
			states = None
		elif show == "obsoletes":
			states = ["obsolete"]
		elif show == "broken":
			states = ["broken"]
		else:
			states = ["building", "stable", "testing"]

		# Get all packages that fulfill the required parameters.
		pkgs = self.pakfire.packages.get_all_names(
			user=self.current_user, states=states)

		# Sort all packages in an array like "<first char>" --> [packages, ...]
		# to print them in a table for each letter of the alphabet.
		for pkg in pkgs:
			c = pkg[0][0].lower()

			if not packages.has_key(c):
				packages[c] = []

			packages[c].append(pkg)

		self.render("packages-list.html", packages=packages)


class PackageNameHandler(BaseHandler):
	def get(self, name):
		builds = self.pakfire.builds.get_active_builds(name)
		if not builds:
			raise tornado.web.HTTPError(404, "Package '%s' was not found" % name)

		# Get the latest build to show the package meta information.
		latest_build = builds[0]

		# Get the latest bugs from bugzilla.
		bugs = self.pakfire.bugzilla.get_bugs_from_component(name)

		self.render("package-detail-list.html", name=name, builds=builds,
			latest_build=latest_build, pkg=latest_build.pkg, bugs=bugs)


class PackageScratchBuildsHandler(BaseHandler):
	def get(self, name):
		offset = self.get_argument("offset", 0)
		limit  = self.get_argument("limit", 10)

		scratch_builds = self.pakfire.builds.get_by_name(name, type="scratch",
			limit=limit, offset=offset)

		if scratch_builds:
			latest_build = scratch_builds[0]
		else:
			release_builds = self.pakfire.builds.get_by_name(name, type="release", limit=1)
			if not release_builds:
				raise tornado.web.HTTPError(404, "Could not find any build with this name: %s" % name)

			latest_build = release_builds[0]

		self.render("packages/builds/scratch.html", builds=scratch_builds,
			pkg=latest_build.pkg)


class PackageChangelogHandler(BaseHandler):
	def get(self, name):
		limit = self.get_argument("limit", 10)
		try:
			limit = int(limit)
		except ValueError:
			limit = 10

		offset = self.get_argument("offset", 0)
		try:
			offset = int(offset)
		except ValueError:
			offset = 0

		# Get one more build than requested to find out if there are more items
		# to display (next button).
		builds = self.pakfire.builds.get_changelog(name, limit=limit + 1, offset=offset)

		if len(builds) >= limit:
			have_next = True
		else:
			have_next = False

		if offset < limit:
			have_prev = False
		else:
			have_prev = True

		# Clip list to limit.
		builds = builds[:limit]

		self.render("packages/changelog.html", name=name, builds=builds,
			limit=limit, offset=offset, have_prev=have_prev, have_next=have_next)


class PackageDetailHandler(BaseHandler):
	def get(self, uuid):
		pkg = self.pakfire.packages.get_by_uuid(uuid)
		if not pkg:
			raise tornado.web.HTTPError(404, "Package not found: %s" % uuid)

		self.render("package-detail.html", pkg=pkg)

	@tornado.web.authenticated
	def post(self, name, epoch, version, release):
		pkg = self.pakfire.packages.get_by_tuple(name, epoch, version, release)

		action = self.get_argument("action", None)

		if action == "comment":
			vote = self.get_argument("vote", None)
			if not self.current_user.is_tester() and \
					not self.current_user.is_admin():
				vote = None

			pkg.comment(self.current_user.id, self.get_argument("text"),
				vote or "none")

		self.render("package-detail.html", pkg=pkg)


class PackagePropertiesHandler(BaseHandler):
	@tornado.web.authenticated
	def get(self, name):
		build = self.pakfire.builds.get_latest_by_name(name)

		if not build:
			raise tornado.web.HTTPError(404, "Package '%s' was not found" % name)

		# Check if the user has sufficient permissions.
		if not build.has_perm(self.current_user):
			raise tornado.web.HTTPError(403, "User %s is not allowed to manage build %s" \
				% (self.current_user, build))

		self.render("package-properties.html", build=build,
			pkg=build.pkg, properties=build.pkg.properties)

	@tornado.web.authenticated
	def post(self, name):
		build = self.pakfire.builds.get_latest_by_name(name)

		if not build:
			raise tornado.web.HTTPError(404, "Package '%s' was not found" % name)

		# Check if the user has sufficient permissions.
		if not build.has_perm(self.current_user):
			raise tornado.web.HTTPError(403, "User %s is not allowed to manage build %s" \
				% (self.current_user, build))

		critical_path = self.get_argument("critical_path", False)
		if critical_path:
			critical_path = True
		else:
			critical_path = False
		build.pkg.update_property("critical_path", critical_path)


class PackageFileDownloadHandler(BaseHandler):
	def get_file(self, pkg_uuid, filename):
		# Fetch package.
		pkg = self.pakfire.packages.get_by_uuid(pkg_uuid)
		if not pkg:
			raise tornado.web.HTTPError(404, "Package not found: %s" % pkg_uuid)

		# Check if the package has got a file with the given name.
		if not filename in [f.name for f in pkg.filelist]:
			raise tornado.web.HTTPError(404, "Package %s does not contain file %s" % (pkg, filename))

		# Open the package in the filesystem.
		pkg_file = pkg.get_file()
		if not pkg_file:
			raise tornado.web.HTTPError(404, "Could not open package %s" % pkg.path)

		# Open the file to transfer it to the client.
		f = pkg_file.open_file(filename)
		if not f:
			raise tornado.web.HTTPError(404, "Package %s does not contain file %s" % (pkg_file, filename))

		# Guess the MIME type of the file.
		(type, encoding) = mimetypes.guess_type(filename)
		if not type:
			type = "text/plain"

		return (pkg, f, type)

	def get(self, pkg_uuid, filename):
		pkg, f, mimetype = self.get_file(pkg_uuid, filename)

		# Send the filename and mimetype in header.
		self.set_header("Content-Disposition", "attachment; filename=%s" % os.path.basename(filename))
		self.set_header("Content-Type", mimetype)

		# Transfer the content chunk by chunk.
		while True:
			buf = f.read(BUFFER_SIZE)
			if not buf:
				break

			self.write(buf)

		f.close()

		# Done.
		self.finish()


class PackageFileViewHandler(PackageFileDownloadHandler):
	def get(self, pkg_uuid, filename):
		pkg, f, mimetype = self.get_file(pkg_uuid, filename)

		# Read in the data.
		content = f.read()
		f.close()

		self.render("packages/view-file.html", pkg=pkg, filename=filename,
			mimetype=mimetype, content=content, filesize=f.size)


class PackageBuildsTimesHandler(BaseHandler):
	def get(self, name):
		latest_build = self.pakfire.builds.get_latest_by_name(name, type="release")

		# If no build with this name was found, we cannot go on.
		if not latest_build:
			raise tornado.web.HTTPError(404)

		# Get the summary stats.
		build_times_summary = self.pakfire.builds.get_build_times_summary(name)

		self.render("packages/builds/times.html", pkg=latest_build.pkg,
			build_times_summary=build_times_summary)
Commit	Line	Data
f6e6ff79 MT	1	#!/usr/bin/python
f6e6ff79 MT	2
01197c1d MT	3	import mimetypes
01197c1d MT	4	import os.path
f6e6ff79 MT	5	import tornado.web
f6e6ff79 MT	6
2c909128	7	from .handlers_base import BaseHandler
f6e6ff79	8
2c909128	9	from ..constants import BUFFER_SIZE
01197c1d	10
f6e6ff79 MT	11	class PackageIDDetailHandler(BaseHandler):
	12	def get(self, id):
	13	package = self.packages.get_by_id(id)
	14	if not package:
	15	return tornado.web.HTTPError(404, "Package not found: %s" % id)
	16
	17	self.render("package-detail.html", package=package)
	18
	19
	20	class PackageListHandler(BaseHandler):
	21	def get(self):
	22	packages = {}
	23
	24	show = self.get_argument("show", None)
	25	if show == "all":
	26	states = None
	27	elif show == "obsoletes":
	28	states = ["obsolete"]
	29	elif show == "broken":
	30	states = ["broken"]
	31	else:
	32	states = ["building", "stable", "testing"]
	33
	34	# Get all packages that fulfill the required parameters.
1104bcbf	35	pkgs = self.pakfire.packages.get_all_names(
f6e6ff79 MT	36	user=self.current_user, states=states)
	37
	38	# Sort all packages in an array like "<first char>" --> [packages, ...]
	39	# to print them in a table for each letter of the alphabet.
	40	for pkg in pkgs:
	41	c = pkg[0][0].lower()
	42
	43	if not packages.has_key(c):
	44	packages[c] = []
	45
	46	packages[c].append(pkg)
	47
	48	self.render("packages-list.html", packages=packages)
	49
	50
	51	class PackageNameHandler(BaseHandler):
	52	def get(self, name):
1104bcbf	53	builds = self.pakfire.builds.get_active_builds(name)
fd0e70ec	54	if not builds:
f6e6ff79 MT	55	raise tornado.web.HTTPError(404, "Package '%s' was not found" % name)
f6e6ff79 MT	56
fd0e70ec MT	57	# Get the latest build to show the package meta information.
fd0e70ec MT	58	latest_build = builds[0]
f6e6ff79 MT	59
	60	# Get the latest bugs from bugzilla.
	61	bugs = self.pakfire.bugzilla.get_bugs_from_component(name)
	62
fd0e70ec MT	63	self.render("package-detail-list.html", name=name, builds=builds,
fd0e70ec MT	64	latest_build=latest_build, pkg=latest_build.pkg, bugs=bugs)
f6e6ff79 MT	65
f6e6ff79 MT	66
a15d6139 MT	67	class PackageScratchBuildsHandler(BaseHandler):
	68	def get(self, name):
	69	offset = self.get_argument("offset", 0)
	70	limit = self.get_argument("limit", 10)
	71
	72	scratch_builds = self.pakfire.builds.get_by_name(name, type="scratch",
1104bcbf	73	limit=limit, offset=offset)
a15d6139 MT	74
	75	if scratch_builds:
	76	latest_build = scratch_builds[0]
	77	else:
1104bcbf	78	release_builds = self.pakfire.builds.get_by_name(name, type="release", limit=1)
a15d6139 MT	79	if not release_builds:
	80	raise tornado.web.HTTPError(404, "Could not find any build with this name: %s" % name)
	81
	82	latest_build = release_builds[0]
	83
	84	self.render("packages/builds/scratch.html", builds=scratch_builds,
	85	pkg=latest_build.pkg)
	86
	87
4b1e87c4 MT	88	class PackageChangelogHandler(BaseHandler):
	89	def get(self, name):
	90	limit = self.get_argument("limit", 10)
	91	try:
	92	limit = int(limit)
	93	except ValueError:
	94	limit = 10
	95
	96	offset = self.get_argument("offset", 0)
	97	try:
	98	offset = int(offset)
	99	except ValueError:
	100	offset = 0
	101
	102	# Get one more build than requested to find out if there are more items
	103	# to display (next button).
	104	builds = self.pakfire.builds.get_changelog(name, limit=limit + 1, offset=offset)
	105
	106	if len(builds) >= limit:
	107	have_next = True
	108	else:
	109	have_next = False
	110
	111	if offset < limit:
	112	have_prev = False
	113	else:
	114	have_prev = True
	115
	116	# Clip list to limit.
	117	builds = builds[:limit]
	118
	119	self.render("packages/changelog.html", name=name, builds=builds,
	120	limit=limit, offset=offset, have_prev=have_prev, have_next=have_next)
	121
	122
f6e6ff79 MT	123	class PackageDetailHandler(BaseHandler):
	124	def get(self, uuid):
	125	pkg = self.pakfire.packages.get_by_uuid(uuid)
	126	if not pkg:
	127	raise tornado.web.HTTPError(404, "Package not found: %s" % uuid)
	128
	129	self.render("package-detail.html", pkg=pkg)
	130
	131	@tornado.web.authenticated
	132	def post(self, name, epoch, version, release):
	133	pkg = self.pakfire.packages.get_by_tuple(name, epoch, version, release)
	134
	135	action = self.get_argument("action", None)
	136
	137	if action == "comment":
	138	vote = self.get_argument("vote", None)
	139	if not self.current_user.is_tester() and \
	140	not self.current_user.is_admin():
	141	vote = None
	142
	143	pkg.comment(self.current_user.id, self.get_argument("text"),
	144	vote or "none")
	145
	146	self.render("package-detail.html", pkg=pkg)
	147
	148
	149	class PackagePropertiesHandler(BaseHandler):
	150	@tornado.web.authenticated
	151	def get(self, name):
1104bcbf	152	build = self.pakfire.builds.get_latest_by_name(name)
f6e6ff79 MT	153
	154	if not build:
	155	raise tornado.web.HTTPError(404, "Package '%s' was not found" % name)
	156
	157	# Check if the user has sufficient permissions.
	158	if not build.has_perm(self.current_user):
	159	raise tornado.web.HTTPError(403, "User %s is not allowed to manage build %s" \
	160	% (self.current_user, build))
	161
	162	self.render("package-properties.html", build=build,
	163	pkg=build.pkg, properties=build.pkg.properties)
	164
	165	@tornado.web.authenticated
	166	def post(self, name):
1104bcbf	167	build = self.pakfire.builds.get_latest_by_name(name)
f6e6ff79 MT	168
	169	if not build:
	170	raise tornado.web.HTTPError(404, "Package '%s' was not found" % name)
	171
	172	# Check if the user has sufficient permissions.
	173	if not build.has_perm(self.current_user):
	174	raise tornado.web.HTTPError(403, "User %s is not allowed to manage build %s" \
	175	% (self.current_user, build))
	176
	177	critical_path = self.get_argument("critical_path", False)
	178	if critical_path:
	179	critical_path = True
	180	else:
	181	critical_path = False
	182	build.pkg.update_property("critical_path", critical_path)
01197c1d MT	183
	184
	185	class PackageFileDownloadHandler(BaseHandler):
de4e09a5	186	def get_file(self, pkg_uuid, filename):
01197c1d MT	187	# Fetch package.
	188	pkg = self.pakfire.packages.get_by_uuid(pkg_uuid)
	189	if not pkg:
	190	raise tornado.web.HTTPError(404, "Package not found: %s" % pkg_uuid)
	191
	192	# Check if the package has got a file with the given name.
	193	if not filename in [f.name for f in pkg.filelist]:
	194	raise tornado.web.HTTPError(404, "Package %s does not contain file %s" % (pkg, filename))
	195
	196	# Open the package in the filesystem.
	197	pkg_file = pkg.get_file()
	198	if not pkg_file:
e088f666	199	raise tornado.web.HTTPError(404, "Could not open package %s" % pkg.path)
01197c1d MT	200
	201	# Open the file to transfer it to the client.
	202	f = pkg_file.open_file(filename)
	203	if not f:
	204	raise tornado.web.HTTPError(404, "Package %s does not contain file %s" % (pkg_file, filename))
	205
01197c1d MT	206	# Guess the MIME type of the file.
	207	(type, encoding) = mimetypes.guess_type(filename)
	208	if not type:
	209	type = "text/plain"
de4e09a5 MT	210
	211	return (pkg, f, type)
	212
	213	def get(self, pkg_uuid, filename):
	214	pkg, f, mimetype = self.get_file(pkg_uuid, filename)
	215
	216	# Send the filename and mimetype in header.
	217	self.set_header("Content-Disposition", "attachment; filename=%s" % os.path.basename(filename))
	218	self.set_header("Content-Type", mimetype)
01197c1d MT	219
	220	# Transfer the content chunk by chunk.
	221	while True:
	222	buf = f.read(BUFFER_SIZE)
	223	if not buf:
	224	break
	225
	226	self.write(buf)
	227
	228	f.close()
	229
	230	# Done.
	231	self.finish()
de4e09a5 MT	232
	233
	234	class PackageFileViewHandler(PackageFileDownloadHandler):
	235	def get(self, pkg_uuid, filename):
	236	pkg, f, mimetype = self.get_file(pkg_uuid, filename)
	237
	238	# Read in the data.
	239	content = f.read()
	240	f.close()
	241
5669a87f	242	self.render("packages/view-file.html", pkg=pkg, filename=filename,
de4e09a5	243	mimetype=mimetype, content=content, filesize=f.size)
bc293d03 MT	244
	245
	246	class PackageBuildsTimesHandler(BaseHandler):
	247	def get(self, name):
1104bcbf	248	latest_build = self.pakfire.builds.get_latest_by_name(name, type="release")
bc293d03 MT	249
	250	# If no build with this name was found, we cannot go on.
	251	if not latest_build:
	252	raise tornado.web.HTTPError(404)
	253
	254	# Get the summary stats.
4f90cf84	255	build_times_summary = self.pakfire.builds.get_build_times_summary(name)
bc293d03 MT	256
	257	self.render("packages/builds/times.html", pkg=latest_build.pkg,
	258	build_times_summary=build_times_summary)