Merge branch 'master' into type__rbenv

cdist/conf/type/__jail/gencode-remote

@@ -35,7 +35,8 @@ fi
 state="$(cat "$__object/parameter/state")"
 
 started="true"
-[ -f "$__object/parameter/stopped" ] && started="false"
+# If the user wants the jail gone, it implies it shouldn't be started.
+[ -f "$__object/parameter/stopped" -o "$state" = "absent" ] && started="false"
 
 if [ -f "$__object/parameter/ip" ]; then
    ip="$(cat "$__object/parameter/ip")"
@@ -92,14 +93,6 @@ fi
 present="$(cat "$__object/explorer/present")"
 status="$(cat "$__object/explorer/status")"
 
-# Defining a jail as absent and started at the same time
-#    makes no sense. Treat this as an error.
-if [ "$started" = "true" -a "$state" = "absent" ]; then
-   exec >&2
-   echo "Can't have --state absent and --started true together\!"
-   exit 1
-fi
-
 stopJail() {
 # Check $status before issuing command
    if [ "$status" = "STARTED" ]; then

cdist/conf/type/__package_pip/gencode-remote

@@ -46,10 +46,10 @@ fi
 
 case "$state_should" in
     present)
-        echo $pip install -q pyro
+        echo $pip install -q "$name"
     ;;
     absent)
-        echo $pip uninstall -q -y pyro
+        echo $pip uninstall -q -y "$name"
     ;;
     *)
         echo "Unknown state: $state_should" >&2

cdist/config_install.py

@@ -43,26 +43,25 @@ class ConfigInstall(object):
         self.context = context
         self.log = logging.getLogger(self.context.target_host)
 
-        # For easy access
-        self.local = context.local
-        self.remote = context.remote
-
         # Initialise local directory structure
-        self.local.create_files_dirs()
+        self.context.local.create_files_dirs()
         # Initialise remote directory structure
-        self.remote.create_files_dirs()
+        self.context.remote.create_files_dirs()
 
-        self.explorer = core.Explorer(self.context.target_host, self.local, self.remote)
-        self.manifest = core.Manifest(self.context.target_host, self.local)
-        self.code = core.Code(self.context.target_host, self.local, self.remote)
+        self.explorer = core.Explorer(self.context.target_host, self.context.local, self.context.remote)
+        self.manifest = core.Manifest(self.context.target_host, self.context.local)
+        self.code = core.Code(self.context.target_host, self.context.local, self.context.remote)
+
+        # Add switch to disable code execution
+        self.dry_run = False
 
     def cleanup(self):
         # FIXME: move to local?
-        destination = os.path.join(self.local.cache_path, self.context.target_host)
-        self.log.debug("Saving " + self.local.out_path + " to " + destination)
+        destination = os.path.join(self.context.local.cache_path, self.context.target_host)
+        self.log.debug("Saving " + self.context.local.out_path + " to " + destination)
         if os.path.exists(destination):
             shutil.rmtree(destination)
-        shutil.move(self.local.out_path, destination)
+        shutil.move(self.context.local.out_path, destination)
 
     def deploy_to(self):
         """Mimic the old deploy to: Deploy to one host"""
@@ -79,7 +78,7 @@ class ConfigInstall(object):
 
     def stage_prepare(self):
         """Do everything for a deploy, minus the actual code stage"""
-        self.explorer.run_global_explorers(self.local.global_explorer_out_path)
+        self.explorer.run_global_explorers(self.context.local.global_explorer_out_path)
         self.manifest.run_initial_manifest(self.context.initial_manifest)
 
         self.log.info("Running object manifests and type explorers")
@@ -88,8 +87,8 @@ class ConfigInstall(object):
         new_objects_created = True
         while new_objects_created:
             new_objects_created = False
