How to use

DefaultRestControllerImpl

in

org.kie.server.services.impl.controller

@Override
public void setRegistry(KieServerRegistry registry) {
  this.context = registry;
  
  this.restController = new DefaultRestControllerImpl(this.context);
}

@SuppressWarnings("unchecked")
protected <T> T makeHttpDeleteRequestAndCreateCustomResponse(String uri, Class<T> resultType, String user, String password, String token) {
  logger.debug("About to send DELETE request to '{}' ", uri);
  KieServerHttpRequest request = newRequest( uri, user, password, token ).delete();
  KieServerHttpResponse response = request.response();
  if ( response.code() == Response.Status.OK.getStatusCode() ||
      response.code() == Response.Status.NO_CONTENT.getStatusCode() ) {
    T serviceResponse = deserialize( response.body(), resultType);
    return serviceResponse;
  } else {
    throw new IllegalStateException( "Error while sending DELETE request to " + uri + " response code " + response.code() );
  }
}

public KieServerSetup connectToSingleController(KieServerInfo serverInfo, KieServerConfig config, String controllerUrl) {
  String connectAndSyncUrl = controllerUrl + "/server/" + KieServerEnvironment.getServerId();
  String userName = config.getConfigItemValue(KieServerConstants.CFG_KIE_CONTROLLER_USER, "kieserver");
  String password = loadControllerPassword(config);
  String token = config.getConfigItemValue(KieServerConstants.CFG_KIE_CONTROLLER_TOKEN);
  try {
    KieServerSetup kieServerSetup = makeHttpPutRequestAndCreateCustomResponse(connectAndSyncUrl, serialize(serverInfo), KieServerSetup.class, userName, password, token);
    if (kieServerSetup != null) {
      // once there is non null list let's return it
      return kieServerSetup;
    }
    
  } catch (Exception e) {
    // let's check all other controllers in case of running in cluster of controllers
    logger.warn("Exception encountered while syncing with controller at {} error {}", connectAndSyncUrl, e.getCause() == null ? e.getMessage() : e.getCause().getMessage());
    logger.debug("Exception encountered while syncing with controller at {} error {}", connectAndSyncUrl, e.getMessage(), e);
          
  }
  return null;
}

@Override
public void apply(KieServerRegistry kieServerRegistry, KieServer kieServer) {
  DefaultRestControllerImpl controller = new DefaultRestControllerImpl(kieServerRegistry);
  List<String> containerAliases = kieServerRegistry.getContainerAliases();
  if (containerAliases.isEmpty()) {
    logger.debug("No containers found, quiting");
    return;
  }
  for (String alias : containerAliases) {
    List<KieContainerInstanceImpl> containerInstances = kieServerRegistry.getContainersForAlias(alias);
    if (containerInstances.isEmpty() || containerInstances.size() == 1) {
      logger.debug("Containers for alias {} are already on expected level (number of containers is {})", alias, containerInstances.size());
      continue;
    }
    String latestContainerId = LatestContainerLocator.get().locateContainer(alias, containerInstances);
    final Map<String, String> report = new HashMap<>();
    containerInstances.stream()
        .filter(kci -> !kci.getContainerId().equals(latestContainerId))
        .filter(kci -> !kci.getStatus().equals(KieContainerStatus.CREATING))
        .forEach(kci -> {
          ServiceResponse<Void> response = kieServer.disposeContainer(kci.getContainerId());
          report.put(kci.getContainerId(), response.getType().toString());
          logger.debug("Dispose of container {} completed with {} message {}", kci.getContainerId(), response.getType().toString(), response.getMsg());
          if (response.getType().equals(ServiceResponse.ResponseType.SUCCESS)) {
            controller.stopContainer(kci.getContainerId());
          }
    });
    logger.info("KeepLatestContainerOnlyPolicy applied to {} successfully (report {})", alias, report);
  }
}

