DEV Community: Stephan

Tracking players using ML solutions

Stephan — Mon, 30 Dec 2019 08:59:04 +0000

A challenging problem is tracking individuals using machine learning solutions. I will investigate several possible solutions for my open source sports analysis project.

For each solution I will use the same short basketball video which starts with several isolated players and ends with multiple occlusions. The output video is in slow motion so we can more easily observe what's happening.

Occlusion occurs if an object you are tracking is hidden (occluded) by another object. Like two persons walking past each other, or a car that drives under a bridge.

First the players need to be localised, this is often done using a convolutional neural network (for example Mask-RCNN). In the second phase the tracking needs to happen where often key points of the human body are linked to a unique person and visualised.

If we would have multiple cameras we could actually track each player based on his/her face recognition. See my article on Face Recognition at Devoxx.

As always, please don't hesitate to suggest any other possible techniques or solutions which I should investigate.

Tracking with OpenCV

OpenCV has build-in support to track objects and the actual implementation is very straight forward. With just a couple of lines of code you can track a moving object as follows:

import cv2

# ...

# Create MultiTracker object
multiTracker = cv2.MultiTracker_create()

# Initialize MultiTracker 
for pBox in players_boxes:
  # Add rectangle to track within given frame  
  multiTracker.add(cv2.TrackerCSRT_create(), frame, pBox)

# ...

# get updated location of objects in subsequent frames
success, boxes = multiTracker.update(frame)

# draw new boxes on current frame

# ...

As you can see from the annotated video it does a pretty good job right until a player passes (overlaps) another player (= occlusion).

A total of 6 persons were tracked, only the referee and one yellow player was tracked correctly until the end. Hmmm not the result I was hoping for.

Video result can be viewed on YouTube.

Tracking with Key Points

The next experiment is with COCO R-CNN KeyPoints which can easily be enabled using Detectron2.

As you can see from the output below, the rectangle around each person uses the same colour as long as it's tracking the same person. However when occlusion happens the same result is experienced as with OpenCV.... chaos.

Video result can be viewed on YouTube.

Tracking with Pose Flow

Pose Flow shows a unique number for each person that it tracks and uses the same coloured rectangle around the same person in addition to the key points of the human body.

It starts out really confident but again (as with the previous experiments) when occlusion appears it basically looses track of the overlapping players.

Video result can be viewed on YouTube

BTW Full scientific details on the Pose Flow algorithm can be download here.

Shout out to Jarosław Gilewski for his Detectron2 Pipeline project which allowed me to rapidly run the above simulations!

The Pose Track challenge

PoseTrack is a large-scale benchmark for human pose estimation and articulated tracking in video. We provide a publicly available training and validation set as well as an evaluation server for benchmarking on a held-out test set.

PoseTrack organises every year tracking and detection competitions for single frame and multiple frames pose datasets.

In 2018 the "Pose Flow team" ended on the 13th position and the "Key Track" team won the multi-person tracking challenge.

Pose tracking is an important problem that requires identifying unique human pose-instances and matching them temporally across different frames of a video. However, existing pose tracking methods are unable to accurately model temporal relationships and require significant computation, often computing the tracks offline.

The Key Track solution

KeyTrack introduces Pose Entailment, where a binary classification is made as to whether two poses from different time steps are the same person.

Unfortunately I was unable to find an (open source) Key Track implementation. If you know where to find it please let me know and I will try it out.

The scientific paper can be downloaded here.

The ideal camera setup?

One idea is to change the angle of the stationary camera(s) so you get a birds-eye view hopefully limiting the number of occlusions that can happen.

The ideal setup would be a top-down stationary camera above the middle of the court. The IP enabled camera should need a super wide angle lens. Similar to the European APIDIS basketball project where the Université catholique de Louvain were involved.

The APIDIS project used seven 2 megapixel colour IP cameras (Arecont Vision AV2100) recording at 22 fps with timestamp for each frame at 1600x1200 pixels.

And (as shown below) an additional two cameras, each recording a side of the basketball court.

The journey towards creating a Basketball mini-map

Stephan — Sat, 21 Dec 2019 15:22:24 +0000

One specific goal of the open source basketball analytics machine learning project is to provide a mini-map of the players. Basically a top-down view of the court with the different players represented as coloured circles.

Eventually we could also draw the players movement on the 2D view to detect patterns of basketball plays.

Let's have a closer look how this can be accomplished using Python, OpenCV and machine learning libraries.

BTW Suggestions and comments are always very welcome to improve this open source project. I've also included a fully working tutorial of this article so you can experiment with the provided code (link in footer of article).

Where to place the camera?

I've done two camera experiments, one where the camera is positioned in the corner and another where it's placed in the middle (as shown in the pictures below).

The best result for image transformations was achieved where the camera was positioned in the middle.

Read also my article on how to record a basketball game on a budget

Identify the players with Detectron2

With Mask R-CNN models you can easily identify objects in an image. #Yolo

I played with Yolo last week but wanted to experiment with Detectron2 (powered by PyTorch). This is an open source project from Facebook, it implements state-of-the-art object detection algorithms. It's amazing what it can detect, let's have a closer look.

Funny enough the used model thinks that the right basketball hoop is a TV with 56% probability. It also correctly found a chair with 61% probability.

We'll need to filter out the persons and actually work only with the players that are on the court. The used picture has all the players grouped together because it's the start of a game, as a result only 8 out of 10 players were found.

The COCO Panoptic Segmentation model detects the ceiling, walls and floor and colours them accordingly. This will be very interesting input for the court detection, because now we can limit the "search" in the floor polygon.

Detectron2 also supports Human Pose Estimation which we'll use in the future to classify basketball actions of players.

Retrieving the position of each player is accomplished using following python code.

The DefaultPredictor.predictor method returns a list of rectangle coordinates (pred_boxes) of each identified object. The object classes are stored in pred_classes, where person objects are marked as 0.

Because the automatic court detection is not yet ready, I had to provide the polygon coordinates of the court manually.

pts_src = np.array([
    [1, 258],       # left bottom - bottom corner
    [400, 308],     # middle bottom corner
    [798, 280],     # right bottom - bottom corner
    [798, 220],     # right bottom - top corner
    [612, 176],     # top right rorner
    [186, 168],     # top left corner
    [3, 201]        # left bottom - top corner
    ])

Drawing this polygon onto the image allowed me to debug my court coordinates and adjust them when needed.

Representing a player on the court

We will draw a blue circle for each player by iterating over the predicated coordinates of the found objects (boxes). We should only include Person objects which are positioned within the court polygon coordinates using : Point(player_pos).within(court) statement

# Use the boxes info from the tensor prediction result
#
# x1,y1 ------
# |          |
# |          |
# |          |
# --------x2,y2
#

from shapely.geometry import Point, Polygon

color = [255, 0, 0]   # BLUE
thickness = 2
radius = 2

