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

     * Lease a number of VMs and then destroy them all at once.
     */
    @Test(groups="basic5", dependsOnGroups="basic1")
    public void leaseMany() throws Exception {
        logger.debug("leaseMany");
        final Manager rm = this.locator.getManager();


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


        final int durationSecs = 240;
        final int memory = 64;
        final int numNodes = 5;
        final CreateRequest creq =
                this.populator().getCreateRequest("suite:failure:leaseMany",
                                                  durationSecs, memory, numNodes);
        final Caller caller = this.populator().getCaller();
        final CreateResult result = rm.create(creq, caller);


        final VM[] vms = result.getVMs();
        assertEquals(5, vms.length);
        for (int i = 0; i < vms.length; i++) {
            assertNotNull(vms[i]);
            logger.info("Leased vm '" + vms[i].getID() + '\'');
            assertTrue(rm.exists(vms[i].getID(), Manager.INSTANCE));
        }


        Thread.sleep(2000L);
        
        for (int i = 0; i < vms.length; i++) {
            assertTrue(rm.exists(vms[i].getID(), Manager.INSTANCE));
        }
        allvms = rm.getGlobalAll();
        assertEquals(5, allvms.length);


        Thread.sleep(2000L);


        for (int i = 0; i < vms.length; i++) {
            rm.trash(vms[i].getID(), Manager.INSTANCE, caller);
        }


        Thread.sleep(2000L);


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


        for (int i = 0; i < vms.length; i++) {
            assertFalse(rm.exists(vms[i].getID(), Manager.INSTANCE));
        }
    }

