Merge lp:~fwereade/pyjuju/provider-base into lp:pyjuju

[William Reade]

The ec2 and orchestra MachineProviders have been getting much more similar, and it's time to create a common base class; as part of this change, I've altered the interface slightly such that the base class provides .shutdown_machine and .destroy_environment (renamed from .shutdown); subclasses are expected to implement the new .shutdown_machines method.

I've left the DummyProvider separate (besides fixing the interface), because *many* tests use it in such a way as to assume it's already bootstrapped (or doesn't need to be bootstrapped, from an alternative perspective), and it seems more sensible to keep it optimized for the common case than to (1) rearrange its code and (2) demand that all the clients change to accommodate things they don't really care about.

[William Reade (fwereade)]

(er, didn't directly test the base class itself... marked WIP again before someone does it for me)

[lp:~fwereade/pyjuju/provider-base]

319. By William Reade on 2011-08-11

unsaved file

[William Reade (fwereade)]

> (er, didn't directly test the base class itself... marked WIP again before
> someone does it for me)

OK, I think the base class is now thoroughly tested; the parts that aren't hit in test_base.py are hit via MachineProviderBase subclasses in the other tests, which only mock out/override the parts of the interface which would otherwise raise NotImplemented. One exception: the LaunchMachine test stubs out get_zookeeper_machines separately, to avoid adding to the already-excessive complexity, but I think we have that covered from all angles already.

This branch now makes me think that find_zookeepers, SaveState, and LoadState (at least) should lose their independent existence and just become plain MachineProviderBase methods, but that feels like a job for another branch.

[lp:~fwereade/pyjuju/provider-base]

320. By William Reade on 2011-08-12

merge parent

321. By William Reade on 2011-08-12

merge parent

322. By William Reade on 2011-08-15

merge parent

323. By William Reade on 2011-08-16

merge parent

[Gustavo Niemeyer (niemeyer)]

Very good branch, thanks!

+1, with [1] sorted.

[1]

+ # XXX something's a bit inelegant here; also see Bootstrap operation
+ launch = self.launch_machine_class(self)
+ return launch.run(machine_data=machine_data)

Indeed.. it doesn't look necessary. launch_machine_class can go away
entirely and the subclass can simply define its own start_machie method,
with the base raising NotImplemented. I bet it's going to be less code
in the end.

+ super(MachineProvider, self).__init__(
+ environment_name, config, EC2LaunchMachine)

Yeah, this really sounds wrong. Why EC2LaunchMachine and not
everything else? Let's drop it.

[2]

+ data = super(MachineProvider, self).get_serialization_data()
+ data.setdefault("access-key", os.environ.get("AWS_ACCESS_KEY_ID"))
+ data.setdefault("secret-key", os.environ.get("AWS_SECRET_ACCESS_KEY"))

Nice clean up!

[3]

+ """Retrieve an S3-backed C{FileStorage}."""
+ return FileStorage(self.s3, self.config["control-bucket"])

Good stuff too.

review: Approve

[lp:~fwereade/pyjuju/provider-base]

324. By William Reade on 2011-08-17

merge trunk

325. By William Reade on 2011-08-17

merge lp:~fwereade/ensemble/provider-base-launch-machine

[William Reade (fwereade)]

[1] addressed in https://code.launchpad.net/~fwereade/ensemble/provider-base-launch-machine/+merge/71850 (now merged); includes a general rename of "bootstrap" -- in the narrow context of launching a machine which will run a zookeeper and a provisioning agent, as opposed to the broader start-ensemble-itself context -- to "master".

[Kapil Thangavelu (hazmat)]

looks very nice +1

review: Approve

[lp:~fwereade/pyjuju/provider-base]

326. By William Reade on 2011-08-17

merge trunk

=== modified file 'ensemble/control/shutdown.py'
--- ensemble/control/shutdown.py	2011-06-09 15:13:03 +0000
+++ ensemble/control/shutdown.py	2011-08-17 16:02:43 +0000
@@ -29,4 +29,4 @@
         returnValue(None)
     options.log.info("Shutting down environment %r (type: %s)..." % (
         environment.name, environment.type))
-    yield provider.shutdown()
+    yield provider.destroy_environment()

=== modified file 'ensemble/control/tests/test_shutdown.py'
--- ensemble/control/tests/test_shutdown.py	2011-06-09 15:13:03 +0000
+++ ensemble/control/tests/test_shutdown.py	2011-08-17 16:02:43 +0000
@@ -89,7 +89,7 @@
             return succeed(True)
 
         provider = self.mocker.patch(MachineProvider)
-        provider.shutdown()
+        provider.destroy_environment()
         self.mocker.call(track_shutdown_call, with_object=True)
 
         self.setup_exit(0)

=== added file 'ensemble/providers/common/base.py'
--- ensemble/providers/common/base.py	1970-01-01 00:00:00 +0000
+++ ensemble/providers/common/base.py	2011-08-17 16:02:43 +0000
@@ -0,0 +1,173 @@
+import copy
+from operator import itemgetter
+
+from ensemble.environment.errors import EnvironmentsConfigError
+from ensemble.providers.common.bootstrap import Bootstrap
+from ensemble.providers.common.findzookeepers import find_zookeepers
+from ensemble.providers.common.state import SaveState, LoadState
+from ensemble.providers.common.utils import get_user_authorized_keys
+
+
+class MachineProviderBase(object):
+    """Base class supplying common functionality for MachineProviders.
+
+    To write a working subclass, you will need to override the following
+    methods:
+
+        * connect
+        * get_file_storage
+        * start_machine
+        * get_machines
+        * shutdown_machines
+        * open_port
+        * close_port
+        * get_opened_ports
+
+    You may want to override the following methods, but you should be careful
+    to call MachineProviderBase's implementation (or be very sure you don't
+    need to:
+
+        * __init__
+        * get_serialization_data
+
+    You probably shouldn't override anything else.
+    """
+
+    def __init__(self, environment_name, config):
+        if ("authorized-keys-path" in config and
+            "authorized-keys" in config):
+            raise EnvironmentsConfigError(
+                "Environment config cannot define both authorized-keys "
+                "and authorized-keys-path. Pick one!")
+
+        self.environment_name = environment_name
+        self.config = config
+
+    def get_serialization_data(self):
+        """Get provider configuration suitable for serialization."""
+        data = copy.deepcopy(self.config)
+        data["authorized-keys"] = get_user_authorized_keys(data)
+        # Not relevant, on a remote system.
+        data.pop("authorized-keys-path", None)
+        return data
+
+    #================================================================
+    # Subclasses need to implement their own versions of everything
+    # in the following block
+
+    def connect(self, share=False):
+        """Connect to the zookeeper ensemble running in the machine provider.
+
+        @param share: Requests sharing of the connection with other clients
+            attempting to connect to the same provider, if that's feasible.
+
+        returns an open C{txzookeeper.client.ZookeeperClient} and a
+        C{ensemble.storage.connection.TunnelProtocol}
+        """
+        raise NotImplementedError()
+
+    def get_file_storage(self):
+        """Retrieve the provider C{FileStorage} abstraction."""
+        raise NotImplementedError()
+
+    def start_machine(self, machine_data, master=False):
+        """Start a machine in the provider.
+
+        @param machine_data: a dictionary of data to pass along to the newly
+           launched machine.
+
+        @param master: if True, machine will initialize the ensemble admin
+            and run a provisioning agent.
+        """
+        raise NotImplementedError()
+
+    def get_machines(self, instance_ids=()):
+        """List machines running in the provider.
+
+        @param instance_ids: ids of instances you want to get. Leave empty
+            to list all machines owned by this provider.
+
+        @return: a list of provider-specific ProviderMachines.
+
+        @raise: MachinesNotFound
+        """
+        raise NotImplementedError()
+
+    def shutdown_machines(self, requested_machines=()):
+        """Terminate machines associated with this provider.
+
+        @param requested_machines: list of machines to shut down; leave
+            empty to shut down all associated machines.
+        """
+        raise NotImplementedError()
+
+    def open_port(self, machine, machine_id, port, protocol="tcp"):
+        """Authorizes `port` using `protocol` for `machine`."""
+        raise NotImplementedError()
+
+    def close_port(self, machine, machine_id, port, protocol="tcp"):
+        """Revokes `port` using `protocol` for `machine`."""
+        raise NotImplementedError()
+
+    def get_opened_ports(self, machine, machine_id):
+        """Returns a set of open (port, protocol) pairs for `machine`."""
+        raise NotImplementedError()
+
+    #================================================================
+    # Subclasses will not generally need to override the methods in
+    # this block
+
+    def get_zookeeper_machines(self):
+        """Find running zookeeper instances.
+
+        @return: the first valid instance found as a single element list.
+
+        @raise: EnvironmentNotFound
+        """
+        return find_zookeepers(self)
+
+    def bootstrap(self):
+        """Bootstrap an ensemble server in the provider."""
+        return Bootstrap(self).run()
+
+    def get_machine(self, instance_id):
+        """Retrieve a provider machine by instance id.
+
+        @param instance_id: instance_id of the Machine you want to get.
+
+        @raise: MachinesNotFound
+        """
+        d = self.get_machines([instance_id])
+        d.addCallback(itemgetter(0))
+        return d
+
+    def shutdown_machine(self, machine):
+        """Terminate one machine associated with this provider.
+
+        @param machine: machine to shut down.
+
+        @raise: MachinesNotFound
+        """
+        d = self.shutdown_machines([machine])
+        d.addCallback(itemgetter(0))
+        return d
+
+    def destroy_environment(self):
+        """Clear ensemble state and terminate all associated machines"""
+        return self.shutdown_machines()
+
+    def save_state(self, state):
+        """Save state to the provider.
+
+        @param state
+        @type dict
+        """
+        return SaveState(self).run(state)
+
+    def load_state(self):
+        """Load state from the provider.
+
+        @return: a dictionary.
+        """
+        return LoadState(self).run()
+

=== modified file 'ensemble/providers/common/bootstrap.py'
--- ensemble/providers/common/bootstrap.py	2011-08-04 09:50:57 +0000
+++ ensemble/providers/common/bootstrap.py	2011-08-17 16:02:43 +0000
@@ -41,11 +41,10 @@
         return storage.put(_VERIFY_PATH, StringIO("storage is writable"))
 
     def _cannot_write(self, failure):
-        raise ProviderError("Bootstrap aborted: file storage not writable (%s)"
-                            % str(failure.value))
+        raise ProviderError(
+            "Bootstrap aborted because file storage is not writable: %s"
+            % str(failure.value))
 
     def _launch_machine(self, unused):
         log.debug("Launching Ensemble bootstrap instance.")
-        launch_class = self._provider.launch_machine_class
-        launch = launch_class(self._provider, bootstrap=True)
-        return launch.run({"machine-id": "0"})
+        return self._provider.start_machine({"machine-id": "0"}, master=True)

=== modified file 'ensemble/providers/common/launch.py'
--- ensemble/providers/common/launch.py	2011-08-11 18:43:06 +0000
+++ ensemble/providers/common/launch.py	2011-08-17 16:02:43 +0000
@@ -56,7 +56,7 @@
 class LaunchMachine(object):
     """Abstract class with generic instance-launching logic.
 
-    Constructing with bootstrap=True will cause the run method to
+    Constructing with master=True will cause the run method to
     construct a machine which is also running a zookeeper for the
     cluster, and a provisioning agent, as well as the usual machine
     agent.
@@ -66,9 +66,9 @@
     convenient to override C{get_machine_variables} as well.
     """
 
-    def __init__(self, provider, bootstrap=False):
+    def __init__(self, provider, master=False):
         self._provider = provider
-        self._bootstrap = bootstrap
+        self._master = master
 
     @inlineCallbacks
     def run(self, machine_data):
@@ -86,8 +86,8 @@
         machine_variables = yield self.get_machine_variables(machine_data)
         provider_machines = yield self.start_machine(
             machine_variables, machine_data["machine-id"])
-        if self._bootstrap:
-            yield self._on_bootstrap_launched(provider_machines)
+        if self._master:
+            yield self._on_master_launched(provider_machines)
         returnValue(provider_machines)
 
     def start_machine(self, machine_variables, machine_id):
@@ -128,7 +128,7 @@
 
     @inlineCallbacks
     def _get_zookeeper_hosts(self):
-        if self._bootstrap:
+        if self._master:
             returnValue("localhost:2181")
         machines = yield self._provider.get_zookeeper_machines()
         hosts = [m.private_dns_name for m in machines]
@@ -137,7 +137,7 @@
 
     def _get_packages(self):
         result = list(DEFAULT_PACKAGES)
-        if self._bootstrap:
+        if self._master:
             result.extend(BOOTSTRAP_PACKAGES)
         return result
 
@@ -150,7 +150,7 @@
             "sudo mkdir -p /var/lib/ensemble",
             "sudo mkdir -p /var/log/ensemble"])
 
