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

@@ -54,6 +54,10 @@ jobs:
           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,3 +1,3 @@
-version="3.0.5" 
+version="3.8.3" 
 maxColumn = 120
-runner.dialect = scala213source3
+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

@@ -2,12 +2,12 @@
 LibreCaptcha is a framework that allows developers to create their own [CAPTCHA](https://en.wikipedia.org/wiki/CAPTCHA)s.
 The framework defines the API for a CAPTCHA generator and takes care of mundane details
 such as:
-  * An HTTP interface for serving CAPTCHAs
-  * Background workers to pre-compute CAPTCHAs and to store them in a database
-  * Managing secrets for the CAPTCHAs (tokens, expected answers, etc)
-  * Safe re-impressions of CAPTCHA images (by creating unique tokens for every impression)
-  * Garbage collection of stale CAPTCHAs
-  * Sandboxed plugin architecture (TBD)
+* An HTTP interface for serving CAPTCHAs
+* Background workers to pre-compute CAPTCHAs and to store them in a database
+* Managing secrets for the CAPTCHAs (tokens, expected answers, etc)
+* Safe re-impressions of CAPTCHA images (by creating unique tokens for every impression)
+* Garbage collection of stale CAPTCHAs
+* Sandboxed plugin architecture (TBD)
 
 Some sample CAPTCHA generators are included in the distribution (see below). We will continue adding more samples to the list. For quick
 deployments the samples themselves might be sufficient. Projects with more resources might want create their own CAPTCHAs
@@ -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
 
@@ -119,7 +131,7 @@ If a sufficient number of users agree on their answer to the unknown word, it is
 The service can be accessed using a simple HTTP API.
 
 ### - `/v1/captcha`: `POST`
-  - Parameters:
+- Parameters:
     - `level`: `String` -
       The difficulty level of a captcha
         - easy
@@ -134,29 +146,29 @@ The service can be accessed using a simple HTTP API.
         - 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.
 
-  - Returns:
+- Returns:
     - `id`: `String` - The uuid of the captcha generated
 
 
 ### - `/v1/media`: `GET`
-  - Parameters:
+- Parameters:
     - `id`: `String` - The uuid of the captcha
 
-  - Returns:
+- Returns:
     - `image`: `Array[Byte]` - The requested media as bytes
 
 
 ### - `/v1/answer`: `POST`
-  - Parameter:
+- Parameter:
     - `id`: `String` - The uuid of the captcha that needs to be solved
     - `answer`: `String` - The answer to the captcha that needs to be validated
 
-  - Returns:
+- Returns:
     - `result`: `String` - The result after validation/checking of the answer
         - True - If the answer is correct
         - False - If the answer is incorrect
@@ -168,9 +180,9 @@ The service can be accessed using a simple HTTP API.
 In javascript:
 
 ```js
-const resp = await fetch("/v1/captcha", {
+const resp = await fetch("/v2/captcha", {
     method: 'POST',
-   body: JSON.stringify({level: "easy", media: "image/png", "input_type" : "text"})
+    body: JSON.stringify({level: "easy", media: "image/png", "input_type" : "text", size: "350x100"})
 })
 
 const respJson = await resp.json();
@@ -188,7 +200,7 @@ if (resp.ok) {
 
 
 // When user submits an answer it can be sent to the server for verification thusly:
-const resp = await fetch("/v1/answer", {
+const resp = await fetch("/v2/answer", {
     method: 'POST',
     body: JSON.stringify({id: captchaId, answer: "user input"})
 });

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,25 +2,24 @@ lazy val root = (project in file(".")).settings(
   inThisBuild(
     List(
       organization := "com.example",
-      scalaVersion := "2.13.7",
-      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.24",
-  libraryDependencies += "com.sksamuel.scrimage" % "scrimage-filters" % "4.0.24",
-  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",
-  "-Xsource:3"
+  "-deprecation"
 )
 javacOptions += "-g:none"
 compileOrder := CompileOrder.JavaThenScala
@@ -29,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.5
+sbt.version=1.10.6

project/plugins.sbt

@@ -1,4 +1,4 @@
-addSbtPlugin("ch.epfl.scala" % "sbt-scalafix" % "0.9.33")
-addSbtPlugin("org.scalameta" % "sbt-scalafmt" % "2.4.5")
-addSbtPlugin("com.lightbend.sbt" % "sbt-java-formatter" % "0.7.0")
-addSbtPlugin("com.eed3si9n" % "sbt-assembly" % "1.1.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

@@ -5,12 +5,12 @@ 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.PngImageWriter;
 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);
@@ -81,10 +82,14 @@ public class FontFunCaptcha implements ChallengeProvider {
     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 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 lc.misc.PngImageWriter;
+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,32 +35,43 @@ 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 {
@@ -74,8 +82,11 @@ public class ShadowTextCaptcha implements ChallengeProvider {
     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

@@ -11,7 +11,14 @@ public class HelperFunctions {
     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);

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

@@ -1,9 +1,9 @@
 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;
@@ -13,7 +13,6 @@ import javax.imageio.metadata.IIOInvalidTreeException;
 import javax.imageio.metadata.IIOMetadata;
 import javax.imageio.metadata.IIOMetadataNode;
 import javax.imageio.stream.ImageOutputStream;
-import java.awt.image.BufferedImage;
 
 public class PngImageWriter {
 
@@ -26,7 +25,8 @@ public class PngImageWriter {
         iw.hasNext(); ) {
       ImageWriter writer = iw.next();
       ImageWriteParam writeParam = writer.getDefaultWriteParam();
-      ImageTypeSpecifier typeSpecifier = ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_INT_RGB);
+      ImageTypeSpecifier typeSpecifier =
+          ImageTypeSpecifier.createFromBufferedImageType(BufferedImage.TYPE_INT_RGB);
       IIOMetadata metadata = writer.getDefaultImageMetadata(typeSpecifier, writeParam);
       if (metadata.isReadOnly() || !metadata.isStandardMetadataFormatSupported()) {
         continue;

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,29 +1,45 @@
 package lc
 
-import lc.core.{CaptchaProviders, Captcha, Config}
+import lc.core.{CaptchaProviders, CaptchaManager, Config}
 import lc.server.Server
 import lc.background.BackgroundTask
+import lc.database.Statements
 
 object LCFramework {
   def main(args: scala.Array[String]): Unit = {
-    val configFilePath = if (args.length > 0){
+    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 captcha = new Captcha(config = config, captchaProviders = captchaProviders)
-    val backgroundTask = new BackgroundTask(config = config, captcha = captcha)
+    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, captcha = captcha, playgroundEnabled = config.playgroundEnabled, corsHeader = config.corsHeader)
+    val server = new Server(
+      address = config.address,
+      port = config.port,
+      captchaManager = captchaManager,
+      playgroundEnabled = config.playgroundEnabled,
+      corsHeader = config.corsHeader
+    )
+
+    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 configFilePath = if (args.length > 0){
+    val configFilePath = if (args.length > 0) {
       args(0)
     } else {
       "data/config.json"
@@ -31,8 +47,7 @@ object MakeSamples {
     val config = new Config(configFilePath)
     val captchaProviders = new CaptchaProviders(config = config)
     val samples = captchaProviders.generateChallengeSamples()
-    samples.foreach {
-      case (key, sample) =>
+    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,11 +2,11 @@ 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(config: Config, captcha: Captcha) {
+class BackgroundTask(config: Config, captchaManager: CaptchaManager) {
 
   private val task = new Runnable {
     def run(): Unit = {
@@ -18,34 +18,73 @@ class BackgroundTask(config: Config, captcha: Captcha) {
         val challengeGCPstmt = Statements.tlStmts.get.challengeGCPstmt
         challengeGCPstmt.executeUpdate()
 
-        val imageNum = Statements.tlStmts.get.getCountChallengeTable.executeQuery()
-        var throttleIn = (config.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 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

@@ -13,7 +13,9 @@ 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,14 +45,14 @@ 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()
@@ -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

@@ -10,6 +10,7 @@ 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"
@@ -20,37 +21,47 @@ 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)
+    val s = r.nextInt(2)
+    image = filterTypes(s).applyFilter(image, !mediumLevel)
     val img = image.awt()
     val baos = new ByteArrayOutputStream()
-    try {
     PngImageWriter.write(baos, img);
-    } catch {
-      case e: Exception =>
-        e.printStackTrace()
-    }
     new Challenge(baos.toByteArray, "image/png", secret)
   }
   def checkAnswer(secret: String, answer: String): Boolean = {
@@ -59,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)
@@ -75,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

@@ -31,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)

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 {
@@ -21,11 +21,12 @@ object AttributesEnum extends Enumeration {
   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
 
-class Captcha(config: Config, captchaProviders: CaptchaProviders) {
+class CaptchaManager(config: Config, captchaProviders: CaptchaProviders) {
 
   def getCaptcha(id: Id): Either[Error, Image] = {
     val blob = getImage(id.id)
@@ -37,17 +34,19 @@ class Captcha(config: Config, captchaProviders: CaptchaProviders) {
   }
 
   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 @@ class Captcha(config: Config, captchaProviders: CaptchaProviders) {
     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()) {
@@ -108,11 +108,31 @@ class Captcha(config: Config, captchaProviders: CaptchaProviders) {
     }
   }
 
+  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 @@ class Captcha(config: Config, captchaProviders: CaptchaProviders) {
         None
       }
     }
+  }
 
   private def updateAttempted(token: Int): Unit = {
     val updateAttemptedPstmt = Statements.tlStmts.get.updateAttemptedPstmt

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

@@ -1,6 +1,6 @@
 package lc.core
 
-import lc.captchas._
+import lc.captchas.*
 import lc.captchas.interfaces.ChallengeProvider
 import lc.captchas.interfaces.Challenge
 import scala.collection.mutable.Map
@@ -9,18 +9,17 @@ import lc.misc.HelperFunctions
 class CaptchaProviders(config: Config) {
   private val providers = Map(
     "FilterChallenge" -> new FilterChallenge,
-    //"FontFunCaptcha" -> new FontFunCaptcha,
+    // "FontFunCaptcha" -> new FontFunCaptcha,
     "PoppingCharactersCaptcha" -> new PoppingCharactersCaptcha,
     "ShadowTextCaptcha" -> new ShadowTextCaptcha,
     "RainDropsCaptcha" -> new RainDropsCP,
     "DebugCaptcha" -> new DebugCaptcha
-    //"LabelCaptcha" -> new LabelCaptcha
+    // "LabelCaptcha" -> new LabelCaptcha
   )
 
   def generateChallengeSamples(): Map[String, Challenge] = {
-    providers.map {
-      case (key, provider) =>
-        (key, provider.returnChallenge())
+    providers.map { case (key, provider) =>
+      (key, provider.returnChallenge("easy", "350x100"))
     }
   }
 
@@ -36,6 +35,7 @@ class CaptchaProviders(config: Config) {
       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 @@ class CaptchaProviders(config: Config) {
 
   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,6 +4,9 @@ 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
@@ -21,7 +24,7 @@ class Config(configFilePath: String) {
     } catch {
       case _: FileNotFoundException => {
         val configFileContent = getDefaultConfig()
-        val file = if(new File(configFilePath).isDirectory){
+        val file = if (new File(configFilePath).isDirectory) {
           new File(configFilePath.concat("/config.json"))
         } else {
           new File(configFilePath)
@@ -38,19 +41,21 @@ class Config(configFilePath: String) {
     }
 
   private val configJson = parse(configString)
+  private val configFields: ConfigField = configJson.extract[ConfigField]
 
-  val port: Int = (configJson \ AttributesEnum.PORT.toString).extract[Int]
-  val address: String = (configJson \ AttributesEnum.ADDRESS.toString).extract[String]
-  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 playgroundEnabled: Boolean = (configJson \ AttributesEnum.PLAYGROUND_ENABLED.toString).extract[Boolean]
-  val corsHeader: String = (configJson \ AttributesEnum.CORS_HEADER.toString).extract[String]
+  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
@@ -65,16 +70,18 @@ class Config(configFilePath: String) {
         (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())
           ),
           (
@@ -82,6 +89,7 @@ class Config(configFilePath: String) {
               (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())
           ),
           (
@@ -89,6 +97,7 @@ class Config(configFilePath: String) {
               (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())
           ),
           (
@@ -96,6 +105,7 @@ class Config(configFilePath: String) {
               (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())
           )
         ))
@@ -105,6 +115,6 @@ class Config(configFilePath: String) {
 
 }
 
-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/captcha2", "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,7 +1,8 @@
 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.{Answer, ByteConvert, Error, Id, Parameters}
 import lc.core.Config.formats
@@ -12,9 +13,15 @@ import java.net.InetSocketAddress
 import java.util
 import scala.jdk.CollectionConverters._
 
-class Server(address: String, port: Int, captcha: Captcha, playgroundEnabled: Boolean, corsHeader: String) {
+class Server(
+    address: String,
+    port: Int,
+    captchaManager: CaptchaManager,
+    playgroundEnabled: Boolean,
+    corsHeader: String
+) {
   var headerMap: util.Map[String, util.List[String]] = _
-  if( corsHeader.nonEmpty ) {
+  if (corsHeader.nonEmpty) {
     headerMap = Map("Access-Control-Allow-Origin" -> List(corsHeader).asJava).asJava
   }
   val serverBuilder: ServerBuilder = picoserve.Server
@@ -22,22 +29,22 @@ class Server(address: String, port: Int, captcha: Captcha, playgroundEnabled: Bo
     .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)
+        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"))
         }
@@ -45,15 +52,15 @@ class Server(address: String, port: Int, captcha: Captcha, playgroundEnabled: Bo
       }
     )
     .POST(
-      "/v1/answer",
+      "/v2/answer",
       (request) => {
         val json = parse(request.getBodyString())
         val answer = json.extract[Answer]
-        val result = captcha.checkAnswer(answer)
+        val result = captchaManager.checkAnswer(answer)
         getResponse(result, headerMap)
       }
     )
-  if( playgroundEnabled ) {
+  if (playgroundEnabled) {
     serverBuilder.GET(
       "/demo/index.html",
       (_) => {
@@ -62,11 +69,28 @@ class Server(address: String, port: Int, captcha: Captcha, playgroundEnabled: Bo
         new StringResponse(200, str)
       }
     )
+    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")
   }
 
   val server: picoserve.Server = serverBuilder.build()
 
-  private def getResponse(response: Either[Error, ByteConvert], responseHeaders: util.Map[String, util.List[String]]): ByteResponse = {
+  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(), responseHeaders)

tests/debug-config.json

@@ -3,15 +3,17 @@
   "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