Making the switch to v2

.gitmodules

-[submodule "lib/ansible/modules/core"]
-	path = lib/ansible/modules/core
-	url = https://github.com/ansible/ansible-modules-core.git
-	branch = devel
-[submodule "lib/ansible/modules/extras"]
-	path = lib/ansible/modules/extras
-	url = https://github.com/ansible/ansible-modules-extras.git
-	branch = devel
-[submodule "v2/ansible/modules/core"]
-	path = v2/ansible/modules/core
-	url = https://github.com/ansible/ansible-modules-core.git
-	branch = devel
-[submodule "v2/ansible/modules/extras"]
-	path = v2/ansible/modules/extras
-	url = https://github.com/ansible/ansible-modules-extras.git
-	branch = devel

bin/ansible

@@ -18,6 +18,8 @@
 # along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
 
 ########################################################
+from __future__ import (absolute_import)
+__metaclass__ = type
 
 __requires__ = ['ansible']
 try:
@@ -33,175 +35,45 @@ except Exception:
 import os
 import sys
 
-from ansible.runner import Runner
-import ansible.constants as C
-from ansible import utils
-from ansible import errors
-from ansible import callbacks
-from ansible import inventory
-########################################################
-
-class Cli(object):
-    ''' code behind bin/ansible '''
-
-    # ----------------------------------------------
-
-    def __init__(self):
-        self.stats = callbacks.AggregateStats()
-        self.callbacks = callbacks.CliRunnerCallbacks()
-        if C.DEFAULT_LOAD_CALLBACK_PLUGINS:
-            callbacks.load_callback_plugins()
-
-    # ----------------------------------------------
-
-    def parse(self):
-        ''' create an options parser for bin/ansible '''
-
-        parser = utils.base_parser(
-            constants=C,
-            runas_opts=True,
-            subset_opts=True,
-            async_opts=True,
-            output_opts=True,
-            connect_opts=True,
-            check_opts=True,
-            diff_opts=False,
-            usage='%prog <host-pattern> [options]'
-        )
-
-        parser.add_option('-a', '--args', dest='module_args',
-            help="module arguments", default=C.DEFAULT_MODULE_ARGS)
-        parser.add_option('-m', '--module-name', dest='module_name',
-            help="module name to execute (default=%s)" % C.DEFAULT_MODULE_NAME,
-            default=C.DEFAULT_MODULE_NAME)
-
-        options, args = parser.parse_args()
-        self.callbacks.options = options
-
-        if len(args) == 0 or len(args) > 1:
-            parser.print_help()
-            sys.exit(1)
-
-        # privlege escalation command line arguments need to be mutually exclusive
-        utils.check_mutually_exclusive_privilege(options, parser)
-
-        if (options.ask_vault_pass and options.vault_password_file):
-            parser.error("--ask-vault-pass and --vault-password-file are mutually exclusive")
-
-        return (options, args)
-
-    # ----------------------------------------------
-
-    def run(self, options, args):
-        ''' use Runner lib to do SSH things '''
-
-        pattern = args[0]
-
-        sshpass = becomepass = vault_pass = become_method = None
-
-        # Never ask for an SSH password when we run with local connection
-        if options.connection == "local":
-            options.ask_pass = False
-        else:
-            options.ask_pass = options.ask_pass or C.DEFAULT_ASK_PASS
-
-        options.ask_vault_pass = options.ask_vault_pass or C.DEFAULT_ASK_VAULT_PASS
-
-        # become
-        utils.normalize_become_options(options)
-        prompt_method = utils.choose_pass_prompt(options)
-        (sshpass, becomepass, vault_pass) = utils.ask_passwords(ask_pass=options.ask_pass, become_ask_pass=options.become_ask_pass, ask_vault_pass=options.ask_vault_pass, become_method=prompt_method)
-
-        # read vault_pass from a file
-        if not options.ask_vault_pass and options.vault_password_file:
-            vault_pass = utils.read_vault_file(options.vault_password_file)
-
-        extra_vars = utils.parse_extra_vars(options.extra_vars, vault_pass)
-
-        inventory_manager = inventory.Inventory(options.inventory, vault_password=vault_pass)
-        if options.subset:
-            inventory_manager.subset(options.subset)
-        hosts = inventory_manager.list_hosts(pattern)
-
-        if len(hosts) == 0:
-            callbacks.display("No hosts matched", stderr=True)
-            sys.exit(0)
-
-        if options.listhosts:
-            for host in hosts:
-                callbacks.display('    %s' % host)
-            sys.exit(0)
-
-        if options.module_name in ['command','shell'] and not options.module_args:
-            callbacks.display("No argument passed to %s module" % options.module_name, color='red', stderr=True)
-            sys.exit(1)
-
-        if options.tree:
-            utils.prepare_writeable_dir(options.tree)
-
-        runner = Runner(
-            module_name=options.module_name,
-            module_path=options.module_path,
-            module_args=options.module_args,
-            remote_user=options.remote_user,
-            remote_pass=sshpass,
-            inventory=inventory_manager,
-            timeout=options.timeout,
-            private_key_file=options.private_key_file,
-            forks=options.forks,
-            pattern=pattern,
-            callbacks=self.callbacks,
-            transport=options.connection,
-            subset=options.subset,
-            check=options.check,
-            diff=options.check,
-            vault_pass=vault_pass,
-            become=options.become,
-            become_method=options.become_method,
-            become_pass=becomepass,
-            become_user=options.become_user,
-            extra_vars=extra_vars,
-        )
-
-        if options.seconds:
-            callbacks.display("background launch...\n\n", color='cyan')
-            results, poller = runner.run_async(options.seconds)
-            results = self.poll_while_needed(poller, options)
-        else:
-            results = runner.run()
-
-        return (runner, results)
-
-    # ----------------------------------------------
-
-    def poll_while_needed(self, poller, options):
-        ''' summarize results from Runner '''
-
-        # BACKGROUND POLL LOGIC when -B and -P are specified
-        if options.seconds and options.poll_interval > 0:
-            poller.wait(options.seconds, options.poll_interval)
-
-        return poller.results
-
+from ansible.errors import AnsibleError, AnsibleOptionsError
+from ansible.utils.display import Display
 
 ########################################################
 
 if __name__ == '__main__':
-    callbacks.display("", log_only=True)
-    callbacks.display(" ".join(sys.argv), log_only=True)
-    callbacks.display("", log_only=True)
 
-    cli = Cli()
-    (options, args) = cli.parse()
+    cli = None
+    display = Display()
+    me = os.path.basename(__file__)
+
     try:
-        (runner, results) = cli.run(options, args)
-        for result in results['contacted'].values():
-            if 'failed' in result or result.get('rc', 0) != 0:
-                sys.exit(2)
-        if results['dark']:
-            sys.exit(3)
-    except errors.AnsibleError, e:
-        # Generic handler for ansible specific errors
-        callbacks.display("ERROR: %s" % str(e), stderr=True, color='red')
-        sys.exit(1)
+        if me == 'ansible-playbook':
+            from ansible.cli.playbook import PlaybookCLI as mycli
+        elif me == 'ansible':
+            from ansible.cli.adhoc import AdHocCLI as mycli
+        elif me == 'ansible-pull':
+            from ansible.cli.pull import PullCLI as mycli
+        elif me == 'ansible-doc':
+            from ansible.cli.doc import DocCLI as mycli
+        elif me == 'ansible-vault':
+            from ansible.cli.vault import VaultCLI as mycli
+        elif me == 'ansible-galaxy':
+            from ansible.cli.galaxy import GalaxyCLI as mycli
+
+        cli = mycli(sys.argv, display=display)
+        if cli:
+            cli.parse()
+            sys.exit(cli.run())
+        else:
+            raise AnsibleError("Program not implemented: %s" % me)
 
+    except AnsibleOptionsError as e:
+        cli.parser.print_help()
+        display.display(str(e), stderr=True, color='red')
+        sys.exit(1)
+    except AnsibleError as e:
+        display.display(str(e), stderr=True, color='red')
+        sys.exit(2)
+    except KeyboardInterrupt:
+        display.error("interrupted")
+        sys.exit(4)

bin/ansible-doc

+ansible
\ No newline at end of file

bin/ansible-galaxy

+ansible
\ No newline at end of file

bin/ansible-playbook

+ansible
\ No newline at end of file

bin/ansible-pull

+ansible
\ No newline at end of file

bin/ansible-vault

+ansible
\ No newline at end of file

lib/ansible/__init__.py

@@ -14,5 +14,9 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
-__version__ = '2.0.0'
-__author__ = 'Michael DeHaan'
+
+# Make coding more python3-ish
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+__version__ = '2.0'

lib/ansible/constants.py

@@ -15,10 +15,15 @@
 # You should have received a copy of the GNU General Public License
 # along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
 
+# Make coding more python3-ish
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
 import os
 import pwd
 import sys
-import ConfigParser
+
+from six.moves import configparser
 from string import ascii_letters, digits
 
 # copied from utils, avoid circular reference fun :)
