def _execute_template(self, conn, host, tmp): ''' handler for template operations ''' # load up options options = utils.parse_kv(self.module_args) source = options.get('src', None) dest = options.get('dest', None) metadata = options.get('metadata', None) if source is None or dest is None: return (host, True, dict(failed=True, msg="src and dest are required"), '') # apply templating to source argument so vars can be used in the path inject = self.setup_cache.get(conn.host,{}) source = utils.template(source, inject, self.setup_cache) (host, ok, data, err) = (None, None, None, None) if self.is_playbook: # not running from a playbook so we have to fetch the remote # setup file contents before proceeding... if metadata is None: if self.remote_user == 'root': metadata = '/etc/ansible/setup' else: # path is expanded on remote side metadata = "~/.ansible/setup" # install the template module slurp_module = self._transfer_module(conn, tmp, 'slurp') # run the slurp module to get the metadata file args = "src=%s" % metadata (result1, err, executed) = self._execute_module(conn, tmp, slurp_module, args) result1 = utils.json_loads(result1) if not 'content' in result1 or result1.get('encoding','base64') != 'base64': result1['failed'] = True return self._return_from_module(conn, host, result1, err, executed) content = base64.b64decode(result1['content']) inject = utils.json_loads(content) # install the template module try: resultant = utils.template(source_data, inject, self.setup_cache) copy_module = self._transfer_module(conn, tmp, 'copy') # template the source data locally source_data = file(utils.path_dwim(self.basedir, source)).read() resultant = '' (host, ok, data, err) = self._return_from_module(conn, host, result1, err, executed) if ok: return self._chain_file_module(conn, tmp, data, err, options, executed) else: return (host, ok, data, err) except Exception, e: return (host, False, dict(failed=True, msg=str(e)), '')
def _execute_template(self, conn, host, tmp): ''' handler for template operations ''' # load up options options = utils.parse_kv(self.module_args) source = options.get('src', None) dest = options.get('dest', None) metadata = options.get('metadata', None) if source is None or dest is None: return (host, True, dict(failed=True, msg="src and dest are required"), '') # apply templating to source argument so vars can be used in the path inject = self.setup_cache.get(conn.host,{}) source = utils.template(source, inject, self.setup_cache) (host, ok, data, err) = (None, None, None, None) if not self.is_playbook: # not running from a playbook so we have to fetch the remote # setup file contents before proceeding... if metadata is None: if self.remote_user == 'root': metadata = '/etc/ansible/setup' else: # path is expanded on remote side metadata = "~/.ansible/setup" # install the template module slurp_module = self._transfer_module(conn, tmp, 'slurp') # run the slurp module to get the metadata file args = "src=%s" % metadata (result1, err, executed) = self._execute_module(conn, tmp, slurp_module, args) result1 = utils.json_loads(result1) if not 'content' in result1 or result1.get('encoding','base64') != 'base64': result1['failed'] = True return self._return_from_module(conn, host, result1, err, executed) content = base64.b64decode(result1['content']) inject = utils.json_loads(content) # install the template module copy_module = self._transfer_module(conn, tmp, 'copy') # template the source data locally source_data = file(utils.path_dwim(self.basedir, source)).read() resultant = '' try: resultant = utils.template(source_data, inject, self.setup_cache) except Exception, e: return (host, False, dict(failed=True, msg=str(e)), '')
def _add_variables_from_script(self, conn, inject): ''' support per system variabes from external variable scripts, see web docs ''' host = conn.host cmd = [Runner._external_variable_script, '--host', host] if self.extra_vars: cmd.extend(['--extra-vars', self.extra_vars]) cmd = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=False ) out, err = cmd.communicate() inject2 = {} try: inject2 = utils.json_loads(out) except: raise errors.AnsibleError("%s returned invalid result when called with hostname %s" % ( Runner._external_variable_script, host )) # store injected variables in the templates inject.update(inject2)
def test_one(self): pb = os.path.join(self.test_dir, 'playbook1.yml') expected = os.path.join(self.test_dir, 'playbook1.events') expected = utils.json_loads(file(expected).read()) actual = self._run(pb) # if different, this will output to screen print utils.bigjson(actual) assert cmp(expected, actual) == 0, "expected events match actual events" # make sure the template module took options from the vars section data = file('/tmp/ansible_test_data_template.out').read() assert data.find("ears") != -1, "template success"
def parse_hosts_from_script(cls, host_list): """ evaluate a script that returns list of hosts by groups """ results = [] groups = dict(ungrouped=[]) host_list = os.path.abspath(host_list) cls._external_variable_script = host_list cmd = subprocess.Popen([host_list], stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=False) out, err = cmd.communicate() try: groups = utils.json_loads(out) except: raise errors.AnsibleError("invalid JSON response from script: %s" % host_list) for (groupname, hostlist) in groups.iteritems(): for host in hostlist: if host not in results: results.append(host) return (results, groups)
def _get_variables_from_script(self, host): ''' support per system variabes from external variable scripts, see web docs ''' cmd = [self.inventory_file, '--host', host] cmd = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=False ) out, err = cmd.communicate() variables = {} try: variables = utils.json_loads(out) except: raise errors.AnsibleError("%s returned invalid result when called with hostname %s" % ( self.inventory_file, host )) return variables
def parse_hosts_from_script(cls, host_list, extra_vars): ''' evaluate a script that returns list of hosts by groups ''' results = [] groups = dict(ungrouped=[]) host_list = os.path.abspath(host_list) cls._external_variable_script = host_list cmd = [host_list, '--list'] if extra_vars: cmd.extend(['--extra-vars', extra_vars]) cmd = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=False) out, err = cmd.communicate() rc = cmd.returncode if rc: raise errors.AnsibleError("%s: %s" % (host_list, err)) try: groups = utils.json_loads(out) except: raise errors.AnsibleError("invalid JSON response from script: %s" % host_list) for (groupname, hostlist) in groups.iteritems(): for host in hostlist: if host not in results: results.append(host) return (results, groups)
def _parse_from_script(self): ''' evaluate a script that returns list of hosts by groups ''' results = [] groups = dict(ungrouped=[]) cmd = [self.inventory_file, '--list'] cmd = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=False) out, err = cmd.communicate() rc = cmd.returncode if rc: raise errors.AnsibleError("%s: %s" % self.inventory_file, err) try: groups = utils.json_loads(out) except: raise errors.AnsibleError("invalid JSON response from script: %s" % self.inventory_file) for (groupname, hostlist) in groups.iteritems(): for host in hostlist: if host not in results: results.append(host) return (results, groups)
def _execute_template(self, conn, tmp): ''' handler for template operations ''' # load up options options = utils.parse_kv(self.module_args) source = options.get('src', None) dest = options.get('dest', None) metadata = options.get('metadata', None) if (source is None and 'first_available_file' not in self.module_vars) or dest is None: result = dict(failed=True, msg="src and dest are required") return ReturnData(host=conn.host, comm_ok=False, result=result) # apply templating to source argument so vars can be used in the path inject = self.setup_cache.get(conn.host, {}) # if we have first_available_file in our vars # look up the files and use the first one we find as src if 'first_available_file' in self.module_vars: found = False for fn in self.module_vars.get('first_available_file'): fn = utils.template(fn, inject, self.setup_cache) if os.path.exists(fn): source = fn found = True break if not found: result = dict( failed=True, msg="could not find src in first_available_file list") return ReturnData(host=conn.host, comm_ok=False, result=result) if self.module_vars is not None: inject.update(self.module_vars) source = utils.template(source, inject, self.setup_cache) #(host, ok, data, err) = (None, None, None, None) if not self.is_playbook: # not running from a playbook so we have to fetch the remote # setup file contents before proceeding... if metadata is None: if self.remote_user == 'root': metadata = '/etc/ansible/setup' else: # path is expanded on remote side metadata = "~/.ansible/setup" # install the template module slurp_module = self._transfer_module(conn, tmp, 'slurp') # run the slurp module to get the metadata file args = "src=%s" % metadata result1 = self._execute_module(conn, tmp, slurp_module, args) if not 'content' in result1.result or result1.result.get( 'encoding', 'base64') != 'base64': result1.result['failed'] = True return result1 content = base64.b64decode(result1.result['content']) inject = utils.json_loads(content) # install the template module copy_module = self._transfer_module(conn, tmp, 'copy') # template the source data locally try: resultant = utils.template_from_file(utils.path_dwim( self.basedir, source), inject, self.setup_cache, no_engine=False) except Exception, e: result = dict(failed=True, msg=str(e)) return ReturnData(host=conn.host, comm_ok=False, result=result)
def _execute_template(self, conn, host, tmp): """ handler for template operations """ # load up options options = utils.parse_kv(self.module_args) source = options.get("src", None) dest = options.get("dest", None) metadata = options.get("metadata", None) if (source is None and "first_available_file" not in self.module_vars) or dest is None: return (host, True, dict(failed=True, msg="src and dest are required"), "") # apply templating to source argument so vars can be used in the path inject = self.setup_cache.get(conn.host, {}) inject.update(self.module_vars) # if we have first_available_file in our vars # look up the files and use the first one we find as src if "first_available_file" in self.module_vars: found = False for fn in self.module_vars.get("first_available_file"): fn = utils.template(fn, inject, self.setup_cache) if os.path.exists(fn): source = fn found = True break if not found: return (host, True, dict(failed=True, msg="could not find src in first_available_file list"), "") source = utils.template(source, inject, self.setup_cache) (host, ok, data, err) = (None, None, None, None) if not self.is_playbook: # not running from a playbook so we have to fetch the remote # setup file contents before proceeding... if metadata is None: if self.remote_user == "root": metadata = "/etc/ansible/setup" else: # path is expanded on remote side metadata = "~/.ansible/setup" # install the template module slurp_module = self._transfer_module(conn, tmp, "slurp") # run the slurp module to get the metadata file args = "src=%s" % metadata (result1, err, executed) = self._execute_module(conn, tmp, slurp_module, args) result1 = utils.json_loads(result1) if not "content" in result1 or result1.get("encoding", "base64") != "base64": result1["failed"] = True return self._return_from_module(conn, host, result1, err, executed) content = base64.b64decode(result1["content"]) inject = utils.json_loads(content) # install the template module copy_module = self._transfer_module(conn, tmp, "copy") # template the source data locally try: resultant = utils.template_from_file( utils.path_dwim(self.basedir, source), inject, self.setup_cache, no_engine=False ) except Exception, e: return (host, False, dict(failed=True, msg=str(e)), "")
def _execute_template(self, conn, tmp): ''' handler for template operations ''' # load up options options = utils.parse_kv(self.module_args) source = options.get('src', None) dest = options.get('dest', None) metadata = options.get('metadata', None) if (source is None and 'first_available_file' not in self.module_vars) or dest is None: result = dict(failed=True, msg="src and dest are required") return ReturnData(host=conn.host, comm_ok=False, result=result) # apply templating to source argument so vars can be used in the path inject = self.setup_cache.get(conn.host,{}) # if we have first_available_file in our vars # look up the files and use the first one we find as src if 'first_available_file' in self.module_vars: found = False for fn in self.module_vars.get('first_available_file'): fn = utils.template(fn, inject, self.setup_cache) if os.path.exists(fn): source = fn found = True break if not found: result = dict(failed=True, msg="could not find src in first_available_file list") return ReturnData(host=conn.host, comm_ok=False, result=result) if self.module_vars is not None: inject.update(self.module_vars) source = utils.template(source, inject, self.setup_cache) #(host, ok, data, err) = (None, None, None, None) if not self.is_playbook: # not running from a playbook so we have to fetch the remote # setup file contents before proceeding... if metadata is None: if self.remote_user == 'root': metadata = '/etc/ansible/setup' else: # path is expanded on remote side metadata = "~/.ansible/tmp/setup" # install the template module slurp_module = self._transfer_module(conn, tmp, 'slurp') # run the slurp module to get the metadata file args = "src=%s" % metadata result1 = self._execute_module(conn, tmp, slurp_module, args) if not 'content' in result1.result or result1.result.get('encoding','base64') != 'base64': result1.result['failed'] = True return result1 content = base64.b64decode(result1.result['content']) inject = utils.json_loads(content) # install the template module copy_module = self._transfer_module(conn, tmp, 'copy') # template the source data locally try: resultant = utils.template_from_file(self.basedir, source, inject, self.setup_cache) except Exception, e: result = dict(failed=True, msg=str(e)) return ReturnData(host=conn.host, comm_ok=False, result=result)
def main(args, battleschool_dir=None): if not battleschool_dir: battleschool_dir = "%s/.battleschool" % os.environ['HOME'] # TODO: make battle OO or more modular #----------------------------------------------------------- # make ansible defaults, battleschool defaults AC.DEFAULT_HOST_LIST = C.DEFAULT_HOST_LIST AC.DEFAULT_SUDO_FLAGS = C.DEFAULT_SUDO_FLAGS #----------------------------------------------------------- # create parser for CLI options usage = "%prog" parser = utils.base_parser(constants=AC, usage=usage, connect_opts=True, runas_opts=False, subset_opts=True, check_opts=True, diff_opts=True, output_opts=True) parser.version = "%s %s" % ("battleschool", __version__) parser.add_option('-e', '--extra-vars', dest="extra_vars", default=None, help="set additional key=value variables from the CLI") # parser.add_option('--tags', dest='tags', default='all', # help="only run plays and tasks tagged with these values") parser.add_option( '--syntax-check', dest='syntax', action='store_true', help= "do a playbook syntax check on the playbook, do not execute the playbook" ) parser.add_option('--list-tasks', dest='listtasks', action='store_true', help="do list all tasks that would be executed") parser.add_option( '--step', dest='step', action='store_true', help="one-step-at-a-time: confirm each task before running") parser.add_option("-s", "--sudo", default=AC.DEFAULT_SUDO, action="store_true", dest='sudo', help="run operations with sudo (nopasswd)") parser.add_option('--config-dir', dest='config_dir', default=None, help="config directory for battleschool (default=%s)" % battleschool_dir) parser.add_option('--config-file', dest='config_file', default=None, help="config file for battleschool (default=%s/%s)" % (battleschool_dir, "config.yml")) parser.add_option('-u', '--update-sources', dest='update_sources', default=False, action='store_true', help="update playbooks from sources(git, url, etc...)") parser.add_option( '--acquire-only', dest='acquire_only', default=False, action='store_true', help="configure mac_pkg module to only aquire package (ie download only" ) options, args = parser.parse_args(args) # options.connection = 'local' playbooks_to_run = [] #[C.DEFAULT_PLAYBOOK] #----------------------------------------------------------- # setup inventory inventory = ansible.inventory.Inventory(options.inventory) inventory.subset(options.subset) if len(inventory.list_hosts()) == 0: raise errors.AnsibleError("provided hosts list is empty") #----------------------------------------------------------- # setup default options sshpass = None sudopass = None options.remote_user = AC.DEFAULT_REMOTE_USER if not options.listhosts and not options.syntax and not options.listtasks: options.ask_pass = AC.DEFAULT_ASK_PASS options.ask_sudo_pass = options.ask_sudo_pass or AC.DEFAULT_ASK_SUDO_PASS passwds = utils.ask_passwords(ask_pass=options.ask_pass, ask_sudo_pass=options.ask_sudo_pass) sshpass = passwds[0] sudopass = passwds[1] # if options.sudo_user or options.ask_sudo_pass: # options.sudo = True options.sudo_user = AC.DEFAULT_SUDO_USER if options.extra_vars and options.extra_vars[0] in '[{': extra_vars = utils.json_loads(options.extra_vars) else: extra_vars = utils.parse_kv(options.extra_vars) only_tags = None # options.tags.split(",") #----------------------------------------------------------- # setup config_dir and battleschool_dir if options.config_dir: battleschool_dir = options.config_dir else: options.config_dir = battleschool_dir #----------------------------------------------------------- # setup module_path if options.module_path is None: options.module_path = AC.DEFAULT_MODULE_PATH if options.module_path is None: options.module_path = C.DEFAULT_MODULE_PATH if C.DEFAULT_MODULE_PATH not in options.module_path: options.module_path = "%s:%s" % (C.DEFAULT_MODULE_PATH, options.module_path) #----------------------------------------------------------- # parse config data config_path = load_config_path(options, inventory, sshpass, sudopass) if os.path.exists(config_path) and os.path.isfile(config_path): config_data = utils.parse_yaml_from_file(config_path) else: config_data = {} #----------------------------------------------------------- # set config_dir if "cache_dir" in config_data: options.cache_dir = os.path.expanduser(config_data["cache_dir"]) elif _platform == "darwin": # OS X options.cache_dir = os.path.expanduser("~/Library/Caches/battleschool") else: options.cache_dir = "%s/cache" % battleschool_dir os.environ["BATTLESCHOOL_CACHE_DIR"] = options.cache_dir #----------------------------------------------------------- # setup extra_vars for later use if extra_vars is None: extra_vars = dict() extra_vars['battleschool_config_dir'] = battleschool_dir extra_vars['battleschool_cache_dir'] = options.cache_dir extra_vars['mac_pkg_acquire_only'] = options.acquire_only #----------------------------------------------------------- # set mac_version for extra_vars if _platform == "darwin": mac_version = platform.mac_ver()[0].split(".") extra_vars['mac_version'] = mac_version extra_vars['mac_major_minor_version'] = "%s.%s" % (mac_version[0], mac_version[1]) #----------------------------------------------------------- # serialize extra_vars since there is now way to pass data # to a module without modifying every playbook tempdir = tempfile.gettempdir() extra_vars_path = os.path.join(tempdir, "battleschool_extra_vars.json") with open(extra_vars_path, 'w') as f: f.write(json.dumps(extra_vars)) #----------------------------------------------------------- # setup and run source handlers handlers = getSourceHandlers() if 'sources' in config_data and config_data['sources']: sources = config_data['sources'] display(banner("Updating sources")) for handler in handlers: source = handler(options, sources) playbooks = source.run(inventory, sshpass, sudopass) for playbook in playbooks: playbooks_to_run.append(playbook) else: display(banner("No sources to update")) #----------------------------------------------------------- # validate playbooks for playbook in playbooks_to_run: if not os.path.exists(playbook): raise errors.AnsibleError("the playbook: %s could not be found" % playbook) if not os.path.isfile(playbook): raise errors.AnsibleError( "the playbook: %s does not appear to be a file" % playbook) #----------------------------------------------------------- # run all playbooks specified from config for playbook in playbooks_to_run: stats = callbacks.AggregateStats() # let inventory know which playbooks are using so it can know the basedirs inventory.set_playbook_basedir(os.path.dirname(playbook)) runner_cb = BattleschoolRunnerCallbacks() playbook_cb = BattleschoolCallbacks() #TODO: option to use default callbacks # runner_cb = callbacks.PlaybookRunnerCallbacks(stats, verbose=utils.VERBOSITY) # playbook_cb = callbacks.PlaybookCallbacks(verbose=utils.VERBOSITY) if options.step: playbook_cb.step = options.step pb = ansible.playbook.PlayBook( playbook=playbook, module_path=options.module_path, inventory=inventory, forks=options.forks, remote_user=options.remote_user, remote_pass=sshpass, callbacks=playbook_cb, runner_callbacks=runner_cb, stats=stats, timeout=options.timeout, transport=options.connection, sudo=options.sudo, sudo_user=options.sudo_user, sudo_pass=sudopass, extra_vars=extra_vars, private_key_file=options.private_key_file, only_tags=only_tags, check=options.check, diff=options.diff) if options.listhosts or options.listtasks: print '' print 'playbook: %s' % playbook print '' playnum = 0 for (play_ds, play_basedir) in zip(pb.playbook, pb.play_basedirs): playnum += 1 play = ansible.playbook.Play(pb, play_ds, play_basedir) label = play.name if options.listhosts: hosts = pb.inventory.list_hosts(play.hosts) print ' play #%d (%s): host count=%d' % (playnum, label, len(hosts)) for host in hosts: print ' %s' % host if options.listtasks: matched_tags, unmatched_tags = play.compare_tags( pb.only_tags) unmatched_tags.discard('all') unknown_tags = set( pb.only_tags) - (matched_tags | unmatched_tags) if unknown_tags: continue print ' play #%d (%s): task count=%d' % ( playnum, label, len(play.tasks())) for task in play.tasks(): if set(task.tags).intersection(pb.only_tags): if getattr(task, 'name', None) is not None: # meta tasks have no names print ' %s' % task.name print '' continue if options.syntax: # if we've not exited by now then we are fine. print 'Playbook Syntax is fine' return 0 failed_hosts = [] try: pb.run() hosts = sorted(pb.stats.processed.keys()) # display(callbacks.banner("PLAY RECAP")) playbook_cb.on_stats(pb.stats) for host in hosts: smry = pb.stats.summarize(host) if smry['unreachable'] > 0 or smry['failures'] > 0: failed_hosts.append(host) if len(failed_hosts) > 0: filename = pb.generate_retry_inventory(failed_hosts) if filename: display(" to retry, use: --limit @%s\n" % filename) for host in hosts: smry = pb.stats.summarize(host) print_stats(host, smry) # print "" if len(failed_hosts) > 0: return 2 except errors.AnsibleError, e: display("ERROR: %s" % e, color='red') return 1