update scala version in scripts

Update scala3-library to 3.6.2

.git-blame-ignore-revs

@@ -0,0 +1,5 @@
+# Scala Steward: Reformat with sbt-java-formatter 0.8.0
+57ce691a00babb03e0cae03a26fe56d63fc609af
+
+# Scala Steward: Reformat with scalafmt 3.6.1
+f2b19baca828a4d88b46bc009aef6d7115e63924

.github/scala-steward.conf

@@ -0,0 +1,3 @@
+# If true, Scala Steward will sign off all commits (e.g. `git --signoff`).
+# Default: false
+signoffCommits = true

.github/workflows/ci.yml

@@ -16,6 +16,7 @@ jobs:
       uses: actions/setup-java@v1
       with:
         java-version: 1.11
+    - uses: sbt/setup-sbt@v1
     - name: Run tests
       run: sbt test assembly
     - name: Run linter

.github/workflows/docker-latest.yml

@@ -3,6 +3,8 @@ name: Update docker image
 on:
   push:
     branches: [ master ]
+    tags:
+      - 'v*'
 
 jobs:
   build:
@@ -20,7 +22,20 @@ jobs:
       - name: Assemble Jar
         run: sbt assembly
 
+      -
+        name: Docker meta
+        id: meta
+        uses: docker/metadata-action@v3
+        with:
+          images: librecaptcha/lc-core
+          tags: |
+            type=ref,event=branch
+            type=ref,event=pr
+            type=semver,pattern={{version}}
+            type=semver,pattern={{major}}.{{minor}}
+
       - name: Login to Docker Hub
+        if: github.event_name != 'pull_request'
         uses: docker/login-action@v1
         with:
           username: ${{ secrets.DOCKER_HUB_USERNAME }}
@@ -36,8 +51,13 @@ jobs:
         with:
           context: ./
           file: ./Runner.Dockerfile
-          push: true
-          tags: librecaptcha/lc-core:latest
+          push: ${{ github.event_name != 'pull_request' }}
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          platforms: |
+            linux/amd64
+            linux/arm64
+            linux/arm/v7
 
       - name: Image digest
         run: echo ${{ steps.docker_build.outputs.digest }}

.scalafix.conf

@@ -1,8 +1,5 @@
 rules=[
-    ExplicitResultTypes,
-    RemoveUnused,
     DisableSyntax,
     LeakingImplicitClassVal,
     NoValInForComprehension,
-    ProcedureSyntax
 ]

.scalafmt.conf

@@ -1,2 +1,3 @@
-version=2.5.2 
+version="3.8.3" 
 maxColumn = 120
+runner.dialect = scala3

Dockerfile

@@ -1,9 +1,10 @@
-FROM adoptopenjdk/openjdk16:alpine AS base-builder
-ARG SBT_VERSION=1.3.13
-RUN apk add --no-cache bash
+FROM eclipse-temurin:17-jre-jammy AS base-builder
+ARG SBT_VERSION=1.7.1
 ENV JAVA_HOME="/usr/lib/jvm/default-jvm/"
 ENV PATH=$PATH:${JAVA_HOME}/bin
 RUN \
+        apt update && \
+        apt install -y wget && \
 	wget -O sbt-$SBT_VERSION.tgz https://github.com/sbt/sbt/releases/download/v$SBT_VERSION/sbt-$SBT_VERSION.tgz && \
         tar -xzvf sbt-$SBT_VERSION.tgz && \
         rm sbt-$SBT_VERSION.tgz
@@ -22,15 +23,15 @@ FROM sbt-builder as builder
 COPY src/ src/
 RUN sbt assembly
 
-FROM adoptopenjdk/openjdk16:alpine-jre  AS base-core
+FROM eclipse-temurin:17-jre-jammy  AS base-core
 ENV JAVA_HOME="/usr/lib/jvm/default-jvm/"
-RUN apk add --update ttf-dejavu
+RUN apt update && apt install -y fonts-dejavu
 ENV PATH=$PATH:${JAVA_HOME}/bin
 
 
 FROM base-core
 WORKDIR /lc-core
-COPY --from=builder /build/target/scala-2.13/LibreCaptcha.jar .
+COPY --from=builder /build/target/scala-3.6.2/LibreCaptcha.jar .
 RUN mkdir data/
 
 EXPOSE 8888

README.md

@@ -47,18 +47,25 @@ docker-compose up
 Using `docker`:
 
 ```
-docker run -v lcdata:/lc-core/data librecaptcha/lc-core:latest
+docker run -p=8888:8888 -v ./lcdata:/lc-core/data librecaptcha/lc-core:2.0
 ```
 
 A default `config.json` is automatically created in the mounted volume.
 
