def __init__(self):
"""
Creates the instance and sets the logger.
"""
display = Display()
self.log = logging.getLogger('transport')
# TODO: Make verbosity more configurable
display.verbosity = 1
if logging.getLevelName(self.log.level) == 'DEBUG':
display.verbosity = 5
# replace Displays display method with our own
display.display = lambda msg, *a, **k: self.log.info(msg)
super(LogForward, self).__init__(display)
def __init__(self):
"""
Creates the instance and sets the logger.
"""
display = Display()
self.log = logging.getLogger('transport')
# TODO: Make verbosity more configurable
display.verbosity = 1
if logging.getLevelName(self.log.level) == 'DEBUG':
display.verbosity = 5
# replace Displays display method with our own
display.display = lambda msg, *a, **k: self.log.info(msg)
super(LogForward, self).__init__(display)
def run(self):
super(GrapherCLI, self).run()
loader, inventory, variable_manager = CLI._play_prereqs()
# Looks like the display is a singleton. This instruction will NOT return a new instance.
# This is why we set the verbosity later because someone set it before us.
display = Display()
display.verbosity = self.options.verbosity
grapher = PlaybookGrapher(
data_loader=loader,
inventory_manager=inventory,
variable_manager=variable_manager,
display=display,
tags=self.options.tags,
skip_tags=self.options.skip_tags,
playbook_filename=self.options.playbook_filename,
include_role_tasks=self.options.include_role_tasks)
grapher.make_graph()
svg_path = grapher.render_graph(self.options.output_filename,
self.options.save_dot_file)
post_processor = PostProcessor(svg_path=svg_path)
post_processor.post_process(
graph_representation=grapher.graph_representation)
post_processor.write()
display.display(f"fThe graph has been exported to {svg_path}")
return svg_path
def __init__(self, options, playbook, extra_vars=None, loader=DataLoader(),
password=None, variable_manager=VariableManager(),
verbosity=1, host_list=None):
# Verbosity
display = Display()
display.verbosity = verbosity
# El equivalente de -e en la terminal
self.extra_vars = extra_vars
# Ni idea, pero es necesario
self.loader = loader
# Contraseña del vault, de haber
self.passwords = password
# Añade automaticamente las variables
self.variable_manager = variable_manager
# Crea un falso inventario dinámico y se lo pasa al gestor de variables
self.inventory = Inventory(loader=loader,
variable_manager=variable_manager,
host_list=host_list)
# Añade el inventario
self.variable_manager.set_inventory(self.inventory)
# Añade variables a mano
if extra_vars is not None:
self.variable_manager.extra_vars = extra_vars
# Definir playbook
self.playbook = playbook
# Define opciones
self.options = options
# Define la lista de hosts
self.host_list = host_list
def display():
"""
Return a display
:return:
"""
from ansible.utils.display import Display
display = Display()
display.verbosity = 3
return display
def pytest_configure(config):
"""Validate --ansible-* parameters."""
log.debug("pytest_configure() called")
config.addinivalue_line("markers", "ansible(**kwargs): Ansible integration")
# Enable connection debugging
if config.option.verbose > 0:
if hasattr(ansible.utils, 'VERBOSITY'):
ansible.utils.VERBOSITY = int(config.option.verbose)
else:
from ansible.utils.display import Display
display = Display()
display.verbosity = int(config.option.verbose)
assert config.pluginmanager.register(PyTestAnsiblePlugin(config), "ansible")
def _load(self):
variable_manager = VariableManager()
variable_manager.extra_vars = {}
variable_manager.options_vars = {'ansible_check_mode': False}
loader = DataLoader()
passwords = dict(vault_pass='******')
#display seems not to work yet :-(
display = Display()
display.verbosity = self.options.verbosity
# playbook_executor.display.verbosity = self.options.verbosity
extra_vars = {
'elastic_url': Configuration.elastic_url,
'uuid': self._job.uuid
}
self.variable_manager.extra_vars = extra_vars
inventory = Inventory(loader=loader,
variable_manager=variable_manager,
host_list=self.inventoryContainer.allHosts())
for group in self.inventoryContainer.groups:
if group.name == 'all':
if group.vars:
inventory.get_group('all').vars.update(group.vars)
else:
group.parent_groups.append(inventory.get_group('all'))
inventory.add_group(group)
variable_manager.set_inventory(inventory)
playbook = "%s/%s" % (self.pb_dir__, self.playbook__)
pbx = PlaybookExecutor(playbooks=[playbook],
inventory=inventory,
variable_manager=variable_manager,
loader=loader,
options=self.options,
passwords=passwords)
pbx.run()
def main():
variable_manager = VariableManager()
loader = DataLoader()
passwd = None
become_passwd = None
display = Display()
parser = argparse.ArgumentParser()
prepare_parser(parser)
args = parser.parse_args()
if args.askpass:
passwd = getpass.getpass("SSH password:"******"BECOME password "
"[defaults to SSH password]:")
if become_passwd == "":
become_passwd = passwd
options = Options(
connection=args.connection,
module_path=args.module_path,
forks=args.forks,
become=args.become,
become_method=args.become_method,
become_user=args.become_user,
check=args.check,
remote_user=args.remote_user,
private_key_file=args.private_key_file,
ssh_common_args=None,
sftp_extra_args=None,
scp_extra_args=None,
ssh_extra_args=None,
verbosity=args.verbose
)
display.verbosity = args.verbose
cb = CallbackModule(display)
if not os.path.isfile(args.inventory):
exit("ERROR! Can't open host list")
inventory = Inventory(
loader=loader,
variable_manager=variable_manager,
host_list=args.inventory
)
inventory.subset(args.subset)
play_source = dict(
name="Assign roles %s" % args.roles,
hosts='all',
gather_facts='no',
roles=args.roles)
variable_manager.set_inventory(inventory)
play = Play().load(
play_source,
variable_manager=variable_manager,
loader=loader
)
tqm = None
try:
tqm = TaskQueueManager(
inventory=inventory,
variable_manager=variable_manager,
loader=loader,
options=options,
passwords={'conn_pass': passwd, 'become_pass': become_passwd},
stdout_callback=cb
)
tqm.run(play)
finally:
if tqm is not None:
tqm.cleanup()
# print host.name
# print result._result
# since the API is constructed for CLI it expects certain options to always be set in the context object
context.CLIARGS = ImmutableDict(connection='smart',
module_path=['/to/mymodules'],
forks=10,
become=None,
verbosity=0,
become_method=None,
become_user=None,
check=False,
diff=False)
display.verbosity = context.CLIARGS['verbosity']
# initialize needed objects
loader = DataLoader(
) # Takes care of finding and reading yaml, json and ini files
passwords = dict() # dict(vault_pass='******')
# Instantiate our ResultCallback for handling results as they come in. Ansible expects this to be one of its main display outlets
results_callback = ResultCallback()
# create inventory, use path to host config file as source or hosts in a comma separated string
# inventory = InventoryManager(loader=loader, sources='localhost,')
inventory = InventoryManager(loader=loader, sources=["/etc/ansible/hosts"])
#print(inventory.get_groups_dict()['compute'])
# variable manager takes care of merging all the different sources to give you a unified view of variables available in each context
#!/usr/bin/env python3 # Starting points: # * Learning test 1 # - files: hosts ansible.cfg # - command: ansible -i hosts -m ping all # * Learning test 2 # - files: hosts ansible.cfg poll_test.yaml # - command: ansible-playbook -i hosts poll_test.yaml # - same through Python API: # This must be configured before other ansible imports: from ansible.utils.display import Display display = Display() # this variable name is an ansible convention and is imported from ansible code with `from __main__ import display` display.verbosity = 3 from ansible import constants as C from ansible.inventory.manager import InventoryManager from ansible.parsing.dataloader import DataLoader from ansible.vars.manager import VariableManager from ansible.executor.playbook_executor import PlaybookExecutor playbook_filepath = 'poll_test.yaml' hosts_filepath = 'hosts' loader = DataLoader() inventory = InventoryManager(loader=loader, sources=hosts_filepath) variable_manager = VariableManager(loader=loader, inventory=inventory) from argparse import Namespace
