private synchronized LensClient getClient() { if (lensClient == null) { lensClient = new LensClient(); } return lensClient; }
@Override public void close() { closeConnection(); } }
/** * API for non blocking use. * * @param query the query * @return the query handle * @throws LensAPIException the lens exception */ public QueryHandle createLensRDDAsync(String query) throws LensAPIException { return getClient().executeQueryAsynch(query, ""); }
/** * Test client creation. */ @Test public void testClientCreation() { LensClient client = null; try { client = new LensClient(); } catch (Throwable t) { Assert.fail("Client should have been able to create a connection to server"); } finally { if (client != null) { client.closeConnection(); } } }
private LensQueryCommands setupQueryCommands(boolean withMetrics) throws Exception { LensClient client = new LensClient(); client.setConnectionParam("lens.query.enable.persistent.resultset.indriver", "false"); if (withMetrics) { client.setConnectionParam("lens.query.enable.metrics.per.query", "true"); } LensQueryCommands qCom = new LensQueryCommands(); qCom.setClient(client); return qCom; }
@Test public void testProxyLensQuery() throws Exception { LensClient client = new LensClient(); QueryHandle handle = client.executeQueryAsynch("cube select id,name from test_dim", "proxyTestQuery", new LensConf()); client.getStatement().waitForQueryToComplete(handle); LensQuery query = client.getQueryDetails(handle); ProxyLensQuery proxyQuery = new ProxyLensQuery(client.getStatement(), handle); Assert.assertEquals(query.getStatus().successful(), proxyQuery.getStatus().successful()); Assert.assertEquals(query.getSubmissionTime(), proxyQuery.getSubmissionTime()); ProxyLensQuery proxyQuery2 = new ProxyLensQuery(client.getStatement(), handle); Assert.assertEquals(proxyQuery, proxyQuery2); Assert.assertEquals(proxyQuery, query); Assert.assertEquals(proxyQuery.hashCode(), query.hashCode()); client.closeConnection();
QueryHandle queryHandle = getClient().executeQueryAsynch(sql, queryName, new LensConf()); return queryHandle.getHandleIdString(); } else { LensClientResultSetWithStats resultWithStats; long timeOutMillis = getClient().getConf().getLong(LensCliConfigConstants.QUERY_EXECUTE_TIMEOUT_MILLIS, LensCliConfigConstants.DEFAULT_QUERY_EXECUTE_TIMEOUT_MILLIS); LensClient.getCliLogger().info("Executing query with timeout of {} milliseconds", timeOutMillis); QueryHandleWithResultSet result = getClient().executeQueryWithTimeout(sql, queryName, timeOutMillis, new LensConf()); if (result.getResult() == null) { LensClient.getCliLogger().info("Couldn't complete query execution within timeout. Waiting for completion"); resultWithStats = getClient().getSyncResults(result.getQueryHandle()); } else { LensClientResultSet clientResultSet = new LensClientResultSet(result.getResultMetadata(), result.getResult()); resultWithStats = new LensClientResultSetWithStats(clientResultSet, getClient().getQueryDetails(result.getQueryHandle()));
super.setUp(); client = new LensClient(createLensClientConfigWithServerUrl()); client.createDatabase(TEST_DB, true); assertTrue(client.setDatabase(TEST_DB)); APIResult result = client.createCube("target/test-classes/sample-cube.xml"); assertEquals(result.getStatus(), APIResult.Status.SUCCEEDED); result = client.createStorage("target/test-classes/local-storage.xml"); assertEquals(result.getStatus(), APIResult.Status.SUCCEEDED); result = client.createDimension("target/test-classes/test-dimension.xml"); assertEquals(result.getStatus(), APIResult.Status.SUCCEEDED); result = client.createDimension("target/test-classes/test-detail.xml"); assertEquals(result.getStatus(), APIResult.Status.SUCCEEDED); result = client.createDimensionTable("target/test-classes/dim_table.xml"); assertEquals(result.getStatus(), APIResult.Status.SUCCEEDED); timePart.getPartSpecElement().add(partElement); xp.setTimePartitionSpec(timePart); result = client.addPartitionToDim("dim_table", "local", xp); assertEquals(result.getStatus(), APIResult.Status.SUCCEEDED);
@Test public void testWaitForQueryToCompleteWithAndWithoutRetryOnTimeOut() throws LensAPIException { LensClientConfig config = createLensClientConfigWithServerUrl(); config.set(ENABLE_SLEEP_FOR_GET_QUERY_OP, "true"); config.setInt(LensClientConfig.READ_TIMEOUT_MILLIS, 3000); try (LensClient lensClient = new LensClient(config)) { assertTrue(lensClient.setDatabase(TEST_DB)); //Test waitForQueryToComplete without retry on timeout QueryHandle handle = lensClient.executeQueryAsynch("cube select id,name from test_dim", "test3", new LensConf()); try { lensClient.getStatement().waitForQueryToComplete(handle, false); fail("SocketTimeoutException was expected"); } catch (Exception e) { if (!isExceptionDueToSocketTimeout(e)) { fail("SocketTimeoutException was excepted as part of Read Timeout"); } } //Test waitForQueryToComplete with Retry on timeout handle = lensClient.executeQueryAsynch("cube select id,name from test_dim", "test3", new LensConf()); lensClient.getStatement().waitForQueryToComplete(handle); LensQuery query = lensClient.getQueryDetails(handle); assertTrue(query.getStatus().successful()); } }
@Test(dataProvider = "testIterableHttpResultSetDP") public void testHttpResultSet(String query, Map<String, String> queryConf, boolean isResultZipped, int columnNamesExpected, int rowsExpected) throws Exception { for (Map.Entry<String, String> e : queryConf.entrySet()) { client.setConnectionParam(e.getKey(), e.getValue()); } LensConf conf = new LensConf(); Map<String, String> confProps = new HashMap<>(); confProps.put("custom.property.for.validation", "present"); conf.addProperties(confProps); QueryHandle handle = client.executeQueryAsynch(query, "testQuery", conf); client.getStatement().waitForQueryToComplete(handle); assertTrue(client.getStatement().wasQuerySuccessful()); LensQuery persistedQuery = client.getQueryDetails(handle); Assert.assertNotNull(persistedQuery.getQueryConf()); Assert.assertEquals(persistedQuery.getQueryConf().getProperty("custom.property.for.validation"), "present"); ResultSet result = null; boolean isHeaderRowPresent = columnNamesExpected > 0 ? true : false; result = client.getHttpResultSet(handle); assertNotNull(result); validateResult(result, columnNamesExpected, rowsExpected); }
@Test public void testTimeout() throws LensAPIException { LensClientConfig config = createLensClientConfigWithServerUrl(); LensClient lensClient = new LensClient(config); assertTrue(lensClient.setDatabase(TEST_DB)); try { // Setting very small timeout. Expecting timeouts after this // Note: Timeout values can be changed even after LensClient has been created. config.setInt(LensClientConfig.READ_TIMEOUT_MILLIS, 200); lensClient.executeQueryWithTimeout("cube select id,name from test_dim", "test1", 100000, new LensConf()); fail("Read Timeout was expected"); } catch (Exception e) { if (!(isExceptionDueToSocketTimeout(e))) { log.error("Unexpected Exception", e); fail("SocketTimeoutException was excepted as part of Read Timeout"); } else { log.debug("Expected Exception", e); } } //Setting back default timeout. Not expecting timeouts after this config.setInt(LensClientConfig.READ_TIMEOUT_MILLIS, LensClientConfig.DEFAULT_READ_TIMEOUT_MILLIS); QueryHandleWithResultSet result = lensClient.executeQueryWithTimeout("cube select id,name from test_dim", "test2", 100000, new LensConf()); assertTrue(result.getStatus().successful()); lensClient.closeConnection(); }
/** * Creates a new client and tests database creation and deletion */ @Test public void testClient() throws Exception { LensClientConfig lensClientConfig = createLensClientConfigWithServerUrl(); lensClientConfig.setLensDatabase(TEST_DB); Assert.assertEquals(lensClientConfig.getLensDatabase(), TEST_DB); try (LensClient client = new LensClient(lensClientConfig)) { Assert.assertEquals(client.getCurrentDatabae(), TEST_DB, "current database"); client.createDatabase("testclientdb", true); Assert.assertTrue(client.getAllDatabases().contains("testclientdb")); client.dropDatabase("testclientdb", false); Assert.assertFalse(client.getAllDatabases().contains("testclientdb")); Assert.assertTrue(RequestTestFilter.isAccessed(), "RequestTestFilter not invoked"); } }
@DataProvider(name = "executeSyncQueryDP") private Object[][] executeSyncQueryDP() { LensClient client1 = new LensClient(); client1.setConnectionParam("lens.query.enable.persistent.resultset.indriver", "false"); client1.setConnectionParam("lens.query.enable.persistent.resultset", "false"); client1.setConnectionParam("lens.query.enable.metrics.per.query", "true"); client1.getConf().setLong(LensCliConfigConstants.QUERY_EXECUTE_TIMEOUT_MILLIS, 100); LensQueryCommands qCom1 = new LensQueryCommands(); qCom1.setClient(client1); LensClient client2 = new LensClient(); client2.setConnectionParam("lens.query.enable.persistent.resultset.indriver", "false"); client2.setConnectionParam("lens.query.enable.persistent.resultset", "true"); client2.getConf().setLong(LensCliConfigConstants.QUERY_EXECUTE_TIMEOUT_MILLIS, 20000); LensQueryCommands qCom2 = new LensQueryCommands(); qCom2.setClient(client2); LensClient client3 = new LensClient(); client3.setConnectionParam("lens.query.enable.persistent.resultset.indriver", "false"); client3.setConnectionParam("lens.query.enable.persistent.resultset", "true"); client3.setConnectionParam(LensConfConstants.QUERY_OUTPUT_FORMATTER, DeferredInMemoryResultFormatter.class.getName()); client3.setConnectionParam("deferPersistenceByMillis", "5000"); // property used for test only client3.getConf().setLong(LensCliConfigConstants.QUERY_EXECUTE_TIMEOUT_MILLIS, 20000); LensQueryCommands qCom3 = new LensQueryCommands(); qCom3.setClient(client3);
/** * Test CLI command to get session handle */ @Test public void testGetSessionHandle() { LensConnectionCommands commands = new LensConnectionCommands(); try (LensClient client = new LensClient()) { commands.setClient(client); LensSessionHandle sessionHandle = client.getConnection().getSessionHandle(); Assert.assertNotNull(sessionHandle); String output = commands.getSessionHandle(); Assert.assertTrue(output.contains(sessionHandle.getPublicId().toString()), "session handle output: " + output); } } }
public LensMLClient(LensClient lensClient) { client = new LensMLJerseyClient(lensClient.getConnection(), lensClient .getConnection().getSessionHandle()); }
public QueryStatus getQueryStatus(String q) { return getQueryStatus(QueryHandle.fromString(q)); }
/** * Sets up query command instances and adds partitions to a table. * @throws Exception */ @BeforeClass public void setup() throws Exception { LensClient client = new LensClient(); LensCubeCommands command = new LensCubeCommands(); command.setClient(client); log.debug("Starting to test cube commands"); URL cubeSpec = TestLensQueryCommands.class.getClassLoader().getResource("schema/cubes/base/sample-cube.xml"); command.createCube(new File(cubeSpec.toURI())); TestLensDimensionCommands.createDimension(); TestLensDimensionTableCommands.addDim1Table("dim_table", "schema/dimtables/dim_table.xml", "local"); // Add partition URL dataDir = TestLensQueryCommands.class.getClassLoader().getResource("dim2-part"); XPartition xp = new XPartition(); xp.setFactOrDimensionTableName("dim_table"); xp.setLocation(new Path(dataDir.toURI()).toString()); xp.setUpdatePeriod(XUpdatePeriod.HOURLY); XTimePartSpec timePart = new XTimePartSpec(); XTimePartSpecElement partElement = new XTimePartSpecElement(); partElement.setKey("dt"); partElement.setValue(DatatypeFactory.newInstance().newXMLGregorianCalendar(new GregorianCalendar())); timePart.getPartSpecElement().add(partElement); xp.setTimePartitionSpec(timePart); APIResult result = client.addPartitionToDim("dim_table", "local", xp); assertEquals(result.getStatus(), APIResult.Status.SUCCEEDED); }
/** * Test purged finished result set. * * @param qCom the q com */ @Test(dataProvider = "queryCommands") public void purgedFinishedResultSet(LensQueryCommands qCom) throws InterruptedException { System.out.println("@@START_FINISHED_PURGED_RESULT_TEST-------------"); qCom.getClient().setConnectionParam("lens.query.enable.persistent.resultset", "true"); String query = "cube select id,name from test_dim"; String qh = qCom.executeQuery(query, true, "testQuery"); while (!qCom.getClient().getQueryStatus(qh).finished()) { Thread.sleep(100); } assertTrue(qCom.getStatus(qh).contains("Status: SUCCESSFUL")); String result = qCom.getQueryResults(qh, null, true); System.out.println("@@ RESULT " + result); assertNotNull(result); // This is to check for positive processing time assertFalse(result.contains("(-")); System.out.println("@@END_FINISHED_PURGED_RESULT_TEST-------------"); qCom.getClient().setConnectionParam("lens.query.enable.persistent.resultset", "false"); closeClientConnection(qCom); }
public LensQuery getQueryDetails(String handle) { return getQueryDetails(QueryHandle.fromString(handle)); }
/** * Test show persistent result set. * * @param qCom the q com * @throws Exception the exception */ @Test(dataProvider = "queryCommands") public void showPersistentResultSet(LensQueryCommands qCom) throws Exception { System.out.println("@@PERSISTENT_RESULT_TEST-------------"); qCom.getClient().setConnectionParam("lens.query.enable.persistent.resultset", "true"); qCom.getClient().setConnectionParam("lens.query.prefetch.inmemory.resultset", "false"); String query = "cube select id,name from test_dim"; try { String result = qCom.executeQuery(query, false, "testQuery3"); System.out.println("@@ RESULT " + result); assertNotNull(result); assertFalse(result.contains("Failed to get resultset")); } catch (Exception exc) { log.error("Exception not expected while getting resultset.", exc); fail("Exception not expected: " + exc.getMessage()); } //Downlaod once downloadResult(qCom, qCom.getClient().getStatement().getQueryHandleString(), "testQuery3", "\"1\",\"first\""); //Download Again downloadResult(qCom, qCom.getClient().getStatement().getQueryHandleString(), "testQuery3", "\"1\",\"first\""); System.out.println("@@END_PERSISTENT_RESULT_TEST-------------"); qCom.getClient().setConnectionParam("lens.query.enable.persistent.resultset.indriver", "false"); closeClientConnection(qCom); }