def run(self, tmp=None, task_vars=None):
"""
Simple action plugin that returns the mocked output
when linchpin_mock is True
"""
super(ActionModule, self).run(tmp, task_vars)
# contains all the module arguments
module_args = self._task.args.copy()
# task vars.keys() contains all the variable required
# when passed a extra_var as key value pair task_vars
# would return mocked output of the named module.
# print(task_vars['vars'].keys())
# print(task_vars['vars'].get('linchpin_mock', False))
linchpin_mock = task_vars['vars'].get('linchpin_mock', False)
task_name = "_".join(self._task.get_name().split())
print(task_name)
if linchpin_mock:
if task_name.startswith("libvirt_:_DLCIE"):
return mock_utils.get_mock_data(module_args, "stat_DLCIE")
if task_name.startswith("libvirt_:_DISMT"):
return mock_utils.get_mock_data(module_args, "stat_DISMT")
if task_name.startswith("libvirt_:_LDSKAE"):
return mock_utils.get_mock_data(module_args, "stat_LDSKAE")
module_return = self._execute_module(module_args=module_args,
task_vars=task_vars,
tmp=tmp)
return module_return
def run(self, tmp=None, task_vars=None):
"""
Simple action plugin that returns the mocked output
when linchpin_mock is True
"""
super(ActionModule, self).run(tmp, task_vars)
module_args = self._task.args.copy()
linchpin_mock = task_vars['vars'].get('linchpin_mock', False)
up = task_vars['vars'].get('state', 'present') == 'present'
if up and linchpin_mock:
return mock_utils.get_mock_data(module_args, "azure_vm.present")
elif not up and linchpin_mock:
return mock_utils.get_mock_data(module_args, "azure_vm.absent")
module_return = self._execute_module(module_args=module_args,
task_vars=task_vars,
tmp=tmp)
return module_return
def run(self, tmp=None, task_vars=None):
vm = self._task.get_variable_manager()
if vm.extra_vars.get('no_monitor', False):
def get_dict(context, key):
return context.__context_dict[key]
def set_dict(context, key, value):
context.__context_dict[key] = value
context = MagicMock()
context.__context_dict = {}
context.__getitem__ = get_dict
context.__setitem__ = set_dict
wait = 0
else:
context = zmq.Context()
wait = 2
socket = context.socket(zmq.REQ)
socket.connect("tcp://localhost:5599")
socket.RCVTIMEO = 2000
if task_vars is None:
task_vars = dict()
name = "{}({})".format(self._task.args['name'],
self._task.args['count'])
msg = dict(status=dict(target=name, state='Provisioning'), bar=50)
socket.send_string(str(msg))
socket.recv_string()
super(ActionModule, self).run(tmp, task_vars)
module_args = self._task.args.copy()
linchpin_mock = task_vars['vars'].get('linchpin_mock',
False)
if linchpin_mock:
return mock_utils.get_mock_data(module_args,
"dummy")
else:
module_return = self._execute_module(module_name='dummy',
module_args=module_args,
task_vars=task_vars, tmp=tmp)
del tmp # tmp no longer has any effect
sleep(wait)
msg = dict(status=dict(target=name, state='Done'), bar=50)
socket.send(str(msg).encode('utf-8'))
socket.recv_string()
sleep(wait)
return module_return
def run(self, tmp=None, task_vars=None):
"""
Simple action plugin that returns the mocked output
when linchpin_mock is True
"""
super(ActionModule, self).run(tmp, task_vars)
module_args = self._task.args.copy()
linchpin_mock = task_vars['vars'].get('linchpin_mock', False)
if linchpin_mock:
return mock_utils.get_mock_data(module_args, "ec2_vpc_igw")
module_return = self._execute_module(module_args=module_args,
task_vars=task_vars,
tmp=tmp)
return module_return
def run(self, tmp=None, task_vars=None):
"""
Simple action plugin that returns the mocked output
when linchpin_mock is True
"""
super(ActionModule, self).run(tmp, task_vars)
# contains all the module arguments
module_args = self._task.args.copy()
# task vars.keys() contains all the variable required
# when passed a extra_var as key value pair task_vars
# would return mocked output of the named module.
# print(task_vars['vars'].keys())
# print(task_vars['vars'].get('linchpin_mock', False))
linchpin_mock = task_vars['vars'].get('linchpin_mock', False)
if linchpin_mock:
return mock_utils.get_mock_data(module_args, "os_router")
module_return = self._execute_module(module_args=module_args,
task_vars=task_vars,
tmp=tmp)
return module_return
def run(self, tmp=None, task_vars=None):
"""
Simple action plugin that returns the mocked output
when linchpin_mock is True
"""
super(ActionModule, self).run(tmp, task_vars)
# contains all the module arguments
module_args = self._task.args.copy()
# task vars.keys() contains all the variable required
# when passed a extra_var as key value pair task_vars
# would return mocked output of the named module.
# print(task_vars['vars'].keys())
# print(task_vars['vars'].get('linchpin_mock', False))
linchpin_mock = task_vars['vars'].get('linchpin_mock', False)
state = task_vars['vars'].get('state')
task_name = "_".join(self._task.get_name().split())
print(task_name)
if linchpin_mock and state == "absent":
if task_name.startswith("libvirt_:"):
return mock_utils.get_mock_data(module_args, "virt_vm_status")
if task_name.startswith("libvirt_:_undefine_node"):
return mock_utils.get_mock_data(module_args, "virt_vm_status")
if linchpin_mock:
if task_name.startswith("libvirt_:_DNAE"):
return mock_utils.get_mock_data(
module_args, "virt_does_node_already_exist")
if task_name.startswith("libvirt_:_DN"):
return mock_utils.get_mock_data(module_args,
"virt_define_node")
if task_name.startswith("libvirt_:_SVM"):
return mock_utils.get_mock_data(module_args, "virt_SVM")
if task_name.startswith("libvirt_:_WFVMTSD"):
return mock_utils.get_mock_data(module_args, "virt_vm_status")
if task_name.startswith("libvirt_:_MSVMISD"):
return mock_utils.get_mock_data(module_args, "virt_msvmisd")
if task_name.startswith("libvirt_:_SVMA"):
return mock_utils.get_mock_data(module_args,
"virt_start_vm_again")
if task_name.startswith("libvirt_:_DND"):
return mock_utils.get_mock_data(module_args,
"virt_dump_node_data")
if task_name.startswith("libvirt_:_VNF"):
return mock_utils.get_mock_data(module_args, "virt_net_facts")
if task_name.startswith("libvirt_:_MSVAR"):
return mock_utils.get_mock_data(module_args, "virt_MSVAR")
if task_name.startswith("libvirt_:_MSVARWPE"):
return mock_utils.get_mock_data(module_args, "virt_MSVARWPE")
module_return = self._execute_module(module_args=module_args,
task_vars=task_vars,
tmp=tmp)
return module_return
def run(self, tmp=None, task_vars=None):
module_args = self._task.args.copy()
if task_vars is None:
task_vars = dict()
linchpin_mock = task_vars['vars'].get('linchpin_mock', False)
if linchpin_mock:
return mock_utils.get_mock_data(module_args, "ec2")
vm = self._task.get_variable_manager()
if vm.extra_vars.get('no_monitor', False):
def get_dict(context, key):
return context.__context_dict[key]
def set_dict(context, key, value):
context.__context_dict[key] = value
context = MagicMock()
context.__context_dict = {}
context.__getitem__ = get_dict
context.__setitem__ = set_dict
else:
context = zmq.Context()
socket = context.socket(zmq.REQ)
socket.connect("tcp://localhost:5599")
socket.RCVTIMEO = 2000
if task_vars is None:
task_vars = dict()
if self._task.args.get('state', 'present') == 'present':
action = 'present'
base = self._task.args['instance_tags']['name']
count = int(self._task.args.get('count', '1'))
for index in range(1, count):
name = "{}({})".format(base, index)
msg = dict(status=dict(target=name, state='Provisioning'),
bar=10)
socket.send_string(str(msg))
socket.recv_string()
elif self._task.args['state'] == 'absent':
action = 'absent'
name = "{}({})".format(
self._task.args['instance_tags']['name'],
self._task.args['instance_ids'])
msg = dict(status=dict(target=name, state='Destryoing'),
bar=10)
socket.send(str(msg).encode('utf-8'))
socket.recv_string()
result = super(ActionModule, self).run(tmp, task_vars)
result = self._execute_module(task_vars=task_vars,
wrap_async=self._task.async_val)
del tmp # tmp no longer has any effect
done = False
old_state = ''
while not done:
facts_args = \
dict(instance_ids=result['instance_ids'],
aws_access_key=self._task.args['aws_access_key'],
aws_secret_key=self._task.args['aws_secret_key'],
region=self._task.args['region'])
info = self._execute_module(module_name='ec2_instance_facts',
module_args=facts_args,
task_vars=task_vars)
done = True
for instance in info['instances']:
state = instance['state']['name']
if state not in ['running', 'terminated']:
done = False
if state != old_state:
old_state = state
if state == 'pending':
bar = 40
if state == 'running':
state = 'Done'
bar = 50
if state == 'shutting-down':
bar = 40
if state == 'terminated':
state = 'Done'
bar = 50
else:
bar = 0
base = instance['tags']['name']
if action == 'present':
index = info['instances'].index(instance)
elif action == 'absent':
index = instance['instance_id']
name = "{}({})".format(base, index)
msg = dict(status=dict(target=name, state=state), bar=bar)
socket.send(str(msg).encode('utf-8'))
socket.recv_string()
return result
module_return = self._execute_module(module_args=module_args,
task_vars=task_vars,
tmp=tmp)
return module_return