Search in sources :

Example 1 with SenderConfiguration

use of org.wso2.transport.http.netty.contract.config.SenderConfiguration in project wso2-synapse by wso2.

the class TargetRequestHandler method createHttpClient.

public static HttpClientConnector createHttpClient(URL url, MessageContext msgContext, HttpWsConnectorFactory httpWsConnectorFactory, ConnectionManager connectionManager, BootstrapConfiguration bootstrapConfiguration, TargetConfiguration targetConfiguration) throws AxisFault {
    try {
        SenderConfiguration senderConfiguration = new SenderConfiguration();
        populateSenderConfigurations(msgContext, senderConfiguration, targetConfiguration, url);
        return httpWsConnectorFactory.createHttpClientConnector(bootstrapConfiguration, senderConfiguration, connectionManager);
    } catch (Exception ex) {
        throw new AxisFault("Error while creating the HTTP Client Connector. ", ex);
    }
}
Also used : AxisFault(org.apache.axis2.AxisFault) SenderConfiguration(org.wso2.transport.http.netty.contract.config.SenderConfiguration) MalformedURLException(java.net.MalformedURLException) IOException(java.io.IOException)

Example 2 with SenderConfiguration

use of org.wso2.transport.http.netty.contract.config.SenderConfiguration in project ballerina by ballerina-lang.

the class CreateHttpClient method populateSenderConfigurationOptions.

