code-addict

Authentication and authorization in Flutter For Web using Keycloak and Spring Boot 2 application as resource server

2021-02-21T16:20:00+01:00

I wanted to play with several technologies in this project. First thing I wanted to see is how to do the authentication configuration in the Flutter application. I focused only on Flutter For Web although the project should be able to run on other platforms too. I used Keycloak as the authentication and authorization server. Keycloak can be safely treated as a swiss army knife when it comes to authorization and authentication. The last topic is the method of authorization using the JWT token in the application that will be used as an API (or resource server). I’m using Kotlin, Spring Boot, Web Flux, and the Spring Boot Oauth2 Resource Server starter library. All the source code can be found in my repository GitHub account.

The entire project can be run using docker-compose:

version: "3.7"
services:
  flutter-kotlin-api:
    container_name: flutter-kotlin-api
    image: flutter-kotlin-api
    environment:
      - SPRING_SECURITY_OAUTH2_RESOURCESERVER_JWT_JWK_SET_URI=http://flutter-kotlin-keycloak:8080/auth/realms/kotlin-flutter-demo-realm/protocol/openid-connect/certs
    ports: 
      - "8080:8080"
  flutter-kotlin-gui:
    container_name: flutter-kotlin-gui
    image: flutter-kotlin-gui
    ports: 
      - "80:80"
  flutter-kotlin-keycloak:
    container_name: flutter-kotlin-keycloak
    image: jboss/keycloak:12.0.3
    environment:
      - KEYCLOAK_USER=admin 
      - KEYCLOAK_PASSWORD=admin 
      - KEYCLOAK_IMPORT=/tmp/realm-export.json
    ports:
      - "8081:8080"
    volumes:
      - ./keycloak-docker/realm-export.json:/tmp/realm-export.json

but let’s discuss the components of the project :wink:

Keycloak

Keycloak is an open source software product that allow single sign-on with identity and access management. For the purpose of this application it will serve as an authentication/authorization server. The entire authentication and authorization process will consist of the following steps:

The user who want to access /secured endpoint need to first log in using login page.
Username and password is authenticated using Keycloak API
After successfull logging in, Keycloak returns the JWT token.
User can now attempt to enter /secured endpoint using a JWT token.
The API server checks the signature of the JWT token with the public endpoint in Keycloak and authorize the action. In prepared docker-compose configuration you can saw section with Keycloak and its configuration. Configuration is imported at container startup (see realm-export.json), the file contains the configuration of the entire realm, including client, role and user (username -> user , password -> password). If you want to view the Keycloak configuration, you can do it by entering the administrator console. Keycloak administrator username and password are configured in docker-compose: ``` … environment:
- KEYCLOAK_USER=admin
- KEYCLOAK_PASSWORD=admin … ``` In the Keycloak configuration the most important thing for us is the configuration of the client. Go to Clients and choose login-app from the list. The imported configuration should look like this:

Note the configuration of Valid Redirect URIs and Web Origins. The first is important when we use the Keycloak login page to authenticate the user(I am not discussing this approach in this post). The second indicates domains that can request Keycloak API (CORS). If the application that is our GUI is running on the same domain as the keycloak then you do not need to configure anything here. Otherwise, enter a specific domain name. The current value of * (which means that every domain had access) is not safe and may only be used for development purposes :fire:

Entering Roles we can also see one added user role:

If you want to get more information about Keycloak configuration read about it e.g. Keycloak docs , Baeldung blog

Flutter application

Flutter is quite a new framework, and an even newer part of it is dedicated to web development. To start playing with Flutter, install it on your system according to the instructions on this page. And to add web support, follow the instruction on this page. Currently, Flutter 2 already supports web development in stable version (until recently only in beta). If you are using Flutter in version below 2 you need to issue following commands before creating a flutter project:

 flutter channel beta
 flutter upgrade
 flutter config --enable-web

Running flutter channel beta replaces your current version of Flutter with the beta version which supports web development.

Then all you have to do is run flutter create myapp to create application scaffold.

Let’s move on to the application itself. The libraries necessary for the project to run are listed in the pubsec.yaml file:

name: gui
description: A new Flutter project.

# The following line prevents the package from being accidentally published to
# pub.dev using `pub publish`. This is preferred for private packages.
publish_to: 'none' # Remove this line if you wish to publish to pub.dev

# The following defines the version and build number for your application.
# A version number is three numbers separated by dots, like 1.2.43
# followed by an optional build number separated by a +.
# Both the version and the builder number may be overridden in flutter
# build by specifying --build-name and --build-number, respectively.
# In Android, build-name is used as versionName while build-number used as versionCode.
# Read more about Android versioning at https://developer.android.com/studio/publish/versioning
# In iOS, build-name is used as CFBundleShortVersionString while build-number used as CFBundleVersion.
# Read more about iOS versioning at
# https://developer.apple.com/library/archive/documentation/General/Reference/InfoPlistKeyReference/Articles/CoreFoundationKeys.html
version: 1.0.0+1

environment:
  sdk: ">=2.7.0 <3.0.0"

dependencies:
  flutter:
    sdk: flutter
  http: 0.13.0
  flutter_flavor: 1.1.3

  # The following adds the Cupertino Icons font to your application.
  # Use with the CupertinoIcons class for iOS style icons.
  cupertino_icons: ^1.0.0
  shared_preferences: ^2.0.3

dev_dependencies:
  flutter_test:
    sdk: flutter

# For information on the generic Dart part of this file, see the
# following page: https://dart.dev/tools/pub/pubspec

# The following section is specific to Flutter.
flutter:

  # The following line ensures that the Material Icons font is
  # included with your application, so that you can use the icons in
  # the material Icons class.
  uses-material-design: true

  # To add assets to your application, add an assets section, like this:
  # assets:
  #   - images/a_dot_burr.jpeg
  #   - images/a_dot_ham.jpeg

  # An image asset can refer to one or more resolution-specific "variants", see
  # https://flutter.dev/assets-and-images/#resolution-aware.

  # For details regarding adding assets from package dependencies, see
  # https://flutter.dev/assets-and-images/#from-packages

  # To add custom fonts to your application, add a fonts section here,
  # in this "flutter" section. Each entry in this list should have a
  # "family" key with the font family name, and a "fonts" key with a
  # list giving the asset and other descriptors for the font. For
  # example:
  # fonts:
  #   - family: Schyler
  #     fonts:
  #       - asset: fonts/Schyler-Regular.ttf
  #       - asset: fonts/Schyler-Italic.ttf
  #         style: italic
  #   - family: Trajan Pro
  #     fonts:
  #       - asset: fonts/TrajanPro.ttf
  #       - asset: fonts/TrajanPro_Bold.ttf
  #         weight: 700
  #
  # For details regarding fonts from package dependencies,
  # see https://flutter.dev/custom-fonts/#from-packages

I left the generated comments but the most important is the list of libraries under the dependencies section. As you can see, in addition to the SDK, I used the http library which provides the http client,flutter_flavor which allows to pass parameters to the application (this way I pass the main API address). The shared_preferences library is also important, it gives access to local storage in the web application, and on other platforms access to application databases.

When writing an application in Flutter, we create the code mainly in the lib and test directory, the rest of the directories are intended for individual platforms and their task is to run the builded code (for the platform). Of course, when developing for mobile platforms, we will probably tweak something platform sepcific source code ,at least some basic configuration.

Let’s start with the main file:

import 'package:flutter/material.dart';
import 'package:flutter_flavor/flutter_flavor.dart';
import 'flutter_api_demo_app.dart';


void main() {
   FlavorConfig(
        name: "DEV",
        color: Colors.red,
        location: BannerLocation.bottomStart,
        variables: {
            "baseApiUrl": "http://localhost:8080",
            "baseKeycloakUrl": "http://localhost:8081",
        },
    );

  runApp(FlutterApiDemoApp());
}

The only curiosity in this file is FalvorConfig which allows us to create various configurations, e.g. PROD, DEV.

Another FlutterApiDemoApp class is mentioned in the runApp method. Let’s take a look at the file flutter_api_demo_app.dart in which this class is located

import 'package:flutter/material.dart';
import 'package:gui/constants/api_path.dart';
import 'package:gui/login_page.dart';
import 'package:gui/models/api_response.dart';
import 'package:gui/services/rest_api_service.dart';
import 'models/server_message.dart';

class FlutterApiDemoApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter with Keycloak Demo',
      theme: ThemeData(
        primarySwatch: Colors.blue,
        visualDensity: VisualDensity.adaptivePlatformDensity,
      ),
      home: UserHomePage(
        username: null,
      ),
    );
  }
}

class UserHomePage extends StatefulWidget {
  UserHomePage({Key key, this.username}) : super(key: key);
  final String title = 'User Home Page';
  final String username;
  @override
  _UserHomePageState createState() => _UserHomePageState();
}

class _UserHomePageState extends State<UserHomePage> {
  String _serverMessage = '';
  Color _serverMessageStyleColor = Colors.blue;

  _fetchSecuredServerMessage() async {
    var apiService = await RestApiService.getInstance();
    final response = await apiService.apiGetSecured<ServerMessage>(
        ApiPath.API_SECURED, (json) => ServerMessage.fromJson(json));
    _updateState(response);
  }

  _fetchNotSecuredServerMessage() async {
    var apiService = await RestApiService.getInstance();
    final response = await apiService.apiGetNotSecured<ServerMessage>(
        ApiPath.API_NOT_SECURED, (json) => ServerMessage.fromJson(json));
    _updateState(response);
  }

  void _updateState(ApiResponse<ServerMessage> response) {
    if (response.code == 200) {
      _updateServerMessage(response.body);
      _updateServerMessageStyleColor(Colors.blue);
    } else {
      final requestFailedMsg =
          "Failed to fetch data from: ${ApiPath.API_SECURED}";
      _updateServerMessage(new ServerMessage(message: requestFailedMsg));
      _updateServerMessageStyleColor(Colors.red);
    }
  }

  void _updateServerMessage(ServerMessage serverMessage) {
    setState(() {
      _serverMessage = serverMessage.message;
    });
  }

  void _updateServerMessageStyleColor(MaterialColor newColor) {
    setState(() {
      _serverMessageStyleColor = newColor;
    });
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
        appBar: AppBar(
          title: Text(widget.title),
          leading: GestureDetector(
            onTap: () {
              debugPrint("Future menu");
            },
            child: Icon(
              Icons.menu,
            ),
          ),
          actions: <Widget>[
            Padding(
              padding: EdgeInsets.only(top: 20.0),
              child: Text("Username: ${widget.username}"),
            ),
            Padding(
                padding: EdgeInsets.only(right: 40.0),
                child: GestureDetector(
                  onTap: () {
                    Navigator.push(context,
                        MaterialPageRoute(builder: (context) => LoginPage()));
                  },
                  child: Icon(
                    Icons.portrait,
                    size: 26.0,
                  ),
                ))
          ],
        ),
        body: Center(
          child: Container(
            padding: EdgeInsets.all(20),
            child: Column(
              mainAxisAlignment: MainAxisAlignment.center,
              crossAxisAlignment: CrossAxisAlignment.center,
              children: <Widget>[
                Row(
                  mainAxisAlignment: MainAxisAlignment.center,
                  children: [
                    Column(
                      children: [
                        ElevatedButton(
                          child: Text('Non secured API'),
                          onPressed: () =>
                              _fetchNotSecuredServerMessage(),
                        )
                      ],
                    ),
                    Column(
                      children: [
                        ElevatedButton(
                          child: Text('Secured API'),
                          onPressed: () => _fetchSecuredServerMessage(),
                        )
                      ],
                    )
                  ],
                ),
                Divider(),
                Row(mainAxisAlignment: MainAxisAlignment.center, children: [
                  Text(
                    '$_serverMessage',
                    style: new TextStyle(
                        inherit: true,
                        fontSize: 20.0,
                        fontWeight: FontWeight.bold,
                        decorationStyle: TextDecorationStyle.wavy,
                        color: _serverMessageStyleColor),
                  ),
                ])
              ],
            ),
          ),
        ));
  }
}

The FlutterApiDemoApp class itself is rather simple and just defines the page title and the home part. As you can see I use another class for home part -> UserHomePage which extends StatefulWidget. It is a more complicated one, but I will cover it one by one:

because it extends StatefulWidget we can override creteState method . This method returns _UserHomePageState which is state of the UserHomePage.
the state of our application is two variables: String _serverMessage and Color _serverMessageStyleColor. There are two methods _updateServerMessage and _updateServerMessageStyleColor that deal with changing state.
the _fetchSecuredServerMessage and _fetchNotSecuredServerMessage methods are used when the buttons on the home page are pressed. (one for the /secured endpoint and the other for/not-secured). They both use RestApiService to establish a connection and update the state using a message from the API server and color. Blue in case of success and red in case of failure.

Let’s take a look at the RestApiService service which is used to connect to the API:

import 'dart:convert';

import 'package:flutter/foundation.dart';
import 'package:gui/models/api_response.dart';
import 'package:gui/services/session_storage_service.dart';
import 'package:http/http.dart' as http;
import 'package:http/http.dart';

class RestApiService {
  static RestApiService service;

  static Future<RestApiService> getInstance() async {
    if (service == null) {
      service = RestApiService();
    }
    return service;
  }

  Future<ApiResponse<T>> apiGetSecured<T>(
      Uri uri, T Function(Map<String, dynamic>) fromJson) async {
    final headers = await createAuthHeader();
    if (headers == null) {
      return ApiResponse<T>(body: null, code: 401);
    }
    final response = await http.get(uri, headers: headers);
    return parseResponse(response, fromJson);
  }

  Future<ApiResponse<T>> apiGetNotSecured<T>(
      Uri uri, T Function(Map<String, dynamic>) fromJson) async {
    final response = await http.get(uri);
    return parseResponse(response, fromJson);
  }

  ApiResponse<T> parseResponse<T>(
      Response response, T Function(Map<String, dynamic>) fromJson) {
    if (response.statusCode == 200) {
      final parsedBody = deserialize<T>(response.body, (x) => fromJson(x));
      return ApiResponse<T>(body: parsedBody, code: response.statusCode);
    } else {
      final requestFailedMsg =
          "Failed to fetch data from: ${response.request.url}";
      debugPrint(requestFailedMsg);
      return ApiResponse<T>(body: null, code: response.statusCode);
    }
  }

  T deserialize<T>(
    String json,
    T factory(Map<String, dynamic> data),
  ) {
    return factory(jsonDecode(json) as Map<String, dynamic>);
  }

  Future<Map<String, String>> createAuthHeader() async {
    var sessionStorageService = await SessionStorageService.getInstance();
    var accessToken = sessionStorageService.retriveAccessToken();
    if (accessToken == null) {
      debugPrint("No access token in local storage found. Please log in.");
      return null;
    }
    return {"Authorization": "Bearer $accessToken"};
  }
}

