Posted on by — Leave a comment

Forward proxy_pass and add CORS headers in nginx

In the recent app that I develop, there is a situation like this: The API, created with Spring Boot . The Angular app calls the API but got a CORS error. I did a few searches online and found out that I need to add additional configuration in the code.

The problem is since I have a haproxy instance that does all the CORS things on the production server, adding the configuration to spring boot just for development doesn’t make much sense to me.

You may say, let’s use HAproxy on the development server. Well, that is a good option. However, setting up haproxy on Windows is not simple, and using Docker Desktop seems a bit overkill.

So, nginx is the most sensible choice.

And it turned out, it’s quite easy to setup with nginx too.

The flow

The request flow now becomes something like this. Instead of calling the API directly from the Angular app, we will call the Nginx proxy.

When the API returns, we add the CORS header so our browser will not complain about the missing headers.

The code

First, download Nginx here http://nginx.org/en/download.html and extract it somewhere on your Windows machine.

Now, open the conf folder and edit the file name nginx.conf then put the following content in:


#user  nobody;
worker_processes  1;

#error_log  logs/error.log;
#error_log  logs/error.log  notice;
#error_log  logs/error.log  info;

#pid        logs/nginx.pid;


events {
    worker_connections  1024;
}


http {
    include       mime.types;
    default_type  application/octet-stream;

    #log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
    #                  '$status $body_bytes_sent "$http_referer" '
    #                  '"$http_user_agent" "$http_x_forwarded_for"';

    #access_log  logs/access.log  main;

    sendfile        on;
    #tcp_nopush     on;

    #keepalive_timeout  0;
    keepalive_timeout  65;
  server {
      listen       8081;

      server_name  localhost;


      location / {
          add_header Content-Type text/plain;
          add_header 'Access-Control-Allow-Origin' '*'  always;
          add_header 'Access-Control-Max-Age' '3600'  always;
          add_header 'Access-Control-Allow-Methods' 'GET, POST, PUT, DELETE, OPTIONS' always;
          add_header 'Access-Control-Allow-Headers' '*' always;

          if ($request_method = OPTIONS ) {
              return 200;
          }

          proxy_set_header X-Real-IP $remote_addr;
          proxy_set_header Host $host;
          proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
          proxy_pass http://192.168.100.6:8080;
          proxy_pass_request_headers      on;
      }


  }
  
}

And that’s all you need to code. Click on the nginx.exe file to see all the requests flow through and the CORS headers are added to the response.

A note for docker users

If you prefer to use docker, the implementation could be a bit different:

  1. Put the content below in /etc/nginx/conf.d/default.conf
  2. You probably want to set the port number at the line #2 to 80 since it’s an nginx container we are running. You also need to map port 8081 to 80 of the container.
  3. The URL at the line #21 also need to change. When running in docker image, localhost is not your localhost anymore. You may need to put the IP of your pc here to make it works.
server {
    listen       8081;

    server_name  localhost;


    location / {
        add_header Content-Type text/plain;
        add_header 'Access-Control-Allow-Origin' '*'  always;
        add_header 'Access-Control-Max-Age' '3600'  always;
        add_header 'Access-Control-Allow-Methods' 'GET, POST, PUT, DELETE, OPTIONS' always;
        add_header 'Access-Control-Allow-Headers' '*' always;
        
        if ($request_method = OPTIONS ) {
            return 200;
        }
        
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header Host $host;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_pass http://192.168.100.6:8080;
        proxy_pass_request_headers      on;
    }


}
Posted on by — Leave a comment

[Java Concurrency] 03: Callable

In the previous article, you’ve already known about the Runnable interface. To execute a task, you can simply create a class implement Runnable and pass an instance of that class in a thread.

Runnable instances don’t provide a return value, you may need a different solution if your use case requires capturing return values.

Introducing Callable

Similar to Runnable, the Callable interface is a functional interface. One of the key differences is you can return a value if your class implement Callable.

Let’s create a class implementing Callable:

package com.datmt.concurrency.java.simpletasks;

import java.util.concurrent.Callable;

public class D_SimpleCallableTask implements Callable<String> {
    private static int instanceCount;
    @Override
    public String call() throws Exception {
        try {

            System.out.println("START: D_SimpleCallableTask in "  + Thread.currentThread().getName() + " with instance #" + instanceCount);
            Thread.sleep(1000);

            System.out.println("DONE: D_SimpleCallableTask in "  + Thread.currentThread().getName()  + " with instance #" + instanceCount);

        } catch (InterruptedException ex) {
            ex.printStackTrace();
            return null;
        } finally {
            instanceCount++;
        }
        return  "Done calling in D_SimpleCallableTask at instance count: " + instanceCount;

    }
}

As you can see, the class D_SimpleCallableTask emulates a long running process (takes 1 second) and then returns a string.

But how do we get the return result of a callable?

Getting the result of callables

To execute a Callable instance, we don’t use thread. Instead, we will use an ExecutorService instance. Don’t worry if you don’t know about ExecutoreService yet. We will cover that in a later article.