@Override
public void disconnect(KieServerInfo serverInfo) {
  if (this.client.isActive()) {
    this.client.close();
  } else {            
    
    KieServerState currentState = context.getStateRepository().load(KieServerEnvironment.getServerId());
    Set<String> controllers = currentState.getControllers();
    KieServerConfig config = currentState.getConfiguration();
    if (controllers != null && !controllers.isEmpty()) {
      for (String controllerUrl : controllers) {
        if (controllerUrl != null && !controllerUrl.isEmpty() && !controllerUrl.toLowerCase().startsWith("ws")) {
          
          logger.info("Kie Server points to non Web Socket controller '{}', using default REST mechanism", controllerUrl);
          
          boolean disconnected = restController.disconnectFromSingleController(serverInfo, config, controllerUrl);
          if (disconnected) {
            break;
          }
        }
      }
    }
  }
  
}

@Override
public KieServerSetup connect(KieServerInfo serverInfo) {
  KieServerState currentState = context.getStateRepository().load(KieServerEnvironment.getServerId());
  Set<String> controllers = currentState.getControllers();
  KieServerConfig config = currentState.getConfiguration();
  if (controllers != null && !controllers.isEmpty()) {
    for (String controllerUrl : controllers) {
      if (controllerUrl != null && !controllerUrl.isEmpty()) {
        KieServerSetup kieServerSetup = connectToSingleController(serverInfo, config, controllerUrl);
        if (kieServerSetup != null) {
          return kieServerSetup;
        }
      }
    }
    throw new KieControllerNotConnectedException("Unable to connect to any controller");
  } else {
    throw new KieControllerNotDefinedException("Unable to connect to any controller");
  }
}

public void startContainer(String containerId) {
  KieServerState currentState = context.getStateRepository().load(KieServerEnvironment.getServerId());
  Set<String> controllers = currentState.getControllers();
  KieServerConfig config = currentState.getConfiguration();
  if (controllers != null && !controllers.isEmpty()) {
    for (String controllerUrl : controllers) {
      if (controllerUrl != null && !controllerUrl.isEmpty()) {
        String connectAndSyncUrl = controllerUrl + "/management/servers/" + KieServerEnvironment.getServerId() + "/containers/" + containerId + "/status/started";
        String userName = config.getConfigItemValue(KieServerConstants.CFG_KIE_CONTROLLER_USER, "kieserver");
        String password = loadControllerPassword(config);
        String token = config.getConfigItemValue(KieServerConstants.CFG_KIE_CONTROLLER_TOKEN);
        try {
          makeHttpPostRequestAndCreateCustomResponse(connectAndSyncUrl, "", null, userName, password, token);
          break;
        } catch (Exception e) {
          // let's check all other controllers in case of running in cluster of controllers
          logger.warn("Exception encountered while syncing with controller at {} error {}", connectAndSyncUrl, e.getCause() == null ? e.getMessage() : e.getCause().getMessage());
          logger.debug("Exception encountered while syncing with controller at {} error {}", connectAndSyncUrl, e.getMessage(), e);
        }
      }
    }
  }
}

public boolean disconnectFromSingleController(KieServerInfo serverInfo, KieServerConfig config, String controllerUrl) {
  String connectAndSyncUrl = null;
  try {
    connectAndSyncUrl = controllerUrl + "/server/" + KieServerEnvironment.getServerId()+"/?location="+ URLEncoder.encode(serverInfo.getLocation(), "UTF-8");
    String userName = config.getConfigItemValue(KieServerConstants.CFG_KIE_CONTROLLER_USER, "kieserver");
    String password = loadControllerPassword(config);
    String token = config.getConfigItemValue(KieServerConstants.CFG_KIE_CONTROLLER_TOKEN);
    makeHttpDeleteRequestAndCreateCustomResponse(connectAndSyncUrl, null, userName, password, token);
    return true;
  } catch (Exception e) {
    // let's check all other controllers in case of running in cluster of controllers
    logger.debug("Exception encountered while syncing with controller at {} error {}", connectAndSyncUrl, e.getMessage(), e);
    
    return false;
  }
}