The service is a singleton and hence the getInstance method. There are two important methods apiGetSecured and apiGetNotSecured that are used to connect to the API. The apiGetNotSecured method is simple and just does an http GET request and then parses the server’s response into the ApiResponse class. The second method is more complicated because if we want to connect to a secured endpoint, we must have a JWT token in the headers of that request. The JWT token is added to the header in the createAuthHeader method. The token is extracted in it using the retriveAccessToken method from the SessionStorageService service. Let’s take a look at this service.

import 'package:shared_preferences/shared_preferences.dart';
import 'dart:convert';
import 'package:gui/models/token_model.dart';

class SessionStorageService {
  static SessionStorageService manager;
  static SharedPreferences _prefs;
  static const String ACCESS_TOKEN_KEY = "ACCESS_TOKEN";

  static Future<SessionStorageService> getInstance() async {
    if (manager == null || _prefs == null) {
      manager = SessionStorageService();
      _prefs = await SharedPreferences.getInstance();
    }
    return manager;
  }

  void saveAccessToken(String accessToken) {
    _prefs.setString(ACCESS_TOKEN_KEY, accessToken);
  }

  String retriveAccessToken() {
    var tokenJson = _prefs.getString(ACCESS_TOKEN_KEY);
    if (tokenJson == null) {
      return null;
    }
    return TokenModel.fromJson(jsonDecode(tokenJson)).accessToken;
  }
}

This service is also singleton (like all of them in this applcation). Service uses the shared_preferences library, which allows for reading and writing from local storage for web applications (it can be also use in different platform to save in local database). saveAccessToken method saves token in local storage and retriveAccessToken retrives it from there :wink: Now it is still worth pointing to the place where the saveAccessToken method is used. It is the login page:

import 'package:flutter/material.dart';
import 'package:gui/flutter_api_demo_app.dart';
import 'package:gui/services/auth_service.dart';

class LoginPage extends StatelessWidget {
  final TextEditingController _usernameController = TextEditingController();
  final TextEditingController _passwordController = TextEditingController();

  void displayDialog(context, title, text) => showDialog(
        context: context,
        builder: (context) =>
            AlertDialog(title: Text(title), content: Text(text)),
      );

  Future<int> attemptLogIn(String username, String password) async {
    var authService = await AuthService.getInstance();
    return authService.authenticateUser(username, password);
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
        appBar: AppBar(
          title: Text("Log In Page"),
        ),
        body: Padding(
          padding: const EdgeInsets.all(8.0),
          child: Column(
            children: <Widget>[
              TextField(
                controller: _usernameController,
                decoration: InputDecoration(labelText: 'Username'),
              ),
              TextField(
                controller: _passwordController,
                obscureText: true,
                decoration: InputDecoration(labelText: 'Password'),
              ),
              ElevatedButton(
                  onPressed: () async {
                    var username = _usernameController.text;
                    var statusCode =
                        await attemptLogIn(username, _passwordController.text);
                    if (statusCode == 200) {
                      Navigator.push(
                          context,
                          MaterialPageRoute(
                              builder: (context) =>
                                  UserHomePage(username: username)));
                    } else {
                      displayDialog(context, "Something went wrong",
                          "No account was found matching that username and password");
                    }
                  },
                  child: Text("Log In")),
            ],
          ),
        ));
  }
}

It is a very simple widget. It displays the input fields for username and password, and after pressing the Log In button, the method attemptLogIn is triggered. If login is successful, you will be redirected to UserHomePage with your username, if not message is displayed. The attemptLogIn method uses the service AuthService which I will describe now.

import 'package:flutter/foundation.dart';
import 'package:gui/constants/api_path.dart';
import 'package:gui/services/session_storage_service.dart';
import 'package:http/http.dart' as http;

class AuthService {
  static AuthService service;

  static Future<AuthService> getInstance() async {
    if (service == null) {
      service = AuthService();
    }
    return service;
  }

  Future<int> authenticateUser(String username, String password) async {
     var res = await http.post(ApiPath.KEYCLOAK_AUTH, headers: {
      "Content-Type": "application/x-www-form-urlencoded"
    }, body: {
      "username": username,
      "password": password,
      "client_id": "login-app",
      "grant_type": "password"
    });

    if (res.statusCode == 200) {
      var sessionStorageService = await SessionStorageService.getInstance();
      sessionStorageService.saveAccessToken(res.body);
      return res.statusCode;
    } else {
      debugPrint(
          "An Error Occurred during loggin in. Status code: ${res.statusCode} , body: ${res.body.toString()}");
      return res.statusCode;
    }
  }
}

This service has one method and one task, to authenticate the user in Keycloak and, if successful, save the JWT token.

I have described the entire code. I did not paste the code of the DTO models and the class containing constant fields used by services. You can see it in my repository :smiley:

Using VS Code Remote - Containers extension to develop flutter app

In order not to have to install Flutter on my system and be able to easily transfer the project to another computer, I added the Dockerfile_dev file to the project with the appropriate Flutter configuration, thanks to which I can use the Visual Studio Code Remote - Containers extension. This extension lets you use a Docker container as a full-featured development environment. You can read more about it on this page. The mentioned Dockerfile_dev file looks like this:

FROM ubuntu:20.04
ARG DEBIAN_FRONTEND=noninteractive

ENV FLUTTER_WEB_PORT="8090"
ENV FLUTTER_DEBUG_PORT="42000"

# Prerequisites
RUN apt-get update && apt-get install -y unzip xz-utils git openssh-client curl && apt-get upgrade -y 

# Install flutter beta
RUN curl -L https://storage.googleapis.com/flutter_infra/releases/stable/linux/flutter_linux_2.0.1-stable.tar.xz | tar -C /opt -xJ

ENV PATH="$PATH":"/opt/flutter/.pub-cache/bin:/opt/flutter/bin"

# Enable web capabilities
RUN flutter upgrade
RUN flutter update-packages

As you can see, there is nothing unusual here, we download FLutter and update packages. It is also necessary to configure the VS Code extension. It is located in the file .devcontainer/devcontainer:

{
	"name": "Flutter",
	"dockerFile": "../Dockerfile_dev",
	"extensions": [
		"dart-code.dart-code",
		"dart-code.flutter",
		"k--kato.intellij-idea-keybindings"
	],
	"runArgs": [],
	"postCreateCommand": "flutter pub get"
}

We indicate in it the Dockerfile that we want to use and needed VS Code extensions which we will also use during development. There is also postCreateCommand which runs flutter pub get command (install packages) after container is created. There are many more configuration options - take a look at the documentation on the page I mentioned above. To run the docker configuration using the extension, click the green icon in the lower left corner of VS Code:

There is no difference when developing with Visual Studio Code Remote - Containers extension. If, for example, we want to run the Flutter application in debug mode, all we have to do is install the Dart Debug Extension in Chrome. To run the application use following launch command:

flutter run -d web-server --web-port $FLUTTER_WEB_PORT

FLUTTER_WEB_PORT is set to 8090 in Dockerfile_dev so if you use VS Code extension then your application will start using this port.

If you want to debug please use the added launch configuration:

{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "flutter-dart DEBUG",
            "request": "launch",
            "type": "dart",
            "program": "lib/main.dart",
            "args": [
                "-d",
                "web-server",
                "--web-port",
                "$FLUTTER_WEB_PORT",
                "--web-enable-expression-evaluation"
            ]
        }
    ]
}

Sometimes VS Code shows you errors in the code, click on the Remote-Containers extension icon and click on Reopen ... this should help (you can also ignore them when you want to just run the application).

In the directory with flutter project I have also included the Dockerfile configuration which allows you to build and run the builded project:

# Stage 1 : build production code
FROM ubuntu:20.04 AS build
ARG DEBIAN_FRONTEND=noninteractive
## Prerequisites
RUN apt-get update && apt-get install -y unzip xz-utils git openssh-client curl && apt-get upgrade -y 

## Install flutter beta
RUN curl -L https://storage.googleapis.com/flutter_infra/releases/stable/linux/flutter_linux_2.0.1-stable.tar.xz | tar -C /opt -xJ
ENV PATH="$PATH":"/opt/flutter/.pub-cache/bin:/opt/flutter/bin"

COPY . /app
WORKDIR /app/

RUN flutter build web

## Stage 2 : create the docker final image
FROM nginx:alpine
WORKDIR /usr/share/nginx/html
COPY --from=build /app/build/web ./
COPY nginx/nginx.conf /etc/nginx/nginx.conf

This is multistage configuration. First part prepares Flutter environment and build application and then second part is Nginx server with basic configuration used to run this build. To build a project image simply run following command:

docker build -t flutter-kotlin-gui .

Spring Boot API application

The application acting as the project API is written with Kotlin and Spring Boot 2 using the Spring WebFlux module. The application has two endpoints:

import org.springframework.security.access.prepost.PreAuthorize
import org.springframework.web.bind.annotation.GetMapping
import org.springframework.web.bind.annotation.RestController
import reactor.core.publisher.Mono

@RestController
class ApiController {

    @PreAuthorize("permitAll()")
    @GetMapping("/not-secured")
    fun getNonSecuredMessage() = Mono.just(ApiResponse("Server return non secured message"))

    @PreAuthorize("hasRole('USER')")
    @GetMapping("/secured")
    fun getSecuredMessage() = Mono.just(ApiResponse("Server return SECURED message"))
}

As you can see one of them is secured and one permits all connections. Security configuration using JWT tokens for an application using WebFlux should looks as follows:

import org.slf4j.LoggerFactory
import org.springframework.context.annotation.Bean
import org.springframework.security.config.annotation.method.configuration.EnableReactiveMethodSecurity
import org.springframework.security.config.annotation.web.reactive.EnableWebFluxSecurity
import org.springframework.security.config.web.server.ServerHttpSecurity
import org.springframework.security.oauth2.server.resource.authentication.ReactiveJwtAuthenticationConverterAdapter
import org.springframework.security.web.server.SecurityWebFilterChain
import org.springframework.web.cors.reactive.CorsWebFilter

import org.springframework.web.cors.CorsConfiguration
import org.springframework.web.cors.reactive.UrlBasedCorsConfigurationSource


/**
 * For Reactive web applications (WebFlux)
 **/
@EnableWebFluxSecurity
@EnableReactiveMethodSecurity
class ReactiveSecurityConfig {

    private val log = LoggerFactory.getLogger(this.javaClass)

    @Bean
    fun springSecurityFilterChain(http: ServerHttpSecurity): SecurityWebFilterChain? {
        log.info("Customizing security configuration (reactive)")
        http
            .authorizeExchange { exchanges ->
                exchanges
                    .anyExchange().permitAll()
            }
            .oauth2ResourceServer { oauth2ResourceServer ->
                oauth2ResourceServer
                    .jwt { jwt ->
                        jwt.jwtAuthenticationConverter(
                            ReactiveJwtAuthenticationConverterAdapter(
                                KeycloakRealmRoleConverter()
                            )
                        )
                    }
            }
        return http.build()
    }

An important point is setting jwt.jwtAuthenticationConverter(ReactiveJwtAuthenticationConverterAdapterKeycloakRealmRoleConverter()). KeycloakRealmRoleConverter allows to extract roles from a JWT token:

import org.springframework.security.core.authority.SimpleGrantedAuthority
import org.springframework.security.oauth2.jwt.Jwt
import org.springframework.security.oauth2.server.resource.authentication.JwtAuthenticationConverter
import java.util.Collections.emptyList
import java.util.Collections.emptyMap

class KeycloakRealmRoleConverter : JwtAuthenticationConverter() {
    private val authorityPrefix = "ROLE_"

