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); } }