Exemple #1
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void whenInToSlaveStateLosingQuorumShouldPutInPending()
        public virtual void WhenInToSlaveStateLosingQuorumShouldPutInPending()
        {
            // Given
            InstanceId me    = new InstanceId(1);
            InstanceId other = new InstanceId(2);
            HighAvailabilityMemberContext context = new SimpleHighAvailabilityMemberContext(me, false);
            AvailabilityGuard             guard   = mock(typeof(DatabaseAvailabilityGuard));
            ObservedClusterMembers        members = MockClusterMembers(me, emptyList(), singletonList(other));

            ClusterMemberEvents            events = mock(typeof(ClusterMemberEvents));
            ClusterMemberListenerContainer memberListenerContainer = MockAddClusterMemberListener(events);

            HighAvailabilityMemberStateMachine stateMachine = BuildMockedStateMachine(context, events, members, guard);

            stateMachine.Init();
            ClusterMemberListener memberListener = memberListenerContainer.Get();
            HAStateChangeListener probe          = new HAStateChangeListener();

            stateMachine.AddHighAvailabilityMemberListener(probe);

            // Send it to MASTER
            memberListener.MemberIsAvailable(MASTER, other, URI.create("ha://whatever"), StoreId.DEFAULT);

            assertThat(stateMachine.CurrentState, equalTo(HighAvailabilityMemberState.ToSlave));

            // When
            memberListener.MemberIsFailed(new InstanceId(2));

            // Then
            assertThat(stateMachine.CurrentState, equalTo(HighAvailabilityMemberState.Pending));
            assertThat(probe.InstanceStopsConflict, @is(false));
            assertThat(probe.InstanceDetachedConflict, @is(true));
            verify(guard, times(1)).require(any(typeof(AvailabilityRequirement)));
        }
Exemple #2
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void whenInSlaveStateLosingOtherSlaveShouldNotPutInPending()
        public virtual void WhenInSlaveStateLosingOtherSlaveShouldNotPutInPending()
        {
            // Given
            InstanceId me         = new InstanceId(1);
            InstanceId master     = new InstanceId(2);
            InstanceId otherSlave = new InstanceId(3);
            HighAvailabilityMemberContext context = new SimpleHighAvailabilityMemberContext(me, false);
            AvailabilityGuard             guard   = mock(typeof(DatabaseAvailabilityGuard));
            ObservedClusterMembers        members = MockClusterMembers(me, singletonList(master), singletonList(otherSlave));

            ClusterMemberEvents            events = mock(typeof(ClusterMemberEvents));
            ClusterMemberListenerContainer memberListenerContainer = MockAddClusterMemberListener(events);

            HighAvailabilityMemberStateMachine stateMachine = BuildMockedStateMachine(context, events, members, guard);

            stateMachine.Init();
            ClusterMemberListener memberListener = memberListenerContainer.Get();
            HAStateChangeListener probe          = new HAStateChangeListener();

            stateMachine.AddHighAvailabilityMemberListener(probe);

            // Send it to MASTER
            memberListener.MemberIsAvailable(MASTER, master, URI.create("ha://whatever"), StoreId.DEFAULT);
            memberListener.MemberIsAvailable(SLAVE, me, URI.create("ha://whatever3"), StoreId.DEFAULT);
            memberListener.MemberIsAvailable(SLAVE, otherSlave, URI.create("ha://whatever2"), StoreId.DEFAULT);

            assertThat(stateMachine.CurrentState, equalTo(HighAvailabilityMemberState.Slave));

            // When
            memberListener.MemberIsFailed(otherSlave);

            // Then
            assertThat(stateMachine.CurrentState, equalTo(HighAvailabilityMemberState.Slave));
            assertThat(probe.InstanceStopsConflict, @is(false));
        }
