#
from buildfarm import (
+ BuildFarm,
hostdb,
)
-from buildfarm.sqldb import StormCachingBuildFarm
import commands
import os
import smtplib
import time
from email.MIMEText import MIMEText
-buildfarm = StormCachingBuildFarm()
+buildfarm = BuildFarm()
def update_rsyncd_secrets():
temp_rsyncd_secrets = os.path.join(os.path.dirname(__file__), "../rsyncd.secrets.new")
# along with this program; if not, write to the Free Software
# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+from buildfarm.sqldb import distinct_builds, Cast, StormBuild, setup_schema, StormCachingBuildResultStore, StormHostDatabase
+from buildfarm.tree import Tree
+from storm.database import create_database
+from storm.expr import Desc
+from storm.store import Store
+
import ConfigParser
import os
import re
-GIT_ROOT = "/data/git"
-
-
-class Tree(object):
- """A tree to build."""
-
- def __init__(self, name, scm, repo, branch, subdir="", srcdir=""):
- self.name = name
- self.repo = repo
- self.scm = scm
- self.branch = branch
- self.subdir = subdir
- self.srcdir = srcdir
- self.scm = scm
-
- def get_branch(self):
- 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)
-
-
def read_trees_from_conf(path):
"""Read trees from a configuration file.
OLDAGE = 60*60*4,
DEADAGE = 60*60*24*4
- def __init__(self, path=None):
+ def __init__(self, path=None, store=None, timeout=0.5):
+ self.timeout = timeout
+ self.store = store
if path is None:
path = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
self.path = path
return "%s(%r)" % (self.__class__.__name__, self.path)
def _open_build_results(self):
- from buildfarm.build import BuildResultStore
path = os.path.join(self.path, "data", "oldrevs")
- return BuildResultStore(path)
+ return StormCachingBuildResultStore(path, self._get_store())
def _open_upload_build_results(self):
from buildfarm.build import UploadBuildResultStore
return UploadBuildResultStore(path)
def _open_hostdb(self):
- from buildfarm import hostdb
- return hostdb.PlainTextHostDatabase.from_file(os.path.join(self.webdir, "hosts.list"))
+ return StormHostDatabase(self._get_store())
def _load_compilers(self):
from buildfarm import util
return set(util.load_list(os.path.join(self.webdir, "compilers.list")))
def commit(self):
- pass
+ if self.store is not None:
+ self.store.commit()
def lcov_status(self, tree):
"""get status of build"""
yield build
def get_last_builds(self):
- return sorted(self.get_new_builds(), reverse=True)
+ result = self._get_store().find(StormBuild)
+ return distinct_builds(result.order_by(Desc(StormBuild.upload_time)))
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
+ result = self._get_store().find(StormBuild,
+ Cast(StormBuild.tree, "TEXT") == Cast(tree, "TEXT"))
+ return distinct_builds(result.order_by(Desc(StormBuild.upload_time)))
def host_last_build(self, host):
return max([build.upload_time for build in self.get_host_builds(host)])
def get_host_builds(self, host):
- from buildfarm.build import NoSuchBuildError
- ret = []
- for compiler in self.compilers:
- for tree in sorted(self.trees.keys()):
- try:
- ret.append(self.get_build(tree, host, compiler))
- except NoSuchBuildError:
- pass
- ret.sort(reverse=True)
- return ret
+ result = self._get_store().find(StormBuild, StormBuild.host == host)
+ return distinct_builds(result.order_by(Desc(StormBuild.upload_time)))
+
+ def _get_store(self):
+ if self.store is not None:
+ return self.store
+ db_path = os.path.join(self.path, "db", "hostdb.sqlite")
+ db = create_database("sqlite:%s?timeout=%f" % (db_path, self.timeout))
+ self.store = Store(db)
+ setup_schema(self.store)
+ return self.store
+
+ def get_revision_builds(self, tree, revision=None):
+ return self._get_store().find(StormBuild,
+ Cast(StormBuild.tree, "TEXT") == Cast(tree, "TEXT"),
+ Cast(StormBuild.revision, "TEXT") == Cast(revision, "TEXT"))
def commit(self):
pass
-
-
-class PlainTextHostDatabase(HostDatabase):
-
- def __init__(self, hosts):
- self._hosts = hosts
-
- @classmethod
- def from_file(cls, path):
- ret = {}
- f = open(path, 'r')
- try:
- for l in f:
- (host, platform) = l.split(":", 1)
- ret[host] = platform.strip().decode("utf-8")
- finally:
- f.close()
- return cls(ret)
-
- def hosts(self):
- for name, platform in self._hosts.iteritems():
- yield Host(name, platform=platform)
-
- def __getitem__(self, name):
- try:
- return Host(name=name, platform=self._hosts[name])
- except KeyError:
- raise NoSuchHost(name)
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
-from buildfarm import (
- BuildFarm,
+from buildfarm.tree import (
Tree,
)
from buildfarm.build import (
yield build
-class StormCachingBuildFarm(BuildFarm):
-
- def __init__(self, path=None, store=None, timeout=0.5):
- self.timeout = timeout
- self.store = store
- super(StormCachingBuildFarm, self).__init__(path)
-
- def _get_store(self):
- if self.store is not None:
- return self.store
- db_path = os.path.join(self.path, "db", "hostdb.sqlite")
- db = create_database("sqlite:%s?timeout=%f" % (db_path, self.timeout))
- self.store = Store(db)
- setup_schema(self.store)
- return self.store
-
- def _open_hostdb(self):
- return StormHostDatabase(self._get_store())
-
- def _open_build_results(self):
- path = os.path.join(self.path, "data", "oldrevs")
- return StormCachingBuildResultStore(path, self._get_store())
-
- def get_host_builds(self, host):
- result = self._get_store().find(StormBuild, StormBuild.host == host)
- return distinct_builds(result.order_by(Desc(StormBuild.upload_time)))
-
- def get_tree_builds(self, tree):
- result = self._get_store().find(StormBuild,
- Cast(StormBuild.tree, "TEXT") == Cast(tree, "TEXT"))
- return distinct_builds(result.order_by(Desc(StormBuild.upload_time)))
-
- def get_last_builds(self):
- result = self._get_store().find(StormBuild)
- return distinct_builds(result.order_by(Desc(StormBuild.upload_time)))
-
- def get_revision_builds(self, tree, revision=None):
- return self._get_store().find(StormBuild,
- Cast(StormBuild.tree, "TEXT") == Cast(tree, "TEXT"),
- Cast(StormBuild.revision, "TEXT") == Cast(revision, "TEXT"))
-
- def commit(self):
- self.store.commit()
-
-
class StormTree(Tree):
__storm_table__ = "tree"
self.assertEquals(t["pidl"].scm, "git")
-class BuildFarmTestBase(object):
+class BuildFarmTests(BuildFarmTestCase):
def setUp(self):
+ super(BuildFarmTests, self).setUp()
self.write_compilers(["cc"])
self.write_hosts({"myhost": "Fedora",
"charis": "Debian"})
self.write_trees({"trivial": {"scm": "git", "repo": "git://foo", "branch": "master"},
"other": {"scm": "git", "repo": "other.git", "branch": "HEAD"}})
+ self.x = BuildFarm(self.path)
def test_get_new_builds_empty(self):
self.assertEquals([], list(self.x.get_new_builds()))
self.assertEquals("cc", build.compiler)
self.assertIs(None, build.revision)
-
-class BuildFarmTests(BuildFarmTestBase, BuildFarmTestCase):
-
- def setUp(self):
- BuildFarmTestCase.setUp(self)
- BuildFarmTestBase.setUp(self)
- self.x = BuildFarm(self.path)
NoSuchBuildError,
)
from buildfarm.tests import BuildFarmTestCase
-from buildfarm.tests.test_buildfarm import BuildFarmTestBase
from buildfarm.tests.test_build import BuildResultStoreTestBase
from buildfarm.tests.test_hostdb import HostDatabaseTests
from buildfarm.sqldb import (
StormHostDatabase,
- StormCachingBuildFarm,
)
import testtools
-class StormCachingBuildFarmTestCase(BuildFarmTestCase):
-
- def setUp(self):
- super(StormCachingBuildFarmTestCase, self).setUp()
- self.buildfarm = StormCachingBuildFarm(self.path)
-
- def write_hosts(self, hosts):
- for host in hosts:
- self.buildfarm.hostdb.createhost(host)
-
-
class StormHostDatabaseTests(testtools.TestCase, HostDatabaseTests):
def setUp(self):
self.db = StormHostDatabase()
-class StormCachingBuildResultStoreTests(StormCachingBuildFarmTestCase,BuildResultStoreTestBase):
+class StormCachingBuildResultStoreTests(BuildFarmTestCase,BuildResultStoreTestBase):
def setUp(self):
- StormCachingBuildFarmTestCase.setUp(self)
+ BuildFarmTestCase.setUp(self)
BuildResultStoreTestBase.setUp(self)
self.x = self.buildfarm.builds
""")
self.x.upload_build(Build(path[:-4], "tdb", "charis", "cc"))
self.assertEquals("myrev", self.x.get_latest_revision("tdb", "charis", "cc"))
-
-
-
-class StormCachingBuildFarmTests(BuildFarmTestBase, StormCachingBuildFarmTestCase):
-
- def setUp(self):
- StormCachingBuildFarmTestCase.setUp(self)
- BuildFarmTestBase.setUp(self)
- self.x = self.buildfarm
parser.add_option("--port", help="Port to listen on [localhost:8000]",
default="localhost:8000", type=str)
opts, args = parser.parse_args()
- from buildfarm.sqldb import StormCachingBuildFarm
- buildfarm = StormCachingBuildFarm()
+ from buildfarm.sqldb import BuildFarm
+ buildfarm = BuildFarm()
buildApp = BuildFarmApp(buildfarm)
from wsgiref.simple_server import make_server
import mimetypes
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
-from buildfarm.sqldb import StormCachingBuildFarm
+from buildfarm.sqldb import BuildFarm
import optparse
import sys
(opts, args) = parser.parse_args()
-buildfarm = StormCachingBuildFarm()
+buildfarm = BuildFarm()
if opts.tree:
builds = buildfarm.get_tree_builds(opts.tree)
MissingRevisionInfo,
NoSuchBuildError,
)
-from buildfarm.sqldb import StormCachingBuildFarm
+from buildfarm.sqldb import BuildFarm
from buildfarm.web import build_uri
from email.mime.text import MIMEText
import logging
resource.setrlimit(resource.RLIMIT_RSS, (300000, 300000))
resource.setrlimit(resource.RLIMIT_DATA, (300000, 300000))
-buildfarm = StormCachingBuildFarm(timeout=40.0)
+buildfarm = BuildFarm(timeout=40.0)
smtp = smtplib.SMTP()
smtp.connect()
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
-from buildfarm.sqldb import StormCachingBuildFarm
+from buildfarm.sqldb import BuildFarm
from buildfarm.web import host_uri
import optparse
import smtplib
parser.add_option("--dry-run", help="Don't actually send any emails.", action="store_true")
(opts, args) = parser.parse_args()
-buildfarm = StormCachingBuildFarm(timeout=40.0)
+buildfarm = BuildFarm(timeout=40.0)
smtp = smtplib.SMTP()
smtp.connect()
)
from buildfarm.hostdb import NoSuchHost
-from buildfarm.sqldb import StormCachingBuildFarm, StormBuild
+from buildfarm.sqldb import BuildFarm, StormBuild
-buildfarm = StormCachingBuildFarm()
+buildfarm = BuildFarm()
store = buildfarm._get_store()
git.samba.org / build-farm.git / commitdiff