    override fun extractAuthorities(jwt: Jwt): Collection<SimpleGrantedAuthority> {
        val authorities = jwt.claims["realm_access"] as Map<String, List<String>>? ?: emptyMap()
        return authorities.getOrDefault("roles", emptyList())
            .map { roleName -> "$authorityPrefix${roleName.toUpperCase()}" }
            .map { role -> SimpleGrantedAuthority(role) }
    }
}

I also added a simplified CORS filter configuration that allows you to connect from any foreign domain (*). Of course, this settung is not recommended and should be adjusted in production environment :fire: :

import org.springframework.context.annotation.Configuration
import org.springframework.web.reactive.config.CorsRegistry
import org.springframework.web.reactive.config.EnableWebFlux
import org.springframework.web.reactive.config.WebFluxConfigurer


@Configuration
@EnableWebFlux
class CorsGlobalConfiguration : WebFluxConfigurer {
    override fun addCorsMappings(corsRegistry: CorsRegistry) {
        corsRegistry.addMapping("/**")
            .allowedOrigins("*")
            .allowedMethods("PUT", "GET", "POST")
            .maxAge(3600)
    }
}

I’ve also pushed some sample configuration for a project that does not use WebFlux (pl.codeaddict.flutterapi.config.nonreactive package) to repository.

In addition to the above classes, there are two more in the API project. First one serves as an endpoints response:

data class ApiResponse(val message: String

And the second one is just the main class for this application:

import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.runApplication

@SpringBootApplication
class FlutterApiApplication

fun main(args: Array<String>) {
	runApplication<FlutterApiApplication>(*args)
}

Ok, lets have a look at application.yml:

spring:
  security:
    oauth2:
      resourceserver:
        jwt:
          jwk-set-uri: http://localhost:8081/auth/realms/kotlin-flutter-demo-realm/protocol/openid-connect/certs

logging:
  level:
    org.springframework:
      security: INFO

The first part is quite important. We are configuring the endpoint url that allows us to check the signature of the JWT token. Keycloak provides such an endpoint. The configuration for this is also added in docker-compose.yml file. Second part of the configuration is there to setup logging level in case of any troubles with security.

Last but not least project gradle configuration:

import org.jetbrains.kotlin.gradle.tasks.KotlinCompile

plugins {
	id("org.springframework.boot") version "2.4.2"
	id("io.spring.dependency-management") version "1.0.11.RELEASE"
	id("com.google.cloud.tools.jib") version "2.7.1"

	kotlin("jvm") version "1.4.21"
	kotlin("plugin.spring") version "1.4.21"
}

group = "pl.codeaddict"
version = "0.0.1-SNAPSHOT"
java.sourceCompatibility = JavaVersion.VERSION_11

repositories {
	mavenCentral()
}

dependencies {
	implementation("org.springframework.boot:spring-boot-starter-webflux")
	implementation("com.fasterxml.jackson.module:jackson-module-kotlin")
	implementation("io.projectreactor.kotlin:reactor-kotlin-extensions")
	implementation("org.jetbrains.kotlin:kotlin-reflect")
	implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8")
	implementation("org.jetbrains.kotlinx:kotlinx-coroutines-reactor")
	implementation("org.springframework.boot:spring-boot-starter-oauth2-resource-server")

	testImplementation("org.springframework.boot:spring-boot-starter-test")
	testImplementation("io.projectreactor:reactor-test")
}

tasks.withType<KotlinCompile> {
	kotlinOptions {
		freeCompilerArgs = listOf("-Xjsr305=strict")
		jvmTarget = "11"
	}
}

tasks.withType<Test> {
	useJUnitPlatform()
}

jib {
	from {
		image = "gcr.io/distroless/java-debian10:11"
	}
	to {
		image = "flutter-kotlin-api"
	}
	container {
		jvmFlags = listOf("-Duser.timezone=UTC")
		ports = listOf("8080")
		creationTime = "USE_CURRENT_TIMESTAMP"
	}
}

There is probably nothing special here except maybe jib plugin that allows to easily build a docker image with the application.

You can run application using Spring Boot plugin:

./gradlew bootRun

or build docker image using jib:

 ./gradlew jibDockerBuild

The project requires Java version >= 11.

Running whole project

If you build all the docker images following the instructions in the above sections, you can run all parts of the project (API, GUI, Keycloak) with one command issued in the root of the project:

docker-compose up

The application graphic interface should look like this:

There are two buttons in the middle. One runs the endpoint /secured and the second is for/not-secured endpoint. In the upper right corner you can see the username, which if the user is not logged in is null (yes, I know it’s ugly :wink: ). There is an icon next to the username that leads to the login page.

If you click on the icon next to the username, you will be taken to the login page. You can login using the user data added in Keycloak in our imported realm configuration (username -> user , password -> password).

After logging in successfully, you will be redirected back to the home page where you can try out if /secured endpoint is accessible.

As an extra, in the curl-scripts directory, I created some useful curl scripts that calls to the secured and insecure API. Thanks to them, you can check the authentication in application and Keycloak API operation. There is also a script that refreshes ACCESS TOKEN using REFRESH TOKEN (I did not implement it in the application), so you can play around fit it.

What is missing in this project

Certainly many things :smiley: . But it wasn’t my goal to implement everything. I think the most important shortcomings are:

user after clicking on endpoint /secured should be probably automatically taken to login page.
JWT token expires after some time (can be set in Keycloak), and should be refreshed using refresh token.
the token is stored in local storage, it is not an ideal solution in terms of security.

Summary

This is it! You can find all the source code in my repository GitHub account. Have fun and thanks for reading!

How to write the first Kotlin code in Java project

2020-10-30T09:01:00+01:00

Although JDK 15 was released a few weeks ago, unfortunately some programmers, especially in server applications development, still have to deal with a much older version of Java in their projects. This leads to frustration and very often people rotation in projects. The IT world is relentlessly rushing forward and as specialists in our profession, we would like to have access to the latest technologies that make our work more enjoyable, but also more efficient.

Programmers are cunning creatures and try to cope with using different libraries such as lombok, vavr, streamsupport or retrolambda, but using them (especially several at once) makes the configuration unreadable and sensitive to changes. I used to be in the position of a man who was looking for such solutions, and today, working mainly with the Kotlin language, I often wonder why I did not persuade the team to switch to this language.

I think the main factor that prevented me from doing this was the fear of possible problems with the project setup, the time it took to learn a new language and the need to convince the rest of the team. All this is also influenced by the fact that it is difficult to convince “business” to do it. We can often hear the sentence “If it’s working, why break it”. Today, however, I know that such a transition is not difficult and I would like to share it with you and sincerely persuade you to do so.

For those who do not know the advantages of Kotlin, let’s start by answering the question “Why is it worth switching to Kotlin at all?”

Java and Kotlin interoperability. In our project, we do not have to rewrite everything from scratch. All you have to do is create kotlin folder in src/main in addition to the java directory. We can safely call Java code from Kotlin and vice versa.
Kotlin compiles to JVM 6 by default so you can use it for really old projects. Newer versions of the JVM can also be used.
Simple to learn. Kotlin is inspired by existing languages, such as Java, C#, JavaScript, Scala, and Groovy. I am sure that the programmers of these languages will be able to start writing effectively in a new language within a few days.
Concise. Enabling the use of lambdas, extension functions, and higher-order functions. Thanks to this, we can get rid of all the libraries that I mentioned at the beginning of the text.
Safe. One of the most common pitfalls in many programming languages, is trying to access a reference element with a value of null. This, of course, results in the application throwing an exception, which in Java is NullPointerException. In Kotlin, the type system distinguishes between references that can contain null and those that cannot, which makes it much more difficult to go wrong.
Production ready. Behind Kotlin there are over a hundred engineers from JetBrains, a company known for the best IDE IntelliJ IDEA, and on the web you can find many examples of server applications that have been written or translated into Kotlin. My company is also working on such projects and they are implemented successfully.
Automatic Java code conversion to Kotlin in Intellij IDEA. This may not be a adventage of the language itself, but it is a feature that helps make the transition to Kotlin a lot. Every Java example you find on the web is simply pasted into the IDE, which converts it to Kotlin. The converted code this way is not perfect, but it is fully usable. I wouldn’t be honest if I didn’t mention that but there are probably few percent examples that we have to fix manually.

Ok, once we’ve answered the question is it worth it, we need to think about how to do it. I assume you are using some kind of build tool in your projects. So let’s start with Maven.

For example, I used the first multi-module project that I found on Google by typing “github maven multi module” .

Project root configuration:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  
  <groupId>io.jitpack</groupId>
  <artifactId>example-root</artifactId>
  <version>2.0-SNAPSHOT</version>
  <packaging>pom</packaging>
  <name>example-root</name>
  
  <modules>
    <module>module1</module>
    <module>module2</module>
  </modules>
  
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.2</version>
        <configuration> <!-- Compile java 7 compatible bytecode -->
          <source>1.7</source>
          <target>1.7</target>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

It’s time to add Kotlin. So I add some necessary elements to the main pom.xml:

The variable with the Kotlin version we will use:

 <properties>
    <kotlin.version>1.4.10</kotlin.version>
  </properties>

Kotlin standard library dependency which provides many useful functions:

 <dependencies>
    <dependency>
      <groupId>org.jetbrains.kotlin</groupId>
      <artifactId>kotlin-stdlib</artifactId>
      <version>${kotlin.version}</version>
    </dependency>
  </dependencies>

We add to the build section the configuration of the source code paths and a plugin that compiles Kotlin’s source code:

<sourceDirectory>${project.basedir}/src/main/kotlin</sourceDirectory>
<testSourceDirectory>${project.basedir}/src/test/kotlin</testSourceDirectory>

    <plugins>
      <plugin>
        <groupId>org.jetbrains.kotlin</groupId>
        <artifactId>kotlin-maven-plugin</artifactId>
        <version>${kotlin.version}</version>
        <executions>
          <execution>
            <id>compile</id>
            <goals>
              <goal>compile</goal>
            </goals>
            <configuration>
              <sourceDirs>
                <sourceDir>${project.basedir}/src/main/kotlin</sourceDir>
                <sourceDir>${project.basedir}/src/main/java</sourceDir>
              </sourceDirs>
            </configuration>
          </execution>
          <execution>
            <id>test-compile</id>
            <goals> <goal>test-compile</goal> </goals>
            <configuration>
              <sourceDirs>
                <sourceDir>${project.basedir}/src/test/kotlin</sourceDir>
                <sourceDir>${project.basedir}/src/test/java</sourceDir>
              </sourceDirs>
            </configuration>
          </execution>
        </executions>
      </plugin>

The entire configuration looks like this:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  
  <groupId>io.jitpack</groupId>
  <artifactId>example-root</artifactId>
  <version>2.0-SNAPSHOT</version>
  <packaging>pom</packaging>
  <name>example-root</name>
  
  <modules>
    <module>module1</module>
    <module>module2</module>
  </modules>

  <properties>
    <kotlin.version>1.4.10</kotlin.version>
  </properties>

  <dependencies>
    <dependency>
      <groupId>org.jetbrains.kotlin</groupId>
      <artifactId>kotlin-stdlib</artifactId>
      <version>${kotlin.version}</version>
    </dependency>
  </dependencies>

  <build>
    <sourceDirectory>${project.basedir}/src/main/kotlin</sourceDirectory>
    <testSourceDirectory>${project.basedir}/src/test/kotlin</testSourceDirectory>

    <plugins>
      <plugin>
        <groupId>org.jetbrains.kotlin</groupId>
        <artifactId>kotlin-maven-plugin</artifactId>
        <version>${kotlin.version}</version>
        <executions>
          <execution>
            <id>compile</id>
            <goals>
              <goal>compile</goal>
            </goals>
            <configuration>
              <sourceDirs>
                <sourceDir>${project.basedir}/src/main/kotlin</sourceDir>
                <sourceDir>${project.basedir}/src/main/java</sourceDir>
              </sourceDirs>
            </configuration>
          </execution>
          <execution>
            <id>test-compile</id>
            <goals> <goal>test-compile</goal> </goals>
            <configuration>
              <sourceDirs>
                <sourceDir>${project.basedir}/src/test/kotlin</sourceDir>
                <sourceDir>${project.basedir}/src/test/java</sourceDir>
              </sourceDirs>
            </configuration>
          </execution>
        </executions>
      </plugin>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.2</version>
        <configuration> <!-- Compile java 7 compatible bytecode -->
          <source>1.7</source>
          <target>1.7</target>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

Now is the time to add some code written in Kotlin. So I’m adding the kotlin directory to module1 and the package that already exists in the project, as well as a simple service io.jitpack.KotlinRulezService.kt, with the following content:

class KotlinRulezService {
    
    fun talkToMe(greetingWord: String) {
        println("Kotlin Rulez $greetingWord")
    }
}

There is one class written in Java in module1 and that is the main class of the application: io.jitpack.App.java:

public class App 
{
    public static final String GREETING = "Hello World!";
    
    public static void main( String[] args )
    {
        System.out.println(GREETING);
    }
}

Let’s add to it, call to our Kotlin service. After the changes, it should look like this:

public class App 
{
    public static final String GREETING = "Hello World!";
    
    public static void main( String[] args )
    {
        KotlinRulezService service = new KotlinRulezService();
        service.talkToMe(GREETING);
    }
}

Running mvn compile after all this changes should be no problem.

As you can see, adding Kotlin to a project using Maven is very simple. Now let’s try to do the same with the project using Gradle. I will approach this task in the same way as before, i.e. using the first project that Google will find me after entering “github gradle multi module”. This time it is a project gradle-multi-module .

Our configuration is as follows:

buildscript {
    ext {
        springBootVersion = '2.1.3.RELEASE'
    }
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
        classpath "io.spring.gradle:dependency-management-plugin:1.0.6.RELEASE"
    }
}

allprojects {
    group 'com.sungjun'
    version '1.0-SNAPSHOT'
}

subprojects {
    apply plugin: 'java'
    apply plugin: 'org.springframework.boot'
    apply plugin: 'io.spring.dependency-management'

    sourceCompatibility = 1.8

    repositories {
        mavenCentral()
    }

    dependencies {
        testCompile group: 'junit', name: 'junit', version: '4.12'
    }
}

project(':sample-api') {
    dependencies {
        compile project(':sample-common')
    }
}

project(':sample-admin') {
    dependencies {
        compile project(':sample-common')
    }
}

We can build the project using ./gradlew build command. It’s time to add Kotlin:

As in the previous case, we need to add a plugin that will compile the Kotlin code for us. To do this, add the following code to the main build.gradle file under the buildscript section:

plugins {
    id "org.jetbrains.kotlin.jvm" version "1.3.72"
}

For this project, it was necessary to downgrade to a lower version of the plug-in due to the use of Gradle version 4.10.3 in the project.

In the same file we have a subprojects section to which we need to add an apply plugin: 'kotlin' so that we can use Kotlin code in each sub-module.
We also need to add a dependency to the Kotlin standard library: implementation "org.jetbrains.kotlin: kotlin-stdlib-jdk8" in dependencies of the subprojects section. Ultimately, the main configuration file looks like this:

buildscript {
    ext {
        springBootVersion = '2.1.3.RELEASE'
    }
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
        classpath "io.spring.gradle:dependency-management-plugin:1.0.6.RELEASE"
    }
}

plugins {
    id "org.jetbrains.kotlin.jvm" version "1.3.72"
}

allprojects {
    group 'com.sungjun'
    version '1.0-SNAPSHOT'
}

subprojects {
    apply plugin: 'java'
    apply plugin: 'org.springframework.boot'
    apply plugin: 'io.spring.dependency-management'
    apply plugin: 'kotlin'

    sourceCompatibility = 1.8

    repositories {
        mavenCentral()
    }

    dependencies {
        testCompile group: 'junit', name: 'junit', version: '4.12'
        implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
    }
}

project(':sample-api') {
    dependencies {
        compile project(':sample-common')
    }
}

project(':sample-admin') {
    dependencies {
        compile project(':sample-common')
    }
}

We can now start writing some code in Kotlin. In the sub-module sample-api, add the kotlin directory in the src/main directory and add the com.sungjun.api.service package to it. As I mentioned at the beginning of the text, if we use IntelliJ Idea, we can easily convert code written in Java into Kotlin.

I think it would be nice to try it on the example of the service com.sungjun.api.service.MemberServiceCustom in the module mentioned above. So I will create a Kotlin class with the same name: MemberServiceCustom.kt and paste the following Java code into it:

import com.sungjun.common.member.Member;
import com.sungjun.common.repository.MemberRepository;
import org.springframework.stereotype.Service;

@Service
public class MemberServiceCustom {

    private MemberRepository memberRepository;

    public MemberServiceCustom(MemberRepository memberRepository) {
        this.memberRepository = memberRepository;
    }

    public Long singup (Member member) {
        return memberRepository.save(member).getId();
    }
}

The IDE itself will ask whether to convert the code, and as a result of this operation we will get the following Kotlin code:

import com.sungjun.common.member.Member
import com.sungjun.common.repository.MemberRepository
import org.springframework.stereotype.Service

@Service
class MemberServiceCustom(private val memberRepository: MemberRepository) {
    fun singup(member: Member): Long {
        return memberRepository.save(member).id
    }

}

The first thing that catches your eye is the brevity of this code, and you can write it down in even more compact form:

import com.sungjun.common.member.Member
import com.sungjun.common.repository.MemberRepository
import org.springframework.stereotype.Service

@Service
class MemberServiceCustom(private val memberRepository: MemberRepository) {
    fun singup(member: Member) = memberRepository.save(member).id
}

We now need to remove the old Java service because we have a name conflict in this package. We can check all our work by running the test com.sungjun.api.service.MemberServiceCustomTest, which is used by the mentioned service. And that’s the end of the changes needed to use Kotlin Gradle project.

Summary

I hope that in this text I encouraged the use of Kotlin in your projects. I know that commercial projects can be very complex, but let’s remember that with a bit of work we can bring the project into the twenty-first century. Quite often we try to support ourselves with various libraries that can complicate the building process. As you can see in the text, we can easily switch them all into a language that is very pleasant, efficient and can significantly improve the reception of the project by current and new programmers.

At my current work, we write almost all of our server applications in Kotlin. We have never had problems with introducing this language to the project, as well as with the onboarding of new programmers who only dealt with Java before.

