use of org.ballerinalang.connector.api.BallerinaConnectorException in project ballerina by ballerina-lang.
the class WebSocketServicesRegistry method addUpgradableServiceByName.
public void addUpgradableServiceByName(WebSocketService service, String basePath) {
basePath = urlDecode(basePath);
service.setBasePath(basePath);
try {
getUriTemplate().parse(basePath, service, new WebSocketDataElementFactory());
} catch (URITemplateException | UnsupportedEncodingException e) {
throw new BallerinaConnectorException(e.getMessage());
}
logger.info("Service deployed : " + service.getName() + " with context " + basePath);
}
use of org.ballerinalang.connector.api.BallerinaConnectorException 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));
}
use of org.ballerinalang.connector.api.BallerinaConnectorException in project ballerina by ballerina-lang.
the class InitEndpoint method setRequestSizeValidationConfig.
private void setRequestSizeValidationConfig(Struct requestLimits, ListenerConfiguration listenerConfiguration) {
long maxUriLength = requestLimits.getIntField(HttpConstants.REQUEST_LIMITS_MAXIMUM_URL_LENGTH);
long maxHeaderSize = requestLimits.getIntField(HttpConstants.REQUEST_LIMITS_MAXIMUM_HEADER_SIZE);
long maxEntityBodySize = requestLimits.getIntField(HttpConstants.REQUEST_LIMITS_MAXIMUM_ENTITY_BODY_SIZE);
RequestSizeValidationConfig requestSizeValidationConfig = listenerConfiguration.getRequestSizeValidationConfig();
if (maxUriLength != -1) {
if (maxUriLength >= 0) {
requestSizeValidationConfig.setMaxUriLength(Math.toIntExact(maxUriLength));
} else {
throw new BallerinaConnectorException("Invalid configuration found for maxUriLength : " + maxUriLength);
}
}
if (maxHeaderSize != -1) {
if (maxHeaderSize >= 0) {
requestSizeValidationConfig.setMaxHeaderSize(Math.toIntExact(maxHeaderSize));
} else {
throw new BallerinaConnectorException("Invalid configuration found for maxHeaderSize : " + maxHeaderSize);
}
}
if (maxEntityBodySize != -1) {
if (maxEntityBodySize >= 0) {
requestSizeValidationConfig.setMaxEntityBodySize(Math.toIntExact(maxEntityBodySize));
} else {
throw new BallerinaConnectorException("Invalid configuration found for maxEntityBodySize : " + maxEntityBodySize);
}
}
}
use of org.ballerinalang.connector.api.BallerinaConnectorException in project ballerina by ballerina-lang.
the class InitEndpoint method setSslConfig.
private ListenerConfiguration setSslConfig(Struct sslConfig, ListenerConfiguration listenerConfiguration) {
listenerConfiguration.setScheme(HttpConstants.PROTOCOL_HTTPS);
Struct trustStore = sslConfig.getStructField(HttpConstants.ENDPOINT_CONFIG_TRUST_STORE);
Struct keyStore = sslConfig.getStructField(HttpConstants.ENDPOINT_CONFIG_KEY_STORE);
Struct protocols = sslConfig.getStructField(HttpConstants.ENDPOINT_CONFIG_PROTOCOLS);
Struct validateCert = sslConfig.getStructField(HttpConstants.ENDPOINT_CONFIG_VALIDATE_CERT);
if (keyStore != null) {
String keyStoreFile = keyStore.getStringField(HttpConstants.FILE_PATH);
String keyStorePassword = keyStore.getStringField(HttpConstants.PASSWORD);
if (StringUtils.isBlank(keyStoreFile)) {
// TODO get from language pack, and add location
throw new BallerinaConnectorException("Keystore location must be provided for secure connection");
}
if (StringUtils.isBlank(keyStorePassword)) {
// TODO get from language pack, and add location
throw new BallerinaConnectorException("Keystore password value must be provided for secure connection");
}
listenerConfiguration.setKeyStoreFile(keyStoreFile);
listenerConfiguration.setKeyStorePass(keyStorePassword);
}
String sslVerifyClient = sslConfig.getStringField(HttpConstants.SSL_CONFIG_SSL_VERIFY_CLIENT);
listenerConfiguration.setVerifyClient(sslVerifyClient);
if (trustStore != null) {
String trustStoreFile = trustStore.getStringField(HttpConstants.FILE_PATH);
String trustStorePassword = trustStore.getStringField(HttpConstants.PASSWORD);
if (StringUtils.isBlank(trustStoreFile) && StringUtils.isNotBlank(sslVerifyClient)) {
// TODO get from language pack, and add location
throw new BallerinaException("Truststore location must be provided to enable Mutual SSL");
}
if (StringUtils.isBlank(trustStorePassword) && StringUtils.isNotBlank(sslVerifyClient)) {
// TODO get from language pack, and add location
throw new BallerinaException("Truststore password value must be provided to enable Mutual SSL");
}
listenerConfiguration.setTrustStoreFile(trustStoreFile);
listenerConfiguration.setTrustStorePass(trustStorePassword);
}
List<Parameter> serverParamList = new ArrayList<>();
Parameter serverParameters;
if (protocols != null) {
String sslEnabledProtocols = protocols.getStringField(HttpConstants.ENABLED_PROTOCOLS);
String sslProtocol = protocols.getStringField(HttpConstants.PROTOCOL_VERSION);
if (StringUtils.isNotBlank(sslEnabledProtocols)) {
serverParameters = new Parameter(HttpConstants.ANN_CONFIG_ATTR_SSL_ENABLED_PROTOCOLS, sslEnabledProtocols);
serverParamList.add(serverParameters);
}
if (StringUtils.isNotBlank(sslProtocol)) {
listenerConfiguration.setSSLProtocol(sslProtocol);
}
}
String cipher = sslConfig.getStringField(HttpConstants.SSL_CONFIG_CIPHERS);
if (StringUtils.isNotBlank(cipher)) {
serverParameters = new Parameter(HttpConstants.ANN_CONFIG_ATTR_CIPHERS, cipher);
serverParamList.add(serverParameters);
}
if (validateCert != null) {
boolean validateCertificateEnabled = validateCert.getBooleanField(HttpConstants.ENABLE);
long cacheSize = validateCert.getIntField(HttpConstants.SSL_CONFIG_CACHE_SIZE);
long cacheValidationPeriod = validateCert.getIntField(HttpConstants.SSL_CONFIG_CACHE_VALIDITY_PERIOD);
listenerConfiguration.setValidateCertEnabled(validateCertificateEnabled);
if (validateCertificateEnabled) {
if (cacheSize != 0) {
listenerConfiguration.setCacheSize(Math.toIntExact(cacheSize));
}
if (cacheValidationPeriod != 0) {
listenerConfiguration.setCacheValidityPeriod(Math.toIntExact(cacheValidationPeriod));
}
}
}
listenerConfiguration.setTLSStoreType(HttpConstants.PKCS_STORE_TYPE);
String serverEnableSessionCreation = String.valueOf(sslConfig.getBooleanField(HttpConstants.SSL_CONFIG_ENABLE_SESSION_CREATION));
Parameter enableSessionCreationParam = new Parameter(HttpConstants.SSL_CONFIG_ENABLE_SESSION_CREATION, serverEnableSessionCreation);
serverParamList.add(enableSessionCreationParam);
if (!serverParamList.isEmpty()) {
listenerConfiguration.setParameters(serverParamList);
}
listenerConfiguration.setId(HttpUtil.getListenerInterface(listenerConfiguration.getHost(), listenerConfiguration.getPort()));
return listenerConfiguration;
}
use of org.ballerinalang.connector.api.BallerinaConnectorException in project ballerina by ballerina-lang.
the class WebSocketDispatcher method findService.
/**
* This will find the best matching service for given web socket request.
*
* @param webSocketMessage incoming message.
* @return matching service.
*/
public static WebSocketService findService(WebSocketServicesRegistry servicesRegistry, Map<String, String> pathParams, WebSocketMessage webSocketMessage, HTTPCarbonMessage msg) {
try {
String serviceUri = webSocketMessage.getTarget();
serviceUri = servicesRegistry.refactorUri(serviceUri);
URI requestUri;
try {
requestUri = URI.create(serviceUri);
} catch (IllegalArgumentException e) {
throw new BallerinaConnectorException(e.getMessage());
}
WebSocketService service = servicesRegistry.getUriTemplate().matches(requestUri.getPath(), pathParams, webSocketMessage);
if (service == null) {
throw new BallerinaConnectorException("no Service found to handle the service request: " + serviceUri);
}
msg.setProperty(HttpConstants.QUERY_STR, requestUri.getRawQuery());
return service;
} catch (Throwable throwable) {
ErrorHandlerUtils.printError(throwable);
throw new BallerinaConnectorException("no Service found to handle the service request");
}
}
Aggregations