Merge lp:~blake-rouse/maas/maas-automate into lp:~maas-committers/maas/trunk

[Gavin Panella]

[MAAS Lander (maas-lander)]

Transitioned to Git.

lp:maas has now moved from Bzr to Git.
Please propose your branches with Launchpad using Git.

git clone https://git.launchpad.net/maas

Unmerged revisions

4300. By Blake Rouse on 2015-10-15

Configure subnets and add the boilerplate for importing boot images.

4299. By Blake Rouse on 2015-10-06

Add all the logic to configure boot images, clusters, and interfaces.

4298. By Blake Rouse on 2015-10-05

Fix code the run inside the container.

4297. By Blake Rouse on 2015-10-05

Start of maas-automate.

4296. By Blake Rouse on 2015-10-04

Maas automate.

=== modified file 'Makefile'
--- Makefile	2015-12-21 21:19:44 +0000
+++ Makefile	2015-12-22 17:03:15 +0000
@@ -81,6 +81,13 @@
 	echo '/src/**/*.pyc' >> $@
 	echo '/etc/**/*.pyc' >> $@
 
+<<<<<<< TREE
+=======
+bin/python:
+	$(virtualenv) --python=$(python) --system-site-packages $(CURDIR)
+	#bin/pip install hypothesis==0.7.2  # buildout can't install this.
+
+>>>>>>> MERGE-SOURCE
 configure-buildout:
 	utilities/configure-buildout
 
@@ -140,6 +147,10 @@
 	$(buildout) install config-test
 	@touch --no-create $@
 
+bin/maas-automate: bin/buildout buildout.cfg versions.cfg setup.py
+	$(buildout) install automate
+	@touch --no-create $@
+
 bin/flake8: bin/buildout buildout.cfg versions.cfg setup.py
 	$(buildout) install flake8
 	@touch --no-create $@

=== modified file 'buildout.cfg'
--- buildout.cfg	2015-12-08 14:51:58 +0000
+++ buildout.cfg	2015-12-22 17:03:15 +0000
@@ -259,6 +259,16 @@
   environ.setdefault("DEV_DB_NAME", "test_maas_e2e")
   environ.setdefault("MAAS_PREVENT_MIGRATIONS", "1")
 
+[automate]
+recipe = zc.recipe.egg
+eggs =
+entry-points =
+  maas-automate=maasautomate.main:main
+extra-paths =
+  ${common:extra-paths}
+scripts =
+  maas-automate
+
 [flake8]
 recipe = zc.recipe.egg
 eggs =