-            for cdist_object in core.CdistObject.list_objects(self.local.object_path,
-                                                         self.local.type_path):
+            for cdist_object in core.CdistObject.list_objects(self.context.local.object_path,
+                                                         self.context.local.type_path):
                 if cdist_object.state == core.CdistObject.STATE_PREPARED:
                     self.log.debug("Skipping re-prepare of object %s", cdist_object)
                     continue
@@ -104,11 +103,10 @@ class ConfigInstall(object):
         self.manifest.run_type_manifest(cdist_object)
         cdist_object.state = core.CdistObject.STATE_PREPARED
 
-    def object_run(self, cdist_object):
+    def object_run(self, cdist_object, dry_run=False):
         """Run gencode and code for an object"""
         self.log.debug("Trying to run object " + cdist_object.name)
         if cdist_object.state == core.CdistObject.STATE_DONE:
-            # TODO: remove once we are sure that this really never happens.
             raise cdist.Error("Attempting to run an already finished object: %s", cdist_object)
 
         cdist_type = cdist_object.cdist_type
@@ -121,11 +119,12 @@ class ConfigInstall(object):
             cdist_object.changed = True
 
         # Execute
-        if cdist_object.code_local:
-            self.code.run_code_local(cdist_object)
-        if cdist_object.code_remote:
-            self.code.transfer_code_remote(cdist_object)
-            self.code.run_code_remote(cdist_object)
+        if not dry_run:
+            if cdist_object.code_local:
+                self.code.run_code_local(cdist_object)
+            if cdist_object.code_remote:
+                self.code.transfer_code_remote(cdist_object)
+                self.code.run_code_remote(cdist_object)
 
         # Mark this object as done
         self.log.debug("Finishing run of " + cdist_object.name)
@@ -135,13 +134,49 @@ class ConfigInstall(object):
         """The final (and real) step of deployment"""
         self.log.info("Generating and executing code")
 
-        objects = core.CdistObject.list_objects(
-            self.local.object_path,
-            self.local.type_path)
+        # FIXME: think about parallel execution (same for stage_prepare)
+        self.all_resolved = False
+        while not self.all_resolved:
+            self.stage_run_iterate()
 
-        dependency_resolver = resolver.DependencyResolver(objects)
-        self.log.debug(pprint.pformat(dependency_resolver.dependencies))
+    def stage_run_iterate(self):
+        """
+        Run one iteration of the run
 
-        for cdist_object in dependency_resolver:
-            self.log.debug("Run object: %s", cdist_object)
-            self.object_run(cdist_object)
+        To be repeated until all objects are done
+        """
+        objects = list(core.CdistObject.list_objects(self.context.local.object_path, self.context.local.type_path))
+        object_state_list=' '.join('%s:%s:%s:%s' % (o, o.state, o.all_requirements, o.satisfied_requirements) for o in objects)
+
+        self.log.debug("Object state (name:state:requirements:satisfied): %s" % object_state_list)
+
+        objects_changed = False
+        self.all_resolved = True
+        for cdist_object in objects:
+            if not cdist_object.state == cdist_object.STATE_DONE:
+                self.all_resolved = False
+                self.log.debug("Object %s not done" % cdist_object.name)
+                if cdist_object.satisfied_requirements:
+                    self.log.debug("Running object %s with satisfied requirements" % cdist_object.name)
+                    self.object_run(cdist_object, self.dry_run)
+                    objects_changed = True
+
+        self.log.debug("All resolved: %s Objects changed: %s" % (self.all_resolved, objects_changed))
+
+        # Not all are resolved, but nothing has been changed => bad dependencies!
+        if not objects_changed and not self.all_resolved:
+            # Create list of unfinished objects + their requirements for print
+
+            evil_objects = []
+            good_objects = []
+            for cdist_object in objects:
+                if not cdist_object.state == cdist_object.STATE_DONE:
+                    evil_objects.append("%s: required: %s, autorequired: %s" %
+                        (cdist_object.name, cdist_object.requirements, cdist_object.autorequire))
+                else:
+                    evil_objects.append("%s (%s): required: %s, autorequired: %s" %
+                        (cdist_object.state, cdist_object.name, 
+                        cdist_object.requirements, cdist_object.autorequire))
+
+            errormessage = "Cannot solve requirements for the following objects: %s - solved: %s" % (",".join(evil_objects), ",".join(good_objects))
+            raise cdist.Error(errormessage)

