What is SNI? Wikipedia:

Server Name Indication (SNI) is an extension to the TLS computer networking protocol [1] by which a client indicates which hostname it is attempting to connect to at the start of the handshaking process. This allows a server to present multiple certificates on the same IP address and TCP port number and hence allows multiple secure (HTTPS) websites (or any other Service over TLS) to be served by the same IP address without requiring all those sites to use the same certificate

This should handle by JVM, unfortunately, there is a bug in the way JVM handle SNI http://bugs.java.com/bugdatabase/view_bug.do?bug_id=8144566. Oracle planned to release the fix with JDK 9.

I found a workaround solution as below:

SSLContext sslcontext = SSLContexts.createSystemDefault();
SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslcontext) {

    @Override
    public Socket connectSocket(
            int connectTimeout,
            Socket socket,
            HttpHost host,
            InetSocketAddress remoteAddress,
            InetSocketAddress localAddress,
            HttpContext context) throws IOException, ConnectTimeoutException {
        if (socket instanceof SSLSocket) {
            try {
                PropertyUtils.setProperty(socket, "host", host.getHostName());
            } catch (NoSuchMethodException ex) {
            } catch (IllegalAccessException ex) {
            } catch (InvocationTargetException ex) {
            }
        }
        return super.connectSocket(connectTimeout, socket, host, remoteAddress,
                localAddress, context);
    }

};
CloseableHttpClient httpclient = HttpClients.custom()
        .setSSLSocketFactory(sslsf)
        .build();
CloseableHttpResponse response = httpclient.execute(new HttpGet("https://verisign.com/"));
try {
    System.out.println(response.getStatusLine());
    EntityUtils.consume(response.getEntity());
} finally {
    response.close();
}

Ref:
https://issues.apache.org/jira/browse/HTTPCLIENT-1119

Originally published at ngthphat.wordpress.com on June 9, 2017.

This article shows you how to handle multipart/form-data in camel. Assume that we need to write an application that allows user to upload multiple reports via RESTful Api. To solve this requirement, we need complete steps below:

1) Tell camel which component we want to handle REST request
2) Define REST signature
3) Define a processor to extract data
4) Write unit test
5) Write Main class and test with Postman

Now, Let’s start with some dependencies as below:

<properties>
    <java.version>1.8</java.version>
    <camel.version>2.18.1</camel.version>
    <sf4j.version>1.7.21</sf4j.version>
</properties>

<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-core</artifactId>
    <version>${camel.version}</version>
</dependency>
<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-netty</artifactId>
    <version>${camel.version}</version>
</dependency>
<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-netty4-http</artifactId>
    <version>${camel.version}</version>
</dependency>
<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-test</artifactId>
    <version>${camel.version}</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>${sf4j.version}</version>
    <type>jar</type>
</dependency>
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-simple</artifactId>
    <version>${sf4j.version}</version>
</dependency>

Step 1) We will tell to camel that we will use netty4-http as Restful handler. To simplify, I add some fixed value as below. However in case of production code, you should move them to config file.

public class BaseRestRoute extends RouteBuilder {
    @Override 
    public void configure() throws Exception {
        restConfiguration().component("netty4-http")
                .host("localhost")
                .port("8881")
                .bindingMode(RestBindingMode.auto);
    }
}

Step 2) Define REST signature. One of my favorite point about camel framework its fluent api. How easy it is to define REST signature?

public class UploadReportRoute extends BaseRestRoute{
    private Processor processor;
    public UploadReportRoute(Processor processor){
        this.processor = processor;
    }
    @Override 
    public void configure() throws Exception {
        super.configure();
        rest("/upload")
                .description("Upload Multiple Report via camel and netty")
                .consumes("multipart/form-data")
                .produces("application/json")
                .post("/report")
                .to("seda:uploadReportProcessor");
        from("seda:uploadReportProcessor")
                .routeId("uploadProcessorRoute")
                .process(processor);
    }
}

We have just defined a REST API (POST — ‘/upload/report’) consume multipart/form-data and produce a result in JSON format.

Step 3) Define a camel processor to extract data from nettyHttpRequest

