def main():
module = AnsibleModule(
argument_spec={
"hostname": {"required": True, "type": 'str'},
"username": {"required": True, "type": 'str'},
"password": {"required": True, "type": 'str', "no_log": True},
"port": {"type": 'int', "default": 443},
"syslog_servers":
{"type": 'list', "elements": 'dict', "options":
{"id": {"type": 'int', "choices": [1, 2, 3, 4], "required": True},
"enabled": {"type": 'bool'},
"destination_address": {"type": 'str'},
"port_number": {"type": 'int'}
},
"required_one_of": [("enabled", "destination_address", "port_number")],
"required_if": [("enabled", True, ("destination_address",))]
}
},
supports_check_mode=True
)
try:
with RestOME(module.params, req_session=True) as rest_obj:
input_config = validate_input(module)
current_list = get_current_syslog(rest_obj)
payload = compare_get_payload(module, current_list, input_config)
resp = rest_obj.invoke_request("POST", SYSLOG_SET, data=payload, api_timeout=120)
# POST Call taking average 50-60 seconds so api_timeout=120
module.exit_json(msg=SUCCESS_MSG, syslog_details=resp.json_data, changed=True)
except HTTPError as err:
module.fail_json(msg=str(err), error_info=json.load(err))
except URLError as err:
module.exit_json(msg=str(err), unreachable=True)
except (IOError, ValueError, SSLError, TypeError, ConnectionError, AttributeError, IndexError, KeyError) as err:
module.fail_json(msg=str(err))
def main():
module = AnsibleModule(
argument_spec={
"hostname": {
"required": True,
"type": "str"
},
"username": {
"required": True,
"type": "str"
},
"password": {
"required": True,
"type": "str",
"no_log": True
},
"port": {
"required": False,
"type": "int",
"default": 443
},
"webserver_port": {
"required": False,
"type": "int"
},
"webserver_timeout": {
"required": False,
"type": "int"
},
},
required_one_of=[["webserver_port", "webserver_timeout"]],
supports_check_mode=True)
try:
with RestOME(module.params, req_session=False) as rest_obj:
updated_payload, port_change = get_updated_payload(
rest_obj, module)
msg = "Successfully updated network web server configuration."
resp = rest_obj.invoke_request("PUT",
WEBSERVER_CONFIG,
data=updated_payload)
module.exit_json(msg=msg,
webserver_configuration=resp.json_data,
changed=True)
except HTTPError as err:
module.fail_json(msg=str(err), error_info=json.load(err))
except URLError as err:
module.exit_json(msg=str(err), unreachable=True)
except SSLError as err:
if port_change:
module.exit_json(msg="{0} Port has changed to {1}.".format(
msg, port_change),
webserver_configuration=updated_payload,
changed=True)
else:
module.fail_json(msg=str(err))
except (IOError, ValueError, TypeError, ConnectionError,
SSLValidationError) as err:
module.fail_json(msg=str(err))
except Exception as err:
module.fail_json(msg=str(err))
def main():
module = AnsibleModule(
argument_spec={
"hostname": {"required": True, "type": 'str'},
"username": {"required": True, "type": 'str'},
"password": {"required": True, "type": 'str', "no_log": True},
"port": {"required": False, "default": 443, "type": 'int'},
"state": {"required": False, "type": 'str', "default": "present",
"choices": ['present', 'absent']},
"user_id": {"required": False, "type": 'int'},
"name": {"required": False, "type": 'str'},
"attributes": {"required": False, "type": 'dict'},
},
mutually_exclusive=[['user_id', 'name'], ],
required_if=[['state', 'present', ['attributes']], ],
supports_check_mode=False)
try:
_validate_inputs(module)
if module.params.get("attributes") is None:
module.params["attributes"] = {}
with RestOME(module.params, req_session=True) as rest_obj:
method, path, payload = _get_resource_parameters(module, rest_obj)
resp = rest_obj.invoke_request(method, path, data=payload)
if resp.success:
exit_module(module, resp, method)
except HTTPError as err:
fail_module(module, msg=str(err), user_status=json.load(err))
except (URLError, SSLValidationError, ConnectionError, TypeError, ValueError) as err:
fail_module(module, msg=str(err))
def main():
module = AnsibleModule(
argument_spec={
"hostname": {
"required": True,
"type": "str"
},
"username": {
"required": True,
"type": "str"
},
"password": {
"required": True,
"type": "str",
"no_log": True
},
"port": {
"required": False,
"type": "int",
"default": 443
},
"power_state": {
"required": True,
"type": "str",
"choices": ["on", "off", "coldboot", "warmboot", "shutdown"]
},
"device_service_tag": {
"required": False,
"type": "str"
},
"device_id": {
"required": False,
"type": "int"
},
},
required_one_of=[["device_service_tag", "device_id"]],
mutually_exclusive=[["device_service_tag", "device_id"]],
supports_check_mode=True)
try:
if module.params['device_id'] is None and module.params[
'device_service_tag'] is None:
module.fail_json(
msg=
"device_id and device_service_tag attributes should not be None."
)
job_status = {}
with RestOME(module.params, req_session=True) as rest_obj:
payload = get_device_resource(module, rest_obj)
job_status = spawn_update_job(rest_obj, payload)
except HTTPError as err:
module.fail_json(msg=str(err), job_status=json.load(err))
except (URLError, SSLValidationError, ConnectionError, TypeError,
ValueError) as err:
module.fail_json(msg=str(err))
module.exit_json(msg="Power State operation job submitted successfully.",
job_status=job_status,
changed=True)
def main():
module = AnsibleModule(argument_spec={
"hostname": {
"required": True,
"type": "str"
},
"username": {
"required": True,
"type": "str"
},
"password": {
"required": True,
"type": "str",
"no_log": True
},
"port": {
"required": False,
"type": "int",
"default": 443
},
"template_name": {
"required": True,
"type": "str"
},
"identity_pool_name": {
"required": False,
"type": "str"
},
},
supports_check_mode=False)
try:
with RestOME(module.params, req_session=True) as rest_obj:
template_id = get_template_id(rest_obj, module)
identity_id, message = 0, "Successfully detached identity pool from template."
if module.params["identity_pool_name"] is not None:
identity_id = get_identity_id(rest_obj, module)
message = "Successfully attached identity pool to template."
nic_bonding_tech = get_template_vlan_info(rest_obj, template_id)
payload = {
"TemplateId": template_id,
"IdentityPoolId": identity_id,
"BondingTechnology": nic_bonding_tech
}
resp = rest_obj.invoke_request("POST", CONFIG_URI, data=payload)
if resp.status_code == 200:
module.exit_json(msg=message, changed=True)
except HTTPError as err:
module.fail_json(msg=str(err), error_info=json.load(err))
except URLError as err:
module.exit_json(msg=str(err), unreachable=True)
except (ValueError, TypeError, ConnectionError, SSLError,
SSLValidationError) as err:
module.fail_json(msg=str(err))
except Exception as err:
module.fail_json(msg=str(err))
def test_get_device_type(self, mock_response, mocker):
mock_response.success = True
mock_response.status_code = 200
mock_response.json_data = {
"@odata.context":
"/api/$metadata#Collection(DeviceService.DeviceType)",
"@odata.count":
5,
"value": [{
"@odata.type": "#DeviceService.DeviceType",
"DeviceType": 1000,
"Name": "SERVER",
"Description": "Server Device"
}, {
"@odata.type": "#DeviceService.DeviceType",
"DeviceType": 2000,
"Name": "CHASSIS",
"Description": "Chassis Device"
}, {
"@odata.type": "#DeviceService.DeviceType",
"DeviceType": 3000,
"Name": "STORAGE",
"Description": "Storage Device"
}, {
"@odata.type": "#DeviceService.DeviceType",
"DeviceType": 4000,
"Name": "NETWORK_IOM",
"Description": "NETWORK IO Module Device"
}, {
"@odata.type": "#DeviceService.DeviceType",
"DeviceType": 8000,
"Name": "STORAGE_IOM",
"Description": "Storage IOM Device"
}]
}
mocker.patch(MODULE_UTIL_PATH + 'ome.RestOME.invoke_request',
return_value=mock_response)
module_params = {
'hostname': '192.168.0.1',
'username': '******',
'password': '******',
"port": 443
}
with RestOME(module_params, False) as obj:
type_map = obj.get_device_type()
assert type_map == {
1000: "SERVER",
2000: "CHASSIS",
3000: "STORAGE",
4000: "NETWORK_IOM",
8000: "STORAGE_IOM"
}
def main():
module = AnsibleModule(
argument_spec={
"hostname": {"required": True, "type": 'str'},
"username": {"required": True, "type": 'str'},
"password": {"required": True, "type": 'str', "no_log": True},
"port": {"required": False, "default": 443, "type": 'int'},
"state": {"default": "present", "choices": ['present', 'absent']},
"catalog_name": {"type": 'list', "elements": 'str'},
"new_catalog_name": {"type": 'str'},
"catalog_id": {"type": 'list', "elements": 'int'},
"catalog_description": {"required": False, "type": 'str'},
"source": {"required": False, "type": 'str'},
"source_path": {"required": False, "type": 'str'},
"file_name": {"required": False, "type": 'str'},
"repository_type": {"required": False,
"choices": ["NFS", "CIFS", "HTTP", "HTTPS", "DELL_ONLINE"]},
"repository_username": {"required": False, "type": 'str'},
"repository_password": {"required": False, "type": 'str', "no_log": True},
"repository_domain": {"required": False, "type": 'str'},
"check_certificate": {"required": False, "type": 'bool', "default": False},
"job_wait": {"type": 'bool', "default": True},
"job_wait_timeout": {"type": 'int', "default": 600}
},
required_if=[
['state', 'present',
['repository_type'], False],
['state', 'present',
['new_catalog_name', 'catalog_description', 'catalog_name', 'catalog_id', 'source', 'source_path',
'file_name', 'repository_type', 'repository_username', 'repository_password',
'repository_domain', 'check_certificate'], True],
],
mutually_exclusive=[('catalog_name', 'catalog_id')],
required_one_of=[('catalog_name', 'catalog_id')],
supports_check_mode=True)
try:
with RestOME(module.params, req_session=True) as rest_obj:
state = module.params['state']
validate_names(state, module)
requested_catalog_list, all_catalog = check_existing_catalog(module, rest_obj, state)
if state == 'absent':
delete_catalog(module, rest_obj, requested_catalog_list)
else:
perform_present_action(module, rest_obj, requested_catalog_list, all_catalog)
except HTTPError as err:
module.fail_json(msg=str(err), error_info=json.load(err))
except URLError as err:
module.exit_json(msg=str(err), unreachable=True)
except (IOError, ValueError, TypeError, SSLError, ConnectionError, SSLValidationError) as err:
module.fail_json(msg=str(err))
def main():
module = AnsibleModule(argument_spec={
"hostname": {
"required": True,
"type": 'str'
},
"username": {
"required": True,
"type": 'str'
},
"password": {
"required": True,
"type": 'str',
"no_log": True
},
"port": {
"required": False,
"type": 'int',
"default": 443
},
"target_port": {
"required": True,
"type": 'str'
},
"breakout_type": {
"required": True,
"type": 'str'
},
},
supports_check_mode=True)
try:
with RestOME(module.params, req_session=True) as rest_obj:
device_id = get_device_id(module, rest_obj)
breakout_config, breakout_capability, interface_id = get_port_information(
module, rest_obj, device_id)
breakout_status = set_breakout(module, rest_obj, breakout_config,
breakout_capability, interface_id,
device_id)
if breakout_status:
module.exit_json(
msg=
"Port breakout configuration job submitted successfully.",
breakout_status=breakout_status.json_data,
changed=True)
except HTTPError as err:
module.fail_json(msg=str(err), error_info=json.load(err))
except URLError as err:
module.exit_json(msg=str(err), unreachable=True)
except (SSLValidationError, ConnectionError, TypeError, ValueError,
IndexError, SSLError) as err:
module.fail_json(msg=str(err))
def main():
module = AnsibleModule(argument_spec={
"hostname": {
"required": True,
"type": 'str'
},
"username": {
"required": True,
"type": 'str'
},
"password": {
"required": True,
"type": 'str',
"no_log": True
},
"port": {
"required": False,
"type": 'int',
"default": 443
},
"baseline_name": {
"type": 'str',
"required": False
},
},
supports_check_mode=True)
try:
with RestOME(module.params, req_session=False) as rest_obj:
baseline_name = module.params.get("baseline_name")
resp = rest_obj.invoke_request('GET', "UpdateService/Baselines")
data = resp.json_data
if len(data["value"]) == 0:
module.fail_json(
msg="No firmware baseline exists in the system.")
if baseline_name is not None:
data = get_specific_baseline(module, baseline_name, data)
module.exit_json(
msg="Successfully fetched firmware baseline information.",
baseline_info=data)
except HTTPError as err:
if err.getcode() == 404:
module.fail_json(
msg="404 Not Found.The requested resource is not available.")
module.fail_json(msg=str(err), error_info=json.load(err))
except URLError as err:
module.exit_json(msg=str(err), unreachable=True)
except (IOError, ValueError, SSLError, TypeError, ConnectionError) as err:
module.fail_json(msg=str(err))
except Exception as err:
module.fail_json(msg=str(err))
def test_invoke_request_error_case_handling(self, exc, mock_response,
mocker):
open_url_mock = mocker.patch(MODULE_UTIL_PATH + 'ome.open_url',
return_value=mock_response)
open_url_mock.side_effect = exc("test")
module_params = {
'hostname': '192.168.0.1',
'username': '******',
'password': '******',
"port": 443
}
req_session = False
with pytest.raises(exc) as e:
with RestOME(module_params, req_session) as obj:
obj.invoke_request("/testpath", "GET")
def test_invoke_request_without_session(self, mock_response, mocker):
mocker.patch(MODULE_UTIL_PATH + 'ome.open_url',
return_value=mock_response)
module_params = {
'hostname': '192.168.0.1',
'username': '******',
'password': '******',
"port": 443
}
req_session = False
with RestOME(module_params, req_session) as obj:
response = obj.invoke_request("/testpath", "GET")
assert response.status_code == 200
assert response.json_data == {"value": "data"}
assert response.success is True
def test_invoke_request_http_error_handling(self, mock_response, mocker):
open_url_mock = mocker.patch(MODULE_UTIL_PATH + 'ome.open_url',
return_value=mock_response)
open_url_mock.side_effect = HTTPError('http://testhost.com/', 400,
'Bad Request Error', {}, None)
module_params = {
'hostname': '192.168.0.1',
'username': '******',
'password': '******',
"port": 443
}
req_session = False
with pytest.raises(HTTPError) as e:
with RestOME(module_params, req_session) as obj:
obj.invoke_request("/testpath", "GET")
def main():
module = AnsibleModule(
argument_spec={
"hostname": {"required": True, "type": 'str'},
"username": {"required": True, "type": 'str'},
"password": {"required": True, "type": 'str', "no_log": True},
"port": {"required": False, "type": 'int', "default": 443},
"account_id": {"type": 'int', "required": False},
"system_query_options": {"required": False, "type": 'dict', "options": {
"filter": {"type": 'str', "required": False},
}},
},
mutually_exclusive=[
('account_id', 'system_query_options')
],
supports_check_mode=True
)
account_uri = "AccountService/Accounts"
query_param = None
try:
with RestOME(module.params, req_session=True) as rest_obj:
if module.params.get("account_id") is not None:
# Fetch specific account
account_id = module.params.get("account_id")
account_path = "{0}('{1}')".format(account_uri, account_id)
elif module.params.get("system_query_options") is not None:
# Fetch all the user based on UserName
query_param = _get_query_parameters(module.params)
account_path = account_uri
else:
# Fetch all users
account_path = account_uri
resp = rest_obj.invoke_request('GET', account_path, query_param=query_param)
user_facts = resp.json_data
user_exists = True
if "value" in user_facts and len(user_facts["value"]) == 0:
user_exists = False
# check for 200 status as GET only returns this for success
if resp.status_code == 200 and user_exists:
module.exit_json(user_info={module.params["hostname"]: user_facts})
else:
module.fail_json(msg="Unable to retrieve the account details.")
except HTTPError as err:
module.fail_json(msg=json.load(err))
except URLError as err:
module.exit_json(msg=str(err), unreachable=True)
except (SSLValidationError, ConnectionError, TypeError, ValueError) as err:
module.fail_json(msg=str(err))
def main():
module = AnsibleModule(
argument_spec={
"hostname": {"required": True, "type": 'str'},
"username": {"required": True, "type": 'str'},
"password": {"required": True, "type": 'str', "no_log": True},
"port": {"required": False, "default": 443, "type": 'int'},
"id": {"required": False, "type": 'int'},
"name": {"required": False, "type": 'str'}
},
mutually_exclusive=[["id", "name"]],
supports_check_mode=True)
try:
with RestOME(module.params, req_session=True) as rest_obj:
# Form URI to fetch network VLAN information
network_vlan_uri = "{0}({1})".format(NETWORK_VLAN_BASE_URI, module.params.get("id")) if module.params.get(
"id") else "{0}?$top={1}".format(NETWORK_VLAN_BASE_URI, SAFE_MAX_LIMIT)
resp = rest_obj.invoke_request('GET', network_vlan_uri)
if resp.status_code == 200:
network_vlan_info = resp.json_data.get('value') if isinstance(resp.json_data.get('value'), list) else [
resp.json_data]
if module.params.get("name"):
network_vlan_name = module.params.get("name")
network_vlan = []
for item in network_vlan_info:
if item["Name"] == network_vlan_name.strip():
network_vlan = [item]
break
if not network_vlan:
module.fail_json(msg=NETWORK_VLAN_NAME_NOT_FOUND.format(network_vlan_name))
network_vlan_info = network_vlan
# Get network type and Qos Type information
network_type_dict = get_network_type_and_qos_type_information(rest_obj)
# Update each network VLAN with network type and wos type information
for network_vlan in network_vlan_info:
network_vlan = clean_data(network_vlan)
network_vlan['Type'] = network_type_dict[network_vlan['Type']]
module.exit_json(msg=MODULE_SUCCESS_MESSAGE, network_vlan_info=network_vlan_info)
else:
module.fail_json(msg=MODULE_FAILURE_MESSAGE)
except HTTPError as err:
if err.getcode() == 404:
module.fail_json(msg=str(err))
module.fail_json(msg=str(MODULE_FAILURE_MESSAGE), error_info=json.load(err))
except URLError as err:
module.exit_json(msg=str(err), unreachable=True)
except (IOError, ValueError, SSLError, TypeError, KeyError, ConnectionError, SSLValidationError) as err:
module.fail_json(msg=str(err))
def test_get_report_list_error_case(self, mock_response, mocker):
mocker.patch(MODULE_UTIL_PATH + 'ome.open_url',
return_value=mock_response)
invoke_obj = mocker.patch(
MODULE_UTIL_PATH + 'ome.RestOME.invoke_request',
side_effect=HTTPError('http://testhost.com/', 400,
'Bad Request Error', {}, None))
module_params = {
'hostname': '192.168.0.1',
'username': '******',
'password': '******',
"port": 443
}
with pytest.raises(HTTPError) as e:
with RestOME(module_params, False) as obj:
obj.get_all_report_details("DeviceService/Devices")
def main():
module = AnsibleModule(
argument_spec={
"hostname": {
"required": True,
"type": "str"
},
"username": {
"required": True,
"type": "str"
},
"password": {
"required": True,
"type": "str",
"no_log": True
},
"port": {
"required": False,
"default": 443,
"type": "int"
},
"baseline": {
"required": True,
"type": "str"
},
"device_id": {
"required": False,
"type": "int"
},
"device_service_tag": {
"required": False,
"type": "str"
},
},
mutually_exclusive=[["device_id", "device_service_tag"]],
supports_check_mode=True)
try:
with RestOME(module.params, req_session=True) as rest_obj:
report = compliance_report(module, rest_obj)
module.exit_json(compliance_info=report)
except HTTPError as err:
module.fail_json(msg=str(err), error_info=json.load(err))
except URLError as err:
module.exit_json(msg=str(err), unreachable=True)
except (IOError, ValueError, TypeError, SSLError, ConnectionError,
SSLValidationError) as err:
module.fail_json(msg=str(err))
def test_invoke_request_with_session_connection_error(
self, mocker, mock_response):
mock_response.success = False
mock_response.status_code = 500
mock_response.json_data = {}
mocker.patch(MODULE_UTIL_PATH + 'ome.RestOME.invoke_request',
return_value=mock_response)
module_params = {
'hostname': '192.168.0.1',
'username': '******',
'password': '******',
"port": 443
}
req_session = True
with pytest.raises(ConnectionError):
with RestOME(module_params, req_session) as obj:
obj.invoke_request("/testpath", "GET")
def test_get_device_id_from_service_tag_ome_case02(self, mocker,
mock_response):
mock_response.success = True
mock_response.status_code = 200
mock_response.json_data = {"@odata.count": 0, "value": []}
mocker.patch(MODULE_UTIL_PATH + 'ome.RestOME.invoke_request',
return_value=mock_response)
ome_default_args = {
'hostname': '192.168.0.1',
'username': '******',
'password': '******',
"port": 443
}
with RestOME(ome_default_args, True) as obj:
details = obj.get_device_id_from_service_tag("xyz")
assert details["Id"] is None
assert details["value"] == {}
def test_build_url(self, query_param, mocker):
"""builds complete url"""
base_uri = 'https://192.168.0.1:443/api'
path = "AccountService/Accounts"
module_params = {
'hostname': '192.168.0.1',
'username': '******',
'password': '******',
"port": 443
}
mocker.patch(MODULE_UTIL_PATH + 'ome.RestOME._get_base_url',
return_value=base_uri)
inp = query_param["inp"]
out = query_param["out"]
url = RestOME(module_params=module_params)._build_url(path,
query_param=inp)
assert url == base_uri + "/" + path + "?" + out
assert "+" not in url
def test_get_all_items_with_pagination(self, mock_response, mocker):
mock_response.success = True
mock_response.status_code = 200
mock_response.json_data = {
"@odata.count": 50,
"value": list(range(51))
}
mocker.patch(MODULE_UTIL_PATH + 'ome.RestOME.invoke_request',
return_value=mock_response)
module_params = {
'hostname': '192.168.0.1',
'username': '******',
'password': '******',
"port": 443
}
with RestOME(module_params, True) as obj:
reports = obj.get_all_items_with_pagination(
"DeviceService/Devices")
assert reports == {"total_count": 50, "value": list(range(51))}
def main():
snmp_options = {"enabled": {"type": "bool", "required": True},
"port_number": {"type": "int", "required": False},
"community_name": {"type": "str", "required": False}}
ssh_options = {"enabled": {"type": "bool", "required": True},
"port_number": {"type": "int", "required": False},
"max_sessions": {"type": "int", "required": False},
"max_auth_retries": {"type": "int", "required": False},
"idle_timeout": {"type": "float", "required": False}}
racadm_options = {"enabled": {"type": "bool", "required": True}}
module = AnsibleModule(
argument_spec={
"hostname": {"required": True, "type": "str"},
"username": {"required": True, "type": "str"},
"password": {"required": True, "type": "str", "no_log": True},
"port": {"required": False, "type": "int", "default": 443},
"device_id": {"required": False, "type": "int"},
"device_service_tag": {"required": False, "type": "str"},
"snmp_settings": {"type": "dict", "required": False, "options": snmp_options,
"required_if": [["enabled", True, ("community_name",)]]},
"ssh_settings": {"type": "dict", "required": False, "options": ssh_options},
"remote_racadm_settings": {"type": "dict", "required": False, "options": racadm_options},
},
mutually_exclusive=[('device_id', 'device_service_tag')],
required_one_of=[["snmp_settings", "ssh_settings", "remote_racadm_settings"]],
supports_check_mode=True,
)
if not any([module.params.get("snmp_settings"), module.params.get("ssh_settings"),
module.params.get("remote_racadm_settings")]):
module.fail_json(msg=CONFIG_FAIL_MSG)
try:
with RestOME(module.params, req_session=True) as rest_obj:
check_domain_service(module, rest_obj)
resp = fetch_device_details(module, rest_obj)
resp_data = resp.json_data
resp_data["SshConfiguration"]["IdleTimeout"] = resp_data["SshConfiguration"]["IdleTimeout"] / 60
module.exit_json(msg=SUCCESS_MSG, network_services_details=resp_data, changed=True)
except HTTPError as err:
module.fail_json(msg=str(err), error_info=json.load(err))
except URLError as err:
module.exit_json(msg=str(err), unreachable=True)
except (IOError, ValueError, SSLError, TypeError, ConnectionError, AttributeError, IndexError, KeyError) as err:
module.fail_json(msg=str(err))
def main():
power_options = {"enable_power_cap": {"type": "bool", "required": True},
"power_cap": {"type": "int", "required": False}}
redundancy_options = {"redundancy_policy": {"type": "str", "default": "NO_REDUNDANCY",
"choices": ["NO_REDUNDANCY", "GRID_REDUNDANCY", "PSU_REDUNDANCY"]}}
hot_spare_options = {"enable_hot_spare": {"required": True, "type": "bool"},
"primary_grid": {"required": False, "type": "str", "default": "GRID_1",
"choices": ["GRID_1", "GRID_2"]}}
module = AnsibleModule(
argument_spec={
"hostname": {"required": True, "type": "str"},
"username": {"required": True, "type": "str"},
"password": {"required": True, "type": "str", "no_log": True},
"port": {"required": False, "type": "int", "default": 443},
"device_id": {"required": False, "type": "int"},
"device_service_tag": {"required": False, "type": "str"},
"power_configuration": {"type": "dict", "required": False, "options": power_options,
"required_if": [["enable_power_cap", True, ("power_cap",), True]]},
"redundancy_configuration": {"type": "dict", "required": False, "options": redundancy_options},
"hot_spare_configuration": {"type": "dict", "required": False, "options": hot_spare_options,
"required_if": [["enable_hot_spare", True, ("primary_grid",)]]},
},
mutually_exclusive=[('device_id', 'device_service_tag')],
required_one_of=[["power_configuration", "redundancy_configuration", "hot_spare_configuration"]],
supports_check_mode=True,
)
try:
if not any([module.params.get("power_configuration"), module.params.get("redundancy_configuration"),
module.params.get("hot_spare_configuration")]):
module.fail_json(msg=CONFIG_FAIL_MSG)
with RestOME(module.params, req_session=True) as rest_obj:
check_domain_service(module, rest_obj)
resp = fetch_device_details(module, rest_obj)
module.exit_json(msg=SUCCESS_MSG, power_details=resp.json_data, changed=True)
except HTTPError as err:
module.fail_json(msg=str(err), error_info=json.load(err))
except URLError as err:
module.exit_json(msg=str(err), unreachable=True)
except (IOError, ValueError, SSLError, TypeError, ConnectionError, AttributeError, IndexError, KeyError) as err:
module.fail_json(msg=str(err))
def main():
module = AnsibleModule(
argument_spec={
"hostname": {"required": True, "type": 'str'},
"username": {"required": True, "type": 'str'},
"password": {"required": True, "type": 'str', "no_log": True},
"port": {"required": False, "default": 443, "type": 'int'},
# "state": {"required": False, "default": "present",
# "choices": ['present', 'absent']},
"baseline_name": {"required": True, "type": 'str'},
"baseline_description": {"required": False, "type": 'str'},
"catalog_name": {"required": False, "type": 'str'},
"downgrade_enabled": {"required": False, "type": 'bool', "default": True},
"is_64_bit": {"required": False, "type": 'bool', "default": True},
"device_ids": {"required": False, "type": 'list', "elements": 'int'},
"device_service_tags": {"required": False, "type": 'list', "elements": 'str'},
"device_group_names": {"required": False, "type": 'list', "elements": 'str'},
},
mutually_exclusive=[
('device_ids', 'device_service_tags', 'device_group_names')
],
# required_if=[['state', 'present', ['device_id', 'device_service_tags', 'group_name']]],
supports_check_mode=False)
try:
with RestOME(module.params, req_session=True) as rest_obj:
myparams = module.params
if not any([myparams.get("device_ids"), myparams.get("device_service_tags"),
myparams.get("device_group_names")]):
module.fail_json(msg="No Targets Specified for baseline creation")
payload = _get_baseline_payload(module, rest_obj)
resp = rest_obj.invoke_request("POST", "UpdateService/Baselines", data=payload)
if resp.success:
module.exit_json(changed=True, msg="Successfully created task for creating Baseline",
baseline_status=resp.json_data)
except HTTPError as err:
module.fail_json(msg=str(err), error_info=json.load(err))
except (URLError, SSLValidationError, SSLError, ConnectionError, TypeError, ValueError, KeyError) as err:
module.fail_json(msg=str(err))
module.fail_json(msg="Failed to perform baseline operation, no response received from host")
def main():
module = AnsibleModule(
argument_spec={
"hostname": {"required": True, "type": 'str'},
"username": {"required": True, "type": 'str'},
"password": {"required": True, "type": 'str', "no_log": True},
"port": {"required": False, "default": 443, "type": 'int'},
"command": {"required": False, "default": "create", "aliases": ['state'],
"choices": ['create', 'modify', 'deploy', 'delete', 'export', 'import', 'clone']},
"template_id": {"required": False, "type": 'int'},
"template_name": {"required": False, "type": 'str'},
"template_view_type": {"required": False, "default": 'Deployment',
"choices": ['Deployment', 'Compliance', 'Inventory', 'Sample', 'None']},
"device_id": {"required": False, "type": 'list', "default": [], "elements": 'int'},
"device_service_tag": {"required": False, "type": 'list', "default": [], "elements": 'str'},
"attributes": {"required": False, "type": 'dict'},
},
required_if=[
['command', 'create', ['attributes']],
['command', 'modify', ['attributes']],
['command', 'import', ['attributes']],
['command', 'clone', ['attributes']]
],
mutually_exclusive=[["template_id", "template_name"]],
supports_check_mode=False)
try:
_validate_inputs(module)
with RestOME(module.params, req_session=True) as rest_obj:
path, payload, rest_method = _get_resource_parameters(module, rest_obj)
resp = rest_obj.invoke_request(rest_method, path, data=payload)
if resp.success:
exit_module(module, resp)
except HTTPError as err:
fail_module(module, msg=str(err), error_info=json.load(err))
except URLError as err:
password_no_log(module.params.get("attributes"))
module.exit_json(msg=str(err), unreachable=True)
except (SSLValidationError, ConnectionError, TypeError, ValueError, KeyError) as err:
fail_module(module, msg=str(err))
def test_get_job_type_id_null_case(self, mock_response, mocker):
mock_response.success = True
mock_response.status_code = 200
mock_response.json_data = {
"@odata.count": 50,
"value": [{
"Name": "PowerChange",
"Id": 11
}]
}
mocker.patch(MODULE_UTIL_PATH + 'ome.RestOME.invoke_request',
return_value=mock_response)
jobtype_name = "FirmwareUpdate"
module_params = {
'hostname': '192.168.0.1',
'username': '******',
'password': '******',
"port": 443
}
with RestOME(module_params, True) as obj:
job_id = obj.get_job_type_id(jobtype_name)
assert job_id is None
def main():
credentials_options = {"username": {"type": "str", "required": True},
"password": {"type": "str", "required": True, "no_log": True}}
module = AnsibleModule(
argument_spec={
"hostname": {"required": True, "type": "str"},
"username": {"required": True, "type": "str"},
"password": {"required": True, "type": "str", "no_log": True},
"port": {"required": False, "type": "int", "default": 443},
"destination_address": {"required": True, "type": "str"},
"port_number": {"required": False, "type": "int"},
"use_ssl": {"required": False, "type": "bool"},
"enable_authentication": {"required": True, "type": "bool"},
"credentials":
{"required": False, "type": "dict",
"options": credentials_options,
},
},
required_if=[['enable_authentication', True, ['credentials']], ],
supports_check_mode=True
)
try:
with RestOME(module.params, req_session=True) as rest_obj:
curr_resp = fetch_smtp_settings(rest_obj)
payload = update_payload(module, curr_resp)
diff = _diff_payload(curr_resp, payload)
process_check_mode(module, diff)
resp = update_smtp_settings(rest_obj, payload)
exit_module(module, msg=SUCCESS_MSG,
smtp_details=resp.json_data, changed=True)
except HTTPError as err:
fail_module(module, msg=str(err), error_info=json.load(err))
except URLError as err:
exit_module(module, msg=str(err), unreachable=True)
except (IOError, ValueError, SSLError, TypeError, ConnectionError, AttributeError, IndexError, KeyError) as err:
fail_module(module, msg=str(err), error_info=json.load(err))
def main():
design_choices = ['2xMX5108n_Ethernet_Switches_in_same_chassis',
'2xMX9116n_Fabric_Switching_Engines_in_same_chassis',
'2xMX9116n_Fabric_Switching_Engines_in_different_chassis'
]
module = AnsibleModule(
argument_spec={
"hostname": {"required": True, "type": "str"},
"username": {"required": True, "type": "str"},
"password": {"required": True, "type": "str", "no_log": True},
"port": {"required": False, "type": "int", "default": 443},
"state": {"type": "str", "required": False, "default": "present", "choices": ['present', 'absent']},
"name": {"required": True, "type": "str"},
"new_name": {"required": False, "type": "str"},
"description": {"required": False, "type": "str"},
"fabric_design": {"required": False, "type": "str",
"choices": design_choices},
"primary_switch_service_tag": {"required": False, "type": "str"},
"secondary_switch_service_tag": {"required": False, "type": "str"},
"override_LLDP_configuration": {"required": False, "type": "str", "choices": ['Enabled', 'Disabled']},
},
required_if=[['state', 'present', ('new_name', 'description', 'fabric_design', 'primary_switch_service_tag',
'secondary_switch_service_tag', 'override_LLDP_configuration',), True]],
supports_check_mode=True
)
try:
with RestOME(module.params, req_session=True) as rest_obj:
fabric_actions(rest_obj, module)
except HTTPError as err:
if err.code == 501:
module.fail_json(msg=SYSTEM_NOT_SUPPORTED_ERROR_MSG, error_info=json.load(err))
module.fail_json(msg=str(err), error_info=json.load(err))
except URLError as err:
module.exit_json(msg=str(err), unreachable=True)
except (IOError, ValueError, TypeError, SSLError, ConnectionError, SSLValidationError) as err:
module.fail_json(msg=str(err))
def main():
module = AnsibleModule(argument_spec={
"hostname": {
"required": True,
"type": 'str'
},
"username": {
"required": True,
"type": 'str'
},
"password": {
"required": True,
"type": 'str',
"no_log": True
},
"port": {
"required": False,
"default": 443,
"type": 'int'
},
"state": {
"required": False,
"type": 'str',
"default": "present",
"choices": ['present', 'absent']
},
"group_name": {
"required": True,
"type": 'str'
},
"role": {
"required": False,
"type": 'str'
},
"directory_name": {
"required": False,
"type": 'str'
},
"directory_id": {
"required": False,
"type": 'int'
},
"domain_username": {
"required": False,
"type": 'str'
},
"domain_password": {
"required": False,
"type": 'str',
"no_log": True
},
},
mutually_exclusive=[
['directory_name', 'directory_id'],
],
supports_check_mode=True)
try:
with RestOME(module.params, req_session=True) as rest_obj:
if module.params["state"] == "present":
resp, msg = directory_user(module, rest_obj)
if isinstance(resp, list):
resp = resp[0]
module.exit_json(
msg="Successfully {0} the active directory user group.".
format(msg),
domain_user_status=resp,
changed=True)
if module.params["state"] == "absent":
user = get_directory_user(module, rest_obj)
msg, changed = delete_directory_user(rest_obj, int(user["Id"]))
user = rest_obj.strip_substr_dict(user)
module.exit_json(msg=msg,
changed=changed,
domain_user_status=user)
except HTTPError as err:
module.fail_json(msg=str(err), error_info=json.load(err))
except URLError as err:
module.exit_json(msg=str(err), unreachable=True)
except (IOError, ValueError, TypeError, SSLError, ConnectionError,
SSLValidationError) as err:
module.fail_json(msg=str(err))
def main():
module = AnsibleModule(
argument_spec={
"hostname": {
"required": True,
"type": 'str'
},
"username": {
"required": True,
"type": 'str'
},
"password": {
"required": True,
"type": 'str',
"no_log": True
},
"port": {
"required": False,
"default": 443,
"type": 'int'
},
"command": {
"default": "create",
"choices": ['create', 'modify', 'delete', 'remediate']
},
"names": {
"required": True,
"type": 'list',
"elements": 'str'
},
"template_name": {
"type": 'str'
},
"template_id": {
"type": 'int'
},
"device_ids": {
"required": False,
"type": 'list',
"elements": 'int'
},
"device_service_tags": {
"required": False,
"type": 'list',
"elements": 'str'
},
"device_group_names": {
"required": False,
"type": 'list',
"elements": 'str'
},
"description": {
"type": 'str'
},
"job_wait": {
"required": False,
"type": 'bool',
"default": True
},
"job_wait_timeout": {
"required": False,
"type": 'int',
"default": 10800
},
"new_name": {
"type": 'str'
},
},
required_if=[
['command', 'create', ['template_name', 'template_id'], True],
[
'command', 'remediate',
[
'device_ids', 'device_service_tags', 'job_wait',
'job_wait_timeout'
], True
],
[
'command', 'modify',
[
'new_name', 'description', 'template_name', 'template_id',
'device_ids', 'device_service_tags', 'device_group_names'
], True
],
],
mutually_exclusive=[('device_ids', 'device_service_tags'),
('device_ids', 'device_group_names'),
('device_service_tags', 'device_group_names'),
('template_id', 'template_name')],
supports_check_mode=True)
try:
with RestOME(module.params, req_session=True) as rest_obj:
compliance_operation(module, rest_obj)
except HTTPError as err:
module.fail_json(msg=str(err), error_info=json.load(err))
except URLError as err:
module.exit_json(msg=str(err), unreachable=True)
except (IOError, ValueError, TypeError, SSLError, ConnectionError,
SSLValidationError) as err:
module.fail_json(msg=str(err))
def main():
module = AnsibleModule(
argument_spec={
"hostname": {
"required": True,
"type": "str"
},
"username": {
"required": True,
"type": "str"
},
"password": {
"required": True,
"type": "str",
"no_log": True
},
"port": {
"required": False,
"type": "int",
"default": 443
},
"device_ids": {
"required": False,
"type": "list",
"elements": "int"
},
"device_service_tags": {
"required": False,
"type": "list",
"elements": "str"
},
"device_group_name": {
"required": False,
"type": "str"
},
"log_type": {
"required": False,
"type": "str",
"default": "support_assist_collection",
"choices": ["support_assist_collection", "application"]
},
"mask_sensitive_info": {
"required": False,
"type": "bool",
"default": False
},
"log_selectors": {
"required": False,
"type": "list",
"choices": ["RAID_LOGS", "OS_LOGS"],
"elements": "str"
},
"share_address": {
"required": True,
"type": "str"
},
"share_name": {
"required": True,
"type": "str"
},
"share_type": {
"required": True,
"type": "str",
"choices": ["NFS", "CIFS"]
},
"share_user": {
"required": False,
"type": "str"
},
"share_password": {
"required": False,
"type": "str",
"no_log": True
},
"share_domain": {
"required": False,
"type": "str"
},
"job_wait": {
"required": False,
"type": "bool",
"default": True
},
"job_wait_timeout": {
"required": False,
"type": "int",
"default": 60
},
"test_connection": {
"required": False,
"type": "bool",
"default": False
},
},
required_if=[['log_type', 'application', ['mask_sensitive_info']],
[
'log_type', 'support_assist_collection',
[
'device_ids', 'device_service_tags',
'device_group_name'
], True
],
['share_type', 'CIFS', ['share_user', 'share_password']]],
mutually_exclusive=[('device_ids', 'device_service_tags',
'device_group_name')],
supports_check_mode=True)
try:
with RestOME(module.params, req_session=True) as rest_obj:
# checking the domain service
if module.params["log_type"] == "application":
check_domain_service(module, rest_obj)
# checking any existing running job
job_allowed, job_lst = rest_obj.check_existing_job_state(
"DebugLogs_Task")
if not job_allowed:
module.fail_json(
msg=
"An export log job is already running. Wait for the job to finish."
)
# test network connection
if module.params["test_connection"]:
conn_resp = rest_obj.test_network_connection(
module.params["share_address"],
module.params["share_name"], module.params["share_type"],
module.params["share_user"],
module.params["share_password"],
module.params["share_domain"])
job_failed, job_message = rest_obj.job_tracking(
conn_resp.json_data["Id"], job_wait_sec=5, sleep_time=5)
if job_failed:
module.fail_json(
msg=
"Unable to access the share. Ensure that the share address, share name, "
"share domain, and share credentials provided are correct."
)
# validation for device id/tag/group
valid_device = []
if module.params["log_type"] == "support_assist_collection" and \
module.params.get("device_group_name") is not None:
valid_device = group_validation(module, rest_obj)
elif module.params["log_type"] == "support_assist_collection" and \
module.params.get("device_group_name") is None:
valid_device = device_validation(module, rest_obj)
# extract log job operation
response = extract_log_operation(module,
rest_obj,
device_lst=valid_device)
message = "Export log job submitted successfully."
if module.params["job_wait"]:
seconds = module.params["job_wait_timeout"] * 60
job_failed, job_message = rest_obj.job_tracking(
response.json_data["Id"],
job_wait_sec=seconds,
sleep_time=5)
message = "Export log job completed successfully."
if job_message == "The job is not complete after {0} seconds.".format(
seconds):
module.fail_json(
msg=
"The export job is not complete because it has exceeded the configured timeout period.",
job_status=response.json_data)
if job_failed:
message, failed_job = find_failed_jobs(
response.json_data, rest_obj)
if failed_job:
module.fail_json(msg=message,
job_status=response.json_data)
response = rest_obj.invoke_request(
"GET", "{0}({1})".format(JOB_URI,
response.json_data["Id"]))
resp = response.json_data
if resp:
resp = rest_obj.strip_substr_dict(resp)
module.exit_json(msg=message, job_status=resp)
except HTTPError as err:
module.fail_json(msg=str(err), error_info=json.load(err))
except URLError as err:
module.exit_json(msg=str(err), unreachable=True)
except (IOError, ValueError, TypeError, SSLError, ConnectionError,
SSLValidationError) as err:
module.fail_json(msg=str(err))