i  = 0
for box in pred_boxes:

  # Include only class Person
  if pred_classes[i] == 0:  

    x1 = int(box[0])
    y1 = int(box[1])

    x2 = int(box[2])
    y2 = int(box[3])

    xc = x1 + int((x2 - x1)/2)
    player_pos = (xc, y2)

    court = Polygon(src_pts)

    # Draw only players that are within the basketball court
    if Point(player_pos).within(court):
      cv2.circle(im, player_pos, radius, color, thickness, lineType=8, shift=0)

    i += 1

Great, we now have marked 8 players on the basketball court and two which are hidden in the back 🏀💪🏻

Image transformations

Using homography image transformation we can morph the above image onto a 2D court image shown below.

No alt text provided for this image
We declare the similar court coordinates (the same 7 points starting with left bottom - bottom corner, etc.) but now from the 2D image.

# Four corners of the court + mid-court circle point in destination image 
# Start top-left corner and go anti-clock wise + mid-court circle point
dst_pts = np.array([
    [43, 355],       # left bottom - bottom corner
    [317, 351],      # middle bottom corner
    [563, 351],      # right bottom - bottom corner
    [629, 293],      # right bottom - top corner
    [628, 3],        # top right rorner
    [8, 4],          # top left corner
    [2, 299]         # left bottom - top corner
    ])

Now for the Homography call which behind the scene uses matrix multiplication mathematics.

# Calculate Homography

h, status = cv2.findHomography(src_pts, dst_pts)

img_out = cv2.warpPerspective(im, h, (img_dst.shape[1], img_dst.shape[0]))

The output image (img_out) shows the player dots within a 2D view of the court!! 😱

The basketball mini-map solution is almost here.

Mask strategy

One approach to get the player coordinates on the transformed basketball court image is via a colour mask.

lower_range = np.array([255,0,0])                         # Set the Lower range value of blue in BGR
upper_range = np.array([255,155,155])                     # Set the Upper range value of blue in BGR
mask = cv2.inRange(img_out, lower_range, upper_range)     # Create a mask with range
result = cv2.bitwise_and(img_out, img_out, mask = mask)   # Performing bitwise and operation with mask in img variable                            

mask = cv2.inRange(result, lower_range, upper_range)  
cv2_imshow(mask)

Now we can retrieve the coordinates of the "non zero" pixels in the mask and use these coordinates to draw a circle on the 2D basketball court image.

#get all non zero values
coord = cv2.findNonZero(mask)

# Radius of circle 
radius = 3

# Blue color in BGR 
color = (255, 0, 0) 

# Line thickness of 2 px 
thickness = 2

court_img = cv2.imread('./court.jpg')
for pos in coord:
  center_coordinates = (pos[0][0], pos[0][1])
  cv2.circle(court_img, center_coordinates, radius, color, thickness) 

cv2_imshow(court_img)

Update (29 Dec 2019)

By studying the player trail tracking visualisation I ran into this ball tracking example. That demo uses the OpenCV findContours method to retrieve the coordinates of the masked ball. So instead of using cv2.findNonZero(mask) which returns all the non zero pixels in the mask, I can now retrieve just 8 coordinates of the players within the mask using the following code:

cnts = cv2.findContours(mask.copy(), 
                        cv2.RETR_EXTERNAL, 
                        cv2.CHAIN_APPROX_SIMPLE)
cnts = imutils.grab_contours(cnts)

Great, a (draft) workable solution has arrived :)

See also video example output on YouTube.

What is still missing?

We still need to identify the players per team which can be achieved using colour detection.

If we can identify each individual player we could also do player tracking on the mini map.

I did create a full tutorial which will take you step-by-step through the above journey.

Hopefully this is enough to experiment and maybe come up with some practical suggestions on how to finalise the 2D mapping?!

Peace,

Stephan

Open Source Sports Video Analysis using Maching Learning

Stephan — Mon, 16 Dec 2019 08:32:45 +0000

The mission is to develop an open source machine learning solution which will use computer vision to analyse (home made) sports videos.

For starters I want to focus on Basketball games but the solution should also be applicable to any sport which has players and a court.

Further documentation, code examples and eventually a working open-source solution will get published on GitHub.

Feel free to contact me if you want to help out, have suggestions or know about existing open source projects that we can (re)use.

Project Goals

Short (1 and 2) and long term (3 and 4) project goals.

Player tracking per team.
Video mapping onto 2D basketball court.
Game play action detection (with tagging) and analytics
More advanced game analytics like lay-up, dunk, pick & roll, running distance, etc.

Basically similar to the football analytics video shown below but then for basketball and open sourced.

Machine Learning Models

Based on the Player Tracking and Analysis of Basketball Plays paper, the following machine learning models need to be created.

1) Court Detection - find lines of the court
2) Person Detection - detect individuals ✅
3) Player Detection and Color Classification - players detection standing on the court and separate these individuals into two teams
4) Player Tracking - Keep positions information frame by frame
5) Mapping via Homography - translate onto a court

Court Detection

Explained in Court Reconstruction for Camera Calibration in Broadcast Basketball Videos [2]

The video frames that we obtained from Youtube were initially converted from the BGR to the HSV (hue, saturation
and value) color model. We then focused on the H-plane in order to create a binary model of the system. Then, we
proceeded to perform erosion and dilation of the image in order to get rid of artifacts that were not related to the court. Subsequently, we made use of the Canny edge detector to detect the lines in our system. Finally, we performed the Hough transform in order to detect the straight lines in the system.

Court detection strategies

As you can see in the images above, these are not NBA courts. Many criss-cross lines define a basketball court which will make it very hard to auto detect.

Let's have a closer look at a few strategies.

Naive Court Detection

Converting the image to HSV
Isolating pixels within a given hue range
Developing a bitwise-AND mask
Using Canny edge detection
Using Hough Transformation

The Python code "court_detection1.py" is included in this project.

Basketball court detection (with too many lines) will be very difficult to identify using above strategies.

Binary segmentation using auto encoders

An auto encoder for sports field segmentation will be required as explained in the Classification of Actions by Simone Francia (see section 3.2.2 : Auto encoder model of the basketball court)

Field Segmentation Datasets

In order for training to work, a 100,000-frame dataset of basketball courts is required.
To do this, about 1000 frames needs to be extracted from each game which is then used for the creation of the data set.
The size of the dataset can be increased through simple data augmentation techniques.

Through the OpenCV function cv2.polylines it is possible to create n points {p1, p2, .., pn } on the image plane. These points are then used to draw a polygon.

def draw_poly_box(frame, pts, color=[0, 255, 0]):
    """Draw polylines bounding box.

    Parameters
    ----------
    frame : OpenCV Mat
        A given frame with an object
    pts : numpy array
        consists of bounding box information with size (n points, 2)
    color : list
        color of the bounding box, the default is green

    Returns
    -------
    new_frame : OpenCV Mat
        A frame with given bounding box.
    """
    new_frame = frame.copy()
    temp_pts = np.array(pts, np.int32)
    temp_pts = temp_pts.reshape((-1, 1, 2))
    cv2.polylines(new_frame, [temp_pts], True, color, thickness=2)

    return new_frame

This polygon, annotated by manually, is interpreted as a field (basketball court) and colored white inside, while the outside will be black.

Data Augmentation for the Dataset Field

The annotation of the field has been carried out for one frame every second, and being the videos of 25 fps, it is equivalent to annotating a frame every 25. The annotation of 1000 frames is not sufficient to create a robust auto-coder model; for this reason, some Data Augmentation solutions have been adopted in order to provide the autoencoder model with a sufficient number of examples for training.

Every court image can also be rotated with an angle ranging from -15 and 15. From each original court image two other combinations are created, choosing a random angle between the interval.

Persons Detection

Object detection locates the presence of an object in an image and draws a bounding box around that object, in our case this would be a person.

Common Object Detection model architectures are :

R-Convolutional Neural Networks or R-CNN
Fast R-CNN
Faster R-CNN
Mask R-CNN
SSD (Single Shot MultiBox Defender)
YOLO (You Only Look Once)
Objects as Points
Data Augmentation Strategies for Object Detection

You can find a working example by Arun Ponnusamy using Yolo and OpenCV. The result image is shown below.

Another approach is using Convolutional Neural Networks like TensorFlow. More details on the different model architectures can be found in A 2019 Guide to Object Detection.

Mask R-CCN allows us to segment the foreground object from the background as shown in this Mask R-CNN example and the image below. This will help in the next model where we'll detect a player and based on color classification link them to a team.

Player Detection and Color Classification

Excerpt from Learning to Track and Identify Players from Broadcast Sports Videos [4].

In order to reduce the number of false positive detections, we use the fact that players of the same team wear
jerseys whose colors are different from the spectators, referees, and the other team. Specifically, we train a
logistic regression classifier [32] that maps image patches to team labels (Team A, Team B, and other), where image patches are represented by RGB color histograms. We can then filter out false positive detections (spectators and referees) and, at the same time, group detections into their respective teams. Notice that it is possible to add color features to the DPM detector and train a player detector for a specific team [33]. However, [33] requires a larger labeled training data, while the proposed method only needs a handful examples.
After performing this step, we significantly boost precision to 97% while retaining a recall level of 74%.

The Mask R-CNN application allows us to extract the segmented image of each identified person. Extracting the dominate colors per segmented image should allow us to classify the players by team. However for some unknown reason the used python code to accomplish this doesn't identify the yellow jersey color (yet).

Players Tracking

Excerpt from Learning to Track and Identify Players from Broadcast Sports Videos [4].

Face recognition is infeasible in this domain, because image resolution is too low even for human to identify
players. Recognising jersey numbers is possible, but still very challenging. We tried to use image thresholding to
detect candidate regions of numbers, and run an OCR to recognise them. However, we got very poor results because image thresholding cannot reliably detect numbers, and the off-the-shelf OCR is unable to recognise numbers on deformed jerseys. Frequent pose and orientation changes of players further complicate the
problem, because frontal views of faces or numbers are very rare from a single camera view. We adopt a different approach, ignoring face and number recognition, and instead focusing on identification of players as entities. We extract several visual features from the entire body of players. These features can be faces, numbers on the jersey, skin or hair colors. By combining all these weak features together into a novel Conditional Random Field (CRF), the system is able to automatically identify sports players, even in video frames taken from a single pan-tilt-zoom camera.

The open source Alpha Pose project can detect a human body within an image and provide a full description of a human pose.

Alpha Pose is the “first real-time multi-person system to jointly detect human body, hand, and facial key points on single images using 130 key points.

Once we can identify a body pose the direction can be calculated and these can be mapped onto a 2D playing plane/field/court as shown above.

Court Mapping via Homography

How can we map a player in a video onto a 2D court?

A homography is a perspective transformation of a plane (in our case a basketball court) from one camera view into a different. Basically with a perspective transformation you can map 3D points onto 2D image using a transformation matrix.

By having the dimensions of the court, we are able to find a 3x3 homography matrix that is computed using an affine transform. Each player’s position is then multiplied by the homography matrix that projects them into the model court.

See also this scientific paper on A Two-point Method for PTZ Camera Calibration in Sports [22]

A Python example on how to use the OpenCV Homography algorithm can be seen below. This is based an article by Satya Mallick.

    #!/usr/bin/env python

        import cv2
        import numpy as np

        if __name__ == '__main__' :

            # Read source image.
        im_src = cv2.imread('book2.jpg')
        # Four corners of the book in source image
        pts_src = np.array([[141, 131], [480, 159], [493, 630],[64, 601]])


        # Read destination image.
        im_dst = cv2.imread('book1.jpg')
        # Four corners of the book in destination image.
        pts_dst = np.array([[318, 256],[534, 372],[316, 670],[73, 473]])

        # Calculate Homography
        h, status = cv2.findHomography(pts_src, pts_dst)

        # Warp source image to destination based on homography
        im_out = cv2.warpPerspective(im_src, h, (im_dst.shape[1],im_dst.shape[0]))

        # Display images
        cv2.imshow("Source Image", im_src)
        cv2.imshow("Destination Image", im_dst)
        cv2.imshow("Warped Source Image", im_out)

        cv2.waitKey(0)

More Advanced Machine Learning Models

In a future version of the project we could also consider adding Start of Game (SoC), Track Ball and Goal (score) machine learning models.

Start of Game (SoG)

If we want to solution to automatically analyse a video we could also considering adding a Start of Game (SoC) model. This identifies the players at a certain position on the court which will flag the beginning of a game or quarter when doing basketball analysis.

Track Ball

Tracking the ball will be a requirement when we want to achieve scoring analytics. Some very interesting research studies have been published on this subject : A deep learning ball tracking system in soccer videos [5]

An example of tracking a large ball using OpenCV can be found here.

Pose estimator

Alpha Pose is the “first real-time multi-person system to jointly detect human body, hand, and facial key points (in total 130 key points) on single images,”. The solution is capable of taking in an image and detecting key points (eyes, nose, various joints, etc.) on all human figures in the image. This allows the full description of a human pose in an image.

Alpha Pose can potentially be a building block to detect shots, layups, dunks etc.

A must read related document is Sports Analytics With Computer Vision [7].

And another great article giving an overview on the available human pose estimation solutions.

Shot Detection

Another very interesting machine learning model that we can use is the open source project on basketball shot detection and analysis shared by Rembert Daems (Thanks for the info).

This program is able to detect when a shot occurs and fill in the balls flight from captured data. It calculates the balls initial velocity and launch angle. It is able to estimate the balls flight perpendicular to the camera plane (The z axis) using a single camera. The program is also able to detect when the balls flight is interrupted by another object and will drop those data points.

Actions recognition

Simone Francia developed a basketball action recognition dataset as shown in the video below. I've contacted Simone to get more details how his dataset can be used.

Goal (Score)

Eventually we also want to have a model which can identify when a player makes a goal (in basketball this can be a free throw which is one point, two or three points). As confirmed by the ML6 presentation, different Goal modals will need to be combined. For example audio peaks could be an indication that a goal was made, of course ball tracking towards to hoop and "entering" the "ring" are all events which could identify a goal.

Another idea (when possible) is to do OCR of the score board and see when the score increases as a confirmation of a goal. Of course the majority of the home made videos do not include the score board.

Further research is required and suggestions are always welcome.

Ensemble Learning

Once we have the different models working we'll most likely need to "stack" them. Basically using the output from one model as the input for another one. Or combine similar models to obtain a better predictive performance.

One technique of ensemble learning is stacking.

Stacking is a way to ensemble multiple classifications. The point of stacking is to explore a space of different models for the same problem. The idea is that you can attack a learning problem with different types of models which are capable to learn some part of the problem, but not the whole space of the problem. So, you can build multiple different learners and you use them to build an intermediate prediction, one prediction for each learned model. Then you add a new model which learns from the intermediate predictions the same target.

This final model is said to be stacked on the top of the others, hence the name. Thus, you might improve your overall performance, and often you end up with a model which is better than any individual intermediate model.

https://www.geeksforgeeks.org/stacking-in-machine-learning/

Training Data

Over the past 7 years I've recorded my son's basketball games and these are available on YouTube. We have thousands of hours of training data which we can use to test and train our machine learning models!

Machine Learning Hardware (on a budget)

This NVIDIA Jetson Nano board could be an interesting and in-expensive solution to train and deploy the Sports Analytics machine learning software.

According to NVIDIA this is a small, powerful computer that let us run multiple neural networks in parallel for applications like "image classification, object detection, segmentation, and speech processing."

Architecture

Once it comes to the architecture we're back on solid ground and have enough experience to make something beautiful.

The machine learning models can get integrated using an architecture explained by ML6 at Devoxx Belgium 2019 [3].

As you can see the architecture is based on Google Cloud but I'm convinced this architecture can most likely also be accomplished using Amazon, IBM or even Microsoft cloud services.

Data crunching

As explained in [3] some models will only need one video frame others will need multiple frames sorted by a timestamp (time-series) to analyse for example player movement.

A possible approach could be accomplished as follows:

Commercial solutions

Second Spectrum. See also this non technical TED talk by Rajiv Mageswaran.
PlaySight has an AI solution to analyse sport games.
Any others?

ML Sporting references

Mask R-CNN

Mask R-CNN with OpenCV example

Homography References

Face Recognition in Action @ Devoxx

Stephan — Fri, 29 Nov 2019 17:12:10 +0000

Every Devoxx Belgium edition produces 4000+ pictures by our event photographer Dimitris (and in the past by An). These pictures are then published into Flickr albums and can be freely used by speakers, attendees and the event organiser.

Finding a specific speaker in the different albums often feels like going down a visual rabbit hole. After scrolling through many Flickr pages and wasting a bit of time, you often find the hidden gem.

This time consuming effort was crying for an automated approach!

Since many years I was searching for a technical solution which would provide me an API that I could integrate in the different conference apps.

A first low level Python solution

In 2018 Alex van Boxel introduced me to Lien Wuyts. She was interested in doing her dissertation exactly on this subject. With the support from Alex, Jan-Kees and myself she worked on a Python prototype where an existing paparazzi model was used to find speaker faces.

A first rough solution was demo'ed during Devoxx Belgium 2018 in an informal BOF session. Together with Jan-Kees she also provided more details during a Devoxx interview.

An Out of the Box Solution

The solution from Lien remained an experimental prototype. Luckily Jan-Kees van Andel was still interested in this project and he suggested the JPoint team would tackle this opportunity during a team-building weekend. After that weekend he informed me they had a working solution based on AWS Recognition.

It works!

Tim van Eijndhoven (a colleague of Jan-Kees) took ownership of the project and he provided a REST interface which I could use from within the new Angular CFP.DEV web app.

The integration was very straight forward. I post the speaker avatar image using a REST interface and the "face-recognition backend" returns me a list of Flickr URL's. These are then listed in the CFP.DEV admin for review. Each picture also has a similarity percentage and includes even the rectangle coordinates where the face was found within the picture.

My PHP CFP.DEV plugin then displays these speaker images on a related Wordpress page.

Wordpress page

Amazon Rekognition also provides highly accurate facial analysis and facial search capabilities that you can use to detect, analyze, and compare faces for a wide variety of user verification, people counting, and public safety use cases.

The Amazon Rekognition model is a scary beast because it works frighteningly well. It finds speakers faces in various unsuspected places. During several Devoxx Belgium program committee meetings we were testing the system with all sorts of pictures and each time we were amazed of the results it presented.

Where's Wally?

Or... where's Mario Fusco? The recognition API returned pictures of speakers where we often had no idea if (s)he was included. After searching for several minutes you could find the speaker, often hidden away with only a portion of the face visible 😱

Or some pictures were returned (for example here of James Birnie) where a partial speaker face was shown on the twitter wall.

Or Louis Jacomet was found because he photobombed our end-of-devoxx-belgium pizza picture 😂🍕

You can find other gems by visiting the Devoxx Belgium speakers page.

Privacy & GDPR

Because of the amazing accuracy we decided to only use this for the speakers. Every user that submits a talk needs to accept the CFP terms & conditions. As a result this gives us permission to publish their talk on YouTube and share their event photo's on Flickr 👍🏼

Project Details

The "Face recognition" project was obviously presented at Devoxx Belgium 2019 by both Tim van Eijndhoven and Roy Braam.

Make sure to watch the presentation if you want more technical details.

Arun Gupta was of course very excited to interview Tim and Roy about their AWS solution.

Thanks again guys for the effort, much appreciated.

What's next?

We now have a nice working solution which obviously could be offered as a service by JPoint, will see what happens on that front 😎

But let's brain-storm for a minute what else could we do with this face recognition solution if we exclude the privacy part:

We could have a camera at the entrance of each room and track which attendee goes to which talk. Based on this info we could recommend talks to other attendees who go to similar sessions. Of course this could already be done just by analysing their schedule favourites instead of tracking faces, which is too scary.
We could allow attendees to upload their photo and we then return all the related Flickr photos where they're included.
Roy van Rijn suggested on Twitter that this solution could also be used in situations where a person wants to enforce his "right to be forgotten". We can now easily find all pictures where a person is included and censure him/her out.
We could have a camera at the main entrance and welcome speakers when they enter the venue. Or use it as a notification to inform me that the speaker has arrived. That would actually be cool but we can already do this when they scan their eTicket.

What else could we do moving forward?

Let me know in the comments below 😎👌

Create the smallest Docker image using JHipster 6 and Java 11+

Stephan — Tue, 21 May 2019 13:57:14 +0000

This article will explain how to create the smallest Docker image possible using JHipster 6 and Java 11+.

Make sure to first read the "Better, Faster, Lighter Java with Java 12 and JHipster 6" by Matt Raible.

Today (Monday 13th of May 2019) Mohammed Aboullaite (from Devoxx Morocco) gave an awesome related talk "Docker containers & java: What I wish I’ve been told!" with lots of interesting info. Make sure to check out his slide deck.

Setup your Java 11 development environment

You can skip this part if you've Java 11 already running on your development machine.

SDKman is a great tool for installing multiple versions of Java. This tool also allows you to switch very easily between different java versions. #MustHave

After installation you can list all the available Java SDK versions.

$ sdk list java
You can select (and install) the Java 11 SDK version as follows:

$ sdk use java 11.0.3-zulu
Now we can change the maven pom.xml java.version from 1.8 to 11.

<java.version>11</java.version>

The SDK files are located in a hidden directory .sdkman which makes it a bit harder to be re-used in IDEA. Adding a symbolic link is a pragmatic solution:

$ cd /Library/Java/JavaVirtualMachines

$ sudo ln -s /Users/stephan/.sdkman/candidates/java/11.0.3-zulu 11.0.03-zulu

Now you can add SDK 11 to your IDEA.

The 'broken' Dockerfile from JHipster

JHipster provides a Dockerfile which is located in src/main/docker :

FROM openjdk:11-jre-slim-stretch

ENV SPRING_OUTPUT_ANSI_ENABLED=ALWAYS \
    JHIPSTER_SLEEP=0 \
    JAVA_OPTS=""

# Add a jhipster user to run our application so that it doesn't need to run as root
RUN adduser -D -s /bin/sh jhipster

WORKDIR /home/jhipster

ADD entrypoint.sh entrypoint.sh
RUN chmod 755 entrypoint.sh && chown jhipster:jhipster entrypoint.sh
USER jhipster

ENTRYPOINT ["./entrypoint.sh"]

EXPOSE 8080

ADD *.war app.war

I've several issue's with this Dockerfile, the main one is... it doesn't work 😂

Make sure to read the addendum why the Dockerfile is broken.

1) The adduser command gives an error when building the Docker image.

Option d is ambiguous (debug, disabled-login, disabled-password)
Option s is ambiguous (shell, system)
adduser [--home DIR] [--shell SHELL] [--no-create-home] [--uid ID]
[--firstuid ID] [--lastuid ID] [--gecos GECOS] [--ingroup GROUP | --gid ID]
[--disabled-password] [--disabled-login] [--add_extra_groups] USER
   Add a normal user


adduser --system [--home DIR] [--shell SHELL] [--no-create-home] [--uid ID]
[--gecos GECOS] [--group | --ingroup GROUP | --gid ID] [--disabled-password]
[--disabled-login] [--add_extra_groups] USER
   Add a system user


adduser --group [--gid ID] GROUP
addgroup [--gid ID] GROUP
   Add a user group


addgroup --system [--gid ID] GROUP
   Add a system group


adduser USER GROUP
   Add an existing user to an existing group


general options:
  --quiet | -q      don't give process information to stdout
  --force-badname   allow usernames which do not match the
                    NAME_REGEX configuration variable
  --help | -h       usage message
  --version | -v    version number and copyright
  --conf | -c FILE  use FILE as configuration file

The command '/bin/sh -c adduser -D -s /bin/sh jhipster' returned a non-zero code: 1

2) The Dockerfile should add a JAR file and not a war file (see the maven pom.xml file packaging field).

The entrypoint.sh script sshould also use a jar file instead of a war.

#!/bin/sh

echo "The application will start in ${JHIPSTER_SLEEP}s..." && sleep ${JHIPSTER_SLEEP}
exec java ${JAVA_OPTS} -noverify -XX:+AlwaysPreTouch -Djava.security.egd=file:/dev/./urandom -jar "${HOME}/app.war" "$@"

DockerFile V2
FROM openjdk:11-jre-slim-stretch

ENV SPRING_OUTPUT_ANSI_ENABLED=ALWAYS \
    JHIPSTER_SLEEP=0 \
    JAVA_OPTS=""

# Add a jhipster user to run our application so that it doesn't need to run as root
RUN adduser --home /home/jhipster --disabled-password jhipster

WORKDIR /home/jhipster

ADD entrypoint.sh entrypoint.sh
RUN chmod 755 entrypoint.sh && chown jhipster:jhipster entrypoint.sh
USER jhipster

ENTRYPOINT ["./entrypoint.sh"]

EXPOSE 8080

ADD *.jar app.jar

This produces a Docker image of 340Mb but can we make it smaller?

From Debian to Alpine Linux (to Distroless)

The JHipster Dockerfile uses an OpenJDK 11 runtime image which is based on Debian, that explains partially why the image is 340Mb. Switching to Alpine Linux is a better strategy!

Mohammed from Devoxx MA suggested to look into an even smaller possibility using Google's "Distroless" Docker images. #NeedMoreTimeToInvestigate

HINT: Consider watching this very interesting Voxxed Days Zurich 2019 presentation from Matthew Gilliard on Java Containers. He takes a Hello World example and deploys it using different strategies including native images.

Azul's OpenJDK Zulu

Azul provides an Alpine Linux OpenJDK distribution for Java 11, the best of both worlds!

The Azul runtime integrates and natively supports the musl library, which makes the integration more efficient (in terms of the footprint and runtime performance).

See also the Portola Project - The goal of this project is to provide a port of the JDK to the Alpine Linux distribution, and in particular the musl C library.

Let's Strip with JLink

Now that we're (finally) on Java 9+ we can take advantage of the Java modules system. This means we can create a custom JVM which only includes the Java modules used by our application.

To find out which modules are used we can use jdeps to introspect our project jar file.

$ jdeps --list-deps myapp-1.0.0.jar

java.base
java.logging
java.sql

Looks like the app only requires 3 Java modules. Unfortunately this is not correct, more on this later.

Next step is to create a custom JVM using jlink and add the 3 required modules:

$ jlink --output myjdk --module-path $JAVA_HOME/jmods --add-modules java.base,java.sql,java.logging

The above command creates a myjdk directory where everything is included to run our jar file.

The Final Dockerfile

After running the JHipster application on a production machine I noticed several modules were still missing to run the Spring Boot web app using Java 11.

java.desktop       // For Java Beans getter's and setters
java.management    // JMX 
jdk.management     // JDK-specific management interfaces for the JVM
java.naming        // JNDI
jdk.unsupported    // Sun.misc.Unsafe
jdk.crypto.ec      // SSL
java.net.http      // HTTP

