Weserv Images

https://github.com/weserv/images
Admin
Source code for wsrv.nl, an image processing and manipulation service leveraging libvips and nginx...
Tokens:19,049
Snippets:57
Trust Score:6.4
License:BSD-3-Clause
Update:1 year ago
Show doc for...
Tokens:
Raw
### CMake Build Configuration

Source: https://github.com/weserv/images/blob/5.x/src/tools/CMakeLists.txt

Configures the build process for the project executable, linking libraries, and defining installation paths using CMake. This snippet sets up an executable named `${PROJECT_NAME}-cli`, links it to the main project library, and installs it to the binary directory.

```cmake
add_executable(${PROJECT_NAME}-cli cli.cpp cli_environment.h)

target_link_libraries(${PROJECT_NAME}-cli
        PRIVATE
            ${PROJECT_NAME}
        )

install(TARGETS ${PROJECT_NAME}-cli
        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
        COMPONENT ${PROJECT_NAME}-cli
        )
```

--------------------------------

### Install Library and Headers

Source: https://github.com/weserv/images/blob/5.x/src/api/CMakeLists.txt

Defines installation rules for the built library and header files. The shared library is installed to the library directory, and headers are installed to the include directory.

```cmake
install(TARGETS ${PROJECT_NAME}
        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
        COMPONENT ${PROJECT_NAME}
        )

install(DIRECTORY ${PROJECT_SOURCE_DIR}/include/
        DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
        FILES_MATCHING PATTERN "*.h"
        )
```

--------------------------------

### Build weserv/images Project

Source: https://github.com/weserv/images/blob/5.x/INSTALL.md

Clones the weserv/images repository, creates a build directory, configures the build using CMake with Release type, and compiles the project using parallel processing.

```bash
git clone --recurse-submodules https://github.com/weserv/images.git
cd images
mkdir build && cd build
cmake .. \
  -DCMAKE_BUILD_TYPE=Release
sudo cmake --build . -- -j$(nproc)
```

--------------------------------

### Configure and Install Pkg-config File

Source: https://github.com/weserv/images/blob/5.x/src/api/CMakeLists.txt

Generates a pkg-config file (`weserv.pc`) from a template and installs it to the pkgconfig directory, enabling easier dependency management for other projects.

```cmake
# Add a pkg-config file
configure_file("${CMAKE_CURRENT_SOURCE_DIR}/weserv.pc.in"
        "weserv.pc" @ONLY
        )

install(FILES "${CMAKE_CURRENT_BINARY_DIR}/weserv.pc"
        DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig"
        )
```

--------------------------------

### Run Unit Tests with CMake

Source: https://github.com/weserv/images/blob/5.x/test/README.md

Instructions to clone the repository, configure the build with CMake, build the project, and run unit tests. It specifies build type, enabling tests, and disabling Nginx module installation.

```bash
git clone https://github.com/weserv/images.git
cd images
mkdir build && cd build
cmake .. \
  -DCMAKE_BUILD_TYPE=Debug \
  -DBUILD_TESTS=ON \
  -DINSTALL_NGX_MODULE=OFF
cmake --build . -- -j$(nproc)
ctest -j $(nproc) --output-on-failure
```

--------------------------------

### Install RHEL 10 Build Dependencies

Source: https://github.com/weserv/images/blob/5.x/INSTALL.md

Installs essential repositories like EPEL, Remi, and RPM Fusion, followed by necessary packages and development tools for building weserv/images on RHEL 10. Includes libvips and its optional modules.

```bash
# Install the EPEL repository configuration package
dnf install epel-release

# Enable the CodeReady Builder repository since EPEL packages may depend on packages from it
crb enable
# or:
# subscription-manager repos --enable "codeready-builder-for-rhel-10-$(uname -m)-rpms"

# Install the Remi repository configuration package
dnf install https://rpms.remirepo.net/enterprise/remi-release-10.rpm

# Install the RPM Fusion repository configuration package (for libheif)
dnf install --nogpgcheck https://mirrors.rpmfusion.org/free/el/rpmfusion-free-release-10.noarch.rpm

# Enable Remi's RPM repository
dnf config-manager --set-enabled remi

# Install libvips (+ development files and command-line tools)
dnf install vips vips-devel vips-tools

# Install optional modules
dnf install vips-heif vips-magick-im7 vips-poppler

# Install build requirements
dnf group install --with-optional 'Development Tools'
dnf install openssl-devel pcre2-devel zlib-devel
```

