How to use

KieServerIntegration

in

org.jbpm.workbench.ks.integration

  protected KieServicesClient getKieServicesClient(final String serverTemplateId) {
    KieServicesClient client = kieServerIntegration.getServerClient(serverTemplateId);
    if (client == null) {
      throw new RuntimeException("No connection to '" + serverTemplateId + "' server(s)");
    }
    return client;
  }
}

long elapsed = 0;
try {
  QueryServicesClient queryClient = kieServerIntegration.getAdminServerClient(serverTemplateId, serverInstanceId).getServicesClient(QueryServicesClient.class);
      elapsed += 500;
      queryClient = kieServerIntegration.getAdminServerClientCheckEndpoints(serverTemplateId).getServicesClient(QueryServicesClient.class);
      LOGGER.debug("Cannot reach KIE Server, elapsed time while waiting '{}', max time '{}' error {}",
             elapsed,

public void onServerTemplateUpdated(@Observes ServerTemplateUpdated serverTemplateUpdated) {
  buildClientsForServer(serverTemplateUpdated.getServerTemplate());
}

kieServerIntegration.onServerInstanceConnected(new ServerInstanceConnected(serverInstance2));
       kieServerIntegration.getServerTemplatesClients().size());
assertNotNull(kieServerIntegration.getServerTemplatesClients().get(serverTemplateId));
assertEquals(2,
       kieServerIntegration.getServerTemplatesClients().get(serverTemplateId).size());
assertNotNull(kieServerIntegration.getServerTemplatesClients().get(serverTemplateId).get(SERVER_TEMPLATE_KEY));
assertNotNull(kieServerIntegration.getServerTemplatesClients().get(serverTemplateId).get(containerSpec.getId()));
assertNotNull(kieServerIntegration.getServerClient(serverTemplateId, "not-existing"));
assertEquals(kieServerIntegration.getServerTemplatesClients().get(serverTemplateId).get(SERVER_TEMPLATE_KEY),
       kieServerIntegration.getServerClient(serverTemplateId, "not-existing"));
assertEquals(1,
       kieServerIntegration.getServerInstancesById().size());
assertNotNull(kieServerIntegration.getServerInstancesById().get(serverInstanceId2));
kieServerIntegration.onServerInstanceConnected(new ServerInstanceConnected(serverInstance1));
       kieServerIntegration.getServerTemplatesClients().size());
assertNotNull(kieServerIntegration.getServerTemplatesClients().get(serverTemplateId));
assertEquals(2,
       kieServerIntegration.getServerTemplatesClients().get(serverTemplateId).size());
assertNotNull(kieServerIntegration.getServerTemplatesClients().get(serverTemplateId).get(SERVER_TEMPLATE_KEY));
assertNotNull(kieServerIntegration.getServerTemplatesClients().get(serverTemplateId).get(containerSpec.getId()));
assertEquals(2,
       kieServerIntegration.getServerInstancesById().size());
assertNotNull(kieServerIntegration.getServerInstancesById().get(serverInstanceId1));
kieServerIntegration.onServerInstanceDisconnected(new ServerInstanceDisconnected(serverInstanceId1));

void onDataSetDefRemovedEvent(@Observes DataSetDefRemovedEvent event) {
  checkNotNull("event",
         event);
  DataSetDef def = event.getDataSetDef();
  if (def instanceof RemoteDataSetDef) {
    kieServerIntegration.broadcastToKieServers(((RemoteDataSetDef) def).getServerTemplateId(), (KieServicesClient client) -> {
      QueryServicesClient instanceQueryClient = client.getServicesClient(QueryServicesClient.class);
      instanceQueryClient.unregisterQuery(def.getUUID());
      return null;
    });
    
    LOGGER.info("Data set definition {} ({}) deletion event processed", def.getUUID(), def.getName());
  }
  
}    