=== added file 'maas-automate.yaml'
--- maas-automate.yaml	1970-01-01 00:00:00 +0000
+++ maas-automate.yaml	2015-12-22 17:03:15 +0000
@@ -0,0 +1,179 @@
+# Configuration for the MAAS Automation tool.
+
+# Creator to use for building of MAAS.
+#
+# Available Creators:
+#   creator:
+#     type: lxc-clone
+#     name: maas         # Name of the container to clone.
+#     username: ubuntu   # Username of the user to place
+#                        # data. (Default: ubuntu)
+#     path: /srv/data    # Path to build the package and install
+#                        # from. (Default: /home/{username}/maas-automate)
+#
+creator:
+  type: lxc-clone
+  name: maas
+  dist_upgrade: false
+
+# Install curtin from a branch instead of using the distributions
+# curtin package.
+#curtin:
+#  branch: lp:curtin
+
+# Configuration that is applied to the MAAS deployment before any nodes are
+# enlisted or probed into MAAS. All boot images will also be imported before
+# any enlistment or probing is done.
+config:
+  boot_sources:
+    - url: http://maas.ubuntu.com/images/ephemeral-v2/releases/
+      keyring_filename: /usr/share/keyrings/ubuntu-cloudimage-keyring.gpg
+      selections:
+        - os: ubuntu
+          release: precise
+          arches:
+            - amd64
+            - i386
+        - os: ubuntu
+          release: trusty
+          arches:
+            - amd64
+            - i386
+        - os: ubuntu
+          release: vivid
+          arches:
+            - amd64
+            - i386
+  ubuntu:
+    main_archive: http://archive.ubuntu.com/ubuntu
+    ports_archive: http://ports.ubuntu.com/ubuntu-ports
+  boot:
+    kernel_opts: ""
+  network:
+    http_proxy: ""
+    upstream_dns: 192.168.1.1
+    ntp_server: ntp.ubuntu.com
+  clusters:
+    master:
+      name: maas
+      interfaces:
+        eth0:
+          management: 2
+          ip: 192.168.122.2
+          router_ip: 192.168.122.1
+          subnet_mask: 255.255.255.0
+          ip_range_low: 192.168.122.150
+          ip_range_high: 192.168.122.254
+          static_ip_range_low: 192.168.122.10
+          static_ip_range_high: 192.168.122.149
+  subnets:
+    - cidr: 192.168.123.0/24
+      vlan: 1
+
+# Probe for the following chassis and enlist all the machines in those
+# chasis into the MAAS.
+probe:
+  - type: virsh
+    address: qemu+ssh://blake@192.168.122.1/system
+    password: p@ssw0rd
+    prefix_filter: maas
+    machines: 4
+    timeout: 60
+
+# Modify the configuration of the selected machines below. The machines are
+# identified by a MAS address of one of its interfaces. This list doesn't need
+# to contain all the machines, just the machines that needs modifications
+# performed.
+machines:
+  - mac_address: 52:54:00:f1:ec:be
+    architecture: amd64/generic
+    storage:
+      layout: flat
+    networking:
+      interfaces:
+        - mac_address: 52:54:00:f1:ec:be
+          links:
+            - type: auto
+              subnet: 192.168.122.0/24
+            - type: static
+              subnet: 192.168.123.0/24
+              ip: 192.168.123.50
+  - mac_address: 52:54:00:80:cc:02
+    architecture: i386/generic
+    storage:
+      layout: lvm
+    networking:
+      interfaces:
+        - mac_address: 52:54:00:80:cc:02
+          links:
+            - type: auto
+              subnet: 192.168.122.0/24
+        - mac_address: 52:54:00:f2:0a:bd
+          links:
+            - type: auto
+              subnet: 192.168.122.0/24
+        - mac_address: 2:54:00:0f:58:77
+          links:
+            - type: auto
+              subnet: 192.168.122.0/24
+
+# Deploy the following configurations. Multiple will be performed at once until
+# all deployment options are choosen. Even if one fails all the others will
+# still be performed, until all have been performed.
+deploy:
+  - os: ubuntu
+    release: precise
+    hwe_kernel: hwe-p
+    arch: amd64
+  - os: ubuntu
+    release: precise
+    hwe_kernel: hwe-t
+    arch: amd64
+  - os: ubuntu
+    release: precise
+    hwe_kernel: hwe-v
+    arch: amd64
+  - os: ubuntu
+    release: trusty
+    hwe_kernel: hwe-t
+    arch: amd64
+  - os: ubuntu
+    release: trusty
+    hwe_kernel: hwe-v
+    arch: amd64
+  - os: ubuntu
+    release: vivid
+    arch: amd64
+  - os: ubuntu
+    release: wily
+    arch: amd64
+  - os: ubuntu
+    release: trusty
+    arch: i386
+  - os: ubuntu
+    release: vivid
+    arch: i386
+  - os: ubuntu
+    release: wily
+    arch: i386
+
+# Use the MAAS installation with Juju. The list of deployments will be tried
+# in order with Juju. If one of the deployments fails all the others will
+# still be performed, untill all have been performed.
+juju:
+  - ppa: juju/stable
+    options:
+      disable_network_management: true
+    deploy:
+      - charm: trusty/mysql
+      - charm: trusty/wordpress
+        relate: trusty/mysql
+        expose: true
+  - ppa: juju/devel
+    options:
+      use_address_allocation: true
+    deploy:
+      - charm: trusty/mysql
+      - charm: trusty/wordpress
+        relate: trusty/mysql
+        expose: true

=== added directory 'src/maasautomate'
=== added file 'src/maasautomate/__init__.py'
=== added file 'src/maasautomate/config.py'
--- src/maasautomate/config.py	1970-01-01 00:00:00 +0000
+++ src/maasautomate/config.py	2015-12-22 17:03:15 +0000
@@ -0,0 +1,76 @@
+# Copyright 2015 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""Configuration for MAAS automate."""
+
+from __future__ import (
+    absolute_import,
+    print_function,
+    unicode_literals,
+    )
+
+str = None
+
+__metaclass__ = type
+__all__ = []
+
+import base64
+import os
+
+import yaml
+
+
+DEFAULT_CONFIG_PATH = "~/.maas/automate.yaml"
+
+
+class MissingConfigError(Exception):
+    """Raise when the configuration file is missing."""
+
+
+class InvalidConfigError(Exception):
+    """Raise when the configuration file is invalid."""
+
+
+def find_config():
+    """Return the path to the configuration file."""
+    path = os.environ.get("MAAS_AUTOMATE_CONFIG", DEFAULT_CONFIG_PATH)
+    path = os.path.expanduser(path)
+    if not os.path.exists(path):
+        raise MissingConfigError(
+            "Unable to find configuration file: %s" % path)
+    else:
+        return path
+
+
+def load_config():
+    """Load the configuration file."""
+    path = find_config()
+    with open(path, "r") as fp:
+        return yaml.load(fp.read())
+
+
+def load_config_from_base64(data):
+    """Load the configuration from base64."""
+    config = base64.b64decode(data)
+    return yaml.load(config)
+
+
+def get_config_value(
+        config, key, default=None, required=False, section="global"):
+    """Return the config value from `config` for `key`.
+
+    `config` does not have to be the entire loaded config, it can be
+    just a piece of the config as well.
+    """
+    assert isinstance(config, dict)
+    if required and key not in config:
+        raise InvalidConfigError(
+            "%s is required in the %s section." % (key, section))
+    else:
+        return config.get(key, default)
+
+
+def convert_config_to_base64(config):
+    """Return the config in base64 YAML."""
+    config = yaml.dump(config)
+    return base64.b64encode(config)

