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)