public class UploadProcessor implements Processor {
    private static final Logger LOGGER = LoggerFactory.getLogger(UploadProcessor.class);
    @Override 
    public void process(Exchange exchange) throws Exception {
        HttpPostRequestDecoder postRequest = new HttpPostRequestDecoder(exchange.getIn(NettyHttpMessage.class).getHttpRequest());
        getHttpDataAttributes(postRequest);
        exchange.getIn().setBody(new ResponseWrapper(ResponseStatus.Success));
    }
    public void getHttpDataAttributes(HttpPostRequestDecoder request) {
        ResponseWrapper result = new ResponseWrapper();
        try {
            for (InterfaceHttpData part : request.getBodyHttpDatas()) {
                if (part instanceof MixedAttribute) {
                    Attribute attribute = (MixedAttribute) part;
                    LOGGER.info(String.format(“Found key: %s and value: %s ", attribute.getName(), attribute.getValue()));
                } else if (part instanceof MixedFileUpload) {
                    MixedFileUpload attribute = (MixedFileUpload) part;
                    LOGGER.info(String.format("Found key: %s and value: %s ", attribute.getName(), attribute.getFilename()));
                }
            }
        } catch (IOException e) {
            String errorMsg = String.format("Cannot parse request");
            result.setMessage(errorMsg);
            LOGGER.error(errorMsg,e);
        } finally {
            request.destroy();
        }
    }
}

Step 4) Write some test

Let define some mock endpoints as below:

@Produce(uri = "direct:mockProducerRoute")
protected ProducerTemplate templateProducerRoute;
@EndpointInject(uri = "mock:mockEndRoute")
protected MockEndpoint mockEndRoute;
@Before 
public void mockEndpoints() throws Exception {
    AdviceWithRouteBuilder routeMockEndpoint = new AdviceWithRouteBuilder() {
        @Override 
        public void configure() throws Exception {
            replaceFromWith(templateProducerRoute.getDefaultEndpoint().getEndpointUri());
            interceptSendToEndpoint("direct:uploadServiceProcessor")
                    .skipSendToOriginalEndpoint()
                    .to(mockEndRoute);
        }
    };
    context.getRouteDefinition("uploadProcessorRoute").adviceWith(context, routeMockEndpoint);
}
@Override 
protected RoutesBuilder[] createRouteBuilders() throws Exception {
    return new RoutesBuilder[]{
            new UploadReportRoute(new UploadProcessor())};
}

You can checkout an example of test case in my github repo. Whenever the test case is executed, you able to see some information log as:
UploadProcessor — Found part with key: paymentMethod and value: ippOcbc
UploadProcessor — Found part with key: file and value: report_file_name.csv

Step 5) Write App class and test with Postman
Let create a new class name “App”, then add UploadReportRoute into CamelContext :

public static void main(String[] args) throws Exception {
    UploadReportRoute uploadService = new UploadReportRoute(new UploadProcessor());
    Main main = new Main();
    main.addRouteBuilder(uploadService);
    main.run(args);
}

Let start our application, after the application is started successful , you will able to see some log message as below:
[main] INFO org.apache.camel.component.netty4.SingleTCPNettyServerBootstrapFactory — ServerBootstrap binding to localhost:8881
[main] INFO org.apache.camel.component.netty4.NettyConsumer — Netty consumer bound to: localhost:8881
[main] INFO org.apache.camel.impl.DefaultCamelContext — Route: route1 started and consuming from: http://localhost:8881/upload/report?httpMethodRestrict=POST

Let do real the test with Postman:

It’s worked as expectation.

By default, netty allows upload maximum 1MB for each part file. You can increase this number by updating the BaseRestRoute:

getContext().setUseMDCLogging(true);
Long maxSize = 2L * 1024 * 1024;
restConfiguration().component("netty4-http")
        .host("localhost")
        .port("8881")
        .endpointProperty("chunkedMaxContentLength", maxSize.toString())
        .bindingMode(RestBindingMode.auto);

You can check out the source code from this link.

Originally published at ngthphat.wordpress.com on March 31, 2017.