How to use

getUrl

method

in

org.kie.server.controller.api.model.runtime.ServerInstanceKey

public boolean isAlive(ServerInstanceKey serverInstanceKey) {
  boolean alive = false;
  try {
    // get client will internally call serverinfo
    getClient(serverInstanceKey.getUrl());
    alive = true;
  } catch (Exception e) {
    logger.debug("Unable to connect to server instance at {} due to {}",
           serverInstanceKey.getUrl(),
           e.getMessage());
  }
  return alive;
}

public ContainerKey( final String containerSpecId,
    final String containerName,
    final ServerInstanceKey serverInstanceKey ) {
  this.serverTemplateId = serverInstanceKey.getServerTemplateId();
  this.containerSpecId = containerSpecId;
  this.containerName = containerName;
  this.url = serverInstanceKey.getUrl();
}

public boolean hasServerInstance(String serverInstanceUrl) {
  for (ServerInstanceKey spec : getServerInstanceKeys()) {
    if (serverInstanceUrl.equals(spec.getUrl())) {
      return true;
    }
  }
  return false;
}

public boolean hasServerInstance(String serverInstanceUrl) {
  for (ServerInstanceKey spec : getServerInstanceKeys()) {
    if (serverInstanceUrl.equals(spec.getUrl())) {
      return true;
    }
  }
  return false;
}

public ContainerKey( final String containerSpecId,
    final String containerName,
    final ServerInstanceKey serverInstanceKey ) {
  this.serverTemplateId = serverInstanceKey.getServerTemplateId();
  this.containerSpecId = containerSpecId;
  this.containerName = containerName;
  this.url = serverInstanceKey.getUrl();
}

public KieServicesClient getAdminServerClient(String serverTemplateId,
                       String serverInstanceId) {
  try {
    ServerInstanceKey instance = specManagementService.getServerTemplate(serverTemplateId).getServerInstanceKeys()
        .stream()
        .filter(si -> si.getServerInstanceId().equals(serverInstanceId))
        .findFirst()
        .get();
    String url = instance.getUrl();
    KieServicesClient client = clientProviders
        .stream()
        .filter(provider -> provider.supports(url))
        .findFirst()
        .get()
        .get(url);
    logger.debug("Using client {}",
           client);
    return client;
  } catch (Exception e) {
    return adminClients.get(serverTemplateId);
  }
}

public void onServerInstanceDisconnected(@Observes ServerInstanceDisconnected serverInstanceDisconnected) {
  ServerInstanceKey serverInstanceKey = serverInstancesById.get(serverInstanceDisconnected.getServerInstanceId());
  if (serverInstanceKey != null) {
    Iterator<Map.Entry<String, KieServicesClient>> iterator = serverTemplatesClients.entrySet().iterator();
    while (iterator.hasNext()) {
      Map.Entry<String, KieServicesClient> entry = iterator.next();
      if (entry.getKey().startsWith(serverInstanceKey.getServerTemplateId())) {
        KieServicesClient client = entry.getValue();
        if (client != null) {
          LoadBalancer loadBalancer = ((AbstractKieServicesClientImpl) client).getLoadBalancer();
          loadBalancer.markAsFailed(serverInstanceKey.getUrl());
          logger.debug("Server instance {} for server template {} removed from client thus won't be used for operations", serverInstanceKey.getUrl(), serverInstanceKey.getServerTemplateId());
        }
        logger.debug("KieServerClient load balancer updated for server template {}", entry.getKey());
      }
    }
    serverInstancesById.remove(serverInstanceKey.getServerInstanceId());
    // update admin client
    KieServicesClient adminClient = adminClients.get(serverInstanceKey.getServerTemplateId());
    if (adminClient != null) {
      LoadBalancer loadBalancer = ((AbstractKieServicesClientImpl) adminClient).getLoadBalancer();
      loadBalancer.markAsFailed(serverInstanceKey.getUrl());
      logger.debug("Server instance {} for server template {} removed from client thus won't be used for operations", serverInstanceKey.getUrl(), serverInstanceKey.getServerTemplateId());
    }
  }
}

public List<Object> broadcastToKieServers(String serverTemplateId,
                     Function<KieServicesClient, Object> operation) {
  List<Object> results = new ArrayList<>();
  ServerTemplate serverTemplate = specManagementService.getServerTemplate(serverTemplateId);
  if (serverTemplate.getServerInstanceKeys() == null || serverTemplate.getServerInstanceKeys().isEmpty()) {
    return results;
  }
  for (ServerInstanceKey instanceUrl : serverTemplate.getServerInstanceKeys()) {
    try {
      KieServicesClient client = getClient(instanceUrl.getUrl());
      Object result = operation.apply(client);
      results.add(result);
      logger.debug("KIE Server at {} returned result {} for broadcast operation {}", instanceUrl, result, operation);
    } catch (Exception e) {
      logger.debug("Unable to send breadcast to {} due to {}", instanceUrl, e.getMessage(), e);
    }
  }
  return results;
}

