Client

CompletableFuture<ClientResponse> callService(URI uri, ClientRequest request, Optional<String> requestBody)

    @Test
    public void testPetsPetIdDeleteHandlerTest() throws ClientException {

        final Http2Client client = Http2Client.getInstance();
        final CountDownLatch latch = new CountDownLatch(1);
        final ClientConnection connection;
        try {
            if(enableHttps) {
                connection = client.borrowConnection(new URI(url), Http2Client.WORKER, Http2Client.SSL, Http2Client.BUFFER_POOL, enableHttp2 ? OptionMap.create(UndertowOptions.ENABLE_HTTP2, true): OptionMap.EMPTY).get();
            } else {
                connection = client.borrowConnection(new URI(url), Http2Client.WORKER, Http2Client.BUFFER_POOL, OptionMap.EMPTY).get();
            }
        } catch (Exception e) {
            throw new ClientException(e);
        }
        final AtomicReference<ClientResponse> reference = new AtomicReference<>();
        String requestUri = "/v1/pets/VKVDHrCqEjLdRSJEzweRKRPFflj";
        String httpMethod = "delete";
        try {
            ClientRequest request = new ClientRequest().setPath(requestUri).setMethod(Methods.DELETE);
            
            //customized header parameters 
            request.getRequestHeaders().put(new HttpString("key"), "hgNijJaFIMAgwKhUIgnndaLfD");
            request.getRequestHeaders().put(new HttpString("host"), "localhost");
            connection.sendRequest(request, client.createClientCallback(reference, latch));
            
            latch.await();
        } catch (Exception e) {
            logger.error("Exception: ", e);
            throw new ClientException(e);
        } finally {
            client.returnConnection(connection);
        }
        String body = reference.get().getAttachment(Http2Client.RESPONSE_BODY);
        Optional<HeaderValues> contentTypeName = Optional.ofNullable(reference.get().getResponseHeaders().get(Headers.CONTENT_TYPE));
        SchemaValidatorsConfig config = new SchemaValidatorsConfig();
        ResponseValidator responseValidator = new ResponseValidator(config);
        int statusCode = reference.get().getResponseCode();
        Status status;
        if(contentTypeName.isPresent()) {
            status = responseValidator.validateResponseContent(body, requestUri, httpMethod, String.valueOf(statusCode), contentTypeName.get().getFirst());
        } else {
            status = responseValidator.validateResponseContent(body, requestUri, httpMethod, String.valueOf(statusCode), JSON_MEDIA_TYPE);
        }
        Assert.assertNull(status);
    }

request:
 errorThreshold: 2
 timeout: 3000
 resetTimeout: 7000
 # the flag to indicate whether http/2 is enabled when calling client.callService()
 enableHttp2: true
 # the maximum host capacity of connection pool
 connectionPoolSize: 1000
 # the maximum request limitation for each connection
 maxReqPerConn: 1000000
 # maximum quantity of connection in connection pool for each host
 maxConnectionNumPerHost: 1000
 # minimum quantity of connection in connection pool for each host. The corresponding connection number will shrink to minConnectionNumPerHost
 # by remove least recently used connections when the connection number of a host reach 0.75 * maxConnectionNumPerHost.
 minConnectionNumPerHost: 250

try {
    ClientRequest requestB = new ClientRequest().setMethod(Methods.GET).setPath(apibPath);
    
    CompletableFuture<ClientResponse> response = client.callService(new URI(apibHost), requestB, Optional.empty());
    
    int statusCodeB = response.join().getResponseCode();
    if (statusCodeB >= 300) {
        throw new Exception("Failed to call API B: " + statusCodeB);
    }
    String apibList = response.join().getAttachment(Http2Client.RESPONSE_BODY);
} catch (Exception e) {
    logger.error("Exception:", e);
    throw new ClientException(e);
}

