Examples of org.nimbustools.api.services.rm.Manager

org.nimbustools.api.services.rm.Manager
imbusproject.org/images/sh.png" alt="[Start here] " /> The main RM interface.

Better documentation/diagrams coming, the best way to learn right now is to see how it is invoked in one of the message layer implementations.

The main documentation task is to document the tricky areas like 'legal inputs' etc. From looking at the method names you should be able to see the basic usage:
- create VMs
- request spot instances
- manage VMs by instance handle or group handle
- destroy VMs by instance handle or group handle
- query for up to date information
- register callbacks for state changes or terminations events
Click on the "Manager" link above to see the source code which has a more natural grouping of the methods.

todo: document each method independently

todo: richer exceptions/hiearchy

     * @throws Exception problem
     */
    @Test(groups="prereqs")
    public void retrieveModuleLocator() throws Exception {
        logger.debug("retrieveModuleLocator");
        final Manager rm = this.locator.getManager();
        final VM[] vms = rm.getGlobalAll();


        // we know there are zero so far because it is in group 'prereqs'
        assertEquals(0, vms.length);
    }

View Full Code Here

     * @throws Exception problem
     */
    @Test(dependsOnGroups="prereqs")
    public void leaseOne() throws Exception {
        logger.debug("leaseOne");
        final Manager rm = this.locator.getManager();


        final Caller caller = this.populator().getCaller();
        final CreateResult result =
                rm.create(this.populator().getCreateRequest("suite:basic:leaseOne"),
                          caller);


        final VM[] vms = result.getVMs();
        assertEquals(1, vms.length);
        assertNotNull(vms[0]);
        logger.info("Leased vm '" + vms[0].getID() + '\'');


        assertTrue(rm.exists(vms[0].getID(), Manager.INSTANCE));


        Thread.sleep(1000L);
        rm.trash(vms[0].getID(), Manager.INSTANCE, caller);
    }

