def patch_pmdu_power_meter():
view_helper.run_pre_check(pre_check.pre_check_function_call,
command_name_enum.set_rm_state)
throttle_args = {}
actions = {
"DatacenterThrottleEnabled":
(apply_power_throttle, parameter_parser("dcpolicy", int,
enums.Boolean), {
"args": throttle_args
}),
"AlertEnabled": (apply_power_throttle,
parameter_parser("policy", int, enums.Boolean), {
"args": throttle_args
}),
"AlertLimitWatts":
(controls.manage_powermeter.set_rack_power_limit_policy,
parameter_parser("powerlimit", float), {})
}
result = validate_patch_request_and_execute(actions, "pmdu_power_meter")
throttle = apply_power_throttle(force_set=True, args=throttle_args)
view_helper.append_response_information(result, throttle)
return get_handler.get_pmdu_power_meter(patch=result)
def post_rack_manager_tftp_get():
view_helper.run_pre_check(pre_check.pre_check_function_call,
command_name_enum.set_rm_config)
validation = {
"Server": parameter_parser("server", str, IPAddress),
"File": parameter_parser("file", str),
}
params = validate_action_parameters(validation)
result = controls.manage_rack_manager.manager_tftp_client_get(**params)
return check_action_result(result)
def post_accounts():
view_helper.run_pre_check(pre_check.pre_check_function_call,
command_name_enum.set_rm_config)
validation = {
"UserName": parameter_parser("username", str),
"Password": parameter_parser("pwd", str),
"RoleId": parameter_parser("role", str, RoleId)
}
params = validate_action_parameters(validation)
result = controls.manage_user.user_create_new(**params)
return check_action_result(result, success_code=201)
def post_system_reset(system):
system = int(system)
view_helper.run_pre_check(pre_check.pre_check_function_call,
command_name_enum.set_blade_state,
device_id=system)
validation = {
"ResetType":
parameter_parser(
"type", str, ResetType, {
"valid": [
ResetType.ON, ResetType.GRACEFUL_SHUTDOWN,
ResetType.GRACEFUL_RESTART
]
})
}
params = validate_action_parameters(validation)
if (params["type"] == ResetType.ON):
result = controls.bladepowerstate_lib.set_server_on(system)
elif (params["type"] == ResetType.GRACEFUL_SHUTDOWN):
result = controls.bladepowerstate_lib.set_server_off(system)
else:
result = controls.bladepowerstate_lib.set_server_active_power_cycle(
system)
return check_action_result(result)
def patch_account(account):
parameters.verify_account_name(account)
view_helper.run_pre_check(pre_check.pre_check_function_call,
command_name_enum.set_rm_config)
actions = {
"Password": (controls.manage_user.user_update_password,
parameter_parser("pwd", str), {
"username": account
}),
"RoleId": (controls.manage_user.user_update_role,
parameter_parser("role", str, enums.RoleId), {
"username": account
})
}
result = validate_patch_request_and_execute(actions, "account")
return get_handler.get_account(account, patch=result)
def post_rack_manager_fw_update():
view_helper.run_pre_check(pre_check.pre_check_function_call,
command_name_enum.set_rm_config)
validation = {"File": parameter_parser("filename", str)}
params = validate_action_parameters(validation)
result = controls.manage_rack_manager.set_rack_manager_fwupdate(**params)
return check_action_result(result)
def patch_system_power(system):
system = int(system)
view_helper.run_pre_check(pre_check.pre_check_function_call,
command_name_enum.set_blade_config,
device_id=system)
limit_args = {}
actions = {
"PowerControl/[0]/PowerLimit/LimitInWatts":
(controls.manage_ocspower.set_server_power_limit,
parameter_parser("powerlimitvalue", int), {
"serverid": system
}),
"PowerControl/[0]/Oem/Microsoft/DefaultLimitInWatts":
(apply_default_power_limit, parameter_parser("power_limit", int), {
"server_id": system,
"args": limit_args
}),
"PowerControl/[0]/Oem/Microsoft/AutoRemoveDelayInSec":
(apply_default_power_limit, parameter_parser("auto_remove", int), {
"server_id": system,
"args": limit_args
}),
"PowerControl/[0]/Oem/Microsoft/FastThrottleDurationInMs":
(apply_default_power_limit, parameter_parser("ms_delay", int), {
"server_id": system,
"args": limit_args
}),
"PowerControl/[0]/Oem/Microsoft/AlertAction":
(controls.manage_ocspower.set_server_activate_psu_alert,
parameter_parser("alert_action", int, enums.AlertAction), {
"serverid": system
})
}
result = validate_patch_request_and_execute(actions, "system_power")
limit = apply_default_power_limit(server_id=system,
force_set=True,
args=limit_args)
view_helper.append_response_information(result, limit)
return get_handler.get_system_power(system, patch=result)
def post_switch_fw_update():
view_helper.run_pre_check(pre_check.pre_check_function_call,
command_name_enum.set_rm_config)
validation = {"File": parameter_parser("fw_file", str)}
params = validate_action_parameters(validation)
switch = models.switch_manager.getswitch(load_config.switch_ip,
load_config.switch_uart)
result = switch.do_upgrade(**params)
return check_action_result(result)
def post_system_remotemedia_mount(system):
system = int(system)
view_helper.run_pre_check(pre_check.pre_check_function_call,
command_name_enum.set_blade_state,
device_id=system)
validation = {"ImageName": parameter_parser("imagename", str)}
params = validate_action_parameters(validation)
result = controls.manage_rmedia.mount_rmedia(system, **params)
return check_action_result(result)
def post_system_power_fw_update(system):
system = int(system)
view_helper.run_pre_check(pre_check.pre_check_function_call,
command_name_enum.set_blade_config,
device_id=system)
validation = {
"File": parameter_parser("fw_path", str),
"FWRegion": parameter_parser("fw_type", int, FWRegion)
}
params = validate_action_parameters(validation)
params["blade_id"] = system
params["fw_type"] = controls.blade_fw_update.blade_fw_type(
params["fw_type"])
result = controls.blade_fw_update.start_psu_fw_update(**params)
if ("FW Status" in result):
result[completion_code.desc] = result["FW Status"]
return check_action_result(result)
def patch_row_manager_power_control(rack):
view_helper.run_pre_check(pre_check.pre_check_function_call,
command_name_enum.set_rm_state)
rack = int(rack)
actions = {
"PowerState": (controls.manage_powerport.powerport_set_system_reset,
parameter_parser("action_type", str, enums.PowerState,
{"to_lower": True}), {
"port_id": rack,
"port_type": "pdu"
}),
"BootStrapping":
(controls.manage_powerport.powerport_set_row_boot_strapping,
parameter_parser("strapping", str, enums.BootStrapping), {
"port_id": rack
})
}
result = validate_patch_request_and_execute(actions,
"power_control_manager")
return get_handler.get_row_manager_power_control(rack, patch=result)
def patch_rack_manager_chassis():
view_helper.run_pre_check(pre_check.pre_check_function_call,
command_name_enum.set_rm_state)
actions = {
"IndicatorLED":
(controls.manage_rack_manager.set_rack_manager_attention_led,
parameter_parser("setting", int, enums.IndicatorLED), {}),
}
result = validate_patch_request_and_execute(actions,
"rack_manager_chassis")
return get_handler.get_rack_manager_chassis(patch=result)
def patch_system(system):
system = int(system)
view_helper.run_pre_check(pre_check.pre_check_function_call,
command_name_enum.set_blade_state,
device_id=system)
next_boot_args = {"serverid": system}
actions = {
"Boot/BootSourceOverrideTarget":
(apply_blade_next_boot,
parameter_parser("boottype", str, enums.BootSourceOverrideTarget,
{"cmd_arg": True}), {
"args": next_boot_args
}),
"Boot/BootSourceOverrideMode":
(apply_blade_next_boot,
parameter_parser("mode", int, enums.BootSourceOverrideMode), {
"args": next_boot_args
}),
"Oem/Microsoft/TPMPhysicalPresence":
(controls.bladetpmphypresence_lib.set_tpm_physical_presence,
parameter_parser("presence", int, enums.Boolean), {
"serverid": system
}),
"Oem/Microsoft/DefaultPowerState":
(controls.bladepowerstate_lib.set_server_default_powerstate,
parameter_parser("state", str, enums.PowerState), {
"serverid": system
})
}
result = validate_patch_request_and_execute(actions, "system")
next_boot = apply_blade_next_boot(force_set=True, args=next_boot_args)
view_helper.append_response_information(result, next_boot)
return get_handler.get_system(system, patch=result)
def patch_system_chassis(system):
system = int(system)
view_helper.run_pre_check(pre_check.pre_check_function_call,
command_name_enum.set_blade_state,
device_id=system)
actions = {
"IndicatorLED": (controls.bladepowerstate_lib.set_server_attention_led,
parameter_parser("state", int, enums.IndicatorLED), {
"serverid": system
})
}
result = validate_patch_request_and_execute(actions, "system_chassis")
return get_handler.get_system_chassis(system, patch=result)
def patch_system_fpga(system):
system = int(system)
view_helper.run_pre_check(pre_check.pre_check_function_call,
command_name_enum.set_blade_state,
device_id=system)
actions = {
"BypassMode": (controls.manage_fpga.set_fpga_bypass,
parameter_parser("bypass", str, enums.BypassMode), {
"serverid": system
})
}
result = validate_patch_request_and_execute(actions, "system_fpga")
return get_handler.get_system_fpga(system, patch=result)
def post_switch_reset():
view_helper.run_pre_check(pre_check.pre_check_function_call,
command_name_enum.set_rm_state)
validation = {
"ResetType":
parameter_parser("type", str, ResetType,
{"valid": [ResetType.FORCE_RESTART]})
}
validate_action_parameters(validation)
switch = models.switch_manager.getswitch(load_config.switch_ip,
load_config.switch_uart)
result = switch.do_reset()
return check_action_result(result)
def patch_relay_control(relay):
view_helper.run_pre_check(pre_check.pre_check_function_call,
command_name_enum.set_rm_state)
relay = int(relay)
actions = {
"PowerState": (controls.manage_powerport.powerport_set_system_reset,
parameter_parser("action_type", str, enums.PowerState,
{"to_lower": True}), {
"port_id": relay,
"port_type": "relay"
})
}
result = validate_patch_request_and_execute(actions, "power_control_relay")
return get_handler.get_relay_control(relay, patch=result)
def patch_system_bios_config(system):
system = int(system)
view_helper.run_pre_check(pre_check.pre_check_function_call,
command_name_enum.set_blade_config,
device_id=system)
actions = {
"ChosenConfiguration":
(apply_bios_configuration,
parameter_parser("config", str, validate_bios_configuration), {
"server_id": system
})
}
result = validate_patch_request_and_execute(actions, "system_bios_cfg")
return get_handler.get_system_bios_config(system, patch=result)
def post_system_power_fw_update_state(system):
system = int(system)
view_helper.run_pre_check(pre_check.pre_check_function_call,
command_name_enum.set_blade_config,
device_id=system)
validation = {"Operation": parameter_parser("operation", int, Operation)}
params = validate_action_parameters(validation)
op = controls.blade_fw_update.blade_fw_operation(params["operation"])
if (op == controls.blade_fw_update.blade_fw_operation_enum.ABORT):
result = controls.blade_fw_update.abort_psu_fw_update(system)
else:
result = controls.blade_fw_update.query_psu_fw_update(system)
if ("FW Status" in result):
result[completion_code.desc] = result["FW Status"]
return check_action_result(result)
def post_system_power_limit_rearm_trigger(system):
system = int(system)
view_helper.run_pre_check(pre_check.pre_check_function_call,
command_name_enum.set_blade_state,
device_id=system)
validation = {"RearmType": parameter_parser("rearm", int, RearmType)}
params = validate_action_parameters(validation)
current = controls.manage_ocspower.get_server_default_power_limit(system)
if (current.get(completion_code.cc_key, completion_code.failure) !=
completion_code.success):
view_helper.raise_status_response(
500, view_helper.create_response_with_status(current))
params["alert_action"] = int(
AlertAction(current["AlertAction"], convert=True))
result = controls.manage_ocspower.set_server_activate_psu_alert(
system, **params)
return check_action_result(result)
def patch_rack_manager_ethernet(eth):
view_helper.run_pre_check(pre_check.pre_check_function_call,
command_name_enum.set_rm_config)
requested = view_helper.get_json_request_data()
if ("IPv4Addresses" in requested):
address = requested["IPv4Addresses"]
if (len(address) > 1):
raise HTTPError(
status=400,
body="No more than one IP address may be specified.")
ip_args = {}
mgmt_args = {}
actions = {
"IPv4Addresses/[0]/Address":
(apply_ip_address, parameter_parser("address", str, IPAddress), {
"args": ip_args
}),
"IPv4Addresses/[0]/SubnetMask":
(apply_ip_address,
parameter_parser("mask", str,
parameter_parser.validate_subnet_mask), {
"args": ip_args
}),
"IPv4Addresses/[0]/AddressOrigin":
(apply_ip_address,
parameter_parser("addr_type", str, enums.AddressOrigin), {
"args": ip_args
})
}
if (eth == "eth0"):
actions.update({
"IPv4Addresses/[0]/Gateway":
(apply_ip_address, parameter_parser("gateway", str, IPAddress), {
"args": ip_args
}),
})
else:
actions.update({
"Oem/Microsoft/MgmtGateway":
(apply_management_gateway,
parameter_parser("gateway", str, IPAddress), {
"args": mgmt_args
}),
"Oem/Microsoft/MgmtNetmask":
(apply_management_gateway,
parameter_parser("mask", str,
parameter_parser.validate_subnet_mask), {
"args": mgmt_args
})
})
result = validate_patch_request_and_execute(actions,
"rack_manager_ethernet",
default_params={"Intf": eth})
if (not result):
if (ip_args):
ip_args["if_name"] = eth
set_data = apply_ip_address(save_args=False, args=ip_args)
view_helper.append_response_information(result, set_data)
if (mgmt_args):
set_data = apply_management_gateway(save_args=False,
args=mgmt_args)
view_helper.append_response_information(result, set_data)
return get_handler.get_rack_manager_ethernet(eth, patch=result)
def patch_rack_manager():
view_helper.run_pre_check(pre_check.pre_check_function_call,
command_name_enum.set_rm_config)
actions = {
"DateTime": (controls.manage_rack_manager.set_rack_manager_time,
parameter_parser("datetime", str, validate_datetime), {}),
"Oem/Microsoft/HostName": (controls.manage_rack_manager.set_hostname,
parameter_parser("hostname", str), {}),
"Oem/Microsoft/TFTP/ServiceStatus":
(controls.manage_rack_manager.set_manager_tftp_service_state,
parameter_parser("state", str, enums.ServiceStatus), {}),
"Oem/Microsoft/TFTP/ServiceEnabled":
(controls.manage_rack_manager.set_manager_tftp_service_config,
parameter_parser("enable", bool, parameter_parser.validate_bool), {}),
"Oem/Microsoft/NFS/ServiceStatus":
(controls.manage_rack_manager.set_manager_nfs_service_state,
parameter_parser("state", str, enums.ServiceStatus), {}),
"Oem/Microsoft/NFS/ServiceEnabled":
(controls.manage_rack_manager.set_manager_nfs_service_config,
parameter_parser("enable", bool, parameter_parser.validate_bool), {}),
"Oem/Microsoft/NTP/ServiceStatus":
(controls.manage_rack_manager.set_manager_ntp_service_state,
parameter_parser("state", str, enums.ServiceStatus), {}),
"Oem/Microsoft/NTP/ServiceEnabled":
(controls.manage_rack_manager.set_manager_ntp_service_config,
parameter_parser("enable", bool, parameter_parser.validate_bool), {}),
"Oem/Microsoft/NTP/TimeServer":
(controls.manage_rack_manager.set_rack_manager_ntp_server,
parameter_parser("server_ip", str, IPAddress), {}),
"Oem/Microsoft/ThrottleControl/LocalBypass":
(controls.manage_rack_manager.set_manager_throttle_local_bypass,
parameter_parser("enable", bool, parameter_parser.validate_bool), {}),
"Oem/Microsoft/ThrottleControl/LocalEnable":
(controls.manage_rack_manager.set_manager_throttle_output_enable,
parameter_parser("enable", bool, parameter_parser.validate_bool), {})
}
if (not pre_check.get_mode() == rm_mode_enum.rowmanager):
actions.update({
"Oem/Microsoft/RemoteITP/ServiceStatus":
(controls.manage_rack_manager.set_manager_itp_service_state,
parameter_parser("state", str, enums.ServiceStatus), {}),
"Oem/Microsoft/RemoteITP/ServiceEnabled":
(controls.manage_rack_manager.set_manager_itp_service_config,
parameter_parser("enable", bool,
parameter_parser.validate_bool), {})
})
else:
actions.update({
"Oem/Microsoft/ThrottleControl/RowBypass":
(controls.manage_rack_manager.set_row_throttle_bypass,
parameter_parser("enable", bool,
parameter_parser.validate_bool), {}),
"Oem/Microsoft/ThrottleControl/RowEnable":
(controls.manage_rack_manager.set_row_throttle_output_enable,
parameter_parser("enable", bool,
parameter_parser.validate_bool), {})
})
result = validate_patch_request_and_execute(actions, "rack_manager")
return get_handler.get_rack_manager(patch=result)