Exemple #3
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void whenInMasterStateLosingQuorumFromTwoInstancesShouldRemainMaster()
        public virtual void WhenInMasterStateLosingQuorumFromTwoInstancesShouldRemainMaster()
        {
            // Given
            InstanceId me    = new InstanceId(1);
            InstanceId other = new InstanceId(2);
            HighAvailabilityMemberContext context = new SimpleHighAvailabilityMemberContext(me, false);

            AvailabilityGuard      guard   = mock(typeof(DatabaseAvailabilityGuard));
            ObservedClusterMembers members = MockClusterMembers(me, emptyList(), singletonList(other));

            ClusterMemberEvents            events = mock(typeof(ClusterMemberEvents));
            ClusterMemberListenerContainer memberListenerContainer = MockAddClusterMemberListener(events);

            HighAvailabilityMemberStateMachine stateMachine = BuildMockedStateMachine(context, events, members, guard);

            stateMachine.Init();
            ClusterMemberListener memberListener = memberListenerContainer.Get();
            HAStateChangeListener probe          = new HAStateChangeListener();

            stateMachine.AddHighAvailabilityMemberListener(probe);

            // Send it to MASTER
            memberListener.CoordinatorIsElected(me);
            memberListener.MemberIsAvailable(MASTER, me, URI.create("ha://whatever"), StoreId.DEFAULT);

            assertThat(stateMachine.CurrentState, equalTo(HighAvailabilityMemberState.Master));

            // When
            memberListener.MemberIsFailed(new InstanceId(2));

            // Then
            assertThat(stateMachine.CurrentState, equalTo(HighAvailabilityMemberState.Master));
            assertThat(probe.InstanceStopsConflict, @is(false));
            assertThat(probe.InstanceDetachedConflict, @is(false));
        }
Exemple #4
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldStartFromPending()
        public virtual void ShouldStartFromPending()
        {
            // Given
            HighAvailabilityMemberStateMachine memberStateMachine = BuildMockedStateMachine();

            // Then
            assertThat(memberStateMachine.CurrentState, equalTo(HighAvailabilityMemberState.Pending));
        }
Exemple #5
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Before public void setup()
        public virtual void Setup()
        {
            HighAvailabilityMemberContext context = new SimpleHighAvailabilityMemberContext(_me, false);

            ClusterMemberEvents events = mock(typeof(ClusterMemberEvents));

            HighAvailabilityMemberStateMachineTest.ClusterMemberListenerContainer memberListenerContainer = mockAddClusterMemberListener(events);

            _election = mock(typeof(Election));

            _stateMachine = BuildMockedStateMachine(context, events, _election);
            _stateMachine.init();
            _memberListener = memberListenerContainer.Get();
            HighAvailabilityMemberStateMachineTest.HAStateChangeListener probe = new HighAvailabilityMemberStateMachineTest.HAStateChangeListener();
            _stateMachine.addHighAvailabilityMemberListener(probe);
        }
Exemple #6
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldRemainToPendingOnMasterElectedForSomeoneElse()
        public virtual void ShouldRemainToPendingOnMasterElectedForSomeoneElse()
        {
            // Given
            InstanceId me = new InstanceId(1);
            HighAvailabilityMemberContext  context = new SimpleHighAvailabilityMemberContext(me, false);
            ClusterMemberEvents            events  = mock(typeof(ClusterMemberEvents));
            ClusterMemberListenerContainer memberListenerContainer = MockAddClusterMemberListener(events);

            HighAvailabilityMemberStateMachine stateMachine = BuildMockedStateMachine(context, events);

            stateMachine.Init();
            ClusterMemberListener memberListener = memberListenerContainer.Get();

            // When
            memberListener.CoordinatorIsElected(new InstanceId(2));

            // Then
            assertThat(stateMachine.CurrentState, equalTo(HighAvailabilityMemberState.Pending));
        }
Exemple #7
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void whenSlaveOnlyIsElectedStayInPending()
        public virtual void WhenSlaveOnlyIsElectedStayInPending()
        {
            // Given
            InstanceId me = new InstanceId(1);
            HighAvailabilityMemberContext  context = new SimpleHighAvailabilityMemberContext(me, true);
            ClusterMemberEvents            events  = mock(typeof(ClusterMemberEvents));
            ClusterMemberListenerContainer memberListenerContainer = MockAddClusterMemberListener(events);

            HighAvailabilityMemberStateMachine stateMachine = BuildMockedStateMachine(context, events);

            stateMachine.Init();

            ClusterMemberListener memberListener = memberListenerContainer.Get();

            // When
            memberListener.CoordinatorIsElected(me);

            // Then
            assertThat(stateMachine.CurrentState, equalTo(HighAvailabilityMemberState.Pending));
        }
