Examples of org.apache.cassandra.gms.ApplicationState

org.apache.cassandra.gms.ApplicationState
This abstraction represents the state associated with a particular node which an application wants to make available to the rest of the nodes in the cluster. Whenever a piece of state needs to be disseminated to the rest of cluster wrap the state in an instance of ApplicationState and add it to the Gossiper. e.g. if we want to disseminate load information for node A do the following: ApplicationState loadState = new ApplicationState(); Gossiper.instance().addApplicationState("LOAD STATE", loadState);


    public void onChange(EndPoint endpoint, EndPointState epState)
    {
        logger_.debug("CHANGE IN STATE FOR @ StorageLoadBalancer " + endpoint);
        // load information for this specified endpoint for load balancing 
        ApplicationState loadInfoState = epState.getApplicationState(LoadDisseminator.loadInfo_);
        if ( loadInfoState != null )
        {
            String lInfoState = loadInfoState.getState();
            LoadInfo lInfo = new LoadInfo(lInfoState);
            loadInfo_.put(endpoint, lInfo);
            
            /*
            int currentLoad = Integer.parseInt(loadInfoState.getState());

View Full Code Here

     * @param epState state that actually changed for the above endpoint.
     */
    public void onChange(EndPoint endpoint, EndPointState epState)
    {        
        /* node identifier for this endpoint on the identifier space */
        ApplicationState leaderState = epState.getApplicationState(LeaderElector.leaderState_);
        if (leaderState != null && !leader_.equals(endpoint))
        {
            EndPoint leader = EndPoint.fromString( leaderState.getState() );
            logger_.debug("New leader in the cluster is " + leader);
            leader_.set(endpoint);
        }
    }

View Full Code Here

         * tracker. Non leader nodes start the M/R task tracker 
         * thereby initializing the M/R subsystem.
        */
        if ( StorageService.instance().isLeader(leader_.get()) )
        {
            Gossiper.instance().addApplicationState(LeaderElector.leaderState_, new ApplicationState(leader_.toString()));              
        }
    }

View Full Code Here


        InetAddress myEndpoint = InetAddress.getByName("127.0.0.1");
        Range range3 = ss.getPrimaryRangeForEndPoint(three);
        Token fakeToken = ((IPartitioner)StorageService.getPartitioner()).midpoint(range3.left, range3.right);
        assert range3.contains(fakeToken);
        ss.onChange(myEndpoint, StorageService.MOVE_STATE, new ApplicationState(StorageService.STATE_BOOTSTRAPPING + StorageService.Delimiter + ss.getPartitioner().getTokenFactory().toString(fakeToken)));
        tmd = ss.getTokenMetadata();


        InetAddress source2 = BootStrapper.getBootstrapSource(tmd, load);
        assert two.equals(source2) : source2;
    }

View Full Code Here

        */
    }


    public void onJoin(InetAddress endpoint, EndPointState epState)
    {
        ApplicationState loadState = epState.getApplicationState(LoadDisseminator.loadInfo_);
        if (loadState != null)
        {
            onChange(endpoint, LoadDisseminator.loadInfo_, loadState);
        }
    }

View Full Code Here

        List<InetAddress> hosts = new ArrayList<InetAddress>();


        createInitialRing(ss, partitioner, endPointTokens, keyTokens, hosts, 5);


        // Third node leaves
        ss.onChange(hosts.get(2), StorageService.MOVE_STATE, new ApplicationState(StorageService.STATE_LEAVING + StorageService.Delimiter + partitioner.getTokenFactory().toString(endPointTokens.get(2))));


        // check that it is correctly marked as leaving in tmd
        assertTrue(tmd.isLeaving(hosts.get(2)));


        // check that pending ranges are correct (primary range should go to 1st node, first

