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)
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):
is_adapt_b01 = globalvar.IS_ADAPT_B01
if is_adapt_b01:
client = RestfulClient(args)
try:
url = "/api/power/capping"
resp = client.send_request("GET", url)
if (isinstance(resp, dict)) and resp.get("cc") ==\
Constant.SUCCESS_0:
self.limit_in_watts = resp.get("power_meter_set", None)
self.limit_exception = power_meter_shutdown_dict.get(
resp.get("power_meter_shutdown"), None)
self.power_limit_enable_str = power_meter_state_dict.get(
resp.get("power_meter_enable"), None)
else:
err_info = "Failure: failed to get power limit"
self.err_list.append(err_info)
raise FailException(*self.err_list)
finally:
if client.cookie:
client.delete_session()
else:
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) in Constant.SUC_CODE):
self._pack_resource(resp["resource"])
else:
err_info = "Failure: failed to get power capping information"
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)
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.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):
is_adapt_b01 = globalvar.IS_ADAPT_B01
if is_adapt_b01:
client = RestfulClient(args)
try:
url = "/api/settings/pef/snmp"
resp = client.send_request("GET", url)
if isinstance(resp, dict):
self._pack_b01_snmp_resource(resp)
else:
err = "Failure: failed to get snmp information"
self.err_list.append(err)
raise FailException(*self.err_list)
finally:
if client.cookie:
client.delete_session()
else:
client = RedfishClient(args)
systems_id = client.get_systems_id()
url = "/redfish/v1/Managers/%s/SnmpService" % systems_id
resp = client.send_request("get", url)
if (isinstance(resp, dict)
and Constant.SUCCESS_200 == resp.get("status_code", None)):
self._pack_snmp_resource(resp["resource"])
else:
err = "Failure: failed to get snmp 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)
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)
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):
is_adapt_b01 = globalvar.IS_ADAPT_B01
if is_adapt_b01:
client = RestfulClient(args)
try:
url = "/api/sensors"
resp = client.send_request("GET", url)
if isinstance(resp, list):
data = sorted(resp, key=lambda s: s["sensor_number"])
for info in data:
if info.get("type") == "temperature":
temp = Temperature()
temp.pack_b01_temp_resource(info)
self.temperatures.append(temp)
else:
err_info = "Failure: failed to get temperature information"
self.err_list.append(err_info)
raise FailException(*self.err_list)
finally:
if client.cookie:
client.delete_session()
else:
client = RedfishClient(args)
systems_id = client.get_systems_id()
url = "/redfish/v1/Chassis/%s/Thermal" % systems_id
resp = client.send_request("GET", url)
if (isinstance(resp, dict)
and resp.get("status_code", None) in Constant.SUC_CODE):
temperatures = resp["resource"].get("Temperatures", None)
if not temperatures:
self.err_list.append("Failure: no data available for the "
"resource")
raise FailException(*self.err_list)
try:
temperatures = sorted(temperatures,
key=lambda s: s["SensorNumber"])
except KeyError as err:
self.err_list.append(str(err))
raise FailException(*self.err_list)
else:
for info in temperatures:
temp = Temperature()
temp.pack_temp_resource(info)
self.temperatures.append(temp)
else:
self.err_list.append("Failure: failed to get temperature "
"information")
raise FailException(*self.err_list)
return self.suc_list
def run(self, args):
client = RestfulClient(args)
try:
self._get_health_info(client)
url = "/api/system/nic"
resp = client.send_request("GET", url)
finally:
if client.cookie:
client.delete_session()
if isinstance(resp, dict) and Constant.SUCCESS_0 == resp.get(
"cc", None):
nic_info = resp.get("nic_info", None)
if not nic_info:
suc_info = "Success: the NIC list is empty"
self.suc_list.append(suc_info)
else:
self.maximum = len(self.suc_list)
for info in nic_info:
nic = Nic()
nic.pack_nic_resource(info)
self.nics.append(nic)
else:
self.err_list.append("Failure: failed to get nic information list")
raise FailException(*self.err_list)
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):
is_adapt_b01 = globalvar.IS_ADAPT_B01
if is_adapt_b01:
client = RestfulClient(args)
try:
url = "/api/config/boot"
resp = client.send_request("get", url)
if isinstance(resp, dict) and Constant.SUCCESS_0 == \
resp.get("cc"):
self.boot_source_override_target = MODE_DICT.get(
resp.get("mode"), None)
self.boot_source_override_enabled = resp.get(
"alwaysflag", "Once")
self.boot_source_override_mode = DEV_DICT.get(
resp.get("dev"), None)
else:
err_info = "Failure: failed to get boot startup information"
self.err_list.append(err_info)
raise FailException(*self.err_list)
finally:
if client.cookie:
client.delete_session()
else:
client = RedfishClient(args)
systems_id = client.get_systems_id()
url = "/redfish/v1/Systems/%s" % systems_id
resp = client.send_request("get", url)
if (isinstance(resp, dict)
and resp.get("status_code", None) in Constant.SUC_CODE):
boot = resp["resource"].get("Boot", None)
if isinstance(boot, dict):
self.boot_source_override_target = (boot.get(
"BootSourceOverrideTarget", None))
self.boot_source_override_enabled = (boot.get(
"BootSourceOverrideEnabled", None))
self.boot_source_override_mode = (boot.get(
"BootSourceOverrideMode", None))
else:
err_info = "Failure: failed to get boot startup information"
self.err_list.append(err_info)
raise FailException(*self.err_list)
def run(self, args):
is_adapt_b01 = globalvar.IS_ADAPT_B01
if is_adapt_b01:
client = RestfulClient(args)
try:
url = "/api/config/ntp"
resp = client.send_request("GET", url)
if isinstance(resp, dict):
if resp.get("timestamp") is not None:
date_array = datetime.datetime.utcfromtimestamp(
resp.get("timestamp"))
style_time = date_array.strftime("%Y-%m-%d %H:%M:%S")
self.time = style_time
self.timezone = resp.get("timezone")
else:
err_info = "Failure: failed to get time information!"
self.err_list.append(err_info)
raise FailException(*self.err_list)
finally:
if client.cookie:
client.delete_session()
else:
client = RedfishClient(args)
systems_id = client.get_systems_id()
url = "/redfish/v1/Managers/%s" % systems_id
resp = client.send_request("GET", url)
if (isinstance(resp, dict)
and resp.get("status_code", None) in Constant.SUC_CODE):
self.date_time = resp["resource"].get("DateTime", None)
if self.date_time:
self.time = self.date_time[:19].replace("T", " ")
self.timezone = resp["resource"].get("DateTimeLocalOffset",
None)
else:
self.err_list.append(
"Failure: failed to get time information!")
raise FailException(*self.err_list)
return self.suc_list
def run(self, args):
client = RestfulClient(args)
url = "/api/sensors"
try:
resp = client.send_request("GET", url)
psu_sensor = (self.package_results(
list(filter(is_power_sensor, resp))))
self.power = psu_sensor
finally:
if client.cookie:
client.delete_session()
return self.suc_list
def run(self, args):
init_args(args, self.args_lst)
flag = self.check_args(args)
client = RestfulClient(args)
url = "/api/settings/services"
try:
resp = client.send_request("GET", url)
if resp and isinstance(resp, list):
for service in resp:
if service.get("service_name", None) == args.service_type:
url, payload = (self.construct_request_parameters(
service, url, args))
resp = client.send_request("PUT", url, payload)
if (isinstance(resp, dict) and
((resp.get("code") == Constant.FAILED_1306
or resp.get("cc") == Constant.SUCCESS_0) if flag
else resp.get("cc") == Constant.SUCCESS_0)):
suc_info = ("Success: set BMC network protocol "
"services successfully")
self.suc_list.append(suc_info)
else:
err_info = "Failure: service setup failed"
self.err_list.append(err_info)
break
else:
err_info = "Failure: the service item was not found"
self.err_list.append(err_info)
else:
err_info = ("Failure: failed to get service configuration "
"information")
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)
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):
client = RestfulClient(args)
url = "/api/logs/event"
try:
resp = client.send_request("DELETE", url)
finally:
if client.cookie:
client.delete_session()
if isinstance(resp, dict) and not resp:
self.suc_list.append(
"Success: clear system event log successfully")
else:
self.err_list.append("Failure: failed to clear system event log")
raise FailException(*self.err_list)
return self.suc_list
def run(self, args):
client = RestfulClient(args)
url = "/api/settings/network_portmode"
try:
resp = client.send_request("get", url)
if (isinstance(resp, dict) and resp.get(
Constant.COMPLETE_CODE, None) == Constant.SUCCESS_0):
self.net_mode = MODE_DICT.get(resp.get("port_mode"))
else:
err_info = ("Failure: failed to get network port mode "
"information")
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):
restful = RestfulClient(args)
try:
url = "/api/maintenance/restore_hdm"
payload = {"reset": 1}
resp = restful.send_request("POST", url, payload)
finally:
if restful.cookie:
restful.delete_session()
if isinstance(resp, dict) or Constant.SUCCESS_0 == resp.get(
"cc", None):
self.suc_list.append("Success: reset BMC successfully")
else:
self.err_list.append("Failure: failed to reset BMC")
raise FailException(*self.err_list)
return self.suc_list
def run(self, args):
client = RestfulClient(args)
try:
url = "/api/maintenance/restore_defaults"
resp = client.send_request("PUT", url)
finally:
if client.cookie:
client.delete_session()
if isinstance(resp, dict) or Constant.SUCCESS_0 == resp.get("cc"):
self.suc_list.append(
"Success: restore BMC default settings successfully")
else:
self.err_list.append(
"Failure: restore BMC default settings failed")
raise FailException(*self.err_list)
return self.suc_list
def run(self, args):
client = RestfulClient(args)
try:
url = "/api/health_info"
resp = client.send_request("GET", url)
if (isinstance(resp, dict) and
Constant.SUCCESS_0 == resp.get("cc", None)):
self._pack_resource(resp)
else:
err_info = "Failure: failed to get system health 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)
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)
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)
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)
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)
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)
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)
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
