Merge lp:~bigkevmcd/offspring/non-scheduled-builds into lp:offspring

[Kevin McDermott]

This adds metrics for requested builds.

[lp:~bigkevmcd/offspring/non-scheduled-builds]

128. By Kevin McDermott on 2011-12-14

Merge forward.

129. By Kevin McDermott on 2011-12-14

Merge forward.

130. By Kevin McDermott on 2011-12-15

Merge forward.

131. By Kevin McDermott on 2011-12-16

Merge forward.

132. By Kevin McDermott on 2012-01-11

Merge forward.

133. By Kevin McDermott on 2012-01-12

Merge forward.

Unmerged revisions

=== modified file '.bzrignore'
--- .bzrignore	2011-11-18 14:33:37 +0000
+++ .bzrignore	2011-12-14 09:29:35 +0000
@@ -7,3 +7,4 @@
 ./config/launchpad.oauth
 ./builds/
 ./scripts/
+.coverage

=== added directory 'lib/offspring/web/queuemanager/management'
=== added file 'lib/offspring/web/queuemanager/management/__init__.py'
=== added directory 'lib/offspring/web/queuemanager/management/commands'
=== added file 'lib/offspring/web/queuemanager/management/commands/__init__.py'
=== added file 'lib/offspring/web/queuemanager/management/commands/build_metrics.py'
--- lib/offspring/web/queuemanager/management/commands/build_metrics.py	1970-01-01 00:00:00 +0000
+++ lib/offspring/web/queuemanager/management/commands/build_metrics.py	2011-12-14 09:29:35 +0000
@@ -0,0 +1,15 @@
+# Copyright 2010-2011 Canonical Ltd.
+
+from django.core.management.base import NoArgsCommand
+
+from offspring.web.queuemanager.metrics import get_build_result_metrics
+
+
+class Command(NoArgsCommand):
+    help = "Outputs some basic metrics."
+
+    def handle_noargs(self, **options):
+        metrics = get_build_result_metrics()
+
+        for item, value in metrics:
+            self.stdout.write("%s = %s\n" % (item, value))

=== added directory 'lib/offspring/web/queuemanager/management/commands/tests'
=== added file 'lib/offspring/web/queuemanager/management/commands/tests/__init__.py'
=== added file 'lib/offspring/web/queuemanager/management/commands/tests/test_build_metrics.py'
--- lib/offspring/web/queuemanager/management/commands/tests/test_build_metrics.py	1970-01-01 00:00:00 +0000
+++ lib/offspring/web/queuemanager/management/commands/tests/test_build_metrics.py	2011-12-14 09:29:35 +0000
@@ -0,0 +1,28 @@
+# Copyright 2010-2011 Canonical Ltd.
+from cStringIO import StringIO
+
+from mocker import MockerTestCase
+
+from offspring.web.queuemanager.metrics import get_build_result_metrics
+from offspring.web.queuemanager.management.commands.build_metrics import (
+    Command)
+
+
+class TestBuildResultMetricsCommand(MockerTestCase):
+
+    def test_calls_get_build_result_metrics(self):
+        """
+        When called, the build_metrics command should fetch the list of metrics
+        available for offspring.web.queuemanager and output them.
+        """
+        build_result_metrics_mock = self.mocker.replace(get_build_result_metrics)
+        build_result_metrics_mock()
+        self.mocker.result([("Description of value", 200)])
+        self.mocker.replay()
+
+        command = Command()
+        stdout = StringIO()
+        command.stdout = stdout
+        command.handle_noargs()
+
+        self.assertEqual("Description of value = 200\n", stdout.getvalue())

