Java 9 Process API Improvements

September 19, 2016September 19, 2016 Nenko TabakovLeave a comment

Introduction

Java 9 adds improvements to the Process API that deal with ongoing shortcommings like:

getting the PID of the running process
getting the children and/or the descendants of a process

Along with these a new class is added that helps:

listing all running processes
getting info for an arbitrary process
traversing process tree

Note: The information returned by these methods is just a snapshot of the processes running on the OS. Some of them may be missing, stopped etc. during the traversal so handle with care.

Samples

Showing Process Information

Sample showing obtaining information for running processes’ id and command

public static void main(String[] args) {
    ProcessHandle.allProcesses().forEach(processHandle ->
        System.out.println("PID: " + processHandle.getPid() +
                " Command: " + processHandle.info().command().orElse("N/A")));
}

public static void main(String[] args) {

ProcessHandle.allProcesses().forEach(processHandle ->

System.out.println("PID: " + processHandle.getPid() +

" Command: " + processHandle.info().command().orElse("N/A")));

}

Getting information for a process returns Optional and based on that further filtering can be done. For example listing only processes that have available command property:

public static void main(String[] args) {
    Stream<ProcessHandle> processHandleStream = ProcessHandle.allProcesses().filter(
            processHandle -> processHandle.info().command().isPresent()
    );
    processHandleStream.forEach(processHandle -> {
        System.out.println("PID: " + processHandle.getPid() +
                " Command: " + processHandle.info().command().orElse("N/A"));
    });
}

public static void main(String[] args) {

Stream<ProcessHandle> processHandleStream = ProcessHandle.allProcesses().filter(

processHandle -> processHandle.info().command().isPresent()

);

processHandleStream.forEach(processHandle -> {

System.out.println("PID: " + processHandle.getPid() +

" Command: " + processHandle.info().command().orElse("N/A"));

});

}

You can see there is no ‘N/A’ value for ‘Command’ in the output

Sample showing obtaining information for an arbitrary process

public static void main(String[] args) {
    final int pid = 4784; 
 
    ProcessHandle processHandle = ProcessHandle.of(pid).get();
    System.out.println("PID: " + processHandle.getPid());
    System.out.println("Command: " + processHandle.info().command().orElse("N/A"));
    System.out.println("CPU Duration: " + processHandle.info().totalCpuDuration().get().getSeconds() + " seconds");
}

public static void main(String[] args) {

final int pid = 4784;

ProcessHandle processHandle = ProcessHandle.of(pid).get();

System.out.println("PID: " + processHandle.getPid());

System.out.println("Command: " + processHandle.info().command().orElse("N/A"));

System.out.println("CPU Duration: " + processHandle.info().totalCpuDuration().get().getSeconds() + " seconds");

}

In this case the ‘pid’ is of the IDE used for writing the sample.

Getting the ID of the Running Process

public static void main(String[] args) {
    ProcessHandle processHandle = ProcessHandle.current();
    System.out.println("PID: " + processHandle.getPid());
    System.out.println("Command: " + processHandle.info().command().orElse("N/A"));
    System.out.println("CPU Duration: " + processHandle.info().totalCpuDuration().get().getSeconds() + " seconds");
}

public static void main(String[] args) {

ProcessHandle processHandle = ProcessHandle.current();

System.out.println("PID: " + processHandle.getPid());

System.out.println("Command: " + processHandle.info().command().orElse("N/A"));

System.out.println("CPU Duration: " + processHandle.info().totalCpuDuration().get().getSeconds() + " seconds");

}

Sample showing obtaining information for a process that was killed after taking a snapshot from the OS

public static void main(String[] args) {
     final int pid = 4476;

     ProcessHandle processHandle = ProcessHandle.of(pid).get();
     System.out.println("PID: " + processHandle.getPid());
     System.out.println("Command: " + processHandle.info().command().orElse("N/A"));
     System.out.println("CPU Duration: " + processHandle.info().totalCpuDuration().get().getSeconds() + " seconds");
}

public static void main(String[] args) {

final int pid = 4476;

ProcessHandle processHandle = ProcessHandle.of(pid).get();

System.out.println("PID: " + processHandle.getPid());

System.out.println("Command: " + processHandle.info().command().orElse("N/A"));

System.out.println("CPU Duration: " + processHandle.info().totalCpuDuration().get().getSeconds() + " seconds");

}

The output of this snippet is:

PID: 4476
Command: N/A
Exception in thread "main" java.util.NoSuchElementException: No value present
 at java.util.Optional.get(java.base@9-ea/Optional.java:138)
 at cd.sample.process.Main.main(Main.java:14)

PID: 4476

Command: N/A

Exception in thread "main" java.util.NoSuchElementException: No value present

at java.util.Optional.get(java.base@9-ea/Optional.java:138)

at cd.sample.process.Main.main(Main.java:14)

In this case the PID is of a text editor. To repro start the sample code in debug and once the processHandler is obtained stop the text editor.

Traversing process tree

public static void main(String[] args) throws IOException {
    final int pid = 1328;

    Runtime.getRuntime().exec("cmd");

    System.out.println("Showing children processes");
    ProcessHandle processHandle = ProcessHandle.of(pid).get();
    processHandle.children().forEach(childProcess ->
            System.out.println("PID: " + childProcess.getPid() + " Command: " + childProcess.info().command().get())
    );

    System.out.println("Showing descendant processes");
    processHandle.descendants().forEach(childProcess ->
            System.out.println("PID: " + childProcess.getPid() + " Command: " + childProcess.info().command().get())
    );
}

public static void main(String[] args) throws IOException {

final int pid = 1328;

Runtime.getRuntime().exec("cmd");

System.out.println("Showing children processes");

ProcessHandle processHandle = ProcessHandle.of(pid).get();

processHandle.children().forEach(childProcess ->

System.out.println("PID: " + childProcess.getPid() + " Command: " + childProcess.info().command().get())

);

System.out.println("Showing descendant processes");

processHandle.descendants().forEach(childProcess ->

System.out.println("PID: " + childProcess.getPid() + " Command: " + childProcess.info().command().get())

);

}

The output of this program is:

Showing children processes
PID: 5488 Command: C:\Program Files (x86)\JetBrains\IntelliJ IDEA Community Edition 2016.2.1\bin\fsnotifier.exe
PID: 5000 Command: C:\Program Files\Java\jdk-9\bin\java.exe
PID: 2864 Command: C:\Program Files\Java\jdk-9\bin\java.exe
Showing descendant processes
PID: 5488 Command: C:\Program Files (x86)\JetBrains\IntelliJ IDEA Community Edition 2016.2.1\bin\fsnotifier.exe
PID: 5000 Command: C:\Program Files\Java\jdk-9\bin\java.exe
PID: 2864 Command: C:\Program Files\Java\jdk-9\bin\java.exe
PID: 2748 Command: C:\Windows\System32\cmd.exe

Showing children processes

PID: 5488 Command: C:\Program Files (x86)\JetBrains\IntelliJ IDEA Community Edition 2016.2.1\bin\fsnotifier.exe

PID: 5000 Command: C:\Program Files\Java\jdk-9\bin\java.exe

PID: 2864 Command: C:\Program Files\Java\jdk-9\bin\java.exe

Showing descendant processes

PID: 5488 Command: C:\Program Files (x86)\JetBrains\IntelliJ IDEA Community Edition 2016.2.1\bin\fsnotifier.exe

PID: 5000 Command: C:\Program Files\Java\jdk-9\bin\java.exe

PID: 2864 Command: C:\Program Files\Java\jdk-9\bin\java.exe

PID: 2748 Command: C:\Windows\System32\cmd.exe

In this sample ‘pid’ is the running IDE. The output shows the difference between children() and descendants(). At the begging of the programm a new process is started however it is not listed when children() is called and it is shown when descendants() is called.

Sample Application

Sample application that shows:

all process when invoked with argument ‘ps’
process’ children when invoked with arguments ‘children <pid>’
process’ descendants when invoked with arguments ‘descendants <pid>’

public class App {

    public static void main(String[] args) throws IOException {
        final String command = args[0];

        Stream<ProcessHandle> processStream = null;

        if ("ps".equals(command)) {
            processStream = ProcessHandle.allProcesses();
        } else if ("children".equals(command)) {
            processStream = ProcessHandle.of(Long.valueOf(args[1])).get().children();
        } else if ("descendants".equals(command)) {
            processStream = ProcessHandle.of(Long.valueOf(args[1])).get().descendants();
        }

        if (processStream != null) {
            processStream.forEach(App::showInfo);
        } else {
            throw new IllegalArgumentException();
        }
    }

    private static void showInfo(ProcessHandle processHandle) {
        System.out.println("PID: " + processHandle.getPid() + " Command: " + processHandle.info().command().orElse("N/A"));
    }
}

public class App {

public static void main(String[] args) throws IOException {

final String command = args[0];

Stream<ProcessHandle> processStream = null;

if ("ps".equals(command)) {

processStream = ProcessHandle.allProcesses();

} else if ("children".equals(command)) {

processStream = ProcessHandle.of(Long.valueOf(args[1])).get().children();

} else if ("descendants".equals(command)) {

processStream = ProcessHandle.of(Long.valueOf(args[1])).get().descendants();

}

if (processStream != null) {

processStream.forEach(App::showInfo);

} else {

throw new IllegalArgumentException();

}

private static void showInfo(ProcessHandle processHandle) {

System.out.println("PID: " + processHandle.getPid() + " Command: " + processHandle.info().command().orElse("N/A"));

}

Source:App.java

References

Arbitrary Java object serialization to YAML

September 17, 2016 Haruto SatoLeave a comment

There are several good options for java object serialization and deserialization. One of these is to use the YAML data serialization standard.

YAML™ (rhymes with “camel“) is a human-friendly, cross language, Unicode based data serialization language designed around the common native data types of agile programming languages. It is broadly useful for programming needs ranging from configuration files to Internet messaging to object persistence to data auditing.

There are also several Java libraries that implement the YAML standard (as listed on yaml.org).

JvYaml
SnakeYAML
YamlBeans
JYaml

For the purpose of this article we’ll be using SnakeYAML as a solid modern implementation of the YAML 1.1 standard.

Consider the following simple example:

public class Weapon {

    private int dps;
    private String model;

    // getters/setters omitted for brevity
}

public class Weapon {

private int dps;

private String model;

// getters/setters omitted for brevity

}

Source: Weapon.java

This Java bean can be serialized and deserialized with just the following code:

public class WeaponTest {

    @Test
    public void testSerialization() {
        Weapon primary = new Weapon(10, "m4a1");

        Yaml yamlProcessor = new Yaml();
        String yaml = yamlProcessor.dump(primary);

        System.out.println(yaml);

        Weapon primaryCopy = yamlProcessor.loadAs(yaml, Weapon.class);

        Assert.assertFalse(primary == primaryCopy);
        Assert.assertEquals(primary, primaryCopy);
    }
}

public class WeaponTest {

@Test

public void testSerialization() {

Weapon primary = new Weapon(10, "m4a1");

Yaml yamlProcessor = new Yaml();

String yaml = yamlProcessor.dump(primary);

System.out.println(yaml);

Weapon primaryCopy = yamlProcessor.loadAs(yaml, Weapon.class);

Assert.assertFalse(primary == primaryCopy);

Assert.assertEquals(primary, primaryCopy);

}

Source: WeaponTest.java

Simple Java beans are automatically serialized and deserialized, the data looks like this:

!!io.techgarage.Weapon {dps: 10, model: m4a1}

1	!!io.techgarage.Weapon {dps: 10, model: m4a1}

Of course in reality things are not always that simple. Your domain model may contain types that are not Java beans like java.net.URL, java.util.UUID, java.net.InetAddress and others. In this case the serialization process will ignore the non-bean objects and deserialization will fail altogether.

Fortunately SnakeYAML’s represent and construct functionality can easily be extended. Consider the following more complex example:

public class Cyborg {

    private UUID id;
    private String model;
    private InetAddress address;
    private Collection<Weapon> weapons;

    // getters/setters omitted for brevity
}

public class Cyborg {

private UUID id;

private String model;

private InetAddress address;

private Collection<Weapon> weapons;

// getters/setters omitted for brevity

}

Source: Cyborg.java

Now we have non-bean types and java.util.Collection. To handle serialization and deserialization properly we need to use custom representer and constructor.

The representer takes the non-bean objects and transforms them into custom-tagged scalars. Also RepresentInetAddress is registered for both Inet4Address and Inet6Address to handle both protocols.

public class ApplicationRepresenter extends Representer {

    private class RepresentUUID implements Represent {

        @Override
        public Node representData(Object o) {
            UUID uuid = (UUID) o;
            return representScalar(new Tag("!uuid"), uuid.getMostSignificantBits() + " " + uuid.getLeastSignificantBits());
        }
    }

    private class RepresentInetAddress implements Represent {

        @Override
        public Node representData(Object o) {
            InetAddress inetAddr = (InetAddress) o;
            return representScalar(new Tag("!inet"), inetAddr.getHostAddress());
        }
    }

    public ApplicationRepresenter() {
        this.representers.put(UUID.class, new RepresentUUID());

        this.representers.put(Inet4Address.class, new RepresentInetAddress());
        this.representers.put(Inet6Address.class, new RepresentInetAddress());
    }
}

public class ApplicationRepresenter extends Representer {

private class RepresentUUID implements Represent {

@Override

public Node representData(Object o) {

UUID uuid = (UUID) o;

return representScalar(new Tag("!uuid"), uuid.getMostSignificantBits() + " " + uuid.getLeastSignificantBits());

}

private class RepresentInetAddress implements Represent {

@Override

public Node representData(Object o) {

InetAddress inetAddr = (InetAddress) o;

return representScalar(new Tag("!inet"), inetAddr.getHostAddress());

}

public ApplicationRepresenter() {

this.representers.put(UUID.class, new RepresentUUID());

this.representers.put(Inet4Address.class, new RepresentInetAddress());

this.representers.put(Inet6Address.class, new RepresentInetAddress());

}

Source: ApplicationRepresenter.java

The constructor does exactly the opposite of the representer does.

public class ApplicationConstructor extends Constructor {

    private class ConstructUUID extends AbstractConstruct {

        @Override
        public Object construct(Node node) {
            Object o = constructScalar((ScalarNode) node);
            String[] uuidBits = o.toString().split(" ");
            return new UUID(Long.parseLong(uuidBits[0]), Long.parseLong(uuidBits[1]));
        }
    }

    private class ConstructInetAddress extends AbstractConstruct {

        @Override
        public Object construct(Node node) {
            Object o = constructScalar((ScalarNode) node);
            try {
                return InetAddress.getByName(o.toString());
            } catch (UnknownHostException ex) {
                throw new IllegalArgumentException("Bad IP address format!", ex);
            }
        }
    }

    public ApplicationConstructor() {
        this.yamlConstructors.put(new Tag("!uuid"), new ConstructUUID());
        this.yamlConstructors.put(new Tag("!inet"), new ConstructInetAddress());
    }
}

public class ApplicationConstructor extends Constructor {

private class ConstructUUID extends AbstractConstruct {

@Override

public Object construct(Node node) {

Object o = constructScalar((ScalarNode) node);

String[] uuidBits = o.toString().split(" ");

return new UUID(Long.parseLong(uuidBits[0]), Long.parseLong(uuidBits[1]));

}

private class ConstructInetAddress extends AbstractConstruct {

@Override

public Object construct(Node node) {

Object o = constructScalar((ScalarNode) node);

try {

return InetAddress.getByName(o.toString());

} catch (UnknownHostException ex) {

throw new IllegalArgumentException("Bad IP address format!", ex);

}

public ApplicationConstructor() {

this.yamlConstructors.put(new Tag("!uuid"), new ConstructUUID());

this.yamlConstructors.put(new Tag("!inet"), new ConstructInetAddress());

}

Source: ApplicationConstructor.java

Our custom representer and constructor are passed to the constructor of the YAML processor. Putting everything together looks like this:

public class CyborgTest {

    @Test
    public void testSerialization() throws Exception {
        InetAddress ip = InetAddress.getByName("::1"); // IPv6 loopback address

        Weapon primary = new Weapon(10, "m4a1");
        Weapon sidearm = new Weapon(6, "glock");
        Collection<Weapon> weapons = new ArrayList<>();
        weapons.add(primary);
        weapons.add(sidearm);

        Cyborg cyborg = new Cyborg(UUID.randomUUID(), "TG-1000", ip, weapons);

        Yaml yamlProcessor = new Yaml(new ApplicationConstructor(), new ApplicationRepresenter());
        String yaml = yamlProcessor.dump(cyborg);

        System.out.println(yaml);

        Cyborg cyborgCopy = yamlProcessor.loadAs(yaml, Cyborg.class);

        Assert.assertFalse(cyborg == cyborgCopy);
        Assert.assertEquals(cyborg, cyborgCopy);
    }
}

public class CyborgTest {

@Test

public void testSerialization() throws Exception {

InetAddress ip = InetAddress.getByName("::1"); // IPv6 loopback address

Weapon primary = new Weapon(10, "m4a1");

Weapon sidearm = new Weapon(6, "glock");

Collection<Weapon> weapons = new ArrayList<>();

weapons.add(primary);

weapons.add(sidearm);

Cyborg cyborg = new Cyborg(UUID.randomUUID(), "TG-1000", ip, weapons);

Yaml yamlProcessor = new Yaml(new ApplicationConstructor(), new ApplicationRepresenter());

String yaml = yamlProcessor.dump(cyborg);

System.out.println(yaml);

Cyborg cyborgCopy = yamlProcessor.loadAs(yaml, Cyborg.class);

Assert.assertFalse(cyborg == cyborgCopy);

Assert.assertEquals(cyborg, cyborgCopy);

}

Source: CyborgTest.java

Now the type hierarchy is represented in YAML like this:

!!io.techgarage.Cyborg
address: !inet '0:0:0:0:0:0:0:1'
id: !uuid '7761487157133527242 -8447463166146773756'
model: TG-1000
weapons:
  - {dps: 10, model: m4a1}
  - {dps: 6, model: glock}

!!io.techgarage.Cyborg

address: !inet '0:0:0:0:0:0:0:1'

id: !uuid '7761487157133527242 -8447463166146773756'

model: TG-1000

weapons:

- {dps: 10, model: m4a1}

- {dps: 6, model: glock}

As you can see the non-bean type values are tagged with custom tags: !inet and !uuid. That’s how the YAML document is later properly deserialized.