Exemple #8
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldSwitchToToSlaveOnMasterAvailableForSomeoneElse()
        public virtual void ShouldSwitchToToSlaveOnMasterAvailableForSomeoneElse()
        {
            // Given
            InstanceId me = new InstanceId(1);
            HighAvailabilityMemberContext  context = new SimpleHighAvailabilityMemberContext(me, false);
            ClusterMemberEvents            events  = mock(typeof(ClusterMemberEvents));
            ClusterMemberListenerContainer memberListenerContainer = MockAddClusterMemberListener(events);

            HighAvailabilityMemberStateMachine stateMachine = BuildMockedStateMachine(context, events);

            stateMachine.Init();
            ClusterMemberListener memberListener = memberListenerContainer.Get();
            HAStateChangeListener probe          = new HAStateChangeListener();

            stateMachine.AddHighAvailabilityMemberListener(probe);

            // When
            memberListener.MemberIsAvailable(MASTER, new InstanceId(2), URI.create("ha://whatever"), StoreId.DEFAULT);

            // Then
            assertThat(stateMachine.CurrentState, equalTo(HighAvailabilityMemberState.ToSlave));
            assertThat(probe.MasterIsAvailableConflict, @is(true));
        }
Exemple #9
0
 public StateMachineClusterEventListener(HighAvailabilityMemberStateMachine outerInstance)
 {
     this._outerInstance = outerInstance;
 }
