private BladePowerStatePacket GetBladePowerState(byte deviceId) { // Initialize return packet BladePowerStatePacket returnPacket = new BladePowerStatePacket(); returnPacket.CompletionCode = CompletionCode.UnspecifiedError; returnPacket.BladePowerState = 3; try { BladePowerStateResponse stateResponse = (BladePowerStateResponse)this.SendReceive(this.DeviceType, deviceId, new BladePowerStateRequest(), typeof(BladePowerStateResponse)); if (stateResponse.CompletionCode != 0) { returnPacket.CompletionCode = (CompletionCode)stateResponse.CompletionCode; } else { returnPacket.CompletionCode = CompletionCode.Success; returnPacket.BladePowerState = stateResponse.BladePowerState; returnPacket.DecompressionTime = stateResponse.DecompressionTime; } } catch (System.Exception ex) { returnPacket.CompletionCode = CompletionCode.UnspecifiedError; returnPacket.BladePowerState = 2; Tracer.WriteError(this.DeviceId, this.DeviceType, ex); } return(returnPacket); }
private BladePowerStatePacket SetBladePowerState(byte deviceId, byte state) { // Initialize return packet BladePowerStatePacket returnPacket = new BladePowerStatePacket(); returnPacket.CompletionCode = CompletionCode.UnspecifiedError; returnPacket.BladePowerState = 3; Tracer.WriteInfo("SetSledPowerState Switch id: " + deviceId); if (state == (byte)Contracts.PowerState.ON) { try { BladePowerStateOnResponse response = (BladePowerStateOnResponse)this.SendReceive(this.DeviceType, deviceId, new BladePowerStateOnRequest(state), typeof(BladePowerStateOnResponse)); if (response.CompletionCode != 0) { returnPacket.CompletionCode = (CompletionCode)response.CompletionCode; } else { returnPacket.CompletionCode = CompletionCode.Success; returnPacket.BladePowerState = 1; //NOTE: response is not actually returned. returnPacket.DecompressionTime = response.DecompressionTime; } } catch (System.Exception ex) { returnPacket.CompletionCode = CompletionCode.UnspecifiedError; returnPacket.BladePowerState = 3; Tracer.WriteError(this.DeviceId, DeviceType.Power, ex); } } else { try { BladePowerStateOffResponse response = (BladePowerStateOffResponse)this.SendReceive(this.DeviceType, deviceId, new BladePowerStateOffRequest(state), typeof(BladePowerStateOffResponse)); if (response.CompletionCode != 0) { returnPacket.CompletionCode = (CompletionCode)response.CompletionCode; } else { returnPacket.CompletionCode = CompletionCode.Success; returnPacket.BladePowerState = 0; // blade is off returnPacket.DecompressionTime = 0; // blade is off. } } catch (System.Exception ex) { returnPacket.CompletionCode = CompletionCode.UnspecifiedError; returnPacket.BladePowerState = 3; Tracer.WriteError(this.DeviceId, DeviceType.Power, ex); } } return(returnPacket); }
/// <summary> /// Reinitialize the sled and set chassis state /// </summary> private void ReInitialize(byte sledId) { // Serialize initialize and power behavior per sled lock (ChassisState._lock[sledId - 1]) { ChassisState.FailCount[sledId - 1] = 0; // reset fail count since we are going to reinitialize the blade bool status = WcsBladeFacade.InitializeClient(sledId); // TODO: no completion code, only byte status returned if (status != true) { // Initialization failed - move to fail state before retrying again Tracer.WriteInfo("Reinitialization failed with code: {0} for Sled: {1}", status, sledId); Tracer.WriteInfo("State Transition for Sled {0}: {1} -> Fail", sledId, ChassisState.GetStateName(sledId)); ChassisState.SetBladeState((byte)sledId, (byte)BladeState.Fail); // check power status to see if the blade was manually switched off or removed BladePowerStatePacket response = ChassisState.BladePower[sledId - 1].GetBladePowerState(); // If the blade was turned off, set correct status / TODO: do we need this here? if (response.BladePowerState == (byte)Contracts.PowerState.OFF) { Tracer.WriteInfo("SledId {0} is in hard power off state", sledId); Tracer.WriteInfo("State Transition for Sled {0}: {1} -> HardPowerOff", sledId, ChassisState.GetStateName(sledId)); ChassisState.SetBladeState(sledId, (byte)BladeState.HardPowerOff); } } else { // State change: I -> P Tracer.WriteInfo("Reinitialization of Sled: {0} succeeded with status {1}", sledId, status); Tracer.WriteInfo("State Transition for Sled {0}: {1} -> Probation", sledId, ChassisState.GetStateName(sledId)); ChassisState.SetBladeState(sledId, (byte)BladeState.Probation); // Initialize Blade Type (Type might have changed when Blades were reinserted) if (WcsBladeFacade.clients.ContainsKey(sledId)) { ChassisState.BladeTypeCache[sledId - 1] = (byte)WcsBladeFacade.clients[sledId].BladeClassification; } else { ChassisState.BladeTypeCache[sledId - 1] = (byte)BladeType.Unknown; } } } }
/// <summary> /// Internal operation to call both hard power on (soft power on is not exposed to the user) /// </summary> /// <param name="bladeId">Blade ID</param> /// <returns>True/false for success/failure</returns> internal static bool PowerOn(int bladeId) { Tracer.WriteInfo("Received poweron({0})", bladeId); bool powerOnStatus = false; BladePowerStatePacket bladePowerSwitchStatePacket = new BladePowerStatePacket(); CompletionCode status; // Hard Power enable // Serialize setting of state and actual code logic lock (ChassisState.locker[bladeId - 1]) { BladePowerStatePacket currState = ChassisState.BladePower[bladeId - 1].GetBladePowerState(); if (currState.CompletionCode != CompletionCode.Success || (currState.BladePowerState == (byte)Contracts.PowerState.OFF)) { // No return here, because we still want to return a BMC state on the fall through, // if Blade enable read fails for whatever reason Tracer.WriteWarning("PowerOn: Blade {0} Power Enable state read failed (Completion Code: {1:X})", bladeId, currState.CompletionCode); bladePowerSwitchStatePacket = ChassisState.BladePower[bladeId - 1].SetBladePowerState((byte)PowerState.ON); status = bladePowerSwitchStatePacket.CompletionCode; Tracer.WriteInfo("Hard poweron status " + status); if (status == CompletionCode.Success) { // Hard power on status is true, so Blade should be set to Initialization state on success Tracer.WriteInfo("PowerOn: State Transition for blade {0}: {1} -> Initialization", bladeId, ChassisState.GetStateName((byte)bladeId)); ChassisState.SetBladeState((byte)bladeId, (byte)BladeState.Initialization); powerOnStatus = true; } else { Tracer.WriteWarning("PowerOn: Hard Power On failed for BladeId {0} with code {1:X}", bladeId, status); } } else { powerOnStatus = true; // the blade was already powered on, so we dont power it on again } } return(powerOnStatus); }
/// <summary> /// Checks the power enable state of the blade and changes state accordingly /// </summary> /// <param name="deviceId"></param> private static void CheckPowerEnableState(byte deviceId) { // Serialize power behavior lock (ChassisState.locker[deviceId - 1]) { BladePowerStatePacket response = ChassisState.BladePower[deviceId - 1].GetCachedBladePowerState(); if (response.CompletionCode != CompletionCode.Success) { Tracer.WriteInfo("CheckPowerEnableState: Blade {0} Power Enable state read failed (Completion Code: {1:X})", deviceId, response.CompletionCode); } else { if (response.BladePowerState == (byte)Contracts.PowerState.ON) { if (ChassisState.GetBladeState((byte)deviceId) == (byte)BladeState.HardPowerOff) { // Blade is powered on, move to initialization state Tracer.WriteInfo("CheckPowerEnableState: State Transition for blade {0}: {1} -> Initialization", deviceId, ChassisState.GetStateName(deviceId)); ChassisState.SetBladeState((byte)deviceId, (byte)BladeState.Initialization); } } else if (response.BladePowerState == (byte)Contracts.PowerState.OFF) { if (ChassisState.GetBladeState((byte)deviceId) != (byte)BladeState.HardPowerOff) { // Blade is powered off, move to PowerOff state Tracer.WriteInfo("CheckPowerEnableState: State Transition for blade {0}: {1} -> HardPowerOff", deviceId, ChassisState.GetStateName(deviceId)); ChassisState.SetBladeState((byte)deviceId, (byte)BladeState.HardPowerOff); } } else { Tracer.WriteInfo("CheckPowerEnableState: Getting out of else block"); // TODO: do we need to do anything for state that is NA } } } }
private static void EnableDisableDefaultBladeOperations(int bladeId) { // TODO: Check blade type etc and Kill any serial session // TODO: Add trace log messages // Check to see if the blade is hard powered off BladePowerStatePacket response = ChassisState.BladePower[bladeId - 1].GetBladePowerState(); if (response.CompletionCode != CompletionCode.Success) { // Log error here, and proceed to check blade state since we still want to check BMC soft power status // even if blade enable read failed for whatever reason Tracer.WriteError("EnableDisableDefaultBladeOperations: Blade {0} Power Enable state read failed (Completion Code: {1:X})", bladeId, response.CompletionCode); } else if (response.BladePowerState == (byte)Contracts.PowerState.OFF) { // If blade is hard powered off, no further processing is necessary return; } // If the blade is a Jbod, return since the operations done in this method do not apply for Jbods if (ChassisState.GetBladeType((byte)bladeId) == (byte)BladeType.Jbod) { Tracer.WriteInfo("EnableDisableDefaultBladeOperations (Blade#{0}): Ignoring since it is a Jbod", bladeId); return; } DatasafeOperationSupport.ProcessDatasafeAction(bladeId, ConfigLoaded.DatasafeOperationsEnabled ? DatasafeActions.EnableDatasafe : DatasafeActions.DisableDatasafe); if (ConfigLoaded.PsuAlertMonitorEnabled) { WcsBladeFacade.ActivatePsuAlert((byte)bladeId, true, BmcPsuAlertAction.ProcHotAndDpc, true); } else { WcsBladeFacade.ActivatePsuAlert((byte)bladeId, false, BmcPsuAlertAction.NoAction, true); } }
/// <summary> /// Internal method to Power off blade /// </summary> /// <param name="bladeId">Blade ID(1-48)</param> /// <returns>true/false if operation was success/failure</returns> internal static bool PowerOff(int bladeId) { Tracer.WriteInfo("Received poweroff({0})", bladeId); bool powerOffStatus = false; BladePowerStatePacket bladePowerSwitchStatePacket = new BladePowerStatePacket(); // Serialize power off and power on, on the same lock variable per blade, so we prevent inconsistent power state behavior lock (ChassisState.locker[bladeId - 1]) { bladePowerSwitchStatePacket = ChassisState.BladePower[bladeId - 1].SetBladePowerState((byte)PowerState.OFF); CompletionCode status = bladePowerSwitchStatePacket.CompletionCode; // Sleep for specified amount of time after blade hard power off to prevent hardware inconsistent state // - hot-swap controller not completely draining its capacitance leading to inconsistent power state issues Thread.Sleep(ConfigLoaded.WaitTimeAfterBladeHardPowerOffInMsecs); Tracer.WriteInfo("PowerOff: Return: {0}", status); if (status != CompletionCode.Success) { Tracer.WriteError("PowerOff: Blade Hard Power Off Failed with Completion code {0:X}", status); powerOffStatus = false; } else { powerOffStatus = true; // set state to Hard Power Off Tracer.WriteInfo("PowerOff: State Transition for blade {0}: {1} -> HardPowerOff", bladeId, ChassisState.GetStateName((byte)bladeId)); ChassisState.SetBladeState((byte)bladeId, (byte)BladeState.HardPowerOff); ChassisState.PowerFailCount[bladeId - 1] = 0; // Clear blade type and cache ChassisState.BladeTypeCache[bladeId - 1] = (byte)BladeType.Unknown; WcsBladeFacade.ClearBladeClassification((byte)bladeId); } } return(powerOffStatus); }
/// <summary> /// Internal operation to call both hard power on (soft power on is not exposed to the user) /// </summary> /// <param name="bladeId">Blade ID</param> /// <returns>True/false for success/failure</returns> internal static bool PowerOn(int bladeId) { Tracer.WriteInfo("Received poweron({0})", bladeId); bool powerOnStatus = false; BladePowerStatePacket bladePowerSwitchStatePacket = new BladePowerStatePacket(); CompletionCode status; // Hard Power enable // Serialize setting of state and actual code logic lock (ChassisState.locker[bladeId - 1]) { BladePowerStatePacket currState = ChassisState.BladePower[bladeId - 1].GetBladePowerState(); if (currState.CompletionCode != CompletionCode.Success || (currState.BladePowerState == (byte)Contracts.PowerState.OFF)) { // No return here, because we still want to return a BMC state on the fall through, // if Blade enable read fails for whatever reason Tracer.WriteWarning("PowerOn: Blade {0} Power Enable state read failed (Completion Code: {1:X})", bladeId, currState.CompletionCode); bladePowerSwitchStatePacket = ChassisState.BladePower[bladeId - 1].SetBladePowerState((byte)PowerState.ON); status = bladePowerSwitchStatePacket.CompletionCode; Tracer.WriteInfo("Hard poweron status " + status); if (status == CompletionCode.Success) { // Hard power on status is true, so Blade should be set to Initialization state on success Tracer.WriteInfo("PowerOn: State Transition for blade {0}: {1} -> Initialization", bladeId, ChassisState.GetStateName((byte)bladeId)); ChassisState.SetBladeState((byte)bladeId, (byte)BladeState.Initialization); powerOnStatus = true; } else { Tracer.WriteWarning("PowerOn: Hard Power On failed for SledId {0} with code {1:X}", bladeId, status); } } else { powerOnStatus = true; // the blade was already powered on, so we dont power it on again } } return powerOnStatus; }
/// <summary> /// Internal method to Power off blade /// </summary> /// <param name="bladeId">Blade ID(1-48)</param> /// <returns>true/false if operation was success/failure</returns> internal static bool PowerOff(int bladeId) { Tracer.WriteInfo("Received poweroff({0})", bladeId); bool powerOffStatus = false; BladePowerStatePacket bladePowerSwitchStatePacket = new BladePowerStatePacket(); // Serialize power off and power on, on the same lock variable per blade, so we prevent inconsistent power state behavior lock (ChassisState.locker[bladeId - 1]) { bladePowerSwitchStatePacket = ChassisState.BladePower[bladeId - 1].SetBladePowerState((byte)PowerState.OFF); CompletionCode status = bladePowerSwitchStatePacket.CompletionCode; // Sleep for specified amount of time after blade hard power off to prevent hardware inconsistent state // - hot-swap controller not completely draining its capacitance leading to inconsistent power state issues Thread.Sleep(ConfigLoaded.WaitTimeAfterBladeHardPowerOffInMsecs); Tracer.WriteInfo("PowerOff: Return: {0}", status); if (status != CompletionCode.Success) { Tracer.WriteError("PowerOff: Blade Hard Power Off Failed with Completion code {0:X}", status); powerOffStatus = false; } else { powerOffStatus = true; // set state to Hard Power Off Tracer.WriteInfo("PowerOff: State Transition for blade {0}: {1} -> HardPowerOff", bladeId, ChassisState.GetStateName((byte)bladeId)); ChassisState.SetBladeState((byte)bladeId, (byte)BladeState.HardPowerOff); ChassisState.PowerFailCount[bladeId - 1] = 0; // Clear blade type and cache ChassisState.BladeTypeCache[bladeId - 1] = (byte)BladeType.Unknown; WcsBladeFacade.ClearBladeClassification((byte)bladeId); } } return powerOffStatus; }
/// <summary> /// Function that gets fan speed requirements /// from all blades. It also updates the blade states. /// </summary> private static void GetAllBladePwmRequirements() { // Rate is required to timestep over each individual Blade call double rate = (double)getBladePwmReqtTimePeriodInMilliseconds / (double)MaxSledCount; double timeDiff = 0; for (byte blade = 1; blade <= MaxSledCount; blade++) { // Handle shutdown state if (ChassisState.ShutDown) { return; } // default PWM setting byte PWM = (byte)ConfigLoaded.MinPWM; // Query blade type from IPMI layer ChassisState.BladeTypeCache[blade - 1] = (byte)WcsBladeFacade.clients[blade].BladeClassification; // wait for rate limiter which includes the previous time difference for sensor get, and then issue get fan requirement double sleepTime = rate - timeDiff; if (sleepTime > rate) { sleepTime = rate; } if (sleepTime > 0) { Thread.Sleep(TimeSpan.FromMilliseconds(sleepTime)); } Tracer.WriteInfo("GetBladeRequirement called at {0} for BladeId {1} (state: {2})", DateTime.Now, blade, ChassisState.GetStateName(blade)); // Check for the condition where known state is hardpoweroff, but someone plugged a new blade in if (ChassisState.GetBladeState(blade) == (byte)BladeState.HardPowerOff) { CheckPowerEnableState(blade); } // Log Start time DateTime startTime = DateTime.Now; #region Check fail State -> Initialize // If blade was in Fail state if (ChassisState.GetBladeState(blade) == (byte)BladeState.Fail) { // If failed count is greater than a maximum value, we move it to Initialization state if (ChassisState.FailCount[blade - 1] > ConfigLoaded.MaxFailCount) { // Move to Initialization state so that this blade could be reinitialized Tracer.WriteInfo("GetAllBladePwmRequirements: State Transition for blade {0}: {1} -> Initialization", blade, ChassisState.GetStateName(blade)); ChassisState.SetBladeState(blade, (byte)BladeState.Initialization); } else { // Moving out of Fail state - First we use a light-weight get GUID to check whether the blade is there. // do not allow retries on Get System Guid DeviceGuid guid = WcsBladeFacade.GetSystemGuid(blade, false); if (guid.CompletionCode == (byte)CompletionCode.Success) { Tracer.WriteInfo("GetAllBladePwmRequirements: GUID present for blade {0}, GUID: {1}", blade, guid.Guid.ToString()); DeviceGuid cachedGuid = WcsBladeFacade.GetCachedGuid(blade); if (guid.Guid == cachedGuid.Guid) { // Change state to Probation and assume the system was in fail due to timeout. Tracer.WriteInfo("GetAllBladePwmRequirements: State Transition for blade {0}: {1} -> Probation", blade, ChassisState.GetStateName(blade)); ChassisState.SetBladeState(blade, (byte)BladeState.Probation); } else { // Change state to Initialization as the device has changed. Tracer.WriteInfo("GetAllBladePwmRequirements: State Transition for blade {0}: {1} -> Probation", blade, ChassisState.GetStateName(blade)); ChassisState.SetBladeState(blade, (byte)BladeState.Initialization); } } else { Tracer.WriteInfo("GetAllBladePwmRequirements: Get System GUID returns a bad completion status: {0}", guid.CompletionCode); } } // Increase time spent in Fail state everytime we are in this state ChassisState.FailCount[blade - 1]++; } #endregion #region Move Initialize -> Probation // Handles Initialization if (ChassisState.GetBladeState(blade) == (byte)BladeState.Initialization) { BladePowerStatePacket powerstate = ChassisState.BladePower[blade - 1].GetCachedBladePowerState(); if (powerstate.CompletionCode == 0) { if (powerstate.DecompressionTime == 0) { // Will result in Hard Power off or Probation ReInitialize(blade); } } } #endregion // Normal operation - possible states are probation or healthy if (ChassisState.GetBladeState(blade) == (byte)BladeState.Probation || ChassisState.GetBladeState(blade) == (byte)BladeState.Healthy) { #region Jbod (no sensor reading) if (ChassisState.GetBladeType(blade) == (byte)BladeType.Jbod) { // Do not allow retries on system guid. DeviceGuid guid = WcsBladeFacade.GetSystemGuid(blade, false); if (guid.CompletionCode == (byte)CompletionCode.Success) { Tracer.WriteInfo("GetAllBladePwmRequirements: GUID present for JBOD {0}, GUID: {1}", blade, guid.Guid.ToString()); // Change state to Healthy if (ChassisState.GetBladeState(blade) == (byte)BladeState.Probation) { Tracer.WriteInfo("GetAllBladePwmRequirements: State Transition for JBOD {0}: {1} -> Healthy", blade, ChassisState.GetStateName(blade)); ChassisState.SetBladeState(blade, (byte)BladeState.Healthy); } } else { Tracer.WriteInfo("GetAllBladePwmRequirements: Get System GUID for JBOD {0} failed with status {1}", blade, guid.CompletionCode); // Set it to failed state, where we will retry guids and reinitialize if needed Tracer.WriteInfo("GetAllBladePwmRequirements: State Transition for JBOD {0}: {1} -> Fail", blade, ChassisState.GetStateName(blade)); ChassisState.SetBladeState(blade, (byte)BladeState.Fail); } // No need to check for sensor reading, just continue continue; } #endregion #region Server -> Get PWM move to Healthy or move to Fail // Call temperature reading list command SensorReading Temps = WcsBladeFacade.GetSensorReading((byte)blade, (byte)ConfigLoaded.InputSensor, PriorityLevel.System); if (Temps.CompletionCode != (byte)CompletionCode.Success) { Tracer.WriteWarning("GetAllBladePwmRequirements: BladeId: {0} - GetSensorReading for temperature failed with code {1:X}", blade, Temps.CompletionCode); // Move to Fail state if no readings were obtained Tracer.WriteInfo("GetAllBladePwmRequirements: State Transition for blade {0}: {1} -> Fail", blade, ChassisState.GetStateName(blade)); ChassisState.SetBladeState(blade, (byte)BladeState.Fail); } else { Tracer.WriteInfo("GetAllBladePwmRequirements: #### BladeId = " + blade + " Sensor id= " + ConfigLoaded.InputSensor + " Sensor reading = " + Temps.Reading + " Raw = " + Temps.RawReading + ", LowerNonCritical= " + ConfigLoaded.SensorLowThreshold + ", UpperNonCritical= " + ConfigLoaded.SensorHighThreshold); // Handle state logic if needed // Probation state should be shifted to Healthy since there was no timeout, & sensorread succeeded if (ChassisState.GetBladeState(blade) == (byte)BladeState.Probation) { // Change state to healthy Tracer.WriteInfo("GetAllBladePwmRequirements: State Transition for blade {0}: {1} -> Healthy", blade, ChassisState.GetStateName(blade)); ChassisState.SetBladeState(blade, (byte)BladeState.Healthy); ChassisState.FailCount[blade - 1] = 0; // reset the fail count // When a blade transitions to 'Healthy' state, enable/disable default blade operations EnableDisableDefaultBladeOperations(blade); } if (ConfigLoaded.InputSensor != 1) // Non-PWM sensor. { PWM = GetPwmFromTemperature(Temps.Reading, ConfigLoaded.SensorLowThreshold, ConfigLoaded.SensorHighThreshold); } else { // PWM should never be higher or lower than the threshold. if (Temps.Reading < ConfigLoaded.MinPWM || Temps.Reading > ConfigLoaded.MaxPWM) { Tracer.WriteWarning("PWM value " + Temps.Reading + " on blade " + blade + " is out of range (lowThreshold: " + ConfigLoaded.MinPWM + " - highThreshold: " + ConfigLoaded.MaxPWM); PWM = (byte)ConfigLoaded.MinPWM; } else { PWM = (byte)Temps.Reading; } } Tracer.WriteInfo("PWM value on blade {0} for Sensor {1} = {2}", blade, InputSensor, PWM); } #endregion } // write value into requirements table BladeRequirementTable[blade - 1] = PWM; // Log end time and capture time of execution for sensor get command DateTime endTime = DateTime.Now; timeDiff = endTime.Subtract(startTime).TotalMilliseconds; // convert time difference into milliseconds } }
private BladePowerStatePacket SetBladePowerState(byte deviceId, byte state) { // Initialize return packet BladePowerStatePacket returnPacket = new BladePowerStatePacket(); returnPacket.CompletionCode = CompletionCode.UnspecifiedError; returnPacket.BladePowerState = 3; Tracer.WriteInfo("SetSledPowerState Switch id: " + deviceId); if (state == (byte)Contracts.PowerState.ON) { try { BladePowerStateOnResponse response = (BladePowerStateOnResponse)this.SendReceive(this.DeviceType, deviceId, new BladePowerStateOnRequest(state), typeof(BladePowerStateOnResponse)); if (response.CompletionCode != 0) { returnPacket.CompletionCode = (CompletionCode)response.CompletionCode; } else { returnPacket.CompletionCode = CompletionCode.Success; returnPacket.BladePowerState = 1; //NOTE: response is not actually returned. returnPacket.DecompressionTime = response.DecompressionTime; } } catch (System.Exception ex) { returnPacket.CompletionCode = CompletionCode.UnspecifiedError; returnPacket.BladePowerState = 3; Tracer.WriteError(this.DeviceId, DeviceType.Power, ex); } } else { try { BladePowerStateOffResponse response = (BladePowerStateOffResponse)this.SendReceive(this.DeviceType, deviceId, new BladePowerStateOffRequest(state), typeof(BladePowerStateOffResponse)); if (response.CompletionCode != 0) { returnPacket.CompletionCode = (CompletionCode)response.CompletionCode; } else { returnPacket.CompletionCode = CompletionCode.Success; returnPacket.BladePowerState = 0; // blade is off returnPacket.DecompressionTime = 0; // blade is off. } } catch (System.Exception ex) { returnPacket.CompletionCode = CompletionCode.UnspecifiedError; returnPacket.BladePowerState = 3; Tracer.WriteError(this.DeviceId, DeviceType.Power, ex); } } return returnPacket; }
private BladePowerStatePacket GetCachedBladePowerState(byte deviceId) { // Initialize return packet BladePowerStatePacket returnPacket = new BladePowerStatePacket(); returnPacket.CompletionCode = CompletionCode.UnspecifiedError; returnPacket.BladePowerState = 3; try { BladeCachedPowerStateResponse stateResponse = (BladeCachedPowerStateResponse)this.SendReceive(this.DeviceType, deviceId, new BladeCachedPowerStateRequest(), typeof(BladeCachedPowerStateResponse)); if (stateResponse.CompletionCode != 0) { returnPacket.CompletionCode = (CompletionCode)stateResponse.CompletionCode; } else { returnPacket.CompletionCode = CompletionCode.Success; returnPacket.BladePowerState = stateResponse.BladePowerState; returnPacket.DecompressionTime = stateResponse.DecompressionTime; } } catch (System.Exception ex) { returnPacket.CompletionCode = CompletionCode.UnspecifiedError; returnPacket.BladePowerState = 3; Tracer.WriteError(this.DeviceId, DeviceType.Power, ex); } return returnPacket; }