StringBuilder endpoints = new StringBuilder();
for (ServerInstanceKey serverInstanceKey : serverTemplate.getServerInstanceKeys()) {
  endpoints.append(serverInstanceKey.getUrl() + "|");

public void onServerInstanceDisconnected(@Observes ServerInstanceDisconnected serverInstanceDisconnected) {
  ServerInstanceKey serverInstanceKey = serverInstancesById.get(serverInstanceDisconnected.getServerInstanceId());
  if (serverInstanceKey != null) {
    serverTemplatesClients.computeIfPresent(serverInstanceKey.getServerTemplateId(),
                        (serverTemplateId, clients) -> {
                          clients.forEach((key, client) -> {
                            LoadBalancer loadBalancer = ((AbstractKieServicesClientImpl) client).getLoadBalancer();
                            loadBalancer.markAsFailed(serverInstanceKey.getUrl());
                            logger.debug("Server instance '{}' for server template {} removed from client thus won't be used for operations",
                                   serverInstanceKey.getUrl(),
                                   serverInstanceKey.getServerTemplateId());
                            logger.debug("KieServerClient load balancer updated for server template {}",
                                   serverTemplateId.equals(SERVER_TEMPLATE_KEY) ? serverInstanceKey.getServerTemplateId() : serverTemplateId);
                          });
                          return clients;
                        });
    serverInstancesById.remove(serverInstanceKey.getServerInstanceId());
    // update admin client
    KieServicesClient adminClient = adminClients.get(serverInstanceKey.getServerTemplateId());
    if (adminClient != null) {
      LoadBalancer loadBalancer = ((AbstractKieServicesClientImpl) adminClient).getLoadBalancer();
      loadBalancer.markAsFailed(serverInstanceKey.getUrl());
      logger.debug("Server instance {} for server template {} removed from client thus won't be used for operations",
             serverInstanceKey.getUrl(),
             serverInstanceKey.getServerTemplateId());
    }
  }
}

StringBuilder endpoints = new StringBuilder();
for (ServerInstanceKey serverInstanceKey : serverTemplate.getServerInstanceKeys()) {
  endpoints.append(serverInstanceKey.getUrl() + "|");

@Override
public void afterResponseSent() {
  
  ServerTemplate serverTemplate = controller.getTemplateStorage().load(serverInfo.getServerId());
  
  ServerInstanceKey serverInstanceKey = serverTemplate.getServerInstanceKeys().stream()
      .filter(server -> server.getUrl().equals(serverInfo.getLocation()))
      .findFirst()
      .get();
  ServerInstance serverInstance = new ServerInstance();
  serverInstance.setServerName(serverInstanceKey.getServerName());
  serverInstance.setServerTemplateId(serverInstanceKey.getServerTemplateId());
  serverInstance.setServerInstanceId(serverInstanceKey.getServerInstanceId());
  serverInstance.setUrl(serverInstanceKey.getUrl());
  
  controller.getNotificationService().notify(new ServerInstanceUpdated(serverInstance));
  controller.getNotificationService().notify(new ServerInstanceConnected(serverInstance));
}

private void loadContent( final Collection<Container> containers ) {
  view.clear();
  view.setServerName( serverInstanceKey.getServerName() );
  view.setServerURL( serverInstanceKey.getUrl() );
  if ( containers.isEmpty() ) {
    view.setEmptyView( remoteEmptyPresenter.getView() );
  } else {
    remoteStatusPresenter.setup( containers );
    view.setStatusPresenter( remoteStatusPresenter.getView() );
  }
}

protected List<Container> callRemoteKieServerOperation(ServerTemplate serverTemplate,
                            ContainerSpec containerSpec,
                            RemoteKieServerOperation operation) {
  List<Container> containers = new ArrayList<org.kie.server.controller.api.model.runtime.Container>();
  if (serverTemplate.getServerInstanceKeys() == null || serverTemplate.getServerInstanceKeys().isEmpty() || containerSpec == null) {
    return containers;
  }
  for (ServerInstanceKey instanceUrl : serverTemplate.getServerInstanceKeys()) {
    Container container = new Container();
    container.setContainerSpecId(containerSpec.getId());
    container.setServerTemplateId(serverTemplate.getId());
    container.setServerInstanceId(instanceUrl.getServerInstanceId());
    container.setUrl(instanceUrl.getUrl() + "/containers/" + containerSpec.getId());
    container.setStatus(containerSpec.getStatus());
    try {
      final KieServicesClient client = getClient(instanceUrl.getUrl());
      operation.doOperation(client, container);
      containers.add(container);
    } catch (Exception e) {
      logger.debug("Unable to connect to {}",
             instanceUrl);
    }
  }
  return containers;
}

public List<Container> getContainers(ServerInstanceKey serverInstanceKey) {
  if (serverInstanceKey == null || serverInstanceKey.getUrl() == null) {
    return containers;
    KieServicesClient client = getClient(serverInstanceKey.getUrl());
        container.setContainerName(containerResource.getContainerAlias());
        container.setServerInstanceId(serverInstanceKey.getServerInstanceId());
        container.setUrl(serverInstanceKey.getUrl() + CONTAINERS_URI_PART + containerResource.getContainerId());
        container.setResolvedReleasedId(containerResource.getResolvedReleaseId() == null ? containerResource.getReleaseId() : containerResource.getResolvedReleaseId());
        container.setServerTemplateId(serverInstanceKey.getServerTemplateId());
          serverInstanceKey.getUrl(),
          e.getMessage());
    throw e;

@Test
public void testSelectAndRefreshEmptyContainers() {
  final ServerInstanceKey serverInstanceKey = new ServerInstanceKey( "templateId", "serverName", "serverInstanceId", "url" );
  when( runtimeManagementService.getContainersByServerInstance(
      serverInstanceKey.getServerTemplateId(),
      serverInstanceKey.getServerInstanceId() ) ).thenReturn(
      Collections.<Container>emptyList()
  );
  presenter.onSelect( new ServerInstanceSelected( serverInstanceKey ) );
  verify( view ).clear();
  verify( view ).setServerName( serverInstanceKey.getServerName() );
  verify( view ).setServerURL( serverInstanceKey.getUrl() );
  verify( view ).setEmptyView( remoteEmptyPresenter.getView() );
}

@Test
public void testSelectAndRefresh() {
  final ServerInstanceKey serverInstanceKey = new ServerInstanceKey( "templateId", "serverName", "serverInstanceId", "url" );
  final Container container = new Container( "containerSpecId", "containerName", serverInstanceKey, Collections.<Message>emptyList(), null, null );
  final List<Container> containers = Collections.singletonList( container );
  when( runtimeManagementService.getContainersByServerInstance(
      serverInstanceKey.getServerTemplateId(),
      serverInstanceKey.getServerInstanceId() ) ).thenReturn(
      containers
  );
  presenter.onSelect( new ServerInstanceSelected( serverInstanceKey ) );
  verify( view ).clear();
  verify( view ).setServerName( serverInstanceKey.getServerName() );
  verify( view ).setServerURL( serverInstanceKey.getUrl() );
  verify( remoteStatusPresenter ).setup( containers );
  verify( view ).setStatusPresenter( remoteStatusPresenter.getView() );
}

  @Test
  public void testToKey() {
    final String serverTemplateId = "serverTemplateId";
    final String serverName = "serverName";
    final String serverInstanceId = "serverInstanceId";
    final String url = "url";

    ServerInstance serverInstance = new ServerInstance( serverTemplateId, serverName, serverInstanceId, url, "version", new ArrayList<Message>(), new ArrayList<Container>() );

    ServerInstanceKey key = Convert.toKey( serverInstance );

    assertEquals( serverTemplateId, key.getServerTemplateId() );
    assertEquals( serverName, key.getServerName() );
    assertEquals( serverInstanceId, key.getServerInstanceId() );
    assertEquals( url, key.getUrl() );
  }
}

assertEquals("kie_server@localhost:8180", serverInstanceKey.getServerName());
assertEquals("kie_server@localhost:8180", serverInstanceKey.getServerInstanceId());
assertEquals("http://localhost:8180/kie-server/services/rest/server", serverInstanceKey.getUrl());

@Test
public void testGetServerInstances() {
  ServerInstanceKeyList found = runtimeManagementService.getServerInstances(serverTemplate.getId());
  assertNotNull(found);
  assertEquals(0, found.getServerInstanceKeys().length);
  serverTemplate.addServerInstance(new ServerInstanceKey(serverTemplate.getId(), "test server","instanceId" , "http://fake.url.org"));
  specManagementService.saveServerTemplate(serverTemplate);
  found = runtimeManagementService.getServerInstances(serverTemplate.getId());
  assertNotNull(found);
  assertEquals(1, found.getServerInstanceKeys().length);
  org.kie.server.controller.api.model.runtime.ServerInstanceKey server = found.getServerInstanceKeys()[0];
  assertNotNull(server);
  assertEquals(serverTemplate.getId(), server.getServerTemplateId());
  assertEquals("instanceId", server.getServerInstanceId());
  assertEquals("test server", server.getServerName());
  assertEquals("http://fake.url.org", server.getUrl());
}