hexagontk/hexagon

Hexagon is a microservices toolkit written in Kotlin. Its purpose is to ease the building of services (Web applications or APIs) that run inside a cloud platform.

hexagon's Issues

Use Travis secrets only for `master` builds

Using secrets prevents PRs from forks to complete correctly. Use them only when building master (release). Secrets handling is done in .travis.yml.

Port Gradle scripts to Kotlin

Create Undertow server engine

Implement Undertow static file handler

In UndertowEngine. The static resources handler is provisional. Code a proper one to replace this code:

        // TODO Code a proper handler
        val hasAssets = requestHandlers.filterIsInstance<AssetsHandler>().isNotEmpty()
        val resourceHandler =
            if (hasAssets)
                PredicateHandler(
                    Predicates.suffixes(".css", ".js", ".txt"),
                    ResourceHandler(ClassPathResourceManager (getSystemClassLoader (), "public")),
                    sessionHandler
                )
            else
                sessionHandler

Add Rocker template engine

Implement Rocker backend (as com.hexagonkt.templates.pebble.PebbleEngine).

Revamp logo

Improve Servlet backend performance

• Add a filter/servlet by each filter / route with a common prefix
• Process routes with same prefix inside a servlet
• Allow to enable disable features (automatic content-type, etc)
• Pass parameters to backend (buffer sizes and that kind of stuff) using key/value pairs

Modularize source

Modules:

• core: only dependencies will be: slf4j, cronutils and jackson. Includes all functionality, but without engines
• test: test utilities and backends
• events_rabbitmq
• store_mongodb
• serialization_messagepack (to be developed)
• settings_events (to be developed)
• template_pebble
• template_kotlinxhtml
• server_servlet
• server_jetty
• server_undertow (to be developed)
• client_okhttp
• tools
• examples
• desktop
• front_end
• mobile

JMH Tests

Setup Twitter account

Add Rocker template engine to Benchmark

Mongo and rabbitmq in core?

More of a question, I was a little confused on why mongo and rabbitmq things would be in a core rest framework? Is that assuming too much? Seems like perhaps those should be abstracted behind something so that I dont have to pull in those dependencies since many people may not use either of those?

Add mini static site generator (JBake like)

Move common `server` and `client` classes to `com.hexagonkt.http` in `core`

Split in two modules (client and server)

• Client for utilities and client http
• Server for everything else

Write post about Hexagon

Implement the microservice chassis pattern

When done... this is what should be added to the readme:

It also aims to implement the [Microservice Chassis Pattern] for a given platform
(being [Kubernetes] the reference platform). For this matter a range of functionalities will be
developed:

• Configuration management
• Service registering
• Health check
• Operation metrics
• Logging management
• Tracing support

Review RabbitMQ module

Check if connection checks are still needed (with last driver version)

Continuous Deployment

Deploy to Bintray (with Travis) when a tag is created and pushed.

Handle Github pages deployment here too (and get rid of docs directory)

Add test server backend

Add "Test" server implementation for tests without real networking.

This server will be an implementation of ServerEngine with an extra method: send(request: Request): Response that executes the callback and return the result without network involvement.

While developing this server some unspecified cases (route handlers order, etc.) can arise. In that case, please leave a comment to add a test to the Server/Router test suite.

Update project documentation

TOC from:

• http://sparkjava.com/documentation
• https://javalin.io/documentation
• https://www.http4k.org
• http://jooby.org/doc

Update Awesome Kotlin site links

Review HTTP client API

And also rename module to port_http_client.

Remove templates `global.yaml` in favor of settings

Image processing (for site generator)

• https://github.com/rkalla/imgscalr
• http://www.htmlgoodies.com/beyond/java/create-high-quality-thumbnails-using-the-imgscalr-library.html
• https://github.com/jfree/jfreesvg

Implement Authentication and Authorization

Auth https://shiro.apache.org/java-authentication-guide.html
Subject: uid (can be a system, not a person)
Credential: pass, public Key
Principal: personal data name, nick, birthday
Role:
Permission: action:type:id
User: physical human user

A component will have its credentials (as a user) to login in services
it will have a subject (its project name)

Check:

• https://www.pac4j.org
• https://developer.mozilla.org/en-US/docs/Web/HTTP/Authentication
• https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/WWW-Authenticate
• https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Authorization
• https://datatracker.ietf.org/doc/html/rfc7617
• https://datatracker.ietf.org/doc/html/rfc7616
• https://datatracker.ietf.org/doc/html/rfc6750
• https://shiro.apache.org/authentication.html
• https://docs.oracle.com/javase/8/docs/api/index.html?java/security/Identity.html
• https://vertx.io/docs/vertx-auth-common/java/#_basic_concepts
• https://vertx.io/docs/apidocs/io/vertx/ext/auth/User.html#principal--

Support AWS Signature v4: https://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-auth-using-authorization-header.html (already implemented in Sabina in Java)

New project Web site design

Use Google's Material Desing Lite. The scope is only the design, Web site sources are in the hexagon_site module. A generated site to change the style can be found in hexagon_site/new_site in the feature/hexagon-38_documentation_web branch.

Check the following links for themes and structure:

• https://getmdl.io/index.html
• http://beautifulopen.com
• http://denalijs.org
• http://www.sinatrarb.com

For the generation:

• Embed kts script tests inside md files.
• Gather modules documentation from themselves.

Add samples and extra documentation to API docs using Dokka.

Integrate SonarQube in PRs

• https://github.com/integrations/sonarqube
• https://docs.sonarqube.org/display/PLUG/GitHub+Plugin
• https://www.sonarqube.org/

Review *Serialization* API

Create HTTP call record callback

Create callback to store requests/responses (calls), this callback can be used on the HTTP client and the server. The calls list should be available from the callback instance.

