private void assertLockedBy(Address initiator) { assertEquals(IN_TRANSITION, clusterStateManager.getState()); ClusterStateLock stateLock = clusterStateManager.getStateLock(); assertTrue(stateLock.isLocked()); assertEquals(TXN, stateLock.getTransactionId()); assertEquals(initiator, stateLock.getLockOwner()); }
@Test public void test_initialClusterState_rejected() { clusterStateManager.initialClusterState(FROZEN); clusterStateManager.initialClusterState(ACTIVE); assertEquals(FROZEN, clusterStateManager.getState()); }
@Test(expected = TransactionException.class) public void test_lockClusterState_fail() throws Exception { Address initiator = newAddress(); final ClusterState newState = FROZEN; clusterStateManager.lockClusterState(newState, initiator, TXN, 1000, 0); clusterStateManager.lockClusterState(newState, initiator, ANOTHER_TXN, 1000, 0); }
@Test public void test_lockClusterState_getLockExpiryTime() throws Exception { final Address initiator = newAddress(); clusterStateManager.lockClusterState(FROZEN, initiator, TXN, TimeUnit.DAYS.toMillis(1), 0); final ClusterStateLock stateLock = clusterStateManager.getStateLock(); assertTrue( Clock.currentTimeMillis() + TimeUnit.HOURS.toMillis(12) < stateLock.getLockExpiryTime()); }
@Test public void test_changeLocalClusterState_success() throws Exception { final ClusterState newState = FROZEN; final Address initiator = newAddress(); clusterStateManager.lockClusterState(newState, initiator, TXN, 10000, 0); clusterStateManager.commitClusterState(newState, initiator, TXN); assertEquals(newState, clusterStateManager.getState()); final ClusterStateLock stateLock = clusterStateManager.getStateLock(); assertFalse(stateLock.isLocked()); }
@Test public void changeLocalClusterState_shouldChangeNodeStateToShuttingDown_whenStateBecomes_PASSIVE() throws Exception { final ClusterState newState = PASSIVE; final Address initiator = newAddress(); clusterStateManager.lockClusterState(newState, initiator, TXN, 10000, 0); clusterStateManager.commitClusterState(newState, initiator, TXN); assertEquals(newState, clusterStateManager.getState()); verify(node, times(1)).changeNodeStateToPassive(); }
@Test(expected = IllegalStateException.class) public void test_lockClusterState_forPassiveState_whenHasOnGoingMigration() throws Exception { when(partitionService.hasOnGoingMigrationLocal()).thenReturn(true); clusterStateManager.initialClusterState(FROZEN); Address initiator = newAddress(); final ClusterState newState = PASSIVE; clusterStateManager.lockClusterState(newState, initiator, TXN, 1000, 0); assertLockedBy(initiator); }
@Test public void changeLocalClusterState_shouldRemoveMembersDeadWhileFrozen_whenStateBecomes_ACTIVE() throws Exception { final ClusterState newState = ACTIVE; final Address initiator = newAddress(); clusterStateManager.initialClusterState(FROZEN); clusterStateManager.lockClusterState(newState, initiator, TXN, 10000, 0); clusterStateManager.commitClusterState(newState, initiator, TXN); assertEquals(newState, clusterStateManager.getState()); verify(clusterService, times(1)).removeMembersDeadWhileClusterIsNotActive(); }
public void initialClusterState(ClusterState clusterState) { if (node.joined()) { throw new IllegalStateException( "Cannot set initial state after node joined! -> " + clusterState); } clusterStateManager.initialClusterState(clusterState); }
@Test public void test_lockClusterState_success() throws Exception { Address initiator = newAddress(); final ClusterState newState = FROZEN; clusterStateManager.lockClusterState(newState, initiator, TXN, 1000, 0); assertLockedBy(initiator); }
@Override public void reset() { lock.lock(); try { setMembersRef(Collections.singletonMap(thisAddress, thisMember)); clusterHeartbeatManager.reset(); clusterStateManager.reset(); clusterJoinManager.reset(); membersRemovedInNotActiveStateRef.set(Collections.<Address, MemberImpl>emptyMap()); } finally { lock.unlock(); } }
@Test public void test_lockClusterState_expiry() throws Exception { clusterStateManager.lockClusterState(FROZEN, newAddress(), TXN, 1, 0); assertTrueEventually( new AssertTask() { @Override public void run() throws Exception { final ClusterStateLock stateLock = clusterStateManager.getStateLock(); assertFalse(stateLock.isLocked()); assertEquals(ACTIVE, clusterStateManager.getState()); } }); }
private void removeMember(MemberImpl deadMember) { logger.info("Removing " + deadMember); lock.lock(); try { Map<Address, MemberImpl> members = membersMapRef.get(); final Address deadAddress = deadMember.getAddress(); if (members.containsKey(deadAddress)) { // !!! ORDERED !!! Map<Address, MemberImpl> newMembers = new LinkedHashMap<Address, MemberImpl>(members); newMembers.remove(deadAddress); clusterHeartbeatManager.removeMember(deadMember); setMembersRef(newMembers); if (node.isMaster()) { if (logger.isFinestEnabled()) { logger.finest(deadMember + " is dead, sending remove to all other members..."); } invokeMemberRemoveOperation(deadAddress); } final ClusterState clusterState = clusterStateManager.getState(); if (clusterState == ClusterState.FROZEN || clusterState == ClusterState.PASSIVE) { if (logger.isFinestEnabled()) { logger.finest( deadMember + " is dead, added to members left while cluster is " + clusterState + " state"); } Map<Address, MemberImpl> membersRemovedInNotActiveState = new LinkedHashMap<Address, MemberImpl>(membersRemovedInNotActiveStateRef.get()); membersRemovedInNotActiveState.put(deadAddress, deadMember); membersRemovedInNotActiveStateRef.set( Collections.unmodifiableMap(membersRemovedInNotActiveState)); final InternalPartitionServiceImpl partitionService = node.partitionService; partitionService.cancelReplicaSyncRequestsTo(deadAddress); } else { onMemberRemove(deadMember, newMembers); } // async events sendMembershipEventNotifications( deadMember, unmodifiableSet(new LinkedHashSet<Member>(newMembers.values())), false); } } finally { lock.unlock(); } }
@Test public void test_initialClusterState_PASSIVE() { clusterStateManager.initialClusterState(PASSIVE); assertEquals(PASSIVE, clusterStateManager.getState()); }
@Test public void test_initialClusterState_FROZEN() { clusterStateManager.initialClusterState(FROZEN); assertEquals(FROZEN, clusterStateManager.getState()); }
// for testing void changeClusterState(ClusterState newState, int partitionStateVersion) { clusterStateManager.changeClusterState(newState, getMembers(), partitionStateVersion); }
@Override public void changeClusterState(ClusterState newState, TransactionOptions options) { int partitionStateVersion = node.getPartitionService().getPartitionStateVersion(); clusterStateManager.changeClusterState(newState, getMembers(), options, partitionStateVersion); }
@Test(expected = IllegalStateException.class) public void test_lockClusterState_fail_withDifferentPartitionStateVersions() throws Exception { clusterStateManager.lockClusterState(FROZEN, newAddress(), TXN, 1000, 1); }
@Test(expected = TransactionException.class) public void test_changeLocalClusterState_fail_notLocked() throws Exception { clusterStateManager.commitClusterState(FROZEN, newAddress(), TXN); }
@Test(expected = NullPointerException.class) public void test_changeLocalClusterState_nullTransactionId() throws Exception { clusterStateManager.commitClusterState(FROZEN, newAddress(), null); }
@Test(expected = IllegalArgumentException.class) public void test_changeLocalClusterState_IN_TRANSITION() throws Exception { clusterStateManager.commitClusterState(IN_TRANSITION, newAddress(), TXN); }
@Test(expected = NullPointerException.class) public void test_changeLocalClusterState_nullState() throws Exception { clusterStateManager.commitClusterState(null, newAddress(), TXN); }
@Override public ClusterState getClusterState() { return clusterStateManager.getState(); }
@Test public void test_unlockClusterState_fail_whenLockedByElse() throws Exception { clusterStateManager.lockClusterState(FROZEN, newAddress(), TXN, 1000, 0); assertFalse(clusterStateManager.rollbackClusterState(ANOTHER_TXN)); }
@Override public void rollbackTransaction(String transactionId) { logger.info("Rolling back cluster state. Transaction: " + transactionId); clusterStateManager.rollbackClusterState(transactionId); }
@Test public void test_unlockClusterState_fail_whenNotLocked() throws Exception { assertFalse(clusterStateManager.rollbackClusterState(TXN)); }
// for testing void changeClusterState(ClusterState newState, Collection<Member> members) { int partitionStateVersion = node.getPartitionService().getPartitionStateVersion(); clusterStateManager.changeClusterState(newState, members, partitionStateVersion); }
@Test public void test_defaultState() { assertEquals(ACTIVE, clusterStateManager.getState()); }
@Test(expected = TransactionException.class) public void test_changeLocalClusterState_fail_whenLockedByElse() throws Exception { final Address initiator = newAddress(); clusterStateManager.lockClusterState(FROZEN, initiator, TXN, 10000, 0); clusterStateManager.commitClusterState(FROZEN, initiator, ANOTHER_TXN); }
@Test public void test_unlockClusterState_success() throws Exception { clusterStateManager.lockClusterState(FROZEN, newAddress(), TXN, 1000, 0); assertTrue(clusterStateManager.rollbackClusterState(TXN)); }