Fixes for distinct builds.

[build-farm.git] / buildfarm / __init__.py

diff --git a/buildfarm/__init__.py b/buildfarm/__init__.py
index ba87fb18530c8f70bfcc19cffe586846f7838d97..509b024ef619bc34ecad72bfee07e73107705789 100644 (file)
--- a/buildfarm/__init__.py
+++ b/buildfarm/__init__.py
@@ -21,6 +21,8 @@ import ConfigParser
 import os
 import re
 
+GIT_ROOT = "/data/git"
+
 
 class Tree(object):
     """A tree to build."""
@@ -35,8 +37,11 @@ class Tree(object):
         self.scm = scm
 
     def get_branch(self):
-        from buildfarm.history import GitBranch
-        return GitBranch(self.repo, self.branch)
+        if self.scm == "git":
+            from buildfarm.history import GitBranch
+            return GitBranch(os.path.join(GIT_ROOT, self.repo), self.branch)
+        else:
+            raise NotImplementedError(self.scm)
 
     def __repr__(self):
         return "<%s %r>" % (self.__class__.__name__, self.name)
@@ -90,11 +95,13 @@ class BuildFarm(object):
 
     def _open_build_results(self):
         from buildfarm import data
-        return data.BuildResultStore(os.path.join(self.path, "data", "oldrevs"))
+        path = os.path.join(self.path, "data", "oldrevs")
+        return data.BuildResultStore(path)
 
     def _open_upload_build_results(self):
         from buildfarm import data
-        return data.UploadBuildResultStore(os.path.join(self.path, "data", "upload"))
+        path = os.path.join(self.path, "data", "upload")
+        return data.UploadBuildResultStore(path)
 
     def _open_hostdb(self):
         from buildfarm import hostdb
@@ -124,69 +131,43 @@ class BuildFarm(object):
             ret = perc
         return perc
 
-    def get_build(self, tree, host, compiler, rev=None):
-        if rev:
-            return self.builds.get_build(tree, host, compiler, rev)
+    def get_build(self, tree, host, compiler, rev=None, checksum=None):
+        if rev is not None:
+            return self.builds.get_build(tree, host, compiler, rev,
+                checksum=checksum)
         else:
             return self.upload_builds.get_build(tree, host, compiler)
 
     def get_new_builds(self):
         hostnames = set([host.name for host in self.hostdb.hosts()])
         for build in self.upload_builds.get_new_builds():
-            if build.tree in self.trees and build.compiler in self.compilers and build.host in hostnames:
+            if (build.tree in self.trees and
+                build.compiler in self.compilers and
+                build.host in hostnames):
                 yield build
 
+    def get_last_builds(self):
+        return sorted(self.get_new_builds(), reverse=True)
 
-class CachingBuildFarm(BuildFarm):
-
-    def __init__(self, path=None, readonly=False, cachedirname=None):
-        self._cachedirname = cachedirname
-        self.readonly = readonly
-        super(CachingBuildFarm, self).__init__(path)
+    def get_tree_builds(self, tree):
+        ret = []
+        for build in self.builds.get_all_builds():
+            if build.tree == tree:
+                ret.append(build)
+        ret.sort(reverse=True)
+        return ret
 
-    def _get_cachedir(self):
-        if self._cachedirname is not None:
-            return os.path.join(self.path, self._cachedirname)
-        else:
-            return os.path.join(self.path, "cache")
+    def host_last_build(self, host):
+        return max([build.upload_time for build in self.get_host_builds(host)])
 
-    def _open_build_results(self):
+    def get_host_builds(self, host):
         from buildfarm import data
-        return data.CachingBuildResultStore(os.path.join(self.path, "data", "oldrevs"),
-                self._get_cachedir(), readonly=self.readonly)
-
-    def _open_upload_build_results(self):
-        from buildfarm import data
-        return data.CachingUploadBuildResultStore(os.path.join(self.path, "data", "upload"),
-                self._get_cachedir(), readonly=self.readonly)
-
-    def lcov_status(self, tree):
-        """get status of build"""
-        from buildfarm import data, util
-        cachefile = os.path.join(self._get_cachedir(),
-                                    "lcov.%s.%s.status" % (self.LCOVHOST, tree))
-        file = os.path.join(self.lcovdir, self.LCOVHOST, tree, "index.html")
-        try:
-            st1 = os.stat(file)
-        except OSError:
-            # File does not exist
-            raise data.NoSuchBuildError(tree, self.LCOVHOST, "lcov")
-        try:
-            st2 = os.stat(cachefile)
-        except OSError:
-            # file does not exist
-            st2 = None
-
-        if st2 and st1.st_ctime <= st2.st_mtime:
-            ret = util.FileLoad(cachefile)
-            if ret == "":
-                return None
-            return ret
-
-        perc = super(CachingBuildFarm, self).lcov_status(tree)
-        if not self.readonly:
-            util.FileSave(cachefile, perc)
-        return perc
-
-
-
+        ret = []
+        for compiler in self.compilers:
+            for tree in sorted(self.trees.keys()):
+                try:
+                    ret.append(self.get_build(tree, host, compiler))
+                except data.NoSuchBuildError:
+                    pass
+        ret.sort(reverse=True)
+        return ret