├── Makefile
├── .gitignore
├── stubs
    ├── RdKafka
    │   ├── Exception.php
    │   ├── Topic.php
    │   ├── Queue.php
    │   ├── KafkaConsumerTopic.php
    │   ├── Metadata
    │   │   ├── Broker.php
    │   │   ├── Topic.php
    │   │   ├── Partition.php
    │   │   └── Collection.php
    │   ├── Consumer.php
    │   ├── TopicConf.php
    │   ├── Metadata.php
    │   ├── Message.php
    │   ├── ProducerTopic.php
    │   ├── KafkaErrorException.php
    │   ├── TopicPartition.php
    │   ├── Producer.php
    │   ├── ConsumerTopic.php
    │   ├── Conf.php
    │   └── KafkaConsumer.php
    ├── functions.php
    ├── RdKafka.php
    └── constants.php
├── tests
    ├── RdKafkaTest.php
    ├── RdKafka
    │   ├── ExceptionTest.php
    │   ├── TopicTest.php
    │   ├── KafkaErrorExceptionTest.php
    │   ├── TopicConfTest.php
    │   ├── QueueTest.php
    │   ├── ProducerTopicTest.php
    │   ├── MetadataTest.php
    │   ├── ConsumerTopicTest.php
    │   ├── MessageTest.php
    │   ├── ConsumerTest.php
    │   ├── ConfTest.php
    │   └── ProducerTest.php
    ├── FunctionsTest.php
    └── ConstantsTest.php
├── composer.json
├── phpunit.xml
├── .travis.yml
├── README.md
└── LICENSE


/Makefile:
--------------------------------------------------------------------------------
1 | test:
2 | 	mkdir -p build
3 | 	vendor/bin/phpunit
4 | 
5 | build: test
6 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | /vendor/
2 | /composer.lock
3 | /build/
4 | /kafka_2.11-0.9.0.1/
5 | *.cache
6 | 


--------------------------------------------------------------------------------
/stubs/RdKafka/Exception.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace RdKafka;
4 | 
5 | class Exception extends \Exception
6 | {
7 | }
8 | 


