Examples of org.nimbustools.api.repr.SpotRequestInfo

org.nimbustools.api.repr.SpotRequestInfo

        Double previousPrice = rm.getSpotPrice();
        
        final Double bid = previousPrice + 1;
        SpotCreateRequest requestSI = this.populator().getBasicRequestSI("suite:spotinstances:noresources:singleRequest", 1, bid, false);
        
        SpotRequestInfo result = rm.requestSpotInstances(requestSI, caller);


        //Check result
        assertEquals(RequestState.STATE_Open, result.getState().getStateStr());
        assertEquals(bid, result.getSpotPrice());
        assertTrue(!result.isPersistent());
        
        //New spot price is equal largest bid + 0.1 (since there are 0 resources)
        assertEquals(bid + 0.1,  rm.getSpotPrice());
        
        SpotRequestInfo[] spotRequestByCaller = rm.getSpotRequestsByCaller(caller);
        assertEquals(1, spotRequestByCaller.length);
        assertEquals(result, spotRequestByCaller[0]);
        
        assertEquals(result, rm.getSpotRequest(result.getRequestID(), caller));
        
        //Cancel request
        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());
        
        //Check if request was really cancelled
        SpotRequestInfo request = rm.getSpotRequest(result.getRequestID(), caller);
        assertEquals(RequestState.STATE_Canceled, request.getState().getStateStr());           
    }

View Full Code Here

        final Double bid3 = previousPrice + 1;
        SpotCreateRequest req1 = this.populator().getBasicRequestSI("req1", 1, bid1, false);
        SpotCreateRequest req2 = this.populator().getBasicRequestSI("req1", 3, bid2, false);
        SpotCreateRequest req3 = this.populator().getBasicRequestSI("req1", 4, bid3, false);
        
        SpotRequestInfo result1 = rm.requestSpotInstances(req1, caller1);
        SpotRequestInfo result2 = rm.requestSpotInstances(req2, caller2);
        SpotRequestInfo result3 = rm.requestSpotInstances(req3, caller1);


        assertEquals(result1, rm.getSpotRequest(result1.getRequestID(), caller1));
        assertEquals(result2, rm.getSpotRequest(result2.getRequestID(), caller2));
        assertEquals(result3, rm.getSpotRequest(result3.getRequestID(), caller1));
        
        //New spot price is equal largest bid + 0.1 (since there are 0 resources)
        assertEquals(bid1 + 0.1,  rm.getSpotPrice());
        
        SpotRequestInfo[] spotRequestByCaller1 = rm.getSpotRequestsByCaller(caller1);
        assertEquals(2, spotRequestByCaller1.length);
        
        SpotRequestInfo[] spotRequestByCaller2 = rm.getSpotRequestsByCaller(caller2);
        assertEquals(1, spotRequestByCaller2.length);        
        
        //Cancel requests
        rm.cancelSpotInstanceRequests(new String[]{result1.getRequestID(), result3.getRequestID()}, caller1);
        SpotRequestInfo[] cancelledReqs = rm.cancelSpotInstanceRequests(new String[]{result2.getRequestID()}, caller2);
        
        //Check if requests were really cancelled
        assertEquals(RequestState.STATE_Canceled, cancelledReqs[0].getState().getStateStr());
        spotRequestByCaller1 = rm.getSpotRequestsByCaller(caller1);

View Full Code Here

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

