Merge lp:~nskaggs/qa-dashboard/contribtrack into lp:qa-dashboard

[Chris Johnston]

Unmerged revisions

381. By Nicholas Skaggs on 2013-05-03

removed summing of values, instead store a daily value everyday

380. By Nicholas Skaggs on 2013-05-02

fix script to write data properly

379. By Nicholas Skaggs on 2013-05-02

first working version of contribtrack with qatracker pull

378. By Nicholas Skaggs on 2013-05-01

added contributors to model

377. By Nicholas Skaggs on 2013-04-30

skeleton for community results

=== added directory 'contribtrack'
=== added file 'contribtrack/__init__.py'
=== added file 'contribtrack/admin.py'
--- contribtrack/admin.py	1970-01-01 00:00:00 +0000
+++ contribtrack/admin.py	2013-05-06 01:14:24 +0000
@@ -0,0 +1,5 @@
+from django.contrib import admin
+from contribtrack.models import CommunityResult, CommunityContributor
+
+admin.site.register(CommunityResult)
+admin.site.register(CommunityContributor)

=== added directory 'contribtrack/management'
=== added file 'contribtrack/management/__init__.py'
=== added directory 'contribtrack/management/commands'
=== added file 'contribtrack/management/commands/__init__.py'
=== added file 'contribtrack/management/commands/pull_qatracker.py'
--- contribtrack/management/commands/pull_qatracker.py	1970-01-01 00:00:00 +0000
+++ contribtrack/management/commands/pull_qatracker.py	2013-05-06 01:14:24 +0000
@@ -0,0 +1,208 @@
+# QA Dashboard
+# Copyright 2013 Canonical Ltd.
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License version
+# 3, as published by the Free Software Foundation.
+
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU Affero General Public License for more details.
+
+# You should have received a copy of the GNU Affero General Public
+# License along with this program.  If not, see
+# <http://www.gnu.org/licenses/>.
+
+import sys
+from qatracker import QATracker
+import argparse
+import datetime
+import calendar
+import json
+import re
+import os
+import time
+from django.core.management.base import BaseCommand
+from django.db.models import Max
+from optparse import make_option
+
+from contribtrack.models import (
+    CommunityResult,
+    CommunityContributor,
+)
+
+def init(date, days):
+    # Get min and max date in UTC
+    if date:
+        startDate = datetime.datetime.strptime(date, '%Y-%m-%d')
+    else:
+        #just default to right now
+        startDate = datetime.datetime.strptime(datetime.datetime.today().strftime('%Y-%m-%d'),'%Y-%m-%d')
+    endDate = datetime.datetime.strptime(startDate.strftime('%Y-%m-%d'), '%Y-%m-%d') + datetime.timedelta(days=int(days)-1)
+    return startDate, endDate
+
+def generateTimestamp(date):
+    #generate utc timestamp
+    utcDate = datetime.datetime.strptime(date.strftime('%Y-%m-%d %H:%M:%S'), '%Y-%m-%d %H:%M:%S')
+    #print("utcDate: %s" % utcDate)
+    return utcDate
+
+def getInstance(domain, dist):
+    # Establish the XML-RPC connection (user and api-key are optional for read-only access)
+    instance = QATracker("http://" + domain + ".qa.ubuntu.com/xmlrpc.php")
+
+    #Get milestones
+    milestones = [milestone for milestone in instance.get_milestones() if dist in milestone.title]
+
+    if len(milestones) == 0:
+        print("Milestones not found for domain %s and dist %s" % (domain,dist))
+        sys.exit(1)
+
+    # Get a list of all products
+    products = instance.get_products()
+
+    if len(products) == 0:
+        print("Products not found for domain %s and dist %s" % (domain,dist))
+        sys.exit(1)
+
+    return milestones, products
+
+def getStats(milestones, products, date):
+    results = 0
+    bugs = 0
+    cases = 0
+    builds = 0
+    images = 0
+    count = 0
+    stats = []
+    testers = {}
+    #print("Processing %s milestones" % len(milestones))
+    for milestone in milestones:
+        builds = milestone.get_builds()
+        filteredbuilds = []
+        #print("%s builds for %s" % (len(builds),milestone.title))
+
+        #process for dates
+        for build in builds:
+            if build.date:
+                buildDate = datetime.datetime.strptime(build.date.strftime('%Y-%m-%d'), '%Y-%m-%d')
+                processDate = datetime.datetime.strptime(date.strftime('%Y-%m-%d'), '%Y-%m-%d')
+                #print("Comparing %s to %s" % (build.date, date))
+                #product = [product for product in products if product.id == build.productid][0]
+                #print("Comparing %s to %s for %s" % (buildDate, processDate, product.title))
+                #if build.date != date:
+                if buildDate == processDate:
+                    #print("Added %s" % buildDate)
+                    filteredbuilds.append(build)
+
+
+        #print("%s matching builds for %s from %s" % (len(filteredbuilds),processDate.strftime('%Y-%m-%d'), milestone.title))
+        print("%s matching builds from %s" % (len(filteredbuilds), milestone.title))
+
+        for build in filteredbuilds:
+            count += 1
+            #print("Processing build %s of %s        " % (count,len(filteredbuilds)),end='\r')
+            print("Processing build %s of %s        " % (count,len(filteredbuilds)))
+            #clear stats
+            image = {}
+            image["testcases"] = 0
+            image["results"] = 0
+            image["testers"] = 0
+
+            images = images + 1
+            product = [product for product in products if product.id == build.productid][0]
+            image["name"] = product.title
+            #print(" Processing %s" % (product.title))
+            for testcase in product.get_testcases(milestone):
+                cases += 1
+                image["testcases"] += 1
+                for result in build.get_results(testcase):
+                    results += 1
+                    image["results"] += 1
+                    if not result.reportername in testers:
+                        testers[result.reportername] = 0
+                    testers[result.reportername] += 1
+                    image["testers"] += 1
+            #store stats for image
+            stats.append(image)
+
+    # Number of testcases
+    print("%s testers for %s" % (len(testers), milestone.title))
+
+    # Number of results
+    print("%s results for %s" % (results, milestone.title))
+
+    return results,testers
+    
+def processTracker(dist, domain, milestones, products, startDate, endDate):
+    #loop through each date and create data
+    print("Processing %s till %s" % (startDate.strftime('%Y-%m-%d'), endDate.strftime('%Y-%m-%d')))
+    date = startDate
+    while date <= endDate:
+        print("\nProcessing %s " % date.strftime('%Y-%m-%d'))
+        timestamp = generateTimestamp(date)
+        (dayResults, dayContributors) = getStats(milestones, products, date)
+        
+        #add / check for result
+        dbResult, newResult = CommunityResult.objects.get_or_create(value = dayResults, ran_at = date, name = domain, release = dist)    
+        
+        #add / check for person
+        for person in dayContributors:
+           dbContrib, newContrib = CommunityContributor.objects.get_or_create(launchpad_id = person, result = dbResult)
+        
+        #iterate to tomorrow
+        date += datetime.timedelta(days=1)
+
+def main(domain, startDate, endDate, dist):
+    #connect to tracker
+    (milestones, products) = getInstance(domain, dist)
+
+    #remove whitespace for filenaming
+    dist = dist.replace(" ", "")
+
+    #process
+    processTracker(dist, domain, milestones, products, startDate, endDate)
+
+
+class Command(BaseCommand):
+    #help = "Gather bootspeed results from jenkins.qa.ubuntu.com"
+    #args = "[job name] [job name]..."
+
+    option_list = BaseCommand.option_list + (
+        make_option(
+            '-d', '--domain',
+            dest='domain',
+            help='Domain',
+            type=str,
+        ),
+        make_option(
+            '-D', '--days',
+            dest='days',
+            help='days',
+            default=1,
+            type=int,
+        ),
+        make_option(
+            '--dist',
+            dest='dist',
+            help='dist',
+            type=str,
+        ),
+        make_option(
+            '--date',
+            dest='date',
+            help='date',
+            type=str,
+        ),
+    )
+    def handle(self, *args, **options):
+        domain = options.get('domain')
+        days = int(options.get('days'))
+        dist = options.get('dist')
+        date = options.get('date')
+        (startDate, endDate) = init(date, days)
+        main(domain, startDate, endDate, dist)
+        #for x in domain:
+        #    main(x, startDate, endDate, dist)
+

