camel-issues mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From "Roman Vottner (JIRA)" <j...@apache.org>
Subject [jira] [Created] (CAMEL-11998) Configuring SSL via endpointProperty in restConfiguration for an Undertow component will cause a BindException for multiple endpoints
Date Wed, 08 Nov 2017 15:30:00 GMT
Roman Vottner created CAMEL-11998:
-------------------------------------

             Summary: Configuring SSL via endpointProperty in restConfiguration for an Undertow
component will cause a BindException for multiple endpoints
                 Key: CAMEL-11998
                 URL: https://issues.apache.org/jira/browse/CAMEL-11998
             Project: Camel
          Issue Type: Bug
          Components: camel-undertow
    Affects Versions: 2.20.0, 2.19.0
         Environment: MacBookPro 15' with Mac OS X (10.12.6), Oracle Java 1.8.144
            Reporter: Roman Vottner


On recreating the test case depicted in https://github.com/apache/camel/blob/master/components/camel-undertow/src/test/java/org/apache/camel/component/undertow/rest/RestApiUndertowTest.java
and activating SSL configuration, I noticed that multiple endpoints exposed will configure
multiple Undertow consumers which all try to bind onto the same port and thus throw a BindException.

The full Test-Code looks as follows:
{code:java}
import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.CoreMatchers.is;

import at.rovo.utils.TestHttpClient;
import io.undertow.server.HttpServerExchange;
import java.net.InetSocketAddress;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import javax.annotation.Resource;
import javax.net.ssl.SSLSession;
import org.apache.camel.CamelContext;
import org.apache.camel.Exchange;
import org.apache.camel.builder.RouteBuilder;
import org.apache.camel.component.properties.PropertiesComponent;
import org.apache.camel.component.undertow.RestUndertowHttpBinding;
import org.apache.camel.component.undertow.UndertowHttpBinding;
import org.apache.camel.model.rest.RestParamType;
import org.apache.camel.spring.javaconfig.CamelConfiguration;
import org.apache.camel.test.spring.CamelSpringRunner;
import org.apache.camel.test.spring.CamelTestContextBootstrapper;
import org.apache.camel.util.jsse.KeyManagersParameters;
import org.apache.camel.util.jsse.KeyStoreParameters;
import org.apache.camel.util.jsse.SSLContextParameters;
import org.apache.camel.util.jsse.TrustManagersParameters;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.core.env.Environment;
import org.springframework.test.context.BootstrapWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.support.AnnotationConfigContextLoader;

@RunWith(CamelSpringRunner.class)
@BootstrapWith(CamelTestContextBootstrapper.class)
@ContextConfiguration(loader = AnnotationConfigContextLoader.class,
    classes = {UndertowRouteTest.ContextConfig.class})
public class UndertowRouteTest {

  private static final String REMOTE_IP = "REMOTE_IP";
  private static final String REMOTE_PORT = "REMOTE_PORT";
  private static final String USER_AGENT = "USER_AGENT";
  private static final String TLS_PROTOCOL_VERSION = "TLS_PROTOCOL_VERSION";
  private static final String TLS_CIPHER_SUITE = "TLS_CIPHER_SUITE";

  @Configuration
  @PropertySource({"classpath:services-test.properties"})
  public static class ContextConfig extends CamelConfiguration {

    @Resource
    private Environment env;

    @Bean(name = "undertowHttpBinding")
    public UndertowHttpBinding undertowHttpBinding() {
      return new IPResolvableRestUndertowHttpBinding();
    }

    public static class IPResolvableRestUndertowHttpBinding extends RestUndertowHttpBinding
{

      @Override
      public void populateCamelHeaders(HttpServerExchange httpExchange, Map<String, Object>
headersMap, Exchange exchange) throws Exception {
        super.populateCamelHeaders(httpExchange, headersMap, exchange);

        InetSocketAddress peer = httpExchange.getSourceAddress();
        headersMap.put(REMOTE_IP, peer.getAddress().getHostAddress());
        headersMap.put(REMOTE_PORT, peer.getPort());
        for (String key : headersMap.keySet()) {
          if (key.toLowerCase().equals("user-agent")) {
            headersMap.put(USER_AGENT, headersMap.get(key));
          }
        }

        if (null != httpExchange.getConnection().getSslSessionInfo()
            && null != httpExchange.getConnection().getSslSessionInfo().getSSLSession())
{

          SSLSession sslSession = httpExchange.getConnection().getSslSessionInfo().getSSLSession();
          exchange.getIn().setHeader(TLS_PROTOCOL_VERSION, sslSession.getProtocol());
          exchange.getIn().setHeader(TLS_CIPHER_SUITE, sslSession.getCipherSuite());
        }
      }
    }

    @Bean(name = "sslContextParameters")
    public SSLContextParameters sslContextParameters() {
      String keyStore = env.getProperty("ssl.keyStore.resource");
      URL keyStoreUrl = this.getClass().getResource(keyStore);

      KeyStoreParameters ksp = new KeyStoreParameters();
      ksp.setResource(keyStoreUrl.getPath());
      ksp.setPassword(env.getProperty("ssl.keyStore.password"));

      KeyManagersParameters kmp = new KeyManagersParameters();
      kmp.setKeyStore(ksp);
      kmp.setKeyPassword(env.getProperty("ssl.key.password"));

      String trustStore = env.getProperty("ssl.trustStore.resource");
      URL trustStoreUrl = this.getClass().getResource(trustStore);

      KeyStoreParameters tsp = new KeyStoreParameters();
      tsp.setResource(trustStoreUrl.getPath());
      tsp.setPassword(env.getProperty("ssl.trustStore.password"));

      TrustManagersParameters tmp = new TrustManagersParameters();
      tmp.setKeyStore(tsp);

      SSLContextParameters scp = new SSLContextParameters();
      scp.setKeyManagers(kmp);
      scp.setTrustManagers(tmp);
      return scp;
    }

    @Override
    public void setupCamelContext(CamelContext camelContext) throws Exception {
      super.setupCamelContext(camelContext);
      PropertiesComponent pc =
          new PropertiesComponent("classpath:" + env.getProperty("propertyfile"));
      camelContext.addComponent("properties", pc);
    }

    @Override
    public List<RouteBuilder> routes() {
      final List<RouteBuilder> routes = new ArrayList<>();
      routes.add(new RouteBuilder() {
        @Override
        public void configure() throws Exception {
          restConfiguration()
              .component("undertow")
              .host("localhost")
              .port(8383)
              .endpointProperty("sslContextParameters", "#sslContextParameters")
              .endpointProperty("undertowHttpBinding", "#undertowHttpBinding")
//              .apiContextPath("/api-doc")
//              .apiProperty("cors", "true")
//              .apiProperty("api.title", "The hello rest thing")
//              .apiProperty("api.version", "1.2.3")
              ;

          rest("/hello").consumes("application/json").produces("application/json")
              .get("/hi/{name}").description("Saying hi")
                .param().name("name").type(RestParamType.path).dataType("string").description("Who
is it").endParam()
                .to("log:hi")
//              .get("/bye/{name}").description("Saying bye")
//                .param().name("name").type(RestParamType.path).dataType("string").description("Who
is it").endParam()
//                .responseMessage().code(200).message("A reply message").endResponseMessage()
//                .to("log:bye")
//              .post("/bye").description("To update the greeting message").consumes("application/xml").produces("application/xml")
//                .param().name("greeting").type(RestParamType.body).dataType("string").description("Message
to use as greeting").endParam()
//                .to("log:bye")
          ;
        }
      });
      return routes;
    }
  }

