import urllib
import urlparse
+import database
import tracker
+from misc import Object
-from databases import Databases
-from misc import Singleton
-from settings import Settings
+class File(Object):
+ def __init__(self, backend, release, id, data=None):
+ Object.__init__(self, backend)
-class File(object):
- def __init__(self, release, id):
self.id = id
self._release = release
# get all data from database
- self.__data = None
+ self.__data = data
- @property
- def db(self):
- return Databases().webapp
-
- @property
- def tracker(self):
- return self.release.tracker
+ def __cmp__(self, other):
+ return cmp(self.prio, other.prio)
@property
def data(self):
return "torrent"
elif "xen" in filename:
+ if "downloader" in filename:
+ return "xen-downloader"
+
return "xen"
elif "sources" in filename:
@property
def url(self):
- baseurl = Settings().get("download_url")
+ baseurl = self.settings.get("download_url", "http://downloads.ipfire.org")
return urlparse.urljoin(baseurl, self.filename)
"iso" : _("Installable CD image"),
"torrent" : _("Torrent file"),
"flash" : _("Flash image"),
- "alix" : _("Alix image"),
+ "alix" : _("Flash image for devices with serial console"),
"usbfdd" : _("USB FDD Image"),
"usbhdd" : _("USB HDD Image"),
"xen" : _("Pregenerated Xen image"),
+ "xen-downloader": _("Xen-Image Generator"),
}
try:
"armv5tel" : 40,
"armv5tel-scon" : 41,
"xen" : 50,
+ "xen-downloader": 51,
}
try:
"usbfdd" : _("Install IPFire from a floppy-formated USB key."),
"usbhdd" : _("If the floppy image doesn't work, use this image instead."),
"xen" : _("A ready-to-run image for Xen."),
+ "xen-downloader": _("Generator for creating a Xen image."),
}
try:
if not self.torrent_hash:
return
- return self.tracker.get_seeds(self.torrent_hash)
+ return self.backend.tracker.complete(self.torrent_hash)
@property
def peers(self):
if not self.torrent_hash:
return
- return self.tracker.get_peers(self.torrent_hash)
-
- @property
- def completed(self):
- if not self.torrent_hash:
- return
-
- return self.tracker.complete(self.torrent_hash)
+ return self.backend.tracker.incomplete(self.torrent_hash)
-class Release(object):
- @property
- def db(self):
- return Releases().db
-
- @property
- def tracker(self):
- return tracker.Tracker()
-
- def __init__(self, id):
+class Release(Object):
+ def __init__(self, backend, id, data=None):
+ Object.__init__(self, backend)
self.id = id
# get all data from database
- self.__data = \
- self.db.get("SELECT * FROM releases WHERE id = %s", self.id)
+ self.__data = data or self.db.get("SELECT * FROM releases WHERE id = %s", self.id)
assert self.__data
self.__files = []
def __repr__(self):
return "<%s %s>" % (self.__class__.__name__, self.name)
+ def __cmp__(self, other):
+ return cmp(self.id, other.id)
+
@property
def files(self):
if not self.__files:
- files = self.db.query("SELECT id, filename FROM files WHERE releases = %s \
- AND loadable = 'Y' AND NOT filename LIKE '%%.torrent'", self.id)
+ files = self.db.query("SELECT * FROM files WHERE releases = %s \
+ AND NOT filename LIKE '%%.torrent'", self.id)
- self.__files = [File(self, f.id) for f in files]
- self.__files.sort(lambda a, b: cmp(a.prio, b.prio))
+ self.__files = [File(self.backend, self, f.id, f) for f in files]
+ self.__files.sort()
return self.__files
@property
def name(self):
- return self.__data.get("name")
+ return self.__data.name
+
+ @property
+ def sname(self):
+ return self.__data.sname
@property
def stable(self):
- return self.__data.get("stable") == "Y"
+ return self.__data.stable
@property
def published(self):
- return self.__data.get("published") == "Y"
+ return self.__data.published
- @property
- def date(self):
- return self.__data.get("date")
+ date = published
@property
def path(self):
- return self.__data.get("path")
+ return self.__data.path
def get_file(self, type):
for file in self.files:
if filename.endswith(".md5"):
continue
+ logging.info("Hashing %s..." % filename)
filehash = self.__file_hash(filename)
filesize = os.path.getsize(filename)
if f:
f.close()
+ def supports_arch(self, arch):
+ # Currently there is nothing else than i586 supported
+ if arch == "i586":
+ return True
+
+ return False
+
+ def supports_platform(self, platform):
+ # Currently there is nothing else than pcbios supported
+ if platform == "pcbios":
+ return True
+
+ return False
+
+ def is_netboot_capable(self):
+ return self.path and "ipfire-2.x" in self.path
+
+ def netboot_kernel_url(self, arch, platform):
+ assert self.supports_arch(arch)
+ assert self.supports_platform(platform)
+
+ return "http://downloads.ipfire.org/%s/images/vmlinuz" % self.path
-class Releases(object):
- __metaclass__ = Singleton
+ def netboot_initrd_url(self, arch, platform):
+ assert self.supports_arch(arch)
+ assert self.supports_platform(platform)
+
+ return "http://downloads.ipfire.org/%s/images/instroot" % self.path
+
+ def netboot_args(self, arch, platform):
+ return ""
+
+ @property
+ def news_id(self):
+ return self.__data.news_id
@property
- def db(self):
- return Databases().webapp
+ def news(self):
+ if not hasattr(self, "_news"):
+ self._news = self.backend.news.get(self.news_id)
+
+ return self._news
- def list(self):
- return [Release(r.id) for r in self.db.query("SELECT id FROM releases ORDER BY date DESC")]
+class Releases(Object):
def get_by_id(self, id):
- id = int(id)
- if id in [r.id for r in self.db.query("SELECT id FROM releases")]:
- return Release(id)
-
- def get_latest(self, stable=1):
- query = "SELECT id FROM releases WHERE published='Y' AND"
- if stable:
- query += " stable='Y'"
- else:
- query += " stable='N'"
+ ret = self.db.get("SELECT * FROM releases WHERE id = %s", id)
+
+ if ret:
+ return Release(self.backend, ret.id, data=ret)
+
+ def get_by_sname(self, sname):
+ ret = self.db.get("SELECT * FROM releases WHERE sname = %s", sname)
+
+ if ret:
+ return Release(self.backend, ret.id, data=ret)
+
+ def get_by_news_id(self, news_id):
+ ret = self.db.get("SELECT * FROM releases WHERE news_id = %s", news_id)
+
+ if ret:
+ return Release(self.backend, ret.id, data=ret)
+
+ def get_latest(self, stable=True):
+ ret = self.db.get("SELECT * FROM releases WHERE published IS NOT NULL AND published <= NOW() \
+ AND stable = %s ORDER BY published DESC LIMIT 1", stable)
- query += " ORDER BY date DESC LIMIT 1"
+ if ret:
+ return Release(self.backend, ret.id, data=ret)
- release = self.db.get(query)
- if release:
- return Release(release.id)
+ def get_latest_unstable(self):
+ ret = self.db.get("SELECT * FROM releases r1 \
+ WHERE r1.published IS NOT NULL AND r1.published <= NOW() \
+ AND stable = %s AND NOT EXISTS ( \
+ SELECT * FROM releases r2 WHERE r2.stable = %s AND \
+ r2.published IS NOT NULL AND r2.published >= r1.published \
+ ) ORDER BY r1.published DESC LIMIT 1", False, True)
+
+ if ret:
+ return Release(self.backend, ret.id, data=ret)
def get_stable(self):
- releases = self.db.query("""SELECT id FROM releases
- WHERE published='Y' AND stable='Y'
- ORDER BY date DESC""")
+ query = self.db.query("SELECT * FROM releases \
+ WHERE published IS NOT NULL AND published <= NOW() AND stable = TRUE \
+ ORDER BY published DESC")
+
+ releases = []
+ for row in query:
+ release = Release(self.backend, row.id, data=row)
+ releases.append(release)
- return [Release(r.id) for r in releases]
+ return releases
def get_unstable(self):
- releases = self.db.query("""SELECT id FROM releases
- WHERE published='Y' AND stable='N'
- ORDER BY date DESC""")
+ query = self.db.query("SELECT * FROM releases \
+ WHERE published IS NOT NULL AND published <= NOW() AND stable = FALSE \
+ ORDER BY published DESC")
+
+ releases = []
+ for row in query:
+ release = Release(self.backend, row.id, data=row)
+ releases.append(release)
- return [Release(r.id) for r in releases]
+ return releases
def get_all(self):
- releases = self.db.query("""SELECT id FROM releases
- WHERE published='Y' ORDER BY date DESC""")
+ query = self.db.query("SELECT * FROM releases \
+ WHERE published IS NOT NULL AND published <= NOW() \
+ ORDER BY published DESC")
+
+ releases = []
+ for row in query:
+ release = Release(self.backend, row.id, data=row)
+ releases.append(release)
+
+ return releases
+
+ def _get_all(self):
+ query = self.db.query("SELECT * FROM releases ORDER BY published DESC")
- return [Release(r.id) for r in releases]
+ releases = []
+ for row in query:
+ release = Release(self.backend, row.id, data=row)
+ releases.append(release)
+
+ return releases
def get_file_for_torrent_hash(self, torrent_hash):
file = self.db.get("SELECT id, releases FROM files WHERE torrent_hash = %s LIMIT 1",
if not file:
return
- release = Release(file.releases)
- file = File(release, file.id)
+ release = Release(self.backend, file.releases)
+ file = File(self.backend, release, file.id)
return file
-
-
-if __name__ == "__main__":
- r = Releases()
-
- for release in r.get_all():
- print release.name
-
- print r.get_latest()