cdist/core/cdist_object.py

@@ -20,6 +20,7 @@
 #
 #
 
+import fnmatch
 import logging
 import os
 import collections
@@ -56,6 +57,21 @@ class CdistObject(object):
     STATE_RUNNING = "running"
     STATE_DONE = "done"
 
+    def __init__(self, cdist_type, base_path, object_id=None):
+        self.cdist_type = cdist_type # instance of Type
+        self.base_path = base_path
+        self.object_id = object_id
+
+        self.validate_object_id()
+        self.sanitise_object_id()
+
+        self.name = self.join_name(self.cdist_type.name, self.object_id)
+        self.path = os.path.join(self.cdist_type.path, self.object_id, OBJECT_MARKER)
+        self.absolute_path = os.path.join(self.base_path, self.path)
+        self.code_local_path = os.path.join(self.path, "code-local")
+        self.code_remote_path = os.path.join(self.path, "code-remote")
+        self.parameter_path = os.path.join(self.path, "parameter")
+
     @classmethod
     def list_objects(cls, object_base_path, type_base_path):
         """Return a list of object instances"""
@@ -112,21 +128,6 @@ class CdistObject(object):
             raise IllegalObjectIdError(self.object_id,
                 "Missing object_id and type is not a singleton.")
 
-    def __init__(self, cdist_type, base_path, object_id=None):
-        self.cdist_type = cdist_type # instance of Type
-        self.base_path = base_path
-        self.object_id = object_id
-
-        self.validate_object_id()
-        self.sanitise_object_id()
-
-        self.name = self.join_name(self.cdist_type.name, self.object_id)
-        self.path = os.path.join(self.cdist_type.path, self.object_id, OBJECT_MARKER)
-        self.absolute_path = os.path.join(self.base_path, self.path)
-        self.code_local_path = os.path.join(self.path, "code-local")
-        self.code_remote_path = os.path.join(self.path, "code-remote")
-        self.parameter_path = os.path.join(self.path, "parameter")
-
     def object_from_name(self, object_name):
         """Convenience method for creating an object instance from an object name.
 
@@ -209,3 +210,67 @@ class CdistObject(object):
             os.makedirs(absolute_parameter_path, exist_ok=False)
         except EnvironmentError as error:
             raise cdist.Error('Error creating directories for cdist object: %s: %s' % (self, error))
+
+    @property
+    def satisfied_requirements(self):
+        """Return state whether all of our dependencies have been resolved already"""
+
+        satisfied = True
+
+        for requirement in self.all_requirements:
+            log.debug("%s: Checking requirement %s (%s) .." % (self.name, requirement.name, requirement.state))
+            if not requirement.state == self.STATE_DONE:
+                satisfied = False
+                break
+        log.debug("%s is satisfied: %s" % (self.name, satisfied))
+
+        return satisfied
+
+
+    def find_requirements_by_name(self, requirements):
+        """Takes a list of requirement patterns and returns a list of matching object instances.
+
+        Patterns are expected to be Unix shell-style wildcards for use with fnmatch.filter.
+
+        find_requirements_by_name(['__type/object_id', '__other_type/*']) -> 
+            [<Object __type/object_id>, <Object __other_type/any>, <Object __other_type/match>]
+        """
+
+
+        # FIXME: think about where/when to store this - probably not here
+        self.objects = dict((o.name, o) for o in self.list_objects(self.base_path, self.cdist_type.base_path))
+        object_names = self.objects.keys()
+
+        for pattern in requirements:
+            found = False
+            for requirement in fnmatch.filter(object_names, pattern):
+                found = True
+                yield self.objects[requirement]
+            if not found:
+                # FIXME: get rid of the singleton object_id, it should be invisible to the code -> hide it in Object
+                singleton = os.path.join(pattern, 'singleton')
+                if singleton in self.objects:
+                    yield self.objects[singleton]
+                else:
+                    raise RequirementNotFoundError(pattern)
+
+    @property
+    def all_requirements(self):
+        """
+        Return resolved autorequirements and requirements so that
+        a complete list of requirements is returned
+        """
+
+        all_reqs= []
+        all_reqs.extend(self.find_requirements_by_name(self.requirements))
+        all_reqs.extend(self.find_requirements_by_name(self.autorequire))
+
+        return set(all_reqs)
+
+
+class RequirementNotFoundError(cdist.Error):
+    def __init__(self, requirement):
+        self.requirement = requirement
+
+    def __str__(self):
+        return 'Requirement could not be found: %s' % self.requirement

cdist/core/cdist_type.py

@@ -42,6 +42,26 @@ class CdistType(object):
 
     """
 
