Merge branch 'planet' into next

Conflicts:
	www/webapp/handlers.py

diff --cc www/webapp/__init__.py
index 08ad37f3a9602c5cc4b8faae6bf058a316490f19,496b13ca35f1caf864fb30f32f0de27c49909a74..200c097474d35c5a348e9043245733de71968716
--- 1/www/webapp/__init__.py
--- 2/www/webapp/__init__.py
+++ b/www/webapp/__init__.py
@@@ -98,10 -114,24 +111,26 @@@ class Application(tornado.web.Applicati
                        (r"/", MainHandler),
                        (r"/[A-Za-z]{2}/?", MainHandler),
                        (r"/[A-Za-z]{2}/index", DownloadTorrentHandler),
 +                      (r"/a.*", TrackerAnnounceHandler),
 +                      (r"/scrape", TrackerScrapeHandler),
                ] + static_handlers)
  
+               # admin.ipfire.org
+               self.add_handlers(r"admin\.ipfire\.org", [
+                       (r"/", AdminIndexHandler),
+                       (r"/login", AuthLoginHandler),
+                       (r"/logout", AuthLogoutHandler),
+                       # Accounts
+                       (r"/accounts", AdminAccountsHandler),
+                       (r"/accounts/edit/([0-9]+)", AdminAccountsEditHandler),
+                       # Planet
+                       (r"/planet", AdminPlanetHandler),
+                       (r"/planet/compose", AdminPlanetComposeHandler),
+                       (r"/planet/edit/([0-9]+)", AdminPlanetEditHandler),
+                       # API
+                       (r"/api/planet/render", AdminApiPlanetRenderMarkupHandler)
+               ] + static_handlers)
+ 
                # ipfire.org
                self.add_handlers(r".*", [
                        (r".*", tornado.web.RedirectHandler, { "url" : "http://www.ipfire.org" })

diff --cc www/webapp/handlers.py
index 636e0a8be809d0496c8d2f1a83939f80cdcf83b1,71d8508810ce1b5165b42b2a8361273a7c80f755..1eb5b55be18b8080daa433f31b55073731b78fb5
--- 1/www/webapp/handlers.py
--- 2/www/webapp/handlers.py
+++ b/www/webapp/handlers.py
@@@ -21,10 -24,11 +24,12 @@@ from info import inf
  from mirrors import mirrors
  from news import news
  from releases import releases
 +from torrent import tracker, bencode, bdecode, decode_hex
  
  import builds
 -import translations
 +import menu
+ import cluster
+ import markdown
  #import uriel
  
  class BaseHandler(tornado.web.RequestHandler):
@@@ -290,93 -322,52 +304,145 @@@ class RSSHandler(BaseHandler)
                self.render("rss.xml", items=items, lang=lang)
  
  
++<<<<<<< HEAD
 +class TrackerBaseHandler(tornado.web.RequestHandler):
 +      def get_hexencoded_argument(self, name, all=False):
 +              try:
 +                      arguments = self.request.arguments[name]
 +              except KeyError:
 +                      return None
 +
 +              arguments_new = []
 +              for argument in arguments:
 +                      arguments_new.append(decode_hex(argument))
 +
 +              arguments = arguments_new
 +
 +              if all:
 +                      return arguments
 +
 +              return arguments[0]
 +
 +      def send_tracker_error(self, error_message):
 +              self.write(bencode({"failure reason" : error_message }))
 +              self.finish()
 +
 +class TrackerAnnounceHandler(TrackerBaseHandler):
 +      def get(self):
 +              self.set_header("Content-Type", "text/plain")
 +
 +              info_hash = self.get_hexencoded_argument("info_hash")
 +              if not info_hash:
 +                      self.send_tracker_error("Your client forgot to send your torrent's info_hash.")
 +                      return
 +
 +              peer = {
 +                      "id" : self.get_hexencoded_argument("peer_id"),
 +                      "ip" : self.get_argument("ip", None),
 +                      "port" : self.get_argument("port", None),
 +                      "downloaded" : self.get_argument("downloaded", 0),
 +                      "uploaded" : self.get_argument("uploaded", 0),
 +                      "left" : self.get_argument("left", 0),
 +              }
 +
 +              event = self.get_argument("event", "")
 +              if not event in ("started", "stopped", "completed", ""):
 +                      self.send_tracker_error("Got unknown event")
 +                      return
 +
 +              if peer["ip"]:
 +                      if peer["ip"].startswith("10.") or \
 +                              peer["ip"].startswith("172.") or \
 +                              peer["ip"].startswith("192.168."):
 +                              peer["ip"] = self.request.remote_ip
 +
 +              if peer["port"]:
 +                      peer["port"] = int(peer["port"])
 +
 +                      if peer["port"] < 0 or peer["port"] > 65535:
 +                              self.send_tracker_error("Port number is not in valid range")
 +                              return
 +
 +              eventhandlers = {
 +                      "started" : tracker.event_started,
 +                      "stopped" : tracker.event_stopped,
 +                      "completed" : tracker.event_completed,
 +              }
 +
 +              if event:
 +                      eventhandlers[event](info_hash, peer["id"])
 +
 +              tracker.update(hash=info_hash, **peer)
 +
 +              no_peer_id = self.get_argument("no_peer_id", False)
 +              numwant = self.get_argument("numwant", tracker.numwant)
 +
 +              self.write(bencode({
 +                      "tracker id" : tracker.id,
 +                      "interval" : tracker.interval,
 +                      "min interval" : tracker.min_interval,
 +                      "peers" : tracker.get_peers(info_hash, limit=numwant,
 +                              random=True, no_peer_id=no_peer_id),
 +                      "complete" : tracker.complete(info_hash),
 +                      "incomplete" : tracker.incomplete(info_hash),
 +              }))
 +              self.finish()
 +
 +
 +class TrackerScrapeHandler(TrackerBaseHandler):
 +      def get(self):
 +              info_hashes = self.get_hexencoded_argument("info_hash", all=True)
 +
 +              self.write(bencode(tracker.scrape(hashes=info_hashes)))
 +              self.finish()
++=======
+ 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)
++>>>>>>> planet