Gradle, JUnit5, Jacoco Working

The way information is dispersed on the Internet is pretty cool sometimes.  I’ve visited this same topic a couple times and never managed to get JUnit5 and Jacoco working with Gradle.  Fresh searches never turned up a working solution.  The other day, looking at my blog stats I saw an intriguing referrer to one of my past posts. The reference was from a blog written in Japanese. Google translate yielded an awkward version that seemed to offer a solution.  Since the Gradle code needed no translation I tried out some of the changes shown and – viola!

So, Here’s the Working Solution

The goal was to employ JUnit5, generate Jacoco reports, and feed those into Here’s the snippet of working solution.

I believe the secret sauce I missed was in lines 23 and 27.  To see the project that I tested this with, the repo is here.


Trying Out Java 9’s Modules With Gradle

I’ve touch Java 9, compiled with it, run with it, but haven’t yet done anything unique to it. I decided to see what I could do with the module system, and thought I’d see if I could migrate one of my existing project over.  I selected fluentsee because it was small, functional, and had a small number of outside dependencies.

What Resulted

I did get it to “work” with modules in play.

What Worked

  • I managed to build it as a module with Gradle
  • The module system did clarify the dependencies
  • It caught some Java reflection in play and restricted it
  • I could launch it with a simple module oriented command line

What Not So Much

  • The Gradle to deal with JDK 9 was verbose and cumbersome
  • I could not achieve the equivalent of a “fat jar” I’d had before
  • I could not get jlink to create a “deployable” application

What I Did

To get things working I used:

  • JDK 9.0.4
  • Gradle 4.4.1

And then, in my build.gradle I had to pretty much retool every Java related task.  Here’s the bulk of it:

So in addition to reworking compileJava, compileTestJava, and test, I needed to:

  • Make sure the resources got copied
  • Create a module aware jar
  • Create a task to pull everything together into a mod staging directory

With that all done I was able to:

./gradlew clean mJar module
java -p build/mods -m com.github.nwillc.fluentsee -h

To build, stage and run the project. To check out the code look at the feature/jdk9 branch of fluentsee.

Docker Container Jenkins Slaves in AWS

There are some good articles out there about using docker containers as Jenkins slaves.  There are many good reasons to do this. My use case was, we have some special snowflake test setups that didn’t play well together, but didn’t require all of a dedicated machine, so creating docker images for them, and sharing a machine, made more sense.

Mostly It’s Straight Forward

The posts out there cover the topic well.  Basically there’s a Jenkins Plugin needed, the Docker image setup, and then some configuration of the Docker engine on the host machine.

But, There are Always Challeges

I hit three bumps:

  1. Setting up you Docker engine to accept remote requests. This is mentioned in most of the articles, and usually covered to one degree or another. The snag is, pretty much every OS’s installation of Docker is a little different. So while I knew I had to add the “-H tcp://” argument to my dockerd, finding out how on our RedHat install took a bit of doing.
  2. Dealing with AWS’ security groups.  If you’re talking to port 2375, well obviously that port needs to be open. Duh. But that only got me so far, containers fired up but Jenkins’ builds hung.  What wasn’t immediately apparent was, that the ssh communication to the slaves wasn’t going to happen on the traditional port 22. Yes, inside the container it would listen on port 22, but that would be mapped externally to a port in a range of numbers.  So my AWS security group needed to have that range open for inbound connections too.  Using docker inspect on the containers that resulted allowed me to see what they were exposing 22 as. I’m not sure I got “the range”, but I got “a range” that’s worked so far.
  3. The image I built had a banner and messages up login. That confused Jenkins apparently. Once I had it so no messages were displayed when I ssh’d in that resolved that issue.


With those two issues addressed, I’ve now got the special snowflake setup as docker images, and Jenkins spins those up and tears them down as needed.  I’m not entirely happy with the “port range” business, and may revisit it, but for now, like most things Jenkins, its working even if there’s a bit of a code smell.

GraphQL Java 6.o

I’ve been a fan of GraphQL ever since I first tried it.  I push back against RESTful APIs to anyone that will listened (or not).  I’ve written a few post about it (GraphQL: Java Server, JavaScript Client, GraphQL: Java Schema AnnotationsGraphQL: A Java Server in Ratpack).  What I haven’t done, is stay current.  I got hooked on graphql-java at version 3.X and decided the annotations were the best way to go, and sadly the annotations development stalled and made upgrades tricky, and so I didn’t.  But it was a constant nagging itch, to upgrade, and finally I did.

This post will discuss a Ratpack server, using GraphQL-java 6.0. I should note, that as I did this work, the annotations finally release an upgrade. Doh.

GraphQL Java 6.0

I committed to upgrade. The annotations had not kept up so this meant a bit of a rewrite.  Normally I’m pretty suspicious of gratuitous annotation use.  They often mask too much of what’s really going on, and they tend to spray the information about one concern throughout your code, making it hard to locate coherent answers on a topic.  That was exactly the case here.  Leaving the annotations behind meant:

  • I had to figure out what previous magic I now had to handle on my own.
  • I had to determine just how deeply into my code they’d rooted themselves.

I tried to approach it intelligently, but in the end I went with brute force, I removed the dependency, and kept trying to build the project, ripping out references, until, while no longer working, the project built and the annotations were gone.  Then I set about fixing what I’d broken.

What Was Missing?

Basically without the annotations there were two things I needed to repair:

  • Defining the query schema
  • Wiring the queries up to the data sources

Defining Your Schema

GraphQL-java 6.0 supports a domain specific language for defining your schema known as IDL.  It’s a major win.  First, it gets your schema, which is by definition, a single concept, into one place, and makes it coherent.  Second, they didn’t go off and write “Yet Another DSL” but instead supported one that while not part of the official spec, is part of the reference implementation, and has traction in the community. Nice.

Wiring Up Your Data Sources

The best practice for this now is using the “DataFetcher” interface. The name is a bit misleading, since these aren’t just for your queries (i.e. fetching data) but also for your mutations (modifying data).  The name is weak, but the interface and it’s use is a breeze.

To the Code

I did all this work on my snippets server kata project, so for a richer example go there, but for the sake of clarity here will look at the more concise Ratpack GraphQL Server example.

The Dispatcher

This didn’t change hardly at all.  It’s still as simple as grappig a JSON map, pulling out the query and variables, and executing them:

Pretty straight forward.

Defining the Schema: IDL

So in this trivial example all I have are Company entities, defined with this bean:

And all I wanted to support was, get one, get all, save one, delete one.  So I needed to define my Company type, two queries, and two mutations. Defining this in IDL was easy:

Loading The Schema

I just tucked my schema definition into my resources folder and then:

Wiring The Data to The Schema

In GraphQL-java, the way I chose to do this is with DataFetcher implementations. So for example, to find a company, by name, from a map it would look about like:

So that’s the way to “fetch” the data, but how do you connect this to your schema? You define a “RuntimeWiring”:

And then you associate that wiring with your schema you loaded:

And Then…

Well that’s it.  You’ve:

  • Created a GraphQL dispather
  • Defined your entites
  • Defined your GraphQL schema
  • Created queries
  • Instantiated the schema, wired in the queries

Done.  Take a look at my GraphQL server in Ratpack for the complete working code.



Travis-CI to Docker Hub

More and more of my work involved docker images.  I consume them and produce them. My standard open source project CI/CD tool chain stack is Java, Gradle, GitHub, Travis-CI, CodeCov and Bintray.  End to end free and functional.

Recently I moved my snippets server app into a docker image.  This added Docker Hub to my stack, and happily it was an easy addition because of Gradle and Travis-CI.

Setting up the Build

A quick search and review turned up the gradle-docker-plugin.  With this plugin and access to a docker engine you can create, run and push docker images easily. The docs for the plugin will walk you through how to add it to your build.gradle. Also note, to use the types in the tasks below, you’ll need proper import statements. My build.gradle is pretty clean, but I’ll walk through some details below.

Creating the Dockerfile

The plugin is pretty flexible, so the following notes are not the answer but my answer.  Rather than create a fixed Dockerfile, I create mine on the fly from gradle:

task createDockerfile(type: Dockerfile) {
    def labels = [maintainer: '']

    destFile = project.file('build/docker/Dockerfile')
    from 'anapsix/alpine-java:8_server-jre_unlimited'
    label labels
    exposePort 4567
    runCommand 'mkdir -p /opt/service/db'
    volume '/opt/service/db'
    copyFile "libs/$$project.version-standalone.jar", '/opt/service'
    workingDir '/opt/service'
    defaultCommand '--port', '4567', '--store', 'H2'
    entryPoint 'java', '-Djava.awt.headless=true', '-jar', "$$project.version-standalone.jar"

There’s a fair bit going on there so let’s walk through it.  First off, I’m creating the Dockerfile down in my build directory.  Then I’m using the plugin to do standard Dockerfile operations like setting the base from image, creating folders, copying in artifacts, and setting up the command and entry point.  The plugin sticks pretty close to the dockerfile DSL so you should be able to pick it up easily.  It’s worth noting that because this is in gradle, I can use the groovy variables to denote things like the artifact name etc.

Creating the Image

With the task to create the Dockerfile done, building an image is trivial.

task buildImage(type: DockerBuildImage, dependsOn: [assemble, createDockerfile]) {
    inputDir = project.file("build")
    dockerFile = createDockerfile.destFile
    tag = "nwillc/$$project.version"

So here I just indicate where I’ll root the build, in the build folder, and grab the previously created Dockerfile, and tag the image. Running this task will create your artifact, create your Dockerfile, and build the image.

Pushing the Image

I push my images into docker hub’s free public area. So, all I need to add to my build is info about my credentials and a push task.

docker {
    registryCredentials {
        url = ''
        username = 'nwillc'
        password = System.getenv('DOCKER_PASSWD')
        email = ''
task pushImage(type: DockerPushImage, dependsOn: buildImage) {
    imageName buildImage.tag

Note I grab the password from an environment variable. That keeps it out of my github repo and you can set these in a secure manner in Travis-CI.

Running the Build and Doing the Deploy

With your build.gradle ready to go, and your DOCKER_PASSWD set you can now locally do a ./gradlew pushImage and it should all work, ending up with the image in docker hub.

But now let’s get our CI/CD working. Travis-CI has all you need supported. Set the DOCKER_PASSWD in your Travis-CI account’s profile, and then add the relevant bits to your .travis.yml, here are the key elements:

sudo: required
services: docker
  - docker login -u nwillc -p ${DOCKER_PASSWD}
  - ./gradlew pushImage

You’ll need sudo, you have to indicate you’re using the docker service, you’ll need to login to docker hub, and finally push the image after successful build.


With your build.gradle, and .travis.yml enhanced, it’s done. Every push to github builds and tests and if everything is happy your docker hub image is updated.

Information Graveyard

I’m trying to learn how to write a skill for Amazon’s Alexa, taking the tried and true approach of searching for tutorials on the internet.  At this point it’s been only frustration.  I’ve found both Amazon written tutorials and third party ones.  Not a single one yet has provided instructions that correspond to the current Amazon tools.  Some are relatively recent, or at least claim to have been recently updated, but not a one has actually provided a working example.  It’s not a matter of slight differences that can be worked around, each one has had at least one step that didn’t seem to correspond to anything in the AWS console as it is today.

Keeping posts up to date is work, I realize. I’m guilty too, of leaving out of date documentation out in the wild, but I make an effort to be responsible, and I’m not expecting revenue from my posts.  How is it that even Amazon’s own tutorials are completely borked?  I tried this about two months back and it was the same story. Since then both the tutorials and AWS tools have been updated, but the new combination is no more workable than the prior.

Some products are notably bad on this point.  Amazon’s SDKs and tools are a consistent pain point. The Spring ecosystem too is bad.  JBoss a mess.  The problem also is made worse by how the developers refactor code and API.  Making changes and improvements in a way that facilitated migrations is a skill.  I wish Amazon acquired that skill.


I hit on a really good article on the Law of Demeter. If you’re not familiar with it read that article, and if you do you may find my discussion with the author in the comments. The discussion was around the how rigidly you took the term Law.

Why Quibble The Word Law?

I code mostly in Java, classified as an object-oriented language, and I’ve coded in the OO paradigm in C++, Objective-C and Smalltalk too.  But I started in procedural (Pascal and C) and I’ve worked with functional (Lisp, SML), and smatterings of other languages with their styles too.  They all have their strong points. I’ve learned tactics and patterns from them all and when I’m encounter a situation where one applies, if the current tools can implement the tactic I use it.  I’m not saying anything astonishing here, modern tools are rarely purist in their approaches anymore.

The Law of Demeter is a good OO maxim, but if you’re writing code that handles serialized data, whether if be a RESTful service, or data store persistence, etc. you’ll likely be dealing with composited data (addresses, inside accounts, inside portfolios etc.).  Accessing portfolio.account.address.state violates the Law of Demeter. There are patterns to mitigate some of the issues here, like Data Transfer Objects, the Visitor Pattern, or Facade Pattern,  but depending on the situation some of these cures are worse than the problem.

In Summary

Keep the Law of Demeter in mind as you write/review your code. If it’s been rampantly ignored that certainly is a code smell.  But paradigm “laws” are for purists, and writing software is a pragmatic process… so… yeah… it’s a maxim.