Callbacks already developed in the http/http_server module (on the com/hexagonkt/http/server/callbacks package) can be used as reference for development and testing of such components.

The callback should be added to the http/rest_tools module on the com.hexagonkt.http.callbacks package.

For information on how to build the project and pass the tests please refer to the contributing guide.

If you have any question or suggestion, please feel free to use this issue's comments to discuss them 😉

Add SSL support

• Add keystore helper methods (from Sabina/bali)
• Support mutual TLS

Check:

• https://www.naschenweng.info/2018/02/01/java-mutual-ssl-authentication-2-way-ssl-authentication
• https://blog.behrang.org/2019/01/30/ssl-mutual-authentication-java.html
• https://github.com/Hakky54/mutual-tls
• https://coolaj86.com/articles/create-your-own-certificate-authority-for-testing
• https://stackoverflow.com/questions/20056304/in-the-jetty-server-how-can-i-obtain-the-client-certificate-used-when-client-aut

Create testing certs and CAs:

• https://docs.oracle.com/javase/8/docs/technotes/tools/windows/keytool.html
• https://stackoverflow.com/questions/30634658/how-to-create-a-certificate-chain-using-keytool
• https://docs.oracle.com/cd/E19509-01/820-3503/ggezy/index.html
• https://stackoverflow.com/questions/8744607/how-to-add-subject-alernative-name-to-ssl-certs
• https://serverfault.com/questions/605843/unable-to-generate-certificate-with-subject-alternate-name-using-java-1-7-keytool

JETTY settings:

• https://github.com/fstab/http2-examples/blob/master/jetty-http2-server-example/src/main/java/de/consol/labs/h2c/examples/server/Http2Server.java
• https://stackoverflow.com/questions/20056304/in-the-jetty-server-how-can-i-obtain-the-client-certificate-used-when-client-auth
• https://stackoverflow.com/questions/48790981/load-java-trust-store-at-runtime-after-jvm-have-been-launched

Configure project's modules in Bintray

Github site gets broken after releases

Check if a CNAME file is needed in the site branch

Add Undertow engine to TechEmpower benchmark

Add metrics support

http://metrics.dropwizard.io/3.2.2/

Move Repository map/unmap of classes to MongoDB Java Driver codec

Review *Settings* API

Implement router mounting

Add compression support

Implement compression support in port_http_server and port_http_client.

The goal would be to add a configuration parameter in the (Server|Client)Settings classes and force the compression headers to be sent accordingly.

The proper encoding and sending/receiving bodies must be checked by tests in the Ports' tests suites (the test classes used to validate adapters modules).

As a reference, you can check the fabulous MDN documentation regarding the subject:

• https://developer.mozilla.org/en-US/docs/Web/HTTP/Compression
• https://developer.mozilla.org/es/docs/Web/HTTP/Headers/Content-Encoding

Add framework examples

Implement:

• Spark examples
• Javalin examples

Add HTTP/2 support

Fix circular dependencies in IntelliJ

If the project is set up using single modules for components (instead the current strategy: source folders are modules) it fails because of circular dependencies mainly because of hexagon_test

Promote the project

Contact libraries used by Hexagon for them to add a 'backlink' ;)

• http://microservices.io/patterns/microservice-chassis.html
• RabbitMQ
• MongoDB
• Pebble
• Jetty
• Undertow
• JBake
• Lazybones
• Rocker
• Jackson
• SLF4J

Apply to GSoC: https://developers.google.com/open-source/gsoc/resources

Advertise in: http://kotlinlang.org/community (Slack, Blog...)

Check:

• https://opensource.com/business/13/2/self-promoting-open-source-projects
• https://www.quora.com/How-do-you-promote-an-open-source-project
• https://github.com/rdp/open-source-how-to-popularize-your-project
• Atomist
• Travis
• LinkedIn Kotlin groups
• Kotlin Slack
• LinkedIn
• Twitter
• Meetup KotlinMad
• Colleagues WhatsApp
• Tuenti
• Find relevant Developers interested in the subject
• Contact companies doing developments in that field
• Hacker News
• Reddit
• Meneame
• Media, Genbeta DEV

Add .path file for systemd services

See: https://www.freedesktop.org/software/systemd/man/systemd.path.html

Add MIME Type support

Use Java Activation Framework. This could be implemented by moving and refactoring Undertow implementation.

Move current Undertow implementation (using JAF) in UndertowResponse.getMimeType() to Core to be used by other Server Engines if they do not provide one.

Fail on duplicate routes

Forbid duplicate routes in server router

Rename package from `co.there4.hexagon` to `com.hexagonkt`

Add `patch` operation to repositories

Operation to update only certain fields without replacing the whole document

WebSockets support

When completed, create an example project like this one: http://sparkjava.com/tutorials/websocket-chat to show the feature.

Check Javalin implementation: https://javalin.io/documentation#websockets

This task is composed of two big areas:

1. Define the DSL to handle Websockets

The DSL will implement methods to add routes of WS type inside the router. I.e.:

Router {
    webSocket("/path") {
        onConnect {
            send("Message back")
        }
        onError {
            send("Message back")
        }
        onMessage {
            send("Message back")
        }
        onClose {
            send("Message back")
        }
    }
}

All callbacks will have a context to send/receive data to the client. This context will hold
methods to get/set attributes, headers, etc.

2. Implement the routes on adapters

The above step will add a list of routes to the router. On the adapters implementations, these
routes will be converted into the adapter's library format in the fun startup(server: Server)
method.

You can check the implementation of this method on the
http_server_jetty/src/main/kotlin/JettyServletAdapter.kt file, but the actual logic is also on the
http_server_servlet/src/main/kotlin/ServletFilter.kt file.

Update Github documentation