Making the switch to v2

lib/ansible/inventory/__init__.py

@@ -16,36 +16,44 @@
 # along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
 
 #############################################
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
 import fnmatch
 import os
 import sys
 import re
+import stat
 import subprocess
 
-import ansible.constants as C
+from ansible import constants as C
+from ansible.errors import *
+
 from ansible.inventory.ini import InventoryParser
 from ansible.inventory.script import InventoryScript
 from ansible.inventory.dir import InventoryDirectory
 from ansible.inventory.group import Group
 from ansible.inventory.host import Host
-from ansible import errors
-from ansible import utils
+from ansible.plugins import vars_loader
+from ansible.utils.path import is_executable
+from ansible.utils.vars import combine_vars
 
 class Inventory(object):
     """
     Host inventory for ansible.
     """
 
-    __slots__ = [ 'host_list', 'groups', '_restriction', '_also_restriction', '_subset', 
-                  'parser', '_vars_per_host', '_vars_per_group', '_hosts_cache', '_groups_list',
-                  '_pattern_cache', '_vault_password', '_vars_plugins', '_playbook_basedir']
+    #__slots__ = [ 'host_list', 'groups', '_restriction', '_also_restriction', '_subset', 
+    #              'parser', '_vars_per_host', '_vars_per_group', '_hosts_cache', '_groups_list',
+    #              '_pattern_cache', '_vault_password', '_vars_plugins', '_playbook_basedir']
 
-    def __init__(self, host_list=C.DEFAULT_HOST_LIST, vault_password=None):
+    def __init__(self, loader, variable_manager, host_list=C.DEFAULT_HOST_LIST):
 
         # the host file file, or script path, or list of hosts
         # if a list, inventory data will NOT be loaded
         self.host_list = host_list
-        self._vault_password=vault_password
+        self._loader = loader
+        self._variable_manager = variable_manager
 
         # caching to avoid repeated calculations, particularly with
         # external inventory scripts.
@@ -97,7 +105,7 @@ class Inventory(object):
             if os.path.isdir(host_list):
                 # Ensure basedir is inside the directory
                 self.host_list = os.path.join(self.host_list, "")
-                self.parser = InventoryDirectory(filename=host_list)
+                self.parser = InventoryDirectory(loader=self._loader, filename=host_list)
                 self.groups = self.parser.groups.values()
             else:
                 # check to see if the specified file starts with a
@@ -113,9 +121,9 @@ class Inventory(object):
                 except:
                     pass
 
-                if utils.is_executable(host_list):
+                if is_executable(host_list):
                     try:
-                        self.parser = InventoryScript(filename=host_list)
+                        self.parser = InventoryScript(loader=self._loader, filename=host_list)
                         self.groups = self.parser.groups.values()
                     except:
                         if not shebang_present:
@@ -134,19 +142,23 @@ class Inventory(object):
                         else:
                             raise
 
-            utils.plugins.vars_loader.add_directory(self.basedir(), with_subdir=True)
+            vars_loader.add_directory(self.basedir(), with_subdir=True)
         else:
             raise errors.AnsibleError("Unable to find an inventory file, specify one with -i ?")
 
-        self._vars_plugins = [ x for x in utils.plugins.vars_loader.all(self) ]
+        self._vars_plugins = [ x for x in vars_loader.all(self) ]
 
+        # FIXME: shouldn't be required, since the group/host vars file
+        #        management will be done in VariableManager
         # get group vars from group_vars/ files and vars plugins
         for group in self.groups:
-            group.vars = utils.combine_vars(group.vars, self.get_group_variables(group.name, vault_password=self._vault_password))
+            # FIXME: combine_vars
+            group.vars = combine_vars(group.vars, self.get_group_variables(group.name))
 
         # get host vars from host_vars/ files and vars plugins
         for host in self.get_hosts():
-            host.vars = utils.combine_vars(host.vars, self.get_host_variables(host.name, vault_password=self._vault_password))
+            # FIXME: combine_vars
+            host.vars = combine_vars(host.vars, self.get_host_variables(host.name))
 
 
     def _match(self, str, pattern_str):