View Full Code Here

        //Check if requests were cancelled
        assertEquals(RequestState.STATE_Canceled, rm.getSpotRequest(highReqId, caller3).getState().getStateStr());
        assertEquals(RequestState.STATE_Canceled, rm.getSpotRequest(lowReq2Id, caller1).getState().getStateStr());


        //Check if canceled request has allocated VMs
        SpotRequestInfo highReq1 = rm.getSpotRequest(highReqId, caller3);
        assertEquals(RequestState.STATE_Canceled, highReq1.getState().getStateStr());
        assertEquals(8, highReq1.getVMIds().length);


        //Check if persistent request is open
        SpotRequestInfo medReq2 = rm.getSpotRequest(medReq2Id, caller2);
        assertEquals(RequestState.STATE_Open, medReq2.getState().getStateStr());
        assertEquals(0, medReq2.getVMIds().length);


        //Check if non-persistent requests are closed
        assertEquals(RequestState.STATE_Closed, rm.getSpotRequest(lowReq1Id, caller1).getState().getStateStr());
        assertEquals(RequestState.STATE_Closed, rm.getSpotRequest(lowReq3Id, caller2).getState().getStateStr());
        assertEquals(RequestState.STATE_Closed, rm.getSpotRequest(medReq1Id, caller2).getState().getStateStr());


        //Check backfill request state
        backfillRequestsByCaller = rm.getBackfillRequestsByCaller(superuser);
        assertEquals(2, backfillRequestsByCaller.length);


        backfill1Result = rm.getBackfillRequest(backfill1Result.getRequestID(), superuser);
        assertEquals(0, backfill1Result.getVMIds().length);
        assertEquals(RequestState.STATE_Open, backfill1Result.getState().getStateStr());


        backfill2Result = rm.getBackfillRequest(backfill2Result.getRequestID(), superuser);
        assertEquals(0, backfill2Result.getVMIds().length);
        assertEquals(RequestState.STATE_Open, backfill2Result.getState().getStateStr());


        //Trash 5 VMs from highReq
        for (int i = 0; i < 5; i++) {
            rm.trash(highReq1.getVMIds()[i], Manager.INSTANCE, caller3);
        }


        // 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 = 1024MB)
        //
        // Current Requests_______________________________________________________________
        // |   Request  | reqVMs | allocVMs |       Bid        | Status    | Persistent |
        // | lowReq1    |   1    |    0     |  previousPrice+1 | CLOSED    |    false   |
        // | lowReq2    |   3    |    0     |  previousPrice+1 | CANCELLED |    true    |
        // | mediumReq1 |   3    |    0     |  previousPrice+2 | CLOSED    |    false   |
        // | lowReq3    |   1    |    0     |  previousPrice+1 | CLOSED    |    false   |
        // | mediumReq2 |   5    |    5     |  previousPrice+2 | ACTIVE    |    true    |
        // | highReq    |  10    |    3     |  previousPrice+3 | CANCELLED |    false   |
        // ---------------------------------------------------------------------------
        // Backfill Requests__________________________
        // |   Request   | reqVMs | allocVMs | Status |
        // |  backfill1  |   3    |    0     | OPEN   |
        // |  backfill2  |   5    |    0     | OPEN   |
        // --------------------------------------------
        // Requested SI VMs (alive requests): 8
        // Spot price: mediumBid (previousPrice+2)


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


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


        //Check if requests were cancelled
        assertEquals(RequestState.STATE_Canceled, rm.getSpotRequest(highReqId, caller3).getState().getStateStr());
        assertEquals(RequestState.STATE_Canceled, rm.getSpotRequest(lowReq2Id, caller1).getState().getStateStr());


        //Check if canceled request has allocated VMs
        highReq1 = rm.getSpotRequest(highReqId, caller3);
        assertEquals(RequestState.STATE_Canceled, highReq1.getState().getStateStr());
        assertEquals(3, highReq1.getVMIds().length);


        //Check if persistent request is active
        medReq2 = rm.getSpotRequest(medReq2Id, caller2);
        assertEquals(RequestState.STATE_Active, medReq2.getState().getStateStr());
        assertEquals(5, medReq2.getVMIds().length);


        //Check if non-persistent requests are closed
        assertEquals(RequestState.STATE_Closed, rm.getSpotRequest(lowReq1Id, caller1).getState().getStateStr());
        assertEquals(RequestState.STATE_Closed, rm.getSpotRequest(lowReq3Id, caller2).getState().getStateStr());
        assertEquals(RequestState.STATE_Closed, rm.getSpotRequest(medReq1Id, caller2).getState().getStateStr());


        //Check backfill request state
        backfillRequestsByCaller = rm.getBackfillRequestsByCaller(superuser);
        assertEquals(2, backfillRequestsByCaller.length);


        backfill1Result = rm.getBackfillRequest(backfill1Result.getRequestID(), superuser);
        assertEquals(0, backfill1Result.getVMIds().length);
        assertEquals(RequestState.STATE_Open, backfill1Result.getState().getStateStr());


        backfill2Result = rm.getBackfillRequest(backfill2Result.getRequestID(), superuser);
        assertEquals(0, backfill2Result.getVMIds().length);
        assertEquals(RequestState.STATE_Open, backfill2Result.getState().getStateStr());


        rm.trash(highReq1.getGroupID(), Manager.GROUP, caller3);


        // 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 = 1024MB)
        //
        // Current Requests_______________________________________________________________
        // |   Request  | reqVMs | allocVMs |       Bid        | Status    | Persistent |
        // | lowReq1    |   1    |    0     |  previousPrice+1 | CLOSED    |    false   |
        // | lowReq2    |   3    |    0     |  previousPrice+1 | CANCELLED |    true    |
        // | mediumReq1 |   3    |    0     |  previousPrice+2 | CLOSED    |    false   |
        // | lowReq3    |   1    |    0     |  previousPrice+1 | CLOSED    |    false   |
        // | mediumReq2 |   5    |    5     |  previousPrice+2 | ACTIVE    |    true    |
        // | highReq    |  10    |    0     |  previousPrice+3 | CANCELLED |    false   |
        // ---------------------------------------------------------------------------
        // Backfill Requests__________________________
        // |   Request   | reqVMs | allocVMs | Status |
        // |  backfill1  |   3    |    2     | ACTIVE |
        // |  backfill2  |   5    |    1     | ACTIVE |
        // --------------------------------------------
        // Requested SI VMs (alive requests): 5
        // Spot price: MINIMUM_PRICE


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


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


        //Check if requests were cancelled
        assertEquals(RequestState.STATE_Canceled, rm.getSpotRequest(highReqId, caller3).getState().getStateStr());
        assertEquals(RequestState.STATE_Canceled, rm.getSpotRequest(lowReq2Id, caller1).getState().getStateStr());


        //Check if persistent request is active
        medReq2 = rm.getSpotRequest(medReq2Id, caller2);
        assertEquals(RequestState.STATE_Active, medReq2.getState().getStateStr());
        assertEquals(5, medReq2.getVMIds().length);


        //Check if non-persistent requests are closed
        assertEquals(RequestState.STATE_Closed, rm.getSpotRequest(lowReq1Id, caller1).getState().getStateStr());
        assertEquals(RequestState.STATE_Closed, rm.getSpotRequest(lowReq3Id, caller2).getState().getStateStr());
        assertEquals(RequestState.STATE_Closed, rm.getSpotRequest(medReq1Id, caller2).getState().getStateStr());


        //Check backfill request state
        backfillRequestsByCaller = rm.getBackfillRequestsByCaller(superuser);
        assertEquals(2, backfillRequestsByCaller.length);


        backfill1Result = rm.getBackfillRequest(backfill1Result.getRequestID(), superuser);
        assertEquals(2, backfill1Result.getVMIds().length);
        assertEquals(RequestState.STATE_Active, backfill1Result.getState().getStateStr());


        backfill2Result = rm.getBackfillRequest(backfill2Result.getRequestID(), superuser);
        assertEquals(1, backfill2Result.getVMIds().length);
        assertEquals(RequestState.STATE_Active, backfill2Result.getState().getStateStr());


        rm.cancelBackfillRequests(new String[]{backfill1Result.getRequestID()}, superuser);
        rm.trash(backfill1Result.getGroupID(), Manager.GROUP, 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 = 1024MB)
        //
        // Current Requests_______________________________________________________________
        // |   Request  | reqVMs | allocVMs |       Bid        | Status    | Persistent |
        // | lowReq1    |   1    |    0     |  previousPrice+1 | CLOSED    |    false   |
        // | lowReq2    |   3    |    0     |  previousPrice+1 | CANCELLED |    true    |
        // | mediumReq1 |   3    |    0     |  previousPrice+2 | CLOSED    |    false   |
        // | lowReq3    |   1    |    0     |  previousPrice+1 | CLOSED    |    false   |
        // | mediumReq2 |   5    |    5     |  previousPrice+2 | ACTIVE    |    true    |
        // | highReq    |  10    |    0     |  previousPrice+3 | CANCELLED |    false   |
        // ---------------------------------------------------------------------------
        // Backfill Requests______________________________
        // |   Request   | reqVMs | allocVMs | Status    |
        // |  backfill1  |   3    |    0     | CANCELLED |
        // |  backfill2  |   5    |    3     | ACTIVE    |
        // -----------------------------------------------
        // Requested SI VMs (alive requests): 5
        // Spot price: MINIMUM_PRICE


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


        //Check backfill request state
        backfillRequestsByCaller = rm.getBackfillRequestsByCaller(superuser);
        assertEquals(2, backfillRequestsByCaller.length);


        backfill1Result = rm.getBackfillRequest(backfill1Result.getRequestID(), superuser);
        assertEquals(0, backfill1Result.getVMIds().length);
        assertEquals(RequestState.STATE_Canceled, backfill1Result.getState().getStateStr());


        backfill2Result = rm.getBackfillRequest(backfill2Result.getRequestID(), superuser);
        assertEquals(3, backfill2Result.getVMIds().length);
        assertEquals(RequestState.STATE_Active, backfill2Result.getState().getStateStr());


        rm.cancelSpotInstanceRequests(new String[]{medReq2Id}, caller2);
        rm.trash(medReq2.getGroupID(), Manager.GROUP, caller2);


        // 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 = 1024MB)
        //
        // Current Requests_______________________________________________________________
        // |   Request  | reqVMs | allocVMs |       Bid        | Status    | Persistent |
        // | lowReq1    |   1    |    0     |  previousPrice+1 | CLOSED    |    false   |
        // | lowReq2    |   3    |    0     |  previousPrice+1 | CANCELLED |    true    |
        // | mediumReq1 |   3    |    0     |  previousPrice+2 | CLOSED    |    false   |
        // | lowReq3    |   1    |    0     |  previousPrice+1 | CLOSED    |    false   |
        // | mediumReq2 |   5    |    0     |  previousPrice+2 | CANCELLED |    true    |
        // | highReq    |  10    |    0     |  previousPrice+3 | CANCELLED |    false   |
        // ---------------------------------------------------------------------------
        // Backfill Requests______________________________
        // |   Request   | reqVMs | allocVMs | Status    |
        // |  backfill1  |   3    |    0     | CANCELLED |
        // |  backfill2  |   5    |    5     | ACTIVE    |
        // -----------------------------------------------
        // Requested SI VMs (alive requests): 0
        // Spot price: MINIMUM_PRICE


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


        //Check if persistent request was cancelled
        medReq2 = rm.getSpotRequest(medReq2Id, caller2);
        assertEquals(RequestState.STATE_Canceled, medReq2.getState().getStateStr());
        assertEquals(0, medReq2.getVMIds().length);


        //Check backfill request state
        backfillRequestsByCaller = rm.getBackfillRequestsByCaller(superuser);
        assertEquals(2, backfillRequestsByCaller.length);

