initial rewrite

.gitignore

@@ -1,9 +1,3 @@
-# Nix #
-/result
-
-# Direnv #
-/.direnv/
-
 # Python #
 # Virtual Environment
 /.venv/
@@ -19,6 +13,18 @@ __pycache__/
 /.pytest_cache/
 /.mypy_cache/
 
+# Nix #
+
+# Build
+/result
+
+# MicroVM
+/var.img
+/control.socket
+
+# Direnv #
+/.direnv/
+
 # Project specific files #
 config.json
 db.json

Dockerfile

@@ -1,28 +0,0 @@
-# Nix builder
-FROM nixos/nix:latest AS builder
-
-# Copy our source and setup our working dir.
-COPY . /tmp/build
-WORKDIR /tmp/build
-
-# Build our Nix environment
-RUN nix \
-    --extra-experimental-features "nix-command flakes" \
-    --option filter-syscalls false \
-    build
-
-# Copy the Nix store closure into a directory. The Nix store closure is the
-# entire set of Nix store values that we need for our build.
-RUN mkdir /tmp/nix-store-closure
-RUN cp -r $(nix-store -qR result/) /tmp/nix-store-closure
-
-# Final image is based on scratch. We copy a bunch of Nix dependencies
-# but they're fully self-contained so we don't need Nix anymore.
-FROM scratch
-
-WORKDIR /app
-
-# Copy /nix/store
-COPY --from=builder /tmp/nix-store-closure /nix/store
-COPY --from=builder /tmp/build/result /app
-CMD ["/app/bin/testdata"]

README.md

@@ -1,15 +1,19 @@
-# Simple Testdata Generator
+# Simple Test Data Generator
 
 ## Example Config
 
 ```json
 {
-    "keys": ["TESTKEY1", "TESTKEY2", "TESTKEY3"],
+    "binds": [
-    "max-size": "1GiB",
+        "127.0.0.1:9250"
-    "max-data": "1TiB",
+    ],
-    "buffer-size": "12MiB",
+    "log": "-",
-    "database": "./db.json",
+    "buffer-size": "4KiB",
-    "database-update-interval": 5.0,
+    "max-size": "2GB",
-    "log": "./log.jsonl"
+    "keys": [
+        "TESTKEY"
+    ],
+    "max-data": "10GB",
+    "database": "database.json"
 }
 ```

docker-compose.yaml

@@ -1,15 +0,0 @@
-services:
-  testdata:
-    image: result/latest
-
-    build:
-      dockerfile: ./Dockerfile
-
-    environment:
-          TESTDATA_HOST: 0.0.0.0
-          TESTDATA_PORT: 1234
-          TESTDATA_CONFIG: ./config.json
-    volumes:
-      - ./config.json:/app/config.json
-      - ./db.json:/app/db.json
-      - ./log.jsonl:/app/log.jsonl

flake.lock