--------------------------------------------------------------------------------
/stubs/RdKafka/Topic.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace RdKafka;
 4 | 
 5 | abstract class Topic
 6 | {
 7 |     /**
 8 |      * @return string
 9 |      */
10 |     public function getName(): string
11 |     {
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/tests/RdKafkaTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use PHPUnit\Framework\TestCase;
 4 | 
 5 | class RdKafkaTest extends TestCase
 6 | {
 7 |     public function testRdKafkaClassIsAbstract()
 8 |     {
 9 |         $reflector = new ReflectionClass(\RdKafka::class);
10 | 
11 |         $this->assertTrue($reflector->isAbstract());
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/stubs/RdKafka/Queue.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace RdKafka;
 4 | 
 5 | class Queue
 6 | {
 7 |     private function __construct()
 8 |     {
 9 |     }
10 | 
11 |     /**
12 |      * @param int $timeout_ms
13 |      *
14 |      * @return Message|null
15 |      */
16 |     public function consume(int $timeout_ms)
17 |     {
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/tests/RdKafka/ExceptionTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace RdKafka;
 4 | 
 5 | use PHPUnit\Framework\TestCase;
 6 | 
 7 | class ExceptionTest extends TestCase
 8 | {
 9 |     public function testRdKafkaExceptionIsThrowable()
10 |     {
11 |         self::expectException(Exception::class);
12 |         throw new Exception();
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/stubs/RdKafka/KafkaConsumerTopic.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace RdKafka;
 4 | 
 5 | class KafkaConsumerTopic extends Topic
 6 | {
 7 |     /**
 8 |      * @param int $partition
 9 |      * @param int $offset
10 |      *
11 |      * @return void
12 |      */
13 |     public function offsetStore(int $partition, int $offset)
14 |     {
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/tests/RdKafka/TopicTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace RdKafka;
 4 | 
 5 | use PHPUnit\Framework\TestCase;
 6 | 
 7 | class TopicTest extends TestCase
 8 | {
 9 |     public function testClassIsAbstract()
10 |     {
11 |         $reflector = new \ReflectionClass(Topic::class);
12 | 
13 |         $this->assertTrue($reflector->isAbstract());
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "kwn/php-rdkafka-stubs",
 3 |     "description": "Rdkafka extension stubs for your IDE",
 4 |     "license": "MIT",
 5 |     "authors": [
 6 |         {
 7 |             "name": "Karol Wnuk",
 8 |             "email": "k.wnuk@ascetic.pl"
 9 |         }
10 |     ],
11 |     "require": {
12 |         "ext-rdkafka": ">=6.0"
13 |     },
14 |     "require-dev": {
15 |         "phpunit/phpunit": "^8.2.4"
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/phpunit.xml:
--------------------------------------------------------------------------------
 1 | <phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 2 |          xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/8.2/phpunit.xsd"
 3 |          bootstrap="vendor/autoload.php"
 4 |          colors="true"
 5 |          verbose="true">
 6 |     <testsuites>
 7 |         <testsuite name="RdKafka extension tests">
 8 |             <directory suffix=".php">tests/</directory>
 9 |         </testsuite>
10 |     </testsuites>
11 | </phpunit>
12 | 


--------------------------------------------------------------------------------
/stubs/RdKafka/Metadata/Broker.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace RdKafka\Metadata;
 4 | 
 5 | class Broker
 6 | {
 7 |     /**
 8 |      * @return int
 9 |      */
10 |     public function getId(): int
11 |     {
12 |     }
13 | 
14 |     /**
15 |      * @return string
16 |      */
17 |     public function getHost(): string
18 |     {
19 |     }
20 | 
21 |     /**
22 |      * @return int
23 |      */
24 |     public function getPort(): int
25 |     {
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/stubs/RdKafka/Metadata/Topic.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace RdKafka\Metadata;
 4 | 
 5 | class Topic
 6 | {
 7 |     /**
 8 |      * @return string
 9 |      */
10 |     public function getTopic(): string
11 |     {
12 |     }
13 | 
14 |     /**
15 |      * @return Partition[]
16 |      */
17 |     public function getPartitions(): array
18 |     {
19 |     }
20 | 
21 |     /**
22 |      * @return mixed
23 |      */
24 |     public function getErr()
25 |     {
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/stubs/RdKafka/Consumer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace RdKafka;
 4 | 
 5 | class Consumer extends \RdKafka
 6 | {
 7 |     /**
 8 |      * @param Conf|null $conf
 9 |      */
10 |     public function __construct(Conf $conf = null)
11 |     {
12 |     }
13 | 
14 |     /**
15 |      * @param string         $topic_name
16 |      * @param TopicConf|null $topic_conf
17 |      *
18 |      * @return ConsumerTopic
19 |      */
20 |     public function newTopic(string $topic_name, TopicConf $topic_conf = null): Topic
21 |     {
22 |     }
23 | 
24 |     /**
25 |      * @return Queue
26 |      */
27 |     public function newQueue(): Queue
28 |     {
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/tests/FunctionsTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use PHPUnit\Framework\TestCase;
 4 | 
 5 | class FunctionsTest extends TestCase
 6 | {
 7 |     public function testErr2Str()
 8 |     {
 9 |         $this->assertTrue(function_exists('rd_kafka_err2str'));
10 |     }
11 | 
12 |     public function testErrno2Err()
13 |     {
14 |         $this->assertTrue(function_exists('rd_kafka_errno2err'));
15 |     }
16 | 
17 |     public function testErrno()
18 |     {
19 |         $this->assertTrue(function_exists('rd_kafka_errno'));
20 |     }
21 | 
22 |     public function testOffsetTail()
23 |     {
24 |         $this->assertTrue(function_exists('rd_kafka_offset_tail'));
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/stubs/RdKafka/Metadata/Partition.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace RdKafka\Metadata;
 4 | 
 5 | class Partition
 6 | {
 7 |     /**
 8 |      * @return int
 9 |      */
10 |     public function getId(): int
11 |     {
12 |     }
13 | 
14 |     /**
15 |      * @return mixed
16 |      */
17 |     public function getErr()
18 |     {
19 |     }
20 | 
21 |     /**
22 |      * @return mixed
23 |      */
24 |     public function getLeader()
25 |     {
26 |     }
27 | 
28 |     /**
29 |      * @return mixed
30 |      */
31 |     public function getReplicas()
32 |     {
33 |     }
34 | 
35 |     /**
36 |      * @return mixed
37 |      */
38 |     public function getIsrs()
39 |     {
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/stubs/RdKafka/TopicConf.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace RdKafka;
 4 | 
 5 | /**
 6 |  * Configuration reference: https://github.com/edenhill/librdkafka/blob/master/CONFIGURATION.md
 7 |  */
 8 | class TopicConf
 9 | {
10 |     /**
11 |      * @return array
12 |      */
13 |     public function dump(): array
14 |     {
15 |     }
16 | 
17 |     /**
18 |      * @param string $name
19 |      * @param string $value
20 |      *
21 |      * @return void
22 |      */
23 |     public function set(string $name, string $value)
24 |     {
25 |     }
26 | 
27 |     /**
28 |      * @param int $partitioner
29 |      *
30 |      * @return void
31 |      */
32 |     public function setPartitioner(int $partitioner)
33 |     {
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/stubs/RdKafka/Metadata.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace RdKafka;
 4 | 
 5 | use RdKafka\Metadata\Broker;
 6 | use RdKafka\Metadata\Collection;
 7 | use RdKafka\Metadata\Topic;
 8 | 
 9 | class Metadata
10 | {
11 |     /**
12 |      * @return Collection|Broker[]
13 |      */
14 |     public function getBrokers(): Collection
15 |     {
16 |     }
17 | 
18 |     /**
19 |      * @return Collection|Topic[]
20 |      */
21 |     public function getTopics(): Collection
22 |     {
23 |     }
24 | 
25 |     /**
26 |      * @return int
27 |      */
28 |     public function getOrigBrokerId(): int
29 |     {
30 |     }
31 | 
32 |     /**
33 |      * @return string
34 |      */
35 |     public function getOrigBrokerName(): string
36 |     {
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/stubs/functions.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /**
 4 |  * @param int $err Error code
 5 |  *
 6 |  * @return string Returns the error as a string.
 7 |  */
 8 | function rd_kafka_err2str(int $err): string
 9 | {
10 | }
11 | 
12 | /**
13 |  * @param int $errnox A system errno
14 |  *
15 |  * @deprecated
16 |  *
17 |  * @return int Returns a kafka error code as an integer.
18 |  */
19 | function rd_kafka_errno2err(int $errnox)
20 | {
21 | }
22 | 
23 | /**
24 |  * @return int Returns the system errno as an integer.
25 |  *
26 |  * @deprecated
27 |  */
28 | function rd_kafka_errno(): int
29 | {
30 | }
31 | 
32 | /**
33 |  * @param int $cnt
34 |  *
35 |  * @return int Returns the special offset as an integer.
36 |  */
37 | function rd_kafka_offset_tail(int $cnt): int
38 | {
39 | }
40 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: php
 2 | 
 3 | dist: bionic
 4 | 
 5 | php:
 6 |   - 7.3
 7 | 
 8 | before_install:
 9 |   - sudo apt-get -y install gcc scala zookeeperd git
10 |   - git clone --depth 1 --branch v1.8.2 https://github.com/edenhill/librdkafka.git
11 |   - cd librdkafka
12 |   - ./configure
13 |   - make
14 |   - sudo make install
15 |   - cd ..
16 |   - wget https://archive.apache.org/dist/kafka/2.3.0/kafka_2.11-2.3.0.tgz
17 |   - tar zxf kafka_2.11-2.3.0.tgz
18 | 
19 | install:
20 |   - pecl install rdkafka-5.0.2
21 |   - composer self-update
22 |   - composer install
23 | 
24 | before_script:
25 |   - nohup kafka_2.11-2.3.0/bin/kafka-server-start.sh kafka_2.11-2.3.0/config/server.properties > kafka_2.11-2.3.0/kafka.log 2>&1 &
26 |   - sleep 10
27 | 
28 | script:
29 |   - make build
30 | 


--------------------------------------------------------------------------------
/tests/RdKafka/KafkaErrorExceptionTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace RdKafka;
 4 | 
 5 | use PHPUnit\Framework\TestCase;
 6 | 
 7 | class KafkaErrorExceptionTest extends TestCase
 8 | {
 9 |     public function testRdKafkaExceptionIsThrowable()
10 |     {
11 |         self::expectException(KafkaErrorException::class);
12 |         self::expectExceptionMessage('some message');
13 |         self::expectExceptionCode(900);
14 | 
15 |         $e = new KafkaErrorException('some message', 900, 'detailed error', true, false, true);
16 | 
17 |         self::assertEquals('detailed error', $e->getErrorString());
18 |         self::assertTrue($e->isFatal());
19 |         self::assertFalse($e->isRetriable());
20 |         self::assertTrue($e->transactionRequiresAbort());
21 | 
22 |         throw $e;
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/stubs/RdKafka/Metadata/Collection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace RdKafka\Metadata;
 4 | 
 5 | class Collection implements \Iterator, \Countable
 6 | {
 7 |     /**
 8 |      * @return mixed
 9 |      */
10 |     public function current()
11 |     {
12 |     }
13 | 
14 |     /**
15 |      * @return void
16 |      */
17 |     public function next()
18 |     {
19 |     }
20 | 
21 |     /**
22 |      * @return mixed
23 |      */
24 |     public function key()
25 |     {
26 |     }
27 | 
28 |     /**
29 |      * @return boolean
30 |      */
31 |     public function valid(): bool
32 |     {
33 |     }
34 | 
35 |     /**
36 |      * @return void
37 |      */
38 |     public function rewind()
39 |     {
40 |     }
41 | 
42 |     /**
43 |      * @return int
44 |      */
45 |     public function count(): int
46 |     {
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/stubs/RdKafka/Message.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace RdKafka;
 4 | 
 5 | class Message
 6 | {
 7 |     /**
 8 |      * @var int|null
 9 |      */
10 |     public $err;
11 | 
12 |     /**
13 |      * @var string|null
14 |      */
15 |     public $topic_name;
16 | 
17 |     /**
18 |      * @var int|null
19 |      */
20 |     public $partition;
21 | 
22 |     /**
23 |      * @var string|null
24 |      */
25 |     public $payload;
26 | 
27 |     /**
28 |      * @var int|null
29 |      */
30 |     public $len;
31 | 
32 |     /**
33 |      * @var string|null
34 |      */
35 |     public $key;
36 | 
37 |     /**
38 |      * @var int|null
39 |      */
40 |     public $offset;
41 | 
42 |     /**
43 |      * @var int|null
44 |      */
45 |     public $timestamp;
46 | 
47 |     /**
48 |      * @var string|null
49 |      */
50 |     public $opaque;
51 | 
52 |     /**
53 |      * @return string
54 |      */
55 |     public function errstr(): string
56 |     {
57 |     }
58 | 
59 |     public function headers(): array
60 |     {
61 |     }
62 | }
63 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Stubs for PHP Rdkafka extension (6.0.4 version)
 2 | 
 3 | [![Build Status](https://travis-ci.org/kwn/php-rdkafka-stubs.svg?branch=master)](https://travis-ci.org/kwn/php-rdkafka-stubs)
 4 | [![Latest Stable Version](https://poser.pugx.org/kwn/php-rdkafka-stubs/v/stable)](https://packagist.org/packages/kwn/php-rdkafka-stubs)
 5 | 
 6 | This package provides you a set of stubs for [RdKafka extension](https://github.com/arnaud-lb/php-rdkafka). It currently supports version >6. For older verisions of rdkafka extenstion (3.x and 0.9) please use version 1.x of this repository. 
 7 | 
 8 | ## Installation
 9 | 
10 | Add package to your composer.json dev dependencies
11 | 
12 | ```
13 | $ composer require kwn/php-rdkafka-stubs --dev
14 | ```
15 | 
16 | ## Usage
17 | 
18 | Once package is installed, your IDE should simply discover all stubs automatically. Please notice, that `kwn/php-rdkafka-stubs`
19 | package has no autoloader configuration provided, so stubs classes are visible in your IDE, but don't clashes with `rdkafka`
20 | extension namespaces.
21 | 


--------------------------------------------------------------------------------
/tests/RdKafka/TopicConfTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace RdKafka;
 4 | 
 5 | use PHPUnit\Framework\TestCase;
 6 | 
 7 | class TopicConfTest extends TestCase
 8 | {
 9 |     /**
10 |      * @var TopicConf
11 |      */
12 |     private $topicConf;
13 | 
14 |     public function setUp(): void
15 |     {
16 |         $this->topicConf = new TopicConf();
17 |     }
18 | 
19 |     public function testDump()
20 |     {
21 |         $this->markTestSkipped('Fails on CI');
22 | 
23 |         $expectedKeys = [
24 |             'request.required.acks',
25 |             'enforce.isr.cnt',
26 |             'request.timeout.ms',
27 |             'message.timeout.ms',
28 |             'produce.offset.report',
29 |             'auto.commit.enable',
30 |             'auto.commit.interval.ms',
31 |             'auto.offset.reset',
32 |             'offset.store.path',
33 |             'offset.store.sync.interval.ms',
34 |             'offset.store.method'
35 |         ];
36 | 
37 |         $dumpedKeys = array_keys($this->topicConf->dump());
38 | 
39 |         $this->assertEquals($expectedKeys, $dumpedKeys);
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/stubs/RdKafka/ProducerTopic.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace RdKafka;
 4 | 
 5 | class ProducerTopic extends Topic
 6 | {
 7 |     private function __construct()
 8 |     {
 9 |     }
10 | 
11 |     /**
12 |      * @param int    $partition
13 |      * @param int    $msgflags
14 |      * @param string|null $payload
15 |      * @param string|null $key
16 |      * @param string|null $opaque
17 |      *
18 |      * @throws Exception
19 |      * @return void
20 |      */
21 |     public function produce(int $partition, int $msgflags, string $payload = null, string $key = null, string $opaque = null)
22 |     {
23 |     }
24 | 
25 |     /**
26 |      * @param int         $partition
27 |      * @param int         $msgflags
28 |      * @param string      $payload
29 |      * @param string|null $key
30 |      * @param array|null  $headers
31 |      * @param int         $timestamp_ms
32 |      * @param string|null $opaque
33 |      *
34 |      * @throws Exception
35 |      */
36 |     public function producev(int $partition, int $msgflags, string $payload, string $key = null, array $headers = null, int $timestamp_ms = null, string $opaque = null)
37 |     {
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2016 Karol Wnuk
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/stubs/RdKafka/KafkaErrorException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace RdKafka;
 4 | 
 5 | class KafkaErrorException extends \Exception
 6 | {
 7 |     /**
 8 |      * @param string $message
 9 |      * @param int $code
10 |      * @param string $errorString
11 |      * @param boolean $isFatal
12 |      * @param boolean $isRetriable
13 |      * @param boolean $transactionRequiresAbort
14 |      */
15 |     public function __construct(
16 |         string $message,
17 |         int $code,
18 |         string $errorString,
19 |         bool $isFatal,
20 |         bool $isRetriable,
21 |         bool $transactionRequiresAbort
22 |     ) {
23 |         parent::__construct($message, $code);
24 |     }
25 | 
26 |     /**
27 |      * @returns string
28 |      */
29 |     public function getErrorString(): string
30 |     {
31 |     }
32 | 
33 |     /**
34 |      * @returns boolean
35 |      */
36 |     public function isFatal(): bool
37 |     {
38 |     }
39 | 
40 |     /**
41 |      * @returns boolean
42 |      */
43 |     public function isRetriable(): bool
44 |     {
45 |     }
46 | 
47 |     /**
48 |      * @returns boolean
49 |      */
50 |     public function transactionRequiresAbort(): bool
51 |     {
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/tests/RdKafka/QueueTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace RdKafka;
 4 | 
 5 | use PHPUnit\Framework\TestCase;
 6 | 
 7 | class QueueTest extends TestCase
 8 | {
 9 |     const PARTITION = 0;
10 | 
11 |     /**
12 |      * @var ConsumerTopic
13 |      */
14 |     private $consumerTopic;
15 | 
16 |     /**
17 |      * @var Queue
18 |      */
19 |     private $queue;
20 | 
21 |     public function setUp(): void
22 |     {
23 |         $conf = new Conf();
24 |         $conf->set('metadata.broker.list', 'localhost:9092');
25 |         $consumer = new Consumer($conf);
26 | 
27 |         $this->consumerTopic = $consumer->newTopic('test');
28 |         $this->queue = $consumer->newQueue();
29 |     }
30 | 
31 |     public function testConsumeViaQueue()
32 |     {
33 |         $this->markTestSkipped('Consuming via queue does not work');
34 | 
35 |         $this->consumerTopic->consumeQueueStart(self::PARTITION, RD_KAFKA_OFFSET_BEGINNING, $this->queue);
36 |         $this->consumerTopic->consume(self::PARTITION, 100);
37 |         $this->consumerTopic->consumeStop(self::PARTITION);
38 | 
39 |         $message = $this->queue->consume(200);
40 | 
41 |         $this->assertInstanceOf(Message::class, $message);
42 |     }
43 | }
44 | 


--------------------------------------------------------------------------------
/stubs/RdKafka/TopicPartition.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace RdKafka;
 4 | 
 5 | class TopicPartition
 6 | {
 7 |     /**
 8 |      * @param string $topic
 9 |      * @param int    $partition
10 |      * @param int    $offset
11 |      */
12 |     public function __construct($topic, $partition, $offset = null)
13 |     {
14 |     }
15 | 
16 |     /**
17 |      * @return int
18 |      */
19 |     public function getOffset(): int
20 |     {
21 |     }
22 | 
23 |     /**
24 |      * @return int
25 |      */
26 |     public function getPartition(): int
27 |     {
28 |     }
29 | 
30 |     /**
31 |      * @return string
32 |      */
33 |     public function getTopic(): string
34 |     {
35 |     }
36 | 
37 |     /**
38 |      * @param int $offset
39 |      *
40 |      * @return void
41 |      */
42 |     public function setOffset(int $offset)
43 |     {
44 |     }
45 | 
46 |     /**
47 |      * @param int $partition
48 |      *
49 |      * @return void
50 |      */
51 |     public function setPartition(int $partition)
52 |     {
53 |     }
54 | 
55 |     /**
56 |      * @param string $topic_name
57 |      *
58 |      * @return void
59 |      */
60 |     public function setTopic(string $topic_name)
61 |     {
62 |     }
63 | }
64 | 


--------------------------------------------------------------------------------
/tests/RdKafka/ProducerTopicTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace RdKafka;
 4 | 
 5 | use PHPUnit\Framework\TestCase;
 6 | 
 7 | class ProducerTopicTest extends TestCase
 8 | {
 9 |     /**
10 |      * @var ProducerTopic
11 |      */
12 |     private $producerTopic;
13 | 
14 |     public function setUp(): void
15 |     {
16 |         $conf = new Conf();
17 |         $conf->set('metadata.broker.list', 'localhost:9092');
18 |         $producer = new Producer($conf);
19 | 
20 |         $this->producerTopic = $producer->newTopic('test');
21 |     }
22 | 
23 |     public function testProducerTopicCantBeInstantiatedDirectly()
24 |     {
25 |         $reflector = new \ReflectionClass(ProducerTopic::class);
26 |         $constructor = $reflector->getConstructor();
27 | 
28 |         $this->assertTrue($constructor->isPrivate());
29 |     }
30 | 
31 |     public function testGetName()
32 |     {
33 |         $topicName = $this->producerTopic->getName();
34 | 
35 |         $this->assertEquals('test', $topicName);
36 |     }
37 | 
38 |     public function testProduce()
39 |     {
40 |         $this->producerTopic->produce(RD_KAFKA_PARTITION_UA, 0, 'testing kafka messages', 'test_key');
41 | 
42 |         $this->markTestIncomplete('Add consumer to test if message has been sent');
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/stubs/RdKafka/Producer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace RdKafka;
 4 | 
 5 | class Producer extends \RdKafka
 6 | {
 7 |     /**
 8 |      * @param Conf $conf
 9 |      */
10 |     public function __construct(Conf $conf = null)
11 |     {
12 |     }
13 | 
14 |     /**
15 |      * @param string         $topic_name
16 |      * @param TopicConf|null $topic_conf
17 |      *
18 |      * @return ProducerTopic
19 |      */
20 |     public function newTopic(string $topic_name, TopicConf $topic_conf = null): Topic
21 |     {
22 |     }
23 | 
24 |     /**
25 |      * @param int $timeoutMs
26 |      *
27 |      * @throws KafkaErrorException
28 |      * @return void
29 |      */
30 |     public function initTransactions(int $timeoutMs)
31 |     {
32 |     }
33 | 
34 |     /**
35 |      * @throws KafkaErrorException
36 |      * @return void
37 |      */
38 |     public function beginTransaction()
39 |     {
40 |     }
41 | 
42 |     /**
43 |      * @param int $timeoutMs
44 |      *
45 |      * @throws KafkaErrorException
46 |      * @return void
47 |      */
48 |     public function commitTransaction(int $timeoutMs)
49 |     {
50 |     }
51 | 
52 |     /**
53 |      * @param int $timeoutMs
54 |      *
55 |      * @throws KafkaErrorException
56 |      * @return void
57 |      */
58 |     public function abortTransaction(int $timeoutMs)
59 |     {
60 |     }
61 | }
62 | 


--------------------------------------------------------------------------------
/tests/RdKafka/MetadataTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace RdKafka;
 4 | 
 5 | use PHPUnit\Framework\TestCase;
 6 | use RdKafka\Metadata\Collection;
 7 | 
 8 | class MetadataTest extends TestCase
 9 | {
10 |     /**
11 |      * @var Metadata
12 |      */
13 |     private $metadata;
14 | 
15 |     public function setUp(): void
16 |     {
17 |         $conf = new Conf();
18 |         $conf->set('metadata.broker.list', 'localhost:9092');
19 |         $producer = new Producer($conf);
20 | 
21 |         sleep(1);
22 | 
23 |         if (method_exists($producer, 'getMetadata')) {
24 |             $this->metadata = $producer->getMetadata(true, null, 1000);
25 |         } else {
26 |             $this->metadata = $producer->metadata(true, null, 1000);
27 |         }
28 |     }
29 | 
30 |     public function testGetBrokers()
31 |     {
32 |         $this->assertInstanceOf(Collection::class, $this->metadata->getBrokers());
33 |     }
34 | 
35 |     public function testGetTopics()
36 |     {
37 |         $this->assertInstanceOf(Collection::class, $this->metadata->getTopics());
38 |     }
39 | 
40 |     public function testGetOrigBrokerId()
41 |     {
42 |         $this->assertEquals(0, $this->metadata->getOrigBrokerId());
43 |     }
44 | 
45 |     public function testGetOrigBrokerName()
46 |     {
47 |         $this->assertEquals('localhost:9092/0', $this->metadata->getOrigBrokerName());
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/tests/RdKafka/ConsumerTopicTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace RdKafka;
 4 | 
 5 | use PHPUnit\Framework\TestCase;
 6 | 
 7 | class ConsumerTopicTest extends TestCase
 8 | {
 9 |     const PARTITION = 0;
10 | 
11 |     /**
12 |      * @var ConsumerTopic
13 |      */
14 |     private $consumerTopic;
15 | 
16 |     public function setUp(): void
17 |     {
18 |         $conf = new Conf();
19 |         $conf->set('metadata.broker.list', 'localhost:9092');
20 |         $consumer = new Consumer();
21 | 
22 |         $this->consumerTopic = $consumer->newTopic('test');
23 |     }
24 | 
25 |     public function testConsumerTopicCantBeInstantiatedDirectly()
26 |     {
27 |         $reflector = new \ReflectionClass(ConsumerTopic::class);
28 |         $constructor = $reflector->getConstructor();
29 | 
30 |         $this->assertTrue($constructor->isPrivate());
31 |     }
32 | 
33 |     public function testGetName()
34 |     {
35 |         $topicName = $this->consumerTopic->getName();
36 | 
37 |         $this->assertEquals('test', $topicName);
38 |     }
39 | 
40 |     public function testConsume()
41 |     {
42 |         $this->markTestSkipped('Fails on CI');
43 | 
44 |         $conf = new Conf();
45 |         $conf->set('metadata.broker.list', 'localhost:9092');
46 |         $producer = new Producer($conf);
47 | 
48 |         /** @var ProducerTopic $producerTopic */
49 |         $producerTopic = $producer->newTopic('test');
50 |         $producerTopic->produce(self::PARTITION, 0, 'test message');
51 | 
52 |         $this->consumerTopic->consumeStart(self::PARTITION, RD_KAFKA_OFFSET_BEGINNING);
53 | 
54 |         $message = $this->consumerTopic->consume(self::PARTITION, 1000);
55 | 
56 |         $this->consumerTopic->consumeStop(self::PARTITION);
57 | 
58 |         $this->assertInstanceOf(Message::class, $message);
59 |     }
60 | }
61 | 


--------------------------------------------------------------------------------
/tests/RdKafka/MessageTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace RdKafka;
 4 | 
 5 | use PHPUnit\Framework\TestCase;
 6 | 
 7 | class MessageTest extends TestCase
 8 | {
 9 |     const PARTITION = 0;
10 |     const OFFSET    = -1;
11 | 
12 |     /**
13 |      * @var Message
14 |      */
15 |     private $message;
16 | 
17 |     public function setUp(): void
18 |     {
19 |         $conf = new Conf();
20 |         $conf->set('metadata.broker.list', 'localhost:9092');
21 | 
22 |         $producer = new Producer($conf);
23 | 
24 |         /** @var ProducerTopic $producerTopic */
25 |         $producerTopic = $producer->newTopic('test');
26 |         $producerTopic->produce(RD_KAFKA_PARTITION_UA, self::PARTITION, 'test message 2', 'key_2');
27 | 
28 |         $consumer = new Consumer($conf);
29 | 
30 |         /** @var ConsumerTopic $consumerTopic */
31 |         $consumerTopic = $consumer->newTopic('test');
32 |         $consumerTopic->consumeStart(self::PARTITION, RD_KAFKA_OFFSET_BEGINNING);
33 | 
34 |         $this->message = $consumerTopic->consume(self::PARTITION, 1000);
35 | 
36 |         //$consumerTopic->consumeStop(self::PARTITION);
37 |     }
38 | 
39 |     public function testMessageProperties()
40 |     {
41 |         $this->markTestSkipped('Fails on CI');
42 | 
43 |         $this->assertEquals(0, $this->message->err);
44 |         $this->assertEquals('test', $this->message->topic_name);
45 |         $this->assertEquals(self::PARTITION, $this->message->partition);
46 |         $this->assertEquals('test message 2', $this->message->payload);
47 |         $this->assertEquals('key_2', $this->message->key);
48 |         $this->assertGreaterThanOrEqual(0, $this->message->offset);
49 |     }
50 | 
51 |     public function testErrstr()
52 |     {
53 |         $this->markTestSkipped('Fails on CI');
54 | 
55 |         $this->assertEquals('test message 2', $this->message->errstr());
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------
/stubs/RdKafka/ConsumerTopic.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace RdKafka;
 4 | 
 5 | class ConsumerTopic extends Topic
 6 | {
 7 |     private function __construct()
 8 |     {
 9 |     }
10 | 
11 |     /**
12 |      * @param int $partition
13 |      * @param int $timeout_ms
14 |      *
15 |      * @return Message|null
16 |      */
17 |     public function consume(int $partition, int $timeout_ms)
18 |     {
19 |     }
20 | 
21 |     /**
22 |      * @param int   $partition
23 |      * @param int   $offset
24 |      * @param Queue $queue
25 |      *
26 |      * @return void
27 |      */
28 |     public function consumeQueueStart(int $partition, int $offset, Queue $queue)
29 |     {
30 |     }
31 | 
32 |     /**
33 |      * @param int $partition
34 |      * @param int $offset
35 |      *
36 |      * @return void
37 |      */
38 |     public function consumeStart(int $partition, int $offset)
39 |     {
40 |     }
41 | 
42 |     /**
43 |      * @param int $partition
44 |      *
45 |      * @return void
46 |      */
47 |     public function consumeStop(int $partition)
48 |     {
49 |     }
50 | 
51 |     /**
52 |      * @param int $partition
53 |      * @param int $offset
54 |      *
55 |      * @return void
56 |      */
57 |     public function offsetStore(int $partition, int $offset)
58 |     {
59 |     }
60 | 
61 |     /**
62 |      * @param int $partition
63 |      * @param int $timeout_ms
64 |      * @param int $batch_size
65 |      *
66 |      * @throws Exception
67 |      * @throws \InvalidArgumentException
68 |      * @return Message[]|null
69 |      */
70 |     public function consumeBatch(int $partition, int $timeout_ms, int $batch_size)
71 |     {
72 |     }
73 | 
74 |     /**
75 |      * @param int $partition
76 |      * @param int $timeout_ms
77 |      * @param callable $callback
78 |      *
79 |      * @return void
80 |      */
81 |     public function consumeCallback(int $partition, int $timeout_ms, callable $callback)
82 |     {
83 |     }
84 | }
85 | 


--------------------------------------------------------------------------------
/tests/RdKafka/ConsumerTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace RdKafka;
 4 | 
 5 | use PHPUnit\Framework\Error\Deprecated;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class ConsumerTest extends TestCase
 9 | {
10 |     /**
11 |      * @var Consumer
12 |      */
13 |     private $consumer;
14 | 
15 |     public function setUp(): void
16 |     {
17 |         $conf = new Conf();
18 |         $conf->set('metadata.broker.list', 'localhost:9092');
19 |         $this->consumer = new Consumer($conf);
20 |     }
21 | 
22 |     public function testAddBrokers()
23 |     {
24 |         $addedBrokersNumber = $this->consumer->addBrokers('localhost:9092');
25 | 
26 |         $this->assertEquals(1, $addedBrokersNumber);
27 |     }
28 | 
29 |     public function testGetMetadata()
30 |     {
31 |         if (method_exists($this->consumer, 'getMetadata')) {
32 |             $metadata = $this->consumer->getMetadata(true, null, 60e3);
33 |         } else {
34 |             $metadata = $this->consumer->metadata(true, null, 60e3);
35 |         }
36 | 
37 |         $this->assertInstanceOf(Metadata::class, $metadata);
38 |     }
39 | 
40 |     public function testGetOutQLen()
41 |     {
42 |         if (method_exists($this->consumer, 'getOutQLen')) {
43 |             $outQLen = $this->consumer->getOutQLen();
44 |         } else {
45 |             $outQLen = $this->consumer->outQLen();
46 |         }
47 | 
48 |         $this->assertEquals(0, $outQLen);
49 |     }
50 | 
51 |     public function testNewQueue()
52 |     {
53 |         $queue = $this->consumer->newQueue();
54 | 
55 |         $this->assertInstanceOf(Queue::class, $queue);
56 |     }
57 | 
58 |     public function testNewTopic()
59 |     {
60 |         $topic = $this->consumer->newTopic('test');
61 | 
62 |         $this->assertInstanceOf(ConsumerTopic::class, $topic);
63 |     }
64 | 
65 |     public function testPoll()
66 |     {
67 |         $this->consumer->poll(0);
68 | 
69 |         $this->markTestIncomplete('Create real test and trigger a callback using poll()');
70 |     }
71 | }
72 | 


--------------------------------------------------------------------------------
/tests/RdKafka/ConfTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace RdKafka;
 4 | 
 5 | use PHPUnit\Framework\TestCase;
 6 | 
 7 | class ConfTest extends TestCase
 8 | {
 9 |     /**
10 |      * @var Conf
11 |      */
12 |     private $conf;
13 | 
14 |     public function setUp(): void
15 |     {
16 |         $this->conf = new Conf();
17 |     }
18 | 
19 |     /**
20 |      * dump() returns all values for parameters as strings
21 |      */
22 |     public function testDump()
23 |     {
24 |         $this->markTestSkipped('Fails on CI');
25 | 
26 |         $expectedKeys = [
27 |             'client.id',
28 |             'message.max.bytes',
29 |             'receive.message.max.bytes',
30 |             'metadata.request.timeout.ms',
31 |             'topic.metadata.refresh.interval.ms',
32 |             'topic.metadata.refresh.fast.cnt',
33 |             'topic.metadata.refresh.fast.interval.ms',
34 |             'topic.metadata.refresh.sparse',
35 |             'socket.timeout.ms',
36 |             'socket.send.buffer.bytes',
37 |             'socket.receive.buffer.bytes',
38 |             'socket.keepalive.enable',
39 |             'socket.max.fails',
40 |             'broker.address.ttl',
41 |             'broker.address.family',
42 |             'statistics.interval.ms',
43 |             'log_cb',
44 |             'log_level',
45 |             'socket_cb',
46 |             'open_cb',
47 |             'internal.termination.signal',
48 |             'queued.min.messages',
49 |             'queued.max.messages.kbytes',
50 |             'fetch.wait.max.ms',
51 |             'fetch.message.max.bytes',
52 |             'fetch.min.bytes',
53 |             'fetch.error.backoff.ms',
54 |             'queue.buffering.max.messages',
55 |             'queue.buffering.max.ms',
56 |             'message.send.max.retries',
57 |             'retry.backoff.ms',
58 |             'compression.codec',
59 |             'batch.num.messages',
60 |             'delivery.report.only.error'
61 |         ];
62 | 
63 |         $dumpedKeys = array_keys($this->conf->dump());
64 | 
65 |         $this->assertEquals($expectedKeys, $dumpedKeys);
66 |     }
67 | 
68 |     public function testSet()
69 |     {
70 |         $this->conf->set('batch.num.messages', 666);
71 | 
72 |         $dumpedConfig = $this->conf->dump();
73 |         $batchNumMessages = $dumpedConfig['batch.num.messages'];
74 | 
75 |         $this->assertEquals(666, $batchNumMessages);
76 |     }
77 | }
78 | 


--------------------------------------------------------------------------------
/stubs/RdKafka/Conf.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace RdKafka;
  4 | 
  5 | /**
  6 |  * Configuration reference: https://github.com/edenhill/librdkafka/blob/master/CONFIGURATION.md
  7 |  */
  8 | class Conf
  9 | {
 10 |     /**
 11 |      * @return array<string, string>
 12 |      */
 13 |     public function dump(): array
 14 |     {
 15 |     }
 16 | 
 17 |     /**
 18 |      * @param string $name
 19 |      * @param string $value
 20 |      *
 21 |      * @return void
 22 |      */
 23 |     public function set(string $name, string $value)
 24 |     {
 25 |     }
 26 | 
 27 |     /**
 28 |      * @param TopicConf $topic_conf
 29 |      *
 30 |      * @deprecated Set default topic settings normally like global configuration settings.
 31 |      *
 32 |      * @return void
 33 |      */
 34 |     public function setDefaultTopicConf(TopicConf $topic_conf)
 35 |     {
 36 |     }
 37 | 
 38 |     /**
 39 |      * @param callable $callback (RdKafka\Kafka $kafka, RdKafka\Message $message)
 40 |      *
 41 |      * @return void
 42 |      */
 43 |     public function setDrMsgCb(callable $callback)
 44 |     {
 45 |     }
 46 | 
 47 |     /**
 48 |      * @param callable $callback (RdKafka\KafkaConsumer|RdKafka\Producer $kafka, int $err, string $reason)
 49 |      *
 50 |      * @return void
 51 |      */
 52 |     public function setErrorCb(callable $callback)
 53 |     {
 54 |     }
 55 | 
 56 |     /**
 57 |      * @param callable $callback (RdKafka\KafkaConsumer $kafka, int $err, array $partitions)
 58 |      *
 59 |      * @return void
 60 |      */
 61 |     public function setRebalanceCb(callable $callback)
 62 |     {
 63 |     }
 64 | 
 65 |     /**
 66 |      * @param callable $callback (object $kafka, string $json, int $json_len);
 67 |      *
 68 |      * @return void
 69 |      */
 70 |     public function setStatsCb(callable $callback)
 71 |     {
 72 |     }
 73 | 
 74 |     /**
 75 |      * @param callable $callback (RdKafka\Message $msg)
 76 |      *
 77 |      * @return void
 78 |      */
 79 |     public function setConsumeCb(callable $callback)
 80 |     {
 81 |     }
 82 | 
 83 |     /**
 84 |      * @param callable $callback (object $kafka, int $err, array $partitions);
 85 |      *
 86 |      * @return void
 87 |      */
 88 |     public function setOffsetCommitCb(callable $callback)
 89 |     {
 90 |     }
 91 | 
 92 |     /**
 93 |      * @param callable $callback (object $kafka, int $level, string $facility, string $message);
 94 |      *
 95 |      * @return void
 96 |      */
 97 |     public function setLogCb(callable $callback)
 98 |     {
 99 |     }
100 | 
101 |     /**
102 |      * @param callable $callback (RdKafka\Producer $producer)
103 |      *
104 |      * @return void
105 |      */
106 |     public function setOauthbearerTokenRefreshCb(callable $callback)
107 |     {
108 | 
109 |     }
110 | }
111 | 


--------------------------------------------------------------------------------
/stubs/RdKafka.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | use RdKafka\Exception;
  4 | use RdKafka\Metadata;
  5 | use RdKafka\Topic;
  6 | use RdKafka\TopicConf;
  7 | use RdKafka\TopicPartition;
  8 | 
  9 | abstract class RdKafka
 10 | {
 11 |     /**
 12 |      * @param string $broker_list
 13 |      *
 14 |      * @return int
 15 |      */
 16 |     public function addBrokers(string $broker_list): int
 17 |     {
 18 |     }
 19 | 
 20 |     /**
 21 |      * @param bool       $all_topics
 22 |      * @param Topic|null $only_topic
 23 |      * @param int        $timeout_ms
 24 |      *
 25 |      * @throws Exception
 26 |      * @return Metadata
 27 |      */
 28 |     public function getMetadata(bool $all_topics, Topic $only_topic = null, int $timeout_ms): Metadata
 29 |     {
 30 |     }
 31 | 
 32 |     /**
 33 |      * @return int
 34 |      */
 35 |     public function getOutQLen(): int
 36 |     {
 37 |     }
 38 | 
 39 |     /**
 40 |      * @param string    $topic_name
 41 |      * @param TopicConf $topic_conf
 42 |      *
 43 |      * @return Topic
 44 |      */
 45 |     public function newTopic(string $topic_name, TopicConf $topic_conf = null): Topic
 46 |     {
 47 |     }
 48 | 
 49 |     /**
 50 |      * @param int $timeout_ms
 51 |      *
 52 |      * @return void
 53 |      */
 54 |     public function poll(int $timeout_ms)
 55 |     {
 56 |     }
 57 | 
 58 |     /**
 59 |      * @param int $level
 60 |      *
 61 |      * @deprecated
 62 |      *
 63 |      * @return void
 64 |      */
 65 |     public function setLogLevel(int $level)
 66 |     {
 67 |     }
 68 | 
 69 |     /**
 70 |      * @deprecated
 71 |      */
 72 |     public function setLogger(int $logger_id)
 73 |     {
 74 |     }
 75 | 
 76 |     /**
 77 |      * @param string $topic
 78 |      * @param int $partition
 79 |      * @param int $low
 80 |      * @param int $high
 81 |      * @param int $timeout_ms
 82 |      */
 83 |     public function queryWatermarkOffsets(string $topic, int $partition, int &$low, int &$high, int $timeout_ms)
 84 |     {
 85 |     }
 86 | 
 87 |     /**
 88 |      * @param TopicPartition[] $topicPartitions
 89 |      * @param int   $timeout_ms
 90 |      * @return TopicPartition[]
 91 |      */
 92 |     public function offsetsForTimes (array $topicPartitions, int $timeout_ms): array
 93 |     {
 94 |     }
 95 | 
 96 |     /**
 97 |      * @param int $purge_flags
 98 |      * @return int
 99 |      */
100 |     public function purge(int $purge_flags): int
101 |     {
102 |     }
103 | 
104 |     /**
105 |      * @param int $timeout_ms
106 |      * @return int
107 |      */
108 |     public function flush(int $timeout_ms): int
109 |     {
110 |     }
111 | 
112 |     /**
113 |      * @param string $token_value
114 |      * @param int|float|string $lifetime_ms
115 |      * @param string $principal_name
116 |      * @param array $extensions
117 |      *
118 |      * @return void
119 |      */
120 |     public function oauthbearerSetToken(string $token_value, $lifetime_ms, string $principal_name, array $extensions = [])
121 |     {
122 |     }
123 | 
124 |     /**
125 |      * @param string $error
126 |      *
127 |      * @return void
128 |      */
129 |     public function oauthbearerSetTokenFailure(string $error)
130 |     {
131 |     }
132 | 
133 |     /**
134 |      * @param int $timeout_ms
135 |      *
136 |      * @return int
137 |      */
138 |     public function getControllerId(int $timeout_ms): int
139 |     {
140 | 
141 |     }
142 | }
143 | 


--------------------------------------------------------------------------------
/tests/ConstantsTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | use PHPUnit\Framework\TestCase;
  4 | 
  5 | class ConstantsTest extends TestCase
  6 | {
  7 |     /** @var array */
  8 |     private static $stubConstants;
  9 | 
 10 |     /** @var array */
 11 |     private static $extensionConstants;
 12 | 
 13 |     public static function setUpBeforeClass(): void
 14 |     {
 15 |         self::$extensionConstants = get_defined_constants(true)['rdkafka'];
 16 |         self::$stubConstants = self::loadConstantsFromStub();
 17 |     }
 18 | 
 19 |     public function testConstantsExistInStubOnly()
 20 |     {
 21 |         // constants that present in stub but not in extension
 22 |         $stubConstantsNotInExtension = array_diff_key(
 23 |             self::$stubConstants,
 24 |             array_flip([
 25 |                 /** @link https://github.com/edenhill/librdkafka/blob/master/src/rdkafka.h */
 26 |                 'RD_KAFKA_RESP_ERR_GROUP_LOAD_IN_PROGRESS', // RD_KAFKA_RESP_ERR_GROUP_LOAD_IN_PROGRESS
 27 |                 'RD_KAFKA_RESP_ERR_GROUP_COORDINATOR_NOT_AVAILABLE', // RD_KAFKA_RESP_ERR_COORDINATOR_NOT_AVAILABLE
 28 |                 'RD_KAFKA_RESP_ERR_NOT_COORDINATOR_FOR_GROUP', // RD_KAFKA_RESP_ERR_NOT_COORDINATOR
 29 |                 'RD_KAFKA_OFFSET_INVALID', // not present in extension
 30 |             ]),
 31 |             self::$extensionConstants
 32 |         );
 33 | 
 34 |         $this->assertCount(
 35 |             0,
 36 |             $stubConstantsNotInExtension,
 37 |             sprintf(
 38 |                 'In stub but not in extension: %s',
 39 |                 var_export($stubConstantsNotInExtension, true)
 40 |             )
 41 |         );
 42 |     }
 43 | 
 44 |     public function testConstantsExistInExtensionOnly()
 45 |     {
 46 |         // constants that present in extension but not in stub
 47 |         $extensionConstantsNotInStub = array_diff_key(
 48 |             self::$extensionConstants,
 49 |             self::$stubConstants
 50 |         );
 51 | 
 52 |         $this->assertCount(
 53 |             0,
 54 |             $extensionConstantsNotInStub,
 55 |             sprintf(
 56 |                 'In extension but not in stub: %s',
 57 |                 var_export($extensionConstantsNotInStub, true)
 58 |             )
 59 |         );
 60 |     }
 61 | 
 62 |     public function testConstantsExistButInvalidValue()
 63 |     {
 64 |         $extensionConstants = self::$extensionConstants;
 65 |         $stubConstants = self::$stubConstants;
 66 | 
 67 |         // unset because depends of extension version
 68 |         unset($extensionConstants['RD_KAFKA_VERSION']);
 69 |         unset($extensionConstants['RD_KAFKA_BUILD_VERSION']);
 70 |         unset($stubConstants['RD_KAFKA_VERSION']);
 71 |         unset($stubConstants['RD_KAFKA_BUILD_VERSION']);
 72 | 
 73 |         // constants in both places but has different values
 74 |         $this->assertEquals(
 75 |             array_intersect_key(
 76 |                 $extensionConstants,
 77 |                 $stubConstants
 78 |             ),
 79 |             array_intersect_key(
 80 |                 $stubConstants,
 81 |                 $extensionConstants
 82 |             )
 83 |         );
 84 |     }
 85 | 
 86 |     private static function loadConstantsFromStub(): array
 87 |     {
 88 |         $stubConstants = [];
 89 |         $constantsStubFile = fopen(__DIR__ . '/../stubs/constants.php', 'r+');
 90 |         while (!feof($constantsStubFile)) {
 91 |             $line = trim(fgets($constantsStubFile));
 92 |             if (!preg_match('/const ([0-9A-Z_]+) = (.+);/', $line, $matches)) {
 93 |                 continue;
 94 |             }
 95 | 
 96 |             $stubConstants[$matches[1]] = (int) $matches[2];
 97 |         }
 98 | 
 99 |         return $stubConstants;
100 |     }
101 | }
102 | 


--------------------------------------------------------------------------------
/tests/RdKafka/ProducerTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace RdKafka;
  4 | 
  5 | use PHPUnit\Framework\Error\Deprecated;
  6 | use PHPUnit\Framework\TestCase;
  7 | 
  8 | class ProducerTest extends TestCase
  9 | {
 10 |     const MESSAGE_PAYLOAD = 'test payload';
 11 | 
 12 |     /**
 13 |      * @var Producer
 14 |      */
 15 |     private $producer;
 16 | 
 17 |     /**
 18 |      * @var string
 19 |      */
 20 |     private $filename;
 21 | 
 22 |     public function setUp(): void
 23 |     {
 24 |         $this->filename = __DIR__ . '/../../build/message.txt';
 25 | 
 26 |         if (is_file($this->filename)) {
 27 |             unlink($this->filename);
 28 |         }
 29 | 
 30 |         $configuration = new Conf();
 31 |         $configuration->set('metadata.broker.list', 'localhost:9092');
 32 |         $configuration->setDrMsgCb(function (\RdKafka $kafka, Message $message) {
 33 |             file_put_contents($this->filename, $message->payload);
 34 |         });
 35 | 
 36 |         $this->producer = new Producer($configuration);
 37 |     }
 38 | 
 39 |     public function testAddBrokers()
 40 |     {
 41 |         $addedBrokersNumber = $this->producer->addBrokers('localhost:9092');
 42 | 
 43 |         self::assertEquals(1, $addedBrokersNumber);
 44 |     }
 45 | 
 46 |     public function testGetMetadata()
 47 |     {
 48 |         $metadata = $this->producer->getMetadata(true, null, 5000);
 49 | 
 50 |         self::assertInstanceOf(Metadata::class, $metadata);
 51 |     }
 52 | 
 53 |     public function testGetOutQLen()
 54 |     {
 55 |         $outQLen = $this->producer->getOutQLen();
 56 | 
 57 |         self::assertEquals(0, $outQLen);
 58 |     }
 59 | 
 60 |     public function testNewTopic()
 61 |     {
 62 |         $topic = $this->producer->newTopic('test');
 63 | 
 64 |         self::assertInstanceOf(ProducerTopic::class, $topic);
 65 |     }
 66 | 
 67 |     public function testPoll()
 68 |     {
 69 |         $topic = $this->producer->newTopic('test');
 70 |         $topic->produce(RD_KAFKA_PARTITION_UA, 0, self::MESSAGE_PAYLOAD);
 71 | 
 72 |         $this->producer->poll(0);
 73 |         $this->producer->flush(10000);
 74 | 
 75 |         self::assertStringEqualsFile($this->filename, self::MESSAGE_PAYLOAD);
 76 |     }
 77 | 
 78 |     public function testInitTransactions()
 79 |     {
 80 |         $configuration = new Conf();
 81 |         $configuration->set('metadata.broker.list', 'localhost:9092');
 82 |         $configuration->set('transactional.id', 'some-id');
 83 | 
 84 |         $this->producer = new Producer($configuration);
 85 | 
 86 |         self::assertNull($this->producer->initTransactions(10000));
 87 |     }
 88 | 
 89 |     public function testBeginTransaction()
 90 |     {
 91 |         $configuration = new Conf();
 92 |         $configuration->set('metadata.broker.list', 'localhost:9092');
 93 |         $configuration->set('transactional.id', 'some-id');
 94 | 
 95 |         $this->producer = new Producer($configuration);
 96 | 
 97 |         $this->producer->initTransactions(10000);
 98 |         self::assertNull($this->producer->beginTransaction());
 99 |     }
100 | 
101 |     public function testCommitTransaction()
102 |     {
103 |         $configuration = new Conf();
104 |         $configuration->set('metadata.broker.list', 'localhost:9092');
105 |         $configuration->set('transactional.id', 'some-id');
106 | 
107 |         $this->producer = new Producer($configuration);
108 | 
109 |         $this->producer->initTransactions(10000);
110 |         $this->producer->beginTransaction();
111 |         self::assertNull($this->producer->commitTransaction(10000));
112 |     }
113 | 
114 |     public function testAbortTransaction()
115 |     {
116 |         $configuration = new Conf();
117 |         $configuration->set('metadata.broker.list', 'localhost:9092');
118 |         $configuration->set('transactional.id', 'some-id');
119 | 
120 |         $this->producer = new Producer($configuration);
121 | 
122 |         $this->producer->initTransactions(10000);
123 |         $this->producer->beginTransaction();
124 |         self::assertNull($this->producer->abortTransaction(10000));
125 |     }
126 | }
127 | 


--------------------------------------------------------------------------------
/stubs/RdKafka/KafkaConsumer.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace RdKafka;
  4 | 
  5 | class KafkaConsumer
  6 | {
  7 |     /**
  8 |      * @param Conf $conf
  9 |      */
 10 |     public function __construct(Conf $conf)
 11 |     {
 12 |     }
 13 | 
 14 |     /**
 15 |      * @param TopicPartition[]|null $topic_partitions
 16 |      *
 17 |      * @throws Exception
 18 |      * @return void
 19 |      */
 20 |     public function assign(array $topic_partitions = null)
 21 |     {
 22 |     }
 23 | 
 24 |     /**
 25 |      * @param null|Message|TopicPartition[] $message_or_offsets
 26 |      *
 27 |      * @throws Exception
 28 |      * @return void
 29 |      */
 30 |     public function commit($message_or_offsets = null)
 31 |     {
 32 |     }
 33 | 
 34 |     /**
 35 |      * @param string|null $message_or_offsets
 36 |      *
 37 |      * @throws Exception
 38 |      * @return void
 39 |      */
 40 |     public function commitAsync(string $message_or_offsets = null)
 41 |     {
 42 |     }
 43 | 
 44 |     /**
 45 |      * @param int $timeout_ms
 46 |      *
 47 |      * @throws Exception
 48 |      * @throws \InvalidArgumentException
 49 |      * @return Message
 50 |      */
 51 |     public function consume(int $timeout_ms): Message
 52 |     {
 53 |     }
 54 | 
 55 |     /**
 56 |      * @throws Exception
 57 |      * @return TopicPartition[]
 58 |      */
 59 |     public function getAssignment(): array
 60 |     {
 61 |     }
 62 | 
 63 |     /**
 64 |      * @param bool                    $all_topics
 65 |      * @param KafkaConsumerTopic|null $only_topic
 66 |      * @param int                     $timeout_ms
 67 |      *
 68 |      * @throws Exception
 69 |      * @return Metadata
 70 |      */
 71 |     public function getMetadata(bool $all_topics, KafkaConsumerTopic $only_topic = null, int $timeout_ms): Metadata
 72 |     {
 73 |     }
 74 | 
 75 |     /**
 76 |      * @return string[]
 77 |      */
 78 |     public function getSubscription(): array
 79 |     {
 80 |     }
 81 | 
 82 |     /**
 83 |      * @param string         $topic_name
 84 |      * @param TopicConf|null $topic_conf
 85 |      *
 86 |      * @return KafkaConsumerTopic
 87 |      */
 88 |     public function newTopic(string $topic_name, TopicConf $topic_conf = null): KafkaConsumerTopic
 89 |     {
 90 |     }
 91 | 
 92 |     /**
 93 |      * @param string[] $topics
 94 |      * Regex pattern matching automatically performed for topics prefixed with ^ (e.g. ^myPfx[0-9]_.*)
 95 |      *
 96 |      * @throws Exception
 97 |      * @return void
 98 |      */
 99 |     public function subscribe(array $topics)
100 |     {
101 |     }
102 | 
103 |     /**
104 |      * @throws Exception
105 |      * @return void
106 |      */
107 |     public function unsubscribe()
108 |     {
109 |     }
110 | 
111 |     /**
112 |      * @param TopicPartition[] $topicPartitions
113 |      * @param int              $timeout_ms Timeout in milliseconds
114 |      *
115 |      * @throws Exception
116 |      * @return TopicPartition[]
117 |      */
118 |     public function getCommittedOffsets(array $topicPartitions, int $timeout_ms): array
119 |     {
120 |     }
121 | 
122 |     /**
123 |      * @param TopicPartition[] $topicPartitions
124 |      * @param int              $timeout_ms
125 |      * @return TopicPartition[]
126 |      */
127 |     public function offsetsForTimes(array $topicPartitions, int $timeout_ms): array
128 |     {
129 |     }
130 | 
131 |     /**
132 |      * @param string $topic
133 |      * @param int $partition
134 |      * @param int $low
135 |      * @param int $high
136 |      * @param int $timeout_ms
137 |      */
138 |     public function queryWatermarkOffsets(string $topic, int $partition, int &$low, int &$high, int $timeout_ms)
139 |     {
140 |     }
141 | 
142 |     /**
143 |      * @param TopicPartition[] $topics
144 |      *
145 |      * @throws Exception
146 |      * @return TopicPartition[]
147 |      */
148 |     public function getOffsetPositions(array $topics): array
149 |     {
150 |     }
151 | 
152 |     /**
153 |      * @return void
154 |      */
155 |     public function close()
156 |     {
157 |     }
158 | 
159 |     /**
160 |      * @param TopicPartition[] $topic_partitions
161 |      * @return TopicPartition[]
162 |      */
163 |     public function pausePartitions(array $topic_partitions): array
164 |     {
165 |     }
166 | 
167 |     /**
168 |      * @param TopicPartition[] $topic_partitions
169 |      * @return TopicPartition[]
170 |      */
171 |     public function resumePartitions(array $topic_partitions): array
172 |     {
173 |     }
174 | 
175 |     /**
176 |      * @param array $topic_partitions
177 |      */
178 |     public function incrementalAssign(array $topic_partitions)
179 |     {
180 |     }
181 | 
182 |     /**
183 |      * @param array $topic_partitions
184 |      */
185 |     public function incrementalUnassign(array $topic_partitions)
186 |     {
187 |     }
188 | }
189 | 


--------------------------------------------------------------------------------
/stubs/constants.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | /** @link https://arnaud.le-blanc.net/php-rdkafka-doc/phpdoc/rdkafka.constants.html */
  4 | 
  5 | const RD_KAFKA_RESP_ERR__BEGIN = -200;
  6 | const RD_KAFKA_RESP_ERR__BAD_MSG = -199;
  7 | const RD_KAFKA_RESP_ERR__BAD_COMPRESSION = -198;
  8 | const RD_KAFKA_RESP_ERR__DESTROY = -197;
  9 | const RD_KAFKA_RESP_ERR__FAIL = -196;
 10 | const RD_KAFKA_RESP_ERR__TRANSPORT = -195;
 11 | const RD_KAFKA_RESP_ERR__CRIT_SYS_RESOURCE = -194;
 12 | const RD_KAFKA_RESP_ERR__RESOLVE = -193;
 13 | const RD_KAFKA_RESP_ERR__MSG_TIMED_OUT = -192;
 14 | const RD_KAFKA_RESP_ERR__PARTITION_EOF = -191;
 15 | const RD_KAFKA_RESP_ERR__UNKNOWN_PARTITION = -190;
 16 | const RD_KAFKA_RESP_ERR__FS = -189;
 17 | const RD_KAFKA_RESP_ERR__UNKNOWN_TOPIC = -188;
 18 | const RD_KAFKA_RESP_ERR__ALL_BROKERS_DOWN = -187;
 19 | const RD_KAFKA_RESP_ERR__INVALID_ARG = -186;
 20 | const RD_KAFKA_RESP_ERR__TIMED_OUT = -185;
 21 | const RD_KAFKA_RESP_ERR__QUEUE_FULL = -184;
 22 | const RD_KAFKA_RESP_ERR__ISR_INSUFF = -183;
 23 | const RD_KAFKA_RESP_ERR__NODE_UPDATE = -182;
 24 | const RD_KAFKA_RESP_ERR__SSL = -181;
 25 | const RD_KAFKA_RESP_ERR__WAIT_COORD = -180;
 26 | const RD_KAFKA_RESP_ERR__UNKNOWN_GROUP = -179;
 27 | const RD_KAFKA_RESP_ERR__IN_PROGRESS = -178;
 28 | const RD_KAFKA_RESP_ERR__PREV_IN_PROGRESS = -177;
 29 | const RD_KAFKA_RESP_ERR__EXISTING_SUBSCRIPTION = -176;
 30 | const RD_KAFKA_RESP_ERR__ASSIGN_PARTITIONS = -175;
 31 | const RD_KAFKA_RESP_ERR__REVOKE_PARTITIONS = -174;
 32 | const RD_KAFKA_RESP_ERR__CONFLICT = -173;
 33 | const RD_KAFKA_RESP_ERR__STATE = -172;
 34 | const RD_KAFKA_RESP_ERR__UNKNOWN_PROTOCOL = -171;
 35 | const RD_KAFKA_RESP_ERR__NOT_IMPLEMENTED = -170;
 36 | const RD_KAFKA_RESP_ERR__AUTHENTICATION = -169;
 37 | const RD_KAFKA_RESP_ERR__NO_OFFSET = -168;
 38 | const RD_KAFKA_RESP_ERR__OUTDATED = -167;
 39 | const RD_KAFKA_RESP_ERR__TIMED_OUT_QUEUE = -166;
 40 | const RD_KAFKA_RESP_ERR__UNSUPPORTED_FEATURE = -165;
 41 | const RD_KAFKA_RESP_ERR__WAIT_CACHE = -164;
 42 | const RD_KAFKA_RESP_ERR__INTR = -163;
 43 | const RD_KAFKA_RESP_ERR__KEY_SERIALIZATION = -162;
 44 | const RD_KAFKA_RESP_ERR__VALUE_SERIALIZATION = -161;
 45 | const RD_KAFKA_RESP_ERR__KEY_DESERIALIZATION = -160;
 46 | const RD_KAFKA_RESP_ERR__VALUE_DESERIALIZATION = -159;
 47 | const RD_KAFKA_RESP_ERR__PARTIAL = -158;
 48 | const RD_KAFKA_RESP_ERR__READ_ONLY = -157;
 49 | const RD_KAFKA_RESP_ERR__NOENT = -156;
 50 | const RD_KAFKA_RESP_ERR__UNDERFLOW = -155;
 51 | const RD_KAFKA_RESP_ERR__INVALID_TYPE = -154;
 52 | const RD_KAFKA_RESP_ERR__RETRY = -153;
 53 | const RD_KAFKA_RESP_ERR__PURGE_QUEUE = -152;
 54 | const RD_KAFKA_RESP_ERR__PURGE_INFLIGHT = -151;
 55 | const RD_KAFKA_RESP_ERR__FATAL = -150;
 56 | const RD_KAFKA_RESP_ERR__INCONSISTENT = -149;
 57 | const RD_KAFKA_RESP_ERR__GAPLESS_GUARANTEE = -148;
 58 | const RD_KAFKA_RESP_ERR__MAX_POLL_EXCEEDED = -147;
 59 | const RD_KAFKA_RESP_ERR__UNKNOWN_BROKER = -146;
 60 | const RD_KAFKA_RESP_ERR__NOT_CONFIGURED = -145;
 61 | const RD_KAFKA_RESP_ERR__FENCED = -144;
 62 | const RD_KAFKA_RESP_ERR__APPLICATION = -143;
 63 | const RD_KAFKA_RESP_ERR__ASSIGNMENT_LOST = -142;
 64 | const RD_KAFKA_RESP_ERR__NOOP = -141;
 65 | const RD_KAFKA_RESP_ERR__AUTO_OFFSET_RESET = -140;
 66 | const RD_KAFKA_RESP_ERR__LOG_TRUNCATION = -139;
 67 | const RD_KAFKA_RESP_ERR__END = -100;
 68 | const RD_KAFKA_RESP_ERR_UNKNOWN = -1;
 69 | const RD_KAFKA_RESP_ERR_NO_ERROR = 0;
 70 | const RD_KAFKA_RESP_ERR_OFFSET_OUT_OF_RANGE = 1;
 71 | const RD_KAFKA_RESP_ERR_INVALID_MSG = 2;
 72 | const RD_KAFKA_RESP_ERR_UNKNOWN_TOPIC_OR_PART = 3;
 73 | const RD_KAFKA_RESP_ERR_INVALID_MSG_SIZE = 4;
 74 | const RD_KAFKA_RESP_ERR_LEADER_NOT_AVAILABLE = 5;
 75 | const RD_KAFKA_RESP_ERR_NOT_LEADER_FOR_PARTITION = 6;
 76 | const RD_KAFKA_RESP_ERR_REQUEST_TIMED_OUT = 7;
 77 | const RD_KAFKA_RESP_ERR_BROKER_NOT_AVAILABLE = 8;
 78 | const RD_KAFKA_RESP_ERR_REPLICA_NOT_AVAILABLE = 9;
 79 | const RD_KAFKA_RESP_ERR_MSG_SIZE_TOO_LARGE = 10;
 80 | const RD_KAFKA_RESP_ERR_STALE_CTRL_EPOCH = 11;
 81 | const RD_KAFKA_RESP_ERR_OFFSET_METADATA_TOO_LARGE = 12;
 82 | const RD_KAFKA_RESP_ERR_NETWORK_EXCEPTION = 13;
 83 | const RD_KAFKA_RESP_ERR_COORDINATOR_LOAD_IN_PROGRESS = 14;
 84 | const RD_KAFKA_RESP_ERR_COORDINATOR_NOT_AVAILABLE = 15;
 85 | const RD_KAFKA_RESP_ERR_NOT_COORDINATOR = 16;
 86 | const RD_KAFKA_RESP_ERR_GROUP_LOAD_IN_PROGRESS = 14; // alias, RD_KAFKA_RESP_ERR_COORDINATOR_LOAD_IN_PROGRESS
 87 | const RD_KAFKA_RESP_ERR_GROUP_COORDINATOR_NOT_AVAILABLE = 15; // alias, RD_KAFKA_RESP_ERR_COORDINATOR_NOT_AVAILABLE
 88 | const RD_KAFKA_RESP_ERR_NOT_COORDINATOR_FOR_GROUP = 16; // alias, RD_KAFKA_RESP_ERR_NOT_COORDINATOR
 89 | const RD_KAFKA_RESP_ERR_TOPIC_EXCEPTION = 17;
 90 | const RD_KAFKA_RESP_ERR_RECORD_LIST_TOO_LARGE = 18;
 91 | const RD_KAFKA_RESP_ERR_NOT_ENOUGH_REPLICAS = 19;
 92 | const RD_KAFKA_RESP_ERR_NOT_ENOUGH_REPLICAS_AFTER_APPEND = 20;
 93 | const RD_KAFKA_RESP_ERR_INVALID_REQUIRED_ACKS = 21;
 94 | const RD_KAFKA_RESP_ERR_ILLEGAL_GENERATION = 22;
 95 | const RD_KAFKA_RESP_ERR_INCONSISTENT_GROUP_PROTOCOL = 23;
 96 | const RD_KAFKA_RESP_ERR_INVALID_GROUP_ID = 24;
 97 | const RD_KAFKA_RESP_ERR_UNKNOWN_MEMBER_ID = 25;
 98 | const RD_KAFKA_RESP_ERR_INVALID_SESSION_TIMEOUT = 26;
 99 | const RD_KAFKA_RESP_ERR_REBALANCE_IN_PROGRESS = 27;
100 | const RD_KAFKA_RESP_ERR_INVALID_COMMIT_OFFSET_SIZE = 28;
101 | const RD_KAFKA_RESP_ERR_TOPIC_AUTHORIZATION_FAILED = 29;
102 | const RD_KAFKA_RESP_ERR_GROUP_AUTHORIZATION_FAILED = 30;
103 | const RD_KAFKA_RESP_ERR_CLUSTER_AUTHORIZATION_FAILED = 31;
104 | const RD_KAFKA_RESP_ERR_INVALID_TIMESTAMP = 32;
105 | const RD_KAFKA_RESP_ERR_UNSUPPORTED_SASL_MECHANISM = 33;
106 | const RD_KAFKA_RESP_ERR_ILLEGAL_SASL_STATE = 34;
107 | const RD_KAFKA_RESP_ERR_UNSUPPORTED_VERSION = 35;
108 | const RD_KAFKA_RESP_ERR_TOPIC_ALREADY_EXISTS = 36;
109 | const RD_KAFKA_RESP_ERR_INVALID_PARTITIONS = 37;
110 | const RD_KAFKA_RESP_ERR_INVALID_REPLICATION_FACTOR = 38;
111 | const RD_KAFKA_RESP_ERR_INVALID_REPLICA_ASSIGNMENT = 39;
112 | const RD_KAFKA_RESP_ERR_INVALID_CONFIG = 40;
113 | const RD_KAFKA_RESP_ERR_NOT_CONTROLLER = 41;
114 | const RD_KAFKA_RESP_ERR_INVALID_REQUEST = 42;
115 | const RD_KAFKA_RESP_ERR_UNSUPPORTED_FOR_MESSAGE_FORMAT = 43;
116 | const RD_KAFKA_RESP_ERR_POLICY_VIOLATION = 44;
117 | const RD_KAFKA_RESP_ERR_OUT_OF_ORDER_SEQUENCE_NUMBER = 45;
118 | const RD_KAFKA_RESP_ERR_DUPLICATE_SEQUENCE_NUMBER = 46;
119 | const RD_KAFKA_RESP_ERR_INVALID_PRODUCER_EPOCH = 47;
120 | const RD_KAFKA_RESP_ERR_INVALID_TXN_STATE = 48;
121 | const RD_KAFKA_RESP_ERR_INVALID_PRODUCER_ID_MAPPING = 49;
122 | const RD_KAFKA_RESP_ERR_INVALID_TRANSACTION_TIMEOUT = 50;
123 | const RD_KAFKA_RESP_ERR_CONCURRENT_TRANSACTIONS = 51;
124 | const RD_KAFKA_RESP_ERR_TRANSACTION_COORDINATOR_FENCED = 52;
125 | const RD_KAFKA_RESP_ERR_TRANSACTIONAL_ID_AUTHORIZATION_FAILED = 53;
126 | const RD_KAFKA_RESP_ERR_SECURITY_DISABLED = 54;
127 | const RD_KAFKA_RESP_ERR_OPERATION_NOT_ATTEMPTED = 55;
128 | const RD_KAFKA_RESP_ERR_KAFKA_STORAGE_ERROR = 56;
129 | const RD_KAFKA_RESP_ERR_LOG_DIR_NOT_FOUND = 57;
130 | const RD_KAFKA_RESP_ERR_SASL_AUTHENTICATION_FAILED = 58;
131 | const RD_KAFKA_RESP_ERR_UNKNOWN_PRODUCER_ID = 59;
132 | const RD_KAFKA_RESP_ERR_REASSIGNMENT_IN_PROGRESS = 60;
133 | const RD_KAFKA_RESP_ERR_DELEGATION_TOKEN_AUTH_DISABLED = 61;
134 | const RD_KAFKA_RESP_ERR_DELEGATION_TOKEN_NOT_FOUND = 62;
135 | const RD_KAFKA_RESP_ERR_DELEGATION_TOKEN_OWNER_MISMATCH = 63;
136 | const RD_KAFKA_RESP_ERR_DELEGATION_TOKEN_REQUEST_NOT_ALLOWED = 64;
137 | const RD_KAFKA_RESP_ERR_DELEGATION_TOKEN_AUTHORIZATION_FAILED = 65;
138 | const RD_KAFKA_RESP_ERR_DELEGATION_TOKEN_EXPIRED = 66;
139 | const RD_KAFKA_RESP_ERR_INVALID_PRINCIPAL_TYPE = 67;
140 | const RD_KAFKA_RESP_ERR_NON_EMPTY_GROUP = 68;
141 | const RD_KAFKA_RESP_ERR_GROUP_ID_NOT_FOUND = 69;
142 | const RD_KAFKA_RESP_ERR_FETCH_SESSION_ID_NOT_FOUND = 70;
143 | const RD_KAFKA_RESP_ERR_INVALID_FETCH_SESSION_EPOCH = 71;
144 | const RD_KAFKA_RESP_ERR_LISTENER_NOT_FOUND = 72;
145 | const RD_KAFKA_RESP_ERR_TOPIC_DELETION_DISABLED = 73;
146 | const RD_KAFKA_RESP_ERR_FENCED_LEADER_EPOCH = 74;
147 | const RD_KAFKA_RESP_ERR_UNKNOWN_LEADER_EPOCH = 75;
148 | const RD_KAFKA_RESP_ERR_UNSUPPORTED_COMPRESSION_TYPE = 76;
149 | const RD_KAFKA_RESP_ERR_STALE_BROKER_EPOCH = 77;
150 | const RD_KAFKA_RESP_ERR_OFFSET_NOT_AVAILABLE = 78;
151 | const RD_KAFKA_RESP_ERR_MEMBER_ID_REQUIRED = 79;
152 | const RD_KAFKA_RESP_ERR_PREFERRED_LEADER_NOT_AVAILABLE = 80;
153 | const RD_KAFKA_RESP_ERR_GROUP_MAX_SIZE_REACHED = 81;
154 | const RD_KAFKA_RESP_ERR_FENCED_INSTANCE_ID = 82;
155 | const RD_KAFKA_RESP_ERR_ELIGIBLE_LEADERS_NOT_AVAILABLE = 83;
156 | const RD_KAFKA_RESP_ERR_ELECTION_NOT_NEEDED = 84;
157 | const RD_KAFKA_RESP_ERR_NO_REASSIGNMENT_IN_PROGRESS = 85;
158 | const RD_KAFKA_RESP_ERR_GROUP_SUBSCRIBED_TO_TOPIC = 86;
159 | const RD_KAFKA_RESP_ERR_INVALID_RECORD = 87;
160 | const RD_KAFKA_RESP_ERR_UNSTABLE_OFFSET_COMMIT = 88;
161 | const RD_KAFKA_RESP_ERR_THROTTLING_QUOTA_EXCEEDED = 89;
162 | const RD_KAFKA_RESP_ERR_PRODUCER_FENCED = 90;
163 | const RD_KAFKA_RESP_ERR_RESOURCE_NOT_FOUND = 91;
164 | const RD_KAFKA_RESP_ERR_DUPLICATE_RESOURCE = 92;
165 | const RD_KAFKA_RESP_ERR_UNACCEPTABLE_CREDENTIAL = 93;
166 | const RD_KAFKA_RESP_ERR_INCONSISTENT_VOTER_SET = 94;
167 | const RD_KAFKA_RESP_ERR_INVALID_UPDATE_VERSION = 95;
168 | const RD_KAFKA_RESP_ERR_FEATURE_UPDATE_FAILED = 96;
169 | const RD_KAFKA_RESP_ERR_PRINCIPAL_DESERIALIZATION_FAILURE = 97;
170 | const RD_KAFKA_CONSUMER = 1;
171 | const RD_KAFKA_OFFSET_BEGINNING = -2;
172 | const RD_KAFKA_OFFSET_END = -1;
173 | const RD_KAFKA_OFFSET_STORED = -1000;
174 | const RD_KAFKA_OFFSET_INVALID = -1001;
175 | const RD_KAFKA_PARTITION_UA = -1;
176 | const RD_KAFKA_PRODUCER = 0;
177 | const RD_KAFKA_VERSION = 33751295;
178 | const RD_KAFKA_BUILD_VERSION = 33751295;
179 | const RD_KAFKA_CONF_UNKNOWN = -2;
180 | const RD_KAFKA_CONF_INVALID = -1;
181 | const RD_KAFKA_CONF_OK = 0;
182 | const RD_KAFKA_MSG_PARTITIONER_RANDOM = 2;
183 | const RD_KAFKA_MSG_PARTITIONER_CONSISTENT = 3;
184 | const RD_KAFKA_MSG_PARTITIONER_CONSISTENT_RANDOM = 4;
185 | const RD_KAFKA_MSG_PARTITIONER_MURMUR2 = 5;
186 | const RD_KAFKA_MSG_PARTITIONER_MURMUR2_RANDOM = 6;
187 | const RD_KAFKA_LOG_PRINT = 100;
188 | const RD_KAFKA_LOG_SYSLOG = 101;
189 | const RD_KAFKA_LOG_SYSLOG_PRINT = 102;
190 | const RD_KAFKA_PURGE_F_QUEUE = 1;
191 | const RD_KAFKA_PURGE_F_INFLIGHT = 2;
192 | const RD_KAFKA_PURGE_F_NON_BLOCKING = 4;
193 | const RD_KAFKA_MSG_F_BLOCK = 4;
194 | 


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