View Full Code Here

        Calendar ts1 = Calendar.getInstance();


        //Objects and requests setup
        Caller caller = this.populator().getCaller();
        Caller superuser = this.populator().getSuperuserCaller();
        Manager rm = this.locator.getManager();


        Double previousPrice = rm.getSpotPrice();


        logger.debug("Submitting backfill request..");


        AsyncCreateRequest backfillRequest = this.populator().getBackfillRequest("backfill", 10);
        RequestInfo backfillResult = rm.addBackfillRequest(backfillRequest, superuser);


        // Spot Instances Snapshot
        //
        // Total memory: 1280MB
        // Reserved free memory (for ordinary WS requests): 256MB  (minimum reserved capacity)
        // Available basic SI VMs: 8 (128MB x 8 = 1024)
        //
        // Current SI Requests________________________________________________________
        // |   Request  | reqVMs | allocVMs |       Bid        | Status | Persistent |
        // ---------------------------------------------------------------------------
        // Backfill Requests__________________________
        // |   Request  | reqVMs | allocVMs | Status |
        // | backfill   |   10   |    8     | ACTIVE |
        // -------------------------------------------
        // Requested SI VMs (alive requests): 0
        // Spot price: MINIUM_PRICE (since requestedVMs < availableVMs)


        logger.debug("Waiting 10 seconds for resources to be allocated.");
        Thread.sleep(10000);


        //Verify there are no spot instance requests
        SpotRequestInfo[] spotRequestByCaller = rm.getSpotRequestsByCaller(superuser);
        assertEquals(0, spotRequestByCaller.length);
        spotRequestByCaller = rm.getSpotRequestsByCaller(caller);
        assertEquals(0, spotRequestByCaller.length);


        //Check backfill request state
        RequestInfo[] backfillRequestsByCaller = rm.getBackfillRequestsByCaller(superuser);
        assertEquals(1, backfillRequestsByCaller.length);
        String[] vmIdsBefore = backfillRequestsByCaller[0].getVMIds();
        assertEquals(8, vmIdsBefore.length);
        assertEquals(RequestState.STATE_Active, backfillRequestsByCaller[0].getState().getStateStr());


        //New spot price is equal to minimum price (since there are still available resources)
        assertEquals(MINIMUM_PRICE,  rm.getSpotPrice());


        final Double bid = previousPrice + 1;
        SpotCreateRequest requestSI = this.populator().getBasicRequestSI("singleRequest", 1, bid, false);


        logger.debug("Submitting basic SI request: singleRequest");


        //Request spot instances
        SpotRequestInfo result = rm.requestSpotInstances(requestSI, caller);


        logger.debug("Waiting 10 seconds for resources to be allocated.");
        Thread.sleep(10000);


        //Check result
        //note: cannot check state at this point, because it can either be
        //OPEN (not scheduled yet) or ACTIVE (already scheduled)
        assertEquals(bid, result.getSpotPrice());
        assertTrue(!result.isPersistent());


        // Spot Instances Snapshot
        //
        // Total memory: 1280MB
        // Reserved free memory (for ordinary WS requests): 256MB  (minimum reserved capacity)
        // Available basic SI VMs: 8 (128MB x 8 = 1024)
        //
        // Current SI Requests___________________________________________________________
        // |   Request  | reqVMs | allocVMs |       Bid        | Status | Persistent |
        // | singleReq  |    1   |    1     |  previousPrice+1 | ACTIVE |    false   |
        // ---------------------------------------------------------------------------
        // Backfill Requests__________________________
        // |   Request  | reqVMs | allocVMs | Status |
        // | backfill   |   10   |    7     | ACTIVE |
        // -------------------------------------------
        // Requested SI VMs (alive requests): 1
        // Spot price: MINIUM_PRICE (since requestedVMs < availableVMs)


        //Check backfill request state
        backfillRequestsByCaller = rm.getBackfillRequestsByCaller(superuser);
        assertEquals(1, backfillRequestsByCaller.length);
        String[] vmIdsAfter = backfillRequestsByCaller[0].getVMIds();
        assertEquals(7, vmIdsAfter.length);
        assertEquals(RequestState.STATE_Active, backfillRequestsByCaller[0].getState().getStateStr());


        //This check is to ensure that the VMs now are the same as before (ie. VMs were not restarted)
        Integer equalVms = 0;
        for (String vmIdBefore : vmIdsBefore) {
            for (String vmIdAfter : vmIdsAfter) {
                if(vmIdAfter.equals(vmIdBefore)){
                    equalVms++;
                    break;
                }
            }
        }
        assertEquals(new Integer(7), equalVms);


        //New spot price is equal to minimum price (since there are still available resources)
        assertEquals(MINIMUM_PRICE,  rm.getSpotPrice());


        spotRequestByCaller = rm.getSpotRequestsByCaller(caller);
        assertEquals(1, spotRequestByCaller.length);


        //Let's assume the request was already scheduled, so the state should be ACTIVE
        SpotRequestInfo request = rm.getSpotRequest(result.getRequestID(), caller);
        assertEquals(RequestState.STATE_Active, request.getState().getStateStr());
        assertEquals(1, request.getVMIds().length);


        logger.debug("Cancelling basic SI request: singleRequest");


        SpotRequestInfo[] cancelledReqs = rm.cancelSpotInstanceRequests(new String[]{result.getRequestID()}, caller);
        assertEquals(1, cancelledReqs.length);
        assertEquals(RequestState.STATE_Canceled, cancelledReqs[0].getState().getStateStr());
        assertEquals(result.getRequestID(), cancelledReqs[0].getRequestID());


        // Spot Instances Snapshot
        //
        // Total memory: 1280MB
        // Reserved free memory (for ordinary WS requests): 256MB
        // Available basic SI VMs: 8 (128MB x 8 = 1024)
        //
        // Current Requests______________________________________________________________
        // |   Request  | reqVMs | allocVMs |       Bid        |   Status  | Persistent |
        // | singleReq  |    1   |    1     |  previousPrice+1 | CANCELLED |    false   |
        // ------------------------------------------------------------------------------
        // Backfill Requests__________________________
        // |   Request  | reqVMs | allocVMs | Status |
        // | backfill   |   10   |    7     | ACTIVE |
        // -------------------------------------------
        // Requested SI VMs (alive requests): 1
        // Spot price: MINIUM_PRICE (since requestedVMs < availableVMs)


        logger.debug("Waiting 10 seconds for resources to be pre-empted.");
        Thread.sleep(10000);


        //Check backfill request state
        backfillRequestsByCaller = rm.getBackfillRequestsByCaller(superuser);
        assertEquals(1, backfillRequestsByCaller.length);
        assertEquals(7, backfillRequestsByCaller[0].getVMIds().length);
        assertEquals(RequestState.STATE_Active, backfillRequestsByCaller[0].getState().getStateStr());


        //Check if request was really cancelled
        request = rm.getSpotRequest(result.getRequestID(), caller);
        assertEquals(RequestState.STATE_Canceled, request.getState().getStateStr());
        assertEquals(1, request.getVMIds().length);


        Double higherBid = previousPrice + 2;
        requestSI = this.populator().getBasicRequestSI("higherRequest", 7, higherBid, false);


        logger.debug("Submitting basic SI request: higherRequest");


        //Request spot instances
        SpotRequestInfo result2 = rm.requestSpotInstances(requestSI, caller);


        // Spot Instances Snapshot
        //
        // Total memory: 1280MB
        // Reserved free memory (for ordinary WS requests): 256MB
        // Available basic SI VMs: 8 (128MB x 8 = 1024)
        //
        // Current Requests______________________________________________________________
        // |   Request  | reqVMs | allocVMs |       Bid        |   Status  | Persistent |
        // | singleReq  |    1   |    1     |  previousPrice+1 | CANCELLED |    false   |
        // | higherReq  |    7   |    7     |  previousPrice+2 | ACTIVE    |    false   |
        // ------------------------------------------------------------------------------
        // Backfill Requests__________________________
        // |   Request  | reqVMs | allocVMs | Status |
        // | backfill   |   10   |    0     | OPEN   |
        // -------------------------------------------
        // Requested SI VMs (alive requests): 8
        // Spot price: bid (previousPrice+1)


        logger.debug("Waiting 10 seconds for resources to be pre-empted.");
        Thread.sleep(10000);


        //New spot price is equal to bid
        assertEquals(bid,  rm.getSpotPrice());


        //Check backfill request state
        backfillRequestsByCaller = rm.getBackfillRequestsByCaller(superuser);
        assertEquals(1, backfillRequestsByCaller.length);
        assertEquals(0, backfillRequestsByCaller[0].getVMIds().length);
        assertEquals(RequestState.STATE_Open, backfillRequestsByCaller[0].getState().getStateStr());


        //Check if request was really cancelled
        request = rm.getSpotRequest(result.getRequestID(), caller);
        assertEquals(RequestState.STATE_Canceled, request.getState().getStateStr());
        assertEquals(1, request.getVMIds().length);


        //Check if submitted request is active
        request = rm.getSpotRequest(result2.getRequestID(), caller);
        assertEquals(RequestState.STATE_Active, request.getState().getStateStr());
        assertEquals(7, request.getVMIds().length);


        requestSI = this.populator().getBasicRequestSI("higherRequest2", 1, higherBid, false);


        logger.debug("Submitting basic SI request: higherRequest2");


        //Request spot instances
        SpotRequestInfo result3 = rm.requestSpotInstances(requestSI, caller);


        // Spot Instances Snapshot
        //
        // Total memory: 1280MB
        // Reserved free memory (for ordinary WS requests): 256MB
        // Available basic SI VMs: 8 (128MB x 8 = 1024)
        //
        // Current Requests______________________________________________________________
        // |   Request  | reqVMs | allocVMs |       Bid        |   Status  | Persistent |
        // | singleReq  |    1   |    0     |  previousPrice+1 | CANCELLED |    false   |
        // | higherReq  |    7   |    7     |  previousPrice+2 | ACTIVE    |    false   |
        // | higherReq2 |    1   |    1     |  previousPrice+2 | ACTIVE    |    false   |
        // ------------------------------------------------------------------------------
        // Backfill Requests__________________________
        // |   Request  | reqVMs | allocVMs | Status |
        // | backfill   |   10   |    0     | OPEN   |
        // -------------------------------------------
        // Requested SI VMs (alive requests): 8
        // Spot price: higherBid (previousPrice+2)


        logger.debug("Waiting 10 seconds for resources to be pre-empted.");
        Thread.sleep(10000);


        //New spot price is equal to higherBid
        assertEquals(higherBid,  rm.getSpotPrice());


        //Check backfill request state
        backfillRequestsByCaller = rm.getBackfillRequestsByCaller(superuser);
        assertEquals(1, backfillRequestsByCaller.length);
        assertEquals(0, backfillRequestsByCaller[0].getVMIds().length);
        assertEquals(RequestState.STATE_Open, backfillRequestsByCaller[0].getState().getStateStr());


        //Check if request has no VMs
        request = rm.getSpotRequest(result.getRequestID(), caller);
        assertEquals(RequestState.STATE_Canceled, request.getState().getStateStr());
        assertEquals(0, request.getVMIds().length);


        //Check if previous submitted request is active
        request = rm.getSpotRequest(result2.getRequestID(), caller);
        assertEquals(RequestState.STATE_Active, request.getState().getStateStr());
        assertEquals(7, request.getVMIds().length);


        //Check if submitted request is active
        request = rm.getSpotRequest(result3.getRequestID(), caller);
        assertEquals(RequestState.STATE_Active, request.getState().getStateStr());
        assertEquals(1, request.getVMIds().length);


        logger.debug("Trashing higherRequest VMs");


        request = rm.getSpotRequest(result2.getRequestID(), caller);
        rm.trash(request.getGroupID(), Manager.GROUP, caller);


        // Spot Instances Snapshot
        //
        // Total memory: 1280MB
        // Reserved free memory (for ordinary WS requests): 256MB
        // Available basic SI VMs: 8 (128MB x 8 = 1024)
        //
        // Current Requests______________________________________________________________
        // |   Request  | reqVMs | allocVMs |       Bid        |   Status  | Persistent |
        // | singleReq  |    1   |    0     |  previousPrice+1 | CANCELLED |    false   |
        // | higherReq  |    7   |    0     |  previousPrice+2 | CLOSED    |    false   |
        // | higherReq2 |    1   |    1     |  previousPrice+2 | ACTIVE    |    false   |
        // ------------------------------------------------------------------------------
        // Backfill Requests__________________________
        // |   Request  | reqVMs | allocVMs | Status |
        // | backfill   |   10   |    7     | ACTIVE |
        // -------------------------------------------
        // Requested SI VMs (alive requests): 1
        // Spot price: MINIUM_PRICE (since requestedVMs < availableVMs)


        logger.debug("Waiting 10 seconds for resources to be pre-empted.");
        Thread.sleep(10000);


        //New spot price is equal to minimum price (since there are still available resources)
        assertEquals(MINIMUM_PRICE,  rm.getSpotPrice());


        //Check backfill request state
        backfillRequestsByCaller = rm.getBackfillRequestsByCaller(superuser);
        assertEquals(1, backfillRequestsByCaller.length);
        assertEquals(7, backfillRequestsByCaller[0].getVMIds().length);
        assertEquals(RequestState.STATE_Active, backfillRequestsByCaller[0].getState().getStateStr());


        //Check if request has no VMs
        request = rm.getSpotRequest(result.getRequestID(), caller);
        assertEquals(RequestState.STATE_Canceled, request.getState().getStateStr());
        assertEquals(0, request.getVMIds().length);


        //Check if previous submitted request is closed
        request = rm.getSpotRequest(result2.getRequestID(), caller);
        assertEquals(RequestState.STATE_Closed, request.getState().getStateStr());
        assertEquals(0, request.getVMIds().length);


        //Check if submitted request is active
        request = rm.getSpotRequest(result3.getRequestID(), caller);
        assertEquals(RequestState.STATE_Active, request.getState().getStateStr());
        assertEquals(1, request.getVMIds().length);


        logger.debug("Cancelling backfill request.");


        RequestInfo[] cancelledBackfillReqs = rm.cancelBackfillRequests(new String[]{backfillResult.getRequestID()}, superuser);
        assertEquals(1, cancelledBackfillReqs.length);
        assertEquals(RequestState.STATE_Canceled, cancelledBackfillReqs[0].getState().getStateStr());
        assertEquals(backfillResult.getRequestID(), cancelledBackfillReqs[0].getRequestID());


        logger.debug("Waiting for termination.");
        Thread.sleep(2100);


        //Check backfill request state
        RequestInfo backfillReq = rm.getBackfillRequest(backfillResult.getRequestID(), superuser);
        assertEquals(0, backfillReq.getVMIds().length);
        assertEquals(RequestState.STATE_Canceled, backfillReq.getState().getStateStr());


        logger.debug("Trashing higherRequest2 VMs");


        request = rm.getSpotRequest(result3.getRequestID(), caller);
        rm.trash(request.getVMIds()[0], Manager.INSTANCE, caller);


        // Spot Instances Snapshot
        //
        // Total memory: 1280MB
        // Reserved free memory (for ordinary WS requests): 256MB
        // Available basic SI VMs: 8 (128MB x 8 = 1024)
        //
        // Current Requests______________________________________________________________
        // |   Request  | reqVMs | allocVMs |       Bid        |   Status  | Persistent |
        // | singleReq  |    1   |    0     |  previousPrice+1 | CANCELLED |    false   |
        // | higherReq  |    7   |    0     |  previousPrice+2 | CLOSED    |    false   |
        // | higherReq2 |    1   |    0     |  previousPrice+2 | CLOSED    |    false   |
        // ------------------------------------------------------------------------------
        // Backfill Requests__________________________
        // |   Request  | reqVMs | allocVMs | Status |
        // | backfill   |   10   |    7     | ACTIVE |
        // -------------------------------------------
        // Requested SI VMs (alive requests): 0
        // Spot price: MINIUM_PRICE (since requestedVMs < availableVMs)


        logger.debug("Waiting 10 seconds for resources to be pre-empted.");
        Thread.sleep(10000);


        //New spot price is equal to minimum price (since there are still available resources)
        assertEquals(MINIMUM_PRICE,  rm.getSpotPrice());


        //Check backfill request state
        backfillRequestsByCaller = rm.getBackfillRequestsByCaller(superuser);
        assertEquals(1, backfillRequestsByCaller.length);
        assertEquals(0, backfillRequestsByCaller[0].getVMIds().length);
        assertEquals(RequestState.STATE_Canceled, backfillRequestsByCaller[0].getState().getStateStr());


        //Check if request has no VMs
        request = rm.getSpotRequest(result.getRequestID(), caller);
        assertEquals(RequestState.STATE_Canceled, request.getState().getStateStr());
        assertEquals(0, request.getVMIds().length);


        //Check if previous submitted request is closed
        request = rm.getSpotRequest(result2.getRequestID(), caller);
        assertEquals(RequestState.STATE_Closed, request.getState().getStateStr());
        assertEquals(0, request.getVMIds().length);


        //Check if submitted request is closed
        request = rm.getSpotRequest(result3.getRequestID(), caller);
        assertEquals(RequestState.STATE_Closed, request.getState().getStateStr());
        assertEquals(0, request.getVMIds().length);


        Double[] prices = {MINIMUM_PRICE, bid, higherBid, MINIMUM_PRICE};


        //Check spot price history
        SpotPriceEntry[] history = rm.getSpotPriceHistory();


        assertEquals(prices.length, history.length);


        for (int i = 0; i < history.length; i++) {
            assertEquals(prices[i], history[i].getSpotPrice());
        }


        history = rm.getSpotPriceHistory(null, ts1);


        assertEquals(1, history.length);


        history = rm.getSpotPriceHistory(ts1, null);


        assertEquals(3, history.length);


        for (int i = 1; i < prices.length; i++) {
            assertEquals(prices[i], history[i-1].getSpotPrice());

View Full Code Here

                    "StatusHome not initialized properly, no master context");
        }


        // some room for internal IoC in the future
        
        final Manager mgr = this.master.getModuleLocator().getManager();


        final ReprFactory repr =
                this.master.getModuleLocator().getReprFactory();


        final URL baseURL;