@Before
public void setup() {
  this.dataSetDefRegistry = Mockito.mock(DataSetDefRegistry.class);
  this.kieServerIntegration = Mockito.mock(KieServerIntegration.class);
  this.event = new EventSourceMock<KieServerDataSetRegistered>() {
    @Override
    public void fire(KieServerDataSetRegistered event) {
      receivedEvents.add(event);
    }
  };
  this.kieClient = Mockito.mock(KieServicesClient.class);
  this.queryClient = Mockito.mock(QueryServicesClient.class);
  when(kieClient.getServicesClient(any())).thenReturn(queryClient);
  when(kieServerIntegration.getAdminServerClient(anyString(),
                          anyString())).thenReturn(kieClient);
  ExecutorService executorService = Executors.newCachedThreadPool(new DescriptiveThreadFactory());
  this.kieServerDataSetManager = new KieServerDataSetManager(dataSetDefRegistry,
                                kieServerIntegration,
                                event,
                                executorService,
                                specManagementService);
}

providers.add(provider);
kieServerIntegration.setKieServicesClientProviders(providers);
kieServerIntegration.broadcastToKieServers(serverTemplateId, operation);

kieServerIntegration.onServerInstanceConnected(new ServerInstanceConnected(serverInstance2));
       kieServerIntegration.getServerTemplatesClients().size());
assertNotNull(kieServerIntegration.getServerTemplatesClients().get(serverTemplateId));
assertEquals(2,
       kieServerIntegration.getServerTemplatesClients().get(serverTemplateId).size());
assertNotNull(kieServerIntegration.getServerTemplatesClients().get(serverTemplateId).get(SERVER_TEMPLATE_KEY));
assertNotNull(kieServerIntegration.getServerTemplatesClients().get(serverTemplateId).get(containerSpec.getId()));
assertNotNull(kieServerIntegration.getServerClient(serverTemplateId, "not-existing"));
assertEquals(kieServerIntegration.getServerTemplatesClients().get(serverTemplateId).get(SERVER_TEMPLATE_KEY),
       kieServerIntegration.getServerClient(serverTemplateId, "not-existing"));
assertEquals(1,
       kieServerIntegration.getServerInstancesById().size());
assertNotNull(kieServerIntegration.getServerInstancesById().get(serverInstanceId2));
kieServerIntegration.onServerInstanceConnected(new ServerInstanceConnected(serverInstance1));
       kieServerIntegration.getServerTemplatesClients().size());
assertNotNull(kieServerIntegration.getServerTemplatesClients().get(serverTemplateId));
assertEquals(2,
       kieServerIntegration.getServerTemplatesClients().get(serverTemplateId).size());
assertNotNull(kieServerIntegration.getServerTemplatesClients().get(serverTemplateId).get(SERVER_TEMPLATE_KEY));
assertNotNull(kieServerIntegration.getServerTemplatesClients().get(serverTemplateId).get(containerSpec.getId()));
assertEquals(2,
       kieServerIntegration.getServerInstancesById().size());
assertNotNull(kieServerIntegration.getServerInstancesById().get(serverInstanceId1));
kieServerIntegration.onServerInstanceDisconnected(new ServerInstanceDisconnected(serverInstanceId1));

@Test
public void testPerformQueryRegularMode() {
  QueryFilterSpec filterSpec = new QueryFilterSpec();
  
  ConsoleDataSetLookup dataSetLookup = Mockito.mock(ConsoleDataSetLookup.class);
  when(dataSetLookup.testMode()).thenReturn(false);
  when(dataSetLookup.getNumberOfRows()).thenReturn(10);
  when(dataSetLookup.getRowOffset()).thenReturn(1);
  when(dataSetLookup.getDataSetUUID()).thenReturn("");
  
  kieServerDataSetProvider.performQuery(dataSetDef, dataSetLookup, queryServicesClient, filterSpec);
  
  verify(kieServerIntegration, times(0)).broadcastToKieServers(anyString(),
                            any());
  verify(dataSetLookup, times(1)).testMode();
  
  verify(queryServicesClient).query(anyString(),
                   anyString(),
                   any(QueryFilterSpec.class),
                   anyInt(),
                   anyInt(),
                   any());
}    

