/// <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>
/// Returns the default blade board power state
/// </summary>
/// <param name="bladeId">Blade ID (1-24)</param>
/// <returns>Blade State Response packet</returns>
public BladeStateResponse GetBladeDefaultPowerState(int bladeId)
{
Tracer.WriteInfo("Received GetBladeDefaultPowerState({0})", bladeId);
Tracer.WriteUserLog("Invoked GetBladeDefaultPowerState({0})", bladeId);
BladeStateResponse response = new BladeStateResponse();
response.bladeNumber = bladeId;
response.completionCode = Contracts.CompletionCode.Unknown;
response.statusDescription = String.Empty;
Contracts.ChassisResponse varResponse = ValidateRequest("GetBladeDefaultPowerState", bladeId);
if (varResponse.completionCode != Contracts.CompletionCode.Success)
{
response.completionCode = varResponse.completionCode;
response.statusDescription = varResponse.statusDescription;
return response;
}
Ipmi.SystemStatus powerPolicy = WcsBladeFacade.GetChassisState((byte)bladeId);
if (powerPolicy.CompletionCode != (byte)CompletionCode.Success)
{
Tracer.WriteWarning("GetBladeDefaultPowerState failed with completion code:"
+ Ipmi.IpmiSharedFunc.ByteToHexString((byte)powerPolicy.CompletionCode));
response.completionCode = Contracts.CompletionCode.Failure;
response.statusDescription = response.completionCode.ToString();
response.bladeState = PowerState.NA;
}
else
{
response.completionCode = Contracts.CompletionCode.Success;
Ipmi.PowerRestoreOption currentSetting = powerPolicy.PowerOnPolicy;
switch (currentSetting)
{
case Microsoft.GFS.WCS.ChassisManager.Ipmi.PowerRestoreOption.StayOff:
response.bladeState = PowerState.OFF;
Tracer.WriteInfo("GetBladeDefaultPowerState(BladeId: {0}) return is OFF", bladeId);
break;
case Microsoft.GFS.WCS.ChassisManager.Ipmi.PowerRestoreOption.AlwaysPowerUp:
response.bladeState = PowerState.ON;
Tracer.WriteInfo("GetBladeDefaultPowerState(BladeID: {0}) return is ON", bladeId);
break;
case Microsoft.GFS.WCS.ChassisManager.Ipmi.PowerRestoreOption.GetCurrentPolicy:
response.bladeState = PowerState.NA;
Tracer.WriteInfo("GetBladeDefaultPowerState(BladeID: {0}) return is curr policy", bladeId);
break;
case Microsoft.GFS.WCS.ChassisManager.Ipmi.PowerRestoreOption.PreviousState:
response.bladeState = PowerState.NA;
Tracer.WriteInfo("GetBladeDefaultPowerState(BladeID: {0}) return is prev state", bladeId);
break;
case Microsoft.GFS.WCS.ChassisManager.Ipmi.PowerRestoreOption.Unknown:
response.bladeState = PowerState.NA;
Tracer.WriteInfo("GetBladeDefaultPowerState(BladeID: {0}) return is unknown", bladeId);
break;
default:
response.bladeState = PowerState.NA;
Tracer.WriteInfo("GetBladeDefaultPowerState(BladeID: {0}) return is NA", bladeId);
break;
}
}
return response;
}
/// <summary>
/// Get Blade soft power state
/// </summary>
/// <param name="bladeId">Blade ID(1-48)</param>
/// <returns>Blade state response class object</returns>
public BladeStateResponse GetBladeState(int bladeId)
{
Tracer.WriteInfo("Received GetBladeState({0})", bladeId);
Tracer.WriteUserLog("Invoked GetBladeState(bladeid: {0})", bladeId);
BladeStateResponse stateResponse = new BladeStateResponse();
stateResponse.bladeNumber = bladeId;
stateResponse.bladeState = Contracts.PowerState.NA;
stateResponse.completionCode = Contracts.CompletionCode.Unknown;
stateResponse.statusDescription = String.Empty;
Contracts.ChassisResponse varResponse = ValidateRequest("GetBladeState", bladeId);
if (varResponse.completionCode != Contracts.CompletionCode.Success)
{
stateResponse.completionCode = varResponse.completionCode;
stateResponse.statusDescription = varResponse.statusDescription;
return stateResponse;
}
// Check to see if the blade enable itself is OFF - then the BMC power state does not matter
BladePowerStatePacket response = ChassisState.BladePower[bladeId - 1].GetBladePowerState();
if (response.CompletionCode != CompletionCode.Success)
{
// 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("GetBladeState: Blade {0} Power Enable state read failed (Completion Code: {1:X})", bladeId, response.CompletionCode);
stateResponse.completionCode =
ChassisManagerUtil.GetContractsCompletionCodeMapping((byte)response.CompletionCode);
stateResponse.statusDescription = stateResponse.completionCode.ToString();
}
else
{
// Only if the blade enable is OFF, we return that status, for anything else we have to read BMC status
if (response.PowerStatus == Contracts.PowerState.OFF)
{
// Since we do not know if a blade is present in that slot or not, we return NA as power state
stateResponse.bladeState = Contracts.PowerState.OFF;
stateResponse.completionCode = Contracts.CompletionCode.Success;
return stateResponse;
}
else if (response.PowerStatus == Contracts.PowerState.ON)
{
if (response.DecompressionTime > 0)
{
stateResponse.completionCode = Contracts.CompletionCode.Success;
stateResponse.bladeState = PowerState.OnFwDecompress;
stateResponse.statusDescription = string.Format("Blade On. Firmware Decompression Time Remaining: {0}", response.DecompressionTime);
return stateResponse;
}
}
}
Ipmi.SystemStatus powerState = WcsBladeFacade.GetChassisState((byte)bladeId);
Tracer.WriteInfo("GetBladeState {0} Return: {1}, Blade State: {2}", bladeId, powerState.CompletionCode, powerState.PowerState.ToString());
if (powerState.CompletionCode != (byte)CompletionCode.Success)
{
Tracer.WriteError("GetBladeState Failed with Completion code {0:X}", powerState.CompletionCode);
stateResponse.bladeState = Contracts.PowerState.NA;
stateResponse.completionCode =
ChassisManagerUtil.GetContractsCompletionCodeMapping((byte)powerState.CompletionCode);
stateResponse.statusDescription = stateResponse.completionCode.ToString();
}
else
{
stateResponse.completionCode = Contracts.CompletionCode.Success;
if (powerState.PowerState == Ipmi.IpmiPowerState.On)
{
stateResponse.bladeState = Contracts.PowerState.ON;
}
else
{
stateResponse.bladeState = Contracts.PowerState.OFF;
}
}
return stateResponse;
}
/// <summary>
/// A test for SetBladeActivePowerCycle
/// </summary>
public TestsResultResponse SetBladeActivePowerCycleTest()
{
BladeStateResponse response = new BladeStateResponse();
string failureMessage = string.Empty;
int randomBlade = 0;
bool isServer = false;
int bladeIndex = 1;
Console.WriteLine("\n!!!!!!!!! Starting execution of SetBladeActivePowerCycleTest.");
//make sure you pick a server and not a JBOD
while (!isServer && bladeIndex <= this.ChassisPopulation)
{
randomBlade = new Random().Next(1, (byte)this.ChassisPopulation);
if (!this.JbodLocations.Contains(bladeIndex) && !this.EmptySlots.Contains(bladeIndex))
{
isServer = true;
}
else
{
bladeIndex++;
}
}
if (bladeIndex > this.ChassisPopulation)
{
failureMessage = "\n!!!Failed to find a server machine to run the test.";
Console.WriteLine(failureMessage);
return new TestsResultResponse(ExecutionResult.Failed, failureMessage);
}
this.Channel.SetPowerOn(randomBlade);
System.Threading.Thread.Sleep(50000);
this.Channel.SetBladeOn(randomBlade);
System.Threading.Thread.Sleep(50000);
//Make sure blade is on to start with
response = this.Channel.GetBladeState(randomBlade);
if (response.bladeState != PowerState.ON)
{
failureMessage = "\n!!!Blade should be ON.";
Console.WriteLine(failureMessage);
return new TestsResultResponse(ExecutionResult.Failed, failureMessage);
}
//PowerCycle blade
this.Channel.SetBladeActivePowerCycle(randomBlade, 20);
System.Threading.Thread.Sleep(10000);
response = this.Channel.GetBladeState(randomBlade);
if (response.bladeState != PowerState.OFF)
{
failureMessage = string.Format("\n!!!Blade should still be off for blade# {0}", randomBlade);
Console.WriteLine(failureMessage);
return new TestsResultResponse(ExecutionResult.Failed, failureMessage);
}
System.Threading.Thread.Sleep(20000);
response = this.Channel.GetBladeState(randomBlade);
if (response.bladeState != PowerState.ON)
{
failureMessage = "\n!!!Blade should be already turned ON.";
Console.WriteLine(failureMessage);
return new TestsResultResponse(ExecutionResult.Failed, failureMessage);
}
Console.WriteLine("\n++++++++++++++++++++++++++++++++");
failureMessage = "\n!!!!!!!!! Successfully finished execution of SetBladeActivePowerCycleTest.";
Console.WriteLine(failureMessage);
return new TestsResultResponse(ExecutionResult.Passed, failureMessage);
}
/// <summary>
/// command specific implementation
/// argVal command class member has all user-entered command argument indicators and parameter values
/// Currently just prints all argument indicators and argument values
/// </summary>
internal override void commandImplementation()
{
uint sledId = 1;
BladeStateResponse myResponse = new BladeStateResponse();
GetAllBladesStateResponse myResponses = new GetAllBladesStateResponse();
try
{
if (this.argVal.ContainsKey('a'))
{
myResponses = WcsCli2CmConnectionManager.channel.GetAllBladesState();
}
else if (this.argVal.ContainsKey('i'))
{
dynamic mySledId = null;
this.argVal.TryGetValue('i', out mySledId);
sledId = (uint)mySledId;
myResponse = WcsCli2CmConnectionManager.channel.GetBladeState((int)mySledId);
}
}
catch (Exception ex)
{
SharedFunc.ExceptionOutput(ex);
return;
}
if ((this.argVal.ContainsKey('a') && myResponses == null) || myResponse == null)
{
Console.WriteLine(WcsCliConstants.serviceResponseEmpty);
return;
}
if (this.argVal.ContainsKey('a'))
{
for (int index = 0; index < myResponses.bladeStateResponseCollection.Count(); index++)
{
if (myResponses.bladeStateResponseCollection[index].completionCode == Contracts.CompletionCode.Success)
{
if (myResponses.bladeStateResponseCollection[index].bladeState == Contracts.PowerState.ON)
{
Console.WriteLine("Blade State " + myResponses.bladeStateResponseCollection[index].bladeNumber + ": ON");
}
else if (myResponses.bladeStateResponseCollection[index].bladeState == Contracts.PowerState.OFF)
{
Console.WriteLine("Blade State " + myResponses.bladeStateResponseCollection[index].bladeNumber + ": OFF");
}
else
{
Console.WriteLine("Blade State " + myResponses.bladeStateResponseCollection[index].bladeNumber + ": --");
}
}
else
{
// If not success, return the exact error state
Console.WriteLine("Blade State " + myResponses.bladeStateResponseCollection[index].bladeNumber + ": "
+ myResponses.bladeStateResponseCollection[index].completionCode.ToString());
}
}
}
else
{
if (myResponse.completionCode == Contracts.CompletionCode.Success)
{
if (myResponse.bladeState == Contracts.PowerState.ON)
{
Console.WriteLine("Blade State " + myResponse.bladeNumber + ": ON");
}
else if (myResponse.bladeState == Contracts.PowerState.OFF)
{
Console.WriteLine("Blade State " + myResponse.bladeNumber + ": OFF");
}
else
{
Console.WriteLine("Blade State " + myResponse.bladeNumber + ": --");
}
}
else if (myResponse.completionCode == Contracts.CompletionCode.Unknown)
{
Console.WriteLine("Blade State " + myResponse.bladeNumber + ": " + WcsCliConstants.bladeStateUnknown);
}
else
{
// Display error if other than success/unknown
Console.WriteLine("Blade State " + sledId + ": " + myResponse.completionCode.ToString());
}
}
}
private TestResponse TrueAfterRestartGetBladeMezzPassThroughMode(int bladeId)
{
TestCase testCase = new TestCase("TrueAfterRestartGetBladeMezzPassThroughMode", 24181);
CmTestLog.Info(string.Format(
"\n !!!!!!Verifying {0} Returns Correct Pass-ThroughMode After Restarting Blade. WorkItemId: {1}!!!!!!",
this.currentApi, testCase.WorkItemId));
TestResponse response = new TestResponse();
BladeResponse setBladeActivePowerCycleResponse = new BladeResponse();
BladeStateResponse getBladeStateResponse = new BladeStateResponse();
this.TestChannelContext = this.ListTestChannelContexts[(int)WCSSecurityRole.WcsCmAdmin];
// Restart blade
setBladeActivePowerCycleResponse = this.TestChannelContext.SetBladeActivePowerCycle(bladeId, Convert.ToInt32(CmConstants.OffTimeSec));
if (setBladeActivePowerCycleResponse.completionCode != CompletionCode.Success)
{
LogMessage.Message = string.Format(
"{0}: Failed to restart blade {1} with completion code {2}",
this.currentApi, bladeId, setBladeActivePowerCycleResponse.completionCode);
LogMessage.Log(LogMessage.MessageType.Failure, ref response);
}
// Sleep Thread for 2 minutes 30 seconds
CmTestLog.Info(string.Format("Thread sleeping for {0} seconds...",
TimeSpan.FromSeconds(150)));
Thread.Sleep(TimeSpan.FromSeconds(150));
// Verify blade soft-powered on
getBladeStateResponse = this.TestChannelContext.GetBladeState(bladeId);
if (getBladeStateResponse.completionCode != CompletionCode.Success ||
getBladeStateResponse.bladeState != PowerState.ON)
{
LogMessage.Message = string.Format(
"{0}: Blade {1} did not soft-power ON",
this.currentApi, bladeId);
LogMessage.Log(LogMessage.MessageType.Failure, ref response);
}
else
{
CallAndVerifyGetBladeMezzPassThroughMode(bladeId, ref response, "true");
}
testCase.LogPassOrFail(ref response, currentApi);
return response;
}
/// <summary>
/// command specific implementation
/// argVal command class member has all user-entered command argument indicators and parameter values
/// Currently just prints all argument indicators and argument values
/// </summary>
internal override void commandImplementation()
{
uint sledId = 1;
BladeStateResponse myResponse = new BladeStateResponse();
GetAllBladesStateResponse myResponses = new GetAllBladesStateResponse();
try
{
if (this.argVal.ContainsKey('a'))
{
myResponses = WcsCli2CmConnectionManager.channel.GetAllBladesState();
}
else if (this.argVal.ContainsKey('i'))
{
dynamic mySledId = null;
this.argVal.TryGetValue('i', out mySledId);
sledId = (uint)mySledId;
myResponse = WcsCli2CmConnectionManager.channel.GetBladeState((int)mySledId);
}
}
catch (Exception ex)
{
SharedFunc.ExceptionOutput(ex);
return;
}
if ((this.argVal.ContainsKey('a') && myResponses == null) || myResponse == null)
{
Console.WriteLine(WcsCliConstants.serviceResponseEmpty);
return;
}
if (this.argVal.ContainsKey('a'))
{
for (int index = 0; index < myResponses.bladeStateResponseCollection.Count(); index++)
{
if (ResponseValidation.ValidateBladeResponse(myResponses.bladeStateResponseCollection[index].bladeNumber, null, myResponses.bladeStateResponseCollection[index], false))
{
if (myResponses.bladeStateResponseCollection[index].bladeState == Contracts.PowerState.ON)
{
Console.WriteLine(WcsCliConstants.commandSuccess + " Blade State " + myResponses.bladeStateResponseCollection[index].bladeNumber + ": ON");
}
else if (myResponses.bladeStateResponseCollection[index].bladeState == Contracts.PowerState.OFF)
{
Console.WriteLine(WcsCliConstants.commandSuccess + " Blade State " + myResponses.bladeStateResponseCollection[index].bladeNumber + ": OFF");
}
else if (myResponses.bladeStateResponseCollection[index].bladeState == Contracts.PowerState.OnFwDecompress)
{
Console.WriteLine(WcsCliConstants.commandSuccess + " Blade State " + myResponses.bladeStateResponseCollection[index].bladeNumber + ": ON - Firmware Decompressing");
}
else
{
Console.WriteLine(WcsCliConstants.commandSuccess + " Blade State " + myResponses.bladeStateResponseCollection[index].bladeNumber + ": --");
}
}
}
}
else
{
if (ResponseValidation.ValidateBladeResponse(myResponse.bladeNumber, null, myResponse, false))
{
if (myResponse.bladeState == Contracts.PowerState.ON)
{
Console.WriteLine(WcsCliConstants.commandSuccess + " Blade State " + myResponse.bladeNumber + ": ON");
}
else if (myResponse.bladeState == Contracts.PowerState.OFF)
{
Console.WriteLine(WcsCliConstants.commandSuccess + " Blade State " + myResponse.bladeNumber + ": OFF");
}
else if (myResponse.bladeState == Contracts.PowerState.OnFwDecompress)
{
Console.WriteLine(WcsCliConstants.commandSuccess + " Blade State " + myResponse.bladeNumber + ": ON - Firmware Decompressing");
}
else
{
Console.WriteLine(WcsCliConstants.commandSuccess + " Blade State " + myResponse.bladeNumber + ": --");
}
}
}
}