private void populateSenderConfigurationOptions(SenderConfiguration senderConfiguration, Struct clientEndpointConfig) {
    ProxyServerConfiguration proxyServerConfiguration = null;
    boolean followRedirect = false;
    int maxRedirectCount = DEFAULT_MAX_REDIRECT_COUNT;
    Struct followRedirects = clientEndpointConfig.getStructField(HttpConstants.FOLLOW_REDIRECT_STRUCT_REFERENCE);
    if (followRedirects != null) {
        followRedirect = followRedirects.getBooleanField(HttpConstants.FOLLOW_REDIRECT_ENABLED);
        maxRedirectCount = (int) followRedirects.getIntField(HttpConstants.FOLLOW_REDIRECT_MAXCOUNT);
    }
    Struct secureSocket = null;
    Value[] targetServices = clientEndpointConfig.getArrayField(HttpConstants.TARGET_SERVICES);
    for (Value targetService : targetServices) {
        secureSocket = targetService.getStructValue().getStructField(HttpConstants.ENDPOINT_CONFIG_SECURE_SOCKET);
        if (secureSocket != null) {
            Struct trustStore = secureSocket.getStructField(HttpConstants.ENDPOINT_CONFIG_TRUST_STORE);
            Struct keyStore = secureSocket.getStructField(HttpConstants.ENDPOINT_CONFIG_KEY_STORE);
            Struct protocols = secureSocket.getStructField(HttpConstants.ENDPOINT_CONFIG_PROTOCOLS);
            Struct validateCert = secureSocket.getStructField(HttpConstants.ENDPOINT_CONFIG_VALIDATE_CERT);
            List<Parameter> clientParams = new ArrayList<>();
            if (trustStore != null) {
                String trustStoreFile = trustStore.getStringField(HttpConstants.FILE_PATH);
                if (StringUtils.isNotBlank(trustStoreFile)) {
                    senderConfiguration.setTrustStoreFile(trustStoreFile);
                }
                String trustStorePassword = trustStore.getStringField(HttpConstants.PASSWORD);
                if (StringUtils.isNotBlank(trustStorePassword)) {
                    senderConfiguration.setTrustStorePass(trustStorePassword);
                }
            }
            if (keyStore != null) {
                String keyStoreFile = keyStore.getStringField(HttpConstants.FILE_PATH);
                if (StringUtils.isNotBlank(keyStoreFile)) {
                    senderConfiguration.setKeyStoreFile(keyStoreFile);
                }
                String keyStorePassword = keyStore.getStringField(HttpConstants.PASSWORD);
                if (StringUtils.isNotBlank(keyStorePassword)) {
                    senderConfiguration.setKeyStorePassword(keyStorePassword);
                }
            }
            if (protocols != null) {
                String sslEnabledProtocols = protocols.getStringField(HttpConstants.ENABLED_PROTOCOLS);
                if (StringUtils.isNotBlank(sslEnabledProtocols)) {
                    Parameter clientProtocols = new Parameter(HttpConstants.SSL_ENABLED_PROTOCOLS, sslEnabledProtocols);
                    clientParams.add(clientProtocols);
                }
                String sslProtocol = protocols.getStringField(HttpConstants.PROTOCOL_VERSION);
                if (StringUtils.isNotBlank(sslProtocol)) {
                    senderConfiguration.setSSLProtocol(sslProtocol);
                }
            }
            if (validateCert != null) {
                boolean validateCertEnabled = validateCert.getBooleanField(HttpConstants.ENABLE);
                int cacheSize = (int) validateCert.getIntField(HttpConstants.SSL_CONFIG_CACHE_SIZE);
                int cacheValidityPeriod = (int) validateCert.getIntField(HttpConstants.SSL_CONFIG_CACHE_VALIDITY_PERIOD);
                senderConfiguration.setValidateCertEnabled(validateCertEnabled);
                if (cacheValidityPeriod != 0) {
                    senderConfiguration.setCacheValidityPeriod(cacheValidityPeriod);
                }
                if (cacheSize != 0) {
                    senderConfiguration.setCacheSize(cacheSize);
                }
            }
            boolean hostNameVerificationEnabled = secureSocket.getBooleanField(HttpConstants.SSL_CONFIG_HOST_NAME_VERIFICATION_ENABLED);
            senderConfiguration.setHostNameVerificationEnabled(hostNameVerificationEnabled);
            String ciphers = secureSocket.getStringField(HttpConstants.SSL_CONFIG_CIPHERS);
            if (StringUtils.isNotBlank(ciphers)) {
                Parameter clientCiphers = new Parameter(HttpConstants.CIPHERS, ciphers);
                clientParams.add(clientCiphers);
            }
            String enableSessionCreation = String.valueOf(secureSocket.getBooleanField(HttpConstants.SSL_CONFIG_ENABLE_SESSION_CREATION));
            Parameter clientEnableSessionCreation = new Parameter(HttpConstants.SSL_CONFIG_ENABLE_SESSION_CREATION, enableSessionCreation);
            clientParams.add(clientEnableSessionCreation);
            if (!clientParams.isEmpty()) {
                senderConfiguration.setParameters(clientParams);
            }
        }
    }
    Struct proxy = clientEndpointConfig.getStructField(HttpConstants.PROXY_STRUCT_REFERENCE);
    if (proxy != null) {
        String proxyHost = proxy.getStringField(HttpConstants.PROXY_HOST);
        int proxyPort = (int) proxy.getIntField(HttpConstants.PROXY_PORT);
        String proxyUserName = proxy.getStringField(HttpConstants.PROXY_USERNAME);
        String proxyPassword = proxy.getStringField(HttpConstants.PROXY_PASSWORD);
        try {
            proxyServerConfiguration = new ProxyServerConfiguration(proxyHost, proxyPort);
        } catch (UnknownHostException e) {
            throw new BallerinaConnectorException("Failed to resolve host" + proxyHost, e);
        }
        if (!proxyUserName.isEmpty()) {
            proxyServerConfiguration.setProxyUsername(proxyUserName);
        }
        if (!proxyPassword.isEmpty()) {
            proxyServerConfiguration.setProxyPassword(proxyPassword);
        }
        senderConfiguration.setProxyServerConfiguration(proxyServerConfiguration);
    }
    senderConfiguration.setFollowRedirect(followRedirect);
    senderConfiguration.setMaxRedirectCount(maxRedirectCount);
    // For the moment we don't have to pass it down to transport as we only support
    // chunking. Once we start supporting gzip, deflate, etc, we need to parse down the config.
    String transferEncoding = clientEndpointConfig.getEnumField(HttpConstants.CLIENT_EP_TRNASFER_ENCODING);
    if (transferEncoding != null && !HttpConstants.ANN_CONFIG_ATTR_CHUNKING.equalsIgnoreCase(transferEncoding)) {
        throw new BallerinaConnectorException("Unsupported configuration found for Transfer-Encoding : " + transferEncoding);
    }
    String chunking = clientEndpointConfig.getEnumField(HttpConstants.CLIENT_EP_CHUNKING);
    senderConfiguration.setChunkingConfig(HttpUtil.getChunkConfig(chunking));
    long endpointTimeout = clientEndpointConfig.getIntField(HttpConstants.CLIENT_EP_ENDPOINT_TIMEOUT);
    if (endpointTimeout < 0 || !isInteger(endpointTimeout)) {
        throw new BallerinaConnectorException("invalid idle timeout: " + endpointTimeout);
    }
    senderConfiguration.setSocketIdleTimeout((int) endpointTimeout);
    boolean isKeepAlive = clientEndpointConfig.getBooleanField(HttpConstants.CLIENT_EP_IS_KEEP_ALIVE);
    senderConfiguration.setKeepAlive(isKeepAlive);
    String httpVersion = clientEndpointConfig.getStringField(HttpConstants.CLIENT_EP_HTTP_VERSION);
    if (httpVersion != null) {
        senderConfiguration.setHttpVersion(httpVersion);
    }
    String forwardedExtension = clientEndpointConfig.getStringField(HttpConstants.CLIENT_EP_FORWARDED);
    senderConfiguration.setForwardedExtensionConfig(HttpUtil.getForwardedExtensionConfig(forwardedExtension));
}
Also used : BallerinaConnectorException(org.ballerinalang.connector.api.BallerinaConnectorException) UnknownHostException(java.net.UnknownHostException) ArrayList(java.util.ArrayList) BStruct(org.ballerinalang.model.values.BStruct) Struct(org.ballerinalang.connector.api.Struct) ProxyServerConfiguration(org.wso2.transport.http.netty.common.ProxyServerConfiguration) Value(org.ballerinalang.connector.api.Value) Parameter(org.wso2.transport.http.netty.config.Parameter)

