/// <summary> /// Test Command: GetChassisInfo: Get Only blade information (bladeInfo=true). /// </summary> /// <param name="allPassed"></param> /// <param name="chassisInfo"></param> /// <returns>True if all check-points pass; false, otherwise.</returns> private TestResponse VerifyOnlyChassisBladeInfo(ChassisInfoResponse chassisInfo) { TestResponse response = new TestResponse(); try { response.Result = ChassisManagerTestHelper.IsTrue(chassisInfo != null, "Received chasssis information "); // Return if chassis information is null if (response.Result == false) { response.ResultDescription.Append("\nReceived chassis object is null"); return response; } if (chassisInfo.completionCode != CompletionCode.Success) { response.Result = false; response.ResultDescription.Append("\nFailed to get chassis information with only bladeInfo set to true, completion code returned: " + chassisInfo.completionCode); CmTestLog.Failure(response.ResultDescription.ToString()); return response; } CmTestLog.Success("Successfully received chassis information"); response = this.VerifyChassisBladeInfo(chassisInfo); // Verify battery info is empty if (!ChassisManagerTestHelper.IsTrue(chassisInfo.batteryCollections.Count == 0, "Battery information is empty")) { response.Result &= false; response.ResultDescription.Append("\nVerifyOnlyChassisBladeInfo failed: Battery information is not empty"); } // Verify PSU information is empty if (!ChassisManagerTestHelper.IsTrue(chassisInfo.psuCollections.Count == 0, "PSU information is empty")) { response.Result &= false; response.ResultDescription.Append("\nVerifyOnlyChassisBatteryInfo failed: PSU information is not empty"); } // Verify chassis controller info is empty if (!ChassisManagerTestHelper.IsTrue(chassisInfo.chassisController == null, "Chassis controller information is empty")) { response.Result &= false; response.ResultDescription.Append("\nVerifyOnlyChassisBatteryInfo failed: Chassis Controller information is not empty"); } } catch (Exception ex) { ChassisManagerTestHelper.IsTrue(false, ex.Message); response.Result = false; response.ResultDescription.Append(ex.Message); } return response; }
/// <summary> /// Verify chassis info /// </summary> /// <param name="allPassed">Flag indicating success/failure</param> /// <param name="chassisInfo">Chassis info response</param> /// <returns>returns success/failure</returns> private TestResponse VerifyChassisInfo(ChassisInfoResponse chassisInfo) { TestResponse response = new TestResponse(); response.Result = ChassisManagerTestHelper.IsTrue(chassisInfo != null, "Received chasssis information "); // Return if chassis information is null if (response.Result == false) { response.ResultDescription.Append("\nReceived chassis object is null"); return response; } if (chassisInfo.completionCode != CompletionCode.Success) { response.Result = false; response.ResultDescription.Append("\nFailed to get chassis information, completion code returned: " + chassisInfo.completionCode); CmTestLog.Failure(response.ResultDescription.ToString()); return response; } CmTestLog.Success("Successfully received chassis info"); TestResponse testResponse = VerifyChassisBladeInfo(chassisInfo); response.Result &= testResponse.Result; response.ResultDescription.Append(testResponse.ResultDescription); testResponse = VerifyChassisPsuInfo(chassisInfo); response.Result &= testResponse.Result; response.ResultDescription.Append(testResponse.ResultDescription); testResponse = VerifyChassisBatteryInfo(chassisInfo); response.Result &= testResponse.Result; response.ResultDescription.Append(testResponse.ResultDescription); testResponse = VerifyChassisControllerInfo(chassisInfo); response.Result &= testResponse.Result; response.ResultDescription.Append(testResponse.ResultDescription); return response; }
/// <summary> /// Test Command: GetChassisInfo: Get Only Battery information (batteryInfo=true). /// </summary> /// <param name="allPassed"></param> /// <param name="chassisHealth"></param> /// <returns>True if all check-points pass; false, otherwise.</returns> private TestResponse VerifyOnlyChassisBatteryInfo(ChassisInfoResponse chassisInfo) { TestResponse response = new TestResponse(); try { response.Result = ChassisManagerTestHelper.IsTrue(chassisInfo != null, "Received chasssis info "); // Return if chassis information is null if (response.Result == false) { response.ResultDescription.Append("\nReceived chassis object is null"); return response; } if (CmConstants.NumBatteries == 0) { foreach (var battery in chassisInfo.batteryCollections) { if (battery.completionCode != CompletionCode.Unknown || battery.presence != 0) { response.ResultDescription.Append(string.Format("\n Battery# {0} returns {1} when it should be Unknown", battery.id, battery.completionCode)); response.ResultDescription.Append(string.Format("Battery# {0} returns Presence value as {1}", battery.id, battery.presence)); response.Result &= false; return response; } } response.Result = true; response.ResultDescription.Append("\nSuccessfully verified response for case of non present batteries."); CmTestLog.Success(response.ResultDescription.ToString()); return response; } else { if (chassisInfo.completionCode != CompletionCode.Success) { response.Result = false; response.ResultDescription.Append("\nFailed to get chassis information with only Chassis Battery Info set to true, completion code returned: " + chassisInfo.completionCode); CmTestLog.Failure(response.ResultDescription.ToString()); return response; } CmTestLog.Success("Successfully received chassis info"); response = VerifyChassisBatteryInfo(chassisInfo); // Verify blade information is empty if (!ChassisManagerTestHelper.IsTrue(chassisInfo.bladeCollections.Count == 0, "Blade information is empty")) { response.Result &= false; response.ResultDescription.Append("\nVerifyOnlyChassisBatteryInfo failed: Blade information is not empty"); } // Verify PSU information is empty if (!ChassisManagerTestHelper.IsTrue(chassisInfo.psuCollections.Count == 0, "PSU information is empty")) { response.Result &= false; response.ResultDescription.Append("\nVerifyOnlyChassisBatteryInfo failed: PSU information is not empty"); } // Verify chassis controller info is empty if (!ChassisManagerTestHelper.IsTrue(chassisInfo.chassisController == null, "Chassis controller information is empty")) { response.Result &= false; response.ResultDescription.Append("\nVerifyOnlyChassisBatteryInfo failed: Chassis Controller information is not empty"); } } } catch (Exception ex) { ChassisManagerTestHelper.IsTrue(false, ex.Message); response.Result = false; response.ResultDescription.Append(ex.Message); } return response; }
private TestResponse GetChassisInfoByAllUsers(WCSSecurityRole roleId) { TestResponse response = new TestResponse(); try { // Use the Domain User Channel this.TestChannelContext = this.ListTestChannelContexts[(int)roleId]; if (this.TestChannelContext != null) { ChassisInfoResponse chassisInfo = new ChassisInfoResponse(); // Test GetChassisInfo, get all information CmTestLog.Info("Verifying chassis information when all params are true"); chassisInfo = this.TestChannelContext.GetChassisInfo(true, true, true, true); TestResponse testResponse = this.VerifyChassisInfo(chassisInfo); response.Result &= testResponse.Result; response.ResultDescription.Append(testResponse.ResultDescription); CmTestLog.Info("Finished verification of GetchassisInfo when all information was returned blade, PSU, battery and chassis controller \n"); // Test GetChassisInfo with no params CmTestLog.Info("Verifying chassis information when all params are false OR no Params\n"); chassisInfo = this.TestChannelContext.GetChassisInfo(false, false, false, false); testResponse = this.VerifyChassisInfo(chassisInfo); response.Result &= testResponse.Result; response.ResultDescription.Append(testResponse.ResultDescription); CmTestLog.Info("Finished verification of GetchassisInfo with no params \n"); // Test for GetChassisInfo with only blade info CmTestLog.Info("Verifying chassis information for only Blade, bladeInfo param is true\n"); chassisInfo = this.TestChannelContext.GetChassisInfo(true, false, false, false); testResponse = this.VerifyOnlyChassisBladeInfo(chassisInfo); response.Result &= testResponse.Result; response.ResultDescription.Append(testResponse.ResultDescription); CmTestLog.Info("Finished verification of GetchassisInfo for only Blade information \n"); // Test for GetChassisInfo for only PSU information CmTestLog.Info("Verifying chassis information for only psuInfo param is true\n"); chassisInfo = this.TestChannelContext.GetChassisInfo(false, true, false, false); testResponse = this.VerifyOnlyChassisPsuInfo(chassisInfo); response.Result &= testResponse.Result; response.ResultDescription.Append(testResponse.ResultDescription); CmTestLog.Info("Finished verification of GetChassisInfo for only PSU information \n"); // Test for GetChassisInfo for only Battery information CmTestLog.Info("Verifying chassis information for only batteryInfo param is true\n"); chassisInfo = this.TestChannelContext.GetChassisInfo(false, false, false, true); testResponse = this.VerifyOnlyChassisBatteryInfo(chassisInfo); response.Result = testResponse.Result; response.ResultDescription.Append(testResponse.ResultDescription); CmTestLog.Info("Finished verification of GetChassisInfo for only battery information \n"); // Test for GetChassisInfo for only chassis controller information CmTestLog.Info("Verifying chassis information for only chassisControllerInfo param is true\n"); chassisInfo = this.TestChannelContext.GetChassisInfo(false, false, true, false); testResponse = this.VerifyOnlyChassisControllerInfo(chassisInfo); response.Result = testResponse.Result; response.ResultDescription.Append(testResponse.ResultDescription); CmTestLog.Info("Finished verification of GetChassisInfo for only chassis controller information \n"); } } catch (Exception ex) { ChassisManagerTestHelper.IsTrue(false, ex.Message); response.Result &= false; response.ResultDescription.Append(ex.Message); } return response; }
/// <summary> /// Verify chassis blade info /// </summary> /// <param name="allPassed">Flag indicating success/failure</param> /// <param name="chassisInfo">Chassis info response</param> /// <returns>returns success/failure</returns> private TestResponse VerifyChassisBladeInfo(ChassisInfoResponse chassisInfo) { TestResponse response = new TestResponse(); CmTestLog.Info("Verifying blade info"); response.Result = ChassisManagerTestHelper.AreEqual(CmConstants.Population, chassisInfo.bladeCollections.Count, "Verified the number of blades in the chassis"); if (response.Result == false) { response.ResultDescription.Append("\nChassis blade info verification failed : Number of blades in the chassis do not match with the config value"); } foreach (var bladeInfo in chassisInfo.bladeCollections) { if (!EmptyLocations.Contains(bladeInfo.bladeNumber)) { response.Result &= ChassisManagerTestHelper.AreEqual(CompletionCode.Success, bladeInfo.completionCode, string.Format("Blade# {0} returns {1}", bladeInfo.bladeNumber, bladeInfo.completionCode)); if (response.Result == false) { response.ResultDescription.Append(string.Format("\nFailed to get blade " + bladeInfo.bladeNumber + " information, completion code returned: " + bladeInfo.completionCode)); } } } return response; }
/// <summary> /// Verify chassis battery info /// </summary> /// <param name="allPassed">Flag indicating success/failure</param> /// <param name="chassisInfo">Chassis info response</param> /// <returns>returns success/failure</returns> private static bool VerifyChassisBatteryInfo(bool allPassed, ChassisInfoResponse chassisInfo) { CmTestLog.Info("Verifying battery info"); allPassed &= ChassisManagerTestHelper.AreEqual(CmConstants.NumBattery, chassisInfo.batteryCollections.Count, "Verified the number of Batteries"); foreach (var battery in chassisInfo.batteryCollections) { allPassed &= ChassisManagerTestHelper.AreEqual(CompletionCode.Success, battery.completionCode, string.Format("Battery #{0} returns success", battery.id)); } return allPassed; }
/// <summary> /// Verify chassis PSU info /// </summary> /// <param name="allPassed">Flag indicating success/failure</param> /// <param name="chassisInfo">Chassis info response</param> /// <returns>returns success/failure</returns> private static TestResponse VerifyChassisPsuInfo(ChassisInfoResponse chassisInfo) { TestResponse response = new TestResponse(); CmTestLog.Info("Verifying PSU info"); if (!ChassisManagerTestHelper.AreEqual(CmConstants.NumPsus, chassisInfo.psuCollections.Count, "Verified the number of PSUs is correct")) { response.Result = false; response.ResultDescription.Append("\n VerifyChassisBatteryInfo : Number of PSUs do not match the config value"); } foreach (var psu in chassisInfo.psuCollections) { if (!ChassisManagerTestHelper.AreEqual(PowerState.ON, psu.state, string.Format("PSU# {0} power state is {1}", psu.id, psu.state))) { response.ResultDescription.Append(string.Format("\nPSU# {0} power state is {1}", psu.id, psu.state)); response.Result &= false; } } return response; }
/// <summary> /// Test GetChassisInfo for all possible parameters /// </summary> /// <returns>True if all check-points pass; false, otherwise.</returns> public TestResponse GetChassisInfoTest() { CmTestLog.Start(); TestResponse response = new TestResponse(); this.ServerLocations = this.GetServerLocations(); this.EmptyLocations = this.GetEmptyLocations(); this.JbodLocations = this.GetJbodLocations(); try { ChassisInfoResponse chassisInfo = new ChassisInfoResponse(); // Test GetChassisInfo, get all information CmTestLog.Info("Verifying chassis information when all params are true"); chassisInfo = this.Channel.GetChassisInfo(true, true, true, true); // define an object of TestResponse class for test results TestResponse testResponse = this.VerifyChassisInfo(chassisInfo); response.Result &= testResponse.Result; response.ResultDescription.Append(testResponse.ResultDescription); CmTestLog.Info("Finished verification of GetchassisInfo when all information was returned blade, PSU, battery and chassis controller \n"); // Test GetChassisInfo with no params CmTestLog.Info("Verifying chassis information when all params are false OR no Params\n"); chassisInfo = this.Channel.GetChassisInfo(false, false, false, false); testResponse = this.VerifyChassisInfo(chassisInfo); response.Result &= testResponse.Result; response.ResultDescription.Append(testResponse.ResultDescription); CmTestLog.Info("Finished verification of GetchassisInfo with no params \n"); // Test for GetChassisInfo with only blade info CmTestLog.Info("Verifying chassis information for only Blade, bladeInfo param is true\n"); chassisInfo = this.Channel.GetChassisInfo(true, false, false, false); testResponse = this.VerifyOnlyChassisBladeInfo(chassisInfo); response.Result &= testResponse.Result; response.ResultDescription.Append(testResponse.ResultDescription); CmTestLog.Info("Finished verification of GetchassisInfo for only Blade information \n"); // Test for GetChassisInfo for only PSU information CmTestLog.Info("Verifying chassis information for only psuInfo param is true"); chassisInfo = this.Channel.GetChassisInfo(false, true, false, false); testResponse = this.VerifyOnlyChassisPsuInfo(chassisInfo); response.Result &= testResponse.Result; response.ResultDescription.Append(testResponse.ResultDescription); CmTestLog.Info("Finished verification of GetChassisInfo for only PSU information \n"); // Test for GetChassisInfo for only Battery information CmTestLog.Info("Verifying chassis information for only batteryInfo param is true\n"); chassisInfo = this.Channel.GetChassisInfo(false, false, false, true); testResponse = this.VerifyOnlyChassisBatteryInfo(chassisInfo); response.Result &= testResponse.Result; response.ResultDescription.Append(testResponse.ResultDescription); CmTestLog.Info("Finished verification of GetChassisInfo for only battery information \n"); // Test for GetChassisInfo for only chassis controller information CmTestLog.Info("Verifying chassis information for only chassisControllerInfo param is true\n"); chassisInfo = this.Channel.GetChassisInfo(false, false, true, false); testResponse = this.VerifyOnlyChassisControllerInfo(chassisInfo); response.Result &= testResponse.Result; response.ResultDescription.Append(testResponse.ResultDescription); CmTestLog.Info("Finished verification of GetChassisInfo for only chassis controller information \n"); } catch (Exception ex) { ChassisManagerTestHelper.IsTrue(false, ex.Message); response.Result &= false; response.ResultDescription.Append(ex.Message); } CmTestLog.End(response.Result); return response; }
/// <summary> /// Verify chassis battery info /// </summary> /// <param name="allPassed">Flag indicating success/failure</param> /// <param name="chassisInfo">Chassis info response</param> /// <returns>returns success/failure</returns> private static TestResponse VerifyChassisBatteryInfo(ChassisInfoResponse chassisInfo) { TestResponse response = new TestResponse(); CmTestLog.Info("Verifying battery info"); if (CmConstants.NumBatteries == 0) { foreach (var battery in chassisInfo.batteryCollections) { if (battery.completionCode != CompletionCode.Unknown || battery.presence != 0) { response.ResultDescription.Append(string.Format("\n Battery# {0} returns {1} when it should be Unknown", battery.id, battery.completionCode)); response.ResultDescription.Append(string.Format("Battery# {0} returns Presence value as {1}", battery.id, battery.presence)); response.Result &= false; } } } else { foreach (var battery in chassisInfo.batteryCollections) { if (!ChassisManagerTestHelper.AreEqual(CompletionCode.Success, battery.completionCode, string.Format("Battery# {0} returns {1}", battery.id, battery.completionCode))) { response.ResultDescription.Append(string.Format("\n Battery# {0} returns {1}", battery.id, battery.completionCode)); response.Result &= false; } } } return response; }
/// <summary> /// Verify chassis info /// </summary> /// <param name="allPassed">Flag indicating success/failure</param> /// <param name="chassisInfo">Chassis info response</param> /// <returns>returns success/failure</returns> private bool VerifyChassisInfo(bool allPassed, ChassisInfoResponse chassisInfo) { allPassed &= ChassisManagerTestHelper.IsTrue(chassisInfo != null, "Received chasssis information "); if (chassisInfo.completionCode != CompletionCode.Success) { CmTestLog.Failure(string.Format("Failed to get chassis info, completion code returned : {0}", chassisInfo.completionCode)); return false; } CmTestLog.Success("Successfully received chassis info"); allPassed = this.VerifyChassisBladeInfo(allPassed, chassisInfo); allPassed = VerifyChassisPsuInfo(allPassed, chassisInfo); allPassed = VerifyChassisBatteryInfo(allPassed, chassisInfo); allPassed = VerifyChassisControllerInfo(allPassed, chassisInfo); return allPassed; }
/// <summary> /// Test Command: GetChassisInfo: Get Only PSU information (psuInfo=true). /// </summary> /// <param name="allPassed"></param> /// <param name="chassisInfo"></param> /// <returns>True if all check-points pass; false, otherwise.</returns> private bool VerifyOnlyChassisPsuInfo(bool allPassed, ChassisInfoResponse chassisInfo) { try { allPassed &= ChassisManagerTestHelper.IsTrue(chassisInfo != null, "Received chasssis information "); if (chassisInfo.completionCode != CompletionCode.Success) { CmTestLog.Failure("Failed to get chassis info"); return false; } CmTestLog.Success("Successfully get chassis info"); allPassed = VerifyChassisPsuInfo(allPassed, chassisInfo); allPassed &= ChassisManagerTestHelper.IsTrue(chassisInfo.bladeCollections.Count == 0, "Blade information is empty"); allPassed &= ChassisManagerTestHelper.IsTrue(chassisInfo.batteryCollections.Count == 0, "Battery information is empty"); allPassed &= ChassisManagerTestHelper.IsTrue(chassisInfo.chassisController == null, "Chassis controller information is empty"); } catch (Exception ex) { ChassisManagerTestHelper.IsTrue(false, ex.Message); allPassed = false; } return allPassed; }
/// <summary> /// Verify chassis blade info /// </summary> /// <param name="allPassed">Flag indicating success/failure</param> /// <param name="chassisInfo">Chassis info response</param> /// <returns>returns success/failure</returns> private bool VerifyChassisBladeInfo(bool allPassed, ChassisInfoResponse chassisInfo) { CmTestLog.Info("Verifying blade info"); allPassed &= ChassisManagerTestHelper.AreEqual(CmConstants.Population, chassisInfo.bladeCollections.Count, "Verified the number of blades in the chassis"); foreach (var bladeInfo in chassisInfo.bladeCollections) { allPassed &= ChassisManagerTestHelper.AreEqual(CompletionCode.Success, bladeInfo.completionCode, string.Format("Blade #{0} returns success", bladeInfo.bladeNumber)); } return allPassed; }
/// <summary> /// Verify chassis PSU info /// </summary> /// <param name="allPassed">Flag indicating success/failure</param> /// <param name="chassisInfo">Chassis info response</param> /// <returns>returns success/failure</returns> private static bool VerifyChassisPsuInfo(bool allPassed, ChassisInfoResponse chassisInfo) { CmTestLog.Info("Verifying PSU info"); allPassed &= ChassisManagerTestHelper.AreEqual(CmConstants.NumPsus, chassisInfo.psuCollections.Count, "Verified the number of PSUs is correct"); foreach (var psu in chassisInfo.psuCollections) { allPassed &= ChassisManagerTestHelper.AreEqual(CompletionCode.Success, psu.completionCode, string.Format("PSU #{0} returns success", psu.id)); allPassed &= ChassisManagerTestHelper.AreEqual(PowerState.ON, psu.state, string.Format("PSU #{0} is ON", psu.id)); } return allPassed; }
/// <summary> /// Verify chassis controller info /// </summary> /// <param name="allPassed">Flag indicating success/failure</param> /// <param name="chassisInfo">Chassis info response</param> /// <returns>returns success/failure</returns> private static bool VerifyChassisControllerInfo(bool allPassed, ChassisInfoResponse chassisInfo) { CmTestLog.Info("Verifying chassis controller info"); allPassed &= ChassisManagerTestHelper.AreEqual(CompletionCode.Success, chassisInfo.chassisController.completionCode, "Chassis controller returns success"); return allPassed; }
public TestsResultResponse CheckChassisInfo(string SKUXMLFile = "Default") { ChassisInfoResponse chassisInfo = new ChassisInfoResponse(); string failureMessage = string.Empty; Console.WriteLine("\n!!!!!!!!! Starting execution of CheckChassisInfo tests."); chassisInfo = this.Channel.GetChassisInfo(true, true, true, true); if (chassisInfo.completionCode != CompletionCode.Success) { failureMessage = "\n!!!Failed to get all chassis components information"; Console.WriteLine(failureMessage); return new TestsResultResponse(ExecutionResult.Failed, failureMessage); } chassisInfo = this.Channel.GetChassisInfo(true, false, false, false); if (chassisInfo.completionCode != CompletionCode.Success) { failureMessage = "\n!!!Failed to get chassis information when asking for only blade information"; Console.WriteLine(failureMessage); return new TestsResultResponse(ExecutionResult.Failed, failureMessage); } chassisInfo = this.Channel.GetChassisInfo(true, true, false, false); if (chassisInfo.completionCode != CompletionCode.Success) { failureMessage = "\n!!!Failed to get chassis information when excluding Chassis controller info"; Console.WriteLine(failureMessage); return new TestsResultResponse(ExecutionResult.Failed, failureMessage); } chassisInfo = this.Channel.GetChassisInfo(true, false, true, false); if (chassisInfo.completionCode != CompletionCode.Success) { failureMessage = "\n!!!Failed to get chassis information when excluding PSU info"; Console.WriteLine(failureMessage); return new TestsResultResponse(ExecutionResult.Failed, failureMessage); } chassisInfo = this.Channel.GetChassisInfo(false, true, true, false); if (chassisInfo.completionCode != CompletionCode.Success) { failureMessage = "\n!!!Failed to get chassis information when excluding Blades info"; Console.WriteLine(failureMessage); return new TestsResultResponse(ExecutionResult.Failed, failureMessage); } chassisInfo = this.Channel.GetChassisInfo(false, true, false, false); if (chassisInfo.completionCode != CompletionCode.Success) { failureMessage = "\n!!!Failed to get chassis information when including only PSU info."; Console.WriteLine(failureMessage); return new TestsResultResponse(ExecutionResult.Failed, failureMessage); } chassisInfo = this.Channel.GetChassisInfo(false, false, true, false); if (chassisInfo.completionCode != CompletionCode.Success) { failureMessage = "\n!!!Failed to get chassis information when asking only for Chassis controller info"; Console.WriteLine(failureMessage); return new TestsResultResponse(ExecutionResult.Failed, failureMessage); } chassisInfo = this.Channel.GetChassisInfo(false, false, false, false); if (chassisInfo.completionCode != CompletionCode.Success) { failureMessage = "\n!!!Failed to get chassis information when excluding all info"; Console.WriteLine(failureMessage); return new TestsResultResponse(ExecutionResult.Failed, failureMessage); } chassisInfo = this.Channel.GetChassisInfo(false, false, false, true); if (chassisInfo.completionCode != CompletionCode.Success) { failureMessage = "\n!!!Failed to get chassis information when asking only for Batteries info"; Console.WriteLine(failureMessage); return new TestsResultResponse(ExecutionResult.Failed, failureMessage); } Console.WriteLine("\n++++++++++++++++++++++++++++++++"); failureMessage = "\n!!!!!!!!! Successfully finished execution of CheckChassisInfo tests"; Console.WriteLine(failureMessage); return new TestsResultResponse(ExecutionResult.Passed, failureMessage); }
/// <summary> /// Verify chassis controller info /// </summary> /// <param name="allPassed">Flag indicating success/failure</param> /// <param name="chassisInfo">Chassis info response</param> /// <returns>returns success/failure</returns> private static TestResponse VerifyChassisControllerInfo(ChassisInfoResponse chassisInfo) { TestResponse response = new TestResponse(); CmTestLog.Info("Verifying chassis controller info"); if (!ChassisManagerTestHelper.AreEqual(CompletionCode.Success, chassisInfo.chassisController.completionCode, "Chassis controller returns success")) { response.Result = false; response.ResultDescription.Append("\n Verify Chassis controller info failed with completion code: " + chassisInfo.chassisController.completionCode); } return response; }
/// <summary> /// Get Chassis Information /// </summary> /// <param name="bladeInfo">Set to True to get blade info </param> /// <param name="psuInfo">Set to True to get PSU info</param> /// <param name="chassisControllerInfo">Set to True to get chassis controller info</param> /// <param name="batteryInfo">Set to True to get battery info</param> /// <returns>Response packet for Chassis Info</returns> public ChassisInfoResponse GetChassisInfo(bool bladeInfo, bool psuInfo, bool chassisControllerInfo, bool batteryInfo) { byte MaxbladeCount = (byte)ConfigLoaded.Population; Tracer.WriteInfo("Received GetChassisInfo bladeInfo = {0}, psuInfo = {1}, chassisControllerInfo = {2})", bladeInfo, psuInfo, chassisControllerInfo); Tracer.WriteInfo(" batteryInfo = {0}", batteryInfo); Tracer.WriteUserLog("Received GetChassisInfo bladeInfo = {0}, psuInfo = {1}, chassisControllerInfo = {2})", bladeInfo, psuInfo, chassisControllerInfo); Tracer.WriteUserLog(" batteryInfo = {0}", batteryInfo); // Check for the scenario where none of the params are specified or where all params are set to false // return everything in that case. if (bladeInfo == false && psuInfo == false && chassisControllerInfo == false && batteryInfo == false) { bladeInfo = true; psuInfo = true; chassisControllerInfo = true; batteryInfo = true; } // Server side class structure to populate blade, psu and battery information ChassisInfoResponse cip = new ChassisInfoResponse(); cip.completionCode = Contracts.CompletionCode.Unknown; cip.statusDescription = String.Empty; // Initialize to empty collections to begin with cip.bladeCollections = new List<BladeInfo>(); cip.chassisController = null; if (bladeInfo) { // Loop to populate blade information for requested number of blades for (int loop = 1; loop <= MaxbladeCount; loop++) { try { BladeInfo bladeInstance = new BladeInfo(); bladeInstance.bladeNumber = loop; // initialize completion code to unknown to start with bladeInstance.completionCode = Contracts.CompletionCode.Unknown; BladeStateResponse bladeResponse = new BladeStateResponse(); Tracer.WriteInfo("Calling Get blade active power state"); bladeResponse = GetBladeState(loop); bladeInstance.completionCode = bladeResponse.completionCode; // Even if one succeeds, we set the function completion code to success if (bladeInstance.completionCode == Contracts.CompletionCode.Success) { cip.completionCode = Contracts.CompletionCode.Success; } else if (bladeInstance.completionCode == Contracts.CompletionCode.FirmwareDecompressing) { cip.completionCode = Contracts.CompletionCode.FirmwareDecompressing; cip.statusDescription = "Blade firmware is decompressing. Data could not be retrieved, for one or more blades"; } else { // If not already set to success, set to failure, because something actually failed here if (cip.completionCode != Contracts.CompletionCode.Success) { cip.completionCode = Contracts.CompletionCode.Failure; cip.statusDescription = "Blade info could not be retrieved, for one or more blades"; } } Contracts.PowerState powerResponse = bladeResponse.bladeState; Tracer.WriteInfo("powerResponse received"); // Get Blade Power State if (powerResponse == PowerState.ON) { bladeInstance.powerState = PowerState.ON; } else if (powerResponse == PowerState.OFF) { bladeInstance.powerState = PowerState.OFF; } else { bladeInstance.powerState = PowerState.NA; } if (bladeInstance.completionCode == Contracts.CompletionCode.Success) { // Get GUID, force session logon if session timed out. Ipmi.DeviceGuid devGuid = WcsBladeFacade.GetSystemGuid((byte)loop, true); if (devGuid.CompletionCode == (byte)CompletionCode.Success) { bladeInstance.bladeGuid = devGuid.Guid; cip.completionCode = Contracts.CompletionCode.Success; } else { Tracer.WriteWarning("GetSystemGuid failed with Completion Code {0}", devGuid.CompletionCode); bladeInstance.bladeGuid = System.Guid.Empty; // If completion code not already set to success, set to failure, because something actually failed here if (cip.completionCode != Contracts.CompletionCode.Success) { cip.completionCode = Contracts.CompletionCode.Failure; cip.statusDescription = "Blade info could not be retrieved, for one or more blades"; } } // Any success is sufficient for this function, so only if we did not succeed, we set new value to completionCode if (bladeInstance.completionCode != Contracts.CompletionCode.Success) { bladeInstance.completionCode = ChassisManagerUtil.GetContractsCompletionCodeMapping(devGuid.CompletionCode); } // BMC Mac address should be added as a list bladeInstance.bladeMacAddress = new List<NicInfo>(); for (byte i = 0; i < ConfigLoaded.NumNicsPerBlade; i++) { Ipmi.NicInfo ipmiNicInfo = WcsBladeFacade.GetNicInfo((byte)loop, (byte)(i + 1)); if (ipmiNicInfo.CompletionCode != (byte)CompletionCode.Success && ipmiNicInfo.CompletionCode != (byte)CompletionCode.IpmiInvalidDataFieldInRequest) { Tracer.WriteError("Nic {0} from Blade {1} returned an error code: {2}", i, loop, ipmiNicInfo.CompletionCode); } Contracts.NicInfo nicInfo = GetNicInfoObject(ipmiNicInfo); bladeInstance.bladeMacAddress.Add(nicInfo); } } else { bladeInstance.bladeGuid = System.Guid.Empty; // BMC Mac address should be added as a list bladeInstance.bladeMacAddress = new List<NicInfo>(); Ipmi.NicInfo ipmiNicInfo = new Ipmi.NicInfo((byte)CompletionCode.FirmwareDecompressing); Contracts.NicInfo nicInfo = GetNicInfoObject(ipmiNicInfo); bladeInstance.bladeMacAddress.Add(nicInfo); } // bladename is BladeId bladeInstance.bladeName = String.Concat("BLADE", loop); // Add blade to list cip.bladeCollections.Add(bladeInstance); } catch (Exception ex) { Tracer.WriteUserLog("GetChassisInfo (Blade portion) failed for blade {0} with exception: {1}", loop, ex.Message); cip.completionCode = Contracts.CompletionCode.Failure; cip.statusDescription = String.Format("GetChassisInfo (Blade portion) failed for blade {0} with exception: {1}", loop, ex.Message); } } } if (psuInfo) { // Get the PSU Info. cip.psuCollections = GetPsuInfo(); // if the master object is not successful, check child objects if (cip.completionCode != Contracts.CompletionCode.Success) { // if Psu status received any positive results, return success. foreach (PsuInfo psu in cip.psuCollections) { // if any children are successful, set master to success. if (psu.completionCode == Contracts.CompletionCode.Success) { cip.completionCode = Contracts.CompletionCode.Success; break; // once a match has been found escape foreach } } // if master completion code is still unknown, replace with failure. if (cip.completionCode == Contracts.CompletionCode.Unknown) { if (ConfigLoaded.NumPsus > 0) cip.completionCode = Contracts.CompletionCode.Failure; else { cip.completionCode = Contracts.CompletionCode.Success; cip.statusDescription += "\nPower Supply monitoring not supported in sku configuration."; } } } } if (batteryInfo) { // Get the battery info cip.batteryCollections = GetBatteryInfo(); // if the master object is not successful, check child objects if (cip.completionCode != Contracts.CompletionCode.Success) { // if battery status received any positive results, return success. foreach (BatteryInfo battery in cip.batteryCollections) { // if any children are successful, set master to success. if (battery.completionCode == Contracts.CompletionCode.Success) { cip.completionCode = Contracts.CompletionCode.Success; break; // once a match has been found escape foreach } } // if master completion code is still unknown, replace with failure. if (cip.completionCode == Contracts.CompletionCode.Unknown) { if (ConfigLoaded.NumBatteries > 0) cip.completionCode = Contracts.CompletionCode.Failure; else { cip.completionCode = Contracts.CompletionCode.Success; cip.statusDescription += "\nBattery monitoring not supported in sku configuration."; } } } } // Chassis Info should be read by reading the Fru device if (chassisControllerInfo) { try { //Populate chassis controller data cip.chassisController = new ChassisControllerInfo(); ServiceVersionResponse version = GetServiceVersion(); if (version.completionCode == Contracts.CompletionCode.Success) { cip.chassisController.softwareVersion = version.serviceVersion; } else { cip.chassisController.softwareVersion = string.Format("Unable to obtain: Completion Code: {0}.", version.completionCode); } // get chassis network properties cip.chassisController.networkProperties = new ChassisNetworkPropertiesResponse(); cip.chassisController.networkProperties = GetChassisNetworkProperties(); // Populate chassis IP address if (cip.chassisController.networkProperties != null) { cip.chassisController.completionCode = Contracts.CompletionCode.Success; cip.completionCode = Contracts.CompletionCode.Success; } else { Tracer.WriteInfo("GetChassisInfo - failed to get chassis network properties"); if (cip.chassisController.completionCode != Contracts.CompletionCode.Success) { cip.chassisController.completionCode = Contracts.CompletionCode.Failure; cip.chassisController.statusDescription = String.Format("GetChassisInfo - failed to get chassis network properties"); } if (cip.completionCode != Contracts.CompletionCode.Success) { cip.completionCode = Contracts.CompletionCode.Failure; cip.statusDescription = "Failed to get chassis information"; } } cip.chassisController.systemUptime = (DateTime.Now - Process.GetCurrentProcess().StartTime).ToString(); // Default Chassis details before reading FRU later cip.chassisController.firmwareVersion = "NA"; cip.chassisController.hardwareVersion = "NA"; cip.chassisController.serialNumber = "NA"; cip.chassisController.assetTag = "NA"; Ipmi.FruDevice fruDevice = ChassisState.CmFruData.ReadFru(DeviceType.ChassisFruEeprom); if (fruDevice.CompletionCode == (byte)CompletionCode.Success) { cip.chassisController.completionCode = Contracts.CompletionCode.Success; cip.completionCode = Contracts.CompletionCode.Success; cip.chassisController.firmwareVersion = fruDevice.ProductInfo.ProductVersion.ToString(); cip.chassisController.hardwareVersion = fruDevice.ProductInfo.Version.ToString(); cip.chassisController.serialNumber = fruDevice.ProductInfo.SerialNumber.ToString(); cip.chassisController.assetTag = fruDevice.ProductInfo.AssetTag.ToString(); } else { Tracer.WriteWarning("CM Fru Read failed with completion code: {0:X}", fruDevice.CompletionCode); if (cip.chassisController.completionCode != Contracts.CompletionCode.Success) { cip.chassisController.completionCode = Contracts.CompletionCode.Failure; cip.chassisController.statusDescription = String.Format("CM Fru Read failed with completion code: {0:X}", fruDevice.CompletionCode); } if (cip.completionCode != Contracts.CompletionCode.Success) { cip.completionCode = Contracts.CompletionCode.Failure; cip.statusDescription = "Failed to get chassis information"; } } } catch (Exception ex) { Tracer.WriteUserLog(" GetChassisInfo failed with exception: " + ex.Message); if (cip.completionCode != Contracts.CompletionCode.Success) { cip.completionCode = Contracts.CompletionCode.Failure; cip.statusDescription = String.Format(" GetChassisInfo failed with exception: " + ex.Message); } } } Tracer.WriteInfo("Return: GetChassisInfo returned, Number of Blades: {0}, Number of PSUs: {1}", cip.bladeCollections.Count(), cip.psuCollections.Count()); return cip; }
/// <summary> /// Test GetChassisInfo for all possible parameters /// </summary> /// <returns>True if all check-points pass; false, otherwise.</returns> public bool GetChassisInfoTest() { CmTestLog.Start(); bool allPassed = true; this.EmptyLocations = this.GetEmptyLocations(); this.JbodLocations = this.GetJbodLocations(); try { ChassisInfoResponse chassisInfo = new ChassisInfoResponse(); // Test GetChassisInfo, get all information CmTestLog.Info("Verifying chassis information when all params are true"); chassisInfo = this.Channel.GetChassisInfo(true, true, true, true); allPassed = this.VerifyChassisInfo(allPassed, chassisInfo); CmTestLog.Info("Finished verification of GetchassisInfo when all information was returned blade, PSU, battery and chassis controller \n"); // Test GetChassisInfo with no params CmTestLog.Info("Verifying chassis information when all params are false OR no Params"); chassisInfo = this.Channel.GetChassisInfo(false, false, false, false); allPassed = this.VerifyChassisInfo(allPassed, chassisInfo); CmTestLog.Info("Finished verification of GetchassisInfo with no params \n"); // Test for GetChassisInfo with only blade info CmTestLog.Info("Verifying chassis information for only Blade, bladeInfo param is true"); chassisInfo = this.Channel.GetChassisInfo(true, false, false, false); allPassed = this.VerifyOnlyChassisBladeInfo(allPassed, chassisInfo); CmTestLog.Info("Finished verification of GetchassisInfo for only Blade information \n"); // Test for GetChassisInfo for only PSU information CmTestLog.Info("Verifying chassis information for only psuInfo param is true"); chassisInfo = this.Channel.GetChassisInfo(false, true, false, false); allPassed = this.VerifyOnlyChassisPsuInfo(allPassed, chassisInfo); CmTestLog.Info("Finished verification of GetChassisInfo for only PSU information \n"); // Test for GetChassisInfo for only Battery information CmTestLog.Info("Verifying chassis information for only batteryInfo param is true"); chassisInfo = this.Channel.GetChassisInfo(false, false, false, true); allPassed = this.VerifyOnlyChassisBatteryInfo(allPassed, chassisInfo); CmTestLog.Info("Finished verification of GetChassisInfo for only battery information \n"); // Test for GetChassisInfo for only chassis controller information CmTestLog.Info("Verifying chassis information for only chassisControllerInfo param is true"); chassisInfo = this.Channel.GetChassisInfo(false, false, true, false); allPassed = this.VerifyOnlyChassisControllerInfo(allPassed, chassisInfo); CmTestLog.Info("Finished verification of GetChassisInfo for only chassis controller information \n"); } catch (Exception ex) { ChassisManagerTestHelper.IsTrue(false, ex.Message); allPassed = false; } CmTestLog.End(allPassed); return allPassed; }