@Override
public void disconnect(KieServerInfo serverInfo) {
  KieServerState currentState = context.getStateRepository().load(KieServerEnvironment.getServerId());
  Set<String> controllers = currentState.getControllers();
  KieServerConfig config = currentState.getConfiguration();
  for (String controllerUrl : controllers ) {
    if (controllerUrl != null && !controllerUrl.isEmpty()) {
      
      boolean disconnected = disconnectFromSingleController(serverInfo, config, controllerUrl);
      if (disconnected) {
        break;
      }
    }
  }
}

logger.info("Kie Server points to non Web Socket controller '{}', using default REST mechanism", controllerUrl);
KieServerSetup kieServerSetup = restController.connectToSingleController(serverInfo, config, controllerUrl);
if (kieServerSetup != null) {
  return kieServerSetup;

  public void stopContainer(String containerId) {

    KieServerState currentState = context.getStateRepository().load(KieServerEnvironment.getServerId());
    Set<String> controllers = currentState.getControllers();

    KieServerConfig config = currentState.getConfiguration();
    if (controllers != null && !controllers.isEmpty()) {
      for (String controllerUrl : controllers) {

        if (controllerUrl != null && !controllerUrl.isEmpty()) {
          String connectAndSyncUrl = controllerUrl + "/management/servers/" + KieServerEnvironment.getServerId() + "/containers/" + containerId + "/status/stopped";

          String userName = config.getConfigItemValue(KieServerConstants.CFG_KIE_CONTROLLER_USER, "kieserver");
          String password = loadControllerPassword(config);
          String token = config.getConfigItemValue(KieServerConstants.CFG_KIE_CONTROLLER_TOKEN);

          try {
            makeHttpPostRequestAndCreateCustomResponse(connectAndSyncUrl, "", null, userName, password, token);
            break;
          } catch (Exception e) {
            // let's check all other controllers in case of running in cluster of controllers
            logger.warn("Exception encountered while syncing with controller at {} error {}", connectAndSyncUrl, e.getCause() == null ? e.getMessage() : e.getCause().getMessage());
            logger.debug("Exception encountered while syncing with controller at {} error {}", connectAndSyncUrl, e.getMessage(), e);
          }

        }
      }
    }
  }
}

@SuppressWarnings("unchecked")
protected <T> T makeHttpPutRequestAndCreateCustomResponse(String uri, String body, Class<T> resultType, String user, String password, String token) {
  logger.debug("About to send PUT request to '{}' with payload '{}' by thread {}", uri, body, Thread.currentThread().getId());
  KieServerHttpRequest request = newRequest( uri, user, password, token ).body(body).put();
  KieServerHttpResponse response = request.response();
  if ( response.code() == Response.Status.CREATED.getStatusCode() ||
      response.code() == Response.Status.BAD_REQUEST.getStatusCode() ) {
    T serviceResponse = deserialize( response.body(), resultType );
    return serviceResponse;
  } else {
    throw new IllegalStateException( "Error while sending PUT request to " + uri + " response code " + response.code() );
  }
}

protected KieServerController getController() {
  KieServerController controller = new DefaultRestControllerImpl(context);
  try {
    Iterator<KieServerController> it = kieControllers.iterator();
    if (it != null && it.hasNext()) {
      controller = it.next();
      if (controller instanceof KieServerRegistryAware) {
        ((KieServerRegistryAware) controller).setRegistry(context);
      }
    }
  } catch (Exception e) {
    logger.debug("Exception when looking up controller implementations {}", e.getMessage(), e);
  }
  return controller;
}

@SuppressWarnings("unchecked")
protected <T> T makeHttpPostRequestAndCreateCustomResponse(String uri, String body, Class<T> resultType, String user, String password, String token) {
  logger.debug("About to send POST request to '{}' with payload '{}'", uri, body);
  KieServerHttpRequest request = newRequest( uri, user, password, token ).body(body).post();
  KieServerHttpResponse response = request.response();
  if ( response.code() == Response.Status.CREATED.getStatusCode() ||
      response.code() == Response.Status.BAD_REQUEST.getStatusCode() ||
      response.code() == Response.Status.OK.getStatusCode()) {
    T serviceResponse = deserialize( response.body(), resultType );
    return serviceResponse;
  } else {
    throw new IllegalStateException( "Error while sending POST request to " + uri + " response code " + response.code() );
  }
}