package com.datmt.concurrency.java.executor;

import com.datmt.concurrency.java.simpletasks.D_SimpleCallableTask;

import java.util.concurrent.*;

public class D_Executor {


    public static void main(String[] args) throws InterruptedException, ExecutionException {

        ExecutorService service = Executors.newSingleThreadExecutor();
        Callable<String> task1 = new D_SimpleCallableTask();

        Future<String> task1Result = service.submit(task1);

        System.out.println("Task 1 result: " + task1Result.get());

    }
}

As you can see, the submit method of ExecutorService takes a Callable instance and returns a Future.

To get the result, simply call the get method on the Future instance. This method will wait, if necessary, to get the result of the call method of the Callable instance.

Throwing exceptions in Callable

Unlike Runnable, you can throw exceptions in Callable instances and catch them later in the caller’s thread.

For example, this code will NOT compile:

package com.datmt.concurrency.java.simpletasks;

public class D_SimpleRunnableTask implements Runnable {

    private static int instanceCount = 0;
    @Override
    public void run() {
        try {

            System.out.println("START: D_SimpleVoidTask in "  + Thread.currentThread().getName() + " with instance #" + instanceCount);
            Thread.sleep(1000);

            System.out.println("DONE: D_SimpleVoidTask in "  + Thread.currentThread().getName()  + " with instance #" + instanceCount);
            // Throwing exception is NOT OK in Runnable
            if (instanceCount < 1)
                throw  new Exception("Because I want to");
            instanceCount++;
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }
    }
}

But this will:

package com.datmt.concurrency.java.simpletasks;

import java.util.concurrent.Callable;

public class D_SimpleCallableTask implements Callable<String> {
    private static int instanceCount;
    @Override
    public String call() throws Exception {
        try {

            System.out.println("START: D_SimpleCallableTask in "  + Thread.currentThread().getName() + " with instance #" + instanceCount);
            Thread.sleep(1000);

            System.out.println("DONE: D_SimpleCallableTask in "  + Thread.currentThread().getName()  + " with instance #" + instanceCount);
            // Throwing exception is OK in Callable
            if (instanceCount < 1)
                throw  new Exception();
        } catch (InterruptedException ex) {
            ex.printStackTrace();
            return null;
        } finally {
            instanceCount++;
        }
        return  "Done calling in D_SimpleCallableTask at instance count: " + instanceCount;

    }
}

In the caller’s thread, you can catch the exception like this:

package com.datmt.concurrency.java.executor;

import com.datmt.concurrency.java.simpletasks.D_SimpleCallableTask;

import java.util.concurrent.*;

public class D_Executor {


    public static void main(String[] args) throws InterruptedException, ExecutionException {

        ExecutorService service = Executors.newSingleThreadExecutor();
        Callable<String> task1 = new D_SimpleCallableTask();
        Callable<String> task2 = new D_SimpleCallableTask();

        try {
            Future<String> task1Result = service.submit(task1);

            System.out.println("Task 1 result: " + task1Result.get());
        } catch (Exception e) {
            System.out.println("got an exception " + e.getMessage());
        }

        Future<String> task2Result = service.submit(task2);

        System.out.println("Task 2 result: " + task2Result.get());
    }
}

Even when task1 threw an exception, task2 still running and produces the expected result:

Throwing execption and handling it in Callable

Conclusion

Callable is a very powerful interface that allows to execute long-running tasks and get the result. You can also throw exceptions in Callable and catch it later in the caller’s thread.

Posted on by — Leave a comment

[Java Concurrency] 02: Runnable

One of the methods to run tasks in multiple thead is to pass Runnable instance to thread and call that start() method.

public class D_Runnable_Thread {

    public static void main(String[] args) {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("start running task...");     
            }
        });
        
        t.start();
    }
}

Runnable is a Functional interface that has only one method that returns void.

If you prefer the lambda syntax, you can write the above code like so:

public class D_Runnable_Thread {

    public static void main(String[] args) {
        Thread t = new Thread(() -> System.out.println("start running task..."));

        t.start();
    }
}

However, for tasks with more than a few lines of code, you would prefer to create a class that implement Runnable.

Class implements Runnable

It’s quite simple to create a class implementing Runnable. You only need to implement the run() method:

public class D_Runtask implements Runnable{
    @Override
    public void run() {
        System.out.println("starting...");
        System.out.println("running...");
    }
}

Now, you can create an instance of this class and pass to a Thread to start the execution:

    public static void main(String[] args) {
        (new Thread(new D_Runtask())).start();
    }

Output:

Passing data into Runnable

In case you need to pass parameters to the job, simply pass them using constructor:


public class D_Runtask implements Runnable {
    private String name;
    public D_Runtask(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        System.out.println("starting..." + this.name);
        System.out.println("running..." + this.name);
    }

    public static void main(String[] args) {
        (new Thread(new D_Runtask("Super task"))).start();
    }
}

Output: