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();
  }
Example #9
0
 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);
  }
Example #11
0
 @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());
         }
       });
 }
Example #13
0
  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());
 }
Example #16
0
 // for testing
 void changeClusterState(ClusterState newState, int partitionStateVersion) {
   clusterStateManager.changeClusterState(newState, getMembers(), partitionStateVersion);
 }
Example #17
0
 @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);
 }
Example #23
0
 @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));
 }
Example #25
0
 @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));
 }
Example #27
0
 // 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));
 }