This is it! You can find all the source code in my repository GitHub account. Have fun and thanks for reading!

How to bring image to life using machine learing

2020-06-12T13:17:00+02:00

Machine learning today allows you to achieve very interesting effects. Probably everyone has heard about Deepfake. In today’s post I wanted to show you how much this technology is available for everybody this days.

Using my repository you will be able to create face image animations using the image of your face recorded in real time on the camera:

…or to create face image animations using the previously created video of your face:

In this post I will show the code from my repository real-time-example-of-first-order-motion-model-for-image-animation but I would not created that without other people’s work. Projects I used:

AliaksandrSiarohin/first-order-model

anandpawara/Real_Time_Image_Animation

Machine learning model used in the program was described in paper:

@InProceedings{Siarohin_2019_NeurIPS,
  author={Siarohin, Aliaksandr and Lathuilière, Stéphane and Tulyakov, Sergey and Ricci, Elisa and Sebe, Nicu},
  title={First Order Motion Model for Image Animation},
  booktitle = {Conference on Neural Information Processing Systems (NeurIPS)},
  month = {December},
  year = {2019}
}

Short explanation on how the model works

In short, the model decouples appearance and motion information. To support complex motions, it uses a representation consisting of a set of learned keypoints along with their local affine transformations. At the end it combines the appearance extracted from the source image with the motion derived from the video.

I encourage you to watch the video of one of the authors of the model.

How to run project

In order to run the project you need to have Docker installed on your machine. I have been tested this project using Docker 19.03.10 version with nvidia-container-toolkit 1.1.2-1 (if you don’t have CUDA compatible graphics card you don’t need nvidia-container-toolkit). It’s best if you have CUDA compatible graphics card and Docker with CUDA capabilities but don’t worry if you haven’t :smiley: , you can still run the project and use image animation but not in realtime. Making predictions without CUDA is just too slow.

To build image please run:

./build.sh

…and then you can run container using (CUDA):

./run.sh

…or using (CPU):

./run_no_cuda.sh

You should see link to jupyter notebook in terminal, something like this:

http://127.0.0.1:8888/?token=edb9623d6c4ff0eac3096f88bb53ed1f3cfefdd9468f06ab

After you open the Jupyter please run demo.ipynb notebook. I will explain few things here but you can also follow instructions and notes included in jupyter notebook.

Explanation of notebook sections

Load imports and setup

It’s one important thing here aprat from imports. Please set USE_CPU to False if you don’t have CUDA compatible graphic card.

Choose source image

In this section you have to choose the image to be animated. You can choose anyone available in the source_image_inputs folder or upload your own image and put it in this folder. Remember that it’s best if the image has the following specifications:

square proportions
the background has an even color
the face is clearly visible In this section we also resizing image to 256x256 and cutting color to three channels.

Create a model and load checkpoints

We use a trained model here so we have to download it. I have created a function that will automatically download the model and extract it to the extract folder if it does not already exist.

Record your source video

Now is the time to record the video that will be used to animate the previously selected photo. You can skip that and use video that I provieded in repository (temp/test_video_cropped.avi), if you wan’t that please jump to Resizing source video and image section. You can also skip creating animation from prepared video and go straight to the Real time image animation section from here and try real time animation!

Crop and scale video