  @Test
  public void testRoute() throws Exception {

//    TestHttpClient client = new TestHttpClient.TestHttpClientBuilder("http://localhost:8383")
//        .build();
    TestHttpClient client = new TestHttpClient.TestHttpClientBuilder("https://localhost:8383")
        .forSSL("/ssl/clientTrust.jks", "truststorePW")
        .build();

    try {
//      TestHttpClient.Response response = client.sendGetRequest("/api-doc");
//      Assert.assertThat("Unexpected status code received: " + response.getStatusCode(),
//          response.getStatusCode(), is(equalTo(200)));

      TestHttpClient.Response response = client.sendGetRequest("/hello/hi/test");
      Assert.assertThat("Unexpected status code received: " + response.getStatusCode(),
          response.getStatusCode(), is(equalTo(200)));

//      TestHttpClient.Response response = client.sendGetRequest("/hello/bye/test");
//      Assert.assertThat("Unexpected status code received: " + response.getStatusCode(),
//          response.getStatusCode(), is(equalTo(200)));
//      Assert.assertThat(response.getContent(), is(equalTo("No response available")));
    } catch (Exception e) {
      Assert.fail("Should not have thrown an exception");
    }
  }
}
{code}

with the TestHttpClient being convenience class that wrapps an Apache HTTP 4.5 client internally:

{code:java}
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.lang.invoke.MethodHandles;
import java.net.URISyntaxException;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.CertificateException;
import java.util.HashMap;
import java.util.Map;

import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.SSLContext;

import org.apache.commons.codec.binary.Base64;
import org.apache.commons.lang.StringUtils;
import org.apache.http.Header;
import org.apache.http.HttpEntity;
import org.apache.http.HttpHost;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.AuthCache;
import org.apache.http.client.CredentialsProvider;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpDelete;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpPut;
import org.apache.http.client.protocol.HttpClientContext;
import org.apache.http.conn.ssl.DefaultHostnameVerifier;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.InputStreamEntity;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.auth.BasicScheme;
import org.apache.http.impl.client.BasicAuthCache;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.ssl.SSLContexts;
import org.apache.http.util.EntityUtils;
import org.json.JSONException;
import org.json.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * This Apache HttpClient 4.5 based test client provides convenience methods for dealing with
HTTP
 * requests and responses sent and received by invoked endpoints.
 */
@SuppressWarnings("unused")
public class TestHttpClient {

  private final static Logger LOG = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());

  private CloseableHttpClient httpClient;
  private String baseUrl;
  private HttpClientContext context = null;

  private TestHttpClient(CloseableHttpClient httpClient, HttpClientContext context, String
baseUrl) {
    this.httpClient = httpClient;
    this.baseUrl = baseUrl;
    this.context = context;
  }

  public Response sendGetRequest(String path) throws IOException {
    if (StringUtils.isBlank(path) || !path.startsWith("/")) {
      throw new IllegalArgumentException("Invalid path provided");
    }
    HttpGet httpGet = new HttpGet(baseUrl + path);

    LOG.debug("Sending GET request to {}", baseUrl + path);
    try (CloseableHttpResponse response = httpClient.execute(httpGet, context)) {
      return processResponse(response);
    }
  }

  public Response sendGetRequest(String path, Map<String, String> headers) throws IOException
{
    if (StringUtils.isBlank(path) || !path.startsWith("/")) {
      throw new IllegalArgumentException("Invalid path provided");
    }
    HttpGet httpGet = new HttpGet(baseUrl + path);
    if (headers != null) {
      for (String header : headers.keySet()) {
        httpGet.setHeader(header, headers.get(header));
      }
    }

    LOG.debug("Sending GET request to {}", baseUrl + path);
    try (CloseableHttpResponse response = httpClient.execute(httpGet, context)) {
      return processResponse(response);
    }
  }

  public Response sendDeleteRequest(String path) throws IOException {
    if (StringUtils.isBlank(path) || !path.startsWith("/")) {
      throw new IllegalArgumentException("Invalid path provided");
    }
    HttpDelete httpDelete = new HttpDelete(baseUrl + path);

    LOG.debug("Sending DELETE request to {}", baseUrl + path);
    try (CloseableHttpResponse response = httpClient.execute(httpDelete, context)) {
      return processResponse(response);
    }
  }

  public Response sendDeleteRequest(String path, Map<String, String> headers) throws
IOException {
    if (StringUtils.isBlank(path) || !path.startsWith("/")) {
      throw new IllegalArgumentException("Invalid path provided");
    }
    HttpDelete httpDelete = new HttpDelete(baseUrl + path);
    if (headers != null) {
      for (String header : headers.keySet()) {
        httpDelete.setHeader(header, headers.get(header));
      }
    }

    LOG.debug("Sending DELETE request to {}", baseUrl + path);
    try (CloseableHttpResponse response = httpClient.execute(httpDelete, context)) {
      return processResponse(response);
    }
  }

