I thought it would muddle the responsibilities of the provisioner and the orchestrator to have the orchestrator initialize the nodes and then the provisioner provisioner them.  The way the OpenStack provisioner coded, it seems inescapable that the it be aware of the type of node that it's working with.

If you look at the methods defined in provisioner base class, this is kind of what i'm envisioning:

```python
    def build_nodes(self, template, deployment, node_wrapper):
        """
        :param node_wrapper: Module that contains a wrap_node function.
        See chef_node_wrapper.wrap_node for an example.
        :type node_wrapper: module
        """
        product = template['product']
        nodes_to_wrap = self.provision(template, deployment)

        built_nodes = []
        for node in nodes_to_wrap:
            wrapped_node = node_wrapper.wrap_node(node=node, product=product,
                                                  environment=
                                                  deployment.environment,
                                                  deployment=deployment,
                                                  provisioner=self,
                                                  branch=deployment.branch)
            self.post_provision(wrapped_node)
            built_nodes.append(wrapped_node)

        for node, features in zip(built_nodes, template['nodes']):
            node.add_features(features)

        return built_nodes

    def load_nodes(self, env, deployment, node_wrapper):
        """
        :param node_wrapper: Module that contains a wrap_node function
        See chef_node_wrapper.wrap_node for an example.
        :type node_wrapper: module
        """
        nodes_to_load = self.reload_node_list(env.nodes, env.local_api)

        loaded_nodes = []
        for node in nodes_to_load:
            if not node.exists:
                logger.error("Non-existent chef node: {0}".format(node.name))
                continue
            wrapped_node = node_wrapper.wrap_node(node=node,
                                                  product=env.product,
                                                  environment=env,
                                                  deployment=deployment,
                                                  provisioner=self,
                                                  branch=env.branch)
            loaded_nodes.append(wrapped_node)
        return loaded_nodes
```