--------------------------------

### Run Weserv Images Container from GitHub Container Registry

Source: https://github.com/weserv/images/blob/5.x/docker/README.md

Pulls and runs the weserv/images container from GitHub Container Registry. It maps port 8080 on the host to port 80 in the container, allowing access to the service. Requires Docker to be installed.

```bash
docker run -d -p 8080:80 --shm-size=1gb --name=weserv ghcr.io/weserv/images:5.x
```

--------------------------------

### CMake Code Coverage Setup

Source: https://github.com/weserv/images/blob/5.x/test/api/CMakeLists.txt

Configures code coverage reporting using LCOV and GCOV. It finds the necessary tools and defines custom targets to collect coverage data and generate an HTML report.

```cmake
if (ENABLE_COVERAGE)
    message(STATUS "Building test suite with coverage information")

    # From https://github.com/RWTH-HPC/CMake-codecov/blob/master/cmake/FindGcov.cmake
    get_filename_component(COMPILER_PATH "${CMAKE_CXX_COMPILER}" PATH)
    string(REGEX MATCH "^[0-9]+" GCC_VERSION "${CMAKE_CXX_COMPILER_VERSION}")
    find_program(GCOV_BIN NAMES gcov-${GCC_VERSION} gcov HINTS ${COMPILER_PATH})

    find_program(LCOV lcov)
    find_program(GENHTML genhtml)

    # Add target to collect coverage information
    add_custom_target(coverage
            COMMAND ${LCOV} -d "${CMAKE_BINARY_DIR}" -b "${PROJECT_SOURCE_DIR}" -c -o coverage.info --gcov-tool ${GCOV_BIN} --no-external
            COMMAND ${LCOV} -r coverage.info '*/_deps/*' '*/test/api/*' -o coverage.info
            WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
            COMMENT "Collect coverage information using LCOV"
            )

    # Add target to generate HTML coverage report
    add_custom_target(coverage-html
            DEPENDS coverage
            COMMAND ${GENHTML} -t "wsrv.nl" -p "${PROJECT_SOURCE_DIR}" --legend --demangle-cpp -o lcov -s coverage.info
            WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
            COMMENT "Generating HTML coverage report lcov/index.html"
            )
endif()
```

--------------------------------

### Fetch Rate Limit Nginx Module

Source: https://github.com/weserv/images/blob/5.x/third_party/rate-limit-nginx-module/CMakeLists.txt

This CMake code snippet uses the FetchContent module to declare and download the rate-limit-nginx-module from its Git repository. It specifies the exact Git tag (v1.0.0) to ensure a consistent build. After fetching, it makes the module available for use and sets a variable pointing to its source directory for further configuration.

```cmake
FetchContent_Declare(rate_limit_nginx_module
        GIT_REPOSITORY https://github.com/weserv/rate-limit-nginx-module.git
        GIT_TAG v1.0.0
        )

FetchContent_MakeAvailable(rate_limit_nginx_module)

set(RATE_LIMIT_MODULE_SOURCE ${rate_limit_nginx_module_SOURCE_DIR} PARENT_SCOPE)
```

--------------------------------

### Configure Include Directories

Source: https://github.com/weserv/images/blob/5.x/src/api/CMakeLists.txt

Sets the include directories for the project target. It specifies public include paths for build and install interfaces, and private paths for external dependencies like VIPS.

```cmake
target_include_directories(${PROJECT_NAME}
        PUBLIC
            $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
            $<INSTALL_INTERFACE:include>
        PRIVATE
            ${VIPS_INCLUDE_DIRS}
        )
```

--------------------------------

### Generate HTML Code Coverage Report

Source: https://github.com/weserv/images/blob/5.x/test/README.md

Command to generate a browsable HTML report for code coverage using LCOV. Requires LCOV to be installed and the CMake build type to be configured for coverage.

```bash
cmake --build . --target coverage-html
```

--------------------------------

### Run Integration Tests with CMake and Prove

Source: https://github.com/weserv/images/blob/5.x/test/README.md

Steps to set up and run integration tests. This involves cloning the repository, configuring CMake, building, setting the Nginx path, and executing tests using the Prove utility with specific paths.

