def boilerplate_module(modfile, args, interpreter, check, destfile): """ simulate what ansible does with new style modules """ loader = DataLoader() complex_args = {} if args.startswith("@"): # Argument is a YAML file (JSON is a subset of YAML) complex_args = utils_vars.combine_vars(complex_args, loader.load_from_file(args[1:])) args = '' elif args.startswith("{"): # Argument is a YAML document (not a file) complex_args = utils_vars.combine_vars(complex_args, loader.load(args)) args = '' if args: parsed_args = parse_kv(args) complex_args = utils_vars.combine_vars(complex_args, parsed_args) task_vars = {} if interpreter: if '=' not in interpreter: print("interpreter must by in the form of \ ansible_python_interpreter=/usr/bin/python") sys.exit(1) interpreter_type, interpreter_path = interpreter.split('=') if not interpreter_type.startswith('ansible_'): interpreter_type = 'ansible_%s' % interpreter_type if not interpreter_type.endswith('_interpreter'): interpreter_type = '%s_interpreter' % interpreter_type task_vars[interpreter_type] = interpreter_path if check: complex_args['_ansible_check_mode'] = True modname = os.path.basename(modfile) modname = os.path.splitext(modname)[0] (module_data, module_style, shebang) = module_common.modify_module( modname, modfile, complex_args, task_vars=task_vars ) if module_style == 'new' \ and 'ZIPLOADER_WRAPPER = True' in module_data: module_style = 'ziploader' modfile2_path = os.path.expanduser(destfile) print("* including generated source,\ if any, saving to: %s" % modfile2_path) if module_style not in ('ziploader', 'old'): print("* this may offset any line numbers in tracebacks/debuggers!") modfile2 = open(modfile2_path, 'w') modfile2.write(module_data) modfile2.close() modfile = modfile2_path return (modfile2_path, modname, module_style)
def _play_prereqs(options): # all needs loader loader = DataLoader() basedir = getattr(options, 'basedir', False) if basedir: loader.set_basedir(basedir) vault_ids = options.vault_ids default_vault_ids = C.DEFAULT_VAULT_IDENTITY_LIST vault_ids = default_vault_ids + vault_ids vault_secrets = CLI.setup_vault_secrets(loader, vault_ids=vault_ids, vault_password_files=options.vault_password_files, ask_vault_pass=options.ask_vault_pass, auto_prompt=False) loader.set_vault_secrets(vault_secrets) # create the inventory, and filter it based on the subset specified (if any) inventory = InventoryManager(loader=loader, sources=options.inventory) # create the variable manager, which will be shared throughout # the code, ensuring a consistent view of global variables variable_manager = VariableManager(loader=loader, inventory=inventory) # load vars from cli options variable_manager.extra_vars = load_extra_vars(loader=loader, options=options) variable_manager.options_vars = load_options_vars(options, CLI.version_info(gitinfo=False)) return loader, inventory, variable_manager
class TestDataLoader(unittest.TestCase): def setUp(self): self._loader = DataLoader() def tearDown(self): pass @patch.object(DataLoader, '_get_file_contents') def test_parse_json_from_file(self, mock_def): mock_def.return_value = ("""{"a": 1, "b": 2, "c": 3}""", True) output = self._loader.load_from_file('dummy_json.txt') self.assertEqual(output, dict(a=1,b=2,c=3)) @patch.object(DataLoader, '_get_file_contents') def test_parse_yaml_from_file(self, mock_def): mock_def.return_value = (""" a: 1 b: 2 c: 3 """, True) output = self._loader.load_from_file('dummy_yaml.txt') self.assertEqual(output, dict(a=1,b=2,c=3)) @patch.object(DataLoader, '_get_file_contents') def test_parse_fail_from_file(self, mock_def): mock_def.return_value = (""" TEXT: *** NOT VALID """, True) self.assertRaises(AnsibleParserError, self._loader.load_from_file, 'dummy_yaml_bad.txt')
class TestDataLoaderWithVault(unittest.TestCase): def setUp(self): self._loader = DataLoader() self._loader.set_vault_password('ansible') def tearDown(self): pass @patch.multiple(DataLoader, path_exists=lambda s, x: True, is_file=lambda s, x: True) def test_parse_from_vault_1_1_file(self): vaulted_data = """$ANSIBLE_VAULT;1.1;AES256 33343734386261666161626433386662623039356366656637303939306563376130623138626165 6436333766346533353463636566313332623130383662340a393835656134633665333861393331 37666233346464636263636530626332623035633135363732623332313534306438393366323966 3135306561356164310a343937653834643433343734653137383339323330626437313562306630 3035 """ if PY3: builtins_name = 'builtins' else: builtins_name = '__builtin__' with patch(builtins_name + '.open', mock_open(read_data=vaulted_data.encode('utf-8'))): output = self._loader.load_from_file('dummy_vault.txt') self.assertEqual(output, dict(foo='bar'))
class Runner(object): def __init__(self, playbook, display, hosts=None, options={}, passwords={}, vault_pass=None): self.options = Options() for k, v in options.iteritems(): setattr(self.options, k, v) self.display = display self.display.verbosity = self.options.verbosity # executor has its own verbosity setting playbook_executor.verbosity = self.options.verbosity # gets data from YAML/JSON files self.loader = DataLoader() if vault_pass is not None: self.loader.set_vault_password(vault_pass) elif 'VAULT_PASS' in os.environ: self.loader.set_vault_password(os.environ['VAULT_PASS']) # all the variables from all the various places self.variable_manager = VariableManager() if self.options.python_interpreter is not None: self.variable_manager.extra_vars = { 'ansible_python_interpreter': self.options.python_interpreter } # set inventory, using most of above objects self.inventory = Inventory( loader=self.loader, variable_manager=self.variable_manager, host_list=hosts) if len(self.inventory.list_hosts()) == 0: self.display.error("Provided hosts list is empty.") sys.exit(1) self.inventory.subset(self.options.subset) if len(self.inventory.list_hosts()) == 0: self.display.error("Specified limit does not match any hosts.") sys.exit(1) self.variable_manager.set_inventory(self.inventory) # setup playbook executor, but don't run until run() called self.pbex = playbook_executor.PlaybookExecutor( playbooks=[playbook], inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords=passwords) def run(self): # run playbook and get stats self.pbex.run() stats = self.pbex._tqm._stats return stats
def load_vars(fname): if not os.path.isfile(fname): return {} if HAS_ANSIBLE2: loader = DataLoader() return loader.load_from_file(file_name=fname) else: vars = {} return ansible.utils.load_vars(fname, vars)
class TaskResult: """ This class is responsible for interpretting the resulting data from an executed task, and provides helper methods for determining the result of a given task. """ def __init__(self, host, task, return_data): self._host = host self._task = task if isinstance(return_data, dict): self._result = return_data.copy() else: self._result = DataLoader().load(return_data) def is_changed(self): return self._check_key("changed") def is_skipped(self): # loop results if "results" in self._result and self._task.loop: results = self._result["results"] # Loop tasks are only considered skipped if all items were skipped. # some squashed results (eg, yum) are not dicts and can't be skipped individually if results and all(isinstance(res, dict) and res.get("skipped", False) for res in results): return True # regular tasks and squashed non-dict results return self._result.get("skipped", False) def is_failed(self): if ( "failed_when_result" in self._result or "results" in self._result and True in [True for x in self._result["results"] if "failed_when_result" in x] ): return self._check_key("failed_when_result") else: return self._check_key("failed") or self._result.get("rc", 0) != 0 def is_unreachable(self): return self._check_key("unreachable") def _check_key(self, key): if "results" in self._result and self._task.loop: flag = False for res in self._result.get("results", []): if isinstance(res, dict): flag |= res.get(key, False) return flag else: return self._result.get(key, False)
class Runner(object): def __init__(self, hostnames, playbook, private_key_file, run_data, become_pass=None, verbosity=0, callback=None, subset_pattern=None): self.hostnames = hostnames self.playbook = os.path.join(playbooks_dir, playbook) self.run_data = run_data self.options = Options(subset=subset_pattern, private_key_file=private_key_file, verbosity=verbosity) self.display = Display() self.display.verbosity = verbosity playbook_executor.verbosity = verbosity passwords = {'become_pass': None} # Gets data from YAML/JSON files self.loader = DataLoader() self.loader.set_vault_password(os.environ.get('VAULT_PASS')) self.variable_manager = VariableManager() self.variable_manager.extra_vars = self.run_data self.inventory = Inventory(loader=self.loader, variable_manager=self.variable_manager, host_list=self.hostnames) self.variable_manager.set_inventory(self.inventory) self.pbex = playbook_executor.PlaybookExecutor( playbooks=[self.playbook], inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords=passwords) if callback: self.pbex._tqm._stdout_callback = callback def run(self): self.pbex.run() stats = self.pbex._tqm._stats run_success = True hosts = sorted(stats.processed.keys()) for h in hosts: t = stats.summarize(h) if t['unreachable'] > 0 or t['failures'] > 0: run_success = False return run_success
class TaskResult: ''' This class is responsible for interpretting the resulting data from an executed task, and provides helper methods for determining the result of a given task. ''' def __init__(self, host, task, return_data): self._host = host self._task = task if isinstance(return_data, dict): self._result = return_data.copy() else: self._result = DataLoader().load(return_data) def is_changed(self): return self._check_key('changed') def is_skipped(self): # loop results if 'results' in self._result: results = self._result['results'] # Loop tasks are only considered skipped if all items were skipped. # some squashed results (eg, yum) are not dicts and can't be skipped individually if results and all(isinstance(res, dict) and res.get('skipped', False) for res in results): return True # regular tasks and squashed non-dict results return self._result.get('skipped', False) def is_failed(self): if 'failed_when_result' in self._result or \ 'results' in self._result and True in [True for x in self._result['results'] if 'failed_when_result' in x]: return self._check_key('failed_when_result') else: return self._check_key('failed') or self._result.get('rc', 0) != 0 def is_unreachable(self): return self._check_key('unreachable') def _check_key(self, key): '''get a specific key from the result or it's items''' if isinstance(self._result, dict) and key in self._result: return self._result.get(key, False) else: flag = False for res in self._result.get('results', []): if isinstance(res, dict): flag |= res.get(key, False) return flag
def run(self): results = None super(InventoryCLI, self).run() # Initialize needed objects if getattr(self, '_play_prereqs', False): self.loader, self.inventory, self.vm = self._play_prereqs(self.options) else: # fallback to pre 2.4 way of initialzing from ansible.vars import VariableManager from ansible.inventory import Inventory self._new_api = False self.loader = DataLoader() self.vm = VariableManager() # use vault if needed if self.options.vault_password_file: vault_pass = CLI.read_vault_password_file(self.options.vault_password_file, loader=self.loader) elif self.options.ask_vault_pass: vault_pass = self.ask_vault_passwords() else: vault_pass = None if vault_pass: self.loader.set_vault_password(vault_pass) # actually get inventory and vars self.inventory = Inventory(loader=self.loader, variable_manager=self.vm, host_list=self.options.inventory) self.vm.set_inventory(self.inventory) if self.options.host: hosts = self.inventory.get_hosts(self.options.host) if len(hosts) != 1: raise AnsibleOptionsError("You must pass a single valid host to --hosts parameter") myvars = self._get_host_variables(host=hosts[0]) self._remove_internal(myvars) # FIXME: should we template first? results = self.dump(myvars) elif self.options.graph: results = self.inventory_graph() elif self.options.list: top = self._get_group('all') if self.options.yaml: results = self.yaml_inventory(top) else: results = self.json_inventory(top) results = self.dump(results) if results: # FIXME: pager? display.display(results) exit(0) exit(1)
def __init__(self, host, task, return_data): self._host = host self._task = task if isinstance(return_data, dict): self._result = return_data.copy() else: self._result = DataLoader().load(return_data)
def __init__(self, inventory, options=None): self.options = self.update_options(options) self.inventory = inventory self.loader = DataLoader() self.variable_manager = VariableManager( loader=self.loader, inventory=self.inventory )
class TaskResult: ''' This class is responsible for interpretting the resulting data from an executed task, and provides helper methods for determining the result of a given task. ''' def __init__(self, host, task, return_data): self._host = host self._task = task if isinstance(return_data, dict): self._result = return_data.copy() else: self._result = DataLoader().load(return_data) def is_changed(self): return self._check_key('changed') def is_skipped(self): if 'results' in self._result and self._task.loop: flag = True for res in self._result.get('results', []): if isinstance(res, dict): flag &= res.get('skipped', False) return flag else: return self._result.get('skipped', False) def is_failed(self): if 'failed_when_result' in self._result or \ 'results' in self._result and True in [True for x in self._result['results'] if 'failed_when_result' in x]: return self._check_key('failed_when_result') else: return self._check_key('failed') or self._result.get('rc', 0) != 0 def is_unreachable(self): return self._check_key('unreachable') def _check_key(self, key): if 'results' in self._result and self._task.loop: flag = False for res in self._result.get('results', []): if isinstance(res, dict): flag |= res.get(key, False) return flag else: return self._result.get(key, False)
def main(self, path): data_dir = self.conf['data_dir'] loader = DataLoader() full_path="%s/%s" % (data_dir, path) if os.path.isfile("%s.yaml" % full_path): ds = loader.load_from_file("%s.yaml" % full_path) elif os.path.isfile("%s.yml" % full_path): ds = loader.load_from_file("%s.yml" % full_path) else: ds={} if ds is None: ds = {} return ds
def __init__(self, inventory, options=None): if options: self.options = options self.inventory = inventory self.loader = DataLoader() self.variable_manager = VariableManager( loader=self.loader, inventory=self.inventory )
class TestDataLoader(unittest.TestCase): def setUp(self): self._loader = DataLoader() def tearDown(self): pass @patch.object(DataLoader, '_get_file_contents') def test_parse_json_from_file(self, mock_def): mock_def.return_value = (b"""{"a": 1, "b": 2, "c": 3}""", True) output = self._loader.load_from_file('dummy_json.txt') self.assertEqual(output, dict(a=1,b=2,c=3)) @patch.object(DataLoader, '_get_file_contents') def test_parse_yaml_from_file(self, mock_def): mock_def.return_value = (b""" a: 1 b: 2 c: 3 """, True) output = self._loader.load_from_file('dummy_yaml.txt') self.assertEqual(output, dict(a=1,b=2,c=3)) @patch.object(DataLoader, '_get_file_contents') def test_parse_fail_from_file(self, mock_def): mock_def.return_value = (b""" TEXT: *** NOT VALID """, True) self.assertRaises(AnsibleParserError, self._loader.load_from_file, 'dummy_yaml_bad.txt') @patch('ansible.errors.AnsibleError._get_error_lines_from_file') @patch.object(DataLoader, '_get_file_contents') def test_tab_error(self, mock_def, mock_get_error_lines): mock_def.return_value = (u"""---\nhosts: localhost\nvars:\n foo: bar\n\tblip: baz""", True) mock_get_error_lines.return_value = ('''\tblip: baz''', '''..foo: bar''') with self.assertRaises(AnsibleParserError) as cm: self._loader.load_from_file('dummy_yaml_text.txt') self.assertIn(yaml_strings.YAML_COMMON_LEADING_TAB_ERROR, str(cm.exception)) self.assertIn('foo: bar', str(cm.exception))
def __init__(self, inventory, ask_vault_pass, vault_password_files, vault_ids): if vault_ids or len(vault_password_files) > 1: raise NotImplementedError from ansible.cli import CLI super(Inventory20, self).__init__() loader = DataLoader() if ask_vault_pass: self.vault_pass = CLI.ask_vault_passwords() elif vault_password_files: self.vault_pass = CLI.read_vault_password_file(vault_password_files[0], loader) if self.vault_pass is not None: loader.set_vault_password(self.vault_pass) self.variable_manager = VariableManager() try: self.inventory = ansible.inventory.Inventory(loader=loader, variable_manager=self.variable_manager, host_list=inventory) except ansible.errors.AnsibleError: raise NoVaultSecretFound self.variable_manager.set_inventory(self.inventory)
def run(self, data_dir="data", conf_file="echelon.yml"): from ansible.parsing.dataloader import DataLoader loader = DataLoader() ds = loader.load_from_file(conf_file) conf_data = self.template_loader(ds) hierarchies = {} if not "hierarchy" in conf_data: return hierarchies # Load the backends backends = {} if not "backends" in conf_data: raise AnsibleError("No 'backends' found in echeclon config file") backend_plugins = [] for backend in conf_data["backends"]: for k in backend: try: backend_plugins.append(self.backend_loader(k, backend[k])) except Exception as e: raise AnsibleError("Failed to load backend plugin (%s): %s" % (k, str(e))) for hierarchy in conf_data["hierarchy"]: for k in hierarchy: data = {} for path in hierarchy[k]: for plugin in backend_plugins: full_path = "%s/%s" % (k, path) data_new = self.template_loader(plugin.main(full_path)) if data_new == {}: continue else: data = self.merge_dicts(data_new, data) break hierarchies[k] = data return hierarchies
def __init__(self, host, task, return_data, task_fields=None): self._host = host self._task = task if isinstance(return_data, dict): self._result = return_data.copy() else: self._result = DataLoader().load(return_data) if task_fields is None: self._task_fields = dict() else: self._task_fields = task_fields
def __init__(self, playbook, run_data, private_key_file=None, verbosity=0, host_file=None): self.playbook = playbook self.run_data = run_data self.options = Options() self.options.output_file = playbook + '.result' self.options.private_key_file = private_key_file self.options.verbosity = verbosity self.options.connection = 'ssh' # Need a connection type "smart" or "ssh" #self.options.become = True self.options.become_method = 'sudo' self.options.become_user = '******' # Set global verbosity self.display = Display() self.display.verbosity = self.options.verbosity # Executor appears to have it's own # verbosity object/setting as well playbook_executor.verbosity = self.options.verbosity # Become Pass Needed if not logging in as user root #passwords = {'become_pass': become_pass} # Gets data from YAML/JSON files self.loader = DataLoader() try: self.loader.set_vault_password(os.environ['VAULT_PASS']) except KeyError: pass # All the variables from all the various places self.variable_manager = VariableManager() self.variable_manager.extra_vars = {} # self.run_data # Set inventory, using most of above objects if (host_file): self.inventory = Inventory(loader=self.loader, variable_manager=self.variable_manager, host_list = host_file) else: self.inventory = Inventory(loader=self.loader, variable_manager=self.variable_manager) self.variable_manager.set_inventory(self.inventory) # Setup playbook executor, but don't run until run() called self.pbex = playbook_executor.PlaybookExecutor( playbooks=[playbook], inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords={})
def __init__(self): """ Creates an instance of the Transport. """ self.logger = logging.getLogger('transport') self.Options = namedtuple( 'Options', ['connection', 'module_path', 'forks', 'remote_user', 'private_key_file', 'ssh_common_args', 'ssh_extra_args', 'sftp_extra_args', 'scp_extra_args', 'become', 'become_method', 'become_user', 'verbosity', 'check']) # initialize needed objects self.variable_manager = VariableManager() self.loader = DataLoader() self.passwords = {}
def __init__(self, hosts=C.DEFAULT_HOST_LIST, forks=C.DEFAULT_FORKS, # 5 timeout=C.DEFAULT_TIMEOUT, # SSH timeout = 10s remote_user=C.DEFAULT_REMOTE_USER, # root module_path=None, # dirs of custome modules connection_type="smart", become=None, become_method=None, become_user=None, check=False, passwords=None, extra_vars=None, private_key_file=None, gather_facts='no'): self.pattern = '' self.variable_manager = VariableManager() self.loader = DataLoader() self.gather_facts = gather_facts self.options = self.Options( connection=connection_type, timeout=timeout, module_path=module_path, forks=forks, become=become, become_method=become_method, become_user=become_user, check=check, remote_user=remote_user, extra_vars=extra_vars or [], private_key_file=private_key_file, ) # self.variable_manager.extra_vars = load_extra_vars(self.loader, # options=self.options) self.variable_manager.extra_vars = extra_vars self.variable_manager.options_vars = load_options_vars(self.options) self.passwords = passwords or {} self.inventory = YoInventory(hosts) self.variable_manager.set_inventory(self.inventory) self.tasks = [] self.play_source = None self.play = None self.runner = None self.timestamp = str(time.time()) self.filename = FILENAME%(self.timestamp,'') self.have_script = 0
def setup_inventory(ctx): """sets up the inventory object for use by other functions""" loader = DataLoader() variable_manager = VariableManager() if ctx.obj['vault_password_command']: try: vault_password = subprocess.check_output(ctx.obj['vault_password_command'], shell=True) except subprocess.CalledProcessError: print "Vault password command exited with non-zero code" sys.exit(1) loader.set_vault_password(vault_password.rstrip()) elif os.environ.get('ANSIBLE_VAULT_PASSWORD_FILE'): with open(os.environ.get('ANSIBLE_VAULT_PASSWORD_FILE'), 'r') as vault_password_file: loader.set_vault_password(vault_password_file.read().strip()) try: if(ctx.obj['inventory']): return Inventory(loader=loader, variable_manager=variable_manager, host_list=ctx.obj['inventory']) else: return Inventory(loader=loader, variable_manager=variable_manager) except AnsibleError as e: # If it fails to decrypt and a password command hasn't been provided, prompt for one if not ctx.obj['vault_password_command'] and str(e) == 'Decryption failed': vault_password = getpass.getpass('Enter vault password:'******'inventory']): return Inventory(loader=loader, variable_manager=variable_manager, host_list=ctx.obj['inventory']) else: return Inventory(loader=loader, variable_manager=variable_manager) else: print "Something went wrong:" print repr(e) sys.exit(1)
def __init__(self, hostnames, playbook, private_key_file, run_data, become_pass=None, verbosity=0, callback=None, subset_pattern=None): self.hostnames = hostnames self.playbook = os.path.join(playbooks_dir, playbook) self.run_data = run_data self.options = Options(subset=subset_pattern, private_key_file=private_key_file, verbosity=verbosity) self.display = Display() self.display.verbosity = verbosity playbook_executor.verbosity = verbosity passwords = {'become_pass': None} # Gets data from YAML/JSON files self.loader = DataLoader() self.loader.set_vault_password(os.environ.get('VAULT_PASS')) self.variable_manager = VariableManager() self.variable_manager.extra_vars = self.run_data self.inventory = Inventory(loader=self.loader, variable_manager=self.variable_manager, host_list=self.hostnames) self.variable_manager.set_inventory(self.inventory) self.pbex = playbook_executor.PlaybookExecutor( playbooks=[self.playbook], inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords=passwords) if callback: self.pbex._tqm._stdout_callback = callback
def path_dwim(basedir, given): dl = DataLoader() dl.set_basedir(basedir) return dl.path_dwim(given)
def parse_yaml_from_file(filepath): dl = DataLoader() if hasattr(dl, 'set_vault_password'): dl.set_vault_password(DEFAULT_VAULT_PASSWORD) return dl.load_from_file(filepath)
def ansible_template(basedir, varname, templatevars, **kwargs): dl = DataLoader() dl.set_basedir(basedir) templar = Templar(dl, variables=templatevars) return templar.template(varname, **kwargs)
def __init__(self, resource, *args, **kwargs): self.resource = resource self.loader = DataLoader() self.variable_manager = VariableManager() self.inventory = self._set_inventory(resource) self.results_raw = {}
def setUp(self): self._loader = DataLoader()
def setUp(self): self._loader = DataLoader() self._loader.set_vault_password('ansible')
class Runner(object): def __init__(self, playbook, run_data, private_key_file=None, verbosity=0, host_file=None): self.playbook = playbook self.run_data = run_data self.options = Options() self.options.output_file = playbook + ".result" self.options.private_key_file = private_key_file self.options.verbosity = verbosity self.options.connection = "ssh" # Need a connection type "smart" or "ssh" # self.options.become = True self.options.become_method = "sudo" self.options.become_user = "******" # Set global verbosity self.display = Display() self.display.verbosity = self.options.verbosity # Executor appears to have it's own # verbosity object/setting as well playbook_executor.verbosity = self.options.verbosity # Become Pass Needed if not logging in as user root # passwords = {'become_pass': become_pass} # Gets data from YAML/JSON files self.loader = DataLoader() try: self.loader.set_vault_password(os.environ["VAULT_PASS"]) except AttributeError: pass # Set inventory, using most of above objects if host_file: self.inventory = InventoryManager(loader=self.loader, sources=host_file) else: self.inventory = InventoryManager(loader=self.loader) # All the variables from all the various places self.variable_manager = VariableManager(loader=self.loader, inventory=self.inventory) self.variable_manager.extra_vars = {} # self.run_data # Setup playbook executor, but don't run until run() called self.pbex = playbook_executor.PlaybookExecutor( playbooks=[playbook], inventory=self.inventory, variable_manager=self.variable_manager, loader=self.loader, options=self.options, passwords={}, ) def run(self): os.environ[ "REQUESTS_CA_BUNDLE"] = "/usr/local/share/ca-certificates/local_certs.crt" callback = ResultCallback() self.pbex._tqm._stdout_callback = callback self.pbex.run() stats = self.pbex._tqm._stats # os.remove(self.hosts.name) return stats, callback.results
def run_ansible_playbook(details): # initialize needed objects passwords = {} # Instantiate our ResultCallback for handling results as they come in. Ansible expects this to be one of its main display outlets results_callback = ResultCallback() ansible_connect = ansible_play() if details['incident']: ansible_connect.incident_number = details['incident_number'] loader = DataLoader() # get the Inventory details inventory = ansible_connect.get_inventory() extra_var = {} variable_manager = VariableManager(loader=loader, inventory=inventory) if details['type'] == "service": play_source=service_play_source(details) extra_var = {f'service_name={details["service"]}'} if details['type'] == "usr_acc_creation": play_source=AD_user_accountCreation(details) extra_var = {f'f_name={details["f_name"]} , uname={details["uname"]}, l_name={details["l_name"]}, g_name={details["g_name"]}'} details['description'] = "User Account has been Created" details['description_failure'] = "Issue in Creating User account on Active Directory" if details['type'] == "group_addtion": details['description'] = "Group has been added to the user account" details['description_failure'] = "Issue in adding user account to Group " play_source = group_addtion_touser(details) context.CLIARGS = ImmutableDict(listtags=False, listtasks=False, listhosts=False, forks=100,private_key_file=None, ssh_common_args=None, ssh_extra_args=None, sftp_extra_args=None, scp_extra_args=None, become=False, become_method='sudo', become_user='******', verbosity=0, check=False, diff=False, extra_vars=extra_var, module_path='run_ansible_playbook.py', syntax=False, connection='ssh') variable_manager._extra_vars=load_extra_vars(loader=loader) # create data structure that represents our play, including tasks, this is basically what our YAML loader does internally. # Create play object, playbook objects use .load instead of init or new methods, # this will also automatically create the task objects from the info provided in play_source play = Play().load(play_source, variable_manager=variable_manager, loader=loader) # Run it - instantiate task queue manager, which takes care of forking and setting up all objects to iterate over host list and tasks tqm = None try: tqm = TaskQueueManager( inventory=inventory, variable_manager=variable_manager, loader=loader, passwords=passwords, stdout_callback=results_callback, # Use our custom callback instead of the ``default`` callback plugin, which prints to stdout ) result = tqm.run(play) # most interesting data for a play is actually sent to the callback's methods if result == 0 and details['incident']: update_incident(details,6, results_callback.output) if result == 0 and details['request']: update_ritm(details,3, results_callback.output) if result != 0 and details['incident']: update_incident(details,2, results_callback.output) if result != 0 and details['request']: update_ritm(details,2, results_callback.output) finally: # we always need to cleanup child procs and the structures we use to communicate with them if tqm is not None: tqm.cleanup() # Remove ansible tmpdir shutil.rmtree(C.DEFAULT_LOCAL_TMP, True)
def get_inventory_manager(inv_files): return InventoryManager(loader=DataLoader(), sources=inv_files)
def execute_playbook(self, playbook_info): output = None try: loader = DataLoader() inventory = InventoryManager(loader=loader, sources=['localhost']) variable_manager = VariableManager(loader=loader, inventory=inventory) Options = namedtuple('Options', [ 'listtags', 'listtasks', 'listhosts', 'syntax', 'connection', 'module_path', 'forks', 'remote_user', 'private_key_file', 'ssh_common_args', 'ssh_extra_args', 'sftp_extra_args', 'scp_extra_args', 'become', 'become_method', 'become_user', 'verbosity', 'check', 'diff' ]) options = Options(listtags=False, listtasks=False, listhosts=False, syntax=False, connection='ssh', module_path=None, forks=100, remote_user=None, private_key_file=None, ssh_common_args=None, ssh_extra_args=None, sftp_extra_args=None, scp_extra_args=None, become=None, become_method=None, become_user=None, verbosity=None, check=False, diff=False) variable_manager.extra_vars = playbook_info['extra_vars'] pbex = PlaybookExecutor(playbooks=[playbook_info['uri']], inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=None) ret_val = pbex.run() if ret_val != 0: msg = MsgBundle.getMessage( MsgBundle.PLAYBOOK_RETURN_WITH_ERROR) raise Exception(msg) output = self.get_plugin_output(pbex) if output is None or output.get('status') is None: msg = MsgBundle.getMessage(MsgBundle.PLAYBOOK_OUTPUT_MISSING) raise Exception(msg) if output.get('status').lower() == "failure": msg = MsgBundle.getMessage(MsgBundle.PLAYBOOK_STATUS_FAILED) raise Exception(msg) return output except Exception as exp: msg = MsgBundle.getMessage(MsgBundle.PLAYBOOK_EXECUTE_ERROR, playbook_uri=playbook_info['uri'], execution_id=playbook_info['extra_vars'] ['playbook_input']['job_execution_id'], exc_msg=repr(exp)) if exp.message: msg = msg + "\n" + exp.message JM_LOGGER.error(msg) # after handling exception, write an END # to stop listening to the file if created unique_pb_id = playbook_info['extra_vars']['playbook_input'][ 'unique_pb_id'] exec_id = playbook_info['extra_vars']['playbook_input'][ 'job_execution_id'] line_in_file = "" if output != None: line_in_file = unique_pb_id + 'PLAYBOOK_OUTPUT##'\ + json.dumps(output) + 'PLAYBOOK_OUTPUT##'\ + '\n' with open("/tmp/" + exec_id, "a") as f: f.write(line_in_file + unique_pb_id + 'END' + '\n') sys.exit(msg)
def get_variable_manager(inv_files): return VariableManager(loader=DataLoader(), inventory=get_inventory_manager(inv_files))
def run(self, command, *args): self._check_ansible() if HAS_ANSIBLE_1: import ansible.inventory import ansible.runner command = self.get_command(command, *args) kwargs = {} if self.ansible_inventory is not None: kwargs["host_list"] = self.ansible_inventory out = ansible.runner.Runner(pattern=self.host, module_name="shell", module_args=command, **kwargs).run()["contacted"][self.host] # Ansible return an unicode object but this is bytes ... # A simple test case is: # >>> assert File("/bin/true").content == open("/bin/true").read() stdout_bytes = b"".join((chr(ord(c)) for c in out['stdout'])) stderr_bytes = b"".join((chr(ord(c)) for c in out['stderr'])) result = base.CommandResult( self, out['rc'], stdout_bytes, stderr_bytes, command, stdout=out["stdout"], stderr=out["stderr"], ) logger.info("RUN %s", result) return result if HAS_ANSIBLE_2: from collections import namedtuple from ansible.parsing.dataloader import DataLoader from ansible.vars import VariableManager from ansible.inventory import Inventory from ansible.playbook.play import Play from ansible.executor.task_queue_manager import TaskQueueManager from ansible.plugins.callback import CallbackBase class SilentCallbackModule(CallbackBase): """ A callback module that does not print anything, but keeps tabs on what's happening in an Ansible play. """ def __init__(self): self.unreachable = {} self.contacted = {} def runner_on_ok(self, host, result): self.contacted[host] = {'success': True, 'result': result} def runner_on_failed(self, host, result, ignore_errors=False): self.contacted[host] = {'success': False, 'result': result} def runner_on_unreachable(self, host, result): self.unreachable[host] = result callback = SilentCallbackModule() command = self.get_command(command, *args) Options = namedtuple('Options', [ 'connection', 'module_path', 'forks', 'remote_user', 'private_key_file', 'ssh_common_args', 'ssh_extra_args', 'sftp_extra_args', 'scp_extra_args', 'become', 'become_method', 'become_user', 'verbosity', 'check' ]) # initialize needed objects variable_manager = VariableManager() loader = DataLoader() options = Options(connection='smart', module_path=None, forks=100, remote_user=None, private_key_file=None, ssh_common_args=None, ssh_extra_args=None, sftp_extra_args=None, scp_extra_args=None, become=None, become_method=None, become_user=None, verbosity=None, check=False) passwords = dict() # create inventory and pass to var manager inventory = Inventory(loader, variable_manager, self.ansible_inventory) variable_manager.set_inventory(inventory) # create play with tasks play_source = dict( name="Ansible Play", hosts=self.host, gather_facts='no', tasks=[dict(action=dict(module="shell", args=command))]) play = Play().load(play_source, variable_manager=variable_manager, loader=loader) # actually run it tqm = None try: tqm = TaskQueueManager( inventory=inventory, variable_manager=variable_manager, loader=loader, options=options, passwords=passwords, stdout_callback=callback, ) tqm.run(play) ret = base.CommandResult( self, 0 if callback.contacted[self.host][u'success'] else 1, bytes(callback.contacted[self.host][u'result'] ["stdout_lines"]), b"", command, stdout=callback.contacted[self.host][u'result']["stdout"], stderr=callback.contacted[self.host][u'result']["stdout"], ) return ret finally: if tqm is not None: tqm.cleanup()
def run(self): super(PlaybookCLI, self).run() # Note: slightly wrong, this is written so that implicit localhost # Manage passwords sshpass = None becomepass = None vault_pass = None passwords = {} # initial error check, to make sure all specified playbooks are accessible # before we start running anything through the playbook executor for playbook in self.args: if not os.path.exists(playbook): raise AnsibleError("the playbook: %s could not be found" % playbook) if not (os.path.isfile(playbook) or stat.S_ISFIFO(os.stat(playbook).st_mode)): raise AnsibleError( "the playbook: %s does not appear to be a file" % playbook) # don't deal with privilege escalation or passwords when we don't need to if not self.options.listhosts and not self.options.listtasks and not self.options.listtags and not self.options.syntax: self.normalize_become_options() (sshpass, becomepass) = self.ask_passwords() passwords = {'conn_pass': sshpass, 'become_pass': becomepass} loader = DataLoader() if self.options.vault_password_file: # read vault_pass from a file vault_pass = CLI.read_vault_password_file( self.options.vault_password_file, loader=loader) loader.set_vault_password(vault_pass) elif self.options.ask_vault_pass: vault_pass = self.ask_vault_passwords() loader.set_vault_password(vault_pass) # create the variable manager, which will be shared throughout # the code, ensuring a consistent view of global variables variable_manager = VariableManager() variable_manager.extra_vars = load_extra_vars(loader=loader, options=self.options) variable_manager.options_vars = load_options_vars(self.options) # create the inventory, and filter it based on the subset specified (if any) inventory = Inventory(loader=loader, variable_manager=variable_manager, host_list=self.options.inventory) variable_manager.set_inventory(inventory) # (which is not returned in list_hosts()) is taken into account for # warning if inventory is empty. But it can't be taken into account for # checking if limit doesn't match any hosts. Instead we don't worry about # limit if only implicit localhost was in inventory to start with. # # Fix this when we rewrite inventory by making localhost a real host (and thus show up in list_hosts()) no_hosts = False if len(inventory.list_hosts()) == 0: # Empty inventory display.warning( "provided hosts list is empty, only localhost is available") no_hosts = True inventory.subset(self.options.subset) if len(inventory.list_hosts()) == 0 and no_hosts is False: # Invalid limit raise AnsibleError("Specified --limit does not match any hosts") # flush fact cache if requested if self.options.flush_cache: self._flush_cache(inventory, variable_manager) # create the playbook executor, which manages running the plays via a task queue manager pbex = PlaybookExecutor(playbooks=self.args, inventory=inventory, variable_manager=variable_manager, loader=loader, options=self.options, passwords=passwords) results = pbex.run() if isinstance(results, list): for p in results: display.display('\nplaybook: %s' % p['playbook']) for idx, play in enumerate(p['plays']): if play._included_path is not None: loader.set_basedir(play._included_path) else: pb_dir = os.path.realpath( os.path.dirname(p['playbook'])) loader.set_basedir(pb_dir) msg = "\n play #%d (%s): %s" % (idx + 1, ','.join( play.hosts), play.name) mytags = set(play.tags) msg += '\tTAGS: [%s]' % (','.join(mytags)) if self.options.listhosts: playhosts = set(inventory.get_hosts(play.hosts)) msg += "\n pattern: %s\n hosts (%d):" % ( play.hosts, len(playhosts)) for host in playhosts: msg += "\n %s" % host display.display(msg) all_tags = set() if self.options.listtags or self.options.listtasks: taskmsg = '' if self.options.listtasks: taskmsg = ' tasks:\n' def _process_block(b): taskmsg = '' for task in b.block: if isinstance(task, Block): taskmsg += _process_block(task) else: if task.action == 'meta': continue all_tags.update(task.tags) if self.options.listtasks: cur_tags = list( mytags.union(set(task.tags))) cur_tags.sort() if task.name: taskmsg += " %s" % task.get_name( ) else: taskmsg += " %s" % task.action taskmsg += "\tTAGS: [%s]\n" % ', '.join( cur_tags) return taskmsg all_vars = variable_manager.get_vars(loader=loader, play=play) play_context = PlayContext(play=play, options=self.options) for block in play.compile(): block = block.filter_tagged_tasks( play_context, all_vars) if not block.has_tasks(): continue taskmsg += _process_block(block) if self.options.listtags: cur_tags = list(mytags.union(all_tags)) cur_tags.sort() taskmsg += " TASK TAGS: [%s]\n" % ', '.join( cur_tags) display.display(taskmsg) return 0 else: return results
def parse_yaml_from_file(filepath): dl = DataLoader() return dl.load_from_file(filepath)
def __init__( self, connection='local', # 连接方式 local 本地方式,smart ssh方式 remote_user=None, # ssh 用户 remote_password=None, # ssh 用户的密码,应该是一个字典, key 必须是 conn_pass private_key_file=None, # 指定自定义的私钥地址 sudo=None, sudo_user=None, ask_sudo_pass=None, module_path=None, # 模块路径,可以指定一个自定义模块的路径 become=None, # 是否提权 become_method=None, # 提权方式 默认 sudo 可以是 su become_user=None, # 提权后,要成为的用户,并非登录用户 check=False, diff=False, host_key_checking=False, listhosts=None, listtasks=None, listtags=None, verbosity=3, syntax=None, start_at_task=None, inventory=None, hostsresource=None, ): # 函数文档注释 """ 初始化函数,定义的默认的选项值, 在初始化的时候可以传参,以便覆盖默认选项的值 """ context.CLIARGS = ImmutableDict( connection=connection, remote_user=remote_user, private_key_file=private_key_file, sudo=sudo, sudo_user=sudo_user, ask_sudo_pass=ask_sudo_pass, module_path=module_path, become=become, become_method=become_method, become_user=become_user, verbosity=verbosity, listhosts=listhosts, listtasks=listtasks, listtags=listtags, syntax=syntax, start_at_task=start_at_task, ) # 三元表达式,假如没有传递 inventory, 就使用 "localhost," # sources这个我们知道这里是设置hosts文件的地方,它可以是一个列表里面包含多个文件路径且文件真实存在,在单纯的执行ad-hoc的时候这里的 # 文件里面必须具有有效的hosts配置,但是当通过动态生成的资产信息的时候这个文件必须存在但是它里面可以是空的,如果这里配置成None那么 # 它不影响资产信息动态生成但是会有一个警告,所以还是要配置一个真实文件。 self.inventory = inventory if inventory else "localhost," # 实例化数据解析器 self.loader = DataLoader() # 设置密码 self.passwords = dict(conn_pass=remote_password) # 实例化回调插件对象 self.results_callback = ResultCallback() # 实例化 资产配置对象 # self.inv_obj = InventoryManager(loader=self.loader, sources="localhost,") # 动态配置 Inventory MyInventory(hostsresource) myinven = MyInventory(hostsresource=hostsresource) self.inv_obj = myinven.INVENTORY # inv_host = self.inv_obj.get_host('39.104.83.140') # print(inv_host.get_vars()) # 变量管理器 self.variable_manager = VariableManager(self.loader, self.inv_obj)
def __init__(self): self.loader = DataLoader() self._options = cli.options if cli else None
def run_command(self, name, ctx=None): cmd = self.able_file.get_command(name) from able.ablefile.command import AbleCommand if not isinstance(cmd, AbleCommand): return 0 cmd.ablefile = self.able_file params, global_params = utils.filter_params(ctx.params) self.options = self.get_global_option_values(cmd, global_params) if 'verbosity' in self.options: display.verbosity = self.options.verbosity # Note: slightly wrong, this is written so that implicit localhost # Manage passwords sshpass = None becomepass = None vault_pass = None passwords = {} # don't deal with privilege escalation or passwords when we don't need to if not self.options.listhosts and not self.options.listtasks and not self.options.listtags and not self.options.syntax: self.normalize_become_options() (conn_pass, become_pass) = self.ask_passwords() passwords['conn_pass'] = conn_pass if conn_pass is not None else self.options.conn_pass passwords['become_pass'] = become_pass if become_pass is not None else self.options.become_pass loader = DataLoader() if self.options.vault_password_file: # read vault_pass from a file vault_pass = CLI.read_vault_password_file(self.options.vault_password_file, loader=loader) loader.set_vault_password(vault_pass) elif self.options.ask_vault_pass: vault_pass = self.ask_vault_passwords()[0] loader.set_vault_password(vault_pass) variable_manager = cmd.get_variable_manager() variable_manager.extra_vars = cmd.get_extra_vars(params, self.options) loader = cmd.get_loader() # create inventory and pass to var manager inventory = AbleInventory( loader=loader, variable_manager=variable_manager, host_list=cmd.get_inventory(), inventory_files=cmd.get_inventory_files() ) variable_manager.set_inventory(inventory) # Run any confirmation prompts cmd.do_confirm(variable_manager, loader) # create the playbook executor, which manages running the plays via a task queue manager ex = AbleCommandExecutor( command=cmd, inventory=inventory, variable_manager=variable_manager, loader=loader, options=self.options, passwords=passwords) results = ex.run() if isinstance(results, list): for p in results: display.display('\nCommand: %s' % p['command']) for idx, play in enumerate(p['plays']): msg = "\n command #%d (%s): %s" % (idx + 1, ','.join(play.hosts), play.name) mytags = set(play.tags) msg += '\tTAGS: [%s]' % (','.join(mytags)) if self.options.listhosts: playhosts = set(inventory.get_hosts(play.hosts)) msg += "\n pattern: %s\n hosts (%d):" % (play.hosts, len(playhosts)) for host in playhosts: msg += "\n %s" % host display.display(msg) all_tags = set() if self.options.listtags or self.options.listtasks: taskmsg = '' if self.options.listtasks: taskmsg = ' tasks:\n' all_vars = cmd.get_variable_manager().get_vars(loader=cmd.get_loader(), play=self) play_context = PlayContext(play=self, options=self.options) for block in play.compile(): block = block.filter_tagged_tasks(play_context, all_vars) if not block.has_tasks(): continue for task in block.block: if task.action == 'meta': continue all_tags.update(task.tags) if self.options.listtasks: cur_tags = list(mytags.union(set(task.tags))) cur_tags.sort() if task.name: taskmsg += " %s" % task.get_name() else: taskmsg += " %s" % task.action taskmsg += "\tTAGS: [%s]\n" % ', '.join(cur_tags) if self.options.listtags: cur_tags = list(mytags.union(all_tags)) cur_tags.sort() taskmsg += " TASK TAGS: [%s]\n" % ', '.join(cur_tags) display.display(taskmsg) return 0 else: return results
fig_title = 'Disk Read Usage' fig_name = 'Disk_Read_usage.png' divide_base = -1 elif args.resource == 'disk_writes': resource_key = '\\\\fluentd-winserv\\PhysicalDisk(_Total)\\Disk Writes/sec' xlabel_message = 'message length (bytes)' ylabel_message = 'Disk Write (bytes/sec)' ylimit = 1000 fig_title = 'Disk Write Usage' fig_name = 'Disk_Write_usage.png' divide_base = -1 if args.base_path == '': pwd = os.path.dirname(os.path.realpath(__file__)) inventory_file_name = os.path.join(pwd, '..', 'ansible/hosts') data_loader = DataLoader() inventory = InventoryManager(loader=data_loader, sources=[inventory_file_name]) collector = inventory.get_groups_dict()['windows'][0] print(collector) base_path = os.path.join(pwd, '..', "ansible", "output", collector, "C:", "tools") else: base_path = args.base_path print(base_path) sns.set(font_scale=1.5) sns.set_style('whitegrid') sns.set_palette('Set3')