boxcar 0.10005.1

data/test/acceptance/version_test.rb

@@ -0,0 +1,15 @@
+require File.expand_path("../base", __FILE__)
+
+describe "vagrant version" do
+  include_context "acceptance"
+
+  it "prints the version when called with '-v'" do
+    result = execute("vagrant", "-v")
+    result.stdout.should match_output(:version, config.vagrant_version)
+  end
+
+  it "prints the version when called with '--version'" do
+    result = execute("vagrant", "--version")
+    result.stdout.should match_output(:version, config.vagrant_version)
+  end
+end

data/test/buildbot/README.md

@@ -0,0 +1,72 @@
+# Vagrant Buildbot System
+
+This is the code for the Vagrant buildbot system. [Buildbot](http://buildbot.net)
+is a continuous integration system that offers an extreme amount
+of flexibility and power.
+
+This directory contains a few subdirectories to setup this CI system:
+
+* `buildbot_config` - This contains the custom Python code to setup the
+  various parts of the buildbot configuration.
+* `master` - This is mostly auto-generated from Buildbot itself, however
+  the `master.cfg` file is the configuration used on the buildmaster.
+* `slave`- This is mostly auto-generated from Buildbot, but the
+  `buildbot.tac` contains some custom code in it to connect to the Vagrant
+  buildmaster.
+
+**NOTE:** One of the dependencies for the Vagrant CI system is currently
+not public, and as such can't be setup by the general public. This will be
+fixed in the next couple weeks.
+
+## Contribute a CI Slave!
+
+**NOTE:** The slave contribution process is still not completely setup and
+will be ironed out very soon after the CI system is up and running.
+
+Vagrant is an open source profit which doesn't have any income from support,
+services, or otherwise. All Vagrant slave machines are donated by the
+community. Donating a machine doesn't require anything more than installing
+and running the slave software. Vagrant is specifically looking for slave
+machines that provide a diverse set of operating systems and cpu architectures
+for testing Vagrant.
+
+## Setting up the Buildmaster
+
+To set up the buildmaster, clone out this directory somewhere and install
+the dependencies:
+
+    pip install -r requirements.txt
+
+Once the dependencies are installed, create a configuration file with the
+settings you want to use somewhere. The settings available for a master are
+defined in `buildbot_config/config/master.py`. An example configuration file:
+
+    [master]
+    slaves=foo:password,bar:anotherpassword
+    web_port=8000
+
+Execute the buildbot using:
+
+    BUILDBOT_CONFIG=/path/to/my/config.cfg buildbot start master/
+
+## Setting up a Buildslave
+
+To set up a slave, clone out this directory and install the dependencies:
+
+    pip install -r requirements.txt
+
+Then, create a configuration file with the slave settings. The settings
+available for a slave are defined in `buildbot_config/config/slave.py`.
+An example configuration file:
+
+    [slave]
+    master_host=ci.vagrantup.com
+    master_port=9989
+    name=the-love-machine
+    password=foobarbaz
+
+Note that the password above will be assigned to you as part of donating
+any slave machine, since it must be setup on the buildmaster side as well.
+Once the configuration is done, run the slave:
+
+    BUILDBOT_CONFIG=/path/to/my/config.cfg buildslave start slave/

data/test/buildbot/buildbot_config/config/loader.py

@@ -0,0 +1,24 @@
+"""
+This module contains the configuration loader for a specific
+choices instance. This is used internally to load the settings.
+"""
+
+import os
+
+from choices import ConfigFileLoader
+
+def load_settings(choices, type):
+    """
+    This will load the proper settings for the given choices
+    instance.
+
+    :Parameters:
+      - `choices`: The choices instance to load.
+      - `type`: The type of configuration, either "master" or
+        "slave"
+    """
+    if "BUILDBOT_CONFIG" not in os.environ:
+        raise ValueError, "BUILDBOT_CONFIG must be set to point to where the configuration file is."
+
+    choices.add_loader(ConfigFileLoader(os.environ["BUILDBOT_CONFIG"], type))
+    return choices.load()

data/test/buildbot/buildbot_config/config/master.py

@@ -0,0 +1,24 @@
+"""
+This module contains the choices definition for settings required
+for the build master to run.
+"""
+
+from choices import Choices
+
+from loader import load_settings
+
+#----------------------------------------------------------------------
+# Define the Settings
+#----------------------------------------------------------------------
+c = Choices()
+c.define('title', type=str, help="Buildmaster title")
+c.define('title_url', type=str, help="URL for title page")
+c.define('buildbot_url', type=str, help="URL to the buildbot master.")
+c.define('slaves', type=str, help="A list of the slave machines. The format should be name:password,name:password,...")
+c.define('web_port', type=int, help="Port to listen on for web service.")
+c.define('http_users', type=str, help="username:password list of users.")
+
+#----------------------------------------------------------------------
+# Load the Settings
+#----------------------------------------------------------------------
+options = load_settings(c, "master")

data/test/buildbot/buildbot_config/config/slave.py

@@ -0,0 +1,22 @@
+"""
+This module contains the choices definition for settings required for the
+build slave to run.
+"""
+
+from choices import Choices
+
+from loader import load_settings
+
+#----------------------------------------------------------------------
+# Define the Settings
+#----------------------------------------------------------------------
+c = Choices()
+c.define("master_host", type=str, help="Host of the build master.")
+c.define("master_port", type=int, help="Port that is listening or build masters.")
+c.define("name", type=str, help="Name of the slave machine.")
+c.define("password", type=str, help="Password for the slave machine to communicate with the master.")
+
+#----------------------------------------------------------------------
+# Load the Settings
+#----------------------------------------------------------------------
+options = load_settings(c, "slave")

data/test/buildbot/buildbot_config/master/__init__.py

@@ -0,0 +1,6 @@
+import buildsteps
+from builders import get_builders
+from change_sources import get_change_sources
+from schedulers import get_schedulers
+from slaves import get_slaves_from_config
+from status import get_status

data/test/buildbot/buildbot_config/master/builders.py

@@ -0,0 +1,78 @@
+"""
+This module contains the logic to create and return the various builders
+that this buildmaster supports. The builders are responsible for taking
+a set of changes and giving the steps necessary to build the project.
+"""
+
+from buildbot.config import BuilderConfig
+from buildbot.process.factory import BuildFactory
+from buildbot.process.properties import WithProperties
+from buildbot.steps.source.git import Git
+
+from buildbot_config.master import buildsteps
+
+def get_builders(slaves):
+    """
+    This returns a list of builder configurations for the given
+    slaves.
+    """
+    return get_vagrant_builders("master", slaves)
+
+def get_vagrant_builders(branch, slaves):
+    """
+    This returns a list of the builders that represent the entire
+    chain for a given branch (unit, acceptance, packaging builds).
+    """
+    platforms = ["linux", "osx", "win"]
+    builders = []
+
+    for platform in platforms:
+        platform_slaves = [s.slavename for s in slaves if platform in s.slavename]
+
+        if len(platform_slaves) > 0:
+            unit = BuilderConfig(
+                name="%s-%s-unit" % (platform, branch),
+                slavenames=platform_slaves,
+                factory=make_vagrant_unit_factory(branch))
+
+            acceptance = BuilderConfig(
+                name="%s-%s-acceptance" % (platform, branch),
+                slavenames=platform_slaves,
+                factory=make_vagrant_acceptance_factory(branch))
+
+            builders.extend([unit, acceptance])
+
+    return builders
+
+def make_vagrant_unit_factory(branch):
+    """
+    This returns the factory that runs the Vagrant unit tests.
+    """
+    f = BuildFactory()
+    f.addStep(Git(repourl="git://github.com/mitchellh/vagrant.git",
+                  branch=branch,
+                  mode="full",
+                  method="fresh",
+                  shallow=True))
+    f.addStep(buildsteps.Bundler())
+    f.addStep(buildsteps.UnitTests())
+
+    return f
+
+def make_vagrant_acceptance_factory(branch):
+    """
+    This returns a build factory that knows how to run the Vagrant
+    acceptance tests.
+    """
+    f = BuildFactory()
+    f.addStep(Git(repourl="git://github.com/mitchellh/vagrant.git",
+                  branch=branch,
+                  mode="full",
+                  method="fresh",
+                  shallow=True))
+    f.addStep(buildsteps.Bundler())
+    f.addStep(buildsteps.AcceptanceBoxes())
+    f.addStep(buildsteps.AcceptanceConfig())
+    f.addStep(buildsteps.AcceptanceTests())
+
+    return f

data/test/buildbot/buildbot_config/master/buildsteps.py

@@ -0,0 +1,100 @@
+"""
+Contains various buildsteps that the build master uses.
+"""
+
+import os
+
+from buildbot.steps.shell import ShellCommand
+from buildbot.process.properties import WithProperties
+
+class Bundler(ShellCommand):
+    """
+    Runs bundler to get the dependencies for a Ruby project.
+    """
+
+    name = "bundler"
+    description = "bundle install"
+    descriptionDone = "bundler install complete"
+    command = ["bundle", "install"]
+    flunkOnFailure = True
+    haltOnFailure = True
+
+class UnitTests(ShellCommand):
+    """
+    Runs the unit tests via a rake command.
+    """
+
+    name = "unit tests"
+    description = "unit tests"
+    descriptionDone = "passed unit tests"
+    command = ["rake", "test:unit"]
+    flunkOnFailure = True
+    haltOnFailure = True
+
+class AcceptanceBoxes(ShellCommand):
+    """
+    This step will download all the boxes required for the tests.
+    """
+
+    name = "acceptance test boxes"
+    description = "downloading required boxes"
+    descriptionDone = description
+    flunkOnFailure = True
+    haltOnFailure = True
+
+    # Make some of our variables renderable with build properties
+    renderables = ShellCommand.renderables + ["box_dir"]
+
+    def __init__(self, **kwargs):
+        self.box_dir = WithProperties("%(workdir)s/boxes")
+        ShellCommand.__init__(self, **kwargs)
+
+    def start(self):
+        # Set the property of the box directory so that later steps
+        # can use it.
+        self.setProperty("box_dir", self.box_dir, self.name)
+
+        # Set the command to be correct
+        self.setCommand(["rake", "acceptance:boxes[%s]" % self.box_dir])
+
+        # Run the actual start method
+        ShellCommand.start(self)
+
+class AcceptanceConfig(ShellCommand):
+    """
+    This step generates the configuration for the acceptance test.
+    """
+
+    name = "acceptance test config"
+    description = "generating config"
+    descriptionDone = "config generated"
+    command = ["rake", WithProperties("acceptance:config[%(box_dir)s]")]
+    flunkOnFailure = True
+    haltOnFailure = True
+
+    def commandComplete(self, cmd):
+        # Set a property with the location of the config file
+        config_path = os.path.join(self.getProperty("workdir"),
+                                   self.getWorkdir(), "acceptance_config.yml")
+        self.setProperty("acceptance_config_path", config_path, self.name)
+
+        ShellCommand.commandComplete(self, cmd)
+
+class AcceptanceTests(ShellCommand):
+    """
+    This step runs the actual acceptance tests.
+    """
+
+    name = "acceptance tests"
+    description = "running"
+    descriptionDone = "done"
+    command = ["rake", "test:acceptance"]
+    flunkOnFailure = True
+    haltOnFailure = True
+
+    def __init__(self, **kwargs):
+        # Make sure that the proper environment variables for the test
+        # get passed through to the slave
+        kwargs["env"] = { "ACCEPTANCE_CONFIG": WithProperties("%(acceptance_config_path)s") }
+        kwargs["timeout"] = 3600
+        ShellCommand.__init__(self, **kwargs)

data/test/buildbot/buildbot_config/master/change_sources.py

@@ -0,0 +1,8 @@
+"""
+Contains the logic to build and return the change sources for
+the build master.
+"""
+
+def get_change_sources():
+    # Currently no sources since we're using a GitHub hook
+    return []

data/test/buildbot/buildbot_config/master/schedulers.py

@@ -0,0 +1,32 @@
+"""
+This module contains the logic which returns the set of
+schedulers to use for the build master.
+"""
+
+from buildbot.changes.filter import ChangeFilter
+from buildbot.schedulers.basic import (
+    Dependent,
+    SingleBranchScheduler)
+
+def get_schedulers(builders):
+    platforms = ["linux", "osx", "win"]
+    schedulers = []
+
+    for platform in platforms:
+        platform_builders = [b for b in builders if platform in b.name]
+
+        # Unit tests for this platform
+        unit_builders = [b.name for b in platform_builders if "unit" in b.name]
+        master_unit = SingleBranchScheduler(name="%s-master-unit" % platform,
+                                            change_filter=ChangeFilter(branch="master"),
+                                            treeStableTimer=60,
+                                            builderNames=unit_builders)
+
+        acceptance_builders = [b.name for b in platform_builders if "acceptance" in b.name]
+        master_acceptance = Dependent(name="%s-master-acceptance" % platform,
+                                      upstream=master_unit,
+                                      builderNames=acceptance_builders)
+
+        schedulers.extend([master_unit, master_acceptance])
+
+    return schedulers

data/test/buildbot/buildbot_config/master/slaves.py

@@ -0,0 +1,60 @@
+"""
+This module contains the classes and methods which help load the
+list of available build slaves based on the configuration.
+"""
+
+from buildbot.buildslave import BuildSlave
+
+class BuildSlavesFromSlaveConfigs(list):
+    """
+    This object turns the ``SlaveConfig`` objects into actual
+    ``BuildSlave`` objects. This list can be directly used as the
+    setting.
+    """
+
+    def __init__(self, configs):
+        for config in configs:
+            self.append(BuildSlave(config.name, config.password))
+
+class SlaveListFromConfig(list):
+    """
+    This object knows how to parse the slave configuration settings
+    and load them into ``SlaveConfig`` value objects. The results
+    can be read directly from this list.
+    """
+
+    def __init__(self, config):
+        for config in self._slave_configs(config):
+            self.append(config)
+
+    def _slave_configs(self, config):
+        """
+        Returns an array of all the slaves that were configured
+        with the given configuration string.
+        """
+        results = []
+        for single in config.split(","):
+            results.append(SlaveConfig(*single.split(":")))
+
+        return results
+
+class SlaveConfig(object):
+    """
+    This is a value class, meant to be immutable, representing
+    the configuration of a single slave.
+    """
+
+    def __init__(self, name, password):
+        self.name = name
+        self.password = password
+
+    def __eq__(self, other):
+        """
+        Provides equality tests for slave configurations, specifically
+        for tests.
+        """
+        return self.__dict__ == other.__dict__
+
+# Shortcut methods to make things a bit nicer
+def get_slaves_from_config(config):
+    return BuildSlavesFromSlaveConfigs(SlaveListFromConfig(config))