#!/usr/bin/python
-import datetime
-import httplib
-import mimetypes
-import operator
+#import httplib
+#import logging
+#import markdown2
import os
-import re
-import simplejson
-import stat
-import sqlite3
-import time
-import unicodedata
-import urlparse
-
-import tornado.database
-import tornado.httpclient
-import tornado.locale
+#import random
+#import re
+#import socket
+#import time
+#import tornado.database
+#import tornado.locale
import tornado.web
+#import unicodedata
-from banners import banners
-from helpers import size, Item
-from info import info
-from mirrors import mirrors
-from news import news
-from releases import releases
-
-import builds
-import cluster
-import markdown
-import translations
-#import uriel
+import backend
-class BaseHandler(tornado.web.RequestHandler):
- def get_user_locale(self):
- uri = self.request.uri.split("/")
- if len(uri) > 1:
- for lang in tornado.locale.get_supported_locales(None):
- if lang[:2] == uri[1]:
- return tornado.locale.get(lang)
+from handlers_admin import *
+from handlers_base import *
+from handlers_boot import *
+from handlers_download import *
+from handlers_iuse import *
+from handlers_mirrors import *
+from handlers_news import *
+from handlers_nopaste import *
+from handlers_planet import *
+from handlers_rss import *
+from handlers_stasy import *
+from handlers_tracker import *
+from handlers_wishlist import *
- @property
- def render_args(self):
- return {
- "banner" : banners.get(),
- "lang" : self.locale.code[:2],
- "langs" : [l[:2] for l in tornado.locale.get_supported_locales(None)],
- "lang_link" : self.lang_link,
- "link" : self.link,
- "title" : "no title given",
- "server" : self.request.host.replace("ipfire", "<span>ipfire</span>"),
- "uri" : self.request.uri,
- "year" : time.strftime("%Y"),
- }
+class RootHandler(BaseHandler):
+ """
+ This handler redirects any request directly to /.
- def render(self, *args, **kwargs):
- nargs = self.render_args
- nargs.update(kwargs)
- nargs["title"] = "%s - %s" % (self.request.host, nargs["title"])
- tornado.web.RequestHandler.render(self, *args, **nargs)
+ It can be used to be compatible with some ancient index urls.
+ """
+ def get(self, *args):
+ self.redirect("/")
- def link(self, s):
- return "/%s/%s" % (self.locale.code[:2], s)
-
- def lang_link(self, lang):
- return "/%s/%s" % (lang, self.request.uri[4:])
-
- def get_error_html(self, status_code, **kwargs):
- if status_code in (404, 500):
- render_args = self.render_args
- render_args.update({
- "code" : status_code,
- "exception" : kwargs.get("exception", None),
- "message" : httplib.responses[status_code],
- })
- return self.render_string("error-%s.html" % status_code, **render_args)
- else:
- return tornado.web.RequestHandler.get_error_html(self, status_code, **kwargs)
- @property
- def hash_db(self):
- return self.application.hash_db
+class LangCompatHandler(BaseHandler):
+ """
+ Redirect links in the old format to current site:
- @property
- def planet_db(self):
- return self.application.planet_db
-
- @property
- def user_db(self):
- return self.application.user_db
-
-
-class MainHandler(BaseHandler):
- def get(self):
- lang = self.locale.code[:2]
- self.redirect("/%s/index" % (lang))
-
-
-class DownloadHandler(BaseHandler):
- def get(self):
- self.render("downloads.html", release=releases.latest)
+ E.g. /en/index -> /index
+ """
+ def get(self, lang, page):
+ self.redirect("/%s" % page)
-class DownloadAllHandler(BaseHandler):
- def get(self):
- self.render("downloads-all.html", releases=releases)
-
-
-class DownloadDevelopmentHandler(BaseHandler):
- def get(self):
- self.render("downloads-development.html", releases=releases)
-
-
-class DownloadTorrentHandler(BaseHandler):
- tracker_url = "http://tracker.ipfire.org:6969/stats?format=txt&mode=tpbs"
+class IndexHandler(BaseHandler):
+ rss_url = "/news.rss"
- @tornado.web.asynchronous
+ """
+ This handler displays the welcome page.
+ """
def get(self):
- http = tornado.httpclient.AsyncHTTPClient()
- http.fetch(self.tracker_url, callback=self.async_callback(self.on_response))
-
- def on_response(self, response):
- torrents = releases.torrents
- hashes = {}
- if response.code == 200:
- for line in response.body.split("\n"):
- if not line: continue
- hash, seeds, peers = line.split(":")
- hash.lower()
- hashes[hash] = {
- "peers" : peers,
- "seeds" : seeds,
- }
-
- self.render("downloads-torrents.html",
- hashes=hashes,
- releases=torrents,
- request_time=response.request_time,
- tracker=urlparse.urlparse(response.request.url).netloc)
+ # Get a list of the most recent news items and put them on the page.
+ latest_news = self.news.get_latest(limit=1, locale=self.locale)
+ # Get the latest release.
+ latest_release = self.releases.get_latest()
-class DownloadMirrorHandler(BaseHandler):
- def get(self):
- self.render("downloads-mirrors.html", mirrors=mirrors)
+ return self.render("index.html", latest_news=latest_news,
+ latest_release=latest_release)
class StaticHandler(BaseHandler):
+ """
+ This handler shows the files that are in plain html format.
+ """
@property
def static_path(self):
return os.path.join(self.application.settings["template_path"], "static")
@property
def static_files(self):
- ret = []
- for filename in os.listdir(self.static_path):
- if filename.endswith(".html"):
- ret.append(filename)
- return ret
+ for dir, subdirs, files in os.walk(self.static_path):
+ dir = dir[len(self.static_path) + 1:]
+ for file in files:
+ if not file.endswith(".html"):
+ continue
+ yield os.path.join(dir, file)
def get(self, name=None):
name = "%s.html" % name
if not name in self.static_files:
raise tornado.web.HTTPError(404)
- self.render("static/%s" % name)
-
-
-class IndexHandler(BaseHandler):
- def get(self):
- self.render("index.html", news=news)
-
-
-class NewsHandler(BaseHandler):
- def get(self):
- self.render("news.html", news=news)
-
-
-class BuildHandler(BaseHandler):
- def prepare(self):
- self.builds = {
- "<12h" : [],
- ">12h" : [],
- ">24h" : [],
- }
-
- for build in builds.find():
- if (time.time() - float(build.get("date"))) < 12*60*60:
- self.builds["<12h"].append(build)
- elif (time.time() - float(build.get("date"))) < 24*60*60:
- self.builds[">12h"].append(build)
- else:
- self.builds[">24h"].append(build)
-
- for l in self.builds.values():
- l.sort()
-
- def get(self):
- self.render("builds.html", builds=self.builds)
-
-
-class UrielBaseHandler(BaseHandler):
- #db = uriel.Database()
- pass
-
-class UrielHandler(UrielBaseHandler):
- def get(self):
- pass
-
-
-class ApiClusterInfoHandler(BaseHandler):
- def get(self):
- id = self.get_argument("id", "null")
-
- c = cluster.Cluster(info["cluster"]["hostname"])
-
- self.write(simplejson.dumps({
- "version": "1.1",
- "id": id,
- "result" : c.json,
- "error" : "null", }))
- self.finish()
-
-
-class TranslationHandler(BaseHandler):
- def get(self):
- self.render("translations.html", projects=translations.projects)
-
-
-class SourceHandler(BaseHandler):
- def get(self):
- source_path = "/srv/sources"
- fileobjects = []
-
- for dir, subdirs, files in os.walk(source_path):
- if not files:
- continue
- for file in files:
- if file in [f["name"] for f in fileobjects]:
- continue
-
- hash = self.hash_db.get_hash(os.path.join(dir, file))
-
- if not hash:
- hash = "0000000000000000000000000000000000000000"
-
- fileobjects.append({
- "dir" : dir[len(source_path)+1:],
- "name" : file,
- "hash" : hash,
- "size" : size(os.path.getsize(os.path.join(source_path, dir, file))),
- })
-
- fileobjects.sort(key=operator.itemgetter("name"))
-
- self.render("sources.html", files=fileobjects)
-
-
-class SourceDownloadHandler(BaseHandler):
- def head(self, path):
- self.get(path, include_body=False)
-
- def get(self, path, include_body=True):
- source_path = "/srv/sources"
-
- path = os.path.abspath(os.path.join(source_path, path[1:]))
-
- if not path.startswith(source_path):
- raise tornado.web.HTTPError(403)
- if not os.path.exists(path):
- raise tornado.web.HTTPError(404)
-
- stat_result = os.stat(path)
- modified = datetime.datetime.fromtimestamp(stat_result[stat.ST_MTIME])
-
- self.set_header("Last-Modified", modified)
- self.set_header("Content-Length", stat_result[stat.ST_SIZE])
-
- mime_type, encoding = mimetypes.guess_type(path)
- if mime_type:
- self.set_header("Content-Type", mime_type)
-
- hash = self.hash_db.get_hash(path)
- if hash:
- self.set_header("X-Hash-Sha1", "%s" % hash)
-
- if not include_body:
- return
- file = open(path, "r")
- try:
- self.write(file.read())
- finally:
- file.close()
-
-
-class DownloadFileHandler(BaseHandler):
- def get(self, path):
- for mirror in mirrors.with_file(path):
- if not mirror.reachable:
- continue
-
- self.redirect(mirror.url + path)
- return
-
- raise tornado.web.HTTPError(404)
-
- def get_error_html(self, status_code, **kwargs):
- return tornado.web.RequestHandler.get_error_html(self, status_code, **kwargs)
-
-
-class RSSHandler(BaseHandler):
- def get(self, lang):
- items = []
- for item in news.get(15):
- item = Item(**item.args.copy())
- for attr in ("subject", "content"):
- if type(item[attr]) == type({}):
- item[attr] = item[attr][lang]
- items.append(item)
-
- self.set_header("Content-Type", "application/rss+xml")
- self.render("rss.xml", items=items, lang=lang)
-
-
-class PlanetBaseHandler(BaseHandler):
- @property
- def db(self):
- return self.application.planet_db
-
-
-class PlanetMainHandler(PlanetBaseHandler):
- def get(self):
- authors = self.db.query("SELECT DISTINCT author_id FROM entries")
- authors = [a["author_id"] for a in authors]
-
- users = []
- for user in self.user_db.users:
- if user.id in authors:
- users.append(user)
-
- entries = self.db.query("SELECT * FROM entries "
- "ORDER BY published DESC LIMIT 3")
-
- for entry in entries:
- entry.author = self.user_db.get_user_by_id(entry.author_id)
-
- self.render("planet-main.html", entries=entries, authors=users)
-
-
-class PlanetUserHandler(PlanetBaseHandler):
- def get(self, user):
- if not user in [u.name for u in self.user_db.users]:
- raise tornado.web.HTTPError(404, "User is unknown")
-
- user = self.user_db.get_user_by_name(user)
-
- entries = self.db.query("SELECT * FROM entries "
- "WHERE author_id = '%s' ORDER BY published DESC" % (user.id))
-
- self.render("planet-user.html", entries=entries, user=user)
-
-
-class PlanetPostingHandler(PlanetBaseHandler):
- def get(self, slug):
- entry = self.db.get("SELECT * FROM entries WHERE slug = %s", slug)
-
- if not entry:
- raise tornado.web.HTTPError(404)
-
- user = self.user_db.get_user_by_id(entry.author_id)
- entry.author = user
-
- self.render("planet-posting.html", entry=entry, user=user)
+ self.render("static/%s" % name, lang=self.locale.code[:2])
projects / people / shoehn / ipfire.org.git / blobdiff