It's obvious that depending on your project functionality, you'll need to add more modules.

Now that we know which Java modules are required we can create the following Dockerfile.

Part 1 : Take Azul's zulu OpenJDK jvm and create a custom JVM in /jlinked directory.

Part 2

Use Alpine linux and copy the jlinked JDK into /opt/jdk and start the java app.
Undertow forced me to run Spring Boot as root because it could otherwise not open some sockets. Further investigation is needed, suggestions are always welcome.

#
# Part 1
#

FROM azul/zulu-openjdk-alpine:11 as zulu

RUN export ZULU_FOLDER=`ls /usr/lib/jvm/` \
    && jlink --compress=1 --strip-debug --no-header-files --no-man-pages \
    --module-path /usr/lib/jvm/$ZULU_FOLDER/jmods \
    --add-modules java.desktop,java.logging,java.sql,java.management,java.naming,jdk.unsupported,jdk.management,jdk.crypto.ec,java.net.http \
    --output /jlinked

#
# Part 2
#

FROM alpine:latest

COPY --from=zulu /jlinked /opt/jdk/

RUN apk update
RUN rm -rf /var/cache/apk/*

ENV CFP_JAVA_OPTS="-Xmx512m"
ENV CFP_PERFORMANCE_OPTS="-Dspring.jmx.enabled=false -Dlog4j2.disableJmx=true"

CMD /opt/jdk/bin/java $CFP_JAVA_OPTS $CFP_PERFORMANCE_OPTS -XX:+UseContainerSupport \
                           -noverify -XX:+AlwaysPreTouch -Djava.security.egd=file:/dev/./urandom -jar /app.jar

ADD target/*.jar /app.jar

EXPOSE 80

The above example is heavily inspired on the ALF.io provided Dockerfile
We now have a 180Mb Docker image which we can deploy to production 😎💪🏻

Can we Go Faster?

On my to do list is to investigate the Application Class Data Sharing (CDS), if configured correctly the app can have a 25% faster startup time!

CDS was a commercial only feature of the Oracle JDK since version 7, but it has also been available in OpenJ9 and now included in OpenJDK since version 10.

Another strategy to investigate is using an exploded jar file, not sure if that will give any noticeable increase in startup time?

Can we Go Smaller?

Absolutely!

Imagine if JHipster could produce a Quarkus and/or Micronaut project based on your JDL. This would mean we could create a native image thanks to GraalVM.

Producing an even smaller Docker image and stellar fast startup... a stellar combination with Google Cloud Run!

TheFutureLooksBright

Comments and suggestions are very welcome!

Cheers,

Stephan

Part 2 of this article series is now available @ https://dev.to/stephan007/the-jhipster-quarkus-demo-app-1a1n

Addendum

Jib

Immediate response on my article came from Christophe, thanks for the feedback!

Christophe Bornet

@cbornet_

@Stephan007 @brunoborges @alpinelinux @AzulSystems @Docker @OpenJDK @alfio_event Interesting. Note that @java_hipster doesn't use the Dockerfile anymore and it has been removed from master. We now use jib instead.

06:58 AM - 13 May 2019

0 7

It seems JHipster is now using Jib instead of the provided Dockerfile. Will need to investigate how the Dockerfile looks like and if it provides a smaller image?!

Jib builds optimised Docker and OCI images for your Java applications without a Docker daemon - and without deep mastery of Docker best practices. It is available as plugins for Maven and Gradle and as a Java library.

./mvnw package -Pprod verify jib:dockerBuild
More details @ https://www.jhipster.tech/docker-compose/#-building-and-running-a-docker-image-of-your-application

"3 Days Ago"

Another response on the article informed me that the JHipster team had switched to OpenJDK11 using Alpine 3 days ago. That's what I love about JHipster, they're at the top of their game!

"Distroless" Docker Images

My Devoxx Morocco friend Mohammed (and Docker Champion) suggested in a Twitter reply to look at Google's Distroless docker images. Looks very promising indeed, need more time to investigate 😄

Mohammed Aboullaite

@laytoun

@Stephan007 @alpinelinux @AzulSystems @Docker @OpenJDK @alfio_event As an alternative to alpine (and the issues with Musl) you can use a very lightweight linux distro from Google (part of the distroless project github.com/GoogleContaine…)

The base image is glibc based and it size is almost 8M! You can achieve similar results with openjdk hotspot

07:38 AM - 13 May 2019

0 4

Illegal Reflective Access via Undertow

Spring Boot uses Undertow and has a dependency on jboss XNIO-NIO. As a result Java 11 will throw a warning : illegal reflective access operation.

Switching to Jetty instead of Undertow might resolve this?

WARNING: An illegal reflective access operation has occurred

[dvbe19-cfp-app-64676889d-4g8nv dvbe19-app] WARNING: Illegal reflective access by org.xnio.nio.NioXnio$2 (jar:file:/app.jar!/BOOT-INF/lib/xnio-nio-3.3.8.Final.jar!/) to constructor sun.nio.ch.EPollSelectorProvider()

[dvbe19-cfp-app-64676889d-4g8nv dvbe19-app] WARNING: Please consider reporting this to the maintainers of org.xnio.nio.NioXnio$2

[dvbe19-cfp-app-64676889d-4g8nv dvbe19-app] WARNING: Use --illegal-access=warn to enable warnings of further illegal reflective access operations

[dvbe19-cfp-app-64676889d-4g8nv dvbe19-app] WARNING: All illegal access operations will be denied in a future release

And another reflective warning. But for this we don't have an alternative (yet).

[INFO] --- maven-war-plugin:2.2:war (default-war) @ cfp ---
WARNING: An illegal reflective access operation has occurred
WARNING: Illegal reflective access by com.thoughtworks.xstream.core.util.Fields (file:/Users/stephan/.m2/repository/com/thoughtworks/xstream/xstream/1.3.1/xstream-1.3.1.jar) to field java.util.Properties.defaults
WARNING: Please consider reporting this to the maintainers of com.thoughtworks.xstream.core.util.Fields
WARNING: Use --illegal-access=warn to enable warnings of further illegal reflective access operations
WARNING: All illegal access operations will be denied in a future release
References
https://developer.okta.com/blog/2019/04/04/java-11-java-12-jhipster-oidc
https://spring.io/blog/2018/12/12/how-fast-is-spring
https://blog.gilliard.lol/2018/11/05/alpine-jdk11-images.html
https://docs.oracle.com/en/java/javase/11/vm/class-data-sharing.html
Docker containers & java: What I wish I've been told! https://docs.google.com/presentation/d/1d2L6O6WELVT6rwwhiw_Z9jBnFzVPtku4URPt4KCsWZQ/edit#slide=id.g5278af057a_0_124
"Docker containers & java: What I wish I've been told!" Video @ https://www.docker.com/dockercon/2019-videos?watch=docker-containers-java-what-i-wish-i-had-been-told

References

The JHipster Quarkus demo app

Stephan — Tue, 21 May 2019 12:46:24 +0000

Last weekend I wrote an article on creating the smallest possible Docker image for my JHipster application. The result was a 180Mb Docker image which starts on avg. in 56 seconds on Google Cloud.

On this rainy Sunday here in Belgium I decided to create a JHipster application which has the fastest possible startup.

Executive summary

59Mb footprint and 0.056s startup time 😱💪🏻

Quarkus to the rescue!

Ever since Red Hat announced Quarkus I wanted to play with this new project and today was that day.

My ambition is basically to replace an existing Spring Boot app (generated by JHipster) and replace it with a Quarkus native version. Let's see how far we can get.

I wanted to mimic the package structure which JHipster uses, which is very logical. Under the service package you'll also find the DTO's and Mappers.

Domain: Hibernate with Panache

Let's start with first creating a (Conference) Event domain object which has a name and description fields.

package com.devoxx.hipster.domain;

import io.quarkus.hibernate.orm.panache.PanacheEntity;

import javax.persistence.*;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;

@Cacheable
@Entity(name = "hipster_event")
public class Event extends PanacheEntity {

    @NotNull@Size(min = 3, max = 100)
    @Column(nullable = false)
    public String name;

    public String description;
}

Hibernate Panache reminds me of Lombok (no getters and setters needed) and in addition you can also use bean validation. With a simple @Cacheable annotation you cam activate Infinispan caching.

EventRepository

package com.devoxx.hipster.repository;

import com.devoxx.hipster.domain.Event;
import io.quarkus.hibernate.orm.panache.PanacheRepositoryBase;

import javax.enterprise.context.ApplicationScoped;

@ApplicationScoped
public class EventRepository implements PanacheRepositoryBase<Event,Integer> {

    public Event findByName(String name){
        return find("name", name).firstResult();
    }
}

The finder methods are created in the EventRepository. For my simple CRUD web application this is currently only an example method. I'm hoping to add paging and sorting functionality here in later versions.

Basic domain objects could be given directly to Angular but when introducing more complex and confidential fields (like emails or OAuth secrets) you want to have a DTO mapper between the domain and web REST package.

MapStruct

MapStruct is a code generator that greatly simplifies the implementation of mappings between Java bean types based on a convention over configuration approach.

JHipster heavily depends on MapStruct so I needed to investigate if it was possible with Quarkus. The actual Quarkus website doesn't mention it but Google did return some recent effort to make MapStruct part of the Quarkus eco-system, great!

package com.devoxx.hipster.service.mapper;

import com.devoxx.hipster.domain.Event;
import com.devoxx.hipster.service.dto.EventDTO;
import org.mapstruct.Mapper;

@Mapper(config = QuarkusMappingConfig.class)
public interface EventMapper {

    EventDTO toDto(Event event);

    Event toEntity(EventDTO eventDTO);
}

The EventMapper needs a reference to a QuarkusMappingConfig interface which tells Quarkus it's using CDI for dependency injection. There is Spring DI support for Quarkus but not sure if MapStruct already supports it?

package com.devoxx.hipster.service.mapper;
import org.mapstruct.MapperConfig;

@MapperConfig(componentModel = "cdi")
interface QuarkusMappingConfig {
}

Domain model, DTO and Mappers DONE 👍🏼

Service Layer

The EventService is very lightweight and I was very tempted to move this logic into the EventResource class but having a clean separation between these vertical layers will eventually be a good thing. So here we go...

@ApplicationScoped
public class EventService {

    @Inject
    EventMapper eventMapper;

    /**
     * Get all events.
     *
     * @return list of event DTOs.
     */public List<EventDTO> getAll() {
        Stream<Event> events = Event.streamAll();
        return events.map(event -> eventMapper.toDto(event) )
                     .collect(Collectors.toList());
    }
}

