Killing java processes started from Port.open

Yes, if you want proper cleanup, the external program has to be well-behaved. I’ve briefly touched on that in the article, in the “program termination” section. So basically, you need to make the Java program terminate if you receive EOF on stdin. No idea how this can be done in Java, but I’d be surprised if this wasn’t possible

If you don’t control the external program, you could use erlport, which will automatically terminate the external program if the owner beam process (or the entire beam node) stops.

Besides of the already mentioned erlport there are a couple of other projects available, like porcelain which relies on a wrapper written in Golang, which has to be installed seperately, or rambo which explicitely not only manages the lifecycle of the program, but also is able to wrap those programs that do only print their own reply after stdin got closed. Its wrapper is written in Rust, and as far as I remember you need to have rust installed to compile the library.

Thanks - I’m watching for EOF in my code and that doesn’t appear to be triggering. I’ll double-check and go to ErlPort if I can’t get it working.

Thanks @NobbZ - I have no problem receiving the inputs from the external process, it’s just shutting it down cleanly afterwards that’s the problem.

I’ll double-check receives of EOF first, then I’ll try on Linux to see if there is some weird Windows effect, then I’ll see if ErlPorts does a more aggressive shutdown, then I’ll take a look at the other options you presented.

Thanks to you both for your suggestions. I’ll let you know how I go.

OK, problem exists between chair & keyboard. My main loop was badly behaved. I stripped it back to the most basic stdin read loop and it terminates ok. Time to start building it up again and see where it fails.

For reference, here’s a minimal Java program that works nicely over ports, terminating when the process or BEAM terminates (including brutally killing from Windows task manager):

package com.thing;
import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {
        int ch;
        while(true) {
            ch = System.in.read();
            if (ch == -1) {break;} // This is the EOF signal in Java
            if (ch == 'q') {break;}
            if (ch == 't') {System.out.println("tasks");}
            System.out.println(" got " + ch + " - " + (char)ch);
        }
    }
}

Creator of Rambo here. Don’t use libraries if you’re writing your own port. Libraries are for working around external programs that cannot be changed.

Your minimal program is a good start, just need to read (block on) standard input on another thread so your MS Project job can run.

If you don’t care about JVM startup time, just run your port with System.cmd on demand. Otherwise if your Java process is long-lived, you’ll need to consider the communication protocol between your Java and Erlang processes.

Thanks for the mention. To clarify, Rambo only requires the Rust compiler if you are not using Linux, macOS or Windows. Bundled binaries should cover most users.

Thanks @jayjun - yes, the java process will be long lived. I’ve worked up a more extended example that uses Erlang ETF to transmit the payload back and forth. The Ericsson JInterface library has all the parsing and packaging routines. There are a couple of gotchas that I’ll write up (eg the OtpOutputStream doesn’t write the first byte - 131 - for some reason so you have to do that by hand), but it seems pretty straightforward otherwise. The Java side can respond synchronously to each call in my case which simplifies things on that side.

Cool, just be careful of the classic pipe buffer deadlock if you’re not continuously reading while writing. And you cannot terminate early if the port is closed or if the Erlang node dies.

Thanks @jayjun - that sounds like some hard-won experience right there!