-        if self._bootstrap:
+        if self._master:
             launch_scripts.append(self._get_initialize_script())
 
         # Every machine has its own agent.
@@ -162,7 +162,7 @@
             "--pidfile=/var/run/ensemble/machine-agent.pid")
         launch_scripts.append(machine_agent_script_template % machine_data)
 
-        if self._bootstrap:
+        if self._master:
             launch_scripts.append(_get_provision_agent_script(machine_data))
 
         return launch_scripts
@@ -185,7 +185,10 @@
         return _get_initialize_script(
             self.get_instance_id_command(), admin_secret)
 
-    def _on_bootstrap_launched(self, machines):
+    def _on_master_launched(self, machines):
+        # TODO this should be part of Bootstrap (and should really extend,
+        # rather than effectively replace, the result of
+        # self._provider.get_zookeeper_machines)
         instance_ids = [m.instance_id for m in machines]
         d = self._provider.save_state({"zookeeper-instances": instance_ids})
         d.addCallback(lambda _: machines)

=== added file 'ensemble/providers/common/tests/test_base.py'
--- ensemble/providers/common/tests/test_base.py	1970-01-01 00:00:00 +0000
+++ ensemble/providers/common/tests/test_base.py	2011-08-17 16:02:43 +0000
@@ -0,0 +1,135 @@
+from twisted.internet.defer import fail, succeed
+
+from ensemble.environment.errors import EnvironmentsConfigError
+from ensemble.lib.testing import TestCase
+from ensemble.machine import ProviderMachine
+from ensemble.providers.common.base import MachineProviderBase
+
+
+class SomeError(Exception):
+    pass
+
+
+class DummyLaunchMachine(object):
+
+    def __init__(self, master=False):
+        self._master = master
+
+    def run(self, machine_data):
+        return succeed([ProviderMachine(machine_data["machine-id"])])
+
+
+class DummyProvider(MachineProviderBase):
+
+    def __init__(self, config=None):
+        super(DummyProvider, self).__init__("venus", config or {})
+
+
+class MachineProviderBaseTest(TestCase):
+
+    def test_init(self):
+        provider = DummyProvider({"some": "config"})
+        self.assertEquals(provider.environment_name, "venus")
+        self.assertEquals(provider.config, {"some": "config"})
+
+    def test_bad_config(self):
+        try:
+            DummyProvider({"authorized-keys": "foo",
+                           "authorized-keys-path": "bar"})
+        except EnvironmentsConfigError as error:
+            expect = ("Environment config cannot define both authorized-keys "
+                      "and authorized-keys-path. Pick one!")
+            self.assertEquals(str(error), expect)
+        else:
+            self.fail("Failed to detect bad config")
+
+    def test_get_serialization_data(self):
+        keys_path = self.makeFile("some-key")
+        provider = DummyProvider({"foo": {"bar": "baz"},
+                                  "authorized-keys-path": keys_path})
+        data = provider.get_serialization_data()
+        self.assertEquals(data, {"foo": {"bar": "baz"},
+                                 "authorized-keys": "some-key"})
+        data["foo"]["bar"] = "qux"
+        self.assertEquals(provider.config, {"foo": {"bar": "baz"},
+                                            "authorized-keys-path": keys_path})
+
+    def test_get_machine_error(self):
+        provider = DummyProvider()
+        provider.get_machines = self.mocker.mock()
+        provider.get_machines(["piffle"])
+        self.mocker.result(fail(SomeError()))
+        self.mocker.replay()
+
+        d = provider.get_machine("piffle")
+        self.assertFailure(d, SomeError)
+        return d
+
+    def test_get_machine_success(self):
+        provider = DummyProvider()
+        provider.get_machines = self.mocker.mock()
+        provider.get_machines(["piffle"])
+        machine = object()
+        self.mocker.result(succeed([machine]))
+        self.mocker.replay()
+
+        d = provider.get_machine("piffle")
+
+        def verify(result):
+            self.assertEquals(result, machine)
+        d.addCallback(verify)
+        return d
+
+    def test_shutdown_machine_error(self):
+        provider = DummyProvider()
+        provider.shutdown_machines = self.mocker.mock()
+        machine = object()
+        provider.shutdown_machines([machine])
+        self.mocker.result(fail(SomeError()))
+        self.mocker.replay()
+
+        d = provider.shutdown_machine(machine)
+        self.assertFailure(d, SomeError)
+        return d
+
+    def test_shutdown_machine_success(self):
+        provider = DummyProvider()
+        provider.shutdown_machines = self.mocker.mock()
+        machine = object()
+        provider.shutdown_machines([machine])
+        probably_the_same_machine = object()
+        self.mocker.result(succeed([probably_the_same_machine]))
+        self.mocker.replay()
+
+        d = provider.shutdown_machine(machine)
+
+        def verify(result):
+            self.assertEquals(result, probably_the_same_machine)
+        d.addCallback(verify)
+        return d
+
+    def test_destroy_environment_error(self):
+        provider = DummyProvider()
+        provider.shutdown_machines = self.mocker.mock()
+        provider.shutdown_machines()
+        self.mocker.result(fail(SomeError()))
+        self.mocker.replay()
+
+        d = provider.destroy_environment()
+        self.assertFailure(d, SomeError)
+        return d
+
+    def test_destroy_environment_success(self):
+        provider = DummyProvider()
+        provider.shutdown_machines = self.mocker.mock()
+        provider.shutdown_machines()
+        machines = object()
+        self.mocker.result(succeed(machines))
+        self.mocker.replay()
+
+        d = provider.destroy_environment()
+
+        def verify(result):
+            self.assertEquals(result, machines)
+        d.addCallback(verify)
+        return d

=== modified file 'ensemble/providers/common/tests/test_findzookeepers.py'
--- ensemble/providers/common/tests/test_findzookeepers.py	2011-08-16 13:24:41 +0000
+++ ensemble/providers/common/tests/test_findzookeepers.py	2011-08-17 16:02:43 +0000
@@ -1,69 +1,79 @@
+from cStringIO import StringIO
+from yaml import dump
+
 from twisted.internet.defer import fail, succeed
 
 from ensemble.errors import EnvironmentNotFound, MachinesNotFound
 from ensemble.lib.testing import TestCase
-from ensemble.providers.common.findzookeepers import find_zookeepers
-
-
-class DummyProvider(object):
-
-    def __init__(self, state, get_machine):
-        self.state = state
-        self.get_machine = get_machine
-
-    def load_state(self):
-        return succeed(self.state)
+from ensemble.providers.common.base import MachineProviderBase
+
+
+class SomeError(Exception):
+    pass
 
 
 class FindZookeepersTest(TestCase):
 
     def get_provider(self, state):
-        return DummyProvider(state, self.mocker.mock())
+        test = self
+
+        class DummyStorage(object):
+
+            def get(self, path):
+                test.assertEquals(path, "provider-state")
+                return succeed(StringIO(dump(state)))
+
+        class DummyProvider(MachineProviderBase):
+
+            def __init__(self):
+                self.get_machines = test.mocker.mock()
+
+            def get_file_storage(self):
+                return DummyStorage()
+
+        return DummyProvider()
 
     def test_no_state(self):
         provider = self.get_provider(False)
-        d = find_zookeepers(provider)
+        d = provider.get_zookeeper_machines()
         self.assertFailure(d, EnvironmentNotFound)
         return d
 
     def test_empty_state(self):
         provider = self.get_provider({})
-        d = find_zookeepers(provider)
+        d = provider.get_zookeeper_machines()
         self.assertFailure(d, EnvironmentNotFound)
         return d
 
     def test_get_machine_error_aborts(self):
         provider = self.get_provider(
             {"zookeeper-instances": ["porter", "carter"]})
-        provider.get_machine("porter")
-
-        class SomeError(Exception):
-            pass
+        provider.get_machines(["porter"])
         self.mocker.result(fail(SomeError()))
         self.mocker.replay()
 
-        d = find_zookeepers(provider)
+        d = provider.get_zookeeper_machines()
         self.assertFailure(d, SomeError)
         return d
 
     def test_bad_machine(self):
         provider = self.get_provider({"zookeeper-instances": ["porter"]})
-        provider.get_machine("porter")
+        provider.get_machines(["porter"])
         self.mocker.result(fail(MachinesNotFound(["porter"])))
         self.mocker.replay()
 
-        d = find_zookeepers(provider)
+        d = provider.get_zookeeper_machines()
         self.assertFailure(d, EnvironmentNotFound)
         return d
 
     def test_good_machine(self):
         provider = self.get_provider({"zookeeper-instances": ["porter"]})
-        provider.get_machine("porter")
+        provider.get_machines(["porter"])
         machine = object()
-        self.mocker.result(succeed(machine))
+        self.mocker.result(succeed([machine]))
         self.mocker.replay()
 
-        d = find_zookeepers(provider)
+        d = provider.get_zookeeper_machines()
 
         def verify_machine(result):
             self.assertEquals(result, [machine])
@@ -73,19 +83,19 @@
     def test_gets_all_good_machines(self):
         provider = self.get_provider(
             {"zookeeper-instances": ["porter", "carter", "miller", "baker"]})
-        provider.get_machine("porter")
+        provider.get_machines(["porter"])
         self.mocker.result(fail(MachinesNotFound(["porter"])))
-        provider.get_machine("carter")
+        provider.get_machines(["carter"])
         carter = object()
-        self.mocker.result(succeed(carter))
-        provider.get_machine("miller")
+        self.mocker.result(succeed([carter]))
+        provider.get_machines(["miller"])
         self.mocker.result(fail(MachinesNotFound(["miller"])))
-        provider.get_machine("baker")
+        provider.get_machines(["baker"])
         baker = object()
-        self.mocker.result(succeed(baker))
+        self.mocker.result(succeed([baker]))
         self.mocker.replay()
 
-        d = find_zookeepers(provider)
+        d = provider.get_zookeeper_machines()
 
         def verify_machine(result):
             self.assertEquals(result, [carter, baker])

=== modified file 'ensemble/providers/common/tests/test_launch.py'
--- ensemble/providers/common/tests/test_launch.py	2011-08-10 18:16:51 +0000
+++ ensemble/providers/common/tests/test_launch.py	2011-08-17 16:02:43 +0000
@@ -1,11 +1,11 @@
 import logging
 import tempfile
 
-from twisted.internet.defer import fail, succeed
+from twisted.internet.defer import fail, inlineCallbacks, succeed
 
 from ensemble.errors import EnvironmentNotFound, ProviderError
 from ensemble.lib.testing import TestCase
-from ensemble.providers.common.bootstrap import Bootstrap
+from ensemble.providers.common.base import MachineProviderBase
 from ensemble.providers.common.launch import (
     BOOTSTRAP_PACKAGES, DEFAULT_PACKAGES, DEFAULT_REPOSITORIES, LaunchMachine)
 from ensemble.providers.dummy import DummyMachine, FileStorage
@@ -18,7 +18,7 @@
 class DummyLaunchMachine(LaunchMachine):
 
     def start_machine(self, variables, data):
-        if self._bootstrap:
+        if self._master:
             name = "bootstrapped-instance-id"
         else:
             name = "some-instance-id"
@@ -42,11 +42,15 @@
 
 def get_provider(launch_class=DummyLaunchMachine, config=None, zookeeper=True,
                  file_storage_class=WorkingFileStorage):
-    class DummyProvider(object):
-        config = {"authorized-keys": "abc"}
-        launch_machine_class = launch_class
+
+    class DummyProvider(MachineProviderBase):
+
+        def __init__(self, config):
+            super(DummyProvider, self).__init__("venus", config)
+            self._file_storage = file_storage_class()
 
         def get_zookeeper_machines(self):
+            # this is mocked out to avoid insane complexity
             if isinstance(zookeeper, Exception):
                 return fail(zookeeper)
             return succeed(
@@ -54,21 +58,21 @@
                              private_dns_name="zookeeper.internal")])
 
         def get_file_storage(self):
-            return file_storage_class()
-
-        def save_state(self, state):
-            self.saved_state = state
-            return succeed(None)
-
+            return self._file_storage
+
+        def start_machine(self, machine_data, master=False):
+            return launch_class(self, master).run(machine_data)
+
+    create_config = {"authorized-keys": "abc"}
     if config is not None:
-        DummyProvider.config.update(config)
-    return DummyProvider()
+        create_config.update(config)
+    return DummyProvider(create_config)
 
 
 def get_launch(launch_class=DummyLaunchMachine, config=None,
-               zookeeper=True, bootstrap=False):
+               zookeeper=True, master=False):
     provider = get_provider(launch_class, config, zookeeper)
-    return launch_class(provider, bootstrap=bootstrap)
+    return launch_class(provider, master=master)
 
 
 class LaunchMachineTest(TestCase):
@@ -90,17 +94,14 @@
         d.addCallback(self._verify_machines)
         return d
 
+    @inlineCallbacks
     def test_bootstrap_run(self):
         provider = get_provider(config={"admin-secret": "whatever"})
-        launch = DummyLaunchMachine(provider, bootstrap=True)
-        d = launch.run({"machine-id": "machine-32767"})
-
-        def verify_state_saved(_):
-            self.assertEquals(
-                provider.saved_state,
-                {"zookeeper-instances": ["bootstrapped-instance-id"]})
-        d.addCallback(verify_state_saved)
-        return d
+        launch = DummyLaunchMachine(provider, master=True)
+        yield launch.run({"machine-id": "machine-32767"})
+        saved_state = yield provider.load_state()
+        self.assertEquals(
+            saved_state, {"zookeeper-instances": ["bootstrapped-instance-id"]})
 
     def test_get_machine_variables_normal(self):
         launch = get_launch()
@@ -152,8 +153,7 @@
         return d
 
     def test_get_machine_variables_bootstrap(self):
-        launch = get_launch(config={"admin-secret": "SEEKRIT"},
-                            bootstrap=True)
+        launch = get_launch(config={"admin-secret": "SEEKRIT"}, master=True)
         d = launch.get_machine_variables({"machine-id": "machine-757"})
 
         def verify_vars(vars):
@@ -199,23 +199,21 @@
         class BBQError(Exception):
             pass
         provider = get_provider(zookeeper=BBQError())
-        bootstrap = Bootstrap(provider)
-        d = bootstrap.run()
+        d = provider.bootstrap()
         self.assertFailure(d, BBQError)
         return d
 
     def test_bootstrap_unwritable_storage(self):
         provider = get_provider(zookeeper=EnvironmentNotFound(),
                                 file_storage_class=UnwritableFileStorage)
-        d = Bootstrap(provider).run()
+        d = provider.bootstrap()
         self.assertFailure(d, ProviderError)
         return d
 
     def test_bootstrap_no_launch(self):
         log = self.capture_logging("ensemble.common", level=logging.DEBUG)
         provider = get_provider()
-        bootstrap = Bootstrap(provider)
-        d = bootstrap.run()
+        d = provider.bootstrap()
 
         def verify_machines(machines):
             (machine,) = machines
@@ -232,8 +230,7 @@
         log = self.capture_logging("ensemble.common", level=logging.DEBUG)
         provider = get_provider(config={"admin-secret": "SEEKRIT"},
                                 zookeeper=EnvironmentNotFound())
-        bootstrap = Bootstrap(provider)
-        d = bootstrap.run()
+        d = provider.bootstrap()
 
         def verify_machines(machines):
             (machine,) = machines

=== modified file 'ensemble/providers/common/tests/test_state.py'
--- ensemble/providers/common/tests/test_state.py	2011-07-26 10:45:08 +0000
+++ ensemble/providers/common/tests/test_state.py	2011-08-17 16:02:43 +0000
@@ -6,10 +6,11 @@
 from ensemble.errors import FileNotFound
 from ensemble.lib.mocker import MATCH
 from ensemble.lib.testing import TestCase
+from ensemble.providers.common.base import MachineProviderBase
 from ensemble.providers.common.state import LoadState, SaveState
 
 
-class DummyProvider(object):
+class DummyProvider(MachineProviderBase):
 
     def __init__(self, get=None, put=None):
         self._get = get

=== modified file 'ensemble/providers/common/tests/test_utils.py'
--- ensemble/providers/common/tests/test_utils.py	2011-08-03 15:53:38 +0000
+++ ensemble/providers/common/tests/test_utils.py	2011-08-17 16:02:43 +0000
@@ -91,7 +91,7 @@
             "OSError('Bad',)")
 
 
-class FormatCloudIniTest(TestCase):
+class FormatCloudInitTest(TestCase):
 
     def test_format_cloud_init_with_data(self):
         """The format cloud init creates a user-data cloud-init config file.

=== modified file 'ensemble/providers/dummy.py'
--- ensemble/providers/dummy.py	2011-08-12 19:28:37 +0000
+++ ensemble/providers/dummy.py	2011-08-17 16:02:43 +0000
@@ -2,17 +2,16 @@
 import os
 import tempfile
 
+from twisted.internet.defer import inlineCallbacks, returnValue, succeed, fail
+
 from txzookeeper import ZookeeperClient
-from twisted.internet.defer import succeed, fail
-
-
-log = logging.getLogger("ensemble.providers")
-
 
 from ensemble.errors import (
     EnvironmentNotFound, FileNotFound, MachinesNotFound, ProviderError)
 from ensemble.machine import ProviderMachine
 
+log = logging.getLogger("ensemble.providers")
+
 
 class DummyMachine(ProviderMachine):
     """Provider machine implementation specific to the dummy provider."""
@@ -59,7 +58,7 @@
             return fail(MachinesNotFound(missing_instance_ids))
         return succeed(machines)
 
-    def start_machine(self, machine_data):
+    def start_machine(self, machine_data, master=False):
         """Start a machine in the provider."""
         if not "machine-id" in machine_data:
             return fail(ProviderError(
@@ -85,13 +84,16 @@
             return succeed(self._machines[:1])
         return self.start_machine({"machine-id": 0})
 
-    def shutdown(self):
+    @inlineCallbacks
+    def shutdown_machines(self, requested_machines=()):
         """
         Terminate any machine resources associated to the provider.
         """
-        machines = self._machines
-        self._machines = []
-        return succeed(machines)
+        instance_ids = [m.instance_id for m in requested_machines]
+        machines = yield self.get_machines(instance_ids)
+        for machine in machines:
+            self._machines.remove(machine)
+        returnValue(machines)
 
     def shutdown_machine(self, machine):
         """Terminate the given machine"""
@@ -103,6 +105,9 @@
                 return
         return fail(ProviderError("Machine not found %r" % machine))
 
+    def destroy_environment(self):
+        return self.shutdown_machines()
+
     def save_state(self, state):
         """Save the state to the provider."""
         self._state = state

=== modified file 'ensemble/providers/ec2/__init__.py'
--- ensemble/providers/ec2/__init__.py	2011-08-17 08:58:51 +0000
+++ ensemble/providers/ec2/__init__.py	2011-08-17 16:02:43 +0000
@@ -1,5 +1,3 @@
-import copy
-from operator import itemgetter
 import os
 import re
 
@@ -8,14 +6,10 @@
 from txaws.ec2.exception import EC2Error
 from txaws.service import AWSServiceRegion
 
-from ensemble.environment.errors import EnvironmentsConfigError
 from ensemble.errors import (
     MachinesNotFound, ProviderError, ProviderInteractionError)
-from ensemble.providers.common.bootstrap import Bootstrap
-from ensemble.providers.common.findzookeepers import find_zookeepers
-from ensemble.providers.common.state import SaveState, LoadState
-from ensemble.providers.common.utils import (
-    convert_unknown_error, get_user_authorized_keys)
+from ensemble.providers.common.base import MachineProviderBase
+from ensemble.providers.common.utils import convert_unknown_error
 
 from .connect import EC2Connect
 from .files import FileStorage
@@ -26,13 +20,10 @@
 from .utils import get_region_uri
 
 
-class MachineProvider(object):
-
-    launch_machine_class = EC2LaunchMachine
+class MachineProvider(MachineProviderBase):
 
     def __init__(self, environment_name, config):
-        self.environment_name = environment_name
-        self.config = config
+        super(MachineProvider, self).__init__(environment_name, config)
 
         if not config.get("ec2-uri"):
             ec2_uri = get_region_uri(config.get("region", "us-east-1"))
@@ -47,27 +38,14 @@
         self.s3 = self._service.get_s3_client()
         self.ec2 = self._service.get_ec2_client()
 
-        if ("authorized-keys-path" in config and
-            "authorized-keys" in config):
-            raise EnvironmentsConfigError(
-                "Environment config cannot define both authorized-keys "
-                "and authorized-keys-path. Pick one!")
-
     def get_serialization_data(self):
-        """Return a dictionary serialization of the provider configuration.
+        """Get provider configuration suitable for serialization.
 
-        Additionally this extracts crednetial information from the environment.
+        Also extracts credential information from the environment.
         """
-        data = copy.deepcopy(self.config)
-        data["secret-key"] = self.config.get(
-            "secret-key", os.environ.get("AWS_SECRET_ACCESS_KEY"))
-        data["access-key"] = self.config.get(
-            "access-key", os.environ.get("AWS_ACCESS_KEY_ID"))
-        data["authorized-keys"] = get_user_authorized_keys(data)
-
-        # Not relevant, on a remote system.
-        data.pop("authorized-keys-path", None)
-
+        data = super(MachineProvider, self).get_serialization_data()
+        data.setdefault("access-key", os.environ.get("AWS_ACCESS_KEY_ID"))
+        data.setdefault("secret-key", os.environ.get("AWS_SECRET_ACCESS_KEY"))
         return data
 
     def _run_operation(self, operation, *args, **kw):
@@ -88,9 +66,19 @@
         return self._run_operation(connect, share=share)
 
     def get_file_storage(self):
-        """Retrieve the provider C{FileStorage} abstraction."""
-        file_storage = FileStorage(self.s3, self.config["control-bucket"])
-        return file_storage
+        """Retrieve an S3-backed C{FileStorage}."""
+        return FileStorage(self.s3, self.config["control-bucket"])
+
+    def start_machine(self, machine_data, master=False):
+        """Start a machine in the provider.
+
+        @param machine_data: a dictionary of data to pass along to the newly
+           launched machine.
+
+        @param master: if True, machine will initialize the ensemble admin
+            and run a provisioning agent.
+        """
+        return EC2LaunchMachine(self, master).run(machine_data)
 
     @inlineCallbacks
     def get_machines(self, instance_ids=()):
@@ -132,33 +120,8 @@
                 raise MachinesNotFound(missing)
         returnValue(machines)
 
-    def get_machine(self, instance_id):
-        """Retrieve a provider machine by instance id."""
-        d = self.get_machines([instance_id])
-        d.addCallback(itemgetter(0))
-        return d
-
-    def start_machine(self, machine_data):
-        """Start a machine in the provider.
-
-        @param machine_data a dictionary of data to pass along to the newly
-               launched machine.
-        @type dict
-        """
-        launch = EC2LaunchMachine(self)
-        return launch.run(machine_data=machine_data)
-
-    def bootstrap(self):
-        """Bootstrap an ensemble server in the provider."""
-        bootstrap = Bootstrap(self)
-        return bootstrap.run()
-
-    def shutdown_machine(self, machine):
-        """Stop a machine in the provider."""
-        return self.shutdown([machine])
-
     @inlineCallbacks
-    def shutdown(self, requested_machines=()):
+    def shutdown_machines(self, requested_machines=()):
         """Terminate machine resources associated with this provider."""
         for machine in requested_machines:
             if not isinstance(machine, EC2ProviderMachine):
@@ -170,30 +133,7 @@
         if killable_machines:
             killable_ids = [m.instance_id for m in killable_machines]
             yield self.ec2.terminate_instances(*killable_ids)
-
-    def save_state(self, state):
-        """Save state to the provider.
-
-        @param state
-        @type dict
-        """
-        return SaveState(self).run(state)
-
-    def load_state(self):
-        """Load state from the provider.
-
-        @return: a dictionary.
-        """
-        return LoadState(self).run()
-
-    def get_zookeeper_machines(self):
-        """Find running zookeeper instances.
-
-        @return: the first valid instance found as a single element list.
-
-        @raise: EnvironmentNotFound
-        """
-        return find_zookeepers(self)
+            returnValue(killable_machines)
 
     def open_port(self, machine, machine_id, port, protocol="tcp"):
         """Authorizes `port` using `protocol` on EC2 for `machine`."""

=== modified file 'ensemble/providers/ec2/tests/test_provider.py'
--- ensemble/providers/ec2/tests/test_provider.py	2011-05-03 08:54:13 +0000
+++ ensemble/providers/ec2/tests/test_provider.py	2011-08-17 16:02:43 +0000
@@ -115,14 +115,16 @@
         serialized.pop("authorized-keys", None)
         self.assertEqual(config, serialized)
 
