Adding feature to figure the reverse dependecies of roles which is super useful when making a change

Author: Nathaniel Felsen

ansigenome/constants.py

@@ -10,7 +10,7 @@
 PACKAGE_RESOURCE = pkg_resources.resource_filename(__name__, "data")
 
 VALID_ACTIONS = ("config", "scan", "gendoc", "genmeta",
-                 "export", "init", "run")
+                 "export", "init", "run", "reverse_dependencies")
 
 ALLOWED_GENDOC_FORMATS = ("rst", "md")
 ALLOWED_GRAPH_FORMATS = ("png", "dot")
@@ -174,6 +174,11 @@
     " and more",
     "help_init": "init new roles with a custom meta file and tests",
     "help_run": "run shell commands inside of each role's directory",
+    "help_reverse_dependencies": "generate a list of reverse dependencies" +
+    " for a given list of role",
+    "no_role_found": "No role named '%role' was found in the path",
+    "role_missing_out": "You must supply -r <role(s)> to get the list of" +
+    " reverse dependencies",
 }
 
 TEST_PATH = os.path.join(os.path.sep, "tmp", "ansigenome")

ansigenome/scan.py

@@ -6,6 +6,8 @@
 import ui as ui
 import utils as utils
 
+import networkx as nx
+
 from ansigenome.export import Export
 
 
@@ -14,14 +16,16 @@ class Scan(object):
     Loop over each role on the roles path and report back stats on them.
     """
     def __init__(self, args, options, config,
-                 gendoc=False, genmeta=False, export=False):
+                 gendoc=False, genmeta=False, export=False,
+                 reverse_dependencies=False):
         self.roles_path = args[0]
 
         self.options = options
         self.config = config
         self.gendoc = gendoc
         self.genmeta = genmeta
         self.export = export
+        self.reverse_dependencies = reverse_dependencies
 
         # set the readme output format
         self.readme_format = c.ALLOWED_GENDOC_FORMATS[0]
@@ -42,6 +46,9 @@ def __init__(self, args, options, config,
         self.all_files = []
         self.yaml_files = []
 
+        if self.reverse_dependencies:
+            self.gr = nx.DiGraph()
+
         # only load and validate the readme when generating docs
         if self.gendoc:
             # only change the format if it is different than the default
@@ -85,6 +92,9 @@ def __init__(self, args, options, config,
         if self.export:
             self.export_roles()
 
+        if self.reverse_dependencies:
+            self.search_in_digraph(options)
+
     def limit_roles(self):
         """
         Limit the roles being scanned.
@@ -100,6 +110,42 @@ def limit_roles(self):
 
         self.roles = new_roles
 
+    def create_digraph(self):
+        """
+        Create reverse dependencie graph
+        """
+        roles = self.report["roles"]
+        for role in roles:
+            dependencies = roles[role]['dependencies']
+            self.gr.add_node(role)
+            for dependencie in dependencies:
+                self.gr.add_node(dependencie)
+                self.gr.add_edge(dependencie, role)
+
+    def search_in_digraph(self, options):
+        if not options.roles:
+            ui.error(c.MESSAGES["role_missing_out"])
+            sys.exit(1)
+
+        roles = options.roles
+        search_result = []
+        for role in roles.split(","):
+            try:
+                dependencies = list(nx.bfs_tree(self.gr, role))
+                search_result = list(set(search_result) | set(dependencies))
+            except nx.networkx.exception.NetworkXError:
+                ui.warn("",
+                        c.MESSAGES["no_role_found"].replace("%role", role),
+                        "")
+                pass
+            except:
+                print "Unexpected error:", sys.exc_info()[0]
+        if options.out_file:
+            utils.string_to_file(options.out_file,
+                                 "['" + "', '".join(search_result) + "']")
+        else:
+            print search_result
+
     def scan_roles(self):
         """
         Iterate over each role and report its stats.
@@ -129,13 +175,18 @@ def scan_roles(self):
                 if self.valid_meta(key):
                     self.make_meta_dict_consistent()
                     self.write_meta(key)
-            else:
+            elif not self.reverse_dependencies:
                 self.update_scan_report(key)
 
-            if not self.config["options_quiet"] and not self.export:
-                ui.role(key,
-                        self.report["roles"][key],
-                        self.report["stats"]["longest_role_name_length"])
+            if not self.config["options_quiet"] and not self.export and \
+                    not self.reverse_dependencies:
+                        ui.role(
+                            key,
+                            self.report["roles"][key],
+                            self.report["stats"]["longest_role_name_length"]
+                            )
+        if self.reverse_dependencies:
+            return self.create_digraph()
 
         self.tally_role_columns()
 

ansigenome/test_helpers.py

@@ -126,6 +126,37 @@ def random_string(length=8):
         string.ascii_lowercase) for _ in range(length))
 
 
+def create_roles_with_dependencies(path):
+    """
+    Create a number of roles.
+    """
+    role_names = []
+
+    full_path = os.path.join(path, 'role1')
+    utils.capture_shell("ansigenome init {0} -c system".format(full_path))
+    meta_path = os.path.join(full_path, 'meta', 'main.yml')
+    with open(meta_path, "w") as myfile:
+        myfile.write("---\ndependencies:\n  - { role: role2 }\n")
+    role_names.append(os.path.basename(full_path))
+
+    full_path = os.path.join(path, 'role2')
+    utils.capture_shell("ansigenome init {0} -c system".format(full_path))
+    meta_path = os.path.join(full_path, 'meta', 'main.yml')
+    with open(meta_path, "w") as myfile:
+        myfile.write("---\ndependencies:\n  - { role: role3 }\n")
+    role_names.append(os.path.basename(full_path))
+
+    role_names.append(os.path.basename(full_path))
+    full_path = os.path.join(path, 'role3')
+    utils.capture_shell("ansigenome init {0} -c system".format(full_path))
+    meta_path = os.path.join(full_path, 'meta', 'main.yml')
+    with open(meta_path, "w") as myfile:
+        myfile.write("---\ndependencies:\n  - { role: role4 }\n")
+    role_names.append(os.path.basename(full_path))
+
+    return role_names
+
+
 def create_roles(path, number=2):
     """
     Create a number of roles.

