public void testRejoinSysprocButFail() throws Exception {
VoltProjectBuilder builder = getBuilderForTest();
boolean success = builder.compile(Configuration.getPathToCatalogForTest("rejoin.jar"), 1, 1, 0);
assertTrue(success);
MiscUtils.copyFile(
builder.getPathToDeployment(), Configuration.getPathToCatalogForTest("rejoin.xml"));
VoltDB.Configuration config = new VoltDB.Configuration();
config.m_pathToCatalog = Configuration.getPathToCatalogForTest("rejoin.jar");
config.m_pathToDeployment = Configuration.getPathToCatalogForTest("rejoin.xml");
config.m_isRejoinTest = true;
ServerThread localServer = new ServerThread(config);
localServer.start();
localServer.waitForInitialization();
Client client = ClientFactory.createClient();
client.createConnection("localhost");
SyncCallback scb = new SyncCallback();
success = false;
while (!success) {
success = client.callProcedure(scb, "@Rejoin", "localhost", config.m_internalPort + 1);
if (!success) Thread.sleep(100);
}
scb.waitForResponse();
ClientResponse response = scb.getResponse();
assertTrue(response.getStatusString().contains("Unable to find down node"));
client.close();
localServer.shutdown();
localServer.join();
}
@Test
public void testLoader() {
final VoltDB.Configuration configuration = new VoltDB.Configuration();
configuration.m_noLoadLibVOLTDB = true;
MockVoltDB mockvolt = new MockVoltDB();
VoltDB.replaceVoltDBInstanceForTest(mockvolt);
assert (EELibraryLoader.loadExecutionEngineLibrary(false));
// assertEquals(0, mockvolt.getCrashCount());
assert (EELibraryLoader.loadExecutionEngineLibrary(true));
// assertEquals(1, mockvolt.getCrashCount());
// VoltDB.initialize(configuration);
// assertFalse(EELibraryLoader.loadExecutionEngineLibrary(true));
// assertEquals(1, mockvolt.getCrashCount());
}
public void testRejoinPropogateAdminMode() throws Exception {
// Reset the VoltFile prefix that may have been set by previous tests in this suite
org.voltdb.utils.VoltFile.resetSubrootForThisProcess();
VoltProjectBuilder builder = getBuilderForTest();
builder.setSecurityEnabled(true);
LocalCluster cluster =
new LocalCluster("rejoin.jar", 2, 3, 1, BackendTarget.NATIVE_EE_JNI, true);
boolean success = cluster.compileWithAdminMode(builder, 9998, false);
assertTrue(success);
MiscUtils.copyFile(
builder.getPathToDeployment(), Configuration.getPathToCatalogForTest("rejoin.xml"));
cluster.setHasLocalServer(false);
cluster.startUp();
ClientResponse response;
Client client;
client = ClientFactory.createClient(m_cconfig);
client.createConnection("localhost", 9997);
response = client.callProcedure("@Pause");
assertEquals(ClientResponse.SUCCESS, response.getStatus());
client.close();
cluster.shutDownSingleHost(0);
Thread.sleep(100);
VoltDB.Configuration config = new VoltDB.Configuration();
config.m_pathToCatalog = Configuration.getPathToCatalogForTest("rejoin.jar");
config.m_pathToDeployment = Configuration.getPathToCatalogForTest("rejoin.xml");
config.m_rejoinToHostAndPort = m_username + ":" + m_password + "@localhost:9996";
config.m_isRejoinTest = true;
ServerThread localServer = new ServerThread(config);
localServer.start();
localServer.waitForInitialization();
Thread.sleep(1000);
assertTrue(VoltDB.instance().getMode() == OperationMode.PAUSED);
localServer.shutdown();
cluster.shutDown();
}
@Test
public void testLoader() {
VoltDB.Configuration configuration = new VoltDB.Configuration();
configuration.m_noLoadLibVOLTDB = true;
MockVoltDB mockvolt = new MockVoltDB();
VoltDB.ignoreCrash = true;
VoltDB.replaceVoltDBInstanceForTest(mockvolt);
mockvolt.m_noLoadLib = true;
assertFalse(EELibraryLoader.loadExecutionEngineLibrary(false));
assertFalse(VoltDB.wasCrashCalled);
boolean threw = false;
try {
assertFalse(EELibraryLoader.loadExecutionEngineLibrary(true));
} catch (AssertionError ae) {
threw = true;
}
assertTrue(threw);
assertTrue(VoltDB.wasCrashCalled);
VoltDB.wasCrashCalled = false;
VoltDB.initialize(configuration);
assertFalse(EELibraryLoader.loadExecutionEngineLibrary(true));
assertFalse(VoltDB.wasCrashCalled);
// Now test SUCCESS case
configuration = new VoltDB.Configuration();
VoltDBInterface mockitovolt = mock(VoltDBInterface.class);
VoltDBInterface realvolt = new RealVoltDB();
when(mockitovolt.getEELibraryVersionString()).thenReturn(realvolt.getEELibraryVersionString());
CatalogContext catContext = mock(CatalogContext.class);
Cluster cluster = mock(Cluster.class);
when(cluster.getVoltroot()).thenReturn(System.getProperty("java.io.tmpdir"));
when(catContext.getCluster()).thenReturn(cluster);
when(mockitovolt.getCatalogContext()).thenReturn(catContext);
VoltDB.replaceVoltDBInstanceForTest(mockitovolt);
VoltDB.initialize(configuration);
assertTrue(EELibraryLoader.loadExecutionEngineLibrary(true));
}
ServerThread startup() throws UnsupportedEncodingException {
String simpleSchema =
"create table cjk ("
+ "sval1 varchar(1024) not null, "
+ "sval2 varchar(1024) default 'foo', "
+ "sval3 varchar(1024) default 'bar', "
+ "PRIMARY KEY(sval1));";
/*String simpleSchema =
"create table cjk (" +
"sval1 varchar(20) not null, " +
"sval2 varchar(20) default 'foo', " +
"sval3 varchar(20) default 'bar', " +
"PRIMARY KEY(sval1));";*/
File schemaFile = VoltProjectBuilder.writeStringToTempFile(simpleSchema);
String schemaPath = schemaFile.getPath();
schemaPath = URLEncoder.encode(schemaPath, "UTF-8");
VoltProjectBuilder builder = new VoltProjectBuilder();
builder.addSchema(schemaPath);
builder.addPartitionInfo("cjk", "sval1");
builder.addStmtProcedure("Insert", "insert into cjk values (?,?,?);");
builder.addStmtProcedure("Select", "select * from cjk;");
builder.setHTTPDPort(8095);
boolean success = builder.compile(Configuration.getPathToCatalogForTest("cjk.jar"), 1, 1, 0);
assertTrue(success);
VoltDB.Configuration config = new VoltDB.Configuration();
config.m_pathToCatalog = Configuration.getPathToCatalogForTest("cjk.jar");
config.m_pathToDeployment = builder.getPathToDeployment();
ServerThread server = new ServerThread(config);
server.start();
server.waitForInitialization();
return server;
}
public void testBasicCreateStatementProc() throws Exception {
String pathToCatalog = Configuration.getPathToCatalogForTest("adhocddl.jar");
String pathToDeployment = Configuration.getPathToCatalogForTest("adhocddl.xml");
VoltProjectBuilder builder = new VoltProjectBuilder();
builder.addLiteralSchema(
"create table FOO ("
+ "ID integer not null,"
+ "VAL bigint, "
+ "constraint PK_TREE primary key (ID)"
+ ");\n"
+ "create table FOO_R ("
+ "ID integer not null,"
+ "VAL bigint, "
+ "constraint PK_TREE_R primary key (ID)"
+ ");\n");
builder.addPartitionInfo("FOO", "ID");
builder.setUseDDLSchema(true);
boolean success = builder.compile(pathToCatalog, 2, 1, 0);
assertTrue("Schema compilation failed", success);
MiscUtils.copyFile(builder.getPathToDeployment(), pathToDeployment);
VoltDB.Configuration config = new VoltDB.Configuration();
config.m_pathToCatalog = pathToCatalog;
config.m_pathToDeployment = pathToDeployment;
try {
startSystem(config);
// Procedure shouldn't exist
boolean threw = false;
assertFalse(findProcedureInSystemCatalog("FOOCOUNT"));
try {
m_client.callProcedure("FOOCOUNT", 1000L);
} catch (ProcCallException pce) {
assertTrue(pce.getMessage().contains("Procedure FOOCOUNT was not found"));
threw = true;
}
assertTrue("FOOCOUNT procedure shouldn't exist", threw);
try {
m_client.callProcedure(
"@AdHoc", "create procedure FOOCOUNT as select * from FOO where ID=?;");
} catch (ProcCallException pce) {
pce.printStackTrace();
fail("Should be able to create statement procedure");
}
assertTrue(findProcedureInSystemCatalog("FOOCOUNT"));
assertFalse(verifySinglePartitionProcedure("FOOCOUNT"));
// Make sure we can call it
try {
m_client.callProcedure("FOOCOUNT", 1000L);
} catch (ProcCallException pce) {
pce.printStackTrace();
fail("Should be able to call procedure FOOCOUNT");
}
// partition that sucker
try {
m_client.callProcedure(
"@AdHoc", "partition procedure FOOCOUNT on table FOO column ID parameter 0;");
} catch (ProcCallException pce) {
pce.printStackTrace();
fail("Should be able to partition the procedure FOOCOUNT");
}
// Make sure we can call it
assertTrue(verifySinglePartitionProcedure("FOOCOUNT"));
try {
m_client.callProcedure("FOOCOUNT", 1000L);
} catch (ProcCallException pce) {
pce.printStackTrace();
fail("Should be able to call procedure FOOCOUNT");
}
// now drop it
try {
m_client.callProcedure("@AdHoc", "drop procedure FOOCOUNT");
} catch (ProcCallException pce) {
pce.printStackTrace();
fail("Should be able to drop procedure FOOCOUNT");
}
assertFalse(findProcedureInSystemCatalog("FOOCOUNT"));
// Can't drop it twice
threw = false;
try {
m_client.callProcedure("@AdHoc", "drop procedure FOOCOUNT");
} catch (ProcCallException pce) {
pce.printStackTrace();
threw = true;
}
assertTrue("Can't vanilla drop procedure FOOCOUNT twice", threw);
// unless we use if exists
try {
m_client.callProcedure("@AdHoc", "drop procedure FOOCOUNT if exists");
} catch (ProcCallException pce) {
pce.printStackTrace();
fail("Should be able to drop procedure FOOCOUNT twice with if exists");
}
// Create it again so we can destroy it with drop with if exists, just to be sure
try {
m_client.callProcedure(
"@AdHoc", "create procedure FOOCOUNT as select * from FOO where ID=?;");
} catch (ProcCallException pce) {
pce.printStackTrace();
fail("Should be able to create statement procedure");
}
assertTrue(findProcedureInSystemCatalog("FOOCOUNT"));
// now drop it
try {
m_client.callProcedure("@AdHoc", "drop procedure FOOCOUNT if exists");
} catch (ProcCallException pce) {
pce.printStackTrace();
fail("Should be able to drop procedure FOOCOUNT");
}
assertFalse(findProcedureInSystemCatalog("FOOCOUNT"));
} finally {
teardownSystem();
}
}
public void testSimple() throws Exception {
String simpleSchema =
"create table BLAH ("
+ "IVAL bigint default 0 not null, "
+ "TVAL timestamp default null,"
+ "DVAL decimal default null,"
+ "PRIMARY KEY(IVAL));";
VoltProjectBuilder builder = new VoltProjectBuilder();
builder.addLiteralSchema(simpleSchema);
builder.addPartitionInfo("BLAH", "IVAL");
builder.addStmtProcedure("Insert", "insert into blah values (?, ?, ?);", null);
builder.addStmtProcedure(
"InsertWithDate",
"INSERT INTO BLAH VALUES (974599638818488300, '2011-06-24 10:30:26.002', 5);");
boolean success = builder.compile(Configuration.getPathToCatalogForTest("adhoc.jar"), 2, 1, 0);
assertTrue(success);
MiscUtils.copyFile(
builder.getPathToDeployment(), Configuration.getPathToCatalogForTest("adhoc.xml"));
VoltDB.Configuration config = new VoltDB.Configuration();
config.m_pathToCatalog = Configuration.getPathToCatalogForTest("adhoc.jar");
config.m_pathToDeployment = Configuration.getPathToCatalogForTest("adhoc.xml");
ServerThread localServer = new ServerThread(config);
localServer.start();
localServer.waitForInitialization();
// do the test
Client client = ClientFactory.createClient();
client.createConnection("localhost");
VoltTable modCount =
client.callProcedure("@AdHoc", "INSERT INTO BLAH VALUES (1, 1, 1);").getResults()[0];
assertTrue(modCount.getRowCount() == 1);
assertTrue(modCount.asScalarLong() == 1);
VoltTable result = client.callProcedure("@AdHoc", "SELECT * FROM BLAH;").getResults()[0];
assertTrue(result.getRowCount() == 1);
System.out.println(result.toString());
// test single-partition stuff
result = client.callProcedure("@AdHoc", "SELECT * FROM BLAH;", 0).getResults()[0];
assertTrue(result.getRowCount() == 0);
System.out.println(result.toString());
result = client.callProcedure("@AdHoc", "SELECT * FROM BLAH;", 1).getResults()[0];
assertTrue(result.getRowCount() == 1);
System.out.println(result.toString());
try {
client.callProcedure("@AdHoc", "INSERT INTO BLAH VALUES (0, 0, 0);", 1);
fail("Badly partitioned insert failed to throw expected exception");
} catch (Exception e) {
}
try {
client.callProcedure("@AdHoc", "SLEECT * FROOM NEEEW_OOORDERERER;");
fail("Bad SQL failed to throw expected exception");
} catch (Exception e) {
}
// try a huge bigint literal
modCount =
client.callProcedure(
"@AdHoc",
"INSERT INTO BLAH VALUES (974599638818488300, '2011-06-24 10:30:26.123012', 5);")
.getResults()[0];
modCount =
client.callProcedure(
"@AdHoc", "INSERT INTO BLAH VALUES (974599638818488301, '2011-06-24 10:30:28', 5);")
.getResults()[0];
assertTrue(modCount.getRowCount() == 1);
assertTrue(modCount.asScalarLong() == 1);
result =
client.callProcedure("@AdHoc", "SELECT * FROM BLAH WHERE IVAL = 974599638818488300;")
.getResults()[0];
assertTrue(result.getRowCount() == 1);
System.out.println(result.toString());
result =
client.callProcedure(
"@AdHoc", "SELECT * FROM BLAH WHERE TVAL = '2011-06-24 10:30:26.123012';")
.getResults()[0];
assertTrue(result.getRowCount() == 1);
System.out.println(result.toString());
result =
client.callProcedure("@AdHoc", "SELECT * FROM BLAH WHERE TVAL > '2011-06-24 10:30:25';")
.getResults()[0];
assertEquals(2, result.getRowCount());
System.out.println(result.toString());
result =
client.callProcedure("@AdHoc", "SELECT * FROM BLAH WHERE TVAL < '2011-06-24 10:30:27';")
.getResults()[0];
System.out.println(result.toString());
// We inserted a 1,1,1 row way earlier
assertEquals(2, result.getRowCount());
// try something like the queries in ENG-1242
try {
client.callProcedure(
"@AdHoc", "select * from blah; dfvsdfgvdf select * from blah WHERE IVAL = 1;");
fail("Bad SQL failed to throw expected exception");
} catch (Exception e) {
}
client.callProcedure("@AdHoc", "select\n* from blah;");
// try a decimal calculation (ENG-1093)
modCount =
client.callProcedure(
"@AdHoc", "INSERT INTO BLAH VALUES (2, '2011-06-24 10:30:26', 1.12345*1);")
.getResults()[0];
assertTrue(modCount.getRowCount() == 1);
assertTrue(modCount.asScalarLong() == 1);
result = client.callProcedure("@AdHoc", "SELECT * FROM BLAH WHERE IVAL = 2;").getResults()[0];
assertTrue(result.getRowCount() == 1);
System.out.println(result.toString());
localServer.shutdown();
localServer.join();
}
public void testRejoinDataTransfer() throws Exception {
System.out.println("testRejoinDataTransfer");
VoltProjectBuilder builder = getBuilderForTest();
builder.setSecurityEnabled(true);
LocalCluster cluster =
new LocalCluster("rejoin.jar", 2, 2, 1, BackendTarget.NATIVE_EE_JNI, true);
boolean success = cluster.compile(builder);
assertTrue(success);
MiscUtils.copyFile(
builder.getPathToDeployment(), Configuration.getPathToCatalogForTest("rejoin.xml"));
cluster.setHasLocalServer(false);
cluster.startUp();
ClientResponse response;
Client client;
client = ClientFactory.createClient(m_cconfig);
client.createConnection("localhost");
response = client.callProcedure("InsertSinglePartition", 0);
assertEquals(ClientResponse.SUCCESS, response.getStatus());
response = client.callProcedure("Insert", 1);
assertEquals(ClientResponse.SUCCESS, response.getStatus());
response = client.callProcedure("InsertReplicated", 0);
assertEquals(ClientResponse.SUCCESS, response.getStatus());
cluster.shutDownSingleHost(0);
Thread.sleep(1000);
VoltDB.Configuration config = new VoltDB.Configuration();
config.m_pathToCatalog = Configuration.getPathToCatalogForTest("rejoin.jar");
config.m_pathToDeployment = Configuration.getPathToCatalogForTest("rejoin.xml");
config.m_rejoinToHostAndPort = m_username + ":" + m_password + "@localhost:21213";
config.m_isRejoinTest = true;
ServerThread localServer = new ServerThread(config);
localServer.start();
localServer.waitForInitialization();
Thread.sleep(2000);
client.close();
client = ClientFactory.createClient(m_cconfig);
client.createConnection("localhost", 21213);
//
// Check that the recovery data transferred
//
response = client.callProcedure("SelectBlahSinglePartition", 0);
assertEquals(ClientResponse.SUCCESS, response.getStatus());
assertEquals(response.getResults()[0].fetchRow(0).getLong(0), 0);
response = client.callProcedure("SelectBlah", 1);
assertEquals(ClientResponse.SUCCESS, response.getStatus());
assertEquals(response.getResults()[0].fetchRow(0).getLong(0), 1);
response = client.callProcedure("SelectBlahReplicated", 0);
assertEquals(ClientResponse.SUCCESS, response.getStatus());
assertEquals(response.getResults()[0].fetchRow(0).getLong(0), 0);
//
// Try to insert new data
//
response = client.callProcedure("InsertSinglePartition", 2);
assertEquals(ClientResponse.SUCCESS, response.getStatus());
response = client.callProcedure("Insert", 3);
assertEquals(ClientResponse.SUCCESS, response.getStatus());
response = client.callProcedure("InsertReplicated", 1);
assertEquals(ClientResponse.SUCCESS, response.getStatus());
//
// See that it was inserted
//
response = client.callProcedure("SelectBlahSinglePartition", 2);
assertEquals(ClientResponse.SUCCESS, response.getStatus());
assertEquals(response.getResults()[0].fetchRow(0).getLong(0), 2);
response = client.callProcedure("SelectBlah", 3);
assertEquals(ClientResponse.SUCCESS, response.getStatus());
assertEquals(response.getResults()[0].fetchRow(0).getLong(0), 3);
response = client.callProcedure("SelectBlahReplicated", 1);
assertEquals(ClientResponse.SUCCESS, response.getStatus());
assertEquals(response.getResults()[0].fetchRow(0).getLong(0), 1);
//
// Kill one of the old ones (not the recovered partition)
//
cluster.shutDownSingleHost(1);
Thread.sleep(1000);
client.close();
client = ClientFactory.createClient(m_cconfig);
client.createConnection("localhost", 21212);
//
// See that the cluster is available and the data is still there.
//
response = client.callProcedure("SelectBlahSinglePartition", 2);
assertEquals(ClientResponse.SUCCESS, response.getStatus());
assertEquals(response.getResults()[0].fetchRow(0).getLong(0), 2);
response = client.callProcedure("SelectBlah", 3);
assertEquals(ClientResponse.SUCCESS, response.getStatus());
assertEquals(response.getResults()[0].fetchRow(0).getLong(0), 3);
response = client.callProcedure("SelectBlahReplicated", 1);
assertEquals(ClientResponse.SUCCESS, response.getStatus());
assertEquals(response.getResults()[0].fetchRow(0).getLong(0), 1);
client.close();
localServer.shutdown();
cluster.shutDown();
}
public void testRejoinWithExport() throws Exception {
VoltProjectBuilder builder = getBuilderForTest();
// builder.setTableAsExportOnly("blah", false);
// builder.setTableAsExportOnly("blah_replicated", false);
// builder.setTableAsExportOnly("PARTITIONED", false);
// builder.setTableAsExportOnly("PARTITIONED_LARGE", false);
builder.addExport(
"org.voltdb.export.processors.RawProcessor",
true, // enabled
null); // authGroups (off)
LocalCluster cluster =
new LocalCluster("rejoin.jar", 2, 3, 1, BackendTarget.NATIVE_EE_JNI, true);
boolean success = cluster.compile(builder);
assertTrue(success);
MiscUtils.copyFile(
builder.getPathToDeployment(), Configuration.getPathToCatalogForTest("rejoin.xml"));
cluster.setHasLocalServer(false);
cluster.startUp();
ClientResponse response;
Client client;
client = ClientFactory.createClient(m_cconfig);
client.createConnection("localhost");
response = client.callProcedure("InsertSinglePartition", 0);
assertEquals(ClientResponse.SUCCESS, response.getStatus());
response = client.callProcedure("Insert", 1);
assertEquals(ClientResponse.SUCCESS, response.getStatus());
response = client.callProcedure("InsertReplicated", 0);
assertEquals(ClientResponse.SUCCESS, response.getStatus());
client.close();
client = ClientFactory.createClient(m_cconfig);
client.createConnection("localhost", 21213);
response = client.callProcedure("InsertSinglePartition", 2);
assertEquals(ClientResponse.SUCCESS, response.getStatus());
response = client.callProcedure("Insert", 3);
assertEquals(ClientResponse.SUCCESS, response.getStatus());
client.close();
TrivialExportClient exportClient = new TrivialExportClient();
exportClient.work();
exportClient.work();
Thread.sleep(4000);
exportClient.work();
Thread.sleep(4000);
exportClient.work();
cluster.shutDownSingleHost(0);
Thread.sleep(100);
VoltDB.Configuration config = new VoltDB.Configuration();
config.m_pathToCatalog = Configuration.getPathToCatalogForTest("rejoin.jar");
config.m_pathToDeployment = Configuration.getPathToCatalogForTest("rejoin.xml");
config.m_rejoinToHostAndPort = m_username + ":" + m_password + "@localhost:21213";
config.m_isRejoinTest = true;
ServerThread localServer = new ServerThread(config);
localServer.start();
localServer.waitForInitialization();
Thread.sleep(1000);
while (VoltDB.instance().recovering()) {
Thread.sleep(100);
}
client = ClientFactory.createClient(m_cconfig);
client.createConnection("localhost");
response = client.callProcedure("InsertSinglePartition", 5);
assertEquals(ClientResponse.SUCCESS, response.getStatus());
response = client.callProcedure("Insert", 6);
assertEquals(ClientResponse.SUCCESS, response.getStatus());
response = client.callProcedure("InsertReplicated", 7);
assertEquals(ClientResponse.SUCCESS, response.getStatus());
client.close();
client = ClientFactory.createClient(m_cconfig);
client.createConnection("localhost", 21213);
response = client.callProcedure("InsertSinglePartition", 8);
assertEquals(ClientResponse.SUCCESS, response.getStatus());
response = client.callProcedure("Insert", 9);
assertEquals(ClientResponse.SUCCESS, response.getStatus());
client.close();
exportClient = new TrivialExportClient();
exportClient.work();
Thread.sleep(4000);
exportClient.work();
Thread.sleep(4000);
exportClient.work();
localServer.shutdown();
cluster.shutDown();
}
public void testRestoreThenRejoinPropagatesRestore() throws Exception {
System.out.println("testRestoreThenRejoinThenRestore");
VoltProjectBuilder builder = getBuilderForTest();
builder.setSecurityEnabled(true);
LocalCluster cluster =
new LocalCluster("rejoin.jar", 2, 2, 1, BackendTarget.NATIVE_EE_JNI, true);
ServerThread localServer = null;
try {
boolean success = cluster.compileWithAdminMode(builder, 9998, false);
assertTrue(success);
MiscUtils.copyFile(
builder.getPathToDeployment(), Configuration.getPathToCatalogForTest("rejoin.xml"));
cluster.setHasLocalServer(false);
cluster.startUp();
Client client;
client = ClientFactory.createClient(m_cconfig);
client.createConnection("localhost");
deleteTestFiles();
client.callProcedure("@SnapshotSave", TMPDIR, TESTNONCE, (byte) 1).getResults();
client.callProcedure("@SnapshotRestore", TMPDIR, TESTNONCE);
cluster.shutDownSingleHost(0);
Thread.sleep(1000);
VoltDB.Configuration config = new VoltDB.Configuration();
config.m_pathToCatalog = Configuration.getPathToCatalogForTest("rejoin.jar");
config.m_pathToDeployment = Configuration.getPathToCatalogForTest("rejoin.xml");
config.m_rejoinToHostAndPort = m_username + ":" + m_password + "@localhost:21213";
config.m_isRejoinTest = true;
localServer = new ServerThread(config);
localServer.start();
localServer.waitForInitialization();
Thread.sleep(2000);
client.close();
assertTrue(org.voltdb.sysprocs.SnapshotRestore.m_haveDoneRestore);
client = ClientFactory.createClient(m_cconfig);
client.createConnection("localhost");
// Also make sure a catalog update doesn't reset m_haveDoneRestore
File newCatalog = new File(Configuration.getPathToCatalogForTest("rejoin.jar"));
File deployment = new File(Configuration.getPathToCatalogForTest("rejoin.xml"));
VoltTable[] results = client.updateApplicationCatalog(newCatalog, deployment).getResults();
assertTrue(results.length == 1);
client.close();
assertTrue(org.voltdb.sysprocs.SnapshotRestore.m_haveDoneRestore);
} finally {
cluster.shutDown();
if (localServer != null) {
localServer.shutdown();
}
}
}
public void testRejoinWithMultipartLoad() throws Exception {
ExecutionSite.m_recoveryPermit.drainPermits();
ExecutionSite.m_recoveryPermit.release();
try {
System.out.println("testRejoinWithMultipartLoad");
VoltProjectBuilder builder = getBuilderForTest();
builder.setSecurityEnabled(true);
LocalCluster cluster =
new LocalCluster(
"rejoin.jar",
2,
2,
1,
BackendTarget.NATIVE_EE_JNI,
LocalCluster.FailureState.ALL_RUNNING,
true,
true);
boolean success = cluster.compile(builder);
assertTrue(success);
MiscUtils.copyFile(
builder.getPathToDeployment(), Configuration.getPathToCatalogForTest("rejoin.xml"));
cluster.setHasLocalServer(false);
cluster.startUp();
ClientResponse response;
Client client;
client = ClientFactory.createClient(m_cconfig);
client.createConnection("localhost", 21213);
response = client.callProcedure("InsertSinglePartition", 33);
assertEquals(ClientResponse.SUCCESS, response.getStatus());
response = client.callProcedure("Insert", 1);
assertEquals(ClientResponse.SUCCESS, response.getStatus());
response = client.callProcedure("InsertReplicated", 34);
assertEquals(ClientResponse.SUCCESS, response.getStatus());
cluster.shutDownSingleHost(0);
Thread.sleep(1000);
final Client clientForLoadThread = client;
final java.util.concurrent.atomic.AtomicBoolean shouldContinue =
new java.util.concurrent.atomic.AtomicBoolean(true);
Thread loadThread =
new Thread("Load Thread") {
@Override
public void run() {
try {
final long startTime = System.currentTimeMillis();
while (shouldContinue.get()) {
try {
clientForLoadThread.callProcedure(
new org.voltdb.client.ProcedureCallback() {
@Override
public void clientCallback(ClientResponse clientResponse)
throws Exception {
if (clientResponse.getStatus() != ClientResponse.SUCCESS) {
//
// System.err.println(clientResponse.getStatusString());
}
}
},
"@Statistics",
"MANAGEMENT",
1);
// clientForLoadThread.callProcedure("@Statistics", );
Thread.sleep(1);
final long now = System.currentTimeMillis();
if (now - startTime > 1000 * 10) {
break;
}
} catch (Exception e) {
e.printStackTrace();
break;
}
}
} finally {
try {
clientForLoadThread.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
};
loadThread.start();
Thread.sleep(2000);
ServerThread localServer = null;
try {
VoltDB.Configuration config = new VoltDB.Configuration();
config.m_pathToCatalog = Configuration.getPathToCatalogForTest("rejoin.jar");
config.m_pathToDeployment = Configuration.getPathToCatalogForTest("rejoin.xml");
config.m_rejoinToHostAndPort = m_username + ":" + m_password + "@localhost:21213";
config.m_isRejoinTest = true;
localServer = new ServerThread(config);
localServer.start();
localServer.waitForInitialization();
Thread.sleep(2000);
client = ClientFactory.createClient(m_cconfig);
client.createConnection("localhost", 21213);
//
// Check that the recovery data transferred
//
response = client.callProcedure("SelectBlahSinglePartition", 33);
assertEquals(ClientResponse.SUCCESS, response.getStatus());
assertEquals(response.getResults()[0].fetchRow(0).getLong(0), 33);
} finally {
shouldContinue.set(false);
}
response = client.callProcedure("SelectBlah", 1);
assertEquals(ClientResponse.SUCCESS, response.getStatus());
assertEquals(response.getResults()[0].fetchRow(0).getLong(0), 1);
response = client.callProcedure("SelectBlahReplicated", 34);
assertEquals(ClientResponse.SUCCESS, response.getStatus());
assertEquals(response.getResults()[0].fetchRow(0).getLong(0), 34);
//
// Try to insert new data
//
response = client.callProcedure("InsertSinglePartition", 2);
assertEquals(ClientResponse.SUCCESS, response.getStatus());
response = client.callProcedure("Insert", 3);
assertEquals(ClientResponse.SUCCESS, response.getStatus());
response = client.callProcedure("InsertReplicated", 1);
assertEquals(ClientResponse.SUCCESS, response.getStatus());
//
// See that it was inserted
//
response = client.callProcedure("SelectBlahSinglePartition", 2);
assertEquals(ClientResponse.SUCCESS, response.getStatus());
assertEquals(response.getResults()[0].fetchRow(0).getLong(0), 2);
response = client.callProcedure("SelectBlah", 3);
assertEquals(ClientResponse.SUCCESS, response.getStatus());
assertEquals(response.getResults()[0].fetchRow(0).getLong(0), 3);
response = client.callProcedure("SelectBlahReplicated", 1);
assertEquals(ClientResponse.SUCCESS, response.getStatus());
assertEquals(response.getResults()[0].fetchRow(0).getLong(0), 1);
//
// Kill one of the old ones (not the recovered partition)
//
cluster.shutDownSingleHost(1);
Thread.sleep(1000);
client.close();
client = ClientFactory.createClient(m_cconfig);
client.createConnection("localhost", 21212);
//
// See that the cluster is available and the data is still there.
//
response = client.callProcedure("SelectBlahSinglePartition", 2);
assertEquals(ClientResponse.SUCCESS, response.getStatus());
assertEquals(response.getResults()[0].fetchRow(0).getLong(0), 2);
response = client.callProcedure("SelectBlah", 3);
assertEquals(ClientResponse.SUCCESS, response.getStatus());
assertEquals(response.getResults()[0].fetchRow(0).getLong(0), 3);
response = client.callProcedure("SelectBlahReplicated", 1);
assertEquals(ClientResponse.SUCCESS, response.getStatus());
assertEquals(response.getResults()[0].fetchRow(0).getLong(0), 1);
client.close();
localServer.shutdown();
cluster.shutDown();
} finally {
ExecutionSite.m_recoveryPermit.drainPermits();
ExecutionSite.m_recoveryPermit.release(Integer.MAX_VALUE);
}
}
public void testBasic() throws Exception {
System.out.println("\n\n-----\n testBasic \n-----\n\n");
String pathToCatalog = Configuration.getPathToCatalogForTest("adhocddl.jar");
String pathToDeployment = Configuration.getPathToCatalogForTest("adhocddl.xml");
VoltProjectBuilder builder = new VoltProjectBuilder();
// Need to parallel dbuilder as we modify builder
DeploymentBuilder dbuilder = new DeploymentBuilder(2, 1, 0);
builder.addLiteralSchema(
"create table FOO ("
+ "ID integer not null,"
+ "VAL bigint, "
+ "constraint PK_TREE primary key (ID)"
+ ");\n"
+ "create table FOO_R ("
+ "ID integer not null,"
+ "VAL bigint, "
+ "constraint PK_TREE_R primary key (ID)"
+ ");\n");
builder.addPartitionInfo("FOO", "ID");
dbuilder.setUseDDLSchema(true);
// Use random caps in role names to check case-insensitivity
dbuilder.addUsers(
new DeploymentBuilder.UserInfo[] {
new DeploymentBuilder.UserInfo("admin", "admin", new String[] {"Administrator"})
});
dbuilder.setSecurityEnabled(true);
dbuilder.setEnableCommandLogging(false);
boolean success = builder.compile(pathToCatalog, 2, 1, 0);
assertTrue("Schema compilation failed", success);
dbuilder.writeXML(pathToDeployment);
// MiscUtils.copyFile(builder.getPathToDeployment(), pathToDeployment);
VoltDB.Configuration config = new VoltDB.Configuration();
config.m_pathToCatalog = pathToCatalog;
config.m_pathToDeployment = pathToDeployment;
try {
startServer(config);
ClientConfig adminConfig = new ClientConfig("admin", "admin");
Client adminClient = ClientFactory.createClient(adminConfig);
ClientConfig userConfig = new ClientConfig("user", "user");
Client userClient = ClientFactory.createClient(userConfig);
adminClient.createConnection("localhost");
// Can't connect a user which doesn't exist
boolean threw = false;
try {
userClient.createConnection("localhost");
} catch (IOException ioe) {
threw = true;
assertTrue(ioe.getMessage().contains("Authentication rejected"));
}
assertTrue("Connecting bad user should have failed", threw);
// Add the user with the new role
dbuilder.addUsers(new UserInfo[] {new UserInfo("user", "user", new String[] {"NEWROLE"})});
dbuilder.writeXML(pathToDeployment);
try {
adminClient.updateApplicationCatalog(null, new File(pathToDeployment));
} catch (ProcCallException pce) {
pce.printStackTrace();
fail("Should be able to add a user even with a role that doesn't exist");
}
// Check that we can connect the new user
try {
userClient.createConnection("localhost");
} catch (IOException ioe) {
ioe.printStackTrace();
fail("Should have been able to connect 'user'");
}
// Make sure the user doesn't actually have DEFAULTPROC permissions yet
threw = false;
try {
userClient.callProcedure("FOO.insert", 0, 0);
} catch (ProcCallException pce) {
pce.printStackTrace();
threw = true;
}
assertTrue("'user' shouldn't be able to call procedures yet", threw);
// Okay, it's showtime. Let's add the role through live DDL
try {
adminClient.callProcedure("@AdHoc", "create role NEWROLE with DEFAULTPROC");
} catch (ProcCallException pce) {
pce.printStackTrace();
fail("Creating role should have succeeded");
}
try {
adminClient.updateApplicationCatalog(null, new File(pathToDeployment));
} catch (ProcCallException pce) {
pce.printStackTrace();
fail("Adding 'user' should have succeeded this time");
}
// Make sure the user now has DEFAULTPROC permissions
try {
userClient.callProcedure("FOO.insert", 0, 0);
} catch (ProcCallException pce) {
pce.printStackTrace();
fail("'user' should be able to call default procs now");
}
threw = false;
try {
adminClient.callProcedure("@AdHoc", "create role NEWROLE with ALLPROC");
} catch (ProcCallException pce) {
assertTrue(pce.getMessage().contains("already exists"));
threw = true;
}
assertTrue("Shouldn't be able to 'create' same role twice", threw);
threw = false;
try {
// Use random caps in role names to check case-insensitivity
adminClient.callProcedure("@AdHoc", "create role aDministrator with ALLPROC");
} catch (ProcCallException pce) {
assertTrue(pce.getMessage().contains("already exists"));
threw = true;
}
assertTrue("Shouldn't be able to 'create' ADMINISTRATOR role", threw);
threw = false;
try {
adminClient.callProcedure("@AdHoc", "create role USER with ALLPROC");
} catch (ProcCallException pce) {
assertTrue(pce.getMessage().contains("already exists"));
threw = true;
}
assertTrue("Shouldn't be able to 'create' USER role", threw);
try {
adminClient.callProcedure("@AdHoc", "drop role NEWROLE;");
} catch (ProcCallException pce) {
pce.printStackTrace();
fail("Should be able to drop role NEWROLE");
}
// Can't drop twice
try {
adminClient.callProcedure("@AdHoc", "drop role NEWROLE;");
} catch (ProcCallException pce) {
pce.printStackTrace();
threw = true;
}
assertTrue("Can't vanilla DROP a role which doesn't exist", threw);
// unless you use IF EXISTS
try {
adminClient.callProcedure("@AdHoc", "drop role NEWROLE if exists;");
} catch (ProcCallException pce) {
pce.printStackTrace();
fail("Should be able to drop role NEWROLE if exists");
}
// Make sure the user doesn't actually have DEFAULTPROC permissions any more
threw = false;
try {
userClient.callProcedure("FOO.insert", 0, 0);
} catch (ProcCallException pce) {
pce.printStackTrace();
threw = true;
}
assertTrue("'user' shouldn't be able to call procedures yet", threw);
threw = false;
try {
adminClient.callProcedure("@AdHoc", "drop role USER;");
} catch (ProcCallException pce) {
threw = true;
assertTrue(pce.getMessage().contains("You may not drop the built-in role"));
pce.printStackTrace();
}
assertTrue("Shouldn't be able to drop role USER", threw);
// CHeck the administrator error message, there should end up being multiple
// reasons why we can't get rid of this role (like, we will require you to always
// have a user with this role)
threw = false;
try {
// Use random caps in role names to check case-insensitivity
adminClient.callProcedure("@AdHoc", "drop role adMinistrator;");
} catch (ProcCallException pce) {
threw = true;
assertTrue(pce.getMessage().contains("You may not drop the built-in role"));
pce.printStackTrace();
}
assertTrue("Shouldn't be able to drop role ADMINISTRATOR", threw);
// Make sure that we can't get rid of the administrator user
dbuilder.removeUser("admin");
dbuilder.writeXML(pathToDeployment);
threw = false;
try {
adminClient.updateApplicationCatalog(null, new File(pathToDeployment));
} catch (ProcCallException pce) {
pce.printStackTrace();
threw = true;
}
assertTrue("Shouldn't be able to remove the last remaining ADMINSTRATOR user", threw);
} finally {
teardownSystem();
}
}