  public Response sendPostRequest(String path, String payload, String contentType) throws
IOException {
    if (StringUtils.isBlank(path) || !path.startsWith("/")) {
      throw new IllegalArgumentException("Invalid path provided");
    }
    HttpPost httpPost = new HttpPost(baseUrl+path);
    StringEntity stringPayload = new StringEntity(payload, contentType);
    httpPost.setEntity(stringPayload);

    LOG.debug("Sending POST request to {}", baseUrl + path);
    try (CloseableHttpResponse response = httpClient.execute(httpPost, context)) {
      return processResponse(response);
    }
  }

  public Response sendPostRequest(String path, Map<String, String> headers, String payload,
String contentType) throws IOException {
    if (StringUtils.isBlank(path) || !path.startsWith("/")) {
      throw new IllegalArgumentException("Invalid path provided");
    }
    HttpPost httpPost = new HttpPost(baseUrl+path);
    if (headers != null) {
      for (String header : headers.keySet()) {
        httpPost.setHeader(header, headers.get(header));
      }
    }
    StringEntity stringPayload = new StringEntity(payload, contentType);
    httpPost.setEntity(stringPayload);

    LOG.debug("Sending POST request to {}", baseUrl + path);
    try (CloseableHttpResponse response = httpClient.execute(httpPost, context)) {
      return processResponse(response);
    }
  }

  public Response sendPostRequest(String path, InputStream payload, ContentType contentType)
throws IOException {
    if (StringUtils.isBlank(path) || !path.startsWith("/")) {
      throw new IllegalArgumentException("Invalid path provided");
    }
    HttpPost httpPost = new HttpPost(baseUrl+path);
    InputStreamEntity payloadEntity = new InputStreamEntity(payload, contentType);
    httpPost.setEntity(payloadEntity);

    LOG.debug("Sending POST request to {}", baseUrl + path);
    try (CloseableHttpResponse response = httpClient.execute(httpPost, context)) {
      return processResponse(response);
    }
  }

  public Response sendPostRequest(String path, Map<String, String> headers, InputStream
payload, ContentType contentType) throws IOException {
    if (StringUtils.isBlank(path) || !path.startsWith("/")) {
      throw new IllegalArgumentException("Invalid path provided");
    }
    HttpPost httpPost = new HttpPost(baseUrl+path);
    if (headers != null) {
      for (String header : headers.keySet()) {
        httpPost.setHeader(header, headers.get(header));
      }
    }
    InputStreamEntity payloadEntity = new InputStreamEntity(payload, contentType);
    httpPost.setEntity(payloadEntity);

    LOG.debug("Sending POST request to {}", baseUrl + path);
    try (CloseableHttpResponse response = httpClient.execute(httpPost, context)) {
      return processResponse(response);
    }
  }

  public Response sendPutRequest(String path, String payload, String contentType) throws IOException
{
    if (StringUtils.isBlank(path) || !path.startsWith("/")) {
      throw new IllegalArgumentException("Invalid path provided");
    }
    HttpPut httpPut = new HttpPut(baseUrl+path);
    StringEntity stringPayload = new StringEntity(payload, contentType);
    httpPut.setEntity(stringPayload);

    LOG.debug("Sending POST request to {}", baseUrl + path);
    try (CloseableHttpResponse response = httpClient.execute(httpPut, context)) {
      return processResponse(response);
    }
  }

  public Response sendPutRequest(String path, Map<String, String> headers, String payload,
String contentType) throws IOException {
    if (StringUtils.isBlank(path) || !path.startsWith("/")) {
      throw new IllegalArgumentException("Invalid path provided");
    }
    HttpPut httpPut = new HttpPut(baseUrl+path);
    if (headers != null) {
      for (String header : headers.keySet()) {
        httpPut.setHeader(header, headers.get(header));
      }
    }
    StringEntity stringPayload = new StringEntity(payload, contentType);
    httpPut.setEntity(stringPayload);

    LOG.debug("Sending POST request to {}", baseUrl + path);
    try (CloseableHttpResponse response = httpClient.execute(httpPut, context)) {
      return processResponse(response);
    }
  }

