public void testInvalidCalls() throws Exception { System.out.println("\n\nTESTING INVALID CALLS\n\n\n"); Client client = getFullyConnectedClient(); // // invalid selector // try { // No selector at all. client.callProcedure("@Statistics"); fail(); } catch (ProcCallException ex) { // All badness gets turned into ProcCallExceptions, so we need // to check specifically for this error, otherwise things that // crash the cluster also turn into ProcCallExceptions and don't // trigger failure (ENG-2347) assertEquals( "Incorrect number of arguments to @Statistics (expects 2, received 0)", ex.getMessage()); } try { // extra stuff client.callProcedure("@Statistics", "table", 0, "OHHAI"); fail(); } catch (ProcCallException ex) { assertEquals( "Incorrect number of arguments to @Statistics (expects 2, received 3)", ex.getMessage()); } try { // Invalid selector client.callProcedure("@Statistics", "garbage", 0); fail(); } catch (ProcCallException ex) { } }
protected static void verifyProcFails( Client client, String expectedPattern, String storedProc, Object... args) throws IOException { String what; if (storedProc.compareTo("@AdHoc") == 0) { what = "the statement \"" + args[0] + "\""; } else { what = "the stored procedure \"" + storedProc + "\""; } try { client.callProcedure(storedProc, args); } catch (ProcCallException pce) { String msg = pce.getMessage(); String diagnostic = "Expected " + what + " to throw an exception matching the pattern \"" + expectedPattern + "\", but instead it threw an exception containing \"" + msg + "\"."; Pattern pattern = Pattern.compile(expectedPattern, Pattern.MULTILINE); assertTrue(diagnostic, pattern.matcher(msg).find()); return; } String diagnostic = "Expected " + what + " to throw an exception matching the pattern \"" + expectedPattern + "\", but instead it threw nothing."; fail(diagnostic); }
private void runAndCheck(boolean expectException) throws Exception { try { VoltTable[] results = m_env.m_client.callProcedure("@AdHoc", StringUtils.join(m_queries, "; ")).getResults(); int i = 0; assertEquals(m_expectedCounts.size(), results.length); for (String query : m_queries) { int expectedCount = m_expectedCounts.get(i); if (expectedCount >= 0) { String s = query.toLowerCase().trim(); if (!s.isEmpty()) { if (s.startsWith("insert") || s.startsWith("update") || s.startsWith("delete")) { assertEquals(String.format("%s (row count):", query), 1, results[i].getRowCount()); assertEquals( String.format("%s (result count):", query), expectedCount, results[i].asScalarLong()); } else { assertEquals( String.format("%s (row count):", query), expectedCount, results[i].getRowCount()); } i++; } } } } catch (ProcCallException e) { assertTrue("Unexpected exception for batch: " + e.getMessage(), expectException); } finally { m_queries.clear(); m_expectedCounts.clear(); } }
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 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(); } }