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)