The final Service also includes code for getting one specific event (by id) and saving a DTO.

EventResource

@Path("api/events")
@ApplicationScoped
@Produces("application/json")
@Consumes("application/json")
public class EventResource {

    @Inject
    EventService eventService;

//...

    @GETpublic List<EventDTO> getEvents() {
        List<EventDTO> allEvents = eventService.getAll();

        if (allEvents == null) {
            throw new WebApplicationException("No events available", HttpURLConnection.HTTP_NOT_FOUND);
        }

        return allEvents;
    }

//...
}

The EventResource has again no real surprises. Quarkus uses RestEasy and that's a dip switch I need to change in my neck coming from Spring REST, but I'll survive and learn.

Functional Testing

Writing some functional tests which consume the REST endpoints is again a fun experience and looks as follows.

Talking about fun, Quarkus also supports Kotlin. Should give that a try next.

@QuarkusTest
class EventEndpointTest {

    @Test
    void testGetOneEvent() {
        given()
                .when().get("/api/events/1")
                .then()
                .statusCode(HttpURLConnection.HTTP_OK)
                .assertThat()
                .body(containsString("Devoxx"),
                      containsString("for developers"));

    }

    @Test
    void testGetAllEvents() {
        //List all, the database has initially 2 events
        given()
                .when().get("/api/events")
                .then()
                .statusCode(HttpURLConnection.HTTP_OK)
                .assertThat()
                .body("size()", is(2));

    }
}

Let's FlyWay

JHipster uses Liquibase but Quarkus (for now) only supports FlyWay (Axel thanks for the
invite but I have already a headache just looking at beer 🤪).

Next to adding the FlyWay maven dependency you need to activate it by adding the following line in the application.properties file.

# Flyway minimal config properties
quarkus.flyway.migrate-at-start=true

In the resources/db/migration directory you then add the SQL statements. Don't forget to add a PostgreSQL sequence generator otherwise the new domain objects will not get any ids.

CREATE SEQUENCE hibernate_sequence START 10;

CREATE TABLE hipster_event
(
    id   INT,
    name VARCHAR(100),
    description VARCHAR(255)
);
INSERT INTO hipster_event(id, name, description)
VALUES (1, 'Devoxx Belgium 2019', 'The developers conference from developers for developers'),
       (2, 'Devoxx UK 2019', 'The developers conference in London');

Now that we have all the logic in place lets see how we can run this baby.

GraalVM

You need to download GraalVM 1.0 rc16 and Apache Maven 3.5.3+.

Note: GraalVM v19.0 is not yet supported by Quarkus but looks like the Red Hat team is on it @ https://github.com/quarkusio/quarkus/issues/2412

After the project has been compiled and packaged by maven you can now start the Quarkus application:

$ mvn quarkus:dev

What's really cool is that Quarkus supports hot-reload of the project. Whenever a HTTP request hits the application, it reloads the app because it only takes a few milliseconds. Finally having hot-reload without setting up ZeroTurnaround's JRebel is a very nice bonus.

The most important output is listed below...