try {
    ClientRequest requestB = new ClientRequest().setMethod(Methods.GET).setPath(apibPath);
    
    CompletableFuture<ClientResponse> response = client.callService("http", "com.networknt.petstore-3.0.1", "", requestB, Optional.empty());
    
    int statusCodeB = response.join().getResponseCode();
    if (statusCodeB >= 300) {
        throw new Exception("Failed to call API B: " + statusCodeB);
    }
    String apibList = response.join().getAttachment(Http2Client.RESPONSE_BODY);
} catch (Exception e) {
    logger.error("Exception:", e);
    throw new ClientException(e);
}

    } finally {
        IoUtils.safeClose(connection);
    }

    } finally {
        if(number of minutes passed or number of requests handled) {
            IoUtils.safeClose(connection);
        }
    }

        if(connectionC == null || !connectionC.isOpen()) {
            try {
                apicHost = cluster.serviceToUrl("https", "com.networknt.apic-1.0.0", null);
                connectionC = client.connect(new URI(apicHost), Http2Client.WORKER, Http2Client.SSL, Http2Client.POOL, OptionMap.create(UndertowOptions.ENABLE_HTTP2, true)).get();
            } catch (Exception e) {
                logger.error("Exeption:", e);
                throw new ClientException(e);
            }
        }

    public void testRouterHttps48k() throws Exception {
        ClientConnection connection = null;
        try {
            connection = client.borrowConnection(new URI("https://localhost:8000"), Http2Client.WORKER, Http2Client.SSL, Http2Client.BUFFER_POOL, OptionMap.create(UndertowOptions.ENABLE_HTTP2, true)).get();
            final String json = getResourceFileAsString("48k.json");
            for(int i = 0; i < 100; i++) {
                final CountDownLatch latch = new CountDownLatch(1);
                final AtomicReference<ClientResponse> reference = new AtomicReference<>();
                final ClientRequest request = new ClientRequest().setMethod(Methods.POST).setPath("/v1/postData");
                request.getRequestHeaders().put(Headers.HOST, "localhost");
                request.getRequestHeaders().put(Headers.TRANSFER_ENCODING, "chunked");
                request.getRequestHeaders().put(Headers.CONTENT_TYPE, "application/json");
                connection.sendRequest(request, client.createClientCallback(reference, latch, json));
                latch.await(1000, TimeUnit.MILLISECONDS);
                int statusCode = reference.get().getResponseCode();
                String body = reference.get().getAttachment(Http2Client.RESPONSE_BODY);
                if(statusCode != 200) System.out.println("testRouter4k failed with statusCode = " + statusCode + " body = " + body);
                System.out.println(i);
                if(!body.startsWith("[")) System.out.println(body);
            }
        } finally {
            client.returnConnection(connection);
        }
    }

public class Http2ClientExample {
    static final Logger logger = LoggerFactory.getLogger(Http2ClientExample.class);
    // Get the singleton Http2Client instance
    static Http2Client client = Http2Client.getInstance();

