kafka

base-images/nginx-php-fpm-main/Dockerfile

@@ -173,6 +173,7 @@ RUN echo @testing http://nl.alpinelinux.org/alpine/edge/testing >> /etc/apk/repo
     apk update && apk upgrade &&\
     apk add --no-cache \
     bash \
+    librdkafka-dev \
     openssh-client \
     wget \
     supervisor \
@@ -206,7 +207,6 @@ RUN echo @testing http://nl.alpinelinux.org/alpine/edge/testing >> /etc/apk/repo
     imap-dev \
     libjpeg-turbo-dev \
     postgresql-dev && \
-    librdkafka-dev \
     docker-php-ext-install gd && \
     docker-php-ext-configure gd \
       --with-freetype \
@@ -282,6 +282,11 @@ RUN cp /usr/local/etc/php/php.ini-development /usr/local/etc/php/php.ini && \
             /usr/local/etc/php/php.ini
 
 
+ADD php-rdkafka /usr/local/php-rdkafka
+RUN cd /usr/local/php-rdkafka && /usr/local/bin/phpize && ./configure --with-php-config=/usr/local/bin/php-config && make && make install
+
+
+
 # Add Scripts
 ADD scripts/start.sh /start.sh
 ADD scripts/pull /usr/bin/pull

base-images/nginx-php-fpm-main/Dockerfile2

+#FROM php:8.1.6-fpm-alpine3.15
+FROM php:7.4.30-fpm-alpine3.15
+
+LABEL maintainer="Ric Harvey <ric@squarecows.com>"
+
+ENV php_conf /usr/local/etc/php-fpm.conf
+ENV fpm_conf /usr/local/etc/php-fpm.d/www.conf
+ENV php_vars /usr/local/etc/php/conf.d/docker-vars.ini
+
+ENV NGINX_VERSION 1.21.6
+ENV LUA_MODULE_VERSION 0.10.14
+ENV DEVEL_KIT_MODULE_VERSION 0.3.1
+ENV GEOIP2_MODULE_VERSION 3.3
+ENV LUAJIT_LIB=/usr/lib
+ENV LUAJIT_INC=/usr/include/luajit-2.1
+
+RUN echo @testing http://nl.alpinelinux.org/alpine/edge/testing >> /etc/apk/repositories && \
+    echo /etc/apk/respositories && \
+    apk update && apk upgrade &&\
+    apk add --no-cache \
+    bash \
+    librdkafka-dev \
+    openssh-client \
+    wget \
+    supervisor \
+    curl \
+    libcurl \
+    libpq \
+    git \
+    python3 \
+    py3-pip \
+    ca-certificates \
+    dialog \
+    autoconf \
+    make \
+    openssl-dev \
+    libressl-dev \
+    libzip-dev \
+    bzip2-dev \
+    icu-dev \
+    gcc && \
+    apk add --no-cache --virtual .sys-deps \
+    musl-dev \
+    linux-headers \
+    augeas-dev \
+    libmcrypt-dev \
+    libpng-dev \
+    libxslt-dev \
+    python3-dev \
+    libffi-dev \
+    freetype-dev \
+    sqlite-dev \
+    imap-dev \
+    libjpeg-turbo-dev \
+    postgresql-dev && \
+    docker-php-ext-install gd && \
+    docker-php-ext-configure gd \
+      --with-freetype \
+      --with-jpeg && \
+     pip install --upgrade pip && \
+    #curl iconv session
+    #docker-php-ext-install pdo_mysql pdo_sqlite mysqli mcrypt gd exif intl xsl json soap dom zip opcache && \
+    # docker-php-ext-install iconv pdo_mysql pdo_sqlite pgsql pdo_pgsql mysqli gd exif intl xsl json soap dom zip opcache && \
+    docker-php-ext-install  pdo_mysql mysqli pdo_sqlite pgsql pdo_pgsql exif intl xsl soap zip 
+
+    
+ADD php-rdkafka /usr/local/php-rdkafka
+RUN cd /usr/local/php-rdkafka && /usr/local/bin/phpize && ./configure --with-php-config=/usr/local/bin/php-config && make && make install
+
+
+EXPOSE 443 80 8080
+
+WORKDIR "/var/www/html"
+CMD ["/start.sh"]

base-images/nginx-php-fpm-main/php-rdkafka/.appveyor.yml

+# general configuration
+version: '{branch}.{build}'
+
+# environment configuration
+image: Visual Studio 2017
+clone_folder: C:\projects\rdkafka
+environment:
+  BIN_SDK_VER: 2.2.0
+  DEP: librdkafka-1.5.3
+  matrix:
+    - PHP_VER: 7.4
+      TS: 0
+      VC: vc15
+      ARCH: x64
+      OPCACHE: 0
+    - PHP_VER: 7.4
+      TS: 1
+      VC: vc15
+      ARCH: x64
+      OPCACHE: 1
+    - PHP_VER: 8.0
+      TS: 0
+      VC: vs16
+      ARCH: x64
+      OPCACHE: 0
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
+    - PHP_VER: 8.0
+      TS: 1
+      VC: vs16
+      ARCH: x64
+      OPCACHE: 1
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
+    - PHP_VER: 8.1
+      TS: 0
+      VC: vs16
+      ARCH: x64
+      OPCACHE: 0
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
+    - PHP_VER: 8.1
+      TS: 1
+      VC: vs16
+      ARCH: x64
+      OPCACHE: 1
+      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
+
+cache:
+  - C:\build-cache -> .appveyor.yml, .appveyor\install.ps1
+install:
+  - ps: .appveyor\install.ps1
+
+# build configuration
+build_script:
+  - ps: .appveyor\build.ps1
+
+after_build:
+  - ps: .appveyor\package.ps1

base-images/nginx-php-fpm-main/php-rdkafka/.appveyor/build.ps1

+$ErrorActionPreference = "Stop"
+
+Set-Location 'C:\projects\rdkafka'
+
+$task = New-Item 'task.bat' -Force
+Add-Content $task "call phpize 2>&1"
+Add-Content $task "call configure --with-php-build=C:\build-cache\deps --with-rdkafka --enable-debug-pack 2>&1"
+Add-Content $task "nmake /nologo 2>&1"
+Add-Content $task "exit %errorlevel%"
+& "C:\build-cache\php-sdk-$env:BIN_SDK_VER\phpsdk-$env:VC-$env:ARCH.bat" -t $task
+if (-not $?) {
+    throw "build failed with errorlevel $LastExitCode"
+}

base-images/nginx-php-fpm-main/php-rdkafka/.appveyor/install.ps1

+$ErrorActionPreference = "Stop"
+
+if (-not (Test-Path 'C:\build-cache')) {
+    [void](New-Item 'C:\build-cache' -ItemType 'directory')
+}
+
+$bname = "php-sdk-$env:BIN_SDK_VER.zip"
+if (-not (Test-Path "C:\build-cache\$bname")) {
+    Invoke-WebRequest "https://github.com/Microsoft/php-sdk-binary-tools/archive/$bname" -OutFile "C:\build-cache\$bname"
+}
+$dname0 = "php-sdk-binary-tools-php-sdk-$env:BIN_SDK_VER"
+$dname1 = "php-sdk-$env:BIN_SDK_VER"
+if (-not (Test-Path "C:\build-cache\$dname1")) {
+    Expand-Archive "C:\build-cache\$bname" 'C:\build-cache'
+    Move-Item "C:\build-cache\$dname0" "C:\build-cache\$dname1"
+}
+
+$gareleases = Invoke-WebRequest "https://windows.php.net/downloads/releases/releases.json" | ConvertFrom-Json
+$qareleases = Invoke-WebRequest "https://windows.php.net/downloads/qa/releases.json" | ConvertFrom-Json
+$garev = [regex]::split($gareleases.$env:PHP_VER.version, '[^\d]')[2]
+$qarev = [regex]::split($qareleases.$env:PHP_VER.version, '[^\d]')[2]
+if ($qarev -gt $garev) {
+    $phpversion = $qareleases.$env:PHP_VER.version
+    $phprelease = 'QA'
+} else {
+    $phpversion = $gareleases.$env:PHP_VER.version
+    $phprelease = 'GA'
+}
+
+$ts_part = ''
+if ($env:TS -eq '0') {
+    $ts_part += '-nts'
+}
+$bname = "php-devel-pack-$phpversion$ts_part-Win32-$env:VC-$env:ARCH.zip"
+if (-not (Test-Path "C:\build-cache\$bname")) {
+    if ($phprelease -eq "GA") {
+        Invoke-WebRequest "https://windows.php.net/downloads/releases/$bname" -OutFile "C:\build-cache\$bname"
+    } else {
+        Invoke-WebRequest "https://windows.php.net/downloads/qa/$bname" -OutFile "C:\build-cache\$bname"
+    }
+}
+$dname0 = "php-$phpversion-devel-$env:VC-$env:ARCH"
+$dname1 = "php-$phpversion$ts_part-devel-$env:VC-$env:ARCH"
+if (-not (Test-Path "C:\build-cache\$dname1")) {
+    Expand-Archive "C:\build-cache\$bname" 'C:\build-cache'
+    if ($dname0 -ne $dname1) {
+        Move-Item "C:\build-cache\$dname0" "C:\build-cache\$dname1"
+    }
+}
+$env:PATH = "C:\build-cache\$dname1;$env:PATH"
+
+$bname = "php-$phpversion$ts_part-Win32-$env:VC-$env:ARCH.zip"
+if (-not (Test-Path "C:\build-cache\$bname")) {
+    if ($phprelease -eq "GA") {
+        Invoke-WebRequest "https://windows.php.net/downloads/releases/$bname" -OutFile "C:\build-cache\$bname"
+    } else {
+        Invoke-WebRequest "https://windows.php.net/downloads/qa/$bname" -OutFile "C:\build-cache\$bname"
+    }
+}
+$dname = "php-$phpversion$ts_part-$env:VC-$env:ARCH"
+if (-not (Test-Path "C:\build-cache\$dname")) {
+    Expand-Archive "C:\build-cache\$bname" "C:\build-cache\$dname"
+}
+$env:PATH = "c:\build-cache\$dname;$env:PATH"
+
+$bname = "$env:DEP-$env:VC-$env:ARCH.zip"
+if (-not (Test-Path "C:\build-cache\$bname")) {
+    Invoke-WebRequest "http://windows.php.net/downloads/pecl/deps/$bname" -OutFile "C:\build-cache\$bname"
+    Expand-Archive "C:\build-cache\$bname" 'C:\build-cache\deps'
+    Copy-Item "C:\build-cache\deps\LICENSE" "C:\build-cache\deps\LICENSE.LIBRDKAFKA"
+}

base-images/nginx-php-fpm-main/php-rdkafka/.appveyor/package.ps1

+$ErrorActionPreference = "Stop"
+
+if ($env:TS -eq '0') {
+    $ts_part = 'nts'
+} else {
+    $ts_part = 'ts';
+}
+
+if ($env:APPVEYOR_REPO_TAG -eq "true") {
+    $bname = "php_rdkafka-$env:APPVEYOR_REPO_TAG_NAME-$env:PHP_VER-$ts_part-$env:VC-$env:ARCH"
+} else {
+    $bname = "php_rdkafka-$($env:APPVEYOR_REPO_COMMIT.substring(0, 8))-$env:PHP_VER-$ts_part-$env:VC-$env:ARCH"
+}
+$zip_bname = "$bname.zip"
+
+$dir = 'C:\projects\rdkafka\';
+if ($env:ARCH -eq 'x64') {
+    $dir += 'x64\'
+}
+$dir += 'Release'
+if ($env:TS -eq '1') {
+    $dir += '_TS'
+}
+
+$files = @(
+    "$dir\php_rdkafka.dll",
+    "$dir\php_rdkafka.pdb",
+    "C:\projects\rdkafka\CREDITS",
+    "C:\projects\rdkafka\LICENSE",
+    "C:\projects\rdkafka\README.md",
+    "C:\build-cache\deps\bin\librdkafka.dll",
+    "C:\build-cache\deps\bin\librdkafka.pdb",
+    "C:\build-cache\deps\LICENSE.LIBRDKAFKA"
+)
+Compress-Archive $files "C:\$zip_bname"
+Push-AppveyorArtifact "C:\$zip_bname"

base-images/nginx-php-fpm-main/php-rdkafka/.editorconfig

+root = true
+
+[*]
+insert_final_newline = true
+
+[*.{c,h}]
+indent_style = space
+indent_size = 4
+
+[.travis.yml]
+indent_style = space
+indent_size = 4
+
+[*.md]
+trim_trailing_whitespace = false
+
+[*.phpt]
+trim_trailing_whitespace = true
+indent_style = space
+indent_size = 4
+
+[package.xml]
+indent_style = space
+indent_size = 1

base-images/nginx-php-fpm-main/php-rdkafka/.github/FUNDING.yml

+github: arnaud-lb

base-images/nginx-php-fpm-main/php-rdkafka/.github/ISSUE_TEMPLATE/bug_report.yml

+name: Bug report
+description: Create a bug report
+labels: ["bug"]
+body:
+  - type: textarea
+    attributes:
+      label: Description
+      description: "Please provide a minimal way to reproduce the problem and describe what the expected vs actual behavior is."
+      value: |
+        The following code:
+
+        ```php
+        <?php
+        ```
+
+        Resulted in this output:
+        ```
+        ```
+
+        But I expected this output instead:
+        ```
+        ```
+    validations:
+      required: true
+  - type: input
+    attributes:
+      label: php-rdkafka Version
+      description: "The used php-rdkafka version (if installed from the repository, please specify the commit number)."
+      placeholder: "php-rdkafka 6.0.1 (or commit number)"
+    validations:
+      required: true
+  - type: input
+    attributes:
+      label: librdkafka Version
+      description: "The used librdkafka version, if relevant."
+      placeholder: "librdkafka 1.7.0"
+  - type: input
+    attributes:
+      label: PHP Version
+      description: "The used PHP version, if relevant."
+      placeholder: "PHP 8.1.0"
+  - type: input
+    attributes:
+      label: Operating System
+      description: "The used operating system, if relevant."
+      placeholder: "Ubuntu 20.04"
+  - type: input
+    attributes:
+      label: Kafka Version
+      description: "The used Kafka Version, if relevant."

base-images/nginx-php-fpm-main/php-rdkafka/.github/ISSUE_TEMPLATE/config.yml

+blank_issues_enabled: false
+contact_links:
+  - name: Support / Question
+    url: https://gitter.im/arnaud-lb/php-rdkafka
+    about: Please join gitter for support / questions.

base-images/nginx-php-fpm-main/php-rdkafka/.github/ISSUE_TEMPLATE/feature_request.yml

+name: Feature request
+description: Create a feature request
+labels: ["feature"]
+body:
+  - type: textarea
+    attributes:
+      label: Description
+      description: "Please describe the requested feature and why it should be included in php-rdkafka."
+    validations:
+      required: true

base-images/nginx-php-fpm-main/php-rdkafka/.github/release.yml

+# https://docs.github.com/en/repositories/releasing-projects-on-github/automatically-generated-release-notes
+
+changelog:
+  exclude:
+    labels:
+      - ignore-for-release
+      - doc
+    authors:
+      - octocat
+  categories:
+    - title: Improvements
+      labels:
+        - enhancement
+        - feature
+    - title: Deprecations
+      labels:
+        - deprecations
+    - title: Bugfixes
+      labels:
+        - bug
+        - bugfix
+    - title: Other Changes
+      labels:
+        - "*"

base-images/nginx-php-fpm-main/php-rdkafka/.github/workflows/package.yml

+name: 'Package'
+
+on:
+    pull_request:
+
+jobs:
+    package:
+        name: 'Package'
+        runs-on: 'ubuntu-20.04'
+        steps:
+            - name: 'Check out repository'
+              uses: 'actions/checkout@v2'
+              with:
+                  path: 'php-rdkafka'
+
+            - name: 'Install dependencies'
+              run: 'sudo apt-get -y install php7.4-dev librdkafka-dev'
+
+            - name: 'Package and verify package'
+              run: './php-rdkafka/.github/workflows/package/package.sh'
+
+            - name: 'Archive package'
+              uses: 'actions/upload-artifact@v2'
+              with:
+                  path: 'php-rdkafka/rdkafka.tgz'

base-images/nginx-php-fpm-main/php-rdkafka/.github/workflows/package/package.sh

+#!/bin/sh
+
+set -e
+
+cd php-rdkafka
+
+echo "Checking version consistency"
+
+CODE_VERSION="$(grep PHP_RDKAFKA_VERSION php_rdkafka.h|cut -d'"' -f2)"
+PACKAGE_VERSION="$(grep -m 1 '<release>' package.xml|cut -d'>' -f2|cut -d'<' -f1)"
+
+if ! [ "$CODE_VERSION" = "$PACKAGE_VERSION" ]; then
+    printf "Version in php_rdkafka.h does not match version in package.xml: '%s' vs '%s'" "$CODE_VERSION" "$PACKAGE_VERSION" >&2
+    exit 1
+fi
+
+echo "Packaging"
+
+pecl package
+
+echo "Installing package.xml"
+
+mv "./rdkafka-$PACKAGE_VERSION.tgz" rdkafka.tgz
+sudo pecl install ./rdkafka.tgz
+
+echo "Checking that all test files was included"
+
+sudo pecl list-files rdkafka|grep ^test|sed 's@.*/tests/@@'|sort > installed-test-files
+find tests/ -type f|sed 's@^tests/@@'|sort > repository-test-files
+
+if ! diff -u repository-test-files installed-test-files; then
+    echo "Some test files are missing from package.xml (see diff above)" >&2
+    exit 1
+fi

base-images/nginx-php-fpm-main/php-rdkafka/.github/workflows/release.yml

+# https://help.github.com/en/categories/automating-your-workflow-with-github-actions
+
+name: "Create release"
+
+on:
+  push:
+    tags:
+      - '*'
+
+concurrency: release
+
+jobs:
+  create_release:
+    name: "Create release"
+    runs-on: "ubuntu-latest"
+
+    steps:
+      - name: "Checkout"
+        uses: actions/checkout@v3
+
+      - name: "Generate release notes"
+        run: ./tools/extract-release-notes.php > ${{ github.workspace }}-CHANGELOG.txt
+
+      - name: "Create release"
+        uses: softprops/action-gh-release@v1
+        with:
+          # token: ${{ secrets.BOT_TOKEN }}
+          draft: true
+          discussion_category_name: "General"
+          body_path: ${{ github.workspace }}-CHANGELOG.txt

base-images/nginx-php-fpm-main/php-rdkafka/.github/workflows/test.yml

+name: 'Tests'
+
+on:
+    push:
+        branches:
+            - '6.x'
+    pull_request:
+    schedule:
+        - cron: '30 8 * * 1'
+
+jobs:
+    tests:
+        name: 'Tests'
+        strategy:
+          matrix:
+            include:
+              - php: '8.1.0'
+                librdkafka: 'v1.7.0'
+                memcheck: '1'
+              - php: '8.0.0'
+                librdkafka: 'v1.7.0'
+                memcheck: '1'
+              - php: '7.4.0'
+                librdkafka: 'v1.7.0'
+                memcheck: '1'
+              - php: '8.1.0'
+                librdkafka: 'v1.7.0'
+              - php: '8.0.0'
+                librdkafka: 'v1.7.0'
+              - php: '7.4.0'
+                librdkafka: 'v1.7.0'
+              - php: '7.3.0'
+                librdkafka: 'v1.7.0'
+              - php: '8.1.0'
+                librdkafka: 'v1.6.1'
+              - php: '8.0.0'
+                librdkafka: 'v1.6.1'
+              - php: '7.4.0'
+                librdkafka: 'v1.6.1'
+              - php: '7.3.0'
+                librdkafka: 'v1.6.1'
+              - php: '8.1.0'
+                librdkafka: 'v1.5.3'
+              - php: '8.0.0'
+                librdkafka: 'v1.5.3'
+              - php: '7.4.0'
+                librdkafka: 'v1.5.3'
+              - php: '7.3.0'
+                librdkafka: 'v1.5.3'
+              - php: '8.1.0'
+                librdkafka: 'v1.4.4'
+              - php: '8.0.0'
+                librdkafka: 'v1.4.4'
+              - php: '7.4.0'
+                librdkafka: 'v1.4.4'
+              - php: '7.3.0'
+                librdkafka: 'v1.4.4'
+              - php: '8.1.0'
+                librdkafka: 'v1.0.1'
+              - php: '8.0.0'
+                librdkafka: 'v1.0.1'
+              - php: '7.4.0'
+                librdkafka: 'v1.0.1'
+              - php: '7.3.0'
+                librdkafka: 'v1.0.1'
+              - php: '8.1.0'
+                librdkafka: 'v0.11.6'
+              - php: '8.0.0'
+                librdkafka: 'v0.11.6'
+              - php: '7.4.0'
+                librdkafka: 'v0.11.6'
+              - php: '7.3.0'
+                librdkafka: 'v0.11.6'
+              - php: '7.2.0'
+                librdkafka: 'v0.11.6'
+              - php: '7.1.0'
+                librdkafka: 'v0.11.6'
+              - php: '7.0.0'
+                librdkafka: 'v0.11.6'
+              - php: '8.1.0'
+                librdkafka: 'master'
+                experimental: true
+              - php: '8.0.0'
+                librdkafka: 'master'
+                experimental: true
+              - php: '7.4.0'
+                librdkafka: 'master'
+                experimental: true
+              - php: '7.3.0'
+                librdkafka: 'master'
+                experimental: true
+
+        runs-on: 'ubuntu-20.04'
+        continue-on-error: ${{ !!matrix.experimental }}
+        env:
+            PHP_VERSION: ${{ matrix.php }}
+            LIBRDKAFKA_VERSION: ${{ matrix.librdkafka }}
+            MEMORY_CHECK: ${{ matrix.memcheck }}
+            TEST_KAFKA_BROKERS: kafka:9092
+            TEST_KAFKA_BROKER_VERSION: 2.6
+        steps:
+            - name: 'Check out repository'
+              uses: 'actions/checkout@v2'
+              with:
+                  path: 'php-rdkafka'
+
+            - uses: actions/cache@v2
+              with:
+                  path: ~/build-cache/php
+                  key: ${{ runner.os }}-${{ matrix.php }}-${{ matrix.memcheck }}
+
+            - uses: actions/cache@v2
+              with:
+                  path: ~/build-cache/librdkafka
+                  key: ${{ runner.os }}-${{ matrix.librdkafka }}
+
+            - name: 'Build librdkafka'
+              run: './php-rdkafka/.github/workflows/test/build-librdkafka.sh'
+
+            - name: 'Build PHP'
+              run: './php-rdkafka/.github/workflows/test/build-php.sh'
+
+            - name: 'Build php-rdkafka'
+              run: './php-rdkafka/.github/workflows/test/build-php-rdkafka.sh'
+
+            - name: 'Start Kafka'
+              run: './php-rdkafka/.github/workflows/test/start-kafka.sh'
+
+            - name: 'Run tests'
+              run: './php-rdkafka/.github/workflows/test/tests.sh'

base-images/nginx-php-fpm-main/php-rdkafka/.github/workflows/test/build-librdkafka.sh

+#!/bin/sh
+
+set -ex
+
+if ! [ -f ~/build-cache/librdkafka/usr/local/include/librdkafka/rdkafka.h ] || ! [ -f ~/build-cache/librdkafka/usr/local/bin/kafkacat ]; then
+    echo "librdkafka build is not cached"
+
+    git clone --depth 1 --branch "${LIBRDKAFKA_VERSION:-1.5.0}" "${LIBRDKAFKA_REPOSITORY_URL:-https://github.com/edenhill/librdkafka.git}"
+
+    cd librdkafka
+    ./configure
+    make
+    mkdir -p ~/build-cache/librdkafka
+    sudo make install DESTDIR=$HOME/build-cache/librdkafka
+    test -f ~/build-cache/librdkafka/usr/local/include/librdkafka/rdkafka.h || echo "librdkafka build failed"
+
+    sudo rsync -a ~/build-cache/librdkafka/ /
+    sudo ldconfig
+    cd ..
+
+    git clone --depth 1 --branch "1.6.0" "${LIBRDKAFKA_REPOSITORY_URL:-https://github.com/edenhill/kafkacat.git}"
+
+    cd kafkacat
+    ./configure
+    make
+    sudo make install DESTDIR=$HOME/build-cache/librdkafka
+
+else
+    echo "librdkafka build is cached"
+fi
+
+sudo rsync -av ~/build-cache/librdkafka/ /
+sudo ldconfig

base-images/nginx-php-fpm-main/php-rdkafka/.github/workflows/test/build-php-rdkafka.sh

+#!/bin/sh
+
+set -e
+
+echo "Building php-rdkafka with PHP version:"
+php --version
+
+cd php-rdkafka
+
+PACKAGE_VERSION="$(grep -m 1 '<release>' package.xml|cut -d'>' -f2|cut -d'<' -f1)"
+
+pecl package
+
+if [ $MEMORY_CHECK -eq 1 ]; then
+    PHP_RDKAFKA_CFLAGS="-Wall -Werror -Wno-deprecated-declarations"
+fi
+
+sudo CFLAGS="$PHP_RDKAFKA_CFLAGS" pecl install "./rdkafka-$PACKAGE_VERSION.tgz"
+
+echo "extension=rdkafka.so"|sudo tee /usr/local/etc/php/rdkafka.ini >/dev/null

base-images/nginx-php-fpm-main/php-rdkafka/.github/workflows/test/build-php.sh

+#!/bin/sh
+
+set -ex
+
+if [ $MEMORY_CHECK -eq 1 ]; then
+    sudo apt-get -y install valgrind
+fi
+
+if ! [ -f ~/build-cache/php/usr/local/bin/php ]; then
+    echo "PHP build is not cached"
+    
+    wget https://secure.php.net/distributions/php-${PHP_VERSION}.tar.bz2
+    
+    tar xjf php-${PHP_VERSION}.tar.bz2
+    cd php-${PHP_VERSION}
+
+    PHP_BUILD_FLAGS="--prefix=/usr/local --disable-all --enable-cli --enable-cgi --with-config-file-scan-dir=/usr/local/etc/php --with-zlib"
+
+    if [ $MEMORY_CHECK -eq 1 ]; then
+        PHP_BUILD_FLAGS="$PHP_BUILD_FLAGS --enable-debug --with-valgrind"
+    else
+        case $PHP_VERSION in
+            8.*)
+                PHP_BUILD_FLAGS="$PHP_BUILD_FLAGS --enable-zts"
+                ;;
+            7.*)
+                PHP_BUILD_FLAGS="$PHP_BUILD_FLAGS --enable-maintainer-zts"
+                ;;
+        esac
+    fi
+
+    ./configure $PHP_BUILD_FLAGS $PHP_BUILD_EXTRA_FLAGS
+    make -j $(nproc)
+    mkdir -p ~/build-cache/php
+    sudo make install INSTALL_ROOT=$HOME/build-cache/php
+else
+    echo "PHP build is cached"
+fi
+
+sudo rsync -av ~/build-cache/php/ /
+sudo mkdir -p /usr/local/etc/php

base-images/nginx-php-fpm-main/php-rdkafka/.github/workflows/test/start-kafka.sh

+#!/bin/sh
+
+docker network create kafka_network
+docker pull wurstmeister/zookeeper:3.4.6
+docker run -d --network kafka_network --name zookeeper wurstmeister/zookeeper:3.4.6
+docker pull wurstmeister/kafka:2.13-2.6.0
+docker run -d -p 9092:9092 --network kafka_network -e "KAFKA_AUTO_CREATE_TOPICS_ENABLE=true" -e "KAFKA_CREATE_TOPICS=test-topic:1:1:compact" -e "KAFKA_ADVERTISED_HOST_NAME=kafka" -e "KAFKA_ZOOKEEPER_CONNECT=zookeeper:2181" -e "KAFKA_ADVERTISED_PORT=9092" --name kafka wurstmeister/kafka:2.13-2.6.0
+printf "\n127.0.0.1  kafka\n"|sudo tee /etc/hosts >/dev/null
+
+echo "Waiting for Kafka to be ready"
+
+for i in $(seq 1 20); do
+    if kafkacat -b 127.0.0.1 -L; then
+        echo "Kafka is ready"
+        exit 0
+    fi
+done
+
+echo "Timedout waiting for Kafka to be ready"
+exit 1

base-images/nginx-php-fpm-main/php-rdkafka/.github/workflows/test/tests.sh

+#!/bin/sh
+
+set -xve
+
+cd php-rdkafka
+
+if [ ${MEMORY_CHECK:-0} -eq 1 ]; then
+      echo "Enabling memory checking"
+      showmem=--show-mem
+      checkmem=-m
+fi
+
+cp tests/test_env.php.sample tests/test_env.php
+
+PHP=$(which php)
+sudo REPORT_EXIT_STATUS=1 TEST_PHP_EXECUTABLE="$PHP" "$PHP" /usr/local/lib/php/build/run-tests.php -q $checkmem --show-diff $showmem

base-images/nginx-php-fpm-main/php-rdkafka/.gitignore

+*.dep
+*.la
+*.lo
+*.swp
+.deps
+.libs
+Makefile
+Makefile.fragments
+Makefile.global
+Makefile.objects
+acinclude.m4
+aclocal.m4
+autom4te.cache
+build
+config.guess
+config.h
+config.h.in
+config.h.in~
+config.log
+config.nice
+config.status
+config.sub
+configure
+configure.ac
+configure.in
+include
+install-sh
+libtool
+ltmain.sh
+missing
+mkinstalldirs
+modules
+package.xml
+rdkafka-*.tgz
+run-tests.php
+tests/*/*.diff
+tests/*/*.exp
+tests/*/*.log
+tests/*/*.out
+tests/*/*.php
+tests/*/*.sh
+tmp-php.ini

base-images/nginx-php-fpm-main/php-rdkafka/CONTRIBUTING.md

+# How to contribute
+
+If you would like to contribute, thank you :)
+
+Here are a few informations you need to know before starting:
+
+## Branches
+
+Pull requests should be made against the 5.x branch, which supports both PHP 7 and PHP 8.
+
+## How to make good contributions
+
+- Before starting to work, maybe open an issue to find whether your change would be accepted.
+- Create relatively small PRs. This is easier to review, and will be merged faster. Do not send huge PRs with multiple unrelated changes.
+- Make sure that you followed the design/style (see bellow).
+- Make sure that your changes do not introduce new compiler warnings or errors.
+- Do not make changes that would break existing code.
+
+## Testing
+
+Tests are in phpt file format in the tests directory.
+
+### Using your own machine for building and testing. 
+
+Tests can be run by following compilation and installation procedure 
+and executing `make test`.
+
+To run integration tests, make sure you have Kafka instance running.
+Then, rename `test_env.php.sample` to `test_env.php` and adjust it
+with values proper for your kafka instance.
+
+## Design / naming things
+
+php-rdkafka's goal is to expose the librdkafka APIs to PHP scripts, without
+abstracting it. Rationale:
+
+- Abstractions would be inherently opinionated, which would make the extension
+  less than ideal or unusable in some cases.
+- Abstractions are easily implemented in pure PHP on top of the extension.
+- Remaining close to librdkafka in terms of naming/design makes it possible to
+  refer to librdkafka's documentation and other resources when needed.
+
+As a result, php-rdkafka will:
+
+ - Follow librdkafka's naming for everything
+ - Avoid introducing functions, helpers, classes that do not exist in
+   librdkafka (these are easy to implement in pure PHP, on top of the
+   extension).
+
+However, in order to make the API PHP-ish, some transformations have to be done.
+
+Here is the full design/style guide:
+
+ - For librdkafka functions that return an error type, or signal errors via
+   errno, php-rdkafka throws a Rdkafka\Exception
+ - librdkafka structs are exposed as PHP objects. The object name is derived
+   from the struct name like this:
+   - Remove the `rd_kafka_` prefix
+   - Convert from snake case to camel case
+   - Add `Rdkafka\` namespace
+ - `rd_kafka_*_new` functions are implemented as PHP object constructors / object
+   instantiation
+ - `rd_kafka_*_destroy` functions are implemented as PHP object free handlers
+ - librdkaka functions that take a struct as first argument are implemented as
+   a method of the struct's related PHP object
+ - The user should not be required to manage memory (e.g. free somthing)
+ - Do not change librdkafka's default behavior
+ - Be safe: No user error should cause a crash or a memory leak.
+

base-images/nginx-php-fpm-main/php-rdkafka/CREDITS

+rdkafka
+Arnaud Le Blanc

base-images/nginx-php-fpm-main/php-rdkafka/LICENSE

+The MIT License (MIT)
+
+Copyright (c) 2015 Arnaud Le Blanc
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

base-images/nginx-php-fpm-main/php-rdkafka/conf.h

+/*
+  +----------------------------------------------------------------------+
+  | php-rdkafka                                                          |
+  +----------------------------------------------------------------------+
+  | Copyright (c) 2016 Arnaud Le Blanc                                   |
+  +----------------------------------------------------------------------+
+  | This source file is subject to version 3.01 of the PHP license,      |
+  | that is bundled with this package in the file LICENSE, and is        |
+  | available through the world-wide-web at the following url:           |
+  | http://www.php.net/license/3_01.txt                                  |
+  | If you did not receive a copy of the PHP license and are unable to   |
+  | obtain it through the world-wide-web, please send a note to          |
+  | license@php.net so we can mail you a copy immediately.               |
+  +----------------------------------------------------------------------+
+  | Author: Arnaud Le Blanc <arnaud.lb@gmail.com>                        |
+  +----------------------------------------------------------------------+
+*/
+
+#ifndef KAFKA_CONF_H
+#define KAFKA_CONF_H
+
+enum {
+        MSG_PARTITIONER_RANDOM = 2,
+        MSG_PARTITIONER_CONSISTENT = 3,
+        MSG_PARTITIONER_CONSISTENT_RANDOM = 4,
+        MSG_PARTITIONER_MURMUR2 = 5,
+        MSG_PARTITIONER_MURMUR2_RANDOM = 6
+};
+
+typedef enum {
+    KAFKA_CONF = 1,
+    KAFKA_TOPIC_CONF
+} kafka_conf_type;
+
+typedef struct _kafka_conf_callback {
+    zend_fcall_info fci;
+    zend_fcall_info_cache fcc;
+} kafka_conf_callback;
+
+typedef struct _kafka_conf_callbacks {
+    zval zrk;
+    kafka_conf_callback *error;
+    kafka_conf_callback *rebalance;
+    kafka_conf_callback *dr_msg;
+    kafka_conf_callback *stats;
+    kafka_conf_callback *consume;
+    kafka_conf_callback *offset_commit;
+    kafka_conf_callback *log;
+} kafka_conf_callbacks;
+
+typedef struct _kafka_conf_object {
+    kafka_conf_type type;
+    union {
+        rd_kafka_conf_t         *conf;
+        rd_kafka_topic_conf_t   *topic_conf;
+    } u;
+    kafka_conf_callbacks cbs;
+    zend_object                 std;
+} kafka_conf_object;
+
+kafka_conf_object * get_kafka_conf_object(zval *zconf);
+void kafka_conf_minit(INIT_FUNC_ARGS);
+
+void kafka_conf_callbacks_dtor(kafka_conf_callbacks *cbs);
+void kafka_conf_callbacks_copy(kafka_conf_callbacks *to, kafka_conf_callbacks *from);
+
+void kafka_conf_dr_msg_cb(rd_kafka_t *rk, const rd_kafka_message_t *msg, void *opaque);
+
+extern zend_class_entry * ce_kafka_conf;
+extern zend_class_entry * ce_kafka_topic_conf;
+
+#endif /* KAFKA_CONF_H */

base-images/nginx-php-fpm-main/php-rdkafka/conf.stub.php

+<?php
+
+/**
+ * @generate-class-entries
+ * @generate-function-entries
+ * @generate-legacy-arginfo
+ */
+
+namespace RdKafka;
+
+class Conf
+{
+    public function __construct() {}
+
+    /** @tentative-return-type */
+    public function dump(): array {}
+
+    /** @tentative-return-type */
+    public function set(string $name, string $value): void {}
+
+    /**
+     * @tentative-return-type
+     * @deprecated
+     */
+    public function setDefaultTopicConf(TopicConf $topic_conf): void {}
+
+    /** @tentative-return-type */
+    public function setErrorCb(callable $callback): void {}
+
+    /** @tentative-return-type */
+    public function setDrMsgCb(callable $callback): void {}
+
+    /** @tentative-return-type */
+    public function setStatsCb(callable $callback): void {}
+
+    /** @tentative-return-type */
+    public function setRebalanceCb(callable $callback): void {}
+
+    /** @tentative-return-type */
+    public function setConsumeCb(callable $callback): void {}
+
+    /** @tentative-return-type */
+    public function setOffsetCommitCb(callable $callback): void {}
+
+    /** @tentative-return-type */
+    public function setLogCb(callable $callback): void {}
+}
+
+class TopicConf
+{
+    public function __construct() {}
+
+    /**
+     * @tentative-return-type
+     * @implementation-alias RdKafka\Conf::dump
+     */
+    public function dump(): array {}
+
+    /**
+     * @tentative-return-type
+     * @implementation-alias RdKafka\Conf::set
+     */
+    public function set(string $name, string $value): void {}
+
+    /** @tentative-return-type */
+    public function setPartitioner(int $partitioner): void {}
+}

base-images/nginx-php-fpm-main/php-rdkafka/conf_arginfo.h

+/* This is a generated file, edit the .stub.php file instead.
+ * Stub hash: 86e8e9fcd235f3affc4ef30ca0d96395abcad13f */
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_RdKafka_Conf___construct, 0, 0, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_TENTATIVE_RETURN_TYPE_INFO_EX(arginfo_class_RdKafka_Conf_dump, 0, 0, IS_ARRAY, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_TENTATIVE_RETURN_TYPE_INFO_EX(arginfo_class_RdKafka_Conf_set, 0, 2, IS_VOID, 0)
+	ZEND_ARG_TYPE_INFO(0, name, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, value, IS_STRING, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_TENTATIVE_RETURN_TYPE_INFO_EX(arginfo_class_RdKafka_Conf_setDefaultTopicConf, 0, 1, IS_VOID, 0)
+	ZEND_ARG_OBJ_INFO(0, topic_conf, RdKafka\\TopicConf, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_TENTATIVE_RETURN_TYPE_INFO_EX(arginfo_class_RdKafka_Conf_setErrorCb, 0, 1, IS_VOID, 0)
+	ZEND_ARG_TYPE_INFO(0, callback, IS_CALLABLE, 0)
+ZEND_END_ARG_INFO()
+
+#define arginfo_class_RdKafka_Conf_setDrMsgCb arginfo_class_RdKafka_Conf_setErrorCb
+
+#define arginfo_class_RdKafka_Conf_setStatsCb arginfo_class_RdKafka_Conf_setErrorCb
+
+#define arginfo_class_RdKafka_Conf_setRebalanceCb arginfo_class_RdKafka_Conf_setErrorCb
+
+#define arginfo_class_RdKafka_Conf_setConsumeCb arginfo_class_RdKafka_Conf_setErrorCb
+
+#define arginfo_class_RdKafka_Conf_setOffsetCommitCb arginfo_class_RdKafka_Conf_setErrorCb
+
+#define arginfo_class_RdKafka_Conf_setLogCb arginfo_class_RdKafka_Conf_setErrorCb
+
+#define arginfo_class_RdKafka_TopicConf___construct arginfo_class_RdKafka_Conf___construct
+
+#define arginfo_class_RdKafka_TopicConf_dump arginfo_class_RdKafka_Conf_dump
+
+#define arginfo_class_RdKafka_TopicConf_set arginfo_class_RdKafka_Conf_set
+
+ZEND_BEGIN_ARG_WITH_TENTATIVE_RETURN_TYPE_INFO_EX(arginfo_class_RdKafka_TopicConf_setPartitioner, 0, 1, IS_VOID, 0)
+	ZEND_ARG_TYPE_INFO(0, partitioner, IS_LONG, 0)
+ZEND_END_ARG_INFO()
+
+
+ZEND_METHOD(RdKafka_Conf, __construct);
+ZEND_METHOD(RdKafka_Conf, dump);
+ZEND_METHOD(RdKafka_Conf, set);
+ZEND_METHOD(RdKafka_Conf, setDefaultTopicConf);
+ZEND_METHOD(RdKafka_Conf, setErrorCb);
+ZEND_METHOD(RdKafka_Conf, setDrMsgCb);
+ZEND_METHOD(RdKafka_Conf, setStatsCb);
+ZEND_METHOD(RdKafka_Conf, setRebalanceCb);
+ZEND_METHOD(RdKafka_Conf, setConsumeCb);
+ZEND_METHOD(RdKafka_Conf, setOffsetCommitCb);
+ZEND_METHOD(RdKafka_Conf, setLogCb);
+ZEND_METHOD(RdKafka_TopicConf, __construct);
+ZEND_METHOD(RdKafka_TopicConf, setPartitioner);
+
+
+static const zend_function_entry class_RdKafka_Conf_methods[] = {
+	ZEND_ME(RdKafka_Conf, __construct, arginfo_class_RdKafka_Conf___construct, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_Conf, dump, arginfo_class_RdKafka_Conf_dump, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_Conf, set, arginfo_class_RdKafka_Conf_set, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_Conf, setDefaultTopicConf, arginfo_class_RdKafka_Conf_setDefaultTopicConf, ZEND_ACC_PUBLIC|ZEND_ACC_DEPRECATED)
+	ZEND_ME(RdKafka_Conf, setErrorCb, arginfo_class_RdKafka_Conf_setErrorCb, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_Conf, setDrMsgCb, arginfo_class_RdKafka_Conf_setDrMsgCb, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_Conf, setStatsCb, arginfo_class_RdKafka_Conf_setStatsCb, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_Conf, setRebalanceCb, arginfo_class_RdKafka_Conf_setRebalanceCb, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_Conf, setConsumeCb, arginfo_class_RdKafka_Conf_setConsumeCb, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_Conf, setOffsetCommitCb, arginfo_class_RdKafka_Conf_setOffsetCommitCb, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_Conf, setLogCb, arginfo_class_RdKafka_Conf_setLogCb, ZEND_ACC_PUBLIC)
+	ZEND_FE_END
+};
+
+
+static const zend_function_entry class_RdKafka_TopicConf_methods[] = {
+	ZEND_ME(RdKafka_TopicConf, __construct, arginfo_class_RdKafka_TopicConf___construct, ZEND_ACC_PUBLIC)
+	ZEND_MALIAS(RdKafka_Conf, dump, dump, arginfo_class_RdKafka_TopicConf_dump, ZEND_ACC_PUBLIC)
+	ZEND_MALIAS(RdKafka_Conf, set, set, arginfo_class_RdKafka_TopicConf_set, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_TopicConf, setPartitioner, arginfo_class_RdKafka_TopicConf_setPartitioner, ZEND_ACC_PUBLIC)
+	ZEND_FE_END
+};
+
+static zend_class_entry *register_class_RdKafka_Conf(void)
+{
+	zend_class_entry ce, *class_entry;
+
+	INIT_NS_CLASS_ENTRY(ce, "RdKafka", "Conf", class_RdKafka_Conf_methods);
+	class_entry = zend_register_internal_class_ex(&ce, NULL);
+
+	return class_entry;
+}
+
+static zend_class_entry *register_class_RdKafka_TopicConf(void)
+{
+	zend_class_entry ce, *class_entry;
+
+	INIT_NS_CLASS_ENTRY(ce, "RdKafka", "TopicConf", class_RdKafka_TopicConf_methods);
+	class_entry = zend_register_internal_class_ex(&ce, NULL);
+
+	return class_entry;
+}

base-images/nginx-php-fpm-main/php-rdkafka/conf_legacy_arginfo.h

+/* This is a generated file, edit the .stub.php file instead.
+ * Stub hash: 86e8e9fcd235f3affc4ef30ca0d96395abcad13f */
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_RdKafka_Conf___construct, 0, 0, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_RdKafka_Conf_dump, 0, 0, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_RdKafka_Conf_set, 0, 0, 2)
+	ZEND_ARG_INFO(0, name)
+	ZEND_ARG_INFO(0, value)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_RdKafka_Conf_setDefaultTopicConf, 0, 0, 1)
+	ZEND_ARG_INFO(0, topic_conf)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_RdKafka_Conf_setErrorCb, 0, 0, 1)
+	ZEND_ARG_INFO(0, callback)
+ZEND_END_ARG_INFO()
+
+#define arginfo_class_RdKafka_Conf_setDrMsgCb arginfo_class_RdKafka_Conf_setErrorCb
+
+#define arginfo_class_RdKafka_Conf_setStatsCb arginfo_class_RdKafka_Conf_setErrorCb
+
+#define arginfo_class_RdKafka_Conf_setRebalanceCb arginfo_class_RdKafka_Conf_setErrorCb
+
+#define arginfo_class_RdKafka_Conf_setConsumeCb arginfo_class_RdKafka_Conf_setErrorCb
+
+#define arginfo_class_RdKafka_Conf_setOffsetCommitCb arginfo_class_RdKafka_Conf_setErrorCb
+
+#define arginfo_class_RdKafka_Conf_setLogCb arginfo_class_RdKafka_Conf_setErrorCb
+
+#define arginfo_class_RdKafka_TopicConf___construct arginfo_class_RdKafka_Conf___construct
+
+#define arginfo_class_RdKafka_TopicConf_dump arginfo_class_RdKafka_Conf_dump
+
+#define arginfo_class_RdKafka_TopicConf_set arginfo_class_RdKafka_Conf_set
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_RdKafka_TopicConf_setPartitioner, 0, 0, 1)
+	ZEND_ARG_INFO(0, partitioner)
+ZEND_END_ARG_INFO()
+
+
+ZEND_METHOD(RdKafka_Conf, __construct);
+ZEND_METHOD(RdKafka_Conf, dump);
+ZEND_METHOD(RdKafka_Conf, set);
+ZEND_METHOD(RdKafka_Conf, setDefaultTopicConf);
+ZEND_METHOD(RdKafka_Conf, setErrorCb);
+ZEND_METHOD(RdKafka_Conf, setDrMsgCb);
+ZEND_METHOD(RdKafka_Conf, setStatsCb);
+ZEND_METHOD(RdKafka_Conf, setRebalanceCb);
+ZEND_METHOD(RdKafka_Conf, setConsumeCb);
+ZEND_METHOD(RdKafka_Conf, setOffsetCommitCb);
+ZEND_METHOD(RdKafka_Conf, setLogCb);
+ZEND_METHOD(RdKafka_TopicConf, __construct);
+ZEND_METHOD(RdKafka_TopicConf, setPartitioner);
+
+
+static const zend_function_entry class_RdKafka_Conf_methods[] = {
+	ZEND_ME(RdKafka_Conf, __construct, arginfo_class_RdKafka_Conf___construct, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_Conf, dump, arginfo_class_RdKafka_Conf_dump, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_Conf, set, arginfo_class_RdKafka_Conf_set, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_Conf, setDefaultTopicConf, arginfo_class_RdKafka_Conf_setDefaultTopicConf, ZEND_ACC_PUBLIC|ZEND_ACC_DEPRECATED)
+	ZEND_ME(RdKafka_Conf, setErrorCb, arginfo_class_RdKafka_Conf_setErrorCb, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_Conf, setDrMsgCb, arginfo_class_RdKafka_Conf_setDrMsgCb, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_Conf, setStatsCb, arginfo_class_RdKafka_Conf_setStatsCb, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_Conf, setRebalanceCb, arginfo_class_RdKafka_Conf_setRebalanceCb, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_Conf, setConsumeCb, arginfo_class_RdKafka_Conf_setConsumeCb, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_Conf, setOffsetCommitCb, arginfo_class_RdKafka_Conf_setOffsetCommitCb, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_Conf, setLogCb, arginfo_class_RdKafka_Conf_setLogCb, ZEND_ACC_PUBLIC)
+	ZEND_FE_END
+};
+
+
+static const zend_function_entry class_RdKafka_TopicConf_methods[] = {
+	ZEND_ME(RdKafka_TopicConf, __construct, arginfo_class_RdKafka_TopicConf___construct, ZEND_ACC_PUBLIC)
+	ZEND_MALIAS(RdKafka_Conf, dump, dump, arginfo_class_RdKafka_TopicConf_dump, ZEND_ACC_PUBLIC)
+	ZEND_MALIAS(RdKafka_Conf, set, set, arginfo_class_RdKafka_TopicConf_set, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_TopicConf, setPartitioner, arginfo_class_RdKafka_TopicConf_setPartitioner, ZEND_ACC_PUBLIC)
+	ZEND_FE_END
+};
+
+static zend_class_entry *register_class_RdKafka_Conf(void)
+{
+	zend_class_entry ce, *class_entry;
+
+	INIT_NS_CLASS_ENTRY(ce, "RdKafka", "Conf", class_RdKafka_Conf_methods);
+	class_entry = zend_register_internal_class_ex(&ce, NULL);
+
+	return class_entry;
+}
+
+static zend_class_entry *register_class_RdKafka_TopicConf(void)
+{
+	zend_class_entry ce, *class_entry;
+
+	INIT_NS_CLASS_ENTRY(ce, "RdKafka", "TopicConf", class_RdKafka_TopicConf_methods);
+	class_entry = zend_register_internal_class_ex(&ce, NULL);
+
+	return class_entry;
+}

base-images/nginx-php-fpm-main/php-rdkafka/config.m4

+dnl $Id$
+dnl config.m4 for extension rdkafka
+
+PHP_ARG_WITH(rdkafka, for rdkafka support,
+[  --with-rdkafka             Include rdkafka support])
+
+if test "$PHP_RDKAFKA" != "no"; then
+
+  SEARCH_PATH="/usr/local /usr"     # you might want to change this
+  SEARCH_FOR="/include/librdkafka/rdkafka.h"  # you most likely want to change this
+  if test -r $PHP_RDKAFKA/$SEARCH_FOR; then # path given as parameter
+    RDKAFKA_DIR=$PHP_RDKAFKA
+  else # search default path list
+    AC_MSG_CHECKING([for librdkafka/rdkafka.h" in default path])
+    for i in $SEARCH_PATH ; do
+      if test -r $i/$SEARCH_FOR; then
+        RDKAFKA_DIR=$i
+        AC_MSG_RESULT(found in $i)
+      fi
+    done
+  fi
+  
+  if test -z "$RDKAFKA_DIR"; then
+    AC_MSG_RESULT([not found])
+    AC_MSG_ERROR([Please reinstall the rdkafka distribution])
+  fi
+
+  PHP_ADD_INCLUDE($RDKAFKA_DIR/include)
+
+  SOURCES="rdkafka.c metadata.c metadata_broker.c metadata_topic.c metadata_partition.c metadata_collection.c conf.c topic.c queue.c message.c fun.c kafka_consumer.c topic_partition.c"
+
+  LIBNAME=rdkafka
+  LIBSYMBOL=rd_kafka_new
+
+  PHP_CHECK_LIBRARY($LIBNAME,$LIBSYMBOL,
+  [
+    PHP_ADD_LIBRARY_WITH_PATH($LIBNAME, $RDKAFKA_DIR/$PHP_LIBDIR, RDKAFKA_SHARED_LIBADD)
+    AC_DEFINE(HAVE_RDKAFKALIB,1,[ ])
+  ],[
+    AC_MSG_ERROR([wrong rdkafka lib version or lib not found])
+  ],[
+    -L$RDKAFKA_DIR/$PHP_LIBDIR -lm
+  ])
+
+  ORIG_LDFLAGS="$LDFLAGS"
+  ORIG_CPPFLAGS="$CPPFLAGS"
+  LDFLAGS="-L$RDKAFKA_DIR/$PHP_LIBDIR -lm"
+  CPPFLAGS="-I$RDKAFKA_DIR/include"
+
+  AC_MSG_CHECKING([for librdkafka version])
+  AC_EGREP_CPP(yes,[
+#include <librdkafka/rdkafka.h>
+#if RD_KAFKA_VERSION >= 0x000b0000
+  yes
+#endif
+  ],[
+    AC_MSG_RESULT([>= 0.11.0])
+  ],[
+    AC_MSG_ERROR([librdkafka version 0.11.0 or greater required.])
+  ])
+
+  AC_CHECK_LIB($LIBNAME,[rd_kafka_message_headers],[
+    AC_DEFINE(HAVE_RD_KAFKA_MESSAGE_HEADERS,1,[ ])
+  ],[
+    AC_MSG_WARN([no rd_kafka_message_headers, headers support will not be available])
+  ])
+
+  AC_CHECK_LIB($LIBNAME,[rd_kafka_purge],[
+    AC_DEFINE(HAS_RD_KAFKA_PURGE,1,[ ])
+  ],[
+    AC_MSG_WARN([purge is not available])
+  ])
+
+  AC_CHECK_LIB($LIBNAME,[rd_kafka_init_transactions],[
+    AC_DEFINE(HAS_RD_KAFKA_TRANSACTIONS,1,[ ])
+    SOURCES="$SOURCES kafka_error_exception.c"
+  ],[
+    AC_MSG_WARN([transactions are not available])
+  ])
+
+  AC_CHECK_LIB($LIBNAME,[rd_kafka_msg_partitioner_murmur2],[
+    AC_DEFINE(HAS_RD_KAFKA_PARTITIONER_MURMUR2,1,[ ])
+  ],[
+    AC_MSG_WARN([murmur2 partitioner is not available])
+  ])
+
+  LDFLAGS="$ORIG_LDFLAGS"
+  CPPFLAGS="$ORIG_CPPFLAGS"
+
+  PHP_SUBST(RDKAFKA_SHARED_LIBADD)
+
+  PHP_NEW_EXTENSION(rdkafka, $SOURCES, $ext_shared)
+fi

base-images/nginx-php-fpm-main/php-rdkafka/config.w32

+// $Id$
+// vim:ft=javascript
+
+ARG_WITH("rdkafka", "for rdkafka support", "no");
+
+if (PHP_RDKAFKA != "no") {
+	if (CHECK_LIB("librdkafka.lib", "rdkafka", PHP_RDKAFKA) &&
+		CHECK_HEADER_ADD_INCLUDE("librdkafka/rdkafka.h", "CFLAGS_RDKAFKA")) {
+
+		AC_DEFINE('HAVE_RD_KAFKA_MESSAGE_HEADERS', 1, '');
+		AC_DEFINE('HAS_RD_KAFKA_PURGE', 1, '');
+		AC_DEFINE('HAS_RD_KAFKA_TRANSACTIONS', 1, '');
+		AC_DEFINE('HAS_RD_KAFKA_PARTITIONER_MURMUR2', 1, '');
+		EXTENSION("rdkafka", "rdkafka.c metadata.c metadata_broker.c metadata_topic.c \
+				metadata_partition.c metadata_collection.c conf.c \
+				topic.c queue.c message.c fun.c kafka_consumer.c topic_partition.c kafka_error_exception.c");
+
+		AC_DEFINE('HAVE_RDKAFKA', 1, '');
+	} else {
+		WARNING("rdkafka not enabled; libraries and headers not found");
+	}
+}
+

base-images/nginx-php-fpm-main/php-rdkafka/examples/README.md

+For examples please check the documentation: https://arnaud-lb.github.io/php-rdkafka/phpdoc/rdkafka.examples.html

base-images/nginx-php-fpm-main/php-rdkafka/fun.c

+/*
+  +----------------------------------------------------------------------+
+  | php-rdkafka                                                          |
+  +----------------------------------------------------------------------+
+  | Copyright (c) 2016 Arnaud Le Blanc                                   |
+  +----------------------------------------------------------------------+
+  | This source file is subject to version 3.01 of the PHP license,      |
+  | that is bundled with this package in the file LICENSE, and is        |
+  | available through the world-wide-web at the following url:           |
+  | http://www.php.net/license/3_01.txt                                  |
+  | If you did not receive a copy of the PHP license and are unable to   |
+  | obtain it through the world-wide-web, please send a note to          |
+  | license@php.net so we can mail you a copy immediately.               |
+  +----------------------------------------------------------------------+
+  | Author: Arnaud Le Blanc <arnaud.lb@gmail.com>                        |
+  +----------------------------------------------------------------------+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "php.h"
+#include "php_rdkafka.h"
+#include "php_rdkafka_priv.h"
+#include "librdkafka/rdkafka.h"
+#include "Zend/zend_exceptions.h"
+#include "ext/spl/spl_exceptions.h"
+
+/* {{{ proto array rd_kafka_get_err_descs()
+ * Returns the full list of error codes.
+ */
+PHP_FUNCTION(rd_kafka_get_err_descs)
+{
+    const struct rd_kafka_err_desc *errdescs;
+    size_t cnt;
+    size_t i;
+    int seen_zero = 0;
+
+    if (zend_parse_parameters_none() == FAILURE) {
+        return;
+    }
+
+    rd_kafka_get_err_descs(&errdescs, &cnt);
+
+    array_init_size(return_value, cnt);
+
+    for (i = 0; i < cnt; i++) {
+        const struct rd_kafka_err_desc *desc = &errdescs[i];
+        zval el;
+
+        if (desc->code == 0) {
+            if (seen_zero) {
+                continue;
+            }
+            seen_zero = 1;
+        }
+
+        ZVAL_NULL(&el);
+        array_init(&el);
+        add_assoc_long(&el, "code", desc->code);
+        if (desc->name) {
+            add_assoc_string(&el, "name", (char*) desc->name);
+        } else {
+            add_assoc_null(&el, "name");
+        }
+        if (desc->desc) {
+            add_assoc_string(&el, "desc", (char*) desc->desc);
+        }else {
+            add_assoc_null(&el, "desc");
+        }
+        add_next_index_zval(return_value, &el);
+    }
+}
+/* }}} */
+
+/* {{{ proto string rd_kafka_err2name(int $err)
+ * Returns the name of an error code
+ */
+PHP_FUNCTION(rd_kafka_err2name)
+{
+    zend_long err;
+    const char *name;
+
+    if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &err) == FAILURE) {
+        return;
+    }
+
+    name = rd_kafka_err2name(err);
+
+    if (name) {
+        RETURN_STRING(name);
+    }
+}
+
+/* }}} */
+/* {{{ proto string rd_kafka_err2str(int $err)
+ * Returns a human readable representation of a kafka error.
+ */
+PHP_FUNCTION(rd_kafka_err2str)
+{
+    zend_long err;
+    const char *errstr;
+
+    if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &err) == FAILURE) {
+        return;
+    }
+
+    errstr = rd_kafka_err2str(err);
+
+    if (errstr) {
+        RETURN_STRING(errstr);
+    }
+}
+/* }}} */
+
+/* {{{ proto int rd_kafka_errno()
+ * Returns `errno` */
+PHP_FUNCTION(rd_kafka_errno)
+{
+    if (zend_parse_parameters(ZEND_NUM_ARGS(), "") == FAILURE) {
+        return;
+    }
+
+    RETURN_LONG(errno);
+}
+/* }}} */
+
+/* {{{ proto int rd_kafka_errno2err(int $errnox)
+ * Converts `errno` to a rdkafka error code */
+PHP_FUNCTION(rd_kafka_errno2err)
+{
+    zend_long errnox;
+
+    if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &errnox) == FAILURE) {
+        return;
+    }
+
+    RETURN_LONG(rd_kafka_errno2err(errnox));
+}
+/* }}} */
+
+/* {{{ proto int rd_kafka_thread_cnt()
+ * Retrieve the current number of threads in use by librdkafka.
+ */
+PHP_FUNCTION(rd_kafka_thread_cnt)
+{
+    if (zend_parse_parameters_none() == FAILURE) {
+        return;
+    }
+
+    RETURN_LONG(rd_kafka_thread_cnt());
+}
+/* }}} */
+
+/* {{{ proto int rd_kafka_offset_tail(int $cnt)
+ * Start consuming `$cnt` messages from topic's current `.._END` offset.
+ */
+PHP_FUNCTION(rd_kafka_offset_tail)
+{
+    zend_long cnt;
+
+    if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &cnt) == FAILURE) {
+        return;
+    }
+
+    RETURN_LONG(RD_KAFKA_OFFSET_TAIL(cnt));
+}
+/* }}} */

base-images/nginx-php-fpm-main/php-rdkafka/fun.stub.php

+<?php
+
+/**
+ * @generate-function-entries
+ * @generate-legacy-arginfo
+ */
+
+function rd_kafka_get_err_descs(): array {}
+
+function rd_kafka_err2name(int $err): ?string {}
+
+function rd_kafka_err2str(int $err): ?string {}
+
+/** @deprecated */
+function rd_kafka_errno2err(int $errnox): int {}
+
+/** @deprecated */
+function rd_kafka_errno(): int {}
+
+function rd_kafka_offset_tail(int $cnt): int {}
+
+function rd_kafka_thread_cnt(): int {}

base-images/nginx-php-fpm-main/php-rdkafka/fun_arginfo.h

+/* This is a generated file, edit the .stub.php file instead.
+ * Stub hash: 0e1e56d853a47168a1f7f0950b674c2de6a91976 */
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_rd_kafka_get_err_descs, 0, 0, IS_ARRAY, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_rd_kafka_err2name, 0, 1, IS_STRING, 1)
+	ZEND_ARG_TYPE_INFO(0, err, IS_LONG, 0)
+ZEND_END_ARG_INFO()
+
+#define arginfo_rd_kafka_err2str arginfo_rd_kafka_err2name
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_rd_kafka_errno2err, 0, 1, IS_LONG, 0)
+	ZEND_ARG_TYPE_INFO(0, errnox, IS_LONG, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_rd_kafka_errno, 0, 0, IS_LONG, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_rd_kafka_offset_tail, 0, 1, IS_LONG, 0)
+	ZEND_ARG_TYPE_INFO(0, cnt, IS_LONG, 0)
+ZEND_END_ARG_INFO()
+
+#define arginfo_rd_kafka_thread_cnt arginfo_rd_kafka_errno
+
+
+ZEND_FUNCTION(rd_kafka_get_err_descs);
+ZEND_FUNCTION(rd_kafka_err2name);
+ZEND_FUNCTION(rd_kafka_err2str);
+ZEND_FUNCTION(rd_kafka_errno2err);
+ZEND_FUNCTION(rd_kafka_errno);
+ZEND_FUNCTION(rd_kafka_offset_tail);
+ZEND_FUNCTION(rd_kafka_thread_cnt);
+
+
+static const zend_function_entry ext_functions[] = {
+	ZEND_FE(rd_kafka_get_err_descs, arginfo_rd_kafka_get_err_descs)
+	ZEND_FE(rd_kafka_err2name, arginfo_rd_kafka_err2name)
+	ZEND_FE(rd_kafka_err2str, arginfo_rd_kafka_err2str)
+	ZEND_DEP_FE(rd_kafka_errno2err, arginfo_rd_kafka_errno2err)
+	ZEND_DEP_FE(rd_kafka_errno, arginfo_rd_kafka_errno)
+	ZEND_FE(rd_kafka_offset_tail, arginfo_rd_kafka_offset_tail)
+	ZEND_FE(rd_kafka_thread_cnt, arginfo_rd_kafka_thread_cnt)
+	ZEND_FE_END
+};

base-images/nginx-php-fpm-main/php-rdkafka/fun_legacy_arginfo.h

+/* This is a generated file, edit the .stub.php file instead.
+ * Stub hash: 0e1e56d853a47168a1f7f0950b674c2de6a91976 */
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_rd_kafka_get_err_descs, 0, 0, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_rd_kafka_err2name, 0, 0, 1)
+	ZEND_ARG_INFO(0, err)
+ZEND_END_ARG_INFO()
+
+#define arginfo_rd_kafka_err2str arginfo_rd_kafka_err2name
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_rd_kafka_errno2err, 0, 0, 1)
+	ZEND_ARG_INFO(0, errnox)
+ZEND_END_ARG_INFO()
+
+#define arginfo_rd_kafka_errno arginfo_rd_kafka_get_err_descs
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_rd_kafka_offset_tail, 0, 0, 1)
+	ZEND_ARG_INFO(0, cnt)
+ZEND_END_ARG_INFO()
+
+#define arginfo_rd_kafka_thread_cnt arginfo_rd_kafka_get_err_descs
+
+
+ZEND_FUNCTION(rd_kafka_get_err_descs);
+ZEND_FUNCTION(rd_kafka_err2name);
+ZEND_FUNCTION(rd_kafka_err2str);
+ZEND_FUNCTION(rd_kafka_errno2err);
+ZEND_FUNCTION(rd_kafka_errno);
+ZEND_FUNCTION(rd_kafka_offset_tail);
+ZEND_FUNCTION(rd_kafka_thread_cnt);
+
+
+static const zend_function_entry ext_functions[] = {
+	ZEND_FE(rd_kafka_get_err_descs, arginfo_rd_kafka_get_err_descs)
+	ZEND_FE(rd_kafka_err2name, arginfo_rd_kafka_err2name)
+	ZEND_FE(rd_kafka_err2str, arginfo_rd_kafka_err2str)
+	ZEND_DEP_FE(rd_kafka_errno2err, arginfo_rd_kafka_errno2err)
+	ZEND_DEP_FE(rd_kafka_errno, arginfo_rd_kafka_errno)
+	ZEND_FE(rd_kafka_offset_tail, arginfo_rd_kafka_offset_tail)
+	ZEND_FE(rd_kafka_thread_cnt, arginfo_rd_kafka_thread_cnt)
+	ZEND_FE_END
+};

base-images/nginx-php-fpm-main/php-rdkafka/kafka_consumer.h

+/*
+  +----------------------------------------------------------------------+
+  | php-rdkafka                                                          |
+  +----------------------------------------------------------------------+
+  | Copyright (c) 2016 Arnaud Le Blanc                                   |
+  +----------------------------------------------------------------------+
+  | This source file is subject to version 3.01 of the PHP license,      |
+  | that is bundled with this package in the file LICENSE, and is        |
+  | available through the world-wide-web at the following url:           |
+  | http://www.php.net/license/3_01.txt                                  |
+  | If you did not receive a copy of the PHP license and are unable to   |
+  | obtain it through the world-wide-web, please send a note to          |
+  | license@php.net so we can mail you a copy immediately.               |
+  +----------------------------------------------------------------------+
+  | Author: Arnaud Le Blanc <arnaud.lb@gmail.com>                        |
+  +----------------------------------------------------------------------+
+*/
+
+void kafka_kafka_consumer_minit(INIT_FUNC_ARGS);

base-images/nginx-php-fpm-main/php-rdkafka/kafka_consumer.stub.php

+<?php
+
+/**
+ * @generate-class-entries
+ * @generate-function-entries
+ * @generate-legacy-arginfo
+ */
+
+namespace RdKafka;
+
+class KafkaConsumer
+{
+    private ?callable $error_cb;
+
+    private ?callable $rebalance_cb;
+
+    private ?callable $dr_msg_cb;
+
+    public function __construct(Conf $conf) {}
+
+    /** @tentative-return-type */
+    public function assign(?array $topic_partitions = null): void {}
+
+    /** @tentative-return-type */
+    public function getAssignment(): array {}
+
+    /** @tentative-return-type */
+    public function commit(Message|array|null $message_or_offsets = null): void {}
+
+    /** @tentative-return-type */
+    public function close(): void {}
+
+    /** @tentative-return-type */
+    public function commitAsync(Message|array|null $message_or_offsets = null): void {}
+
+    /** @tentative-return-type */
+    public function consume(int $timeout_ms): Message {}
+
+    /** @tentative-return-type */
+    public function subscribe(array $topics): void {}
+
+    /** @tentative-return-type */
+    public function getSubscription(): array {}
+
+    /** @tentative-return-type */
+    public function unsubscribe(): void {}
+
+    /** @tentative-return-type */
+    public function getMetadata(bool $all_topics, ?Topic $only_topic, int $timeout_ms): Metadata {}
+
+    /** @tentative-return-type */
+    public function newTopic(string $topic_name, ?TopicConf $topic_conf = null): KafkaConsumerTopic {}
+
+    /** @tentative-return-type */
+    public function getCommittedOffsets(array $topic_partitions, int $timeout_ms): array {}
+
+    /** @tentative-return-type */
+    public function getOffsetPositions(array $topic_partitions): array {}
+
+    /** @tentative-return-type */
+    public function queryWatermarkOffsets(string $topic, int $partition, int &$low, int &$high, int $timeout_ms): void {}
+
+    /** @tentative-return-type */
+    public function offsetsForTimes(array $topic_partitions, int $timeout_ms): array {}
+
+    /** @tentative-return-type */
+    public function pausePartitions(array $topic_partitions): array {}
+
+    /** @tentative-return-type */
+    public function resumePartitions(array $topic_partitions): array {}
+}

base-images/nginx-php-fpm-main/php-rdkafka/kafka_consumer_arginfo.h

+/* This is a generated file, edit the .stub.php file instead.
+ * Stub hash: 47e9238c79f5508833423d31a2e09041754dbffb */
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_RdKafka_KafkaConsumer___construct, 0, 0, 1)
+	ZEND_ARG_OBJ_INFO(0, conf, RdKafka\\Conf, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_TENTATIVE_RETURN_TYPE_INFO_EX(arginfo_class_RdKafka_KafkaConsumer_assign, 0, 0, IS_VOID, 0)
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, topic_partitions, IS_ARRAY, 1, "null")
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_TENTATIVE_RETURN_TYPE_INFO_EX(arginfo_class_RdKafka_KafkaConsumer_getAssignment, 0, 0, IS_ARRAY, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_TENTATIVE_RETURN_TYPE_INFO_EX(arginfo_class_RdKafka_KafkaConsumer_commit, 0, 0, IS_VOID, 0)
+	ZEND_ARG_OBJ_TYPE_MASK(0, message_or_offsets, RdKafka\\Message, MAY_BE_ARRAY|MAY_BE_NULL, "null")
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_TENTATIVE_RETURN_TYPE_INFO_EX(arginfo_class_RdKafka_KafkaConsumer_close, 0, 0, IS_VOID, 0)
+ZEND_END_ARG_INFO()
+
+#define arginfo_class_RdKafka_KafkaConsumer_commitAsync arginfo_class_RdKafka_KafkaConsumer_commit
+
+ZEND_BEGIN_ARG_WITH_TENTATIVE_RETURN_OBJ_INFO_EX(arginfo_class_RdKafka_KafkaConsumer_consume, 0, 1, RdKafka\\Message, 0)
+	ZEND_ARG_TYPE_INFO(0, timeout_ms, IS_LONG, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_TENTATIVE_RETURN_TYPE_INFO_EX(arginfo_class_RdKafka_KafkaConsumer_subscribe, 0, 1, IS_VOID, 0)
+	ZEND_ARG_TYPE_INFO(0, topics, IS_ARRAY, 0)
+ZEND_END_ARG_INFO()
+
+#define arginfo_class_RdKafka_KafkaConsumer_getSubscription arginfo_class_RdKafka_KafkaConsumer_getAssignment
+
+#define arginfo_class_RdKafka_KafkaConsumer_unsubscribe arginfo_class_RdKafka_KafkaConsumer_close
+
+ZEND_BEGIN_ARG_WITH_TENTATIVE_RETURN_OBJ_INFO_EX(arginfo_class_RdKafka_KafkaConsumer_getMetadata, 0, 3, RdKafka\\Metadata, 0)
+	ZEND_ARG_TYPE_INFO(0, all_topics, _IS_BOOL, 0)
+	ZEND_ARG_OBJ_INFO(0, only_topic, RdKafka\\Topic, 1)
+	ZEND_ARG_TYPE_INFO(0, timeout_ms, IS_LONG, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_TENTATIVE_RETURN_OBJ_INFO_EX(arginfo_class_RdKafka_KafkaConsumer_newTopic, 0, 1, RdKafka\\KafkaConsumerTopic, 0)
+	ZEND_ARG_TYPE_INFO(0, topic_name, IS_STRING, 0)
+	ZEND_ARG_OBJ_INFO_WITH_DEFAULT_VALUE(0, topic_conf, RdKafka\\TopicConf, 1, "null")
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_TENTATIVE_RETURN_TYPE_INFO_EX(arginfo_class_RdKafka_KafkaConsumer_getCommittedOffsets, 0, 2, IS_ARRAY, 0)
+	ZEND_ARG_TYPE_INFO(0, topic_partitions, IS_ARRAY, 0)
+	ZEND_ARG_TYPE_INFO(0, timeout_ms, IS_LONG, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_TENTATIVE_RETURN_TYPE_INFO_EX(arginfo_class_RdKafka_KafkaConsumer_getOffsetPositions, 0, 1, IS_ARRAY, 0)
+	ZEND_ARG_TYPE_INFO(0, topic_partitions, IS_ARRAY, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_TENTATIVE_RETURN_TYPE_INFO_EX(arginfo_class_RdKafka_KafkaConsumer_queryWatermarkOffsets, 0, 5, IS_VOID, 0)
+	ZEND_ARG_TYPE_INFO(0, topic, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, partition, IS_LONG, 0)
+	ZEND_ARG_TYPE_INFO(1, low, IS_LONG, 0)
+	ZEND_ARG_TYPE_INFO(1, high, IS_LONG, 0)
+	ZEND_ARG_TYPE_INFO(0, timeout_ms, IS_LONG, 0)
+ZEND_END_ARG_INFO()
+
+#define arginfo_class_RdKafka_KafkaConsumer_offsetsForTimes arginfo_class_RdKafka_KafkaConsumer_getCommittedOffsets
+
+#define arginfo_class_RdKafka_KafkaConsumer_pausePartitions arginfo_class_RdKafka_KafkaConsumer_getOffsetPositions
+
+#define arginfo_class_RdKafka_KafkaConsumer_resumePartitions arginfo_class_RdKafka_KafkaConsumer_getOffsetPositions
+
+
+ZEND_METHOD(RdKafka_KafkaConsumer, __construct);
+ZEND_METHOD(RdKafka_KafkaConsumer, assign);
+ZEND_METHOD(RdKafka_KafkaConsumer, getAssignment);
+ZEND_METHOD(RdKafka_KafkaConsumer, commit);
+ZEND_METHOD(RdKafka_KafkaConsumer, close);
+ZEND_METHOD(RdKafka_KafkaConsumer, commitAsync);
+ZEND_METHOD(RdKafka_KafkaConsumer, consume);
+ZEND_METHOD(RdKafka_KafkaConsumer, subscribe);
+ZEND_METHOD(RdKafka_KafkaConsumer, getSubscription);
+ZEND_METHOD(RdKafka_KafkaConsumer, unsubscribe);
+ZEND_METHOD(RdKafka_KafkaConsumer, getMetadata);
+ZEND_METHOD(RdKafka_KafkaConsumer, newTopic);
+ZEND_METHOD(RdKafka_KafkaConsumer, getCommittedOffsets);
+ZEND_METHOD(RdKafka_KafkaConsumer, getOffsetPositions);
+ZEND_METHOD(RdKafka_KafkaConsumer, queryWatermarkOffsets);
+ZEND_METHOD(RdKafka_KafkaConsumer, offsetsForTimes);
+ZEND_METHOD(RdKafka_KafkaConsumer, pausePartitions);
+ZEND_METHOD(RdKafka_KafkaConsumer, resumePartitions);
+
+
+static const zend_function_entry class_RdKafka_KafkaConsumer_methods[] = {
+	ZEND_ME(RdKafka_KafkaConsumer, __construct, arginfo_class_RdKafka_KafkaConsumer___construct, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_KafkaConsumer, assign, arginfo_class_RdKafka_KafkaConsumer_assign, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_KafkaConsumer, getAssignment, arginfo_class_RdKafka_KafkaConsumer_getAssignment, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_KafkaConsumer, commit, arginfo_class_RdKafka_KafkaConsumer_commit, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_KafkaConsumer, close, arginfo_class_RdKafka_KafkaConsumer_close, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_KafkaConsumer, commitAsync, arginfo_class_RdKafka_KafkaConsumer_commitAsync, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_KafkaConsumer, consume, arginfo_class_RdKafka_KafkaConsumer_consume, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_KafkaConsumer, subscribe, arginfo_class_RdKafka_KafkaConsumer_subscribe, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_KafkaConsumer, getSubscription, arginfo_class_RdKafka_KafkaConsumer_getSubscription, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_KafkaConsumer, unsubscribe, arginfo_class_RdKafka_KafkaConsumer_unsubscribe, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_KafkaConsumer, getMetadata, arginfo_class_RdKafka_KafkaConsumer_getMetadata, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_KafkaConsumer, newTopic, arginfo_class_RdKafka_KafkaConsumer_newTopic, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_KafkaConsumer, getCommittedOffsets, arginfo_class_RdKafka_KafkaConsumer_getCommittedOffsets, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_KafkaConsumer, getOffsetPositions, arginfo_class_RdKafka_KafkaConsumer_getOffsetPositions, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_KafkaConsumer, queryWatermarkOffsets, arginfo_class_RdKafka_KafkaConsumer_queryWatermarkOffsets, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_KafkaConsumer, offsetsForTimes, arginfo_class_RdKafka_KafkaConsumer_offsetsForTimes, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_KafkaConsumer, pausePartitions, arginfo_class_RdKafka_KafkaConsumer_pausePartitions, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_KafkaConsumer, resumePartitions, arginfo_class_RdKafka_KafkaConsumer_resumePartitions, ZEND_ACC_PUBLIC)
+	ZEND_FE_END
+};
+
+static zend_class_entry *register_class_RdKafka_KafkaConsumer(void)
+{
+	zend_class_entry ce, *class_entry;
+
+	INIT_NS_CLASS_ENTRY(ce, "RdKafka", "KafkaConsumer", class_RdKafka_KafkaConsumer_methods);
+	class_entry = zend_register_internal_class_ex(&ce, NULL);
+
+	zval property_error_cb_default_value;
+	ZVAL_UNDEF(&property_error_cb_default_value);
+	zend_string *property_error_cb_name = zend_string_init("error_cb", sizeof("error_cb") - 1, 1);
+	zend_declare_typed_property(class_entry, property_error_cb_name, &property_error_cb_default_value, ZEND_ACC_PRIVATE, NULL, (zend_type) ZEND_TYPE_INIT_MASK(MAY_BE_CALLABLE|MAY_BE_NULL));
+	zend_string_release(property_error_cb_name);
+
+	zval property_rebalance_cb_default_value;
+	ZVAL_UNDEF(&property_rebalance_cb_default_value);
+	zend_string *property_rebalance_cb_name = zend_string_init("rebalance_cb", sizeof("rebalance_cb") - 1, 1);
+	zend_declare_typed_property(class_entry, property_rebalance_cb_name, &property_rebalance_cb_default_value, ZEND_ACC_PRIVATE, NULL, (zend_type) ZEND_TYPE_INIT_MASK(MAY_BE_CALLABLE|MAY_BE_NULL));
+	zend_string_release(property_rebalance_cb_name);
+
+	zval property_dr_msg_cb_default_value;
+	ZVAL_UNDEF(&property_dr_msg_cb_default_value);
+	zend_string *property_dr_msg_cb_name = zend_string_init("dr_msg_cb", sizeof("dr_msg_cb") - 1, 1);
+	zend_declare_typed_property(class_entry, property_dr_msg_cb_name, &property_dr_msg_cb_default_value, ZEND_ACC_PRIVATE, NULL, (zend_type) ZEND_TYPE_INIT_MASK(MAY_BE_CALLABLE|MAY_BE_NULL));
+	zend_string_release(property_dr_msg_cb_name);
+
+	return class_entry;
+}

base-images/nginx-php-fpm-main/php-rdkafka/kafka_consumer_legacy_arginfo.h

+/* This is a generated file, edit the .stub.php file instead.
+ * Stub hash: 47e9238c79f5508833423d31a2e09041754dbffb */
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_RdKafka_KafkaConsumer___construct, 0, 0, 1)
+	ZEND_ARG_INFO(0, conf)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_RdKafka_KafkaConsumer_assign, 0, 0, 0)
+	ZEND_ARG_INFO(0, topic_partitions)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_RdKafka_KafkaConsumer_getAssignment, 0, 0, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_RdKafka_KafkaConsumer_commit, 0, 0, 0)
+	ZEND_ARG_INFO(0, message_or_offsets)
+ZEND_END_ARG_INFO()
+
+#define arginfo_class_RdKafka_KafkaConsumer_close arginfo_class_RdKafka_KafkaConsumer_getAssignment
+
+#define arginfo_class_RdKafka_KafkaConsumer_commitAsync arginfo_class_RdKafka_KafkaConsumer_commit
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_RdKafka_KafkaConsumer_consume, 0, 0, 1)
+	ZEND_ARG_INFO(0, timeout_ms)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_RdKafka_KafkaConsumer_subscribe, 0, 0, 1)
+	ZEND_ARG_INFO(0, topics)
+ZEND_END_ARG_INFO()
+
+#define arginfo_class_RdKafka_KafkaConsumer_getSubscription arginfo_class_RdKafka_KafkaConsumer_getAssignment
+
+#define arginfo_class_RdKafka_KafkaConsumer_unsubscribe arginfo_class_RdKafka_KafkaConsumer_getAssignment
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_RdKafka_KafkaConsumer_getMetadata, 0, 0, 3)
+	ZEND_ARG_INFO(0, all_topics)
+	ZEND_ARG_INFO(0, only_topic)
+	ZEND_ARG_INFO(0, timeout_ms)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_RdKafka_KafkaConsumer_newTopic, 0, 0, 1)
+	ZEND_ARG_INFO(0, topic_name)
+	ZEND_ARG_INFO(0, topic_conf)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_RdKafka_KafkaConsumer_getCommittedOffsets, 0, 0, 2)
+	ZEND_ARG_INFO(0, topic_partitions)
+	ZEND_ARG_INFO(0, timeout_ms)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_RdKafka_KafkaConsumer_getOffsetPositions, 0, 0, 1)
+	ZEND_ARG_INFO(0, topic_partitions)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_RdKafka_KafkaConsumer_queryWatermarkOffsets, 0, 0, 5)
+	ZEND_ARG_INFO(0, topic)
+	ZEND_ARG_INFO(0, partition)
+	ZEND_ARG_INFO(1, low)
+	ZEND_ARG_INFO(1, high)
+	ZEND_ARG_INFO(0, timeout_ms)
+ZEND_END_ARG_INFO()
+
+#define arginfo_class_RdKafka_KafkaConsumer_offsetsForTimes arginfo_class_RdKafka_KafkaConsumer_getCommittedOffsets
+
+#define arginfo_class_RdKafka_KafkaConsumer_pausePartitions arginfo_class_RdKafka_KafkaConsumer_getOffsetPositions
+
+#define arginfo_class_RdKafka_KafkaConsumer_resumePartitions arginfo_class_RdKafka_KafkaConsumer_getOffsetPositions
+
+
+ZEND_METHOD(RdKafka_KafkaConsumer, __construct);
+ZEND_METHOD(RdKafka_KafkaConsumer, assign);
+ZEND_METHOD(RdKafka_KafkaConsumer, getAssignment);
+ZEND_METHOD(RdKafka_KafkaConsumer, commit);
+ZEND_METHOD(RdKafka_KafkaConsumer, close);
+ZEND_METHOD(RdKafka_KafkaConsumer, commitAsync);
+ZEND_METHOD(RdKafka_KafkaConsumer, consume);
+ZEND_METHOD(RdKafka_KafkaConsumer, subscribe);
+ZEND_METHOD(RdKafka_KafkaConsumer, getSubscription);
+ZEND_METHOD(RdKafka_KafkaConsumer, unsubscribe);
+ZEND_METHOD(RdKafka_KafkaConsumer, getMetadata);
+ZEND_METHOD(RdKafka_KafkaConsumer, newTopic);
+ZEND_METHOD(RdKafka_KafkaConsumer, getCommittedOffsets);
+ZEND_METHOD(RdKafka_KafkaConsumer, getOffsetPositions);
+ZEND_METHOD(RdKafka_KafkaConsumer, queryWatermarkOffsets);
+ZEND_METHOD(RdKafka_KafkaConsumer, offsetsForTimes);
+ZEND_METHOD(RdKafka_KafkaConsumer, pausePartitions);
+ZEND_METHOD(RdKafka_KafkaConsumer, resumePartitions);
+
+
+static const zend_function_entry class_RdKafka_KafkaConsumer_methods[] = {
+	ZEND_ME(RdKafka_KafkaConsumer, __construct, arginfo_class_RdKafka_KafkaConsumer___construct, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_KafkaConsumer, assign, arginfo_class_RdKafka_KafkaConsumer_assign, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_KafkaConsumer, getAssignment, arginfo_class_RdKafka_KafkaConsumer_getAssignment, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_KafkaConsumer, commit, arginfo_class_RdKafka_KafkaConsumer_commit, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_KafkaConsumer, close, arginfo_class_RdKafka_KafkaConsumer_close, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_KafkaConsumer, commitAsync, arginfo_class_RdKafka_KafkaConsumer_commitAsync, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_KafkaConsumer, consume, arginfo_class_RdKafka_KafkaConsumer_consume, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_KafkaConsumer, subscribe, arginfo_class_RdKafka_KafkaConsumer_subscribe, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_KafkaConsumer, getSubscription, arginfo_class_RdKafka_KafkaConsumer_getSubscription, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_KafkaConsumer, unsubscribe, arginfo_class_RdKafka_KafkaConsumer_unsubscribe, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_KafkaConsumer, getMetadata, arginfo_class_RdKafka_KafkaConsumer_getMetadata, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_KafkaConsumer, newTopic, arginfo_class_RdKafka_KafkaConsumer_newTopic, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_KafkaConsumer, getCommittedOffsets, arginfo_class_RdKafka_KafkaConsumer_getCommittedOffsets, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_KafkaConsumer, getOffsetPositions, arginfo_class_RdKafka_KafkaConsumer_getOffsetPositions, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_KafkaConsumer, queryWatermarkOffsets, arginfo_class_RdKafka_KafkaConsumer_queryWatermarkOffsets, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_KafkaConsumer, offsetsForTimes, arginfo_class_RdKafka_KafkaConsumer_offsetsForTimes, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_KafkaConsumer, pausePartitions, arginfo_class_RdKafka_KafkaConsumer_pausePartitions, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_KafkaConsumer, resumePartitions, arginfo_class_RdKafka_KafkaConsumer_resumePartitions, ZEND_ACC_PUBLIC)
+	ZEND_FE_END
+};
+
+static zend_class_entry *register_class_RdKafka_KafkaConsumer(void)
+{
+	zend_class_entry ce, *class_entry;
+
+	INIT_NS_CLASS_ENTRY(ce, "RdKafka", "KafkaConsumer", class_RdKafka_KafkaConsumer_methods);
+	class_entry = zend_register_internal_class_ex(&ce, NULL);
+
+	zval property_error_cb_default_value;
+	ZVAL_NULL(&property_error_cb_default_value);
+	zend_string *property_error_cb_name = zend_string_init("error_cb", sizeof("error_cb") - 1, 1);
+	zend_declare_property_ex(class_entry, property_error_cb_name, &property_error_cb_default_value, ZEND_ACC_PRIVATE, NULL);
+	zend_string_release(property_error_cb_name);
+
+	zval property_rebalance_cb_default_value;
+	ZVAL_NULL(&property_rebalance_cb_default_value);
+	zend_string *property_rebalance_cb_name = zend_string_init("rebalance_cb", sizeof("rebalance_cb") - 1, 1);
+	zend_declare_property_ex(class_entry, property_rebalance_cb_name, &property_rebalance_cb_default_value, ZEND_ACC_PRIVATE, NULL);
+	zend_string_release(property_rebalance_cb_name);
+
+	zval property_dr_msg_cb_default_value;
+	ZVAL_NULL(&property_dr_msg_cb_default_value);
+	zend_string *property_dr_msg_cb_name = zend_string_init("dr_msg_cb", sizeof("dr_msg_cb") - 1, 1);
+	zend_declare_property_ex(class_entry, property_dr_msg_cb_name, &property_dr_msg_cb_default_value, ZEND_ACC_PRIVATE, NULL);
+	zend_string_release(property_dr_msg_cb_name);
+
+	return class_entry;
+}

base-images/nginx-php-fpm-main/php-rdkafka/kafka_error_exception.c

+/*
+  +----------------------------------------------------------------------+
+  | php-rdkafka                                                          |
+  +----------------------------------------------------------------------+
+  | Copyright (c) 2016 Arnaud Le Blanc                                   |
+  +----------------------------------------------------------------------+
+  | This source file is subject to version 3.01 of the PHP license,      |
+  | that is bundled with this package in the file LICENSE, and is        |
+  | available through the world-wide-web at the following url:           |
+  | http://www.php.net/license/3_01.txt                                  |
+  | If you did not receive a copy of the PHP license and are unable to   |
+  | obtain it through the world-wide-web, please send a note to          |
+  | license@php.net so we can mail you a copy immediately.               |
+  +----------------------------------------------------------------------+
+  | Author: Arnaud Le Blanc <arnaud.lb@gmail.com>                        |
+  +----------------------------------------------------------------------+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "php.h"
+#ifdef HAS_RD_KAFKA_TRANSACTIONS
+#include "php_rdkafka.h"
+#include "php_rdkafka_priv.h"
+#include "Zend/zend_interfaces.h"
+#include "Zend/zend_exceptions.h"
+#include "kafka_error_exception.h"
+#if PHP_VERSION_ID < 80000
+#include "kafka_error_exception_legacy_arginfo.h"
+#else
+#include "kafka_error_exception_arginfo.h"
+#endif
+
+zend_class_entry * ce_kafka_error;
+
+void create_kafka_error(zval *return_value, const rd_kafka_error_t *error) /* {{{ */
+{
+    object_init_ex(return_value, ce_kafka_error);
+
+    zend_update_property_string(ce_kafka_error, Z_RDKAFKA_PROP_OBJ(return_value), ZEND_STRL("message"), rd_kafka_error_name(error));
+    zend_update_property_long(ce_kafka_error, Z_RDKAFKA_PROP_OBJ(return_value), ZEND_STRL("code"), rd_kafka_error_code(error));
+    zend_update_property_string(ce_kafka_error, Z_RDKAFKA_PROP_OBJ(return_value), ZEND_STRL("error_string"), rd_kafka_error_string(error));
+    zend_update_property_bool(ce_kafka_error, Z_RDKAFKA_PROP_OBJ(return_value), ZEND_STRL("isFatal"), rd_kafka_error_is_fatal(error));
+    zend_update_property_bool(ce_kafka_error, Z_RDKAFKA_PROP_OBJ(return_value), ZEND_STRL("isRetriable"), rd_kafka_error_is_retriable(error));
+    zend_update_property_bool(ce_kafka_error, Z_RDKAFKA_PROP_OBJ(return_value), ZEND_STRL("transactionRequiresAbort"), rd_kafka_error_txn_requires_abort(error));
+
+    Z_ADDREF_P(return_value);
+}
+/* }}} */
+
+/* {{{ proto RdKafka\KafkaErrorException::__construct(string $message, int $code[, string $error_string, bool $isFatal, bool $isRetriable, bool $transactionRequiresAbort]) */
+PHP_METHOD(RdKafka_KafkaErrorException, __construct)
+{
+    char *message, *error_string = "";
+    size_t message_length = 0, error_string_length = 0;
+    zend_bool isFatal = 0, isRetriable = 0, transactionRequiresAbort = 0;
+    zend_long code = 0;
+
+    if (zend_parse_parameters(ZEND_NUM_ARGS(), "sl|sbbb", &message, &message_length, &code, &error_string, &error_string_length, &isFatal, &isRetriable, &transactionRequiresAbort) == FAILURE) {
+        return;
+    }
+
+    zend_update_property_string(ce_kafka_error, Z_RDKAFKA_PROP_OBJ(getThis()), ZEND_STRL("message"), message);
+    zend_update_property_long(ce_kafka_error, Z_RDKAFKA_PROP_OBJ(getThis()), ZEND_STRL("code"), code);
+    zend_update_property_string(ce_kafka_error, Z_RDKAFKA_PROP_OBJ(getThis()), ZEND_STRL("error_string"), error_string);
+    zend_update_property_bool(ce_kafka_error, Z_RDKAFKA_PROP_OBJ(getThis()), ZEND_STRL("isFatal"), isFatal);
+    zend_update_property_bool(ce_kafka_error, Z_RDKAFKA_PROP_OBJ(getThis()), ZEND_STRL("isRetriable"), isRetriable);
+    zend_update_property_bool(ce_kafka_error, Z_RDKAFKA_PROP_OBJ(getThis()), ZEND_STRL("transactionRequiresAbort"), transactionRequiresAbort);
+}
+/* }}} */
+
+/* {{{ proto void RdKafka\KafkaErrorException::getErrorString()
+    Get name of error */
+PHP_METHOD(RdKafka_KafkaErrorException, getErrorString)
+{
+    zval *res;
+
+    if (zend_parse_parameters(ZEND_NUM_ARGS(), "") == FAILURE) {
+        return;
+    }
+
+    res = rdkafka_read_property(ce_kafka_error, Z_RDKAFKA_PROP_OBJ(getThis()), ZEND_STRL("error_string"), 0);
+
+    if (!res || Z_TYPE_P(res) != IS_STRING) {
+        return;
+    }
+
+    ZVAL_DEREF(res);
+    ZVAL_COPY(return_value, res);
+}
+/* }}} */
+
+
+/* {{{ proto void RdKafka\KafkaErrorException::isFatal()
+    Return true if error is fatal */
+PHP_METHOD(RdKafka_KafkaErrorException, isFatal)
+{
+    zval *res;
+
+    if (zend_parse_parameters(ZEND_NUM_ARGS(), "") == FAILURE) {
+        return;
+    }
+
+    res = rdkafka_read_property(ce_kafka_error, Z_RDKAFKA_PROP_OBJ(getThis()), ZEND_STRL("isFatal"), 0);
+
+    if (!res || (Z_TYPE_P(res) != IS_TRUE && Z_TYPE_P(res) != IS_FALSE)) {
+        return;
+    }
+
+    ZVAL_DEREF(res);
+    ZVAL_COPY(return_value, res);
+}
+/* }}} */
+
+/* {{{ proto void RdKafka\KafkaErrorException::isRetriable()
+    Return true if error is fatal */
+PHP_METHOD(RdKafka_KafkaErrorException, isRetriable)
+{
+    zval *res;
+
+    if (zend_parse_parameters(ZEND_NUM_ARGS(), "") == FAILURE) {
+        return;
+    }
+
+    res = rdkafka_read_property(ce_kafka_error, Z_RDKAFKA_PROP_OBJ(getThis()), ZEND_STRL("isRetriable"), 0);
+
+    if (!res || (Z_TYPE_P(res) != IS_TRUE && Z_TYPE_P(res) != IS_FALSE)) {
+        return;
+    }
+
+    ZVAL_DEREF(res);
+    ZVAL_COPY(return_value, res);
+}
+/* }}} */
+
+/* {{{ proto void RdKafka\KafkaErrorException::transactionRequiresAbort()
+    Return true if error is fatal */
+PHP_METHOD(RdKafka_KafkaErrorException, transactionRequiresAbort)
+{
+    zval *res;
+
+    if (zend_parse_parameters(ZEND_NUM_ARGS(), "") == FAILURE) {
+        return;
+    }
+
+    res = rdkafka_read_property(ce_kafka_error, Z_RDKAFKA_PROP_OBJ(getThis()), ZEND_STRL("transactionRequiresAbort"), 0);
+
+    if (!res || (Z_TYPE_P(res) != IS_TRUE && Z_TYPE_P(res) != IS_FALSE)) {
+        return;
+    }
+
+    ZVAL_DEREF(res);
+    ZVAL_COPY(return_value, res);
+}
+/* }}} */
+
+void kafka_error_minit() /* {{{ */
+{
+    ce_kafka_error = register_class_RdKafka_KafkaErrorException(ce_kafka_exception);
+} /* }}} */
+#endif
+

base-images/nginx-php-fpm-main/php-rdkafka/kafka_error_exception.h

+/*
+  +----------------------------------------------------------------------+
+  | php-rdkafka                                                          |
+  +----------------------------------------------------------------------+
+  | Copyright (c) 2016 Arnaud Le Blanc                                   |
+  +----------------------------------------------------------------------+
+  | This source file is subject to version 3.01 of the PHP license,      |
+  | that is bundled with this package in the file LICENSE, and is        |
+  | available through the world-wide-web at the following url:           |
+  | http://www.php.net/license/3_01.txt                                  |
+  | If you did not receive a copy of the PHP license and are unable to   |
+  | obtain it through the world-wide-web, please send a note to          |
+  | license@php.net so we can mail you a copy immediately.               |
+  +----------------------------------------------------------------------+
+  | Author: Arnaud Le Blanc <arnaud.lb@gmail.com>                        |
+  +----------------------------------------------------------------------+
+*/
+
+#ifdef HAS_RD_KAFKA_TRANSACTIONS
+
+#include "librdkafka/rdkafka.h"
+#include "Zend/zend_interfaces.h"
+
+extern zend_class_entry * ce_kafka_error;
+void kafka_error_minit();
+void create_kafka_error(zval *return_value, const rd_kafka_error_t *error);
+#endif

base-images/nginx-php-fpm-main/php-rdkafka/kafka_error_exception.stub.php

+<?php
+
+/**
+ * @generate-class-entries
+ * @generate-function-entries
+ * @generate-legacy-arginfo
+ */
+
+namespace RdKafka;
+
+class KafkaErrorException extends Exception
+{
+    private string $error_string;
+
+    private bool $isFatal;
+
+    private bool $isRetriable;
+
+    private bool $transactionRequiresAbort;
+
+    public function __construct(string $message, int $code, string $error_string, bool $isFatal, bool $isRetriable, bool $transactionRequiresAbort) {}
+
+    /** @tentative-return-type */
+    public function getErrorString(): string {}
+
+    /** @tentative-return-type */
+    public function isFatal(): bool {}
+
+    /** @tentative-return-type */
+    public function isRetriable(): bool {}
+
+    /** @tentative-return-type */
+    public function transactionRequiresAbort(): bool {}
+}

base-images/nginx-php-fpm-main/php-rdkafka/kafka_error_exception_arginfo.h

+/* This is a generated file, edit the .stub.php file instead.
+ * Stub hash: 1a50cd552973f23b01a2d6b4e5464ba14320c393 */
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_RdKafka_KafkaErrorException___construct, 0, 0, 6)
+	ZEND_ARG_TYPE_INFO(0, message, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, code, IS_LONG, 0)
+	ZEND_ARG_TYPE_INFO(0, error_string, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO(0, isFatal, _IS_BOOL, 0)
+	ZEND_ARG_TYPE_INFO(0, isRetriable, _IS_BOOL, 0)
+	ZEND_ARG_TYPE_INFO(0, transactionRequiresAbort, _IS_BOOL, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_TENTATIVE_RETURN_TYPE_INFO_EX(arginfo_class_RdKafka_KafkaErrorException_getErrorString, 0, 0, IS_STRING, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_WITH_TENTATIVE_RETURN_TYPE_INFO_EX(arginfo_class_RdKafka_KafkaErrorException_isFatal, 0, 0, _IS_BOOL, 0)
+ZEND_END_ARG_INFO()
+
+#define arginfo_class_RdKafka_KafkaErrorException_isRetriable arginfo_class_RdKafka_KafkaErrorException_isFatal
+
+#define arginfo_class_RdKafka_KafkaErrorException_transactionRequiresAbort arginfo_class_RdKafka_KafkaErrorException_isFatal
+
+
+ZEND_METHOD(RdKafka_KafkaErrorException, __construct);
+ZEND_METHOD(RdKafka_KafkaErrorException, getErrorString);
+ZEND_METHOD(RdKafka_KafkaErrorException, isFatal);
+ZEND_METHOD(RdKafka_KafkaErrorException, isRetriable);
+ZEND_METHOD(RdKafka_KafkaErrorException, transactionRequiresAbort);
+
+
+static const zend_function_entry class_RdKafka_KafkaErrorException_methods[] = {
+	ZEND_ME(RdKafka_KafkaErrorException, __construct, arginfo_class_RdKafka_KafkaErrorException___construct, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_KafkaErrorException, getErrorString, arginfo_class_RdKafka_KafkaErrorException_getErrorString, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_KafkaErrorException, isFatal, arginfo_class_RdKafka_KafkaErrorException_isFatal, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_KafkaErrorException, isRetriable, arginfo_class_RdKafka_KafkaErrorException_isRetriable, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_KafkaErrorException, transactionRequiresAbort, arginfo_class_RdKafka_KafkaErrorException_transactionRequiresAbort, ZEND_ACC_PUBLIC)
+	ZEND_FE_END
+};
+
+static zend_class_entry *register_class_RdKafka_KafkaErrorException(zend_class_entry *class_entry_RdKafka_Exception)
+{
+	zend_class_entry ce, *class_entry;
+
+	INIT_NS_CLASS_ENTRY(ce, "RdKafka", "KafkaErrorException", class_RdKafka_KafkaErrorException_methods);
+	class_entry = zend_register_internal_class_ex(&ce, class_entry_RdKafka_Exception);
+
+	zval property_error_string_default_value;
+	ZVAL_UNDEF(&property_error_string_default_value);
+	zend_string *property_error_string_name = zend_string_init("error_string", sizeof("error_string") - 1, 1);
+	zend_declare_typed_property(class_entry, property_error_string_name, &property_error_string_default_value, ZEND_ACC_PRIVATE, NULL, (zend_type) ZEND_TYPE_INIT_MASK(MAY_BE_STRING));
+	zend_string_release(property_error_string_name);
+
+	zval property_isFatal_default_value;
+	ZVAL_UNDEF(&property_isFatal_default_value);
+	zend_string *property_isFatal_name = zend_string_init("isFatal", sizeof("isFatal") - 1, 1);
+	zend_declare_typed_property(class_entry, property_isFatal_name, &property_isFatal_default_value, ZEND_ACC_PRIVATE, NULL, (zend_type) ZEND_TYPE_INIT_MASK(MAY_BE_BOOL));
+	zend_string_release(property_isFatal_name);
+
+	zval property_isRetriable_default_value;
+	ZVAL_UNDEF(&property_isRetriable_default_value);
+	zend_string *property_isRetriable_name = zend_string_init("isRetriable", sizeof("isRetriable") - 1, 1);
+	zend_declare_typed_property(class_entry, property_isRetriable_name, &property_isRetriable_default_value, ZEND_ACC_PRIVATE, NULL, (zend_type) ZEND_TYPE_INIT_MASK(MAY_BE_BOOL));
+	zend_string_release(property_isRetriable_name);
+
+	zval property_transactionRequiresAbort_default_value;
+	ZVAL_UNDEF(&property_transactionRequiresAbort_default_value);
+	zend_string *property_transactionRequiresAbort_name = zend_string_init("transactionRequiresAbort", sizeof("transactionRequiresAbort") - 1, 1);
+	zend_declare_typed_property(class_entry, property_transactionRequiresAbort_name, &property_transactionRequiresAbort_default_value, ZEND_ACC_PRIVATE, NULL, (zend_type) ZEND_TYPE_INIT_MASK(MAY_BE_BOOL));
+	zend_string_release(property_transactionRequiresAbort_name);
+
+	return class_entry;
+}

base-images/nginx-php-fpm-main/php-rdkafka/kafka_error_exception_legacy_arginfo.h

+/* This is a generated file, edit the .stub.php file instead.
+ * Stub hash: 1a50cd552973f23b01a2d6b4e5464ba14320c393 */
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_RdKafka_KafkaErrorException___construct, 0, 0, 6)
+	ZEND_ARG_INFO(0, message)
+	ZEND_ARG_INFO(0, code)
+	ZEND_ARG_INFO(0, error_string)
+	ZEND_ARG_INFO(0, isFatal)
+	ZEND_ARG_INFO(0, isRetriable)
+	ZEND_ARG_INFO(0, transactionRequiresAbort)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_RdKafka_KafkaErrorException_getErrorString, 0, 0, 0)
+ZEND_END_ARG_INFO()
+
+#define arginfo_class_RdKafka_KafkaErrorException_isFatal arginfo_class_RdKafka_KafkaErrorException_getErrorString
+
+#define arginfo_class_RdKafka_KafkaErrorException_isRetriable arginfo_class_RdKafka_KafkaErrorException_getErrorString
+
+#define arginfo_class_RdKafka_KafkaErrorException_transactionRequiresAbort arginfo_class_RdKafka_KafkaErrorException_getErrorString
+
+
+ZEND_METHOD(RdKafka_KafkaErrorException, __construct);
+ZEND_METHOD(RdKafka_KafkaErrorException, getErrorString);
+ZEND_METHOD(RdKafka_KafkaErrorException, isFatal);
+ZEND_METHOD(RdKafka_KafkaErrorException, isRetriable);
+ZEND_METHOD(RdKafka_KafkaErrorException, transactionRequiresAbort);
+
+
+static const zend_function_entry class_RdKafka_KafkaErrorException_methods[] = {
+	ZEND_ME(RdKafka_KafkaErrorException, __construct, arginfo_class_RdKafka_KafkaErrorException___construct, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_KafkaErrorException, getErrorString, arginfo_class_RdKafka_KafkaErrorException_getErrorString, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_KafkaErrorException, isFatal, arginfo_class_RdKafka_KafkaErrorException_isFatal, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_KafkaErrorException, isRetriable, arginfo_class_RdKafka_KafkaErrorException_isRetriable, ZEND_ACC_PUBLIC)
+	ZEND_ME(RdKafka_KafkaErrorException, transactionRequiresAbort, arginfo_class_RdKafka_KafkaErrorException_transactionRequiresAbort, ZEND_ACC_PUBLIC)
+	ZEND_FE_END
+};
+
+static zend_class_entry *register_class_RdKafka_KafkaErrorException(zend_class_entry *class_entry_RdKafka_Exception)
+{
+	zend_class_entry ce, *class_entry;
+
+	INIT_NS_CLASS_ENTRY(ce, "RdKafka", "KafkaErrorException", class_RdKafka_KafkaErrorException_methods);
+	class_entry = zend_register_internal_class_ex(&ce, class_entry_RdKafka_Exception);
+
+	zval property_error_string_default_value;
+	ZVAL_NULL(&property_error_string_default_value);
+	zend_string *property_error_string_name = zend_string_init("error_string", sizeof("error_string") - 1, 1);
+	zend_declare_property_ex(class_entry, property_error_string_name, &property_error_string_default_value, ZEND_ACC_PRIVATE, NULL);
+	zend_string_release(property_error_string_name);
+
+	zval property_isFatal_default_value;
+	ZVAL_NULL(&property_isFatal_default_value);
+	zend_string *property_isFatal_name = zend_string_init("isFatal", sizeof("isFatal") - 1, 1);
+	zend_declare_property_ex(class_entry, property_isFatal_name, &property_isFatal_default_value, ZEND_ACC_PRIVATE, NULL);
+	zend_string_release(property_isFatal_name);
+
+	zval property_isRetriable_default_value;
+	ZVAL_NULL(&property_isRetriable_default_value);
+	zend_string *property_isRetriable_name = zend_string_init("isRetriable", sizeof("isRetriable") - 1, 1);
+	zend_declare_property_ex(class_entry, property_isRetriable_name, &property_isRetriable_default_value, ZEND_ACC_PRIVATE, NULL);
+	zend_string_release(property_isRetriable_name);
+
+	zval property_transactionRequiresAbort_default_value;
+	ZVAL_NULL(&property_transactionRequiresAbort_default_value);
+	zend_string *property_transactionRequiresAbort_name = zend_string_init("transactionRequiresAbort", sizeof("transactionRequiresAbort") - 1, 1);
+	zend_declare_property_ex(class_entry, property_transactionRequiresAbort_name, &property_transactionRequiresAbort_default_value, ZEND_ACC_PRIVATE, NULL);
+	zend_string_release(property_transactionRequiresAbort_name);
+
+	return class_entry;
+}

base-images/nginx-php-fpm-main/php-rdkafka/message.c

+/*
+  +----------------------------------------------------------------------+
+  | php-rdkafka                                                          |
+  +----------------------------------------------------------------------+
+  | Copyright (c) 2016 Arnaud Le Blanc                                   |
+  +----------------------------------------------------------------------+
+  | This source file is subject to version 3.01 of the PHP license,      |
+  | that is bundled with this package in the file LICENSE, and is        |
+  | available through the world-wide-web at the following url:           |
+  | http://www.php.net/license/3_01.txt                                  |
+  | If you did not receive a copy of the PHP license and are unable to   |
+  | obtain it through the world-wide-web, please send a note to          |
+  | license@php.net so we can mail you a copy immediately.               |
+  +----------------------------------------------------------------------+
+  | Author: Arnaud Le Blanc <arnaud.lb@gmail.com>                        |
+  +----------------------------------------------------------------------+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "php.h"
+#include "php_rdkafka.h"
+#include "php_rdkafka_priv.h"
+#include "librdkafka/rdkafka.h"
+#include "ext/spl/spl_iterators.h"
+#include "Zend/zend_interfaces.h"
+#include "Zend/zend_exceptions.h"
+#include "topic.h"
+#include "message.h"
+#if PHP_VERSION_ID < 80000
+#include "message_legacy_arginfo.h"
+#else
+#include "message_arginfo.h"
+#endif
+
+zend_class_entry * ce_kafka_message;
+
+void kafka_message_new(zval *return_value, const rd_kafka_message_t *message, zend_string *msg_opaque)
+{
+    object_init_ex(return_value, ce_kafka_message);
+
+    rd_kafka_timestamp_type_t tstype;
+    int64_t timestamp;
+
+    timestamp = rd_kafka_message_timestamp(message, &tstype);
+
+    zval headers_array;
+#ifdef HAVE_RD_KAFKA_MESSAGE_HEADERS
+    rd_kafka_headers_t *message_headers = NULL;
+    rd_kafka_resp_err_t header_response;
+    const char *header_name = NULL;
+    const void *header_value = NULL;
+    size_t header_size = 0;
+    size_t i;
+#endif /* HAVE_RD_KAFKA_MESSAGE_HEADERS */
+
+    zend_update_property_long(NULL, Z_RDKAFKA_PROP_OBJ(return_value), ZEND_STRL("err"), message->err);
+
+    if (message->rkt) {
+        zend_update_property_string(NULL, Z_RDKAFKA_PROP_OBJ(return_value), ZEND_STRL("topic_name"), rd_kafka_topic_name(message->rkt));
+    }
+    zend_update_property_long(NULL, Z_RDKAFKA_PROP_OBJ(return_value), ZEND_STRL("partition"), message->partition);
+    if (message->payload) {
+        zend_update_property_long(NULL, Z_RDKAFKA_PROP_OBJ(return_value), ZEND_STRL("timestamp"), timestamp);
+        zend_update_property_stringl(NULL, Z_RDKAFKA_PROP_OBJ(return_value), ZEND_STRL("payload"), message->payload, message->len);
+        zend_update_property_long(NULL, Z_RDKAFKA_PROP_OBJ(return_value), ZEND_STRL("len"), message->len);
+    }
+    if (message->key) {
+        zend_update_property_stringl(NULL, Z_RDKAFKA_PROP_OBJ(return_value), ZEND_STRL("key"), message->key, message->key_len);
+    }
+    zend_update_property_long(NULL, Z_RDKAFKA_PROP_OBJ(return_value), ZEND_STRL("offset"), message->offset);
+
+    array_init(&headers_array);
+#ifdef HAVE_RD_KAFKA_MESSAGE_HEADERS
+    if (message->err == RD_KAFKA_RESP_ERR_NO_ERROR) {
+        rd_kafka_message_headers(message, &message_headers);
+        if (message_headers != NULL) {
+            for (i = 0; i < rd_kafka_header_cnt(message_headers); i++) {
+                header_response = rd_kafka_header_get_all(message_headers, i, &header_name, &header_value, &header_size);
+                if (header_response != RD_KAFKA_RESP_ERR_NO_ERROR) {
+                    break;
+                }
+                add_assoc_stringl(&headers_array, header_name, (const char*)header_value, header_size);
+            }
+        }
+    }
+#endif
+    zend_update_property(NULL, Z_RDKAFKA_PROP_OBJ(return_value), ZEND_STRL("headers"), &headers_array);
+    zval_ptr_dtor(&headers_array);
+
+    if (msg_opaque != NULL) {
+        zend_update_property_str(NULL, Z_RDKAFKA_PROP_OBJ(return_value), ZEND_STRL("opaque"), msg_opaque);
+    }
+}
+
+void kafka_message_list_to_array(zval *return_value, rd_kafka_message_t **messages, long size) /* {{{ */
+{
+    rd_kafka_message_t *msg;
+    zval zmsg;
+    int i;
+
+    array_init_size(return_value, size);
+
+    for (i = 0; i < size; i++) {
+        msg = messages[i];
+        ZVAL_NULL(&zmsg);
+        kafka_message_new(&zmsg, msg, NULL);
+        add_next_index_zval(return_value, &zmsg);
+    }
+} /* }}} */
+
+/* {{{ proto string RdKafka\Message::errstr()
+ *  Returns the error string for an errored KrKafka\Message or NULL if there was no error.
+ */
+PHP_METHOD(RdKafka_Message, errstr)
+{
+    zval *zerr;
+    zval *zpayload;
+    const char *errstr;
+
+    if (zend_parse_parameters(ZEND_NUM_ARGS(), "") == FAILURE) {
+        return;
+    }
+
+    zerr = rdkafka_read_property(NULL, Z_RDKAFKA_PROP_OBJ(getThis()), ZEND_STRL("err"), 0);
+
+    if (!zerr || Z_TYPE_P(zerr) != IS_LONG) {
+        return;
+    }
+
+    errstr = rd_kafka_err2str(Z_LVAL_P(zerr));
+
+    if (errstr) {
+        RETURN_STRING(errstr);
+    }
+
+    zpayload = rdkafka_read_property(NULL, Z_RDKAFKA_PROP_OBJ(getThis()), ZEND_STRL("payload"), 0);
+
+    if (zpayload && Z_TYPE_P(zpayload) == IS_STRING) {
+        RETURN_ZVAL(zpayload, 1, 0);
+    }
+}
+/* }}} */
+
+void kafka_message_minit(INIT_FUNC_ARGS) { /* {{{ */
+    ce_kafka_message = register_class_RdKafka_Message();
+} /* }}} */

base-images/nginx-php-fpm-main/php-rdkafka/message.h

+/*
+  +----------------------------------------------------------------------+
+  | php-rdkafka                                                          |
+  +----------------------------------------------------------------------+
+  | Copyright (c) 2016 Arnaud Le Blanc                                   |
+  +----------------------------------------------------------------------+
+  | This source file is subject to version 3.01 of the PHP license,      |
+  | that is bundled with this package in the file LICENSE, and is        |
+  | available through the world-wide-web at the following url:           |
+  | http://www.php.net/license/3_01.txt                                  |
+  | If you did not receive a copy of the PHP license and are unable to   |
+  | obtain it through the world-wide-web, please send a note to          |
+  | license@php.net so we can mail you a copy immediately.               |
+  +----------------------------------------------------------------------+
+  | Author: Arnaud Le Blanc <arnaud.lb@gmail.com>                        |
+  +----------------------------------------------------------------------+
+*/
+
+void kafka_message_minit(INIT_FUNC_ARGS);
+void kafka_message_new(zval *return_value, const rd_kafka_message_t *message, zend_string *msg_opaque);
+void kafka_message_list_to_array(zval *return_value, rd_kafka_message_t **messages, long size);
+
+extern zend_class_entry * ce_kafka_message;

base-images/nginx-php-fpm-main/php-rdkafka/message.stub.php

+<?php
+
+/**
+ * @generate-class-entries
+ * @generate-function-entries
+ * @generate-legacy-arginfo
+ */
+
+namespace RdKafka;
+
+class Message
+{
+    public int $err;
+
+    public ?string $topic_name = null;
+
+    public ?int $timestamp = null;
+
+    public int $partition;
+
+    public ?string $payload = null;
+
+    public ?int $len = null;
+
+    public ?string $key = null;
+
+    public int $offset;
+
+    public array $headers;
+
+    public ?string $opaque = null;
+
+    /** @tentative-return-type */
+    public function errstr(): ?string {}
+}

base-images/nginx-php-fpm-main/php-rdkafka/message_arginfo.h

+/* This is a generated file, edit the .stub.php file instead.
+ * Stub hash: f642f90b8a3c35c353320c0574902898a3645ee1 */
+
+ZEND_BEGIN_ARG_WITH_TENTATIVE_RETURN_TYPE_INFO_EX(arginfo_class_RdKafka_Message_errstr, 0, 0, IS_STRING, 1)
+ZEND_END_ARG_INFO()
+
+
+ZEND_METHOD(RdKafka_Message, errstr);
+
+
+static const zend_function_entry class_RdKafka_Message_methods[] = {
+	ZEND_ME(RdKafka_Message, errstr, arginfo_class_RdKafka_Message_errstr, ZEND_ACC_PUBLIC)
+	ZEND_FE_END
+};
+
+static zend_class_entry *register_class_RdKafka_Message(void)
+{
+	zend_class_entry ce, *class_entry;
+
+	INIT_NS_CLASS_ENTRY(ce, "RdKafka", "Message", class_RdKafka_Message_methods);
+	class_entry = zend_register_internal_class_ex(&ce, NULL);
+
+	zval property_err_default_value;
+	ZVAL_UNDEF(&property_err_default_value);
+	zend_string *property_err_name = zend_string_init("err", sizeof("err") - 1, 1);
+	zend_declare_typed_property(class_entry, property_err_name, &property_err_default_value, ZEND_ACC_PUBLIC, NULL, (zend_type) ZEND_TYPE_INIT_MASK(MAY_BE_LONG));
+	zend_string_release(property_err_name);
+
+	zval property_topic_name_default_value;
+	ZVAL_NULL(&property_topic_name_default_value);
+	zend_string *property_topic_name_name = zend_string_init("topic_name", sizeof("topic_name") - 1, 1);
+	zend_declare_typed_property(class_entry, property_topic_name_name, &property_topic_name_default_value, ZEND_ACC_PUBLIC, NULL, (zend_type) ZEND_TYPE_INIT_MASK(MAY_BE_STRING|MAY_BE_NULL));
+	zend_string_release(property_topic_name_name);
+
+	zval property_timestamp_default_value;
+	ZVAL_NULL(&property_timestamp_default_value);
+	zend_string *property_timestamp_name = zend_string_init("timestamp", sizeof("timestamp") - 1, 1);
+	zend_declare_typed_property(class_entry, property_timestamp_name, &property_timestamp_default_value, ZEND_ACC_PUBLIC, NULL, (zend_type) ZEND_TYPE_INIT_MASK(MAY_BE_LONG|MAY_BE_NULL));
+	zend_string_release(property_timestamp_name);
+
+	zval property_partition_default_value;
+	ZVAL_UNDEF(&property_partition_default_value);
+	zend_string *property_partition_name = zend_string_init("partition", sizeof("partition") - 1, 1);
+	zend_declare_typed_property(class_entry, property_partition_name, &property_partition_default_value, ZEND_ACC_PUBLIC, NULL, (zend_type) ZEND_TYPE_INIT_MASK(MAY_BE_LONG));
+	zend_string_release(property_partition_name);
+
+	zval property_payload_default_value;
+	ZVAL_NULL(&property_payload_default_value);
+	zend_string *property_payload_name = zend_string_init("payload", sizeof("payload") - 1, 1);
+	zend_declare_typed_property(class_entry, property_payload_name, &property_payload_default_value, ZEND_ACC_PUBLIC, NULL, (zend_type) ZEND_TYPE_INIT_MASK(MAY_BE_STRING|MAY_BE_NULL));
+	zend_string_release(property_payload_name);
+
+	zval property_len_default_value;
+	ZVAL_NULL(&property_len_default_value);
+	zend_string *property_len_name = zend_string_init("len", sizeof("len") - 1, 1);
+	zend_declare_typed_property(class_entry, property_len_name, &property_len_default_value, ZEND_ACC_PUBLIC, NULL, (zend_type) ZEND_TYPE_INIT_MASK(MAY_BE_LONG|MAY_BE_NULL));
+	zend_string_release(property_len_name);
+
+	zval property_key_default_value;
+	ZVAL_NULL(&property_key_default_value);
+	zend_string *property_key_name = zend_string_init("key", sizeof("key") - 1, 1);
+	zend_declare_typed_property(class_entry, property_key_name, &property_key_default_value, ZEND_ACC_PUBLIC, NULL, (zend_type) ZEND_TYPE_INIT_MASK(MAY_BE_STRING|MAY_BE_NULL));
+	zend_string_release(property_key_name);
+
+	zval property_offset_default_value;
+	ZVAL_UNDEF(&property_offset_default_value);
+	zend_string *property_offset_name = zend_string_init("offset", sizeof("offset") - 1, 1);
+	zend_declare_typed_property(class_entry, property_offset_name, &property_offset_default_value, ZEND_ACC_PUBLIC, NULL, (zend_type) ZEND_TYPE_INIT_MASK(MAY_BE_LONG));
+	zend_string_release(property_offset_name);
+
+	zval property_headers_default_value;
+	ZVAL_UNDEF(&property_headers_default_value);
+	zend_string *property_headers_name = zend_string_init("headers", sizeof("headers") - 1, 1);
+	zend_declare_typed_property(class_entry, property_headers_name, &property_headers_default_value, ZEND_ACC_PUBLIC, NULL, (zend_type) ZEND_TYPE_INIT_MASK(MAY_BE_ARRAY));
+	zend_string_release(property_headers_name);
+
+	zval property_opaque_default_value;
+	ZVAL_NULL(&property_opaque_default_value);
+	zend_string *property_opaque_name = zend_string_init("opaque", sizeof("opaque") - 1, 1);
+	zend_declare_typed_property(class_entry, property_opaque_name, &property_opaque_default_value, ZEND_ACC_PUBLIC, NULL, (zend_type) ZEND_TYPE_INIT_MASK(MAY_BE_STRING|MAY_BE_NULL));
+	zend_string_release(property_opaque_name);
+
+	return class_entry;
+}

base-images/nginx-php-fpm-main/php-rdkafka/message_legacy_arginfo.h

+/* This is a generated file, edit the .stub.php file instead.
+ * Stub hash: f642f90b8a3c35c353320c0574902898a3645ee1 */
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_class_RdKafka_Message_errstr, 0, 0, 0)
+ZEND_END_ARG_INFO()
+
+
+ZEND_METHOD(RdKafka_Message, errstr);
+
+
+static const zend_function_entry class_RdKafka_Message_methods[] = {
+	ZEND_ME(RdKafka_Message, errstr, arginfo_class_RdKafka_Message_errstr, ZEND_ACC_PUBLIC)
+	ZEND_FE_END
+};
+
+static zend_class_entry *register_class_RdKafka_Message(void)
+{
+	zend_class_entry ce, *class_entry;
+
+	INIT_NS_CLASS_ENTRY(ce, "RdKafka", "Message", class_RdKafka_Message_methods);
+	class_entry = zend_register_internal_class_ex(&ce, NULL);
+
+	zval property_err_default_value;
+	ZVAL_NULL(&property_err_default_value);
+	zend_string *property_err_name = zend_string_init("err", sizeof("err") - 1, 1);
+	zend_declare_property_ex(class_entry, property_err_name, &property_err_default_value, ZEND_ACC_PUBLIC, NULL);
+	zend_string_release(property_err_name);
+
+	zval property_topic_name_default_value;
+	ZVAL_NULL(&property_topic_name_default_value);
+	zend_string *property_topic_name_name = zend_string_init("topic_name", sizeof("topic_name") - 1, 1);
+	zend_declare_property_ex(class_entry, property_topic_name_name, &property_topic_name_default_value, ZEND_ACC_PUBLIC, NULL);
+	zend_string_release(property_topic_name_name);
+
+	zval property_timestamp_default_value;
+	ZVAL_NULL(&property_timestamp_default_value);
+	zend_string *property_timestamp_name = zend_string_init("timestamp", sizeof("timestamp") - 1, 1);
+	zend_declare_property_ex(class_entry, property_timestamp_name, &property_timestamp_default_value, ZEND_ACC_PUBLIC, NULL);
+	zend_string_release(property_timestamp_name);
+
+	zval property_partition_default_value;
+	ZVAL_NULL(&property_partition_default_value);
+	zend_string *property_partition_name = zend_string_init("partition", sizeof("partition") - 1, 1);
+	zend_declare_property_ex(class_entry, property_partition_name, &property_partition_default_value, ZEND_ACC_PUBLIC, NULL);
+	zend_string_release(property_partition_name);
+
+	zval property_payload_default_value;
+	ZVAL_NULL(&property_payload_default_value);
+	zend_string *property_payload_name = zend_string_init("payload", sizeof("payload") - 1, 1);
+	zend_declare_property_ex(class_entry, property_payload_name, &property_payload_default_value, ZEND_ACC_PUBLIC, NULL);
+	zend_string_release(property_payload_name);
+
+	zval property_len_default_value;
+	ZVAL_NULL(&property_len_default_value);
+	zend_string *property_len_name = zend_string_init("len", sizeof("len") - 1, 1);
+	zend_declare_property_ex(class_entry, property_len_name, &property_len_default_value, ZEND_ACC_PUBLIC, NULL);
+	zend_string_release(property_len_name);
+
+	zval property_key_default_value;
+	ZVAL_NULL(&property_key_default_value);
+	zend_string *property_key_name = zend_string_init("key", sizeof("key") - 1, 1);
+	zend_declare_property_ex(class_entry, property_key_name, &property_key_default_value, ZEND_ACC_PUBLIC, NULL);
+	zend_string_release(property_key_name);
+
+	zval property_offset_default_value;
+	ZVAL_NULL(&property_offset_default_value);
+	zend_string *property_offset_name = zend_string_init("offset", sizeof("offset") - 1, 1);
+	zend_declare_property_ex(class_entry, property_offset_name, &property_offset_default_value, ZEND_ACC_PUBLIC, NULL);
+	zend_string_release(property_offset_name);
+
+	zval property_headers_default_value;
+	ZVAL_NULL(&property_headers_default_value);
+	zend_string *property_headers_name = zend_string_init("headers", sizeof("headers") - 1, 1);
+	zend_declare_property_ex(class_entry, property_headers_name, &property_headers_default_value, ZEND_ACC_PUBLIC, NULL);
+	zend_string_release(property_headers_name);
+
+	zval property_opaque_default_value;
+	ZVAL_NULL(&property_opaque_default_value);
+	zend_string *property_opaque_name = zend_string_init("opaque", sizeof("opaque") - 1, 1);
+	zend_declare_property_ex(class_entry, property_opaque_name, &property_opaque_default_value, ZEND_ACC_PUBLIC, NULL);
+	zend_string_release(property_opaque_name);
+
+	return class_entry;
+}

base-images/nginx-php-fpm-main/php-rdkafka/metadata.c

+/*
+  +----------------------------------------------------------------------+
+  | php-rdkafka                                                          |
+  +----------------------------------------------------------------------+
+  | Copyright (c) 2016 Arnaud Le Blanc                                   |
+  +----------------------------------------------------------------------+
+  | This source file is subject to version 3.01 of the PHP license,      |
+  | that is bundled with this package in the file LICENSE, and is        |
+  | available through the world-wide-web at the following url:           |
+  | http://www.php.net/license/3_01.txt                                  |
+  | If you did not receive a copy of the PHP license and are unable to   |
+  | obtain it through the world-wide-web, please send a note to          |
+  | license@php.net so we can mail you a copy immediately.               |
+  +----------------------------------------------------------------------+
+  | Author: Arnaud Le Blanc <arnaud.lb@gmail.com>                        |
+  +----------------------------------------------------------------------+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "php.h"
+#include "php_rdkafka.h"
+#include "php_rdkafka_priv.h"
+#include "librdkafka/rdkafka.h"
+#include "metadata_collection.h"
+#include "metadata_topic.h"
+#include "metadata_broker.h"
+#include "metadata_partition.h"
+#include "Zend/zend_exceptions.h"
+#if PHP_VERSION_ID < 80000
+#include "metadata_legacy_arginfo.h"
+#else
+#include "metadata_arginfo.h"
+#endif
+
+typedef struct _object_intern {
+    const rd_kafka_metadata_t *metadata;
+    zend_object               std;
+} object_intern;
+
+static HashTable *get_debug_info(Z_RDKAFKA_OBJ *object, int *is_temp);
+
+static zend_class_entry * ce;
+static zend_object_handlers handlers;
+
+static void brokers_collection(zval *return_value, Z_RDKAFKA_OBJ *parent, object_intern *intern) { /* {{{ */
+    kafka_metadata_collection_init(return_value, parent, intern->metadata->brokers, intern->metadata->broker_cnt, sizeof(*intern->metadata->brokers), kafka_metadata_broker_ctor);
+}
+/* }}} */
+
+static void topics_collection(zval *return_value, Z_RDKAFKA_OBJ *parent, object_intern *intern) { /* {{{ */
+    kafka_metadata_collection_init(return_value, parent, intern->metadata->topics, intern->metadata->topic_cnt, sizeof(*intern->metadata->topics), kafka_metadata_topic_ctor);
+}
+/* }}} */
+
+static void kafka_metadata_free(zend_object *object) /* {{{ */
+{
+    object_intern *intern = php_kafka_from_obj(object_intern, object);
+
+    if (intern->metadata) {
+        rd_kafka_metadata_destroy(intern->metadata);
+    }
+
+    zend_object_std_dtor(&intern->std);
+}
+/* }}} */
+
+static zend_object *kafka_metadata_new(zend_class_entry *class_type) /* {{{ */
+{
+    zend_object* retval;
+    object_intern *intern;
+
+    intern = zend_object_alloc(sizeof(*intern), class_type);
+    zend_object_std_init(&intern->std, class_type);
+    object_properties_init(&intern->std, class_type);
+
+    retval = &intern->std;
+    retval->handlers = &handlers;
+
+    return retval;
+}
+/* }}} */
+
+static object_intern * get_object(zval *zmetadata)
+{
+    object_intern *ometadata = Z_RDKAFKA_P(object_intern, zmetadata);
+
+    if (!ometadata->metadata) {
+        zend_throw_exception_ex(NULL, 0, "RdKafka\\Metadata::__construct() has not been called");
+        return NULL;
+    }
+
+    return ometadata;
+}
+
+static HashTable *get_debug_info(Z_RDKAFKA_OBJ *object, int *is_temp) /* {{{ */
+{
+    zval ary;
+    object_intern *intern;
+    zval brokers;
+    zval topics;
+
+    *is_temp = 1;
+
+    array_init(&ary);
+
+    intern = rdkafka_get_debug_object(object_intern, object);
+    if (!intern) {
+        return Z_ARRVAL(ary);
+    }
+
+    ZVAL_NULL(&brokers);
+    brokers_collection(&brokers, object, intern);
+    add_assoc_zval(&ary, "brokers", &brokers);
+
+    ZVAL_NULL(&topics);
+    topics_collection(&topics, object, intern);
+    add_assoc_zval(&ary, "topics", &topics);
+
+    add_assoc_long(&ary, "orig_broker_id", intern->metadata->orig_broker_id);
+    add_assoc_string(&ary, "orig_broker_name", intern->metadata->orig_broker_name);
+
+    return Z_ARRVAL(ary);
+}
+/* }}} */
+
+/* {{{ proto long RdKafka\Metadata::getOrigBrokerId()
+   Broker originating this metadata */
+PHP_METHOD(RdKafka_Metadata, getOrigBrokerId)
+{
+    object_intern *intern;
+
+    if (zend_parse_parameters_none() == FAILURE) {
+        return;
+    }
+
+    intern = get_object(getThis());
+    if (!intern) {
+        return;
+    }
+
+    RETURN_LONG(intern->metadata->orig_broker_id);
+}
+/* }}} */
+
+/* {{{ proto string RdKafka\Metadata::getOrigBrokerName()
+   Name of originating broker */
+PHP_METHOD(RdKafka_Metadata, getOrigBrokerName)
+{
+    object_intern *intern;
+
+    if (zend_parse_parameters_none() == FAILURE) {
+        return;
+    }
+
+    intern = get_object(getThis());
+    if (!intern) {
+        return;
+    }
+
+    RETURN_STRING(intern->metadata->orig_broker_name);
+}
+/* }}} */
+
+/* {{{ proto RdKafka\Metadata\Collection RdKafka\Metadata::getBrokers()
+   Topics */
+PHP_METHOD(RdKafka_Metadata, getBrokers)
+{
+    object_intern *intern;
+
+    if (zend_parse_parameters_none() == FAILURE) {
+        return;
+    }
+
+    intern = get_object(getThis());
+    if (!intern) {
+        return;
+    }
+
+    brokers_collection(return_value, Z_RDKAFKA_PROP_OBJ(getThis()), intern);
+}
+/* }}} */
+
+/* {{{ proto RdKafka\Metadata\Collection RdKafka\Metadata::getTopics()
+   Topics */
+PHP_METHOD(RdKafka_Metadata, getTopics)
+{
+    object_intern *intern;
+
+    if (zend_parse_parameters_none() == FAILURE) {
+        return;
+    }
+
+    intern = get_object(getThis());
+    if (!intern) {
+        return;
+    }
+
+    topics_collection(return_value, Z_RDKAFKA_PROP_OBJ(getThis()), intern);
+}
+/* }}} */
+
+void kafka_metadata_minit(INIT_FUNC_ARGS)
+{
+    ce = register_class_RdKafka_Metadata();
+    ce->create_object = kafka_metadata_new;
+
+    handlers = kafka_default_object_handlers;
+    handlers.get_debug_info = get_debug_info;
+    handlers.free_obj = kafka_metadata_free;
+    handlers.offset = XtOffsetOf(object_intern, std);
+
+    kafka_metadata_topic_minit(INIT_FUNC_ARGS_PASSTHRU);
+    kafka_metadata_broker_minit(INIT_FUNC_ARGS_PASSTHRU);
+    kafka_metadata_partition_minit(INIT_FUNC_ARGS_PASSTHRU);
+    kafka_metadata_collection_minit(INIT_FUNC_ARGS_PASSTHRU);
+}
+
+void kafka_metadata_init(zval *return_value, const rd_kafka_metadata_t *metadata)
+{
+    object_intern *intern;
+
+    if (object_init_ex(return_value, ce) != SUCCESS) {
+        return;
+    }
+
+    intern = Z_RDKAFKA_P(object_intern, return_value);
+    if (!intern) {
+        return;
+    }
+
+    intern->metadata = metadata;
+}