@@ -192,9 +204,9 @@ class Inventory(object):
 
         # exclude hosts mentioned in any restriction (ex: failed hosts)
         if self._restriction is not None:
-            hosts = [ h for h in hosts if h.name in self._restriction ]
+            hosts = [ h for h in hosts if h in self._restriction ]
         if self._also_restriction is not None:
-            hosts = [ h for h in hosts if h.name in self._also_restriction ]
+            hosts = [ h for h in hosts if h in self._also_restriction ]
 
         return hosts
 
@@ -320,6 +332,8 @@ class Inventory(object):
         new_host = Host(pattern)
         new_host.set_variable("ansible_python_interpreter", sys.executable)
         new_host.set_variable("ansible_connection", "local")
+        new_host.ipv4_address = '127.0.0.1'
+
         ungrouped = self.get_group("ungrouped")
         if ungrouped is None:
             self.add_group(Group('ungrouped'))
@@ -420,7 +434,7 @@ class Inventory(object):
 
         group = self.get_group(groupname)
         if group is None:
-            raise errors.AnsibleError("group not found: %s" % groupname)
+            raise Exception("group not found: %s" % groupname)
 
         vars = {}
 
@@ -428,19 +442,21 @@ class Inventory(object):
         vars_results = [ plugin.get_group_vars(group, vault_password=vault_password) for plugin in self._vars_plugins if hasattr(plugin, 'get_group_vars')]
         for updated in vars_results:
             if updated is not None:
-                vars = utils.combine_vars(vars, updated)
+                # FIXME: combine_vars
+                vars = combine_vars(vars, updated)
 
         # Read group_vars/ files
-        vars = utils.combine_vars(vars, self.get_group_vars(group))
+        # FIXME: combine_vars
+        vars = combine_vars(vars, self.get_group_vars(group))
 
         return vars
 
-    def get_variables(self, hostname, update_cached=False, vault_password=None):
+    def get_vars(self, hostname, update_cached=False, vault_password=None):
 
         host = self.get_host(hostname)
         if not host:
-            raise errors.AnsibleError("host not found: %s" % hostname)
-        return host.get_variables()
+            raise Exception("host not found: %s" % hostname)
+        return host.get_vars()
 
     def get_host_variables(self, hostname, update_cached=False, vault_password=None):
 
@@ -460,22 +476,26 @@ class Inventory(object):
         vars_results = [ plugin.run(host, vault_password=vault_password) for plugin in self._vars_plugins if hasattr(plugin, 'run')]
         for updated in vars_results:
             if updated is not None:
-                vars = utils.combine_vars(vars, updated)
+                # FIXME: combine_vars
+                vars = combine_vars(vars, updated)
 
         # plugin.get_host_vars retrieves just vars for specific host
         vars_results = [ plugin.get_host_vars(host, vault_password=vault_password) for plugin in self._vars_plugins if hasattr(plugin, 'get_host_vars')]
         for updated in vars_results:
             if updated is not None:
-                vars = utils.combine_vars(vars, updated)
+                # FIXME: combine_vars
+                vars = combine_vars(vars, updated)
 
         # still need to check InventoryParser per host vars
         # which actually means InventoryScript per host,
         # which is not performant
         if self.parser is not None:
-            vars = utils.combine_vars(vars, self.parser.get_host_variables(host))
+            # FIXME: combine_vars
+            vars = combine_vars(vars, self.parser.get_host_variables(host))
 
         # Read host_vars/ files
-        vars = utils.combine_vars(vars, self.get_host_vars(host))
+        # FIXME: combine_vars
+        vars = combine_vars(vars, self.get_host_vars(host))
 
         return vars
 
@@ -490,7 +510,7 @@ class Inventory(object):
 
         """ return a list of hostnames for a pattern """
 
-        result = [ h.name for h in self.get_hosts(pattern) ]
+        result = [ h for h in self.get_hosts(pattern) ]
         if len(result) == 0 and pattern in ["localhost", "127.0.0.1"]:
             result = [pattern]
         return result
@@ -498,11 +518,7 @@ class Inventory(object):
     def list_groups(self):
         return sorted([ g.name for g in self.groups ], key=lambda x: x)
 