@Before
public void setup() {
  this.dataSetDefRegistry = Mockito.mock(DataSetDefRegistry.class);
  this.kieServerIntegration = Mockito.mock(KieServerIntegration.class);
  this.event = new EventSourceMock<KieServerDataSetRegistered>() {
    @Override
    public void fire(KieServerDataSetRegistered event) {
      receivedEvents.add(event);
    }
  };
  this.kieClient = Mockito.mock(KieServicesClient.class);
  this.queryClient = Mockito.mock(QueryServicesClient.class);
  when(kieClient.getServicesClient(any())).thenReturn(queryClient);
  when(kieServerIntegration.getAdminServerClient(anyString(),
                          anyString())).thenReturn(kieClient);
  ExecutorService executorService = Executors.newCachedThreadPool(new DescriptiveThreadFactory());
  this.kieServerDataSetManager = new KieServerDataSetManager(dataSetDefRegistry,
                                kieServerIntegration,
                                event,
                                executorService,
                                specManagementService);
}

providers.add(provider);
kieServerIntegration.setKieServicesClientProviders(providers);
kieServerIntegration.broadcastToKieServers(serverTemplateId, operation);

protected KieServicesClient getKieServicesClient(final String serverTemplateId) {
  KieServicesClient client = kieServerIntegration.getServerClient(serverTemplateId);
  if (client == null) {
    throw new RuntimeException("No connection to '" + serverTemplateId + "' server(s)");
  }
  return client;
}

private void registerQueriesWithRetryException(Exception exception) throws Exception {
  QueryDefinition query = QueryDefinition.builder().name("test").expression("expression").source("jbpm").target("CUSTOM").build();
  Set<QueryDefinition> definitions = new HashSet<>();
  definitions.add(query);
  KieServicesClient kieClientRecreated = Mockito.mock(KieServicesClient.class);
  QueryServicesClient queryClientRecreated = Mockito.mock(QueryServicesClient.class);
  when(kieClientRecreated.getServicesClient(any())).thenReturn(queryClientRecreated);
  when(kieServerIntegration.getAdminServerClientCheckEndpoints(anyString())).thenReturn(kieClientRecreated);
  doThrow(exception).when(queryClient).replaceQuery(any());
  kieServerDataSetManager.registerQueriesWithRetry("template",
                           "instance",
                           definitions);
  verify(kieServerIntegration,
      times(1)).getAdminServerClient(anyString(),
                     anyString());
  verify(kieServerIntegration,
      times(1)).getAdminServerClientCheckEndpoints(anyString());
  verify(queryClient,
      times(1)).replaceQuery(any());
  verify(queryClientRecreated,
      times(1)).replaceQuery(any());
  assertEquals(1,
         receivedEvents.size());
}

@Test
public void testPerformQueryTestMode() {
  QueryFilterSpec filterSpec = new QueryFilterSpec();
  
  ConsoleDataSetLookup dataSetLookup = Mockito.mock(ConsoleDataSetLookup.class);
  when(dataSetLookup.testMode()).thenReturn(true);
  when(dataSetLookup.getNumberOfRows()).thenReturn(10);
  when(dataSetLookup.getRowOffset()).thenReturn(1);
  when(dataSetLookup.getDataSetUUID()).thenReturn("");
  
  kieServerDataSetProvider.performQuery(dataSetDef, dataSetLookup, queryServicesClient, filterSpec);
  
  verify(kieServerIntegration).broadcastToKieServers(anyString(),
                            any());
  verify(dataSetLookup, times(1)).testMode();
  
  verify(queryServicesClient).query(anyString(),
                   anyString(),
                   any(QueryFilterSpec.class),
                   anyInt(),
                   anyInt(),
                   any());
}

  @Test
  public void testRegisterQueriesOnServerWithoutBPMCapability() throws Exception {

    when(kieClient.getServicesClient(any())).thenThrow(KieServicesException.class);

    QueryDefinition query = QueryDefinition.builder().name("test").expression("expression").source("jbpm").target("CUSTOM").build();
    Set<QueryDefinition> definitions = new HashSet<>();
    definitions.add(query);

    kieServerDataSetManager.registerQueriesWithRetry("template",
                             "instance",
                             definitions);

    verify(kieServerIntegration,
        times(1)).getAdminServerClient(anyString(),
                       anyString());
    verify(queryClient,
        never()).replaceQuery(any());

    assertEquals(0,
           receivedEvents.size());
  }
}

