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 construct_request_parameters(self, args, max_value, min_value,
limit_in_watts, exception):
payload = dict()
if args.status == "Disable":
if args.limit_value or args.exception:
para_lst = []
if args.limit_value:
para_lst.append(str(args.limit_value))
if args.exception:
para_lst.append(args.exception)
err_info = ("Argument: parameters are not available "
"when setting power off: %s" % ", ".join(para_lst))
self.err_list.append(err_info)
raise FailException(*self.err_list)
else:
payload["power_meter_enable"] = 0
payload["power_meter_set"] = ""
else:
payload["power_meter_enable"] = 1
limit_value = (args.limit_value
if args.limit_value else limit_in_watts)
if limit_value < min_value or limit_value > max_value:
err_info = ("Argument: invalid choice: "
"(choose from %s to %s)" % (min_value, max_value))
self.err_list.append(err_info)
raise FailException(*self.err_list)
payload["power_meter_set"] = limit_value
exception = args.exception if args.exception else exception
payload['power_meter_shutdown'] = (0 if exception == "NoAction" else 1)
return payload
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 = "/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 request(self, method, url, body=None):
headers = {"X-CSRFTOKEN": self.token, "Cookie": self.cookie}
if isinstance(body, dict):
try:
payload = json.dumps(body)
except (KeyError, TypeError, AttributeError, Exception) as err:
self.err_message.append(str(err))
raise FailException(*self.err_message)
else:
headers["Content-Type"] = u"application/json"
else:
payload = body
if self.port is not None:
url = r"https://%s:%s%s" % (self.host, self.port, url)
else:
url = r"https://%s%s" % (self.host, url)
try:
resp = HTTP.request(method,
url,
body=payload,
retries=False,
headers=headers,
timeout=30)
result = json.loads(resp.data.decode("utf-8"))
except (TypeError, AttributeError, Exception) as err:
self.err_message.append(str(err))
raise FailException(*self.err_message)
return result
def _get_raid(self, client):
systems_id = client.get_systems_id()
url = "/redfish/v1/Systems/%s/Storages" % systems_id
resp = client.send_request("GET", url)
if (isinstance(resp, dict)
and resp.get("status_code", None) in Constant.SUC_CODE):
raid_members = resp["resource"].get("Members", None)
if not raid_members:
self.suc_list.append("Success: raid card resource is empty")
return
for member in raid_members:
url = member.get("@odata.id", None)
resp = client.send_request("GET", url)
if (isinstance(resp, dict) and resp.get("status_code", None)
in Constant.SUC_CODE):
raid = Raid()
raid.pack_raid_resource(resp["resource"])
self.raids.append(raid)
else:
self.err_list.append("Failure: failed to get raid card "
"details")
raise FailException(*self.err_list)
else:
self.err_list.append("Failure: failed to get raid card"
" collection information")
raise FailException(*self.err_list)
def get_screen_capture(self, url, body=None):
headers = {"X-CSRFTOKEN": self.token, "Cookie": self.cookie}
if isinstance(body, dict):
try:
payload = json.dumps(body)
except (KeyError, TypeError, AttributeError, Exception) as err:
self.err_message.append(str(err))
raise FailException(*self.err_message)
else:
headers["Content-Type"] = u"application/json"
else:
payload = body
if self.port is not None:
url = r"https://%s:%s%s" % (self.host, self.port, url)
else:
url = r"https://%s%s" % (self.host, url)
try:
res = HTTP.request("GET",
url,
retries=False,
headers=headers,
body=payload)
result = res.data
except (KeyError, TypeError, AttributeError, Exception) as err:
self.err_message.append(str(err))
raise FailException(*self.err_message)
return result
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 _check_args(self, args):
if args.file_path is not None:
try:
with open(args.file_path, 'w'):
pass
except IOError as err:
self.err_list.append(str(err))
raise FailException(*self.err_list)
else:
os.remove(args.file_path)
if args.time is not None and args.count is not None:
self.err_list.append("Argument: time parameter and quantity "
"parameter cannot be used at the same time")
raise FailException(*self.err_list)
if args.time is not None:
time_org_str = args.time
try:
time_str = parse(time_org_str)
utc_time_str = time_str.replace(tzinfo=timezone.utc)
args.time = (time.mktime(time_str.timetuple()) +
(time_str - utc_time_str).total_seconds() + 28800)
except (ValueError, TypeError, Exception):
err_info = ("Argument: invalid choice: "
"%s (the time format is incorrect, "
"exp: 2019-03-13T03:24:45+08:00)" % time_org_str)
self.err_list.append(err_info)
raise FailException(*self.err_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)
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 get_process(self, client, config_type):
url = '/api/maintenance/upload_restore_process'
time.sleep(5)
index = 0
while index < 100:
resp = client.send_request("GET", url)
if (isinstance(resp, dict)
and resp.get(Constant.COMPLETE_CODE) == 0
and isinstance(resp.get('progress', None), int)):
if resp['progress'] == 255:
suc_info = ("Success: import %s configuration "
"successfully" % config_type)
self.suc_list.append(suc_info)
break
else:
err_info = ("Failure: get upload restore process failed, "
"reason: %s" % resp.get(Constant.COMPLETE_ERROR))
self.err_list.append(err_info)
raise FailException(*self.err_list)
time.sleep(2)
index += 1
else:
err_info = "Failure: get file upload progress timeout"
self.err_list.append(err_info)
raise FailException(*self.err_list)
def check_package_args(self, args):
payload = dict()
if args.start_date is not None and not is_valid_date(args.start_date):
err_info = ("Argument: invalid choice: %s "
"(the date format is incorrect)" % args.start_date)
self.err_list.append(err_info)
raise FailException(*self.err_list)
if args.end_date is not None and not is_valid_date(args.end_date):
err_info = ("Argument: invalid choice: %s "
"(the date format is incorrect)" % args.end_date)
self.err_list.append(err_info)
raise FailException(*self.err_list)
if args.end_date is not None and args.start_date is not None:
end_date = string2time(args.end_date)
start_date = string2time(args.start_date)
if start_date > end_date:
err_info = ("Argument: the end date must be later than the "
"start date")
self.err_list.append(err_info)
raise FailException(*self.err_list)
payload["start_date"] = args.start_date
payload["end_date"] = args.end_date
elif ((not args.end_date and args.start_date)
or (args.end_date and not args.start_date)):
err_info = "Argument: start time and end time must appear in pairs"
self.err_list.append(err_info)
raise FailException(*self.err_list)
else:
payload["start_date"] = "0"
payload["end_date"] = "0"
payload["EmailNumber"] = ""
payload["ContactName"] = ""
payload["PhoneNumber"] = ""
return payload
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 _get_b01_processor(self, client, args):
cpu_list = list()
url = "/api/system/processor"
resp = client.send_request("GET", url)
i = 1
if isinstance(resp, list):
for info in resp:
if isinstance(info, dict):
cpu = CPU()
cpu.name = "CPU%s" % (str(i))
cpu.temperature = self._get_temp(client, cpu.name)
cpu.pack_restful_resource(info)
cpu_list.append(cpu)
i = i + 1
else:
self.err_list.append("Failure: failed to get cpu "
"information")
raise FailException(*self.err_list)
try:
cpu_list = sorted(cpu_list, key=lambda s: s.id)
except (KeyError, ValueError, Exception) as err:
self.err_list.append(str(err))
raise FailException(*self.err_list)
else:
self.err_list.append("Failure: failed to get system CPUs "
"information")
raise FailException(*self.err_list)
if not cpu_list:
err_info = "Failure: resource was not found"
self.err_list.append(err_info)
raise FailException(*self.err_list)
return cpu_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 _get_ctrl(self, client, args):
url = "/api/system/storageinfo/ctrl/list"
resp = client.send_request("get", url)
if (not resp or Constant.SUCCESS_0 != resp.get("cc", None)
or not isinstance(resp.get("card_list", None), list)):
err_info = "Failure: failed to get controller card information"
self.err_list.append(err_info)
raise FailException(*self.err_list)
card_list = resp["card_list"]
if args.controller_id is None and not card_list:
suc = "Success: resource is empty"
self.suc_list.append(suc)
return self.suc_list
flag = False
for card in card_list:
ctrl_id = card.get("ctrl_id", None)
if args.controller_id is None:
flag = True
self._get_ctrl_detail(ctrl_id, client)
elif args.controller_id == card.get("ctrl_id", None):
flag = True
self._get_ctrl_detail(ctrl_id, client)
break
if not flag:
err_info = "Failure: resource was not found"
self.err_list.append(err_info)
raise FailException(*self.err_list)
def _parse_trap_server(self, args):
self.trap_servers = list()
s_dict = dict()
s_dict["MemberId"] = args.member_id
s_dict["Enabled"] = (("Enabled" == args.server_enabled)
if args.server_enabled is not None else None)
s_dict["TrapServerPort"] = None
if args.server_port is not None:
if args.server_port < 1 or args.server_port > 65535:
err = ("Argument: invalid choice: %s "
"(choose from 1 to 65535)" % args.server_port)
self.err_list.append(err)
raise FailException(*self.err_list)
else:
s_dict["TrapServerPort"] = args.server_port
if args.server_address:
if (is_ipv4(args.server_address) or
is_ipv6(args.server_address) or
is_domain(args.server_address)):
s_dict["TrapServerAddress"] = args.server_address
else:
err = ("Argument: invalid choice: %s "
"(the server address is invalid)" %
args.server_address)
self.err_list.append(err)
raise FailException(*self.err_list)
self.trap_servers.append(s_dict)
def _get_logical_disk_list(self, client):
logical_disk_list_url = list()
systems_id = client.get_systems_id()
url = "/redfish/v1/Systems/%s/Storages" % systems_id
resp = client.send_request("GET", url)
if (isinstance(resp, dict)
and resp.get("status_code", None) in Constant.SUC_CODE):
raid_members = resp["resource"].get("Members", None)
for member in raid_members:
url = "%s/Volumes" % member.get("@odata.id", None)
resp = client.send_request("GET", url)
if (isinstance(resp, dict) and resp.get("status_code", None)
in Constant.SUC_CODE):
logical_drivers = resp["resource"].get("Members", None)
for driver in logical_drivers:
logical_disk_list_url.append(driver.get("@odata.id"))
else:
err = ("Failure: failed to get logical disk "
"collection information")
self.err_list.append(err)
raise FailException(*self.err_list)
else:
err = ("Failure: failed to get logical disk "
"collection information")
self.err_list.append(err)
raise FailException(*self.err_list)
return logical_disk_list_url
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):
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 _parse_parameters(self, args):
cmd_type = "snmp"
if "snmp_v1_enabled" in args:
cmd_type = "snmp"
flag_snmp = (
args.snmp_v1_enabled is not None or
args.snmp_v2c_enabled is not None or
args.long_password_enabled is not None or
args.read_only_community is not None or
args.read_write_community is not None
)
flag_trap = (
args.service_enabled is not None or
args.trap_mode is not None or
args.trap_version is not None or
args.trap_v3_user is not None or
args.community_name is not None or
args.alarm_severity is not None
)
flag_server = args.trap_servers
flag_snmp = flag_snmp or flag_trap or flag_server
if not flag_snmp:
err = "Argument: at least one parameter must be specified"
self.err_list.append(err)
raise FailException(*self.err_list)
self._parse_snmp(args)
elif "service_enabled" in args:
cmd_type = "SNMP trap common"
flag_trap = (
args.service_enabled is not None or
args.trap_version is not None or
args.community_name is not None or
args.alarm_severity is not None or
args.trap_v3_user is not None
)
if not flag_trap:
err = "Argument: need at least one parameter"
self.err_list.append(err)
raise FailException(*self.err_list)
self._parse_trap_com(args)
elif "member_id" in args:
cmd_type = "SNMP trap destination"
flag_server = (
args.server_enabled is not None or
args.server_port is not None or
args.server_address is not None
)
if not flag_server:
err = "Argument: need at least one parameter"
self.err_list.append(err)
raise FailException(*self.err_list)
self._parse_trap_server(args)
return cmd_type
def request(self, method, url, data=None, timeout=100):
if isinstance(data, dict):
try:
payload = json.dumps(data)
except (KeyError, TypeError, AttributeError, Exception) as err:
self.err_message.append(str(err))
raise FailException(*self.err_message)
else:
payload = data
if self.port is not None:
url = r"https://%s:%s%s" % (self.host, self.port, url)
else:
url = r"https://%s%s" % (self.host, url)
headers = {
"Content-Type": "application/json",
"Authorization": "Basic %s" % self.auth.decode("utf-8"),
}
try:
response = requests.request(method,
url,
data=payload,
headers=headers,
verify=False,
timeout=timeout)
if response is None:
err_message = ("Failure: failed to establish a new "
"connection to the host")
self.err_message.append(err_message)
raise FailException(*self.err_message)
if method == "GET":
resp = {
"status_code": response.status_code,
"resource": json.loads(response.content.decode('utf8'))
}
elif method == "POST":
resp = {
"status_code": response.status_code,
"resource": response.text
}
elif method == "DELETE":
resp = {
"status_code": response.status_code,
"resource": response.content
}
elif method == "PATCH":
resp = {
"status_code": response.status_code,
"resource": response.content
}
except (KeyError, TypeError, AttributeError, Exception) as err:
self.err_message.append(str(err))
raise FailException(*self.err_message)
return resp
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 _construct_request(self, client, payload):
url = "/api/settings/network/%s" % payload.get("id", None)
if (payload.get("ipv4_dhcp_enable", None) == 1 and
self.ipv4_dhcp_enable is None and
(self.ipv4_address or self.ipv4_gateway or self.ipv4_subnet)):
self.err_list.append("Argument: parameter is not available in "
"DHCP mode")
raise FailException(*self.err_list)
elif (payload.get("ipv6_dhcp_enable", None) == 1 and
self.ipv6_dhcp_enable is None and
(self.ipv6_address or self.ipv6_gateway or self.ipv6_prefix)):
self.err_list.append("Argument: parameter is not available in "
"DHCP mode")
raise FailException(*self.err_list)
if self.ipv4_enable is not None:
payload["ipv4_enable"] = self.ipv4_enable
if self.ipv4_dhcp_enable is not None:
payload["ipv4_dhcp_enable"] = self.ipv4_dhcp_enable
if self.ipv4_address is not None:
payload["ipv4_address"] = self.ipv4_address
if self.ipv4_subnet is not None:
payload["ipv4_subnet"] = self.ipv4_subnet
if self.ipv4_gateway is not None:
payload["ipv4_gateway"] = self.ipv4_gateway
if self.ipv6_enable is not None:
payload["ipv6_enable"] = self.ipv6_enable
if self.ipv6_dhcp_enable is not None:
payload["ipv6_dhcp_enable"] = self.ipv6_dhcp_enable
if self.ipv6_address is not None:
payload["ipv6_address"] = self.ipv6_address
if self.ipv6_prefix is not None:
payload["ipv6_prefix"] = self.ipv6_prefix
if self.ipv6_gateway is not None:
payload["ipv6_gateway"] = self.ipv6_gateway
if self.vlan_enable is not None:
payload["vlan_enable"] = self.vlan_enable
if self.vlan_id is not None:
payload["vlan_id"] = self.vlan_id
if self.vlan_priority is not None:
payload["vlan_priority"] = self.vlan_priority
resp = client.send_request("PUT", url, payload)
if (isinstance(resp, dict) and
Constant.SUCCESS_0 == resp.get("cc", None)):
suc_info = "Success: set network successfully"
self.suc_list.append(suc_info)
else:
err_info = "Failure: failed to set network"
self.err_list.append(err_info)
raise FailException(*self.err_list)
def _parse_b01_args(self, args):
self.enabled = (("Enable" == args.enabled) if args.enabled is not None
else True)
self.user_name = args.new_user_name
self.password = args.new_pwd
role_id_dict = {"Administrator": "administrator",
"Operator": "operator",
"Commonuser": "******",
"OEM": "none"
}
self.role_id = role_id_dict.get(args.role_id)
self.kvm_enable = 0
self.vmedia_enable = 0
if args.privilege is not None:
priv_set = set(filter(None, args.privilege.split(r',')))
if not priv_set.issubset({"KVM", "VMM", "SOL", "None"}):
err = ("Argument: the privilege parameter is invalid, "
"must be selected in {KVM,VMM,SOL,None}")
self.err_list.append(err)
raise FailException(*self.err_list)
if "KVM" in priv_set:
self.kvm_enable = 1
if "VMM" in priv_set:
self.vmedia_enable = 1
if "Enable" == args.snmp_v3_enable:
self.snmp_v3_enable = 1
else:
self.snmp_v3_enable = 0
self.snmp_v3_access_permission = args.snmp_v3_access_permission
self.snmp_v3_auth_protocol = args.snmp_v3_auth_protocol
self.snmp_v3_priv_protocol = args.snmp_v3_priv_protocol
if self.enabled is not True:
if (self.snmp_v3_enable or self.snmp_v3_access_permission or
self.snmp_v3_auth_protocol or self.snmp_v3_priv_protocol):
err = "Argument: invalid snmp mode, please check parameter"
self.err_list.append(err)
raise FailException(*self.err_list)
if self.snmp_v3_enable:
if len(self.password) < 8:
err = "Argument: invalid snmp mode, please check parameter"
self.err_list.append(err)
raise FailException(*self.err_list)
if self.web_enable is False or self.ipmi_enable is False:
if "User" != self.role_id:
err = ("Argument: invalid role! Web and IPMI "
"can be disable only if the role is user")
self.err_list.append(err)
raise FailException(*self.err_list)
def construct_request_parameters(self, resp):
payload = dict()
if self.snmp_v1_enabled is not None:
payload["SnmpV1Enabled"] = self.snmp_v1_enabled
if self.snmp_v2c_enabled is not None:
payload["SnmpV2CEnabled"] = self.snmp_v2c_enabled
if self.long_password_enabled is not None:
payload["LongPasswordEnabled"] = self.long_password_enabled
if self.read_only_community is not None:
payload["ReadOnlyCommunity"] = self.read_only_community
if self.read_write_community is not None:
payload["ReadWriteCommunity"] = self.read_write_community
if self.community_name is not None:
payload["CommunityName"] = self.community_name
if self.service_enabled is not None:
payload["ServiceEnabled"] = self.service_enabled
if self.trap_version is not None:
payload["TrapVersion"] = self.trap_version
if self.trap_v3_user is not None:
payload["TrapV3User"] = self.trap_v3_user
alarm_severity = {
"All": "All",
"Critical": "Critical",
"MinorAndMajorAndCritical": "Minor+Major+Critical",
"WarningAndCritical": "Warning+Critical",
"MajorAndCritical": "Major+Critical"
}
if globalvar.HDM_VERSION < "2.10.00":
if self.alarm_severity == "MajorAndCritical":
err = ("Argument: invalid choice: %s, the current HDM version "
"does not support" % self.alarm_severity)
self.err_list.append(err)
raise FailException(*self.err_list)
if self.alarm_severity is not None:
payload["AlarmSeverity"] = alarm_severity.get(self.alarm_severity)
if self.trap_mode is not None:
payload["TrapMode"] = self.trap_mode
if self.trap_servers:
payload["TrapServer"] = self.trap_servers
if (self.community_name is not None and
(payload.get("TrapVersion") == "v3" or (payload.get(
"TrapVersion") is None and resp["resource"][
"SnmpTrapNotification"].get(
"TrapVersion") == "v3"))):
err_info = ("Argument: the trap community name parameter "
"is not available in v3 mode")
self.err_list.append(err_info)
raise FailException(*self.err_list)
return payload
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):
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 get_storages_disk_driver(self, resp, client, physical_disk_list, s_id):
raid_members = resp["resource"].get("Members", None)
if not raid_members:
url = "/redfish/v1/Chassis/%s/Drives" % s_id
resp = client.send_request("GET", url)
if (isinstance(resp, dict) and
resp.get("status_code", None) in Constant.SUC_CODE):
physical_drivers = resp["resource"].get("Members", None)
if physical_drivers:
ctrl = dict()
ctrl["AssetTag"] = None
ctrl["MemberId"] = None
physical_url = list()
for driver in physical_drivers:
pd = Pdisk(None, None, driver.get("@odata.id"))
physical_url.append(pd)
ctrl["url"] = physical_url
physical_disk_list.append(ctrl)
else:
err = ("Failure: failed to get physical disk"
" collection information")
self.err_list.append(err)
raise FailException(*self.err_list)
for member in raid_members:
url = member.get("@odata.id", None)
resp = client.send_request("GET", url)
if (isinstance(resp, dict) and
resp.get("status_code", None) in Constant.SUC_CODE):
raid_name = resp["resource"].get("Name")
physical_drivers = resp["resource"].get("Drives", None)
if physical_drivers:
ctrl = dict()
storage_controllers = (
resp["resource"].get("StorageControllers", None))
if storage_controllers:
ctrl["AssetTag"] = (
storage_controllers[0].get("AssetTag", None))
ctrl["MemberId"] = (
storage_controllers[0].get("MemberId", None))
physical_url = list()
for driver in physical_drivers:
pd = Pdisk(raid_name, None, driver.get("@odata.id"))
physical_url.append(pd)
ctrl["url"] = physical_url
physical_disk_list.append(ctrl)
else:
err = "Failure: failed to get raid card details"
self.err_list.append(err)
raise FailException(*self.err_list)