+class FailCreateTest(TestCase):
+
     def test_conflicting_authorized_keys_options(self):
         """
         We can't handle two different authorized keys options, so deny
         constructing an environment that way.
         """
-        config = self.get_config()
+        config = {}
         config["authorized-keys"] = "File content"
         config["authorized-keys-path"] = "File path"
         error = self.assertRaises(EnvironmentsConfigError,
-                                  MachineProvider, self.env_name, config)
+                                  MachineProvider, "some-env-name", config)
         self.assertIn("authorized-keys", str(error))

=== modified file 'ensemble/providers/ec2/tests/test_shutdown.py'
--- ensemble/providers/ec2/tests/test_shutdown.py	2011-08-12 21:01:27 +0000
+++ ensemble/providers/ec2/tests/test_shutdown.py	2011-08-17 16:02:43 +0000
@@ -11,7 +11,7 @@
 
 class EC2ShutdownMachineTest(EC2TestMixin, TestCase):
 
-    def test_shutdown(self):
+    def test_shutdown_machine(self):
         instance = self.get_instance("i-foobar")
         self.ec2.describe_instances("i-foobar")
         self.mocker.result(succeed([instance]))
@@ -21,9 +21,15 @@
 
         machine = EC2ProviderMachine("i-foobar")
         provider = self.get_provider()
-        return provider.shutdown_machine(machine)
-
-    def test_shutdown_invalid_group(self):
+        d = provider.shutdown_machine(machine)
+
+        def verify(machine):
+            self.assertTrue(isinstance(machine, EC2ProviderMachine))
+            self.assertEquals(machine.instance_id, "i-foobar")
+        d.addCallback(verify)
+        return d
+
+    def test_shutdown_machine_invalid_group(self):
         """
         Attempting to shutdown a machine that does not belong to this
         provider instance raises an exception.
@@ -43,7 +49,7 @@
         d.addCallback(verify)
         return d
 
-    def test_shutdown_invalid_machine(self):
+    def test_shutdown_machine_invalid_machine(self):
         """
         Attempting to shutdown a machine that from a different provider
         type will raise a syntaxerror.
@@ -61,12 +67,81 @@
         d.addCallback(check_error)
         return d
 
-
-class EC2ShutdownTest(EC2TestMixin, TestCase):
-
-    def test_shutdown(self):
+    def test_shutdown_machines_all(self):
+        self.ec2.describe_instances()
+        self.mocker.result(succeed([
+            self.get_instance("i-amkillable"),
+            self.get_instance("i-amdead", "shutting-down"),
+            self.get_instance("i-amalien", groups=["other"]),
+            self.get_instance("i-amkillabletoo")]))
+        self.ec2.terminate_instances("i-amkillable", "i-amkillabletoo")
+        self.mocker.result(succeed([
+            ("i-amkillable", "running", "shutting-down"),
+            ("i-amkillabletoo", "running", "shutting-down")]))
+        self.mocker.replay()
+
+        provider = self.get_provider()
+        d = provider.shutdown_machines()
+
+        def verify(result):
+            (machine_1, machine_2) = result
+            self.assertTrue(isinstance(machine_1, EC2ProviderMachine))
+            self.assertEquals(machine_1.instance_id, "i-amkillable")
+            self.assertTrue(isinstance(machine_2, EC2ProviderMachine))
+            self.assertEquals(machine_2.instance_id, "i-amkillabletoo")
+        d.addCallback(verify)
+        return d
+
+    def test_shutdown_machines_some_invalid(self):
+        self.ec2.describe_instances("i-amkillable", "i-amdead")
+        self.mocker.result(succeed([
+            self.get_instance("i-amkillable"),
+            self.get_instance("i-amdead", "shutting-down")]))
+        self.mocker.replay()
+
+        provider = self.get_provider()
+        d = provider.shutdown_machines([
+            EC2ProviderMachine("i-amkillable"),
+            EC2ProviderMachine("i-amdead")])
+        self.failUnlessFailure(d, MachinesNotFound)
+
+        def verify(error):
+            self.assertEquals(str(error),
+                              "Cannot find machine: i-amdead")
+        d.addCallback(verify)
+        return d
+
+    def test_shutdown_machines_some_success(self):
+        self.ec2.describe_instances("i-amkillable", "i-amkillabletoo")
+        self.mocker.result(succeed([
+            self.get_instance("i-amkillable"),
+            self.get_instance("i-amkillabletoo")]))
+        self.ec2.terminate_instances("i-amkillable", "i-amkillabletoo")
+        self.mocker.result(succeed([
+            ("i-amkillable", "running", "shutting-down"),
+            ("i-amkillabletoo", "running", "shutting-down")]))
+        self.mocker.replay()
+
+        provider = self.get_provider()
+        d = provider.shutdown_machines([
+            EC2ProviderMachine("i-amkillable"),
+            EC2ProviderMachine("i-amkillabletoo")])
+
+        def verify(result):
+            (machine_1, machine_2) = result
+            self.assertTrue(isinstance(machine_1, EC2ProviderMachine))
+            self.assertEquals(machine_1.instance_id, "i-amkillable")
+            self.assertTrue(isinstance(machine_2, EC2ProviderMachine))
+            self.assertEquals(machine_2.instance_id, "i-amkillabletoo")
+        d.addCallback(verify)
+        return d
+
+
+class EC2DestroyTest(EC2TestMixin, TestCase):
+
+    def test_destroy_environment(self):
         """
-        The shutdown operation terminates all running and pending
+        The destroy_environment operation terminates all running and pending
         instances associated to the C{MachineProvider} instance.
         """
         instances = [self.get_instance("i-canbekilled"),
@@ -83,16 +158,30 @@
         self.mocker.replay()
 
         provider = self.get_provider()
-        return provider.shutdown()
+        d = provider.destroy_environment()
+
+        def verify(result):
+            (machine_1, machine_2) = result
+            self.assertTrue(isinstance(machine_1, EC2ProviderMachine))
+            self.assertEquals(machine_1.instance_id, "i-canbekilled")
+            self.assertTrue(isinstance(machine_2, EC2ProviderMachine))
+            self.assertEquals(machine_2.instance_id, "i-canbekilledtoo")
+        d.addCallback(verify)
+        return d
 
     def test_shutdown_no_instances(self):
         """
-        If there are no instances to shutdown, running the shutdown
-        operation returns None.
+        If there are no instances to shutdown, running the destroy_environment
+        operation does nothing.
         """
         self.ec2.describe_instances()
         self.mocker.result(succeed([]))
         self.mocker.replay()
 
         provider = self.get_provider()
-        return provider.shutdown()
+        d = provider.destroy_environment()
+
+        def verify(result):
+            self.assertEquals(result, None)
+        d.addCallback(verify)
+        return d

=== modified file 'ensemble/providers/orchestra/__init__.py'
--- ensemble/providers/orchestra/__init__.py	2011-08-12 20:31:16 +0000
+++ ensemble/providers/orchestra/__init__.py	2011-08-17 16:02:43 +0000
@@ -1,13 +1,6 @@
-import copy
-from operator import itemgetter
-
 from twisted.internet.defer import inlineCallbacks, returnValue
 
-from ensemble.environment.errors import EnvironmentsConfigError
-from ensemble.providers.common.bootstrap import Bootstrap
-from ensemble.providers.common.findzookeepers import find_zookeepers
-from ensemble.providers.common.state import SaveState, LoadState
-from ensemble.providers.common.utils import get_user_authorized_keys
+from ensemble.providers.common.base import MachineProviderBase
 
 from .cobbler import CobblerClient
 from .files import FileStorage
@@ -15,43 +8,12 @@
 from .machine import machine_from_dict
 
 
-class MachineProvider(object):
-
-    launch_machine_class = OrchestraLaunchMachine
+class MachineProvider(MachineProviderBase):
 
     def __init__(self, environment_name, config):
-        self.environment_name = environment_name
-        self.config = config
+        super(MachineProvider, self).__init__(environment_name, config)
         self.cobbler = CobblerClient(config)
 
-        if ("authorized-keys-path" in config and
-            "authorized-keys" in config):
-            raise EnvironmentsConfigError(
-                "Environment config cannot define both authorized-keys "
-                "and authorized-keys-path. Pick one!")
-
-    def get_serialization_data(self):
-        """Return a dictionary serialization of the provider configuration.
-
-        Additionally this extracts credential information from the environment.
-        """
-        data = copy.deepcopy(self.config)
-        data["authorized-keys"] = get_user_authorized_keys(data)
-        data.pop("authorized-keys-path", None)
-        return data
-
-    def connect(self, share=False):
-        """
-        Connect to the zookeeper ensemble running in the machine provider.
-
-        @param share: Requests sharing of the connection with other clients
-            attempting to connect to the same provider, if that's feasible.
-
-        returns an open C{txzookeeper.client.ZookeeperClient} and a
-        C{ensemble.storage.connection.TunnelProtocol}
-        """
-        raise NotImplementedError()
-
     def get_file_storage(self):
         """Retrieve the provider C{FileStorage} abstraction."""
         if "storage-url" not in self.config:
@@ -59,6 +21,17 @@
                 "http://%(orchestra-server)s/webdav" % self.config)
         return FileStorage(self.config["storage-url"])
 
