Examples with ManagedCluster org.neo4j.kernel.impl.ha.ClusterManager.ManagedCluster used on opensource projects

Example 16 with ManagedCluster

use of org.neo4j.kernel.impl.ha.ClusterManager.ManagedCluster in project neo4j by neo4j.

the class ReadOnlySlaveTest method givenClusterWithReadOnlySlaveWhenWriteTxOnSlaveThenCommitFails.

@Test
public void givenClusterWithReadOnlySlaveWhenWriteTxOnSlaveThenCommitFails() throws Throwable {
    // When
    ManagedCluster cluster = clusterRule.startCluster();
    HighlyAvailableGraphDatabase readOnlySlave = cluster.getMemberByServerId(new InstanceId(2));
    try (Transaction tx = readOnlySlave.beginTx()) {
        readOnlySlave.createNode();
        tx.success();
        fail("Should have thrown exception");
    } catch (WriteOperationsNotAllowedException ex) {
    // Then
    }
}

Example 17 with ManagedCluster

use of org.neo4j.kernel.impl.ha.ClusterManager.ManagedCluster in project neo4j by neo4j.

the class ReadOnlySlaveTest method givenClusterWithReadOnlySlaveWhenAddNewRelTypeOnSlaveThenThrowException.

@Test
public void givenClusterWithReadOnlySlaveWhenAddNewRelTypeOnSlaveThenThrowException() throws Throwable {
    // Given
    ManagedCluster cluster = clusterRule.startCluster();
    Node node;
    Node node2;
    HighlyAvailableGraphDatabase master = cluster.getMaster();
    try (Transaction tx = master.beginTx()) {
        node = master.createNode();
        node2 = master.createNode();
        tx.success();
    }
    // When
    HighlyAvailableGraphDatabase readOnlySlave = cluster.getMemberByServerId(new InstanceId(2));
    try (Transaction tx = readOnlySlave.beginTx()) {
        Node slaveNode = readOnlySlave.getNodeById(node.getId());
        Node slaveNode2 = readOnlySlave.getNodeById(node2.getId());
        // Then
        slaveNode.createRelationshipTo(slaveNode2, RelationshipType.withName("KNOWS"));
        tx.success();
        fail("Should have thrown exception");
    } catch (WriteOperationsNotAllowedException ex) {
    // Ok!
    }
}

Example 18 with ManagedCluster

use of org.neo4j.kernel.impl.ha.ClusterManager.ManagedCluster in project neo4j by neo4j.

the class SchemaIndexHaIT method creatingIndexOnMasterShouldHaveSlavesBuildItAsWell.

@Test
public void creatingIndexOnMasterShouldHaveSlavesBuildItAsWell() throws Throwable {
    // GIVEN
    ManagedCluster cluster = clusterRule.startCluster();
    HighlyAvailableGraphDatabase master = cluster.getMaster();
    Map<Object, Node> data = createSomeData(master);
    // WHEN
    IndexDefinition index = createIndex(master);
    cluster.sync();
    // THEN
    awaitIndexOnline(index, cluster, data);
}

Example 19 with ManagedCluster

use of org.neo4j.kernel.impl.ha.ClusterManager.ManagedCluster in project neo4j by neo4j.

the class SchemaIndexHaIT method populatingSchemaIndicesOnMasterShouldBeBroughtOnlineOnSlavesAfterStoreCopy.

@Test
public void populatingSchemaIndicesOnMasterShouldBeBroughtOnlineOnSlavesAfterStoreCopy() throws Throwable {
    /*
        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(IS_MASTER);
    ManagedCluster cluster = clusterRule.withDbFactory(dbFactory).startCluster();
    try {
        cluster.await(allSeesAllAsAvailable());
        HighlyAvailableGraphDatabase slave = cluster.getAnySlave();
        // 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.getMaster();
        Map<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;
        try (Transaction tx = master.beginTx()) {
            index = Iterables.single(master.schema().getIndexes());
            awaitIndexOnline(index, master, data);
            tx.success();
        }
        // Check slave
        try (Transaction tx = slave.beginTx()) {
            awaitIndexOnline(index, slave, data);
            tx.success();
        }
    } finally {
        for (HighlyAvailableGraphDatabase db : cluster.getAllMembers()) {
            dbFactory.triggerFinish(db);
        }
    }
}

Example 20 with ManagedCluster

use of org.neo4j.kernel.impl.ha.ClusterManager.ManagedCluster in project neo4j by neo4j.

the class SchemaIndexHaIT method onlineSchemaIndicesOnMasterShouldBeBroughtOnlineOnSlavesAfterStoreCopy.

@Test
public void onlineSchemaIndicesOnMasterShouldBeBroughtOnlineOnSlavesAfterStoreCopy() throws Throwable {
    /*
        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();
    ManagedCluster cluster = clusterRule.withDbFactory(dbFactory).startCluster();
    cluster.await(allSeesAllAsAvailable(), 120);
    HighlyAvailableGraphDatabase slave = cluster.getAnySlave();
    // 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.getMaster();
    Map<Object, Node> data = createSomeData(master);
    createIndex(master);
    dbFactory.awaitPopulationStarted(master);
    // And the population finishes
    dbFactory.triggerFinish(master);
    IndexDefinition index;
    try (Transaction tx = master.beginTx()) {
        index = Iterables.single(master.schema().getIndexes());
        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);
    try (Transaction tx = slave.beginTx()) {
        awaitIndexOnline(index, slave, data);
        tx.success();
    }
}