=== added file 'contribtrack/management/commands/qatracker.py'
--- contribtrack/management/commands/qatracker.py	1970-01-01 00:00:00 +0000
+++ contribtrack/management/commands/qatracker.py	2013-05-06 01:14:24 +0000
@@ -0,0 +1,492 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+
+# Copyright (C) 2011, 2012  Canonical Ltd.
+# Author: Stéphane Graber <[e-mail]>
+
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
+# USA
+
+try:
+    import xmlrpc.client as xmlrpclib
+except ImportError:
+    import xmlrpclib
+
+import base64
+from datetime import datetime
+
+# Taken from qatracker/qatracker.modules (PHP code)
+# cat qatracker.module | grep " = array" | sed -e 's/^\$//g' \
+#   -e 's/array(/[/g' -e 's/);/]/g' -e "s/t('/\"/g" -e "s/')/\"/g"
+### AUTO-GENERATED ->
+qatracker_build_milestone_status = ["Active", "Re-building", "Disabled",
+                                    "Superseded", "Ready"]
+qatracker_milestone_notify = ["No", "Yes"]
+qatracker_milestone_autofill = ["No", "Yes"]
+qatracker_milestone_status = ["Testing", "Released", "Archived"]
+qatracker_milestone_series_status = ["Active", "Disabled"]
+qatracker_milestone_series_manifest_status = ["Active", "Disabled"]
+qatracker_product_status = ["Active", "Disabled"]
+qatracker_product_type = ["iso", "package", "hardware"]
+qatracker_product_download_type = ["HTTP", "RSYNC", "ZSYNC",
+                                   "GPG signature", "MD5 checksum", "Comment",
+                                   "Torrent"]
+qatracker_testsuite_testcase_status = ["Mandatory", "Disabled", "Run-once",
+                                       "Optional"]
+qatracker_result_result = ["Failed", "Passed", "In progress"]
+qatracker_result_status = ["Active", "Disabled"]
+### <- AUTO-GENERATED
+
+
+class QATrackerRPCObject():
+    """Base class for objects received over XML-RPC"""
+
+    CONVERT_BOOL = []
+    CONVERT_DATE = []
+    CONVERT_INT = []
+
+    def __init__(self, tracker, rpc_dict):
+        # Convert the dict we get from the API into an object
+
+        for key in rpc_dict:
+            key = unicode(key)
+            if key in self.CONVERT_INT:
+                try:
+                    setattr(self, key, int(rpc_dict[key]))
+                except ValueError:
+                    setattr(self, key, None)
+            elif key in self.CONVERT_BOOL:
+                setattr(self, key, rpc_dict[key] == "true")
+            elif key in self.CONVERT_DATE:
+                try:
+                    setattr(self, key, datetime.strptime(rpc_dict[key],
+                                                         '%Y-%m-%d %H:%M:%S'))
+                except ValueError:
+                    setattr(self, key, None)
+            else:
+                setattr(self, key, unicode(rpc_dict[key]))
+
+        self.tracker = tracker
+
+    def __repr__(self):
+        return "%s: %s" % (self.__class__.__name__, self.title)
+
+
+class QATrackerBug(QATrackerRPCObject):
+    """A bug entry"""
+
+    CONVERT_INT = ['bugnumber', 'count']
+    CONVERT_DATE = ['earliest_report', 'latest_report']
+
+    def __repr__(self):
+        return "%s: %s" % (self.__class__.__name__, self.bugnumber)
+
+
+class QATrackerBuild(QATrackerRPCObject):
+    """A build entry"""
+
+    CONVERT_INT = ['id', 'productid', 'userid', 'status']
+    CONVERT_DATE = ['date']
+
+    def __repr__(self):
+        return "%s: %s" % (self.__class__.__name__, self.id)
+
+    def add_result(self, testcase, result, comment='', hardware='', bugs={}):
+        """Add a result to the build"""
+
+        if (self.tracker.access not in ("user", "admin") and
+                self.tracker.access is not None):
+            raise Exception("Access denied, you need 'user' but are '%s'" %
+                            self.tracker.access)
+
+        build_testcase = None
+
+        # FIXME: Supporting 'str' containing the testcase name would be nice
+        if isinstance(testcase, QATrackerTestcase):
+            build_testcase = testcase.id
+        elif isinstance(testcase, int):
+            build_testcase = testcase
+
+        if not build_testcase:
+            raise IndexError("Couldn't find testcase: %s" % (testcase,))
+
+        if isinstance(result, list):
+            raise TypeError("result must be a string or an integer")
+
+        build_result = self.tracker._get_valid_id_list(qatracker_result_result,
+                                                       result)
+
+        if not isinstance(bugs, dict):
+            raise TypeError("bugs must be a dict")
+
+        for bug in bugs:
+            if not isinstance(bug, int) or bug <= 0:
+                raise ValueError("A bugnumber must be a number >= 0")
+
+            if not isinstance(bugs[bug], int) or bugs[bug] not in (0, 1):
+                raise ValueError("A bugimportance must be in (0,1)")
+
+        resultid = int(self.tracker.tracker.results.add(self.id,
+                                                        build_testcase,
+                                                        build_result[0],
+                                                        str(comment),
+                                                        str(hardware),
+                                                        bugs))
+        if resultid == -1:
+            raise Exception("Couldn't post your result.")
+
+        new_result = None
+        for entry in self.get_results(build_testcase, 0):
+            if entry.id == resultid:
+                new_result = entry
+                break
+
+        return new_result
+
+    def get_results(self, testcase, status=qatracker_result_status):
+        """Get a list of results for the given build and testcase"""
+
+        build_testcase = None
+
+        # FIXME: Supporting 'str' containing the testcase name would be nice
+        if isinstance(testcase, QATrackerTestcase):
+            build_testcase = testcase.id
+        elif isinstance(testcase, int):
+            build_testcase = testcase
+
+        if not build_testcase:
+            raise IndexError("Couldn't find testcase: %s" % (testcase,))
+
+        record_filter = self.tracker._get_valid_id_list(
+            qatracker_result_status,
+            status)
+
+        if len(record_filter) == 0:
+            return []
+
+        results = []
+        for entry in self.tracker.tracker.results.get_list(
+                self.id, build_testcase, list(record_filter)):
+            results.append(QATrackerResult(self.tracker, entry))
+
+        return results
+
+
+class QATrackerMilestone(QATrackerRPCObject):
+    """A milestone entry"""
+
+    CONVERT_INT = ['id', 'status', 'series']
+    CONVERT_BOOL = ['notify']
+
+    def get_bugs(self):
+        """Returns a list of all bugs linked to this milestone"""
+
+        bugs = []
+        for entry in self.tracker.tracker.bugs.get_list(self.id):
+            bugs.append(QATrackerBug(self.tracker, entry))
+
+        return bugs
+
+    def add_build(self, product, version, note="", notify=True):
+        """Add a build to the milestone"""
+
+        if self.status != 0:
+            raise TypeError("Only active milestones are accepted")
+
+        if self.tracker.access != "admin" and self.tracker.access is not None:
+            raise Exception("Access denied, you need 'admin' but are '%s'" %
+                            self.tracker.access)
+
+        if not isinstance(notify, bool):
+            raise TypeError("notify must be a boolean")
+
+        build_product = None
+
+        if isinstance(product, QATrackerProduct):
+            build_product = product
+        else:
+            valid_products = self.tracker.get_products(0)
+
+            for entry in valid_products:
+                if (entry.title.lower() == str(product).lower() or
+                        entry.id == product):
+                    build_product = entry
+                    break
+
+        if not build_product:
+            raise IndexError("Couldn't find product: %s" % product)
+
+        if build_product.status != 0:
+            raise TypeError("Only active products are accepted")
+
+        self.tracker.tracker.builds.add(build_product.id, self.id,
+                                        str(version), str(note), notify)
+
+        new_build = None
+        for entry in self.get_builds(0):
+            if (entry.productid == build_product.id
+                    and entry.version == str(version)):
+                new_build = entry
+                break
+
+        return new_build
+
+    def get_builds(self, status=qatracker_build_milestone_status):
+        """Get a list of builds for the milestone"""
+
+        record_filter = self.tracker._get_valid_id_list(
+            qatracker_build_milestone_status, status)
+
+        if len(record_filter) == 0:
+            return []
+
+        builds = []
+        for entry in self.tracker.tracker.builds.get_list(self.id,
+                                                          list(record_filter)):
+            builds.append(QATrackerBuild(self.tracker, entry))
+
+        return builds
+
+
+class QATrackerProduct(QATrackerRPCObject):
+    CONVERT_INT = ['id', 'type', 'status']
+
+    def get_testcases(self, series,
+                      status=qatracker_testsuite_testcase_status):
+        """Get a list of testcases associated with the product"""
+
+        record_filter = self.tracker._get_valid_id_list(
+            qatracker_testsuite_testcase_status, status)
+
+        if len(record_filter) == 0:
+            return []
+
+        if isinstance(series, QATrackerMilestone):
+            seriesid = series.series
+        elif isinstance(series, int):
+            seriesid = series
+        else:
+            raise TypeError("series needs to be a valid QATrackerMilestone"
+                            " instance or an integer")
+
+        testcases = []
+        for entry in self.tracker.tracker.testcases.get_list(
+                self.id, seriesid, list(record_filter)):
+            testcases.append(QATrackerTestcase(self.tracker, entry))
+
+        return testcases
+
+
+class QATrackerResult(QATrackerRPCObject):
+    CONVERT_INT = ['id', 'reporterid', 'revisionid', 'result', 'changedby',
+                   'status']
+    CONVERT_DATE = ['date', 'lastchange']
+    __deleted = False
+
+    def __repr__(self):
+        return "%s: %s" % (self.__class__.__name__, self.id)
+
+    def delete(self):
+        """Remove the result from the tracker"""
+
+        if (self.tracker.access not in ("user", "admin") and
+                self.tracker.access is not None):
+            raise Exception("Access denied, you need 'user' but are '%s'" %
+                            self.tracker.access)
+
+        if self.__deleted:
+            raise IndexError("Result has already been removed")
+
+        retval = self.tracker.tracker.results.delete(self.id)
+        if retval is not True:
+            raise Exception("Failed to remove result")
+
+        self.status = 1
+        self.__deleted = True
+
+    def save(self):
+        """Save any change that happened on this entry"""
+
+        if (self.tracker.access not in ("user", "admin") and
+                self.tracker.access is not None):
+            raise Exception("Access denied, you need 'user' but are '%s'" %
+                            self.tracker.access)
+
+        if self.__deleted:
+            raise IndexError("Result no longer exists")
+
+        retval = self.tracker.tracker.results.update(self.id, self.result,
+                                                     self.comment,
+                                                     self.hardware,
+                                                     self.bugs)
+        if retval is not True:
+            raise Exception("Failed to update result")
+
+
+class QATrackerSeries(QATrackerRPCObject):
+    CONVERT_INT = ['id', 'status']
+
+    def get_manifest(self, status=qatracker_milestone_series_manifest_status):
+        """Get a list of products in the series' manifest"""
+
+        record_filter = self.tracker._get_valid_id_list(
+            qatracker_milestone_series_manifest_status, status)
+
+        if len(record_filter) == 0:
+            return []
+
+        manifest_entries = []
+        for entry in self.tracker.tracker.series.get_manifest(
+                self.id, list(record_filter)):
+            manifest_entries.append(QATrackerSeriesManifest(
+                                    self.tracker, entry))
+
+        return manifest_entries
+
+
+class QATrackerSeriesManifest(QATrackerRPCObject):
+    CONVERT_INT = ['id', 'productid', 'status']
+
+    def __repr__(self):
+        return "%s: %s" % (self.__class__.__name__, self.product_title)
+
+
+class QATrackerTestcase(QATrackerRPCObject):
+    CONVERT_INT = ['id', 'status', 'weight', 'suite']
+
+
+class QATracker():
+    def __init__(self, url, username=None, password=None):
+        class AuthTransport(xmlrpclib.Transport):
+            def set_auth(self, auth):
+                self.auth = auth
+
+            def get_host_info(self, host):
+                host, extra_headers, x509 = \
+                    xmlrpclib.Transport.get_host_info(self, host)
+                if extra_headers is None:
+                    extra_headers = []
+                extra_headers.append(('Authorization', 'Basic %s' % auth))
+                return host, extra_headers, x509
+
+        if username and password:
+            try:
+                auth = str(base64.b64encode(
+                           bytes('%s:%s' % (username, password), 'utf-8')),
+                           'utf-8')
+            except TypeError:
+                auth = base64.b64encode('%s:%s' % (username, password))
+
+            transport = AuthTransport()
+            transport.set_auth(auth)
+            drupal = xmlrpclib.ServerProxy(url, transport=transport)
+        else:
+            drupal = xmlrpclib.ServerProxy(url)
+
+        # Call listMethods() so if something is wrong we know it immediately
+        drupal.system.listMethods()
+
+        # Get our current access
+        self.access = drupal.qatracker.get_access()
+
+        self.tracker = drupal.qatracker
+
+    def _get_valid_id_list(self, status_list, status):
+        """ Get a list of valid keys and a list or just a single
+            entry of input to check against the list of valid keys.
+            The function looks for valid indexes and content, doing
+            case insensitive checking for strings and returns a list
+            of indexes for the list of valid keys. """
+
+        def process(status_list, status):
+            valid_status = [entry.lower() for entry in status_list]
+
+            if isinstance(status, int):
+                if status < 0 or status >= len(valid_status):
+                    raise IndexError("Invalid status: %s" % status)
+                return int(status)
+
+            if isinstance(status, str):
+                status = status.lower()
+                if status not in valid_status:
+                    raise IndexError("Invalid status: %s" % status)
+                return valid_status.index(status)
+
+            raise TypeError("Invalid status type: %s (expected str or int)" %
+                            type(status))
+
+        record_filter = set()
+
+        if isinstance(status, list):
+            for entry in status:
+                record_filter.add(process(status_list, entry))
+        else:
+            record_filter.add(process(status_list, status))
+
+        return list(record_filter)
+
+    def get_bugs(self):
+        """Get a list of all bugs reported on the site"""
+
+        bugs = []
+        for entry in self.tracker.bugs.get_list(0):
+            bugs.append(QATrackerBug(self, entry))
+
+        return bugs
+
+    def get_milestones(self, status=qatracker_milestone_status):
+        """Get a list of all milestones"""
+
+        record_filter = self._get_valid_id_list(qatracker_milestone_status,
+                                                status)
+
+        if len(record_filter) == 0:
+            return []
+
+        milestones = []
+        for entry in self.tracker.milestones.get_list(list(record_filter)):
+            milestones.append(QATrackerMilestone(self, entry))
+
+        return milestones
+
+    def get_products(self, status=qatracker_product_status):
+        """Get a list of all products"""
+
+        record_filter = self._get_valid_id_list(qatracker_product_status,
+                                                status)
+
+        if len(record_filter) == 0:
+            return []
+
+        products = []
+        for entry in self.tracker.products.get_list(list(record_filter)):
+            products.append(QATrackerProduct(self, entry))
+
+        return products
+
+    def get_series(self, status=qatracker_milestone_series_status):
+        """Get a list of all series"""
+
+        record_filter = self._get_valid_id_list(
+            qatracker_milestone_series_status, status)
+
+        if len(record_filter) == 0:
+            return []
+
+        series = []
+        for entry in self.tracker.series.get_list(list(record_filter)):
+            series.append(QATrackerSeries(self, entry))
+
+        return series

