vagrant 1.0.7 → 1.5.0

data/test/acceptance/version_test.rb

@@ -1,15 +0,0 @@
-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

@@ -1,72 +0,0 @@
-# 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

@@ -1,24 +0,0 @@
-"""
-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

@@ -1,24 +0,0 @@
-"""
-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

@@ -1,22 +0,0 @@
-"""
-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

@@ -1,6 +0,0 @@
-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

@@ -1,78 +0,0 @@
-"""
-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

@@ -1,100 +0,0 @@
-"""
-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

@@ -1,8 +0,0 @@
-"""
-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

@@ -1,32 +0,0 @@
-"""
-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

@@ -1,60 +0,0 @@
-"""
-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))