  public Response sendPutRequest(String path, InputStream payload, ContentType contentType)
throws IOException {
    if (StringUtils.isBlank(path) || !path.startsWith("/")) {
      throw new IllegalArgumentException("Invalid path provided");
    }
    HttpPut httpPut = new HttpPut(baseUrl+path);
    InputStreamEntity payloadEntity = new InputStreamEntity(payload, contentType);
    httpPut.setEntity(payloadEntity);

    LOG.debug("Sending POST request to {}", baseUrl + path);
    try (CloseableHttpResponse response = httpClient.execute(httpPut, context)) {
      return processResponse(response);
    }
  }

  public Response sendPutRequest(String path, Map<String, String> headers, InputStream
payload, ContentType contentType) throws IOException {
    if (StringUtils.isBlank(path) || !path.startsWith("/")) {
      throw new IllegalArgumentException("Invalid path provided");
    }
    HttpPut httpPut = new HttpPut(baseUrl+path);
    if (headers != null) {
      for (String header : headers.keySet()) {
        httpPut.setHeader(header, headers.get(header));
      }
    }
    InputStreamEntity payloadEntity = new InputStreamEntity(payload, contentType);
    httpPut.setEntity(payloadEntity);

    LOG.debug("Sending POST request to {}", baseUrl + path);
    try (CloseableHttpResponse response = httpClient.execute(httpPut, context)) {
      return processResponse(response);
    }
  }

  private Response processResponse(CloseableHttpResponse response) throws IOException{
    HttpEntity entity = response.getEntity();
    Response _response = new Response();
    _response.setStatusCode(response.getStatusLine().getStatusCode());
    if (entity != null) {
      _response.setContentLength(entity.getContentLength());
    } else {
      _response.setContentLength(0L);
    }

    Map<String, String> headers = new HashMap<>();
    for (Header header : response.getAllHeaders()) {
      headers.put(header.getName(), header.getValue());
    }
    _response.setHeaders(headers);

    if (response.getStatusLine().getStatusCode() != 204 && entity != null) {
      BufferedReader reader = new BufferedReader(new InputStreamReader(entity.getContent()));
      StringBuilder sb = new StringBuilder();
      String line;
      while ((line = reader.readLine()) != null) {
        sb.append(line);
      }
      EntityUtils.consume(entity);

      LOG.debug("Received response: {}", sb.toString());
      _response.setContent(sb.toString());
      if (_response.getContentLength() <= 0) {
        _response.setContentLength(sb.length());
      }
    }
    return _response;
  }

  public static String decodeBase64(String base64) {
    return new String(Base64.decodeBase64(base64));
  }

  public static JSONObject convertResponseToJson(String response) throws JSONException {
    return new JSONObject(decodeBase64(response));
  }

  public class Response {

    private int statucCode = 400;
    private String content = null;
    private Map<String, String> headers = null;
    private long contentLength = 0L;

    Response() {

    }

    public int getStatusCode() {
      return statucCode;
    }

    void setStatusCode(int statucCode) {
      this.statucCode = statucCode;
    }

    public String getContent() {
      return content;
    }

    void setContent(String content) {
      this.content = content;
    }

    public Map<String, String> getHeaders() {
      return headers;
    }

    void setHeaders(Map<String, String> headers) {
      this.headers = headers;
    }

    public long getContentLength() {
      return this.contentLength;
    }

    void setContentLength(long contentLength) {
      this.contentLength = contentLength;
    }
  }

  /**
   * A test HTTP client based on Apache commons HTTP client
   */
  public static class TestHttpClientBuilder {

    private String protocol;
    private String host;
    private int port;
    private String truststoreLoc = null;
    private String truststorePW = null;
    private String user = null;
    private String password = null;

    public TestHttpClientBuilder(String protocol, String host, int port) {
      this.protocol = protocol;
      this.host = host;
      this.port = port;
    }

