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
    public void leaseOnePublicOnePrivate() throws Exception {
        logger.debug("leaseOnePublicOnePrivate");
        final Manager rm = this.locator.getManager();


        final Caller caller = this.populator().getCaller();


        /* One */
        final CreateRequest req =
                this.populator().getCreateRequestCustomNetwork(
                        "suite:issue37:leaseOnePublicOnePrivate",
                        "public");
        final CreateResult result = rm.create(req, 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));


        final NIC[] nics = vms[0].getNics();
        assertEquals(1, nics.length);
        assertEquals("public", nics[0].getNetworkName());


        /* Two */
        final CreateRequest req2 =
                this.populator().getCreateRequestCustomNetwork(
                        "suite:issue37:leaseOnePublicOnePrivate",
                        "private");
        final CreateResult result2 = rm.create(req2, caller);


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


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


        final NIC[] nics2 = vms2[0].getNics();
        assertEquals(1, nics2.length);
        assertEquals("private", nics2[0].getNetworkName());


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

View Full Code Here

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


        final Caller caller = this.populator().getCaller();


        /* One */
        final CreateRequest req =
                this.populator().getCreateRequestCustomNetwork(
                        "suite:issue37:leaseTwoPrivate",
                        "private");
        final CreateResult result = rm.create(req, 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));


        final NIC[] nics = vms[0].getNics();
        assertEquals(1, nics.length);
        assertEquals("private", nics[0].getNetworkName());


        /* It should not be possible to lease two VMs that want private networks,
           there is only one VMM with private ability (and RAM is being filled). */
        final CreateRequest req2 =
                this.populator().getCreateRequestCustomNetwork(
                        "suite:issue37:leaseOnePublicOnePrivate",
                        "private");


        boolean rrdException = false; 
        try {
            final CreateResult result2 = rm.create(req2, caller);
        } catch (ResourceRequestDeniedException e) {
            rrdException = true;
        }
        assertTrue(rrdException);


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

