public static CommandStatuses fromFullStatuses(final Map<CommandId, CommandStatus> fullStatuses) { final Map<CommandId, CommandStatus.Status> statuses = fullStatuses.entrySet().stream().collect( Collectors.toMap(Map.Entry::getKey, entry -> entry.getValue().getStatus()) ); return new CommandStatuses(statuses); } }
@Override public int hashCode() { return Objects.hash(getStatus(), getMessage()); } }
@Override public boolean matches(final Object item) { return item instanceof CommandStatus && ((CommandStatus) item).getStatus().equals(status); }
@Test public void shoudlHandleTerminateRequestCorrectly() throws InterruptedException { // When: final Response response = ksqlResource.terminateCluster(VALID_TERMINATE_REQUEST); // Then: assertThat(response.getStatus(), equalTo(200)); assertThat(response.getEntity(), instanceOf(KsqlEntityList.class)); assertThat(((KsqlEntityList) response.getEntity()).size(), equalTo(1)); assertThat(((KsqlEntityList) response.getEntity()).get(0), instanceOf(CommandStatusEntity.class)); final CommandStatusEntity commandStatusEntity = (CommandStatusEntity) ((KsqlEntityList) response.getEntity()).get(0); assertThat(commandStatusEntity.getCommandStatus().getStatus(), equalTo(CommandStatus.Status.QUEUED)); verify(commandStore).enqueueCommand( eq(TerminateCluster.TERMINATE_CLUSTER_STATEMENT_TEXT), isA(Statement.class), any(), eq(Collections.singletonMap( ClusterTerminateRequest.DELETE_TOPIC_LIST_PROP, ImmutableList.of("Foo")))); }
@Test public void shouldRegisterBeforeDistributeAndReturnStatusOnGetNewCommands() { // Given: when(commandIdAssigner.getCommandId(any())).thenReturn(commandId); when(commandTopic.send(any(), any())).thenAnswer( invocation -> { final QueuedCommand queuedCommand = commandStore.getNewCommands().get(0); assertThat(queuedCommand.getCommandId(), equalTo(commandId)); assertThat(queuedCommand.getStatus().isPresent(), equalTo(true)); assertThat( queuedCommand.getStatus().get().getStatus().getStatus(), equalTo(CommandStatus.Status.QUEUED)); return recordMetadata; } ); // When: commandStore.enqueueCommand(statementText, statement, KSQL_CONFIG, OVERRIDE_PROPERTIES); // Then: verify(commandTopic).send(any(), any()); }
@Test public void shouldReturnStatusForSpecificCommand() { // When: final RestResponse<CommandStatus> response = ksqlRestClient.makeStatusRequest("TOPIC/c1/CREATE"); // Then: assertThat(response, is(notNullValue())); assertThat(response.isSuccessful(), is(true)); assertThat(response.getResponse().getStatus(), is(CommandStatus.Status.SUCCESS)); }
private void terminateQueries() { final Command terminateCommand1 = new Command( "TERMINATE CSAS_USER1PV_0;", Collections.emptyMap(), ksqlConfig.getAllConfigPropsWithSecretsObfuscated()); final CommandId terminateCommandId1 = new CommandId(CommandId.Type.STREAM, "_TerminateGen", CommandId.Action.CREATE); handleStatement( statementExecutor, terminateCommand1, terminateCommandId1, Optional.empty()); assertThat( getCommandStatus(terminateCommandId1).getStatus(), equalTo(CommandStatus.Status.SUCCESS)); final Command terminateCommand2 = new Command( "TERMINATE CTAS_TABLE1_1;", Collections.emptyMap(), ksqlConfig.getAllConfigPropsWithSecretsObfuscated()); final CommandId terminateCommandId2 = new CommandId(CommandId.Type.TABLE, "_TerminateGen", CommandId.Action.CREATE); handleStatement( statementExecutor, terminateCommand2, terminateCommandId2, Optional.empty()); assertThat( getCommandStatus(terminateCommandId2).getStatus(), equalTo(CommandStatus.Status.SUCCESS)); }
containsInAnyOrder(topicCommandId, csCommandId, csasCommandId, ctasCommandId, terminateCmdId)); assertThat(statusStore.get(topicCommandId).getStatus(), equalTo(CommandStatus.Status.SUCCESS)); assertThat(statusStore.get(csCommandId).getStatus(), equalTo(CommandStatus.Status.SUCCESS)); assertThat(statusStore.get(csasCommandId).getStatus(), equalTo(CommandStatus.Status.SUCCESS)); assertThat(statusStore.get(ctasCommandId).getStatus(), equalTo(CommandStatus.Status.ERROR)); assertThat(statusStore.get(terminateCmdId).getStatus(), equalTo(CommandStatus.Status.SUCCESS));
@Test public void shouldHandleCorrectDDLStatement() { final Command command = new Command("REGISTER TOPIC users_topic " + "WITH (value_format = 'json', kafka_topic='user_topic_json');", Collections.emptyMap(), ksqlConfig.getAllConfigPropsWithSecretsObfuscated()); final CommandId commandId = new CommandId(CommandId.Type.TOPIC, "_CorrectTopicGen", CommandId.Action.CREATE); handleStatement(command, commandId, Optional.empty()); final Map<CommandId, CommandStatus> statusStore = statementExecutor.getStatuses(); Assert.assertNotNull(statusStore); Assert.assertEquals(statusStore.size(), 1); Assert.assertEquals(statusStore.get(commandId).getStatus(), CommandStatus.Status.SUCCESS); }
@Test public void shouldHandlePriorStatements() { final TestUtils testUtils = new TestUtils(); final List<Pair<CommandId, Command>> priorCommands = testUtils.getAllPriorCommandRecords(); final CommandId topicCommandId = new CommandId(CommandId.Type.TOPIC, "_CSASTopicGen", CommandId.Action.CREATE); final CommandId csCommandId = new CommandId(CommandId.Type.STREAM, "_CSASStreamGen", CommandId.Action.CREATE); final CommandId csasCommandId = new CommandId(CommandId.Type.STREAM, "_CSASGen", CommandId.Action.CREATE); final CommandId ctasCommandId = new CommandId(CommandId.Type.TABLE, "_CTASGen", CommandId.Action.CREATE); priorCommands.forEach( pair -> statementExecutor.handleRestore( new QueuedCommand(pair.left, pair.right) ) ); final Map<CommandId, CommandStatus> statusStore = statementExecutor.getStatuses(); Assert.assertNotNull(statusStore); Assert.assertEquals(4, statusStore.size()); Assert.assertEquals(CommandStatus.Status.SUCCESS, statusStore.get(topicCommandId).getStatus()); Assert.assertEquals(CommandStatus.Status.SUCCESS, statusStore.get(csCommandId).getStatus()); Assert.assertEquals(CommandStatus.Status.SUCCESS, statusStore.get(csasCommandId).getStatus()); Assert.assertEquals(CommandStatus.Status.ERROR, statusStore.get(ctasCommandId).getStatus()); }
@Test public void shouldFailCreateAsSelectIfExceedActivePersistentQueriesLimit() { // Given: createStreamsAndStartTwoPersistentQueries(); // Prepare to try adding a third final KsqlConfig cmdConfig = givenCommandConfig(KsqlConfig.KSQL_ACTIVE_PERSISTENT_QUERY_LIMIT_CONFIG, 2); final Command csasCommand = givenCommand("CREATE STREAM user2pv AS select * from pageview;", cmdConfig); final CommandId csasCommandId = new CommandId(CommandId.Type.STREAM, "_CSASGen2", CommandId.Action.CREATE); // When: handleStatement(csasCommand, csasCommandId, Optional.empty()); // Then: final CommandStatus commandStatus = getCommandStatus(csasCommandId); assertThat("CSAS statement should fail since exceeds limit of 2 active persistent queries", commandStatus.getStatus(), is(CommandStatus.Status.ERROR)); assertThat( commandStatus.getMessage(), containsString("would cause the number of active, persistent queries " + "to exceed the configured limit")); }
@Test public void shouldHandleIncorrectDDLStatement() { final Command command = new Command("REGIST ER TOPIC users_topic " + "WITH (value_format = 'json', kafka_topic='user_topic_json');", Collections.emptyMap(), ksqlConfig.getAllConfigPropsWithSecretsObfuscated()); final CommandId commandId = new CommandId(CommandId.Type.TOPIC, "_IncorrectTopicGen", CommandId.Action.CREATE); handleStatement(command, commandId, Optional.empty()); final Map<CommandId, CommandStatus> statusStore = statementExecutor.getStatuses(); Assert.assertNotNull(statusStore); Assert.assertEquals(statusStore.size(), 1); Assert.assertEquals(statusStore.get(commandId).getStatus(), CommandStatus.Status.ERROR); }
@Test public void shouldFailInsertIntoIfExceedActivePersistentQueriesLimit() { // Given: createStreamsAndStartTwoPersistentQueries(); // Set limit and prepare to try adding a query that exceeds the limit final KsqlConfig cmdConfig = givenCommandConfig(KsqlConfig.KSQL_ACTIVE_PERSISTENT_QUERY_LIMIT_CONFIG, 1); final Command insertIntoCommand = givenCommand("INSERT INTO user1pv select * from pageview;", cmdConfig); final CommandId insertIntoCommandId = new CommandId(CommandId.Type.STREAM, "_InsertQuery1", CommandId.Action.CREATE); // When: handleStatement(insertIntoCommand, insertIntoCommandId, Optional.empty()); // Then: statement should fail since exceeds limit of 1 active persistent query final CommandStatus commandStatus = getCommandStatus(insertIntoCommandId); assertThat(commandStatus.getStatus(), is(CommandStatus.Status.ERROR)); assertThat( commandStatus.getMessage(), containsString("would cause the number of active, persistent queries " + "to exceed the configured limit")); }
private void printKsqlResponse(final RestResponse<KsqlEntityList> response) throws IOException { if (response.isSuccessful()) { final KsqlEntityList ksqlEntities = response.getResponse(); boolean noErrorFromServer = true; for (final KsqlEntity entity : ksqlEntities) { if (entity instanceof CommandStatusEntity && ( ((CommandStatusEntity) entity).getCommandStatus().getStatus() == CommandStatus.Status.ERROR) ) { final String fullMessage = ((CommandStatusEntity) entity).getCommandStatus().getMessage(); terminal.printError(fullMessage.split("\n")[0], fullMessage); noErrorFromServer = false; } } if (noErrorFromServer) { terminal.printKsqlEntityList(response.getResponse()); } } else { terminal.printErrorMessage(response.getErrorMessage()); } }
handleStatement(ctasCommand, ctasCommandId, Optional.empty()); assertThat(getCommandStatus(csCommandId).getStatus(), equalTo(CommandStatus.Status.SUCCESS)); assertThat(getCommandStatus(csasCommandId).getStatus(), equalTo(CommandStatus.Status.SUCCESS)); assertThat(getCommandStatus(ctasCommandId).getStatus(), equalTo(CommandStatus.Status.SUCCESS));
assertThat(dropStreamCommandStatus1.get().getStatus(), CoreMatchers.equalTo(CommandStatus.Status.ERROR)); assertThat( assertThat(dropStreamCommandStatus2.get().getStatus(), CoreMatchers.equalTo(CommandStatus.Status.ERROR)); assertThat( assertThat(dropTableCommandStatus1.get().getStatus(), CoreMatchers.equalTo(CommandStatus.Status.ERROR)); assertThat(
private static void runStatement(final String statement, final KsqlRestClient restClient) { final RestResponse response = restClient.makeKsqlRequest(statement); Assert.assertThat(response.isSuccessful(), is(true)); final KsqlEntityList entityList = ((KsqlEntityList) response.get()); Assert.assertThat(entityList.size(), equalTo(1)); Assert.assertThat(entityList.get(0), instanceOf(CommandStatusEntity.class)); final CommandStatusEntity entity = (CommandStatusEntity) entityList.get(0); final CommandStatus status = entity.getCommandStatus(); Assert.assertThat(status, not(CommandStatus.Status.ERROR)); if (status.getStatus() != Status.SUCCESS) { assertThatEventually( "", () -> { final RestResponse statusResponse = restClient .makeStatusRequest(entity.getCommandId().toString()); Assert.assertThat(statusResponse.isSuccessful(), is(true)); Assert.assertThat(statusResponse.get(), instanceOf(CommandStatus.class)); return ((CommandStatus) statusResponse.get()).getStatus(); }, anyOf( is(CommandStatus.Status.SUCCESS), is(CommandStatus.Status.TERMINATED), is(CommandStatus.Status.ERROR)), 120, TimeUnit.SECONDS ); } }