```bash
git clone https://github.com/weserv/images.git
cd images
mkdir build && cd build
cmake .. \
  -DCMAKE_BUILD_TYPE=Debug
cmake --build . -- -j$(nproc)

cd ../
export PATH="/usr/local/nginx/sbin:$PATH"
TEST_NGINX_SERVROOT="$PWD/servroot" prove -I/path/to/test-nginx/lib -r test/nginx
```

--------------------------------

### Disable Nginx Module Installation via CMake

Source: https://github.com/weserv/images/blob/5.x/test/README.md

CMake command-line option to prevent the Nginx module from being installed during the build process. This is useful when only testing the module's functionality without system-wide installation.

```cmake
-DINSTALL_NGX_MODULE=OFF
```

--------------------------------

### Build and Run Weserv Images Container from Source

Source: https://github.com/weserv/images/blob/5.x/docker/README.md

Builds the weserv/images Docker container from a Dockerfile, allowing specification of an Nginx version. It then runs the built container, mapping host port 8080 to container port 80. Requires Docker and the source code.

```bash
docker build --build-arg NGINX_VERSION=1.29.0 -t weserv/images -f docker/Dockerfile .
docker run -d -p 8080:80 --shm-size=1gb --name=weserv weserv/images
```

--------------------------------

### Enable Test Building via CMake

Source: https://github.com/weserv/images/blob/5.x/test/README.md

CMake command-line option to ensure that test executables are built as part of the project. This is essential for running unit and integration tests.

```cmake
-DBUILD_TESTS=ON
```

--------------------------------

### Run Specific Integration Test Files

Source: https://github.com/weserv/images/blob/5.x/test/README.md

Demonstrates how to execute only specific test files within the integration test suite using the Prove utility. This allows for targeted testing of particular functionalities.

```bash
cd images
export PATH="/usr/local/nginx/sbin:$PATH"
prove -I/path/to/test-nginx/lib test/nginx/file.t test/nginx/proxy.t
```

--------------------------------

### Check Jemalloc Configuration and Stats

Source: https://github.com/weserv/images/blob/5.x/docker/README.md

Executes a bash command inside the 'weserv' container to print jemalloc memory allocator statistics. This is useful for performance tuning and debugging memory usage. Requires jemalloc to be configured and the container to be running.

```bash
docker exec -e MALLOC_CONF="stats_print:true,stats_print_opts:mdablxeh" weserv bash
```

--------------------------------

### Update RPM Packages in Container

Source: https://github.com/weserv/images/blob/5.x/docker/README.md

Updates all installed RPM packages within the 'weserv' Docker container using the 'dnf update -y' command. This ensures the container's software is up-to-date. Requires a running container named 'weserv' with dnf package manager.

```bash
docker exec weserv dnf update -y
```

--------------------------------

### Define Project Sources

Source: https://github.com/weserv/images/blob/5.x/src/api/CMakeLists.txt

Lists all source files (.cpp) that will be compiled and linked into the project library. These files contain the implementation details for the library's functionality.

```cmake
set(SOURCES
        parsers/color.cpp
        parsers/coordinate.cpp
        parsers/query.cpp
        io/source.cpp
        io/target.cpp
        processors/alignment.cpp
        processors/background.cpp
        processors/blur.cpp
        processors/brightness.cpp
        processors/contrast.cpp
        processors/crop.cpp
        processors/embed.cpp
        processors/filter.cpp
        processors/gamma.cpp
        processors/mask.cpp
        processors/modulate.cpp
        processors/orientation.cpp
        processors/rotation.cpp
        processors/sharpen.cpp
        processors/stream.cpp
        processors/thumbnail.cpp
        processors/tint.cpp
        processors/trim.cpp
        utils/status.cpp
        api_manager_impl.cpp
        )
```

--------------------------------

### CMake Build Options and Valgrind Integration

Source: https://github.com/weserv/images/blob/5.x/test/api/CMakeLists.txt

Defines build options like Valgrind execution and automatically finds the valgrind executable. If valgrind is enabled and found, it configures a memory checking command for test execution.