=== added file 'src/maasautomate/console.py'
--- src/maasautomate/console.py	1970-01-01 00:00:00 +0000
+++ src/maasautomate/console.py	2015-12-22 17:03:15 +0000
@@ -0,0 +1,70 @@
+# Copyright 2015 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""Output information to the console."""
+
+from __future__ import (
+    absolute_import,
+    print_function,
+    unicode_literals,
+    )
+
+str = None
+
+__metaclass__ = type
+__all__ = []
+
+from functools import partial
+from subprocess import (
+    PIPE,
+    Popen,
+    STDOUT,
+)
+import sys
+
+from provisioningserver.utils.shell import ExternalProcessError
+
+
+def run_command(command, *args, **kwargs):
+    """Run `command` while outputting to the console."""
+    output = kwargs.pop("output", True)
+    prefix = kwargs.pop("prefix", None)
+    process = Popen(command, *args, stdout=PIPE, stderr=STDOUT, **kwargs)
+    ret = ""
+    while True:
+        line = process.stdout.readline()
+        if line != "":
+            ret += line
+            if output:
+                if prefix:
+                    sys.stdout.write("%s: %s" % (prefix, line))
+                else:
+                    sys.stdout.write(line)
+                sys.stdout.flush()
+        else:
+            returncode = process.wait()
+            if returncode != 0:
+                raise ExternalProcessError(
+                    process.returncode, command, output=ret)
+            else:
+                break
+    return ret
+
+
+def print_prefix(prefix, msg):
+    """Print the message with prefix."""
+    print("%s: %s" % (prefix, msg))
+
+
+start = partial(print_prefix, "S")
+install = partial(print_prefix, "I")
+config = partial(print_prefix, "C")
+enlist = partial(print_prefix, "E")
+deploy = partial(print_prefix, "D")
+
+cmd = run_command
+start_cmd = partial(run_command, prefix="S")
+install_cmd = partial(run_command, prefix="I")
+config_cmd = partial(run_command, prefix="C")
+enlist_cmd = partial(run_command, prefix="E")
+deploy_cmd = partial(run_command, prefix="D")