@PostConstruct
public void createAvailableClients() {
  ServiceLoader<KieServicesClientProvider> loader = ServiceLoader.load(KieServicesClientProvider.class);
  loader.forEach(provider -> {
    // skip default http/rest based client providers and use admin client created here
    if (!provider.supports("http")) {
      clientProviders.add(provider);
    }
    allClientProviders.add(provider);
  });
  clientProviders.sort((KieServicesClientProvider one, KieServicesClientProvider two) -> one.getPriority().compareTo(two.getPriority()));
  kieServices = KieServices.Factory.get();
  ServerTemplateList serverTemplates = specManagementService.listServerTemplates();
  logger.debug("Found {} server templates, creating clients for them...",
         serverTemplates.getServerTemplates().length);
  for (ServerTemplate serverTemplate : serverTemplates.getServerTemplates()) {
    buildClientsForServer(serverTemplate);
  }
}

protected KieServicesClient getKieServicesClient(final String serverTemplateId) {
  KieServicesClient client = kieServerIntegration.getServerClient(serverTemplateId);
  if (client == null) {
    throw new RuntimeException("No connection to '" + serverTemplateId + "' server(s)");
  }
  return client;
}

private void registerQueriesWithRetryException(Exception exception) throws Exception {
  QueryDefinition query = QueryDefinition.builder().name("test").expression("expression").source("jbpm").target("CUSTOM").build();
  Set<QueryDefinition> definitions = new HashSet<>();
  definitions.add(query);
  KieServicesClient kieClientRecreated = Mockito.mock(KieServicesClient.class);
  QueryServicesClient queryClientRecreated = Mockito.mock(QueryServicesClient.class);
  when(kieClientRecreated.getServicesClient(any())).thenReturn(queryClientRecreated);
  when(kieServerIntegration.getAdminServerClientCheckEndpoints(anyString())).thenReturn(kieClientRecreated);
  doThrow(exception).when(queryClient).replaceQuery(any());
  kieServerDataSetManager.registerQueriesWithRetry("template",
                           "instance",
                           definitions);
  verify(kieServerIntegration,
      times(1)).getAdminServerClient(anyString(),
                     anyString());
  verify(kieServerIntegration,
      times(1)).getAdminServerClientCheckEndpoints(anyString());
  verify(queryClient,
      times(1)).replaceQuery(any());
  verify(queryClientRecreated,
      times(1)).replaceQuery(any());
  assertEquals(1,
         receivedEvents.size());
}

@Test
public void testPerformQueryRegularMode() {
  QueryFilterSpec filterSpec = new QueryFilterSpec();
  
  ConsoleDataSetLookup dataSetLookup = Mockito.mock(ConsoleDataSetLookup.class);
  when(dataSetLookup.testMode()).thenReturn(false);
  when(dataSetLookup.getNumberOfRows()).thenReturn(10);
  when(dataSetLookup.getRowOffset()).thenReturn(1);
  when(dataSetLookup.getDataSetUUID()).thenReturn("");
  
  kieServerDataSetProvider.performQuery(dataSetDef, dataSetLookup, queryServicesClient, filterSpec);
  
  verify(kieServerIntegration, times(0)).broadcastToKieServers(anyString(),
                            any());
  verify(dataSetLookup, times(1)).testMode();
  
  verify(queryServicesClient).query(anyString(),
                   anyString(),
                   any(QueryFilterSpec.class),
                   anyInt(),
                   anyInt(),
                   any());
}    

  @Test
  public void testRegisterQueriesOnServerWithoutBPMCapability() throws Exception {

    when(kieClient.getServicesClient(any())).thenThrow(KieServicesException.class);

    QueryDefinition query = QueryDefinition.builder().name("test").expression("expression").source("jbpm").target("CUSTOM").build();
    Set<QueryDefinition> definitions = new HashSet<>();
    definitions.add(query);

    kieServerDataSetManager.registerQueriesWithRetry("template",
                             "instance",
                             definitions);

    verify(kieServerIntegration,
        times(1)).getAdminServerClient(anyString(),
                       anyString());
    verify(queryClient,
        never()).replaceQuery(any());

    assertEquals(0,
           receivedEvents.size());
  }
}