INFO  [io.qua.dep.QuarkusAugmentor] (main) Beginning quarkus augmentation
INFO  [io.qua.fly.FlywayProcessor] (build-6) Adding application migrations in path: file:/Users/stephan/java/projects/quarkushipster/backend/target/classes/db/migration/
INFO  [io.qua.fly.FlywayProcessor] (build-6) Adding application migrations in path: file:/Users/stephan/java/projects/quarkushipster/backend/target/classes/db/migration
INFO  [io.qua.dep.QuarkusAugmentor] (main) Quarkus augmentation completed in 703ms
INFO  [org.fly.cor.int.lic.VersionPrinter] (main) Flyway Community Edition 5.2.4 by Boxfuse
INFO  [org.fly.cor.int.dat.DatabaseFactory] (main) Database: jdbc:postgresql:quarkus_hipster (PostgreSQL 10.5)
INFO  [org.fly.cor.int.com.DbValidate] (main) Successfully validated 1 migration (execution time 00:00.013s)
INFO  [org.fly.cor.int.sch.JdbcTableSchemaHistory] (main) Creating Schema History table: "public"."flyway_schema_history"
INFO  [org.fly.cor.int.com.DbMigrate] (main) Current version of schema "public": << Empty Schema >>
INFO  [org.fly.cor.int.com.DbMigrate] (main) Migrating schema "public" to version 1.0.0 - HIPSTER
INFO  [org.fly.cor.int.com.DbMigrate] (main) Successfully applied 1 migration to schema "public" (execution time 00:00.050s)
INFO  [io.quarkus] (main) Quarkus 0.15.0 started in 1.781s. Listening on: http://[::]:8080
INFO  [io.quarkus] (main) Installed features: [agroal, cdi, flyway, hibernate-orm, jdbc-postgresql, narayana-jta, resteasy, resteasy-jsonb]

OOOOOooooh Quarkus started my simple CRUD Java application in 1.781 seconds.

Quarkus 0.15.0 started in 1.781s.

And it's not even running in native mode yet 😱

Going Native

Before you can build a native package you need to install the GraalVM native-image tool. Change the shell directory to the GraalVM bin directory and type the following:

$ gu install native-image

Now you can create a native image of the Java application which will take a few tweets and one coffee (around 3 minutes depending on your computer).

$ mvn package -Dnative

The maven command will create a {project}{version}-runner application in the target directory. You can just start the application by executing it in a shell.

The native app first started "only" at around 5,056 seconds but it seemed I had to update my /etc/hosts and add my hostname to the localhost.

127.0.0.1       localhost   Stephans-MacBook-Pro.local
::1             localhost   Stephans-MacBook-Pro.local

Once that was added the native app started in 0,056s as shown below and the application is only 56Mb small 😱

And now the FrontEnd

Had to relax first a bit after the speed shock, but now let's generate the Angular 7 app using JHipster.

JHipster Client

We only need to create the Angular side of the project, which you can do as follows:

$ jhipster --skip-server

Once created we can now import the JDL (JHipster Domain Language) file which will create all the related Angular CRUD pages and logic. The current JDL only has the Event domain model in it with two fields: name & description.

$ jhipster import-jdl jhipster.jdl

This is too easy, the previous command produces state-of-the-art Angular TypeScript code in less than 5 minutes. An average developer would need a day (or more) to make this and probably bill the customer one week!

You run the Angular JHipster web app using npm start and then open your browser and point it to http://localhost:9000

This is what you get:

To show the conference event data I had to implement a few mock REST endpoints in Quarkus for the user authentication and account details.

I also disabled the ROLE_USER authorities in the event.route.ts file because this is not yet configured.

Once those changes were made I could enjoy my CRUD logic.... euh, wait... what? Damn... the browser doesn't like accessing port 9000 and accessing the REST backend endpoints on port 8080. Cross-Origin Resource Sharing (CORS).

Hmm, how will Quarkus handle CORS?

Google pointed me to an example CorsFilter I had to add to the Quarkus project, and that did the trick, great!

We now have a (none secure) Angular web app created by JHipster and talking to a Quarkus backend with a startup time of less than 2 seconds & hot-reload of both the web and the java modules.

What's next?

Another rainy weekend should allow me to add RBAC & JWT (which Quarkus supports) but in the mean time you can checkout the project from

devoxx / quarkusHipster

Quarkus JHipster demo project

This is a basic JHipster Angular CRUD application using Quarkus as the backend service.

Checkout also my related LinkedIn article.

The backend code is very straight forward and uses the following Quarkus (extensions) :

RESTEasy to expose the REST endpoints
Hibernate ORM with Panache to perform the CRUD operations on the database
MapStruct for DTO mapping
FlyWay version control for the database tables
ArC, the CDI inspired dependency injection tool with zero overhead
The high performance Agroal connection pool
Infinispan based caching
All safely coordinated by the Narayana Transaction Manager
A PostgreSQL database; see below to run one via Docker

This demo application is based on the Quarkus example project 'hibernate-orm-panache-resteasy' provided by the RedHat team @ https://github.com/quarkusio/quarkus-quickstarts

Thanks to the Quarkus (Red Hat), JHipster, GraalVM teams for their amazing work!

Requirements

To compile and run this demo you will need:

GraalVM 1.0 rc16
Apache…

View on GitHub

Or on GitLab @ https://gitlab.com/voxxed/quarkushipster

I do accept Merge Requests 😎👍🏼

Thanks again to the GraalVM, Quarkus and JHipster teams for making this magic possible!

Addendum

After publishing the article I got some interesting feedback on Twitter, looks like the startup time is still way too slow 😎

Sanne

@sannegrinovero

@Stephan007 @QuarkusIO @juliendubois @angular @GetMapStruct @FlywayDb @Infinispan @springboot hi @Stephan007 ! Many thanks for the great article, but the boot times you got are way too slow 😅 something is wrong, I'll check it out ... cc/ @emmanuelbernard @QuarkusIO

10:07 AM - 20 May 2019

0 4

I should be getting around 0.015s in native mode but for some unknown reason (DNS resolving?) my native app starts only after 5 seconds. According to Emmanuel it might be related to some slow/unavailable DNS resolution.

Emmanuel Bernard

@emmanuelbernard

@Stephan007 @SanneGrinovero @shelajev @QuarkusIO @juliendubois @angular @GetMapStruct @FlywayDb @Infinispan @springboot I’ve seen something like that on crappy networks. We do suspect some slow/unavailable DNS resolution of sort. Seems to be a general Java problem though vs just Quarkus.

13:31 PM - 20 May 2019

0 1

The above issue was resolved by adding my hostname to the localhost in /etc/hosts!!

You can follow the related discussion on my Twitter timeline.

Stephan

@stephan007

JHipster meets Quarkus, a demo project journey article with bleeding fast startup and small footprint! linkedin.com/pulse/jhipster…

06:44 AM - 20 May 2019

53 123