Example 3 with SenderConfiguration

use of org.wso2.transport.http.netty.contract.config.SenderConfiguration in project ballerina by ballerina-lang.

the class CreateHttpClient method execute.

@Override
public void execute(Context context) {
    BStruct configBStruct = (BStruct) context.getRefArgument(0);
    Struct clientEndpointConfig = BLangConnectorSPIUtil.toStruct(configBStruct);
    String url = context.getStringArgument(0);
    HttpConnectionManager connectionManager = HttpConnectionManager.getInstance();
    String scheme;
    if (url.startsWith("http://")) {
        scheme = HttpConstants.PROTOCOL_HTTP;
    } else if (url.startsWith("https://")) {
        scheme = HttpConstants.PROTOCOL_HTTPS;
    } else {
        throw new BallerinaException("malformed URL: " + url);
    }
    Map<String, Object> properties = HTTPConnectorUtil.getTransportProperties(connectionManager.getTransportConfig());
    SenderConfiguration senderConfiguration = HTTPConnectorUtil.getSenderConfiguration(connectionManager.getTransportConfig(), scheme);
    if (connectionManager.isHTTPTraceLoggerEnabled()) {
        senderConfiguration.setHttpTraceLogEnabled(true);
    }
    senderConfiguration.setTLSStoreType(HttpConstants.PKCS_STORE_TYPE);
    populateSenderConfigurationOptions(senderConfiguration, clientEndpointConfig);
    Struct connectionThrottling = clientEndpointConfig.getStructField(HttpConstants.CONNECTION_THROTTLING_STRUCT_REFERENCE);
    if (connectionThrottling != null) {
        long maxActiveConnections = connectionThrottling.getIntField(HttpConstants.CONNECTION_THROTTLING_MAX_ACTIVE_CONNECTIONS);
        if (!isInteger(maxActiveConnections)) {
            throw new BallerinaConnectorException("invalid maxActiveConnections value: " + maxActiveConnections);
        }
        senderConfiguration.getPoolConfiguration().setMaxActivePerPool((int) maxActiveConnections);
        long waitTime = connectionThrottling.getIntField(HttpConstants.CONNECTION_THROTTLING_WAIT_TIME);
        senderConfiguration.getPoolConfiguration().setMaxWaitTime(waitTime);
    }
    HttpClientConnector httpClientConnector = httpConnectorFactory.createHttpClientConnector(properties, senderConfiguration);
    BStruct httpClient = BLangConnectorSPIUtil.createBStruct(context.getProgramFile(), HTTP_PACKAGE_PATH, HTTP_CLIENT, url, clientEndpointConfig);
    httpClient.addNativeData(HttpConstants.HTTP_CLIENT, httpClientConnector);
    httpClient.addNativeData(HttpConstants.CLIENT_ENDPOINT_CONFIG, clientEndpointConfig);
    context.setReturnValues(httpClient);
}
Also used : BStruct(org.ballerinalang.model.values.BStruct) BallerinaConnectorException(org.ballerinalang.connector.api.BallerinaConnectorException) HttpClientConnector(org.wso2.transport.http.netty.contract.HttpClientConnector) HttpConnectionManager(org.ballerinalang.net.http.HttpConnectionManager) SenderConfiguration(org.wso2.transport.http.netty.config.SenderConfiguration) BallerinaException(org.ballerinalang.util.exceptions.BallerinaException) BStruct(org.ballerinalang.model.values.BStruct) Struct(org.ballerinalang.connector.api.Struct)

Aggregations

BallerinaConnectorException (org.ballerinalang.connector.api.BallerinaConnectorException)2 Struct (org.ballerinalang.connector.api.Struct)2 BStruct (org.ballerinalang.model.values.BStruct)2 IOException (java.io.IOException)1 MalformedURLException (java.net.MalformedURLException)1 UnknownHostException (java.net.UnknownHostException)1 ArrayList (java.util.ArrayList)1 AxisFault (org.apache.axis2.AxisFault)1 Value (org.ballerinalang.connector.api.Value)1 HttpConnectionManager (org.ballerinalang.net.http.HttpConnectionManager)1 BallerinaException (org.ballerinalang.util.exceptions.BallerinaException)1 ProxyServerConfiguration (org.wso2.transport.http.netty.common.ProxyServerConfiguration)1 Parameter (org.wso2.transport.http.netty.config.Parameter)1 SenderConfiguration (org.wso2.transport.http.netty.config.SenderConfiguration)1 HttpClientConnector (org.wso2.transport.http.netty.contract.HttpClientConnector)1 SenderConfiguration (org.wso2.transport.http.netty.contract.config.SenderConfiguration)1