Java ReplicationConnection.setReadOnly方法代码示例

import com.mysql.jdbc.ReplicationConnection; //导入方法依赖的package包/类
public void testReplicationConnectionGroupHostManagement() throws Exception {
    String replicationGroup1 = "rg1";

    Properties props = new Properties();
    props.setProperty("replicationConnectionGroup", replicationGroup1);
    props.setProperty("retriesAllDown", "3");
    ReplicationConnection conn2 = this.getUnreliableReplicationConnection(new String[] { "first", "second", "third" }, props);
    assertNotNull("Connection should not be null", this.conn);
    conn2.setAutoCommit(false);
    String port = getPort(props, new NonRegisteringDriver());
    String firstHost = "first:" + port;
    String secondHost = "second:" + port;
    String thirdHost = "third:" + port;

    // "first" should be master, "second" and "third" should be slaves.
    assertEquals(1, ReplicationConnectionGroupManager.getConnectionCountWithHostAsMaster(replicationGroup1, firstHost));
    assertEquals(0, ReplicationConnectionGroupManager.getConnectionCountWithHostAsSlave(replicationGroup1, firstHost));

    // remove "third" from slave pool:
    conn2.removeSlave(thirdHost);

    assertEquals(0, ReplicationConnectionGroupManager.getConnectionCountWithHostAsMaster(replicationGroup1, thirdHost));
    assertEquals(0, ReplicationConnectionGroupManager.getConnectionCountWithHostAsSlave(replicationGroup1, thirdHost));

    // add "third" back into slave pool:
    conn2.addSlaveHost(thirdHost);

    assertEquals(0, ReplicationConnectionGroupManager.getConnectionCountWithHostAsMaster(replicationGroup1, thirdHost));
    assertEquals(1, ReplicationConnectionGroupManager.getConnectionCountWithHostAsSlave(replicationGroup1, thirdHost));

    conn2.setReadOnly(false);

    assertEquals(0, ReplicationConnectionGroupManager.getNumberOfMasterPromotion(replicationGroup1));

    // failover to "second" as master
    ReplicationConnectionGroupManager.promoteSlaveToMaster(replicationGroup1, secondHost);
    assertEquals(1, ReplicationConnectionGroupManager.getNumberOfMasterPromotion(replicationGroup1));

    // "first" is still a master:
    assertEquals(1, ReplicationConnectionGroupManager.getConnectionCountWithHostAsMaster(replicationGroup1, firstHost));
    assertEquals(0, ReplicationConnectionGroupManager.getConnectionCountWithHostAsSlave(replicationGroup1, firstHost));
    assertEquals(1, ReplicationConnectionGroupManager.getConnectionCountWithHostAsMaster(replicationGroup1, secondHost));
    assertEquals(0, ReplicationConnectionGroupManager.getConnectionCountWithHostAsSlave(replicationGroup1, secondHost));

    ReplicationConnectionGroupManager.removeMasterHost(replicationGroup1, firstHost);

    conn2.createStatement().execute("SELECT 1");
    assertFalse(conn2.isClosed());

    conn2.commit();

    // validate that queries are successful:
    conn2.createStatement().execute("SELECT 1");
    assertTrue(conn2.isHostMaster(secondHost));

    // master is now offline
    UnreliableSocketFactory.downHost("second");
    try {
        Statement lstmt = conn2.createStatement();
        lstmt.execute("SELECT 1");
        fail("Should fail here due to closed connection");
    } catch (SQLException sqlEx) {
        assertEquals("08S01", sqlEx.getSQLState());
    }

}
 

import com.mysql.jdbc.ReplicationConnection; //导入方法依赖的package包/类
public void testReplicationConnectionMemory() throws Exception {
    Properties props = new Properties();
    props.setProperty("retriesAllDown", "3");
    String replicationGroup = "memoryGroup";
    props.setProperty("replicationConnectionGroup", replicationGroup);

    Set<MockConnectionConfiguration> configs = new HashSet<MockConnectionConfiguration>();
    MockConnectionConfiguration first = new MockConnectionConfiguration("first", "slave", null, false);
    MockConnectionConfiguration second = new MockConnectionConfiguration("second", "master", null, false);
    MockConnectionConfiguration third = new MockConnectionConfiguration("third", "slave", null, false);

    configs.add(first);
    configs.add(second);
    configs.add(third);

    ReplicationConnection conn2 = this.getUnreliableReplicationConnection(configs, props);

    ReplicationConnectionGroupManager.promoteSlaveToMaster(replicationGroup, first.getAddress());
    ReplicationConnectionGroupManager.removeMasterHost(replicationGroup, second.getAddress());
    ReplicationConnectionGroupManager.addSlaveHost(replicationGroup, second.getAddress());

    conn2.setReadOnly(false);

    assertFalse(conn2.isReadOnly());
    assertTrue(conn2.isMasterConnection());
    assertTrue(conn2.isHostMaster(first.getAddress()));
    assertTrue(conn2.isHostSlave(second.getAddress()));
    assertTrue(conn2.isHostSlave(third.getAddress()));

    // make sure state changes made are reflected in new connections:

    ReplicationConnection conn3 = this.getUnreliableReplicationConnection(configs, props);

    conn3.setReadOnly(false);

    assertFalse(conn3.isReadOnly());
    assertTrue(conn3.isMasterConnection());
    assertTrue(conn3.isHostMaster(first.getAddress()));
    assertTrue(conn3.isHostSlave(second.getAddress()));
    assertTrue(conn3.isHostSlave(third.getAddress()));

}
 

