Example #1
0
  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());
  }
Example #3
0
  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();
  }
Example #4
0
  @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));
  }
Example #5
0
  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();
    }
  }
Example #7
0
  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();
  }
Example #8
0
  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();
  }
Example #9
0
  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();
  }
Example #10
0
  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();
      }
    }
  }
Example #11
0
  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);
    }
  }
Example #12
0
  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();
    }
  }