View Full Code Here

     * Lease a VM and then wait for it to expire
     */
    @Test(groups="basicwait", dependsOnGroups="basic5")
    public void leaseOneWait() throws Exception {
        logger.debug("leaseOneWait");
        final Manager rm = this.locator.getManager();


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


        final int durationSecs = 5;
        final int memory = 64;
        final int numNodes = 1;
        final CreateRequest creq =
                this.populator().getCreateRequest("suite:failure:leaseOneWait",
                                                  durationSecs, memory, numNodes);
        final Caller caller = this.populator().getCaller();
        final CreateResult result = rm.create(creq, 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(10000L);


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

View Full Code Here

     * Lease a VM and then unpropagate it.  Then allow to expire
     */
    @Test(groups="unpropWait", dependsOnGroups="basicwait")
    public void unpropOneWait() throws Exception {
        logger.debug("unpropOneWait");
        final Manager rm = this.locator.getManager();


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


        final int durationSecs = 5;
        final int memory = 64;
        final int numNodes = 1;
        final CreateRequest creq =
                this.populator().getCreateRequest("suite:failure:unpropOneWait",
                                                  durationSecs, memory, numNodes);
        final Caller caller = this.populator().getCaller();
        final CreateResult result = rm.create(creq, 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(1500L);


        allvms = rm.getGlobalAll();
        assertEquals(State.STATE_Running, allvms[0].getState().getState());


        // Unpropagate:
        rm.shutdownSave(vms[0].getID(), Manager.INSTANCE,
                        this.populator().getShutdownTasks() , caller);


        allvms = rm.getGlobalAll();
        assertEquals(1, allvms.length);
        
        // Wait for complete termination:
        Thread.sleep(15000L);


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

View Full Code Here

     * After a wait, trigger shutdown task to succeed.  Ensure it finally gets killed.
     */
    @Test(groups="basicfail1", dependsOnGroups="unpropWait")
    public void basicFail() throws Exception {
        logger.debug("basicFail");
        final Manager rm = this.locator.getManager();


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


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


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


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


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


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


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


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


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


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


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

View Full Code Here

     * More of the same idea as in basicFail() but working with more instances and situations
     */
    @Test(groups="complicatedfail", dependsOnGroups="basicfail1")
    public void complicatedFail() throws Exception {
        logger.debug("complicatedFail");
        final Manager rm = this.locator.getManager();


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


        final int durationSecs = 240;
        final int memory = 64;
        final int numNodes = 5;
        final CreateRequest creq =
                this.populator().getCreateRequest("suite:failure:complicatedFail",
                                                  durationSecs, memory, numNodes);
        final Caller caller = this.populator().getCaller();
        final CreateResult result = rm.create(creq, caller);


        final VM[] vms = result.getVMs();
        assertEquals(5, vms.length);
        for (int i = 0; i < vms.length; i++) {
            assertNotNull(vms[i]);
            logger.info("Leased vm '" + vms[i].getID() + '\'');
            assertTrue(rm.exists(vms[i].getID(), Manager.INSTANCE));
        }


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


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


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


        int lastFailCount = MockShutdownTrash.getFailCount();
        assertFalse(0 == lastFailCount);
        assertTrue(rm.exists(vms[0].getID(), Manager.INSTANCE));
        assertTrue(rm.exists(vms[1].getID(), Manager.INSTANCE));
        allvms = rm.getGlobalAll();
        assertEquals(5, allvms.length);


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


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


        Thread.sleep(15000L);


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


        // Start counting from scratch
        MockShutdownTrash.resetFailCount();


        // Add two in a new group, with very short duration
        final int durationSecs2 = 5;
        final int memory2 = 64;
        final int numNodes2 = 2;
        final CreateRequest creq2 =
                this.populator().getCreateRequest("suite:failure:complicatedFail2",
                                                  durationSecs2, memory2, numNodes2);
        final CreateResult result2 = rm.create(creq2, caller);


        VM[] vms2 = result2.getVMs();
        assertEquals(2, vms2.length);
        for (int i = 0; i < vms2.length; i++) {
            assertNotNull(vms2[i]);
            logger.info("Leased vm '" + vms2[i].getID() + '\'');
            assertTrue(rm.exists(vms2[i].getID(), Manager.INSTANCE));
        }


        allvms = rm.getGlobalAll();
        assertEquals(5, allvms.length);
        
        // Wait for them to terminate successfully
        Thread.sleep(8000L);


        assertEquals(0, MockShutdownTrash.getFailCount());


        // Should now be gone:
        assertFalse(rm.exists(vms2[0].getID(), Manager.INSTANCE));
        assertFalse(rm.exists(vms2[1].getID(), Manager.INSTANCE));
        allvms = rm.getGlobalAll();
        assertEquals(3, allvms.length);


        // Old ones should remain:
        assertTrue(rm.exists(vms[2].getID(), Manager.INSTANCE));
        assertTrue(rm.exists(vms[3].getID(), Manager.INSTANCE));
        assertTrue(rm.exists(vms[4].getID(), Manager.INSTANCE));


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


        // Try to kill all but one
        rm.trash(vms[2].getID(), Manager.INSTANCE, caller);
        rm.trash(vms[3].getID(), Manager.INSTANCE, caller);
        Thread.sleep(4000L);


        // Shouldn't work
        allvms = rm.getGlobalAll();
        assertEquals(3, allvms.length);
        assertTrue(rm.exists(vms[2].getID(), Manager.INSTANCE));
        assertTrue(rm.exists(vms[3].getID(), Manager.INSTANCE));
        assertTrue(rm.exists(vms[4].getID(), Manager.INSTANCE));


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


        Thread.sleep(8000L);


        // Should now be gone:
        assertFalse(rm.exists(vms[2].getID(), Manager.INSTANCE));
        assertFalse(rm.exists(vms[3].getID(), Manager.INSTANCE));
        allvms = rm.getGlobalAll();
        assertEquals(1, allvms.length);


        // And this one should now die right away:
        rm.trash(vms[4].getID(), Manager.INSTANCE, caller);
        assertFalse(rm.exists(vms[4].getID(), Manager.INSTANCE));
        allvms = rm.getGlobalAll();
        assertEquals(0, allvms.length);
    }

View Full Code Here

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


        // some room for internal IoC in the future


        final Manager mgr = this.master.getModuleLocator().getManager();


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


        final MetadataServer mdServer =
                this.master.getModuleLocator().getMetadataServer();


        final URL baseURL;
        try {
            baseURL = this.master.getBaseURL();
        } catch (IOException e) {
            final String err =
                    "Problem finding base container URL: " + e.getMessage();
            throw new ResourceException(err, e);
        }


        final InstanceTranslate trInstance =
                new InstanceTranslate(repr, baseURL);


        final Translate translate =
                            new Translate(repr,
                                          new TranslateDefinitionImpl(repr),
                                          new TranslateRAImpl(repr),
                                          new TranslateNetImpl(repr),
                                          trInstance,
                                          baseURL);


        final ContextBrokerHome brokerHome;
        try {
            brokerHome = OtherContext.discoverContextBrokerHome();
        } catch (Exception e) {
            throw new ResourceException(e.getMessage(), e);
        }


        final FactoryResource resource =
                new FactoryResource(mgr, translate, brokerHome, repr, mdServer);


        resource.setRPs(mgr.getAdvertised());


        return resource;
    }

View Full Code Here

     * termination failed game
     */
    @Test(groups="unpropFail", dependsOnGroups="complicatedfail")
    public void unpropOneFail() throws Exception {
        logger.debug("unpropOneFail");
        final Manager rm = this.locator.getManager();


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


        final int durationSecs = 5;
        final int memory = 64;
        final int numNodes = 1;
        final CreateRequest creq =
                this.populator().getCreateRequest("suite:failure:unpropOneFail",
                                                  durationSecs, memory, numNodes);
        final Caller caller = this.populator().getCaller();
        final CreateResult result = rm.create(creq, 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(1500L);


        MockShutdownTrash.resetFailCount();


        allvms = rm.getGlobalAll();
        assertEquals(State.STATE_Running, allvms[0].getState().getState());


        // Shutdown (but don't unpropagate or trash it):
        rm.shutdown(vms[0].getID(), Manager.INSTANCE, null, caller);


        allvms = rm.getGlobalAll();
        assertEquals(1, allvms.length);


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


        // Wait for complete termination ... to fail.
        Thread.sleep(15000L);


        assertFalse(0 == MockShutdownTrash.getFailCount());


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


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


        Thread.sleep(10000L);


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

View Full Code Here

        }
    }


    private void stopWorkspaceService() {
        logger.info("Stopping Workspace Manager (thread pools)..");
        final Manager rm = this.locator.getManager();
        if (rm != null) {
            rm.shutdownImmediately();
            logger.info("Workspace Manager (thread pools) stopped");
        } else {
            logger.info("No Workspace Manager");
        }
    }

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.