Recorded video need to be croped and scaled so only your face will be visible in it. The library [1adrianb/face-alignment] (https://github.com/1adrianb/face-alignment){:target=”_blank”} is used to search for the right area to crop in video:

class CropVideoArgs:
    def __init__(self, video_input):
        self.inp = video_input
        self.image_shape = (256,256)
        self.increase = 0.1
        self.iou_with_initial = 0.25
        self.min_frames = 150
        self.cpu = USE_CPU
args = CropVideoArgs(VIDEO_RECORDING)

commands = process_video(args)

After you run above cell, program will search for any faces in provided video and the corresponding parameters for the ffmpeg program, will be returned. You could provide long file with many different faces and program will find all of them and it returning also time (start,end) when face is appearing in recording. For simplicity I use only the first founded face and I use these parameters in the next cell to call ffmpeg.

This process can be slow when you not using CUDA…

Resizing source video

This section automatically selects a recording. If no new recording is available(VIDEO_RECORDING_CROPED), a test recording is used (VIDEO_RECORDING_CROPED_TEST). Test recording is just video with my ugly face :suspect: . Video recording is also resized to 256x256 and only three color channels are used.

Perform image animation

In this section, we will do animation using the model. There are important parameter relative which can produce different results:

when True it is using relative keypoint displacement
when False it is using absolute coordinates. Using absolute coordinates, there are no special requirements for the source video and the appearance of the source image. However, as mentioned by author of the model this usually leads to poor performance, because irrelevant details such as shape are transferred. So using relative coordinates it’s usually better but requires that the object in the first frame of the video and in the source image have the same pose.

I leave two combinations from original project and you can do any of them and choose the best. All resulting recordings are saved in temp folder.

Save animation result with source video and possibly convert to GIF

You can create video file with source image and animation and also convert it to GIF. It will look lie this:

Real time image animation

Here is the coolest part. You can do animation in real time. The camera image is croped and scaled in real time using OpenCV. The result is visible in frame and also recorded to a file.

Summary

You can find all the source code in my repository GitHub account

And don’t forget to give some :star2: to authors of other projects mentioned in the beggining ! Have fun and thanks for reading!

Analyzing data stream with Siddhi and Spring Boot 2

2020-02-09T13:52:00+01:00

Analyzing a data stream to look up patterns is a popular thing this days. Siddhi is a very interesting and one of the easiest tools. The Siddhi package consists of an engine as well as a graphic editor. The engine can be used both as a embedded library and as a separately launched docker container. In Spring applications I recommend the latter option because I don’t see a sensible way to use the library (unless we run the applications as CommandLineRunner) To start with, let’s create a simple application that will receive a POST request with a message and send it to the RabbitMQ queue and will receive information about alarms from another queue. I use Kotlin everywhere to have some extra fun.

This is root project build.gradle file:

import org.jetbrains.kotlin.gradle.tasks.KotlinCompile

buildscript {
    repositories {
        jcenter()
    }
    dependencies {
        classpath("se.transmode.gradle:gradle-docker:1.2")
    }
}

plugins {
    java
    id("org.springframework.boot") version "2.2.4.RELEASE"
    id("io.spring.dependency-management") version "1.0.9.RELEASE"
    kotlin("jvm") version "1.3.61"
    kotlin("plugin.spring") version "1.3.61"
    application
    groovy
}
apply(plugin = "docker")

group = "pl.codeaddict"
version = "0.0.1-SNAPSHOT"
java.sourceCompatibility = JavaVersion.VERSION_1_8

repositories {
    mavenCentral()
    jcenter()
}

dependencies {
    implementation("org.springframework.boot:spring-boot-starter-amqp")
    implementation("org.springframework.boot:spring-boot-starter-webflux")
    implementation("com.fasterxml.jackson.module:jackson-module-kotlin")
    implementation("org.jetbrains.kotlin:kotlin-reflect")
    implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8")
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-reactor")
    testImplementation("org.springframework.boot:spring-boot-starter-test") {
        exclude(group = "org.junit.vintage", module = "junit-vintage-engine")
    }
    testImplementation("io.projectreactor:reactor-test")
    testImplementation("org.springframework.amqp:spring-rabbit-test")
}

tasks.withType<Test> {
    useJUnitPlatform()
}

tasks.withType<KotlinCompile> {
    kotlinOptions {
        freeCompilerArgs = listOf("-Xjsr305=strict")
        jvmTarget = "1.8"
    }
}

application {
    mainClassName = "pl.codeaddict.siddhidemoclient.SiddhidemoclientApplicationKt"
}

configure<se.transmode.gradle.plugins.docker.DockerPluginExtension> {
    maintainer = "Michal Kostewicz <m.kostewicz84@gmail.com>"
    baseImage = "adoptopenjdk/openjdk8:alpine-slim"
}

tasks.register("copyJar",Copy::class){
    dependsOn("build")
    from(file("$buildDir/libs/siddhidemoclient-0.0.1-SNAPSHOT.jar"))
    into(file("$buildDir/docker"))
}

tasks.register("appDocker" ,se.transmode.gradle.plugins.docker.DockerTask::class) {
    dependsOn("copyJar")
    addFile("siddhidemoclient-0.0.1-SNAPSHOT.jar", "/")
    entryPoint(listOf("java", "-Djava.security.egd=file:/dev/./urandom", "-jar", "/siddhidemoclient-0.0.1-SNAPSHOT.jar"))
}

Some things definitely need to be explained.

First of all, I’m using the se.transmode.gradle:gradle-docker:1.2 plugin that allows me to build a docker image for the application. That’s why I created few custom code blocks: configure, copyJar task, appDocker task.

Secondly, I’m using spring-boot-starter-webflux but to tell the truth it’s not needed in this example and you can easily replace it with spring-boot-starter-web.

And the last important thing, I set the Kotlin code compilation to byte code compatible with Java 8 using jvmTarget = "1.8".

In the application I added a simple configuration of the RabbitMQ messages queue:

import org.springframework.amqp.core.Queue
import org.springframework.beans.factory.annotation.Value
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration

@Configuration
class RabbitMQConfig {
    @Value("\${siddhidemo.rabbitmq.messageQueue}")
    val messageQueue: String? = null

    @Bean
    fun queue(): Queue {
        return Queue(messageQueue, false);
    }
}

The class is very simple. As you can see, the queue name is parameterized in application.yml. Now a simple service whose task is to send messages to a configured queue:

import org.springframework.amqp.core.Queue
import org.springframework.amqp.rabbit.core.RabbitTemplate
import org.springframework.stereotype.Service


@Service
class RabbitMQSenderService(
        private val rabbitTemplate: RabbitTemplate,
        private val queue: Queue) {

    fun send(message: String) {
        rabbitTemplate.convertAndSend(queue.name, message);
        println(" [x] Sent '$message'");
    }
}

Let’s move to the first controller whose task is to capture a POST request with a message and send to RabbitMQ through the service:

import org.springframework.web.bind.annotation.PostMapping
import org.springframework.web.bind.annotation.RequestBody
import org.springframework.web.bind.annotation.RestController

@RestController
class MessageQueueController(
        private val rabbitMQSender: RabbitMQSenderService) {

    @PostMapping(value = ["/messages"])
    fun addMessageToQueue(@RequestBody msg: String): String {
        rabbitMQSender.send(msg);
        return "Message sent to the RabbitMQ Successfully";
    }
}

And now the last part of the application, i.e. the service listening for the alarm queue and writing incoming messages to the console:

import org.springframework.amqp.rabbit.annotation.Exchange
import org.springframework.amqp.rabbit.annotation.Queue
import org.springframework.amqp.rabbit.annotation.QueueBinding
import org.springframework.amqp.rabbit.annotation.RabbitListener
import org.springframework.stereotype.Component

@Component
class RabbitMQAlarmReceiver {

    @RabbitListener(bindings = [QueueBinding(value = Queue(value = "\${siddhidemo.rabbitmq.alertsQueue}", durable = "true"),
            exchange = Exchange(value = "\${siddhidemo.rabbitmq.alertsExchange}", durable = "false", ignoreDeclarationExceptions = "true"),
            key = ["\${siddhidemo.rabbitmq.alertsRoutingKey}"])]
    )
    fun receiver(`in`: String) {
        println(" [x] Received '$`in`'")
    }
}

Warning! Siddhi self doesn’t have (or at least I didn’t find anything like that) the possibility of creating queues, exchanges and binding them. This should be done either through the RabbitMQ configuration or, as in this class above, through the configurations in the application, except that the application must have appropriate privileges in RabbitMQ. In the configuration located in the annotation @RabbitListener we configure the queue, exchange, routing key and bind the whole thing together.

Let’s have quick look at application.yml:

siddhidemo.rabbitmq:
  messageQueue: 'messages'
  alertsQueue: 'alerts'
  alertsRoutingKey: 'alerts'
  alertsExchange: 'direct_alerts'
spring:
  rabbitmq:
    host: siddhi-demo-rabbit-mq
    port: 5672
    username: guest
    password: guest

logging.level.root: DEBUG

I don’t think anything about the configuration should be discussed. It is worth mentioning that the RabbitMQ host name is prepared for the docker-compose configuration which I prepared in my project (see my GitHub project)

Ok, now it’s time to create logic on the Siddhi side. In Siddhi we define the so-called applications in which we define the logic of stream analysis. We save the application in separate files with the extension .siddhi. Our example looks like that:

@App:name('SIMPLE_ALERT_FILTER')

@info(name = 'stream from messages queue')
@source(type ='rabbitmq',
uri = 'amqp://guest:guest@siddhi-demo-rabbit-mq:5672',
routing.key= 'messages',
exchange.name= 'direct',
queue.name= 'messages',
@map(type='json'))
define stream MessageStream (msg string);

@sink(type = 'log')
@sink(type ='rabbitmq',
uri = 'amqp://guest:guest@siddhi-demo-rabbit-mq:5672',
routing.key= 'alerts',
exchange.name= 'direct_alerts',
queue.name= 'alerts',
@map(type='json'))
define stream AlertStream (msg string, msg_count long);

@info(name = 'count messages that equals alert in batches in 30 seconds window')
from MessageStream#window.timeBatch(30 sec, 0, true)
select msg, count() as msg_count
group by msg
having msg_count > 3 and msg == "alert"
insert into AlertStream;

Let’s discuss the code step by step.

The first element is @App. This is the name of our application. It must be the same as the file name.

Next is the source definition. So the source of our stream. In our case, source is the messages queue in RabbitMQ. The @Info element is optional and can be used to describe code elements. @map element is used to define how to convert the incoming event, there are few built-in types but in our case I use JSON because the sent event is in the form of JSON (I will write example message below).

Next is the sink definition. As the name suggests, it is a place where something flows down. In our case, it is a separate alerts queue to which the events specified in the query flow. As you can see there are two @sink definitions, one of which is simply used to log events to the console.

The last fragment is the query itself, which checks whether in the message stream (MessageStream) for a 30-second time window there are more than 3 messages with the alert content and if so it inserts them to AlertStream (which is our sink).

To run the application you need docker images with Siddhi and RabbitMQ, I prepared docker-compose in my GitHub repo. If you cloned my project you just need to run:

./gradlew appDocker
cd /docker && docker-comose up

or just run ./gradlew bootRun but check RabbitMQ configuration in application.yml.

Ok, let’s try our code. To send a message to the application, you can use the curl or import the following code into Postman:

curl --location --request POST 'localhost:8080/messages' \
--header 'Content-Type: text/plain' \
--data-raw '{"msg": "just message"}'

Let’s send any message other than alert(like the one above) and after some while send alert message more than three times duirng 30 second time window. When you look at application logs docker logs siddhi-demo-app, you should see that alert receiver print message:

 [x] Received '{"event":{"msg":"alert","msg_count":4}}'

This is it! You can find all the source code in my repository GitHub account. Have fun and thanks for reading!

Spring Boot 2 vs Quarkus - comparison

2020-02-09T13:52:00+01:00

Recently, I watched Quarkus presentations by @burrsutter. The topic interested me a lot because although on a daily basis I don’t work with systems that requires running many instances of microservices, but as a developer I am always interested when someone says that something works faster and needs less resources. Burr in his presentation showed very quickly the comparison of Quarkus and Spring Boot, but I wanted to do it a little more accurately myself while playing with a new technology.

During presentation, an important question was asked about comparing the Spring Boot application that is running on a “warmed up” JVM and thus could be faster than the native Quarkus application…let’s answer this question with some data.

I use Kotlin in both apps and I will give additional thoughts on the use of Kotlin with Quarkus.

Description of both projects

First I will show code of both applications and describe it a bit, and then we will go to performance testing and comparison.

This is Quarkus project build.gradle.kts file:

import io.quarkus.gradle.tasks.QuarkusNative
import org.jetbrains.kotlin.gradle.tasks.KotlinCompile

group = "pl.codeaddict"
version = "1.0.0-SNAPSHOT"

plugins {
    java
    id("io.quarkus") version "1.3.1.Final"
    kotlin("jvm") version "1.3.71"
    kotlin("plugin.allopen") version "1.3.71"
}

repositories {
    mavenCentral()
}

dependencies {
    implementation(kotlin("stdlib-jdk8"))

    implementation(enforcedPlatform("io.quarkus:quarkus-bom:1.3.1.Final"))
    implementation("io.quarkus:quarkus-kotlin")
    implementation("io.quarkus:quarkus-resteasy")
    implementation("io.quarkus:quarkus-resteasy-jackson")
    implementation("io.quarkus:quarkus-agroal")
    implementation("io.quarkus:quarkus-jdbc-h2")

    testImplementation("io.quarkus:quarkus-junit5")
    testImplementation("io.rest-assured:rest-assured")
}

tasks {
    named<QuarkusNative>("buildNative") {
        isEnableHttpUrlHandler = true
    }
}

allOpen {
    annotation("javax.ws.rs.Path")
    annotation("javax.enterprise.context.ApplicationScoped")
    annotation("io.quarkus.test.junit.QuarkusTest")
}

java {
    sourceCompatibility = JavaVersion.VERSION_11
    targetCompatibility = JavaVersion.VERSION_11
}

val compileKotlin: KotlinCompile by tasks
compileKotlin.kotlinOptions {
    jvmTarget = "11"
}

val compileTestKotlin: KotlinCompile by tasks
compileTestKotlin.kotlinOptions {
    jvmTarget = "11"
}

Some things need to be explained. First of all, remember that if you want to build a native application in Quarkus, you must use Quarkus extensions. The list of extensions is available here, and I think there are so many of them that they can meet a lot of developers’ needs. So I used the extensions that were required to create a simple application that provides REST API and connects to the database. For the latter, I used the simplest agroal library which provide JDBC connection pool and provide interfaces to communicate with the database. Another important thing is isEnableHttpUrlHandler option, you need to set it to true if you creating web application and http url handler should be enabled in native build. As you can see I used the allopen plugin which sets the compilation so that all classes are not final but only if they have specific annotations (check allOpen code block). This allows to create proxy objects and is required by many libraries including Quarkus when using Kotlin.

To create project configuration you can also use an initilizer similar to the one offered by Spring.

Let’s have look on Spring Boot project build.gradle.kts file:

import org.jetbrains.kotlin.gradle.tasks.KotlinCompile

plugins {
	id("org.springframework.boot") version "2.2.6.RELEASE"
	id("io.spring.dependency-management") version "1.0.9.RELEASE"
	kotlin("jvm") version "1.3.71"
	kotlin("plugin.spring") version "1.3.71"
}

group = "pl.codeaddict"
version = "1.0.0-SNAPSHOT"

repositories {
	mavenCentral()
}

dependencies {
	implementation("org.springframework.boot:spring-boot-starter")
	implementation("org.springframework.boot:spring-boot-starter-web")
	implementation("org.springframework.boot:spring-boot-starter-data-jdbc")
	runtimeOnly("com.h2database:h2:1.4.200")

	implementation("org.jetbrains.kotlin:kotlin-reflect")
	implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8")

	testImplementation("org.springframework.boot:spring-boot-starter-test") {
		exclude(group = "org.junit.vintage", module = "junit-vintage-engine")
	}
	testImplementation("io.rest-assured:rest-assured")

}

tasks.withType<Test> {
	useJUnitPlatform()
}

java {
	sourceCompatibility = JavaVersion.VERSION_11
	targetCompatibility = JavaVersion.VERSION_11
}

val compileKotlin: KotlinCompile by tasks
compileKotlin.kotlinOptions {
	jvmTarget = "11"
	freeCompilerArgs = listOf("-Xjsr305=strict")
}

val compileTestKotlin: KotlinCompile by tasks
compileTestKotlin.kotlinOptions {
	jvmTarget = "11"
}

As you can see in above file I used very similar libraries so that the projects differ as little as possible. Access to the database will be done through the JDBC template.

Ok, time to show API controller (Quarkus project):

import javax.ws.rs.*
import javax.ws.rs.core.MediaType

@Path("/api")
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
class ApiResource(private val service: ApiResourceService) {

    @GET
    @Path("/{data}")
    fun apiGet(@PathParam("data") data: String): DataObject {
        return service.readDataObject(data)
                .orElseThrow { RuntimeException("No data object with data: $data") }
    }

    @POST
    fun apiPost(dataObject: DataObject): Int {
        return service.storeDataObject(dataObject)
    }
}

I don’t think there is much to explain here. In Quarkus we use JAX-RS annotations to configure context of the application. I created two endpoints, one for returning data from DB and one for saving new data in DB.

API controller in Spring Boot is very similar:

import org.springframework.http.MediaType
import org.springframework.web.bind.annotation.*

@RestController
class ApiResource(private val service: ApiResourceService) {

    @GetMapping(path = ["/api/{name}"], produces = [MediaType.APPLICATION_JSON_VALUE])
    fun apiGet(@PathVariable name: String): DataObject {
        return service.readDataObject(name)
                .orElseThrow { RuntimeException("No data object with name: $name") }
    }

    @PostMapping(path = ["/api"], consumes = [MediaType.APPLICATION_JSON_VALUE], produces = [MediaType.APPLICATION_JSON_VALUE])
    fun apiPost(@RequestBody dataObject: DataObject): Int {
        return service.storeDataObject(dataObject)
    }
}

Let’s have a look at main application service in Quarkus project:

import io.agroal.api.AgroalDataSource
import java.sql.Connection
import java.sql.ResultSet
import java.util.*
import javax.inject.Singleton


@Singleton
open class ApiResourceService(private val dataSource: AgroalDataSource) {

    fun readDataObject(data: String): Optional<DataObject> {
        synchronized(this) {
            val sql = "SELECT * FROM DATA_OBJECTS WHERE DATA = '$data'"
            val connection = getConnection()
            val statement = connection.createStatement()
            val results: ResultSet = statement.executeQuery(sql)
            var dataResult: DataObject? = null
            while (results.next()) {
                val resultData: String = results.getString("DATA")
                dataResult = DataObject(resultData)
                break
            }
            statement.close()
            connection.close()
            return Optional.ofNullable(dataResult)
        }
    }

    fun storeDataObject(data: DataObject): Int {
        synchronized(this) {
            val connection = getConnection()
            val statement = connection.createStatement()
            statement.execute("DROP TABLE DATA_OBJECTS IF EXISTS")
            statement.execute("CREATE TABLE DATA_OBJECTS(" +
                    "ID INT, DATA VARCHAR(100))")

            val result: Int =
                    statement.executeUpdate("INSERT INTO DATA_OBJECTS(DATA) VALUES ('${data.data}')")
            statement.close()
            connection.close()
            return result
        }
    }

    private fun getConnection(): Connection {
        println("JDBC Metrics:" + dataSource.metrics)
        return dataSource.connection
    }
}

One important thing worth mention. Quarkus gives us hot reload when we use ./gradlew quarkusDev without any additional requirements. It’s cool feature. Unfortunately, when we use Kotlin we can encounter many problems with the initialization or injection of beans. For example, the annotation @ApplicationScope which can be found in many Quarkus examples, makes the dataSource object not initializing. When we use this annotation and we change something in the ApiResourceService.class and hot reload occurs dataSource object will be null. I used the @Singleton annotation here, but its limitations should be taken into account (check StackOverflow question) or do not use the Kotlin with Quarkus :disappointed: (Kotlin is still marked as beta on Quarkus initializer site).

Another problem I found is that we can’t use @Synchronized annotation because Quarkus won’t start in dev mode although I wouldn’t use them too often :wink:.

Let’s see same service but for Spring Boot project:

import org.springframework.jdbc.core.JdbcTemplate
import org.springframework.stereotype.Service
import java.sql.ResultSet
import java.util.*


@Service
open class ApiResourceService(private val jdbcTemplate: JdbcTemplate) {

    fun readDataObject(data: String): Optional<DataObject> {
        synchronized(this) {
            val sql = "SELECT * FROM DATA_OBJECTS WHERE DATA = ?"

            return Optional.ofNullable(jdbcTemplate.queryForObject(sql, arrayOf<Any>(data)) { rs: ResultSet, _: Int ->
                DataObject(rs.getString("DATA"))
            })
        }
    }

    fun storeDataObject(dataObject: DataObject): Int {
        synchronized(this) {
            jdbcTemplate.execute("DROP TABLE DATA_OBJECTS IF EXISTS")
            jdbcTemplate.execute("CREATE TABLE DATA_OBJECTS(" +
                    "ID INT, DATA VARCHAR(100))")
            return jdbcTemplate.update("INSERT INTO DATA_OBJECTS(DATA) VALUES (?)", dataObject.data)
        }
    }
}

In both project I use same entity model:

data class DataObject (val data: String = "")

Last but not least, properties files. First Quarkus:

quarkus.datasource.db-kind=h2
quarkus.datasource.username=sa

quarkus.datasource.jdbc.url=jdbc:h2:tcp://localhost:1521/test
quarkus.datasource.jdbc.initial-size=10
quarkus.datasource.jdbc.min-size=10
quarkus.datasource.jdbc.max-size=100
quarkus.datasource.jdbc.enable-metrics=true
quarkus.datasource.metrics.enabled=true

I added properties which turn on metrics for datasource so I can check if connections are created and closed porperly. It’s worth to mention that Quarkus use one property file for every profiles (configuration entries for each profile are marked with prefix), so I thinking that it can be quite messy sometimes. In the first versions it was not possible to use the YAML file but now it is possible after adding the appropriate extension.

Spring Boot property file:

spring.datasource.url=jdbc:h2:tcp://localhost:1521/test
spring.datasource.username=sa
spring.datasource.password=
spring.datasource.hikari.minimumIdle=10
spring.datasource.hikari.maximumPoolSize=100
logging.level.com.zaxxer.hikari=TRACE

I’ve turned on logging for HikariCP to see status of connection pool.

The only visible difference between projects is the parameter quarkus.datasource.jdbc.initial-size. The connection pool in Spring Boot is created in the amount specified by the spring.datasource.hikari.minimumIdle parameter so here I had to set it to have Quarkus application have pool initialized same as Spring Boot.

Running the applications

We can proceed to running the application. Let’s start by running the H2 database in a separate docker container. We can do it using the prepared docker-compose.yml configuration which can be found in the root project directory. Just use below command:

docker-compose up -d h2

…this will start H2 database. Now we have few options when it comes to running Quarkus project:

Start in JVM (dev mode) - just run ./gradlew quarkusDev. This mode is made for development and it has hot reload turn on by default.
Build the application uber-JAR and run so that it use JVM. You can build uber JAR using ./gradlew clean build -x test -Dquarkus.package.uber-jar=true command and run builded JAR with java -jar ./build/QuarkusSimpleAPI-1.0.0-SNAPSHOT-runner.jar. I ommited tests because the only ones that I created are integration tests and applciation need to be up and running before.
Native build (using Docker) - I prepared docker configuration in order to simplify build process. You can use ./build_native.sh script from QuarkusSimpleAPI project dir and then ./run_native.sh script.
Native (without docker). You need to install GrallVM and run ./gradlew clean build -x test -Dquarkus.package.type=native and you can run QuarkusSimpleAPI-1.0.0-SNAPSHOT-runner as normal application.

With Spring Boot project we have two options. You can simply run ./gradlew bootRun or build JAR using ./gradlew build -x test command and then run it using: java -jar ./build/SpringSimpleAPI-1.0.0-SNAPSHOT.jar

To run everything you can use docker-compose up command in project root directory. It runs Quarkus application, both in native and JVM mode, Spring Boot app and H2 in separate container.

If you run the applications, you will immediately see the difference in the start time of each version. But it’s time to run deep dive into tests :smirk:.

Tests

Application launch time

Test conditions: I run applications one at a time in docker containers with the H2 container already running. The values are taken from the application log.
Number of attempts: 11

Results:

app-quarkus-jvm,3.665,1.737,1.716,1.715,1.667,1.877,1.811,1.676,1.895,1.793,1.921
app-spring-boot,3.807,2.724,2.856,2.891,2.819,2.760,2.732,2.744,2.758,2.818,2.908
app-quarkus-native,0.892,0.013,0.016,0.014,0.014,0.012,0.012,0.014,0.014,0.012,0.013

The first launch of each container is noticeably slower but I have kept this data in results.

Plot:

As you can see, Quarkus (native) wins with a significant advantage.

Artifact size

Results:

app-quarkus-jvm,23.388866
app-spring-boot,26.882397
app-quarkus-native,47.413896

Plot:

The native application built using Quarkus has the largest size, but keep in mind that we don’t need Java Runtime with Quarkus Native, so it can really save us a lot.

Application memmory usage

Test conditions: I start all applications on docker and read docker stats. First value is memmory usage when application is at rest and second is maximal usage when receiving requests (I used the wrk tool to load the application. wrk -t2 -c10 -d1m $url command)

Results:

app-quarkus-jvm,97.34,418.2
app-spring-boot,287.3,601.5
app-quarkus-native,6.488,282.5

Plot:

As you can see, Quarkus also wins the competition.

Testing performance

To make testing easier, I added an Dockerfile with the wrk tool that I will be using to test performance. If you want to run tests by yourself first you should build image using test-scripts/perfBuildDocker.sh and then you can run any test script (scripts are prefixed with perf). I set the connection pool size for both applications to min 10, max 100. An I run wrk with 2 simultaneous threads and 10 connections with duration of 10 seconds. This can also be described as ten users that request repeatedly for ten seconds. Application has two endpoints GET which reads from database and POST to write to it.

Quarkus on JVM

GET ‘/api/{data}’

Script used to run tests: perfGetObjQuarkusJVM.sh

Results:

Running 10s test @ http://quarkus-vs-spring-app-quarkus-jvm:8080/api/SlimShady
2 threads and 10 connections
Thread Stats   Avg      Stdev     Max   +/- Stdev
Latency    15.57ms   33.22ms 343.49ms   97.10%
Req/Sec   526.93    251.38     1.50k    65.46%
10219 requests in 10.02s, 0.89MB read
Requests/sec:   1020.09
Transfer/sec:     90.65KB

POST ‘/api/’

Script used to run tests: perfPostObjQuarkusNative.sh

Results:

Running 10s test @ http://quarkus-vs-spring-app-quarkus-jvm:8080/api/
2 threads and 10 connections
Thread Stats   Avg      Stdev     Max   +/- Stdev
Latency    22.45ms   40.84ms 387.82ms   96.29%
Req/Sec   332.73    112.97   580.00     67.53%
6443 requests in 10.01s, 446.73KB read
Requests/sec:    643.53
Transfer/sec:     44.62KB

Quarkus as native application

GET ‘/api/{data}’

Script used to run tests: perfGetObjQuarkusNative.sh

Results:

Running 10s test @ http://quarkus-vs-spring-app-quarkus-native:8080/api/SlimShady
2 threads and 10 connections
Thread Stats   Avg      Stdev     Max   +/- Stdev
Latency     4.64ms    2.15ms  26.13ms   78.92%
Req/Sec     1.09k   103.47     1.36k    72.50%
21780 requests in 10.00s, 1.89MB read
Requests/sec:   2177.64
Transfer/sec:    193.52KB

POST ‘/api/’

Script used to run tests: perfPostObjQuarkusNative.sh

Results:

Running 10s test @ http://quarkus-vs-spring-app-quarkus-native:8080/api/
2 threads and 10 connections
Thread Stats   Avg      Stdev     Max   +/- Stdev
Latency     9.02ms    2.99ms  45.99ms   74.27%
Req/Sec   560.27     67.75   696.00     66.00%
11160 requests in 10.01s, 773.79KB read
Requests/sec:   1114.74
Transfer/sec:     77.29KB

Spring Boot

GET ‘/api/{data}’

Script used to run tests: perfGetObjSpring.sh

Results:

Running 10s test @ http://quarkus-vs-spring-app-spring-jvm:8080/api/SlimShady
2 threads and 10 connections
Thread Stats   Avg      Stdev     Max   +/- Stdev
Latency    11.41ms   45.57ms 441.14ms   96.85%
Req/Sec     1.69k   649.85     2.70k    58.85%
32407 requests in 10.00s, 4.49MB read
Requests/sec:   3239.68
Transfer/sec:    459.34KB

POST ‘/api/’

Script used to run tests: perfPostObjSpring.sh

Results:

Running 10s test @ http://quarkus-vs-spring-app-spring-jvm:8080/api/
2 threads and 10 connections
Thread Stats   Avg      Stdev     Max   +/- Stdev
Latency    14.41ms   46.06ms 429.64ms   96.80%
Req/Sec   847.83    303.67     1.80k    71.35%
16240 requests in 10.00s, 1.94MB read
Requests/sec:   1623.40
Transfer/sec:    198.48KB

Spring Boot long run test (warming up JVM)

Test conditions are similar to those above –> 2 simultaneous threads with 10 connections, but this time I use duration of 15 min.

GET ‘/api/{data}’

Script used to run tests: perfGetObjSpringLong.sh

Results:

Running 15m test @ http://quarkus-vs-spring-app-spring-jvm:8080/api/SlimShady
2 threads and 10 connections
Thread Stats   Avg      Stdev     Max   +/- Stdev
Latency     1.55ms    4.86ms 402.72ms   99.50%
Req/Sec     3.59k   361.49     4.72k    74.17%
6423216 requests in 15.00m, 0.87GB read
Requests/sec:   7136.70
Transfer/sec:      0.99MB

POST ‘/api/’

Script used to run tests: perfPostObjSpringLong.sh

Results:

Running 15m test @ http://quarkus-vs-spring-app-spring-jvm:8080/api/
2 threads and 10 connections
Thread Stats   Avg      Stdev     Max   +/- Stdev
Latency     3.77ms    5.83ms 438.59ms   99.22%
Req/Sec     1.40k   146.65     2.01k    73.86%
2500953 requests in 15.00m, 298.59MB read
Requests/sec:   2778.57
Transfer/sec:    339.70KB

Lets summarize and plot data!

First let’s see latency for our requests. I take average latencies:

Requests per second:

As you can see Quarkus is doing well, however, the warm-up Spring Boot came out best. To sum up, if we have a microservice environment in which we often launch new instances and we care about immediate performance, it is worth using Quarkus. On the other hand, if we have long-lived service, you can easily stay with the good old Spring Boot. Of course, the size of the application and the need for RAM are also important considerations - these can be important indicators when choosing a framework. Quarkus is still a young project but it is worth paying attention to it.

This is it! You can find all the source code in my repository GitHub account. I also share the jupyter notebook in it. Have fun and thanks for reading!

API documentation with Spock and REST Assured in Spring Boot 2

2019-12-25T08:54:00+01:00

I have to start this post from the fact that I love Spock library and for some time I write tests only with use of it. I recently had the task to do API documentation and decided to do it with the help of the REST Assured library. There are a lot of guides and documentation on how to run REST Assured tests in conjunction with JUnit, but few (even less good) regarding the connection with Spock. Unfortunately for some reason I encountered a lot of problems when solving these task. In the end I managed to do it and that’s why I writing this text. Gathering all this I would like to describe how to use Spock and REST Assured to generate documentation of REST API and attach it to the project.

This is root project build.gradle file:

plugins {
	id 'org.springframework.boot' version '2.2.2.RELEASE'
	id 'io.spring.dependency-management' version '1.0.8.RELEASE'
	id 'org.asciidoctor.convert' version '1.6.1'
	id 'groovy'
}

group = 'pl.codeaddict'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '11'

repositories {
	mavenCentral()
}

ext {
	snippetsDir = "$buildDir/generated-snippets"
	spockVersion = '1.3-groovy-2.5'
	springRestDocsVersion = '2.0.4.RELEASE'
	lombokVersion = '1.18.10'
}

dependencies {
	implementation 'org.springframework.boot:spring-boot-starter-web'

	compileOnly "org.projectlombok:lombok:$lombokVersion"

	testImplementation "org.spockframework:spock-core:$spockVersion"
	testImplementation "org.spockframework:spock-spring:$spockVersion"
	testImplementation('org.springframework.boot:spring-boot-starter-test') {
		exclude group: 'org.junit.vintage', module: 'junit-vintage-engine'
	}
	asciidoctor "org.springframework.restdocs:spring-restdocs-asciidoctor:$springRestDocsVersion"
	testImplementation("org.springframework.restdocs:spring-restdocs-restassured:$springRestDocsVersion") {
		exclude group: 'com.sun.xml.bind', module: 'jaxb-osgi'
	}

	annotationProcessor "org.projectlombok:lombok:$lombokVersion"
}

test {
	outputs.dir snippetsDir
}

task copyAsciidocTemplate(type: Copy) {
	dependsOn test
	from "src/docs/asciidoc"
	into snippetsDir
}

asciidoctor {
	dependsOn copyAsciidocTemplate
	sourceDir snippetsDir
	doLast {
		copy {
			from "$buildDir/asciidoc/html5"
			into "$buildDir/resources/main/public/docs"
			include "**/*.html"
		}
	}
}

bootRun.dependsOn(asciidoctor) 

As you can see in the file above there are a few things to do in order to add Spock and Rest assured. In addition to the obvious, i.e. adding libraries, I configured the path where parts of the API documentation will be generated:

snippetsDir = "$buildDir/generated-snippets"

I also created a task (copyAsciidocTemplate) that will copy the template document from the src/docs/asciidoc directory to the same directory where the fragments of API documentation will be generated. Some tutorials show that the generated parts are thrown into the src directory. but for me it is a bad approach..

The configuration of the ascidoc -> html converter plugin (org.asciidoctor.convert) should be placed in the asciidoctor task. I also added there a fragment that copies the generated files to the resources directory, which causes them to be added to the application jar. The last line connects the task ascidoctor with the bootRun task, so it’s build documentation when bootRun task is run.

I have also added a groovy plugin. Remember that after adding it, the Java plugin will also be added automatically so you don’t have to add it anymore.

An important part of the application is the documentation template /src/docs/asciidocs/api.adoc:

= Blog demo API

== Login

operation::login[snippets="curl-request,response-headers"]

== Add Post

operation::add_post[snippets="curl-request,request-headers,request-body,request-fields,response-body,response-fields"]

== Modify Post

operation::modify_post[snippets="curl-request,path-parameters,request-headers,request-body,request-fields"]

== Get Post

operation::get_post[snippets="curl-request,path-parameters,request-headers,response-body,response-fields"]

It is a file that collects all generated fragments into a whole. For example, operation::get_post defines the parts of the documentation for the operation get_post (the name defined in the BlogApiDocumentationSpec.groovy tests, line 137). Please note that curl-request,path-parameters,request-headers,response-body,response-fields fragments must be generated by our test code (but more on this in a moment).

I will not paste the entire test class, only the method testing the get_post operation and generating the fragments used in the template described above:

    void "get post details"() {
        given:
        final request =
                given(this.requestSpec)
                        .port(serverPort)
                        .contentType(MediaType.APPLICATION_JSON_VALUE)
                        .accept(MediaType.APPLICATION_JSON.toString())
                        .header("Authorization", "Bearer TOKEN")
                        .filter(
                                document(
                                        "get_post",
                                        pathParameters(
                                                parameterWithName("id")
                                                        .description("Blog post unique identification number")),
                                        responseFields(
                                                fieldWithPath("id")
                                                        .description("Blog post identification number"),
                                                fieldWithPath("text")
                                                        .description("Blog post text"),
                                        ),
                                        requestHeaders(
                                                headerWithName("Authorization").description(
                                                        "Token for user authentication"))
                                ))

        when:
        final response = request.get('/api/post/{id}', [id: "123-4234"])

        then:
        response.statusCode() == HttpStatus.OK.value()
    }

In given section we define what our request should look like and what response we expect. We set the Accept and Content-type request headers to the value MediaType.APPLICATION_JSON_VALUE and custom Authorization header to value Bearer TOKEN. Then in the filter method we describe how the request and response should look like and what specific parameters mean (description methods). At this point, we also define fragments of documentation that we list in the template (e.g. request-headers). All elements defined in filter will be checked during tests. In when section we running our request with the id path parameter equal to “123-4234”. In then section we perform a simple check whether the response code is 200. I invite you to my Github account for the whole class.

I added a simple controller in the application:

package pl.codeaddict.spockapidocs;

import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api")
public class BlogApiController {

    @PostMapping("/login")
    public ResponseEntity<Void> login(LoginRequest loginRequest) {
        return ResponseEntity.ok().header("Set-Auth-Token", "TOKEN").build();
    }

    @PostMapping("/post")
    public ResponseEntity<AddPostResponse> addPost(AddPostRequest addPostRequest) {
        return ResponseEntity.ok().body(new AddPostResponse("111-333"));
    }

    @PutMapping("/post/{id}")
    public ResponseEntity<Void> modifyPost(@PathVariable String id, ModifyPostRequest modifyPostRequest) {
        return ResponseEntity.ok().build();
    }

    @GetMapping("/post/{id}")
    public ResponseEntity<GetPostDetailsResponse> getPostDetails(@PathVariable String id) {
        return ResponseEntity.ok().body(new GetPostDetailsResponse("111-333","Blog post text"));
    }

}

I will not describe it in more detail, but if you want to expand your knowledge, I encourage you to read the Spring tutorials and documentation about RESTfull web services.

You can now start the applications by running ./gradlew bootRun command in project directory. Open http://localhost:8080/docs/api.html address in your browser and enjoy beautiful documentation.

This is it! You can find all the source code in my repository GitHub account. Have fun and thanks for reading!

Drawing a picture captured by a webcam in the Minecraft game using Python, OpenCV and Raspberry Jam Mod for Minecraft.

2018-06-10T12:35:00+02:00

My daughter attends the classes on which she recently wrote Python scripts that can interfere with Minecraft world. Everything can be implemented with thanks to great mod created by arpruss - Raspberry Jam Mod. Creator of the mod wrote great instruction on Instructables that show you how to install and use the mod in Minecraft. I wanted to play with mod and I thought it would be fun to draw in a Minecraft what can now be caught in the lens of a computer camera and mainly meant my own face :).

