Examples of CreateResult

org.apache.zookeeper.OpResult.CreateResult
org.jboss.dashboard.workspace.export.structure.CreateResult
Implementation of a Workspace creation result, used on Import process.
org.nimbustools.api.repr.CreateResult

Examples of org.jboss.dashboard.workspace.export.structure.CreateResult

    public CreateResult create(final XMLNode node, final boolean onStartup) {
        return create(node, Collections.EMPTY_MAP, onStartup);
    }


    public CreateResult create(final XMLNode node, final Map attributes, final boolean onStartup) {
        final CreateResult result = new CreateResult();


        HibernateTxFragment txFragment = new HibernateTxFragment() {
            protected void txFragment(Session session) throws Exception {
                if (ExportVisitor.WORKSPACE.equals(node.getObjectName())) {
                    createWorkspace(result, node, attributes, onStartup);
                } else if (ExportVisitor.RESOURCE.equals(node.getObjectName())) {
                    createResource(result, null, null, null, node, attributes, onStartup);
                } else {
                    throw new IllegalArgumentException("Invalid workspace node.");
                }
            }
        };
        try {
            txFragment.execute();
        } catch (Exception e) {
            log.error("Error:", e);
            return new CreateResult(e);
        }
        return result;
    }

View Full Code Here

Examples of org.jboss.dashboard.workspace.export.structure.CreateResult

            renderFragment("empty");
        } else {
            renderFragment("outputStart");
            boolean anyErrors = false;
            for (int i = 0; i < results.length; i++) {
                CreateResult result = results[i];
                if (result.hasErrors()) anyErrors = true;
            }
            for (int i = 0; i < results.length; i++) {
                CreateResult result = results[i];
                renderCreateResult(request, response, result, i, anyErrors);
            }
            renderFragment("outputEnd");


            if (anyErrors)

View Full Code Here

Examples of org.jboss.dashboard.workspace.export.structure.CreateResult

    public CreateResult create(final XMLNode node, final boolean onStartup) {
        return create(node, Collections.EMPTY_MAP, onStartup);
    }


    public CreateResult create(final XMLNode node, final Map attributes, final boolean onStartup) {
        final CreateResult result = new CreateResult();


        HibernateTxFragment txFragment = new HibernateTxFragment() {
            protected void txFragment(Session session) throws Exception {
                if (ExportVisitor.WORKSPACE.equals(node.getObjectName())) {
                    createWorkspace(result, node, attributes, onStartup);
                } else if (ExportVisitor.RESOURCE.equals(node.getObjectName())) {
                    createResource(result, null, null, null, node, attributes, onStartup);
                } else {
                    throw new IllegalArgumentException("Invalid workspace node.");
                }
            }
        };
        try {
            txFragment.execute();
        } catch (Exception e) {
            log.error("Error:", e);
            return new CreateResult(e);
        }
        return result;
    }

View Full Code Here

Examples of org.jboss.dashboard.workspace.export.structure.CreateResult

    public CreateResult create(final XMLNode node, final boolean onStartup) {
        return create(node, Collections.EMPTY_MAP, onStartup);
    }


    public CreateResult create(final XMLNode node, final Map attributes, final boolean onStartup) {
        final CreateResult result = new CreateResult();


        HibernateTxFragment txFragment = new HibernateTxFragment() {
            protected void txFragment(Session session) throws Exception {
                if (ExportVisitor.WORKSPACE.equals(node.getObjectName())) {
                    createWorkspace(result, node, attributes, onStartup);
                } else if (ExportVisitor.RESOURCE.equals(node.getObjectName())) {
                    createResource(result, null, null, null, node, attributes, onStartup);
                } else {
                    throw new IllegalArgumentException("Invalid workspace node.");
                }
            }
        };
        try {
            txFragment.execute();
        } catch (Exception e) {
            log.error("Error:", e);
            return new CreateResult(e);
        }
        return result;
    }

View Full Code Here

Examples of org.jboss.dashboard.workspace.export.structure.CreateResult

            Map attributes = (Map) attributesForCreation.get(i);
            if (ExportVisitor.WORKSPACE.equals(nodeToCreate.getObjectName())
                    ||
                    ExportVisitor.RESOURCE.equals(nodeToCreate.getObjectName())
                    ) {
                CreateResult result = workspaceBuilder.create(nodeToCreate, attributes, onStartup);
                createResults.add(result);
            }
        }


        return (CreateResult[]) createResults.toArray(new CreateResult[createResults.size()]);

View Full Code Here

Examples of 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

Examples of org.nimbustools.api.repr.CreateResult

        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

Examples of org.nimbustools.api.repr.CreateResult


        // 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

Examples of org.nimbustools.api.repr.CreateResult

    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

Examples of org.nimbustools.api.repr.CreateResult

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

0 1 2 3 4 5

TOP

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.