bin/ansigenome

@@ -14,6 +14,9 @@ from ansigenome.config import Config
 from ansigenome.init import Init
 from ansigenome.run import Run
 from ansigenome.scan import Scan
+from ansigenome.reverse_dependencies import ReverseDependencies
+
+
 
 
 def get_action(args):
@@ -123,15 +126,21 @@ def build_option_parser(action):
         parser.add_option("-c", "--galaxy-categories",
                           dest="galaxy_categories",
                           help="comma separated string of galaxy categories")
+    elif action == "reverse_dependencies":
+        parser.set_usage("{0} -r roles [-o OUT_FILE]".format(usage_prefix))
+        parser.add_option("-r", "--roles",
+                          dest="roles",
+                          help="comma separated string of roles to do analyze")
     elif action == "run":
         parser.set_usage("{0} ROLES_PATH -m COMMAND".format
                          (usage_prefix))
         parser.add_option("-m", "--command", dest="command",
                           help="execute this shell command on each role")
-    if action in ("scan", "gendoc", "genmeta", "export", "run"):
+    if action in ("scan", "gendoc", "genmeta", "export", "run",
+                  "reverse_dependencies"):
         parser.add_option("-l", "--limit", dest="limit",
                           help="comma separated string of roles to white list")
-    if action in ("config", "export"):
+    if action in ("config", "export", "reverse_dependencies"):
         parser.add_option("-o", "--out", dest="out_file",
                           help="output file path")
 
@@ -188,6 +197,13 @@ def execute_run(args, options, config, parser):
     check_roles_path(args, parser)
     Run(args, options, config)
 
+def execute_reverse_dependencies(args, options, config, parser):
+    """
+    Execute reverse dependencies.
+    """
+    check_roles_path(args, parser)
+    Scan(args, options, config, reverse_dependencies=True)
+
 
 def execute_init(args, options, config, parser):
     """

setup.py

@@ -18,7 +18,8 @@
       description="A tool to help you gather information and " +
       "manage your Ansible roles.",
       license="GPLv3",
-      install_requires=["jinja2", "PyYAML", "setuptools"],
+      install_requires=["jinja2", "PyYAML", "setuptools", "networkx",
+                        "pyparsing==1.5.7"],
       packages=["ansigenome"],
       package_data={"ansigenome": ["VERSION", "data/*"]},
       scripts=["bin/ansigenome"],

test/integration/test_reverse_dependencies.py

@@ -0,0 +1,60 @@
+import os
+import unittest
+
+import ansigenome.constants as c
+import ansigenome.test_helpers as th
+import ansigenome.utils as utils
+
+
+class TestReverseDependencies(unittest.TestCase):
+    """
+    Integration tests for the genmeta command.
+    """
+    def setUp(self):
+        self.test_path = os.getenv("ANSIGENOME_TEST_PATH", c.TEST_PATH)
+
+        if not os.path.exists(self.test_path):
+            os.makedirs(self.test_path)
+
+    def tearDown(self):
+        th.rmrf(self.test_path)
+
+    def test_reverse_dependencies(self):
+        th.create_roles_with_dependencies(self.test_path)
+
+        # ----------------------------------------------------------------
+        # test role that doens't exists
+        # ----------------------------------------------------------------
+        (out, err) = utils.capture_shell(
+            "ansigenome reverse_dependencies {0} -r test1".format(
+                self.test_path))
+        th.print_out("test role that doens't exists:", out)
+        self.assertIn("No role named 'test1' was found in the path", out)
+
+        # ----------------------------------------------------------------
+        # test role that exists but has no reverse dependency
+        # ----------------------------------------------------------------
+
+        (out, err) = utils.capture_shell(
+            "ansigenome reverse_dependencies {0} -r role1".format(
+                self.test_path))
+
+        th.print_out("test role that exists but has no reverse dependency:",
+                     out)
+        self.assertIn("['role1']", out)
+
+        # ----------------------------------------------------------------
+        # test role that exists and have reverse dependency
+        # ----------------------------------------------------------------
+
+        (out, err) = utils.capture_shell(
+            "ansigenome reverse_dependencies {0} -r role2".format(
+                self.test_path))
+
+        th.print_out("test role that exists and have reverse dependency:", out)
+        self.assertIn("'role1'", out)
+        self.assertIn("'role2'", out)
+        self.assertNotIn("'role3'", out)
+
+if __name__ == "__main__":
+    unittest.main()