    public static void main(String[] args) {
        Http2ClientExample e = new Http2ClientExample();
        try {
            e.testHttp2Get();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        System.exit(0);
    }

    /**
     * This is a simple example that create a new HTTP 2.0 connection for get request
     * and close the connection after the call is done. As you can see that it is using
     * a hard coded uri which points to a statically deployed service on fixed ip and port
     *
     */
    public void testHttp2Get() throws Exception {
        final CountDownLatch latch = new CountDownLatch(1);
        SimpleConnectionHolder.ConnectionToken connectionToken = null;

        final AtomicReference<ClientResponse> reference = new AtomicReference<>();
        boolean completed  = false;
        try {
            connectionToken = client.borrow(new URI("https://localhost:9445"), Http2Client.WORKER, client.getDefaultXnioSsl(), Http2Client.BUFFER_POOL, OptionMap.create(UndertowOptions.ENABLE_HTTP2, true));
            ClientConnection connection = (ClientConnection) connectionToken.getRawConnection();
            ClientRequest request = new ClientRequest().setPath("/v1/pets").setMethod(Methods.GET);
            request.getRequestHeaders().put(Headers.CONTENT_TYPE, "application/json");
            request.getRequestHeaders().put(Headers.TRANSFER_ENCODING, "chunked");
            request.getRequestHeaders().put(new HttpString("host"), "localhost");
            connection.sendRequest(request, client.createClientCallback(reference, latch));
            completed = latch.await(ClientConfig.get().getTimeout(), TimeUnit.MILLISECONDS);
        } catch (InterruptedException e) {
            logger.error("InterruptedException:", e);
            throw new ClientException(e);
        } finally {
            client.restore(connectionToken);
        }
        if(!completed) {
            logger.error("Request timeout");
            throw new ClientException("Request timeout");
        } else {
            int statusCode = reference.get().getResponseCode();
            String body = reference.get().getAttachment(Http2Client.RESPONSE_BODY);
            System.out.println("testHttp2Get: statusCode = " + statusCode + " body = " + body);
        }
    }
}

# This is the configuration file for Http2Client.
---
# Settings for TLS
tls:
  # if the server is using self-signed certificate, this need to be false. If true, you have to use CA signed certificate or load
  # truststore that contains the self-signed certificate.
  verifyHostname: ${client.verifyHostname:true}
  # indicate of system load default cert.
  loadDefaultTrustStore: ${client.loadDefaultTrustStore:true}
  # trust store contains certificates that server needs. Enable if tls is used.
  loadTrustStore: ${client.loadTrustStore:true}
  # trust store location can be specified here or system properties javax.net.ssl.trustStore and password javax.net.ssl.trustStorePassword
  trustStore: ${client.trustStore:client.truststore}
  # trust store password
  trustStorePass: ${client.trustStorePass:password}
  # key store contains client key and it should be loaded if two-way ssl is used.
  loadKeyStore: ${client.loadKeyStore:false}
  # key store location
  keyStore: ${client.keyStore:client.keystore}
  # key store password
  keyStorePass: ${client.keyStorePass:password}
  # private key password
  keyPass: ${client.keyPass:password}
  # public issued CA cert  password
  defaultCertPassword: ${client.defaultCertPassword:changeit}
  # TLS version. Default is TSLv1.2, and you can downgrade to TLSv1 to support some internal old servers that support only TLSv1.1(deprecated
  # and risky). You can also upgrade to TSLv1.3 for maximum security if all your servers support it.
  tlsVersion: ${client.tlsVersion:TLSv1.2}
# settings for OAuth2 server communication
oauth:
  # OAuth 2.0 token endpoint configuration
  # If there are multiple oauth providers per serviceId, then we need to update this flag to true. In order to derive the serviceId from the
  # path prefix, we need to set up the pathPrefixServices below if there is no duplicated paths between services.
  multipleAuthServers: ${client.multipleAuthServers:false}
  token:
    cache:
      #capacity of caching TOKENs
      capacity: ${client.tokenCacheCapacity:200}
    # The scope token will be renewed automatically 1 minute before expiry
    tokenRenewBeforeExpired: ${client.tokenRenewBeforeExpired:60000}
    # if scope token is expired, we need short delay so that we can retry faster.
    expiredRefreshRetryDelay: ${client.expiredRefreshRetryDelay:2000}
    # if scope token is not expired but in renew window, we need slow retry delay.
    earlyRefreshRetryDelay: ${client.earlyRefreshRetryDelay:4000}
    # token server url. The default port number for token service is 6882. If this is set,
    # it will take high priority than serviceId for the direct connection
    server_url: ${client.tokenServerUrl:}
    # token service unique id for OAuth 2.0 provider. If server_url is not set above,
    # a service discovery action will be taken to find an instance of token service.
    serviceId: ${client.tokenServiceId:com.networknt.oauth2-token-1.0.0}
    # For users who leverage SaaS OAuth 2.0 provider from lightapi.net or others in the public cloud
    # and has an internal proxy server to access code, token and key services of OAuth 2.0, set up the
    # proxyHost here for the HTTPS traffic. This option is only working with server_url and serviceId
    # below should be commented out. OAuth 2.0 services cannot be discovered if a proxy server is used.
    proxyHost: ${client.tokenProxyHost:}
    # We only support HTTPS traffic for the proxy and the default port is 443. If your proxy server has
    # a different port, please specify it here. If proxyHost is available and proxyPort is missing, then
    # the default value 443 is going to be used for the HTTP connection.
    proxyPort: ${client.tokenProxyPort:}
    # set to true if the oauth2 provider supports HTTP/2
    enableHttp2: ${client.tokenEnableHttp2:true}
    # the following section defines uri and parameters for authorization code grant type
    authorization_code:
      # token endpoint for authorization code grant
      uri: ${client.tokenAcUri:/oauth2/token}
      # client_id for authorization code grant flow.
      client_id: ${client.tokenAcClientId:f7d42348-c647-4efb-a52d-4c5787421e72}
      # client_secret for authorization code grant flow.
      client_secret: ${client.tokenAcClientSecret:f6h1FTI8Q3-7UScPZDzfXA}
      # the web server uri that will receive the redirected authorization code
      redirect_uri: ${client.tokenAcRedirectUri:https://localhost:3000/authorization}
      # optional scope, default scope in the client registration will be used if not defined.
      # If there are scopes specified here, they will be verified against the registered scopes.
      # In values.yml, you define a list of strings for the scope(s).
      scope: ${client.tokenAcScope:}
      # - petstore.r
      # - petstore.w
    # the following section defines uri and parameters for client credentials grant type
    client_credentials:
      # token endpoint for client credentials grant
      uri: ${client.tokenCcUri:/oauth2/token}
      # client_id for client credentials grant flow.
      client_id: ${client.tokenCcClientId:f7d42348-c647-4efb-a52d-4c5787421e72}
      # client_secret for client credentials grant flow.
      client_secret: ${client.tokenCcClientSecret:f6h1FTI8Q3-7UScPZDzfXA}
      # optional scope, default scope in the client registration will be used if not defined.
      # If there are scopes specified here, they will be verified against the registered scopes.
      # In values.yml, you define a list of strings for the scope(s).
      scope: ${client.tokenCcScope:}
      # - petstore.r
      # - petstore.w
      # The serviceId to the service specific OAuth 2.0 configuration. Used only when multipleOAuthServer is
      # set as true. For detailed config options, please see the values.yml in the client module test.
      serviceIdAuthServers: ${client.tokenCcServiceIdAuthServers:}
    refresh_token:
      # token endpoint for refresh token grant
      uri: ${client.tokenRtUri:/oauth2/token}
      # client_id for refresh token grant flow.
      client_id: ${client.tokenRtClientId:f7d42348-c647-4efb-a52d-4c5787421e72}
      # client_secret for refresh token grant flow
      client_secret: ${client.tokenRtClientSecret:f6h1FTI8Q3-7UScPZDzfXA}
      # optional scope, default scope in the client registration will be used if not defined.
      # If there are scopes specified here, they will be verified against the registered scopes.
      # In values.yml, you define a list of strings for the scope(s).
      scope: ${client.tokenRtScope:}
      # - petstore.r
      # - petstore.w
    # light-oauth2 key distribution endpoint configuration for token verification
    key:
      # key distribution server url for token verification. It will be used if it is configured.
      # If it is not set, a service lookup will be taken with serviceId to find an instance.
      server_url: ${client.tokenKeyServerUrl:}
      # key serviceId for key distribution service, it will be used if above server_url is not configured.
      serviceId: ${client.tokenKeyServiceId:com.networknt.oauth2-key-1.0.0}
      # the path for the key distribution endpoint
      uri: ${client.tokenKeyUri:/oauth2/key}
      # client_id used to access key distribution service. It can be the same client_id with token service or not.
      client_id: ${client.tokenKeyClientId:f7d42348-c647-4efb-a52d-4c5787421e72}
      # client secret used to access the key distribution service.
      client_secret: ${client.tokenKeyClientSecret:f6h1FTI8Q3-7UScPZDzfXA}
      # set to true if the oauth2 provider supports HTTP/2
      enableHttp2: ${client.tokenKeyEnableHttp2:true}
      # The serviceId to the service specific OAuth 2.0 configuration. Used only when multipleOAuthServer is
      # set as true. For detailed config options, please see the values.yml in the client module test.
      serviceIdAuthServers: ${client.tokenKeyServiceIdAuthServers:}
  # sign endpoint configuration
  sign:
    # token server url. The default port number for token service is 6882. If this url exists, it will be used.
    # if it is not set, then a service lookup against serviceId will be taken to discover an instance.
    # server_url: ${client.signServerUrl:https://localhost:6882}
    # For users who leverage SaaS OAuth 2.0 provider from lightapi.net or others in the public cloud
    # and has an internal proxy server to access code, token and key services of OAuth 2.0, set up the
    # proxyHost here for the HTTPS traffic. This option is only working with server_url and serviceId
    # below should be commented out. OAuth 2.0 services cannot be discovered if a proxy server is used.
    # proxyHost: ${client.signProxyHost:proxy.lightapi.net}
    # We only support HTTPS traffic for the proxy and the default port is 443. If your proxy server has
    # a different port, please specify it here. If proxyHost is available and proxyPort is missing, then
    # the default value 443 is going to be used for the HTTP connection.
    # proxyPort: ${client.signProxyPort:3128}
    # token serviceId. If server_url doesn't exist, the serviceId will be used to lookup the token service.
    serviceId: ${client.signServiceId:com.networknt.oauth2-token-1.0.0}
    # signing endpoint for the sign request
    uri: ${client.signUri:/oauth2/token}
    # timeout in milliseconds
    timeout: ${client.signTimeout:2000}
    # set to true if the oauth2 provider supports HTTP/2
    enableHttp2: ${client.signEnableHttp2:true}
    # client_id for client authentication
    client_id: ${client.signClientId:f7d42348-c647-4efb-a52d-4c5787421e72}
    # client secret for client authentication and it can be encrypted here.
    client_secret: ${client.signClientSecret:f6h1FTI8Q3-7UScPZDzfXA}
    # the key distribution sever config for sign. It can be different then token key distribution server.
    key:
      # key distribution server url. It will be used to establish connection if it exists.
      # if it is not set, then a service lookup against serviceId will be taken to discover an instance.
      # server_url: ${client.signKeyServerUrl:https://localhost:6886}
      # the unique service id for key distribution service, it will be used to lookup key service if above url doesn't exist.
      serviceId: ${client.signKeyServiceId:com.networknt.oauth2-key-1.0.0}
      # the path for the key distribution endpoint
      uri: ${client.signKeyUri:/oauth2/key}
      # client_id used to access key distribution service. It can be the same client_id with token service or not.
      client_id: ${client.signKeyClientId:f7d42348-c647-4efb-a52d-4c5787421e72}
      # client secret used to access the key distribution service.
      client_secret: ${client.signKeyClientSecret:f6h1FTI8Q3-7UScPZDzfXA}
      # set to true if the oauth2 provider supports HTTP/2
      enableHttp2: ${client.signKeyEnableHttp2:true}
  # de-ref by reference token to JWT token. It is separate service as it might be the external OAuth 2.0 provider.
  deref:
    # Token service server url, this might be different than the above token server url. The static url will be used if it is configured.
    # server_url: ${client.derefServerUrl:https://localhost:6882}
    # For users who leverage SaaS OAuth 2.0 provider in the public cloud and has an internal
    # proxy server to access code, token and key services of OAuth 2.0, set up the proxyHost
    # here for the HTTPS traffic. This option is only working with server_url and serviceId
    # below should be commented out. OAuth 2.0 services cannot be discovered if a proxy is used.
    # proxyHost: ${client.derefProxyHost:proxy.lightapi.net}
    # We only support HTTPS traffic for the proxy and the default port is 443. If your proxy server has
    # a different port, please specify it here. If proxyHost is available and proxyPort is missing, then
    # the default value 443 is going to be used for the HTTP connection.
    # proxyPort: ${client.derefProxyPort:3128}
    # token service unique id for OAuth 2.0 provider. Need for service lookup/discovery. It will be used if above server_url is not configured.
    serviceId: ${client.derefServiceId:com.networknt.oauth2-token-1.0.0}
    # set to true if the oauth2 provider supports HTTP/2
    enableHttp2: ${client.derefEnableHttp2:true}
    # the path for the key distribution endpoint
    uri: ${client.derefUri:/oauth2/deref}
    # client_id used to access key distribution service. It can be the same client_id with token service or not.
    client_id: ${client.derefClientId:f7d42348-c647-4efb-a52d-4c5787421e72}
    # client_secret for deref
    client_secret: ${client.derefClientSecret:f6h1FTI8Q3-7UScPZDzfXA}
# If you have multiple OAuth 2.0 providers and use path prefix to decide which OAuth 2.0 server
# to get the token or JWK. If two or more services have the same path, you must use serviceId in
# the request header to use the serviceId to find the OAuth 2.0 provider configuration.
pathPrefixServices: ${client.pathPrefixServices:}
# circuit breaker configuration for the client
request:
  # number of timeouts/errors to break the circuit
  errorThreshold: ${client.errorThreshold:2}
  # timeout in millisecond to indicate a client error.
  timeout: ${client.timeout:3000}
  # reset the circuit after this timeout in millisecond
  resetTimeout: ${client.resetTimeout:7000}
  # if open tracing is enabled. traceability, correlation and metrics should not be in the chain if opentracing is used.
  injectOpenTracing: ${client.injectOpenTracing:false}
  # inject serviceId as callerId into the http header for metrics to collect the caller. The serviceId is from server.yml
  injectCallerId: ${client.injectCallerId:false}
  # the flag to indicate whether http/2 is enabled when calling client.callService()
  enableHttp2: ${client.enableHttp2:true}
  # the maximum host capacity of connection pool
  connectionPoolSize: ${client.connectionPoolSize:1000}
  # Connection expire time when connection pool is used. By default, the cached connection will be closed after 30 minutes.
  # This is one way to force the connection to be closed so that the client-side discovery can be balanced.
  connectionExpireTime: ${client.connectionExpireTime:1800000}
  # The maximum request limitation for each connection in the connection pool. By default, a connection will be closed after
  # sending 1 million requests. This is one way to force the client-side discovery to re-balance the connections.
  maxReqPerConn: ${client.maxReqPerConn:1000000}
  # maximum quantity of connection in connection pool for each host
  maxConnectionNumPerHost: ${client.maxConnectionNumPerHost:1000}
  # minimum quantity of connection in connection pool for each host. The corresponding connection number will shrink to minConnectionNumPerHost
  # by remove least recently used connections when the connection number of a host reach 0.75 * maxConnectionNumPerHost.
  minConnectionNumPerHost: ${client.minConnectionNumPerHost:250}

tls:
  ...
  trustStore: ssl/client.truststore
  ...
  keyStore: ssl/client.keystore
  ...

tls:
  ...
  trustStore: client.truststore
  ...
  keyStore: client.keystore
  ...

# This file contains all the secrets for the server and client in order to manage and
# secure all of them in the same place. In Kubernetes, this file will be mapped to
# Secrets and all other config files will be mapped to mapConfig

---

# Sever section

# Key store password, the path of keystore is defined in server.yml
serverKeystorePass: password

# Key password, the key is in keystore
serverKeyPass: password

# Trust store password, the path of truststore is defined in server.yml
serverTruststorePass: password


# Client section

# Key store password, the path of keystore is defined in server.yml
clientKeystorePass: password

# Key password, the key is in keystore
clientKeyPass: password

# Trust store password, the path of truststore is defined in server.yml
clientTruststorePass: password

# Authorization code client secret for OAuth2 server
authorizationCodeClientSecret: f6h1FTI8Q3-7UScPZDzfXA

# Client credentials client secret for OAuth2 server
clientCredentialsClientSecret: f6h1FTI8Q3-7UScPZDzfXA

# Fresh token client secret for OAuth2 server
refreshTokenClientSecret: f6h1FTI8Q3-7UScPZDzfXA

# Key distribution client secret for OAuth2 server
keyClientSecret: f6h1FTI8Q3-7UScPZDzfXA

# De-Reference access token to JWT token client secret.
derefClientSecret: f6h1FTI8Q3-7UScPZDzfXA

# Consul service registry and discovery

# Consul Token for service registry and discovery
consulToken: token1

# EmailSender password default address is [email protected]
emailPassword: change-to-real-password