setup ffsaf server

src/main/docker/Dockerfile.jvm

@@ -0,0 +1,97 @@
+####
+# This Dockerfile is used in order to build a container that runs the Quarkus application in JVM mode
+#
+# Before building the container image run:
+#
+# ./mvnw package
+#
+# Then, build the image with:
+#
+# docker build -f src/main/docker/Dockerfile.jvm -t quarkus/ffsaf-site-jvm .
+#
+# Then run the container using:
+#
+# docker run -i --rm -p 8080:8080 quarkus/ffsaf-site-jvm
+#
+# If you want to include the debug port into your docker image
+# you will have to expose the debug port (default 5005 being the default) like this :  EXPOSE 8080 5005.
+# Additionally you will have to set -e JAVA_DEBUG=true and -e JAVA_DEBUG_PORT=*:5005
+# when running the container
+#
+# Then run the container using :
+#
+# docker run -i --rm -p 8080:8080 quarkus/ffsaf-site-jvm
+#
+# This image uses the `run-java.sh` script to run the application.
+# This scripts computes the command line to execute your Java application, and
+# includes memory/GC tuning.
+# You can configure the behavior using the following environment properties:
+# - JAVA_OPTS: JVM options passed to the `java` command (example: "-verbose:class")
+# - JAVA_OPTS_APPEND: User specified Java options to be appended to generated options
+#   in JAVA_OPTS (example: "-Dsome.property=foo")
+# - JAVA_MAX_MEM_RATIO: Is used when no `-Xmx` option is given in JAVA_OPTS. This is
+#   used to calculate a default maximal heap memory based on a containers restriction.
+#   If used in a container without any memory constraints for the container then this
+#   option has no effect. If there is a memory constraint then `-Xmx` is set to a ratio
+#   of the container available memory as set here. The default is `50` which means 50%
+#   of the available memory is used as an upper boundary. You can skip this mechanism by
+#   setting this value to `0` in which case no `-Xmx` option is added.
+# - JAVA_INITIAL_MEM_RATIO: Is used when no `-Xms` option is given in JAVA_OPTS. This
+#   is used to calculate a default initial heap memory based on the maximum heap memory.
+#   If used in a container without any memory constraints for the container then this
+#   option has no effect. If there is a memory constraint then `-Xms` is set to a ratio
+#   of the `-Xmx` memory as set here. The default is `25` which means 25% of the `-Xmx`
+#   is used as the initial heap size. You can skip this mechanism by setting this value
+#   to `0` in which case no `-Xms` option is added (example: "25")
+# - JAVA_MAX_INITIAL_MEM: Is used when no `-Xms` option is given in JAVA_OPTS.
+#   This is used to calculate the maximum value of the initial heap memory. If used in
+#   a container without any memory constraints for the container then this option has
+#   no effect. If there is a memory constraint then `-Xms` is limited to the value set
+#   here. The default is 4096MB which means the calculated value of `-Xms` never will
+#   be greater than 4096MB. The value of this variable is expressed in MB (example: "4096")
+# - JAVA_DIAGNOSTICS: Set this to get some diagnostics information to standard output
+#   when things are happening. This option, if set to true, will set
+#  `-XX:+UnlockDiagnosticVMOptions`. Disabled by default (example: "true").
+# - JAVA_DEBUG: If set remote debugging will be switched on. Disabled by default (example:
+#    true").
+# - JAVA_DEBUG_PORT: Port used for remote debugging. Defaults to 5005 (example: "8787").
+# - CONTAINER_CORE_LIMIT: A calculated core limit as described in
+#   https://www.kernel.org/doc/Documentation/scheduler/sched-bwc.txt. (example: "2")
+# - CONTAINER_MAX_MEMORY: Memory limit given to the container (example: "1024").
+# - GC_MIN_HEAP_FREE_RATIO: Minimum percentage of heap free after GC to avoid expansion.
+#   (example: "20")
+# - GC_MAX_HEAP_FREE_RATIO: Maximum percentage of heap free after GC to avoid shrinking.
+#   (example: "40")
+# - GC_TIME_RATIO: Specifies the ratio of the time spent outside the garbage collection.
+#   (example: "4")
+# - GC_ADAPTIVE_SIZE_POLICY_WEIGHT: The weighting given to the current GC time versus
+#   previous GC times. (example: "90")
+# - GC_METASPACE_SIZE: The initial metaspace size. (example: "20")
+# - GC_MAX_METASPACE_SIZE: The maximum metaspace size. (example: "100")
+# - GC_CONTAINER_OPTIONS: Specify Java GC to use. The value of this variable should
+#   contain the necessary JRE command-line options to specify the required GC, which
+#   will override the default of `-XX:+UseParallelGC` (example: -XX:+UseG1GC).
+# - HTTPS_PROXY: The location of the https proxy. (example: "myuser@127.0.0.1:8080")
+# - HTTP_PROXY: The location of the http proxy. (example: "myuser@127.0.0.1:8080")
+# - NO_PROXY: A comma separated lists of hosts, IP addresses or domains that can be
+#   accessed directly. (example: "foo.example.com,bar.example.com")
+#
+###
+FROM registry.access.redhat.com/ubi8/openjdk-17:1.18
+
+ENV LANGUAGE='en_US:en'
+
+
+# We make four distinct layers so if there are application changes the library layers can be re-used
+COPY --chown=185 target/quarkus-app/lib/ /deployments/lib/
+COPY --chown=185 target/quarkus-app/*.jar /deployments/
+COPY --chown=185 target/quarkus-app/app/ /deployments/app/
+COPY --chown=185 target/quarkus-app/quarkus/ /deployments/quarkus/
+
+EXPOSE 8080
+USER 185
+ENV JAVA_OPTS_APPEND="-Dquarkus.http.host=0.0.0.0 -Djava.util.logging.manager=org.jboss.logmanager.LogManager"
+ENV JAVA_APP_JAR="/deployments/quarkus-run.jar"
+
+ENTRYPOINT [ "/opt/jboss/container/java/run/run-java.sh" ]
+

src/main/docker/Dockerfile.legacy-jar

@@ -0,0 +1,93 @@
+####
+# This Dockerfile is used in order to build a container that runs the Quarkus application in JVM mode
+#
+# Before building the container image run:
+#
+# ./mvnw package -Dquarkus.package.type=legacy-jar
+#
+# Then, build the image with:
+#
+# docker build -f src/main/docker/Dockerfile.legacy-jar -t quarkus/ffsaf-site-legacy-jar .
+#
+# Then run the container using:
+#
+# docker run -i --rm -p 8080:8080 quarkus/ffsaf-site-legacy-jar
+#
+# If you want to include the debug port into your docker image
+# you will have to expose the debug port (default 5005 being the default) like this :  EXPOSE 8080 5005.
+# Additionally you will have to set -e JAVA_DEBUG=true and -e JAVA_DEBUG_PORT=*:5005
+# when running the container
+#
+# Then run the container using :
+#
+# docker run -i --rm -p 8080:8080 quarkus/ffsaf-site-legacy-jar
+#
+# This image uses the `run-java.sh` script to run the application.
+# This scripts computes the command line to execute your Java application, and
+# includes memory/GC tuning.
+# You can configure the behavior using the following environment properties:
+# - JAVA_OPTS: JVM options passed to the `java` command (example: "-verbose:class")
+# - JAVA_OPTS_APPEND: User specified Java options to be appended to generated options
+#   in JAVA_OPTS (example: "-Dsome.property=foo")
+# - JAVA_MAX_MEM_RATIO: Is used when no `-Xmx` option is given in JAVA_OPTS. This is
+#   used to calculate a default maximal heap memory based on a containers restriction.
+#   If used in a container without any memory constraints for the container then this
+#   option has no effect. If there is a memory constraint then `-Xmx` is set to a ratio
+#   of the container available memory as set here. The default is `50` which means 50%
+#   of the available memory is used as an upper boundary. You can skip this mechanism by
+#   setting this value to `0` in which case no `-Xmx` option is added.
+# - JAVA_INITIAL_MEM_RATIO: Is used when no `-Xms` option is given in JAVA_OPTS. This
+#   is used to calculate a default initial heap memory based on the maximum heap memory.
+#   If used in a container without any memory constraints for the container then this
+#   option has no effect. If there is a memory constraint then `-Xms` is set to a ratio
+#   of the `-Xmx` memory as set here. The default is `25` which means 25% of the `-Xmx`
+#   is used as the initial heap size. You can skip this mechanism by setting this value
+#   to `0` in which case no `-Xms` option is added (example: "25")
+# - JAVA_MAX_INITIAL_MEM: Is used when no `-Xms` option is given in JAVA_OPTS.
+#   This is used to calculate the maximum value of the initial heap memory. If used in
+#   a container without any memory constraints for the container then this option has
+#   no effect. If there is a memory constraint then `-Xms` is limited to the value set
+#   here. The default is 4096MB which means the calculated value of `-Xms` never will
+#   be greater than 4096MB. The value of this variable is expressed in MB (example: "4096")
+# - JAVA_DIAGNOSTICS: Set this to get some diagnostics information to standard output
+#   when things are happening. This option, if set to true, will set
+#  `-XX:+UnlockDiagnosticVMOptions`. Disabled by default (example: "true").
+# - JAVA_DEBUG: If set remote debugging will be switched on. Disabled by default (example:
+#    true").
+# - JAVA_DEBUG_PORT: Port used for remote debugging. Defaults to 5005 (example: "8787").
+# - CONTAINER_CORE_LIMIT: A calculated core limit as described in
+#   https://www.kernel.org/doc/Documentation/scheduler/sched-bwc.txt. (example: "2")
+# - CONTAINER_MAX_MEMORY: Memory limit given to the container (example: "1024").
+# - GC_MIN_HEAP_FREE_RATIO: Minimum percentage of heap free after GC to avoid expansion.
+#   (example: "20")
+# - GC_MAX_HEAP_FREE_RATIO: Maximum percentage of heap free after GC to avoid shrinking.
+#   (example: "40")
+# - GC_TIME_RATIO: Specifies the ratio of the time spent outside the garbage collection.
+#   (example: "4")
+# - GC_ADAPTIVE_SIZE_POLICY_WEIGHT: The weighting given to the current GC time versus
+#   previous GC times. (example: "90")
+# - GC_METASPACE_SIZE: The initial metaspace size. (example: "20")
+# - GC_MAX_METASPACE_SIZE: The maximum metaspace size. (example: "100")
+# - GC_CONTAINER_OPTIONS: Specify Java GC to use. The value of this variable should
+#   contain the necessary JRE command-line options to specify the required GC, which
+#   will override the default of `-XX:+UseParallelGC` (example: -XX:+UseG1GC).
+# - HTTPS_PROXY: The location of the https proxy. (example: "myuser@127.0.0.1:8080")
+# - HTTP_PROXY: The location of the http proxy. (example: "myuser@127.0.0.1:8080")
+# - NO_PROXY: A comma separated lists of hosts, IP addresses or domains that can be
+#   accessed directly. (example: "foo.example.com,bar.example.com")
+#
+###
+FROM registry.access.redhat.com/ubi8/openjdk-17:1.18
+
+ENV LANGUAGE='en_US:en'
+
+
+COPY target/lib/* /deployments/lib/
+COPY target/*-runner.jar /deployments/quarkus-run.jar
+
+EXPOSE 8080
+USER 185
+ENV JAVA_OPTS_APPEND="-Dquarkus.http.host=0.0.0.0 -Djava.util.logging.manager=org.jboss.logmanager.LogManager"
+ENV JAVA_APP_JAR="/deployments/quarkus-run.jar"
+
+ENTRYPOINT [ "/opt/jboss/container/java/run/run-java.sh" ]

src/main/docker/Dockerfile.native

@@ -0,0 +1,27 @@
+####
+# This Dockerfile is used in order to build a container that runs the Quarkus application in native (no JVM) mode.
+#
+# Before building the container image run:
+#
+# ./mvnw package -Dnative
+#
+# Then, build the image with:
+#
+# docker build -f src/main/docker/Dockerfile.native -t quarkus/ffsaf-site .
+#
+# Then run the container using:
+#
+# docker run -i --rm -p 8080:8080 quarkus/ffsaf-site
+#
+###
+FROM registry.access.redhat.com/ubi8/ubi-minimal:8.9
+WORKDIR /work/
+RUN chown 1001 /work \
+    && chmod "g+rwX" /work \
+    && chown 1001:root /work
+COPY --chown=1001:root target/*-runner /work/application
+
+EXPOSE 8080
+USER 1001
+
+ENTRYPOINT ["./application", "-Dquarkus.http.host=0.0.0.0"]

src/main/docker/Dockerfile.native-micro

@@ -0,0 +1,30 @@
+####
+# This Dockerfile is used in order to build a container that runs the Quarkus application in native (no JVM) mode.
+# It uses a micro base image, tuned for Quarkus native executables.
+# It reduces the size of the resulting container image.
+# Check https://quarkus.io/guides/quarkus-runtime-base-image for further information about this image.
+#
+# Before building the container image run:
+#
+# ./mvnw package -Dnative
+#
+# Then, build the image with:
+#
+# docker build -f src/main/docker/Dockerfile.native-micro -t quarkus/ffsaf-site .
+#
+# Then run the container using:
+#
+# docker run -i --rm -p 8080:8080 quarkus/ffsaf-site
+#
+###
+FROM quay.io/quarkus/quarkus-micro-image:2.0
+WORKDIR /work/
+RUN chown 1001 /work \
+    && chmod "g+rwX" /work \
+    && chown 1001:root /work
+COPY --chown=1001:root target/*-runner /work/application
+
+EXPOSE 8080
+USER 1001
+
+ENTRYPOINT ["./application", "-Dquarkus.http.host=0.0.0.0"]

src/main/java/fr/titionfire/ExampleResource.java

@@ -0,0 +1,16 @@
+package fr.titionfire;
+
+import jakarta.ws.rs.GET;
+import jakarta.ws.rs.Path;
+import jakarta.ws.rs.Produces;
+import jakarta.ws.rs.core.MediaType;
+
+@Path("/hello")
+public class ExampleResource {
+
+    @GET
+    @Produces(MediaType.TEXT_PLAIN)
+    public String hello() {
+        return "Hello from RESTEasy Reactive";
+    }
+}

src/main/java/fr/titionfire/SomePage.java

@@ -0,0 +1,29 @@
+package fr.titionfire;
+
+import io.quarkus.qute.Template;
+import io.quarkus.qute.TemplateInstance;
+
+import jakarta.ws.rs.GET;
+import jakarta.ws.rs.Path;
+import jakarta.ws.rs.Produces;
+import jakarta.ws.rs.QueryParam;
+import jakarta.ws.rs.core.MediaType;
+
+import static java.util.Objects.requireNonNull;
+
+@Path("/some-page")
+public class SomePage {
+
+    private final Template page;
+
+    public SomePage(Template page) {
+        this.page = requireNonNull(page, "page is required");
+    }
+
+    @GET
+    @Produces(MediaType.TEXT_HTML)
+    public TemplateInstance get(@QueryParam("name") String name) {
+        return page.data("name", name);
+    }
+
+}

src/main/java/fr/titionfire/ffsaf/data/SafcaNamingStrategy.java

@@ -0,0 +1,37 @@
+package fr.titionfire.ffsaf.data;
+
+import org.hibernate.boot.model.naming.Identifier;
+import org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl;
+import org.hibernate.engine.jdbc.env.spi.JdbcEnvironment;
+
+public class SafcaNamingStrategy extends PhysicalNamingStrategyStandardImpl {
+
+    private final static String PREFIX = "ffsaf__";
+
+    @Override
+    public Identifier toPhysicalTableName(Identifier name, JdbcEnvironment context) {
+        return new Identifier(convertToSnakeCasePrefixed(name.getText()), name.isQuoted());
+    }
+
+    @Override
+    public Identifier toPhysicalColumnName(Identifier name, JdbcEnvironment context) {
+        return new Identifier(convertToSnakeCase(name.getText()), name.isQuoted());
+    }
+
+    private String convertToSnakeCase(final String identifier) {
+        final String regex = "([a-z])([A-Z])";
+        final String replacement = "$1_$2";
+        return identifier
+                .replaceAll(regex, replacement)
+                .toLowerCase();
+    }
+
+    private String convertToSnakeCasePrefixed(final String identifier) {
+        final String regex = "([a-z])([A-Z])";
+        final String replacement = "$1_$2";
+        final String newName = identifier
+                .replaceAll(regex, replacement)
+                .toLowerCase();
+        return PREFIX + newName;
+    }
+}

src/main/java/fr/titionfire/ffsaf/data/model/ClubModel.java

@@ -0,0 +1,28 @@
+package fr.titionfire.ffsaf.data.model;
+
+import io.quarkus.runtime.annotations.RegisterForReflection;
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+@RegisterForReflection
+
+@Entity
+@Table(name = "club")
+public class ClubModel {
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    Long id;
+
+    String name;
+
+    String country;
+
+    String shieldURL;
+}

src/main/java/fr/titionfire/ffsaf/data/model/CombModel.java

@@ -0,0 +1,40 @@
+package fr.titionfire.ffsaf.data.model;
+
+import fr.titionfire.ffsaf.utils.Categorie;
+import fr.titionfire.ffsaf.utils.Genre;
+import io.quarkus.runtime.annotations.RegisterForReflection;
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+@RegisterForReflection
+
+@Entity
+@Table(name = "comb")
+public class CombModel {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    Long id;
+
+    String lname = "";
+    String fname = "";
+
+    Categorie categorie;
+
+    @ManyToOne(fetch = FetchType.EAGER)
+    @JoinColumn(name = "club", referencedColumnName = "id")
+    ClubModel club;
+
+    Genre genre;
+
+    int licence = 0;
+
+    String country = "fr";
+}

src/main/java/fr/titionfire/ffsaf/domain/entity/ClubEntity.java

@@ -0,0 +1,24 @@
+package fr.titionfire.ffsaf.domain.entity;
+
+import fr.titionfire.ffsaf.data.model.ClubModel;
+import io.quarkus.runtime.annotations.RegisterForReflection;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+
+@Data
+@AllArgsConstructor
+@RegisterForReflection
+public class ClubEntity {
+    private long id;
+    private String name;
+    private String country;
+    private String shieldURL;
+
+    public static ClubEntity fromModel (ClubModel model) {
+        return new ClubEntity(model.getId(), model.getName(), model.getCountry(), model.getShieldURL());
+    }
+
+    public ClubModel toModel () {
+        return new ClubModel(this.id, this.name, this.country, this.shieldURL);
+    }
+}

src/main/java/fr/titionfire/ffsaf/domain/entity/CombEntity.java

@@ -0,0 +1,38 @@
+package fr.titionfire.ffsaf.domain.entity;
+
+import fr.titionfire.ffsaf.data.model.CombModel;
+import fr.titionfire.ffsaf.utils.Categorie;
+import fr.titionfire.ffsaf.utils.Genre;
+import io.quarkus.runtime.annotations.RegisterForReflection;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+
+@Data
+@AllArgsConstructor
+@RegisterForReflection
+public class CombEntity {
+    private long id;
+    private String lname = "";
+    private String fname = "";
+    private Categorie categorie;
+    private ClubEntity club;
+    private Genre genre;
+    private int licence;
+    private String country;
+
+    public static CombEntity fromModel(CombModel model) {
+        if (model == null)
+            return null;
+
+        return new CombEntity(model.getId(), model.getLname(), model.getFname(), model.getCategorie(),
+                (model.getClub() == null) ? null : ClubEntity.fromModel(model.getClub()),
+                model.getGenre(), model.getLicence(), model.getCountry());
+    }
+
+    public static String getFullName(CombModel model) {
+        return model.getFname() + " " + model.getLname();
+    }
+    public String getFullName() {
+        return this.fname + " " + this.lname;
+    }
+}

src/main/java/fr/titionfire/ffsaf/net2/Client_Thread.java

@@ -0,0 +1,229 @@
+package fr.titionfire.ffsaf.net2;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import fr.titionfire.ffsaf.utils.JsonConsumer;
+import fr.titionfire.ffsaf.utils.Pair;
+import jakarta.inject.Inject;
+import jakarta.transaction.Transactional;
+import org.jboss.logging.Logger;
+import org.quartz.*;
+
+import javax.crypto.BadPaddingException;
+import javax.crypto.Cipher;
+import javax.crypto.IllegalBlockSizeException;
+import javax.crypto.NoSuchPaddingException;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.net.Socket;
+import java.nio.charset.StandardCharsets;
+import java.security.InvalidKeyException;
+import java.security.NoSuchAlgorithmException;
+import java.security.PublicKey;
+import java.util.Base64;
+import java.util.HashMap;
+import java.util.UUID;
+
+public class Client_Thread extends Thread {
+    private static final Logger LOGGER = Logger.getLogger(Client_Thread.class);
+
+    public static final ObjectMapper MAPPER = new ObjectMapper();
+
+    private final Socket s;
+    private final OutputStreamWriter dos;
+    private final BufferedReader br;
+
+    public final ServerCustom serv;
+
+    private boolean isAuth;
+
+    private final HashMap<UUID, JsonConsumer<Object>> waitResult = new HashMap<>();
+
+    public Client_Thread(ServerCustom serv, Socket s, PublicKey publicKey) throws IOException {
+        this.serv = serv;
+        this.s = s;
+        this.isAuth = false;
+
+        dos = new OutputStreamWriter(s.getOutputStream(), StandardCharsets.UTF_8); // to send data to the client
+        br = new BufferedReader(new InputStreamReader(s.getInputStream(), StandardCharsets.UTF_8)); // to read data
+        // coming from the client
+        LOGGER.infof("Connection established to %s", s.getInetAddress().getHostAddress());
+
+        String auth_code = UUID.randomUUID() + "-" + UUID.randomUUID();
+        JsonConsumer<Object> consumer = new JsonConsumer<>(Object.class, t -> {
+            if (t.equals(auth_code)) {
+                isAuth = true;
+                LOGGER.infof("Client %s is auth", s.getInetAddress().getHostAddress());
+            } else {
+                LOGGER.warnf("Client %s is not auth", s.getInetAddress().getHostAddress());
+                stopSoket();
+            }
+        });
+
+        try {
+            Cipher cipher = Cipher.getInstance("RSA");
+            cipher.init(Cipher.ENCRYPT_MODE, publicKey);
+
+            byte[] bytes = cipher.doFinal(auth_code.getBytes(StandardCharsets.UTF_8));
+            sendReq(new String(Base64.getEncoder().encode(bytes)), "auth", consumer);
+        } catch (NoSuchAlgorithmException | NoSuchPaddingException | IllegalBlockSizeException | BadPaddingException | InvalidKeyException e) {
+            LOGGER.error(e.getMessage(), e);
+        }
+    }
+
+    @Override
+    public void run() {
+        while (!s.isClosed()) {
+            String jsonmessage;
+            // read from client
+            try {
+                if ((jsonmessage = br.readLine()) != null) {
+                    jsonmessage = jsonmessage.replace('¤', '\n');
+                    process_message(jsonmessage);
+                } else {
+                    s.close();
+                }
+            } catch (IOException e) {
+                if (e.getMessage().equals("Stream closed") || e.getMessage().equals("Connection reset")) {
+                    break;
+                }
+                LOGGER.error(e.getMessage(), e);
+            }
+        }
+
+        serv.onCloseClient(this);
+
+        // close connection
+        try {
+            dos.close();
+            br.close();
+            LOGGER.infof("Connection closed for %s", s.getInetAddress().getHostAddress());
+        } catch (IOException e) {
+            LOGGER.error(e.getMessage(), e);
+        }
+    }
+
+    private void process_message(String jsonmessage) {
+        try {
+            JsonNode node = MAPPER.readTree(jsonmessage);
+            if (node.has("uuid") && node.has("code") && node.has("type")) {
+                Message<JsonNode> message = new Message<>(UUID.fromString(node.get("uuid").asText()),
+                        node.get("code").asText(), MessageType.valueOf(node.get("type").asText()),
+                        (node.has("data")) ? node.get("data") : null);
+
+                LOGGER.debugf("Message Received of %s: %s", s.getInetAddress().getHostAddress(), message);
+
+                if (message.type() == MessageType.REQUEST || message.type() == MessageType.NOTIFY) {
+                    if (serv.iMap.containsKey(message.code())) {
+                        if (isAuth) {
+                            UUID uuid = UUID.randomUUID();
+                            serv.jobData.put(uuid, new Pair<>(this, message));
+
+                            JobKey jobKey = JobKey.jobKey(uuid.toString(), "client-request");
+                            JobDetail job = JobBuilder.newJob(CallSyncJob.class)
+                                    .usingJobData("uuid", uuid.toString())
+                                    .storeDurably(true)
+                                    .withIdentity(jobKey)
+                                    .build();
+                            serv.quartz.addJob(job, true);
+                            serv.quartz.triggerJob(jobKey);
+                        }
+                    } else {
+                        this.sendErr("No receiver found", message.code(), message.uuid());
+                        LOGGER.warnf("No receiver found for %s", message.code());
+                    }
+                } else {
+                    if (waitResult.containsKey(message.uuid())) {
+                        if (waitResult.get(message.uuid()) != null)
+                            waitResult.get(message.uuid()).castAndAccept(message.data());
+
+                        waitResult.remove(message.uuid());
+                    } else {
+                        LOGGER.warnf("No waiting message found for %s", message.uuid());
+                    }
+                }
+            } else {
+                LOGGER.debugf("Message format incorrect: %s", jsonmessage);
+            }
+        } catch (Exception e) {
+            LOGGER.debug(jsonmessage);
+            LOGGER.error(e.getMessage(), e);
+        }
+    }
+
+    public void sendNotify(Object object, String type) {
+        sendMessage(new Message<>(UUID.randomUUID(), type, MessageType.NOTIFY, object));
+    }
+
+    public void sendReq(Object object, String type) {
+        sendReq(object, type, null);
+    }
+
+    public void sendReq(Object object, String code, JsonConsumer<Object> consumer) {
+        UUID uuid;
+        do {
+            uuid = UUID.randomUUID();
+        } while (waitResult.containsKey(uuid));
+        waitResult.put(uuid, consumer);
+
+        sendMessage(new Message<>(uuid, code, MessageType.REQUEST, object));
+    }
+
+    public void sendRepTo(Object object, Message<?> in) {
+        sendMessage(new Message<>(in.uuid(), in.code(), MessageType.REPLY, object));
+    }
+
+    public void sendErr(String msg, String type, UUID uuid) {
+        sendMessage(new Message<>(uuid, type, MessageType.ERROR, msg));
+    }
+
+    public void sendErrTo(String msg, Message<?> in) {
+        sendMessage(new Message<>(in.uuid(), in.code(), MessageType.ERROR, msg));
+    }
+
+    public void sendMessage(Message<?> message) {
+        try {
+            synchronized (dos) {
+                dos.write(MAPPER.writeValueAsString(message).replace('¤', ' ').replace('\n', '¤') + '\n');
+                dos.flush();
+            }
+        } catch (IOException e) {
+            LOGGER.error(e.getMessage(), e);
+        }
+        LOGGER.tracef("Send message type: %s, code: %s, uuid: %s, to: %s", message.type(), message.code(),
+                message.uuid(), s.getInetAddress().getHostAddress());
+    }
+
+    public void stopSoket() {
+        try {
+            s.close();
+        } catch (IOException ignored) {
+        }
+    }
+
+    public static class CallSyncJob implements Job {
+        @Inject
+        ServerCustom socket;
+
+        @Transactional
+        public void execute(JobExecutionContext context) {
+            UUID uuid = UUID.fromString(context.getMergedJobDataMap().getString("uuid"));
+            Pair<Client_Thread, Message<JsonNode>> pair = socket.jobData.get(uuid);
+
+            if (pair != null) {
+                try {
+                    socket.iMap.get(pair.getValue().code()).castAndCall(pair.getKey(), pair.getValue());
+                } catch (JsonProcessingException e) {
+                    LOGGER.error(e.getMessage(), e);
+                }
+
+                socket.jobData.remove(uuid);
+            } else {
+                LOGGER.errorf("no get found %d", socket.jobData.size());
+            }
+        }
+    }
+}

src/main/java/fr/titionfire/ffsaf/net2/Message.java

@@ -0,0 +1,19 @@
+package fr.titionfire.ffsaf.net2;
+
+import io.quarkus.runtime.annotations.RegisterForReflection;
+
+import java.util.UUID;
+
+@RegisterForReflection
+public record Message<T> (UUID uuid, String code, MessageType type, T data){
+
+    @Override
+    public String toString() {
+        return "Message{" +
+                "uuid=" + uuid +
+                ", code='" + code + '\'' +
+                ", type=" + type +
+                ", data=" + data +
+                '}';
+    }
+}

src/main/java/fr/titionfire/ffsaf/net2/MessageType.java

@@ -0,0 +1,5 @@
+package fr.titionfire.ffsaf.net2;
+
+public enum MessageType {
+    REQUEST, REPLY, ERROR, NOTIFY
+}

src/main/java/fr/titionfire/ffsaf/net2/ServerCustom.java

@@ -0,0 +1,148 @@
+package fr.titionfire.ffsaf.net2;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import fr.titionfire.ffsaf.net2.packet.IAction;
+import fr.titionfire.ffsaf.net2.packet.RegisterAction;
+import fr.titionfire.ffsaf.utils.Pair;
+import io.quarkus.runtime.ShutdownEvent;
+import io.quarkus.runtime.StartupEvent;
+import jakarta.enterprise.event.Observes;
+import jakarta.inject.Singleton;
+import org.eclipse.microprofile.config.inject.ConfigProperty;
+import org.jboss.logging.Logger;
+import org.quartz.Scheduler;
+
+import javax.net.ssl.*;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.Socket;
+import java.security.*;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.stream.Stream;
+
+import jakarta.inject.Inject;
+
+@Singleton
+public class ServerCustom extends Thread {
+    private static final Logger LOGGER = Logger.getLogger("SocketServer");
+
+    protected ConcurrentHashMap<UUID, Pair<Client_Thread, Message<JsonNode>>> jobData = new ConcurrentHashMap<>();
+    protected HashMap<String, IAction> iMap = new HashMap<>();
+    public final ArrayList<Client_Thread> clients = new ArrayList<>();
+
+    private SSLServerSocket server;
+    private boolean run;
+
+    @ConfigProperty(name = "internal-port")
+    int port;
+
+    @ConfigProperty(name = "certificate_password")
+    String certificate_password;
+
+    @ConfigProperty(name = "certificate_file")
+    String certificate_file;
+
+    @Inject
+    protected Scheduler quartz;
+
+    private PublicKey publicKey;
+
+    private X509TrustManager tm(KeyStore keystore) throws NoSuchAlgorithmException, KeyStoreException {
+        TrustManagerFactory trustMgrFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
+        trustMgrFactory.init(keystore);
+        TrustManager[] trustManagers = trustMgrFactory.getTrustManagers();
+        for (TrustManager trustManager : trustManagers) {
+            if (trustManager instanceof X509TrustManager) {
+                return (X509TrustManager) trustManager;
+            }
+        }
+        return null;
+    }
+
+    private X509KeyManager km(KeyStore keystore) throws NoSuchAlgorithmException, KeyStoreException, UnrecoverableKeyException {
+        KeyManagerFactory keyMgrFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
+        keyMgrFactory.init(keystore, certificate_password.toCharArray());
+        KeyManager[] keyManagers = keyMgrFactory.getKeyManagers();
+        for (KeyManager keyManager : keyManagers) {
+            if (keyManager instanceof X509KeyManager) {
+                return (X509KeyManager) keyManager;
+            }
+        }
+        return null;
+    }
+
+    private SSLServerSocket getServerSocketWithCert(int port, InputStream pathToCert) throws Exception {
+        TrustManager[] tmm = new TrustManager[1];
+        KeyManager[] kmm = new KeyManager[1];
+
+        KeyStore ks = KeyStore.getInstance("JKS");
+        ks.load(pathToCert, certificate_password.toCharArray());
+        tmm[0] = tm(ks);
+        kmm[0] = km(ks);
+
+        SSLContext ctx = SSLContext.getInstance("TLSv1.2");
+        ctx.init(kmm, tmm, null);
+
+        publicKey = ks.getCertificate("ffsaf").getPublicKey();
+
+        SSLServerSocketFactory socketFactory = ctx.getServerSocketFactory();
+        return (SSLServerSocket) socketFactory.createServerSocket(port);
+    }
+
+    @Override
+    public void run() {
+        try {
+            this.run = true;
+            this.server = getServerSocketWithCert(this.port, new FileInputStream(new File(this.certificate_file)));
+            RegisterAction.register(iMap);
+            LOGGER.info("Starting socket server!!");
+            while (this.run) {
+                Socket socket = this.server.accept();
+                Client_Thread cThread = new Client_Thread(this, socket, publicKey);
+                synchronized (clients) {
+                    this.clients.add(cThread);
+                }
+                cThread.start();
+            }
+            LOGGER.info("Shutting down Socket server!!");
+        } catch (Exception e) {
+            LOGGER.info("Server start failed! (" + e.getMessage() + ")");
+            this.interrupt();
+        }
+    }
+
+    public void onCloseClient(Client_Thread cThread) {
+        synchronized (clients) {
+            clients.remove(cThread);
+        }
+    }
+
+    public void stop2() {
+        this.run = false;
+
+        try {
+            this.server.close();
+            clients.forEach(Client_Thread::stopSoket);
+        } catch (IOException ignored) {
+        }
+    }
+
+    void onStart(@Observes StartupEvent ev) {
+        LOGGER.info("The server is starting...");
+        this.start();
+    }
+
+    void onStop(@Observes ShutdownEvent ev) {
+        LOGGER.info("The server is stopping...");
+        this.stop2();
+    }
+
+    public Stream<Client_Thread> get_clients() {
+        return clients.stream();
+    }
+}

src/main/java/fr/titionfire/ffsaf/net2/packet/CIA.java

@@ -0,0 +1,25 @@
+package fr.titionfire.ffsaf.net2.packet;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonNode;
+import fr.titionfire.ffsaf.net2.Client_Thread;
+import fr.titionfire.ffsaf.net2.Message;
+
+import java.util.function.BiConsumer;
+
+import static fr.titionfire.ffsaf.net2.Client_Thread.MAPPER;
+
+public class CIA<T> implements IAction{
+    private final Class<T> clazz;
+    private final BiConsumer<Client_Thread, Message<T>> iAction;
+
+    public CIA(Class<T> clazz, BiConsumer<Client_Thread, Message<T>> iAction){
+        this.clazz = clazz;
+        this.iAction = iAction;
+    }
+
+    @Override
+    public void dataIn(Client_Thread client_Thread, Message<JsonNode> message) throws JsonProcessingException {
+        iAction.accept(client_Thread, new Message<>(message.uuid(), message.code(), message.type(), MAPPER.treeToValue(message.data(), clazz)));
+    }
+}

src/main/java/fr/titionfire/ffsaf/net2/packet/IAction.java

@@ -0,0 +1,14 @@
+package fr.titionfire.ffsaf.net2.packet;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonNode;
+import fr.titionfire.ffsaf.net2.Client_Thread;
+import fr.titionfire.ffsaf.net2.Message;
+
+public interface IAction {
+    void dataIn(Client_Thread client_Thread, Message<JsonNode> message) throws JsonProcessingException;
+
+    default void castAndCall (Client_Thread client_Thread, Message<JsonNode> message) throws JsonProcessingException {
+        this.dataIn(client_Thread, message);
+    }
+}

src/main/java/fr/titionfire/ffsaf/net2/packet/RegisterAction.java

@@ -0,0 +1,11 @@
+package fr.titionfire.ffsaf.net2.packet;
+
+import java.util.HashMap;
+
+public class RegisterAction {
+
+	public static void register(HashMap<String, IAction> iMap) {
+		iMap.clear();
+
+	}
+}

src/main/java/fr/titionfire/ffsaf/utils/Categorie.java

@@ -0,0 +1,33 @@
+package fr.titionfire.ffsaf.utils;
+
+import java.util.ResourceBundle;
+
+public enum Categorie {
+    SUPER_MINI,
+    MINI_POUSSIN,
+    POUSSIN,
+    BENJAMIN,
+    MINIME,
+    CADET,
+    JUNIOR,
+    SENIOR1,
+    SENIOR2,
+    VETERAN1,
+    VETERAN2;
+
+    public String getName(ResourceBundle BUNDLE) {
+        return switch (this){
+            case SUPER_MINI -> BUNDLE.getString("Cat.SUPER_MINI");
+            case MINI_POUSSIN -> BUNDLE.getString("Cat.MINI_POUSSIN");
+            case POUSSIN -> BUNDLE.getString("Cat.POUSSIN");
+            case BENJAMIN -> BUNDLE.getString("Cat.BENJAMIN");
+            case MINIME -> BUNDLE.getString("Cat.MINIME");
+            case CADET -> BUNDLE.getString("Cat.CADET");
+            case JUNIOR -> BUNDLE.getString("Cat.JUNIOR");
+            case SENIOR1 -> BUNDLE.getString("Cat.SENIOR1");
+            case SENIOR2 -> BUNDLE.getString("Cat.SENIOR2");
+            case VETERAN1 -> BUNDLE.getString("Cat.VETERAN1");
+            case VETERAN2 -> BUNDLE.getString("Cat.VETERAN2");
+        };
+    }
+}

src/main/java/fr/titionfire/ffsaf/utils/Genre.java

@@ -0,0 +1,5 @@
+package fr.titionfire.ffsaf.utils;
+
+public enum Genre {
+    H, F
+}

src/main/java/fr/titionfire/ffsaf/utils/JsonConsumer.java

@@ -0,0 +1,28 @@
+package fr.titionfire.ffsaf.utils;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.core.TreeNode;
+
+import java.util.function.Consumer;
+
+import static fr.titionfire.ffsaf.net2.Client_Thread.MAPPER;
+
+public class JsonConsumer<T> implements Consumer<T> {
+
+    private final Class<T> clazz;
+    private final Consumer<T> consumer;
+
+    public JsonConsumer(Class<T> clazz, Consumer<T> consumer){
+        this.clazz = clazz;
+        this.consumer = consumer;
+    }
+
+    public void castAndAccept (TreeNode message) throws JsonProcessingException {
+        this.accept(MAPPER.treeToValue(message, clazz));
+    }
+
+    @Override
+    public void accept(T t) {
+        consumer.accept(t);
+    }
+}

src/main/java/fr/titionfire/ffsaf/utils/Pair.java

@@ -0,0 +1,15 @@
+package fr.titionfire.ffsaf.utils;
+
+import io.quarkus.runtime.annotations.RegisterForReflection;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@RegisterForReflection
+public class Pair<K, V> {
+    private K key;
+    private V value;
+}

src/main/resources/application.properties

@@ -0,0 +1,22 @@
+# DEV
+%dev.quarkus.datasource.db-kind=mysql
+%dev.quarkus.datasource.reactive.url=mysql://${database.hostname}:${database.port}/${database.database}?charset=utf8mb4
+
+# DB
+quarkus.datasource.db-kind=postgresql
+quarkus.datasource.username=${database.user}
+quarkus.datasource.password=${database.pass}
+quarkus.datasource.reactive.url=postgresql://${database.hostname}:${database.port}/${database.database}?charset=utf8mb4
+
+quarkus.hibernate-orm.database.generation=update
+quarkus.hibernate-orm.physical-naming-strategy=fr.titionfire.ffsaf.data.SafcaNamingStrategy
+
+quarkus.http.cors=true
+quarkus.quartz.start-mode=forced
+
+database.prefix = test2_
+database.database=safca
+database.hostname=localhost
+database.port=3306
+database.user=root
+database.pass=

src/main/resources/templates/page.qute.html

@@ -0,0 +1,31 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
+    <title>Hello {name ?: "Qute"}</title>
+    <style>
+        body {
+            background-color: #000;
+            color: #fff;
+        }
+
+        h1 {
+            color: #4695EB;
+            font-size: 6vw;
+        }
+
+        h1 b {
+            color: #be9100;
+        }
+
+        p {
+            font-size: 2vw;
+        }
+    </style>
+</head>
+<body>
+<h1>Hello <b>{name ?: "Qute"}</b></h1>
+
+<p>Create your web page using Quarkus RESTEasy & Qute</p>
+</body>
+</html>