-    # TODO: remove this function
-    def get_restriction(self):
-        return self._restriction
-
-    def restrict_to(self, restriction):
+    def restrict_to_hosts(self, restriction):
         """ 
         Restrict list operations to the hosts given in restriction.  This is used
         to exclude failed hosts in main playbook code, don't use this for other
@@ -544,7 +560,7 @@ class Inventory(object):
                     results.append(x)
             self._subset = results
 
-    def lift_restriction(self):
+    def remove_restriction(self):
         """ Do not restrict list operations """
         self._restriction = None
     
@@ -588,10 +604,12 @@ class Inventory(object):
             self._playbook_basedir = dir
             # get group vars from group_vars/ files
             for group in self.groups:
-                group.vars = utils.combine_vars(group.vars, self.get_group_vars(group, new_pb_basedir=True))
+                # FIXME: combine_vars
+                group.vars = combine_vars(group.vars, self.get_group_vars(group, new_pb_basedir=True))
             # get host vars from host_vars/ files
             for host in self.get_hosts():
-                host.vars = utils.combine_vars(host.vars, self.get_host_vars(host, new_pb_basedir=True))
+                # FIXME: combine_vars
+                host.vars = combine_vars(host.vars, self.get_host_vars(host, new_pb_basedir=True))
             # invalidate cache
             self._vars_per_host = {}
             self._vars_per_group = {}
@@ -639,15 +657,15 @@ class Inventory(object):
             if _basedir == self._playbook_basedir and scan_pass != 1:
                 continue
 
+            # FIXME: these should go to VariableManager
             if group and host is None:
                 # load vars in dir/group_vars/name_of_group
                 base_path = os.path.join(basedir, "group_vars/%s" % group.name)
-                results = utils.load_vars(base_path, results, vault_password=self._vault_password)
-
+                self._variable_manager.add_group_vars_file(base_path, self._loader)
             elif host and group is None:
                 # same for hostvars in dir/host_vars/name_of_host
                 base_path = os.path.join(basedir, "host_vars/%s" % host.name)
-                results = utils.load_vars(base_path, results, vault_password=self._vault_password)
+                self._variable_manager.add_host_vars_file(base_path, self._loader)
 
         # all done, results is a dictionary of variables for this particular host.
         return results

lib/ansible/inventory/dir.py

@@ -17,20 +17,25 @@
 # along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
 
 #############################################
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
 
 import os
-import ansible.constants as C
+
+from ansible import constants as C
+from ansible.errors import AnsibleError
+
 from ansible.inventory.host import Host
 from ansible.inventory.group import Group
 from ansible.inventory.ini import InventoryParser
 from ansible.inventory.script import InventoryScript
-from ansible import utils
-from ansible import errors
+from ansible.utils.path import is_executable
+from ansible.utils.vars import combine_vars
 
 class InventoryDirectory(object):
     ''' Host inventory parser for ansible using a directory of inventories. '''
 
-    def __init__(self, filename=C.DEFAULT_HOST_LIST):
+    def __init__(self, loader, filename=C.DEFAULT_HOST_LIST):
         self.names = os.listdir(filename)
         self.names.sort()
         self.directory = filename
@@ -38,10 +43,12 @@ class InventoryDirectory(object):
         self.hosts = {}
         self.groups = {}
 
+        self._loader = loader
+
         for i in self.names:
 
             # Skip files that end with certain extensions or characters
-            if any(i.endswith(ext) for ext in ("~", ".orig", ".bak", ".ini", ".retry", ".pyc", ".pyo")):
+            if any(i.endswith(ext) for ext in ("~", ".orig", ".bak", ".ini", ".cfg", ".retry", ".pyc", ".pyo")):
                 continue
             # Skip hidden files
             if i.startswith('.') and not i.startswith('./'):
@@ -51,9 +58,9 @@ class InventoryDirectory(object):
                 continue
             fullpath = os.path.join(self.directory, i)
             if os.path.isdir(fullpath):
-                parser = InventoryDirectory(filename=fullpath)
-            elif utils.is_executable(fullpath):
-                parser = InventoryScript(filename=fullpath)
+                parser = InventoryDirectory(loader=loader, filename=fullpath)
+            elif is_executable(fullpath):
+                parser = InventoryScript(loader=loader, filename=fullpath)
             else:
                 parser = InventoryParser(filename=fullpath)
             self.parsers.append(parser)
@@ -153,7 +160,7 @@ class InventoryDirectory(object):
 
         # name
         if group.name != newgroup.name:
-            raise errors.AnsibleError("Cannot merge group %s with %s" % (group.name, newgroup.name))
+            raise AnsibleError("Cannot merge group %s with %s" % (group.name, newgroup.name))
 
         # depth
         group.depth = max([group.depth, newgroup.depth])
@@ -196,14 +203,14 @@ class InventoryDirectory(object):
                 self.groups[newparent.name].add_child_group(group)
 
         # variables
-        group.vars = utils.combine_vars(group.vars, newgroup.vars)
+        group.vars = combine_vars(group.vars, newgroup.vars)
 
     def _merge_hosts(self,host, newhost):
         """ Merge all of instance newhost into host """
 
         # name
         if host.name != newhost.name:
-            raise errors.AnsibleError("Cannot merge host %s with %s" % (host.name, newhost.name))
+            raise AnsibleError("Cannot merge host %s with %s" % (host.name, newhost.name))
 
         # group membership relation
         for newgroup in newhost.groups:
@@ -218,7 +225,7 @@ class InventoryDirectory(object):
                 self.groups[newgroup.name].add_host(host)
 
         # variables
-        host.vars = utils.combine_vars(host.vars, newhost.vars)
+        host.vars = combine_vars(host.vars, newhost.vars)
 
     def get_host_variables(self, host):
         """ Gets additional host variables from all inventories """

lib/ansible/inventory/expand_hosts.py

@@ -30,6 +30,9 @@ expanded into 001, 002 ...009, 010.
 Note that when beg is specified with left zero padding, then the length of
 end must be the same as that of beg, else an exception is raised.
 '''
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
 import string
 
 from ansible import errors

lib/ansible/inventory/group.py

@@ -14,11 +14,15 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
 
-class Group(object):
+from ansible.utils.debug import debug
+
+class Group:
     ''' a group of ansible hosts '''
 
-    __slots__ = [ 'name', 'hosts', 'vars', 'child_groups', 'parent_groups', 'depth', '_hosts_cache' ]
+    #__slots__ = [ 'name', 'hosts', 'vars', 'child_groups', 'parent_groups', 'depth', '_hosts_cache' ]
 
     def __init__(self, name=None):
 
@@ -29,9 +33,49 @@ class Group(object):
         self.child_groups = []
         self.parent_groups = []
         self._hosts_cache = None
+
         #self.clear_hosts_cache()
-        if self.name is None:
-            raise Exception("group name is required")
+        #if self.name is None:
+        #    raise Exception("group name is required")
+
+    def __repr__(self):
+        return self.get_name()
+
+    def __getstate__(self):
+        return self.serialize()
+
+    def __setstate__(self, data):
+        return self.deserialize(data)
+
+    def serialize(self):
+        parent_groups = []
+        for parent in self.parent_groups:
+            parent_groups.append(parent.serialize())
+
+        result = dict(
+            name=self.name,
+            vars=self.vars.copy(),
+            parent_groups=parent_groups,
+            depth=self.depth,
+        )
+
+        debug("serializing group, result is: %s" % result)
+        return result
+
+    def deserialize(self, data):
+        debug("deserializing group, data is: %s" % data)
+        self.__init__()
+        self.name = data.get('name')
+        self.vars = data.get('vars', dict())
+
+        parent_groups = data.get('parent_groups', [])
+        for parent_data in parent_groups:
+            g = Group()
+            g.deserialize(parent_data)
+            self.parent_groups.append(g)
+
+    def get_name(self):
+        return self.name
 
     def add_child_group(self, group):
 
@@ -100,7 +144,7 @@ class Group(object):
                 hosts.append(mine)
         return hosts
 
-    def get_variables(self):
+    def get_vars(self):
         return self.vars.copy()
 
     def _get_ancestors(self):

lib/ansible/inventory/host.py

@@ -15,24 +15,88 @@
 # You should have received a copy of the GNU General Public License
 # along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
 
-import ansible.constants as C
-from ansible import utils
+# Make coding more python3-ish
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
 
-class Host(object):
+from ansible import constants as C
+from ansible.inventory.group import Group
+from ansible.utils.vars import combine_vars
+
+__all__ = ['Host']
+
+class Host:
     ''' a single ansible host '''
 
-    __slots__ = [ 'name', 'vars', 'groups' ]
+    #__slots__ = [ 'name', 'vars', 'groups' ]
+
+    def __getstate__(self):
+        return self.serialize()
+
+    def __setstate__(self, data):
+        return self.deserialize(data)
+
+    def __eq__(self, other):
+        return self.name == other.name
+
+    def serialize(self):
+        groups = []
+        for group in self.groups:
+            groups.append(group.serialize())
+
+        return dict(
+            name=self.name,
+            vars=self.vars.copy(),
+            ipv4_address=self.ipv4_address,
+            ipv6_address=self.ipv6_address,
+            port=self.port,
+            gathered_facts=self._gathered_facts,
+            groups=groups,
+        )
+
+    def deserialize(self, data):
+        self.__init__()
+
+        self.name         = data.get('name')
+        self.vars         = data.get('vars', dict())
+        self.ipv4_address = data.get('ipv4_address', '')
+        self.ipv6_address = data.get('ipv6_address', '')
+        self.port         = data.get('port')
+
+        groups = data.get('groups', [])
+        for group_data in groups:
+            g = Group()
+            g.deserialize(group_data)
+            self.groups.append(g)
 
     def __init__(self, name=None, port=None):
 
         self.name = name
         self.vars = {}
         self.groups = []
-        if port and port != C.DEFAULT_REMOTE_PORT:
-            self.set_variable('ansible_ssh_port', int(port))
 
-        if self.name is None:
-            raise Exception("host name is required")
+        self.ipv4_address = name
+        self.ipv6_address = name
+
+        if port and port != C.DEFAULT_REMOTE_PORT:
+            self.port = int(port)
+        else:
+            self.port = C.DEFAULT_REMOTE_PORT
+
+        self._gathered_facts = False
+
+    def __repr__(self):
+        return self.get_name()
+
+    def get_name(self):
+        return self.name
+
+    @property
+    def gathered_facts(self):
+        return self._gathered_facts
+
+    def set_gathered_facts(self, gathered):
+        self._gathered_facts = gathered
 
     def add_group(self, group):
 
@@ -52,16 +116,15 @@ class Host(object):
                 groups[a.name] = a
         return groups.values()
 
-    def get_variables(self):
+    def get_vars(self):
 
         results = {}
         groups = self.get_groups()
         for group in sorted(groups, key=lambda g: g.depth):
-            results = utils.combine_vars(results, group.get_variables())
-        results = utils.combine_vars(results, self.vars)
+            results = combine_vars(results, group.get_vars())
+        results = combine_vars(results, self.vars)
         results['inventory_hostname'] = self.name
         results['inventory_hostname_short'] = self.name.split('.')[0]
         results['group_names'] = sorted([ g.name for g in groups if g.name != 'all'])
         return results
 
-

lib/ansible/inventory/ini.py

@@ -16,17 +16,20 @@
 # along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
 
 #############################################
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
 
-import ansible.constants as C
+import ast
+import shlex
+import re
+
+from ansible import constants as C
+from ansible.errors import *
 from ansible.inventory.host import Host
 from ansible.inventory.group import Group
 from ansible.inventory.expand_hosts import detect_range
 from ansible.inventory.expand_hosts import expand_hostname_range
-from ansible import errors
-from ansible import utils
-import shlex
-import re
-import ast
+from ansible.utils.unicode import to_unicode
 
 class InventoryParser(object):
     """
