src/web/handlers.py

   1 #!/usr/bin/python
   2
   3 import tornado.web
   4
   5 from . import base
   6
   7 class IndexHandler(base.BaseHandler):
   8         def get(self):
   9                 jobs = []
  10
  11                 # Get all active jobs
  12                 jobs += self.backend.jobs.get_active()
  13
  14                 # Get some recently finished jobs
  15                 jobs += self.backend.jobs.get_recently_ended(limit=12)
  16
  17                 # Updates
  18                 updates = []
  19                 active = True
  20                 for type in ("stable", "unstable", "testing"):
  21                         u = self.backend.updates.get_latest(type=type)
  22                         if u:
  23                                 updates.append((type, u, active))
  24                                 active = False
  25
  26                 self.render("index.html", jobs=jobs, updates=updates)
  27
  28
  29 class UploadsHandler(base.BaseHandler):
  30         @tornado.web.authenticated
  31         def get(self):
  32                 if not self.current_user.is_admin():
  33                         raise tornado.web.HTTPError(403)
  34
  35                 self.render("uploads-list.html", uploads=self.backend.uploads)
  36
  37
  38 class DocsIndexHandler(base.BaseHandler):
  39         def get(self):
  40                 self.render("docs-index.html")
  41
  42
  43 class DocsBuildsHandler(base.BaseHandler):
  44         def get(self):
  45                 self.render("docs-build.html")
  46
  47
  48 class DocsUsersHandler(base.BaseHandler):
  49         def get(self):
  50                 self.render("docs-users.html")
  51
  52
  53 class DocsWhatsthisHandler(base.BaseHandler):
  54         def get(self):
  55                 self.render("docs-whatsthis.html")
  56
  57
  58 class FileDetailHandler(base.BaseHandler):
  59         def get(self, uuid):
  60                 pkg, file = self.backend.packages.get_with_file_by_uuid(uuid)
  61
  62                 if not file:
  63                         raise tornado.web.HTTPError(404, "File not found")
  64
  65                 self.render("file-detail.html", pkg=pkg, file=file)
  66
  67
  68 class LogHandler(base.BaseHandler):
  69         def get(self):
  70                 self.render("log.html", log=self.backend.log)
  71
  72
  73 class SessionsHandler(base.BaseHandler):
  74         def prepare(self):
  75                 # This is only accessible for administrators.
  76                 if not self.current_user.is_admin():
  77                         raise tornado.web.HTTPError(403)
  78
  79         @tornado.web.authenticated
  80         def get(self):
  81                 # Sort the sessions by user.
  82                 users = {}
  83
  84                 for s in self.backend.sessions:
  85                         print s.user, s.user in users
  86                         try:
  87                                 users[s.user].append(s)
  88                         except KeyError:
  89                                 users[s.user] = [s]
  90
  91                 sessions = sorted(users.items())
  92
  93                 self.render("sessions/index.html", sessions=sessions)
  94
  95
  96 class RepositoryDetailHandler(base.BaseHandler):
  97         def get(self, distro, repo):
  98                 distro = self.backend.distros.get_by_name(distro)
  99                 if not distro:
 100                         raise tornado.web.HTTPError(404)
 101
 102                 repo = distro.get_repo(repo)
 103                 if not repo:
 104                         raise tornado.web.HTTPError(404)
 105
 106                 limit = self.get_argument("limit", 50)
 107                 try:
 108                         limit = int(limit)
 109                 except ValueError:
 110                         limit = None
 111
 112                 offset = self.get_argument("offset", 0)
 113                 try:
 114                         offset = int(offset)
 115                 except ValueError:
 116                         offset = None
 117
 118                 builds = repo.get_builds(limit=limit, offset=offset)
 119                 unpushed_builds = repo.get_unpushed_builds()
 120                 obsolete_builds = repo.get_obsolete_builds()
 121
 122                 # Get the build times of this repository.
 123                 build_times = repo.get_build_times()
 124
 125                 self.render("repository-detail.html", distro=distro, repo=repo,
 126                         builds=builds, unpushed_builds=unpushed_builds,
 127                         obsolete_builds=obsolete_builds, build_times=build_times)
 128
 129
 130 class RepositoryEditHandler(base.BaseHandler):
 131         @tornado.web.authenticated
 132         def get(self, distro, repo):
 133                 distro = self.backend.distros.get_by_name(distro)
 134                 if not distro:
 135                         raise tornado.web.HTTPError(404)
 136
 137                 repo = distro.get_repo(repo)
 138                 if not repo:
 139                         raise tornado.web.HTTPError(404)
 140
 141                 # XXX check if user has permissions to do this
 142
 143                 self.render("repository-edit.html", distro=distro, repo=repo)
 144
 145
 146 class RepositoryConfHandler(base.BaseHandler):
 147         def get(self, distro, repo):
 148                 distro = self.backend.distros.get_by_name(distro)
 149                 if not distro:
 150                         raise tornado.web.HTTPError(404)
 151
 152                 repo = distro.get_repo(repo)
 153                 if not repo:
 154                         raise tornado.web.HTTPError(404)
 155
 156                 # This is a plaintext file.
 157                 self.set_header("Content-Type", "text/plain")
 158
 159                 # Write the header.
 160                 self.write("# Downloaded from the pakfire build service on %s.\n\n" \
 161                         % datetime.datetime.utcnow())
 162                 self.write(repo.get_conf())
 163                 self.finish()
 164
 165
 166 class RepositoryMirrorlistHandler(base.BaseHandler):
 167         def get(self, distro, repo):
 168                 distro = self.backend.distros.get_by_name(distro)
 169                 if not distro:
 170                         raise tornado.web.HTTPError(404)
 171
 172                 repo = distro.get_repo(repo)
 173                 if not repo:
 174                         raise tornado.web.HTTPError(404)
 175
 176                 # Send nothing if repository isn't supposed to be mirrored
 177                 if not repo.mirrored:
 178                         raise tornado.web.HTTPError(404)
 179
 180                 # This is a plaintext file.
 181                 self.set_header("Content-Type", "text/plain")
 182
 183                 arch = self.get_argument("arch", None)
 184                 if not arch or not self.backend.arches.exists(arch):
 185                         raise tornado.web.HTTPError(400, "You must specify a valid architecture")
 186
 187                 ret = {
 188                         "type"    : "mirrorlist",
 189                         "version" : 1,
 190                 }
 191
 192                 mirrors = []
 193                 for mirror in self.backend.mirrors.make_mirrorlist(self.current_address):
 194                         mirrors.append({
 195                                 "url"       : "/".join((mirror.url, repo.basepath, arch)),
 196                                 "location"  : mirror.country_code,
 197                         })
 198
 199                 # Always use the buildservice itself as last resort
 200                 mirrors.append({
 201                         "url" : "/".join((repo.url, arch)),
 202                 })
 203
 204                 ret["mirrors"] = mirrors
 205                 self.finish(ret)
 206
 207
 208 class RepoActionHandler(base.BaseHandler):
 209         @tornado.web.authenticated
 210         def post(self, type):
 211                 assert type in ("run", "remove")
 212
 213                 action_id = self.get_argument("id")
 214
 215                 action = self.backend.repos.get_action_by_id(action_id)
 216                 if not action:
 217                         raise tornado.web.HTTPError(400)
 218
 219                 if type == "run":
 220                         action.run(self.current_user)
 221
 222                 elif type == "remove":
 223                         action.delete(self.current_user)