View Full Code Here

    public void mixedSIandWSrequests() throws Exception {
        logger.debug("mixedSIandWSrequests");


        //Objects and requests setup


        Manager rm = this.locator.getManager();


        Caller siCaller = this.populator().getCaller();
        Caller wsCaller = this.populator().getCaller();


        Double previousPrice = rm.getSpotPrice();


        final Double lowBid = previousPrice + 1;
        final Double mediumBid = previousPrice + 3;


        SpotCreateRequest lowReq1 = this.populator().getBasicRequestSI("lowReq2", 3, lowBid, false);
        SpotCreateRequest lowReq2 = this.populator().getBasicRequestSI("lowReq3", 2, lowBid, true);
        SpotCreateRequest mediumReq = this.populator().getBasicRequestSI("mediumReq1", 3, mediumBid, false);


        logger.debug("Submitting SI requests: lowReq1, lowReq2, mediumReq1");


        //Submit 3 SI Requests
        String lowReq1Id = rm.requestSpotInstances(lowReq1, siCaller).getRequestID();
        String lowReq2Id = rm.requestSpotInstances(lowReq2, siCaller).getRequestID();
        String medReqId = rm.requestSpotInstances(mediumReq, siCaller).getRequestID();


        // Spot Instances Snapshot
        //
        // Total memory: 1280MB
        // Used WS memory: 0MB
        // 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    |   3    |     3    | previousPrice+1  | ACTIVE |    false   |
        // | lowReq2    |   2    |     2    | previousPrice+1  | ACTIVE |    true    |
        // | mediumReq1 |   3    |     3    | previousPrice+3  | ACTIVE |    false   |
        // ---------------------------------------------------------------------------
        // Requested SI VMs (alive requests): 8
        // Spot price: lowBid (previousPrice+1)


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


        //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 void multipleSIRequestsOnly() throws Exception {
        logger.debug("multipleRequestsSIOnly");


        //Objects and requests setup


        Manager rm = this.locator.getManager();


        Caller caller1 = this.populator().getCaller();
        Caller caller2 = this.populator().getCaller();
        Caller caller3 = this.populator().getCaller();
        Caller superuser = this.populator().getSuperuserCaller();


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


        AsyncCreateRequest backfill1 = this.populator().getBackfillRequest("backfill1", 3);
        RequestInfo backfill1Result = rm.addBackfillRequest(backfill1, superuser);
        AsyncCreateRequest backfill2 = this.populator().getBackfillRequest("backfill2", 5);
        RequestInfo backfill2Result = rm.addBackfillRequest(backfill2, 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 |
        // |  backfill1  |   3    |    3     | ACTIVE |
        // |  backfill2  |   5    |    5     | 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(caller1);
        assertEquals(0, spotRequestByCaller.length);
        spotRequestByCaller = rm.getSpotRequestsByCaller(caller2);
        assertEquals(0, spotRequestByCaller.length);
        spotRequestByCaller = rm.getSpotRequestsByCaller(caller3);
        assertEquals(0, spotRequestByCaller.length);


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


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


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


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


        Double previousPrice = rm.getSpotPrice();


        final Double lowBid = previousPrice + 1;
        final Double mediumBid = previousPrice + 2;
        final Double highBid = previousPrice + 3;


        SpotCreateRequest lowReq1 = this.populator().getBasicRequestSI("lowReq1", 1, lowBid, false);
        SpotCreateRequest lowReq2 = this.populator().getBasicRequestSI("lowReq2", 3, lowBid, true);
        SpotCreateRequest lowReq3 = this.populator().getBasicRequestSI("lowReq3", 1, lowBid, false);
        SpotCreateRequest mediumReq1 = this.populator().getBasicRequestSI("mediumReq1", 3, mediumBid, false);
        SpotCreateRequest mediumReq2 = this.populator().getBasicRequestSI("mediumReq2", 5, mediumBid, true);
        SpotCreateRequest highReq = this.populator().getBasicRequestSI("highReq", 10, highBid, false);


        logger.debug("Submitting SI requests: lowReq1, lowReq2, mediumReq1");


        //Submit 3 SI Requests
        String lowReq1Id = rm.requestSpotInstances(lowReq1, caller1).getRequestID();
        String lowReq2Id = rm.requestSpotInstances(lowReq2, caller1).getRequestID();
        String medReq1Id = rm.requestSpotInstances(mediumReq1, caller2).getRequestID();


        // 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    |    1     |  previousPrice+1 | ACTIVE |    false   |
        // | lowReq2    |   3    |    3     |  previousPrice+1 | ACTIVE |    true    |
        // | mediumReq1 |   3    |    3     |  previousPrice+2 | ACTIVE |    false   |
        // ---------------------------------------------------------------------------
        // Backfill Requests__________________________
        // |   Request   | reqVMs | allocVMs | Status |
        // |  backfill1  |   3    |    1     | ACTIVE |
        // |  backfill2  |   5    |    0     | OPEN   |
        // --------------------------------------------
        // Requested SI VMs (alive requests): 7
        // Spot price: MINIMUM_PRICE (since requestedVMs < availableVMs)


        Calendar ts2 = Calendar.getInstance();


        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 all submitted requests are active
        SpotRequestInfo[] caller1Reqs = rm.getSpotRequestsByCaller(caller1);
        for (SpotRequestInfo caller1Req : caller1Reqs) {
            assertEquals(RequestState.STATE_Active, caller1Req.getState().getStateStr());
        }
        SpotRequestInfo[] caller2Reqs = rm.getSpotRequestsByCaller(caller2);
        assertEquals(RequestState.STATE_Active, caller2Reqs[0].getState().getStateStr());


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


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


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


        logger.debug("Submitting SI request: lowReq3");


        //Submit another SI Request
        String lowReq3Id = rm.requestSpotInstances(lowReq3, caller2).getRequestID();


        // 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    |    1     |  previousPrice+1 | ACTIVE |    false   |
        // | lowReq2    |   3    |    3     |  previousPrice+1 | ACTIVE |    true    |
        // | mediumReq1 |   3    |    3     |  previousPrice+2 | ACTIVE |    false   |
        // | lowReq3    |   1    |    1     |  previousPrice+1 | ACTIVE |    false   |
        // ---------------------------------------------------------------------------
        // Backfill Requests__________________________
        // |   Request   | reqVMs | allocVMs | Status |
        // |  backfill1  |   3    |    0     | OPEN   |
        // |  backfill2  |   5    |    0     | OPEN   |
        // --------------------------------------------
        // Requested SI VMs (alive requests): 8
        // Spot price: lowBid (previousPrice+1)


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


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


        //Check if submitted request is active
        assertEquals(RequestState.STATE_Active, rm.getSpotRequest(lowReq3Id, caller2).getState().getStateStr());


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


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


        //Submit another medium-bid SI Request
        String medReq2Id = rm.requestSpotInstances(mediumReq2, caller2).getRequestID();


        // 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 | OPEN   |    true    |
        // | mediumReq1 |   3    |    3     |  previousPrice+2 | ACTIVE |    false   |
        // | lowReq3    |   1    |    0     |  previousPrice+1 | CLOSED |    false   |
        // | mediumReq2 |   5    |    5     |  previousPrice+2 | ACTIVE |    true    |
        // ---------------------------------------------------------------------------
        // Backfill Requests__________________________
        // |   Request   | reqVMs | allocVMs | Status |
        // |  backfill1  |   3    |    0     | OPEN   |
        // |  backfill2  |   5    |    0     | OPEN   |
        // --------------------------------------------
        // Requested SI VMs (alive requests): 11
        // Spot price: mediumBid (previousPrice+2)


        Calendar ts4 = Calendar.getInstance();


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


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


        //Check if submitted request is active
        assertEquals(RequestState.STATE_Active, rm.getSpotRequest(medReq2Id, caller2).getState().getStateStr());


        //Check if previous medium-bid request is still active
        assertEquals(RequestState.STATE_Active, rm.getSpotRequest(medReq1Id, caller2).getState().getStateStr());


        //Check if persistent lower-bid requests are open
        assertEquals(RequestState.STATE_Open, rm.getSpotRequest(lowReq2Id, caller1).getState().getStateStr());


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


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


        logger.debug("Submitting SI request: highReq");


        //Submit a higher-bid SI Request
        String highReqId = rm.requestSpotInstances(highReq, caller3).getRequestID();


        // 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 | OPEN   |    true    |
        // | mediumReq1 |   3    |    0     |  previousPrice+2 | CLOSED |    false   |
        // | lowReq3    |   1    |    0     |  previousPrice+1 | CLOSED |    false   |
        // | mediumReq2 |   5    |    0     |  previousPrice+2 | OPEN   |    true    |
        // | highReq    |  10    |    8     |  previousPrice+3 | ACTIVE |    false   |
        // ---------------------------------------------------------------------------
        // Backfill Requests__________________________
        // |   Request   | reqVMs | allocVMs | Status |
        // |  backfill1  |   3    |    0     | OPEN   |
        // |  backfill2  |   5    |    0     | OPEN   |
        // --------------------------------------------
        // Requested SI VMs (alive requests): 18
        // Spot price: highBid (previousPrice+3)


        Calendar ts5 = Calendar.getInstance();


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


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


        //Check if submitted request is active
        assertEquals(RequestState.STATE_Active, rm.getSpotRequest(highReqId, caller3).getState().getStateStr());


        //Check if persistent requests are open
        assertEquals(RequestState.STATE_Open, rm.getSpotRequest(lowReq2Id, caller1).getState().getStateStr());
        assertEquals(RequestState.STATE_Open, rm.getSpotRequest(medReq2Id, caller2).getState().getStateStr());


        //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);
        assertEquals(0, backfillRequestsByCaller[0].getVMIds().length);
        assertEquals(RequestState.STATE_Open, backfillRequestsByCaller[0].getState().getStateStr());
        assertEquals(0, backfillRequestsByCaller[1].getVMIds().length);
        assertEquals(RequestState.STATE_Open, backfillRequestsByCaller[1].getState().getStateStr());


        rm.cancelSpotInstanceRequests(new String[]{lowReq2Id}, caller1);
        rm.cancelSpotInstanceRequests(new String[]{highReqId}, 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    |    0     |  previousPrice+2 | OPEN      |    true    |
        // | highReq    |  10    |    8     |  previousPrice+3 | CANCELLED |    false   |
        // ---------------------------------------------------------------------------
        // Backfill Requests__________________________
        // |   Request   | reqVMs | allocVMs | Status |
        // |  backfill1  |   3    |    0     | OPEN   |
        // |  backfill2  |   5    |    0     | OPEN   |
        // --------------------------------------------
        // Requested SI VMs (alive requests): 15
        // Spot price: highBid (previousPrice+3)


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


        //New spot price is equal to minimum price
        assertEquals(highBid,  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
        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);


        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(5, backfill2Result.getVMIds().length);
        assertEquals(RequestState.STATE_Active, backfill2Result.getState().getStateStr());


        //Expected prices from full history


        Double[] prices = new Double[]{MINIMUM_PRICE, lowBid, mediumBid, highBid, mediumBid, 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());
        }


        //Expected prices before ts2


        prices = new Double[]{MINIMUM_PRICE};


        //Check spot price history
        history = rm.getSpotPriceHistory(null, ts2);


        assertEquals(prices.length, history.length);


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


        //Expected prices from ts2 to ts4


        prices = new Double[]{lowBid, mediumBid};


        //Check spot price history
        history = rm.getSpotPriceHistory(ts2, ts4);


        assertEquals(prices.length, history.length);


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


        //Expected prices from ts4 to ts5


        prices = new Double[]{highBid};


        //Check spot price history
        history = rm.getSpotPriceHistory(ts4, ts5);


        assertEquals(prices.length, history.length);


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

View Full Code Here

     * @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 persistOne() throws Exception {
        logger.debug("persistOne");
        final Manager rm = this.locator.getManager();
        final Caller caller = this.populator().getCaller();


        PersistenceAdapter persistence = (PersistenceAdapter) applicationContext.getBean("nimbus-rm.persistence.PersistenceAdapter");
        AsyncRequestMap asyncRequestMap = new AsyncRequestMap(persistence);

View Full Code Here

    @Test
    public void leaseOne() throws Exception {




        logger.debug("leaseOne");
        final Manager rm = this.locator.getManager();


        final Caller caller = this.populator().getCaller();


        final CreateRequest req =
                this.populator().getCreateRequest(
                        "suite:availabilityZone:leaseOne");


        assertEquals(null, req.getRequestedResourcePool());


        final CreateResult result = rm.create(req, 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

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


        final Caller caller = this.populator().getCaller();


        /* One */
        final CreateRequest req =
                this.populator().getCreateRequestCustomZone(
                        "suite:availabilityZone:leaseOneZone1OneZone2",
                        "zone1");


        assertEquals("zone1", req.getRequestedResourcePool());


        final CreateResult result = rm.create(req, 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));




        /* Two */
        final CreateRequest req2 =
                this.populator().getCreateRequestCustomZone(
                        "suite:issue37:leaseOneZone1OneZone2",
                        "zone2");


        final CreateResult result2 = rm.create(req2, caller);


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


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


        final NIC[] nics2 = vms2[0].getNics();
        //assertEquals(1, nics2.length);
        //assertEquals("private", nics2[0].getNetworkName());


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

View Full Code Here

     */
    @DirtiesContext
    @Test(groups="dirtyTest")
    public void dirtyTest() throws Exception {
        logger.debug("dirtyTest");
        final Manager rm = this.locator.getManager();


        final Caller caller = this.populator().getCaller();
        final CreateResult result =
                rm.create(this.populator().getCreateRequest("suite:basic:dirtyTest"),
                          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));
    }

View Full Code Here

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


        assertEquals(0, vms.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.