@@ -35,13 +40,15 @@ def get_config(p, section, key, env_var, default, boolean=False, integer=False,
     ''' return a configuration variable with casting '''
     value = _get_config(p, section, key, env_var, default)
     if boolean:
-        return mk_boolean(value)
-    if value and integer:
-        return int(value)
-    if value and floating:
-        return float(value)
-    if value and islist:
-        return [x.strip() for x in value.split(',')]
+        value = mk_boolean(value)
+    if value:
+        if integer:
+            value = int(value)
+        elif floating:
+            value = float(value)
+        elif islist:
+            if isinstance(value, basestring):
+                value = [x.strip() for x in value.split(',')]
     return value
 
 def _get_config(p, section, key, env_var, default):
@@ -60,7 +67,7 @@ def _get_config(p, section, key, env_var, default):
 def load_config_file():
     ''' Load Config File order(first found is used): ENV, CWD, HOME, /etc/ansible '''
 
-    p = ConfigParser.ConfigParser()
+    p = configparser.ConfigParser()
 
     path0 = os.getenv("ANSIBLE_CONFIG", None)
     if path0 is not None:
@@ -73,8 +80,8 @@ def load_config_file():
         if path is not None and os.path.exists(path):
             try:
                 p.read(path)
-            except ConfigParser.Error as e:
-                print "Error reading config file: \n%s" % e
+            except configparser.Error as e:
+                print("Error reading config file: \n{0}".format(e))
                 sys.exit(1)
             return p
     return None
@@ -98,7 +105,8 @@ YAML_FILENAME_EXTENSIONS = [ "", ".yml", ".yaml", ".json" ]
 DEFAULTS='defaults'
 
 # configurable things
-DEFAULT_HOST_LIST         = shell_expand_path(get_config(p, DEFAULTS, 'inventory', 'ANSIBLE_INVENTORY', get_config(p, DEFAULTS,'hostfile','ANSIBLE_HOSTS', '/etc/ansible/hosts')))
+DEFAULT_DEBUG             = get_config(p, DEFAULTS, 'debug',            'ANSIBLE_DEBUG',            False, boolean=True)
+DEFAULT_HOST_LIST         = shell_expand_path(get_config(p, DEFAULTS, 'hostfile', 'ANSIBLE_HOSTS', get_config(p, DEFAULTS,'inventory','ANSIBLE_INVENTORY', '/etc/ansible/hosts')))
 DEFAULT_MODULE_PATH       = get_config(p, DEFAULTS, 'library',          'ANSIBLE_LIBRARY',          None)
 DEFAULT_ROLES_PATH        = shell_expand_path(get_config(p, DEFAULTS, 'roles_path',       'ANSIBLE_ROLES_PATH',       '/etc/ansible/roles'))
 DEFAULT_REMOTE_TMP        = get_config(p, DEFAULTS, 'remote_tmp',       'ANSIBLE_REMOTE_TEMP',      '$HOME/.ansible/tmp')
@@ -112,6 +120,7 @@ DEFAULT_POLL_INTERVAL     = get_config(p, DEFAULTS, 'poll_interval',    'ANSIBLE
 DEFAULT_REMOTE_USER       = get_config(p, DEFAULTS, 'remote_user',      'ANSIBLE_REMOTE_USER',      active_user)
 DEFAULT_ASK_PASS          = get_config(p, DEFAULTS, 'ask_pass',  'ANSIBLE_ASK_PASS',    False, boolean=True)
 DEFAULT_PRIVATE_KEY_FILE  = shell_expand_path(get_config(p, DEFAULTS, 'private_key_file', 'ANSIBLE_PRIVATE_KEY_FILE', None))
+DEFAULT_SUDO_USER         = get_config(p, DEFAULTS, 'sudo_user',        'ANSIBLE_SUDO_USER',        'root')
 DEFAULT_ASK_SUDO_PASS     = get_config(p, DEFAULTS, 'ask_sudo_pass',    'ANSIBLE_ASK_SUDO_PASS',    False, boolean=True)
 DEFAULT_REMOTE_PORT       = get_config(p, DEFAULTS, 'remote_port',      'ANSIBLE_REMOTE_PORT',      None, integer=True)
 DEFAULT_ASK_VAULT_PASS    = get_config(p, DEFAULTS, 'ask_vault_pass',    'ANSIBLE_ASK_VAULT_PASS',    False, boolean=True)
@@ -122,7 +131,6 @@ DEFAULT_MANAGED_STR       = get_config(p, DEFAULTS, 'ansible_managed',  None,
 DEFAULT_SYSLOG_FACILITY   = get_config(p, DEFAULTS, 'syslog_facility',  'ANSIBLE_SYSLOG_FACILITY', 'LOG_USER')
 DEFAULT_KEEP_REMOTE_FILES = get_config(p, DEFAULTS, 'keep_remote_files', 'ANSIBLE_KEEP_REMOTE_FILES', False, boolean=True)
 DEFAULT_SUDO              = get_config(p, DEFAULTS, 'sudo', 'ANSIBLE_SUDO', False, boolean=True)
-DEFAULT_SUDO_USER         = get_config(p, DEFAULTS, 'sudo_user',        'ANSIBLE_SUDO_USER',        'root')
 DEFAULT_SUDO_EXE          = get_config(p, DEFAULTS, 'sudo_exe', 'ANSIBLE_SUDO_EXE', 'sudo')
 DEFAULT_SUDO_FLAGS        = get_config(p, DEFAULTS, 'sudo_flags', 'ANSIBLE_SUDO_FLAGS', '-H')
 DEFAULT_HASH_BEHAVIOUR    = get_config(p, DEFAULTS, 'hash_behaviour', 'ANSIBLE_HASH_BEHAVIOUR', 'replace')
@@ -141,7 +149,7 @@ BECOME_METHODS            = ['sudo','su','pbrun','pfexec','runas']
 BECOME_ERROR_STRINGS      = {'sudo': 'Sorry, try again.', 'su': 'Authentication failure', 'pbrun': '', 'pfexec': '', 'runas': ''}
 DEFAULT_BECOME            = get_config(p, 'privilege_escalation', 'become', 'ANSIBLE_BECOME',False, boolean=True)
 DEFAULT_BECOME_METHOD     = get_config(p, 'privilege_escalation', 'become_method', 'ANSIBLE_BECOME_METHOD','sudo' if DEFAULT_SUDO else 'su' if DEFAULT_SU else 'sudo' ).lower()
-DEFAULT_BECOME_USER       = get_config(p, 'privilege_escalation', 'become_user', 'ANSIBLE_BECOME_USER',default=None)
+DEFAULT_BECOME_USER       = get_config(p, 'privilege_escalation', 'become_user', 'ANSIBLE_BECOME_USER', 'root')
 DEFAULT_BECOME_ASK_PASS   = get_config(p, 'privilege_escalation', 'become_ask_pass', 'ANSIBLE_BECOME_ASK_PASS', False, boolean=True)
 # need to rethink impementing these 2
 DEFAULT_BECOME_EXE = None
@@ -156,6 +164,7 @@ DEFAULT_CONNECTION_PLUGIN_PATH = get_config(p, DEFAULTS, 'connection_plugins', '
 DEFAULT_LOOKUP_PLUGIN_PATH     = get_config(p, DEFAULTS, 'lookup_plugins',     'ANSIBLE_LOOKUP_PLUGINS', '~/.ansible/plugins/lookup_plugins:/usr/share/ansible_plugins/lookup_plugins')
 DEFAULT_VARS_PLUGIN_PATH       = get_config(p, DEFAULTS, 'vars_plugins',       'ANSIBLE_VARS_PLUGINS', '~/.ansible/plugins/vars_plugins:/usr/share/ansible_plugins/vars_plugins')
 DEFAULT_FILTER_PLUGIN_PATH     = get_config(p, DEFAULTS, 'filter_plugins',     'ANSIBLE_FILTER_PLUGINS', '~/.ansible/plugins/filter_plugins:/usr/share/ansible_plugins/filter_plugins')
+DEFAULT_STDOUT_CALLBACK        = get_config(p, DEFAULTS, 'stdout_callback',    'ANSIBLE_STDOUT_CALLBACK', 'default')
 
 CACHE_PLUGIN                   = get_config(p, DEFAULTS, 'fact_caching', 'ANSIBLE_CACHE_PLUGIN', 'memory')
 CACHE_PLUGIN_CONNECTION        = get_config(p, DEFAULTS, 'fact_caching_connection', 'ANSIBLE_CACHE_PLUGIN_CONNECTION', None)
@@ -173,8 +182,8 @@ DEPRECATION_WARNINGS           = get_config(p, DEFAULTS, 'deprecation_warnings',
 DEFAULT_CALLABLE_WHITELIST     = get_config(p, DEFAULTS, 'callable_whitelist', 'ANSIBLE_CALLABLE_WHITELIST', [], islist=True)
 COMMAND_WARNINGS               = get_config(p, DEFAULTS, 'command_warnings', 'ANSIBLE_COMMAND_WARNINGS', False, boolean=True)
 DEFAULT_LOAD_CALLBACK_PLUGINS  = get_config(p, DEFAULTS, 'bin_ansible_callbacks', 'ANSIBLE_LOAD_CALLBACK_PLUGINS', False, boolean=True)
-DEFAULT_FORCE_HANDLERS         = get_config(p, DEFAULTS, 'force_handlers', 'ANSIBLE_FORCE_HANDLERS', False, boolean=True)
-
+RETRY_FILES_ENABLED            = get_config(p, DEFAULTS, 'retry_files_enabled', 'ANSIBLE_RETRY_FILES_ENABLED', True, boolean=True)
+RETRY_FILES_SAVE_PATH          = get_config(p, DEFAULTS, 'retry_files_save_path', 'ANSIBLE_RETRY_FILES_SAVE_PATH', '~/')
 
 RETRY_FILES_ENABLED            = get_config(p, DEFAULTS, 'retry_files_enabled', 'ANSIBLE_RETRY_FILES_ENABLED', True, boolean=True)
 RETRY_FILES_SAVE_PATH          = get_config(p, DEFAULTS, 'retry_files_save_path', 'ANSIBLE_RETRY_FILES_SAVE_PATH', '~/')
@@ -196,10 +205,16 @@ ACCELERATE_KEYS_FILE_PERMS     = get_config(p, 'accelerate', 'accelerate_keys_fi
 ACCELERATE_MULTI_KEY           = get_config(p, 'accelerate', 'accelerate_multi_key', 'ACCELERATE_MULTI_KEY', False, boolean=True)
 PARAMIKO_PTY                   = get_config(p, 'paramiko_connection', 'pty', 'ANSIBLE_PARAMIKO_PTY', True, boolean=True)
 
+# galaxy related
+DEFAULT_GALAXY_URI             = get_config(p, 'galaxy', 'server_uri', 'ANSIBLE_GALAXY_SERVER_URI', 'https://galaxy.ansible.com')
+# this can be configured to blacklist SCMS but cannot add new ones unless the code is also updated
+GALAXY_SCMS                    = get_config(p, 'galaxy', 'scms', 'ANSIBLE_GALAXY_SCMS', ['git','hg'], islist=True)
+
 # characters included in auto-generated passwords
 DEFAULT_PASSWORD_CHARS = ascii_letters + digits + ".,:-_"
 
 # non-configurable things
+MODULE_REQUIRE_ARGS       = ['command', 'shell', 'raw', 'script']
 DEFAULT_BECOME_PASS       = None
 DEFAULT_SUDO_PASS         = None
 DEFAULT_REMOTE_PASS       = None

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 = []
+
+        self.ipv4_address = name
+        self.ipv6_address = name
+
         if port and port != C.DEFAULT_REMOTE_PORT:
-            self.set_variable('ansible_ssh_port', int(port))
+            self.port = int(port)
+        else:
+            self.port = C.DEFAULT_REMOTE_PORT
+
+        self._gathered_facts = False
 
-        if self.name is None:
-            raise Exception("host name is required")
+    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):
 

lib/ansible/module_utils/basic.py

@@ -43,7 +43,7 @@ BOOLEANS = BOOLEANS_TRUE + BOOLEANS_FALSE
 # can be inserted in any module source automatically by including
 # #<<INCLUDE_ANSIBLE_MODULE_COMMON>> on a blank line by itself inside
 # of an ansible module. The source of this common code lives
-# in lib/ansible/module_common.py
+# in ansible/executor/module_common.py
 
 import locale
 import os
@@ -65,6 +65,7 @@ import pwd
 import platform
 import errno
 import tempfile
+from itertools import imap, repeat
 
 try:
     import json
@@ -234,7 +235,7 @@ def load_platform_subclass(cls, *args, **kwargs):
     return super(cls, subclass).__new__(subclass)
 
 
-def json_dict_unicode_to_bytes(d):
+def json_dict_unicode_to_bytes(d, encoding='utf-8'):
     ''' Recursively convert dict keys and values to byte str
 
         Specialized for json return because this only handles, lists, tuples,
@@ -242,17 +243,17 @@ def json_dict_unicode_to_bytes(d):
     '''
 
     if isinstance(d, unicode):
-        return d.encode('utf-8')
+        return d.encode(encoding)
     elif isinstance(d, dict):
-        return dict(map(json_dict_unicode_to_bytes, d.iteritems()))
+        return dict(imap(json_dict_unicode_to_bytes, d.iteritems(), repeat(encoding)))
     elif isinstance(d, list):
-        return list(map(json_dict_unicode_to_bytes, d))
+        return list(imap(json_dict_unicode_to_bytes, d, repeat(encoding)))
     elif isinstance(d, tuple):
-        return tuple(map(json_dict_unicode_to_bytes, d))
+        return tuple(imap(json_dict_unicode_to_bytes, d, repeat(encoding)))
     else:
         return d
 
-def json_dict_bytes_to_unicode(d):
+def json_dict_bytes_to_unicode(d, encoding='utf-8'):
     ''' Recursively convert dict keys and values to byte str
 
         Specialized for json return because this only handles, lists, tuples,
@@ -260,13 +261,13 @@ def json_dict_bytes_to_unicode(d):
     '''
 
     if isinstance(d, str):
-        return unicode(d, 'utf-8')
+        return unicode(d, encoding)
     elif isinstance(d, dict):
-        return dict(map(json_dict_bytes_to_unicode, d.iteritems()))
+        return dict(imap(json_dict_bytes_to_unicode, d.iteritems(), repeat(encoding)))
     elif isinstance(d, list):
-        return list(map(json_dict_bytes_to_unicode, d))
+        return list(imap(json_dict_bytes_to_unicode, d, repeat(encoding)))
     elif isinstance(d, tuple):
-        return tuple(map(json_dict_bytes_to_unicode, d))
+        return tuple(imap(json_dict_bytes_to_unicode, d, repeat(encoding)))
     else:
         return d
 
@@ -359,9 +360,9 @@ class AnsibleModule(object):
         # reset to LANG=C if it's an invalid/unavailable locale
         self._check_locale()
 
-        (self.params, self.args) = self._load_params()
+        self.params = self._load_params()
 
-        self._legal_inputs = ['CHECKMODE', 'NO_LOG']
+        self._legal_inputs = ['_ansible_check_mode', '_ansible_no_log']
         
         self.aliases = self._handle_aliases()
 
@@ -888,7 +889,7 @@ class AnsibleModule(object):
 
     def _check_for_check_mode(self):
         for (k,v) in self.params.iteritems():
-            if k == 'CHECKMODE':
+            if k == '_ansible_check_mode':
                 if not self.supports_check_mode:
                     self.exit_json(skipped=True, msg="remote module does not support check mode")
                 if self.supports_check_mode:
@@ -896,13 +897,13 @@ class AnsibleModule(object):
 
     def _check_for_no_log(self):
         for (k,v) in self.params.iteritems():
-            if k == 'NO_LOG':
+            if k == '_ansible_no_log':
                 self.no_log = self.boolean(v)
 
     def _check_invalid_arguments(self):
         for (k,v) in self.params.iteritems():
             # these should be in legal inputs already
-            #if k in ('CHECKMODE', 'NO_LOG'):
+            #if k in ('_ansible_check_mode', '_ansible_no_log'):
             #    continue
             if k not in self._legal_inputs:
                 self.fail_json(msg="unsupported parameter for module: %s" % k)
@@ -1075,20 +1076,11 @@ class AnsibleModule(object):
 
     def _load_params(self):
         ''' read the input and return a dictionary and the arguments string '''
-        args = MODULE_ARGS
-        items   = shlex.split(args)
-        params = {}
-        for x in items:
-            try:
-                (k, v) = x.split("=",1)
-            except Exception, e:
-                self.fail_json(msg="this module requires key=value arguments (%s)" % (items))
-            if k in params:
-                self.fail_json(msg="duplicate parameter: %s (value=%s)" % (k, v))
-            params[k] = v
-        params2 = json_dict_unicode_to_bytes(json.loads(MODULE_COMPLEX_ARGS))
-        params2.update(params)
-        return (params2, args)
+        params = json_dict_unicode_to_bytes(json.loads(MODULE_COMPLEX_ARGS))
+        if params is None:
+            params = dict()
+        return params
+
 
     def _log_invocation(self):
         ''' log that ansible ran the module '''
@@ -1209,13 +1201,17 @@ class AnsibleModule(object):
             self.fail_json(msg='Boolean %s not in either boolean list' % arg)
 
     def jsonify(self, data):
-        for encoding in ("utf-8", "latin-1", "unicode_escape"):
+        for encoding in ("utf-8", "latin-1"):
             try:
                 return json.dumps(data, encoding=encoding)
-            # Old systems using simplejson module does not support encoding keyword.
-            except TypeError, e:
-                return json.dumps(data)
-            except UnicodeDecodeError, e:
+            # Old systems using old simplejson module does not support encoding keyword.
+            except TypeError:
+                try:
+                    new_data = json_dict_bytes_to_unicode(data, encoding=encoding)
+                except UnicodeDecodeError:
+                    continue
+                return json.dumps(new_data)
+            except UnicodeDecodeError:
                 continue
         self.fail_json(msg='Invalid unicode encoding encountered')
 
@@ -1452,7 +1448,7 @@ class AnsibleModule(object):
         msg = None
         st_in = None
 
-        # Set a temporart env path if a prefix is passed
+        # Set a temporary env path if a prefix is passed
         env=os.environ
         if path_prefix:
             env['PATH']="%s:%s" % (path_prefix, env['PATH'])

lib/ansible/module_utils/powershell.ps1

@@ -142,14 +142,14 @@ Function ConvertTo-Bool
     return
 }
 
-# Helper function to calculate a hash of a file in a way which powershell 3 
+# Helper function to calculate md5 of a file in a way which powershell 3 
 # and above can handle:
-Function Get-FileChecksum($path)
+Function Get-FileMd5($path)
 {
     $hash = ""
     If (Test-Path -PathType Leaf $path)
     {
-        $sp = new-object -TypeName System.Security.Cryptography.SHA1CryptoServiceProvider;
+        $sp = new-object -TypeName System.Security.Cryptography.MD5CryptoServiceProvider;
         $fp = [System.IO.File]::Open($path, [System.IO.Filemode]::Open, [System.IO.FileAccess]::Read);
         [System.BitConverter]::ToString($sp.ComputeHash($fp)).Replace("-", "").ToLower();
         $fp.Dispose();

lib/ansible/modules/__init__.py

+# (c) 2012-2014, Michael DeHaan <michael.dehaan@gmail.com>
+#
+# This file is part of Ansible
+#
+# Ansible 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.
+#
+# Ansible 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 Ansible.  If not, see <http://www.gnu.org/licenses/>.
+
+# Make coding more python3-ish
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type

core @ 9028e9d4

-Subproject commit 9028e9d4be8a3dbb96c81a799e18f3adf63d9fd0

extras @ dd80fa22

-Subproject commit dd80fa221ce0adb3abd658fbd1aa09bf7cf8a6dc

v2/ansible/modules/__init__.py → lib/ansible/new_inventory/group.py

@@ -18,3 +18,4 @@
 # Make coding more python3-ish
 from __future__ import (absolute_import, division, print_function)
 __metaclass__ = type
+

lib/ansible/parsing/yaml/constructor.py

+# (c) 2012-2014, Michael DeHaan <michael.dehaan@gmail.com>
+#
+# This file is part of Ansible
+#
+# Ansible 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.
+#
+# Ansible 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 Ansible.  If not, see <http://www.gnu.org/licenses/>.
+
+# Make coding more python3-ish
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+from yaml.constructor import Constructor
+from ansible.parsing.yaml.objects import AnsibleMapping, AnsibleSequence, AnsibleUnicode
+
+class AnsibleConstructor(Constructor):
+    def __init__(self, file_name=None):
+        self._ansible_file_name = file_name
+        super(AnsibleConstructor, self).__init__()
+
+    def construct_yaml_map(self, node):
+        data = AnsibleMapping()
+        yield data
+        value = self.construct_mapping(node)
+        data.update(value)
+        data.ansible_pos = self._node_position_info(node)
+
+    def construct_mapping(self, node, deep=False):
+        ret = AnsibleMapping(super(Constructor, self).construct_mapping(node, deep))
+        ret.ansible_pos = self._node_position_info(node)
+
+        return ret
+
+    def construct_yaml_str(self, node):
+        # Override the default string handling function
+        # to always return unicode objects
+        value = self.construct_scalar(node)
+        ret = AnsibleUnicode(value)
+
+        ret.ansible_pos = self._node_position_info(node)
+
+        return ret
+
+    def construct_yaml_seq(self, node):
+        data = AnsibleSequence()
+        yield data
+        data.extend(self.construct_sequence(node))
+        data.ansible_pos = self._node_position_info(node)
+
+    def _node_position_info(self, node):
+        # the line number where the previous token has ended (plus empty lines)
+        # Add one so that the first line is line 1 rather than line 0
+        column = node.start_mark.column + 1
+        line = node.start_mark.line + 1
+
+        # in some cases, we may have pre-read the data and then
+        # passed it to the load() call for YAML, in which case we
+        # want to override the default datasource (which would be
+        # '<string>') to the actual filename we read in
+        datasource = self._ansible_file_name or node.start_mark.name
+
+        return (datasource, line, column)
+
+AnsibleConstructor.add_constructor(
+    u'tag:yaml.org,2002:map',
+    AnsibleConstructor.construct_yaml_map)
+
+AnsibleConstructor.add_constructor(
+    u'tag:yaml.org,2002:python/dict',
+    AnsibleConstructor.construct_yaml_map)
+
+AnsibleConstructor.add_constructor(
+    u'tag:yaml.org,2002:str',
+    AnsibleConstructor.construct_yaml_str)
+
+AnsibleConstructor.add_constructor(
+    u'tag:yaml.org,2002:python/unicode',
+    AnsibleConstructor.construct_yaml_str)
+
+AnsibleConstructor.add_constructor(
+    u'tag:yaml.org,2002:seq',
+    AnsibleConstructor.construct_yaml_seq)

lib/ansible/playbook/become.py

+# (c) 2012-2014, Michael DeHaan <michael.dehaan@gmail.com>
+#
+# This file is part of Ansible
+#
+# Ansible 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.
+#
+# Ansible 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 Ansible.  If not, see <http://www.gnu.org/licenses/>.
+
+# Make coding more python3-ish
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+from ansible import constants as C
+from ansible.errors import AnsibleError, AnsibleParserError
+from ansible.playbook.attribute import Attribute, FieldAttribute
+#from ansible.utils.display import deprecated
+
+class Become:
+
+    # Privlege escalation
+    _become              = FieldAttribute(isa='bool', default=False)
+    _become_method       = FieldAttribute(isa='string')
+    _become_user         = FieldAttribute(isa='string')
+    _become_pass         = FieldAttribute(isa='string')
+
+    def __init__(self):
+        return super(Become, self).__init__()
+
+    def _detect_privilege_escalation_conflict(self, ds):
+
+        # Fail out if user specifies conflicting privilege escalations
+        has_become = 'become' in ds or 'become_user'in ds
+        has_sudo   = 'sudo' in ds or 'sudo_user' in ds
+        has_su     = 'su' in ds or 'su_user' in ds
+
+        if has_become:
+            msg = 'The become params ("become", "become_user") and'
+            if has_sudo:
+                raise AnsibleParserError('%s sudo params ("sudo", "sudo_user") cannot be used together' % msg)
+            elif has_su:
+                raise AnsibleParserError('%s su params ("su", "su_user") cannot be used together' % msg)
+        elif has_sudo and has_su:
+            raise AnsibleParserError('sudo params ("sudo", "sudo_user") and su params ("su", "su_user") cannot be used together')
+
+    def _preprocess_data_become(self, ds):
+        """Preprocess the playbook data for become attributes
+
+        This is called from the Base object's preprocess_data() method which
+        in turn is called pretty much anytime any sort of playbook object
+        (plays, tasks, blocks, etc) are created.
+        """
+
+        self._detect_privilege_escalation_conflict(ds)
+
+        # Setting user implies setting become/sudo/su to true
+        if 'become_user' in ds and not ds.get('become', False):
+            ds['become'] = True
+
+        # Privilege escalation, backwards compatibility for sudo/su
+        if 'sudo' in ds or 'sudo_user' in ds:
+            ds['become_method'] = 'sudo'
+            if 'sudo' in ds:
+                ds['become'] = ds['sudo']
+                del ds['sudo']
+            else:
+                ds['become'] = True
+            if 'sudo_user' in ds:
+                ds['become_user'] = ds['sudo_user']
+                del ds['sudo_user']
+
+            #deprecated("Instead of sudo/sudo_user, use become/become_user and set become_method to 'sudo' (default)")
+
+        elif 'su' in ds or 'su_user' in ds:
+            ds['become_method'] = 'su'
+            if 'su' in ds:
+                ds['become'] = ds['su']
+                del ds['su']
+            else:
+                ds['become'] = True
+            if 'su_user' in ds:
+                ds['become_user'] = ds['su_user']
+                del ds['su_user']
+
+            #deprecated("Instead of su/su_user, use become/become_user and set become_method to 'su' (default is sudo)")
+
+        # if we are becoming someone else, but some fields are unset,
+        # make sure they're initialized to the default config values
+        if ds.get('become', False):
+            if ds.get('become_method', None) is None:
+                ds['become_method'] = C.DEFAULT_BECOME_METHOD
+            if ds.get('become_user', None) is None:
+                ds['become_user'] = C.DEFAULT_BECOME_USER
+
+        return ds
+
+    def _get_attr_become(self):
+        '''
+        Override for the 'become' getattr fetcher, used from Base.
+        '''
+        if hasattr(self, '_get_parent_attribute'):
+            return self._get_parent_attribute('become')
+        else:
+            return self._attributes['become']
+
+    def _get_attr_become_method(self):
+        '''
+        Override for the 'become_method' getattr fetcher, used from Base.
+        '''
+        if hasattr(self, '_get_parent_attribute'):
+            return self._get_parent_attribute('become_method')
+        else:
+            return self._attributes['become_method']
+
+    def _get_attr_become_user(self):
+        '''
+        Override for the 'become_user' getattr fetcher, used from Base.
+        '''
+        if hasattr(self, '_get_parent_attribute'):
+            return self._get_parent_attribute('become_user')
+        else:
+            return self._attributes['become_user']
+
+    def _get_attr_become_password(self):
+        '''
+        Override for the 'become_password' getattr fetcher, used from Base.
+        '''
+        if hasattr(self, '_get_parent_attribute'):
+            return self._get_parent_attribute('become_password')
+        else:
+            return self._attributes['become_password']
+
+

lib/ansible/playbook/conditional.py

+# (c) 2012-2014, Michael DeHaan <michael.dehaan@gmail.com>
+#
+# This file is part of Ansible
+#
+# Ansible 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.
+#
+# Ansible 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 Ansible.  If not, see <http://www.gnu.org/licenses/>.
+
+# Make coding more python3-ish
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+from ansible.errors import *
+from ansible.playbook.attribute import FieldAttribute
+from ansible.template import Templar
+
+class Conditional:
+
+    '''
+    This is a mix-in class, to be used with Base to allow the object
+    to be run conditionally when a condition is met or skipped.
+    '''
+
+    _when = FieldAttribute(isa='list', default=[])
+
+    def __init__(self, loader=None):
+        # when used directly, this class needs a loader, but we want to
+        # make sure we don't trample on the existing one if this class
+        # is used as a mix-in with a playbook base class
+        if not hasattr(self, '_loader'):
+            if loader is None:
+                raise AnsibleError("a loader must be specified when using Conditional() directly")
+            else:
+                self._loader = loader
+        super(Conditional, self).__init__()
+
+    def _validate_when(self, attr, name, value):
+        if not isinstance(value, list):
+            setattr(self, name, [ value ])
+
+    def evaluate_conditional(self, all_vars):
+        '''
+        Loops through the conditionals set on this object, returning
+        False if any of them evaluate as such.
+        '''
+
+        templar = Templar(loader=self._loader, variables=all_vars, fail_on_undefined=False)
+        for conditional in self.when:
+            if not self._check_conditional(conditional, templar, all_vars):
+                return False
+        return True
+
+    def _check_conditional(self, conditional, templar, all_vars):
+        '''
+        This method does the low-level evaluation of each conditional
+        set on this object, using jinja2 to wrap the conditionals for
+        evaluation.
+        '''
+
+        original = conditional
+        if conditional is None or conditional == '':
+            return True
+
+        if conditional in all_vars and '-' not in unicode(all_vars[conditional]):
+            conditional = all_vars[conditional]
+
+        conditional = templar.template(conditional)
+        if not isinstance(conditional, basestring) or conditional == "":
+            return conditional
+
+        # a Jinja2 evaluation that results in something Python can eval!
+        presented = "{%% if %s %%} True {%% else %%} False {%% endif %%}" % conditional
+        conditional = templar.template(presented)
+
+        val = conditional.strip()
+        if val == presented:
+            # the templating failed, meaning most likely a
+            # variable was undefined. If we happened to be
+            # looking for an undefined variable, return True,
+            # otherwise fail
+            if "is undefined" in original:
+                return True
+            elif "is defined" in original:
+                return False
+            else:
+                raise AnsibleError("error while evaluating conditional: %s (%s)" % (original, presented))
+        elif val == "True":
+            return True
+        elif val == "False":
+            return False
+        else:
+            raise AnsibleError("unable to evaluate conditional: %s" % original)
+

lib/ansible/playbook/handler.py

+# (c) 2012-2014, Michael DeHaan <michael.dehaan@gmail.com>
+#
+# This file is part of Ansible
+#
+# Ansible 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.
+#
+# Ansible 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 Ansible.  If not, see <http://www.gnu.org/licenses/>.
+
+# Make coding more python3-ish
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+from ansible.errors import AnsibleError
+#from ansible.inventory.host import Host
+from ansible.playbook.task import Task
+
+class Handler(Task):
+
+    def __init__(self, block=None, role=None, task_include=None):
+        self._flagged_hosts = []
+
+        super(Handler, self).__init__(block=block, role=role, task_include=task_include)
+
+    def __repr__(self):
+        ''' returns a human readable representation of the handler '''
+        return "HANDLER: %s" % self.get_name()
+
+    @staticmethod
+    def load(data, block=None, role=None, task_include=None, variable_manager=None, loader=None):
+        t = Handler(block=block, role=role, task_include=task_include)
+        return t.load_data(data, variable_manager=variable_manager, loader=loader)
+
+    def flag_for_host(self, host):
+        #assert instanceof(host, Host)
+        if host not in self._flagged_hosts:
+            self._flagged_hosts.append(host)
+
+    def has_triggered(self, host):
+        return host in self._flagged_hosts
+
+    def serialize(self):
+        result = super(Handler, self).serialize()
+        result['is_handler'] = True
+        return result

lib/ansible/playbook/helpers.py

+# (c) 2012-2014, Michael DeHaan <michael.dehaan@gmail.com>
+#
+# This file is part of Ansible
+#
+# Ansible 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.
+#
+# Ansible 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 Ansible.  If not, see <http://www.gnu.org/licenses/>.
+
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+import os
+
+from types import NoneType
+
+from ansible.errors import AnsibleParserError
+from ansible.parsing.yaml.objects import AnsibleBaseYAMLObject, AnsibleSequence
+
+
+def load_list_of_blocks(ds, play, parent_block=None, role=None, task_include=None, use_handlers=False, variable_manager=None, loader=None):
+    '''
+    Given a list of mixed task/block data (parsed from YAML),
+    return a list of Block() objects, where implicit blocks
+    are created for each bare Task.
+    '''
+ 
+    # we import here to prevent a circular dependency with imports
+    from ansible.playbook.block import Block
+
+    assert ds is None or isinstance(ds, list), 'block has bad type: %s' % type(ds)
+
+    block_list = []
+    if ds:
+        for block in ds:
+            b = Block.load(
+                block,
+                play=play,
+                parent_block=parent_block,
+                role=role,
+                task_include=task_include,
+                use_handlers=use_handlers,
+                variable_manager=variable_manager,
+                loader=loader
+            )
+            block_list.append(b)
+
+    return block_list
+
+
+def load_list_of_tasks(ds, play, block=None, role=None, task_include=None, use_handlers=False, variable_manager=None, loader=None):
+    '''
+    Given a list of task datastructures (parsed from YAML),
+    return a list of Task() or TaskInclude() objects.
+    '''
+
+    # we import here to prevent a circular dependency with imports
+    from ansible.playbook.block import Block
+    from ansible.playbook.handler import Handler
+    from ansible.playbook.task import Task
+
+    assert isinstance(ds, list), 'task has bad type: %s' % type(ds)
+
+    task_list = []
+    for task in ds:
+        if not isinstance(task, dict):
+            raise AnsibleParserError("task/handler entries must be dictionaries (got a %s)" % type(task), obj=ds)
+
+        if 'block' in task:
+            t = Block.load(
+                task,
+                play=play,
+                parent_block=block,
+                role=role,
+                task_include=task_include,
+                use_handlers=use_handlers,
+                variable_manager=variable_manager,
+                loader=loader,
+            )
+        else:
+            if use_handlers:
+                t = Handler.load(task, block=block, role=role, task_include=task_include, variable_manager=variable_manager, loader=loader)
+            else:
+                t = Task.load(task, block=block, role=role, task_include=task_include, variable_manager=variable_manager, loader=loader)
+
+        task_list.append(t)
+
+    return task_list
+
+
+def load_list_of_roles(ds, current_role_path=None, variable_manager=None, loader=None):
+    '''
+    Loads and returns a list of RoleInclude objects from the datastructure
+    list of role definitions
+    '''
+
+    # we import here to prevent a circular dependency with imports
+    from ansible.playbook.role.include import RoleInclude
+
+    assert isinstance(ds, list), 'roles has bad type: %s' % type(ds)
+
+    roles = []
+    for role_def in ds:
+        i = RoleInclude.load(role_def, current_role_path=current_role_path, variable_manager=variable_manager, loader=loader)
+        roles.append(i)
+
+    return roles
+

lib/ansible/playbook/playbook_include.py

+# (c) 2012-2014, Michael DeHaan <michael.dehaan@gmail.com>
+#
+# This file is part of Ansible
+#
+# Ansible 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.
+#
+# Ansible 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 Ansible.  If not, see <http://www.gnu.org/licenses/>.
+
+# Make coding more python3-ish
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+import os
+
+from ansible.parsing.splitter import split_args, parse_kv
+from ansible.parsing.yaml.objects import AnsibleBaseYAMLObject, AnsibleMapping
+from ansible.playbook.attribute import FieldAttribute
+from ansible.playbook.base import Base
+from ansible.playbook.conditional import Conditional
+from ansible.playbook.taggable import Taggable
+from ansible.errors import AnsibleParserError
+
+class PlaybookInclude(Base):
+
+    _name      = FieldAttribute(isa='string')
+    _include   = FieldAttribute(isa='string')
+    _vars      = FieldAttribute(isa='dict', default=dict())
+
+    @staticmethod
+    def load(data, basedir, variable_manager=None, loader=None):
+        return PlaybookInclude().load_data(ds=data, basedir=basedir, variable_manager=variable_manager, loader=loader)
+
+    def load_data(self, ds, basedir, variable_manager=None, loader=None):
+        '''
+        Overrides the base load_data(), as we're actually going to return a new
+        Playbook() object rather than a PlaybookInclude object
+        '''
+
+        # import here to avoid a dependency loop
+        from ansible.playbook import Playbook
+
+        # first, we use the original parent method to correctly load the object
+        # via the load_data/preprocess_data system we normally use for other
+        # playbook objects
+        new_obj = super(PlaybookInclude, self).load_data(ds, variable_manager, loader)
+
+        # then we use the object to load a Playbook
+        pb = Playbook(loader=loader)
+
+        file_name = new_obj.include
+        if not os.path.isabs(file_name):
+            file_name = os.path.join(basedir, file_name)
+
+        pb._load_playbook_data(file_name=file_name, variable_manager=variable_manager)
+
+        # finally, playbook includes can specify a list of variables, which are simply
+        # used to update the vars of each play in the playbook
+        for entry in pb._entries:
+            entry.vars.update(new_obj.vars)
+
+        return pb
+
+    def preprocess_data(self, ds):
+        '''
+        Regorganizes the data for a PlaybookInclude datastructure to line
+        up with what we expect the proper attributes to be
+        '''
+
+        assert isinstance(ds, dict)
+
+        # the new, cleaned datastructure, which will have legacy
+        # items reduced to a standard structure
+        new_ds = AnsibleMapping()
+        if isinstance(ds, AnsibleBaseYAMLObject):
+            new_ds.ansible_pos = ds.ansible_pos
+
+        for (k,v) in ds.iteritems():
+            if k == 'include':
+                self._preprocess_include(ds, new_ds, k, v)
+            else:
+                # some basic error checking, to make sure vars are properly
+                # formatted and do not conflict with k=v parameters
+                # FIXME: we could merge these instead, but controlling the order
+                #        in which they're encountered could be difficult
+                if k == 'vars':
+                    if 'vars' in new_ds:
+                        raise AnsibleParserError("include parameters cannot be mixed with 'vars' entries for include statements", obj=ds)
+                    elif not isinstance(v, dict):
+                        raise AnsibleParserError("vars for include statements must be specified as a dictionary", obj=ds)
+                new_ds[k] = v
+
+        return super(PlaybookInclude, self).preprocess_data(new_ds)
+
+    def _preprocess_include(self, ds, new_ds, k, v):
+        '''
+        Splits the include line up into filename and parameters
+        '''
+
+        # The include line must include at least one item, which is the filename
+        # to include. Anything after that should be regarded as a parameter to the include
+        items = split_args(v)
+        if len(items) == 0:
+            raise AnsibleParserError("include statements must specify the file name to include", obj=ds)
+        else:
+            # FIXME/TODO: validate that items[0] is a file, which also
+            #             exists and is readable
+            new_ds['include'] = items[0]
+            if len(items) > 1:
+                # rejoin the parameter portion of the arguments and
+                # then use parse_kv() to get a dict of params back
+                params = parse_kv(" ".join(items[1:]))
+                if 'vars' in new_ds:
+                    # FIXME: see fixme above regarding merging vars
+                    raise AnsibleParserError("include parameters cannot be mixed with 'vars' entries for include statements", obj=ds)
+                new_ds['vars'] = params
+

lib/ansible/playbook/role/definition.py

+# (c) 2014 Michael DeHaan, <michael@ansible.com>
+#
+# This file is part of Ansible
+#
+# Ansible 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.
+#
+# Ansible 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 Ansible.  If not, see <http://www.gnu.org/licenses/>.
+
+# Make coding more python3-ish
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+from six import iteritems, string_types
+
+import os
+
+from ansible import constants as C
+from ansible.errors import AnsibleError
+from ansible.parsing.yaml.objects import AnsibleBaseYAMLObject, AnsibleMapping
+from ansible.playbook.attribute import Attribute, FieldAttribute
+from ansible.playbook.base import Base
+from ansible.playbook.become import Become
+from ansible.playbook.conditional import Conditional
+from ansible.playbook.taggable import Taggable
+from ansible.utils.path import unfrackpath
+
+
+__all__ = ['RoleDefinition']
+
+
+class RoleDefinition(Base, Become, Conditional, Taggable):
+
+    _role = FieldAttribute(isa='string')
+
+    def __init__(self, role_basedir=None):
+        self._role_path    = None
+        self._role_basedir = role_basedir
+        self._role_params  = dict()
+        super(RoleDefinition, self).__init__()
+
+    #def __repr__(self):
+    #    return 'ROLEDEF: ' + self._attributes.get('role', '<no name set>')
+
+    @staticmethod
+    def load(data, variable_manager=None, loader=None):
+        raise AnsibleError("not implemented")
+
+    def preprocess_data(self, ds):
+
+        assert isinstance(ds, dict) or isinstance(ds, string_types)
+
+        if isinstance(ds, dict):
+            ds = super(RoleDefinition, self).preprocess_data(ds)
+
+        # we create a new data structure here, using the same
+        # object used internally by the YAML parsing code so we
+        # can preserve file:line:column information if it exists
+        new_ds = AnsibleMapping()
+        if isinstance(ds, AnsibleBaseYAMLObject):
+            new_ds.ansible_pos = ds.ansible_pos
+
+        # first we pull the role name out of the data structure,
+        # and then use that to determine the role path (which may
+        # result in a new role name, if it was a file path)
+        role_name = self._load_role_name(ds)
+        (role_name, role_path) = self._load_role_path(role_name)
+
+        # next, we split the role params out from the valid role
+        # attributes and update the new datastructure with that
+        # result and the role name
+        if isinstance(ds, dict):
+            (new_role_def, role_params) = self._split_role_params(ds)
+            new_ds.update(new_role_def)
+            self._role_params = role_params
+
+        # set the role name in the new ds
+        new_ds['role'] = role_name
+
+        # we store the role path internally
+        self._role_path = role_path
+
+        # save the original ds for use later
+        self._ds = ds
+
+        # and return the cleaned-up data structure
+        return new_ds
+
+    def _load_role_name(self, ds):
+        '''
+        Returns the role name (either the role: or name: field) from
+        the role definition, or (when the role definition is a simple
+        string), just that string
+        '''
+
+        if isinstance(ds, string_types):
+            return ds
+
+        role_name = ds.get('role', ds.get('name'))
+        if not role_name:
+            raise AnsibleError('role definitions must contain a role name', obj=ds)
+
+        return role_name
+
+    def _load_role_path(self, role_name):
+        '''
+        the 'role', as specified in the ds (or as a bare string), can either
+        be a simple name or a full path. If it is a full path, we use the
+        basename as the role name, otherwise we take the name as-given and
+        append it to the default role path
+        '''
+
+        role_path = unfrackpath(role_name)
+
+        if self._loader.path_exists(role_path):
+            role_name = os.path.basename(role_name)
+            return (role_name, role_path)
+        else:
+            # we always start the search for roles in the base directory of the playbook
+            role_search_paths = [os.path.join(self._loader.get_basedir(), 'roles'), './roles', './']
+
+            # also search in the configured roles path
+            if C.DEFAULT_ROLES_PATH:
+                configured_paths = C.DEFAULT_ROLES_PATH.split(os.pathsep)
+                role_search_paths.extend(configured_paths)
+
+            # finally, append the roles basedir, if it was set, so we can
+            # search relative to that directory for dependent roles
+            if self._role_basedir:
+                role_search_paths.append(self._role_basedir)
+
+            # now iterate through the possible paths and return the first one we find
+            for path in role_search_paths:
+                role_path = unfrackpath(os.path.join(path, role_name))
+                if self._loader.path_exists(role_path):
+                    return (role_name, role_path)
+
+        # FIXME: make the parser smart about list/string entries in
+        #        the yaml so the error line/file can be reported here
+
+        raise AnsibleError("the role '%s' was not found" % role_name)
+
+    def _split_role_params(self, ds):
+        '''
+        Splits any random role params off from the role spec and store
+        them in a dictionary of params for parsing later
+        '''
+
+        role_def = dict()
+        role_params = dict()
+        for (key, value) in iteritems(ds):
+            # use the list of FieldAttribute values to determine what is and is not
+            # an extra parameter for this role (or sub-class of this role)
+            if key not in [attr_name for (attr_name, attr_value) in self._get_base_attributes().iteritems()]:
+                # this key does not match a field attribute, so it must be a role param
+                role_params[key] = value
+            else:
+                # this is a field attribute, so copy it over directly
+                role_def[key] = value
+
+        return (role_def, role_params)
+
+    def get_role_params(self):
+        return self._role_params.copy()
+
+    def get_role_path(self):
+        return self._role_path

lib/ansible/playbook/role/include.py

+# (c) 2014 Michael DeHaan, <michael@ansible.com>
+#
+# This file is part of Ansible
+#
+# Ansible 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.
+#
+# Ansible 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 Ansible.  If not, see <http://www.gnu.org/licenses/>.
+
+# Make coding more python3-ish
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+from six import iteritems, string_types
+
+import os
+
+from ansible.errors import AnsibleError, AnsibleParserError
+from ansible.playbook.attribute import Attribute, FieldAttribute
+from ansible.playbook.role.definition import RoleDefinition
+
+
+__all__ = ['RoleInclude']
+
+
+class RoleInclude(RoleDefinition):
+
+    """
+    FIXME: docstring
+    """
+
+    def __init__(self, role_basedir=None):
+        super(RoleInclude, self).__init__(role_basedir=role_basedir)
+
+    @staticmethod
+    def load(data, current_role_path=None, parent_role=None, variable_manager=None, loader=None):
+        assert isinstance(data, string_types) or isinstance(data, dict)
+
+        ri = RoleInclude(role_basedir=current_role_path)
+        return ri.load_data(data, variable_manager=variable_manager, loader=loader)
+

lib/ansible/playbook/role/metadata.py

+# (c) 2014 Michael DeHaan, <michael@ansible.com>
+#
+# This file is part of Ansible
+#
+# Ansible 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.
+#
+# Ansible 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 Ansible.  If not, see <http://www.gnu.org/licenses/>.
+
+# Make coding more python3-ish
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+import os
+
+from six import iteritems, string_types
+
+from ansible.errors import AnsibleParserError
+from ansible.playbook.attribute import Attribute, FieldAttribute
+from ansible.playbook.base import Base
+from ansible.playbook.helpers import load_list_of_roles
+from ansible.playbook.role.include import RoleInclude
+
+
+__all__ = ['RoleMetadata']
+
+
+class RoleMetadata(Base):
+    '''
+    This class wraps the parsing and validation of the optional metadata
+    within each Role (meta/main.yml).
+    '''
+
+    _allow_duplicates = FieldAttribute(isa='bool', default=False)
+    _dependencies     = FieldAttribute(isa='list', default=[])
+    _galaxy_info      = FieldAttribute(isa='GalaxyInfo')
+
+    def __init__(self, owner=None):
+        self._owner = owner
+        super(RoleMetadata, self).__init__()
+
+    @staticmethod
+    def load(data, owner, variable_manager=None, loader=None):
+        '''
+        Returns a new RoleMetadata object based on the datastructure passed in.
+        '''
+
+        if not isinstance(data, dict):
+            raise AnsibleParserError("the 'meta/main.yml' for role %s is not a dictionary" % owner.get_name())
+
+        m = RoleMetadata(owner=owner).load_data(data, variable_manager=variable_manager, loader=loader)
+        return m
+
+    def _load_dependencies(self, attr, ds):
+        '''
+        This is a helper loading function for the dependencies list,
+        which returns a list of RoleInclude objects
+        '''
+
+        current_role_path = None
+        if self._owner:
+            current_role_path = os.path.dirname(self._owner._role_path)
+
+        return load_list_of_roles(ds, current_role_path=current_role_path, variable_manager=self._variable_manager, loader=self._loader)
+
+    def _load_galaxy_info(self, attr, ds):
+        '''
+        This is a helper loading function for the galaxy info entry
+        in the metadata, which returns a GalaxyInfo object rather than
+        a simple dictionary.
+        '''
+
+        return ds
+
+    def serialize(self):
+        return dict(
+            allow_duplicates = self._allow_duplicates,
+            dependencies     = self._dependencies,
+        )
+
+    def deserialize(self, data):
+        setattr(self, 'allow_duplicates', data.get('allow_duplicates', False))
+        setattr(self, 'dependencies', data.get('dependencies', []))

lib/ansible/playbook/role/requirement.py

+# (c) 2014 Michael DeHaan, <michael@ansible.com>
+#
+# This file is part of Ansible
+#
+# Ansible 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.
+#
+# Ansible 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 Ansible.  If not, see <http://www.gnu.org/licenses/>.
+
+# Make coding more python3-ish
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+from six import iteritems, string_types
+
+import os
+
+from ansible.errors import AnsibleError, AnsibleParserError
+from ansible.playbook.role.definition import RoleDefinition
+
+__all__ = ['RoleRequirement']
+
+
+class RoleRequirement(RoleDefinition):
+
+    """
+    FIXME: document various ways role specs can be specified
+    """
+
+    def __init__(self):
+        pass
+
+    def _get_valid_spec_keys(self):
+        return (
+            'name',
+            'role',
+            'scm',
+            'src',
+            'version',
+        )
+
+    def parse(self, ds):
+        '''
+        FIXME: docstring
+        '''
+
+        assert type(ds) == dict or isinstance(ds, string_types)
+
+        role_name    = ''
+        role_params  = dict()
+        new_ds       = dict()
+
+        if isinstance(ds, string_types):
+            role_name = ds
+        else:
+            ds = self._preprocess_role_spec(ds)
+            (new_ds, role_params) = self._split_role_params(ds)
+
+            # pull the role name out of the ds
+            role_name = new_ds.get('role_name')
+            del ds['role_name']
+
+        return (new_ds, role_name, role_params)
+
+    def _preprocess_role_spec(self, ds):
+        if 'role' in ds:
+            # Old style: {role: "galaxy.role,version,name", other_vars: "here" }
+            role_info = self._role_spec_parse(ds['role'])
+            if isinstance(role_info, dict):
+                # Warning: Slight change in behaviour here.  name may be being
+                # overloaded.  Previously, name was only a parameter to the role.
+                # Now it is both a parameter to the role and the name that
+                # ansible-galaxy will install under on the local system.
+                if 'name' in ds and 'name' in role_info:
+                    del role_info['name']
+                ds.update(role_info)
+        else:
+            # New style: { src: 'galaxy.role,version,name', other_vars: "here" }
+            if 'github.com' in ds["src"] and 'http' in ds["src"] and '+' not in ds["src"] and not ds["src"].endswith('.tar.gz'):
+                ds["src"] = "git+" + ds["src"]
+
+            if '+' in ds["src"]:
+                (scm, src) = ds["src"].split('+')
+                ds["scm"] = scm
+                ds["src"] = src
+
+            if 'name' in ds:
+                ds["role"] = ds["name"]
+                del ds["name"]
+            else:
+                ds["role"] = self._repo_url_to_role_name(ds["src"])
+
+            # set some values to a default value, if none were specified
+            ds.setdefault('version', '')
+            ds.setdefault('scm', None)
+
+        return ds
+
+    def _repo_url_to_role_name(self, repo_url):
+        # gets the role name out of a repo like
+        # http://git.example.com/repos/repo.git" => "repo"
+
+        if '://' not in repo_url and '@' not in repo_url:
+            return repo_url
+        trailing_path = repo_url.split('/')[-1]
+        if trailing_path.endswith('.git'):
+            trailing_path = trailing_path[:-4]
+        if trailing_path.endswith('.tar.gz'):
+            trailing_path = trailing_path[:-7]
+        if ',' in trailing_path:
+            trailing_path = trailing_path.split(',')[0]
+        return trailing_path
+
+    def _role_spec_parse(self, role_spec):
+        # takes a repo and a version like
+        # git+http://git.example.com/repos/repo.git,v1.0
+        # and returns a list of properties such as:
+        # {
+        #   'scm': 'git',
+        #   'src': 'http://git.example.com/repos/repo.git',
+        #   'version': 'v1.0',
+        #   'name': 'repo'
+        # }
+
+        default_role_versions = dict(git='master', hg='tip')
+
+        role_spec = role_spec.strip()
+        role_version = ''
+        if role_spec == "" or role_spec.startswith("#"):
+            return (None, None, None, None)
+
+        tokens = [s.strip() for s in role_spec.split(',')]
+
+        # assume https://github.com URLs are git+https:// URLs and not
+        # tarballs unless they end in '.zip'
+        if 'github.com/' in tokens[0] and not tokens[0].startswith("git+") and not tokens[0].endswith('.tar.gz'):
+            tokens[0] = 'git+' + tokens[0]
+
+        if '+' in tokens[0]:
+            (scm, role_url) = tokens[0].split('+')
+        else:
+            scm = None
+            role_url = tokens[0]
+
+        if len(tokens) >= 2:
+            role_version = tokens[1]
+
+        if len(tokens) == 3:
+            role_name = tokens[2]
+        else:
+            role_name = self._repo_url_to_role_name(tokens[0])
+
+        if scm and not role_version:
+            role_version = default_role_versions.get(scm, '')
+
+        return dict(scm=scm, src=role_url, version=role_version, role_name=role_name)
+
+

lib/ansible/playbook/taggable.py

+# (c) 2012-2014, Michael DeHaan <michael.dehaan@gmail.com>
+#
+# This file is part of Ansible
+#
+# Ansible 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.
+#
+# Ansible 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 Ansible.  If not, see <http://www.gnu.org/licenses/>.
+
+# Make coding more python3-ish
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+from ansible.errors import AnsibleError
+from ansible.playbook.attribute import FieldAttribute
+from ansible.template import Templar
+
+class Taggable:
+
+    untagged = set(['untagged'])
+    _tags = FieldAttribute(isa='list', default=[])
+
+    def __init__(self):
+        super(Taggable, self).__init__()
+
+    def _load_tags(self, attr, ds):
+        if isinstance(ds, list):
+            return ds
+        elif isinstance(ds, basestring):
+            return [ ds ]
+        else:
+            raise AnsibleError('tags must be specified as a list', obj=ds)
+
+    def _get_attr_tags(self):
+        '''
+        Override for the 'tags' getattr fetcher, used from Base.
+        '''
+        tags = self._attributes['tags']
+        if tags is None:
+            tags = []
+        if hasattr(self, '_get_parent_attribute'):
+            tags = self._get_parent_attribute('tags', extend=True)
+        return tags
+
+    def evaluate_tags(self, only_tags, skip_tags, all_vars):
+        ''' this checks if the current item should be executed depending on tag options '''
+
+        should_run = True
+
+        if self.tags:
+            templar = Templar(loader=self._loader, variables=all_vars)
+            tags = templar.template(self.tags)
+
+            if not isinstance(tags, list):
+                if tags.find(',') != -1:
+                    tags = set(tags.split(','))
+                else:
+                    tags = set([tags])
+            else:
+                tags = set(tags)
+        else:
+            # this makes intersection work for untagged
+            tags = self.__class__.untagged
+
+        if only_tags:
+
+            should_run = False
+
+            if 'always' in tags or 'all' in only_tags:
+                 should_run = True
+            elif tags.intersection(only_tags):
+                should_run = True
+            elif 'tagged' in only_tags and tags != self.__class__.untagged:
+                should_run = True
+
+        if should_run and skip_tags:
+
+            # Check for tags that we need to skip
+            if 'all' in skip_tags:
+                if 'always' not in tags or 'always' in skip_tags:
+                    should_run = False
+            elif tags.intersection(skip_tags):
+                should_run = False
+            elif 'tagged' in skip_tags and tags != self.__class__.untagged:
+                should_run = False
+
+        return should_run

lib/ansible/plugins/action/add_host.py

+# (c) 2012-2014, Michael DeHaan <michael.dehaan@gmail.com>
+# Copyright 2012, Seth Vidal <skvidal@fedoraproject.org>
+#
+# This file is part of Ansible
+#
+# Ansible 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.
+#
+# Ansible 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 Ansible.  If not, see <http://www.gnu.org/licenses/>.
+
+# Make coding more python3-ish
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+from ansible.plugins.action import ActionBase
+
+class ActionModule(ActionBase):
+    ''' Create inventory hosts and groups in the memory inventory'''
+
+    ### We need to be able to modify the inventory
+    BYPASS_HOST_LOOP = True
+    TRANSFERS_FILES = False
+
+    def run(self, tmp=None, task_vars=dict()):
+
+        # FIXME: is this necessary in v2?
+        #if self.runner.noop_on_check(inject):
+        #    return ReturnData(conn=conn, comm_ok=True, result=dict(skipped=True, msg='check mode not supported for this module'))
+
+        # Parse out any hostname:port patterns
+        new_name = self._task.args.get('name', self._task.args.get('hostname', None))
+        #vv("creating host via 'add_host': hostname=%s" % new_name)
+
+        if ":" in new_name:
+            new_name, new_port = new_name.split(":")
+            self._task.args['ansible_ssh_port'] = new_port
+
+        groups = self._task.args.get('groupname', self._task.args.get('groups', self._task.args.get('group', ''))) 
+        # add it to the group if that was specified
+        new_groups = []
+        if groups:
+            for group_name in groups.split(","):
+                if group_name not in new_groups:
+                    new_groups.append(group_name.strip())
+
+        # Add any variables to the new_host
+        host_vars = dict()
+        for k in self._task.args.keys():
+            if not k in [ 'name', 'hostname', 'groupname', 'groups' ]:
+                host_vars[k] = self._task.args[k] 
+
+        return dict(changed=True, add_host=dict(host_name=new_name, groups=new_groups, host_vars=host_vars))
+
+

lib/ansible/plugins/action/assemble.py

+# (c) 2013-2014, Michael DeHaan <michael.dehaan@gmail.com>
+#           Stephen Fromm <sfromm@gmail.com>
+#           Brian Coca  <briancoca+dev@gmail.com>
+#
+# This file is part of Ansible
+#
+# Ansible 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.
+#
+# Ansible 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
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+import os
+import os.path
+import pipes
+import shutil
+import tempfile
+import base64
+import re
+
+from ansible.plugins.action import ActionBase
+from ansible.utils.boolean import boolean
+from ansible.utils.hashing import checksum_s
+
+class ActionModule(ActionBase):
+
+    TRANSFERS_FILES = True
+
+    def _assemble_from_fragments(self, src_path, delimiter=None, compiled_regexp=None):
+        ''' assemble a file from a directory of fragments '''
+
+        tmpfd, temp_path = tempfile.mkstemp()
+        tmp = os.fdopen(tmpfd,'w')
+        delimit_me = False
+        add_newline = False
+
+        for f in sorted(os.listdir(src_path)):
+            if compiled_regexp and not compiled_regexp.search(f):
+                continue
+            fragment = "%s/%s" % (src_path, f)
+            if not os.path.isfile(fragment):
+                continue
+            fragment_content = file(fragment).read()
+
+            # always put a newline between fragments if the previous fragment didn't end with a newline.
+            if add_newline:
+                tmp.write('\n')
+
+            # delimiters should only appear between fragments
+            if delimit_me:
+                if delimiter:
+                    # un-escape anything like newlines
+                    delimiter = delimiter.decode('unicode-escape')
+                    tmp.write(delimiter)
+                    # always make sure there's a newline after the
+                    # delimiter, so lines don't run together
+                    if delimiter[-1] != '\n':
+                        tmp.write('\n')
+
+            tmp.write(fragment_content)
+            delimit_me = True
+            if fragment_content.endswith('\n'):
+                add_newline = False
+            else:
+                add_newline = True
+
+        tmp.close()
+        return temp_path
+
+    def run(self, tmp=None, task_vars=dict()):
+
+        src        = self._task.args.get('src', None)
+        dest       = self._task.args.get('dest', None)
+        delimiter  = self._task.args.get('delimiter', None)
+        remote_src = self._task.args.get('remote_src', 'yes')
+        regexp     = self._task.args.get('regexp', None)
+
+        if src is None or dest is None:
+            return dict(failed=True, msg="src and dest are required")
+
+        if boolean(remote_src):
+            return self._execute_module(tmp=tmp)
+        elif self._task._role is not None:
+            src = self._loader.path_dwim_relative(self._task._role._role_path, 'files', src)
+        else:
+            # the source is local, so expand it here
+            src = self._loader.path_dwim(os.path.expanduser(src))
+
+        _re = None
+        if regexp is not None:
+            _re = re.compile(regexp)
+
+        # Does all work assembling the file
+        path = self._assemble_from_fragments(src, delimiter, _re)
+
+        path_checksum = checksum_s(path)
+        dest = self._remote_expand_user(dest, tmp)
+        remote_checksum = self._remote_checksum(tmp, dest)
+
+        if path_checksum != remote_checksum:
+            resultant = file(path).read()
+            # FIXME: diff needs to be moved somewhere else
+            #if self.runner.diff:
+            #    dest_result = self._execute_module(module_name='slurp', module_args=dict(path=dest), tmp=tmp, persist_files=True)
+            #    if 'content' in dest_result:
+            #        dest_contents = dest_result['content']
+            #        if dest_result['encoding'] == 'base64':
+            #            dest_contents = base64.b64decode(dest_contents)
+            #        else:
+            #            raise Exception("unknown encoding, failed: %s" % dest_result)
+            xfered = self._transfer_data('src', resultant)
+
+            # fix file permissions when the copy is done as a different user
+            if self._connection_info.become and self._connection_info.become_user != 'root':
+                self._remote_chmod('a+r', xfered, tmp)
+
+            # run the copy module
+            
+            new_module_args = self._task.args.copy()
+            new_module_args.update(
+                dict(
+                    src=xfered,
+                    dest=dest,
+                    original_basename=os.path.basename(src),
+                )
+            )
+
+            # FIXME: checkmode stuff
+            #if self.runner.noop_on_check(inject):
+            #    return ReturnData(conn=conn, comm_ok=True, result=dict(changed=True), diff=dict(before_header=dest, after_header=src, after=resultant))
+            #else:
+            #    res = self.runner._execute_module(conn, tmp, 'copy', module_args_tmp, inject=inject)
+            #    res.diff = dict(after=resultant)
+            #    return res
+            res = self._execute_module(module_name='copy', module_args=new_module_args, tmp=tmp)
+            #res.diff = dict(after=resultant)
+            return res
+        else:
+            new_module_args = self._task.args.copy()
+            new_module_args.update(
+                dict(
+                    src=xfered,
+                    dest=dest,
+                    original_basename=os.path.basename(src),
+                )
+            )
+
+            return self._execute_module(module_name='file', module_args=new_module_args, tmp=tmp)

lib/ansible/plugins/action/assert.py

+# Copyright 2012, Dag Wieers <dag@wieers.com>
+#
+# This file is part of Ansible
+#
+# Ansible 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.
+#
+# Ansible 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 Ansible.  If not, see <http://www.gnu.org/licenses/>.
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+from ansible.errors import AnsibleError
+from ansible.playbook.conditional import Conditional
+from ansible.plugins.action import ActionBase
+
+class ActionModule(ActionBase):
+    ''' Fail with custom message '''
+
+    TRANSFERS_FILES = False
+
+    def run(self, tmp=None, task_vars=dict()):
+
+        if not 'that' in self._task.args:
+            raise AnsibleError('conditional required in "that" string')
+
+        msg = None
+        if 'msg' in self._task.args:
+            msg = self._task.args['msg']
+
+        # make sure the 'that' items are a list
+        thats = self._task.args['that']
+        if not isinstance(thats, list):
+            thats = [ thats ]
+
+        # Now we iterate over the that items, temporarily assigning them
+        # to the task's when value so we can evaluate the conditional using
+        # the built in evaluate function. The when has already been evaluated
+        # by this point, and is not used again, so we don't care about mangling
+        # that value now
+        cond = Conditional(loader=self._loader)
+        for that in thats:
+            cond.when = [ that ]
+            test_result = cond.evaluate_conditional(all_vars=task_vars)
+            if not test_result:
+                result = dict(
+                   failed       = True,
+                   evaluated_to = test_result,
+                   assertion    = that,
+                )
+
+                if msg:
+                    result['msg'] = msg
+
+                return result
+
+        return dict(changed=False, msg='all assertions passed')
+

lib/ansible/plugins/action/async.py

+# (c) 2012-2014, Michael DeHaan <michael.dehaan@gmail.com>
+#
+# This file is part of Ansible
+#
+# Ansible 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.
+#
+# Ansible 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 Ansible.  If not, see <http://www.gnu.org/licenses/>.
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+import json
+import random
+
+from ansible import constants as C
+from ansible.plugins.action import ActionBase
+
+class ActionModule(ActionBase):
+
+    def run(self, tmp=None, task_vars=dict()):
+        ''' transfer the given module name, plus the async module, then run it '''
+
+        # FIXME: noop stuff needs to be sorted ut
+        #if self.runner.noop_on_check(inject):
+        #    return ReturnData(conn=conn, comm_ok=True, result=dict(skipped=True, msg='check mode not supported for this module'))
+
+        if not tmp:
+            tmp = self._make_tmp_path()
+
+        module_name = self._task.action
+        async_module_path  = self._shell.join_path(tmp, 'async_wrapper')
+        remote_module_path = self._shell.join_path(tmp, module_name)
+
+        env_string = self._compute_environment_string()
+
+        # configure, upload, and chmod the target module
+        (module_style, shebang, module_data) = self._configure_module(module_name=module_name, module_args=self._task.args)
+        self._transfer_data(remote_module_path, module_data)
+        self._remote_chmod(tmp, 'a+rx', remote_module_path)
+
+        # configure, upload, and chmod the async_wrapper module
+        (async_module_style, shebang, async_module_data) = self._configure_module(module_name='async_wrapper', module_args=dict())
+        self._transfer_data(async_module_path, async_module_data)
+        self._remote_chmod(tmp, 'a+rx', async_module_path)
+
+        argsfile = self._transfer_data(self._shell.join_path(tmp, 'arguments'), json.dumps(self._task.args))
+
+        async_limit = self._task.async
+        async_jid   = str(random.randint(0, 999999999999))
+
+        async_cmd = " ".join([str(x) for x in [async_module_path, async_jid, async_limit, remote_module_path, argsfile]])
+        result = self._low_level_execute_command(cmd=async_cmd, tmp=None)
+
+        # clean up after
+        if tmp and "tmp" in tmp and not C.DEFAULT_KEEP_REMOTE_FILES:
+            self._remove_tmp_path(tmp)
+
+        result['changed'] = True
+
+        return result
+
+

lib/ansible/plugins/action/debug.py

+# Copyright 2012, Dag Wieers <dag@wieers.com>
+#
+# This file is part of Ansible
+#
+# Ansible 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.
+#
+# Ansible 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 Ansible.  If not, see <http://www.gnu.org/licenses/>.
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+from ansible.plugins.action import ActionBase
+from ansible.utils.boolean import boolean
+from ansible.template import Templar
+
+class ActionModule(ActionBase):
+    ''' Print statements during execution '''
+
+    TRANSFERS_FILES = False
+
+    def run(self, tmp=None, task_vars=dict()):
+
+        if 'msg' in self._task.args:
+            if 'fail' in self._task.args and boolean(self._task.args['fail']):
+                result = dict(failed=True, msg=self._task.args['msg'])
+            else:
+                result = dict(msg=self._task.args['msg'])
+        # FIXME: move the LOOKUP_REGEX somewhere else
+        elif 'var' in self._task.args: # and not utils.LOOKUP_REGEX.search(self._task.args['var']):
+            templar = Templar(loader=self._loader, shared_loader_obj=self._shared_loader_obj, variables=task_vars)
+            results = templar.template(self._task.args['var'], convert_bare=True)
+            result = dict()
+            result[self._task.args['var']] = results
+        else:
+            result = dict(msg='here we are')
+
+        # force flag to make debug output module always verbose
+        result['verbose_always'] = True
+
+        return result

lib/ansible/plugins/action/fetch.py

+# (c) 2012-2014, Michael DeHaan <michael.dehaan@gmail.com>
+#
+# This file is part of Ansible
+#
+# Ansible 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.
+#
+# Ansible 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 Ansible.  If not, see <http://www.gnu.org/licenses/>.
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+import os
+import pwd
+import random
+import traceback
+import tempfile
+import base64
+
+from ansible import constants as C
+from ansible.errors import *
+from ansible.plugins.action import ActionBase
+from ansible.utils.boolean import boolean
+from ansible.utils.hashing import checksum, checksum_s, md5, secure_hash
+
+class ActionModule(ActionBase):
+
+    def run(self, tmp=None, task_vars=dict()):
+        ''' handler for fetch operations '''
+
+        # FIXME: is this even required anymore?
+        #if self.runner.noop_on_check(inject):
+        #    return ReturnData(conn=conn, comm_ok=True, result=dict(skipped=True, msg='check mode not (yet) supported for this module'))
+
+        source            = self._task.args.get('src', None)
+        dest              = self._task.args.get('dest', None)
+        flat              = boolean(self._task.args.get('flat'))
+        fail_on_missing   = boolean(self._task.args.get('fail_on_missing'))
+        validate_checksum = boolean(self._task.args.get('validate_checksum', self._task.args.get('validate_md5')))
+
+        if 'validate_md5' in self._task.args and 'validate_checksum' in self._task.args:
+            return dict(failed=True, msg="validate_checksum and validate_md5 cannot both be specified")
+
+        if source is None or dest is None:
+            return dict(failed=True, msg="src and dest are required")
+
+        source = self._shell.join_path(source)
+        source = self._remote_expand_user(source, tmp)
+
+        # calculate checksum for the remote file
+        remote_checksum = self._remote_checksum(tmp, source)
+
+        # use slurp if sudo and permissions are lacking
+        remote_data = None
+        if remote_checksum in ('1', '2') or self._connection_info.become:
+            slurpres = self._execute_module(module_name='slurp', module_args=dict(src=source), tmp=tmp)
+            if slurpres.get('rc') == 0:
+                if slurpres['encoding'] == 'base64':
+                    remote_data = base64.b64decode(slurpres['content'])
+                if remote_data is not None:
+                    remote_checksum = checksum_s(remote_data)
+                # the source path may have been expanded on the
+                # target system, so we compare it here and use the
+                # expanded version if it's different
+                remote_source = slurpres.get('source')
+                if remote_source and remote_source != source:
+                    source = remote_source
+            else:
+                # FIXME: should raise an error here? the old code did nothing
+                pass
+
+        # calculate the destination name
+        if os.path.sep not in self._shell.join_path('a', ''):
+            source_local = source.replace('\\', '/')
+        else:
+            source_local = source
+
+        dest = os.path.expanduser(dest)
+        if flat:
+            if dest.endswith(os.sep):
+                # if the path ends with "/", we'll use the source filename as the
+                # destination filename
+                base = os.path.basename(source_local)
+                dest = os.path.join(dest, base)
+            if not dest.startswith("/"):
+                # if dest does not start with "/", we'll assume a relative path
+                dest = self._loader.path_dwim(dest)
+        else:
+            # files are saved in dest dir, with a subdir for each host, then the filename
+            if 'inventory_hostname' in task_vars:
+                target_name = task_vars['inventory_hostname']
+            else:
+                target_name = self._connection_info.remote_addr
+            dest = "%s/%s/%s" % (self._loader.path_dwim(dest), target_name, source_local)
+
+        dest = dest.replace("//","/")
+
+        if remote_checksum in ('0', '1', '2', '3', '4'):
+            # these don't fail because you may want to transfer a log file that possibly MAY exist
+            # but keep going to fetch other log files
+            if remote_checksum == '0':
+                result = dict(msg="unable to calculate the checksum of the remote file", file=source, changed=False)
+            elif remote_checksum == '1':
+                if fail_on_missing:
+                    result = dict(failed=True, msg="the remote file does not exist", file=source)
+                else:
+                    result = dict(msg="the remote file does not exist, not transferring, ignored", file=source, changed=False)
+            elif remote_checksum == '2':
+                result = dict(msg="no read permission on remote file, not transferring, ignored", file=source, changed=False)
+            elif remote_checksum == '3':
+                result = dict(msg="remote file is a directory, fetch cannot work on directories", file=source, changed=False)
+            elif remote_checksum == '4':
+                result = dict(msg="python isn't present on the system.  Unable to compute checksum", file=source, changed=False)
+            return result
+
+        # calculate checksum for the local file
+        local_checksum = checksum(dest)
+
+        if remote_checksum != local_checksum:
+            # create the containing directories, if needed
+            if not os.path.isdir(os.path.dirname(dest)):
+                os.makedirs(os.path.dirname(dest))
+
+            # fetch the file and check for changes
+            if remote_data is None:
+                self._connection.fetch_file(source, dest)
+            else:
+                f = open(dest, 'w')
+                f.write(remote_data)
+                f.close()
+            new_checksum = secure_hash(dest)
+            # For backwards compatibility.  We'll return None on FIPS enabled
+            # systems
+            try:
+                new_md5 = md5(dest)
+            except ValueError:
+                new_md5 = None
+
+            if validate_checksum and new_checksum != remote_checksum:
+                return dict(failed=True, md5sum=new_md5, msg="checksum mismatch", file=source, dest=dest, remote_md5sum=None, checksum=new_checksum, remote_checksum=remote_checksum)
+            return dict(changed=True, md5sum=new_md5, dest=dest, remote_md5sum=None, checksum=new_checksum, remote_checksum=remote_checksum)
+        else:
+            # For backwards compatibility.  We'll return None on FIPS enabled
+            # systems
+            try:
+                local_md5 = md5(dest)
+            except ValueError:
+                local_md5 = None
+
+            return dict(changed=False, md5sum=local_md5, file=source, dest=dest, checksum=local_checksum)
+

lib/ansible/plugins/action/group_by.py

+# Copyright 2012, Jeroen Hoekx <jeroen@hoekx.be>
+#
+# This file is part of Ansible
+#
+# Ansible 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.
+#
+# Ansible 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 Ansible.  If not, see <http://www.gnu.org/licenses/>.
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+from ansible.errors import *
+from ansible.plugins.action import ActionBase
+
+class ActionModule(ActionBase):
+    ''' Create inventory groups based on variables '''
+
+    ### We need to be able to modify the inventory
+    BYPASS_HOST_LOOP = True
+    TRANSFERS_FILES = False
+
+    def run(self, tmp=None, task_vars=dict()):
+
+        if not 'key' in self._task.args:
+            return dict(failed=True, msg="the 'key' param is required when using group_by")
+
+        group_name = self._task.args.get('key')
+        group_name = group_name.replace(' ','-')
+
+        return dict(changed=True, add_group=group_name)
+

lib/ansible/plugins/action/include_vars.py

+# (c) 2013-2014, Benno Joy <benno@ansible.com>
+#
+# This file is part of Ansible
+#
+# Ansible 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.
+#
+# Ansible 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 Ansible.  If not, see <http://www.gnu.org/licenses/>.
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+import os
+
+from types import NoneType
+
+from ansible.errors import AnsibleError
+from ansible.parsing import DataLoader
+from ansible.plugins.action import ActionBase
+
+class ActionModule(ActionBase):
+
+    TRANSFERS_FILES = False
+
+    def run(self, tmp=None, task_vars=dict()):
+
+        source = self._task.args.get('_raw_params')
+
+        if self._task._role:
+            source = self._loader.path_dwim_relative(self._task._role._role_path, 'vars', source)
+        else:
+            source = self._loader.path_dwim(source)
+
+        if os.path.exists(source):
+            data = self._loader.load_from_file(source)
+            if data is None:
+                data = {}
+            if not isinstance(data, dict):
+                raise AnsibleError("%s must be stored as a dictionary/hash" % source)
+            return dict(ansible_facts=data)
+        else:
+            return dict(failed=True, msg="Source file not found.", file=source)
+

lib/ansible/plugins/action/patch.py

+# (c) 2015, Brian Coca  <briancoca+dev@gmail.com>
+#
+# This file is part of Ansible
+#
+# Ansible 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.
+#
+# Ansible 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
+
+# Make coding more python3-ish
+from __future__ import (absolute_import, division, print_function)
+__metaclass__ = type
+
+import os
+
+from ansible.plugins.action import ActionBase
+from ansible.utils.boolean import boolean
+
+class ActionModule(ActionBase):
+
+    def run(self, tmp=None, task_vars=dict()):
+
+        src        = self._task.args.get('src', None)
+        dest       = self._task.args.get('dest', None)
+        remote_src = boolean(self._task.args.get('remote_src', 'no'))
+
+        if src is None:
+            return dict(failed=True, msg="src is required")
+        elif remote_src:
+            # everything is remote, so we just execute the module
+            # without changing any of the module arguments
+            return self._execute_module()
+
+        if self._task._role is not None:
+            src = self._loader.path_dwim_relative(self._task._role._role_path, 'files', src)
+        else:
+            src = self._loader.path_dwim(src)
+
+        # create the remote tmp dir if needed, and put the source file there
+        if tmp is None or "-tmp-" not in tmp:
+            tmp = self._make_tmp_path()
+
+        tmp_src = self._shell.join_path(tmp, os.path.basename(src))
+        self._connection.put_file(src, tmp_src)
+
+        if self._connection_info.become and self._connection_info.become_user != 'root':
+            # FIXME: noop stuff here
+            #if not self.runner.noop_on_check(inject):
+            #    self._remote_chmod('a+r', tmp_src, tmp)
+            self._remote_chmod('a+r', tmp_src, tmp)
+
+        new_module_args = self._task.args.copy()
+        new_module_args.update(
+            dict(
+                src=tmp_src,
+            )
+        )
+
+        return self._execute_module('patch', module_args=new_module_args)