Exemple #10
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void whenHAModeSwitcherSwitchesToSlaveTheOtherModeSwitcherDoNotGetTheOldMasterClient() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void WhenHAModeSwitcherSwitchesToSlaveTheOtherModeSwitcherDoNotGetTheOldMasterClient()
        {
            InstanceId me      = new InstanceId(1);
            StoreId    storeId = newStoreIdForCurrentVersion();
            HighAvailabilityMemberContext context = mock(typeof(HighAvailabilityMemberContext));

            when(context.MyId).thenReturn(me);
            AvailabilityGuard      guard        = mock(typeof(DatabaseAvailabilityGuard));
            ObservedClusterMembers members      = mock(typeof(ObservedClusterMembers));
            ClusterMember          masterMember = mock(typeof(ClusterMember));

            when(masterMember.HARole).thenReturn("master");
            when(masterMember.HasRole("master")).thenReturn(true);
            when(masterMember.InstanceId).thenReturn(new InstanceId(2));
            when(masterMember.StoreId).thenReturn(storeId);
            ClusterMember self = new ClusterMember(me);

            when(members.Members).thenReturn(Arrays.asList(self, masterMember));
            when(members.CurrentMember).thenReturn(self);
            DependencyResolver    dependencyResolver = mock(typeof(DependencyResolver));
            FileSystemAbstraction fs = mock(typeof(FileSystemAbstraction));

            when(fs.FileExists(any(typeof(File)))).thenReturn(true);
            when(dependencyResolver.ResolveDependency(typeof(FileSystemAbstraction))).thenReturn(fs);
            when(dependencyResolver.ResolveDependency(typeof(Monitors))).thenReturn(new Monitors());
            NeoStoreDataSource dataSource = mock(typeof(NeoStoreDataSource));

            when(dataSource.DependencyResolver).thenReturn(dependencyResolver);
            when(dataSource.StoreId).thenReturn(storeId);
            when(dependencyResolver.ResolveDependency(typeof(NeoStoreDataSource))).thenReturn(dataSource);
            when(dependencyResolver.ResolveDependency(typeof(TransactionIdStore))).thenReturn(new SimpleTransactionIdStore());
            when(dependencyResolver.ResolveDependency(typeof(ObservedClusterMembers))).thenReturn(members);
            UpdatePuller updatePuller = mock(typeof(UpdatePuller));

            when(updatePuller.TryPullUpdates()).thenReturn(true);
            when(dependencyResolver.ResolveDependency(typeof(UpdatePuller))).thenReturn(updatePuller);

            ClusterMemberAvailability clusterMemberAvailability = mock(typeof(ClusterMemberAvailability));
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final TriggerableClusterMemberEvents events = new TriggerableClusterMemberEvents();
            TriggerableClusterMemberEvents events = new TriggerableClusterMemberEvents();

            Election election = mock(typeof(Election));
            HighAvailabilityMemberStateMachine stateMachine = new HighAvailabilityMemberStateMachine(context, guard, members, events, election, NullLogProvider.Instance);

            ClusterMembers clusterMembers = new ClusterMembers(members, stateMachine);

            when(dependencyResolver.ResolveDependency(typeof(ClusterMembers))).thenReturn(clusterMembers);

            stateMachine.Init();
            stateMachine.Start();

//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.kernel.ha.DelegateInvocationHandler<org.neo4j.kernel.ha.com.master.Master> handler = new org.neo4j.kernel.ha.DelegateInvocationHandler<>(org.neo4j.kernel.ha.com.master.Master.class);
            DelegateInvocationHandler <Master> handler = new DelegateInvocationHandler <Master>(typeof(Master));

            MasterClientResolver masterClientResolver = mock(typeof(MasterClientResolver));
            MasterClient         masterClient         = mock(typeof(MasterClient));

            when(masterClient.ProtocolVersion).thenReturn(MasterClient214.PROTOCOL_VERSION);
            when(masterClient.Handshake(anyLong(), any(typeof(StoreId)))).thenReturn(new ResponseAnonymousInnerClass(this, storeId, mock(typeof(ResourceReleaser)), handler));
            when(masterClient.ToString()).thenReturn("TheExpectedMasterClient!");
            when(masterClientResolver.Instantiate(anyString(), anyInt(), anyString(), any(typeof(Monitors)), any(typeof(StoreId)), any(typeof(LifeSupport)))).thenReturn(masterClient);

//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.CountDownLatch latch = new java.util.concurrent.CountDownLatch(2);
            System.Threading.CountdownEvent latch = new System.Threading.CountdownEvent(2);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.atomic.AtomicBoolean switchedSuccessfully = new java.util.concurrent.atomic.AtomicBoolean();
            AtomicBoolean switchedSuccessfully = new AtomicBoolean();

            SwitchToSlave.Monitor monitor = new MonitorAnonymousInnerClass(this, latch, switchedSuccessfully);

            Config config = Config.defaults(ClusterSettings.server_id, me.ToString());

            DatabaseTransactionStats transactionCounters = mock(typeof(DatabaseTransactionStats));

            when(transactionCounters.NumberOfActiveTransactions).thenReturn(0L);

            PageCache pageCacheMock = mock(typeof(PageCache));
            PagedFile pagedFileMock = mock(typeof(PagedFile));

            when(pagedFileMock.LastPageId).thenReturn(1L);
            when(pageCacheMock.Map(any(typeof(File)), anyInt())).thenReturn(pagedFileMock);

            TransactionIdStore transactionIdStoreMock = mock(typeof(TransactionIdStore));

            when(transactionIdStoreMock.LastCommittedTransaction).thenReturn(new TransactionId(0, 0, 0));
            SwitchToSlaveCopyThenBranch switchToSlave = new SwitchToSlaveCopyThenBranch(DatabaseLayout.of(new File("")), NullLogService.Instance, mock(typeof(FileSystemAbstraction)), config, mock(typeof(HaIdGeneratorFactory)), handler, mock(typeof(ClusterMemberAvailability)), mock(typeof(RequestContextFactory)), mock(typeof(PullerFactory), RETURNS_MOCKS), Iterables.empty(), masterClientResolver, monitor, new Org.Neo4j.com.storecopy.StoreCopyClientMonitor_Adapter(), Suppliers.singleton(dataSource), Suppliers.singleton(transactionIdStoreMock), slave =>
            {
                SlaveServer mock = mock(typeof(SlaveServer));
                when(mock.SocketAddress).thenReturn(new InetSocketAddress("localhost", 123));
                return(mock);
            }, updatePuller, pageCacheMock, mock(typeof(Monitors)), () => transactionCounters);

            ComponentSwitcherContainer   switcherContainer = new ComponentSwitcherContainer();
            HighAvailabilityModeSwitcher haModeSwitcher    = new HighAvailabilityModeSwitcher(switchToSlave, mock(typeof(SwitchToMaster)), election, clusterMemberAvailability, mock(typeof(ClusterClient)), storeSupplierMock(), me, switcherContainer, NeoStoreDataSourceSupplierMock(), NullLogService.Instance);

            haModeSwitcher.Init();
            haModeSwitcher.Start();
            haModeSwitcher.ListeningAt(URI.create("http://localhost:12345"));

            stateMachine.AddHighAvailabilityMemberListener(haModeSwitcher);

//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.atomic.AtomicReference<org.neo4j.kernel.ha.com.master.Master> ref = new java.util.concurrent.atomic.AtomicReference<>(null);
            AtomicReference <Master> @ref = new AtomicReference <Master>(null);

            //noinspection unchecked
            AbstractComponentSwitcher <object> otherModeSwitcher = new AbstractComponentSwitcherAnonymousInnerClass(this, mock(typeof(DelegateInvocationHandler)), handler, latch, @ref);

            switcherContainer.Add(otherModeSwitcher);
            // When
            events.SwitchToSlave(me);

            // Then
            latch.await();
            assertTrue("mode switch failed", switchedSuccessfully.get());
            Master actual = @ref.get();

            // let's test the toString()s since there are too many wrappers of proxies
            assertEquals(masterClient.ToString(), actual.ToString());

            stateMachine.Stop();
            stateMachine.Shutdown();
            haModeSwitcher.Stop();
            haModeSwitcher.Shutdown();
        }