=== added directory 'contribtrack/migrations'
=== added file 'contribtrack/migrations/0001_initial.py'
--- contribtrack/migrations/0001_initial.py	1970-01-01 00:00:00 +0000
+++ contribtrack/migrations/0001_initial.py	2013-05-06 01:14:24 +0000
@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*-
+import datetime
+from south.db import db
+from south.v2 import SchemaMigration
+from django.db import models
+
+
+class Migration(SchemaMigration):
+
+    def forwards(self, orm):
+        # Adding model 'CommunityResult'
+        db.create_table('community_results', (
+            ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
+            ('created_at', self.gf('django.db.models.fields.DateTimeField')(auto_now_add=True, blank=True)),
+            ('updated_at', self.gf('django.db.models.fields.DateTimeField')(auto_now=True, blank=True)),
+            ('internal', self.gf('django.db.models.fields.BooleanField')(default=True)),
+            ('publish', self.gf('django.db.models.fields.BooleanField')(default=True)),
+            ('name', self.gf('django.db.models.fields.CharField')(max_length=200)),
+            ('value', self.gf('django.db.models.fields.FloatField')()),
+            ('ran_at', self.gf('django.db.models.fields.DateTimeField')()),
+            ('jenkins_url', self.gf('django.db.models.fields.URLField')(max_length=200, null=True)),
+            ('release', self.gf('django.db.models.fields.CharField')(max_length=4096)),
+        ))
+        db.send_create_signal('contribtrack', ['CommunityResult'])
+
+        # Adding model 'CommunityContributor'
+        db.create_table('community_contributors', (
+            ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
+            ('launchpad_id', self.gf('django.db.models.fields.CharField')(max_length=4096)),
+            ('result', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['contribtrack.CommunityResult'])),
+        ))
+        db.send_create_signal('contribtrack', ['CommunityContributor'])
+
+
+    def backwards(self, orm):
+        # Deleting model 'CommunityResult'
+        db.delete_table('community_results')
+
+        # Deleting model 'CommunityContributor'
+        db.delete_table('community_contributors')
+
+
+    models = {
+        'contribtrack.communitycontributor': {
+            'Meta': {'object_name': 'CommunityContributor', 'db_table': "'community_contributors'"},
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'launchpad_id': ('django.db.models.fields.CharField', [], {'max_length': '4096'}),
+            'result': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['contribtrack.CommunityResult']"})
+        },
+        'contribtrack.communityresult': {
+            'Meta': {'object_name': 'CommunityResult', 'db_table': "'community_results'"},
+            'created_at': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'internal': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
+            'jenkins_url': ('django.db.models.fields.URLField', [], {'max_length': '200', 'null': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '200'}),
+            'publish': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
+            'ran_at': ('django.db.models.fields.DateTimeField', [], {}),
+            'release': ('django.db.models.fields.CharField', [], {'max_length': '4096'}),
+            'updated_at': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'}),
+            'value': ('django.db.models.fields.FloatField', [], {})
+        }
+    }
+
+    complete_apps = ['contribtrack']
\ No newline at end of file

