public void willCancelBIOSWrite(TimeSpan delay)
{
using (bladeDirectorDebugServices svc = new bladeDirectorDebugServices(basicBladeTests.WCFPath, basicBladeTests.WebURI))
{
machinePools.bladeDirectorURL = svc.servicesURL;
string hostIP = "1.1.1.1";
bladeSpec spec = svc.svcDebug.createBladeSpec("172.17.129.131", "192.168.129.131", "172.17.2.131", 1234, false, VMDeployStatus.notBeingDeployed, " ... ", "idk", "box", bladeLockType.lockAll, bladeLockType.lockAll);
svc.svcDebug.initWithBladesFromBladeSpec(new[] { spec }, false, NASFaultInjectionPolicy.retunSuccessful);
resultAndBladeName res = svc.svcDebug._RequestAnySingleNode(hostIP);
Assert.AreEqual(resultCode.success, res.result.code);
string ourBlade = ((resultAndBladeName)testUtils.waitForSuccess(svc, res, TimeSpan.FromSeconds(30))).bladeName;
// Start a BIOS read
resultAndWaitToken readRes = svc.svcDebug._rebootAndStartReadingBIOSConfiguration(hostIP, ourBlade);
Assert.AreEqual(resultCode.pending, readRes.result.code);
// Wait a while to see if we get somewhere where it is impossible to free without a hueg delay
Thread.Sleep(delay);
// Then free the blade. The BIOS operation should be cancelled before it soaks up all the ten minutes of time.
resultAndWaitToken releaseRes = svc.svcDebug._ReleaseBladeOrVM(hostIP, ourBlade, false);
testUtils.waitForSuccess(svc, releaseRes, TimeSpan.FromMinutes(1));
// And it should be no longer getting.
resultAndWaitToken bladeState = svc.svc.getProgress(readRes.waitToken);
Assert.AreNotEqual(resultCode.pending, bladeState.result.code);
// It no longer be allocated to us, since we released it earlier.
GetBladeStatusResult ownershipRes = svc.svc.GetBladeStatus(ourBlade);
Assert.AreEqual(GetBladeStatusResult.unused, ownershipRes);
}
}
public void willDeallocateBladeDuringBIOSSetting()
{
using (bladeDirectorDebugServices svc = new bladeDirectorDebugServices(basicBladeTests.WCFPath))
{
string hostIP = "1.1.1.1";
svc.svcDebug.initWithBladesFromIPList(new[] { "172.17.129.131" }, true, NASFaultInjectionPolicy.retunSuccessful);
string ourBlade = testUtils.doBladeAllocationForTest(svc, hostIP);
// Start a slowwww BIOS read
svc.svcDebug._setBIOSOperationTimeIfMocked(60 * 10);
resultAndWaitToken readRes = svc.svcDebug._rebootAndStartReadingBIOSConfiguration(hostIP, ourBlade);
Assert.AreEqual(resultCode.pending, readRes.result.code);
// Then free the blade. The BIOS operation should be cancelled before it soaks up all the ten minutes of time.
resultAndWaitToken releaseRes = svc.svcDebug._ReleaseBladeOrVM(hostIP, ourBlade, false);
testUtils.waitForSuccess(svc, releaseRes, TimeSpan.FromMinutes(1));
// And it should be no longer getting.
resultAndWaitToken bladeState = svc.svc.getProgress(readRes.waitToken);
Assert.AreNotEqual(resultCode.pending, bladeState.result.code);
// And should not be allocated
GetBladeStatusResult ownershipRes = svc.svc.GetBladeStatus(ourBlade);
Assert.AreEqual(GetBladeStatusResult.unused, ownershipRes);
}
}
public void willDeallocateOldVMsOnLogon()
{
using (bladeDirectorDebugServices svc = new bladeDirectorDebugServices(basicBladeTests.WCFPath, "172.17.129.131", true))
{
string hostIP = "1.1.1.1";
testUtils.doLogin(svc, hostIP);
// Allocate all the blades, then login again. The allocated blades should no longer be allocated.
string ourVM = testUtils.doVMAllocationForTest(svc, hostIP);
// Find the parent blade of the VM we got, and make sure it is now in use (by the blade director)
vmSpec VMSpec = svc.svc.getVMByIP_withoutLocking(ourVM);
bladeSpec bladeSpec = svc.svc.getBladeByIP_withoutLocking(VMSpec.parentBladeIP);
GetBladeStatusResult bladeState = svc.svcDebug._GetBladeStatus(hostIP, bladeSpec.bladeIP);
string bladeIP = bladeSpec.bladeIP;
Assert.AreEqual(bladeState, GetBladeStatusResult.notYours);
// Do a new login, which should cause our blades to be deallocated.
testUtils.doLogin(svc, hostIP);
// The VM should now not exist.
Assert.AreEqual(null, svc.svc.getVMByIP_withoutLocking(ourVM));
// Find the parent blade of the VM we got, and make sure it is now unused.
GetBladeStatusResult bladeState2 = svc.svcDebug._GetBladeStatus(hostIP, bladeIP);
Assert.AreEqual(bladeState2, GetBladeStatusResult.unused);
}
}
public void willReallocateBladeAfterLogin()
{
using (bladeDirectorDebugServices svc = new bladeDirectorDebugServices(basicBladeTests.WCFPath))
{
string hostIP = "1.1.1.1";
svc.svcDebug.initWithBladesFromIPList(new[] { "172.17.129.131" }, true, NASFaultInjectionPolicy.retunSuccessful);
string ourBlade = testUtils.doBladeAllocationForTest(svc, hostIP);
// It should be ours..
GetBladeStatusResult bladeState = svc.svcDebug._GetBladeStatus(hostIP, ourBlade);
Assert.AreEqual(bladeState, GetBladeStatusResult.yours);
// Then free it 'dirtily', by logging in again.
resultAndWaitToken res = svc.svcDebug._logIn(hostIP);
while (res.result.code == resultCode.pending)
{
res = svc.svc.getProgress(res.waitToken);
Thread.Sleep(TimeSpan.FromSeconds(3));
}
Assert.AreEqual(resultCode.success, res.result.code);
// The blade should now be unused.
bladeState = svc.svcDebug._GetBladeStatus(hostIP, ourBlade);
Assert.AreEqual(bladeState, GetBladeStatusResult.unused);
// And if we allocate again, we should get it OK.
ourBlade = testUtils.doBladeAllocationForTest(svc, hostIP);
bladeState = svc.svcDebug._GetBladeStatus(hostIP, ourBlade);
Assert.AreEqual(bladeState, GetBladeStatusResult.yours);
}
}
public void willDeallocateBladeAtLoginDuringVMProvisioning()
{
using (bladeDirectorDebugServices svc = new bladeDirectorDebugServices(basicBladeTests.WCFPath))
{
string hostIP = "1.1.1.1";
svc.svcDebug.initWithBladesFromIPList(new[] { "172.17.129.131" }, true, NASFaultInjectionPolicy.retunSuccessful);
VMHardwareSpec hwspec = new VMHardwareSpec
{
cpuCount = 1,
memoryMB = 1024 * 3
};
VMSoftwareSpec swspec = new VMSoftwareSpec();
// Start a slow VM allocation
svc.svcDebug._setExecutionResultsIfMocked(mockedExecutionResponses.successfulButSlow);
resultAndWaitToken res = svc.svcDebug._requestAnySingleVM(hostIP, hwspec, swspec);
Assert.AreEqual(resultCode.pending, res.result.code);
// Then re-login. The VM operation should be cancelled.
resultAndWaitToken releaseRes = svc.svcDebug._logIn(hostIP);
testUtils.waitForSuccess(svc, releaseRes, TimeSpan.FromMinutes(1));
// And it should be no longer provisioning the VM.
resultAndWaitToken bladeState = svc.svc.getProgress(res.waitToken);
Assert.AreNotEqual(resultCode.pending, bladeState.result.code);
// And should not be allocated.
GetBladeStatusResult ownershipRes = svc.svc.GetBladeStatus("172.17.129.131");
Assert.AreEqual(GetBladeStatusResult.unused, ownershipRes);
}
}
public void willDeallocateOldBladesOnLogon()
{
using (bladeDirectorDebugServices svc = new bladeDirectorDebugServices(basicBladeTests.WCFPath))
{
string hostIP = "1.1.1.1";
svc.svcDebug.initWithBladesFromIPList(new[] { "172.17.129.131" }, true, NASFaultInjectionPolicy.retunSuccessful);
// Allocate a blade, then login again. The allocated blade should no longer be allocated.
string ourBlade = testUtils.doBladeAllocationForTest(svc, hostIP);
testUtils.doLogin(svc, hostIP);
GetBladeStatusResult bladeState = svc.svcDebug._GetBladeStatus(hostIP, ourBlade);
Assert.AreEqual(bladeState, GetBladeStatusResult.unused);
}
}
public void canAllocateVMMocked()
{
string hostIP = "1.1.1.1";
using (bladeDirectorDebugServices svc = new bladeDirectorDebugServices(basicBladeTests.WCFPath, new[] { "1.1.1.1", "2.2.2.2", "3.3.3.3" }))
{
VMHardwareSpec hwSpec = new VMHardwareSpec()
{
memoryMB = 2344, cpuCount = 2
};
VMSoftwareSpec swSpec = new VMSoftwareSpec();
resultAndBladeName[] allocRes = doVMAllocationsForTest(svc, hostIP, new[] { new vmHWAndSWSpec(hwSpec, swSpec) });
Assert.AreEqual(1, allocRes.Length);
resultAndBladeName allocatedBlade = allocRes[0];
// TODO: check nas events
mockedCall[] nasEvents = svc.svcDebug._getNASEventsIfMocked();
foreach (mockedCall call in nasEvents)
{
Debug.WriteLine(call.functionName + " " + call.message);
}
// TODO: check executions all happened okay
// This blade should become a VM server
GetBladeStatusResult allocated1 = svc.svcDebug._GetBladeStatus(hostIP, "172.17.129.130");
Assert.AreEqual(allocated1, GetBladeStatusResult.notYours);
// And there should now be one VM allocated to us at present.
vmSpec VMConfig = svc.svc.getVMByIP_withoutLocking(allocatedBlade.bladeName);
Assert.AreEqual("172.17.158.1", allocatedBlade.bladeName);
Assert.AreEqual("VM_30_01", VMConfig.friendlyName);
Assert.AreEqual("172.17.158.1", VMConfig.VMIP);
Assert.AreEqual("10.0.158.1", VMConfig.iscsiIP);
Assert.AreEqual("00:50:56:00:30:01", VMConfig.eth0MAC);
Assert.AreEqual("00:50:56:01:30:01", VMConfig.eth1MAC);
Assert.AreEqual(2344, VMConfig.memoryMB);
Assert.AreEqual(2, VMConfig.cpuCount);
Assert.AreEqual(hostIP, VMConfig.currentOwner);
}
}
private void updateNow()
{
lock (this)
{
using (BladeDirectorServices svc = new BladeDirectorServices(_baseURL))
{
foreach (ownedBlade blade in _blades)
{
GetBladeStatusResult bladeStatus = svc.svc.GetBladeStatus(blade.bladeIPAddress);
if (bladeStatus == GetBladeStatusResult.releasePending)
{
blade.isReleaseRequested = true;
}
else
{
blade.isReleaseRequested = false;
}
}
}
}
}
public void willDeallocateBladeAfterVMDestruction()
{
using (bladeDirectorDebugServices svc = new bladeDirectorDebugServices(basicBladeTests.WCFPath, "2.2.2.2", true))
{
string hostIP = "1.1.1.1";
string ourVM = testUtils.doVMAllocationForTest(svc, hostIP);
// Our blade should become a VM server
GetBladeStatusResult bladeState = svc.svcDebug._GetBladeStatus(hostIP, "2.2.2.2");
Assert.AreEqual(GetBladeStatusResult.notYours, bladeState);
// Then free the VM.
resultAndWaitToken releaseRes = svc.svcDebug._ReleaseBladeOrVM(hostIP, ourVM, false);
testUtils.waitForSuccess(svc, releaseRes, TimeSpan.FromSeconds(10));
// The blade itself should become unused.
bladeState = svc.svcDebug._GetBladeStatus(hostIP, "2.2.2.2");
Assert.AreEqual(GetBladeStatusResult.unused, bladeState);
}
}
public void willDeallocateBlade()
{
using (bladeDirectorDebugServices svc = new bladeDirectorDebugServices(basicBladeTests.WCFPath))
{
string hostIP = "1.1.1.1";
svc.svcDebug.initWithBladesFromIPList(new[] { "172.17.129.131" }, true, NASFaultInjectionPolicy.retunSuccessful);
string ourBlade = testUtils.doBladeAllocationForTest(svc, hostIP);
// It should be ours..
GetBladeStatusResult bladeState = svc.svcDebug._GetBladeStatus(hostIP, ourBlade);
Assert.AreEqual(bladeState, GetBladeStatusResult.yours);
// Then free it
resultAndWaitToken releaseRes = svc.svcDebug._ReleaseBladeOrVM(hostIP, ourBlade, false);
testUtils.waitForSuccess(svc, releaseRes, TimeSpan.FromSeconds(10));
// And it should be unused.
bladeState = svc.svcDebug._GetBladeStatus(hostIP, ourBlade);
Assert.AreEqual(bladeState, GetBladeStatusResult.unused);
}
}
