Examples of org.nimbustools.api.repr.CreateResult

org.nimbustools.api.repr.CreateResult

        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

        final Caller caller = this.populator().getCaller();
        final CreateRequest request =
                this.populator().getCreateRequest("suite:issue26:tooMuchMemory", 240, 3584, 1);
        boolean impossibleMemory = false;
        try {
            final CreateResult result = rm.create(request, caller);
        } catch (ImpossibleAmountOfMemoryException e) {
            impossibleMemory = true;
        }
        assertTrue(impossibleMemory);
    }

View Full Code Here


        // In 10 seconds, trigger the shutdown task to start succeeding
        this.suiteExecutor.submit(new DestroyEnableFutureTask(10));


        final long startMs = System.currentTimeMillis();
        final CreateResult result = rm.create(req, caller);


        final long endMs = System.currentTimeMillis();
        final long totalSeconds = (endMs - startMs) / 1000;
        logger.info("Total seconds: " + totalSeconds);


        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

    public void memoryFreed() throws Exception {
        final Manager rm = this.locator.getManager();
        final Caller caller = this.populator().getCaller();
        final CreateRequest request =
                this.populator().getCreateRequest("memoryFreed", 240, 63, 1);
        final CreateResult result = rm.create(request, caller);
        final VM[] vms = result.getVMs();


        VmmNode node = getNodes()[0];
        assertFalse(node.isVacant());


        rm.trash(vms[0].getID(), Manager.INSTANCE, caller);

View Full Code Here

        /* 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));

View Full Code Here

        /* 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);

View Full Code Here

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

View Full Code Here

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

View Full Code Here

    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

    public void leaseOne() throws Exception {
        logger.debug("leaseOne");
        final Manager rm = this.locator.getManager();


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


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


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

View Full Code Here

0 1 2

TOP

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

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.IdempotentCreationSuite

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

org.globus.workspace.testing.suites.spotinstances.BackfillTerminationSuite

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.