+The above commands should work with `podman` as well, if docker.io registry is pre-configured. Otherwise,
+you can manually specify the repository like so:
+
+```
+podman run -p=8888:8888 -v ./lcdata:/lc-core/data docker.io/librecaptcha/lc-core:2.0
+```
+
 ## Quick test
 Open [localhost:8888/demo/index.html](http://localhost:8888/demo/index.html) in browser.
 
 Alternatively, on the command line, try:
 
 ```
-> $ curl -d '{"media":"image/png","level":"easy","input_type":"text"}' localhost:8888/v1/captcha
+> $ curl -d '{"media":"image/png","level":"easy","input_type":"text","size":"350x100"}' localhost:8888/v2/captcha
 {"id":"3bf928ce-a1e7-4616-b34f-8252d777855d"}
 
 > $ curl "localhost:8888/v1/media?id=3bf928ce-a1e7-4616-b34f-8252d777855d" -o sample.png
@@ -91,6 +98,11 @@ create CAPTCHAs that suit their application and audience, with matching themes a
 And, the more the variety of CAPTCHAS, the harder it is for bots to crack CAPTCHAs.
 
 ## Sample CAPTCHAs
+These are included in this server.
+
+### ShadowText
+![ShadowText Sample](./samples/shadowText.png)
+
 
 ### FilterCaptcha
 
@@ -115,6 +127,9 @@ If a sufficient number of users agree on their answer to the unknown word, it is
 ***
 
 ## HTTP API
+
+The service can be accessed using a simple HTTP API.
+
 ### - `/v1/captcha`: `POST`
 - Parameters:
     - `level`: `String` -
@@ -131,12 +146,12 @@ If a sufficient number of users agree on their answer to the unknown word, it is
         - image/png
         - image/gif
         - (More to come)
-    - `size`: `Map` - 
-      The dimensions of a captcha (Optional). It needs two more fields nested in this parameter
-       - `height`: `Int`
-       - `width`: `Int`
+    - `size`: String -
+      The dimensions of a captcha. It needs to be a string in the format `"widthxheight"` in pixels, and will be matched
+      with the `allowedSizes` config setting. Example: `size: "450x200"` which requests an image of width 450 and height
+      200 pixels.
 
-  - Return type:
+- Returns:
     - `id`: `String` - The uuid of the captcha generated
 
 
@@ -144,7 +159,7 @@ If a sufficient number of users agree on their answer to the unknown word, it is
 - Parameters:
     - `id`: `String` - The uuid of the captcha
 
-  - Return type:
+- Returns:
     - `image`: `Array[Byte]` - The requested media as bytes
 
 
@@ -153,12 +168,46 @@ If a sufficient number of users agree on their answer to the unknown word, it is
     - `id`: `String` - The uuid of the captcha that needs to be solved
     - `answer`: `String` - The answer to the captcha that needs to be validated
 
-  - Return Type:
+- Returns:
     - `result`: `String` - The result after validation/checking of the answer
         - True - If the answer is correct
         - False - If the answer is incorrect
         - Expired - If the time limit to solve the captcha exceeds
 
+
+## Example usage
+
+In javascript:
+
+```js
+const resp = await fetch("/v2/captcha", {
+    method: 'POST',
+    body: JSON.stringify({level: "easy", media: "image/png", "input_type" : "text", size: "350x100"})
+})
+
+const respJson = await resp.json();
+
+let captchaId = null;
+
+if (resp.ok) {
+    // The CAPTCHA can be displayed using the data in respJson.
+    console.log(respJson);
+    // Store the id somewhere so that it can be used later for answer verification
+    captchaId = respJson.id;
+} else {
+    console.err(respJson);
+}
+
+
+// When user submits an answer it can be sent to the server for verification thusly:
+const resp = await fetch("/v2/answer", {
+    method: 'POST',
+    body: JSON.stringify({id: captchaId, answer: "user input"})
+});
+const respJson = await resp.json();
+console.log(respJson.result);
+```
+
 ***
 
 ## Roadmap

Runner.Dockerfile

@@ -1,12 +1,12 @@
-FROM adoptopenjdk/openjdk16:alpine-jre  AS base-core
+FROM eclipse-temurin:17-jre-jammy  AS base-core
 ENV JAVA_HOME="/usr/lib/jvm/default-jvm/"
-RUN apk add --update ttf-dejavu
+RUN apt update && apt install -y fonts-dejavu
 ENV PATH=$PATH:${JAVA_HOME}/bin
 
 
 FROM base-core
 RUN mkdir /lc-core
-COPY target/scala-2.13/LibreCaptcha.jar /lc-core
+COPY target/scala-3.6.2/LibreCaptcha.jar /lc-core
 WORKDIR /lc-core
 RUN mkdir data/
 

build.sbt

@@ -2,23 +2,23 @@ lazy val root = (project in file(".")).settings(
   inThisBuild(
     List(
       organization := "com.example",
-      scalaVersion := "2.13.5",
-      version := "0.1.0-SNAPSHOT",
+      scalaVersion := "3.6.2",
+      version := "0.2.1-snapshot",
       semanticdbEnabled := true,
-      semanticdbVersion := scalafixSemanticdb.revision,
-      scalafixScalaBinaryVersion := "2.13"
+      semanticdbVersion := scalafixSemanticdb.revision
+
+      // This is apparently not supported on Scala 3 currently
+      // scalafixScalaBinaryVersion := "3.1"
     )
   ),
   name := "LibreCaptcha",
-  libraryDependencies += "com.sksamuel.scrimage" % "scrimage-core" % "4.0.12",
-  libraryDependencies += "com.sksamuel.scrimage" % "scrimage-filters" % "4.0.12",
-  libraryDependencies += "org.json4s" % "json4s-jackson_2.13" % "3.6.11"
+  libraryDependencies += "com.sksamuel.scrimage" % "scrimage-core" % "4.3.0",
+  libraryDependencies += "com.sksamuel.scrimage" % "scrimage-filters" % "4.3.0",
+  libraryDependencies += "org.json4s" %% "json4s-jackson" % "4.0.7"
 )
 
 Compile / unmanagedResourceDirectories += { baseDirectory.value / "lib" }
 scalacOptions ++= List(
-  "-Yrangepos",
-  "-Ywarn-unused",
   "-deprecation"
 )
 javacOptions += "-g:none"
@@ -28,4 +28,12 @@ assembly / mainClass := Some("lc.LCFramework")
 Compile / run / mainClass := Some("lc.LCFramework")
 assembly / assemblyJarName := "LibreCaptcha.jar"
 
+ThisBuild / assemblyMergeStrategy := {
+  case PathList("module-info.class")         => MergeStrategy.discard
+  case x if x.endsWith("/module-info.class") => MergeStrategy.discard
+  case x =>
+    val oldStrategy = (ThisBuild / assemblyMergeStrategy).value
+    oldStrategy(x)
+}
+
 run / fork := true

docker-compose.yml

@@ -4,6 +4,8 @@ services:
   lc-core:
     container_name: "libre-captcha"
     image: librecaptcha/lc-core:latest
+    # Comment "image" & uncomment "build" if you intend to build from source
+    #build: .
     volumes: 
       - "./docker-data:/lc-core/data"
     ports: 

project/build.properties

@@ -1 +1 @@
-sbt.version=1.5.0
+sbt.version=1.10.6

project/plugins.sbt

@@ -1,4 +1,4 @@
-addSbtPlugin("ch.epfl.scala" % "sbt-scalafix" % "0.9.27")
-addSbtPlugin("org.scalameta" % "sbt-scalafmt" % "2.4.2")
-addSbtPlugin("com.lightbend.sbt" % "sbt-java-formatter" % "0.6.0")
-addSbtPlugin("com.eed3si9n" % "sbt-assembly" % "0.15.0")
+addSbtPlugin("ch.epfl.scala" % "sbt-scalafix" % "0.13.0")
+addSbtPlugin("org.scalameta" % "sbt-scalafmt" % "2.5.2")
+addSbtPlugin("com.lightbend.sbt" % "sbt-java-formatter" % "0.8.0")
+addSbtPlugin("com.eed3si9n" % "sbt-assembly" % "2.3.0")

src/main/java/lc/captchas/FontFunCaptcha.java

@@ -1,16 +1,16 @@
 package lc.captchas;
 
-import javax.imageio.ImageIO;
 import java.awt.*;
 import java.awt.image.BufferedImage;
 import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.FilenameFilter;
-import java.util.Map;
 import java.util.List;
+import java.util.Map;
 import lc.captchas.interfaces.Challenge;
 import lc.captchas.interfaces.ChallengeProvider;
 import lc.misc.HelperFunctions;
+import lc.misc.PngImageWriter;
 
 public class FontFunCaptcha implements ChallengeProvider {
 
@@ -58,9 +58,10 @@ public class FontFunCaptcha implements ChallengeProvider {
     return null;
   }
 
-  private byte[] fontFun(String captchaText, String level, String path) {
+  private byte[] fontFun(
+      final int width, final int height, String captchaText, String level, String path) {
     String[] colors = {"#f68787", "#f8a978", "#f1eb9a", "#a4f6a5"};
-    BufferedImage img = new BufferedImage(350, 100, BufferedImage.TYPE_INT_RGB);
+    BufferedImage img = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
     Graphics2D graphics2D = img.createGraphics();
     for (int i = 0; i < captchaText.length(); i++) {
       Font font = loadCustomFont(level, path);
@@ -74,17 +75,21 @@ public class FontFunCaptcha implements ChallengeProvider {
     graphics2D.dispose();
     ByteArrayOutputStream baos = new ByteArrayOutputStream();
     try {
-      ImageIO.write(img, "png", baos);
+      PngImageWriter.write(baos, img);
     } catch (Exception e) {
       e.printStackTrace();
     }
     return baos.toByteArray();
   }
 
-  public Challenge returnChallenge() {
+  public Challenge returnChallenge(String level, String size) {
     String secret = HelperFunctions.randomString(7);
+    final int[] size2D = HelperFunctions.parseSize2D(size);
+    final int width = size2D[0];
+    final int height = size2D[1];
     String path = "./lib/fonts/";
-    return new Challenge(fontFun(secret, "medium", path), "image/png", secret.toLowerCase());
+    return new Challenge(
+        fontFun(width, height, secret, "medium", path), "image/png", secret.toLowerCase());
   }
 
   public boolean checkAnswer(String secret, String answer) {

src/main/java/lc/captchas/PoppingCharactersCaptcha.java

@@ -1,51 +1,51 @@
 package lc.captchas;
 
-import java.awt.Font;
-import java.awt.RenderingHints;
 import java.awt.Color;
+import java.awt.Font;
 import java.awt.Graphics2D;
+import java.awt.RenderingHints;
 import java.awt.image.BufferedImage;
+import java.io.ByteArrayOutputStream;
 import java.io.IOException;
+import java.util.List;
 import java.util.Map;
 import java.util.function.Consumer;
 import java.util.stream.IntStream;
-import java.util.LinkedList;
-import java.util.List;
-
 import javax.imageio.stream.MemoryCacheImageOutputStream;
-import java.io.ByteArrayOutputStream;
 import lc.captchas.interfaces.Challenge;
 import lc.captchas.interfaces.ChallengeProvider;
-import lc.misc.HelperFunctions;
 import lc.misc.GifSequenceWriter;
+import lc.misc.HelperFunctions;
 
 public class PoppingCharactersCaptcha implements ChallengeProvider {
-  private final Font font = new Font("Arial", Font.ROMAN_BASELINE, 48);
-  private final int width = 250;
-  private final int height = 100;
 
-  private Integer[] computeOffsets(final String text) {
+  private int[] computeOffsets(
+      final Font font, final int width, final int height, final String text) {
     final var img = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
     final var graphics2D = img.createGraphics();
     final var frc = graphics2D.getFontRenderContext();
-    final var advances = new LinkedList<Integer>();
+    final var advances = new int[text.length() + 1];
     final var spacing = font.getStringBounds(" ", frc).getWidth() / 3;
     var currX = 0;
     for (int i = 0; i < text.length(); i++) {
       final var c = text.charAt(i);
-      advances.add(currX);
+      advances[i] = currX;
       currX += font.getStringBounds(String.valueOf(c), frc).getWidth();
       currX += spacing;
-    };
+    }
+    ;
+    advances[text.length()] = currX;
     graphics2D.dispose();
-    return advances.toArray(new Integer[]{});
+    return advances;
   }
 
-  private BufferedImage makeImage(final Consumer<Graphics2D> f) {
+  private BufferedImage makeImage(
+      final Font font, final int width, final int height, final Consumer<Graphics2D> f) {
     final var img = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
     final var graphics2D = img.createGraphics();
     graphics2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
-    graphics2D.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
+    graphics2D.setRenderingHint(
+        RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
     graphics2D.setFont(font);
     f.accept(graphics2D);
     graphics2D.dispose();
@@ -56,23 +56,42 @@ public class PoppingCharactersCaptcha implements ChallengeProvider {
     return HelperFunctions.randomNumber(-2, +2);
   }
 
-  private byte[] gifCaptcha(final String text) {
+  private byte[] gifCaptcha(final int width, final int height, final String text) {
     try {
+      final var fontHeight = (int) (height * 0.5);
+      final Font font = new Font("Arial", Font.ROMAN_BASELINE, fontHeight);
       final var byteArrayOutputStream = new ByteArrayOutputStream();
       final var output = new MemoryCacheImageOutputStream(byteArrayOutputStream);
       final var writer = new GifSequenceWriter(output, 1, 900, true);
-      final var advances = computeOffsets(text);
+      final var advances = computeOffsets(font, width, height, text);
+      final var expectedWidth = advances[advances.length - 1];
+      final var scale = width / (float) expectedWidth;
       final var prevColor = Color.getHSBColor(0f, 0f, 0.1f);
-      IntStream.range(0, text.length()).forEach(i -> {
-        final var color = Color.getHSBColor(HelperFunctions.randomNumber(0, 100)/100.0f, 0.6f, 1.0f);
-        final var nextImage = makeImage((g) -> {
+      IntStream.range(0, text.length())
+          .forEach(
+              i -> {
+                final var color =
+                    Color.getHSBColor(HelperFunctions.randomNumber(0, 100) / 100.0f, 0.6f, 1.0f);
+                final var nextImage =
+                    makeImage(
+                        font,
+                        width,
+                        height,
+                        (g) -> {
+                          g.scale(scale, 1);
                           if (i > 0) {
                             final var prevI = (i - 1) % text.length();
                             g.setColor(prevColor);
-            g.drawString(String.valueOf(text.charAt(prevI)), advances[prevI] + jitter(), 45 + jitter());
+                            g.drawString(
+                                String.valueOf(text.charAt(prevI)),
+                                advances[prevI] + jitter(),
+                                fontHeight * 1.1f + jitter());
                           }
                           g.setColor(color);
-          g.drawString(String.valueOf(text.charAt(i)), advances[i] + jitter(), 45 + jitter());
+                          g.drawString(
+                              String.valueOf(text.charAt(i)),
+                              advances[i] + jitter(),
+                              fontHeight * 1.1f + jitter());
                         });
                 try {
                   writer.writeToSequence(nextImage);
@@ -100,9 +119,12 @@ public class PoppingCharactersCaptcha implements ChallengeProvider {
         "supportedInputType", List.of("text"));
   }
 
-  public Challenge returnChallenge() {
+  public Challenge returnChallenge(String level, String size) {
     final var secret = HelperFunctions.randomString(6);
-    return new Challenge(gifCaptcha(secret), "image/gif", secret.toLowerCase());
+    final int[] size2D = HelperFunctions.parseSize2D(size);
+    final int width = size2D[0];
+    final int height = size2D[1];
+    return new Challenge(gifCaptcha(width, height, secret), "image/gif", secret.toLowerCase());
   }
 
   public boolean checkAnswer(String secret, String answer) {

src/main/java/lc/captchas/ShadowTextCaptcha.java

@@ -1,21 +1,18 @@
 package lc.captchas;
 
-import javax.imageio.ImageIO;
-import java.awt.Graphics2D;
-import java.awt.RenderingHints;
 import java.awt.Color;
 import java.awt.Font;
-import java.awt.font.TextLayout;
+import java.awt.Graphics2D;
 import java.awt.image.BufferedImage;
 import java.awt.image.ConvolveOp;
 import java.awt.image.Kernel;
 import java.io.ByteArrayOutputStream;
-import java.util.Map;
 import java.util.List;
-
-import lc.misc.HelperFunctions;
+import java.util.Map;
 import lc.captchas.interfaces.Challenge;
 import lc.captchas.interfaces.ChallengeProvider;
+import lc.misc.HelperFunctions;
+import lc.misc.PngImageWriter;
 
 public class ShadowTextCaptcha implements ChallengeProvider {
 
@@ -38,44 +35,58 @@ public class ShadowTextCaptcha implements ChallengeProvider {
     return answer.toLowerCase().equals(secret);
   }
 
-  private byte[] shadowText(String text) {
-    BufferedImage img = new BufferedImage(350, 100, BufferedImage.TYPE_INT_RGB);
-    Font font = new Font("Arial", Font.ROMAN_BASELINE, 48);
-    Graphics2D graphics2D = img.createGraphics();
-    graphics2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
-    graphics2D.setRenderingHint(
-        RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
+  private float[] makeKernel(int size) {
+    final int N = size * size;
+    final float weight = 1.0f / (N);
+    final float[] kernel = new float[N];
+    java.util.Arrays.fill(kernel, weight);
+    return kernel;
+  };
 
-    TextLayout textLayout = new TextLayout(text, font, graphics2D.getFontRenderContext());
+  private byte[] shadowText(final int width, final int height, String text) {
+    BufferedImage img = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
+    final int fontHeight = (int) (height * 0.5f);
+    Font font = new Font("Arial", Font.PLAIN, fontHeight);
+    Graphics2D graphics2D = img.createGraphics();
     HelperFunctions.setRenderingHints(graphics2D);
     graphics2D.setPaint(Color.WHITE);
-    graphics2D.fillRect(0, 0, 350, 100);
+    graphics2D.fillRect(0, 0, width, height);
     graphics2D.setPaint(Color.BLACK);
-    textLayout.draw(graphics2D, 15, 50);
+    graphics2D.setFont(font);
+    final var stringWidth = graphics2D.getFontMetrics().stringWidth(text);
+    final var padding = (stringWidth > width) ? 0 : (width - stringWidth) / 2;
+    final var scaleX = (stringWidth > width) ? width / ((double) stringWidth) : 1d;
+    graphics2D.scale(scaleX, 1d);
+    graphics2D.drawString(text, padding, fontHeight * 1.1f);
     graphics2D.dispose();
-    float[] kernel = {
-      1f / 9f, 1f / 9f, 1f / 9f,
-      1f / 9f, 1f / 9f, 1f / 9f,
-      1f / 9f, 1f / 9f, 1f / 9f
-    };
-    ConvolveOp op = new ConvolveOp(new Kernel(3, 3, kernel), ConvolveOp.EDGE_NO_OP, null);
+    final int kernelSize = (int) Math.ceil((Math.min(width, height) / 50.0));
+    ConvolveOp op =
+        new ConvolveOp(
+            new Kernel(kernelSize, kernelSize, makeKernel(kernelSize)),
+            ConvolveOp.EDGE_NO_OP,
+            null);
     BufferedImage img2 = op.filter(img, null);
     Graphics2D g2d = img2.createGraphics();
     HelperFunctions.setRenderingHints(g2d);
     g2d.setPaint(Color.WHITE);
-    textLayout.draw(g2d, 13, 50);
+    g2d.scale(scaleX, 1d);
+    g2d.setFont(font);
+    g2d.drawString(text, padding - kernelSize, fontHeight * 1.1f);
     g2d.dispose();
     ByteArrayOutputStream baos = new ByteArrayOutputStream();
     try {
-      ImageIO.write(img2, "png", baos);
+      PngImageWriter.write(baos, img2);
     } catch (Exception e) {
       e.printStackTrace();
     }
     return baos.toByteArray();
   }
 
-  public Challenge returnChallenge() {
+  public Challenge returnChallenge(String level, String size) {
     String secret = HelperFunctions.randomString(6);
-    return new Challenge(shadowText(secret), "image/png", secret.toLowerCase());
+    final int[] size2D = HelperFunctions.parseSize2D(size);
+    final int width = size2D[0];
+    final int height = size2D[1];
+    return new Challenge(shadowText(width, height, secret), "image/png", secret.toLowerCase());
   }
 }

src/main/java/lc/captchas/interfaces/ChallengeProvider.java

@@ -1,12 +1,12 @@
 package lc.captchas.interfaces;
 
-import java.util.Map;
 import java.util.List;
+import java.util.Map;
 
 public interface ChallengeProvider {
   public String getId();
 
-  public Challenge returnChallenge();
+  public Challenge returnChallenge(String level, String size);
 
   public boolean checkAnswer(String secret, String answer);
 

src/main/java/lc/misc/GifSequenceWriter.java

@@ -3,12 +3,12 @@
 
 package lc.misc;
 
-import javax.imageio.*;
-import javax.imageio.metadata.*;
-import javax.imageio.stream.*;
 import java.awt.image.*;
 import java.io.*;
 import java.util.Iterator;
+import javax.imageio.*;
+import javax.imageio.metadata.*;
+import javax.imageio.stream.*;
 
 public class GifSequenceWriter {
   protected ImageWriter gifWriter;

src/main/java/lc/misc/HelperFunctions.java

@@ -7,11 +7,18 @@ public class HelperFunctions {
 
   private static Random random = new Random();
 
-  synchronized public static void setSeed(long seed){
+  public static synchronized void setSeed(long seed) {
     random.setSeed(seed);
   }
 
+  public static int[] parseSize2D(final String size) {
+    final String[] fields = size.split("x");
+    final int[] result = {Integer.parseInt(fields[0]), Integer.parseInt(fields[1])};
+    return result;
+  }
+
   public static void setRenderingHints(Graphics2D g2d) {
+    g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
     g2d.setRenderingHint(
         RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
     g2d.setRenderingHint(
@@ -23,7 +30,8 @@ public class HelperFunctions {
   public static final String safeNumbers = "23456789";
   public static final String allNumbers = safeNumbers + "10";
   public static final String specialCharacters = "$#%@&?";
-  public static final String safeCharacters = safeAlphabets + safeNumbers + specialCharacters;
+  public static final String safeAlphaNum = safeAlphabets + safeNumbers;
+  public static final String safeCharacters = safeAlphaNum + specialCharacters;
 
   public static String randomString(final int n) {
     return randomString(n, safeCharacters);
@@ -38,12 +46,11 @@ public class HelperFunctions {
     return stringBuilder.toString();
   }
 
-  synchronized public static int randomNumber(int min, int max) {
+  public static synchronized int randomNumber(int min, int max) {
     return random.nextInt((max - min) + 1) + min;
   }
 
-  synchronized public static int randomNumber(int bound) {
+  public static synchronized int randomNumber(int bound) {
     return random.nextInt(bound);
   }
-  
 }

src/main/java/lc/misc/PngImageWriter.java

@@ -0,0 +1,68 @@
+package lc.misc;
+
+import java.awt.image.BufferedImage;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.Iterator;
+import javax.imageio.IIOImage;
+import javax.imageio.ImageIO;
+import javax.imageio.ImageTypeSpecifier;
+import javax.imageio.ImageWriteParam;
+import javax.imageio.ImageWriter;
+import javax.imageio.metadata.IIOInvalidTreeException;
+import javax.imageio.metadata.IIOMetadata;
+import javax.imageio.metadata.IIOMetadataNode;
+import javax.imageio.stream.ImageOutputStream;
+
+public class PngImageWriter {
+
+  static final int DPI = 245;
+  static final double INCH_2_CM = 2.54;
+
+  public static void write(ByteArrayOutputStream boas, BufferedImage gridImage) throws IOException {
+    final String formatName = "png";
+    for (Iterator<ImageWriter> iw = ImageIO.getImageWritersByFormatName(formatName);
+        iw.hasNext(); ) {
+      ImageWriter writer = iw.next();
+      ImageWriteParam writeParam = writer.getDefaultWriteParam();
+      ImageTypeSpecifier typeSpecifier =
+          ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_INT_RGB);
+      IIOMetadata metadata = writer.getDefaultImageMetadata(typeSpecifier, writeParam);
+      if (metadata.isReadOnly() || !metadata.isStandardMetadataFormatSupported()) {
+        continue;
+      }
+
+      setDPIMeta(metadata);
+
+      final ImageOutputStream stream = ImageIO.createImageOutputStream(boas);
+      try {
+        writer.setOutput(stream);
+        writer.write(metadata, new IIOImage(gridImage, null, metadata), writeParam);
+      } finally {
+        stream.close();
+      }
+      break;
+    }
+  }
+
+  private static void setDPIMeta(IIOMetadata metadata) throws IIOInvalidTreeException {
+
+    // for PNG, it's dots per millimeter
+    double dotsPerMilli = 1.0 * DPI / 10 / INCH_2_CM;
+
+    IIOMetadataNode horiz = new IIOMetadataNode("HorizontalPixelSize");
+    horiz.setAttribute("value", Double.toString(dotsPerMilli));
+
+    IIOMetadataNode vert = new IIOMetadataNode("VerticalPixelSize");
+    vert.setAttribute("value", Double.toString(dotsPerMilli));
+
+    IIOMetadataNode dim = new IIOMetadataNode("Dimension");
+    dim.appendChild(horiz);
+    dim.appendChild(vert);
+
+    IIOMetadataNode root = new IIOMetadataNode("javax_imageio_1.0");
+    root.appendChild(dim);
+
+    metadata.mergeTree("javax_imageio_1.0", root);
+  }
+}

src/main/java/org/limium/picoserve/Server.java

@@ -3,21 +3,21 @@
 
 package org.limium.picoserve;
 
-import java.net.InetSocketAddress;
+import com.sun.net.httpserver.HttpExchange;
+import com.sun.net.httpserver.HttpHandler;
+import com.sun.net.httpserver.HttpServer;
 import java.io.IOException;
-import java.util.List;
-import java.util.Map;
-import java.util.LinkedList;
-import java.util.concurrent.Executor;
-import java.util.regex.Pattern;
-import java.util.Arrays;
-import java.util.Optional;
-import java.util.stream.Collectors;
+import java.net.InetSocketAddress;
 import java.net.URLDecoder;
 import java.nio.charset.StandardCharsets;
-import com.sun.net.httpserver.HttpServer;
-import com.sun.net.httpserver.HttpHandler;
-import com.sun.net.httpserver.HttpExchange;
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.Executor;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
 
 public final class Server {
   private final HttpServer server;

src/main/resources/index.html

@@ -20,9 +20,10 @@
     const levelInput = document.getElementById("levelInput").value
     const mediaInput = document.getElementById("mediaInput").value
     const typeInput = document.getElementById("typeInput").value
-    fetch("/v1/captcha", {
+    const sizeInput = document.getElementById("sizeInput").value
+    fetch("/v2/captcha", {
        method: 'POST',
-       body: JSON.stringify({level: levelInput, media: mediaInput, "input_type" : typeInput})
+       body: JSON.stringify({level: levelInput, media: mediaInput, "input_type" : typeInput, "size": sizeInput})
     }).then(async function(resp) {
       const respJson = await resp.json()
       if (resp.ok) {
@@ -30,7 +31,7 @@
         const resultDiv = document.getElementById("result")
         const result = `
           <p>Id: ${id}</p>
-          <p><img src="/v1/media?id=${id}" /> </p>
+          <p><img src="/v2/media?id=${id}" /> </p>
           <input type="text" id="answerInput" />
           <button onClick="submitAnswer('${id}')">Submit</button>
           <div id="answerResult" />
@@ -43,7 +44,7 @@
   }
   async function submitAnswer(id) {
     const ans = document.getElementById("answerInput").value;
-    const resp = await fetch("/v1/answer", {
+    const resp = await fetch("/v2/answer", {
        method: 'POST',
        body: JSON.stringify({id: id, answer: ans})
     })
@@ -70,6 +71,10 @@
       <span>Input Type</span>
       <input type="text" id="typeInput" value="text" />
     </div>
+    <div class="inputGroup">
+      <span>Input Size</span>
+      <input type="text" id="sizeInput" value="350x100" />
+    </div>
     <div class="inputGroup">
       <button onClick="loadCaptcha()">Get New CAPTCHA</button>
     </div>

src/main/scala/lc/Main.scala

@@ -1,27 +1,53 @@
 package lc
 
-import lc.core.CaptchaProviders
+import lc.core.{CaptchaProviders, CaptchaManager, Config}
 import lc.server.Server
 import lc.background.BackgroundTask
-import lc.core.Config
+import lc.database.Statements
 
 object LCFramework {
   def main(args: scala.Array[String]): Unit = {
-    val backgroundTask = new BackgroundTask(
-      throttle = Config.throttle,
-      timeLimit = Config.captchaExpiryTimeLimit
+    val configFilePath = if (args.length > 0) {
+      args(0)
+    } else {
+      "data/config.json"
+    }
+    val config = new Config(configFilePath)
+    Statements.maxAttempts = config.maxAttempts
+    val captchaProviders = new CaptchaProviders(config = config)
+    val captchaManager = new CaptchaManager(config = config, captchaProviders = captchaProviders)
+    val backgroundTask = new BackgroundTask(config = config, captchaManager = captchaManager)
+    backgroundTask.beginThread(delay = config.threadDelay)
+    val server = new Server(
+      address = config.address,
+      port = config.port,
+      captchaManager = captchaManager,
+      playgroundEnabled = config.playgroundEnabled,
+      corsHeader = config.corsHeader
     )
-    backgroundTask.beginThread(delay = Config.threadDelay)
-    val server = new Server(port = Config.port)
+
+    Runtime.getRuntime.addShutdownHook(new Thread {
+      override def run(): Unit = {
+        println("Shutting down gracefully...")
+        backgroundTask.shutdown()
+      }
+    })
+
     server.start()
   }
 }
 
 object MakeSamples {
   def main(args: scala.Array[String]): Unit = {
-    val samples = CaptchaProviders.generateChallengeSamples()
-    samples.foreach {
-      case (key, sample) =>
+    val configFilePath = if (args.length > 0) {
+      args(0)
+    } else {
+      "data/config.json"
+    }
+    val config = new Config(configFilePath)
+    val captchaProviders = new CaptchaProviders(config = config)
+    val samples = captchaProviders.generateChallengeSamples()
+    samples.foreach { case (key, sample) =>
       val extensionMap = Map("image/png" -> "png", "image/gif" -> "gif")
       println(key + ": " + sample)
 

src/main/scala/lc/background/taskThread.scala

@@ -2,50 +2,89 @@ package lc.background
 
 import lc.database.Statements
 import java.util.concurrent.{ScheduledThreadPoolExecutor, TimeUnit}
-import lc.core.{Captcha, Config}
+import lc.core.{CaptchaManager, Config}
 import lc.core.{Parameters, Size}
 import lc.misc.HelperFunctions
 
-class BackgroundTask(throttle: Int, timeLimit: Int) {
+class BackgroundTask(config: Config, captchaManager: CaptchaManager) {
 
   private val task = new Runnable {
     def run(): Unit = {
       try {
         val mapIdGCPstmt = Statements.tlStmts.get.mapIdGCPstmt
-        mapIdGCPstmt.setInt(1, timeLimit)
+        mapIdGCPstmt.setInt(1, config.captchaExpiryTimeLimit)
         mapIdGCPstmt.executeUpdate()
 
         val challengeGCPstmt = Statements.tlStmts.get.challengeGCPstmt
         challengeGCPstmt.executeUpdate()
 
-        val imageNum = Statements.tlStmts.get.getCountChallengeTable.executeQuery()
-        var throttleIn = (throttle * 1.1).toInt
-        if (imageNum.next())
-          throttleIn = (throttleIn - imageNum.getInt("total"))
-        while (0 < throttleIn) {
-          Captcha.generateChallenge(getRandomParam())
-          throttleIn -= 1
+        val allCombinations = allParameterCombinations()
+        val requiredCountPerCombination = Math.max(1, (config.bufferCount * 1.01) / allCombinations.size).toInt
+
+        for (param <- allCombinations) {
+          if (!shutdownInProgress) {
+            val countExisting = captchaManager.getCount(param).getOrElse(0)
+            val countRequired = requiredCountPerCombination - countExisting
+            if (countRequired > 0) {
+              val countCreate = Math.min(1.0 + requiredCountPerCombination / 10.0, countRequired).toInt
+              println(s"Creating $countCreate of $countRequired captchas for $param")
+
+              for (i <- 0 until countCreate) {
+                if (!shutdownInProgress) {
+                  captchaManager.generateChallenge(param)
+                }
+              }
+            }
+          }
         }
       } catch { case exception: Exception => println(exception) }
     }
   }
 
+  private def allParameterCombinations(): List[Parameters] = {
+    (config.captchaConfig).flatMap { captcha =>
+      (captcha.allowedLevels).flatMap { level =>
+        (captcha.allowedMedia).flatMap { media =>
+          (captcha.allowedInputType).flatMap { inputType =>
+            (captcha.allowedSizes).map { size =>
+              Parameters(level, media, inputType, size)
+            }
+          }
+        }
+      }
+    }
+  }
+
   private def getRandomParam(): Parameters = {
-    val captcha = pickRandom(Config.captchaConfig)
+    val captcha = pickRandom(config.captchaConfig)
     val level = pickRandom(captcha.allowedLevels)
     val media = pickRandom(captcha.allowedMedia)
     val inputType = pickRandom(captcha.allowedInputType)
+    val size = pickRandom(captcha.allowedSizes)
 
-    Parameters(level, media, inputType, Some(Size(0, 0)))
+    Parameters(level, media, inputType, size)
   }
 
   private def pickRandom[T](list: List[T]): T = {
     list(HelperFunctions.randomNumber(list.size))
   }
 
+  private val ex = new ScheduledThreadPoolExecutor(1)
+
   def beginThread(delay: Int): Unit = {
-    val ex = new ScheduledThreadPoolExecutor(1)
     ex.scheduleWithFixedDelay(task, 1, delay, TimeUnit.SECONDS)
   }
 
+  @volatile var shutdownInProgress = false
+
+  def shutdown(): Unit = {
+    println("  Shutting down background task...")
+    shutdownInProgress = true
+    ex.shutdown()
+    println("    Finished Shutting background task")
+    println("  Shutting down DB...")
+    Statements.tlStmts.get.shutdown.execute()
+    println("    Finished shutting down db")
+  }
+
 }

src/main/scala/lc/captchas/DebugCaptcha.scala

@@ -1,6 +1,5 @@
 package lc.captchas
 
-import javax.imageio.ImageIO
 import java.awt.Color
 import java.awt.Font
 import java.awt.font.TextLayout
@@ -12,8 +11,11 @@ import java.util.List
 import lc.misc.HelperFunctions
 import lc.captchas.interfaces.Challenge
 import lc.captchas.interfaces.ChallengeProvider
+import lc.misc.PngImageWriter
 
-/** This captcha is only for debugging purposes. It creates very simple captchas that are deliberately easy to solve with OCR engines */
+/** This captcha is only for debugging purposes. It creates very simple captchas that are deliberately easy to solve
+  * with OCR engines
+  */
 class DebugCaptcha extends ChallengeProvider {
 
   def getId(): String = {
@@ -26,9 +28,12 @@ class DebugCaptcha extends ChallengeProvider {
 
   def supportedParameters(): Map[String, List[String]] = {
     Map.of(
-      "supportedLevels", List.of("debug"),
-      "supportedMedia", List.of("image/png"),
-      "supportedInputType", List.of("text")
+      "supportedLevels",
+      List.of("debug"),
+      "supportedMedia",
+      List.of("image/png"),
+      "supportedInputType",
+      List.of("text")
     )
   }
 
@@ -40,20 +45,20 @@ class DebugCaptcha extends ChallengeProvider {
     matches
   }
 
-  private def simpleText(text: String): Array[Byte] = {
-    val img = new BufferedImage(350, 100, BufferedImage.TYPE_INT_RGB)
+  private def simpleText(width: Int, height: Int, text: String): Array[Byte] = {
+    val img = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB)
     val font = new Font("Arial", Font.ROMAN_BASELINE, 56)
     val graphics2D = img.createGraphics()
     val textLayout = new TextLayout(text, font, graphics2D.getFontRenderContext())
     HelperFunctions.setRenderingHints(graphics2D)
     graphics2D.setPaint(Color.WHITE)
-    graphics2D.fillRect(0, 0, 350, 100)
+    graphics2D.fillRect(0, 0, width, height)
     graphics2D.setPaint(Color.BLACK)
     textLayout.draw(graphics2D, 15, 50)
     graphics2D.dispose()
     val baos = new ByteArrayOutputStream()
     try {
-      ImageIO.write(img, "png", baos)
+      PngImageWriter.write(baos, img);
     } catch {
       case e: Exception =>
         e.printStackTrace()
@@ -61,8 +66,11 @@ class DebugCaptcha extends ChallengeProvider {
     baos.toByteArray()
   }
 
-  def returnChallenge(): Challenge = {
+  def returnChallenge(level: String, size: String): Challenge = {
     val secret = HelperFunctions.randomString(6, HelperFunctions.safeAlphabets)
-    new Challenge(simpleText(secret), "image/png", secret.toLowerCase())
+    val size2D = HelperFunctions.parseSize2D(size)
+    val width = size2D(0)
+    val height = size2D(1)
+    new Challenge(simpleText(width, height, secret), "image/png", secret.toLowerCase())
   }
 }

src/main/scala/lc/captchas/FilterChallenge.scala

@@ -8,6 +8,9 @@ import java.awt.Color
 import lc.captchas.interfaces.ChallengeProvider
 import lc.captchas.interfaces.Challenge
 import java.util.{List => JavaList, Map => JavaMap}
+import java.io.ByteArrayOutputStream
+import lc.misc.PngImageWriter
+import lc.misc.HelperFunctions
 
 class FilterChallenge extends ChallengeProvider {
   def getId = "FilterChallenge"
@@ -18,30 +21,48 @@ class FilterChallenge extends ChallengeProvider {
 
   def supportedParameters(): JavaMap[String, JavaList[String]] = {
     JavaMap.of(
-      "supportedLevels",JavaList.of("medium", "hard"),
-      "supportedMedia", JavaList.of("image/png"),
-      "supportedInputType", JavaList.of("text")
+      "supportedLevels",
+      JavaList.of("medium", "hard"),
+      "supportedMedia",
+      JavaList.of("image/png"),
+      "supportedInputType",
+      JavaList.of("text")
     )
   }
 
-  def returnChallenge(): Challenge = {
-    val filterTypes = List(new FilterType1, new FilterType2)
+  private val filterTypes = List(new FilterType1, new FilterType2)
+
+  def returnChallenge(level: String, size: String): Challenge = {
+    val mediumLevel = level == "medium"
     val r = new scala.util.Random
-    val alphabet = "abcdefghijklmnopqrstuvwxyz"
-    val n = 8
-    val secret = LazyList.continually(r.nextInt(alphabet.size)).map(alphabet).take(n).mkString
-    val canvas = new BufferedImage(225, 50, BufferedImage.TYPE_INT_RGB)
+    val characters = if (mediumLevel) HelperFunctions.safeAlphaNum else HelperFunctions.safeCharacters
+    val n = if (mediumLevel) 5 else 7
+    val secret = LazyList.continually(r.nextInt(characters.size)).map(characters).take(n).mkString
+    val size2D = HelperFunctions.parseSize2D(size)
+    val width = size2D(0)
+    val height = size2D(1)
+    val canvas = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB)
     val g = canvas.createGraphics()
+    val fontHeight = (height * 0.6).toInt
     g.setColor(Color.WHITE)
     g.fillRect(0, 0, canvas.getWidth, canvas.getHeight)
     g.setColor(Color.BLACK)
-    g.setFont(new Font("Serif", Font.PLAIN, 30))
-    g.drawString(secret, 5, 30)
+    val font = new Font("Serif", Font.BOLD, fontHeight)
+    g.setFont(font)
+    val stringWidth = g.getFontMetrics().stringWidth(secret)
+    val scaleX = if (stringWidth > width) width / (stringWidth.toDouble) else 1d
+    val margin = if (stringWidth > width) 0 else (width - stringWidth)
+    val xOffset = (margin * r.nextDouble).toInt
+    g.scale(scaleX, 1d)
+    g.drawString(secret, xOffset, fontHeight)
     g.dispose()
     var image = ImmutableImage.fromAwt(canvas)
-    val s = scala.util.Random.nextInt(2)
-    image = filterTypes(s).applyFilter(image)
-    new Challenge(image.bytes(new nio.PngWriter()), "image/png", secret)
+    val s = r.nextInt(2)
+    image = filterTypes(s).applyFilter(image, !mediumLevel)
+    val img = image.awt()
+    val baos = new ByteArrayOutputStream()
+    PngImageWriter.write(baos, img);
+    new Challenge(baos.toByteArray, "image/png", secret)
   }
   def checkAnswer(secret: String, answer: String): Boolean = {
     secret == answer
@@ -49,14 +70,15 @@ class FilterChallenge extends ChallengeProvider {
 }
 
 trait FilterType {
-  def applyFilter(image: ImmutableImage): ImmutableImage
+  def applyFilter(image: ImmutableImage, hardLevel: Boolean): ImmutableImage
 }
 
 class FilterType1 extends FilterType {
-  override def applyFilter(image: ImmutableImage): ImmutableImage = {
-    val blur = new GaussianBlurFilter(2)
+  override def applyFilter(image: ImmutableImage, hardLevel: Boolean): ImmutableImage = {
+    val radius = if (hardLevel) 3 else 2
+    val blur = new GaussianBlurFilter(radius)
     val smear = new SmearFilter(com.sksamuel.scrimage.filter.SmearType.Circles, 10, 10, 10, 0, 1)
-    val diffuse = new DiffuseFilter(2)
+    val diffuse = new DiffuseFilter(radius.toFloat)
     blur.apply(image)
     diffuse.apply(image)
     smear.apply(image)
@@ -65,9 +87,10 @@ class FilterType1 extends FilterType {
 }
 
 class FilterType2 extends FilterType {
-  override def applyFilter(image: ImmutableImage): ImmutableImage = {
+  override def applyFilter(image: ImmutableImage, hardLevel: Boolean): ImmutableImage = {
+    val radius = if (hardLevel) 2f else 1f
     val smear = new SmearFilter(com.sksamuel.scrimage.filter.SmearType.Circles, 10, 10, 10, 0, 1)
-    val diffuse = new DiffuseFilter(1)
+    val diffuse = new DiffuseFilter(radius)
     val ripple = new RippleFilter(com.sksamuel.scrimage.filter.RippleType.Noise, 1, 1, 0.005.toFloat, 0.005.toFloat)
     diffuse.apply(image)
     ripple.apply(image)

src/main/scala/lc/captchas/LabelCaptcha.scala

@@ -10,6 +10,7 @@ import java.awt.Color
 import lc.captchas.interfaces.ChallengeProvider
 import lc.captchas.interfaces.Challenge
 import java.util.{List => JavaList, Map => JavaMap}
+import lc.misc.PngImageWriter
 
 class LabelCaptcha extends ChallengeProvider {
   private var knownFiles = new File("known").list.toList
@@ -30,13 +31,16 @@ class LabelCaptcha extends ChallengeProvider {
 
   def supportedParameters(): JavaMap[String, JavaList[String]] = {
     JavaMap.of(
-      "supportedLevels", JavaList.of("hard"),
-      "supportedMedia", JavaList.of("image/png"),
-      "supportedInputType", JavaList.of("text")
+      "supportedLevels",
+      JavaList.of("hard"),
+      "supportedMedia",
+      JavaList.of("image/png"),
+      "supportedInputType",
+      JavaList.of("text")
     )
   }
 
-  def returnChallenge(): Challenge =
+  def returnChallenge(level: String, size: String): Challenge =
     synchronized {
       val r = scala.util.Random.nextInt(knownFiles.length)
       val s = scala.util.Random.nextInt(unknownFiles.length)
@@ -49,7 +53,7 @@ class LabelCaptcha extends ChallengeProvider {
 
       val token = encrypt(knownImageFile + "," + unknownImageFile)
       val baos = new ByteArrayOutputStream()
-      ImageIO.write(mergedImage, "png", baos)
+      PngImageWriter.write(baos, mergedImage);
 
       new Challenge(baos.toByteArray(), "image/png", token)
     }

src/main/scala/lc/captchas/RainDropsCaptcha.scala

@@ -11,6 +11,7 @@ import lc.captchas.interfaces.ChallengeProvider
 import lc.captchas.interfaces.Challenge
 import lc.misc.GifSequenceWriter
 import java.util.{List => JavaList, Map => JavaMap}
+import lc.misc.HelperFunctions
 
 class Drop {
   var x = 0
@@ -24,8 +25,6 @@ class Drop {
 }
 
 class RainDropsCP extends ChallengeProvider {
-  private val alphabet = "abcdefghijklmnopqrstuvwxyz"
-  private val n = 6
   private val bgColor = new Color(200, 200, 200)
   private val textColor = new Color(208, 208, 218)
   private val textHighlightColor = new Color(100, 100, 125)
@@ -38,9 +37,12 @@ class RainDropsCP extends ChallengeProvider {
 
   def supportedParameters(): JavaMap[String, JavaList[String]] = {
     JavaMap.of(
-      "supportedLevels", JavaList.of("medium", "easy"),
-      "supportedMedia", JavaList.of("image/gif"),
-      "supportedInputType", JavaList.of("text")
+      "supportedLevels",
+      JavaList.of("medium", "easy"),
+      "supportedMedia",
+      JavaList.of("image/gif"),
+      "supportedInputType",
+      JavaList.of("text")
     )
   }
 
@@ -53,11 +55,13 @@ class RainDropsCP extends ChallengeProvider {
     })
   }
 
-  def returnChallenge(): Challenge = {
+  def returnChallenge(level: String, size: String): Challenge = {
     val r = new scala.util.Random
-    val secret = LazyList.continually(r.nextInt(alphabet.size)).map(alphabet).take(n).mkString
-    val width = 450
-    val height = 100
+    val n = if (level == "easy") 4 else 6
+    val secret = HelperFunctions.randomString(n, HelperFunctions.safeAlphaNum)
+    val size2D = HelperFunctions.parseSize2D(size)
+    val width = size2D(0)
+    val height = size2D(1)
     val imgType = BufferedImage.TYPE_INT_RGB
     val xOffset = 2 + r.nextInt(3)
     val xBias = (height / 10) - 2
@@ -77,7 +81,8 @@ class RainDropsCP extends ChallengeProvider {
       xOffset
     )
 
-    val baseFont = new Font(Font.MONOSPACED, Font.BOLD, 80)
+    val fontHeight = (height * 0.5f).toInt
+    val baseFont = new Font(Font.MONOSPACED, Font.BOLD, fontHeight)
     val attributes = new java.util.HashMap[TextAttribute, Object]()
     attributes.put(TextAttribute.TRACKING, Double.box(0.2))
     attributes.put(TextAttribute.WEIGHT, TextAttribute.WEIGHT_EXTRABOLD)
@@ -114,17 +119,22 @@ class RainDropsCP extends ChallengeProvider {
         }
       }
 
-      // center the text
       g.setFont(spacedFont)
-      val textWidth = g.getFontMetrics().charsWidth(secret.toCharArray, 0, secret.toCharArray.length)
-      val textX = (width - textWidth) / 2
+      val textWidth = g.getFontMetrics().stringWidth(secret)
+      val scaleX = if (textWidth > width) width / textWidth.toDouble else 1.0d
+      g.scale(scaleX, 1)
 
-      // paint the top outline
+      // center the text
+      val textX = if (textWidth > width) 0 else ((width - textWidth) / 2)
+
+      // this will be overlapped by the following text to show the top outline because of the offset
+      val yOffset = (fontHeight * 0.01).ceil.toInt
       g.setColor(textHighlightColor)
-      g.drawString(secret, textX, 69)
+      g.drawString(secret, textX, (fontHeight * 1.1).toInt - yOffset)
+
       // paint the text
       g.setColor(textColor)
-      g.drawString(secret, textX, 70)
+      g.drawString(secret, textX, (fontHeight * 1.1).toInt)
 
       g.dispose()
       writer.writeToSequence(canvas)

src/main/scala/lc/core/captchaFields.scala

@@ -10,7 +10,7 @@ object ParametersEnum extends Enumeration {
   val ALLOWEDLEVELS: Value = Value("allowedLevels")
   val ALLOWEDMEDIA: Value = Value("allowedMedia")
   val ALLOWEDINPUTTYPE: Value = Value("allowedInputType")
-
+  val ALLOWEDSIZES: Value = Value("allowedSizes")
 }
 
 object AttributesEnum extends Enumeration {
@@ -19,10 +19,14 @@ object AttributesEnum extends Enumeration {
   val NAME: Value = Value("name")
   val RANDOM_SEED: Value = Value("randomSeed")
   val PORT: Value = Value("port")
+  val ADDRESS: Value = Value("address")
   val CAPTCHA_EXPIRY_TIME_LIMIT: Value = Value("captchaExpiryTimeLimit")
-  val THROTTLE: Value = Value("throttle")
+  val BUFFER_COUNT: Value = Value("bufferCount")
   val THREAD_DELAY: Value = Value("threadDelay")
+  val PLAYGROUND_ENABLED: Value = Value("playgroundEnabled")
+  val CORS_HEADER: Value = Value("corsHeader")
   val CONFIG: Value = Value("config")
+  val MAX_ATTEMPTS_RATIO: Value = Value("maxAttemptsRatio")
 }
 
 object ResultEnum extends Enumeration {

src/main/scala/lc/core/captchaManager.scala

@@ -1,15 +1,12 @@
 package lc.core
 
-import java.sql.ResultSet
-import java.util.UUID
-import java.io.ByteArrayInputStream
+import lc.captchas.interfaces.{Challenge, ChallengeProvider}
 import lc.database.Statements
-import lc.core.CaptchaProviders
-import lc.captchas.interfaces.ChallengeProvider
-import lc.captchas.interfaces.Challenge
-import java.sql.Blob
+import java.io.ByteArrayInputStream
+import java.sql.{Blob, ResultSet}
+import java.util.UUID
 
-object Captcha {
+class CaptchaManager(config: Config, captchaProviders: CaptchaProviders) {
 
   def getCaptcha(id: Id): Either[Error, Image] = {
     val blob = getImage(id.id)
@@ -37,17 +34,19 @@ object Captcha {
   }
 
   def generateChallenge(param: Parameters): Option[Int] = {
-    val provider = CaptchaProviders.getProvider(param)
-    provider match {
-      case Some(value) => {
-        val providerId = value.getId()
-        val challenge = value.returnChallenge()
+    try {
+      captchaProviders.getProvider(param).flatMap { provider =>
+        val providerId = provider.getId()
+        val challenge = provider.returnChallenge(param.level, param.size)
         val blob = new ByteArrayInputStream(challenge.content)
-        val token = insertCaptcha(value, challenge, providerId, param, blob)
+        val token = insertCaptcha(provider, challenge, providerId, param, blob)
         // println("Added new challenge: " + token.toString)
         token.map(_.toInt)
       }
-      case None => None
+    } catch {
+      case e: Exception =>
+        e.printStackTrace()
+        None
     }
   }
 
@@ -65,7 +64,8 @@ object Captcha {
     insertPstmt.setString(4, challenge.contentType)
     insertPstmt.setString(5, param.level)
     insertPstmt.setString(6, param.input_type)
-    insertPstmt.setBlob(7, blob)
+    insertPstmt.setString(7, param.size)
+    insertPstmt.setBlob(8, blob)
     insertPstmt.executeUpdate()
     val rs: ResultSet = insertPstmt.getGeneratedKeys()
     if (rs.next()) {
@@ -75,9 +75,9 @@ object Captcha {
     }
   }
 
-  val allowedInputType = Config.allowedInputType
-  val allowedLevels = Config.allowedLevels
-  val allowedMedia = Config.allowedMedia
+  val allowedInputType = config.allowedInputType
+  val allowedLevels = config.allowedLevels
+  val allowedMedia = config.allowedMedia
 
   private def validateParam(param: Parameters): Array[String] = {
     var invalid_params = Array[String]()
@@ -108,11 +108,31 @@ object Captcha {
     }
   }
 
+  def getCount(param: Parameters): Option[Int] = {
+    val countPstmt = Statements.tlStmts.get.countForParameterPstmt
+    countPstmt.setString(1, param.level)
+    countPstmt.setString(2, param.media)
+    countPstmt.setString(3, param.input_type)
+    countPstmt.setString(4, param.size.toString())
+    val rs = countPstmt.executeQuery()
+    if (rs.next()) {
+      Some(rs.getInt("count"))
+    } else {
+      None
+    }
+  }
+
   private def getToken(param: Parameters): Option[Int] = {
+    val count = getCount(param).getOrElse(0)
+    if (count == 0) {
+      None
+    } else {
       val tokenPstmt = Statements.tlStmts.get.tokenPstmt
       tokenPstmt.setString(1, param.level)
       tokenPstmt.setString(2, param.media)
       tokenPstmt.setString(3, param.input_type)
+      tokenPstmt.setString(4, param.size)
+      tokenPstmt.setInt(5, count)
       val rs = tokenPstmt.executeQuery()
       if (rs.next()) {
         Some(rs.getInt("token"))
@@ -120,6 +140,7 @@ object Captcha {
         None
       }
     }
+  }
 
   private def updateAttempted(token: Int): Unit = {
     val updateAttemptedPstmt = Statements.tlStmts.get.updateAttemptedPstmt
@@ -142,7 +163,7 @@ object Captcha {
       case None => Right(Success(ResultEnum.EXPIRED.toString))
       case Some(value) => {
         val (provider, secret) = value
-        val check = CaptchaProviders.getProviderById(provider).checkAnswer(secret, answer.answer)
+        val check = captchaProviders.getProviderById(provider).checkAnswer(secret, answer.answer)
         deleteCaptcha(answer.id)
         val result = if (check) ResultEnum.TRUE.toString else ResultEnum.FALSE.toString
         Right(Success(result))
@@ -152,7 +173,7 @@ object Captcha {
 
   private def getSecret(id: String): Option[(String, String)] = {
     val selectPstmt = Statements.tlStmts.get.selectPstmt
-    selectPstmt.setInt(1, Config.captchaExpiryTimeLimit)
+    selectPstmt.setInt(1, config.captchaExpiryTimeLimit)
     selectPstmt.setString(2, id)
     val rs: ResultSet = selectPstmt.executeQuery()
     if (rs.first()) {

src/main/scala/lc/core/captchaProviders.scala

@@ -1,12 +1,12 @@
 package lc.core
 
-import lc.captchas._
+import lc.captchas.*
 import lc.captchas.interfaces.ChallengeProvider
 import lc.captchas.interfaces.Challenge
 import scala.collection.mutable.Map
 import lc.misc.HelperFunctions
 
-object CaptchaProviders {
+class CaptchaProviders(config: Config) {
   private val providers = Map(
     "FilterChallenge" -> new FilterChallenge,
     // "FontFunCaptcha" -> new FontFunCaptcha,
@@ -18,13 +18,12 @@ object CaptchaProviders {
   )
 
   def generateChallengeSamples(): Map[String, Challenge] = {
-    providers.map {
-      case (key, provider) =>
-        (key, provider.returnChallenge())
+    providers.map { case (key, provider) =>
+      (key, provider.returnChallenge("easy", "350x100"))
     }
   }
 
-  private val config = Config.captchaConfig
+  private val captchaConfig = config.captchaConfig
 
   def getProviderById(id: String): ChallengeProvider = {
     return providers(id)
@@ -32,10 +31,11 @@ object CaptchaProviders {
 
   private def filterProviderByParam(param: Parameters): Iterable[(String, String)] = {
     val configFilter = for {
-      configValue <- config
+      configValue <- captchaConfig
       if configValue.allowedLevels.contains(param.level)
       if configValue.allowedMedia.contains(param.media)
       if configValue.allowedInputType.contains(param.input_type)
+      if configValue.allowedSizes.contains(param.size)
     } yield (configValue.name, configValue.config)
 
     val providerFilter = for {
@@ -51,7 +51,7 @@ object CaptchaProviders {
 
   def getProvider(param: Parameters): Option[ChallengeProvider] = {
     val providerConfig = filterProviderByParam(param).toList
-    if (providerConfig.length > 0) {
+    if (providerConfig.nonEmpty) {
       val randomIndex = HelperFunctions.randomNumber(providerConfig.length)
       val providerIndex = providerConfig(randomIndex)._1
       val selectedProvider = providers(providerIndex)

src/main/scala/lc/core/config.scala

@@ -4,15 +4,17 @@ import scala.io.Source.fromFile
 import org.json4s.{DefaultFormats, JValue, JObject, JField, JString}
 import org.json4s.jackson.JsonMethods.{parse, render, pretty}
 import org.json4s.JsonDSL._
+import org.json4s.StringInput
+import org.json4s.jvalue2monadic
+import org.json4s.jvalue2extractable
 import java.io.{FileNotFoundException, File, PrintWriter}
 import java.{util => ju}
 import lc.misc.HelperFunctions
 
-object Config {
+class Config(configFilePath: String) {
 
-  implicit val formats: DefaultFormats.type = DefaultFormats
+  import Config.formats
 
-  private val configFilePath = "data/config.json"
   private val configString =
     try {
       val configFile = fromFile(configFilePath)
@@ -22,7 +24,12 @@ object Config {
     } catch {
       case _: FileNotFoundException => {
         val configFileContent = getDefaultConfig()
-        val configFile = new PrintWriter(new File(configFilePath))
+        val file = if (new File(configFilePath).isDirectory) {
+          new File(configFilePath.concat("/config.json"))
+        } else {
+          new File(configFilePath)
+        }
+        val configFile = new PrintWriter(file)
         configFile.write(configFileContent)
         configFile.close
         configFileContent
@@ -34,16 +41,21 @@ object Config {
     }
 
   private val configJson = parse(configString)
+  private val configFields: ConfigField = configJson.extract[ConfigField]
 
-  val port: Int = (configJson \ AttributesEnum.PORT.toString).extract[Int]
-  val throttle: Int = (configJson \ AttributesEnum.THROTTLE.toString).extract[Int]
-  val seed: Int = (configJson \ AttributesEnum.RANDOM_SEED.toString).extract[Int]
-  val captchaExpiryTimeLimit: Int = (configJson \ AttributesEnum.CAPTCHA_EXPIRY_TIME_LIMIT.toString).extract[Int]
-  val threadDelay: Int = (configJson \ AttributesEnum.THREAD_DELAY.toString).extract[Int]
+  val port: Int = configFields.portInt.getOrElse(8888)
+  val address: String = configFields.address.getOrElse("0.0.0.0")
+  val bufferCount: Int = configFields.bufferCountInt.getOrElse(1000)
+  val seed: Int = configFields.seedInt.getOrElse(375264328)
+  val captchaExpiryTimeLimit: Int = configFields.captchaExpiryTimeLimitInt.getOrElse(5)
+  val threadDelay: Int = configFields.threadDelayInt.getOrElse(2)
+  val playgroundEnabled: Boolean = configFields.playgroundEnabledBool.getOrElse(true)
+  val corsHeader: String = configFields.corsHeader.getOrElse("")
+  val maxAttempts: Int = Math.max(1, (configFields.maxAttemptsRatioFloat.getOrElse(0.01f) * bufferCount).toInt)
 
   private val captchaConfigJson = (configJson \ "captchas")
-  val captchaConfigTransform: JValue = captchaConfigJson transformField {
-    case JField("config", JObject(config)) => ("config", JString(config.toString))
+  val captchaConfigTransform: JValue = captchaConfigJson transformField { case JField("config", JObject(config)) =>
+    ("config", JString(config.toString))
   }
   val captchaConfig: List[CaptchaConfig] = captchaConfigTransform.extract[List[CaptchaConfig]]
   val allowedLevels: Set[String] = captchaConfig.flatMap(_.allowedLevels).toSet
@@ -56,15 +68,20 @@ object Config {
     val defaultConfigMap =
       (AttributesEnum.RANDOM_SEED.toString -> new ju.Random().nextInt()) ~
         (AttributesEnum.PORT.toString -> 8888) ~
+        (AttributesEnum.ADDRESS.toString -> "0.0.0.0") ~
         (AttributesEnum.CAPTCHA_EXPIRY_TIME_LIMIT.toString -> 5) ~
-        (AttributesEnum.THROTTLE.toString -> 1000) ~
+        (AttributesEnum.BUFFER_COUNT.toString -> 1000) ~
         (AttributesEnum.THREAD_DELAY.toString -> 2) ~
+        (AttributesEnum.PLAYGROUND_ENABLED.toString -> true) ~
+        (AttributesEnum.CORS_HEADER.toString -> "") ~
+        (AttributesEnum.MAX_ATTEMPTS_RATIO.toString -> 0.01f) ~
         ("captchas" -> List(
           (
             (AttributesEnum.NAME.toString -> "FilterChallenge") ~
               (ParametersEnum.ALLOWEDLEVELS.toString -> List("medium", "hard")) ~
               (ParametersEnum.ALLOWEDMEDIA.toString -> List("image/png")) ~
               (ParametersEnum.ALLOWEDINPUTTYPE.toString -> List("text")) ~
+              (ParametersEnum.ALLOWEDSIZES.toString -> List("350x100")) ~
               (AttributesEnum.CONFIG.toString -> JObject())
           ),
           (
@@ -72,6 +89,7 @@ object Config {
               (ParametersEnum.ALLOWEDLEVELS.toString -> List("hard")) ~
               (ParametersEnum.ALLOWEDMEDIA.toString -> List("image/gif")) ~
               (ParametersEnum.ALLOWEDINPUTTYPE.toString -> List("text")) ~
+              (ParametersEnum.ALLOWEDSIZES.toString -> List("350x100")) ~
               (AttributesEnum.CONFIG.toString -> JObject())
           ),
           (
@@ -79,6 +97,7 @@ object Config {
               (ParametersEnum.ALLOWEDLEVELS.toString -> List("easy")) ~
               (ParametersEnum.ALLOWEDMEDIA.toString -> List("image/png")) ~
               (ParametersEnum.ALLOWEDINPUTTYPE.toString -> List("text")) ~
+              (ParametersEnum.ALLOWEDSIZES.toString -> List("350x100")) ~
               (AttributesEnum.CONFIG.toString -> JObject())
           ),
           (
@@ -86,6 +105,7 @@ object Config {
               (ParametersEnum.ALLOWEDLEVELS.toString -> List("easy", "medium")) ~
               (ParametersEnum.ALLOWEDMEDIA.toString -> List("image/gif")) ~
               (ParametersEnum.ALLOWEDINPUTTYPE.toString -> List("text")) ~
+              (ParametersEnum.ALLOWEDSIZES.toString -> List("350x100")) ~
               (AttributesEnum.CONFIG.toString -> JObject())
           )
         ))
@@ -94,3 +114,7 @@ object Config {
   }
 
 }
+
+object Config {
+  implicit val formats: DefaultFormats.type = DefaultFormats
+}

src/main/scala/lc/core/models.scala

@@ -5,7 +5,7 @@ import lc.core.Config.formats
 
 trait ByteConvert { def toBytes(): Array[Byte] }
 case class Size(height: Int, width: Int)
-case class Parameters(level: String, media: String, input_type: String, size: Option[Size])
+case class Parameters(level: String, media: String, input_type: String, size: String)
 case class Id(id: String) extends ByteConvert { def toBytes(): Array[Byte] = { write(this).getBytes } }
 case class Image(image: Array[Byte]) extends ByteConvert { def toBytes(): Array[Byte] = { image } }
 case class Answer(answer: String, id: String)
@@ -16,5 +16,32 @@ case class CaptchaConfig(
     allowedLevels: List[String],
     allowedMedia: List[String],
     allowedInputType: List[String],
+    allowedSizes: List[String],
     config: String
 )
+case class ConfigField(
+    port: Option[Integer],
+    address: Option[String],
+    bufferCount: Option[Integer],
+    seed: Option[Integer],
+    captchaExpiryTimeLimit: Option[Integer],
+    threadDelay: Option[Integer],
+    playgroundEnabled: Option[java.lang.Boolean],
+    corsHeader: Option[String],
+    maxAttemptsRatio: Option[java.lang.Float]
+) {
+  lazy val portInt: Option[Int] = mapInt(port)
+  lazy val bufferCountInt: Option[Int] = mapInt(bufferCount)
+  lazy val seedInt: Option[Int] = mapInt(seed)
+  lazy val captchaExpiryTimeLimitInt: Option[Int] = mapInt(captchaExpiryTimeLimit)
+  lazy val threadDelayInt: Option[Int] = mapInt(threadDelay)
+  lazy val maxAttemptsRatioFloat: Option[Float] = mapFloat(maxAttemptsRatio)
+  lazy val playgroundEnabledBool: Option[Boolean] = playgroundEnabled.map(_ || false)
+
+  private def mapInt(x: Option[Integer]): Option[Int] = {
+    x.map(_ + 0)
+  }
+  private def mapFloat(x: Option[java.lang.Float]): Option[Float] = {
+    x.map(_ + 0.0f)
+  }
+}

src/main/scala/lc/database/DB.scala

@@ -1,9 +1,10 @@
 package lc.database
 
-import java.sql._
+import java.sql.{Connection, DriverManager, Statement}
 
 class DBConn() {
-  val con: Connection = DriverManager.getConnection("jdbc:h2:./data/H2/captcha", "sa", "")
+  val con: Connection =
+    DriverManager.getConnection("jdbc:h2:./data/H2/captcha3;MAX_COMPACT_TIME=8000;DB_CLOSE_ON_EXIT=FALSE", "sa", "")
 
   def getStatement(): Statement = {
     con.createStatement()

src/main/scala/lc/database/statements.scala

@@ -17,6 +17,7 @@ class Statements(dbConn: DBConn, maxAttempts: Int) {
       "contentType varchar, " +
       "contentLevel varchar, " +
       "contentInput varchar, " +
+      "size varchar, " +
       "image blob, " +
       "attempted int default 0, " +
       "PRIMARY KEY(token));" +
@@ -37,8 +38,8 @@ class Statements(dbConn: DBConn, maxAttempts: Int) {
 
   val insertPstmt: PreparedStatement = dbConn.con.prepareStatement(
     "INSERT INTO " +
-      "challenge(id, secret, provider, contentType, contentLevel, contentInput, image) " +
-      "VALUES (?, ?, ?, ?, ?, ?, ?)",
+      "challenge(id, secret, provider, contentType, contentLevel, contentInput, size, image) " +
+      "VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
     Statement.RETURN_GENERATED_KEYS
   )
 
@@ -70,6 +71,18 @@ class Statements(dbConn: DBConn, maxAttempts: Int) {
       "WHERE token = ?;"
   )
 
+  val countForParameterPstmt: PreparedStatement = dbConn.con.prepareStatement(
+    s"""
+      SELECT count(*) as count
+        FROM challenge
+        WHERE attempted < $maxAttempts AND
+        contentLevel = ? AND
+        contentType = ? AND
+        contentInput = ? AND
+        size = ?
+        """
+  )
+
   val tokenPstmt: PreparedStatement = dbConn.con.prepareStatement(
     s"""
       SELECT token, attempted
@@ -77,8 +90,11 @@ class Statements(dbConn: DBConn, maxAttempts: Int) {
         WHERE attempted < $maxAttempts AND
         contentLevel = ? AND
         contentType = ? AND
-        contentInput = ?
-        ORDER BY attempted ASC LIMIT 1"""
+        contentInput = ? AND
+        size = ?
+        LIMIT 1
+        OFFSET FLOOR(RAND()*?)
+         """
   )
 
   val deleteAnswerPstmt: PreparedStatement = dbConn.con.prepareStatement(
@@ -107,6 +123,14 @@ class Statements(dbConn: DBConn, maxAttempts: Int) {
     "SELECT * FROM mapId"
   )
 
+  val shutdown: PreparedStatement = dbConn.con.prepareStatement(
+    "SHUTDOWN"
+  )
+
+  val shutdownCompact: PreparedStatement = dbConn.con.prepareStatement(
+    "SHUTDOWN COMPACT"
+  )
+
 }
 
 object Statements {
@@ -118,6 +142,6 @@ object Statements {
      ```
    */
   private val dbConn: DBConn = new DBConn()
-  private val maxAttempts = 10
+  var maxAttempts: Int = 10
   val tlStmts: ThreadLocal[Statements] = ThreadLocal.withInitial(() => new Statements(dbConn, maxAttempts))
 }

src/main/scala/lc/server/Server.scala

@@ -1,53 +1,67 @@
 package lc.server
 
 import org.json4s.jackson.JsonMethods.parse
-import lc.core.Captcha
+import org.json4s.jvalue2extractable
+import lc.core.CaptchaManager
 import lc.core.ErrorMessageEnum
-import lc.core.{Parameters, Id, Answer, Error, ByteConvert}
+import lc.core.{Answer, ByteConvert, Error, Id, Parameters}
 import lc.core.Config.formats
 import org.limium.picoserve
-import org.limium.picoserve.Server.ByteResponse
+import org.limium.picoserve.Server.{ByteResponse, ServerBuilder, StringResponse}
 import scala.io.Source
-import org.limium.picoserve.Server.StringResponse
+import java.net.InetSocketAddress
+import java.util
+import scala.jdk.CollectionConverters._
 
-class Server(port: Int) {
-  val server: picoserve.Server = picoserve.Server
+class Server(
+    address: String,
+    port: Int,
+    captchaManager: CaptchaManager,
+    playgroundEnabled: Boolean,
+    corsHeader: String
+) {
+  var headerMap: util.Map[String, util.List[String]] = _
+  if (corsHeader.nonEmpty) {
+    headerMap = Map("Access-Control-Allow-Origin" -> List(corsHeader).asJava).asJava
+  }
+  val serverBuilder: ServerBuilder = picoserve.Server
     .builder()
-    .port(port)
+    .address(new InetSocketAddress(address, port))
     .backlog(32)
     .POST(
-      "/v1/captcha",
+      "/v2/captcha",
       (request) => {
         val json = parse(request.getBodyString())
         val param = json.extract[Parameters]
-        val id = Captcha.getChallenge(param)
-        getResponse(id)
+        val id = captchaManager.getChallenge(param)
+        getResponse(id, headerMap)
       }
     )
     .GET(
-      "/v1/media",
+      "/v2/media",
       (request) => {
         val params = request.getQueryParams()
         val result = if (params.containsKey("id")) {
           val paramId = params.get("id").get(0)
           val id = Id(paramId)
-          Captcha.getCaptcha(id)
+          captchaManager.getCaptcha(id)
         } else {
           Left(Error(ErrorMessageEnum.INVALID_PARAM.toString + "=> id"))
         }
-        getResponse(result)
+        getResponse(result, headerMap)
       }
     )
     .POST(
-      "/v1/answer",
+      "/v2/answer",
       (request) => {
         val json = parse(request.getBodyString())
         val answer = json.extract[Answer]
-        val result = Captcha.checkAnswer(answer)
-        getResponse(result)
+        val result = captchaManager.checkAnswer(answer)
+        getResponse(result, headerMap)
       }
     )
-    .GET(
+  if (playgroundEnabled) {
+    serverBuilder.GET(
       "/demo/index.html",
       (_) => {
         val resStream = getClass().getResourceAsStream("/index.html")
@@ -55,21 +69,40 @@ class Server(port: Int) {
         new StringResponse(200, str)
       }
     )
-    .build()
+    serverBuilder.GET(
+      "/",
+      (_) => {
+        val str = """
+        <html>
+          <h2>Welcome to LibreCaptcha server</h2>
+          <h3><a href="/demo/index.html">Link to Demo</a></h3>
+          <h3>API is served at <b>/v2/</b></h3>
+        </html>
+        """
+        new StringResponse(200, str)
+      }
+    )
+    println("Playground enabled on /demo/index.html")
+  }
 
-  private def getResponse(response: Either[Error, ByteConvert]): ByteResponse = {
+  val server: picoserve.Server = serverBuilder.build()
+
+  private def getResponse(
+      response: Either[Error, ByteConvert],
+      responseHeaders: util.Map[String, util.List[String]]
+  ): ByteResponse = {
     response match {
       case Right(value) => {
-        new ByteResponse(200, value.toBytes())
+        new ByteResponse(200, value.toBytes(), responseHeaders)
       }
       case Left(value) => {
-        new ByteResponse(500, value.toBytes())
+        new ByteResponse(500, value.toBytes(), responseHeaders)
       }
     }
   }
 
   def start(): Unit = {
-    println("Starting server on port:" + port)
+    println("Starting server on " + address + ":" + port)
     server.start()
   }
 }

tests/debug-config.json

@@ -1,14 +1,19 @@
 {
   "randomSeed" : 20,
   "port" : 8888,
+  "address" : "0.0.0.0",
   "captchaExpiryTimeLimit" : 5,
-  "throttle" : 10,
+  "bufferCount" : 10,
   "threadDelay" : 2,
+  "playgroundEnabled" : false,
+  "corsHeader" : "*",
+  "maxAttemptsRatio" : 0.01,
   "captchas" : [ {
     "name" : "DebugCaptcha",
     "allowedLevels" : [ "debug" ],
     "allowedMedia" : [ "image/png" ],
     "allowedInputType" : [ "text" ],
+    "allowedSizes" : [ "350x100" ],
     "config" : { }
   }]
 }

tests/locustfile-functional.py

@@ -22,9 +22,9 @@ class QuickStartUser(SequentialTaskSet):
 
     @task
     def captcha(self):
-        captcha_params = {"level":"debug","media":"image/png","input_type":"text"}
+        captcha_params = {"level":"debug","media":"image/png","input_type":"text", "size":"350x100"}
 
-        with self.client.post(path="/v1/captcha", json=captcha_params, name="/captcha", catch_response = True) as resp:
+        with self.client.post(path="/v2/captcha", json=captcha_params, name="/captcha", catch_response = True) as resp:
           if resp.status_code != 200:
             resp.failure("Status was not 200: " + resp.text)
           captchaJson = resp.json()
@@ -32,7 +32,7 @@ class QuickStartUser(SequentialTaskSet):
           if not uuid:
             resp.failure("uuid not returned on /captcha endpoint: " + resp.text)
 
-        with self.client.get(path="/v1/media?id=%s" % uuid, name="/media", stream=True, catch_response = True) as resp:
+        with self.client.get(path="/v2/media?id=%s" % uuid, name="/media", stream=True, catch_response = True) as resp:
           if resp.status_code != 200:
             resp.failure("Status was not 200: " + resp.text)
 
@@ -41,7 +41,7 @@ class QuickStartUser(SequentialTaskSet):
         ocrAnswer = self.solve(uuid, media)
 
         answerBody = {"answer": ocrAnswer,"id": uuid}
-        with self.client.post(path='/v1/answer', json=answerBody, name="/answer", catch_response=True) as resp:
+        with self.client.post(path='/v2/answer', json=answerBody, name="/answer", catch_response=True) as resp:
           if resp.status_code != 200:
               resp.failure("Status was not 200: " + resp.text)
           else:

tests/locustfile.py

@@ -24,9 +24,9 @@ class QuickStartUser(SequentialTaskSet):
     @task
     def captcha(self):
         # TODO: Iterate over parameters for a more comprehensive test
-        captcha_params = {"level":"easy","media":"image/png","input_type":"text"}
+        captcha_params = {"level":"easy","media":"image/png","input_type":"text", "size":"350x100"}
 
-        resp = self.client.post(path="/v1/captcha", json=captcha_params, name="/captcha")
+        resp = self.client.post(path="/v2/captcha", json=captcha_params, name="/captcha")
         if resp.status_code != 200:
             print("\nError on /captcha endpoint: ")
             print(resp)
@@ -36,14 +36,14 @@ class QuickStartUser(SequentialTaskSet):
         uuid = json.loads(resp.text).get("id")
         answerBody = {"answer": "qwer123","id": uuid}
 
-        resp = self.client.get(path="/v1/media?id=%s" % uuid, name="/media")
+        resp = self.client.get(path="/v2/media?id=%s" % uuid, name="/media")
         if resp.status_code != 200:
             print("\nError on /media endpoint: ")
             print(resp)
             print(resp.text)
             print("----------------END.MEDIA-------------------\n\n")
 
-        resp = self.client.post(path='/v1/answer', json=answerBody, name="/answer")
+        resp = self.client.post(path='/v2/answer', json=answerBody, name="/answer")
         if resp.status_code != 200:
             print("\nError on /answer endpoint: ")
             print(resp)

tests/run.sh

@@ -4,7 +4,7 @@ python3 -m venv testEnv
 source ./testEnv/bin/activate
 pip install locust
 mkdir -p data/
-java -jar target/scala-2.13/LibreCaptcha.jar &
+java -jar target/scala-3.6.2/LibreCaptcha.jar &
 JAVA_PID=$!
 sleep 4
 
@@ -22,7 +22,7 @@ echo Run functional test
 cp data/config.json data/config.json.bak
 cp tests/debug-config.json data/config.json
 
-java -jar target/scala-2.13/LibreCaptcha.jar &
+java -jar target/scala-3.6.2/LibreCaptcha.jar &
 JAVA_PID=$!
 sleep 4