View Full Code Here


        // create a ring or 10 nodes
        createInitialRing(ss, partitioner, endPointTokens, keyTokens, hosts, 10);


        // nodes 6, 8 and 9 leave
        ss.onChange(hosts.get(6), StorageService.MOVE_STATE, new ApplicationState(StorageService.STATE_LEAVING + StorageService.Delimiter + partitioner.getTokenFactory().toString(endPointTokens.get(6))));
        ss.onChange(hosts.get(8), StorageService.MOVE_STATE, new ApplicationState(StorageService.STATE_LEAVING + StorageService.Delimiter + partitioner.getTokenFactory().toString(endPointTokens.get(8))));
        ss.onChange(hosts.get(9), StorageService.MOVE_STATE, new ApplicationState(StorageService.STATE_LEAVING + StorageService.Delimiter + partitioner.getTokenFactory().toString(endPointTokens.get(9))));
        
        // boot two new nodes with keyTokens.get(5) and keyTokens.get(7)
        InetAddress boot1 = InetAddress.getByName("127.0.1.1");
        ss.onChange(boot1, StorageService.MOVE_STATE, new ApplicationState(StorageService.STATE_BOOTSTRAPPING + StorageService.Delimiter + partitioner.getTokenFactory().toString(keyTokens.get(5))));
        InetAddress boot2 = InetAddress.getByName("127.0.1.2");
        ss.onChange(boot2, StorageService.MOVE_STATE, new ApplicationState(StorageService.STATE_BOOTSTRAPPING + StorageService.Delimiter + partitioner.getTokenFactory().toString(keyTokens.get(7))));


        Collection<InetAddress> endPoints = null;


        // tokens 5, 15 and 25 should go three nodes
        for (int i=0; i<3; ++i)
        {
            endPoints = testStrategy.getWriteEndpoints(keyTokens.get(i), testStrategy.getNaturalEndpoints(keyTokens.get(i)));
            assertTrue(endPoints.size() == 3);
            assertTrue(endPoints.contains(hosts.get(i+1)));
            assertTrue(endPoints.contains(hosts.get(i+2)));
            assertTrue(endPoints.contains(hosts.get(i+3)));
        }


        // token 35 should go to nodes 4, 5, 6, 7 and boot1
        endPoints = testStrategy.getWriteEndpoints(keyTokens.get(3), testStrategy.getNaturalEndpoints(keyTokens.get(3)));
        assertTrue(endPoints.size() == 5);
        assertTrue(endPoints.contains(hosts.get(4)));
        assertTrue(endPoints.contains(hosts.get(5)));
        assertTrue(endPoints.contains(hosts.get(6)));
        assertTrue(endPoints.contains(hosts.get(7)));
        assertTrue(endPoints.contains(boot1));


        // token 45 should go to nodes 5, 6, 7, 0, boot1 and boot2
        endPoints = testStrategy.getWriteEndpoints(keyTokens.get(4), testStrategy.getNaturalEndpoints(keyTokens.get(4)));
        assertTrue(endPoints.size() == 6);
        assertTrue(endPoints.contains(hosts.get(5)));
        assertTrue(endPoints.contains(hosts.get(6)));
        assertTrue(endPoints.contains(hosts.get(7)));
        assertTrue(endPoints.contains(hosts.get(0)));
        assertTrue(endPoints.contains(boot1));
        assertTrue(endPoints.contains(boot2));


        // token 55 should go to nodes 6, 7, 8, 0, 1, boot1 and boot2
        endPoints = testStrategy.getWriteEndpoints(keyTokens.get(5), testStrategy.getNaturalEndpoints(keyTokens.get(5)));
        assertTrue(endPoints.size() == 7);
        assertTrue(endPoints.contains(hosts.get(6)));
        assertTrue(endPoints.contains(hosts.get(7)));
        assertTrue(endPoints.contains(hosts.get(8)));
        assertTrue(endPoints.contains(hosts.get(0)));
        assertTrue(endPoints.contains(hosts.get(1)));
        assertTrue(endPoints.contains(boot1));
        assertTrue(endPoints.contains(boot2));


        // token 65 should go to nodes 7, 8, 9, 0, 1 and boot2
        endPoints = testStrategy.getWriteEndpoints(keyTokens.get(6), testStrategy.getNaturalEndpoints(keyTokens.get(6)));
        assertTrue(endPoints.size() == 6);
        assertTrue(endPoints.contains(hosts.get(7)));
        assertTrue(endPoints.contains(hosts.get(8)));
        assertTrue(endPoints.contains(hosts.get(9)));
        assertTrue(endPoints.contains(hosts.get(0)));
        assertTrue(endPoints.contains(hosts.get(1)));
        assertTrue(endPoints.contains(boot2));


        // token 75 should to go nodes 8, 9, 0, 1, 2 and boot2
        endPoints = testStrategy.getWriteEndpoints(keyTokens.get(7), testStrategy.getNaturalEndpoints(keyTokens.get(7)));
        assertTrue(endPoints.size() == 6);
        assertTrue(endPoints.contains(hosts.get(8)));
        assertTrue(endPoints.contains(hosts.get(9)));
        assertTrue(endPoints.contains(hosts.get(0)));
        assertTrue(endPoints.contains(hosts.get(1)));
        assertTrue(endPoints.contains(hosts.get(2)));
        assertTrue(endPoints.contains(boot2));


        // token 85 should go to nodes 9, 0, 1 and 2
        endPoints = testStrategy.getWriteEndpoints(keyTokens.get(8), testStrategy.getNaturalEndpoints(keyTokens.get(8)));
        assertTrue(endPoints.size() == 4);
        assertTrue(endPoints.contains(hosts.get(9)));
        assertTrue(endPoints.contains(hosts.get(0)));
        assertTrue(endPoints.contains(hosts.get(1)));
        assertTrue(endPoints.contains(hosts.get(2)));


        // token 95 should go to nodes 0, 1 and 2
        endPoints = testStrategy.getWriteEndpoints(keyTokens.get(9), testStrategy.getNaturalEndpoints(keyTokens.get(9)));
        assertTrue(endPoints.size() == 3);
        assertTrue(endPoints.contains(hosts.get(0)));
        assertTrue(endPoints.contains(hosts.get(1)));
        assertTrue(endPoints.contains(hosts.get(2)));


        // Now finish node 6 and node 9 leaving, as well as boot1 (after this node 8 is still
        // leaving and boot2 in progress
        ss.onChange(hosts.get(6), StorageService.MOVE_STATE, new ApplicationState(StorageService.STATE_LEFT + StorageService.Delimiter + StorageService.LEFT_NORMALLY + StorageService.Delimiter + partitioner.getTokenFactory().toString(endPointTokens.get(6))));
        ss.onChange(hosts.get(9), StorageService.MOVE_STATE, new ApplicationState(StorageService.STATE_LEFT + StorageService.Delimiter + StorageService.LEFT_NORMALLY + StorageService.Delimiter + partitioner.getTokenFactory().toString(endPointTokens.get(9))));
        ss.onChange(boot1, StorageService.MOVE_STATE, new ApplicationState(StorageService.STATE_NORMAL + StorageService.Delimiter + partitioner.getTokenFactory().toString(keyTokens.get(5))));


        // tokens 5, 15 and 25 should go three nodes
        for (int i=0; i<3; ++i)
        {
            endPoints = testStrategy.getWriteEndpoints(keyTokens.get(i), testStrategy.getNaturalEndpoints(keyTokens.get(i)));

View Full Code Here


        // create a ring or 5 nodes
        createInitialRing(ss, partitioner, endPointTokens, keyTokens, hosts, 5);


        // node 2 leaves
        ss.onChange(hosts.get(2), StorageService.MOVE_STATE, new ApplicationState(StorageService.STATE_LEAVING + StorageService.Delimiter + partitioner.getTokenFactory().toString(endPointTokens.get(2))));


        // don't bother to test pending ranges here, that is extensively tested by other
        // tests. Just check that the node is in appropriate lists.
        assertTrue(tmd.isMember(hosts.get(2)));
        assertTrue(tmd.isLeaving(hosts.get(2)));
        assertTrue(tmd.getBootstrapTokens().isEmpty());


        // Bootstrap the node immedidiately to keyTokens.get(4) without going through STATE_LEFT
        ss.onChange(hosts.get(2), StorageService.MOVE_STATE, new ApplicationState(StorageService.STATE_BOOTSTRAPPING + StorageService.Delimiter + partitioner.getTokenFactory().toString(keyTokens.get(4))));


        assertFalse(tmd.isMember(hosts.get(2)));
        assertFalse(tmd.isLeaving(hosts.get(2)));
        assertTrue(tmd.getBootstrapTokens().get(keyTokens.get(4)).equals(hosts.get(2)));


        // Bootstrap node hosts.get(3) to keyTokens.get(1)
        ss.onChange(hosts.get(3), StorageService.MOVE_STATE, new ApplicationState(StorageService.STATE_BOOTSTRAPPING + StorageService.Delimiter + partitioner.getTokenFactory().toString(keyTokens.get(1))));


        assertFalse(tmd.isMember(hosts.get(3)));
        assertFalse(tmd.isLeaving(hosts.get(3)));
        assertTrue(tmd.getBootstrapTokens().get(keyTokens.get(4)).equals(hosts.get(2)));
        assertTrue(tmd.getBootstrapTokens().get(keyTokens.get(1)).equals(hosts.get(3)));


        // Bootstrap node hosts.get(2) further to keyTokens.get(3)
        ss.onChange(hosts.get(2), StorageService.MOVE_STATE, new ApplicationState(StorageService.STATE_BOOTSTRAPPING + StorageService.Delimiter + partitioner.getTokenFactory().toString(keyTokens.get(3))));


        assertFalse(tmd.isMember(hosts.get(2)));
        assertFalse(tmd.isLeaving(hosts.get(2)));
        assertTrue(tmd.getBootstrapTokens().get(keyTokens.get(3)).equals(hosts.get(2)));
        assertTrue(tmd.getBootstrapTokens().get(keyTokens.get(4)) == null);
        assertTrue(tmd.getBootstrapTokens().get(keyTokens.get(1)).equals(hosts.get(3)));


        // Go to normal again for both nodes
        ss.onChange(hosts.get(2), StorageService.MOVE_STATE, new ApplicationState(StorageService.STATE_NORMAL + StorageService.Delimiter + partitioner.getTokenFactory().toString(keyTokens.get(3))));
        ss.onChange(hosts.get(3), StorageService.MOVE_STATE, new ApplicationState(StorageService.STATE_NORMAL + StorageService.Delimiter + partitioner.getTokenFactory().toString(keyTokens.get(2))));


        assertTrue(tmd.isMember(hosts.get(2)));
        assertFalse(tmd.isLeaving(hosts.get(2)));
        assertTrue(tmd.getToken(hosts.get(2)).equals(keyTokens.get(3)));
        assertTrue(tmd.isMember(hosts.get(3)));

View Full Code Here


        // create a ring or 5 nodes
        createInitialRing(ss, partitioner, endPointTokens, keyTokens, hosts, 5);


        // node 2 leaves
        ss.onChange(hosts.get(2), StorageService.MOVE_STATE, new ApplicationState(StorageService.STATE_LEAVING + StorageService.Delimiter + partitioner.getTokenFactory().toString(endPointTokens.get(2))));


        assertTrue(tmd.isLeaving(hosts.get(2)));
        assertTrue(tmd.getToken(hosts.get(2)).equals(endPointTokens.get(2)));


        // back to normal
        ss.onChange(hosts.get(2), StorageService.MOVE_STATE, new ApplicationState(StorageService.STATE_NORMAL + StorageService.Delimiter + partitioner.getTokenFactory().toString(keyTokens.get(2))));


        assertTrue(tmd.getLeavingEndPoints().isEmpty());
        assertTrue(tmd.getToken(hosts.get(2)).equals(keyTokens.get(2)));


        // node 3 goes through leave and left and then jumps to normal
        ss.onChange(hosts.get(2), StorageService.MOVE_STATE, new ApplicationState(StorageService.STATE_LEAVING + StorageService.Delimiter + partitioner.getTokenFactory().toString(keyTokens.get(2))));
        ss.onChange(hosts.get(2), StorageService.MOVE_STATE, new ApplicationState(StorageService.STATE_LEFT + StorageService.Delimiter + StorageService.LEFT_NORMALLY + StorageService.Delimiter + partitioner.getTokenFactory().toString(keyTokens.get(2))));
        ss.onChange(hosts.get(2), StorageService.MOVE_STATE, new ApplicationState(StorageService.STATE_NORMAL + StorageService.Delimiter + partitioner.getTokenFactory().toString(keyTokens.get(4))));


        assertTrue(tmd.getBootstrapTokens().isEmpty());
        assertTrue(tmd.getLeavingEndPoints().isEmpty());
        assertTrue(tmd.getToken(hosts.get(2)).equals(keyTokens.get(4)));

View Full Code Here


        // create a ring or 5 nodes
        createInitialRing(ss, partitioner, endPointTokens, keyTokens, hosts, 5);


        // node 2 leaves with _different_ token
        ss.onChange(hosts.get(2), StorageService.MOVE_STATE, new ApplicationState(StorageService.STATE_LEAVING + StorageService.Delimiter + partitioner.getTokenFactory().toString(keyTokens.get(0))));


        assertTrue(tmd.getToken(hosts.get(2)).equals(keyTokens.get(0)));
        assertTrue(tmd.isLeaving(hosts.get(2)));
        assertTrue(tmd.getEndPoint(endPointTokens.get(2)) == null);


        // go to boostrap
        ss.onChange(hosts.get(2), StorageService.MOVE_STATE, new ApplicationState(StorageService.STATE_BOOTSTRAPPING + StorageService.Delimiter + partitioner.getTokenFactory().toString(keyTokens.get(1))));


        assertFalse(tmd.isLeaving(hosts.get(2)));
        assertTrue(tmd.getBootstrapTokens().size() == 1);
        assertTrue(tmd.getBootstrapTokens().get(keyTokens.get(1)).equals(hosts.get(2)));


        // jump to leaving again
        ss.onChange(hosts.get(2), StorageService.MOVE_STATE, new ApplicationState(StorageService.STATE_LEAVING + StorageService.Delimiter + partitioner.getTokenFactory().toString(keyTokens.get(1))));


        assertTrue(tmd.getEndPoint(keyTokens.get(1)).equals(hosts.get(2)));
        assertTrue(tmd.isLeaving(hosts.get(2)));
        assertTrue(tmd.getBootstrapTokens().isEmpty());


        // go to state left
        ss.onChange(hosts.get(2), StorageService.MOVE_STATE, new ApplicationState(StorageService.STATE_LEFT + StorageService.Delimiter + StorageService.LEFT_NORMALLY + StorageService.Delimiter + partitioner.getTokenFactory().toString(keyTokens.get(1))));


        assertFalse(tmd.isMember(hosts.get(2)));
        assertFalse(tmd.isLeaving(hosts.get(2)));


        ss.setPartitionerUnsafe(oldPartitioner);

View Full Code Here

0 1 2 3 4 5 6

TOP

Related Classes of org.apache.cassandra.gms.ApplicationState

org.apache.cassandra.db.migration.Migration

org.apache.cassandra.dht.BootStrapperTest

org.apache.cassandra.service.LeaderElector

org.apache.cassandra.service.LoadDisseminator

org.apache.cassandra.service.MigrationManager

org.apache.cassandra.service.MoveTest

org.apache.cassandra.service.StorageLoadBalancer

org.apache.cassandra.service.StorageService

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.