=== added file 'src/maasautomate/creator.py'
--- src/maasautomate/creator.py	1970-01-01 00:00:00 +0000
+++ src/maasautomate/creator.py	2015-12-22 17:03:15 +0000
@@ -0,0 +1,123 @@
+# Copyright 2015 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""
+Creator core for MAAS automate.
+
+Each specific module is loaded from maasautomate.creators. This just provides
+the logic to load the specific creator based on the configuration file.
+"""
+
+from __future__ import (
+    absolute_import,
+    print_function,
+    unicode_literals,
+    )
+
+str = None
+
+__metaclass__ = type
+__all__ = []
+
+from importlib import import_module
+import os
+
+from maasautomate import console
+from maasautomate.config import (
+    convert_config_to_base64,
+    get_config_value,
+)
+
+
+class InvalidCreatorError(Exception):
+    """Raised when the creator does not exist or is not exporting the correct
+    attributes."""
+
+
+class CreatorFailError(Exception):
+    """Raised when the creator failed."""
+
+
+class Creator:
+    """Creator that provides the logic for automating MAAS.
+
+    This wraps the backend driver so different backends can be supported.
+    """
+
+    def __init__(self, creator_name, run_data, config, driver):
+        self.creator_name = creator_name
+        self.run_data = run_data
+        self.config = config
+        self.driver = driver
+
+    def start(self):
+        """Start the creator."""
+        # The driver provides all this logic.
+        console.start(
+            "Starting the machine with creator '%s'." % self.creator_name)
+        self.driver.start()
+
+    def cleanup(self):
+        """Cleanup the creator."""
+        # The driver provides all the logic.
+        self.driver.cleanup()
+
+    def run_internal(self):
+        """Run automate inside of the machine."""
+        # Place the tarball into the machine.
+        console.start("Injecting the branch in the machine.")
+        tarball_path = self.driver.inject_tarball()
+        self.run_data.workdir = os.path.dirname(tarball_path)
+        tarball_name = os.path.basename(tarball_path)
+
+        # Extract the tarball and set the working directory to the contents.
+        console.start("Extracting the branch onto the machine.")
+        self.driver.execute_command(
+            console.start_cmd, ["tar", "zxf", tarball_name])
+        self.run_data.workdir = os.path.join(
+            self.run_data.workdir, tarball_name.replace(".tar.gz", ""))
+
+        # Start the runner inside the machine.
+        run_internal_data = convert_config_to_base64(self.config)
+        console.start("Starting MAAS automate inside the machine.")
+        self.driver.execute_command(console.cmd, [
+            "make", "bin/maas-automate"
+            ], output=False)
+        try:
+            self.driver.execute_command(console.cmd, [
+                "bin/maas-automate", "--run-internal", run_internal_data
+                ])
+        except console.ExternalProcessError:
+            # Catch this error as the internal run will print the real error
+            # internal on the machine.
+            raise CreatorFailError()
+
+
+def get_creator_driver_import_path(creator_type):
+    """Return the import path for the creator type."""
+    creator_type = creator_type.replace('-', '_')
+    return "maasautomate.creators.%s" % creator_type
+
+
+def import_creator_driver(creator_type, run_data, config):
+    """Import the creator driver."""
+    module_path = get_creator_driver_import_path(creator_type)
+    try:
+        module = import_module(module_path)
+    except ImportError:
+        raise InvalidCreatorError("Creator %s does not exist." % creator_type)
+    else:
+        if not hasattr(module, "load_creator"):
+            raise InvalidCreatorError(
+                "Creator %s is missing the required load_creator function." % (
+                    creator_type))
+    return module.load_creator(run_data, config)
+
+
+def load_creator(run_data, config):
+    """Load the creator from the config."""
+    creator_config = get_config_value(config, "creator", required=True)
+    creator_type = get_config_value(
+        creator_config, "type", required=True, section="creator")
+    driver = import_creator_driver(creator_type, run_data, creator_config)
+    return Creator(creator_type, run_data, config, driver)

=== added directory 'src/maasautomate/creators'
=== added file 'src/maasautomate/creators/__init__.py'
=== added file 'src/maasautomate/creators/lxc_clone.py'
--- src/maasautomate/creators/lxc_clone.py	1970-01-01 00:00:00 +0000
+++ src/maasautomate/creators/lxc_clone.py	2015-12-22 17:03:15 +0000
@@ -0,0 +1,175 @@
+# Copyright 2015 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""
+lxc-clone creator for MAAS automate.
+
+Creator that clones an already existing LXC to perform the automation. This
+allows the developer to setup the LXC before starting the automation.
+"""
+
+from __future__ import (
+    absolute_import,
+    print_function,
+    unicode_literals,
+    )
+
+str = None
+
+__metaclass__ = type
+__all__ = [
+    "load_creator"
+]
+
+import os
+from shutil import copyfile
+
+from maasautomate.config import get_config_value
+from provisioningserver.utils.fs import ensure_dir
+from provisioningserver.utils.shell import (
+    call_and_check,
+    ExternalProcessError,
+)
+
+
+class LXCCloneCreator:
+
+    def __init__(self, run_data, config):
+        self.run_data = run_data
+        self.config = config
+        self.name = get_config_value(
+            config, "name", required=True, section="creator")
+        self.username = get_config_value(
+            config, "username", default="ubuntu")
+
+    def _get_containers(self):
+        """Return list of existing containers."""
+        return [
+            line.strip()
+            for line in call_and_check(["lxc-ls"]).splitlines()
+        ]
+
+    def _run_container_exists(self):
+        """Return True if the run container exists."""
+        containers = self._get_containers()
+        return self.run_data.run_name in containers
+
+    def _clone_container(self):
+        """Clone the container."""
+        call_and_check([
+            "lxc-clone",
+            self.name,
+            self.run_data.run_name,
+            ])
+
+    def _start_container(self):
+        """Start the container."""
+        call_and_check([
+            "lxc-start",
+            "-d",
+            "-q",
+            "-n",
+            self.run_data.run_name,
+        ])
+
+    def _get_container_rootfs(self):
+        """Return the path to the containers rootfs."""
+        output = call_and_check([
+            "lxc-info",
+            "-n",
+            self.run_data.run_name,
+            "-c",
+            "lxc.rootfs",
+        ])
+        return output.split("=")[1].strip()
+
+    def start(self):
+        """Create and start the container."""
+        self._clone_container()
+        self._start_container()
+
+    def cleanup(self):
+        """Clean up the created container."""
+        try:
+            call_and_check([
+                "lxc-stop",
+                "-k",
+                "-n",
+                self.run_data.run_name,
+                ])
+        except ExternalProcessError:
+            # Ignore the error, might already be stopped.
+            pass
+        if self._run_container_exists():
+            call_and_check([
+                "lxc-destroy",
+                "-n",
+                self.run_data.run_name,
+            ])
+
+    def inject_tarball(self):
+        """Inject the tarball directly into the container."""
+        path = get_config_value(
+            self.config, "path", default=None, required=False)
+        if path is None:
+            path = "/home/%s/maas-automate" % self.username
+
+        # Create the required directory.
+        injection_path = os.path.join(
+            self._get_container_rootfs(), path.lstrip("/"))
+        ensure_dir(injection_path)
+
+        # Inject the file into the container.
+        tarball_base = os.path.basename(self.run_data.tarball)
+        injection_filepath = os.path.join(injection_path, tarball_base)
+        copyfile(self.run_data.tarball, injection_filepath)
+
+        # Set the permissions correctly.
+        inside_path = os.path.join(path, tarball_base)
+        call_and_check([
+            "lxc-attach",
+            "-n",
+            self.run_data.run_name,
+            "--clear-env",
+            "--",
+            "chown",
+            "%s:%s" % (self.username, self.username),
+            path
+            ])
+        call_and_check([
+            "lxc-attach",
+            "-n",
+            self.run_data.run_name,
+            "--clear-env",
+            "--",
+            "chown",
+            "%s:%s" % (self.username, self.username),
+            inside_path
+            ])
+
+        # Return the path from inside of the container.
+        return inside_path
+
+    def execute_command(self, runner, command, *args, **kwargs):
+        """Execute the command inside the container."""
+        bash_cmd = "cd %s && %s" % (
+            self.run_data.workdir,
+            " ".join(command),
+            )
+        return runner([
+            "lxc-attach",
+            "-n",
+            self.run_data.run_name,
+            "--clear-env",
+            "--",
+            "sudo",
+            "-u", self.username,
+            "/bin/bash",
+            "-c",
+            bash_cmd,
+        ], *args, **kwargs)
+
+
+def load_creator(run_data, config):
+    """Load the creator with `config`."""
+    return LXCCloneCreator(run_data, config)

