def operation_helper(module, fos_ip_addr, fos_user_name, fos_password, https,
ssh_hostkeymust, throttle, vfid, op_name, in_name,
attributes, result, timeout):
if not is_full_human(attributes, result):
module.exit_json(**result)
if vfid is None:
vfid = 128
ret_code, auth, fos_version = login(fos_ip_addr, fos_user_name,
fos_password, https, throttle, result,
timeout)
if ret_code != 0:
module.exit_json(**result)
result["input"] = attributes
ret_code = to_fos_operation(op_name, in_name, attributes, result)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module, timeout)
if not module.check_mode:
ret_code = 0
ret_code, resp = operation_post(fos_user_name, fos_password,
fos_ip_addr, op_name, in_name,
fos_version, https, auth, vfid, result,
attributes, ssh_hostkeymust, timeout)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module, timeout)
result["changed"] = True
to_human_operation(op_name, in_name, resp["Response"])
result["operation_resp"] = resp["Response"]
logout(fos_ip_addr, https, auth, result, timeout)
module.exit_json(**result)
def zoning_find_pair_common(module, fos_ip_addr, https, auth, vfid, type_str,
obj_name, new_name, result, timeout):
type_get = None
name = None
if type_str == "alias":
type_get = alias_get
name = "alias-name"
elif type_str == "zone":
type_get = zone_get
name = "zone-name"
elif type_str == "cfg":
type_get = cfg_get
name = "cfg-name"
else:
result["failed"] = True
result['msg'] = "invalid type string" + type_str
exit_after_login(fos_ip_addr, https, auth, result, module, timeout)
ret_code, get_resp = type_get(fos_ip_addr, https, auth, vfid, result,
timeout)
if ret_code != 0:
result["failed"] = True
result['msg'] = "failed to read from database"
exit_after_login(fos_ip_addr, https, auth, result, module, timeout)
r_list = resp_to_list(get_resp, type_str)
obj_name_dict = {}
new_name_dict = {}
for obj in r_list:
if obj[name] == obj_name:
obj_name_dict = obj_to_yml(obj)
if obj[name] == new_name:
new_name_dict = obj_to_yml(obj)
return obj_name_dict, new_name_dict
def main():
"""
Main function
"""
argument_spec = dict(credential=dict(required=True,
type='dict',
no_log=True),
vfid=dict(required=False, type='int'),
throttle=dict(required=False, type='float'),
module_name=dict(required=True, type='str'),
obj_name=dict(required=True, type='str'))
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=False)
input_params = module.params
# Set up state variables
fos_ip_addr = input_params['credential']['fos_ip_addr']
fos_user_name = input_params['credential']['fos_user_name']
fos_password = input_params['credential']['fos_password']
https = input_params['credential']['https']
ssh_hostkeymust = True
if 'ssh_hostkeymust' in input_params['credential']:
ssh_hostkeymust = input_params['credential']['ssh_hostkeymust']
throttle = input_params['throttle']
vfid = input_params['vfid']
module_name = input_params['module_name']
obj_name = input_params['obj_name']
result = {"changed": False}
if vfid is None:
vfid = 128
ret_code, auth, fos_version = login(fos_ip_addr, fos_user_name,
fos_password, https, throttle, result)
if ret_code != 0:
module.exit_json(**result)
facts = {}
facts['ssh_hostkeymust'] = ssh_hostkeymust
ret_code, response = singleton_get(fos_user_name, fos_password,
fos_ip_addr, module_name, obj_name,
fos_version, https, auth, vfid, result,
ssh_hostkeymust)
if ret_code != 0:
result["singleton_get"] = ret_code
exit_after_login(fos_ip_addr, https, auth, result, module)
obj = response["Response"][obj_name]
to_human_singleton(module_name, obj_name, obj)
result["obj"] = obj
ret_dict = {}
ret_dict[obj_name] = obj
result["ansible_facts"] = ret_dict
logout(fos_ip_addr, https, auth, result)
module.exit_json(**result)
def list_helper(module, fos_ip_addr, fos_user_name, fos_password, https,
ssh_hostkeymust, throttle, vfid, module_name, list_name,
entries, all_entries, result, timeout):
if not is_full_human(entries, result):
module.exit_json(**result)
if all_entries == None:
result["all_entries_default"] = all_entries
all_entries = True
if vfid is None:
vfid = 128
if entries == None:
entries = []
ret_code, auth, fos_version = login(fos_ip_addr, fos_user_name,
fos_password, https, throttle, result,
timeout)
if ret_code != 0:
module.exit_json(**result)
ret_code, response = list_get(fos_user_name, fos_password, fos_ip_addr,
module_name, list_name, fos_version, https,
auth, vfid, result, ssh_hostkeymust, timeout)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module, timeout)
current_entries = response["Response"][str_to_yang(list_name)]
if not isinstance(current_entries, list):
if current_entries is None:
current_entries = []
else:
current_entries = [current_entries]
to_human_list(module_name, list_name, current_entries, result)
# for switch list object only, we only support one for now
# and allow users to not specifcy the WWN of the switch
# thus missing key of the entry. We'll get it from the switch
if module_name == "brocade_fibrechannel_switch" and list_name == "fibrechannel_switch":
if len(entries) != 1:
result["failed"] = True
result["msg"] = "Only one entry in an array is supported"
exit_after_login(fos_ip_addr, https, auth, result, module, timeout)
entries[0]["name"] = current_entries[0]["name"]
if module_name == "brocade_access_gateway" and list_name == "port_group":
for port_group in current_entries:
if "port_group_n_ports" in port_group and port_group[
"port_group_n_ports"] == None:
port_group["port_group_n_ports"] = {"n_port": None}
if "port_group_f_ports" in port_group and port_group[
"port_group_f_ports"] == None:
port_group["port_group_f_ports"] = {"f_port": None}
diff_entries = []
for entry in entries:
for current_entry in current_entries:
if list_entry_keys_matched(entry, current_entry, module_name,
list_name):
diff_attributes = generate_diff(result, current_entry, entry)
if len(diff_attributes) > 0:
for key in list_entry_keys(module_name, list_name):
diff_attributes[key] = entry[key]
diff_entries.append(diff_attributes)
if module_name == "brocade_security" and list_name == "user_config":
new_diff_entries = []
for diff_entry in diff_entries:
# password canot change using patch update
# any entries with password are popp'ed off.
if not "password" in diff_entry:
new_diff_entries.append(diff_entry)
diff_entries = new_diff_entries
ret_code = to_fos_list(module_name, list_name, diff_entries, result)
result["diff_retcode"] = ret_code
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module, timeout)
add_entries = []
for entry in entries:
# check to see if the new entry matches any of the old ones
found = False
for current_entry in current_entries:
if list_entry_keys_matched(entry, current_entry, module_name,
list_name):
found = True
break
if not found:
new_entry = {}
for k, v in entry.items():
new_entry[k] = v
add_entries.append(new_entry)
if module_name == "brocade_logging" and list_name == "syslog_server":
new_add_entries = []
for add_entry in add_entries:
secured = ("secured_mode" in add_entry
and add_entry["secured_mode"] == True)
if not secured:
new_add_entry = {}
new_add_entry["server"] = add_entry["server"]
new_add_entries.append(new_add_entry)
else:
new_add_entries.append(add_entry)
add_entries = new_add_entries
ret_code = to_fos_list(module_name, list_name, add_entries, result)
result["add_retcode"] = ret_code
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module, timeout)
delete_entries = []
for current_entry in current_entries:
found = False
for entry in entries:
if list_entry_keys_matched(entry, current_entry, module_name,
list_name):
found = True
break
if not found:
delete_entry = {}
for key in list_entry_keys(module_name, list_name):
delete_entry[key] = current_entry[key]
delete_entries.append(delete_entry)
ret_code = to_fos_list(module_name, list_name, delete_entries, result)
result["delete_retcode"] = ret_code
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module, timeout)
result["response"] = response
result["current_entries"] = current_entries
result["diff_entries"] = diff_entries
result["add_entries"] = add_entries
result["delete_entries"] = delete_entries
if len(diff_entries) > 0:
if not module.check_mode:
ret_code = 0
ret_code = list_patch(fos_user_name, fos_password, fos_ip_addr,
module_name, list_name, fos_version, https,
auth, vfid, result, diff_entries,
ssh_hostkeymust, timeout)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module,
timeout)
result["changed"] = True
if len(add_entries) > 0:
if not module.check_mode:
ret_code = list_post(fos_user_name, fos_password, fos_ip_addr,
module_name, list_name, fos_version, https,
auth, vfid, result, add_entries,
ssh_hostkeymust, timeout)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module,
timeout)
result["changed"] = True
if len(delete_entries) > 0 and all_entries:
if not module.check_mode:
ret_code = list_delete(fos_user_name, fos_password, fos_ip_addr,
module_name, list_name, fos_version, https,
auth, vfid, result, delete_entries,
ssh_hostkeymust, timeout)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module,
timeout)
result["changed"] = True
logout(fos_ip_addr, https, auth, result, timeout)
module.exit_json(**result)
def singleton_helper(module, fos_ip_addr, fos_user_name, fos_password, https,
ssh_hostkeymust, throttle, vfid, module_name, obj_name,
attributes, result, timeout):
if not is_full_human(attributes, result):
module.exit_json(**result)
if vfid is None:
vfid = 128
ret_code, auth, fos_version = login(fos_ip_addr, fos_user_name,
fos_password, https, throttle, result,
timeout)
if ret_code != 0:
module.exit_json(**result)
result['ssh_hostkeymust'] = ssh_hostkeymust
ret_code, response = singleton_get(fos_user_name, fos_password,
fos_ip_addr, module_name, obj_name,
fos_version, https, auth, vfid, result,
ssh_hostkeymust, timeout)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module, timeout)
resp_attributes = response["Response"][str_to_yang(obj_name)]
to_human_singleton(module_name, obj_name, resp_attributes)
diff_attributes = generate_diff(result, resp_attributes, attributes)
# any object specific special processing
if module_name == "brocade_maps" and obj_name == "maps_config":
# relay_ip_address and domain_name needs to be specifid
# at the same time based on FOS REST requirements
if "relay_ip_address" in diff_attributes and "domain_name" not in diff_attributes:
diff_attributes["domain_name"] = resp_attributes["domain_name"]
result["kept the same"] = "domain_name"
elif "relay_ip_address" not in diff_attributes and "domain_name" in diff_attributes:
diff_attributes["relay_ip_address"] = resp_attributes[
"relay_ip_address"]
result["kept the same"] = "relay_ip_address"
if "relay_ip_address" in diff_attributes and diff_attributes[
"relay_ip_address"] == None:
result["failed"] = True
result['msg'] = "must specify relay_ip_address if configured empty"
exit_after_login(fos_ip_addr, https, auth, result, module, timeout)
elif "domain_name" in diff_attributes and diff_attributes[
"domain_name"] == None:
result["failed"] = True
result['msg'] = "must specify domain_name if configured empty"
exit_after_login(fos_ip_addr, https, auth, result, module, timeout)
result["diff_attributes"] = diff_attributes
result["current_attributes"] = resp_attributes
result["new_attributes"] = attributes
if len(diff_attributes) > 0:
ret_code = to_fos_singleton(module_name, obj_name, diff_attributes,
result)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module, timeout)
if not module.check_mode:
ret_code = 0
ret_code = singleton_patch(fos_user_name, fos_password,
fos_ip_addr, module_name, obj_name,
fos_version, https, auth, vfid, result,
diff_attributes, ssh_hostkeymust,
timeout)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module,
timeout)
result["changed"] = True
else:
logout(fos_ip_addr, https, auth, result, timeout)
module.exit_json(**result)
logout(fos_ip_addr, https, auth, result, timeout)
module.exit_json(**result)
def main():
"""
Main function
"""
argument_spec = dict(credential=dict(required=True, type='dict'),
vfid=dict(required=False, type='int'),
throttle=dict(required=False, type='float'),
user_configs=dict(required=False, type='list'),
delete_user_configs=dict(required=False, type='list'))
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
input_params = module.params
# Set up state variables
fos_ip_addr = input_params['credential']['fos_ip_addr']
fos_user_name = input_params['credential']['fos_user_name']
fos_password = input_params['credential']['fos_password']
https = input_params['credential']['https']
ssh_hostkeymust = True
if 'ssh_hostkeymust' in input_params['credential']:
ssh_hostkeymust = input_params['credential']['ssh_hostkeymust']
throttle = input_params['throttle']
vfid = input_params['vfid']
user_configs = input_params['user_configs']
delete_user_configs = input_params['delete_user_configs']
result = {"changed": False}
if vfid is None:
vfid = 128
ret_code, auth, fos_version = login(fos_ip_addr, fos_user_name,
fos_password, https, throttle, result)
if ret_code != 0:
module.exit_json(**result)
ret_code, response = user_config_get(fos_ip_addr, https, auth, vfid,
result)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
resp_uc = response["Response"]["user-config"]
if isinstance(resp_uc, list):
c_user_configs = resp_uc
else:
c_user_configs = [resp_uc]
for c_user_config in c_user_configs:
if "virtual-fabric-role-id-list" in c_user_config and not isinstance(
c_user_config["virtual-fabric-role-id-list"], list):
c_user_config["virtual-fabric-role-id-list"] = [
c_user_config["virtual-fabric-role-id-list"]
]
# convert REST to human readable format first
for c_user_config in c_user_configs:
to_human_user_config(c_user_config)
# if delete user config is not None, then we make sure
# the user config is not present.
# user config creation or update does not happen at the same
# time
if delete_user_configs != None:
to_delete = []
for delete_user_config in delete_user_configs:
found = False
for c_user_config in c_user_configs:
if c_user_config["name"] == delete_user_config["name"]:
found = True
break
if found:
to_delete.append(delete_user_config)
if len(to_delete) > 0:
if not module.check_mode:
ret_code = user_config_delete(fos_ip_addr, https, auth, vfid,
result, to_delete)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
result["changed"] = True
logout(fos_ip_addr, https, auth, result)
module.exit_json(**result)
diff_user_configs = []
for new_uc in user_configs:
for c_user_config in c_user_configs:
if new_uc["name"] == c_user_config["name"]:
diff_attributes = generate_diff(result, c_user_config, new_uc)
# cannot change password using patch
# so skip for diff identification
if "password" in diff_attributes:
diff_attributes.pop("password")
if len(diff_attributes) > 0:
result["c_user_config"] = c_user_config
diff_attributes["name"] = new_uc["name"]
ret_code = to_fos_user_config(diff_attributes, result)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result,
module)
diff_user_configs.append(diff_attributes)
add_user_configs = []
for new_uc in user_configs:
found = False
for c_user_config in c_user_configs:
if new_uc["name"] == c_user_config["name"]:
found = True
if not found:
new_user_config = {}
for k, v in new_uc.items():
new_user_config[k] = v
ret_code = to_fos_user_config(new_user_config, result)
result["retcode"] = ret_code
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
add_user_configs.append(new_user_config)
result["resp_uc"] = resp_uc
result["user_configs"] = user_configs
result["diff_user_configs"] = diff_user_configs
result["add_user_configs"] = add_user_configs
if len(diff_user_configs) > 0:
if not module.check_mode:
ret_code = user_config_patch(fos_user_name, fos_password,
fos_ip_addr, fos_version, https, auth,
vfid, result, diff_user_configs,
ssh_hostkeymust)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
result["changed"] = True
if len(add_user_configs) > 0:
if not module.check_mode:
ret_code = user_config_post(fos_ip_addr, https, auth, vfid, result,
add_user_configs)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
result["changed"] = True
logout(fos_ip_addr, https, auth, result)
module.exit_json(**result)
def main():
"""
Main function
"""
argument_spec = dict(credential=dict(required=True,
type='dict',
no_log=True),
vfid=dict(required=False, type='int'),
throttle=dict(required=False, type='float'),
wwn=dict(required=True, type='str'))
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=False)
input_params = module.params
# Set up state variables
fos_ip_addr = input_params['credential']['fos_ip_addr']
fos_user_name = input_params['credential']['fos_user_name']
fos_password = input_params['credential']['fos_password']
https = input_params['credential']['https']
ssh_hostkeymust = True
if 'ssh_hostkeymust' in input_params['credential']:
ssh_hostkeymust = input_params['credential']['ssh_hostkeymust']
throttle = input_params['throttle']
vfid = input_params['vfid']
wwn = input_params['wwn']
result = {"changed": False}
if vfid is None:
vfid = 128
ret_code, auth, fos_version = login(fos_ip_addr, fos_user_name,
fos_password, https, throttle, result)
if ret_code != 0:
module.exit_json(**result)
facts = {}
facts['ssh_hostkeymust'] = ssh_hostkeymust
ret_code, response = defined_get(fos_ip_addr, https, auth, vfid, result)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
alias_list = []
if "alias" in response["Response"]["defined-configuration"]:
if isinstance(response["Response"]["defined-configuration"]["alias"],
list):
alias_list = response["Response"]["defined-configuration"]["alias"]
else:
alias_list = [
response["Response"]["defined-configuration"]["alias"]
]
result["alias_list"] = alias_list
ret_list = []
for alias in alias_list:
if "member-entry" in alias and "alias-entry-name" in alias[
"member-entry"]:
if isinstance(alias["member-entry"]["alias-entry-name"], list):
for entry in alias["member-entry"]["alias-entry-name"]:
if entry == wwn.lower():
ret_list.append(alias)
break
else:
if alias["member-entry"]["alias-entry-name"] == wwn.lower():
ret_list.append(alias)
ret_dict = {}
if len(ret_list) > 0:
ret_dict["alias"] = ret_list
result["ansible_facts"] = ret_dict
logout(fos_ip_addr, https, auth, result)
module.exit_json(**result)
def main():
"""
Main function
"""
argument_spec = dict(credential=dict(required=True,
type='dict',
no_log=True),
vfid=dict(required=False, type='int'),
throttle=dict(required=False, type='float'),
timeout=dict(required=False, type='float'),
gather_subset=dict(required=True, type='list'))
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=False)
input_params = module.params
# Set up state variables
fos_ip_addr = input_params['credential']['fos_ip_addr']
fos_user_name = input_params['credential']['fos_user_name']
fos_password = input_params['credential']['fos_password']
https = input_params['credential']['https']
ssh_hostkeymust = True
if 'ssh_hostkeymust' in input_params['credential']:
ssh_hostkeymust = input_params['credential']['ssh_hostkeymust']
throttle = input_params['throttle']
timeout = input_params['timeout']
vfid = input_params['vfid']
gather_subset = input_params['gather_subset']
result = {"changed": False}
if vfid is None:
vfid = 128
ret_code, auth, fos_version = login(fos_ip_addr, fos_user_name,
fos_password, https, throttle, result,
timeout)
if ret_code != 0:
module.exit_json(**result)
facts = {}
facts['ssh_hostkeymust'] = ssh_hostkeymust
if gather_subset is not None:
for subset in gather_subset:
if subset != "all" and subset not in valid_areas:
result["failed"] = True
result[
"msg"] = "Request for unknown module and object " + subset
logout(fos_ip_addr, https, auth, result, timeout)
module.exit_json(**result)
for area in valid_areas:
if (gather_subset is None or area in gather_subset
or "all" in gather_subset):
get_list = False
get_singleton = False
if area == "brocade_access_gateway_port_group":
module_name = "brocade_access_gateway"
list_name = "port_group"
get_list = True
elif area == "brocade_access_gateway_n_port_map":
module_name = "brocade_access_gateway"
list_name = "n_port_map"
get_list = True
elif area == "brocade_access_gateway_f_port_list":
module_name = "brocade_access_gateway"
list_name = "f_port_list"
get_list = True
elif area == "brocade_access_gateway_device_list":
module_name = "brocade_access_gateway"
list_name = "device_list"
get_list = True
elif area == "brocade_access_gateway_policy":
module_name = "brocade_access_gateway"
obj_name = "policy"
get_singleton = True
elif area == "brocade_access_gateway_n_port_settings":
module_name = "brocade_access_gateway"
obj_name = "n_port_settings"
get_singleton = True
elif area == "brocade_interface_fibrechannel":
module_name = "brocade_interface"
list_name = "fibrechannel"
get_list = True
elif area == "brocade_fibrechannel_switch":
module_name = "brocade_fibrechannel_switch"
list_name = "fibrechannel_switch"
get_list = True
elif area == "brocade_logging_syslog_server":
module_name = "brocade_logging"
list_name = "syslog_server"
get_list = True
elif area == "brocade_security_ipfilter_rule":
module_name = "brocade_security"
list_name = "ipfilter_rule"
get_list = True
elif area == "brocade_security_ipfilter_policy":
module_name = "brocade_security"
list_name = "ipfilter_policy"
get_list = True
elif area == "brocade_security_user_config":
module_name = "brocade_security"
list_name = "user_config"
get_list = True
elif area == "brocade_security_security_certificate":
module_name = "brocade_security"
list_name = "security_certificate"
get_list = True
elif area == "brocade_security_sshutil_public_key":
module_name = "brocade_security"
list_name = "sshutil_public_key"
get_list = True
elif area == "brocade_media_media_rdp":
module_name = "brocade_media"
list_name = "media_rdp"
get_list = True
elif area == "brocade_fibrechannel_trunk_trunk":
module_name = "brocade_fibrechannel_trunk"
list_name = "trunk"
get_list = True
elif area == "brocade_fibrechannel_trunk_performance":
module_name = "brocade_fibrechannel_trunk"
list_name = "performance"
get_list = True
elif area == "brocade_fibrechannel_trunk_trunk_area":
module_name = "brocade_fibrechannel_trunk"
list_name = "trunk_area"
get_list = True
elif area == "brocade_fabric_fabric_switch":
module_name = "brocade_fabric"
list_name = "fabric_switch"
get_list = True
elif area == "brocade_security_password_cfg":
module_name = "brocade_security"
obj_name = "password_cfg"
get_singleton = True
elif area == "brocade_chassis_chassis":
module_name = "brocade_chassis"
obj_name = "chassis"
get_singleton = True
elif area == "brocade_fibrechannel_configuration_fabric":
module_name = "brocade_fibrechannel_configuration"
obj_name = "fabric"
get_singleton = True
elif area == "brocade_fibrechannel_configuration_port_configuration":
module_name = "brocade_fibrechannel_configuration"
obj_name = "port_configuration"
get_singleton = True
elif area == "brocade_time_clock_server":
module_name = "brocade_time"
obj_name = "clock_server"
get_singleton = True
elif area == "brocade_time_time_zone":
module_name = "brocade_time"
obj_name = "time_zone"
get_singleton = True
elif area == "brocade_logging_audit":
module_name = "brocade_logging"
obj_name = "audit"
get_singleton = True
elif area == "brocade_snmp_system":
module_name = "brocade_snmp"
obj_name = "system"
get_singleton = True
if get_singleton:
ret_code, response = singleton_get(fos_user_name, fos_password,
fos_ip_addr, module_name,
obj_name, fos_version,
https, auth, vfid, result,
ssh_hostkeymust, timeout)
if ret_code != 0:
result[module_name + "_" + obj_name + "_get"] = ret_code
exit_after_login(fos_ip_addr, https, auth, result, module,
timeout)
obj = response["Response"][str_to_yang(obj_name)]
to_human_singleton(module_name, obj_name, obj)
facts[area] = obj
elif get_list:
ret_code, response = list_get(fos_user_name, fos_password,
fos_ip_addr, module_name,
list_name, fos_version, https,
auth, vfid, result,
ssh_hostkeymust, timeout)
if ret_code != 0:
result[module_name + "_" + list_name + "_get"] = ret_code
exit_after_login(fos_ip_addr, https, auth, result, module,
timeout)
obj_list = response["Response"][str_to_yang(list_name)]
if not isinstance(obj_list, list):
if obj_list is None:
obj_list = []
else:
obj_list = [obj_list]
to_human_list(module_name, list_name, obj_list, result)
facts[area] = obj_list
elif area == "brocade_zoning":
ret_code, response = defined_get(fos_ip_addr, https, auth,
vfid, result, timeout)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module,
timeout)
zoning = {}
zoning["defined-configuration"] = (
response["Response"]["defined-configuration"])
ret_code, response = effective_get(fos_ip_addr, https, auth,
vfid, result, timeout)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module,
timeout)
zoning["effective-configuration"] = (
response["Response"]["effective-configuration"])
to_human_zoning(zoning["effective-configuration"])
facts[area] = zoning
result["ansible_facts"] = facts
logout(fos_ip_addr, https, auth, result, timeout)
module.exit_json(**result)
def zoning_common(fos_ip_addr, https, auth, vfid, result, module, input_list,
members_add_only, members_remove_only,
to_delete_list, type_str, type_diff_processing,
type_diff_processing_to_delete, type_get,
type_post, type_delete, active_cfg):
"""
common flow of zone database updates.
:param fos_ip_addr: ip address of FOS switch
:type fos_ip_addr: str
:param is_https: indicate to use HTTP or HTTPS
:type is_https: bool
:param auth: authorization struct from login
:type auth: dict
:param result: dict to keep track of execution msgs
:type result: dict
:param module: AnsibleModule
:type module: AnsibleModule
:param input_list: list of zones, aliases or cfgs
:type input_list: list
:param to_delete_list: list of zones, aliases or cfgs to delete
:type to_delete_list: list
:param type_str: "zone", "alias", or "cfg"
:type type_str: str
:param type_diff_processing: function to compare expected & current
:type type_diff_processing: func
:param type_diff_processing_to_delete: function to compare to delete & current
:type type_diff_processing_to_delete: func
:param type_get: function to get the current db
:type type_get: func
:param type_post: function to post to FOS
:type type_post: func
:param type_delete: function to delete from FOS
:type type_delete: func
:param active_cfg: cfg to be enabled at the end. if None, only saved.
:type active_cfg: str
:return: code to indicate failure or success
:rtype: int
"""
ret_code, cfgname, checksum = cfgname_checksum_get(fos_ip_addr,
https, auth,
vfid, result)
if ret_code != 0:
result["failed"] = True
result['msg'] = "failed to checksum"
exit_after_login(fos_ip_addr, https, auth, result, module)
ret_code, get_resp = type_get(fos_ip_addr,
https, auth, vfid, result)
if ret_code != 0:
result["failed"] = True
result['msg'] = "failed to read from database"
exit_after_login(fos_ip_addr, https, auth, result, module)
if get_resp is None:
c_list = []
else:
if isinstance(get_resp["Response"][type_str], list):
c_list = get_resp["Response"][type_str]
else:
if get_resp["Response"][type_str] is None:
c_list = []
else:
c_list = [get_resp["Response"][type_str]]
# result["input_list"] = input_list
# result["c_list"] = c_list
if input_list:
ret_code, post_list, remove_list, common_list = type_diff_processing(result,
input_list,
c_list)
result["post_list"] = post_list
result["remove_list"] = remove_list
result["common_list"] = common_list
# scenarios to return no changes
# to add list has nothing or
# add list has something but members_remove_only is True
# and
# to remove list has nothing or
# to remove list has something but members_add_only is True or
# to remove list has something but member_remove_only is True
# and
# common_list has nothing and member_remove_only is True
# and cfg is not enabled
if (len(post_list) == 0 or (len(post_list) > 0 and members_remove_only == True)) and (len(remove_list) == 0 or (len(remove_list) > 0 and members_add_only == True) or (len(remove_list) > 0 and members_remove_only == True)) and (members_remove_only == None or (len(common_list) == 0 and members_remove_only == True)) and active_cfg is None:
exit_after_login(fos_ip_addr, https, auth, result, module)
need_to_save = False
if len(post_list) > 0 and (members_remove_only == None or members_remove_only == False):
if not module.check_mode:
ret_code = type_post(fos_ip_addr, https, auth, vfid,
result, post_list)
if ret_code != 0:
ret_code = cfg_abort(fos_ip_addr, https,
auth, vfid, result)
result["failed"] = True
result['msg'] = "HTTP POST failed"
exit_after_login(fos_ip_addr, https, auth, result, module)
need_to_save = True
if len(remove_list) > 0 and (members_add_only == False or members_add_only == None) and (members_remove_only == None or members_remove_only == False):
if not module.check_mode:
ret_code = type_delete(fos_ip_addr, https, auth, vfid,
result, remove_list)
if ret_code != 0:
ret_code = cfg_abort(fos_ip_addr, https,
auth, vfid, result)
result["failed"] = True
result['msg'] = "HTTP DELETE failed"
exit_after_login(fos_ip_addr, https, auth, result, module)
need_to_save = True
if len(common_list) > 0 and (members_remove_only == True):
if not module.check_mode:
ret_code = type_delete(fos_ip_addr, https, auth, vfid,
result, common_list)
if ret_code != 0:
ret_code = cfg_abort(fos_ip_addr, https,
auth, vfid, result)
result["failed"] = True
result['msg'] = "HTTP DELETE common failed"
exit_after_login(fos_ip_addr, https, auth, result, module)
need_to_save = True
if active_cfg is None:
if need_to_save:
if not module.check_mode:
# if something changed and there is already an active cfg
# reenable that cfg
ret_code = 0
failed_msg = ""
if cfgname is not None:
failed_msg = "CFG ENABLE failed"
ret_code = cfg_enable(fos_ip_addr, https, auth, vfid,
result, checksum, cfgname)
else:
failed_msg = "CFG SAVE failed"
ret_code = cfg_save(fos_ip_addr, https, auth, vfid,
result, checksum)
if ret_code != 0:
ret_code = cfg_abort(fos_ip_addr, https,
auth, vfid, result)
result['msg'] = failed_msg
result["failed"] = True
exit_after_login(fos_ip_addr, https, auth,
result, module)
result["changed"] = True
else:
if need_to_save or cfgname != active_cfg:
if not module.check_mode:
ret_code = cfg_enable(fos_ip_addr, https, auth, vfid,
result, checksum, active_cfg)
if ret_code != 0:
ret_code = cfg_abort(fos_ip_addr, https,
auth, vfid, result)
result['msg'] = "CFG ENABLE failed"
result["failed"] = True
exit_after_login(fos_ip_addr, https, auth, result, module)
result["changed"] = True
if to_delete_list:
need_to_save = False
ret_code, delete_list = type_diff_processing_to_delete(result,
to_delete_list,
c_list)
result["delete_list"] = delete_list
if len(delete_list) == 0:
return 0
if not module.check_mode:
ret_code = type_delete(fos_ip_addr, https, auth, vfid,
result, delete_list)
if ret_code != 0:
ret_code = cfg_abort(fos_ip_addr, https, auth, vfid, result)
result["failed"] = True
result['msg'] = "HTTP DELETE failed"
exit_after_login(fos_ip_addr, https, auth, result, module)
need_to_save = True
if active_cfg is None:
if need_to_save:
if not module.check_mode:
ret_code = 0
failed_msg = ""
if cfgname is not None:
failed_msg = "CFG ENABLE failed"
ret_code = cfg_enable(fos_ip_addr, https, auth, vfid,
result, checksum, cfgname)
else:
failed_msg = "CFG SAVE failed"
ret_code = cfg_save(fos_ip_addr, https, auth, vfid,
result, checksum)
if ret_code != 0:
ret_code = cfg_abort(fos_ip_addr, https, auth,
vfid, result)
result["failed"] = True
result['msg'] = failed_msg
exit_after_login(fos_ip_addr, https, auth,
result, module)
result["changed"] = True
else:
if not module.check_mode:
ret_code = cfg_enable(fos_ip_addr, https, auth, vfid,
result, checksum, active_cfg)
if ret_code != 0:
ret_code = cfg_abort(fos_ip_addr, https,
auth, result)
result["failed"] = True
result['msg'] = "CFG ENABLE failed"
exit_after_login(fos_ip_addr, https, auth, result, module)
result["changed"] = True
return 0
def main():
"""
Main function
"""
argument_spec = dict(credential=dict(required=True,
type='dict',
no_log=True),
vfid=dict(required=False, type='int'),
throttle=dict(required=False, type='float'),
timeout=dict(required=False, type='float'),
ipfilter_policies=dict(required=False, type='list'),
active_policy=dict(required=False, type='str'),
delete_policies=dict(required=False, type='list'))
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
input_params = module.params
# Set up state variables
fos_ip_addr = input_params['credential']['fos_ip_addr']
fos_user_name = input_params['credential']['fos_user_name']
fos_password = input_params['credential']['fos_password']
https = input_params['credential']['https']
throttle = input_params['throttle']
timeout = input_params['timeout']
vfid = input_params['vfid']
ipfilter_policies = input_params['ipfilter_policies']
active_policy = input_params['active_policy']
delete_policies = input_params['delete_policies']
result = {"changed": False}
# if delete policy is not None, then we make sure
# the policy is not present.
# policy creation or update does not happen at the same
# time
if delete_policies != None:
return list_delete_helper(module, fos_ip_addr, fos_user_name,
fos_password, https, True, throttle, vfid,
"brocade_security", "ipfilter_policy",
delete_policies, True, result, timeout)
# if I am dealing with active_policy set, it must be policy list update
if active_policy == None:
return list_helper(module, fos_ip_addr, fos_user_name, fos_password,
https, True, throttle, vfid, "brocade_security",
"ipfilter_policy", ipfilter_policies, False, result,
timeout)
if not is_full_human(ipfilter_policies, result):
module.exit_json(**result)
if vfid is None:
vfid = 128
ret_code, auth, fos_version = login(fos_ip_addr, fos_user_name,
fos_password, https, throttle, result,
timeout)
if ret_code != 0:
module.exit_json(**result)
ret_code, response = ipfilter_policy_get(fos_ip_addr, https, auth, vfid,
result, timeout)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module, timeout)
resp_ir = response["Response"]["ipfilter-policy"]
if isinstance(resp_ir, list):
c_policies = resp_ir
else:
c_policies = [resp_ir]
# convert REST to human readable format first
for c_policy in c_policies:
to_human_ipfilter_policy(c_policy)
# if active policy is not None, then we make sure
# the policy is active or activate. and return
# policy creation or update does not happen at the same
# time
if active_policy != None:
found_disabled_policy = False
found_active_policy = False
activate_list = []
for c_policy in c_policies:
if c_policy["name"] == active_policy:
if c_policy["is_policy_active"] == False:
found_disabled_policy = True
activate_dict = {
"name": c_policy["name"],
"action": "activate"
}
activate_list.append(activate_dict)
else:
found_active_policy = True
activate_dict = {
"name": c_policy["name"],
}
activate_list.append(activate_dict)
if found_disabled_policy:
if not module.check_mode:
ret_code = ipfilter_policy_patch(fos_ip_addr, https, auth,
vfid, result, activate_list,
timeout)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module,
timeout)
result["changed"] = True
elif found_active_policy:
result["same active policy"] = activate_list
else:
result["failed"] = True
result["msg"] = "could not find matching policy"
logout(fos_ip_addr, https, auth, result, timeout)
module.exit_json(**result)
def main():
"""
Main function
"""
argument_spec = dict(
credential=dict(required=True, type='dict', no_log=True),
vfid=dict(required=False, type='int'),
throttle=dict(required=False, type='float'),
clock_server=dict(required=False, type='dict'))
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True
)
input_params = module.params
# Set up state variables
fos_ip_addr = input_params['credential']['fos_ip_addr']
fos_user_name = input_params['credential']['fos_user_name']
fos_password = input_params['credential']['fos_password']
https = input_params['credential']['https']
throttle = input_params['throttle']
vfid = input_params['vfid']
clock_server = input_params['clock_server']
result = {"changed": False}
if vfid is None:
vfid = 128
ret_code, auth, fos_version = login(fos_ip_addr,
fos_user_name, fos_password,
https, throttle, result)
if ret_code != 0:
module.exit_json(**result)
ret_code, response = clock_server_get(
fos_ip_addr, https, auth, vfid, result)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
resp_clock = response["Response"]["clock-server"]
to_human_clock_server(resp_clock)
if "ntp_server_address" in resp_clock and "server_address" in resp_clock["ntp_server_address"]:
if not isinstance(resp_clock["ntp_server_address"]["server_address"], list):
new_list = []
new_list.append(resp_clock["ntp_server_address"]["server_address"])
resp_clock["ntp_server_address"]["server_address"] = new_list
diff_attributes = generate_diff(result, resp_clock, clock_server)
result["diff_attributes"] = diff_attributes
result["clock_server"] = clock_server
result["resp_clock"] = resp_clock
if len(diff_attributes) > 0:
ret_code = to_fos_clock_server(diff_attributes, result)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
if not module.check_mode:
ret_code = clock_server_patch(
fos_ip_addr, https,
auth, vfid, result, diff_attributes)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
result["changed"] = True
else:
logout(fos_ip_addr, https, auth, result)
module.exit_json(**result)
logout(fos_ip_addr, https, auth, result)
module.exit_json(**result)
def main():
"""
Main function
"""
argument_spec = dict(credential=dict(required=True,
type='dict',
no_log=True),
vfid=dict(required=False, type='int'),
throttle=dict(required=False, type='float'),
timeout=dict(required=False, type='float'),
pid=dict(required=True, type='str'))
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=False)
input_params = module.params
# Set up state variables
fos_ip_addr = input_params['credential']['fos_ip_addr']
fos_user_name = input_params['credential']['fos_user_name']
fos_password = input_params['credential']['fos_password']
https = input_params['credential']['https']
ssh_hostkeymust = True
if 'ssh_hostkeymust' in input_params['credential']:
ssh_hostkeymust = input_params['credential']['ssh_hostkeymust']
throttle = input_params['throttle']
timeout = input_params['timeout']
vfid = input_params['vfid']
pid = input_params['pid']
result = {"changed": False}
if vfid is None:
vfid = 128
ret_code, auth, fos_version = login(fos_ip_addr, fos_user_name,
fos_password, https, throttle, result,
timeout)
if ret_code != 0:
module.exit_json(**result)
facts = {}
facts['ssh_hostkeymust'] = ssh_hostkeymust
module_name = "brocade_fabric"
list_name = "fabric_switch"
ret_code, response = list_get(fos_user_name, fos_password, fos_ip_addr,
module_name, list_name, fos_version, https,
auth, vfid, result, ssh_hostkeymust, timeout)
if ret_code != 0:
result["list_get"] = ret_code
exit_after_login(fos_ip_addr, https, auth, result, module, timeout)
obj_list = response["Response"][str_to_yang(list_name)]
if not isinstance(obj_list, list):
if obj_list is None:
obj_list = []
else:
obj_list = [obj_list]
to_human_list(module_name, list_name, obj_list, result)
result["obj_list"] = obj_list
did = int(pid, 16) >> 16
result["did"] = did
ret_dict = {}
for obj in obj_list:
if obj["domain_id"] == str(did):
ret_dict[list_name] = obj
result["ansible_facts"] = ret_dict
logout(fos_ip_addr, https, auth, result, timeout)
module.exit_json(**result)
def main():
"""
Main function
"""
argument_spec = dict(credential=dict(required=True, type='dict'),
vfid=dict(required=False, type='int'),
throttle=dict(required=False, type='float'),
switch=dict(required=True, type='dict'))
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
input_params = module.params
# Set up state variables
fos_ip_addr = input_params['credential']['fos_ip_addr']
fos_user_name = input_params['credential']['fos_user_name']
fos_password = input_params['credential']['fos_password']
https = input_params['credential']['https']
throttle = input_params['throttle']
vfid = input_params['vfid']
switch = input_params['switch']
result = {"changed": False}
if vfid is None:
vfid = 128
ret_code, auth, fos_version = login(fos_ip_addr, fos_user_name,
fos_password, https, throttle, result)
if ret_code != 0:
module.exit_json(**result)
ret_code, response = fc_switch_get(fos_user_name, fos_password,
fos_ip_addr, fos_version, https, auth,
vfid, result)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
resp_switch = response["Response"]["fibrechannel-switch"]
to_human_switch(resp_switch)
if "dns_servers" in resp_switch:
if resp_switch[
"dns_servers"] is not None and "dns_server" in resp_switch[
"dns_servers"]:
if not isinstance(resp_switch["dns_servers"]["dns_server"], list):
new_list = []
new_list.append(resp_switch["dns_servers"]["dns_server"])
resp_switch["dns_servers"]["dns_server"] = new_list
if "ip_address" in resp_switch:
if resp_switch[
"ip_address"] is not None and "ip_address" in resp_switch[
"ip_address"]:
if not isinstance(resp_switch["ip_address"]["ip_address"], list):
new_list = []
new_list.append(resp_switch["ip_address"]["ip_address"])
resp_switch["ip_address"]["ip_address"] = new_list
if "ip_static_gateway_list" in resp_switch:
if resp_switch[
"ip_static_gateway_list"] is not None and "ip_static_gateway" in resp_switch[
"ip_static_gateway_list"]:
if not isinstance(
resp_switch["ip_static_gateway_list"]["ip_static_gateway"],
list):
new_list = []
new_list.append(
resp_switch["ip_static_gateway_list"]["ip_static_gateway"])
resp_switch["ip_static_gateway_list"][
"ip_static_gateway"] = new_list
diff_attributes = generate_diff(result, resp_switch, switch)
result["diff_attributes"] = diff_attributes
result["resp_switch"] = resp_switch
result["switch"] = switch
if len(diff_attributes) > 0:
# let's add name key to it
diff_attributes["name"] = resp_switch["name"]
ret_code = to_fos_switch(diff_attributes, result)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
if not module.check_mode:
ret_code = fc_switch_patch(fos_user_name, fos_password,
fos_ip_addr, fos_version, https, auth,
vfid, result, diff_attributes)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
result["changed"] = True
else:
logout(fos_ip_addr, https, auth, result)
module.exit_json(**result)
logout(fos_ip_addr, https, auth, result)
module.exit_json(**result)
def main():
"""
Main function
"""
argument_spec = dict(
credential=dict(required=True, type='dict', no_log=True),
vfid=dict(required=False, type='int'),
throttle=dict(required=False, type='float'),
timeout=dict(required=False, type='float'),
module_name=dict(required=True, type='str'),
list_name=dict(required=True, type='str'),
attributes=dict(required=False, type='dict'))
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=False
)
input_params = module.params
# Set up state variables
fos_ip_addr = input_params['credential']['fos_ip_addr']
fos_user_name = input_params['credential']['fos_user_name']
fos_password = input_params['credential']['fos_password']
https = input_params['credential']['https']
ssh_hostkeymust = True
if 'ssh_hostkeymust' in input_params['credential']:
ssh_hostkeymust = input_params['credential']['ssh_hostkeymust']
throttle = input_params['throttle']
timeout = input_params['timeout']
vfid = input_params['vfid']
module_name = str_to_human(input_params['module_name'])
list_name = str_to_human(input_params['list_name'])
attributes = input_params['attributes']
result = {"changed": False}
if vfid is None:
vfid = 128
ret_code, auth, fos_version = login(fos_ip_addr,
fos_user_name, fos_password,
https, throttle, result, timeout)
if ret_code != 0:
module.exit_json(**result)
facts = {}
facts['ssh_hostkeymust'] = ssh_hostkeymust
ret_code, response = list_get(fos_user_name, fos_password, fos_ip_addr,
module_name, list_name, fos_version,
https, auth, vfid, result,
ssh_hostkeymust, timeout)
if ret_code != 0:
result["list_get"] = ret_code
exit_after_login(fos_ip_addr, https, auth, result, module, timeout)
obj_list = response["Response"][str_to_yang(list_name)]
if not isinstance(obj_list, list):
if obj_list is None:
obj_list = []
else:
obj_list = [obj_list]
to_human_list(module_name, list_name, obj_list, result)
result["obj_list"] = obj_list
ret_dict = {}
ret_list = []
for obj in obj_list:
if attributes == None:
ret_list.append(obj)
else:
matched_all = 0
for k, v in attributes.items():
if k in obj and obj[k] == v:
matched_all = matched_all + 1
if matched_all == len(attributes.items()):
ret_list.append(obj)
if attributes == None:
result["attributes_len"] = 0
else:
result["attributes_len"] = len(attributes.items())
result["ret_list"] = ret_list
ret_dict[list_name] = ret_list
result["ansible_facts"] = ret_dict
logout(fos_ip_addr, https, auth, result, timeout)
module.exit_json(**result)
def main():
"""
Main function
"""
argument_spec = dict(credential=dict(required=True,
type='dict',
no_log=True),
vfid=dict(required=False, type='int'),
throttle=dict(required=False, type='float'),
module_name=dict(required=True, type='str'),
list_name=dict(required=True, type='str'),
all_entries=dict(required=False, type='bool'),
longer_timeout=dict(required=False, type='int'),
entries=dict(required=True, type='list'))
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
input_params = module.params
# Set up state variables
fos_ip_addr = input_params['credential']['fos_ip_addr']
fos_user_name = input_params['credential']['fos_user_name']
fos_password = input_params['credential']['fos_password']
https = input_params['credential']['https']
ssh_hostkeymust = True
if 'ssh_hostkeymust' in input_params['credential']:
ssh_hostkeymust = input_params['credential']['ssh_hostkeymust']
throttle = input_params['throttle']
vfid = input_params['vfid']
module_name = input_params['module_name']
list_name = input_params['list_name']
entries = input_params['entries']
all_entries = input_params['all_entries']
longer_timeout = input_params['longer_timeout']
result = {"changed": False}
if vfid is None:
vfid = 128
ret_code, auth, fos_version = login(fos_ip_addr, fos_user_name,
fos_password, https, throttle, result)
if ret_code != 0:
module.exit_json(**result)
ret_code, response = list_get(fos_user_name, fos_password, fos_ip_addr,
module_name, list_name, fos_version, https,
auth, vfid, result, ssh_hostkeymust)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
current_entries = response["Response"][list_name]
if not isinstance(current_entries, list):
current_entries = [current_entries]
to_human_list(module_name, list_name, current_entries, result)
result["current_entries"] = current_entries
diff_entries = []
for entry in entries:
for current_entry in current_entries:
if list_entry_keys_matched(entry, current_entry, module_name,
list_name):
diff_attributes = generate_diff(result, current_entry, entry)
if len(diff_attributes) > 0:
for key in list_entry_keys(module_name, list_name):
diff_attributes[key] = entry[key]
diff_entries.append(diff_attributes)
ret_code = to_fos_list(module_name, list_name, diff_entries, result)
result["diff_retcode"] = ret_code
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
add_entries = []
for entry in entries:
# check to see if the new entry matches any of the old ones
found = False
for current_entry in current_entries:
if list_entry_keys_matched(entry, current_entry, module_name,
list_name):
found = True
break
if not found:
new_entry = {}
for k, v in entry.items():
new_entry[k] = v
add_entries.append(new_entry)
ret_code = to_fos_list(module_name, list_name, add_entries, result)
result["add_retcode"] = ret_code
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
delete_entries = []
for current_entry in current_entries:
found = False
for entry in entries:
if list_entry_keys_matched(entry, current_entry, module_name,
list_name):
found = True
break
if not found:
delete_entry = {}
for key in list_entry_keys(module_name, list_name):
delete_entry[key] = current_entry[key]
delete_entries.append(delete_entry)
result["response"] = response
result["current_entries"] = current_entries
result["diff_entries"] = diff_entries
result["add_entries"] = add_entries
result["delete_entries"] = delete_entries
if len(diff_entries) > 0:
if not module.check_mode:
ret_code = 0
if longer_timeout != None:
ret_code = list_patch(fos_user_name, fos_password, fos_ip_addr,
module_name, list_name, fos_version,
https, auth, vfid, result, diff_entries,
ssh_hostkeymust, longer_timeout)
else:
ret_code = list_patch(fos_user_name, fos_password, fos_ip_addr,
module_name, list_name, fos_version,
https, auth, vfid, result, diff_entries,
ssh_hostkeymust)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
result["changed"] = True
if len(add_entries) > 0 and all_entries:
if not module.check_mode:
ret_code = list_post(fos_user_name, fos_password, fos_ip_addr,
module_name, list_name, fos_version, https,
auth, vfid, result, add_entries,
ssh_hostkeymust)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
result["changed"] = True
if len(delete_entries) > 0 and all_entries:
if not module.check_mode:
ret_code = list_delete(fos_user_name, fos_password, fos_ip_addr,
module_name, list_name, fos_version, https,
auth, vfid, result, delete_entries,
ssh_hostkeymust)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
result["changed"] = True
logout(fos_ip_addr, https, auth, result)
module.exit_json(**result)
def main():
"""
Main function
"""
argument_spec = dict(credential=dict(required=True, type='dict'),
vfid=dict(required=False, type='int'),
throttle=dict(required=False, type='float'),
syslog_servers=dict(required=True, type='list'))
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
input_params = module.params
# Set up state variables
fos_ip_addr = input_params['credential']['fos_ip_addr']
fos_user_name = input_params['credential']['fos_user_name']
fos_password = input_params['credential']['fos_password']
https = input_params['credential']['https']
throttle = input_params['throttle']
vfid = input_params['vfid']
syslog_servers = input_params['syslog_servers']
result = {"changed": False}
if vfid is None:
vfid = 128
ret_code, auth, fos_version = login(fos_ip_addr, fos_user_name,
fos_password, https, throttle, result)
if ret_code != 0:
module.exit_json(**result)
ret_code, response = syslog_server_get(fos_ip_addr, https, auth, vfid,
result)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
resp_ss = response["Response"]["syslog-server"]
if isinstance(resp_ss, list):
current_servers = resp_ss
else:
current_servers = [resp_ss]
diff_servers = []
for new_server in syslog_servers:
for current_server in current_servers:
if new_server["server"] == current_server["server"]:
to_human_syslog_server(current_server)
diff_attributes = generate_diff(result, current_server,
new_server)
if len(diff_attributes) > 0:
result["current_server"] = current_server
diff_attributes["server"] = new_server["server"]
ret_code = to_fos_syslog_server(diff_attributes, result)
result["retcode"] = ret_code
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result,
module)
diff_servers.append(diff_attributes)
add_servers = []
for new_server in syslog_servers:
found = False
for current_server in current_servers:
if new_server["server"] == current_server["server"]:
found = True
if not found:
new_yang_server = {}
secured = ("secured_mode" in new_server
and new_serer["secured_mode"] == True)
if secured:
for k, v in new_server.items():
new_yang_server[k] = v
else:
for k, v in new_server.items():
if k == "server":
new_yang_server[k] = v
ret_code = to_fos_syslog_server(new_yang_server, result)
result["retcode"] = ret_code
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
add_servers.append(new_yang_server)
delete_servers = []
for current_server in current_servers:
found = False
for new_server in syslog_servers:
if new_server["server"] == current_server["server"]:
found = True
if not found:
delete_server = {}
delete_server["server"] = current_server["server"]
delete_servers.append(delete_server)
result["resp_ss"] = resp_ss
result["syslog_servers"] = syslog_servers
result["diff_servers"] = diff_servers
result["add_servers"] = add_servers
result["delete_servers"] = delete_servers
if len(diff_servers) > 0:
if not module.check_mode:
ret_code = syslog_server_patch(fos_ip_addr, https, auth, vfid,
result, diff_servers)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
result["changed"] = True
if len(add_servers) > 0:
if not module.check_mode:
ret_code = syslog_server_post(fos_ip_addr, https, auth, vfid,
result, add_servers)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
result["changed"] = True
if len(delete_servers) > 0:
if not module.check_mode:
ret_code = syslog_server_delete(fos_ip_addr, https, auth, vfid,
result, delete_servers)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
result["changed"] = True
logout(fos_ip_addr, https, auth, result)
module.exit_json(**result)
def main():
"""
Main function
"""
argument_spec = dict(
credential=dict(required=True, type='dict'),
vfid=dict(required=False, type='int'),
throttle=dict(required=False, type='float'),
default_zone_access=dict(required=False, type='str'))
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True
)
input_params = module.params
# Set up state variables
fos_ip_addr = input_params['credential']['fos_ip_addr']
fos_user_name = input_params['credential']['fos_user_name']
fos_password = input_params['credential']['fos_password']
https = input_params['credential']['https']
throttle = input_params['throttle']
vfid = input_params['vfid']
default_zone_access = input_params['default_zone_access']
result = {"changed": False}
if vfid is None:
vfid = 128
ret_code, auth, fos_version = login(fos_ip_addr,
fos_user_name, fos_password,
https, throttle, result)
if ret_code != 0:
module.exit_json(**result)
ret_code, response = effective_get(fos_ip_addr, https, auth, vfid, result)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
resp_effective = response["Response"]["effective-configuration"]
to_human_zoning(resp_effective)
diff_attributes = {}
if (default_zone_access is not None and
default_zone_access != resp_effective["default_zone_access"]):
diff_attributes["default_zone_access"] = default_zone_access
if len(diff_attributes) > 0:
ret_code = to_fos_zoning(diff_attributes, result)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
if not module.check_mode:
ret_code = effective_patch(fos_ip_addr, https,
auth, vfid, result, diff_attributes)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
checksum = resp_effective["checksum"]
ret_code = cfg_save(fos_ip_addr, https, auth, vfid,
result, checksum)
if ret_code != 0:
ret_code = cfg_abort(fos_ip_addr, https, auth, vfid, result)
exit_after_login(fos_ip_addr, https, auth, result, module)
result["changed"] = True
else:
logout(fos_ip_addr, https, auth, result)
module.exit_json(**result)
logout(fos_ip_addr, https, auth, result)
module.exit_json(**result)
def main():
"""
Main function
"""
argument_spec = dict(credential=dict(required=True, type='dict'),
vfid=dict(required=False, type='int'),
throttle=dict(required=False, type='float'),
ipfilter_policies=dict(required=False, type='list'),
active_policy=dict(required=False, type='str'),
delete_policies=dict(required=False, type='list'))
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
input_params = module.params
# Set up state variables
fos_ip_addr = input_params['credential']['fos_ip_addr']
fos_user_name = input_params['credential']['fos_user_name']
fos_password = input_params['credential']['fos_password']
https = input_params['credential']['https']
throttle = input_params['throttle']
vfid = input_params['vfid']
ipfilter_policies = input_params['ipfilter_policies']
active_policy = input_params['active_policy']
delete_policies = input_params['delete_policies']
result = {"changed": False}
if vfid is None:
vfid = 128
ret_code, auth, fos_version = login(fos_ip_addr, fos_user_name,
fos_password, https, throttle, result)
if ret_code != 0:
module.exit_json(**result)
ret_code, response = ipfilter_policy_get(fos_ip_addr, https, auth, vfid,
result)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
resp_ir = response["Response"]["ipfilter-policy"]
if isinstance(resp_ir, list):
c_policies = resp_ir
else:
c_policies = [resp_ir]
# convert REST to human readable format first
for c_policy in c_policies:
to_human_ipfilter_policy(c_policy)
# if active policy is not None, then we make sure
# the policy is active or activate. and return
# policy creation or update does not happen at the same
# time
if active_policy != None:
found_disabled_policy = False
found_active_policy = False
activate_list = []
for c_policy in c_policies:
if c_policy["name"] == active_policy:
if c_policy["is_policy_active"] == False:
found_disabled_policy = True
activate_dict = {
"name": c_policy["name"],
"action": "activate"
}
activate_list.append(activate_dict)
else:
found_active_policy = True
activate_dict = {
"name": c_policy["name"],
}
activate_list.append(activate_dict)
if found_disabled_policy:
if not module.check_mode:
ret_code = ipfilter_policy_patch(fos_ip_addr, https, auth,
vfid, result, activate_list)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
result["changed"] = True
elif found_active_policy:
result["same active policy"] = activate_list
else:
result["failed"] = True
result["msg"] = "could not find matching policy"
logout(fos_ip_addr, https, auth, result)
module.exit_json(**result)
# if delete policy is not None, then we make sure
# the policy is not present.
# policy creation or update does not happen at the same
# time
if delete_policies != None:
to_delete = []
for delete_policy in delete_policies:
found = False
for c_policy in c_policies:
if c_policy["name"] == delete_policy["name"]:
found = True
break
if found:
to_delete.append(delete_policy)
if len(to_delete) > 0:
if not module.check_mode:
ret_code = ipfilter_policy_delete(fos_ip_addr, https, auth,
vfid, result, to_delete)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
result["changed"] = True
logout(fos_ip_addr, https, auth, result)
module.exit_json(**result)
diff_policies = []
for new_ip in ipfilter_policies:
for c_policy in c_policies:
if new_ip["name"] == c_policy["name"]:
diff_attributes = generate_diff(result, c_policy, new_ip)
if len(diff_attributes) > 0:
result["c_policy"] = c_policy
diff_attributes["name"] = new_ip["name"]
ret_code = to_fos_ipfilter_policy(diff_attributes, result)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result,
module)
diff_policies.append(diff_attributes)
add_policies = []
for new_ip in ipfilter_policies:
found = False
for c_policy in c_policies:
if new_ip["name"] == c_policy["name"]:
found = True
if not found:
new_policy = {}
for k, v in new_ip.items():
new_policy[k] = v
ret_code = to_fos_ipfilter_policy(new_policy, result)
result["retcode"] = ret_code
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
add_policies.append(new_policy)
result["resp_ir"] = resp_ir
result["ipfilter_policies"] = ipfilter_policies
result["diff_policies"] = diff_policies
result["add_policies"] = add_policies
result["delete_policies"] = delete_policies
if len(diff_policies) > 0:
if not module.check_mode:
ret_code = ipfilter_policy_patch(fos_ip_addr, https, auth, vfid,
result, diff_policies)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
result["changed"] = True
if len(add_policies) > 0:
if not module.check_mode:
ret_code = ipfilter_policy_post(fos_ip_addr, https, auth, vfid,
result, add_policies)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
result["changed"] = True
logout(fos_ip_addr, https, auth, result)
module.exit_json(**result)
def main():
"""
Main function
"""
argument_spec = dict(credential=dict(required=True, type='dict'),
vfid=dict(required=False, type='int'),
throttle=dict(required=False, type='float'),
ports=dict(required=True, type='list'))
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
input_params = module.params
# Set up state variables
fos_ip_addr = input_params['credential']['fos_ip_addr']
fos_user_name = input_params['credential']['fos_user_name']
fos_password = input_params['credential']['fos_password']
https = input_params['credential']['https']
throttle = input_params['throttle']
vfid = input_params['vfid']
ports = input_params['ports']
result = {"changed": False}
if vfid is None:
vfid = 128
ret_code, auth, fos_version = login(fos_ip_addr, fos_user_name,
fos_password, https, throttle, result)
if ret_code != 0:
module.exit_json(**result)
ret_code, response = fc_port_get(fos_ip_addr, https, auth, vfid, result)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
resp_ports = response["Response"]["fibrechannel"]
if isinstance(resp_ports, list):
current_ports = resp_ports
else:
current_ports = [resp_ports]
diff_ports = []
for port in ports:
for current_port in current_ports:
if port["name"] == current_port["name"]:
to_human_fc(current_port)
diff_attributes = generate_diff(result, current_port, port)
if len(diff_attributes) > 0:
result["current_port"] = current_port
diff_attributes["name"] = port["name"]
ret_code = to_fos_fc(diff_attributes, result)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result,
module)
diff_ports.append(diff_attributes)
result["diff_ports"] = diff_ports
if len(diff_ports) > 0:
if not module.check_mode:
ret_code = fc_port_patch(fos_ip_addr, https, auth, vfid, result,
diff_ports)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
result["changed"] = True
else:
logout(fos_ip_addr, https, auth, result)
module.exit_json(**result)
logout(fos_ip_addr, https, auth, result)
module.exit_json(**result)
def main():
"""
Main function
"""
argument_spec = dict(
credential=dict(required=True, type='dict'),
vfid=dict(required=False, type='int'),
throttle=dict(required=False, type='float'),
ipfilter_rules=dict(required=True, type='list'))
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True
)
input_params = module.params
# Set up state variables
fos_ip_addr = input_params['credential']['fos_ip_addr']
fos_user_name = input_params['credential']['fos_user_name']
fos_password = input_params['credential']['fos_password']
https = input_params['credential']['https']
throttle = input_params['throttle']
vfid = input_params['vfid']
ipfilter_rules = input_params['ipfilter_rules']
result = {"changed": False}
if vfid is None:
vfid = 128
ret_code, auth, fos_version = login(fos_ip_addr,
fos_user_name, fos_password,
https, throttle, result)
if ret_code != 0:
module.exit_json(**result)
ret_code, response = ipfilter_rule_get(
fos_ip_addr, https, auth, vfid, result)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
resp_ir = response["Response"]["ipfilter-rule"]
if isinstance(resp_ir, list):
c_rules = resp_ir
else:
c_rules = [resp_ir]
# convert everything to human readable from REST
for c_rule in c_rules:
to_human_ipfilter_rule(c_rule)
diff_rules = []
for new_ir in ipfilter_rules:
for c_rule in c_rules:
if new_ir["policy_name"] == c_rule["policy_name"] and str(new_ir["index"]) == c_rule["index"]:
diff_attributes = generate_diff(result, c_rule, new_ir)
if len(diff_attributes) > 0:
result["c_rule"] = c_rule
diff_attributes["policy_name"] = new_ir["policy_name"]
diff_attributes["index"] = new_ir["index"]
ret_code = to_fos_ipfilter_rule(diff_attributes, result)
result["retcode"] = ret_code
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
diff_rules.append(diff_attributes)
add_rules = []
for new_ir in ipfilter_rules:
found = False
for c_rule in c_rules:
if new_ir["policy_name"] == c_rule["policy_name"] and str(new_ir["index"]) == c_rule["index"]:
found = True
if not found:
new_yang_rule = {}
for k, v in new_ir.items():
new_yang_rule[k] = v
ret_code = to_fos_ipfilter_rule(new_yang_rule, result)
result["retcode"] = ret_code
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
add_rules.append(new_yang_rule)
delete_rules = []
for c_rule in c_rules:
found = False
for new_ir in ipfilter_rules:
if new_ir["policy_name"] == c_rule["policy_name"] and str(new_ir["index"]) == c_rule["index"]:
found = True
if not found:
delete_rule = {}
delete_rule["policy-name"] = c_rule["policy_name"]
delete_rule["index"] = c_rule["index"]
delete_rules.append(delete_rule)
result["resp_ir"] = resp_ir
result["ipfilter_rules"] = ipfilter_rules
result["diff_rules"] = diff_rules
result["add_rules"] = add_rules
result["delete_rules"] = delete_rules
if len(diff_rules) > 0:
if not module.check_mode:
ret_code = ipfilter_rule_patch(
fos_ip_addr, https,
auth, vfid, result, diff_rules)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
result["changed"] = True
if len(add_rules) > 0:
if not module.check_mode:
ret_code = ipfilter_rule_post(
fos_ip_addr, https,
auth, vfid, result, add_rules)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
result["changed"] = True
# if len(delete_rules) > 0:
# if not module.check_mode:
# ret_code = ipfilter_rule_delete(
# fos_ip_addr, https,
# auth, vfid, result, delete_rules)
# if ret_code != 0:
# exit_after_login(fos_ip_addr, https, auth, result, module)
#
# result["changed"] = True
logout(fos_ip_addr, https, auth, result)
module.exit_json(**result)
def main():
"""
Main function
"""
argument_spec = dict(credential=dict(required=True,
type='dict',
no_log=True),
vfid=dict(required=False, type='int'),
throttle=dict(required=False, type='float'),
gather_subset=dict(required=True, type='list'))
module = AnsibleModule(argument_spec=argument_spec,
supports_check_mode=False)
input_params = module.params
# Set up state variables
fos_ip_addr = input_params['credential']['fos_ip_addr']
fos_user_name = input_params['credential']['fos_user_name']
fos_password = input_params['credential']['fos_password']
https = input_params['credential']['https']
ssh_hostkeymust = True
if 'ssh_hostkeymust' in input_params['credential']:
ssh_hostkeymust = input_params['credential']['ssh_hostkeymust']
throttle = input_params['throttle']
vfid = input_params['vfid']
gather_subset = input_params['gather_subset']
result = {"changed": False}
if vfid is None:
vfid = 128
ret_code, auth, fos_version = login(fos_ip_addr, fos_user_name,
fos_password, https, throttle, result)
if ret_code != 0:
module.exit_json(**result)
facts = {}
facts['ssh_hostkeymust'] = ssh_hostkeymust
for area in valid_areas:
if (gather_subset is None or area in gather_subset
or "all" in gather_subset):
if area == "brocade_interface_fibrechannel":
ret_code, response = fc_port_get(fos_ip_addr, https, auth,
vfid, result)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
interface = {}
interface["fibrechannel"] = (
response["Response"]["fibrechannel"])
for port in interface["fibrechannel"]:
to_human_fc(port)
ret_code, response = fc_port_stats_get(fos_ip_addr, https,
auth, vfid, result)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
interface["fibrechannel-statistics"] = (
response["Response"]["fibrechannel-statistics"])
facts[area] = interface
if area == "brocade_zoning":
ret_code, response = defined_get(fos_ip_addr, https, auth,
vfid, result)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
zoning = {}
zoning["defined-configuration"] = (
response["Response"]["defined-configuration"])
ret_code, response = effective_get(fos_ip_addr, https, auth,
vfid, result)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
zoning["effective-configuration"] = (
response["Response"]["effective-configuration"])
to_human_zoning(zoning["effective-configuration"])
facts[area] = zoning
if area == "brocade_chassis":
ret_code, response = chassis_get(fos_user_name, fos_password,
fos_ip_addr, fos_version,
https, auth, vfid, result,
ssh_hostkeymust)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
to_human_chassis(response["Response"]["chassis"])
facts[area] = response["Response"]["chassis"]
if area == "brocade_fibrechannel_configuration_fabric":
ret_code, response = fabric_get(fos_user_name, fos_password,
fos_ip_addr, fos_version,
https, auth, vfid, result,
ssh_hostkeymust)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
to_human_fabric(response["Response"]["fabric"])
facts[area] = response["Response"]["fabric"]
if area == "brocade_fibrechannel_configuration_port_configuration":
ret_code, response = port_configuration_get(
fos_user_name, fos_password, fos_ip_addr, fos_version,
https, auth, vfid, result, ssh_hostkeymust)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
to_human_port_configuration(
response["Response"]["port-configuration"])
facts[area] = response["Response"]["port-configuration"]
if area == "brocade_fibrechannel_switch":
ret_code, response = fc_switch_get(fos_user_name, fos_password,
fos_ip_addr, fos_version,
https, auth, vfid, result,
ssh_hostkeymust)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
to_human_switch(response["Response"]["fibrechannel-switch"])
facts[area] = response["Response"]["fibrechannel-switch"]
if area == "brocade_time_clock_server":
ret_code, response = clock_server_get(fos_ip_addr, https, auth,
vfid, result)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
to_human_clock_server(response["Response"]["clock-server"])
facts[area] = response["Response"]["clock-server"]
if area == "brocade_time_time_zone":
ret_code, response = time_zone_get(fos_ip_addr, https, auth,
vfid, result)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
to_human_time_zone(response["Response"]["time-zone"])
facts[area] = response["Response"]["time-zone"]
if area == "brocade_logging_syslog_server":
ret_code, response = syslog_server_get(fos_ip_addr, https,
auth, vfid, result)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
if isinstance(response["Response"]["syslog-server"], list):
servers = response["Response"]["syslog-server"]
else:
servers = [response["Response"]["syslog-server"]]
for server in servers:
to_human_syslog_server(server)
facts[area] = servers
if area == "brocade_logging_audit":
ret_code, response = audit_get(fos_ip_addr, https, auth, vfid,
result)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
to_human_audit(response["Response"]["audit"])
facts[area] = response["Response"]["audit"]
if area == "brocade_snmp_system":
ret_code, response = system_get(fos_user_name, fos_password,
fos_ip_addr, fos_version,
https, auth, vfid, result)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
to_human_system(response["Response"]["system"])
facts[area] = response["Response"]["system"]
if area == "brocade_security_ipfilter_rule":
ret_code, response = ipfilter_rule_get(fos_ip_addr, https,
auth, vfid, result)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
for rule in response["Response"]["ipfilter-rule"]:
to_human_ipfilter_rule(rule)
facts[area] = response["Response"]["ipfilter-rule"]
if area == "brocade_security_ipfilter_policy":
ret_code, response = ipfilter_policy_get(
fos_ip_addr, https, auth, vfid, result)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
for rule in response["Response"]["ipfilter-policy"]:
to_human_ipfilter_policy(rule)
facts[area] = response["Response"]["ipfilter-policy"]
if area == "brocade_security_user_config":
ret_code, response = user_config_get(fos_ip_addr, https, auth,
vfid, result)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
for rule in response["Response"]["user-config"]:
to_human_user_config(rule)
facts[area] = response["Response"]["user-config"]
result["ansible_facts"] = facts
logout(fos_ip_addr, https, auth, result)
module.exit_json(**result)
def list_delete_helper(module, fos_ip_addr, fos_user_name, fos_password, https,
ssh_hostkeymust, throttle, vfid, module_name, list_name,
entries, all_entries, result, timeout):
if not is_full_human(entries, result):
module.exit_json(**result)
if all_entries == None:
result["all_entries_default"] = all_entries
all_entries = True
if vfid is None:
vfid = 128
ret_code, auth, fos_version = login(fos_ip_addr, fos_user_name,
fos_password, https, throttle, result,
timeout)
if ret_code != 0:
module.exit_json(**result)
ret_code, response = list_get(fos_user_name, fos_password, fos_ip_addr,
module_name, list_name, fos_version, https,
auth, vfid, result, ssh_hostkeymust, timeout)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module, timeout)
current_entries = response["Response"][str_to_yang(list_name)]
if not isinstance(current_entries, list):
if current_entries is None:
current_entries = []
else:
current_entries = [current_entries]
to_human_list(module_name, list_name, current_entries, result)
delete_entries = []
for entry in entries:
# check to see if the new entry matches any of the old ones
found = False
for current_entry in current_entries:
if list_entry_keys_matched(entry, current_entry, module_name,
list_name):
found = True
break
if found:
new_entry = {}
for k, v in entry.items():
new_entry[k] = v
delete_entries.append(new_entry)
ret_code = to_fos_list(module_name, list_name, delete_entries, result)
result["add_retcode"] = ret_code
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module, timeout)
result["response"] = response
result["current_entries"] = current_entries
result["delete_entries"] = delete_entries
if len(delete_entries) > 0:
if not module.check_mode:
ret_code = list_delete(fos_user_name, fos_password, fos_ip_addr,
module_name, list_name, fos_version, https,
auth, vfid, result, delete_entries,
ssh_hostkeymust, timeout)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module,
timeout)
result["changed"] = True
logout(fos_ip_addr, https, auth, result, timeout)
module.exit_json(**result)
def main():
"""
Main function
"""
argument_spec = dict(
credential=dict(required=True, type='dict'),
vfid=dict(required=False, type='int'),
throttle=dict(required=False, type='float'),
chassis=dict(required=True, type='dict'))
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True
)
input_params = module.params
# Set up state variables
fos_ip_addr = input_params['credential']['fos_ip_addr']
fos_user_name = input_params['credential']['fos_user_name']
fos_password = input_params['credential']['fos_password']
https = input_params['credential']['https']
throttle = input_params['throttle']
vfid = input_params['vfid']
chassis = input_params['chassis']
result = {"changed": False}
if vfid is None:
vfid = 128
ret_code, auth, fos_version = login(fos_ip_addr,
fos_user_name, fos_password,
https, throttle, result)
if ret_code != 0:
module.exit_json(**result)
ret_code, response = chassis_get(fos_user_name, fos_password, fos_ip_addr,
fos_version, https, auth, vfid, result)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
resp_chassis = response["Response"]["chassis"]
to_human_chassis(resp_chassis)
diff_attributes = generate_diff(result, resp_chassis, chassis)
result["diff_attributes"] = diff_attributes
result["resp_chassis"] = resp_chassis
result["chassis"] = chassis
if len(diff_attributes) > 0:
ret_code = to_fos_chassis(diff_attributes, result)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
if not module.check_mode:
ret_code = chassis_patch(fos_user_name, fos_password, fos_ip_addr,
fos_version, https,
auth, vfid, result, diff_attributes)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
result["changed"] = True
else:
logout(fos_ip_addr, https, auth, result)
module.exit_json(**result)
logout(fos_ip_addr, https, auth, result)
module.exit_json(**result)
def main():
"""
Main function
"""
argument_spec = dict(
credential=dict(required=True, type='dict', no_log=True),
vfid=dict(required=False, type='int'),
throttle=dict(required=False, type='float'),
module_name=dict(required=True, type='str'),
obj_name=dict(required=True, type='str'),
attributes=dict(required=True, type='dict'))
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True
)
input_params = module.params
# Set up state variables
fos_ip_addr = input_params['credential']['fos_ip_addr']
fos_user_name = input_params['credential']['fos_user_name']
fos_password = input_params['credential']['fos_password']
https = input_params['credential']['https']
ssh_hostkeymust = True
if 'ssh_hostkeymust' in input_params['credential']:
ssh_hostkeymust = input_params['credential']['ssh_hostkeymust']
throttle = input_params['throttle']
vfid = input_params['vfid']
module_name = input_params['module_name']
obj_name = input_params['obj_name']
attributes = input_params['attributes']
result = {"changed": False}
if vfid is None:
vfid = 128
ret_code, auth, fos_version = login(fos_ip_addr,
fos_user_name, fos_password,
https, throttle, result)
if ret_code != 0:
module.exit_json(**result)
result['ssh_hostkeymust'] = ssh_hostkeymust
ret_code, response = singleton_get(fos_user_name, fos_password, fos_ip_addr,
module_name, obj_name, fos_version,
https, auth, vfid, result,
ssh_hostkeymust)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
resp_attributes = response["Response"][obj_name]
to_human_singleton(module_name, obj_name, resp_attributes)
diff_attributes = generate_diff(result, resp_attributes, attributes)
# any object specific special processing
if module_name == "brocade-maps" and obj_name == "maps-config":
# relay_ip_address and domain_name needs to be specifid
# at the same time based on FOS REST requirements
if "relay_ip_address" in diff_attributes and "domain_name" not in diff_attributes:
diff_attributes["domain_name"] = resp_attributes["domain_name"]
result["kept the same"] = "domain_name"
elif "relay_ip_address" not in diff_attributes and "domain_name" in diff_attributes:
diff_attributes["relay_ip_address"] = resp_attributes["relay_ip_address"]
result["kept the same"] = "relay_ip_address"
if "relay_ip_address" in diff_attributes and diff_attributes["relay_ip_address"] == None:
result["failed"] = True
result['msg'] = "must specify relay_ip_address if configured empty"
exit_after_login(fos_ip_addr, https, auth, result, module)
elif "domain_name" in diff_attributes and diff_attributes["domain_name"] == None:
result["failed"] = True
result['msg'] = "must specify domain_name if configured empty"
exit_after_login(fos_ip_addr, https, auth, result, module)
result["diff_attributes"] = diff_attributes
result["resp_attributes"] = resp_attributes
result["attributes"] = attributes
if len(diff_attributes) > 0:
ret_code = to_fos_singleton(module_name, obj_name, diff_attributes, result)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
if not module.check_mode:
ret_code = singleton_patch(fos_user_name, fos_password, fos_ip_addr,
module_name, obj_name,
fos_version, https,
auth, vfid, result, diff_attributes,
ssh_hostkeymust)
if ret_code != 0:
exit_after_login(fos_ip_addr, https, auth, result, module)
result["changed"] = True
else:
logout(fos_ip_addr, https, auth, result)
module.exit_json(**result)
logout(fos_ip_addr, https, auth, result)
module.exit_json(**result)