Merge branch 'archweb' into archweb-generic2

Conflicts:
	devel/views.py
	feeds.py
	public/views.py
	settings.py
	sitestatic/archweb.js
	templates/base.html
	templates/devel/profile.html
	templates/mirrors/status.html
	templates/news/view.html
	templates/packages/flaghelp.html
	templates/packages/opensearch.xml
	templates/public/download.html
	templates/public/feeds.html
	templates/public/index.html
	templates/registration/login.html
	templates/releng/results.html
	templates/todolists/public_list.html

1 files changed, 53 insertions, 25 deletions

diff --git a/mirrors/utils.py b/mirrors/utils.py
index 32fa3587..3ab176b3 100644
--- a/mirrors/utils.py
+++ b/mirrors/utils.py
@@ -1,13 +1,14 @@
 from datetime import timedelta
 
 from django.db.models import Avg, Count, Max, Min, StdDev
+from django.utils.timezone import now
 from django_countries.fields import Country
 
-from main.utils import cache_function, utc_now
+from main.utils import cache_function, database_vendor
 from .models import MirrorLog, MirrorProtocol, MirrorUrl
 
 
-default_cutoff = timedelta(hours=24)
+DEFAULT_CUTOFF = timedelta(hours=24)
 
 def annotate_url(url, delays):
     '''Given a MirrorURL object, add a few more attributes to it regarding
@@ -30,36 +31,57 @@ def annotate_url(url, delays):
 
 
 @cache_function(123)
-def get_mirror_statuses(cutoff=default_cutoff):
-    cutoff_time = utc_now() - cutoff
-    protocols = list(MirrorProtocol.objects.filter(is_download=True))
-    # I swear, this actually has decent performance...
-    urls = MirrorUrl.objects.select_related('mirror', 'protocol').filter(
+def get_mirror_statuses(cutoff=DEFAULT_CUTOFF, mirror_ids=None):
+    cutoff_time = now() - cutoff
+
+    valid_urls = MirrorUrl.objects.filter(
             mirror__active=True, mirror__public=True,
-            protocol__in=protocols,
-            logs__check_time__gte=cutoff_time).annotate(
+            logs__check_time__gte=cutoff_time).distinct()
+
+    if mirror_ids:
+        valid_urls = valid_urls.filter(mirror_id__in=mirror_ids)
+
+    url_data = MirrorUrl.objects.values('id', 'mirror_id').filter(
+            id__in=valid_urls, logs__check_time__gte=cutoff_time).annotate(
             check_count=Count('logs'),
             success_count=Count('logs__duration'),
             last_sync=Max('logs__last_sync'),
             last_check=Max('logs__check_time'),
-            duration_avg=Avg('logs__duration'),
-            duration_stddev=StdDev('logs__duration'))
+            duration_avg=Avg('logs__duration'))
+
+    vendor = database_vendor(MirrorUrl)
+    if vendor != 'sqlite':
+        url_data = url_data.annotate(duration_stddev=StdDev('logs__duration'))
+
+    urls = MirrorUrl.objects.select_related('mirror', 'protocol').filter(
+            id__in=valid_urls).order_by('mirror__id', 'url')
 
     # The Django ORM makes it really hard to get actual average delay in the
     # above query, so run a seperate query for it and we will process the
     # results here.
-    times = MirrorLog.objects.filter(is_success=True, last_sync__isnull=False,
+    times = MirrorLog.objects.values_list(
+            'url_id', 'check_time', 'last_sync').filter(
+            is_success=True, last_sync__isnull=False,
             check_time__gte=cutoff_time)
+    if mirror_ids:
+        times = times.filter(url__mirror_id__in=mirror_ids)
     delays = {}
-    for log in times:
-        delay = log.check_time - log.last_sync
-        delays.setdefault(log.url_id, []).append(delay)
+    for url_id, check_time, last_sync in times:
+        delay = check_time - last_sync
+        delays.setdefault(url_id, []).append(delay)
 
     if urls:
+        url_data = dict((item['id'], item) for item in url_data)
+        for url in urls:
+            for k, v in url_data.get(url.id, {}).items():
+                if k not in ('id', 'mirror_id'):
+                    setattr(url, k, v)
         last_check = max([u.last_check for u in urls])
         num_checks = max([u.check_count for u in urls])
-        check_info = MirrorLog.objects.filter(
-                check_time__gte=cutoff_time).aggregate(
+        check_info = MirrorLog.objects.filter(check_time__gte=cutoff_time)
+        if mirror_ids:
+            check_info = check_info.filter(url__mirror_id__in=mirror_ids)
+        check_info = check_info.aggregate(
                 mn=Min('check_time'), mx=Max('check_time'))
         if num_checks > 1:
             check_frequency = (check_info['mx'] - check_info['mn']) \
@@ -72,6 +94,9 @@ def get_mirror_statuses(cutoff=default_cutoff):
         check_frequency = None
 
     for url in urls:
+        # fake the standard deviation for local testing setups
+        if vendor == 'sqlite':
+            setattr(url, 'duration_stddev', 0.0)
         annotate_url(url, delays)
 
     return {
@@ -84,28 +109,31 @@ def get_mirror_statuses(cutoff=default_cutoff):
 
 
 @cache_function(117)
-def get_mirror_errors(cutoff=default_cutoff):
-    cutoff_time = utc_now() - cutoff
+def get_mirror_errors(cutoff=DEFAULT_CUTOFF, mirror_ids=None):
+    cutoff_time = now() - cutoff
     errors = MirrorLog.objects.filter(
             is_success=False, check_time__gte=cutoff_time,
             url__mirror__active=True, url__mirror__public=True).values(
             'url__url', 'url__country', 'url__protocol__protocol',
-            'url__mirror__country', 'error').annotate(
+            'url__mirror__tier', 'error').annotate(
             error_count=Count('error'), last_occurred=Max('check_time')
             ).order_by('-last_occurred', '-error_count')
+
+    if mirror_ids:
+        urls = urls.filter(mirror_id__in=mirror_ids)
+
     errors = list(errors)
     for err in errors:
-        ctry_code = err['url__country'] or err['url__mirror__country']
-        err['country'] = Country(ctry_code)
+        err['country'] = Country(err['url__country'])
     return errors
 
 
 @cache_function(295)
-def get_mirror_url_for_download(cutoff=default_cutoff):
+def get_mirror_url_for_download(cutoff=DEFAULT_CUTOFF):
     '''Find a good mirror URL to use for package downloads. If we have mirror
     status data available, it is used to determine a good choice by looking at
     the last batch of status rows.'''
-    cutoff_time = utc_now() - cutoff
+    cutoff_time = now() - cutoff
     status_data = MirrorLog.objects.filter(
             check_time__gte=cutoff_time).aggregate(
             Max('check_time'), Max('last_sync'))
@@ -123,7 +151,7 @@ def get_mirror_url_for_download(cutoff=default_cutoff):
     mirror_urls = MirrorUrl.objects.filter(
             mirror__public=True, mirror__active=True, protocol__default=True)
     # look first for a country-agnostic URL, then fall back to any HTTP URL
-    filtered_urls = mirror_urls.filter(mirror__country='')[:1]
+    filtered_urls = mirror_urls.filter(country='')[:1]
     if not filtered_urls:
         filtered_urls = mirror_urls[:1]
     if not filtered_urls: