Split out result and report data to separate module

tobami · tobami · commit d220fb1bdaa2 · 2016-03-28T12:21:28.000+02:00
diff --git a/codespeed/domain.py b/codespeed/domain.py
@@ -1,17 +1,10 @@
 # -*- coding: utf-8 -*-
 from __future__ import absolute_import
 
-import logging
-from datetime import datetime
-from django.core.exceptions import ValidationError
 from django.conf import settings
 
-from codespeed.models import (Environment, Executable, Revision,
-                              Project, Branch, Benchmark,
+from codespeed.models import (Executable, Revision, Project, Branch, Benchmark,
                               Result, Report)
-from codespeed import commits
-
-logger = logging.getLogger(__name__)
 
 
 def get_default_environment(enviros, data, multi=False):
@@ -155,140 +148,3 @@ def getcomparisonexes():
         all_executables[proj] = executables
         exekeys += executablekeys
     return all_executables, exekeys
-
-
-def validate_result(item):
-    """
-    Validates that a result dictionary has all needed parameters
-
-    It returns a tuple
-        Environment, False  when no errors where found
-        Errormessage, True  when there is an error
-    """
-    mandatory_data = [
-        'commitid',
-        'branch',
-        'project',
-        'executable',
-        'benchmark',
-        'environment',
-        'result_value',
-    ]
-
-    error = True
-    for key in mandatory_data:
-        if key not in item:
-            return 'Key "' + key + '" missing from request', error
-        elif key in item and item[key] == "":
-            return 'Value for key "' + key + '" empty in request', error
-
-    # Check that the Environment exists
-    try:
-        e = Environment.objects.get(name=item['environment'])
-        error = False
-        return e, error
-    except Environment.DoesNotExist:
-        return "Environment %(environment)s not found" % item, error
-
-
-def create_report_if_enough_data(rev, exe, e):
-    """Triggers Report creation when there are enough results"""
-    last_revs = Revision.objects.filter(
-        branch=rev.branch
-    ).order_by('-date')[:2]
-    if len(last_revs) > 1:
-        current_results = rev.results.filter(executable=exe, environment=e)
-        last_results = last_revs[1].results.filter(
-            executable=exe, environment=e)
-        # If there is are at least as many results as in the last revision,
-        # create new report
-        if len(current_results) >= len(last_results):
-            logger.debug("create_report_if_enough_data: About to create new report")
-            report, created = Report.objects.get_or_create(
-                executable=exe, environment=e, revision=rev
-            )
-            report.full_clean()
-            report.save()
-            logger.debug("create_report_if_enough_data: Created new report.")
-
-
-def save_result(data):
-    res, error = validate_result(data)
-    if error:
-        return res, True
-    else:
-        assert(isinstance(res, Environment))
-        env = res
-
-    p, created = Project.objects.get_or_create(name=data["project"])
-    branch, created = Branch.objects.get_or_create(name=data["branch"],
-                                                   project=p)
-    b, created = Benchmark.objects.get_or_create(name=data["benchmark"])
-
-    if created:
-        if "description" in data:
-            b.description = data["description"]
-        if "units" in data:
-            b.units = data["units"]
-        if "units_title" in data:
-            b.units_title = data["units_title"]
-        if "lessisbetter" in data:
-            b.lessisbetter = data["lessisbetter"]
-        b.full_clean()
-        b.save()
-
-    try:
-        rev = branch.revisions.get(commitid=data['commitid'])
-    except Revision.DoesNotExist:
-        rev_date = data.get("revision_date")
-        # "None" (as string) can happen when we urlencode the POST data
-        if not rev_date or rev_date in ["", "None"]:
-            rev_date = datetime.today()
-        rev = Revision(branch=branch, project=p, commitid=data['commitid'],
-                       date=rev_date)
-        try:
-            rev.full_clean()
-        except ValidationError as e:
-            return str(e), True
-        if p.repo_type not in ("N", ""):
-            try:
-                commit_logs = commits.get_logs(rev, rev, update=True)
-            except RuntimeError as e:
-                logger.warning("unable to save revision %s info: %s", rev, e,
-                               exc_info=True)
-            else:
-                if commit_logs:
-                    log = commit_logs[0]
-                    rev.author = log['author']
-                    rev.date = log['date']
-                    rev.message = log['message']
-
-        rev.save()
-
-    exe, created = Executable.objects.get_or_create(
-        name=data['executable'],
-        project=p
-    )
-
-    try:
-        r = Result.objects.get(
-            revision=rev, executable=exe, benchmark=b, environment=env)
-    except Result.DoesNotExist:
-        r = Result(revision=rev, executable=exe, benchmark=b, environment=env)
-
-    r.value = data["result_value"]
-    if 'result_date' in data:
-        r.date = data["result_date"]
-    elif rev.date:
-        r.date = rev.date
-    else:
-        r.date = datetime.now()
-
-    r.std_dev = data.get('std_dev')
-    r.val_min = data.get('min')
-    r.val_max = data.get('max')
-
-    r.full_clean()
-    r.save()
-
-    return (rev, exe, env), False
diff --git a/codespeed/models.py b/codespeed/models.py
@@ -9,7 +9,7 @@
 from django.db import models
 from django.conf import settings
 
-from codespeed.github import GITHUB_URL_RE
+from .commits.github import GITHUB_URL_RE
 
 
 class Project(models.Model):
@@ -61,7 +61,7 @@ def working_copy(self):
 
     def save(self, *args, **kwargs):
         """Provide a default for commit browsing url in github repositories."""
-        if not self.commit_browsing_url and self.repo_type == 'H':
+        if not self.commit_browsing_url and self.repo_type == self.GITHUB:
             m = GITHUB_URL_RE.match(self.repo_path)
             if m:
                 url = 'https://github.com/%s/%s/commit/{commitid}' % (
diff --git a/codespeed/results.py b/codespeed/results.py
@@ -0,0 +1,151 @@
+# -*- coding: utf-8 -*-
+from __future__ import absolute_import
+
+import logging
+from datetime import datetime
+
+from django.core.exceptions import ValidationError
+
+from .models import (Environment, Project, Branch, Benchmark, Executable,
+                     Revision, Result, Report)
+from . import commits
+
+logger = logging.getLogger(__name__)
+
+
+def validate_result(item):
+    """
+    Validates that a result dictionary has all needed parameters
+
+    It returns a tuple
+        Environment, False  when no errors where found
+        Errormessage, True  when there is an error
+    """
+    mandatory_data = [
+        'commitid',
+        'branch',
+        'project',
+        'executable',
+        'benchmark',
+        'environment',
+        'result_value',
+    ]
+
+    error = True
+    for key in mandatory_data:
+        if key not in item:
+            return 'Key "' + key + '" missing from request', error
+        elif key in item and item[key] == "":
+            return 'Value for key "' + key + '" empty in request', error
+
+    # Check that the Environment exists
+    try:
+        e = Environment.objects.get(name=item['environment'])
+        error = False
+        return e, error
+    except Environment.DoesNotExist:
+        return "Environment %(environment)s not found" % item, error
+
+
+def save_result(data):
+    res, error = validate_result(data)
+    if error:
+        return res, True
+    else:
+        assert(isinstance(res, Environment))
+        env = res
+
+    p, created = Project.objects.get_or_create(name=data["project"])
+    branch, created = Branch.objects.get_or_create(name=data["branch"],
+                                                   project=p)
+    b, created = Benchmark.objects.get_or_create(name=data["benchmark"])
+
+    if created:
+        if "description" in data:
+            b.description = data["description"]
+        if "units" in data:
+            b.units = data["units"]
+        if "units_title" in data:
+            b.units_title = data["units_title"]
+        if "lessisbetter" in data:
+            b.lessisbetter = data["lessisbetter"]
+        b.full_clean()
+        b.save()
+
+    try:
+        rev = branch.revisions.get(commitid=data['commitid'])
+    except Revision.DoesNotExist:
+        rev_date = data.get("revision_date")
+        # "None" (as string) can happen when we urlencode the POST data
+        if not rev_date or rev_date in ["", "None"]:
+            rev_date = datetime.today()
+        rev = Revision(branch=branch, project=p, commitid=data['commitid'],
+                       date=rev_date)
+        try:
+            rev.full_clean()
+        except ValidationError as e:
+            return str(e), True
+        if p.repo_type not in ("N", ""):
+            try:
+                commit_logs = commits.get_logs(rev, rev, update=True)
+            except RuntimeError as e:
+                logger.warning("unable to save revision %s info: %s", rev, e,
+                               exc_info=True)
+            else:
+                if commit_logs:
+                    log = commit_logs[0]
+                    rev.author = log['author']
+                    rev.date = log['date']
+                    rev.message = log['message']
+
+        rev.save()
+
+    exe, created = Executable.objects.get_or_create(
+        name=data['executable'],
+        project=p
+    )
+
+    try:
+        r = Result.objects.get(
+            revision=rev, executable=exe, benchmark=b, environment=env)
+    except Result.DoesNotExist:
+        r = Result(revision=rev, executable=exe, benchmark=b, environment=env)
+
+    r.value = data["result_value"]
+    if 'result_date' in data:
+        r.date = data["result_date"]
+    elif rev.date:
+        r.date = rev.date
+    else:
+        r.date = datetime.now()
+
+    r.std_dev = data.get('std_dev')
+    r.val_min = data.get('min')
+    r.val_max = data.get('max')
+
+    r.full_clean()
+    r.save()
+
+    return (rev, exe, env), False
+
+
+def create_report_if_enough_data(rev, exe, e):
+    """Triggers Report creation when there are enough results"""
+    last_revs = Revision.objects.filter(
+        branch=rev.branch
+    ).order_by('-date')[:2]
+    if len(last_revs) > 1:
+        current_results = rev.results.filter(executable=exe, environment=e)
+        last_results = last_revs[1].results.filter(
+            executable=exe, environment=e)
+        # If there is are at least as many results as in the last revision,
+        # create new report
+        if len(current_results) >= len(last_results):
+            logger.debug("create_report_if_enough_data: About to create new report")
+            report, created = Report.objects.get_or_create(
+                executable=exe, environment=e, revision=rev
+            )
+            report.full_clean()
+            report.save()
+            logger.debug("Created new report for branch %s and revision %s",
+                         rev.branch, rev.commitid)
diff --git a/codespeed/views.py b/codespeed/views.py
@@ -12,12 +12,12 @@
 from django.template import RequestContext
 from django.conf import settings
 
-from codespeed.models import (Environment, Report, Project, Revision, Result,
-                              Executable, Benchmark, Branch)
-from codespeed.domain import (get_default_environment, getbaselineexecutables,
-                              getdefaultexecutable, getcomparisonexes,
-                              save_result, create_report_if_enough_data)
-from codespeed import commits
+from .models import (Environment, Report, Project, Revision, Result,
+                     Executable, Benchmark, Branch)
+from .domain import (get_default_environment, getbaselineexecutables,
+                     getdefaultexecutable, getcomparisonexes)
+from .results import save_result, create_report_if_enough_data
+from . import commits
 
 logger = logging.getLogger(__name__)
 