@@ -27,11 +27,11 @@
         "spectrum": "spectrum"
       },
       "locked": {
-        "lastModified": 1748464257,
+        "lastModified": 1735074045,
-        "narHash": "sha256-PdnQSE2vPfql9WEjunj2qQnDpuuvk7HH+4djgXJSwFs=",
+        "narHash": "sha256-CeYsC8J2dNiV2FCQOxK1oZ/jNpOF2io7aCEFHmfi95U=",
         "owner": "astro",
         "repo": "microvm.nix",
-        "rev": "e238645b6f0447a2eb1d538d300d5049d4006f9f",
+        "rev": "2ae08de8e8068b00193b9cfbc0acc9dfdda03181",
         "type": "github"
       },
       "original": {
@@ -42,15 +42,15 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1748370509,
+        "lastModified": 1735471104,
-        "narHash": "sha256-QlL8slIgc16W5UaI3w7xHQEP+Qmv/6vSNTpoZrrSlbk=",
+        "narHash": "sha256-0q9NGQySwDQc7RhAV2ukfnu7Gxa5/ybJ2ANT8DQrQrs=",
-        "owner": "NixOS",
+        "owner": "nixos",
         "repo": "nixpkgs",
-        "rev": "4faa5f5321320e49a78ae7848582f684d64783e9",
+        "rev": "88195a94f390381c6afcdaa933c2f6ff93959cb4",
         "type": "github"
       },
       "original": {
-        "owner": "NixOS",
+        "owner": "nixos",
         "ref": "nixos-unstable",
         "repo": "nixpkgs",
         "type": "github"
@@ -65,11 +65,11 @@
     "spectrum": {
       "flake": false,
       "locked": {
-        "lastModified": 1746869549,
+        "lastModified": 1733308308,
-        "narHash": "sha256-BKZ/yZO/qeLKh9YqVkKB6wJiDQJAZNN5rk5NsMImsWs=",
+        "narHash": "sha256-+RcbMAjSxV1wW5UpS9abIG1lFZC8bITPiFIKNnE7RLs=",
         "ref": "refs/heads/main",
-        "rev": "d927e78530892ec8ed389e8fae5f38abee00ad87",
+        "rev": "80c9e9830d460c944c8f730065f18bb733bc7ee2",
-        "revCount": 862,
+        "revCount": 792,
         "type": "git",
         "url": "https://spectrum-os.org/git/spectrum"
       },

flake.nix

@@ -2,7 +2,7 @@
   description = "A webserver to create files for testing purposes";
 
   inputs = {
-    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
+    nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";
 
     microvm = {
       url = "github:astro/microvm.nix";
@@ -10,92 +10,163 @@
     };
   };
 
-  outputs =
+  outputs = {
-    {
+    self,
-      self,
+    nixpkgs,
-      nixpkgs,
+    ...
-      ...
+  } @ inputs: let
-    }@inputs:
+    supportedSystems = ["x86_64-linux" "x86_64-darwin" "aarch64-linux" "aarch64-darwin"];
-    let
+    forAllSystems = nixpkgs.lib.genAttrs supportedSystems;
-      supportedSystems = [ "x86_64-linux" ];
+    pkgs = forAllSystems (system: nixpkgs.legacyPackages.${system}.extend overlay);
-      forAllSystems = nixpkgs.lib.genAttrs supportedSystems;
+
-      pkgs = forAllSystems (system: nixpkgs.legacyPackages.${system});
+    overlay = final: prev: rec {
-    in
+      python3Packages = prev.python3Packages.overrideScope (pfinal: pprev: {
-    {
+        packageNameToDrv = x: builtins.getAttr (cleanPythonPackageName x) final.python3Packages;
-      # `nix build`
-      packages = forAllSystems (system: rec {
-        default = testdata;
-        testdata = pkgs.${system}.callPackage ./nix/package.nix { src = ./.; };
-        vm = self.nixosConfigurations.vm.config.microvm.declaredRunner;
       });
 
-      # `nix develop`
+      cleanPythonPackageName = x: let
-      devShells = forAllSystems (system: rec {
+        cleanName = builtins.match "([a-z,A-Z,0-9,_,-]+).*" x;
-        default = venv;
+      in
+        if cleanName != null
+        then builtins.elemAt cleanName 0
+        else builtins.warn "Could not determine package name from '${x}'" null;
+    };
 
-        venv = pkgs.${system}.mkShell {
+    pyproject = builtins.fromTOML (builtins.readFile ./pyproject.toml);
-          shellHook = ''
-            if [ ! -d .venv/ ]; then
-              echo "Creating Virtual Environment..."
-              ${pkgs.${system}.python3}/bin/python3 -m venv .venv
-            fi
 
-            alias activate='source .venv/bin/activate'
+    buildDependencies = forAllSystems (system: builtins.map pkgs.${system}.python3Packages.packageNameToDrv pyproject.build-system.requires);
+    runtimeDependencies = forAllSystems (system: builtins.map pkgs.${system}.python3Packages.packageNameToDrv pyproject.project.dependencies);
+    optionalDependencies = forAllSystems (system: builtins.mapAttrs (name: value: builtins.map pkgs.${system}.python3Packages.packageNameToDrv value) pyproject.project.optional-dependencies);
+  in {
+    # `nix build`
+    packages = forAllSystems (system: let
+      buildTestdata = {skipCheck ? false}:
+        pkgs.${system}.python3Packages.buildPythonPackage {
+          pname = pyproject.project.name;
+          version = pyproject.project.version;
+          src = ./.;
 
-            echo "Entering Virtual Environment..."
+          pyproject = true;
-            source .venv/bin/activate
+
+          build-system = buildDependencies.${system};
+
+          dependencies = runtimeDependencies.${system};
+
+          optional-dependencies = optionalDependencies.${system};
+
+          nativeCheckInputs = optionalDependencies.${system}.dev;
+
+          checkPhase = let
+            dev = builtins.map (x: x.pname) optionalDependencies.${system}.dev;
+          in ''
+            ${
+              if builtins.elem "pytest" dev && !skipCheck
+              then "pytest src tests"
+              else ""
+            }
+            ${
+              if builtins.elem "mypy" dev && !skipCheck
+              then "mypy src tests"
+              else ""
+            }
+            ${
+              if builtins.elem "pylint" dev && !skipCheck
+              then "pylint src tests"
+              else ""
+            }
           '';
         };
-      });
+    in rec {
+      default = testdata;
+      testdata = buildTestdata {skipCheck = false;};
+      quick = buildTestdata {skipCheck = true;};
+      vm = self.nixosConfigurations.vm.config.microvm.declaredRunner;
+    });
 
-      # NixOS Module
+    # `nix fmt`
-      nixosModules.default = import ./nix/module.nix inputs;
+    formatter = forAllSystems (system: pkgs.${system}.alejandra);
 
-      # NixOS definition for a microvm to test nixosModules
+    # `nix develop`
-      nixosConfigurations."vm" = nixpkgs.lib.nixosSystem {
+    devShells = forAllSystems (system: rec {
-        system = "x86_64-linux";
+      default = venv;
+
+      venv = pkgs.${system}.mkShell {
+        shellHook = ''
+          if [ ! -d .venv/ ]; then
+            echo "Creating Virtual Environment..."
+            ${pkgs.${system}.python3}/bin/python3 -m venv .venv
+          fi
+
+          alias activate='source .venv/bin/activate'
+
+          echo "Entering Virtual Environment..."
+          source .venv/bin/activate
+        '';
+      };
+    });
+
+    # NixOS Module
+    nixosModules.default = import ./nix/module.nix inputs;
+
+    # nixos definition for a microvm to test nixosModules
+    nixosConfigurations = let
+      system = "x86_64-linux";
+    in {
+      vm = nixpkgs.lib.nixosSystem {
+        inherit system;
 
         modules = [
           inputs.microvm.nixosModules.microvm
-          (
+          ({config, ...}: {
-            { config, ... }:
+            system.stateVersion = config.system.nixos.version;
-            {
-              services.getty.autologinUser = "root";
 
-              microvm = {
+            networking.hostName = "vm";
-                hypervisor = "qemu";
+            users.users.root.password = "";
 
-                shares = [
+            microvm = {
-                  {
+              # volumes = [
-                    # Host's /nix/store will be picked up so that no squashfs/erofs will be built for it.
+              #   {
-                    tag = "ro-store";
+              #     mountPoint = "/var";
-                    source = "/nix/store";
+              #     image = "var.img";
-                    mountPoint = "/nix/.ro-store";
+              #     size = 256;
-                  }
+              #   }
-                ];
+              # ];
+              shares = [
+                {
+                  # use proto = "virtiofs" for MicroVMs that are started by systemd
+                  proto = "9p";
+                  tag = "ro-store";
+                  # a host's /nix/store will be picked up so that no
+                  # squashfs/erofs will be built for it.
+                  source = "/nix/store";
+                  mountPoint = "/nix/.ro-store";
+                }
+              ];
 
-                interfaces = [
+              interfaces = [
-                  {
+                {
-                    type = "user";
+                  type = "user";
-                    id = "qemu";
+                  id = "qemu";
-                    # Locally administered have one of 2/6/A/E in the second nibble.
+                  mac = "02:00:00:01:01:01";
-                    mac = "02:00:00:01:01:01";
+                }
-                  }
+              ];
-                ];
 
-                forwardPorts = [
+              forwardPorts = [
-                  {
+                {
-                    host.port = config.services.testdata.port;
+                  host.port = config.services.testdata.port;
-                    guest.port = config.services.testdata.port;
+                  guest.port = config.services.testdata.port;
-                  }
+                }
-                ];
+              ];
-              };
+
-            }
+              # "qemu" has 9p built-in!
-          )
+              hypervisor = "qemu";
+              socket = "control.socket";
+            };
+          })
 
           self.nixosModules.default
           rec {
-            networking.firewall.allowedTCPPorts = [ services.testdata.port ];
+            networking.firewall.allowedTCPPorts = [services.testdata.port];
             services.testdata = {
               enable = true;
 
@@ -103,21 +174,16 @@
               port = 1234;
 
               settings = {
-                keys = [
+                "keys" = ["one" "two" "three"];
-                  "one"
+                "max-size" = "1GB";
-                  "two"
+                "max-data" = "100GB";
-                  "three"
+                "buffer-size" = "12MiB";
-                ];
+                "database" = "/root/testdata_state.json";
-                max-size = "1GB";
-                max-data = "100GB";
-                buffer-size = "12MiB";
-                database = "/root/testdata-state.json";
-                database-update-interval = 5.0;
-                log = "/root/log.jsonl";
               };
             };
           }
         ];
       };
     };
+  };
 }

nix/module.nix

@@ -1,41 +1,32 @@
-inputs:
+inputs: {
-{
   config,
   lib,
   pkgs,
   ...
-}:
+}: let
-let
   cfg = config.services.testdata;
   package = inputs.self.packages.${pkgs.stdenv.hostPlatform.system}.default;
-  inherit (lib)
+  inherit (lib) mkIf mkEnableOption mkOption types;
-    mkIf
-    mkEnableOption
-    mkOption
-    types
-    ;
 
-  format = pkgs.formats.json { };
+  format = pkgs.formats.json {};
   configFile = format.generate "config.json" cfg.settings;
-in
+in {
-{
   options.services.testdata = {
     enable = mkEnableOption "testdata";
 
     settings = mkOption {
-      type =
+      type = with types; let
-        with types;
+        valueType = nullOr (oneOf [
-        let
+          # TODO: restrict type to actual config file structure
-          valueType = nullOr (oneOf [
+          bool
-            bool
+          int
-            int
+          float
-            float
+          str
-            str
+          path
-            path
+          (attrsOf valueType)
-            (attrsOf valueType)
+          (listOf valueType)
-            (listOf valueType)
+        ]);
-          ]);
+      in
-        in
         valueType;
       default = throw "Please specify services.testdata.settings";
     };
@@ -52,7 +43,7 @@ in
   };
 
   config = mkIf cfg.enable {
-    environment.systemPackages = [ package ];
+    environment.systemPackages = [package];
 
     systemd.services.testdata = {
       enable = true;
@@ -62,7 +53,7 @@ in
         ExecStart = "${package}/bin/testdata --config ${configFile} --listen ${cfg.host} --port ${builtins.toString cfg.port}";
       };
 
-      wantedBy = [ "multi-user.target" ];
+      wantedBy = ["multi-user.target"];
     };
   };
 }

nix/package.nix

@@ -1,46 +0,0 @@
-{
-  src,
-  python3Packages,
-}:
-let
-  inherit (python3Packages)
-    setuptools
-    fastapi
-    uvicorn
-    pydantic
-    pytest
-    requests
-    mypy
-    pylint
-    ;
-
-  project = (builtins.fromTOML (builtins.readFile "${src}/pyproject.toml")).project;
-  pname = project.name;
-  version = project.version;
-in
-python3Packages.buildPythonPackage {
-  inherit pname version src;
-
-  pyproject = true;
-
-  build-system = [ setuptools ];
-
-  dependencies = [
-    fastapi
-    uvicorn
-    pydantic
-  ];
-
-  nativeCheckInputs = [
-    pytest
-    requests
-    mypy
-    pylint
-  ];
-
-  checkPhase = ''
-    pytest tests
-    mypy src
-    pylint src
-  '';
-}

pyproject.toml

@@ -1,23 +1,27 @@
 [project]
 name = "testdata"
-version = "1.2.2"
+version = "1.1.0"
-requires-python = "~=3.12, <4"
+requires-python = ">=3.11, <4"
-dependencies = ["fastapi~=0.115", "uvicorn~=0.32", "pydantic~=2.9"]
+dependencies = [
+    "fastapi==0.115.*",
+    "uvicorn==0.32.*",
+    "pydantic==2.10.*",
+]
 
 [project.optional-dependencies]
 dev = [
-    "pytest~=8.3",
+    "pytest==8.3.*",
-    "mypy~=1.13",
+    "mypy==1.13.*",
-    "pylint~=3.3",
+    "pylint==3.3.*",
-    "requests~=2.32",
+    "requests==2.32.*",
-    "types-requests~=2.32",
+    "types-requests==2.32.*"
 ]
 
 [project.scripts]
 testdata = "testdata.main:main"
 
 [build-system]
-requires = ["setuptools~=78.1"]
+requires = ["setuptools==75.*"]
 build-backend = "setuptools.build_meta"
 
 [tool.setuptools.packages.find]
@@ -36,5 +40,5 @@ disable = [
     "missing-class-docstring",
     "missing-function-docstring",
     "too-few-public-methods",
-    "broad-exception-caught",
+    "broad-exception-caught"
 ]

src/testdata/logger/logger.py

@@ -132,7 +132,7 @@ def generate_log_config(log_path: str | None = None) -> dict:
                 'class': logging.handlers.RotatingFileHandler,
                 'level': 'DEBUG',
                 'formatter': 'json',
-                'filename': log_path,
+                'filename': 'log.jsonl',
                 'maxBytes': 1024 * 1024 * 10,  # 10 MiB
                 'backupCount': 3
         }} if log_path is not None else {}),

src/testdata/main.py

@@ -1,32 +1,14 @@
-import os
 import sys
 import argparse
 import asyncio
-import shutil
 
 from .testdata import Testdata
 
 def parse_args(args: list[str]):
-    def formatter(prog):
+    parser = argparse.ArgumentParser()
-        return argparse.ArgumentDefaultsHelpFormatter(prog, max_help_position=shutil.get_terminal_size().columns)
+    parser.add_argument('-c', '--config', type=argparse.FileType('r'), default='./config.json', help='Path to config file in JSON format.')
-
+    parser.add_argument('-l', '--listen', type=str, default='0.0.0.0', help='IP on which to listen.')
-    parser = argparse.ArgumentParser(formatter_class=formatter)
+    parser.add_argument('-p', '--port', type=int, default='8080', help='Port on which to serve the webserver.')
-
-    parser.add_argument(
-        '-c', '--config', type=argparse.FileType('r'),
-        default=os.environ['TESTDATA_CONFIG'] if 'TESTDATA_CONFIG' in os.environ else './config.json',
-        help='Path to config file in JSON format.'
-    )
-    parser.add_argument(
-        '-l', '--listen', type=str,
-        default=os.environ['TESTDATA_HOST'] if 'TESTDATA_HOST' in os.environ else '0.0.0.0',
-        help='IP on which to listen.'
-    )
-    parser.add_argument(
-        '-p', '--port', type=int,
-        default=os.environ['TESTDATA_PORT'] if 'TESTDATA_PORT' in os.environ else 8080,
-        help='Port on which to serve the webserver.'
-    )
 
     return parser.parse_args(args)
 

src/testdata/testdata.py

@@ -1,16 +1,10 @@
 import os
 import json
 import asyncio
-import inspect
-import functools
-import random
-import importlib.metadata
-from datetime import datetime
 
-import uvicorn
 from typing_extensions import Annotated
-from fastapi import FastAPI, Request, Security, status, HTTPException
+import uvicorn
-from fastapi.security import APIKeyHeader, APIKeyQuery
+from fastapi import FastAPI, status, HTTPException
 from fastapi.responses import StreamingResponse
 from pydantic import BaseModel, ConfigDict, Field, BeforeValidator, ValidationError
 
@@ -49,165 +43,85 @@ class Testdata:
         max_size: Annotated[int, BeforeValidator(to_bytes)] = Field(alias='max-size')
         max_data: Annotated[int, BeforeValidator(to_bytes)] = Field(alias='max-data')
         buffer_size: Annotated[int, BeforeValidator(to_bytes)] = Field(alias='buffer-size')
-        database: str | None = None
+        database: str
-        log: str | None = Field(alias='log', default=None)
+        log_path: str | None = Field(alias='log-path', default=None)
-        database_update_interval: float = Field(alias='database-update-interval', default=5)
+        update_database_interval: float = Field(alias='update-database-interval', default=5)
 
     _config: Config
     _api: FastAPI
-    _state: dict
+    _state: dict[str, int]
     _logger: logger.Logger
 
     def __init__(self, config: Config):
         self._config = config
+        self._api = FastAPI(docs_url=None, redoc_url=None)
         self._logger = logger.getLogger('testdata')
-        self._api = self._setup_api()
 
         # Store internal state
-        self._state = {
+        self._state = {'data-used': 0}
-            'version': importlib.metadata.version('testdata'),  # For future compatibility
-            'data-used': {f'{(today := datetime.today()).year}-{today.month:02}': 0}  # math each months data usage
-        }
-
-    def _setup_api(self) -> FastAPI:
-        api = FastAPI(docs_url='/', redoc_url=None)
-
-        # Security
-        def get_api_key(
-            api_key_query: str = Security(APIKeyQuery(name="api_key", auto_error=False)),
-            api_key_header: str = Security(APIKeyHeader(name="x-api-key", auto_error=False))
-        ) -> str:
-            # https://joshdimella.com/blog/adding-api-key-auth-to-fast-api
-
-            if api_key_query in self._config.authorized_keys:
-                return api_key_query
-            if api_key_header in self._config.authorized_keys:
-                return api_key_header
-
-            raise HTTPException(
-                status_code=status.HTTP_401_UNAUTHORIZED,
-                detail='Invalid or missing API Key'
-            )
-
-        # A wrapper to set the function signature to accept the api key dependency
-        def secure(func):
-            # Get old signature
-            positional_only, positional_or_keyword, variadic_positional, keyword_only, variadic_keyword = [], [], [], [], []
-            for value in inspect.signature(func).parameters.values():
-                if value.kind == inspect.Parameter.POSITIONAL_ONLY:
-                    positional_only.append(value)
-                elif value.kind == inspect.Parameter.POSITIONAL_OR_KEYWORD:
-                    positional_or_keyword.append(value)
-                elif value.kind == inspect.Parameter.VAR_POSITIONAL:
-                    variadic_positional.append(value)
-                elif value.kind == inspect.Parameter.KEYWORD_ONLY:
-                    keyword_only.append(value)
-                elif value.kind == inspect.Parameter.VAR_KEYWORD:
-                    variadic_keyword.append(value)
-
-            # Avoid passing an unrecognized keyword
-            if inspect.iscoroutinefunction(func):
-                async def wrapper(*args, **kwargs):
-                    if len(variadic_keyword) == 0:
-                        if 'api_key' in kwargs:
-                            del kwargs['api_key']
-
-                    return await func(*args, **kwargs)
-            else:
-                def wrapper(*args, **kwargs):
-                    if len(variadic_keyword) == 0:
-                        if 'api_key' in kwargs:
-                            del kwargs['api_key']
-
-                    return func(*args, **kwargs)
-
-            # Override signature
-            wrapper.__signature__ = inspect.signature(func).replace(
-                parameters=(
-                    *positional_only,
-                    *positional_or_keyword,
-                    *variadic_positional,
-                    *keyword_only,
-                    inspect.Parameter('api_key', inspect.Parameter.POSITIONAL_OR_KEYWORD, default=Security(get_api_key)),
-                    *variadic_keyword
-                )
-            )
-
-            return functools.wraps(func)(wrapper)
-
-        # Routes
-        api.get('/zeros')(secure(self._zeros))
-
-        return api
-
-    async def _zeros(self, size: int | str, request: Request, filename: str = 'zeros.bin') -> StreamingResponse:
-        try:
-            extra = {'id': f'{random.randint(0, 2 ** 32 - 1):08X}'}
-            self._logger.debug(
-                'Initiated request.',
-                extra=extra | {
-                    'ip': request.client.host if request.client is not None else None,
-                    'query-params': dict(request.query_params),
-                    'headers': dict(request.headers)
-                }
-            )
 
+        @self._api.get('/zeros')
+        async def zeros(api_key: str, size: int | str) -> StreamingResponse:
             try:
-                size = convert_to_bytes(size)
+                self._logger.debug('', extra={'api_key': api_key, 'size': size})
-            except ValueError as err:
-                self._logger.warning('Invalid format for size.', extra=extra)
-                raise HTTPException(
-                    status_code=status.HTTP_400_BAD_REQUEST,
-                    detail='Invalid format for size.'
-                ) from err
 
-            if size < 0:
+                if api_key not in config.authorized_keys:
-                raise MinSizePerRequestError
+                    raise HTTPException(
-            if self._config.max_size < size:
+                        status_code=status.HTTP_401_UNAUTHORIZED,
-                raise MaxSizePerRequestError
+                        detail='Invalid API Key.'
+                    )
+                try:
+                    size = convert_to_bytes(size)
+                except ValueError as err:
+                    self._logger.warning('Invalid format for size.', extra={'api_key': api_key, 'size': size})
+                    raise HTTPException(
+                        status_code=status.HTTP_400_BAD_REQUEST,
+                        detail='Invalid format for size.'
+                    ) from err
 
-            # update internal state
+                if size < 0:
-            current_date = f'{(today := datetime.today()).year}-{today.month:02}'
+                    raise MinSizePerRequestError
-            if current_date not in self._state['data-used']:
+                if config.max_size < size:
-                self._state['data-used'][current_date] = 0
+                    raise MaxSizePerRequestError
-            if self._config.max_data < self._state['data-used'][current_date] + size:
+
-                raise HTTPException(
+                # update internal state
-                    status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                if config.max_data < self._state['data-used'] + size:
-                    detail='Service not available.'
+                    raise HTTPException(
+                        status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                        detail='Service not available.'
+                    )
+                self._state['data-used'] += size
+
+                return StreamingResponse(
+                    status_code=status.HTTP_200_OK,
+                    content=generate_data(size, config.buffer_size),
+                    media_type='application/octet-stream',
+                    headers={
+                        'Content-Length': str(size)
+                    }
                 )
-            self._state['data-used'][current_date] += size
 
-            self._logger.debug('Successfully processed request.', extra=extra)
+            except MinSizePerRequestError as err:
-            return StreamingResponse(
+                self._logger.warning('Size if negative.', extra={'api_key': api_key, 'size': size})
-                status_code=status.HTTP_200_OK,
+                raise HTTPException(
-                content=generate_data(size, self._config.buffer_size),
+                    status_code=status.HTTP_416_REQUESTED_RANGE_NOT_SATISFIABLE,
-                media_type='application/octet-stream',
+                    detail='Size has to be non-negative.'
-                headers={
+                ) from err
-                    'Content-Length': str(size),
+            except MaxSizePerRequestError as err:
-                    'Content-Disposition': f'attachment; filename="{filename}"'
+                self._logger.warning('Exceeded max size per request.', extra={'api_key': api_key, 'size': size})
-                }
+                raise HTTPException(
-            )
+                    status_code=status.HTTP_416_REQUESTED_RANGE_NOT_SATISFIABLE,
+                    detail=f'Exceeded max size per request of {config.max_size} Bytes.'
+                ) from err
+            except Exception as err:
+                self._logger.exception(err)
+                raise err
 
-        except MinSizePerRequestError as err:
+    async def _update_state(self):
-            self._logger.warning('Size if negative.', extra=extra)
+        if os.path.exists(self._config.database):
-            raise HTTPException(
+            mode = 'r+'
-                status_code=status.HTTP_416_REQUESTED_RANGE_NOT_SATISFIABLE,
+        else:
-                detail='Size has to be non-negative.'
+            mode = 'w+'
-            ) from err
-        except MaxSizePerRequestError as err:
-            self._logger.warning('Exceeded max size per request.', extra=extra)
-            raise HTTPException(
-                status_code=status.HTTP_416_REQUESTED_RANGE_NOT_SATISFIABLE,
-                detail=f'Exceeded max size per request of {self._config.max_size} Bytes.'
-            ) from err
-        except Exception as err:
-            self._logger.exception(err)
-            raise err
-
-    async def _update_state(self) -> None:
-        assert self._config.database is not None
-
-        mode = 'r+' if os.path.exists(self._config.database) else 'w+'
 
         with open(self._config.database, mode, encoding='utf-8') as file:
             try:
@@ -217,23 +131,22 @@ class Testdata:
 
             while True:
                 file.seek(0)
-                json.dump(self._state, file, indent=2)
+                json.dump(self._state, file)
                 file.truncate()
-                await asyncio.sleep(self._config.database_update_interval)
+                await asyncio.sleep(self._config.update_database_interval)
 
     async def run(self, host: str, port: int) -> None:
         try:
-            if self._config.log is not None:
+            if self._config.log_path is not None:
-                logger.setup_logging(self._config.log)
+                logger.setup_logging(self._config.log_path)
 
-            self._logger = logger.getLogger('testdata')
+            # self._logger = logger.getLogger('testdata')
             self._logger.info('Server started.')
 
-            coroutines = [uvicorn.Server(uvicorn.Config(self._api, host, port)).serve()]
+            await asyncio.gather(
-            if self._config.database is not None:
+                asyncio.create_task(uvicorn.Server(uvicorn.Config(self._api, host, port)).serve()),
-                coroutines.append(self._update_state())
+                self._update_state()
-
+            )
-            await asyncio.gather(*coroutines)
         except asyncio.exceptions.CancelledError:
             self._logger.info('Server stopped.')
         except Exception as err:

tests/test_testdata.py

@@ -53,17 +53,6 @@ def _server(request) -> Generator[str, None, None]:
                 break
 
 
-@pytest.mark.parametrize('_server', [({
-    'keys': ['one', 'two', 'three'],
-    'max-size': '100',
-    'max-data': 1234,
-    'buffer-size': '12MiB',
-})], indirect=['_server'])
-def test_invalid_api_key(_server):
-    response = requests.get(f'{PROTOCOL}://{HOST}:{PORT}/zeros?api_key=four&size=100', timeout=TIMEOUT)
-    assert response.status_code == 401
-
-
 @pytest.mark.parametrize('_server', [({
     'keys': ['one', 'two', 'three'],
     'max-size': '100',
@@ -96,16 +85,13 @@ def test_request_size_upper_bound(_server):
 
 @pytest.mark.parametrize('_server', [({
     'keys': ['one', 'two', 'three'],
-    'max-size': '100KB',
+    'max-size': '100',
-    'max-data': '100KB',
+    'max-data': 1234,
     'buffer-size': '12MiB',
 })], indirect=['_server'])
-def test_request_max_data_used(_server):
+def test_invalid_api_key(_server):
-    response = requests.get(f'{PROTOCOL}://{HOST}:{PORT}/zeros?api_key=one&size=100KB', timeout=TIMEOUT)
+    response = requests.get(f'{PROTOCOL}://{HOST}:{PORT}/zeros?api_key=four&size=100', timeout=TIMEOUT)
-    assert response.status_code == 200
+    assert response.status_code == 401
-
-    response = requests.get(f'{PROTOCOL}://{HOST}:{PORT}/zeros?api_key=one&size=1', timeout=TIMEOUT)
-    assert response.status_code == 500
 
 
 @pytest.mark.parametrize('_server', [({
@@ -113,32 +99,18 @@ def test_request_max_data_used(_server):
     'max-size': '1KB',
     'max-data': '1KB',
     'buffer-size': '12MiB',
-    'database-update-interval': 0.1
+    'update-database-interval': 0.1
 })], indirect=['_server'])
 def test_check_database_update(_server):
-    import importlib.metadata
-    from datetime import datetime
-
     database = _server
 
     with open(database, 'r', encoding='utf-8') as file:
         file.seek(0)
-        today = datetime.today()
+        assert json.load(file) == {'data-used': 0}
-        assert json.load(file) == {
-            'version': importlib.metadata.version('testdata'),
-            'data-used': {
-                f'{today.year}-{today.month:02}': 0
-            }
-        }
 
         response = requests.get(f'{PROTOCOL}://{HOST}:{PORT}/zeros?api_key=one&size=100', timeout=TIMEOUT)
         assert response.status_code == 200
 
         time.sleep(0.1)
         file.seek(0)
-        assert json.load(file) == {
+        assert json.load(file) == {'data-used': 100}
-            'version': importlib.metadata.version('testdata'),
-            'data-used': {
-                f'{today.year}-{today.month:02}': 100
-            }
-        }