def resultInfo():
config = ansible_runner.run(playbook=os.path.join(playbookBasePath,
'ks-config.yaml'),
private_data_dir=privateDataDir,
artifact_dir=os.path.join(
privateDataDir, 'ks-config'),
ident='ks-config',
quiet=True)
if config.rc != 0:
exit()
result = ansible_runner.run(playbook=os.path.join(playbookBasePath,
'result-info.yaml'),
private_data_dir=privateDataDir,
artifact_dir=os.path.join(
privateDataDir, 'result-info'),
ident='result',
quiet=True)
if result.rc != 0:
exit()
with open('/kubesphere/playbooks/kubesphere_running', 'r') as f:
info = f.read()
print(info)
def setup_data_item(self, data_item, monkeyfs_path, home_dir_path):
source_file = os.path.join(monkeyfs_path, "data")
data_name = data_item["name"]
data_path = data_item["path"]
data_checksum = data_item["dataset_checksum"]
dataset_filename = data_item["dataset_filename"]
installation_location = os.path.join(home_dir_path, data_item["path"])
dataset_full_path = os.path.join(monkeyfs_path, "data", data_name,
data_checksum, dataset_filename)
print("Copying dataset from", dataset_full_path, " to ",
installation_location)
runner = ansible_runner.run(
host_pattern=self.name,
private_data_dir="ansible",
module="file",
module_args="path={} state=directory".format(
installation_location))
runner = ansible_runner.run(
host_pattern=self.name,
private_data_dir="ansible",
module="unarchive",
module_args="src={} remote_src=True dest={} creates=yes".format(
dataset_full_path, installation_location))
print(runner.stats)
if runner.status == "failed":
return False, "Failed to extract archive"
return True, "Successfully setup data item"
def resultInfo(resultState=False):
ks_config = ansible_runner.run(
playbook=os.path.join(playbookBasePath, 'ks-config.yaml'),
private_data_dir=privateDataDir,
artifact_dir=os.path.join(privateDataDir, 'ks-config'),
ident='ks-config',
quiet=True)
if ks_config.rc != 0:
exit()
result = ansible_runner.run(playbook=os.path.join(playbookBasePath,
'result-info.yaml'),
private_data_dir=privateDataDir,
artifact_dir=os.path.join(
privateDataDir, 'result-info'),
ident='result',
quiet=True)
if result.rc != 0:
exit()
config.load_incluster_config()
api = client.CustomObjectsApi()
resource = api.get_namespaced_custom_object(
group="installer.kubesphere.io",
version="v1alpha1",
name="ks-installer",
namespace="kubesphere-system",
plural="clusterconfigurations",
)
if "migration" in resource['status']['core'] and resource['status'][
'core']['migration'] and resultState == False:
migration = ansible_runner.run(
playbook=os.path.join(playbookBasePath, 'ks-migration.yaml'),
private_data_dir=privateDataDir,
artifact_dir=os.path.join(privateDataDir, 'ks-migration'),
ident='ks-migration',
quiet=False)
if migration.rc != 0:
exit()
if resultState == False:
with open('/kubesphere/playbooks/kubesphere_running', 'r') as f:
info = f.read()
print(info)
telemeter = ansible_runner.run(
playbook=os.path.join(playbookBasePath, 'telemetry.yaml'),
private_data_dir=privateDataDir,
artifact_dir=os.path.join(privateDataDir, 'telemetry'),
ident='telemetry',
quiet=True)
if telemeter.rc != 0:
exit()
def _simple_ansible(playbook_path, ip, extravars=None):
ansible_runner.run(
playbook=playbook_path,
verbosity=0,
quiet=False,
inventory=
"{0} ansible_connection=ssh ansible_user=cc ansible_ssh_extra_args='-o StrictHostKeyChecking=no'"
.format(ip), # this assumes Chameleon!
ssh_key=PRIVATE_KEY,
extravars=extravars)
def run_playbook(id=None,
private_data_dir=None,
artifact_dir=None,
playbook_name=None,
playbook_args=None,
module_name=None,
module_args=None,
module_hosts=None):
"""This function is responsible for running a playbook
and returns the results of the queries that the playbook
contains.
"""
result = {}
try:
if playbook_name:
log.info(u"Running playbook '{}' with ID {}".format(
playbook_name, id))
r = ansible_runner.run(ident=id,
private_data_dir=private_data_dir,
artifact_dir=artifact_dir,
playbook=playbook_name,
extravars=playbook_args)
elif module_name:
log.info(u"Running module '{}' with ID {}".format(module_name, id))
r = ansible_runner.run(ident=id,
private_data_dir=private_data_dir,
artifact_dir=artifact_dir,
module=module_name,
module_args=module_args,
host_pattern=module_hosts)
for host in r.events:
if sys.version_info[0] >= 3:
detail = bytes(host.get('stdout', ''),
'utf-8').decode('unicode_escape')
else:
detail = host.get('stdout', '').decode('string_escape')
if host.get('event', '').startswith('runner_on'):
result[host['event_data']['host']] = \
{ 'summary': r.status,
'detail': detail
}
elif host.get('event', '') in ('verbose', 'error'):
result[host['runner_ident']] = \
{ 'summary': r.status,
'detail': detail
}
return result
except Exception as original_exception:
raise ValueError(original_exception)
def start_ansible_playbook(self):
# print('start_ansible_playbook')
ansible_runner.run(private_data_dir=self.temp_dir,
playbook="playbook.yml",
quiet=True,
debug=True,
ignore_logging=True,
cancel_callback=self.cancel_callback,
finished_callback=self.finished_callback,
event_handler=self.runner_process_message)
# print('finished ansible runner')
print(self.temp_dir)
def resultInfo(resultState=False, api=None):
ks_config = ansible_runner.run(
playbook=os.path.join(playbookBasePath, 'ks-config.yaml'),
private_data_dir=privateDataDir,
artifact_dir=os.path.join(privateDataDir, 'ks-config'),
ident='ks-config',
quiet=True
)
if ks_config.rc != 0:
print("Failed to ansible-playbook ks-config.yaml")
exit()
result = ansible_runner.run(
playbook=os.path.join(playbookBasePath, 'result-info.yaml'),
private_data_dir=privateDataDir,
artifact_dir=os.path.join(privateDataDir, 'result-info'),
ident='result',
quiet=True
)
if result.rc != 0:
print("Failed to ansible-playbook result-info.yaml")
exit()
resource = get_cluster_configuration(api)
if "migration" in resource['status']['core'] and resource['status']['core']['migration'] and resultState == False:
migration = ansible_runner.run(
playbook=os.path.join(playbookBasePath, 'ks-migration.yaml'),
private_data_dir=privateDataDir,
artifact_dir=os.path.join(privateDataDir, 'ks-migration'),
ident='ks-migration',
quiet=False
)
if migration.rc != 0:
exit()
if not resultState:
with open('/kubesphere/playbooks/kubesphere_running', 'r') as f:
info = f.read()
logging.info(info)
telemeter = ansible_runner.run(
playbook=os.path.join(playbookBasePath, 'telemetry.yaml'),
private_data_dir=privateDataDir,
artifact_dir=os.path.join(privateDataDir, 'telemetry'),
ident='telemetry',
quiet=True
)
if telemeter.rc != 0:
exit()
def test_missing_private_dir_transmit(tmpdir):
outgoing_buffer = io.BytesIO()
# Transmit
with pytest.raises(ValueError) as excinfo:
run(
streamer='transmit',
_output=outgoing_buffer,
private_data_dir='/foo/bar/baz',
playbook='debug.yml',
)
assert "private_data_dir path is either invalid or does not exist" in str(
excinfo.value)
def test_unparsable_private_dir_worker(tmpdir):
worker_dir = str(tmpdir.mkdir('for_worker'))
incoming_buffer = io.BytesIO(b'')
outgoing_buffer = io.BytesIO()
# Worker
run(
streamer='worker',
_input=incoming_buffer,
_output=outgoing_buffer,
private_data_dir=worker_dir,
)
sent = outgoing_buffer.getvalue()
assert b'"status": "error"' in sent
def run_ansible_script(logFile):
provider_data = read_txt_data(PROVIDER_EDGES_CONFIG_FILE)
customer_data = read_txt_data(CUSTOMER_EDGES_CONFIG_FILE)
network_data = read_yaml_data(ALLOWED_NETWORK_LIST_FILE)
command_list = ["iptables -A INPUT -p icmp -m limit --limit 1/s --limit-burst 1 -j ACCEPT",
"iptables -A INPUT -p icmp -m limit --limit 1/s --limit-burst 1 -j LOG --log-prefix PING-DROP",
"iptables -A INPUT -p icmp -j DROP"]
for nw in network_data["AllowedNetworks"]:
allow_nw_cmd = "iptables -A INPUT -s "+nw+" -j ACCEPT"
command_list.append(allow_nw_cmd)
cmd_data = {"IPTableCommands": command_list}
write_yaml_data(cmd_data, IP_ROUTE_COMMANDS_FILE)
print(cmd_data)
Writing to log file
for cmd in command_list:
for key, provider in enumerate(provider_data["ProviderEdges"]):
for pr in provider:
providerEdgeList[provider[pr]["ip"]] = pr
l = time.strftime("%Y%m%d-%H%M%S") + "PE IPTABLE UPDATE: " + pr + "COMMAND: " + cmd + "\n"
logFile.write(l)
for key, customer in enumerate(customer_data["CustomerEdges"]):
for cr in customer:
customerEdgeList[customer[cr]["ip"]] = cr
l = time.strftime("%Y%m%d-%H%M%S") + "CE IPTABLE UPDATE: " + cr + "COMMAND: " + cmd + "\n"
logFile.write(l)
for key, provider in enumerate(provider_data["ProviderEdges"]):
for pr in provider:
provider_ip = provider[pr]["ip"]
ip_data = {"host": provider_ip}
write_yaml_data(ip_data, IP_FILE)
r = ansible_runner.run(private_data_dir=ANSIBLE_FOLDER_PATH, playbook=IP_ROUTE_SCRIPT)
out = r.get_fact_cache(provider_ip)
for key, customer in enumerate(customer_data["CustomerEdges"]):
for cr in customer:
customer_ip = customer[cr]["ip"]
ip_data = {"host": customer_ip}
write_yaml_data(ip_data, IP_FILE)
r = ansible_runner.run(private_data_dir=ANSIBLE_FOLDER_PATH, playbook=IP_ROUTE_SCRIPT)
out = r.get_fact_cache(customer_ip)
def simulate(self, target, simulation_techniques):
# check targets running vagrant
# get ip address from machine
self.check_targets_running_vagrant(target, self.log)
target_ip = self.get_ip_address_from_machine(target)
print("{} {}".format(self.config['art_repository'],
self.config['art_branch']))
runner = ansible_runner.run(
private_data_dir='.attack_range/',
cmdline=str('-i ' + target_ip + ', '),
roles_path="../ansible/roles",
playbook='../ansible/playbooks/atomic_red_team.yml',
extravars={
'art_branch': self.config['art_branch'],
'art_repository': self.config['art_repository'],
'art_run_techniques': simulation_techniques,
'ansible_user': '******',
'ansible_password': '******',
'ansible_port': 5985,
'ansible_winrm_scheme': 'http'
},
verbosity=0)
if runner.status == "successful":
self.log.info(
"successfully executed technique ID {0} against target: {1}".
format(simulation_techniques, target))
else:
self.log.error(
"failed to executed technique ID {0} against target: {1}".
format(simulation_techniques, target))
sys.exit(1)
def preInstallTasks():
preInstallTasks = collections.OrderedDict()
preInstallTasks['preInstall'] = [
os.path.join(playbookBasePath, 'preinstall.yaml'),
os.path.join(privateDataDir, 'preinstall')
]
preInstallTasks['metrics-server'] = [
os.path.join(playbookBasePath, 'metrics_server.yaml'),
os.path.join(privateDataDir, 'metrics_server')
]
preInstallTasks['common'] = [
os.path.join(playbookBasePath, 'common.yaml'),
os.path.join(privateDataDir, 'common')
]
preInstallTasks['ks-core'] = [
os.path.join(playbookBasePath, 'ks-core.yaml'),
os.path.join(privateDataDir, 'ks-core')
]
for task, paths in preInstallTasks.items():
pretask = ansible_runner.run(
playbook=paths[0], #要执行的playbook，如/kubesphere/playbooks/preinstall.yaml
private_data_dir=privateDataDir, #整个项目执行的根目录元数据与输出的文件都在该目录下，/kubesphere/results，env/cmdline与env/extravars就在该目录下
artifact_dir=paths[1], #存放输出结果的目录，在/private_data_dir目录下，如/kubesphere/results/preinstall
ident=str(task), #存放输出结果的目录，在/private_data_dir目录下，如/kubesphere/results/preinstall/preInstall
quiet=False #为True则不输出ansible-playbook执行的结果，为False则输出
)
if pretask.rc != 0:
exit()
def launch(**kwargs):
extraVars = locals()
print(
"I'm deploying two ec2 instances. It can take several minutes. If you want to observe a process, please use -v (verbose) key"
)
ssh_key_add(**kwargs)
if kwargs.get('launch_mode_with_vcpu') is None:
kwargs['launch_mode_with_vcpu'] = True
r = ansible_runner.run(private_data_dir='./',
playbook='playbooks/playbook_aws_install.yml',
quiet=quietPlaybooks,
extravars={
**kwargs,
**awsCreds,
**sshCreds,
**gitSettings,
**firewallSettings,
**host2BindAdress
})
ini_parser.writeVar('ready4test', str(not r.rc), 'connections')
if r.rc == 0:
vpc_id = r.get_fact_cache('localhost')['vpc_id']
ini_parser.writeVar('ec2_server_id',
r.get_fact_cache('localhost')['server_ec2_id'],
'aws')
ini_parser.writeVar('ec2_client_id',
r.get_fact_cache('localhost')['client_ec2_id'],
'aws')
ini_parser.writeVar('vpc_id', vpc_id, 'aws')
ini_parser.writeVar('iperf3_server_host',
r.get_fact_cache('localhost')['ext_server'],
'connections')
ini_parser.writeVar('iperf3_int_server',
r.get_fact_cache('localhost')['int_server'],
'iperf3')
ini_parser.writeVar('iperf3_client_host',
r.get_fact_cache('localhost')['ext_client'],
'connections')
ini_parser.writeVar('iperf3_int_client',
r.get_fact_cache('localhost')['int_client'],
'iperf3')
ini_parser.writeVar('region', kwargs['region'], 'aws')
ini_parser.writeVar('launch_mode_with_vcpu',
str(kwargs['launch_mode_with_vcpu']), 'aws')
ini_parser.writeVar('instance_type_client',
kwargs['instance_type_client'], 'aws')
ini_parser.writeVar('instance_type_server',
kwargs['instance_type_server'], 'aws')
if kwargs['launch_mode_with_vcpu']:
ini_parser.writeVar('vcpu_server', str(kwargs['vcpu_server']),
'aws')
ini_parser.writeVar('vcpu_client', str(kwargs['vcpu_client']),
'aws')
result = f"I've just deployed two ec2 instances, both are ready to launch a performance tests"
else:
result = "I failed ansible playbook. Installation can be partly finished. Please perform manual cleanp using your AWS console. " \
"to understand why it happen please launch a tool with -v (verbose) key"
return result
def update_ESCU_app(self):
self.log.info("Update ESCU App. This can take some time")
# upload package
if self.config['cloud_provider'] == 'aws':
splunk_ip = aws_service.get_single_instance_public_ip(
'ar-splunk-' + self.config['range_name'] + '-' +
self.config['key_name'], self.config)
elif self.config['cloud_provider'] == 'azure':
splunk_ip = azure_service.get_instance(
self.config, "ar-splunk-" + self.config['range_name'] + "-" +
self.config['key_name'], self.log)['public_ip']
# Upload the replay logs to the Splunk server
ansible_vars = {}
ansible_vars['ansible_user'] = '******'
ansible_vars['ansible_ssh_private_key_file'] = self.config[
'private_key_path']
ansible_vars['splunk_password'] = self.config['attack_range_password']
ansible_vars['security_content_path'] = self.config[
'security_content_path']
cmdline = "-i %s, -u ubuntu" % (splunk_ip)
runner = ansible_runner.run(
private_data_dir=os.path.join(os.path.dirname(__file__), '../'),
cmdline=cmdline,
roles_path=os.path.join(os.path.dirname(__file__),
'../ansible/roles'),
playbook=os.path.join(os.path.dirname(__file__),
'../ansible/playbooks/update_escu.yml'),
extravars=ansible_vars)
def main():
#setup command line args
setup_args()
#get args back and reformat them to work with ansible
arg_vars = unpack_list(parse_args())
#get inventory
inventory = get_inventory()
#playbook
args = parser.parse_args()
playbook = args.playbook
#no output
settings = {"suppress_ansible_output": False}
#get private data dir
directory = os.getcwd() + "/ansible"
#run playbook wiht inventory
r = ansible_runner.run(private_data_dir=directory,
playbook=playbook,
inventory=inventory,
extravars=arg_vars,
verbosity=0,
settings=settings)
clean_up()
def setup_persist_folder(self, job_uid, monkeyfs_bucket_name,
home_dir_path, persist):
print("Persisting folder: ", persist)
persist_path = persist["path"]
persist_name = "." + persist_path.replace("/", "_") + "_sync.sh"
script_path = os.path.join(home_dir_path, persist_name)
monkeyfs_output_folder = "gs://" + \
os.path.join(monkeyfs_bucket_name, "jobs", job_uid, persist_path)
persist_folder_path = os.path.join(home_dir_path, persist_path)
print("Output folder: ", monkeyfs_output_folder)
print("Input folder: ", persist_folder_path)
runner = ansible_runner.run(
host_pattern=self.name,
private_data_dir="ansible",
module="include_role",
module_args="name=gcp/configure/persist_folder",
extravars={
"persist_folder_path": persist_folder_path,
"persist_script_path": script_path,
"bucket_path": monkeyfs_output_folder,
})
if runner.status == "failed":
return False, "Failed to create persisted directory: " + persist_path
return True, "Setup persist ran successfully"
def preInstallTasks():
preInstallTasks = collections.OrderedDict()
preInstallTasks['preInstall'] = [
os.path.join(playbookBasePath, 'preinstall.yaml'),
os.path.join(privateDataDir, 'preinstall')
]
preInstallTasks['metrics-server'] = [
os.path.join(playbookBasePath, 'metrics_server.yaml'),
os.path.join(privateDataDir, 'metrics_server')
]
preInstallTasks['common'] = [
os.path.join(playbookBasePath, 'common.yaml'),
os.path.join(privateDataDir, 'common')
]
preInstallTasks['ks-core'] = [
os.path.join(playbookBasePath, 'ks-core.yaml'),
os.path.join(privateDataDir, 'ks-core')
]
for task, paths in preInstallTasks.items():
pretask = ansible_runner.run(playbook=paths[0],
private_data_dir=privateDataDir,
artifact_dir=paths[1],
ident=str(task),
quiet=False)
if pretask.rc != 0:
exit()
def create_cluster(self):
# Initialize if not already done
if not self.content_folder:
self.initialize()
r = ansible_runner.run(
private_data_dir=self.content_folder,
playbook='cluster.yml',
project_dir=self.content_folder,
cmdline=self.__calculate_command_line_args(),
inventory=self.current_inventory,
ssh_key=self.context.ssh_key_manager.get_private_rsa_key_pem())
if r.rc == 0 and r.status == 'successful':
admin_file = os.path.join(self.content_folder,
'inventory/artifacts/admin.conf')
if os.path.exists(admin_file):
shutil.copyfile(admin_file,
self.context.cluster_space.kubectl_file)
self.__patch_admin_file()
os.chmod(self.context.cluster_space.kubectl_file, 0o644)
# TODO Check if admin.conf is not in the folder and kubespray is configured to copy it to localhost
else:
raise KubesprayCLusterCreationException(
'An error occurred while executing creation cluster.yml playbook'
)
logger.info(f'Kubespray run finished successfully. Time spent')
def ansible_playbook(user_input):
r = ansible_runner.run(data_dir=os.getcwd(), playbook=user_input)
print("{}: {}".format(r.stats, r.rc))
for each_host_event in r.events:
print(each_host_event['event'])
print("Final status: ")
print(r.stats)
def _run_ansible_role(
self, **kwargs: Union[str, int, float]) -> Union[bool, any]:
"""Worker func to run role"""
try:
r = ansible_runner.run(
private_data_dir=ANSIBLE_LOC,
limit=self.sut,
role=kwargs["role"],
rotate_artifacts=1,
directory_isolation_base_path="/tmp/runner",
extravars=kwargs["extra_vars"],
cmdline=kwargs.get("cmdline", "--tags all"),
)
subprocess.call(["rm", "-f", ANSIBLE_LOC + "/project/main.json"])
subprocess.call(["rm", "-f", ANSIBLE_LOC + "/env/extravars"])
except Exception as e:
logging.error(f"Ansible role run got error - {e}")
# clean up
subprocess.call(["rm", "-f", ANSIBLE_LOC + "/project/main.json"])
subprocess.call(["rm", "-f", ANSIBLE_LOC + "/env/extravars"])
return False
if r.status == "successful" and r.rc == 0:
return r
else:
return False
def cleanup_job(self, job, provider_info=dict()):
job_uid = job["job_uid"]
print("\n\nTerminating Machine:", job_uid, "\n\n")
delete_instance_params = {
"monkey_job_uid": job_uid,
"zone": provider_info["zone"],
"gcp_project": provider_info["project"],
"gcp_cred_kind": "serviceaccount",
"gcp_cred_file": provider_info["gcp_cred_file"],
}
print(provider_info)
runner = ansible_runner.run(host_pattern="localhost",
private_data_dir="ansible",
module="include_role",
module_args="name=gcp/delete",
extravars=delete_instance_params)
print(runner.stats)
if runner.status == "failed":
print("Failed Deletion of machine")
return False, "Failed to cleanup job after completion"
return True, "Succesfully cleaned up job"
def run(
server: t.Union[Server, t.Dict],
playbook: str,
extravars: t.Dict = None,
ident: str = None,
**kwargs
):
if not server:
print("Server not found!")
return
if extravars is None:
extravars = {}
if isinstance(server, dict):
priv_data_dir = prepare_priv_dir_dict(server)
extravars["host"] = server["ansible_name"]
else:
priv_data_dir = prepare_priv_dir(server)
extravars["host"] = server.ansible_name
try:
runner = ansible_runner.run(
ident=uuid4() if ident is None else ident,
private_data_dir=priv_data_dir,
project_dir="ansible/project",
playbook=playbook,
extravars=extravars,
**kwargs
)
except OSError:
print(traceback.format_exc())
return
return runner
def test_generate_and_lint_template():
r = ansible_runner.run(
private_data_dir=TEST_DIR,
# inventory='local,', # Supplied in env/cmdline directly
playbook=str(config.rootdir) +
'/infrastructure/ansible/aws-security.yml',
artifact_dir="/tmp/ansible",
rotate_artifacts=5,
quiet=False)
for each_host_event in r.events:
tasks_to_be_validated = [
'Generate CloudFormation AWS Security templates'
]
try:
if each_host_event['event_data']['task'] in tasks_to_be_validated:
for result in each_host_event['event_data']['res']['results']:
print("Changed: {}, Failed: {} \t{}".format(
result['changed'], result['failed'], result['item']))
assert result['failed'] == False
print(result)
if result['dest'].endswith('.yml'):
result_file_path = os.path.abspath(result['dest'])
print(result_file_path)
run_cfn_lint(result_file_path)
except KeyError:
pass
assert r.status == "successful"
print("Ansible playbook run status: {}".format(r.status))
def test_tht_ansible_syntax(pytestconfig):
role_path = ''
mod_path = ''
tht_root = str(pytestconfig.invocation_params.dir)
tht_test_path = os.path.join(tht_root, 'tripleo_heat_templates/tests')
for r in role_paths:
role_path = append_path(role_path, os.path.join(tht_test_path, r))
for m in module_paths:
mod_path = append_path(mod_path, os.path.join(tht_test_path, m))
play_path = os.path.join(tht_test_path, 'test_tht_ansible_syntax.yml')
os.environ["ANSIBLE_ROLES_PATH"] = role_path
os.environ["ANSIBLE_LIBRARY"] = mod_path
# Some variables are generated by config-download and part of TripleO inventory,
# absent from this testing
os.environ["ANSIBLE_ERROR_ON_UNDEFINED_VARS"] = "False"
run = ansible_runner.run(playbook=play_path,
extravars={'tht_root': tht_root},
verbosity=3)
try:
assert run.rc == 0
finally:
print("{}: {}".format(run.status, run.rc))
def test_garbage_private_dir_worker(tmpdir):
worker_dir = str(tmpdir.mkdir('for_worker'))
incoming_buffer = io.BytesIO(
b'{"kwargs": {"playbook": "debug.yml"}}\n{"zipfile": 5}\n\x01\x02\x03\x04\x05{"eof": true}\n'
)
outgoing_buffer = io.BytesIO()
# Worker
run(
streamer='worker',
_input=incoming_buffer,
_output=outgoing_buffer,
private_data_dir=worker_dir,
)
sent = outgoing_buffer.getvalue()
assert b'"status": "error"' in sent
def process(ctx, params):
playbook_path = params[
"playbook_path"] if "playbook_path" in params else "site.yml"
private_data_dir = os.getcwd()
inventory_path = (params["inventory_path"]
if "inventory_path" in params else "inventory/hosts")
extra_vars = dict(webhook_payload=ctx)
if "extra_vars" in params:
extra_vars.update(params["extra_vars"])
# Use the Python that we're running as by default, so dependencies are available
if "ansible_python_interpreter" not in params["extra_vars"]:
extra_vars.update(
{"ansible_python_interpreter": "/opt/app-root/bin/python"})
passwords = dict(vault_pass=params["vault_password"] if "vault_password" in
params else "")
r = ansible_runner.run(
private_data_dir=private_data_dir,
inventory=inventory_path,
playbook=playbook_path,
extravars=extra_vars,
passwords=passwords,
)
print("{}: {}".format(r.status, r.rc))
print(f'Final status: {r.stats}')
def run(self):
"""
Runs the task.
"""
tmpdir = tempfile.mkdtemp()
ssh_priv_key = open(os.path.expanduser('~/.ssh/id_rsa')).read()
runner = ansible_runner.run(
ident=self.task_id,
private_data_dir=tmpdir,
project_dir=self.ansible_dir,
artifact_dir=os.path.abspath(
os.path.join(self.ansible_dir, "artifacts")),
playbook=os.path.abspath(os.path.join(self.ansible_dir,
"full.yml")),
inventory=[os.path.abspath(self.ansible_built_inventory_filepath)],
ssh_key=ssh_priv_key,
extravars=dict({
"provision": True,
"clean": True
}),
envvars=dict({"OBJC_DISABLE_INITIALIZE_FORK_SAFETY": "YES"}),
cmdline="-u root",
)
shutil.rmtree(tmpdir)
if runner.status == "failed" or runner.rc is not 0:
raise RuntimeError(
"task execution failed, ansible finished with {0}".format(
runner.rc))
def on_get(self, req, resp, run=None):
doc = {}
if run is None:
if 'refresh' in req.params:
self.refresh()
doc['directories'] = []
for i in range(len(self.directories)):
doc['directories'].append({
'href':
"%s%s/%s" % (req.prefix, req.path, self.directories[i])
})
doc['message'] = 'Provide param refresh=true to update directory listing'
elif 'playbook' in req.params:
r = ansible_runner.run(private_data_dir=os.path.join(
self.path, run),
rotate_artifacts=1,
**req.params)
doc['status'] = {}
doc['status']['status'] = r.status
doc['status']['stdout'] = r.stdout.readlines()
doc['status']['stats'] = r.stats
else:
doc['message'] = 'Params are passed to the runner eg playbook=testing.yml'
resp.body = json.dumps(doc, ensure_ascii=False)
resp.status = falcon.HTTP_200
def check_aws_provider(yaml):
provider_name = yaml.get("name")
print("Checking integrity of", provider_name, "with type:",
yaml.get("type"))
cred_environment = aws_cred_file_environment(yaml["aws_cred_file"])
runner = ansible_runner.run(playbook='aws_setup_checks.yml',
private_data_dir='ansible',
extravars={
"access_key_id":
cred_environment["AWS_ACCESS_KEY_ID"],
"access_key_secret":
cred_environment["AWS_SECRET_ACCESS_KEY"],
},
quiet=True)
events = [e for e in runner.events]
if runner.status == "failed":
printout_ansible_events(events)
print("Failed to mount the AWS S3 filesystem")
return False
print("Mount successful")
return True
def create_instance(self, machine_params=dict()):
runner = ansible_runner.run(playbook='gcp_create_job.yml',
private_data_dir='ansible',
extravars=machine_params)
print(runner.stats)
if runner.status == "failed":
return None, False
print(machine_params)
retries = 4
while retries > 0:
loader = DataLoader()
inventory = InventoryManager(loader=loader,
sources="ansible/inventory")
try:
h = inventory.get_host(machine_params["monkey_job_uid"])
host_vars = h.get_vars()
inst = MonkeyInstanceGCP(ansible_info=host_vars)
# TODO ensure machine is on
if inst is not None:
return inst, True
except Exception as e:
print("Failed to get host", e)
return None, False
retries -= 1
print("Retry inventory creation for machine")
time.sleep(2)
return None, False