```cmake
option(ENABLE_VALGRIND "Execute test suite with Valgrind" OFF)
option(BUILD_GENERATOR "Build the expected fixtures generator (internal)" OFF)

if (ENABLE_VALGRIND)
    find_program(
            VALGRIND_EXE
            NAMES "valgrind"
            DOC "Path to valgrind executable"
    )
    if (NOT VALGRIND_EXE)
        message(STATUS "valgrind not found")
        set(ENABLE_VALGRIND OFF CACHE BOOL "" FORCE)
    else()
        message(STATUS "Executing test suite with valgrind (${VALGRIND_EXE})")
        set(MEMCHECK_COMMAND "${VALGRIND_EXE} --error-exitcode=1 --leak-check=yes --suppressions=${PROJECT_SOURCE_DIR}/valgrind.suppress")
        separate_arguments(MEMCHECK_COMMAND)
    endif()
endif()
```

--------------------------------

### Check Nginx Configuration Syntax

Source: https://github.com/weserv/images/blob/5.x/docker/README.md

Executes the nginx command with the '-t' flag inside the 'weserv' container to check the syntax of the Nginx configuration files. This helps identify potential configuration errors before reloading.

```bash
docker exec weserv nginx -t
```

--------------------------------

### Nginx Build Configuration with CMake

Source: https://github.com/weserv/images/blob/5.x/third_party/nginx/CMakeLists.txt

This CMake script defines variables and commands to download, configure, and build Nginx. It includes options for compiler flags, modules, and build parallelism, leveraging the `ExternalProject_Add` module.

```cmake
if (NOT NGX_VERSION)
    set(NGX_VERSION 1.29.0)
endif()

set(NGX_ROOT ${CMAKE_CURRENT_BINARY_DIR})

set(NGX_CONFIGURE_OPTS
        ${CUSTOM_NGX_FLAGS}
        #--with-debug
        "--with-cc=${CMAKE_C_COMPILER}"
        "--with-cpp=${CMAKE_CXX_COMPILER}"
        "--with-cc-opt=${CUSTOM_NGX_CC_OPT}"
        "--with-ld-opt=-Wl,-rpath,${PROJECT_SOURCE_DIR}/lib ${CUSTOM_NGX_LD_OPT}"
        "--add$<$<BOOL:${NGX_DYN_MODULE}>:-dynamic>-module=${PROJECT_SOURCE_DIR}"
        "--add$<$<BOOL:${NGX_DYN_MODULE}>:-dynamic>-module=${RATE_LIMIT_MODULE_SOURCE}"
        --with-file-aio
        --with-http_ssl_module
        --with-http_v2_module
        --with-http_realip_module
        --with-http_stub_status_module
        --with-http_secure_link_module
        --with-pcre-jit
        #--with-google_perftools_module
        )

if (CMAKE_GENERATOR MATCHES "Make")
    # Use special command for Makefiles to support parallelism.
    set(MAKE_EXE "$(MAKE)")
else()
    set(MAKE_EXE "make")
endif()

# Avoid warning about DOWNLOAD_EXTRACT_TIMESTAMP on CMake 3.24.
if (CMAKE_VERSION VERSION_GREATER_EQUAL 3.24.0)
    cmake_policy(SET CMP0135 NEW)
endif()

ExternalProject_Add(nginx
        DEPENDS ${PROJECT_NAME}
        PREFIX ${NGX_ROOT}
        SOURCE_DIR ${NGX_ROOT}/nginx
        URL https://nginx.org/download/nginx-${NGX_VERSION}.tar.gz
        CONFIGURE_COMMAND ./configure ${NGX_CONFIGURE_OPTS}
        BUILD_COMMAND ${MAKE_EXE}
        BUILD_ALWAYS 1
        BUILD_IN_SOURCE 1
        )

```

--------------------------------

### Unit Test Executable Generation and CTest Integration

Source: https://github.com/weserv/images/blob/5.x/test/api/CMakeLists.txt

Dynamically finds unit test files and creates a separate executable for each. It configures include paths, link libraries, and registers each test with CTest. Valgrind execution is also configured conditionally.

```cmake
file(GLOB_RECURSE files "${CMAKE_CURRENT_SOURCE_DIR}/unit-*.cpp")
foreach (file ${files})
    get_filename_component(file_basename ${file} NAME_WE)
    string(REGEX REPLACE "unit-([^"]+)" "test-\1" testcase ${file_basename})

    add_executable(${testcase} $<TARGET_OBJECTS:catch2_main> ${file})
    target_compile_definitions(${testcase}
            PRIVATE
                CATCH_CONFIG_FAST_COMPILE
            )
    target_compile_options(${testcase}
            PRIVATE
                $<$<CXX_COMPILER_ID:GNU>:-Wno-deprecated-declarations>
            )
    target_include_directories(${testcase}
            PRIVATE
                ${VIPS_INCLUDE_DIRS}
            )
    target_link_libraries(${testcase}
            PUBLIC
                ${PROJECT_NAME}
            PRIVATE
                ${VIPS_LDFLAGS}
                Catch2::Catch2
            )
    add_test(NAME "${testcase}"
            COMMAND ${testcase}
            WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
            )

    if (ENABLE_VALGRIND)
        add_test(NAME "${testcase}_valgrind"
                COMMAND ${MEMCHECK_COMMAND} ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${testcase}
                WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
                )
        set_tests_properties("${testcase}_valgrind" PROPERTIES LABELS "valgrind")
    endif()
endforeach()
```

--------------------------------

### Fixtures Generator Executable Configuration

Source: https://github.com/weserv/images/blob/5.x/test/api/CMakeLists.txt

Configures and builds a separate executable for generating fixtures if the BUILD_GENERATOR option is enabled. It sets up include directories and link libraries for this utility.

```cmake
if (BUILD_GENERATOR)
    add_executable(fixtures-generator generate_expected_fixtures.cpp)
    target_include_directories(fixtures-generator
            PRIVATE
                ${VIPS_INCLUDE_DIRS}
            )
    target_link_libraries(fixtures-generator
            PUBLIC
                ${PROJECT_NAME}
            PRIVATE
                ${VIPS_LDFLAGS}
            )
endif()
```

--------------------------------

### Reload Nginx Configuration

Source: https://github.com/weserv/images/blob/5.x/docker/README.md

Sends a SIGHUP signal to the Nginx master process within the 'weserv' container, causing it to gracefully reload its configuration files without dropping active connections. Requires a running container named 'weserv'.

```bash
docker exec weserv nginx -s reload
```

--------------------------------

### Catch2 Test Library Object Configuration

Source: https://github.com/weserv/images/blob/5.x/test/api/CMakeLists.txt

Defines an object library for the Catch2 testing framework, including source files and necessary include directories and link libraries. It includes version-specific handling for CMake.

```cmake
# Catch2 library with the main function to speed up build
add_library(catch2_main OBJECT
        base.cpp
        max_color_distance.h
        max_color_distance.cpp
        similar_image.h
        similar_image.cpp
        test_environment.h
        )

# target_link_libraries on object libraries only works with CMake >= 3.12.
if (${CMAKE_VERSION} VERSION_LESS "3.12.0")
    target_include_directories(catch2_main
            PUBLIC
                ${PROJECT_SOURCE_DIR}/include
                $<TARGET_PROPERTY:Catch2::Catch2,INTERFACE_INCLUDE_DIRECTORIES>
            PRIVATE
                ${VIPS_INCLUDE_DIRS}
            )
else()
    target_include_directories(catch2_main
            PRIVATE
                ${VIPS_INCLUDE_DIRS}
            )
    target_link_libraries(catch2_main
            PUBLIC
                ${PROJECT_NAME}
                Catch2::Catch2
            PRIVATE
                ${VIPS_LDFLAGS}
            )
endif()
```

--------------------------------

### Monitor Container CPU Consumption

Source: https://github.com/weserv/images/blob/5.x/docker/README.md

Displays real-time resource usage statistics, including CPU, memory, and network I/O, for all running Docker containers. This command helps in monitoring the performance of the 'weserv' container and other running services.

```bash
docker stats
```

--------------------------------

### Set Target Properties

Source: https://github.com/weserv/images/blob/5.x/src/api/CMakeLists.txt

Configures properties for the project target, specifically setting the VERSION and SOVERSION based on project variables.

```cmake
set_target_properties(${PROJECT_NAME}
        PROPERTIES
            VERSION ${PROJECT_VERSION}
            SOVERSION ${PROJECT_VERSION_MAJOR}
        )
```

--------------------------------

### Define Project Headers

Source: https://github.com/weserv/images/blob/5.x/src/api/CMakeLists.txt

Lists all header files to be included in the project build. These files define the interfaces and structures for the image processing library.

```cmake
set(HEADERS
        exceptions/invalid.h
        exceptions/large.h
        exceptions/unreadable.h
        exceptions/unsupported.h
        io/blob.h
        io/source.h
        io/target.h
        parsers/color.h
        parsers/coordinate.h
        parsers/enumeration.h
        parsers/numeric.h
        parsers/query.h
        processors/alignment.h
        processors/background.h
        processors/base.h
        processors/blur.h
        processors/brightness.h
        processors/contrast.h
        processors/crop.h
        processors/embed.h
        processors/filter.h
        processors/gamma.h
        processors/mask.h
        processors/modulate.h
        processors/orientation.h
        processors/rotation.h
        processors/sharpen.h
        processors/stream.h
        processors/thumbnail.h
        processors/tint.h
        processors/trim.h
        utils/utility.h
        api_manager_impl.h
        enums.h
        )
```

--------------------------------

### Enable Coverage Collection via CMake

Source: https://github.com/weserv/images/blob/5.x/test/README.md

CMake command-line option to enable code coverage collection. This flag should be passed during the CMake configuration step.

```cmake
-DENABLE_COVERAGE=ON
```

--------------------------------

### CMake Configuration for weserv Project

Source: https://github.com/weserv/images/blob/5.x/CMakeLists.txt

Configures the build process for the weserv C++ image service using CMake. It sets project metadata, build options (coverage, sanitizer, tools, tests, Nginx module), C++ standard, compiler flags, and manages dependencies like libvips and Catch2. The configuration includes conditional compilation for features and integration with external libraries.

```cmake
cmake_minimum_required(VERSION 3.14)

project(weserv
        VERSION 5.0.0
        DESCRIPTION "Image cache and resize service"
        LANGUAGES
            C
            CXX
        )

# Set output directories in which to build the target files
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${PROJECT_SOURCE_DIR}/lib)
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${PROJECT_SOURCE_DIR}/lib)
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_SOURCE_DIR}/bin)

# Options
option(ENABLE_COVERAGE "Compile in coverage mode" OFF)
option(ENABLE_SANITIZER "Build with clang sanitizer" OFF)
option(ENABLE_CLANG_TIDY "Enable source code checking using clang-tidy" OFF)
option(BUILD_TOOLS "Whether or not to build the tools" OFF)
option(BUILD_TESTS "Whether or not to build the tests" OFF)
option(INSTALL_NGX_MODULE "Build and install nginx along with the weserv module" ON)

# Set a default build type if none was specified
if (NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
    message(STATUS "Setting build type to 'Release' as none was specified.")
    set(CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build." FORCE)
endif()

# Let's enable C++17
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)

# Coverage flags
if (ENABLE_COVERAGE)
    set(CMAKE_CXX_FLAGS_DEBUG "-O0 -g --coverage")
    set(CMAKE_EXE_LINKER_FLAGS "--coverage")
elseif (CMAKE_COMPILER_IS_GNUCXX)
    # Compiler flags
    set(CMAKE_CXX_FLAGS_RELEASE "-O3 -ffast-math") # Optimize for performance
    set(CMAKE_EXE_LINKER_FLAGS "-s")   # Strip binary
endif()

# AddressSanitizer flags
if (ENABLE_SANITIZER)
    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fsanitize=address -fno-omit-frame-pointer -g -O1")
    set(CMAKE_LINKER_FLAGS_DEBUG "${CMAKE_LINKER_FLAGS_DEBUG} -fsanitize=address -fno-omit-frame-pointer -g -O1")
endif()

if (ENABLE_CLANG_TIDY)
    find_program(
            CLANG_TIDY_EXE
            NAMES "clang-tidy"
            DOC "Path to clang-tidy executable"
    )
    if (NOT CLANG_TIDY_EXE)
        message(STATUS "clang-tidy not found")
        set(ENABLE_CLANG_TIDY OFF CACHE BOOL "" FORCE)
    else()
        set(CMAKE_CXX_CLANG_TIDY "${CLANG_TIDY_EXE}" "-format-style=file")
    endif()
endif()

include(ExternalProject)
include(FetchContent)

# Use GNUInstallDirs to install libraries into correct locations on all platforms
include(GNUInstallDirs)

# Find Catch2 (optional)
find_package(Catch2 3.0.1 QUIET)

# Find libvips (required)
find_package(PkgConfig)
pkg_check_modules(VIPS vips-cpp>=8.12 REQUIRED)

# Create the shared API library
add_subdirectory(src/api)

if (BUILD_TOOLS)
    add_subdirectory(src/tools)
endif()

if (BUILD_TESTS)
    enable_testing()

    # Build Catch2 (a modern test framework), if necessary
    if (NOT Catch2_FOUND)
        add_subdirectory(third_party/catch2)
    endif()

    add_subdirectory(test/api)
endif()

# Install nginx along with the nginx weserv module, if necessary
if (INSTALL_NGX_MODULE)
    add_subdirectory(third_party/rate-limit-nginx-module)

    add_subdirectory(third_party/nginx)
endif()
```

--------------------------------

### Access Container Logs

Source: https://github.com/weserv/images/blob/5.x/docker/README.md

Retrieves the standard output and standard error logs from the running 'weserv' Docker container. This is essential for monitoring the application's activity and diagnosing issues. Requires a running container named 'weserv'.

```bash
docker logs weserv
```

--------------------------------

### Declare and Fetch Catch2 Dependency with CMake

Source: https://github.com/weserv/images/blob/5.x/third_party/catch2/CMakeLists.txt

This snippet demonstrates how to declare and make a Git dependency available using CMake's FetchContent module. It specifies the Git repository URL and tag for the Catch2 library, ensuring it's downloaded and ready for use in the build process.

```cmake
FetchContent_Declare(
        catch2
        GIT_REPOSITORY https://github.com/catchorg/Catch2.git
        GIT_TAG v3.8.1
        )

FetchContent_MakeAvailable(catch2)
```

--------------------------------

### Weserv Nginx Module Configuration

Source: https://github.com/weserv/images/blob/5.x/ngx_conf/README.md

Configuration directives for the Weserv Nginx module, controlling image proxying, filtering, and related settings.

```APIDOC
weserv proxy|filter
  context: location, if in location
  description: Enables the Weserv module for nginx requests. Supports 'proxy' mode for remote server images via '?url=' or 'filter' mode for processing images from other nginx handlers.

weserv_deny_ip <CIDR>
  context: http, server, location
  default: —
  description: Denies access to specified IP addresses or CIDR ranges. Primarily blocks IPs specified directly in URLs (e.g., '?url=127.0.0.1:8080/image.png'). DNS blocking requires a separate recursive DNS server setup.

weserv_connect_timeout <timeout>
  context: http, server, location
  default: 5s
  description: Defines the timeout duration for establishing a connection with a remote server.

weserv_send_timeout <timeout>
  context: http, server, location
  default: 5s
  description: Sets the timeout for transmitting a request to a remote server. This timeout applies between successive write operations, not the entire request transmission. If no data is sent within this time, the connection is closed.

weserv_read_timeout <timeout>
  context: http, server, location
  default: 15s
  description: Defines the timeout for reading a response from a remote server. This timeout applies between successive read operations, not the entire response transmission. If no data is received within this time, the connection is closed.

weserv_user_agent <user_agent>
  context: http, server, location, if in location
  default: Mozilla/5.0 (compatible; ImageFetcher/9.0; +http://wsrv.nl/)
  description: Configures the User-Agent header sent to remote servers when fetching images.

weserv_max_size <size>
  context: http, server, location, if in location
  default: 100m
  description: Sets the maximum allowed size for an image to be processed. Setting this to '0' removes the size limit.

weserv_max_redirects <redirects>
  context: http, server, location, if in location
  default: 10
  description: Sets the maximum number of HTTP redirection-followings allowed when fetching remote images.

weserv_canonical_header on|off
  context: http, server, location, if in location
  default: on
  description: Determines whether the `rel="canonical"` response header is set for proxied images (when using the `proxy` backend mode).

weserv_savers [jpg] [png] [webp] [avif] [tiff] [gif] [json]
  context: http, server, location
  default: jpg png webp avif tiff gif json
  description: Enables or disables specific image savers for use with the `&output=` query parameter. Accepts multiple image format parameters.

weserv_process_timeout <time>
  context: http, server, location
  default: 10s
  description: Specifies the maximum allowed time for image processing operations. Setting this to '0' removes the processing time limit.
```

--------------------------------

### Weserv Zlib Compression Level for PNG

Source: https://github.com/weserv/images/blob/5.x/ngx_conf/README.md

Sets the default zlib compression level to use for PNG images when the '&l=' parameter is not specified. Acceptable values are in the range from 0 (fastest/largest) to 9 (slowest/smallest).

```APIDOC
weserv_zlib_level <level>
  - Description: Sets the default zlib compression level for PNG images.
  - Parameters:
    - level: Integer from 0 (fastest/largest) to 9 (slowest/smallest).
  - Default: 6
  - Context: http, server, location, if in location
```

--------------------------------

### Access Weserv Container Shell

Source: https://github.com/weserv/images/blob/5.x/docker/README.md

Opens an interactive bash shell inside the running 'weserv' Docker container. This is useful for debugging or inspecting the container's environment. Requires a running container named 'weserv'.

```bash
docker exec -it weserv bash
```

--------------------------------

### Stop All Running Docker Containers

Source: https://github.com/weserv/images/blob/5.x/docker/README.md

Stops all currently running Docker containers on the host system. This command is a utility for managing the Docker environment and can be used to halt all services gracefully. It targets all containers listed by 'docker ps -aq'.

```bash
docker stop $(docker ps -aq)
```

--------------------------------

### Remove All Docker Images

Source: https://github.com/weserv/images/blob/5.x/docker/README.md

Removes all Docker images from the host system. This command is used for disk space management and cleaning up the Docker image cache. It targets all images listed by 'docker images -q'. Use with caution.

```bash
docker rmi $(docker images -q)
```

--------------------------------

### Link External Libraries

Source: https://github.com/weserv/images/blob/5.x/src/api/CMakeLists.txt

Links the project target against external libraries. It specifies private linking for VIPS libraries using `${VIPS_LDFLAGS}`.

```cmake
target_link_libraries(${PROJECT_NAME}
        PRIVATE
            ${VIPS_LDFLAGS}
        )
```

--------------------------------

### Set Default AVIF Image Quality

Source: https://github.com/weserv/images/blob/5.x/ngx_conf/README.md

Configures the default quality for AVIF images when '&q=' is not specified. If this directive is absent, the value from 'weserv_quality' is used. Acceptable values are 1-100. Applicable in http, server, and location contexts.

```config
weserv_avif_quality <quality>

# Example:
# weserv_avif_quality 70
```

--------------------------------

### Add Shared Library Target

Source: https://github.com/weserv/images/blob/5.x/src/api/CMakeLists.txt

Creates a shared library target named after the project variable `${PROJECT_NAME}`. It links the defined headers and sources together.

```cmake
add_library(${PROJECT_NAME} SHARED ${HEADERS} ${SOURCES})
```

--------------------------------

### Retrieve Container IP Address

Source: https://github.com/weserv/images/blob/5.x/docker/README.md

Fetches the IP address assigned to the running 'weserv' container. It uses 'docker inspect' to query network settings. This command is useful for network configuration or direct access to the container's IP.

```bash
docker inspect --format='{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' $(docker ps -f name=weserv -q)
docker inspect $(docker ps -f name=weserv -q) | grep IPAddress
```

--------------------------------

### Set Default Image Quality

Source: https://github.com/weserv/images/blob/5.x/ngx_conf/README.md

Sets the default quality for JPEG, WebP, TIFF, and AVIF images when the '&q=' parameter is not provided. Acceptable values range from 1 to 100. Applicable in http, server, and location contexts.

```config
weserv_quality <quality>

# Example:
# weserv_quality 75
```

--------------------------------

### Set Default WebP Image Quality

Source: https://github.com/weserv/images/blob/5.x/ngx_conf/README.md

Sets the default quality for WebP images when '&q=' is not provided. If this directive is absent, the value from 'weserv_quality' is used. Acceptable values are 1-100. Applicable in http, server, and location contexts.

```config
weserv_webp_quality <quality>

# Example:
# weserv_webp_quality 80
```

--------------------------------

### Set Maximum Pages for Multi-page Input

Source: https://github.com/weserv/images/blob/5.x/ngx_conf/README.md

Configures the maximum number of pages to extract from multi-page image inputs like GIF, TIFF, and PDF. Setting this to 0 removes the limit. Applicable in http, server, and location contexts.

```config
weserv_max_pages <pages>

# Example:
# weserv_max_pages 512
```
Tokens:
Raw