I used the OpenCV library to capture images from the camera. In order to install OpenCV you must first install NumPy library. You can download all libraries using pip repository (except the Raspberry Jam mod that can be installed using instructions from Instructables). Additionally on Windows system you can download wheel files from below site:

NumPy
OpenCV

and install them using pip, in example:

pip install opencv_python‑3.4.1+contrib‑cp36‑cp36m‑win32.whl

If you have Minecraft, Raspberry Jam Mod and both of the above libraries you can start writing some code.

First let’s have look at imports:

import cv2 
from mcpi.minecraft import Minecraft
from math import sqrt

As you can see I just imported OpenCV, Minecraft class from mod library and sqrt function from math standard library.

The main part of the code is two global variables and a while loop:

mc = Minecraft.create()
cap = cv2.VideoCapture(0)

...some code omitted

while(1):
 
    # reads frames from a camera
    ret, frame = cap.read()

    # if camera is upside down change value (0 or 1)
    frame_flip = cv2.flip(frame, 0)

    # converting to camera img from bgr to rgb
    frame_rgb = cv2.cvtColor(frame_flip, cv2.COLOR_BGR2RGB)

    # you can experimant with blurr
    #blurred = cv2.GaussianBlur(frame_rgb, (3, 3), 0)

    # resize img
    frame_rgb_resized = cv2.resize(frame_rgb, (80, 60)) 

    # display an original frame and resized frame
    cv2.imshow('Normal picture',frame_rgb)
    cv2.imshow('Resized picture',frame_rgb_resized)

    # Esc key to stop / space to draw picture in Minecraft
    k = cv2.waitKey(5) & 0xFF
    if k == 27:
        break
    if k == 32:
        drawImg(frame_rgb_resized)
 
# close window and deallocate camera
cap.release()
cv2.destroyAllWindows() 

The program reads frames from the camera, reduces their size and changes color to RGB. Most of the cameras in laptops are recorded in BGR color and in order to use the script, it should be converted to RGB (in case of problems, one should look at the camera documentation or make sure it records in BGR). The size of the image can be edited (change cv2.resize(frame_rgb, (width,height)) where width and height are your values), however, you must remember that the bigger the longer it will draw in the game. Sometimes the image from the camera is upside down as it was in my case and it can be flipped using cv2.flip(frame,0). After launching, the program displays two windows, one with a standard image of the camera, the other with a resized image and It expect to press a space key that initiates drawing a selected frame from the camera image. In order to exit the program, you can press escape.

To draw an image in Minecraft I use several additional methods:

... some code omitted

possibleBlocks = (
    ("Air", 0, ( (0, 136, 255) ,),0),
    ("Smooth Stone", 1, ( (125,125, 125) ,),0),
    ("Dirt", 3, ( (133,96,66),),0),
    ("Cobblestone", 4, ( (117,117,117),),0),
    ("Wooden Plank", 5, ( (156,127,78),),0),
    ("Bedrock", 7, ( (83,83,83),),0),
    ("Sand", 12, ( (217,210,158),),0),
    ("Gravel", 13, ( (136, 126, 125),),0),
    ("Gold Ore", 14, ( (143,139,124),),0),
    ("Iron Ore", 15, ( (135,130,126),),0),
    ("Coal Ore", 16, ( (115,115,115),),0),
    ("Wood", 17, ( (154,125,77),),0),
    ("Sponge", 19, ( (182,182,57),),0),
    ("White Wool", 35, ( (221,221,221),),0),
    ("Orange Wool", 35, ( (233,126,55),),1),
    ("Magenta Wool", 35, ( (179,75,200),),2),
    ("Light Blue Wool", 35, ( (103,137,211),),3),
    ("Yellow Wool", 35, ( (192,179,28),),4),
    ("Light Green Wool", 35, ( (59,187,47),),5),
    ("Pink Wool", 35, ( (217,132,153),),6),
    ("Dark Gray Wool", 35, ( (66,67,67),),7),
    ("Gray Wool", 35, ( (157,164,165),),8),
    ("Cyan Wool", 35, ( (39,116,148),),9),
    ("Purple Wool", 35, ( (128,53,195),),10),
    ("Blue Wool", 35, ( (39,51,153),),11),
    ("Brown Wool", 35, ( (85,51,27),),12),
    ("Dark Green Wool", 35, ( (55,76,24),),13),
    ("Red Wool", 35, ( (162,44,42),),14),
    ("Black Wool", 35, ( (26,23,23),),15),
    ("Gold", 41, ( (249,236,77),),0),
    ("Iron", 42, ( (230,230,230),),0),
    ("TwoHalves", 43, ( (159,159,159),),0),
    ("Brick", 45, ( (155,110,97),),0),
    ("Mossy Cobblestone", 48, ( (90,108,90),),0),
    ("Obsidian", 49, ( (20,18,29),),0),
    ("Diamond Ore", 56, ( (129,140,143),),0),
    ("Diamond Block", 57, ( (99,219,213),),0),
    ("Workbench", 58, ( (107,71,42),),0),
    ("Redstone Ore", 73, ( (132,107,107),),0),
    ("Snow Block", 80, ( (239,251,251),),0),
    ("Clay", 82, ( (158,164,176),),0),
    ("Jukebox", 84, ( (107,73,55),),0),
    ("Pumpkin", 86, ( (192,118,21),),0),
    ("Netherrack", 87, ( (110,53,51),),0),
    ("Soul Sand", 88, ( (84,64,51),),0),
    ("Glowstone", 89, ( (137,112,64),),0)
)

def getBlockFromColor(RGB):
	smallestDistIndex = -1
	smallestDist = 300000
	curIndex = 0
	for block in possibleBlocks:
		for blockRGB in block[2]:
			curDist = getColorDist(RGB, blockRGB)

			if (curDist < smallestDist):
				smallestDist = curDist
				smallestDistIndex = curIndex

		curIndex = curIndex + 1

	if (smallestDistIndex == -1):
		return -1

	return possibleBlocks[smallestDistIndex]

def getColorDist(colorRGB, blockRGB):
	return sqrt( pow(colorRGB[0]-blockRGB[0],2) + pow(colorRGB[1]-blockRGB[1],2) + pow(colorRGB[2]-blockRGB[2],2))

def drawImg(img):
    pos = mc.player.getPos()
    height, width, depth = img.shape
    print("Height:" + str(height))
    print("Width:" + str(width))
    for r in range(height):
        for c in range(width):
            pixel= img[r, c]
            mc_block = getBlockFromColor(pixel)
            mc.setBlock(pos.x+r, pos.y, pos.z+c, mc_block[1])

... some code omitted

drawImg(img) method is the one used when user push space key. It take position of the player and size of the picture passed from camera and then itarate over image pixels, chooses block for given pixel color and draw this in Minecraft game (which you must have running :) ). There are getColorDist(colorRGB, blockRGB) and getBlockFromColor(pixel) methods whose main purpose is to choose Minecraft block for the given RGB color of the pixel. I borrow this two methods from TeachCraft Examples GitHub (They using PIL library to draw image files in Minecraft).

Here is the effect of using the code:

This is it! You can find all the source code in my repository GitHub account.

Have fun and thanks for reading!

Using Kafka Streams to search for suspicious traffic in log stream.

2018-06-10T12:35:00+02:00

Detection of various anomalies in the data stream is a very common business need these days. Applications are often used by many users and thus generate a large amount of data.

As part of the entertainment, I decided to create a tool that will detect specific requests (let’s assume that they are potentially dangerous) in the log stream, and also combine different types of logs in the time window to provide more data for the end user. The application will save such search results in a MongoDB database, and also enable the display of this data through the REST controller. As I have never written anything in the Kotlin, I decided that the project will be written in this language.

The Kafka and MongoDB instances are both needed to run the project, so for ease of use I have put the appropriate configurations for docker-compose in the docker directory. Just enter the directory and run docker-compose up.

This time I use Gradle as building tool. This is my gradle.build file:

buildscript {
	ext {
		kotlinVersion = '1.2.51'
		springBootVersion = '2.0.6.RELEASE'
	}
	repositories {
		mavenCentral()
	}
	dependencies {
		classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
		classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${kotlinVersion}")
		classpath("org.jetbrains.kotlin:kotlin-allopen:${kotlinVersion}")
	}
}

apply plugin: 'kotlin'
apply plugin: 'kotlin-spring'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'
apply plugin: 'io.spring.dependency-management'

group = 'pl.codeaddict'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8
compileKotlin {
	kotlinOptions {
		freeCompilerArgs = ["-Xjsr305=strict"]
		jvmTarget = "1.8"
	}
}
compileTestKotlin {
	kotlinOptions {
		freeCompilerArgs = ["-Xjsr305=strict"]
		jvmTarget = "1.8"
	}
}

repositories {
	mavenCentral()
}

dependencies {
	implementation('org.springframework.boot:spring-boot-starter-data-mongodb-reactive')
	implementation('org.springframework.boot:spring-boot-starter-webflux')
	implementation('org.springframework.kafka:spring-kafka')
	implementation('io.projectreactor.kafka:reactor-kafka')
	implementation('com.fasterxml.jackson.module:jackson-module-kotlin')
	implementation('org.apache.kafka:kafka-streams')
	implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8")
	implementation("org.jetbrains.kotlin:kotlin-reflect")
	testImplementation('org.springframework.boot:spring-boot-starter-test')
	testImplementation('io.projectreactor:reactor-test')
}

As you can see I use Spring Boot 2.0.6 RELEASE version and I added MongoDB, Spring WebFlux, Kafka and Kafka reactor libraries. Kafka reactor library is only needed when you want to use reactive streams with Kafka (simple example use is KafkaReciever in KafkaDemoController).

The application itself consists mainly of configuration, producer and streams processing. For the needs of the application, I had to create a log producer, but it should be assumed that in the actual application the producer will be some other application or several applications at once which sends data directly or indirectly to Kafka.

I will omit the producer’s configuration (whole project is on my GitHub. Link at the bottom of the page). Let’s take a look at the configurations of the consumer and Kafka streams:

@Configuration
class KafkaConsumerConfig {
    @Value("\${delivery-stats.stream.threads:1}")
    private val threads: Int = 1

    @Value("\${delivery-stats.kafka.replication-factor:1}")
    private val replicationFactor: Int = 1

    @Value("\${messaging.kafka-dp.brokers.url:localhost:9092}")
    private val brokersUrl: String? = null

    @Bean
    fun consumerProps(): HashMap<String, Any> {
        val props = HashMap<String, Any>()
        props[ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG] = brokersUrl as String
        props[ConsumerConfig.GROUP_ID_CONFIG] = "fraudDetectionGroup"
        props[ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG] = StringDeserializer::class.java
        props[JsonDeserializer.VALUE_DEFAULT_TYPE] = FraudData::class.java
        props[ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG] = JsonDeserializer(FraudData::class.java).javaClass
        return props
    }

    @Bean
    fun kafkaConsumer(): KafkaConsumer<String, FraudData> {
        val consumer: KafkaConsumer<String, FraudData> = KafkaConsumer(consumerProps())
        consumer.subscribe(arrayListOf(Topics.FRAUD.name))
        return consumer
    }

    @Bean
    fun kafkaReceiver(): KafkaReceiver<String,FraudData> {
        val receiverOptions: ReceiverOptions<String, FraudData> = ReceiverOptions.create(consumerProps())
        receiverOptions.subscription(Collections.singleton(Topics.FRAUD.name))
        return KafkaReceiver.create(receiverOptions)
    }

    @Bean(name = arrayOf(KafkaStreamsDefaultConfiguration.DEFAULT_STREAMS_CONFIG_BEAN_NAME))
    fun kStreamsConfigs(): StreamsConfig {
        val props = HashMap<String, Any>()
        props[StreamsConfig.APPLICATION_ID_CONFIG] = "test-streams"
        props[StreamsConfig.BOOTSTRAP_SERVERS_CONFIG] = brokersUrl as String
        props[StreamsConfig.DEFAULT_KEY_SERDE_CLASS_CONFIG] = Serdes.String().javaClass
        props[StreamsConfig.DEFAULT_VALUE_SERDE_CLASS_CONFIG] = JsonSerde(ProxyData::class.java).javaClass
        props[JsonDeserializer.DEFAULT_KEY_TYPE] = String::class.java
        props[JsonDeserializer.DEFAULT_VALUE_TYPE] = ProxyData::class.java
        return StreamsConfig(props)
    }
}

The consumerProps() method is required by KafkaConsumer and KafkaReveiver which both have the same task - to read Kafka’s topics, but the latter does it in a reactive way. The configuration of the KafkaConsumer and KafkaReceiver (fun kafkaConsumer(), fun kafkaReceiver()) it is left for testing purposes only because I do not send detected data to another topic (you can change that in KafkaStreamConsumer class). I left it if someone wanted to play with this and send processed data to another Kafka topic and then pull it with the KafkaConsumer or KafkaReciver.

The most important in this class is the stream configuration which you can find in kStreamsConfig() method. You can really add a lot of parameters there but in my case these are only the most important, i.e. BOOTSTRAP_SERVERS_CONFIG which is address of Kafka running on my local docker. The DEFAULT_KEY_* and DEFAULT_VALUE_* parameters mean the default data types that the stream operates on but it can be configured also later when connecting to different topics.

Let’s take a look at the producer whose only task is to send up to two topics the standard logs for a given topic, and from time to time a row with suspicious data:

@Service
class KafkaMessageProducer {
    private val PROXY_LOG: String = "{\"rt\": 1504812385296, \"src\": \"192.168.100.252\"," +
            " \"dst\": \"192.168.100.180\",\"request\": \"http://example.com/lorem/ipsum/A!sCDn\"}"
    private val PROXY_STRANGE: String = "{\"rt\": 1504812385296, \"src\": \"192.168.100.174\"," +
            " \"dst\": \"192.168.100.252\",\"request\": \"http://strange.com\"}"
    private val DHCP_LOG: String = "{\"rt\": 1504785607870, \"smac\": \"AB:E9:24:26:6C:1C\"," +
            " \"shost\":\"station6.workstation.bank.pl\",\"src\": \"192.168.100.252\"}"
    private val DHCP_STRANGE: String = "{\"rt\": 1504785607870, \"smac\": \"AB:E9:24:26:6C:1X\", " +
            "\"shost\":\"station666.workstation.bank.pl\", \"src\": \"192.168.100.174\"}"

    @Autowired
    private val kafkaTemplate: KafkaTemplate<String, String>? = null

    fun sendMessage(msg: String, topic: String) {
        kafkaTemplate!!.send(topic, msg)
    }

    @Scheduled(fixedRate = 5000)
    fun sendDhcpLogMessage() {
        sendMessage(DHCP_LOG, Topics.DHCP.name)
    }

    @Scheduled(fixedRate = 10000)
    fun sendStrangeDhcpLogMessage() {
        sendMessage(DHCP_STRANGE, Topics.DHCP.name)
    }

    @Scheduled(fixedRate = 10000)
    fun sendStrangeProxyLogMessage() {
        sendMessage(PROXY_STRANGE, Topics.PROXY.name)
    }

    @Scheduled(fixedRate = 5000)
    fun sendProxyLogMessage() {
        sendMessage(PROXY_LOG, Topics.PROXY.name)
    }
}

I think the code in this case is rather simple and does not require any detailed explanation. We can probably go to the main part of the application that handles the data stream from the topics to which the producer sends:

@Service
class KafkaStreamConsumer {
    @Autowired
    var mongoTemplate: MongoTemplate? = null

    @Bean("kafkaStreamProcessing")
    fun startProcessing(builder: StreamsBuilder): KStream<String, ProxyData>? {
        val dhcpStream = builder.stream(Topics.DHCP.name, Consumed.with(Serdes.String(),
                JsonSerde(DhcpData::class.java)))
                .map<String, DhcpData>(DhcpKeyValueMapper())

        val proxyStream = builder.stream(Topics.PROXY.name, Consumed.with(Serdes.String(),
                JsonSerde(ProxyData::class.java)))
                .map<String, ProxyData>(ProxyKeyValueMapper())
        val timeNow = LocalDateTime.now().format(DateTimeFormatter.ISO_DATE_TIME)
        val innerJoin = proxyStream.join(dhcpStream, { proxy, dhcp -> FraudData(dhcp, proxy, timeNow) },
                JoinWindows.of(5000)
                , Serdes.String(), JsonSerde(ProxyData::class.java), JsonSerde(DhcpData::class.java))
                .filter({ _, value -> value.proxyData!!.request == "http://strange.com" })

        innerJoin.foreach { key, value ->  mongoTemplate!!.save(value)}

        // I use mongoDB in this example but you can push result to another Kafka topic.
        //innerJoin.to(Topics.FRAUD.name)
        return proxyStream
    }

    class ProxyKeyValueMapper : KeyValueMapper<String, ProxyData, KeyValue<String, ProxyData>> {
        override fun apply(key: String?, value: ProxyData): KeyValue<String, ProxyData> {
            return KeyValue<String, ProxyData>(value.src, value)
        }
    }

    class DhcpKeyValueMapper : KeyValueMapper<String, DhcpData, KeyValue<String, DhcpData>> {
        override fun apply(key: String?, value: DhcpData): KeyValue<String, DhcpData> {
            return KeyValue<String, DhcpData>(value.src, value)
        }
    }
}