+    def __init__(self, base_path, name):
+        self.base_path = base_path
+        self.name = name
+        self.path = self.name
+        self.absolute_path = os.path.join(self.base_path, self.path)
+        if not os.path.isdir(self.absolute_path):
+            raise NoSuchTypeError(self.path, self.absolute_path)
+        self.manifest_path = os.path.join(self.name, "manifest")
+        self.explorer_path = os.path.join(self.name, "explorer")
+        self.gencode_local_path = os.path.join(self.name, "gencode-local")
+        self.gencode_remote_path = os.path.join(self.name, "gencode-remote")
+        self.manifest_path = os.path.join(self.name, "manifest")
+
+        self.__explorers = None
+        self.__required_parameters = None
+        self.__required_multiple_parameters = None
+        self.__optional_parameters = None
+        self.__optional_multiple_parameters = None
+        self.__boolean_parameters = None
+
     @classmethod
     def list_types(cls, base_path):
         """Return a list of type instances"""
@@ -65,26 +85,6 @@ class CdistType(object):
             # return instance so __init__ is called
         return cls._instances[name]
 
-    def __init__(self, base_path, name):
-        self.base_path = base_path
-        self.name = name
-        self.path = self.name
-        self.absolute_path = os.path.join(self.base_path, self.path)
-        if not os.path.isdir(self.absolute_path):
-            raise NoSuchTypeError(self.path, self.absolute_path)
-        self.manifest_path = os.path.join(self.name, "manifest")
-        self.explorer_path = os.path.join(self.name, "explorer")
-        self.gencode_local_path = os.path.join(self.name, "gencode-local")
-        self.gencode_remote_path = os.path.join(self.name, "gencode-remote")
-        self.manifest_path = os.path.join(self.name, "manifest")
-
-        self.__explorers = None
-        self.__required_parameters = None
-        self.__required_multiple_parameters = None
-        self.__optional_parameters = None
-        self.__optional_multiple_parameters = None
-        self.__boolean_parameters = None
-
     def __repr__(self):
         return '<CdistType %s>' % self.name
 

cdist/test/autorequire/__init__.py

@@ -65,10 +65,10 @@ class AutorequireTestCase(test.CdistTestCase):
         shutil.rmtree(self.temp_dir)
 
     def test_implicit_dependencies(self):
-        self.context.initial_manifest = os.path.join(self.config.local.manifest_path, 'implicit_dependencies')
+        self.context.initial_manifest = os.path.join(self.context.local.manifest_path, 'implicit_dependencies')
         self.config.stage_prepare()
 
