Package com.unboundid.directory.sdk.proxy.scripting

Class ScriptedLDAPHealthCheck

  • All Implemented Interfaces:
    Configurable, Reconfigurable<LDAPHealthCheckConfig>
    @Extensible
@DirectoryProxyServerExtension(appliesToLocalContent=false,
                               appliesToRemoteContent=true)
@ThreadSafety(level=INTERFACE_THREADSAFE)
public abstract class ScriptedLDAPHealthCheck
extends java.lang.Object
implements Reconfigurable<LDAPHealthCheckConfig>
    This class defines an API that must be implemented by scripted extensions which are used to assess the health of backend servers accessed through the Directory Proxy Server. Each health check invocation generates a health check result, which contains the following elements:
    • Health Check State -- This indicates the general health state for the backend server. The state may be AVAILABLE (the server is completely suitable for use), DEGRADED (the server should be avoided if there are better servers but may be used if necessary), or UNAVAILABLE (the server should not be used at all).
    • Health Check Score -- This provides an integer value between 10 (the best score) and 1 (the worst score) that may help rank servers with the same state. Some load-balancing algorithms (e.g., the health-weighted algorithm) may use this to prefer servers with a higher score over those with a lower score. Servers with a state of UNAVAILABLE will always have a score of zero.
    • Messages -- This may optionally provide information about the reason for the state and/or score. This is primarily useful for results indicating that the server is DEGRADED or UNAVAILABLE to provide information about the problem(s) preventing it from being considered AVAILABLE.


    LDAP health checks may be invoked in two ways. They will be invoked on a regular basis to periodically re-assess the health of each backend server, but they may also be invoked after a failed operation in order to more quickly detect a problem that should cause the server to be transitioned to a less-available state. The server will ensure that no more than one health check is in progress at a time for a given server in order to avoid overwhelming it with health checking, but it is still recommended that health checks triggered as a result of a failed operation attempt to use the operation result code to decide whether it may be necessary to actually attempt to communicate with the server.

    Further, it may also be useful to have more stringent criteria for promoting the health of a server than for demoting it in order to avoid a ping-pong effect that may occur if a server is hovering near the border between AVAILABLE and DEGRADED or between DEGRADED and UNAVAILABLE. For example, if a health check attempts to perform an operation in the backend server and the response time for that operation is taken into account when determining the server health, it might be better to require a lower response time in order to transition from DEGRADED to AVAILABLE than was originally required to transition from AVAILABLE to DEGRADED.

    Configuring Groovy-Scripted LDAP Health Checks

    In order to configure a scripted LDAP health check based on this API and written in the Groovy scripting language, use a command like: 
          dsconfig create-ldap-health-check \
           --check-name "{check-name}" \
           --type groovy-scripted \
           --set enabled:true \
           --set "script-class:{class-name}" \
           --set "script-argument:{name=value}"
    where "{check-name}" is the name to use for the LDAP health check instance, "{class-name}" is the fully-qualified name of the Groovy class written using this API, and "{name=value}" represents name-value pairs for any arguments to provide to the LDAP health check. If multiple arguments should be provided to the LDAP health check, then the "--set script-argument:{name=value}" option should be provided multiple times.
    See Also:
    LDAPHealthCheck

    • Constructor Detail

      • ScriptedLDAPHealthCheck

        public ScriptedLDAPHealthCheck()
        Creates a new instance of this LDAP health check. All LDAP health check implementations must include a default constructor, but any initialization should generally be done in the initializeLDAPHealthCheck method.

    • Method Detail

      • defineConfigArguments

        public void defineConfigArguments​(ArgumentParser parser)
                           throws ArgumentException
        Updates the provided argument parser to define any configuration arguments which may be used by this extension. The argument parser may also be updated to define relationships between arguments (e.g., to specify required, exclusive, or dependent argument sets).
        Specified by:
        defineConfigArguments in interface Configurable
        Parameters:
        parser - The argument parser to be updated with the configuration arguments which may be used by this extension.
        Throws:
        ArgumentException - If a problem is encountered while updating the provided argument parser.

      • initializeLDAPHealthCheck

        public void initializeLDAPHealthCheck​(ProxyServerContext serverContext,
                                      LDAPHealthCheckConfig config,
                                      ArgumentParser parser)
                               throws LDAPException
        Initializes this LDAP health check.
        Parameters:
        serverContext - A handle to the server context for the server in which this extension is running.
        config - The general configuration for this LDAP health check.
        parser - The argument parser which has been initialized from the configuration for this LDAP health check.
        Throws:
        LDAPException - If a problem occurs while initializing this LDAP health check.

      • finalizeLDAPHealthCheck

        public void finalizeLDAPHealthCheck()
        Performs any cleanup which may be necessary when this LDAP health check is to be taken out of service.

      • isConfigurationAcceptable

        public boolean isConfigurationAcceptable​(LDAPHealthCheckConfig config,
                                         ArgumentParser parser,
                                         java.util.List<java.lang.String> unacceptableReasons)
        Indicates whether the configuration represented by the provided argument parser is acceptable for use by this extension. The parser will have been used to parse any configuration available for this extension, and any automatic validation will have been performed. This method may be used to perform any more complex validation which cannot be performed automatically by the argument parser.
        Specified by:
        isConfigurationAcceptable in interface Reconfigurable<LDAPHealthCheckConfig>
        Parameters:
        config - The general configuration for this extension.
        parser - The argument parser that has been used to parse the proposed configuration for this extension.
        unacceptableReasons - A list to which messages may be added to provide additional information about why the provided configuration is not acceptable.
        Returns:
        true if the configuration in the provided argument parser appears to be acceptable, or false if not.

      • applyConfiguration

        public ResultCode applyConfiguration​(LDAPHealthCheckConfig config,
                                     ArgumentParser parser,
                                     java.util.List<java.lang.String> adminActionsRequired,
                                     java.util.List<java.lang.String> messages)
        Attempts to apply the configuration from the provided argument parser to this extension.
        Specified by:
        applyConfiguration in interface Reconfigurable<LDAPHealthCheckConfig>
        Parameters:
        config - The general configuration for this extension.
        parser - The argument parser that has been used to parse the new configuration for this extension.
        adminActionsRequired - A list to which messages may be added to provide additional information about any additional administrative actions that may be required to apply some of the configuration changes.
        messages - A list to which messages may be added to provide additional information about the processing performed by this method.
        Returns:
        A result code providing information about the result of applying the configuration change. A result of SUCCESS should be used to indicate that all processing completed successfully. Any other result will indicate that a problem occurred during processing.

      • checkAvailableServer

        public abstract HealthCheckResult checkAvailableServer​(BackendServer backendServer,
                                                       LDAPConnection connection)
        Attempts to determine the health of the provided LDAP external server whose last health check result indicated that the server had a state of AVAILABLE. This method may be periodically invoked for AVAILABLE servers to determine whether their state has changed.
        Parameters:
        backendServer - A handle to the LDAP external server whose health is to be assessed.
        connection - A connection that may be used to communicate with the server in the course of performing the evaluation. The health check should not do anything which may alter the state of this connection.
        Returns:
        Information about the result of the health check.

      • checkDegradedServer

        public abstract HealthCheckResult checkDegradedServer​(BackendServer backendServer,
                                                      LDAPConnection connection)
        Attempts to determine the health of the provided LDAP external server whose last health check result indicated that the server had a state of DEGRADED. This method may be periodically invoked for DEGRADED servers to determine whether their state has changed.
        Parameters:
        backendServer - A handle to the LDAP external server whose health is to be assessed.
        connection - A connection that may be used to communicate with the server in the course of performing the evaluation. The health check should not do anything which may alter the state of this connection.
        Returns:
        Information about the result of the health check.

      • checkUnavailableServer

        public abstract HealthCheckResult checkUnavailableServer​(BackendServer backendServer,
                                                         LDAPConnection connection)
        Attempts to determine the health of the provided LDAP external server whose last health check result indicated that the server had a state of UNAVAILABLE. This method may be periodically invoked for UNAVAILABLE servers to determine whether their state has changed.
        Parameters:
        backendServer - A handle to the LDAP external server whose health is to be assessed.
        connection - A connection that may be used to communicate with the server in the course of performing the evaluation. The health check should not do anything which may alter the state of this connection.
        Returns:
        Information about the result of the health check.

      • checkFailedOperation

        public abstract HealthCheckResult checkFailedOperation​(CompletedProxyOperationContext operationContext,
                                                       LDAPException exception,
                                                       BackendServer backendServer)
        Attempts to determine the health of the provided LDAP external server in which an attempted operation did not complete successfully.
        Parameters:
        operationContext - A handle to the operation context for the operation that failed.
        exception - The exception caught when attempting to process the associated operation in the backend server.
        backendServer - A handle to the backend server in which the operation was processed.
        Returns:
        Information about the result of the health check.