=== added file 'lib/offspring/web/queuemanager/metrics.py'
--- lib/offspring/web/queuemanager/metrics.py	1970-01-01 00:00:00 +0000
+++ lib/offspring/web/queuemanager/metrics.py	2011-12-14 09:29:35 +0000
@@ -0,0 +1,109 @@
+from datetime import datetime, timedelta
+
+from offspring.web.queuemanager.models import BuildResult
+from offspring.enums import ProjectBuildStates
+
+
+def get_average_time(query_params, columns, project=None, automated=None):
+
+    """
+    Return the average time between the two named columns.
+
+    The columns must be listed as the start_time and finish_time for the
+    metric.
+
+    If no Project is supplied, average the times across all projects.
+
+    query_params: A dictionary of Djanqo query filters.
+    columns: Columns to be queried, must be start_time, end_time.
+
+    project: A Project to filter BuildResults with, if none supplied, will use
+        all Projects
+    automated: If not None, filter BuildRequests using the requestor, if True,
+        only BuildRequests with no requestor will be used, otherwise
+        BuildRequests with the requestor field populated will be used.
+    """
+    # FIXME: This should really be done using PostgreSQL queries, but the tests
+    # don't run using PostgreSQL...
+    def delta_to_minutes(delta):
+        """
+        Return the total amount of time represented by a timedelta.
+        """
+        return ((delta.microseconds + (delta.seconds + delta.days
+                                       * 24 * 3600)
+                * 10 ** 6) / 10 ** 6)
+    if project is not None:
+        query_params["project"] = project
+
+    if automated is not None:
+        query_params["requestor__isnull"] = automated
+    build_results = BuildResult.objects.filter(**query_params)
+    time_stamps = build_results.values_list(*columns)
+    if not time_stamps:
+        return 0.0
+    times = [delta_to_minutes(end_time - start_time)
+             for (start_time, end_time) in time_stamps]
+    return float(sum(times)) / len(time_stamps)
+
+
+def get_average_build_time(project=None, automated=None, period=None):
+    """
+    Return the average time taken between BuildResult.started_at and
+    BuildResult.finished_at in seconds for all BuildResults associated with the
+    provided Project.
+
+    period: A tuple of datetime objects (start_time, end_time)
+
+    See get_average_time for the project and automated parameters.
+    """
+    query_params = {"finished_at__isnull": False,
+                    "result__exact": ProjectBuildStates.SUCCESS}
+    if period is not None:
+        query_params["finished_at__range"] = period
+    return get_average_time(query_params, ("started_at", "finished_at"),
+                            project=project, automated=automated)
+
+
+def get_average_queue_time(project=None, automated=None, period=None):
+    """
+    Return the average time taken between BuildResult.requested_at and
+    BuildResult.dispatched_at in seconds for all BuildResults associated with the
+    provided Project.
+
+    period: A tuple of datetime objects (start_time, end_time)
+
+    See get_average_time for the project and automated parameters.
+    """
+    query_params = {}
+    if period is not None:
+        query_params["dispatched_at__range"] = period
+    return get_average_time(query_params, ("requested_at", "dispatched_at"),
+                            project=project, automated=automated)
+
+
+def get_build_result_metrics():
+    """
+    Return some simple metrics, in a format suitable for iterating over and
+    displaying in a command-line tool.
+    """
+    results = []
+    start_date = datetime.utcnow()
+
+    seven_days = (start_date - timedelta(days=7), start_date)
+    thirty_days = (start_date - timedelta(days=30), start_date)
+    ninety_days = (start_date - timedelta(days=90), start_date)
+
+    build_types = [("scheduled", True), ("requested", False)]
+    build_periods = [("7 days", seven_days), ("30 days", thirty_days),
+                     ("90 days", ninety_days)]
+
+    for build_type, automated in build_types:
+        for function, metric_type in [(get_average_build_time, "build"),
+                                      (get_average_queue_time, "queue")]:
+            for text, period in build_periods:
+                metric = "Average %s %s time (%s)" % (build_type, metric_type,
+                                                      text)
+                results.append((metric,
+                                function(period=period, automated=automated)))
+
+    return results

=== modified file 'lib/offspring/web/queuemanager/models.py'
--- lib/offspring/web/queuemanager/models.py	2011-12-08 16:27:50 +0000
+++ lib/offspring/web/queuemanager/models.py	2011-12-14 09:29:35 +0000
@@ -1,15 +1,7 @@
 # Copyright 2010 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
-__all__ = ["Project", "ProjectGroup", "Lexbuilder", "BuildRequest", \
-    "BuildResult", "DailyBuildOrder", "LaunchpadProject", "LaunchpadProjectMilestone", \
-    "ProjectNotificationSubscription", 'Release']
-
-from datetime import (
-    date,
-    datetime,
-    timedelta
-)
+from datetime import date, datetime, timedelta
 import math
 
 from django.conf import settings
@@ -25,6 +17,10 @@
     AccessManager)
 from offspring.enums import ProjectBuildStates
 
+__all__ = ["Project", "ProjectGroup", "Lexbuilder", "BuildRequest",
+           "BuildResult", "DailyBuildOrder", "LaunchpadProject",
+           "LaunchpadProjectMilestone", "ProjectNotificationSubscription",
+           "Release"]
 
 ARCH_CHOICES = (
     (u'i386', u'i386'),
@@ -82,7 +78,7 @@
             project_group=self)
 
     @property
-    def builder(self): 
+    def builder(self):
         return None
 
     @property
