Exemplo n.º 1
0
        private void CreateIndex(HighlyAvailableGraphDatabase master, Label label, string property)
        {
            using (Transaction transaction = master.BeginTx())
            {
                master.Schema().indexFor(label).on(property).create();
                transaction.Success();
            }

            using (Transaction transaction = master.BeginTx())
            {
                master.Schema().awaitIndexesOnline(1, TimeUnit.MINUTES);
                transaction.Success();
            }
        }
Exemplo n.º 2
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldCreateConstraintOnMaster()
            public virtual void ShouldCreateConstraintOnMaster()
            {
                // given
                ClusterManager.ManagedCluster cluster = ClusterRule.startCluster();
                HighlyAvailableGraphDatabase  master  = cluster.Master;
                string type = type(0);
                string key  = key(0);

                // when
                using (Transaction tx = master.BeginTx())
                {
                    CreateConstraint(master, type, key);
                    tx.Success();
                }

                cluster.Sync();

                // then
                foreach (HighlyAvailableGraphDatabase clusterMember in cluster.AllMembers)
                {
                    using (Transaction tx = clusterMember.BeginTx())
                    {
                        ConstraintDefinition constraint = GetConstraint(clusterMember, type, key);
                        ValidateLabelOrRelationshipType(constraint, type);
                        assertEquals(key, single(constraint.PropertyKeys));
                        tx.Success();
                    }
                }
            }
Exemplo n.º 3
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldCopyStoreFromMasterIfBranched() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void ShouldCopyStoreFromMasterIfBranched()
        {
            // GIVEN
            File           dir            = _directory.directory();
            ClusterManager clusterManager = _life.add(new ClusterManager.Builder(dir)
                                                      .withCluster(clusterOfSize(2)).build());

            ClusterManager.ManagedCluster cluster = clusterManager.Cluster;
            cluster.Await(allSeesAllAsAvailable());
            CreateNode(cluster.Master, "A");
            cluster.Sync();

            // WHEN
            HighlyAvailableGraphDatabase slave = cluster.AnySlave;
            File databaseDir = slave.DatabaseLayout().databaseDirectory();

            ClusterManager.RepairKit     starter = cluster.Shutdown(slave);
            HighlyAvailableGraphDatabase master  = cluster.Master;

            CreateNode(master, "B1");
            CreateNode(master, "C");
            CreateNodeOffline(databaseDir, "B2");
            slave = starter.Repair();

            // THEN
            cluster.Await(allSeesAllAsAvailable());
            slave.BeginTx().close();
        }
Exemplo n.º 4
0
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private static void createClusterWithNode(org.neo4j.kernel.impl.ha.ClusterManager clusterManager) throws Throwable
        private static void CreateClusterWithNode(ClusterManager clusterManager)
        {
            try
            {
                clusterManager.Start();

                clusterManager.Cluster.await(allSeesAllAsAvailable());

                long nodeId;
                HighlyAvailableGraphDatabase master = clusterManager.Cluster.Master;
                using (Transaction tx = master.BeginTx())
                {
                    Node node = master.CreateNode();
                    nodeId = node.Id;
                    node.SetProperty("foo", "bar");
                    tx.Success();
                }

                HighlyAvailableGraphDatabase slave = clusterManager.Cluster.AnySlave;
                using (Transaction ignored = slave.BeginTx())
                {
                    Node node = slave.GetNodeById(nodeId);
                    assertThat(node.GetProperty("foo").ToString(), CoreMatchers.equalTo("bar"));
                }
            }
            finally
            {
                clusterManager.SafeShutdown();
            }
        }