+    def start_machine(self, machine_data, master=False):
+        """Start a machine in the provider.
+
+        @param machine_data: a dictionary of data to pass along to the newly
+           launched machine.
+
+        @param master: if True, machine will initialize the ensemble admin
+            and run a provisioning agent.
+        """
+        return OrchestraLaunchMachine(self, master).run(machine_data)
+
     @inlineCallbacks
     def get_machines(self, instance_ids=()):
         """List machines running in the provider.
@@ -72,82 +45,3 @@
         """
         instances = yield self.cobbler.describe_systems(*instance_ids)
         returnValue([machine_from_dict(i) for i in instances])
-
-    def get_machine(self, instance_id):
-        """Retrieve a provider machine by instance id. """
-        d = self.get_machines([instance_id])
-        d.addCallback(itemgetter(0))
-        return d
-
-    def start_machine(self, machine_data):
-        """
-        Start a machine in the provider.
-
-        @param machine_data a dictionary of data to pass along to the newly
-               launched machine.
-        @type dict
-        """
-        launch = OrchestraLaunchMachine(self)
-        return launch.run(machine_data)
-
-    def bootstrap(self):
-        """
-        Bootstrap an ensemble server in the provider.
-        """
-        bootstrap = Bootstrap(self)
-        return bootstrap.run()
-
-    def shutdown_machine(self):
-        """
-        Stop a machine in the provider.
-        """
-        raise NotImplementedError()
-
-    def shutdown(self, requested_machines=()):
-        """Terminate machine resources associated with this provider."""
-        raise NotImplementedError()
-
-    def save_state(self, state):
-        """Save state to the provider.
-
-        @param state
-        @type dict
-        """
-        return SaveState(self).run(state)
-
-    def load_state(self):
-        """Load state from the provider.
-
-        @return: a dictionary.
-        """
-        return LoadState(self).run()
-
-    def get_zookeeper_machines(self):
-        """Find running zookeeper instances.
-
-        @return: the first valid instance found as a single element list.
-
-        @raise: EnvironmentNotFound
-        """
-        return find_zookeepers(self)
-
-    def open_port(self, machine, port, protocol="tcp"):
-        """Expose port to the environment.
-
-        Approximate equivalent of ec2-authorize-group
-        """
-        raise NotImplementedError()
-
-    def close_port(self, machine, port, protocol="tcp"):
-        """Close opened port
-
-        Approximate equivalent of ec2-revoke-group
-        """
-        raise NotImplementedError()
-
-    def get_opened_ports(self, machine):
-        """List ports currently exposed to the environment.
-
-        Approximate equivalent of ec2-describe-group
-        """
-        raise NotImplementedError()

=== modified file 'ensemble/providers/tests/test_dummy.py'
--- ensemble/providers/tests/test_dummy.py	2011-08-11 05:59:30 +0000
+++ ensemble/providers/tests/test_dummy.py	2011-08-17 16:02:43 +0000
@@ -67,14 +67,14 @@
         return self.assertFailure(d, ProviderError)
 
     @inlineCallbacks
-    def test_shutdown(self):
-        result = yield self.provider.shutdown()
+    def test_destroy_environment(self):
+        result = yield self.provider.destroy_environment()
         self.assertEqual(result, [])
 
     @inlineCallbacks
-    def test_shutdown_returns_machines(self):
+    def test_destroy_environment_returns_machines(self):
         yield self.provider.bootstrap()
-        result = yield self.provider.shutdown()
+        result = yield self.provider.destroy_environment()
         self.assertEqual(len(result), 1)
         self.assertTrue(isinstance(result[0], ProviderMachine))