@@ -386,7 +382,7 @@
     requestor = models.ForeignKey(User, db_column="requestor_id", blank=True, null=True, editable=False)
     reason = models.CharField('request reason', blank=True, null=True, max_length=200, editable=False)
     requested_at = models.DateTimeField('date created', auto_now_add=True, blank=True, null=True, editable=False)
-    dispatched_at = models.DateTimeField('date dispatched', editable=False, null=True, blank=True) 
+    dispatched_at = models.DateTimeField('date dispatched', editable=False, null=True, blank=True)
     notes = models.CharField(max_length=200, null=True, blank=True)
 
     access_relation = 'project'

=== modified file 'lib/offspring/web/queuemanager/tests/factory.py'
--- lib/offspring/web/queuemanager/tests/factory.py	2011-12-02 13:55:56 +0000
+++ lib/offspring/web/queuemanager/tests/factory.py	2011-12-14 09:29:35 +0000
@@ -59,7 +59,6 @@
             project_group=project_group)
         for group in access_groups:
             project.access_groups.add(group)
-        project.save()
         return project
 
     def make_project_group(self, name=None, title=None):
@@ -73,7 +72,8 @@
             title = self.get_unique_string()
         return ProjectGroup.objects.create(name=name, title=title)
 
-    def make_build_result(self, project=None, name=None, result=None):
+    def make_build_result(self, project=None, name=None, result=None,
+                          requestor=None):
         """
         Create a BuildResult with the given project or a newly created one if
         none is given.
@@ -83,7 +83,7 @@
         if project is None:
             project = self.make_project()
         return BuildResult.objects.create(
-            project=project, name=name, result=result)
+            project=project, name=name, result=result, requestor=requestor)
 
     def make_release(self, build=None, name=None, creator=None):
         """