=== added file 'src/maasautomate/main.py'
--- src/maasautomate/main.py	1970-01-01 00:00:00 +0000
+++ src/maasautomate/main.py	2015-12-22 17:03:15 +0000
@@ -0,0 +1,74 @@
+# Copyright 2015 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""
+MAAS Automate
+
+Tool to automate the installation of MAAS into an LXC container or a
+virtual machine. The newly installed MAAS with be configure, machines
+enlisted, commissioned, and deployments will be performed.
+"""
+
+from __future__ import (
+    absolute_import,
+    print_function,
+    unicode_literals,
+    )
+
+str = None
+
+__metaclass__ = type
+__all__ = []
+
+import argparse
+import sys
+
+from maasautomate.config import (
+    load_config,
+    load_config_from_base64,
+)
+from maasautomate.creator import (
+    CreatorFailError,
+    load_creator,
+)
+from maasautomate.run import (
+    build_run_data,
+    MAASRunner,
+)
+
+
+def main():
+    """Main entry point for the application."""
+    parser = argparse.ArgumentParser(
+        description="Automate the installation and testing of MAAS.")
+    parser.add_argument(
+        "--uncommitted", action="store_true", help=(
+            "Run automate with uncomitted code in the branch."))
+    parser.add_argument(
+        "--run-internal", help=(
+            "Run automate inside the deployed test machine. "
+            "(Only called internally by maas-automate.)"))
+    args = parser.parse_args()
+    if args.run_internal:
+        # Internal running, means we are running inside the machine.
+        # run_internal contains the base64 encode YAML config.
+        config = load_config_from_base64(args.run_internal)
+        runner = MAASRunner(config)
+        runner.run()
+    else:
+        # Not inside the machine so we need to spawn the machine with the
+        # creator and spawn the internal run.
+        run_data = build_run_data(uncommitted=args.uncommitted)
+        config = load_config()
+        creator = load_creator(run_data, config)
+
+        exit_code = 0
+        try:
+            creator.start()
+            creator.run_internal()
+        except CreatorFailError:
+            exit_code = 1
+        finally:
+            creator.cleanup()
+            run_data.cleanup()
+        sys.exit(exit_code)

=== added file 'src/maasautomate/monitor.py'
--- src/maasautomate/monitor.py	1970-01-01 00:00:00 +0000
+++ src/maasautomate/monitor.py	2015-12-22 17:03:15 +0000
@@ -0,0 +1,98 @@
+# Copyright 2015 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""Monitors MAAS to make sure it stays running."""
+
+from __future__ import (
+    absolute_import,
+    print_function,
+    unicode_literals,
+    )
+
+str = None
+
+__metaclass__ = type
+__all__ = []
+
+from abc import (
+    ABCMeta,
+    abstractmethod,
+    abstractproperty,
+)
+import threading
+import time
+import urllib2
+
+
+class MonitorTimeoutError(Exception):
+    """Raise when the monitor times out waiting."""
+
+
+class MonitorBase:
+
+    __metaclass__ = ABCMeta
+
+    def __init__(self):
+        self.running = False
+
+    def start(self):
+        """Start the monitor."""
+        self._event = threading.Event()
+        self._thread = threading.Thread(target=self._run)
+        self._thread.start()
+
+    def stop(self):
+        """Stop the monitor."""
+        self._event.set()
+        self._thread.join()
+
+    def wait_for_running(self, timeout=60 * 3):
+        """Wait for it to be running."""
+        for _ in range(timeout):
+            if self.running:
+                return
+            time.sleep(1)
+        raise MonitorTimeoutError(
+            "Waiting for '%s' to start running timed out after "
+            "%s seconds." % (self.name, timeout))
+
+    def _run(self):
+        """Run the monitor and update the status."""
+        while True:
+            if self._event.is_set():
+                return
+
+            # Update the running state.
+            self.running = self._monitor()
+
+            # Wait 5 seconds to check if running, but see if thread has been
+            # stopped every second.
+            for _ in range(5):
+                if self._event.is_set():
+                    return
+                time.sleep(1)
+
+    @abstractproperty
+    def name(self):
+        """Name of the service being monitored."""
+
+    @abstractmethod
+    def _monitor(self):
+        """Monitor the endpoint."""
+
+
+class MonitorRegion(MonitorBase):
+    """Monitors the MAAS region to make sure that it is running and stays
+    running."""
+
+    name = "regiond"
+
+    def _monitor(self):
+        """Monitor the RPC endpoint on the region to make sure that
+        it is working."""
+        try:
+            stream = urllib2.urlopen("http://localhost:5240/MAAS/rpc/")
+            stream.close()
+            return True
+        except urllib2.HTTPError:
+            return False