import com.mysql.jdbc.ReplicationConnection; //导入方法依赖的package包/类
/**
 * Tests fix for Bug#56100 - Replication driver routes DML statements to read-only slaves.
 */
public void testBug56100() throws Exception {
    final String port = getPort(null, new NonRegisteringDriver());
    final String hostMaster = "master:" + port;
    final String hostSlave = "slave:" + port;

    final Properties props = new Properties();
    props.setProperty("statementInterceptors", Bug56100StatementInterceptor.class.getName());

    final ReplicationConnection testConn = getUnreliableReplicationConnection(new String[] { "master", "slave" }, props);

    assertTrue(testConn.isHostMaster(hostMaster));
    assertTrue(testConn.isHostSlave(hostSlave));

    // verify that current connection is 'master'
    assertTrue(testConn.isMasterConnection());

    final Statement testStmt1 = testConn.createStatement();
    testBug56100AssertHost(testStmt1, "master");

    // set connection to read-only state and verify that current connection is 'slave' now
    testConn.setReadOnly(true);
    assertFalse(testConn.isMasterConnection());

    final Statement testStmt2 = testConn.createStatement();
    testBug56100AssertHost(testStmt1, "slave");
    testBug56100AssertHost(testStmt2, "slave");

    // set connection to read/write state and verify that current connection is 'master' again
    testConn.setReadOnly(false);
    assertTrue(testConn.isMasterConnection());

    final Statement testStmt3 = testConn.createStatement();
    testBug56100AssertHost(testStmt1, "master");
    testBug56100AssertHost(testStmt2, "master");
    testBug56100AssertHost(testStmt3, "master");

    // let Connection.close() also close open statements
    testConn.close();

    assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
        public Void call() throws Exception {
            testStmt1.execute("SELECT 'Bug56100'");
            return null;
        }
    });

    assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
        public Void call() throws Exception {
            testStmt2.execute("SELECT 'Bug56100'");
            return null;
        }
    });

    assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
        public Void call() throws Exception {
            testStmt3.execute("SELECT 'Bug56100'");
            return null;
        }
    });
}
 

import com.mysql.jdbc.ReplicationConnection; //导入方法依赖的package包/类
public void setReadOnly(boolean readOnly) throws SQLException {
    this.readOnly = readOnly;
    for (ReplicationConnection conn : this.serverConnections.values()) {
        conn.setReadOnly(readOnly);
    }
}
 

import com.mysql.jdbc.ReplicationConnection; //导入方法依赖的package包/类
public void testReplicationConnectionMemory() throws Exception {
	Properties props = new Properties();
	props.setProperty("retriesAllDown", "3");
	String replicationGroup = "memoryGroup";
	props.setProperty("replicationConnectionGroup", replicationGroup);

	Set<MockConnectionConfiguration> configs = new HashSet<MockConnectionConfiguration>();
	MockConnectionConfiguration first = new MockConnectionConfiguration("first", "slave", null, false);
	MockConnectionConfiguration second = new MockConnectionConfiguration("second", "master", null, false);
	MockConnectionConfiguration third = new MockConnectionConfiguration("third", "slave", null, false);

	configs.add(first);
	configs.add(second);
	configs.add(third);

	ReplicationConnection conn2 = this
			.getUnreliableReplicationConnection(configs, props);


	ReplicationConnectionGroupManager.promoteSlaveToMaster(replicationGroup, first.getAddress());
	ReplicationConnectionGroupManager.removeMasterHost(replicationGroup, second.getAddress());
	ReplicationConnectionGroupManager.addSlaveHost(replicationGroup, second.getAddress());

	conn2.setReadOnly(false);

	assertFalse(conn2.isReadOnly());
	assertTrue(conn2.isMasterConnection());
	assertTrue(conn2.isHostMaster(first.getAddress()));
	assertTrue(conn2.isHostSlave(second.getAddress()));
	assertTrue(conn2.isHostSlave(third.getAddress()));


	// make sure state changes made are reflected in new connections:

	ReplicationConnection conn3 = this
			.getUnreliableReplicationConnection(configs, props);


	conn3.setReadOnly(false);

	assertFalse(conn3.isReadOnly());
	assertTrue(conn3.isMasterConnection());
	assertTrue(conn3.isHostMaster(first.getAddress()));
	assertTrue(conn3.isHostSlave(second.getAddress()));
	assertTrue(conn3.isHostSlave(third.getAddress()));


}
 

import com.mysql.jdbc.ReplicationConnection; //导入方法依赖的package包/类
public void setReadOnly(boolean readOnly) throws SQLException {
	this.readOnly = readOnly;
	for (ReplicationConnection conn : serverConnections.values()) {
		conn.setReadOnly(readOnly);
	}
}