-        objects = core.CdistObject.list_objects(self.config.local.object_path, self.config.local.type_path)
+        objects = core.CdistObject.list_objects(self.context.local.object_path, self.context.local.type_path)
         dependency_resolver = resolver.DependencyResolver(objects)
         expected_dependencies = [
             dependency_resolver.objects['__package_special/b'],
@@ -79,7 +79,7 @@ class AutorequireTestCase(test.CdistTestCase):
         self.assertEqual(resolved_dependencies, expected_dependencies)
 
     def test_circular_dependency(self):
-        self.context.initial_manifest = os.path.join(self.config.local.manifest_path, 'circular_dependency')
+        self.context.initial_manifest = os.path.join(self.context.local.manifest_path, 'circular_dependency')
         self.config.stage_prepare()
         # raises CircularDependecyError
         self.config.stage_run()

cdist/test/config_install/__init__.py

@@ -0,0 +1,119 @@
+# -*- coding: utf-8 -*-
+#
+# 2010-2011 Steven Armstrong (steven-cdist at armstrong.cc)
+# 2012 Nico Schottelius (nico-cdist at schottelius.org)
+#
+# This file is part of cdist.
+#
+# cdist is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# cdist is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with cdist. If not, see <http://www.gnu.org/licenses/>.
+#
+#
+
+import os
+import shutil
+
+from cdist import test
+from cdist import core
+
+import cdist
+import cdist.context
+import cdist.config
+
+import os.path as op
+my_dir = op.abspath(op.dirname(__file__))
+fixtures = op.join(my_dir, 'fixtures')
+object_base_path = op.join(fixtures, 'object')
+type_base_path = op.join(fixtures, 'type')
+add_conf_dir = op.join(fixtures, 'conf')
+
+class ConfigInstallRunTestCase(test.CdistTestCase):
+
+    def setUp(self):
+
+        # Change env for context
+        self.orig_environ = os.environ
+        os.environ = os.environ.copy()
+        self.temp_dir = self.mkdtemp()
+
+        self.out_dir = os.path.join(self.temp_dir, "out")
+        self.remote_out_dir = os.path.join(self.temp_dir, "remote")
+
+        os.environ['__cdist_out_dir'] = self.out_dir
+        os.environ['__cdist_remote_out_dir'] = self.remote_out_dir
+
+        self.context = cdist.context.Context(
+            target_host=self.target_host,
+            remote_copy=self.remote_copy,
+            remote_exec=self.remote_exec,
+            exec_path=test.cdist_exec_path,
+            debug=True)
+
+        self.context.local.object_path = object_base_path
+        self.context.local.type_path = type_base_path
+
+        self.config = cdist.config.Config(self.context)
+
+        self.objects = list(core.CdistObject.list_objects(object_base_path, type_base_path))
+        self.object_index = dict((o.name, o) for o in self.objects)
+        self.object_names = [o.name for o in self.objects]
+
+    def tearDown(self):
+        for o in self.objects:
+            o.requirements = []
+            o.state = ""
+
+        os.environ = self.orig_environ
+        shutil.rmtree(self.temp_dir)
+
+    def test_dependency_resolution(self):
+        first   = self.object_index['__first/man']
+        second  = self.object_index['__second/on-the']
+        third   = self.object_index['__third/moon']
+
+        first.requirements = [second.name]
+        second.requirements = [third.name]
+
+        # First run: 
+        # solves first and maybe second (depending on the order in the set)
+        self.config.stage_run_iterate()
+        self.assertTrue(third.state == third.STATE_DONE)
+
+        self.config.stage_run_iterate()
+        self.assertTrue(second.state == second.STATE_DONE)
+
+
+        try:
+            self.config.stage_run_iterate()
+        except cdist.Error:
+            # Allow failing, because the third run may or may not be unecessary already,
+            # depending on the order of the objects
+            pass
+        self.assertTrue(first.state == first.STATE_DONE)
+
+    def test_unresolvable_requirements(self):
+        """Ensure an exception is thrown for unresolvable depedencies"""
+
+        # Create to objects depending on each other - no solution possible
+        first   = self.object_index['__first/man']
+        second  = self.object_index['__second/on-the']
+
+        first.requirements = [second.name]
+        second.requirements = [first.name]
+
+        # First round solves __third/moon
+        self.config.stage_run_iterate()
+
+        # Second round detects it cannot solve the rest
+        with self.assertRaises(cdist.Error):
+            self.config.stage_run_iterate()

cdist/test/config_install/fixtures/object/__third/moon/.cdist/parameter/name

@@ -0,0 +1 @@
+Prometheus

cdist/test/config_install/fixtures/object/__third/moon/.cdist/parameter/planet

@@ -0,0 +1 @@
+Saturn

cdist/test/object/__init__.py

@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 #
 # 2010-2011 Steven Armstrong (steven-cdist at armstrong.cc)
+# 2012 Nico Schottelius (nico-cdist at schottelius.org)
 #
 # This file is part of cdist.
 #
@@ -35,22 +36,33 @@ type_base_path = op.join(fixtures, 'type')
 
 class ObjectClassTestCase(test.CdistTestCase):
 
+    def setUp(self):
+        self.expected_object_names = sorted([
+            '__first/child',
+            '__first/dog',
+            '__first/man',
+            '__first/woman',
+            '__second/on-the',
+            '__second/under-the',
+            '__third/moon'])
+
+        self.expected_objects = []
+        for cdist_object_name in self.expected_object_names:
+            cdist_type, cdist_object_id = cdist_object_name.split("/", maxsplit=1)
+            cdist_object = core.CdistObject(core.CdistType(type_base_path, cdist_type), object_base_path, cdist_object_id)
+            self.expected_objects.append(cdist_object)
+ 
     def test_list_object_names(self):
-        object_names = list(core.CdistObject.list_object_names(object_base_path))
-        self.assertEqual(object_names, ['__first/man', '__second/on-the', '__third/moon'])
+       found_object_names = sorted(list(core.CdistObject.list_object_names(object_base_path)))
+       self.assertEqual(found_object_names, self.expected_object_names)
 
     def test_list_type_names(self):
         type_names = list(cdist.core.CdistObject.list_type_names(object_base_path))
         self.assertEqual(type_names, ['__first', '__second', '__third'])
 
     def test_list_objects(self):
-        objects = list(core.CdistObject.list_objects(object_base_path, type_base_path))
-        objects_expected = [
-            core.CdistObject(core.CdistType(type_base_path, '__first'), object_base_path, 'man'),
-            core.CdistObject(core.CdistType(type_base_path, '__second'), object_base_path, 'on-the'),
-            core.CdistObject(core.CdistType(type_base_path, '__third'), object_base_path, 'moon'),
-        ]
-        self.assertEqual(objects, objects_expected)
+        found_objects = list(core.CdistObject.list_objects(object_base_path, type_base_path))
+        self.assertEqual(found_objects, self.expected_objects)
 
 
 class ObjectIdTestCase(test.CdistTestCase):
@@ -200,3 +212,54 @@ class ObjectTestCase(test.CdistTestCase):
         self.assertTrue(isinstance(other_object, core.CdistObject))
         self.assertEqual(other_object.cdist_type.name, '__first')
         self.assertEqual(other_object.object_id, 'man')
+
+
+
+class ObjectResolveRequirementsTestCase(test.CdistTestCase):
+
+    def setUp(self):
+        self.objects = list(core.CdistObject.list_objects(object_base_path, type_base_path))
+        self.object_index = dict((o.name, o) for o in self.objects)
+        self.object_names = [o.name for o in self.objects]
+
+        print(self.objects)
+
+        self.cdist_type = core.CdistType(type_base_path, '__third')
+        self.cdist_object = core.CdistObject(self.cdist_type, object_base_path, 'moon') 
+
+    def tearDown(self):
+        for o in self.objects:
+            o.requirements = []
+
+    def test_find_requirements_by_name_string(self):
+        """Check that resolving requirements by name works (require all objects)"""
+        requirements = self.object_names
+
+        self.cdist_object.requirements = requirements
+
+        found_requirements = sorted(self.cdist_object.find_requirements_by_name(self.cdist_object.requirements))
+        expected_requirements = sorted(self.objects)
+
+        self.assertEqual(found_requirements, expected_requirements)
+
+    def test_find_requirements_by_name_pattern(self):
+        """Test whether pattern matching on requirements works"""
+
+        # Matches all objects in the end
+        requirements = ['__first/*', '__second/*-the', '__third/moon']
+
+        self.cdist_object.requirements = requirements
+
+        expected_requirements = sorted(self.objects)
+        found_requirements = sorted(self.cdist_object.find_requirements_by_name(self.cdist_object.requirements))
+
+        self.assertEqual(expected_requirements, found_requirements)
+
+    def test_requirement_not_found(self):
+        """Ensure an exception is thrown for missing depedencies"""
+        cdist_object = self.object_index['__first/man']
+        cdist_object.requirements = ['__does/not/exist']
+
+        with self.assertRaises(core.cdist_object.RequirementNotFoundError):
+            # Use list, as generator does not (yet) raise the error
+            list(cdist_object.find_requirements_by_name(cdist_object.requirements))

cdist/test/resolver/__init__.py

@@ -1,88 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# 2010-2011 Steven Armstrong (steven-cdist at armstrong.cc)
-#
-# This file is part of cdist.
-#
-# cdist is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# cdist is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with cdist. If not, see <http://www.gnu.org/licenses/>.
-#
-#
-
-import os
-import shutil
-
-import cdist
-from cdist import test
-from cdist import core
-from cdist import resolver
-
-import os.path as op
-my_dir = op.abspath(op.dirname(__file__))
-fixtures = op.join(my_dir, 'fixtures')
-object_base_path = op.join(fixtures, 'object')
-type_base_path = op.join(fixtures, 'type')
-
-
-class ResolverTestCase(test.CdistTestCase):
-
-    def setUp(self):
-        self.objects = list(core.CdistObject.list_objects(object_base_path, type_base_path))
-        self.object_index = dict((o.name, o) for o in self.objects)
-        self.dependency_resolver = resolver.DependencyResolver(self.objects)
-
-    def tearDown(self):
-        for o in self.objects:
-            o.requirements = []
-
-    def test_find_requirements_by_name_string(self):
-        requirements = ['__first/man', '__second/on-the', '__third/moon']
-        required_objects = [self.object_index[name] for name in requirements]
-        self.assertEqual(sorted(list(self.dependency_resolver.find_requirements_by_name(requirements))),
-            sorted(required_objects))
-
-    def test_find_requirements_by_name_pattern(self):
-        requirements = ['__first/*', '__second/*-the', '__third/moon']
-        requirements_expanded = [
-            '__first/child', '__first/dog', '__first/man', '__first/woman',
-            '__second/on-the', '__second/under-the',
-            '__third/moon'
-        ]
-        required_objects = [self.object_index[name] for name in requirements_expanded]
-        self.assertEqual(sorted(list(self.dependency_resolver.find_requirements_by_name(requirements))),
-            sorted(required_objects))
-
-    def test_dependency_resolution(self):
-        first_man = self.object_index['__first/man']
-        second_on_the = self.object_index['__second/on-the']
-        third_moon = self.object_index['__third/moon']
-        first_man.requirements = [second_on_the.name]
-        second_on_the.requirements = [third_moon.name]
-        self.assertEqual(
-            self.dependency_resolver.dependencies['__first/man'],
-            [third_moon, second_on_the, first_man]
-        )
-
-    def test_circular_reference(self):
-        first_man = self.object_index['__first/man']
-        first_woman = self.object_index['__first/woman']
-        first_man.requirements = [first_woman.name]
-        first_woman.requirements = [first_man.name]
-        with self.assertRaises(resolver.CircularReferenceError):
-            self.dependency_resolver.dependencies
-
-    def test_requirement_not_found(self):
-        first_man = self.object_index['__first/man']
-        first_man.requirements = ['__does/not/exist']
-        with self.assertRaises(cdist.Error):
-            self.dependency_resolver.dependencies