=== added file 'src/maasautomate/run.py'
--- src/maasautomate/run.py	1970-01-01 00:00:00 +0000
+++ src/maasautomate/run.py	2015-12-22 17:03:15 +0000
@@ -0,0 +1,356 @@
+# Copyright 2015 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""Provide the run data."""
+
+from __future__ import (
+    absolute_import,
+    print_function,
+    unicode_literals,
+    )
+
+str = None
+
+__metaclass__ = type
+__all__ = [
+    "build_run_data",
+]
+
+from collections import namedtuple
+from datetime import datetime
+import json
+import os
+import tempfile
+import time
+
+from maasautomate import console
+from maasautomate.config import get_config_value
+from maasautomate.monitor import MonitorRegion
+from maasserver.utils.version import get_maas_branch
+from provisioningserver.utils.shell import call_and_check
+
+
+class RunDataError(Exception):
+    """Raise when data gathering stage fails."""
+
+
+class RunError(Exception):
+    """Raise when an error performing the run."""
+
+
+RunDataBase = namedtuple("RunDataBase", [
+    "datetime",
+    "branch",
+    "tmpdir",
+    "tarball",
+    ])
+
+
+class RunData(RunDataBase):
+    """Current run data."""
+
+    def __init__(self, *args, **kwargs):
+        super(RunData, self).__init__(*args, **kwargs)
+        self.workdir = None
+
+    @property
+    def run_name(self):
+        """Name of the run."""
+        time_str = self.datetime.strftime("%Y-%m-%d-%H-%M-%S")
+        return "maas+%s-%s" % (self.branch.revno(), time_str)
+
+    def cleanup(self):
+        """Cleanup any run data."""
+        os.unlink(self.tarball)
+        os.rmdir(self.tmpdir)
+
+
+def export_branch(tmpdir, revno, uncommitted=False):
+    """Export the current branch."""
+    output_name = "maas+%s" % revno
+    output_path = "%s/%s.tar" % (tmpdir.rstrip('/'), output_name)
+    export_cmd = ["bzr", "export"]
+    if uncommitted:
+        export_cmd.append("--uncommitted")
+    export_cmd.extend(["--root=%s" % output_name, output_path])
+    call_and_check(export_cmd)
+    call_and_check([
+        "tar",
+        "-rf",
+        output_path,
+        "--transform",
+        "s%%^%%%s/%%" % output_name,
+        ".bzr",
+    ])
+    call_and_check(["gzip", output_path])
+    return output_path + ".gz"
+
+
+def build_run_data(uncommitted=False):
+    """Build the current run data."""
+    branch = get_maas_branch()
+    if branch is None:
+        raise RunDataError(
+            "Unable to get MAAS bazaar version, you can only run "
+            "maas-automate from source branch.")
+    console.start("Compressing current branch for injection.")
+    tmpdir = tempfile.mkdtemp(prefix="maas-automate-")
+    tarball = export_branch(tmpdir, branch.revno(), uncommitted=uncommitted)
+    return RunData(
+        datetime=datetime.now(), branch=branch, tmpdir=tmpdir,
+        tarball=tarball)
+
+
+class MAASRunner:
+    """Runs the MAAS auomation inside of the machine to test MAAS."""
+
+    def __init__(self, config):
+        self.config = config
+
+    def run(self):
+        """Perform the automation."""
+        self.apt_update()
+        self.install_curtin()
+        self.install_maas()
+        self.configure()
+
+    def _clean_apikey(self, apikey):
+        """Cleanup the API key output."""
+        for line in apikey.splitlines():
+            line = line.strip()
+            if line != "" and not line.startswith("sudo:"):
+                return line
+
+    def apt_update(self):
+        """Install MAAS and curtin on the machine."""
+        # Update the packages.
+        creator_config = get_config_value(
+            self.config, "creator", required=True)
+        dist_upgrade = get_config_value(
+            creator_config, "dist_upgrade", default=True)
+        if dist_upgrade:
+            console.install("Updating packages on machine.")
+            console.install_cmd(["sudo", "apt-get", "update"])
+            console.install_cmd([
+                "sudo",
+                "DEBIAN_FRONTEND=noninteractive",
+                "apt-get",
+                "dist-upgrade",
+                "-y",
+            ])
+        else:
+            console.install("Skipped updating packages on machine.")
+
+    def install_curtin(self):
+        """Install curtin on the machine if requested."""
+        curtin_config = get_config_value(self.config, "curtin")
+        if curtin_config is not None:
+            branch = get_config_value(curtin_config, "branch")
+            if branch is not None:
+                console.install("Installing curtin from branch: %s" % branch)
+                console.install_cmd([
+                    "/bin/bash", "-c",
+                    "cd .. && bzr branch %s curtin && cd curtin && "
+                    "tools/build-deb -us -uc && "
+                    "sudo dpkg -i *.deb" % branch,
+                ])
+                return
+        console.install(
+            "Curtin was not installed from a branch it will be "
+            "installed from the release archive.")
+
+    def install_maas(self):
+        """Install MAAS on the machine."""
+        # Installing dependencies.
+        console.install("Installing dependencies for MAAS.")
+        console.install_cmd(["make", "install-dependencies"])
+
+        # Make the package.
+        console.install("Building the MAAS packages.")
+        console.install_cmd(["make", "package"])
+
+        # Install MAAS.
+        console.install("Installing MAAS from packaging.")
+        console.install_cmd([
+            "/bin/bash", "-c",
+            "cd ../build-area && "
+            "sudo dpkg -i *.deb || "
+            "sudo apt-get install -f || "
+            "sudo apt-get install -f"])
+        console.install("Installation of MAAS was successful.")
+
+    def configure(self):
+        """Configure the new MAAS installation."""
+        console.config("Creating administrator account.")
+        console.config_cmd([
+            "sudo", "maas-region-admin", "createadmin",
+            "--username", "admin", "--password", "test",
+            "--email", "[e-mail]",
+            ])
+
+        self.regiond_monitor = MonitorRegion()
+        self.regiond_monitor.start()
+        try:
+            console.config("Checking for MAAS regiond to be running.")
+            self.regiond_monitor.wait_for_running()
+            console.config(
+                "MAAS regiond is working and handing RPC connections.")
+
+            console.config("Logging into the MAAS API.")
+            apikey = console.config_cmd([
+                "sudo", "maas-region-admin", "apikey",
+                "--username", "admin",
+                ], output=False)
+            apikey = self._clean_apikey(apikey)
+            console.config_cmd([
+                "maas", "login", "admin",
+                "http://localhost:5240/MAAS", apikey,
+                ], output=False)
+
+            config = get_config_value(self.config, "config")
+            if config is not None:
+                boot_sources = get_config_value(config, "boot_sources")
+                if boot_sources is not None:
+                    self.configure_boot_sources(boot_sources)
+
+                self.configure_global_settings(config)
+
+                clusters_config = get_config_value(config, "clusters")
+                if clusters_config is not None:
+                    self.configure_clusters(clusters_config)
+
+                self.configure_networking(config)
+                self.import_boot_images()
+
+        finally:
+            self.regiond_monitor.stop()
+
+    def _run_maascli(self, runner, cmds, output=True, return_json=False):
+        """Run maascli with the runner and MAAS command."""
+        output = runner(["maas", "admin"] + cmds, output=output)
+        if return_json:
+            return json.loads(output)
+        else:
+            return output
+
+    def _run_maascli_config(self, commands, output=True, return_json=False):
+        """Run maascli as a configuration step."""
+        return self._run_maascli(
+            console.config_cmd, commands,
+            output=output, return_json=return_json)
+
+    def configure_boot_sources(self, config):
+        """Configure the boot sources."""
+        console.config("Clearing default boot sources.")
+        for boot_source in self._run_maascli_config(
+                ["boot-sources", "read"], output=False, return_json=True):
+            self._run_maascli_config(
+                ["boot-source", "delete", "%s" % boot_source["id"]],
+                output=False)
+
+        console.config("Adding new boot sources.")
+        for new_source in config:
+            url = new_source["url"]
+            keyring_filename = new_source["keyring_filename"]
+            source_id = "%s" % self._run_maascli_config([
+                "boot-sources", "create",
+                "url=%s" % url, "keyring_filename=%s" % keyring_filename],
+                output=False, return_json=True)["id"]
+
+            # Wait 3 seconds for the boot source cache to be primed.
+            time.sleep(3)
+
+            for selection in new_source.get("selections", []):
+                cmd = [
+                    "boot-source-selections", "create", source_id,
+                    "os=%s" % selection["os"],
+                    "release=%s" % selection["release"],
+                ]
+                for arch in selection["arches"]:
+                    cmd.append("arches=%s" % arch)
+                cmd.append("subarches=*")
+                cmd.append("labels=*")
+                self._run_maascli_config(cmd, output=False)
+
+    def _set_global_settings(self, key, value):
+        self._run_maascli_config([
+            "maas", "set-config", "name=%s" % key, "value=%s" % value],
+            output=False)
+
+    def _set_config_value(self, config, key):
+        value = config.get(key, None)
+        if value is not None:
+            self._set_global_settings(key, value)
+
+    def configure_global_settings(self, config):
+        """Configure the global settings."""
+        console.config("Setting global configuration values.")
+        ubuntu_config = get_config_value(config, "ubuntu")
+        if ubuntu_config is not None:
+            self._set_config_value(ubuntu_config, "main_archive")
+            self._set_config_value(ubuntu_config, "ports_archive")
+        boot_config = get_config_value(config, "boot")
+        if boot_config is not None:
+            self._set_config_value(boot_config, "kernel_opts")
+        network_config = get_config_value(config, "network")
+        if network_config is not None:
+            self._set_config_value(network_config, "http_proxy")
+            self._set_config_value(network_config, "upstream_dns")
+            self._set_config_value(network_config, "ntp_server")
+
+    def _add_config_to_command(self, command, config):
+        for key, value in config.items():
+            command.append("%s=%s" % (key, value))
+
+    def configure_clusters(self, config):
+        """Configure the cluster settings."""
+        clusters = self._run_maascli_config([
+            "node-groups", "list"], output=False, return_json=True)
+        for cluster_name, config in config.items():
+            console.config(
+                "Configuring cluster controller '%s'." % cluster_name)
+            if cluster_name == "master":
+                # Grap the first cluster uuid.
+                cluster_uuid = clusters[0]["uuid"]
+            else:
+                cluster_uuid = None
+                for cluster in clusters:
+                    if cluster["uuid"] == cluster_name:
+                        cluster_uuid = cluster["uuid"]
+                        break
+                if cluster_uuid:
+                    raise RunError("Unable to find cluster %s." % cluster_name)
+
+            # Update the name or cluster_name if requested.
+            if "name" in config or "cluster_name" in config:
+                cmd = [
+                    "node-group", "update", cluster_uuid
+                ]
+                if "name" in config:
+                    cmd.append("name=%s" % config["name"])
+                if "cluster_name" in config:
+                    cmd.append("cluster_name=%s" % config["cluster_name"])
+
+            # Configure the interfaces for the cluster.
+            for eth_name, eth_config in config.get("interfaces", {}).items():
+                cmd = [
+                    "node-group-interface", "update", cluster_uuid, eth_name,
+                    ]
+                self._add_config_to_command(cmd, eth_config)
+                self._run_maascli_config(cmd, output=False, return_json=False)
+
+    def configure_networking(self, config):
+        """Configure the networking settings."""
+        subnets = get_config_value(config, "subnets", default=[])
+        if len(subnets) > 0:
+            console.config("Configuring subnets.")
+            for subnet in subnets:
+                cmd = [
+                    "subnets", "create",
+                ]
+                self._add_config_to_command(cmd, subnet)
+                self._run_maascli_config(cmd, output=False, return_json=False)
+
+    def import_boot_images(self):
+        """Import the boot images and wait for it to finish."""
+        pass