View Full Code Here


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


        //Check if all submitted requests are active and fulfilled
        SpotRequestInfo lowReq1SR = rm.getSpotRequest(lowReq1Id, siCaller);
        assertEquals(RequestState.STATE_Active, lowReq1SR.getState().getStateStr());
        assertEquals(3, lowReq1SR.getVMIds().length);


        SpotRequestInfo lowReq2SR = rm.getSpotRequest(lowReq2Id, siCaller);
        assertEquals(RequestState.STATE_Active, lowReq2SR.getState().getStateStr());
        assertEquals(2, lowReq2SR.getVMIds().length);


        SpotRequestInfo medReqSR = rm.getSpotRequest(medReqId, siCaller);
        assertEquals(RequestState.STATE_Active, medReqSR.getState().getStateStr());
        assertEquals(3, medReqSR.getVMIds().length);


        logger.debug("Submitting WS request: wsReq1 (2 VMs, 120MB RAM each)");


        CreateRequest wsReq1 = this.populator().getCreateRequest("wsReq1", 1000, 120, 2);
        CreateResult wsReq1Result = rm.create(wsReq1, wsCaller);


        Long mark = System.currentTimeMillis();


        // Spot Instances Snapshot
        //
        // Total memory: 1280MB
        // Used WS memory: 240MB
        // Reserved free memory (for ordinary WS requests): 256MB (minimum reserved capacity)
        // Available basic SI VMs: 6 (128MB x 6 = 768)
        //
        // Current Requests___________________________________________________________
        // |   Request  | reqVMs | allocVMs |       Bid        | Status | Persistent |
        // | lowReq1    |   3    |     2    | previousPrice+1  | ACTIVE |    false   |
        // | lowReq2    |   2    |     1    | previousPrice+1  | ACTIVE |    true    |
        // | mediumReq1 |   3    |     3    | previousPrice+3  | ACTIVE |    false   |
        // ---------------------------------------------------------------------------
        // Requested SI VMs (alive requests): 7 (1 from lowReq1 was closed)
        // Spot price: lowBid (previousPrice+1)


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


        //Check available SI VMs
        assertEquals(6,  getAvailableResources());


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


        lowReq1SR = rm.getSpotRequest(lowReq1Id, siCaller);
        assertEquals(RequestState.STATE_Active, lowReq1SR.getState().getStateStr());
        assertEquals(2, lowReq1SR.getVMIds().length);


        lowReq2SR = rm.getSpotRequest(lowReq2Id, siCaller);
        assertEquals(RequestState.STATE_Active, lowReq2SR.getState().getStateStr());
        assertEquals(1, lowReq2SR.getVMIds().length);


        medReqSR = rm.getSpotRequest(medReqId, siCaller);
        assertEquals(RequestState.STATE_Active, medReqSR.getState().getStateStr());
        assertEquals(3, medReqSR.getVMIds().length);


        logger.debug("Submitting WS request: wsReq2 (2 VMs, 110MB RAM each)");


        CreateRequest wsReq2 = this.populator().getCreateRequest("wsReq2", TASK_TIME, 110, 2);
        rm.create(wsReq2, wsCaller);


        // Spot Instances Snapshot
        //
        // Total memory: 1280MB
        // Used WS memory: 460MB
        // Reserved free memory (for ordinary WS requests): 256MB (minimum reserved capacity)
        // Available basic SI VMs: 4 (128MB x 4 = 512MB)
        //
        // Current Requests___________________________________________________________
        // |   Request  | reqVMs | allocVMs |       Bid        | Status | Persistent |
        // | lowReq1    |   3    |     1    | previousPrice+1  | ACTIVE |    false   |
        // | lowReq2    |   2    |     0    | previousPrice+1  | OPEN   |    true    |
        // | mediumReq1 |   3    |     3    | previousPrice+3  | ACTIVE |    false   |
        // ---------------------------------------------------------------------------
        // Requested SI VMs (alive requests): 6 (2 from lowReq1 were closed)
        // Spot price: lowBid (previousPrice+1)


        logger.debug("Waiting 4 seconds for SI VMs to be pre-empted.");
        Thread.sleep(4000);


        //Check available SI VMs
        assertEquals(4,  getAvailableResources());


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


        lowReq1SR = rm.getSpotRequest(lowReq1Id, siCaller);
        assertEquals(RequestState.STATE_Active, lowReq1SR.getState().getStateStr());
        assertEquals(1, lowReq1SR.getVMIds().length);


        lowReq2SR = rm.getSpotRequest(lowReq2Id, siCaller);
        assertEquals(RequestState.STATE_Open, lowReq2SR.getState().getStateStr());
        assertEquals(0, lowReq2SR.getVMIds().length);


        medReqSR = rm.getSpotRequest(medReqId, siCaller);
        assertEquals(RequestState.STATE_Active, medReqSR.getState().getStateStr());
        assertEquals(3, medReqSR.getVMIds().length);


        //Wait for wsReq2 to finish


        long elapsed = System.currentTimeMillis()-mark;
        long sleepTime = (TASK_TIME*1000 - elapsed) + BUFFER;
        if(sleepTime > 0){
            logger.debug("Waiting " + sleepTime + " milliseconds for wsReq2 to finish.");
            Thread.sleep(sleepTime);
        }


        // Spot Instances Snapshot
        //
        // Total memory: 1280MB
        // Used WS memory: 240MB
        // Reserved free memory (for ordinary WS requests): 256MB (minimum reserved capacity)
        // Available basic SI VMs: 6 (128MB x 6 = 768MB)
        //
        // Current Requests___________________________________________________________
        // |   Request  | reqVMs | allocVMs |       Bid        | Status | Persistent |
        // | lowReq1    |   3    |     1    | previousPrice+1  | ACTIVE |    false   |**
        // | lowReq2    |   2    |     2    | previousPrice+1  | ACTIVE |    true    |
        // | mediumReq1 |   3    |     3    | previousPrice+3  | ACTIVE |    false   |
        // ---------------------------------------------------------------------------
        // Requested SI VMs (alive requests): 6 (2 from lowReq1 were closed)
        // Spot price: lowBid (previousPrice+1)
        //
        // ** lowReq1 is not persistent, so no more VMs are allocated for this
        //    request (since 2 VMs were already finished (pre-empted))


        //Check available SI VMs
        assertEquals(6,  getAvailableResources());


        //Spot price is equal to lower bid
        assertEquals(lowBid,  rm.getSpotPrice());


        lowReq1SR = rm.getSpotRequest(lowReq1Id, siCaller);
        assertEquals(RequestState.STATE_Active, lowReq1SR.getState().getStateStr());
        assertEquals(1, lowReq1SR.getVMIds().length);


        lowReq2SR = rm.getSpotRequest(lowReq2Id, siCaller);
        assertEquals(RequestState.STATE_Active, lowReq2SR.getState().getStateStr());
        assertEquals(2, lowReq2SR.getVMIds().length);


        medReqSR = rm.getSpotRequest(medReqId, siCaller);
        assertEquals(RequestState.STATE_Active, medReqSR.getState().getStateStr());
        assertEquals(3, medReqSR.getVMIds().length);


        logger.debug("Submitting WS request: wsReq3 (2 VMs, 256MB RAM each)");


        CreateRequest wsReq3 = this.populator().getCreateRequest("wsReq3", 500, 256, 2);
        CreateResult wsReq3Result = rm.create(wsReq3, wsCaller);


        // Spot Instances Snapshot
        //
        // Total memory: 1280MB
        // Used WS memory: 752MB
        // Reserved capacity (for ordinary WS requests): 322MB (to ensure 70% max utilization)
        // Available basic SI VMs: 1 (128MB)
        //
        // Current Requests___________________________________________________________
        // |   Request  | reqVMs | allocVMs |       Bid        | Status | Persistent |
        // | lowReq1    |   3    |     0    | previousPrice+1  | CLOSED |    false   |
        // | lowReq2    |   2    |     0    | previousPrice+1  | OPEN   |    true    |
        // | mediumReq1 |   3    |     1    | previousPrice+3  | ACTIVE |    false   |
        // ---------------------------------------------------------------------------
        // Requested SI VMs (alive requests): 3
        // Spot price: lowBid (previousPrice+1)


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


        //Check available SI VMs
        assertEquals(1,  getAvailableResources());


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


        lowReq1SR = rm.getSpotRequest(lowReq1Id, siCaller);
        assertEquals(RequestState.STATE_Closed, lowReq1SR.getState().getStateStr());
        assertEquals(0, lowReq1SR.getVMIds().length);


        lowReq2SR = rm.getSpotRequest(lowReq2Id, siCaller);
        assertEquals(RequestState.STATE_Open, lowReq2SR.getState().getStateStr());
        assertEquals(0, lowReq2SR.getVMIds().length);


        medReqSR = rm.getSpotRequest(medReqId, siCaller);
        assertEquals(RequestState.STATE_Active, medReqSR.getState().getStateStr());
        assertEquals(1, medReqSR.getVMIds().length);


        logger.debug("Submitting WS request: wsReq4 (1 VM with 256MB RAM)");


        CreateRequest wsReq4 = this.populator().getCreateRequest("wsReq4", 500, 256, 1);
        CreateResult wsReq4Result = rm.create(wsReq4, wsCaller);


        // Spot Instances Snapshot
        //
        // Total memory: 1280MB
        // Used WS memory: 1008MB
        // Reserved capacity (for ordinary WS requests): 432MB (to ensure 70% max utilization)
        // Available basic SI VMs: 0
        //
        // Current Requests___________________________________________________________
        // |   Request  | reqVMs | allocVMs |       Bid        | Status | Persistent |
        // | lowReq1    |   3    |     0    | previousPrice+1  | CLOSED |    false   |
        // | lowReq2    |   2    |     0    | previousPrice+1  | OPEN   |    true    |
        // | mediumReq1 |   3    |     0    | previousPrice+3  | CLOSED |    false   |
        // ---------------------------------------------------------------------------
        // Requested SI VMs (alive requests): 2
        // Spot price: lowBid + 1


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


        //Check available SI VMs
        assertEquals(0,  getAvailableResources());


        //New spot price is equal to lower bid + 0.1 (since lower bid is the highest ALIVE bid)
        assertEquals(lowBid+0.1,  rm.getSpotPrice());


        lowReq1SR = rm.getSpotRequest(lowReq1Id, siCaller);
        assertEquals(RequestState.STATE_Closed, lowReq1SR.getState().getStateStr());
        assertEquals(0, lowReq1SR.getVMIds().length);


        lowReq2SR = rm.getSpotRequest(lowReq2Id, siCaller);
        assertEquals(RequestState.STATE_Open, lowReq2SR.getState().getStateStr());
        assertEquals(0, lowReq2SR.getVMIds().length);


        medReqSR = rm.getSpotRequest(medReqId, siCaller);
        assertEquals(RequestState.STATE_Closed, medReqSR.getState().getStateStr());
        assertEquals(0, medReqSR.getVMIds().length);


        logger.debug("Destroying wsReq3 VMs: 2 VMs, 256MB RAM each");


        rm.trash(wsReq3Result.getGroupID(), Manager.GROUP, wsCaller);


        // Spot Instances Snapshot
        //
        // Total memory: 1280MB
        // Used WS memory: 496MB
        // Reserved capacity (for ordinary WS requests): 256MB (minimum reserved capacity)
        // Available basic SI VMs: 4 (128MB x 4 = 512MB)
        //
        // Current Requests___________________________________________________________
        // |   Request  | reqVMs | allocVMs |       Bid        | Status | Persistent |
        // | lowReq1    |   3    |     0    | previousPrice+1  | CLOSED |    false   |
        // | lowReq2    |   2    |     2    | previousPrice+1  | ACTIVE |    true    |
        // | mediumReq1 |   3    |     0    | previousPrice+3  | CLOSED |    false   |
        // ---------------------------------------------------------------------------
        // Requested SI VMs (alive requests): 2
        // Spot price: MINIMUM_PRICE (since requestedVMs < availableVMs)


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


        //Check available SI VMs
        assertEquals(4,  getAvailableResources());


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


        lowReq1SR = rm.getSpotRequest(lowReq1Id, siCaller);
        assertEquals(RequestState.STATE_Closed, lowReq1SR.getState().getStateStr());
        assertEquals(0, lowReq1SR.getVMIds().length);


        lowReq2SR = rm.getSpotRequest(lowReq2Id, siCaller);
        assertEquals(RequestState.STATE_Active, lowReq2SR.getState().getStateStr());
        assertEquals(2, lowReq2SR.getVMIds().length);


        medReqSR = rm.getSpotRequest(medReqId, siCaller);
        assertEquals(RequestState.STATE_Closed, medReqSR.getState().getStateStr());
        assertEquals(0, medReqSR.getVMIds().length);


        logger.debug("Submitting basic SI request request: mediumReq2 (1 VM)");


        SpotCreateRequest mediumReq2 = this.populator().getBasicRequestSI("mediumReq2", 1, mediumBid, false);
        String medReq2Id = rm.requestSpotInstances(mediumReq2, siCaller).getRequestID();


        // Spot Instances Snapshot
        //
        // Total memory: 1280MB
        // Used WS memory: 496MB
        // Reserved capacity (for ordinary WS requests): 256MB (minimum reserved capacity)
        // Available basic SI VMs: 4 (128MB x 4 = 512MB)
        //
        // Current Requests___________________________________________________________
        // |   Request  | reqVMs | allocVMs |       Bid        | Status | Persistent |
        // | lowReq1    |   3    |     0    | previousPrice+1  | CLOSED |    false   |
        // | lowReq2    |   2    |     2    | previousPrice+1  | ACTIVE |    true    |
        // | mediumReq1 |   3    |     0    | previousPrice+3  | CLOSED |    false   |
        // | mediumReq2 |   1    |     1    | previousPrice+3  | ACTIVE |    false   |
        // ---------------------------------------------------------------------------
        // Requested SI VMs (alive requests): 3
        // Spot price: MINIMUM_PRICE (since requestedVMs < availableVMs)


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


        //Check available SI VMs
        assertEquals(4,  getAvailableResources());


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


        lowReq1SR = rm.getSpotRequest(lowReq1Id, siCaller);
        assertEquals(RequestState.STATE_Closed, lowReq1SR.getState().getStateStr());
        assertEquals(0, lowReq1SR.getVMIds().length);


        lowReq2SR = rm.getSpotRequest(lowReq2Id, siCaller);
        assertEquals(RequestState.STATE_Active, lowReq2SR.getState().getStateStr());
        assertEquals(2, lowReq2SR.getVMIds().length);


        medReqSR = rm.getSpotRequest(medReqId, siCaller);
        assertEquals(RequestState.STATE_Closed, medReqSR.getState().getStateStr());
        assertEquals(0, medReqSR.getVMIds().length);


        SpotRequestInfo medReq2SR = rm.getSpotRequest(medReq2Id, siCaller);
        assertEquals(RequestState.STATE_Active, medReq2SR.getState().getStateStr());
        assertEquals(1, medReq2SR.getVMIds().length);


        logger.debug("Shutting down VM from mediumReq2");


        rm.trash(medReq2SR.getVMIds()[0], Manager.INSTANCE, siCaller);


        // Spot Instances Snapshot
        //
        // Total memory: 1280MB
        // Used WS memory: 496MB
        // Reserved capacity (for ordinary WS requests): 256MB (minimum reserved capacity)
        // Available basic SI VMs: 4 (128MB x 4 = 512MB)
        //
        // Current Requests___________________________________________________________
        // |   Request  | reqVMs | allocVMs |       Bid        | Status | Persistent |
        // | lowReq1    |   3    |     0    | previousPrice+1  | CLOSED |    false   |
        // | lowReq2    |   2    |     2    | previousPrice+1  | ACTIVE |    true    |
        // | mediumReq1 |   3    |     0    | previousPrice+3  | CLOSED |    false   |
        // | mediumReq2 |   1    |     0    | previousPrice+3  | CLOSED |    false   |
        // ---------------------------------------------------------------------------
        // Requested SI VMs (alive requests): 2
        // Spot price: MINIMUM_PRICE (since requestedVMs < availableVMs)


        logger.debug("Waiting 10 seconds for VM to shutdown.");
        Thread.sleep(10000);


        //Check available SI VMs
        assertEquals(4,  getAvailableResources());


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


        lowReq1SR = rm.getSpotRequest(lowReq1Id, siCaller);
        assertEquals(RequestState.STATE_Closed, lowReq1SR.getState().getStateStr());
        assertEquals(0, lowReq1SR.getVMIds().length);


        lowReq2SR = rm.getSpotRequest(lowReq2Id, siCaller);
        assertEquals(RequestState.STATE_Active, lowReq2SR.getState().getStateStr());
        assertEquals(2, lowReq2SR.getVMIds().length);


        medReqSR = rm.getSpotRequest(medReqId, siCaller);
        assertEquals(RequestState.STATE_Closed, medReqSR.getState().getStateStr());
        assertEquals(0, medReqSR.getVMIds().length);


        medReq2SR = rm.getSpotRequest(medReq2Id, siCaller);
        assertEquals(RequestState.STATE_Closed, medReq2SR.getState().getStateStr());
        assertEquals(0, medReq2SR.getVMIds().length);


        logger.debug("Submitting basic SI request request: mediumReq2 (1 VM)");


        Double highBid = previousPrice + 4;
        SpotCreateRequest highReq1 = this.populator().getBasicRequestSI("highBid1", 4, highBid, false);
        String highReq1Id = rm.requestSpotInstances(highReq1, siCaller).getRequestID();


        // Spot Instances Snapshot
        //
        // Total memory: 1280MB
        // Used WS memory: 496MB
        // Reserved capacity (for ordinary WS requests): 256MB (minimum reserved capacity)
        // Available basic SI VMs: 4 (128MB x 4 = 512MB)
        //
        // Current Requests___________________________________________________________
        // |   Request  | reqVMs | allocVMs |       Bid        | Status | Persistent |
        // | lowReq1    |   3    |     0    | previousPrice+1  | CLOSED |    false   |
        // | lowReq2    |   2    |     0    | previousPrice+1  | OPEN   |    true    |
        // | mediumReq1 |   3    |     0    | previousPrice+3  | CLOSED |    false   |
        // | mediumReq2 |   1    |     0    | previousPrice+3  | CLOSED |    false   |
        // | highReq1   |   4    |     4    | previousPrice+4  | ACTIVE |    false   |
        // ---------------------------------------------------------------------------
        // Requested SI VMs (alive requests): 4
        // Spot price: MINIMUM_PRICE (since requestedVMs < availableVMs)


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


        //Check available SI VMs
        assertEquals(4,  getAvailableResources());


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


        lowReq1SR = rm.getSpotRequest(lowReq1Id, siCaller);
        assertEquals(RequestState.STATE_Closed, lowReq1SR.getState().getStateStr());
        assertEquals(0, lowReq1SR.getVMIds().length);


        lowReq2SR = rm.getSpotRequest(lowReq2Id, siCaller);
        assertEquals(RequestState.STATE_Open, lowReq2SR.getState().getStateStr());
        assertEquals(0, lowReq2SR.getVMIds().length);


        medReqSR = rm.getSpotRequest(medReqId, siCaller);
        assertEquals(RequestState.STATE_Closed, medReqSR.getState().getStateStr());
        assertEquals(0, medReqSR.getVMIds().length);


        medReq2SR = rm.getSpotRequest(medReq2Id, siCaller);
        assertEquals(RequestState.STATE_Closed, medReq2SR.getState().getStateStr());
        assertEquals(0, medReq2SR.getVMIds().length);


        SpotRequestInfo highReqSR = rm.getSpotRequest(highReq1Id, siCaller);
        assertEquals(RequestState.STATE_Active, highReqSR.getState().getStateStr());
        assertEquals(4, highReqSR.getVMIds().length);


        logger.debug("Trashing machines from request: highReq1");


        rm.trash(highReqSR.getGroupID(), Manager.GROUP, siCaller);


        // Spot Instances Snapshot
        //
        // Total memory: 1280MB
        // Used WS memory: 496MB
        // Reserved capacity (for ordinary WS requests): 256MB (minimum reserved capacity)
        // Available basic SI VMs: 4 (128MB x 4 = 512MB)
        //
        // Current Requests______________________________________________________________
        // |   Request  | reqVMs | allocVMs |       Bid        | Status    | Persistent |
        // | lowReq1    |   3    |     0    | previousPrice+1  | CLOSED    |    false   |
        // | lowReq2    |   2    |     2    | previousPrice+1  | ACTIVE    |    true    |
        // | mediumReq1 |   3    |     0    | previousPrice+3  | CLOSED    |    false   |
        // | mediumReq2 |   1    |     0    | previousPrice+3  | CLOSED    |    false   |
        // | highReq1   |   4    |     0    | previousPrice+4  | CLOSED    |    false   |
        // ------------------------------------------------------------------------------
        // Requested SI VMs (alive requests): 2
        // Spot price: MINIMUM_PRICE (since requestedVMs < availableVMs)


        logger.debug("Waiting 10 seconds for VMs to shutdown.");
        Thread.sleep(10000);


        //Check available SI VMs
        assertEquals(4,  getAvailableResources());


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


        lowReq1SR = rm.getSpotRequest(lowReq1Id, siCaller);
        assertEquals(RequestState.STATE_Closed, lowReq1SR.getState().getStateStr());
        assertEquals(0, lowReq1SR.getVMIds().length);


        lowReq2SR = rm.getSpotRequest(lowReq2Id, siCaller);
        assertEquals(RequestState.STATE_Active, lowReq2SR.getState().getStateStr());
        assertEquals(2, lowReq2SR.getVMIds().length);


        medReqSR = rm.getSpotRequest(medReqId, siCaller);
        assertEquals(RequestState.STATE_Closed, medReqSR.getState().getStateStr());
        assertEquals(0, medReqSR.getVMIds().length);


        medReq2SR = rm.getSpotRequest(medReq2Id, siCaller);
        assertEquals(RequestState.STATE_Closed, medReq2SR.getState().getStateStr());
        assertEquals(0, medReq2SR.getVMIds().length);


        highReqSR = rm.getSpotRequest(highReq1Id, siCaller);
        assertEquals(RequestState.STATE_Closed, highReqSR.getState().getStateStr());
        assertEquals(0, highReqSR.getVMIds().length);


        logger.debug("Destroying remaining WS VMs.");


        rm.trash(wsReq1Result.getGroupID(), Manager.GROUP, wsCaller);
        rm.trash(wsReq4Result.getVMs()[0].getID(), Manager.INSTANCE, wsCaller);

