Merge pull request #49 from ezh/feature/tag-regex

Add regex to simple groups

Author: ezh

cloudselect/cloudselect.py

@@ -7,6 +7,7 @@
 # except according to those terms.
 """CloudSelect module loads configuration, plugins and invokes Select module."""
 import argparse
+import copy
 import inspect
 import json
 import logging
@@ -197,7 +198,7 @@ def merge(dict1, dict2, path=None):
     def options(self, name, metadata=None):
         """Get plugin/block options."""
         group = Container.group()
-        base = Container.config().get(name, {})
+        base = copy.deepcopy(Container.config().get(name, {}))
         override = group.run(name, metadata)
         return self.merge(base, override)
 

cloudselect/group/simple.py

@@ -7,6 +7,7 @@
 # except according to those terms.
 """Module returning appropriate options per group of instances."""
 import logging
+import re
 
 from . import GroupService
 
@@ -21,52 +22,34 @@ def __init__(self):
 
     def run(self, name, metadata):
         """Return dictionary with options for the group of instances."""
-        groups_by_priority = list(self.get_groups_with_priority(self.config()))
-
-        for priority, filters, group in sorted(groups_by_priority, key=lambda x: x[0]):
-            self.logger.debug("Process group %s %s", priority, filters)
-            for entry in filters:
-                if entry == "*":
+        for group in self.config().get("options", []):
+            self.logger.debug("Process group %s", group)
+            entry = group.get("match")
+            if not entry:
+                self.logger.warning("Unable to find 'match' key in %s", group)
+                continue
+            if ":" not in entry:
+                self.logger.warning(
+                    "Unable to parse 'match' value %s for %s", entry, group,
+                )
+                continue
+            key, pattern = entry.split(":", 1)
+            regex = re.compile(pattern)
+            value = metadata
+            for key_part in key.split("."):
+                try:
+                    value = value.get(key_part)
+                    if not value:
+                        self.logger.debug("Unable to find key %s", key_part)
+                        break
+                except (AttributeError, NameError):
+                    self.logger.debug("Unable to find key %s", key_part)
+                    break
+                if isinstance(value, str) and regex.match(value):
+                    self.logger.debug(
+                        "Match pattern %s and value %s", pattern, value,
+                    )
                     result = group.get(name)
-                    if result:
+                    if result is not None:
                         return result
-                elif ":" in entry:
-                    key, pattern = entry.split(":", 1)
-                    value = metadata
-                    for key_part in key.split("."):
-                        try:
-                            value = value.get(key_part)
-                            if not value:
-                                self.logger.debug("Unable to find key %s", key_part)
-                                break
-                        except Exception:
-                            self.logger.debug("Unable to find key %s", key_part)
-                            break
-                        if pattern in value:
-                            self.logger.debug(
-                                "Match pattern %s and value %s", pattern, value,
-                            )
-                            result = group.get(name)
-                            if result is not None:
-                                return result
-                else:
-                    self.logger.warning(
-                        "Unable to find filter definition for %s", group,
-                    )
         return {}
-
-    def get_groups_with_priority(self, groups):
-        """Extract priority for groups."""
-        for pattern in groups:
-            group = groups[pattern]
-            if not isinstance(group, dict):
-                logging.debug("Skip group with pattern %s", pattern)
-                continue
-            filters = pattern.split(" ", 1)
-            priority = self.default_priority
-            if len(filters) == 2 and filters[0].isdigit():
-                priority = int(filters[0])
-                filters = filters[-1].split(",")
-            else:
-                filters = pattern
-            yield [priority, filters, group]

tasks.py

@@ -48,6 +48,7 @@ def release(ctx, version):
             ),
         )
         ctx.run("git push")
+        ctx.run("gren release --tags={}".format(version))
     except Failure as e:
         print(e)
 

test/group/test_simple.py

@@ -17,7 +17,6 @@ def test_options(tmpdir):
 
     It should returns {} if there is no options.
     It should returns shared dictionary if there is no any matched filters.
-    It should returns clarified dictionary if there is * filter.
     It should returns clarified dictionary if there is matched filter.
     """
     cloud = CloudSelect(tmpdir)
@@ -39,19 +38,18 @@ def test_options(tmpdir):
     configuration["option"] = options_a
     assert Container.options("option") == options_a
 
-    configuration["group"]["*"] = {"option": options_a}
+    configuration["group"]["options"] = [{"match": "x:y", "option": options_a}]
     assert Container.options("option") == options_a
-    assert Container.options("option", {"a": {"b": "c"}}) == options_a
-
-    configuration["group"]["*"] = {"option": options_b}
-    assert Container.options("option") == options_b
-    assert Container.options("option", {"a": {"b": "c"}}) == options_b
-
-    configuration["group"]["0 a.b:c"] = {"option": options_c}
-    assert Container.options("option") == options_b
-    assert Container.options("option", {"a": {"b": "c"}}) == options_c
-    assert Container.options("option", {"a": {"b": "d"}}) == options_b
-    assert (
-        Container.options("option", {"a": {"b": "long string with c inside"}})
-        == options_c
+    assert Container.options("option", {"a": {"b": "c123"}}) == options_a
+
+    configuration["group"]["options"].append({"match": "a.b:c123", "option": options_b})
+    assert Container.options("option") == options_a
+    assert Container.options("option", {"a": {"b": "c123"}}) == options_b
+
+    configuration["group"]["options"].append(
+        {"match": "a.b:c(.*3|111)", "option": options_c},
     )
+    assert Container.options("option") == options_a
+    assert Container.options("option", {"a": {"b": "c1nnnn3"}}) == options_c
+    assert Container.options("option", {"a": {"b": "c111111"}}) == options_c
+    assert Container.options("option", {"a": {"b": "c112111"}}) == options_a