def run(self, args):
init_args(args, self.args_lst)
config_dict = self.check_args(args)
client = RedfishClient(args)
systems_id = client.get_systems_id()
url = "/redfish/v1/Systems/%s/Bios" % systems_id
resp = client.send_request("GET", url)
if (isinstance(resp, dict)
and resp.get("status_code") in Constant.SUC_CODE):
attrs = resp["resource"]["Attributes"]
for key_, value_ in config_dict.items():
if attrs.get(key_, None) is not None:
if isinstance(attrs.get(key_, None), int):
try:
config_dict[key_] = int(value_)
except (KeyError, ValueError) as err:
self.err_list.append(str(err))
raise FailException(*self.err_list)
else:
err_message = ("Failure: the BIOS setting item does "
"not exist: %s" % key_)
self.err_list.append(err_message)
raise FailException(*self.err_list)
self.result_response(client, url, config_dict)
else:
err_message = ("Failure: failed to get current BIOS setup "
"information")
self.err_list.append(err_message)
raise FailException(*self.err_list)
return self.suc_list
def run(self, args):
init_args(args, self.args_lst)
client = RestfulClient(args)
try:
ad_config_url = "/api/settings/active_directory_settings"
resp = client.send_request("GET", ad_config_url)
if isinstance(resp, dict) or Constant.SUCCESS_0 == resp.get(
"cc", None):
if 0 == resp.get("enable", None):
self.err_list.append(
"Failure: ad disable, can not add ad user")
raise FailException(*self.err_list)
else:
self.err_list.append("Failure: failed to add ad user")
raise FailException(*self.err_list)
payload = self._construct_param(args)
add_url = "/api/settings/active_directory_users"
resp = client.send_request("POST", add_url, payload)
if (isinstance(resp, dict) and Constant.SUCCESS_0 == resp.get(
"cc", None) or resp.get("role_group_name", None)):
self.suc_list.append("Success: add ad user successfully")
else:
self.err_list.append("Failure: Failed to add ad user")
raise FailException(*self.err_list)
finally:
if client.cookie:
client.delete_session()
return self.suc_list
def run(self, args):
init_args(args, self.args_lst)
if args.dev is None and args.effective is None and args.mode is None:
self.err_list.append("Argument: need at least one parameter")
raise FailException(*self.err_list)
restful = RestfulClient(args)
try:
url = "/api/config/boot"
resp = restful.send_request("GET", url)
if isinstance(resp, dict) and Constant.SUCCESS_0 == resp.get(
"cc", None):
payload = self._construct_param(args, resp)
resp = restful.send_request("POST", url, payload)
if isinstance(resp, dict) or Constant.SUCCESS_0 == resp.get(
"cc", None):
self.suc_list.append(
"Success: set system startup item successfully")
else:
self.err_list.append(
"Failure: failed to set system startup item")
raise FailException(*self.err_list)
else:
self.err_list.append(
"Failure: failed to get system startup item")
raise FailException(*self.err_list)
finally:
if restful.cookie:
restful.delete_session()
return self.suc_list
def run(self, args):
init_args(args, self.args_lst)
client = RestfulClient(args)
try:
url = "/api/settings/users"
resp = client.send_request("GET", url)
if isinstance(resp, list):
for user in resp:
if user.get("name", None) == args.name:
user_id = user.get("id", None)
url = "/api/settings/users/%s" % user_id
resp = client.send_request("DELETE", url)
if (isinstance(resp, dict) and Constant.SUCCESS_0
== resp.get("cc", None)):
suc = "Success: delete user successfully"
self.suc_list.append(suc)
else:
err = "Failure: failed to delete user"
self.err_list.append(err)
raise FailException(*self.err_list)
break
else:
err = "Failure: this user does not exist: %s" % args.name
self.err_list.append(err)
raise FailException(*self.err_list)
else:
self.err_list.append("Failure: failed to get user list")
raise FailException(*self.err_list)
finally:
if client.cookie:
client.delete_session()
return self.suc_list
def run(self, args):
init_args(args, self.args_lst)
if args.count is not None and args.count <= 0:
err_info = ("Argument: invalid choice: %s (the value is a "
"positive integer)") % args.count
self.err_list.append(err_info)
raise FailException(*self.err_list)
client = RestfulClient(args)
try:
url = "/api/health/hdm_log"
resp = client.send_request("get", url)
if isinstance(resp, list):
count = len(resp)
if args.count and args.count < count:
count = args.count
self.hdm_log = get_log_resource(resp, count)
else:
err_info = "Failure: get hdm log failed"
self.err_list.append(err_info)
raise FailException(*self.err_list)
finally:
if client.cookie:
client.delete_session()
return self.suc_list
def run(self, args):
init_args(args, self.args_lst)
is_adapt_b01 = globalvar.IS_ADAPT_B01
if is_adapt_b01:
client = RestfulClient(args)
physical_disk_list = self._get_b01_physical_disk_list(client)
if not physical_disk_list:
suc_info = "Success: raid card resource is empty"
self.suc_list.append(suc_info)
return self.suc_list
else:
client = RedfishClient(args)
physical_disk_list = self._get_physical_disk_list(client)
if args.physical_id is None and not physical_disk_list:
suc_info = "Success: raid card resource is empty"
self.suc_list.append(suc_info)
return self.suc_list
if not self._get_physical_disk_detail(client, physical_disk_list,
args):
err_info = "Failure: resource was not found"
self.err_list.append(err_info)
raise FailException(*self.err_list)
client = RestfulClient(args)
try:
self._get_health_info(client)
finally:
if client.cookie:
client.delete_session()
return self.suc_list
def run(self, args):
init_args(args, self.args_lst)
url = "/api/chassis-status"
client = RestfulClient(args)
try:
resp = client.send_request("GET", url)
if (isinstance(resp, dict) and resp.get("cc", None) ==
Constant.SUCCESS_0):
payload = self.construct_request_parameters(resp, args)
url = "/api/actions/power"
sec_resp = client.send_request("POST", url, payload)
if (isinstance(sec_resp, dict) and sec_resp.get("cc", None) ==
Constant.SUCCESS_0):
operator_suc = ("Success: power control request "
"succeeded: %s" %
args.command_type)
self.suc_list.append(operator_suc)
else:
err_info = "Failure: system power control failed"
self.err_list.append(err_info)
raise FailException(*self.err_list)
else:
err_info = "Failure: failed to get current system power status"
self.err_list.append(err_info)
raise FailException(*self.err_list)
finally:
if client.cookie:
client.delete_session()
return self.suc_list
def run(self, args):
init_args(args, self.args_lst)
self._parse_args(args)
client = RestfulClient(args)
try:
url = "/api/settings/ldap-settings"
resp = client.send_request("GET", url)
if not isinstance(
resp, dict) or Constant.SUCCESS_0 != resp.get("cc", None):
self.err_list.append("Failure: failed to set ldap")
raise FailException(*self.err_list)
self._construct_param(resp)
resp = client.send_request("PUT", url, resp)
if isinstance(resp, dict) and Constant.SUCCESS_0 == resp.get(
"cc", None):
self.suc_list.append("Success: set ldap successfully")
else:
self.err_list.append("Failure: failed to set ldap")
raise FailException(*self.err_list)
finally:
if client.cookie:
client.delete_session()
return self.suc_list
def run(self, args):
init_args(args, self.args_lst)
url = "/redfish/v1/AccountService/Roles"
client = RedfishClient(args)
resp = client.send_request("GET", url)
if (not isinstance(resp, dict)
or Constant.SUCCESS_200 != resp.get("status_code", None)):
self.err_list.append("Failure: get role information failed")
raise FailException(*self.err_list)
role_url_list = list()
if args.role is None:
members = resp["resource"].get("Members", None)
if members and isinstance(members, list):
for member in members:
role_url_list.append(member.get("@odata.id", None))
else:
url = "%s/%s" % (url, args.role)
role_url_list.append(url)
role_list = list()
for role_url in role_url_list:
role_resp = client.send_request("GET", role_url)
if (isinstance(role_resp, dict)
and Constant.SUCCESS_200 == role_resp.get(
"status_code", None)):
role = Role()
role.pack_role_resource(role_resp["resource"])
role_list.append(role)
else:
self.err_list.append("Failure: get role information failed")
raise FailException(*self.err_list)
self.roles = role_list
return self.suc_list
def run(self, args):
init_args(args, self.args_lst)
is_adapt_b01 = globalvar.IS_ADAPT_B01
if is_adapt_b01:
client = RestfulClient(args)
try:
url = "/api/settings/users"
resp = client.send_request("GET", url)
user_id = None
if isinstance(resp, list):
for info in resp:
if info.get("name") == "":
user_id = info.get("id")
break
if user_id is not None:
self._parse_b01_args(args)
payload = self._construct_b01_param()
payload["id"] = user_id
url = "/api/settings/users/" + str(user_id)
resp = client.send_request("PUT", url, payload)
if isinstance(resp, dict) and\
resp.get("cc") == Constant.SUCCESS_0:
suc = "Success: add user successfully"
self.suc_list.append(suc)
else:
err = "Failure: failed to add user"
self.err_list.append(err)
raise FailException(*self.err_list)
else:
err = "Failure: the number of user is up to the limit!"
self.err_list.append(err)
raise FailException(*self.err_list)
finally:
if client.cookie:
client.delete_session()
else:
self._parse_args(args)
payload = self._construct_param()
url = "/redfish/v1/AccountService/Accounts"
client = RedfishClient(args)
resp = client.send_request("POST", url, payload)
if (isinstance(resp, dict) and
resp.get("status_code", None) in Constant.SUC_CODE):
suc = "Success: add user successfully"
self.suc_list.append(suc)
else:
err = "Failure: failed to add user"
self.err_list.append(err)
raise FailException(*self.err_list)
return self.suc_list
def run(self, args):
init_args(args, self.args_lst)
client = RestfulClient(args)
try:
self._get_ctrl(client, args)
finally:
if client.cookie:
client.delete_session()
return self.suc_list
def run(self, args):
init_args(args, self.args_lst)
client = RedfishClient(args)
systems_id = client.get_systems_id()
url = "/redfish/v1/Chassis/%s/Power" % systems_id
resp = client.send_request("get", url)
if (isinstance(resp, dict)
and resp.get("status_code", None) == Constant.SUCCESS_200):
if resp["resource"].get("PowerControl", None) is not None:
try:
power_metrics = (resp["resource"]["PowerControl"][0].get(
"PowerMetrics", None))
power_limit = (resp["resource"]["PowerControl"][0].get(
"PowerLimit", None))
except (TypeError, ValueError, KeyError, SyntaxError) as err:
self.err_list.append(str(err))
raise FailException(*self.err_list)
else:
max_value = power_metrics.get("MaxConsumedWatts")
min_value = power_metrics.get("MinConsumedWatts")
exception = power_limit.get("LimitException")
limit_in_watts = power_limit.get('LimitInWatts')
payload = self.construct_request_parameters(
args, max_value, min_value, limit_in_watts, exception)
client = RestfulClient(args)
try:
url = "/api/power/capping"
resp = client.send_request("POST", url, payload)
if (isinstance(resp, dict) and resp.get(
Constant.COMPLETE_CODE) == Constant.SUCCESS_0):
suc_info = "Success: set power limit succeed"
self.suc_list.append(suc_info)
else:
err_info = "Failure: set power limit failed"
self.err_list.append(err_info)
raise FailException(*self.err_list)
finally:
if client.cookie:
client.delete_session()
else:
err_info = ("Failure: the machine does not "
"support setting power cap")
self.err_list.append(err_info)
raise FailException(*self.err_list)
else:
err_info = "Failure: failed to get the value range of the power cap"
self.err_list.append(err_info)
raise FailException(*self.err_list)
return self.suc_list
def run(self, args):
init_args(args, self.args_lst)
config_type = args.config_type
config_file = args.file_uri
try:
with open(config_file, "w"):
pass
except IOError as err:
self.err_list.append(str(err))
raise FailException(*self.err_list)
else:
os.remove(config_file)
client = RestfulClient(args)
url = "/api/maintenance/%s" % URL_DICT[config_type]
try:
resp = client.send_request("GET", url)
if resp and isinstance(resp, dict):
if not (resp.get(Constant.COMPLETE_CODE)
or resp.get(Constant.COMPLETE_ERROR)):
with open(config_file, "w") as file_output:
file_output.write(
json.dumps(resp, indent=4, separators=(",", ": ")))
suc_info = ("Success: export %s configuration "
"is successful" % config_type)
self.suc_list.append(suc_info)
else:
err_info = (
"Failure: export %s config file failed, "
"reason: %s" %
(config_type, resp.get(Constant.COMPLETE_ERROR)))
self.err_list.append(err_info)
else:
err_info = ("Failure: export %s config file failed, reason: "
"Response can not parse" % config_type)
self.err_list.append(err_info)
except (IOError, Exception) as err:
self.err_list.append((str(err)))
raise FailException(*self.err_list)
else:
if self.err_list:
raise FailException(*self.err_list)
finally:
if client.cookie:
client.delete_session()
return self.suc_list
def run(self, args):
init_args(args, self.args_lst)
config_file = args.file_uri
if not os.path.exists(config_file):
err_info = ("Failure: upload config file failed, "
"reason: File Not Exist")
self.err_list.append(err_info)
raise FailException(*self.err_list)
config_type = args.config_type
url = "/api/maintenance/%s" % URL_DICT[config_type]
try:
with open(config_file, "rb") as config_file_data:
file_read = config_file_data.read()
except (TypeError, ValueError, KeyError, IOError, Exception) as err:
self.err_list.append(str(err))
raise FailException(*self.err_list)
else:
_, file_name = os.path.split(config_file)
fields = {
"config": (file_name, file_read, "application/octet-stream")
}
client = RestfulClient(args)
try:
resp = client.upload_request("POST", url, fields=fields)
if (isinstance(resp, dict) and resp.get(Constant.COMPLETE_CODE)
== Constant.SUCCESS_0):
self.get_process(client, config_type)
elif (isinstance(resp, dict)
and resp.get(Constant.COMPLETE_CODE) != Constant.SUCCESS_0):
err_info = (
"Failure: import %s config file failed, reason: %s" %
(config_type, resp.get(Constant.COMPLETE_CODE)))
self.err_list.append(err_info)
else:
err_info = ("Failure: import %s config file failed, "
"reason: Response can not parse" % config_type)
self.err_list.append(err_info)
if self.err_list:
raise FailException(*self.err_list)
finally:
if client.cookie:
client.delete_session()
return self.suc_list
def run(self, args):
init_args(args, self.args_lst)
client = RestfulClient(args)
try:
hdm_version = get_hdm_firmware(client)
self.overall_health = self._get_health_info(client)
memory_lst = self._get_memory_detail(client)
self.memory = self.resolve_memory_detail_info(memory_lst, args)
if not hdm_version < "1.11":
self.get_info_by_redfish(args)
if not MAX_NUM:
self.maximum = len(memory_lst)
finally:
if client.cookie:
client.delete_session()
return self.suc_list
def run(self, args):
init_args(args, self.args_lst)
payload = self.check_args(args)
client = RedfishClient(args)
systems_id = client.get_systems_id()
url = "/redfish/v1/Chassis/%s/Drives/AlarmThreshold" % systems_id
resp = client.send_request("PATCH", url, payload)
if (isinstance(resp, dict) and resp.get("status_code") in
Constant.SUC_CODE):
suc_info = ("Success: successfully set the "
"predictive failure threshold")
self.suc_list.append(suc_info)
else:
err_message = ("Failure: failure to set predictive failure "
"threshold")
self.err_list.append(err_message)
raise FailException(*self.err_list)
return self.suc_list
def run(self, args):
init_args(args, self.args_lst)
payload = self._construct_param(args)
client = RestfulClient(args)
try:
url = "/api/settings/active_directory_settings"
resp = client.send_request("PUT", url, payload)
if isinstance(resp, dict) and Constant.SUCCESS_0 == resp.get(
"cc", None):
self.suc_list.append("Success: set ad successfully")
else:
self.err_list.append("Failure: failed to set ad")
raise FailException(*self.err_list)
finally:
if client.cookie:
client.delete_session()
return self.suc_list
def run(self, args):
init_args(args, self.args_lst)
client = RestfulClient(args)
try:
url = "/api/settings/ldap-users/%s" % str(args.role_id)
resp = client.send_request("DELETE", url)
finally:
if client.cookie:
client.delete_session()
if (isinstance(resp, dict)
and Constant.SUCCESS_0 == resp.get("cc", None)):
suc = "Success: delete ldap user successfully"
self.suc_list.append(suc)
else:
self.err_list.append("Failure: failed to delete ldap user")
raise FailException(*self.err_list)
return self.suc_list
def run(self, args):
init_args(args, self.args_lst)
client = RestfulClient(args)
try:
if self.check_conditions(client, args):
url = "/api/settings/active_directory_users/%s" % args.role_id
resp = client.send_request("DELETE", url)
if isinstance(resp, dict) and Constant.SUCCESS_0 == resp.get(
"cc", None):
err = "Success: delete ad user successfully"
self.suc_list.append(err)
else:
self.err_list.append("Failure: failed to delete ad user")
raise FailException(*self.err_list)
finally:
if client.cookie:
client.delete_session()
return self.suc_list
def run(self, args):
init_args(args, self.args_lst)
url, payload = self.construct_request_parameters(args)
client = RestfulClient(args)
try:
resp = client.send_request("post", url, payload)
if (isinstance(resp, dict) and
resp.get(Constant.COMPLETE_CODE) == Constant.SUCCESS_0):
suc_info = "Success: set ip login rule succeed"
self.suc_list.append(suc_info)
else:
err_info = "Failure: set ip login rule failed"
self.err_list.append(err_info)
raise FailException(*self.err_list)
finally:
if client.cookie:
client.delete_session()
return self.suc_list
def run(self, args):
init_args(args, self.args_lst)
restful = RestfulClient(args)
try:
url, payload = construct_param(args)
resp = restful.send_request("POST", url, payload)
if isinstance(resp, dict) and Constant.SUCCESS_0 == resp.get(
"cc", None):
self.suc_list.append(
"Success: set the physical disk led light successfully")
else:
self.err_list.append(
"Failure: failed to set the physical disk led light")
raise FailException(*self.err_list)
finally:
if restful.cookie:
restful.delete_session()
return self.suc_list
def run(self, args):
init_args(args, self.args_lst)
payload = self._construct_param(args)
client = RestfulClient(args)
url = "/api/remote/logical_config"
try:
resp = client.send_request("POST", url, payload)
if (isinstance(resp, dict) and
Constant.SUCCESS_0 == resp.get("cc", None)):
self.suc_list.append("Success: add logical drive successfully")
else:
err = "Failure: failed to add logical drive"
self.err_list.append(err)
raise FailException(*self.err_list)
finally:
if client.cookie:
client.delete_session()
return self.suc_list
def run(self, args):
init_args(args, self.args_lst)
client = RestfulClient(args)
url = "/api/settings/services"
try:
resp = client.send_request("GET", url)
if isinstance(resp, list) and resp:
if args.service_type is not None:
self.service = get_service_list(resp, args.service_type)
else:
self.service = get_service_list(resp)
else:
err_info = "Failure: failed to get service information list"
self.err_list.append(err_info)
raise FailException(*self.err_list)
finally:
if client.cookie:
client.delete_session()
return self.suc_list
def run(self, args):
init_args(args, self.args_lst)
self._parse_args(args)
if self.command is not None:
ret, output = getstatusoutput(self.command)
output = output.strip()
if Constant.SUCCESS_0 != ret:
self.err_list.append(output)
err = "Failure: failed to set ntp time synchronization interval"
self.err_list.append(err)
raise FailException(*self.err_list)
else:
if "a2 63 00" == output:
suc = ("Success: set ntp time "
"synchronization interval successful")
self.suc_list.append(suc)
return self.suc_list
else:
err = ("Failure: failed to set "
"ntp time synchronization interval")
self.err_list.append(err)
raise FailException(*self.err_list)
payload = self._construct_param()
if payload:
client = RedfishClient(args)
systems_id = client.get_systems_id()
url = "/redfish/v1/Managers/%s/NtpService" % systems_id
resp = client.send_request('PATCH', url, payload)
if (isinstance(resp, dict)
and resp.get("status_code", None) in Constant.SUC_CODE):
self.suc_list.append("Success: set ntp server information "
"successful")
else:
self.err_list.append("Failure: failed to set ntp server "
"information")
raise FailException(*self.err_list)
return self.suc_list
def run(self, args):
init_args(args, self.args_lst)
if args.is_dual_image == "Dual" and (args.firmware_type != "BMC"
or args.activate_mode != "Auto"):
err_info = ("Failure: to upgrade dual mirrors, the firmware type "
"must be BMC and the startup mode must be automatic, "
"please check the parameters")
self.err_list.append(err_info)
raise FailException(*self.err_list)
global IS_DUAL
if args.is_dual_image == "Dual":
IS_DUAL = True
client = FwUpdateClient(args)
try:
if IS_DUAL:
url = "/api/maintenance/primary_backup_version"
resp = client.send_request("GET", url)
if (isinstance(resp, dict)
and Constant.SUCCESS_0 == resp.get("cc", None)):
global FW_BACKUP_VER, FW_PRIMARY_VER
FW_BACKUP_VER = resp.get("backup_version")
FW_PRIMARY_VER = resp.get("primary_version")
else:
err_info = ("Failure: failed to obtain the HDM version "
"of the standby partition")
self.err_list.append(err_info)
raise FailException(*self.err_list)
client = start_fwupdate(client, args)
finally:
if client.cookie:
client.delete_session()
if client.err_message:
self.err_list.extend(client.err_message)
raise FailException(*self.err_list)
if client.suc_message:
self.suc_list.extend(client.suc_message)
return self.suc_list
def run(self, args):
init_args(args, self.args_lst)
self._check_args(args)
client = RestfulClient(args)
try:
url = "/api/logs/event"
resp = client.send_request("GET", url)
finally:
if client.cookie:
client.delete_session()
if isinstance(resp, list):
if not resp:
suc_info = "Success: event log list is empty"
self.suc_list.append(suc_info)
else:
self._package_results(args, resp)
else:
self.err_list.append("Failure: failed to get event log list!")
raise FailException(*self.err_list)
return self.suc_list
def run(self, args):
init_args(args, self.args_lst)
client = RestfulClient(args)
try:
url = "/api/system/assetTag"
payload = {"asset_tag": args.asset_tag}
resp = client.send_request("POST", url, payload)
if (isinstance(resp, dict) and resp.get(Constant.COMPLETE_CODE)
== Constant.SUCCESS_0):
suc_info = "Success: set asset tag succeed"
self.suc_list.append(suc_info)
else:
err_info = "Failure: Set asset tag failed"
self.err_list.append(err_info)
raise FailException(*self.err_list)
finally:
if client.cookie:
client.delete_session()
return self.suc_list
def run(self, args):
init_args(args, self.args_lst)
is_adapt_b01 = globalvar.IS_ADAPT_B01
if is_adapt_b01:
client = RestfulClient(args)
logic_disk_list = self._get_b01_logical_disk_list(client)
if not logic_disk_list:
suc_info = "Success: raid card resource is empty"
self.suc_list.append(suc_info)
return self.suc_list
else:
if ((args.controller_id is None and args.logical_id is not None) or
(args.controller_id is not None and args.logical_id is None)):
err = ("Argument: RAID card ID and logical disk "
"ID must be specified at the same time")
self.err_list.append(err)
raise FailException(*self.err_list)
client = RedfishClient(args)
logical_disk_list_url = self._get_logical_disk_list(client)
if args.logical_id is None and not logical_disk_list_url:
suc = "Success: raid card resource is empty"
self.suc_list.append(suc)
return self.suc_list
if not self._get_logical_disk_detail(client, logical_disk_list_url,
args):
err_info = "Failure: resource was not found"
self.err_list.append(err_info)
raise FailException(*self.err_list)
client = RestfulClient(args)
try:
self._get_health_info(client)
finally:
if client.cookie:
client.delete_session()
return self.suc_list
def run(self, args):
init_args(args, self.args_lst)
if globalvar.HDM_VERSION < "2.08.00":
err = "Failure: this hdm version does not support this command"
self.err_list.append(err)
raise FailException(*self.err_list)
else:
payload = self._parse_args(args)
url = "/redfish/v1/AccountService/Roles/%s" % args.role_id
client = RedfishClient(args)
resp = client.send_request("PATCH", url, payload)
if (isinstance(resp, dict)
and resp.get("status_code", None) in Constant.SUC_CODE):
suc = "Success: set user role information successfully"
self.suc_list.append(suc)
else:
err = "Failure: failed to set user role information"
self.err_list.append(err)
raise FailException(*self.err_list)
return self.suc_list
def run(self, args):
init_args(args, self.args_lst)
self._check_args(args)
client = RestfulClient(args)
try:
url = "/api/settings/network"
resp = client.send_request("GET", url)
if resp and isinstance(resp, list):
for eth in resp:
if args.network_port_id is not None:
if (args.network_port_id ==
eth.get("interface_name", None)):
self._construct_request(client, eth)
break
elif (eth.get("ipv4_address", None) == args.host
or eth.get('ipv6_address', None) == args.host or (
args.host.startswith("[") and
args.host.endswith("]") and
(eth.get('ipv6_address', None) ==
args.host[1:-1] or
eth.get('ipv6_localLinkAddress', None) ==
args.host[1:-1]))):
self._construct_request(client, eth)
break
else:
err_info = "Argument: the network port does not exist"
self.err_list.append(err_info)
raise FailException(*self.err_list)
else:
self.err_list.append("Failure: failed to get ip information "
"list")
raise FailException(*self.err_list)
finally:
if client.cookie:
client.delete_session()
return self.suc_list