View Full Code Here


    public RequestSpotInstancesResponseType requestSpotInstances(
            RequestSpotInstancesType req, Caller caller, Manager manager)
            throws RemoteException {
        
        final SpotRequestInfo result;
        try {
            SpotCreateRequest creq =
                    this.translateReqSpotInstances(req, caller);
            AddCustomizations.addAll((_CreateRequest)creq,
                                     this.repr, this.mdServer);

View Full Code Here

        
        if(spotRequests != null){
            CancelSpotInstanceRequestsResponseSetItemType[] csirrst = new CancelSpotInstanceRequestsResponseSetItemType[spotRequests.length];
            
            for (int i = 0; i < spotRequests.length; i++) {
                SpotRequestInfo info = spotRequests[i];
                
                CancelSpotInstanceRequestsResponseSetItemType item = new CancelSpotInstanceRequestsResponseSetItemType();
                item.setSpotInstanceRequestId(info.getRequestID());
                item.setState(info.getState().getStateStr());
                csirrst[i] = item;
            }
            
            CancelSpotInstanceRequestsResponseSetType sirst = new CancelSpotInstanceRequestsResponseSetType();
            sirst.setItem(csirrst);

View Full Code Here

TOP

Related Classes of org.nimbustools.api.repr.SpotRequestInfo

org.globus.workspace.testing.suites.spotinstances.NoResourcesSISuite

org.globus.workspace.testing.suites.spotinstances.SingleResourcePoolSISuite

org.nimbustools.messaging.gt4_0_elastic.v2008_05_05.rm.defaults.DefaultCancelSI

org.nimbustools.messaging.gt4_0_elastic.v2008_05_05.rm.defaults.DefaultRequestSI

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.