=== added file 'lib/offspring/web/queuemanager/tests/test_metrics.py'
--- lib/offspring/web/queuemanager/tests/test_metrics.py	1970-01-01 00:00:00 +0000
+++ lib/offspring/web/queuemanager/tests/test_metrics.py	2011-12-14 09:29:35 +0000
@@ -0,0 +1,316 @@
+from datetime import datetime, timedelta, date, time
+
+from django.test import TestCase
+
+from offspring.enums import ProjectBuildStates
+from offspring.web.queuemanager.models import User
+from offspring.web.queuemanager.metrics import (
+    get_average_build_time, get_average_queue_time,
+    get_build_result_metrics)
+
+from offspring.web.queuemanager.tests.factory import factory
+
+
+def create_build_results_with_durations(project, durations,
+                                        requestor=None,
+                                        build_date=date.today(),
+                                        result=ProjectBuildStates.SUCCESS):
+    """
+    Create BuildResults with durations specified.
+
+    project: The Project to associate the BuildResults with.
+    durations: A sequence of time periods in minutes.
+    """
+    finished_at = datetime.combine(build_date, time())
+    for minutes in durations:
+        build_result = factory.make_build_result(
+            project=project, requestor=requestor, result=result)
+        build_result.finished_at = finished_at
+        build_result.started_at = finished_at - timedelta(minutes=minutes)
+        build_result.save()
+
+
+def create_build_results_with_queue_times(project, queue_times, requestor=None,
+                                          build_date=date.today()):
+    """
+    Create BuildResults with queue times specified.
+
+    project: The Project to associate the BuildResults with.
+    queue_times: A sequence of time periods in minutes.
+    """
+    dispatched_at = datetime.combine(build_date, time())
+    for minutes in queue_times:
+        build_result = factory.make_build_result(
+            project=project, requestor=requestor)
+        build_result.dispatched_at = dispatched_at
+        build_result.requested_at = dispatched_at - timedelta(minutes=minutes)
+        build_result.save()
+
+
+class BuildResultMetricsTests(TestCase):
+
+    def setUp(self):
+        self.project = factory.make_project()
+
+    def test_get_average_build_time_single_build(self):
+        """
+        get_average_build_time should return the average time taken to build a
+        project.
+        """
+        build_result = factory.make_build_result(
+            project=self.project, result=ProjectBuildStates.SUCCESS)
+        finished_at = datetime.now()
+        build_result.finished_at = finished_at
+        build_result.started_at = finished_at - timedelta(minutes=10)
+        build_result.save()
+        self.assertEqual(10*60, get_average_build_time(self.project))
+
+    def test_get_average_build_time_only_includes_completed_builds(self):
+        """
+        get_average_build_time should only include builds that are in a
+        completed state.
+        """
+        create_build_results_with_durations(
+            self.project, [10, 20], result=ProjectBuildStates.UNKNOWN)
+        create_build_results_with_durations(
+            self.project, [10, 20], result=ProjectBuildStates.FAILED)
+        create_build_results_with_durations(
+            self.project, [10, 20], result=ProjectBuildStates.PENDING)
+
+        self.assertEqual(0.0, get_average_build_time(self.project))
+
+    def test_get_average_build_time_no_builds(self):
+        """
+        If there are no builds, we should get an average of 0.0.
+        """
+        self.assertEqual(0.0, get_average_build_time(self.project))
+
+    def test_get_average_build_time_unfinished_build(self):
+        """
+        If a build has started, but not yet finished, this we should get 0.0
+        for the average for this entry.
+        """
+        build_result = factory.make_build_result(project=self.project)
+        build_result.started_at = datetime.now() - timedelta(minutes=20)
+        build_result.save()
+        self.assertEqual(0.0, get_average_build_time(self.project))
+
+    def test_get_average_build_time_multiple_builds(self):
+        """
+        The time for each BuildResult should be averaged together.
+        """
+        create_build_results_with_durations(self.project, [10, 20])
+        self.assertEqual(15*60, get_average_build_time(self.project))
+
+    def test_get_average_build_time_multiple_builds_ignores_unfinished(self):
+        """
+        Any unfinished BuildResults should be discounted from the calculation.
+        """
+        create_build_results_with_durations(self.project, [10, 20])
+
+        # Create an additional unfinished build.
+        build_result = factory.make_build_result(project=self.project)
+        build_result.started_at = datetime.now() - timedelta(minutes=20)
+        build_result.save()
+
+        self.assertEqual(15*60, get_average_build_time(self.project))
+
+    def test_get_average_build_time_ignores_other_projects(self):
+        """
+        BuildResults associated with other projects should not be included in
+        the calculation.
+        """
+        create_build_results_with_durations(self.project, [10, 20])
+        create_build_results_with_durations(factory.make_project(), [50, 100])
+        self.assertEqual(15*60, get_average_build_time(self.project))
+
+    def test_get_average_build_time_no_project(self):
+        """
+        If get_average_build_time is not supplied with a Project, then it
+        should calculate the average across all projects.
+        """
+        create_build_results_with_durations(self.project, [10, 20])
+        create_build_results_with_durations(
+            factory.make_project(), [50, 100])
+        # 10 + 20 + 50 + 100 = 180 / 4 = 45 minutes...
+        self.assertEqual(45*60, get_average_build_time())
+
+    def test_get_average_build_time_with_automated_flag(self):
+        """
+        Calling get_average_build_time with automated=True should filter the
+        results to only include automated builds, which are defined as builds
+        with a requestor.
+        """
+        user = User.objects.create_user(u"Testing", u"[e-mail]",
+                                        u"testing")
+        create_build_results_with_durations(self.project, [10, 20])
+        create_build_results_with_durations(
+            factory.make_project(), [50, 100], requestor=user)
+
+    def test_get_average_build_time_filters_by_date(self):
+        """
+        It should be possible to restrict the date queried to a specific time
+        frame.
+
+        Any BuildResults finishing outwith the time period specified shouldn't
+        be included.
+        """
+        build_date = datetime.utcnow() - timedelta(days=30)
+        create_build_results_with_durations(
+            self.project, [10, 20], build_date=build_date)
+
+        # From the day after we create our builds 'til today.
+        time_period = (build_date + timedelta(days=1), datetime.utcnow())
+        self.assertEqual(0.0,
+                         get_average_build_time(period=time_period))
+
+    def test_get_average_build_time_includes_by_date(self):
+        """
+        It should be possible to restrict the date queried to a specific time
+        frame, specifying a period should only include those BuildResults
+        within that period.
+        """
+        build_date = datetime.utcnow() - timedelta(days=30)
+        create_build_results_with_durations(
+            self.project, [10, 20], build_date=build_date)
+
+        create_build_results_with_durations(
+            factory.make_project(), [50, 100],
+            build_date=build_date + timedelta(days=2))
+
+        # From the day after we create our builds 'til today.
+        time_period = (build_date + timedelta(days=1), datetime.utcnow())
+        self.assertEqual(75*60, get_average_build_time(period=time_period))
+
+    def test_get_average_build_time_filters_by_date_and_automated(self):
+        """
+        It should be possible to restrict the date queried to a specific time
+        frame, specifying a period and the automated flag should filter the
+        applicable BuildResults.
+        """
+        user = User.objects.create_user(u"Testing", u"[e-mail]",
+                                        u"testing")
+        build_date = datetime.utcnow() - timedelta(days=30)
+        create_build_results_with_durations(
+            self.project, [10, 20], build_date=build_date,
+            requestor=user)
+        create_build_results_with_durations(
+            factory.make_project(), [40, 40],
+            build_date=build_date + timedelta(days=2))
+
+        # From the day after we create our builds 'til today.
+        time_period = (build_date + timedelta(days=1), datetime.utcnow())
+        self.assertEqual(40*60,
+                         get_average_build_time(period=time_period,
+                                                automated=True))
+
+
+class QueueTimeMetricsTests(TestCase):
+
+    def setUp(self):
+        self.project = factory.make_project()
+
+    def test_average_queue_time_single_build(self):
+        """
+        get_average_queue_time should return the average time a build waits
+        before being dispatched.
+        """
+        build_result = factory.make_build_result(project=self.project)
+        dispatched_at = datetime.now()
+        build_result.dispatched_at = dispatched_at
+        build_result.requested_at = dispatched_at - timedelta(minutes=30)
+        build_result.save()
+        self.assertEqual(30*60, get_average_queue_time(self.project))
+
+    def test_average_queue_time_no_builds(self):
+        """
+        If there are no builds, we should get an average of 0.0.
+        """
+        self.assertEqual(0.0*60, get_average_queue_time(self.project))
+
+    def test_average_queue_time_includes_by_date(self):
+        """
+        It should be possible to restrict the date queried to a specific time
+        frame, specifying a period should only include those BuildResults
+        within that period.
+        """
+        build_date = datetime.utcnow() - timedelta(days=30)
+        create_build_results_with_queue_times(
+            self.project, [10, 20], build_date=build_date)
+
+        create_build_results_with_queue_times(
+            factory.make_project(), [50, 100],
+            build_date=build_date + timedelta(days=2))
+
+        # From the day after we create our builds 'til today.
+        time_period = (build_date + timedelta(days=1), datetime.utcnow())
+        self.assertEqual(75*60,
+                         get_average_queue_time(period=time_period))
+
+
+class GetBuildResultsTests(TestCase):
+
+    def setUp(self):
+        self.project = factory.make_project()
+
+    def test_get_build_result_metrics(self):
+        """
+        get_build_result_metrics should return a list of tuples with the metric
+        being measured, and the time in minutes.
+        """
+        def create_test_data(user=None, offset=0):
+            start_date = datetime.utcnow()
+            last_week = start_date - timedelta(days=8)
+            last_month = start_date - timedelta(days=35)
+            # Two this week, average = 10 + 20/2 = 15
+            create_build_results_with_durations(
+                self.project, [10 + offset, 20], build_date=start_date,
+                requestor=user)
+
+            # Two this week, average = 30 + 18/2 = 24.0
+            create_build_results_with_queue_times(
+                self.project, [30 + offset, 18], build_date=start_date,
+                requestor=user)
+
+            # Two last week, 10 + 10 + 10 + 20/4 = 12.5
+            create_build_results_with_durations(
+                self.project, [10 + offset, 10], build_date=last_week,
+                requestor=user)
+
+            # Two last week, average = 30 + 18 + 14  11/4 = 73
+            create_build_results_with_queue_times(
+                self.project, [14+offset, 11], build_date=last_week,
+                requestor=user)
+
+            # Two last month, 10 + 10 + 10 + 20 + 30 + 40/6 = 20
+            create_build_results_with_durations(
+                self.project, [30+offset, 40], build_date=last_month,
+                requestor=user)
+
+            # Two last month, average = 30 + 18 + 14  11 + 30 + 20/6 = 82
+            create_build_results_with_queue_times(
+                self.project, [30+offset, 20], build_date=last_month,
+                requestor=user)
+
+        # Scheduled builds
+        # Requested builds
+
+        create_test_data()
+        user = User.objects.create_user(u"Testing", u"[e-mail]",
+                                        u"testing")
+        create_test_data(user=user, offset=10)
+
+        self.assertEqual(
+            [("Average scheduled build time (7 days)", 15.0*60),
+             ("Average scheduled build time (30 days)", 12.5*60),
+             ("Average scheduled build time (90 days)", 20.0*60),
+             ("Average scheduled queue time (7 days)", 24.0*60),
+             ("Average scheduled queue time (30 days)", 18.25*60),
+             ("Average scheduled queue time (90 days)", 20.5*60),
+             ("Average requested build time (7 days)", 20.0*60),
+             ("Average requested build time (30 days)", 17.5*60),
+             ("Average requested build time (90 days)", 25.0*60),
+             ("Average requested queue time (7 days)", 29.0*60),
+             ("Average requested queue time (30 days)", 23.25*60),
+             ("Average requested queue time (90 days)", 25.5*60)],
+            get_build_result_metrics())