    public TestHttpClientBuilder(String url) {
      if (StringUtils.isBlank(url)) {
        throw new IllegalArgumentException("Invalid URL provided");
      }
      // separate the protocol - https://localhost:80/... --> protocol: https
      protocol = url.substring(0, url.indexOf(":"));
      if (StringUtils.isBlank(protocol) || !(protocol.equals("http") || protocol.equals("https")))
{
        throw new IllegalArgumentException("Invalid protocol specified: " + protocol);
      }
      int hostStart = protocol.length() + "://".length();
      // check if there is a path delimiter defined
      String hostPort;
      int hostPortEndPos = url.indexOf("/", hostStart);
      if (hostPortEndPos == -1) { // https://localhost:80 -> hostPort: localhost:80
        hostPort = url.substring(hostStart);
      } else { // https://localhost:80/... -> hostPort: localhost:80
        hostPort = url.substring(hostStart, hostPortEndPos);
      }
      // split host and port
      int hostEnd = hostPort.indexOf(":", hostStart);
      if (hostEnd == -1) { // https://localhost --> host: localhost
        host = hostPort;
        if ("http".equals(protocol)) {
          port = 80;
        } else if ("https".equals(protocol)) {
          port = 443;
        }
      } else { // https://localhost:80 --> host: localhost; port: 80
        host = hostPort.substring(0, hostEnd);
        port = Integer.parseInt(hostPort.substring(hostEnd + 1));
      }
    }

    public TestHttpClientBuilder forSSL(String truststoreLoc, String truststorePW) {
      this.truststoreLoc = truststoreLoc;
      this.truststorePW = truststorePW;
      return this;
    }

    public TestHttpClientBuilder withBasicAuth(String user, String password) {
      this.user = user;
      this.password = password;
      return this;
    }

    public TestHttpClient build() throws TestHttpClientBuilderException {

      HttpHost targetHost = new HttpHost(host, port, protocol);

      HttpClientBuilder httpClientBuilder = HttpClients.custom();
      if (StringUtils.isNotBlank(truststoreLoc) && StringUtils.isNotBlank(truststorePW))
{
        if ("http".equals(protocol)) {
          throw new TestHttpClientBuilderException(
              "Cannot setup SSL for HTTP protocol. Please change the protocol to HTTPS!");
        }
        try {
          httpClientBuilder.setSSLSocketFactory(initializeSSL(truststoreLoc, truststorePW));
        } catch (Exception ex) {
          throw new TestHttpClientBuilderException(ex);
        }
      }
      HttpClientContext context = HttpClientContext.create();
      if (StringUtils.isNotBlank(user) && StringUtils.isNotBlank(password)) {
        CredentialsProvider credsProvider = initializeBasicAuthentication(targetHost, user,
                                                                          password);
        httpClientBuilder
            .setDefaultCredentialsProvider(credsProvider);
        AuthCache authCache = new BasicAuthCache();
        BasicScheme basicAuth = new BasicScheme();
        authCache.put(targetHost, basicAuth);

        context.setCredentialsProvider(credsProvider);
        context.setAuthCache(authCache);
      }

      return new TestHttpClient(httpClientBuilder.build(), context, protocol+"://"+host+":"+port);
    }

    private SSLConnectionSocketFactory initializeSSL(String truststoreLoc, String truststorePW)
        throws KeyStoreException, IOException, NoSuchAlgorithmException, CertificateException,
               URISyntaxException, KeyManagementException {
      KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
      try (FileInputStream instream =
               new FileInputStream(new File(getClass().getResource(truststoreLoc).toURI())))
{
        trustStore.load(instream, truststorePW.toCharArray());
      }
      HostnameVerifier hostnameVerifier = new DefaultHostnameVerifier();
      SSLContext sslcontext = SSLContexts.custom().loadTrustMaterial(trustStore, null).build();
      return new SSLConnectionSocketFactory(sslcontext, hostnameVerifier);
    }

    private CredentialsProvider initializeBasicAuthentication(HttpHost targetHost, String
user,
                                                              String password) {
      CredentialsProvider credsProvider = new BasicCredentialsProvider();
      credsProvider.setCredentials(
          new AuthScope(targetHost.getHostName(), targetHost.getPort()),
          new UsernamePasswordCredentials(user, password));
      return credsProvider;
    }
  }
}
{code}

The `BindException` occurs if SSL is enabled and either a currently commented endpoint definition
or the swagger api configuration is reenabled. As long as there is only one rest endpoint
available or the SSL configuration disabled (including switching the test client to plain
HTTP; the other endpoints can be enabled as well) the test succeeds



--
This message was sent by Atlassian JIRA
(v6.4.14#64029)

Mime
View raw message