def main():
argument_spec = purefa_argument_spec()
argument_spec.update(
dict(
name=dict(type='str', required=True),
suffix=dict(type='str'),
restore=dict(type='str'),
overwrite=dict(type='bool', default=False),
target=dict(type='str'),
eradicate=dict(type='bool', default=False),
state=dict(type='str',
default='present',
choices=['absent', 'present', 'copy']),
))
required_if = [('state', 'copy', ['suffix', 'restore'])]
module = AnsibleModule(argument_spec,
required_if=required_if,
supports_check_mode=False)
if module.params['suffix'] is None:
suffix = "snap-" + str(
(datetime.utcnow() -
datetime(1970, 1, 1, 0, 0, 0, 0)).total_seconds())
module.params['suffix'] = suffix.replace(".", "")
if not module.params['target'] and module.params['restore']:
module.params['target'] = module.params['restore']
state = module.params['state']
array = get_system(module)
pgroup = get_pgroup(module, array)
if pgroup is None:
module.fail_json(msg="Protection Group {0} does not exist".format(
module.params('pgroup')))
pgsnap = get_pgsnapshot(module, array)
if pgsnap is None:
module.fail_json(
msg="Selected volume {0} does not exist in the Protection Group".
format(module.params('name')))
if ":" in module.params['name']:
rvolume = get_rpgsnapshot(module, array)
else:
rvolume = get_pgroupvolume(module, array)
if state == 'copy' and rvolume:
restore_pgsnapvolume(module, array)
elif state == 'present' and pgroup and not pgsnap:
create_pgsnapshot(module, array)
elif state == 'present' and pgroup and pgsnap:
update_pgsnapshot(module, array)
elif state == 'present' and not pgroup:
update_pgsnapshot(module, array)
elif state == 'absent' and pgsnap:
delete_pgsnapshot(module, array)
elif state == 'absent' and not pgsnap:
module.exit_json(changed=False)
def main():
if not (len(sys.argv) > 1 and sys.argv[1] == "console"):
module = AnsibleModule(argument_spec={"cloud_type": {"type": "str", "required": True, "choices": ['aws', 'gcp', 'azure', 'lsblk']}}, supports_check_mode=True)
else:
class cDummyAnsibleModule(): # For testing without Ansible (e.g on Windows)
def __init__(self):
self.params = {}
def exit_json(self, changed, **kwargs):
print(changed, json.dumps(kwargs, sort_keys=True, indent=4, separators=(',', ': ')))
def fail_json(self, msg):
print("Failed: " + msg)
exit(1)
module = cDummyAnsibleModule()
module.params = {"cloud_type": sys.argv[2]}
if module.params['cloud_type'] == 'aws':
blockdevmap = cAwsMapper(module=module)
elif module.params['cloud_type'] == 'gcp':
blockdevmap = cGCPMapper(module=module)
elif module.params['cloud_type'] == 'azure':
blockdevmap = cAzureMapper(module=module)
elif module.params['cloud_type'] == 'lsblk':
blockdevmap = cLsblkMapper(module=module)
else:
module.fail_json(msg="cloud_type not valid :" + module.params['cloud_type'])
module.exit_json(changed=False, device_map=blockdevmap.device_map)
def main():
argument_spec = {
"hostname": {
"type": "str",
"required": True
},
"username": {
"type": "str",
"required": True
},
"password": {
"type": "str",
"required": True
},
"filters": {
"type": "dict",
"required": False
},
"name": {
"type": "str"
},
"moid": {
"type": "str"
}
}
if not (len(sys.argv) > 1 and sys.argv[1] == "console"):
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
else:
# For testing without Ansible (e.g on Windows)
module = cDummyAnsibleModule()
## Update VM
module.params = {
"hostname": "192.168.1.3",
"username": "******",
"password": sys.argv[2],
"filters": {
"hw_name": "gold-*"
},
"name": None, # "parsnip-prod-sys-a0-1616868999",
"moid": None # 350
}
iScraper = esxiFreeScraper(hostname=module.params['hostname'],
username=module.params['username'],
password=module.params['password'])
if ("moid" in module.params
and module.params['name']) or ("name" in module.params
and module.params['moid']):
vm_info = iScraper.get_vm_info(name=module.params['name'],
moid=module.params['moid'],
filters=module.params['filters'])
else:
vm_info = iScraper.get_all_vm_info(filters=module.params['filters'])
module.exit_json(changed=False, virtual_machines=vm_info)
def main():
# arguments for the module:
fields = dict(monitor_mode=dict(required=False, type="bool"),
ipv6_address=dict(required=False, type="str"),
ipv4_mask_length=dict(required=False, type="str"),
name=dict(required=True, type="str"),
duplex=dict(required=False, type="str"),
tx_ringsize=dict(required=False, type="int"),
ipv6_autoconfig=dict(required=False, type="bool"),
enabled=dict(required=False, type="bool"),
comments=dict(required=False, type="str"),
mtu=dict(required=False, type="int"),
ipv4_address=dict(required=False, type="str"),
auto_negotiation=dict(required=False, type="bool"),
mac_addr=dict(required=False, type="str"),
rx_ringsize=dict(required=False, type="int"),
speed=dict(required=False, type="str"),
ipv6_mask_length=dict(required=False, type="str"))
module = AnsibleModule(argument_spec=fields, supports_check_mode=True)
was_changed = False
ignore = ["status"]
modules_params_original = module.params
module_params_show = dict((k, v) for k, v in module.params.items()
if k in ["name"] and v is not None)
module.params = module_params_show
before = api_call_gaia(module=module,
api_call_object="show-physical-interface")
[before.pop(key) for key in ignore]
# Run the command:
module.params = modules_params_original
res = api_call_gaia(module=module,
api_call_object="set-physical-interface")
module.params = module_params_show
after = api_call_gaia(module=module,
api_call_object="show-physical-interface")
[after.pop(key) for key in ignore]
was_changed = False if before == after else True
module.exit_json(response=res, changed=was_changed)
def main():
api_keys_list_spec = {
"key_name": dict(type="str"),
"id": dict(type="str"),
"description": dict(type="str"),
"locale": dict(type="str", choices=["en-US", "ja-JP"]),
"role_id": dict(type="int"),
"time_zone": dict(type="str"),
"active": dict(type="bool"),
"created": dict(type="int"),
"last_sign_in": dict(type="int"),
"unlock_time": dict(type="int"),
"unsuccessful_sign_in_attempts": dict(type="int"),
"expiry_date": dict(type="int"),
"secret_key": dict(no_log=True, type="str"),
"service_account": dict(type="bool"),
"current": dict(type="bool"),
}
argspec = dict(
state=dict(choices=["present", "absent", "gathered"],
default="present"),
api_keys=dict(
type="list",
elements="dict",
options=api_keys_list_spec,
no_log=False,
),
)
module = AnsibleModule(argument_spec=argspec, supports_check_mode=True)
deepsec_request = DeepSecurityRequest(module)
module.params = utils.remove_empties(module.params)
if module.params["state"] == "gathered":
display_gathered_result(argspec=argspec,
module=module,
deepsec_request=deepsec_request)
elif module.params["state"] == "absent":
delete_module_api_config(argspec=argspec,
module=module,
deepsec_request=deepsec_request)
elif module.params["state"] == "present":
configure_module_api(argspec=argspec,
module=module,
deepsec_request=deepsec_request)
def run_module():
'''execution logic for the ansible module
This function is organized per the ansible documentation
(https://docs.ansible.com/ansible/latest/dev_guide/developing_modules_documenting.html)
and implements the standardized logic sequence for a custom module:
1. define the module's input spec
2. define the module's return spec
3. create an instance of the AnsibleModule class using the above
(ansible internally takes care of populating hte params member)
4. execute the module's custom logic
4.1 update the params using update_logical_defaults
4.2 parse the params into a desired action, check if it needs to be executed, and possibly
execute (execute_task function)
5. use ansible's exit_json or fail_json to ensure results are sent back to the execution
environmentas expected.
'''
module_args = {
"volttron_root": {
"type": "path",
"default": None,
},
"volttron_venv": {
"type": "path",
"default": None,
},
"volttron_home": {
"type": "path",
"required": False,
"default": None,
},
"agent_configs_dir": {
"type": "path",
"default": None,
},
"time_limit": {
"type": "int",
"default": 30,
},
"agent_vip_id": {
"type": "str",
"required": True,
},
"agent_spec": {
"type": "dict",
"required": True,
},
}
# seed the result dict in the object
# we primarily care about changed and state
# change is if this module effectively modified the target
# state will include any data that you want your module to pass back
# for consumption, for example, in a subsequent task
result = {
'changed': False,
'stdout': '',
'stderr': '',
'command': [],
'return_code': None,
}
# the AnsibleModule object will be our abstraction working with Ansible
# this includes instantiation, a couple of common attr would be the
# args/params passed to the execution, as well as if the module
# supports check mode
module = AnsibleModule(argument_spec=module_args, supports_check_mode=True)
module.params = update_logical_defaults(module)
# if the user is working with this module in only check mode we do not
# want to make any changes to the environment, just return the current
# state with no modifications
if module.check_mode:
module.exit_json(**result)
# actually execute the task
try:
result.update(execute_task(module))
except Exception as e:
import traceback
raise e
#module.fail_json(msg='volttron_agent had an unhandled exception', exception=repr(e), trace=traceback.format_stack())
# in the event of a successful module execution, you will want to
# simple AnsibleModule.exit_json(), passing the key/value results
module.exit_json(**result)
def generate_module():
# NOTE(jeffrey4l): add empty string '' to choices let us use
# pid_mode: "{{ service.pid_mode | default ('') }}" in yaml
argument_spec = dict(
common_options=dict(required=False, type='dict', default=dict()),
action=dict(required=True,
type='str',
choices=[
'compare_container', 'compare_image', 'create_volume',
'get_container_env', 'get_container_state',
'pull_image', 'is_container_running',
'recreate_or_restart_container', 'remove_container',
'remove_image', 'remove_volume', 'restart_container',
'start_container', 'stop_container',
'stop_and_remove_container'
]),
api_version=dict(required=False, type='str', default='auto'),
auth_email=dict(required=False, type='str'),
auth_password=dict(required=False, type='str', no_log=True),
auth_registry=dict(required=False, type='str'),
auth_username=dict(required=False, type='str'),
command=dict(required=False, type='str'),
detach=dict(required=False, type='bool', default=True),
labels=dict(required=False, type='dict', default=dict()),
name=dict(required=False, type='str'),
environment=dict(required=False, type='dict'),
image=dict(required=False, type='str'),
ipc_mode=dict(required=False,
type='str',
choices=['', 'host', 'private', 'shareable']),
cap_add=dict(required=False, type='list', default=list()),
security_opt=dict(required=False, type='list', default=list()),
pid_mode=dict(required=False, type='str', choices=['host', '']),
privileged=dict(required=False, type='bool', default=False),
graceful_timeout=dict(required=False, type='int', default=10),
remove_on_exit=dict(required=False, type='bool', default=True),
restart_policy=dict(
required=False,
type='str',
choices=['no', 'on-failure', 'always', 'unless-stopped']),
restart_retries=dict(required=False, type='int', default=10),
state=dict(required=False,
type='str',
default='running',
choices=['running', 'exited', 'paused']),
tls_verify=dict(required=False, type='bool', default=False),
tls_cert=dict(required=False, type='str'),
tls_key=dict(required=False, type='str'),
tls_cacert=dict(required=False, type='str'),
volumes=dict(required=False, type='list'),
volumes_from=dict(required=False, type='list'),
dimensions=dict(required=False, type='dict', default=dict()),
tty=dict(required=False, type='bool', default=False),
)
required_if = [
['action', 'pull_image', ['image']],
['action', 'start_container', ['image', 'name']],
['action', 'compare_container', ['name']],
['action', 'compare_image', ['name']],
['action', 'create_volume', ['name']],
['action', 'get_container_env', ['name']],
['action', 'get_container_state', ['name']],
['action', 'is_container_running', ['name']],
['action', 'recreate_or_restart_container', ['name']],
['action', 'remove_container', ['name']],
['action', 'remove_image', ['image']],
['action', 'remove_volume', ['name']],
['action', 'restart_container', ['name']],
['action', 'stop_container', ['name']],
['action', 'stop_and_remove_container', ['name']],
]
module = AnsibleModule(argument_spec=argument_spec,
required_if=required_if,
bypass_checks=False)
new_args = module.params.pop('common_options', dict())
# NOTE(jeffrey4l): merge the environment
env = module.params.pop('environment', dict())
if env:
new_args['environment'].update(env)
for key, value in module.params.items():
if key in new_args and value is None:
continue
new_args[key] = value
# if pid_mode = ""/None/False, remove it
if not new_args.get('pid_mode', False):
new_args.pop('pid_mode', None)
# if ipc_mode = ""/None/False, remove it
if not new_args.get('ipc_mode', False):
new_args.pop('ipc_mode', None)
module.params = new_args
return module
def main():
imr_spec = {
"name":
dict(type="str"),
"description":
dict(type="str"),
"severity":
dict(type="str", choices=["low", "medium", "high", "critical"]),
"template":
dict(type="str", choices=["registry", "file", "custom"]),
"registry_key_root":
dict(type="str", no_log=True),
"registry_key_value":
dict(type="str", no_log=True),
"registry_include_subkeys":
dict(type="bool"),
"registry_included_values":
dict(type="list", elements="str"),
"registry_include_default_value":
dict(type="bool"),
"registry_excluded_values":
dict(type="list", elements="str"),
"registry_attributes":
dict(type="list", elements="str"),
"filebase_directory":
dict(type="str"),
"fileinclude_subdirectories":
dict(type="bool"),
"file_included_values":
dict(type="list", elements="str"),
"file_excluded_values":
dict(type="list", elements="str"),
"file_attributes":
dict(type="list", elements="str"),
"custom_xml":
dict(type="str"),
"alert_enabled":
dict(type="bool"),
"real_time_monitoring_enabled":
dict(type="bool"),
"recommendations_mode":
dict(type="str", choices=["enabled", "ignored", "unknown",
"disabled"]),
"minimum_agent_version":
dict(type="str"),
"minimum_manager_version":
dict(type="str"),
"original_issue":
dict(type="int"),
"last_updated":
dict(type="int"),
"type":
dict(type="str"),
"identifier":
dict(type="str"),
"id":
dict(type="int"),
}
argspec = dict(
state=dict(choices=["present", "absent", "gathered"],
default="present"),
config=dict(type="list", elements="dict", options=imr_spec),
)
module = AnsibleModule(argument_spec=argspec, supports_check_mode=True)
deepsec_request = DeepSecurityRequest(module)
module.params = utils.remove_empties(module.params)
if module.params["state"] == "gathered":
display_gathered_result(module=module, deepsec_request=deepsec_request)
elif module.params["state"] == "absent":
reset_module_api_config(module=module, deepsec_request=deepsec_request)
elif module.params["state"] == "present":
configure_module_api(argspec=argspec,
module=module,
deepsec_request=deepsec_request)
def main():
argspec = dict(
state=dict(required=True, choices=['present', 'absent'], type='str'),
id=dict(required=False, type='int'),
name=dict(required=False, type='str'),
description=dict(required=False, type='str', default=''),
application_services=dict(
type='str',
required=False,
),
is_group=dict(type='bool', default=False),
definition_type=dict(type='str', default='CUSTOM'),
members=dict(required=False, type='list', elements='str'),
protocols=dict(
type='list',
required=False,
elements='dict',
options=dict(
name=dict(type='str', required=True),
description=dict(type='str', required=False, default=''),
protocol=dict(type='str',
required=True,
choices=['tcp', 'udp', 'other']),
dst_port=dict(type='str', required=False),
src_port=dict(type='str', required=False),
disable_timeout=dict(
type='bool',
default=False,
),
inactivity_timeout=dict(
type='str',
required=False,
),
inactivity_time_type=dict(
type='str',
default='Seconds' #FIXME: ADD choices [seconds, minutes]
),
protocol_number=dict(type='int', required=False))))
module = AnsibleModule(argument_spec=argspec, supports_check_mode=True)
service_list = dict(application_services='application-services',
is_group='is-group')
protocol_list = dict(
dst_port='dst-port',
src_port='src-port',
disable_timeout='disable-timeout',
inactivity_timeout='inactivity-timeout',
inactivity_time_type='inactivity-time-type',
protocol_number='protocol-number',
)
mgr = SDServiceMgr(module=module)
# marshal (rename) the data
module.params = mgr._marshal(data=module.params,
conversion_list=service_list)
if module.params.get('protocols'):
for protocol in module.params.get('protocols'):
protocol = mgr._marshal(data=protocol,
conversion_list=protocol_list)
if module.params["id"]:
service = mgr.get_by_id(module.params["id"])
elif module.params["name"]:
service = mgr.get_one(name=module.params["name"])
else:
module.fail_json(msg='You must provide either an id or a name')
if module.params["state"] == "present":
#check params
if not module.params["name"]:
module.fail_json(msg='You must provide a name')
#only require protocols suboptions if this isn't a group
if module.params[
"is-group"] == False and not module.params["protocols"]:
module.fail_json(msg='You must provide one or more protocols')
if module.params["is-group"] and module.params["members"] is None:
module.fail_json(
msg=
'You must provide at least one member if the service type is GROUP'
)
# Create the service body
body = mgr._body_builder(module.params)
# Logic for changing an existing service
if service:
# make a copy
patch_body = dict(service=deepcopy(service[0]))
if module.params['is-group']:
members = mgr._update_list(
patch_body['service']['service_refs'],
body['service']['service_refs'], 'name')
patch_body['service']['service_refs'] = members
body['service'].pop('service_refs', None)
elif not module.params['is-group']:
protocols = mgr._update_list(
patch_body['service']['protocols']['protocol'],
body['service']['protocols']['protocol'], 'name')
patch_body['service']['protocols']['protocol'] = protocols
body['service'].pop('protocols', None)
patch_body['service'].update(body['service'])
#compare for differences
if service[0] == patch_body['service']:
module.exit_json(msg='Service already up to date',
service=service[0],
changed=False)
else:
service = mgr.update(service[0]['uuid'], patch_body)
module.exit_json(msg='Service updated',
service=service,
changed=True)
elif not service:
#create
service = mgr.create(body)
module.exit_json(service=service, changed=True)
elif module.params["state"] == "absent":
if not service:
module.exit_json(msg="Service already absent", changed=False)
else:
status, err = mgr.delete(service[0]['uuid'])
if status:
module.exit_json(changed=True)
else:
module.exit_json(
msg=
"Could not delete the service. Most likely it is in use by another group or policy.",
response=err)
def main():
ipr_spec = {
"name":
dict(type="str"),
"description":
dict(type="str"),
"minimum_agent_version":
dict(type="str"),
"application_type_id":
dict(type="int"),
"priority":
dict(type="str",
choices=["lowest", "low", "normal", "high", "highest"]),
"severity":
dict(type="str", choices=["low", "medium", "high", "critical"]),
"detect_only":
dict(type="bool"),
"event_logging_disabled":
dict(type="bool"),
"generate_event_on_packet_drop":
dict(type="bool"),
"always_include_packet_data":
dict(type="bool"),
"debug_mode_enabled":
dict(type="bool"),
"type":
dict(
type="str",
choices=[
"custom",
"smart",
"vulnerability",
"exploit",
"hidden",
"policy",
"info",
],
),
"original_issue":
dict(type="int"),
"id":
dict(type="int"),
"identifier":
dict(type="str"),
"last_updated":
dict(type="int"),
"template":
dict(type="str", choices=["signature", "start-end-patterns",
"custom"]),
"signature":
dict(type="str"),
"start":
dict(type="str"),
"patterns":
dict(type="list", elements="str"),
"end":
dict(type="str"),
"can_be_assigned_alone":
dict(type="bool"),
"case_sensitive":
dict(type="bool"),
"condition":
dict(type="str", choices=["all", "any", "none"]),
"action":
dict(type="str", choices=["drop", "log-only"]),
"custom_xml":
dict(type="str"),
"alert_enabled":
dict(type="bool"),
"schedule_id":
dict(type="int"),
"context_id":
dict(type="int"),
"recommendations_mode":
dict(type="str", choices=["enabled", "ignored", "unknown",
"disabled"]),
"depends_on_rule_ids":
dict(type="list", elements="int"),
"cvss_score":
dict(type="str"),
"cve":
dict(type="list", elements="str"),
}
argspec = dict(
state=dict(choices=["present", "absent", "gathered"],
default="present"),
config=dict(type="list", elements="dict", options=ipr_spec),
)
module = AnsibleModule(argument_spec=argspec, supports_check_mode=True)
deepsec_request = DeepSecurityRequest(module)
module.params = utils.remove_empties(module.params)
if module.params["state"] == "gathered":
display_gathered_result(module=module, deepsec_request=deepsec_request)
elif module.params["state"] == "absent":
reset_module_api_config(module=module, deepsec_request=deepsec_request)
elif module.params["state"] == "present":
configure_module_api(argspec=argspec,
module=module,
deepsec_request=deepsec_request)
def run_module():
''' execution logic for the ansible module
This function is organized per the ansible documentation
(https://docs.ansible.com/ansible/latest/dev_guide/developing_modules_documenting.html)
and implements the standardized logic sequence for a custom module:
1. define the module's input spec
2. define the module's return spec
3. construct an instance of the AnsibleModule class using the above
(ansible internally takes care of populating the params member)
4. execute the module's custom logic
4.1 update the params using update_logical_defaults
4.2 call the bootstrap script in a subprocess
5. use ansible's fail_json or exit_json functions to send results back to the ansible
execution
'''
# define available arguments/parameters a user can pass to the module
# these should match the DOCUMENTATION above
module_args = {
"volttron_root": {
"type": "path",
"required": True,
},
"volttron_env": {
"type": "path",
"required": False,
"default": None,
},
"features": {
"type": "list",
"required": False,
"default": [],
}
}
# seed the result dict in the object
# we primarily care about changed and state
# change is if this module effectively modified the target
# state will include any data that you want your module to pass back
# for consumption, for example, in a subsequent task
result = {
'changed': False,
'bootstrap_stdout': '',
'bootstrap_stderr': '',
}
# the AnsibleModule object will be our abstraction working with Ansible
# this includes instantiation, a couple of common attr would be the
# args/params passed to the execution, as well as if the module
# supports check mode
module = AnsibleModule(
argument_spec=module_args,
supports_check_mode=True
)
module.params = update_logical_defaults(module)
# if the user is working with this module in only check mode we do not
# want to make any changes to the environment, just return the current
# state with no modifications
if module.check_mode:
module.exit_json(**result)
try:
result.update(execute_bootstrap(module))
except Exception as an_exception:
module.fail_json(msg='volttron_bootstrap had an unhandled exception', error=repr(an_exception))
if result['return_code']:
module.fail_json(msg='bootstrap process failed', **result)
# in the event of a successful module execution, you will want to
# simple AnsibleModule.exit_json(), passing the key/value results
module.exit_json(**result)