@@ -34,9 +37,8 @@ class InventoryParser(object):
     """
 
     def __init__(self, filename=C.DEFAULT_HOST_LIST):
-
+        self.filename = filename
         with open(filename) as fh:
-            self.filename = filename
             self.lines = fh.readlines()
             self.groups = {}
             self.hosts = {}
@@ -54,10 +56,7 @@ class InventoryParser(object):
     def _parse_value(v):
         if "#" not in v:
             try:
-                ret = ast.literal_eval(v)
-                if not isinstance(ret, float):
-                    # Do not trim floats. Eg: "1.20" to 1.2
-                    return ret
+                v = ast.literal_eval(v)
             # Using explicit exceptions.
             # Likely a string that literal_eval does not like. We wil then just set it.
             except ValueError:
@@ -66,7 +65,7 @@ class InventoryParser(object):
             except SyntaxError:
                 # Is this a hash with an equals at the end?
                 pass
-        return v
+        return to_unicode(v, nonstring='passthru', errors='strict')
 
     # [webservers]
     # alpha
@@ -91,8 +90,8 @@ class InventoryParser(object):
         self.groups = dict(all=all, ungrouped=ungrouped)
         active_group_name = 'ungrouped'
 
-        for lineno in range(len(self.lines)):
-            line = utils.before_comment(self.lines[lineno]).strip()
+        for line in self.lines:
+            line = self._before_comment(line).strip()
             if line.startswith("[") and line.endswith("]"):
                 active_group_name = line.replace("[","").replace("]","")
                 if ":vars" in line or ":children" in line:
@@ -146,8 +145,11 @@ class InventoryParser(object):
                             try:
                                 (k,v) = t.split("=", 1)
                             except ValueError, e:
-                                raise errors.AnsibleError("%s:%s: Invalid ini entry: %s - %s" % (self.filename, lineno + 1, t, str(e)))
-                            host.set_variable(k, self._parse_value(v))
+                                raise AnsibleError("Invalid ini entry in %s: %s - %s" % (self.filename, t, str(e)))
+                            if k == 'ansible_ssh_host':
+                                host.ipv4_address = self._parse_value(v)
+                            else:
+                                host.set_variable(k, self._parse_value(v))
                     self.groups[active_group_name].add_host(host)
 
     # [southeast:children]
@@ -157,8 +159,8 @@ class InventoryParser(object):
     def _parse_group_children(self):
         group = None
 
-        for lineno in range(len(self.lines)):
-            line = self.lines[lineno].strip()
+        for line in self.lines:
+            line = line.strip()
             if line is None or line == '':
                 continue
             if line.startswith("[") and ":children]" in line:
@@ -173,7 +175,7 @@ class InventoryParser(object):
             elif group:
                 kid_group = self.groups.get(line, None)
                 if kid_group is None:
-                    raise errors.AnsibleError("%s:%d: child group is not defined: (%s)" % (self.filename, lineno + 1, line))
+                    raise AnsibleError("child group is not defined: (%s)" % line)
                 else:
                     group.add_child_group(kid_group)
 
@@ -184,13 +186,13 @@ class InventoryParser(object):
 
     def _parse_group_variables(self):
         group = None
-        for lineno in range(len(self.lines)):
-            line = self.lines[lineno].strip()
+        for line in self.lines:
+            line = line.strip()
             if line.startswith("[") and ":vars]" in line:
                 line = line.replace("[","").replace(":vars]","")
                 group = self.groups.get(line, None)
                 if group is None:
-                    raise errors.AnsibleError("%s:%d: can't add vars to undefined group: %s" % (self.filename, lineno + 1, line))
+                    raise AnsibleError("can't add vars to undefined group: %s" % line)
             elif line.startswith("#") or line.startswith(";"):
                 pass
             elif line.startswith("["):
@@ -199,10 +201,18 @@ class InventoryParser(object):
                 pass
             elif group:
                 if "=" not in line:
-                    raise errors.AnsibleError("%s:%d: variables assigned to group must be in key=value form" % (self.filename, lineno + 1))
+                    raise AnsibleError("variables assigned to group must be in key=value form")
                 else:
                     (k, v) = [e.strip() for e in line.split("=", 1)]
                     group.set_variable(k, self._parse_value(v))
 
     def get_host_variables(self, host):
         return {}
+
+    def _before_comment(self, msg):
+        ''' what's the part of a string before a comment? '''
+        msg = msg.replace("\#","**NOT_A_COMMENT**")
+        msg = msg.split("#")[0]
+        msg = msg.replace("**NOT_A_COMMENT**","#")
+        return msg
+

lib/ansible/inventory/script.py

@@ -16,22 +16,26 @@
 # along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
 
 #############################################
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
 
 import os
 import subprocess
-import ansible.constants as C
+import sys
+
+from ansible import constants as C
+from ansible.errors import *
 from ansible.inventory.host import Host
 from ansible.inventory.group import Group
 from ansible.module_utils.basic import json_dict_bytes_to_unicode
-from ansible import utils
-from ansible import errors
-import sys
 
 
-class InventoryScript(object):
+class InventoryScript:
     ''' Host inventory parser for ansible using external inventory scripts. '''
 
-    def __init__(self, filename=C.DEFAULT_HOST_LIST):
+    def __init__(self, loader, filename=C.DEFAULT_HOST_LIST):
+
+        self._loader = loader
 
         # Support inventory scripts that are not prefixed with some
         # path information but happen to be in the current working
@@ -41,11 +45,11 @@ class InventoryScript(object):
         try:
             sp = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
         except OSError, e:
-            raise errors.AnsibleError("problem running %s (%s)" % (' '.join(cmd), e))
+            raise AnsibleError("problem running %s (%s)" % (' '.join(cmd), e))
         (stdout, stderr) = sp.communicate()
 
         if sp.returncode != 0:
-            raise errors.AnsibleError("Inventory script (%s) had an execution error: %s " % (filename,stderr))
+            raise AnsibleError("Inventory script (%s) had an execution error: %s " % (filename,stderr))
 
         self.data = stdout
         # see comment about _meta below
@@ -58,7 +62,7 @@ class InventoryScript(object):
         all_hosts = {}
 
         # not passing from_remote because data from CMDB is trusted
-        self.raw  = utils.parse_json(self.data)
+        self.raw = self._loader.load(self.data)
         self.raw  = json_dict_bytes_to_unicode(self.raw)
 
         all       = Group('all')
@@ -68,7 +72,7 @@ class InventoryScript(object):
 
         if 'failed' in self.raw:
             sys.stderr.write(err + "\n")
-            raise errors.AnsibleError("failed to parse executable inventory script results: %s" % self.raw)
+            raise AnsibleError("failed to parse executable inventory script results: %s" % self.raw)
 
         for (group_name, data) in self.raw.items():
 
@@ -92,12 +96,12 @@ class InventoryScript(object):
             if not isinstance(data, dict):
                 data = {'hosts': data}
             # is not those subkeys, then simplified syntax, host with vars
-            elif not any(k in data for k in ('hosts','vars','children')):
+            elif not any(k in data for k in ('hosts','vars')):
                 data = {'hosts': [group_name], 'vars': data}
 
             if 'hosts' in data:
                 if not isinstance(data['hosts'], list):
-                    raise errors.AnsibleError("You defined a group \"%s\" with bad "
+                    raise AnsibleError("You defined a group \"%s\" with bad "
                         "data for the host list:\n %s" % (group_name, data))
 
                 for hostname in data['hosts']:
@@ -108,7 +112,7 @@ class InventoryScript(object):
 
             if 'vars' in data:
                 if not isinstance(data['vars'], dict):
-                    raise errors.AnsibleError("You defined a group \"%s\" with bad "
+                    raise AnsibleError("You defined a group \"%s\" with bad "
                         "data for variables:\n %s" % (group_name, data))
 
                 for k, v in data['vars'].iteritems():
@@ -143,12 +147,12 @@ class InventoryScript(object):
         try:
             sp = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
         except OSError, e:
-            raise errors.AnsibleError("problem running %s (%s)" % (' '.join(cmd), e))
+            raise AnsibleError("problem running %s (%s)" % (' '.join(cmd), e))
         (out, err) = sp.communicate()
         if out.strip() == '':
             return dict()
         try:
-            return json_dict_bytes_to_unicode(utils.parse_json(out))
+            return json_dict_bytes_to_unicode(self._loader.load(out))
         except ValueError:
-            raise errors.AnsibleError("could not parse post variable response: %s, %s" % (cmd, out))
+            raise AnsibleError("could not parse post variable response: %s, %s" % (cmd, out))
 

lib/ansible/inventory/vars_plugins/noop.py

@@ -15,6 +15,8 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
 
 class VarsModule(object):