Exemplo n.º 5
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void terminatedTransactionDoesNotForceUpdatePulling()
        public virtual void TerminatedTransactionDoesNotForceUpdatePulling()
        {
            int testTxsOnMaster = 42;

            ClusterManager.ManagedCluster cluster = ClusterRule.withSharedSetting(HaSettings.pull_interval, "0s").withSharedSetting(HaSettings.tx_push_factor, "0").startCluster();

            HighlyAvailableGraphDatabase master = cluster.Master;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.kernel.ha.HighlyAvailableGraphDatabase slave = cluster.getAnySlave();
            HighlyAvailableGraphDatabase slave = cluster.AnySlave;

            CreateNodeOn(master);
            cluster.Sync();

            long lastClosedTxIdOnMaster = LastClosedTxIdOn(master);
            long lastClosedTxIdOnSlave  = LastClosedTxIdOn(slave);

//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.CountDownLatch slaveTxStarted = new java.util.concurrent.CountDownLatch(1);
            System.Threading.CountdownEvent slaveTxStarted = new System.Threading.CountdownEvent(1);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.CountDownLatch slaveShouldCommit = new java.util.concurrent.CountDownLatch(1);
            System.Threading.CountdownEvent slaveShouldCommit = new System.Threading.CountdownEvent(1);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.atomic.AtomicReference<org.neo4j.graphdb.Transaction> slaveTx = new java.util.concurrent.atomic.AtomicReference<>();
            AtomicReference <Transaction> slaveTx = new AtomicReference <Transaction>();
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.concurrent.Future<?> slaveCommit = java.util.concurrent.Executors.newSingleThreadExecutor().submit(() ->
            Future <object> slaveCommit = Executors.newSingleThreadExecutor().submit(() =>
            {
                using (Transaction tx = slave.BeginTx())
                {
                    slaveTx.set(tx);
                    slaveTxStarted.Signal();
                    Await(slaveShouldCommit);
                    tx.success();
                }
            });

            Await(slaveTxStarted);
            CreateNodesOn(master, testTxsOnMaster);

            assertNotNull(slaveTx.get());
            slaveTx.get().terminate();
            slaveShouldCommit.Signal();

            try
            {
                slaveCommit.get();
                fail("Exception expected");
            }
            catch (Exception e)
            {
                assertThat(e, instanceOf(typeof(ExecutionException)));
                assertThat(e.InnerException, instanceOf(typeof(TransientTransactionFailureException)));
            }

            assertEquals(lastClosedTxIdOnMaster + testTxsOnMaster, LastClosedTxIdOn(master));
            assertEquals(lastClosedTxIdOnSlave, LastClosedTxIdOn(slave));
        }
Exemplo n.º 6
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void newSlaveJoiningClusterShouldNotAcceptOperationsUntilConstraintIsOnline() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
            public virtual void NewSlaveJoiningClusterShouldNotAcceptOperationsUntilConstraintIsOnline()
            {
                // Given
                ClusterManager.ManagedCluster cluster = ClusterRule.startCluster();
                string type = type(4);
                string key  = key(4);

                HighlyAvailableGraphDatabase master = cluster.Master;

                HighlyAvailableGraphDatabase slave = cluster.AnySlave;
                File slaveStoreDirectory           = cluster.GetDatabaseDir(slave);

                // Crash the slave
                ClusterManager.RepairKit shutdownSlave = cluster.Shutdown(slave);
                deleteRecursively(slaveStoreDirectory);

                using (Transaction tx = master.BeginTx())
                {
                    CreateConstraint(master, type, key);
                    tx.Success();
                }

                // When
                slave = shutdownSlave.Repair();

                // Then
                using (Transaction ignored = slave.BeginTx())
                {
                    ConstraintDefinition definition = GetConstraint(slave, type, key);
                    assertThat(definition, instanceOf(ConstraintDefinitionClass()));
                    assertThat(single(definition.PropertyKeys), equalTo(key));
                    ValidateLabelOrRelationshipType(definition, type);
                }
            }
Exemplo n.º 7
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void givenClusterWithReadOnlySlaveWhenChangePropertyOnSlaveThenThrowException()
        public virtual void GivenClusterWithReadOnlySlaveWhenChangePropertyOnSlaveThenThrowException()
        {
            // Given
            ManagedCluster cluster = ClusterRule.startCluster();
            Node           node;
            HighlyAvailableGraphDatabase master = cluster.Master;

            using (Transaction tx = master.BeginTx())
            {
                node = master.CreateNode();
                tx.Success();
            }

            // When
            HighlyAvailableGraphDatabase readOnlySlave = cluster.GetMemberByServerId(new InstanceId(2));

            try
            {
                using (Transaction tx = readOnlySlave.BeginTx())
                {
                    Node slaveNode = readOnlySlave.GetNodeById(node.Id);

                    // Then
                    slaveNode.SetProperty("foo", "bar");
                    tx.Success();
                    fail("Should have thrown exception");
                }
            }
            catch (WriteOperationsNotAllowedException)
            {
                // Ok!
            }
        }
Exemplo n.º 8
0
 private void CreateSingleTestLabeledNode(HighlyAvailableGraphDatabase master)
 {
     using (Transaction tx = master.BeginTx())
     {
         master.CreateNode(_testLabel);
         tx.Success();
     }
 }
Exemplo n.º 9
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldRemoveConstraints()
            public virtual void ShouldRemoveConstraints()
            {
                // given
                ClusterManager.ManagedCluster cluster = ClusterRule.startCluster();
                HighlyAvailableGraphDatabase  master  = cluster.Master;
                string type = type(2);
                string key  = key(2);

                long constraintCountBefore;
                long indexCountBefore;

                using (Transaction tx = master.BeginTx())
                {
                    constraintCountBefore = count(master.Schema().Constraints);
                    indexCountBefore      = count(master.Schema().Indexes);
                    CreateConstraint(master, type, key);
                    tx.Success();
                }
                cluster.Sync();

                // and given I have some data for the constraint
                CreateEntityInTx(cluster.AnySlave, type, key, "Foo");

                // when
                using (Transaction tx = master.BeginTx())
                {
                    GetConstraint(master, type, key).drop();
                    tx.Success();
                }
                cluster.Sync();

                // then the constraint should be gone, and not be enforced anymore
                foreach (HighlyAvailableGraphDatabase clusterMember in cluster.AllMembers)
                {
                    using (Transaction tx = clusterMember.BeginTx())
                    {
                        assertNull(GetConstraint(clusterMember, type, key));
                        assertNull(GetIndex(clusterMember, type, key));
                        CreateConstraintViolation(clusterMember, type, key, "Foo");
                        tx.Success();
                    }
                }
            }
Exemplo n.º 10
0
        private void CreateLabeledNodeOnMaster(ClusterManager.ManagedCluster cluster, Label label)
        {
            HighlyAvailableGraphDatabase master = cluster.Master;

            using (Transaction transaction = master.BeginTx())
            {
                Node masterNode = master.CreateNode();
                masterNode.AddLabel(label);
                transaction.Success();
            }
        }
Exemplo n.º 11
0
        private void CheckLabeledNodeExistenceOnSlave(ClusterManager.ManagedCluster cluster, Label label)
        {
            HighlyAvailableGraphDatabase slave = cluster.AnySlave;

            using (Transaction transaction = slave.BeginTx())
            {
                ResourceIterator <Node> slaveNodes = slave.FindNodes(label);
                assertEquals(1, Iterators.asList(slaveNodes).Count);
                transaction.Success();
            }
        }
Exemplo n.º 12
0
        private Node CreateNodeOnMaster(Label testLabel, HighlyAvailableGraphDatabase master)
        {
            Node node;

            using (Transaction transaction = master.BeginTx())
            {
                node = master.CreateNode(testLabel);
                transaction.Success();
            }
            return(node);
        }
Exemplo n.º 13
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void onlineSchemaIndicesOnMasterShouldBeBroughtOnlineOnSlavesAfterStoreCopy() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void OnlineSchemaIndicesOnMasterShouldBeBroughtOnlineOnSlavesAfterStoreCopy()
        {
            /*
             * The master has an index that is online.
             * Then a slave comes online and contacts the master to get copies of the store files.
             * Because the index is online, it should be copied, and the slave should successfully bring the index online.
             */

            // GIVEN
            ControlledGraphDatabaseFactory dbFactory = new ControlledGraphDatabaseFactory();

            ClusterManager.ManagedCluster cluster = ClusterRule.withDbFactory(dbFactory).withSharedSetting(GraphDatabaseSettings.default_schema_provider, _controlledProviderDescriptor.name()).startCluster();
            cluster.Await(allSeesAllAsAvailable(), 120);

            HighlyAvailableGraphDatabase slave = cluster.AnySlave;

            // All slaves in the cluster, except the one I care about, proceed as normal
            ProceedAsNormalWithIndexPopulationOnAllSlavesExcept(dbFactory, cluster, slave);

            // A slave is offline, and has no store files
            ClusterManager.RepairKit slaveDown = BringSlaveOfflineAndRemoveStoreFiles(cluster, slave);

            // And I create an index on the master, and wait for population to start
            HighlyAvailableGraphDatabase master = cluster.Master;
            IDictionary <object, Node>   data   = CreateSomeData(master);

            CreateIndex(master);
            dbFactory.AwaitPopulationStarted(master);

            // And the population finishes
            dbFactory.TriggerFinish(master);
            IndexDefinition index;

            using (Transaction tx = master.BeginTx())
            {
                index = single(master.Schema().Indexes);
                AwaitIndexOnline(index, master, data);
                tx.Success();
            }

            // WHEN the slave comes online after population has finished on the master
            slave = slaveDown.Repair();
            cluster.Await(allSeesAllAsAvailable());
            cluster.Sync();

            // THEN the index should work on the slave
            dbFactory.TriggerFinish(slave);
            using (Transaction tx = slave.BeginTx())
            {
                AwaitIndexOnline(index, slave, data);
                tx.Success();
            }
        }
Exemplo n.º 14
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void givenClusterWhenShutdownMasterThenCannotStartTransactionOnSlave() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void GivenClusterWhenShutdownMasterThenCannotStartTransactionOnSlave()
        {
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.kernel.ha.HighlyAvailableGraphDatabase master = cluster.getMaster();
            HighlyAvailableGraphDatabase master = _cluster.Master;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.kernel.ha.HighlyAvailableGraphDatabase slave = cluster.getAnySlave();
            HighlyAvailableGraphDatabase slave = _cluster.AnySlave;

//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final long nodeId;
            long nodeId;

            using (Transaction tx = master.BeginTx())
            {
                nodeId = master.CreateNode().Id;
                tx.Success();
            }

            _cluster.sync();

            // When
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.FutureTask<bool> result = new java.util.concurrent.FutureTask<>(() ->
            FutureTask <bool> result = new FutureTask <bool>(() =>
            {
                try
                {
                    using (Transaction tx = slave.BeginTx())
                    {
                        tx.AcquireWriteLock(slave.GetNodeById(nodeId));
                    }
                }
                catch (Exception e)
                {
                    return(contains(e, typeof(TransactionFailureException)));
                }
                // Fail otherwise
                return(false);
            });

            DatabaseAvailabilityGuard masterGuard = master.DependencyResolver.resolveDependency(typeof(DatabaseAvailabilityGuard));

            masterGuard.AddListener(new UnavailabilityListener(result));

            master.Shutdown();

            // Then
            assertThat(result.get(), equalTo(true));
        }
Exemplo n.º 15
0
 private long CreateNode(HighlyAvailableGraphDatabase author, string key, object value, bool index)
 {
     using (Transaction tx = author.BeginTx())
     {
         Node node = author.CreateNode();
         node.SetProperty(key, value);
         if (index)
         {
             author.Index().forNodes(key).add(node, key, value);
         }
         tx.Success();
         return(node.Id);
     }
 }
Exemplo n.º 16
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void oneOrTheOtherShouldDeadlock() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void OneOrTheOtherShouldDeadlock()
        {
            AtomicInteger deadlockCount         = new AtomicInteger();
            HighlyAvailableGraphDatabase master = _cluster.Master;
            Node masterA = CreateNodeOnMaster(_testLabel, master);
            Node masterB = CreateNodeOnMaster(_testLabel, master);

            HighlyAvailableGraphDatabase slave = _cluster.AnySlave;

            using (Transaction transaction = slave.BeginTx())
            {
                Node slaveA = slave.GetNodeById(masterA.Id);
                Node slaveB = slave.GetNodeById(masterB.Id);
                System.Threading.CountdownEvent latch = new System.Threading.CountdownEvent(1);

                transaction.AcquireWriteLock(slaveB);

                Thread masterTx = new Thread(() =>
                {
                    try
                    {
                        using (Transaction tx = master.BeginTx())
                        {
                            tx.acquireWriteLock(masterA);
                            latch.Signal();
                            tx.acquireWriteLock(masterB);
                        }
                    }
                    catch (DeadlockDetectedException)
                    {
                        deadlockCount.incrementAndGet();
                    }
                });
                masterTx.Start();
                latch.await();

                try
                {
                    transaction.AcquireWriteLock(slaveA);
                }
                catch (DeadlockDetectedException)
                {
                    deadlockCount.incrementAndGet();
                }
                masterTx.Join();
            }

            assertEquals(1, deadlockCount.get());
        }
Exemplo n.º 17
0
 private static int NodesHavingProperty(HighlyAvailableGraphDatabase slave, string key, string value)
 {
     using (Transaction tx = slave.BeginTx())
     {
         int count = 0;
         foreach (Node node in slave.AllNodes)
         {
             if (value.Equals(node.GetProperty(key, null)))
             {
                 count++;
             }
         }
         tx.Success();
         return(count);
     }
 }
Exemplo n.º 18
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void slaveMustConnectLockManagerToNewMasterAfterTwoOtherClusterMembersRoleSwitch() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void SlaveMustConnectLockManagerToNewMasterAfterTwoOtherClusterMembersRoleSwitch()
        {
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.kernel.ha.HighlyAvailableGraphDatabase initialMaster = cluster.getMaster();
            HighlyAvailableGraphDatabase initialMaster = _cluster.Master;
            HighlyAvailableGraphDatabase firstSlave    = _cluster.AnySlave;
            HighlyAvailableGraphDatabase secondSlave   = _cluster.getAnySlave(firstSlave);

            // Run a transaction on the slaves, to make sure that a master connection has been initialised in all
            // internal pools.
            using (Transaction tx = firstSlave.BeginTx())
            {
                firstSlave.CreateNode();
                tx.Success();
            }
            using (Transaction tx = secondSlave.BeginTx())
            {
                secondSlave.CreateNode();
                tx.Success();
            }
            _cluster.sync();

            ClusterManager.RepairKit failedMaster = _cluster.fail(initialMaster);
            _cluster.await(ClusterManager.masterAvailable(initialMaster));
            failedMaster.Repair();
            _cluster.await(ClusterManager.masterAvailable(initialMaster));
            _cluster.await(ClusterManager.allSeesAllAsAvailable());

            // The cluster has now switched the master role to one of the slaves.
            // The slave that didn't switch, should still have done the work to reestablish the connection to the new
            // master.
            HighlyAvailableGraphDatabase slave = _cluster.getAnySlave(initialMaster);

            using (Transaction tx = slave.BeginTx())
            {
                slave.CreateNode();
                tx.Success();
            }

            // We assert that the transaction above does not throw any exceptions, and that we have now created 3 nodes.
            HighlyAvailableGraphDatabase master = _cluster.Master;

            using (Transaction tx = master.BeginTx())
            {
                assertThat(Iterables.count(master.AllNodes), @is(3L));
            }
        }
Exemplo n.º 19
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void indexPopulationJobsShouldContinueThroughRoleSwitch() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void IndexPopulationJobsShouldContinueThroughRoleSwitch()
        {
            // GIVEN a cluster of 3
            ControlledGraphDatabaseFactory dbFactory = new ControlledGraphDatabaseFactory();

            ClusterManager.ManagedCluster cluster     = ClusterRule.withDbFactory(dbFactory).withSharedSetting(GraphDatabaseSettings.default_schema_provider, _controlledProviderDescriptor.name()).startCluster();
            HighlyAvailableGraphDatabase  firstMaster = cluster.Master;

            // where the master gets some data created as well as an index
            IDictionary <object, Node> data = CreateSomeData(firstMaster);

            CreateIndex(firstMaster);
            //dbFactory.awaitPopulationStarted( firstMaster );
            dbFactory.TriggerFinish(firstMaster);

            // Pick a slave, pull the data and the index
            HighlyAvailableGraphDatabase aSlave = cluster.AnySlave;

            aSlave.DependencyResolver.resolveDependency(typeof(UpdatePuller)).pullUpdates();

            // and await the index population to start. It will actually block as long as we want it to
            dbFactory.AwaitPopulationStarted(aSlave);

            // WHEN we shut down the master
            cluster.Shutdown(firstMaster);

            dbFactory.TriggerFinish(aSlave);
            cluster.Await(masterAvailable(firstMaster));
            // get the new master, which should be the slave we pulled from above
            HighlyAvailableGraphDatabase newMaster = cluster.Master;

            // THEN
            assertEquals("Unexpected new master", aSlave, newMaster);
            using (Transaction tx = newMaster.BeginTx())
            {
                IndexDefinition index = single(newMaster.Schema().Indexes);
                AwaitIndexOnline(index, newMaster, data);
                tx.Success();
            }
            // FINALLY: let all db's finish
            foreach (HighlyAvailableGraphDatabase db in cluster.AllMembers)
            {
                dbFactory.TriggerFinish(db);
            }
        }
Exemplo n.º 20
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void givenClusterWhenMasterGoesDownAndTxIsRunningThenDontWaitToSwitch() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void GivenClusterWhenMasterGoesDownAndTxIsRunningThenDontWaitToSwitch()
        {
            ClusterManager clusterManager = (new ClusterManager.Builder(TestDirectory.directory(TestName.MethodName))).withCluster(ClusterManager.clusterOfSize(3)).build();

            try
            {
                clusterManager.Start();
                ClusterManager.ManagedCluster cluster = clusterManager.Cluster;
                cluster.Await(allSeesAllAsAvailable());

                HighlyAvailableGraphDatabase slave = cluster.AnySlave;

                Transaction tx = slave.BeginTx();
                // Do a little write operation so that all "write" aspects of this tx is initializes properly
                slave.CreateNode();

                // Shut down master while we're keeping this transaction open
                cluster.Shutdown(cluster.Master);

                cluster.Await(masterAvailable());
                cluster.Await(masterSeesSlavesAsAvailable(1));
                // Ending up here means that we didn't wait for this transaction to complete

                tx.Success();

                try
                {
                    tx.Close();
                    fail("Exception expected");
                }
                catch (Exception e)
                {
                    assertThat(e, instanceOf(typeof(TransientTransactionFailureException)));
                    Exception rootCause = rootCause(e);
                    assertThat(rootCause, instanceOf(typeof(TransactionTerminatedException)));
                    assertThat((( TransactionTerminatedException )rootCause).status(), Matchers.equalTo(Org.Neo4j.Kernel.Api.Exceptions.Status_General.DatabaseUnavailable));
                }
            }
            finally
            {
                clusterManager.Stop();
            }
        }
Exemplo n.º 21
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void givenClusterWithReadOnlySlaveWhenWriteTxOnSlaveThenCommitFails()
        public virtual void GivenClusterWithReadOnlySlaveWhenWriteTxOnSlaveThenCommitFails()
        {
            // When
            ManagedCluster cluster = ClusterRule.startCluster();
            HighlyAvailableGraphDatabase readOnlySlave = cluster.GetMemberByServerId(new InstanceId(2));

            try
            {
                using (Transaction tx = readOnlySlave.BeginTx())
                {
                    readOnlySlave.CreateNode();
                    tx.Success();
                    fail("Should have thrown exception");
                }
            }
            catch (WriteOperationsNotAllowedException)
            {
                // Then
            }
        }
Exemplo n.º 22
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void doNotAcquireSharedLocksDuringSlaveReadTx()
        public virtual void DoNotAcquireSharedLocksDuringSlaveReadTx()
        {
            HighlyAvailableGraphDatabase anySlave = _managedCluster.AnySlave;
            HighlyAvailableGraphDatabase master   = _managedCluster.Master;

            using (Transaction tx = master.BeginTx())
            {
                Node node = master.CreateNode(_testLabel);
                node.SetProperty(TEST_PROPERTY, "a");
                tx.Success();
            }

            CreateIndex(master, _testLabel, TEST_PROPERTY);

            using (Transaction transaction = anySlave.BeginTx())
            {
                assertEquals(1, Iterables.count(anySlave.Schema().getIndexes(_testLabel)));
                transaction.Success();
            }
            assertTrue(GetRequestedLocks(anySlave).Count == 0);
        }
Exemplo n.º 23
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldNotBePossibleToCreateConstraintsDirectlyOnSlaves()
            public virtual void ShouldNotBePossibleToCreateConstraintsDirectlyOnSlaves()
            {
                // given
                ClusterManager.ManagedCluster cluster = ClusterRule.startCluster();
                HighlyAvailableGraphDatabase  slave   = cluster.AnySlave;
                string type = type(1);
                string key  = key(1);

                // when
                try
                {
                    using (Transaction ignored = slave.BeginTx())
                    {
                        CreateConstraint(slave, type, key);
                        fail("We expected to not be able to create a constraint on a slave in a cluster.");
                    }
                }
                catch (QueryExecutionException e)
                {
                    assertThat(Exceptions.rootCause(e), instanceOf(typeof(InvalidTransactionTypeKernelException)));
                }
            }
Exemplo n.º 24
0
//JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected:
//ORIGINAL LINE: private Runnable readContestant(final ReadContestantActions action, final long entityId, final org.neo4j.kernel.ha.HighlyAvailableGraphDatabase slave, final java.util.concurrent.atomic.AtomicBoolean end)
        private ThreadStart ReadContestant(ReadContestantActions action, long entityId, HighlyAvailableGraphDatabase slave, AtomicBoolean end)
        {
            return(() =>
            {
                while (!end.get())
                {
                    try
                    {
                        using (Transaction tx = slave.BeginTx())
                        {
                            for (int i = 0; i < 10; i++)
                            {
                                action.VerifyProperties(slave, entityId);
                            }

                            tx.success();
                        }
                    }
                    catch (Exception ignored) when(ignored is TransactionTerminatedException || ignored is TransientTransactionFailureException)
                    {
                    }
                }
            });
        }
Exemplo n.º 25
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void aPendingMemberShouldBeAbleToServeReads() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void APendingMemberShouldBeAbleToServeReads()
        {
            // given
            CreateNodeOnMaster(_testLabel, _cluster.Master);
            _cluster.sync();

            HighlyAvailableGraphDatabase slave = _cluster.AnySlave;

            _cluster.fail(slave, Enum.GetValues(typeof(ClusterManager.NetworkFlag)));
            _cluster.await(instanceEvicted(slave));

            assertEquals(PENDING, slave.InstanceState);

            // when
            for (int i = 0; i < 10; i++)
            {
                try
                {
                    using (Transaction tx = slave.BeginTx())
                    {
                        Node  single = Iterables.single(slave.AllNodes);
                        Label label  = Iterables.single(single.Labels);
                        assertEquals(_testLabel, label);
                        tx.Success();
                        break;
                    }
                }
                catch (TransactionTerminatedException)
                {
                    // Race between going to pending and reading, try again in a little while
                    Thread.Sleep(1_000);
                }
            }

            // then no exceptions thrown
        }
Exemplo n.º 26
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void givenClusterWithReadOnlySlaveWhenAddNewRelTypeOnSlaveThenThrowException()
        public virtual void GivenClusterWithReadOnlySlaveWhenAddNewRelTypeOnSlaveThenThrowException()
        {
            // Given
            ManagedCluster cluster = ClusterRule.startCluster();
            Node           node;
            Node           node2;
            HighlyAvailableGraphDatabase master = cluster.Master;

            using (Transaction tx = master.BeginTx())
            {
                node  = master.CreateNode();
                node2 = master.CreateNode();
                tx.Success();
            }

            // When
            HighlyAvailableGraphDatabase readOnlySlave = cluster.GetMemberByServerId(new InstanceId(2));

            try
            {
                using (Transaction tx = readOnlySlave.BeginTx())
                {
                    Node slaveNode  = readOnlySlave.GetNodeById(node.Id);
                    Node slaveNode2 = readOnlySlave.GetNodeById(node2.Id);

                    // Then
                    slaveNode.CreateRelationshipTo(slaveNode2, RelationshipType.withName("KNOWS"));
                    tx.Success();
                    fail("Should have thrown exception");
                }
            }
            catch (WriteOperationsNotAllowedException)
            {
                // Ok!
            }
        }
Exemplo n.º 27
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void givenClusterWithReadOnlySlaveWhenCreatingNodeOnMasterThenSlaveShouldBeAbleToPullUpdates()
        public virtual void GivenClusterWithReadOnlySlaveWhenCreatingNodeOnMasterThenSlaveShouldBeAbleToPullUpdates()
        {
            ManagedCluster cluster = ClusterRule.startCluster();
            HighlyAvailableGraphDatabase master = cluster.Master;
            Label label = Label.label("label");

            using (Transaction tx = master.BeginTx())
            {
                master.CreateNode(label);
                tx.Success();
            }

            IEnumerable <HighlyAvailableGraphDatabase> allMembers = cluster.AllMembers;

            foreach (HighlyAvailableGraphDatabase member in allMembers)
            {
                using (Transaction tx = member.BeginTx())
                {
                    long count = count(member.FindNodes(label));
                    tx.Success();
                    assertEquals(1, count);
                }
            }
        }
Exemplo n.º 28
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void populatingSchemaIndicesOnMasterShouldBeBroughtOnlineOnSlavesAfterStoreCopy() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void PopulatingSchemaIndicesOnMasterShouldBeBroughtOnlineOnSlavesAfterStoreCopy()
        {
            /*
             * The master has an index that is currently populating.
             * Then a slave comes online and contacts the master to get copies of the store files.
             * Because the index is still populating, it won't be copied. Instead the slave will build its own.
             * We want to observe that the slave builds an index that eventually comes online.
             */

            // GIVEN
            ControlledGraphDatabaseFactory dbFactory = new ControlledGraphDatabaseFactory(_isMaster);

            ClusterManager.ManagedCluster cluster = ClusterRule.withDbFactory(dbFactory).withSharedSetting(GraphDatabaseSettings.default_schema_provider, NativeLuceneFusionIndexProviderFactory20.DESCRIPTOR.name()).startCluster();

            try
            {
                cluster.Await(allSeesAllAsAvailable());

                HighlyAvailableGraphDatabase slave = cluster.AnySlave;

                // A slave is offline, and has no store files
                ClusterManager.RepairKit slaveDown = BringSlaveOfflineAndRemoveStoreFiles(cluster, slave);

                // And I create an index on the master, and wait for population to start
                HighlyAvailableGraphDatabase master = cluster.Master;
                IDictionary <object, Node>   data   = CreateSomeData(master);
                CreateIndex(master);
                dbFactory.AwaitPopulationStarted(master);

                // WHEN the slave comes online before population has finished on the master
                slave = slaveDown.Repair();
                cluster.Await(allSeesAllAsAvailable(), 180);
                cluster.Sync();

                // THEN, population should finish successfully on both master and slave
                dbFactory.TriggerFinish(master);

                // Check master
                IndexDefinition index;
                using (Transaction tx = master.BeginTx())
                {
                    index = single(master.Schema().Indexes);
                    AwaitIndexOnline(index, master, data);
                    tx.Success();
                }

                // Check slave
                using (Transaction tx = slave.BeginTx())
                {
                    AwaitIndexOnline(index, slave, data);
                    tx.Success();
                }
            }
            finally
            {
                foreach (HighlyAvailableGraphDatabase db in cluster.AllMembers)
                {
                    dbFactory.TriggerFinish(db);
                }
            }
        }
Exemplo n.º 29
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void makeSureSlaveCanJoinEvenIfTooFarBackComparedToMaster() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void MakeSureSlaveCanJoinEvenIfTooFarBackComparedToMaster()
        {
            string key   = "foo";
            string value = "bar";

            HighlyAvailableGraphDatabase master = null;
            HighlyAvailableGraphDatabase slave  = null;
            File masterDir = TestDirectory.databaseDir("master");
            File slaveDir  = TestDirectory.databaseDir("slave");

            try
            {
                int masterClusterPort = PortAuthority.allocatePort();
                int masterHaPort      = PortAuthority.allocatePort();
                master = Start(masterDir, 0, stringMap(keep_logical_logs.name(), "1 txs", ClusterSettings.initial_hosts.name(), "127.0.0.1:" + masterClusterPort), masterClusterPort, masterHaPort);
                CreateNode(master, "something", "unimportant");
                CheckPoint(master);
                // Need to start and shutdown the slave so when we start it up later it verifies instead of copying
                int slaveClusterPort = PortAuthority.allocatePort();
                int slaveHaPort      = PortAuthority.allocatePort();
                slave = Start(slaveDir, 1, stringMap(ClusterSettings.initial_hosts.name(), "127.0.0.1:" + masterClusterPort), slaveClusterPort, slaveHaPort);
                slave.Shutdown();

                CreateNode(master, key, value);
                CheckPoint(master);
                // Rotating, moving the above transactions away so they are removed on shutdown.
                RotateLog(master);

                /*
                 * We need to shutdown - rotating is not enough. The problem is that log positions are cached and they
                 * are not removed from the cache until we run into the cache limit. This means that the information
                 * contained in the log can actually be available even if the log is removed. So, to trigger the case
                 * of the master information missing from the master we need to also flush the log entry cache - hence,
                 * restart.
                 */
                master.Shutdown();
                master = Start(masterDir, 0, stringMap(keep_logical_logs.name(), "1 txs", ClusterSettings.initial_hosts.name(), "127.0.0.1:" + masterClusterPort), masterClusterPort, masterHaPort);

                /*
                 * The new log on master needs to have at least one transaction, so here we go.
                 */
                int importantNodeCount = 10;
                for (int i = 0; i < importantNodeCount; i++)
                {
                    CreateNode(master, key, value);
                    CheckPoint(master);
                    RotateLog(master);
                }

                CheckPoint(master);

                slave = Start(slaveDir, 1, stringMap(ClusterSettings.initial_hosts.name(), "127.0.0.1:" + masterClusterPort), slaveClusterPort, slaveHaPort);
                slave.DependencyResolver.resolveDependency(typeof(UpdatePuller)).pullUpdates();

                using (Transaction ignore = slave.BeginTx())
                {
                    assertEquals("store contents differ", importantNodeCount + 1, NodesHavingProperty(slave, key, value));
                }
            }
            finally
            {
                if (slave != null)
                {
                    slave.Shutdown();
                }

                if (master != null)
                {
                    master.Shutdown();
                }
            }
        }
Exemplo n.º 30
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldPullUpdatesOnStartupNoMatterWhat() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        public virtual void ShouldPullUpdatesOnStartupNoMatterWhat()
        {
            HighlyAvailableGraphDatabase slave  = null;
            HighlyAvailableGraphDatabase master = null;

            try
            {
                File testRootDir       = ClusterRule.cleanDirectory("shouldPullUpdatesOnStartupNoMatterWhat");
                File masterDir         = ClusterRule.TestDirectory.databaseDir("master");
                int  masterClusterPort = PortAuthority.allocatePort();
                master = ( HighlyAvailableGraphDatabase )(new TestHighlyAvailableGraphDatabaseFactory()).newEmbeddedDatabaseBuilder(masterDir).setConfig(ClusterSettings.server_id, "1").setConfig(ClusterSettings.cluster_server, "127.0.0.1:" + masterClusterPort).setConfig(ClusterSettings.initial_hosts, "localhost:" + masterClusterPort).setConfig(HaSettings.ha_server, "127.0.0.1:" + PortAuthority.allocatePort()).setConfig(OnlineBackupSettings.online_backup_enabled, Settings.FALSE).newGraphDatabase();

                // Copy the store, then shutdown, so update pulling later makes sense
                File slaveDir = ClusterRule.TestDirectory.databaseDir("slave");
                slave = ( HighlyAvailableGraphDatabase )(new TestHighlyAvailableGraphDatabaseFactory()).newEmbeddedDatabaseBuilder(slaveDir).setConfig(ClusterSettings.server_id, "2").setConfig(ClusterSettings.cluster_server, "127.0.0.1:" + PortAuthority.allocatePort()).setConfig(ClusterSettings.initial_hosts, "localhost:" + masterClusterPort).setConfig(HaSettings.ha_server, "127.0.0.1:" + PortAuthority.allocatePort()).setConfig(OnlineBackupSettings.online_backup_enabled, Settings.FALSE).newGraphDatabase();

                // Required to block until the slave has left for sure
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.CountDownLatch slaveLeftLatch = new java.util.concurrent.CountDownLatch(1);
                System.Threading.CountdownEvent slaveLeftLatch = new System.Threading.CountdownEvent(1);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.cluster.client.ClusterClient masterClusterClient = master.getDependencyResolver().resolveDependency(org.neo4j.cluster.client.ClusterClient.class);
                ClusterClient masterClusterClient = master.DependencyResolver.resolveDependency(typeof(ClusterClient));
                masterClusterClient.AddClusterListener(new ClusterListener_AdapterAnonymousInnerClass(this, slaveLeftLatch, masterClusterClient));

                master.DependencyResolver.resolveDependency(typeof(LogService)).getInternalLog(this.GetType()).info("SHUTTING DOWN SLAVE");
                slave.Shutdown();
                slave = null;

                // Make sure that the slave has left, because shutdown() may return before the master knows
                assertTrue("Timeout waiting for slave to leave", slaveLeftLatch.await(60, TimeUnit.SECONDS));

                long nodeId;
                using (Transaction tx = master.BeginTx())
                {
                    Node node = master.CreateNode();
                    node.SetProperty("from", "master");
                    nodeId = node.Id;
                    tx.Success();
                }

                // Store is already in place, should pull updates
                slave = ( HighlyAvailableGraphDatabase )(new TestHighlyAvailableGraphDatabaseFactory()).newEmbeddedDatabaseBuilder(slaveDir).setConfig(ClusterSettings.server_id, "2").setConfig(ClusterSettings.cluster_server, "127.0.0.1:" + PortAuthority.allocatePort()).setConfig(ClusterSettings.initial_hosts, "localhost:" + masterClusterPort).setConfig(HaSettings.ha_server, "127.0.0.1:" + PortAuthority.allocatePort()).setConfig(HaSettings.pull_interval, "0").setConfig(OnlineBackupSettings.online_backup_enabled, Settings.FALSE).newGraphDatabase();

                slave.BeginTx().close();                         // Make sure switch to slave completes and so does the update pulling on startup

                using (Transaction tx = slave.BeginTx())
                {
                    assertEquals("master", slave.GetNodeById(nodeId).getProperty("from"));
                    tx.Success();
                }
            }
            finally
            {
                if (slave != null)
                {
                    slave.Shutdown();
                }
                if (master != null)
                {
                    master.Shutdown();
                }
            }
        }