In the startProcessing() method, we first create two streams (dhcpStream and proxyStream), and then combine them into one stream working in the time window (5000 ms) which has FraudData type and finally is filtered out using request address. In this simple case, suspicious data has the request address “http://strange.com”. The join method links streams with their keys which in this case are source machine IP addresse (see ProxyKeyValueMapper and DhcpKeyValueMapper which maps data pulled from topic to key, value map). Finally, the data is saved in mongoDB.

The data stored in mongoDB as suspicious can be seen by entering adrees http://localhost:8080/mongo/frauds/stream. The controller supporting this request is shown below. It works with HTML 5 Server-Sent events technology:

@RestController
class KafkaDemoController {
    @Autowired
    val kafkaStreamConsumer: KafkaConsumer<String, FraudData>? = null
    @Autowired
    val kafkaReactorReceiver: KafkaReceiver<String, FraudData>? = null
    @Autowired
    val fraudDataRepository: FraudDataRepository? = null
    @Autowired
    var mongoTemplate: MongoTemplate? = null

    /*Just for testing. Polling data straight from Kafka is probably not a good idea.*/
    @GetMapping("/kafka/poll")
    fun streamConsumer(): String? {
        return kafkaStreamConsumer?.poll(100)
                ?.map { record -> record.value() }?.joinToString(separator = "\n\n")
    }

    @GetMapping("/kafka-reactor/frauds/stream", produces = arrayOf(MediaType.TEXT_EVENT_STREAM_VALUE))
    fun streamReceiver(): Flux<FraudData>? {
        return kafkaReactorReceiver?.receiveAtmostOnce()?.map { record -> record.value() }
    }


    @GetMapping(value = "/mongo/frauds/all")
    fun dataFromMongo(): Flux<FraudData> {
        return fraudDataRepository!!.findAll()
    }

    @GetMapping(value = "/mongo/frauds/stream", produces = arrayOf(MediaType.TEXT_EVENT_STREAM_VALUE))
    @ResponseBody
    fun streamFromMongo(): Flux<FraudData> {
        return fraudDataRepository!!.findWithTailableCursorBy()
                .delayElements(Duration.ofMillis(2500))
    }
}

If you want to use streamReceiver() controller please switch from writing data to mongoDB to send it to the another specific topic (see KafkaStreamConsumer and my previous mention of it).

This is it! You can find all the source code in my repository GitHub account.

Have fun and thanks for reading!

Simple Hazelcast configuration in Spring Boot 2 application.

2018-06-10T12:35:00+02:00

In one of the projects I have to use Hazelcast so I decided it was a good idea to run a simple project consisting of two applications on separate docker containers. The first application will perform the task of the cache server and simultaneously write to it, and the second will read from the cache. The second application will have a REST controller with the help of which you will be able to view the data saved in the cache. Gradle configurations allow you to create two docker images, simplifying the launch of two applications.

This is root project build.gradle file:

buildscript {
    ext {
        kotlinVersion = '1.2.71'
        springBootVersion = '2.1.1.RELEASE'
        gradleDockerVersion   = "1.2"
    }
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${kotlinVersion}")
        classpath("org.jetbrains.kotlin:kotlin-allopen:${kotlinVersion}")
        classpath("se.transmode.gradle:gradle-docker:${gradleDockerVersion}")
    }

}

allprojects {
    group = 'pl.codeaddict'
    version = '0.0.1-SNAPSHOT'
}

subprojects {
    repositories {
        mavenLocal()
        mavenCentral()
    }
}

…and here is build.gradle file for demo-hazelcast-cache:

plugins {
    id 'kotlin'
    id 'kotlin-spring'
    id 'eclipse'
    id 'org.springframework.boot'
    id 'io.spring.dependency-management'
    id 'application'
    id 'docker'
}

mainClassName = 'pl.codeaddict.demohazelcast.cache.DemoHazelcastApplicationCacheKt'
sourceCompatibility = 1.8
compileKotlin {
    kotlinOptions {
        freeCompilerArgs = ["-Xjsr305=strict"]
        jvmTarget = "1.8"
    }
}
compileTestKotlin {
    kotlinOptions {
        freeCompilerArgs = ["-Xjsr305=strict"]
        jvmTarget = "1.8"
    }
}

jar {
    manifest { attributes 'Main-Class': "$mainClassName" }
    from { configurations.compile.collect { it.isDirectory() ? it : zipTree(it) } }
}

docker {
    maintainer = 'Michal Kostewicz <m.kostewicz84@gmail.com>'
    baseImage "frolvlad/alpine-oraclejdk8:slim"
}

task copyTar(type: Copy) {
    from file("$buildDir/distributions/demo-hazelcast-cache-0.0.1-SNAPSHOT.tar")
    into file("$buildDir/docker")
}

task appDocker(type: Docker) {
    dependsOn 'copyTar'
    addFile('demo-hazelcast-cache-0.0.1-SNAPSHOT.tar', '/')
    entryPoint( ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/demo-hazelcast-cache-0.0.1-SNAPSHOT/lib/demo-hazelcast-cache-0.0.1-SNAPSHOT.jar"])
}

dependencies {
    implementation('org.springframework.boot:spring-boot-starter')
    implementation('com.fasterxml.jackson.module:jackson-module-kotlin')
    implementation('com.hazelcast:hazelcast:3.11.1')
    implementation('com.hazelcast:hazelcast-spring:3.11.1')
    implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8")
    implementation("org.jetbrains.kotlin:kotlin-reflect")
    testImplementation('org.springframework.boot:spring-boot-starter-test')
    testImplementation('io.projectreactor:reactor-test')
}

The demo-hazelcast-cache application is designed to create a Hazelcast configuration that will be available in a distributed system and to save simple information in cache at specified intervals. This application does not have any user interface. The following code shows the simple Hazelcast configuration:

@Configuration
class HazelcastConfiguration {
    @Bean
    fun hazelCastConfig(): Config {
        val config = Config()
        config
                .addMapConfig(
                        MapConfig()
                                .setName("configuration")
                                .setMaxSizeConfig(MaxSizeConfig(200, MaxSizeConfig.MaxSizePolicy.FREE_HEAP_SIZE))
                                .setEvictionPolicy(EvictionPolicy.LRU)
                                .setTimeToLiveSeconds(-1))
        return config
    }
}

I will not discuss individual configuration parameters, you can read about them in the Hazelcast documentation. The following code deals with saving the example information in the cache:

@Service
class ScheduledTasks {
    val key = "MY_KEY"

    @Autowired
    private val hazelcastInstance: HazelcastInstance? = null

    @Scheduled(fixedRate = 1000)
    fun changeHazelcastMap() {
        val hazelcastMap: IMap<String, Int> = hazelcastInstance?.getMap("my-map")!!
        if(!hazelcastMap.containsKey(key)){
            hazelcastMap.put(key,0)
        }else{
            var previousInteger: Int = hazelcastMap.get(key)!!
            val nextInteger = ++previousInteger
            hazelcastMap.put(key, nextInteger)
        }
    }
}

Task of second application demo-hazelcast-client is to read from the common cache and show results through the REST controller (localhost:8080/hazelcast/stream). First, let’s look at the build.gradle file:

plugins {
    id 'kotlin'
    id 'kotlin-spring'
    id 'eclipse'
    id 'org.springframework.boot'
    id 'io.spring.dependency-management'
    id 'application'
    id 'docker'
}

mainClassName = 'pl.codeaddict.demohazelcast.client.DemoHazelcastApplicationClientKt'
sourceCompatibility = 1.8
compileKotlin {
    kotlinOptions {
        freeCompilerArgs = ["-Xjsr305=strict"]
        jvmTarget = "1.8"
    }
}
compileTestKotlin {
    kotlinOptions {
        freeCompilerArgs = ["-Xjsr305=strict"]
        jvmTarget = "1.8"
    }
}

jar {
    manifest { attributes 'Main-Class': "$mainClassName" }
    from { configurations.compile.collect { it.isDirectory() ? it : zipTree(it) } }
}

docker {
    maintainer = 'Michal Kostewicz <m.kostewicz84@gmail.com>'
    baseImage "frolvlad/alpine-oraclejdk8:slim"
}

task copyTar(type: Copy) {
    from file("$buildDir/distributions/demo-hazelcast-client-0.0.1-SNAPSHOT.tar")
    into file("$buildDir/docker")
}

task appDocker(type: Docker) {
    dependsOn 'copyTar'
    addFile('demo-hazelcast-client-0.0.1-SNAPSHOT.tar', '/')
    entryPoint( ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/demo-hazelcast-client-0.0.1-SNAPSHOT/lib/demo-hazelcast-client-0.0.1-SNAPSHOT.jar"])
}

dependencies {
    implementation('org.springframework.boot:spring-boot-starter-web')
    implementation('org.springframework.boot:spring-boot-starter-webflux')
    implementation('com.fasterxml.jackson.module:jackson-module-kotlin')
    implementation('com.hazelcast:hazelcast-client:3.11.1')
    implementation('com.hazelcast:hazelcast-spring:3.11.1')
    implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8")
    implementation("org.jetbrains.kotlin:kotlin-reflect")
    testImplementation('org.springframework.boot:spring-boot-starter-test')
    testImplementation('io.projectreactor:reactor-test')
}

The following code shows the simple Hazelcast client configuration:

@Configuration
class HazelcastConfiguration {
    @Bean
    fun clientConfig(): ClientConfig {
        val clientConfig = ClientConfig()
        val networkConfig = clientConfig.getNetworkConfig()
        networkConfig.addAddress("demo-hazelcast-cache:5701", "demo-hazelcast-cache:5702")
                .setSmartRouting(true)
                .addOutboundPortDefinition("34700-34710")
                .setRedoOperation(true)
                .setConnectionTimeout(5000)
                .setConnectionAttemptLimit(5)

        return clientConfig

    }

    @Bean
    fun hazelcastInstance(clientConfig: ClientConfig): HazelcastInstance {
        return HazelcastClient.newHazelcastClient(clientConfig)
    }

}

This time there is one element that I will discuss. In addAddress("demo-hazelcast-cache:5701", "demo-hazelcast-cache:5702") I’m using docker container addresses (hosts names are configured in docker-compose.yml). As I wrote earlier, the application provides a REST controller:

@RestController
class HazelcastClientController {
    val key = "MY_KEY"

    @Autowired
    private val hazelcastInstance: HazelcastInstance? = null

    @GetMapping(value = "/hazelcast/stream", produces = arrayOf(MediaType.TEXT_EVENT_STREAM_VALUE))
    @ResponseBody
    fun streamHazelcastMap(): Flux<String> {
        val hazelcastMap: IMap<String, Int> = hazelcastInstance?.getMap("my-map")!!
        return Flux
                .interval(Duration.ofMillis(1100))
                .map { tick ->  "NEW VALUE: " + hazelcastMap.get(key) }
    }
}

You can see that I am using the same key (MY_KEY) when extracting data from the cache as if they were saved in the first application. Controller works in the Sent-Events technology and streams information every 1100 ms.

You can start both applications by running gradle build job with appDocker task which creates docker images: ./gradlew build appDocker. After creating images you can use simple docker-compose command to start both apps: cd docker && docker-compose up.

This is it! You can find all the source code in my repository GitHub account. Have fun and thanks for reading!

Spring Boot 2 with Apache Camel and SQL component.

2018-06-10T12:35:00+02:00

In this post I would like to introduce a way to configure Apache Camel version 2.24.1 with the SQL component and Spring Boot 2.1. During the configuration of the project with such technology I encountered few problems, so I would like to describe it in a simple way.

This is root project build.gradle file:

plugins {
	id 'org.springframework.boot' version '2.1.7.RELEASE'
	id 'io.spring.dependency-management' version '1.0.8.RELEASE'
	id 'java'
}

group = 'pl.codeaddict'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '1.8'

repositories {
	mavenCentral()
}

dependencies {
	implementation 'org.springframework.boot:spring-boot-starter-jdbc'
	implementation 'org.apache.camel:camel-spring-boot-starter:2.24.0'
	runtimeOnly 'com.microsoft.sqlserver:mssql-jdbc'
	testImplementation 'org.springframework.boot:spring-boot-starter-test'
	implementation 'org.apache.camel:camel-jdbc-starter:2.24.0'
	implementation 'org.apache.camel:camel-sql-starter:2.24.0'
	compileOnly 'org.projectlombok:lombok:1.18.8'
	annotationProcessor 'org.projectlombok:lombok:1.18.8'
}

As you can see when using Spring Boot, we should use Apache Camel starters and not standard Camel dependencies:

implementation 'org.apache.camel:camel-jdbc-starter:2.24.0'
implementation 'org.apache.camel:camel-sql-starter:2.24.0'

Below is the configuration from the applications.properties file:

spring.datasource.url=jdbc:sqlserver://localhost;databaseName=master
spring.datasource.username=sa
spring.datasource.password=QWE45rty
spring.datasource.driverClassName=com.microsoft.sqlserver.jdbc.SQLServerDriver
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.SQLServer2012Dialect
logging.level.root=DEBUG
camel.springboot.main-run-controller=true

I added configuration of the connection to the MS SQL database. I wanted to show how the Apache Camel SQL component works. An unusual thing is the parameter camel.springboot.main-run-controller=true, it allows you to keep the application alive if you do not use Spring’s web components ( spring-boot-starter-web).

The whole application consists basically of one Apache Camel route which is to fetch rows from the database, map them to objects and log them in the console:

@Component
public class QueueSelectRoute extends RouteBuilder {

    @Override
    public void configure() throws Exception {
        from("timer://dbQueryTimer?period=10s")
                .routeId("DATABASE_QUERY_TIMER_ROUTE")
                .to("sql:SELECT * FROM event_queue?dataSource=#dataSource")
                .process(xchg -> {
                    List<Map<String, Object>> row = xchg.getIn().getBody(List.class);
                    row.stream()
                            .map((x) -> {
                                EventQueue eventQueue = new EventQueue();
                                eventQueue.setId((Long)x.get("id"));
                                eventQueue.setData((String)x.get("data"));
                                return eventQueue;
                            }).collect(Collectors.toList());
                })
                .log(LoggingLevel.INFO,"******Database query executed - body:${body}******");

    }

}

Note the use of ?dataSource=#dataSource. The dataSource name points to the DataSource object configured by Spring, it can be changed to another one and thus use different DataSource in different routes. Adding this parameter is required for proper operation of the application.

I added simple Liquibase scripts to the project to simplify project launch. You can also run docker container with MS SQL using below command:

docker run -e 'ACCEPT_EULA=Y' -e 'SA_PASSWORD=QWE45rty' --name camel_example_db -p 1433:1433 -d mcr.microsoft.com/mssql/server:2017-CU8-ubuntu

When your container is up you can run Liquibase scripts which will add simple tables and a few rows of data:

 ./gradlew -p db-schema update

Remember that this should be run from the main project directory and not from the db-schema catalog.

You can now start the applications by running ./gradlew bootRun command in project directory.

This is it! You can find all the source code in my repository GitHub account. Have fun and thanks for reading!