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 path_dwim(basedir, given):
dl = DataLoader()
dl.set_basedir(basedir)
return dl.path_dwim(given)
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 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):
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')