=== added file 'contribtrack/migrations/__init__.py'
=== added file 'contribtrack/models.py'
--- contribtrack/models.py	1970-01-01 00:00:00 +0000
+++ contribtrack/models.py	2013-05-06 01:14:24 +0000
@@ -0,0 +1,13 @@
+from django.db import models
+from performance.models import ResultBase
+
+class CommunityResult(ResultBase):
+    class Meta:
+        db_table = "community_results"
+    release = models.CharField(max_length=4096)
+
+class CommunityContributor(models.Model):
+    class Meta:
+        db_table = "community_contributors"
+    launchpad_id = models.CharField(max_length=4096)
+    result = models.ForeignKey(CommunityResult)

=== added file 'contribtrack/tests.py'
--- contribtrack/tests.py	1970-01-01 00:00:00 +0000
+++ contribtrack/tests.py	2013-05-06 01:14:24 +0000
@@ -0,0 +1,16 @@
+"""
+This file demonstrates writing tests using the unittest module. These will pass
+when you run "manage.py test".
+
+Replace this with more appropriate tests for your application.
+"""
+
+from django.test import TestCase
+
+
+class SimpleTest(TestCase):
+    def test_basic_addition(self):
+        """
+        Tests that 1 + 1 always equals 2.
+        """
+        self.assertEqual(1 + 1, 2)

=== added file 'contribtrack/views.py'
--- contribtrack/views.py	1970-01-01 00:00:00 +0000
+++ contribtrack/views.py	2013-05-06 01:14:24 +0000
@@ -0,0 +1,1 @@
+# Create your views here.

=== modified file 'qa_dashboard/settings.py'
--- qa_dashboard/settings.py	2013-04-18 19:10:24 +0000
+++ qa_dashboard/settings.py	2013-05-06 01:14:24 +0000
@@ -149,6 +149,7 @@
     'smoke',
     'sru',
     'idle_power',
+    'contribtrack',
 )
 
 INSTALLED_APPS = (

=== modified file 'setup.sh'
--- setup.sh	2013-05-04 00:08:00 +0000
+++ setup.sh	2013-05-06 01:14:24 +0000
@@ -1,4 +1,4 @@
-VAGRANT_SETUP=/home/vagrant/vagrant-setup
+VAGRANT_SETUP=~/vagrant
 
 echo "Does the vagrant-setup directory exist?"
 if [ ! -f $VAGRANT_SETUP/_dir ]; then