web/handlers.py

   1 #!/usr/bin/python
   2
   3 import tornado.web
   4
   5 from handlers_auth import *
   6 from handlers_base import *
   7 from handlers_builders import *
   8 from handlers_search import *
   9 from handlers_users import *
  10
  11 class IndexHandler(BaseHandler):
  12         def get(self):
  13                 active_builds = self.pakfire.builds.get_active()
  14                 latest_builds = self.pakfire.builds.get_latest(limit=10)
  15                 next_builds   = self.pakfire.builds.get_next(limit=10)
  16
  17                 # Get counters
  18                 counter_pending = self.pakfire.builds.count(state="pending")
  19
  20                 average_build_time = self.pakfire.builds.average_build_time()
  21
  22                 self.render("index.html", latest_builds=latest_builds,
  23                         active_builds=active_builds, next_builds=next_builds,
  24                         counter_pending=counter_pending, average_build_time=average_build_time)
  25
  26
  27 class PackageIDDetailHandler(BaseHandler):
  28         def get(self, id):
  29                 package = self.packages.get_by_id(id)
  30                 if not package:
  31                         return tornado.web.HTTPError(404, "Package not found: %s" % id)
  32
  33                 self.render("package-detail.html", package=package)
  34
  35
  36 class PackageListHandler(BaseHandler):
  37         def get(self):
  38                 packages = {}
  39
  40                 # Sort all packages in an array like "<first char>" --> [packages, ...]
  41                 # to print them in a table for each letter of the alphabet.
  42                 for pkg in self.pakfire.packages.get_all_names():
  43                         c = pkg[0].lower()
  44
  45                         if not packages.has_key(c):
  46                                 packages[c] = []
  47
  48                         packages[c].append(pkg)
  49
  50                 self.render("package-list.html", packages=packages)
  51
  52
  53 class PackageNameHandler(BaseHandler):
  54         def get(self, package):
  55                 packages = self.pakfire.packages.get_by_name(package)
  56
  57                 if not packages:
  58                         raise tornado.web.HTTPError(404, "Package '%s' was not found")
  59
  60                 # Take info from the most recent package.
  61                 pkg = packages[0]
  62
  63                 self.render("package-detail-list.html", pkg=pkg, packages=packages)
  64
  65
  66 class PackageDetailHandler(BaseHandler):
  67         def get(self, name, epoch, version, release):
  68                 pkg = self.pakfire.packages.get_by_tuple(name, epoch, version, release)
  69                 pkg.update()
  70
  71                 self.render("package-detail.html", pkg=pkg)
  72
  73         @tornado.web.authenticated
  74         def post(self, name, epoch, version, release):
  75                 pkg = self.pakfire.packages.get_by_tuple(name, epoch, version, release)
  76
  77                 action = self.get_argument("action", None)
  78
  79                 if action == "comment":
  80                         vote = self.get_argument("vote", None)
  81                         if not self.current_user.is_tester() and \
  82                                         not self.current_user.is_admin():
  83                                 vote = None
  84
  85                         pkg.comment(self.current_user.id, self.get_argument("text"),
  86                                 vote or "none")
  87
  88                 self.render("package-detail.html", pkg=pkg)
  89
  90
  91 class BuildDetailHandler(BaseHandler):
  92         def get(self, uuid):
  93                 build = self.pakfire.builds.get_by_uuid(uuid)
  94
  95                 if not build:
  96                         raise tornado.web.HTTPError(404, "Build not found")
  97
  98                 self.render("build-detail.html", build=build)
  99
 100
 101 class BuildPriorityHandler(BaseHandler):
 102         @tornado.web.authenticated
 103         def get(self, uuid):
 104                 build = self.pakfire.builds.get_by_uuid(uuid)
 105
 106                 if not build:
 107                         raise tornado.web.HTTPError(404, "Build not found")
 108
 109                 self.render("build-priority.html", build=build)
 110
 111         @tornado.web.authenticated
 112         def post(self, uuid):
 113                 build = self.pakfire.builds.get_by_uuid(uuid)
 114
 115                 if not build:
 116                         raise tornado.web.HTTPError(404, "Build not found")
 117
 118                 # Get the priority from the request data and convert it to an integer.
 119                 # If that cannot be done, we default to zero.
 120                 prio = self.get_argument("priority")
 121                 try:
 122                         prio = int(prio)
 123                 except TypeError:
 124                         prio = 0
 125
 126                 # Check if the value is in a valid range.
 127                 if not prio in (-2, -1, 0, 1, 2):
 128                         prio = 0
 129
 130                 # Save priority.
 131                 build.priority = prio
 132
 133                 self.redirect("/build/%s" % build.uuid)
 134
 135
 136 class BuildScheduleHandler(BaseHandler):
 137         allowed_types = ("test", "rebuild",)
 138
 139         @tornado.web.authenticated
 140         def get(self, uuid):
 141                 type = self.get_argument("type")
 142                 assert type in self.allowed_types
 143
 144                 build = self.pakfire.builds.get_by_uuid(uuid)
 145                 if not build:
 146                         raise tornado.web.HTTPError(404, "Build not found")
 147
 148                 self.render("build-schedule-%s.html" % type, type=type, build=build)
 149
 150         @tornado.web.authenticated
 151         def post(self, uuid):
 152                 type = self.get_argument("type")
 153                 assert type in self.allowed_types
 154
 155                 build = self.pakfire.builds.get_by_uuid(uuid)
 156                 if not build:
 157                         raise tornado.web.HTTPError(404, "Build not found")
 158
 159                 # Get the start offset.
 160                 offset = self.get_argument("offset", 0)
 161                 try:
 162                         offset = int(offset)
 163                 except TypeError:
 164                         offset = 0
 165
 166                 # Submit the build.
 167                 if type == "test":
 168                         build.schedule_test(offset)
 169                 elif type == "rebuild":
 170                         build.schedule_rebuild(offset)
 171
 172                 self.redirect("/build/%s" % build.uuid)
 173
 174
 175 class BuildListHandler(BaseHandler):
 176         def get(self):
 177                 builder = self.get_argument("builder", None)
 178                 state = self.get_argument("state", None)
 179
 180                 builds = self.pakfire.builds.get_latest(state=state, builder=builder,
 181                         limit=25)
 182
 183                 self.render("build-list.html", builds=builds)
 184
 185
 186 class BuildFilterHandler(BaseHandler):
 187         def get(self):
 188                 builders = self.pakfire.builders.get_all()
 189
 190                 self.render("build-filter.html", builders=builders)
 191
 192
 193 class DocsIndexHandler(BaseHandler):
 194         def get(self):
 195                 self.render("docs-index.html")
 196
 197
 198 class DocsBuildsHandler(BaseHandler):
 199         def get(self):
 200                 self.render("docs-build.html")
 201
 202
 203 class DocsUsersHandler(BaseHandler):
 204         def get(self):
 205                 self.render("docs-users.html")
 206
 207
 208 class SourceListHandler(BaseHandler):
 209         def get(self):
 210                 sources = self.pakfire.sources.get_all()
 211
 212                 self.render("source-list.html", sources=sources)
 213
 214
 215 class SourceDetailHandler(BaseHandler):
 216         def get(self, id):
 217                 source = self.pakfire.sources.get_by_id(id)
 218
 219                 self.render("source-detail.html", source=source)
 220
 221
 222 class FileDetailHandler(BaseHandler):
 223         def get(self, uuid):
 224                 pkg, file = self.pakfire.packages.get_with_file_by_uuid(uuid)
 225
 226                 if not file:
 227                         raise tornado.web.HTTPError(404, "File not found")
 228
 229                 self.render("file-detail.html", pkg=pkg, file=file)
 230
 231
 232 class DistributionListHandler(BaseHandler):
 233         def get(self):
 234                 distros = self.pakfire.distros.get_all()
 235
 236                 self.render("distro-list.html", distros=distros)
 237
 238
 239 class DistributionDetailHandler(BaseHandler):
 240         def get(self, name):
 241                 distro = self.pakfire.distros.get_by_name(name)
 242                 if not distro:
 243                         raise tornado.web.HTTPError(404, "Distro not found")
 244
 245                 self.render("distro-detail.html", distro=distro)
 246
 247
 248 class DistributionEditHandler(BaseHandler):
 249         def prepare(self):
 250                 self.arches = self.pakfire.builders.get_all_arches()
 251                 self.sources = self.pakfire.sources.get_all()
 252
 253         @tornado.web.authenticated
 254         def get(self, name):
 255                 distro = self.pakfire.distros.get_by_name(name)
 256                 if not distro:
 257                         raise tornado.web.HTTPError(404, "Distro not found")
 258
 259                 self.render("distro-edit.html", distro=distro, arches=self.arches,
 260                         sources=self.sources)
 261
 262         @tornado.web.authenticated
 263         def post(self, name):
 264                 distro = self.pakfire.distros.get_by_name(name)
 265                 if not distro:
 266                         raise tornado.web.HTTPError(404, "Distro not found")
 267
 268                 name = self.get_argument("name", distro.name)
 269                 vendor = self.get_argument("vendor", distro.vendor)
 270                 slogan = self.get_argument("slogan", distro.slogan)
 271                 arches = self.get_argument("arches", distro.arches)
 272                 sources = self.get_argument("sources", distro.sources)
 273
 274                 distro.set("name", name)
 275                 distro.set("vendor", vendor)
 276                 distro.set("slogan", slogan)
 277                 distro.set("arches", arches)
 278                 distro.set("sources", sources)
 279
 280                 self.redirect("/distribution/%s" % distro.sname)
 281
 282
 283 class LogHandler(BaseHandler):
 284         def get(self):
 285                 self.render("log.html", log=self.pakfire.log)
 286
 287
 288 class RepositoryDetailHandler(BaseHandler):
 289         def get(self, distro, repo):
 290                 distro = self.pakfire.distros.get_by_name(distro)
 291                 if not distro:
 292                         raise tornado.web.HTTPError(404)
 293
 294                 repo = distro.get_repo(repo)
 295                 if not repo:
 296                         raise tornado.web.HTTPError(404)
 297
 298                 self.render("repository-detail.html", distro=distro, repo=repo)
 299
 300
 301 class RepoActionHandler(BaseHandler):
 302         @tornado.web.authenticated
 303         def post(self, type):
 304                 assert type in ("run", "remove")
 305
 306                 action_id = self.get_argument("id")
 307
 308                 action = self.pakfire.repos.get_action_by_id(action_id)
 309                 if not action:
 310                         raise tornado.web.HTTPError(400)
 311
 312                 if type == "run":
 313                         action.run(self.current_user)
 314
 315                 elif type == "remove":
 316                         action.delete(self.current_user)