View Full Code Here


    final String parallelIdempotencyTestToken = UUID.randomUUID().toString();
    @Test(threadPoolSize = 10, invocationCount = 10, timeOut = 10000)
    public void parallelIdempotencyTest() throws Exception {


        final Manager rm = this.locator.getManager();


        final Caller caller = this.populator().getCaller();
        final CreateRequest request1 =
                this.populator().getIdempotentCreateRequest("suite:basic:idempotency",
                        parallelIdempotencyTestToken);
        final CreateResult result1 = rm.create(request1, caller);


        logger.info("Leased vm '" + result1.getVMs()[0].getID() + '\'');
        assertEquals(parallelIdempotencyTestToken, result1.getVMs()[0].getClientToken());
        assertEquals("1", result1.getVMs()[0].getID());
    }

View Full Code Here

     * Check if ModuleLocator can be retrieved and used at all.
     */
    @Test(groups="pr3r3qs")
    public void retrieveModuleLocator() throws Exception {
        logger.debug("retrieveModuleLocator");
        final Manager rm = this.locator.getManager();
        final VM[] vms = rm.getGlobalAll();


        // we know there are zero so far because it is in group 'prereqs'
        assertEquals(0, vms.length);
    }

View Full Code Here

    // -----------------------------------------------------------------------------------------


    @Test(groups="nobackoff", dependsOnGroups="pr3r3qs")
    public void noBackoff() throws Exception {
        logger.debug("nobackoff");
        final Manager rm = this.locator.getManager();


        VM[] allvms = rm.getGlobalAll();
        assertEquals(0, allvms.length);
        
        MockShutdownTrash.resetFailCount();


        final Caller caller = this.populator().getCaller();
        final CreateResult result =
                rm.create(this.populator().getCreateRequest("suite:backoff:nobackoff"),
                          caller);


        final VM[] vms = result.getVMs();
        assertEquals(1, vms.length);
        assertNotNull(vms[0]);
        logger.info("Leased vm '" + vms[0].getID() + '\'');


        assertTrue(rm.exists(vms[0].getID(), Manager.INSTANCE));


        Thread.sleep(2000L);
        assertEquals(0, MockShutdownTrash.getFailCount());


        // Fail at killing the instance:
        MockShutdownTrash.setFail(true);
        logger.warn("Set to fail.");


        rm.trash(vms[0].getID(), Manager.INSTANCE, caller);
        Thread.sleep(2000L);


        // Check that it is at least trying to terminate the node:
        int lastFailCount = MockShutdownTrash.getFailCount();
        assertFalse(0 == lastFailCount);
        
        assertTrue(rm.exists(vms[0].getID(), Manager.INSTANCE));
        allvms = rm.getGlobalAll();
        assertEquals(1, allvms.length);


        long lastFailMs = MockShutdownTrash.getMsAtLastAttempt();
        assertFalse(0 == lastFailMs);


        Thread.sleep(4000L);


        long nextFailMs = MockShutdownTrash.getMsAtLastAttempt();
        assertFalse(nextFailMs == lastFailMs);


        assertTrue(rm.exists(vms[0].getID(), Manager.INSTANCE));
        allvms = rm.getGlobalAll();
        assertEquals(1, allvms.length);


        // Start succeeding to kill the instance:
        MockShutdownTrash.setFail(false);
        logger.warn("Set to succeed.");


        Thread.sleep(4000L);
        
        // Should now be gone:
        assertFalse(rm.exists(vms[0].getID(), Manager.INSTANCE));
        allvms = rm.getGlobalAll();
        assertEquals(0, allvms.length);


        long finalFailMs = MockShutdownTrash.getMsAtLastAttempt();
        assertFalse(finalFailMs == nextFailMs);

View Full Code Here




    @Test(groups="yesbackoff", dependsOnGroups="nobackoff")
    public void testBackoff() throws Exception {
        logger.debug("yesbackoff");
        final Manager rm = this.locator.getManager();


        VM[] allvms = rm.getGlobalAll();
        assertEquals(0, allvms.length);


        MockShutdownTrash.resetFailCount();


        final Caller caller = this.populator().getCaller();
        final CreateResult result =
                rm.create(this.populator().getCreateRequest("suite:backoff:yesbackoff"),
                          caller);


        final VM[] vms = result.getVMs();
        assertEquals(1, vms.length);
        assertNotNull(vms[0]);
        logger.info("Leased vm '" + vms[0].getID() + '\'');


        assertTrue(rm.exists(vms[0].getID(), Manager.INSTANCE));


        Thread.sleep(2000L);
        assertEquals(0, MockShutdownTrash.getFailCount());


        // Fail at killing the instance:
        MockShutdownTrash.setFail(true);
        logger.warn("Set to fail.");


        rm.trash(vms[0].getID(), Manager.INSTANCE, caller);
        Thread.sleep(2000L);


        // Check that it is at least trying to terminate the node:
        int lastFailCount = MockShutdownTrash.getFailCount();
        assertFalse(0 == lastFailCount);


        assertTrue(rm.exists(vms[0].getID(), Manager.INSTANCE));
        allvms = rm.getGlobalAll();
        assertEquals(1, allvms.length);


        long prevFailMs = MockShutdownTrash.getMsAtLastAttempt();
        assertFalse(0 == prevFailMs);


        Thread.sleep(4000L);


        long nextFailMs = MockShutdownTrash.getMsAtLastAttempt();
        assertFalse(nextFailMs == prevFailMs);


        logger.debug("fail difference: " + (nextFailMs - prevFailMs));


        prevFailMs = nextFailMs;
        nextFailMs = 0;


        assertTrue(rm.exists(vms[0].getID(), Manager.INSTANCE));
        allvms = rm.getGlobalAll();
        assertEquals(1, allvms.length);


        long markerTime1 = prevFailMs;


        Thread.sleep(2100L);

View Full Code Here

     * Check if ModuleLocator can be retrieved and used at all.
     */
    @Test(groups="prereqs")
    public void retrieveModuleLocator() throws Exception {
        logger.debug("retrieveModuleLocator");
        final Manager rm = this.locator.getManager();
        final VM[] vms = rm.getGlobalAll();


        // we know there are zero so far because it is in group 'prereqs'
        assertEquals(0, vms.length);
    }

View Full Code Here

     * Lease a VM and then destroy it.
     */
    @Test(groups="basic1", dependsOnGroups="prereqs")
    public void leaseOne() throws Exception {
        logger.debug("leaseOne");
        final Manager rm = this.locator.getManager();


        VM[] allvms = rm.getGlobalAll();
        assertEquals(0, allvms.length);


        final Caller caller = this.populator().getCaller();
        final CreateResult result =
                rm.create(this.populator().getCreateRequest("suite:failure:leaseOne"),
                          caller);


        final VM[] vms = result.getVMs();
        assertEquals(1, vms.length);
        assertNotNull(vms[0]);
        logger.info("Leased vm '" + vms[0].getID() + '\'');


        assertTrue(rm.exists(vms[0].getID(), Manager.INSTANCE));


        Thread.sleep(4000L);
        rm.trash(vms[0].getID(), Manager.INSTANCE, caller);


        Thread.sleep(1000L);
        
        allvms = rm.getGlobalAll();
        assertEquals(0, allvms.length);


    }

View Full Code Here

0 1 2 3

TOP

Related Classes of org.nimbustools.api.services.rm.Manager

org.globus.workspace.testing.NimbusTestBase

org.globus.workspace.testing.suites.basic.AsyncRequestMapSuite

org.globus.workspace.testing.suites.basic.AvailabilityZonesSuite

org.globus.workspace.testing.suites.basic.BasicSuite

org.globus.workspace.testing.suites.basic.DirtiesContextExampleSuite

org.globus.workspace.testing.suites.basic.Issue37Suite

org.globus.workspace.testing.suites.basic.NodeManagementSuite

org.globus.workspace.testing.suites.basic.ParallelIdempotentCreationSuite

org.globus.workspace.testing.suites.failure.BackoffSuite

org.globus.workspace.testing.suites.failure.TerminateSuite

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.