Class Library¶

Class \RdKafka\FFI\Library

uses \RdKafka\FFI\Methods

This class is for internal use. It provides access to the low level interface to librdkafka.

Best practice is to use high level interfaces like \RdKafka\Conf, \RdKafka\Producer, …

See also

https://docs.confluent.io/current/clients/librdkafka/rdkafka_8h.html

Constants¶

PHP_LIBRARY_VERSION¶

public PHP_LIBRARY_VERSION = '0.6.0'

VERSION_AUTODETECT¶

public VERSION_AUTODETECT = ''

VERSION_LATEST¶

public VERSION_LATEST = '2.6.0'

Methods¶

cast()¶

public static cast ( 
    mixed $type, 
    \FFI\CData $ptr
 ): \FFI\CData

Parameters: type mixed; ptr \FFI\CData
Returns: \FFI\CData

getClientVersion()¶

public static getClientVersion (  ): string

The client version exposed to the brokers.

The version has the format v{phpLibraryVersion}-v{bindingVersion}-librdkafka-v{librdkafkaVersion} - e.g. v0.1.0-dev-v1.5.2-librdkafka-v1.5.2)

Returns: string

getFFI()¶

public static getFFI (  ): \FFI

Returns: \FFI

getLibrary()¶

public static getLibrary (  ): string

Returns: string

getLibraryVersion()¶

public static getLibraryVersion (  ): string

The version of librdkafka

Returns: string

getVersion()¶

public static getVersion (  ): string

The version of the current binding with librdkafka

Returns: string

hasMethod()¶

public static hasMethod ( 
    string $name
 ): bool

Whether method is supported by current binding version.

Parameters: name string
Returns: bool

init()¶

public static init ( 
    string $version = self::VERSION_AUTODETECT, 
    string $scope = 'RdKafka', 
    ?string $library = null, 
    ?string $cdef = null
 ): void

Parameters: version string; scope string; library ?string; cdef ?string

new()¶

public static new ( 
    string|\FFI\CData|mixed $type, 
    bool $owned = true, 
    bool $persistent = false
 ): \FFI\CData

Parameters: type string|\FFI\CData|mixed; owned bool; persistent bool
Returns: \FFI\CData

preload()¶

public static preload ( 
    string $version = self::VERSION_AUTODETECT, 
    string $scope = 'RdKafka', 
    ?string $library = null, 
    ?string $cdef = null
 ): \FFI

Parameters: version string; scope string; library ?string; cdef ?string
Returns: \FFI

rd_kafka_AclBindingFilter_new()¶

public static rd_kafka_AclBindingFilter_new ( 
    int $restype, 
    string|null $name, 
    int $resource_pattern_type, 
    string|null $principal, 
    string|null $host, 
    int $operation, 
    int $permission_type, 
    \FFI\CData|null $errstr, 
    int|null $errstr_size
 ): \FFI\CData|null

Create a new AclBindingFilter object. This object is later passed to rd_kafka_DescribeAcls() or rd_kafka_DeletesAcls() in order to filter the acls to retrieve or to delete. Use the same rd_kafka_AclBinding functions to query or destroy it.

Parameters: restype int rd_kafka_ResourceType_t - The ResourceType or RD_KAFKA_RESOURCE_ANY if not filtering by this field.; name string|null const char* - The resource name or NULL if not filtering by this field.; resource_pattern_type int rd_kafka_ResourcePatternType_t - The pattern type or RD_KAFKA_RESOURCE_PATTERN_ANY if not filtering by this field.; principal string|null const char* - A principal or NULL if not filtering by this field.; host string|null const char* - An hostname or ip or NULL if not filtering by this field.; operation int rd_kafka_AclOperation_t - A Kafka operation or RD_KAFKA_ACL_OPERATION_ANY if not filtering by this field.; permission_type int rd_kafka_AclPermissionType_t - A Kafka permission type or RD_KAFKA_ACL_PERMISSION_TYPE_ANY if not filtering by this field.; errstr \FFI\CData|null char* - An error string for returning errors or NULL to not use it.; errstr_size int|null size_t - The errstr size or 0 to not use it.
Returns: \FFI\CData|null rd_kafka_AclBindingFilter_t* - a new allocated AclBindingFilter object, or NULL if the input parameters are invalid. Use rd_kafka_AclBinding_destroy() to free object when done.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a20003b0ae6aeb68f02f3929c5c797372

rd_kafka_AclBinding_destroy()¶

public static rd_kafka_AclBinding_destroy ( 
    \FFI\CData|null $acl_binding
 ): void

Parameters: acl_binding \FFI\CData|null rd_kafka_AclBinding_t*

rd_kafka_AclBinding_destroy_array()¶

public static rd_kafka_AclBinding_destroy_array ( 
    \FFI\CData|null $acl_bindings, 
    int|null $acl_bindings_cnt
 ): void

Parameters: acl_bindings \FFI\CData|null rd_kafka_AclBinding_t**; acl_bindings_cnt int|null size_t

rd_kafka_AclBinding_error()¶

public static rd_kafka_AclBinding_error ( 
    \FFI\CData|null $acl
 ): \FFI\CData|null

Parameters: acl \FFI\CData|null const rd_kafka_AclBinding_t* - )
Returns: \FFI\CData|null const rd_kafka_error_t* - the error object for the given acl binding, or NULL on success.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a3d71c7575dcf5dabfbf6f85ec25db7e5

rd_kafka_AclBinding_host()¶

public static rd_kafka_AclBinding_host ( 
    \FFI\CData|null $acl
 ): string|null

Remarks: lifetime of the returned string is the same as the acl.

Parameters: acl \FFI\CData|null const rd_kafka_AclBinding_t* - )
Returns: string|null const char* - the host for the given acl binding.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ad5428eeaee75110564762eed82b7ab54

rd_kafka_AclBinding_name()¶

public static rd_kafka_AclBinding_name ( 
    \FFI\CData|null $acl
 ): string|null

Remarks: lifetime of the returned string is the same as the acl.

Parameters: acl \FFI\CData|null const rd_kafka_AclBinding_t* - )
Returns: string|null const char* - the resource name for the given acl binding.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ae8aec3bdc076a78fbaf37dc39ea0983c

rd_kafka_AclBinding_new()¶

public static rd_kafka_AclBinding_new ( 
    int $restype, 
    string|null $name, 
    int $resource_pattern_type, 
    string|null $principal, 
    string|null $host, 
    int $operation, 
    int $permission_type, 
    \FFI\CData|null $errstr, 
    int|null $errstr_size
 ): \FFI\CData|null

Create a new AclBinding object. This object is later passed to rd_kafka_CreateAcls().

Parameters: restype int rd_kafka_ResourceType_t - The ResourceType.; name string|null const char* - The resource name.; resource_pattern_type int rd_kafka_ResourcePatternType_t - The pattern type.; principal string|null const char* - A principal, following the kafka specification.; host string|null const char* - An hostname or ip.; operation int rd_kafka_AclOperation_t - A Kafka operation.; permission_type int rd_kafka_AclPermissionType_t - A Kafka permission type.; errstr \FFI\CData|null char* - An error string for returning errors or NULL to not use it.; errstr_size int|null size_t - The errstr size or 0 to not use it.
Returns: \FFI\CData|null rd_kafka_AclBinding_t* - a new allocated AclBinding object, or NULL if the input parameters are invalid. Use rd_kafka_AclBinding_destroy() to free object when done.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a3475335e39b68c6033c87e05f5a4c5fa

rd_kafka_AclBinding_operation()¶

public static rd_kafka_AclBinding_operation ( 
    \FFI\CData|null $acl
 ): int

Parameters: acl \FFI\CData|null const rd_kafka_AclBinding_t* - )
Returns: int rd_kafka_AclOperation_t - the acl operation for the given acl binding.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ab4c620d7a3155c7f8cbf5556b99c2b7d

rd_kafka_AclBinding_permission_type()¶

public static rd_kafka_AclBinding_permission_type ( 
    \FFI\CData|null $acl
 ): int

Parameters: acl \FFI\CData|null const rd_kafka_AclBinding_t* - )
Returns: int rd_kafka_AclPermissionType_t - the permission type for the given acl binding.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#aadb093357b1ed866ae99c710bd5e44f3

rd_kafka_AclBinding_principal()¶

public static rd_kafka_AclBinding_principal ( 
    \FFI\CData|null $acl
 ): string|null

Remarks: lifetime of the returned string is the same as the acl.

Parameters: acl \FFI\CData|null const rd_kafka_AclBinding_t* - )
Returns: string|null const char* - the principal for the given acl binding.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a1e50b091f4562bffd21405799e4f6597

rd_kafka_AclBinding_resource_pattern_type()¶

public static rd_kafka_AclBinding_resource_pattern_type ( 
    \FFI\CData|null $acl
 ): int

Parameters: acl \FFI\CData|null const rd_kafka_AclBinding_t* - )
Returns: int rd_kafka_ResourcePatternType_t - the resource pattern type for the given acl binding.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a7c24d7c8312ea58cfdd18f8bc06fc5c8

rd_kafka_AclBinding_restype()¶

public static rd_kafka_AclBinding_restype ( 
    \FFI\CData|null $acl
 ): int

Parameters: acl \FFI\CData|null const rd_kafka_AclBinding_t* - )
Returns: int rd_kafka_ResourceType_t - the resource type for the given acl binding.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#af576f429f52ace1379cf9d2a4c453d8c

rd_kafka_AclOperation_name()¶

public static rd_kafka_AclOperation_name ( 
    int $acl_operation
 ): string|null

Parameters: acl_operation int rd_kafka_AclOperation_t - )
Returns: string|null const char* - a string representation of the acl_operation

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a191c77d49f59377c37d934ee78c13cd6

rd_kafka_AclPermissionType_name()¶

public static rd_kafka_AclPermissionType_name ( 
    int $acl_permission_type
 ): string|null

Parameters: acl_permission_type int rd_kafka_AclPermissionType_t - )
Returns: string|null const char* - a string representation of the acl_permission_type

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#aaae7406b5febd7ab37daf6cd56405a7c

rd_kafka_AdminOptions_destroy()¶

public static rd_kafka_AdminOptions_destroy ( 
    \FFI\CData|null $options
 ): void

Parameters: options \FFI\CData|null rd_kafka_AdminOptions_t*

rd_kafka_AdminOptions_new()¶

public static rd_kafka_AdminOptions_new ( 
    \FFI\CData|null $rk, 
    int $for_api
 ): \FFI\CData|null

Create a new AdminOptions object.

   The options object is not modified by the Admin API request APIs,
   (e.g. CreateTopics) and may be reused for multiple calls.

Parameters: rk \FFI\CData|null rd_kafka_t* - Client instance.; for_api int rd_kafka_admin_op_t - Specifies what Admin API this AdminOptions object will be used for, which will enforce what AdminOptions_set_..() calls may be used based on the API, causing unsupported set..() calls to fail. Specifying RD_KAFKA_ADMIN_OP_ANY disables the enforcement allowing any option to be set, even if the option is not used in a future call to an Admin API method.
Returns: \FFI\CData|null rd_kafka_AdminOptions_t* - a new AdminOptions object (which must be freed with rd_kafka_AdminOptions_destroy()), or NULL if for_api was set to an unknown API op type.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a685d10a84d9c230ea81545b280925483

rd_kafka_AdminOptions_set_broker()¶

public static rd_kafka_AdminOptions_set_broker ( 
    \FFI\CData|null $options, 
    int|null $broker_id, 
    \FFI\CData|null $errstr, 
    int|null $errstr_size
 ): int

Override what broker the Admin request will be sent to.

By default, Admin requests are sent to the controller broker, with the following exceptions:

AlterConfigs with a BROKER resource are sent to the broker id set as the resource name.
IncrementalAlterConfigs with a BROKER resource are sent to the broker id set as the resource name.
DescribeConfigs with a BROKER resource are sent to the broker id set as the resource name.

Remarks: This API should typically not be used, but serves as a workaround if new resource types are to the broker that the client does not know where to send.

Parameters: options \FFI\CData|null rd_kafka_AdminOptions_t* - Admin Options.; broker_id int|null int32_t - The broker to send the request to.; errstr \FFI\CData|null char* - A human readable error string (nul-terminated) is written to this location that must be of at least errstr_size bytes. The errstr is only written in case of error. - Writable size in errstr.; errstr_size int|null size_t
Returns: int rd_kafka_resp_err_t - RD_KAFKA_RESP_ERR_NO_ERROR on success or an error code on failure in which case an error string will be written errstr.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ae4a84f4fb6aaac8e09e186a7245a9727

rd_kafka_AdminOptions_set_include_authorized_operations()¶

public static rd_kafka_AdminOptions_set_include_authorized_operations ( 
    \FFI\CData|null $options, 
    int|null $true_or_false
 ): \FFI\CData|null

Whether broker should return authorized operations for the given resource in the DescribeConsumerGroups, DescribeTopics, or DescribeCluster calls.

Remarks: This option is valid for DescribeConsumerGroups, DescribeTopics, DescribeCluster.

Parameters: options \FFI\CData|null rd_kafka_AdminOptions_t* - Admin options.; true_or_false int|null int - Defaults to false.
Returns: \FFI\CData|null rd_kafka_error_t* - NULL on success, a new error instance that must be released with rd_kafka_error_destroy() in case of error.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a22c4e359f297cf03f5a109cb72093a27

rd_kafka_AdminOptions_set_isolation_level()¶

public static rd_kafka_AdminOptions_set_isolation_level ( 
    \FFI\CData|null $options, 
    int $value
 ): \FFI\CData|null

Parameters: options \FFI\CData|null rd_kafka_AdminOptions_t*; value int rd_kafka_IsolationLevel_t
Returns: \FFI\CData|null rd_kafka_error_t*

rd_kafka_AdminOptions_set_match_consumer_group_states()¶

public static rd_kafka_AdminOptions_set_match_consumer_group_states ( 
    \FFI\CData|null $options, 
    \FFI\CData|null $consumer_group_states, 
    int|null $consumer_group_states_cnt
 ): \FFI\CData|null

Set consumer groups states to query for.

Remarks: This option is valid for ListConsumerGroups.

Parameters: options \FFI\CData|null rd_kafka_AdminOptions_t* - Admin options.; consumer_group_states \FFI\CData|null const rd_kafka_consumer_group_state_t* - Array of consumer group states.; consumer_group_states_cnt int|null size_t - Size of the consumer_group_states array.
Returns: \FFI\CData|null rd_kafka_error_t* - NULL on success, a new error instance that must be released with rd_kafka_error_destroy() in case of error.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a907d23eac09352f32321e9d0140caab1

rd_kafka_AdminOptions_set_match_consumer_group_types()¶

public static rd_kafka_AdminOptions_set_match_consumer_group_types ( 
    \FFI\CData|null $options, 
    \FFI\CData|null $consumer_group_types, 
    int|null $consumer_group_types_cnt
 ): \FFI\CData|null

Set consumer groups types to query for.

Remarks: This option is valid for ListConsumerGroups.

Parameters: options \FFI\CData|null rd_kafka_AdminOptions_t* - Admin options.; consumer_group_types \FFI\CData|null const rd_kafka_consumer_group_type_t* - Array of consumer group types.; consumer_group_types_cnt int|null size_t - Size of the consumer_group_types array.
Returns: \FFI\CData|null rd_kafka_error_t* - NULL on success, a new error instance that must be released with rd_kafka_error_destroy() in case of error.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a93ca240fdff348f2cb46f870c51ffd1c

rd_kafka_AdminOptions_set_opaque()¶

public static rd_kafka_AdminOptions_set_opaque ( 
    \FFI\CData|null $options, 
    \FFI\CData|object|string|null $opaque
 ): void

Parameters: options \FFI\CData|null rd_kafka_AdminOptions_t*; opaque \FFI\CData|object|string|null void*

rd_kafka_AdminOptions_set_operation_timeout()¶

public static rd_kafka_AdminOptions_set_operation_timeout ( 
    \FFI\CData|null $options, 
    int|null $timeout_ms, 
    \FFI\CData|null $errstr, 
    int|null $errstr_size
 ): int

Sets the broker's operation timeout, such as the timeout for CreateTopics to complete the creation of topics on the controller before returning a result to the application.

CreateTopics: values <= 0 will return immediately after triggering topic creation, while > 0 will wait this long for topic creation to propagate in cluster. Default: 60 seconds.

DeleteTopics: same semantics as CreateTopics. CreatePartitions: same semantics as CreateTopics.

Remarks: This option is valid for CreateTopics, DeleteTopics, CreatePartitions, and DeleteRecords.

Parameters: options \FFI\CData|null rd_kafka_AdminOptions_t* - Admin options.; timeout_ms int|null int - Timeout in milliseconds.; errstr \FFI\CData|null char* - A human readable error string (nul-terminated) is written to this location that must be of at least errstr_size bytes. The errstr is only written in case of error. - Writable size in errstr.; errstr_size int|null size_t
Returns: int rd_kafka_resp_err_t - RD_KAFKA_RESP_ERR_NO_ERROR on success, or RD_KAFKA_RESP_ERR__INVALID_ARG if timeout was out of range in which case an error string will be written errstr.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a708390fc4e94ea64a98009d294116d4c

rd_kafka_AdminOptions_set_request_timeout()¶

public static rd_kafka_AdminOptions_set_request_timeout ( 
    \FFI\CData|null $options, 
    int|null $timeout_ms, 
    \FFI\CData|null $errstr, 
    int|null $errstr_size
 ): int

Sets the overall request timeout, including broker lookup, request transmission, operation time on broker, and response.

Remarks: This option is valid for all Admin API requests.

Parameters: options \FFI\CData|null rd_kafka_AdminOptions_t* - Admin options.; timeout_ms int|null int - Timeout in milliseconds. Defaults to socket.timeout.ms.; errstr \FFI\CData|null char* - A human readable error string (nul-terminated) is written to this location that must be of at least errstr_size bytes. The errstr is only written in case of error. - Writable size in errstr.; errstr_size int|null size_t
Returns: int rd_kafka_resp_err_t - RD_KAFKA_RESP_ERR_NO_ERROR on success, or RD_KAFKA_RESP_ERR__INVALID_ARG if timeout was out of range in which case an error string will be written errstr.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a9988b9e9984f7c884e11176beac17d62

rd_kafka_AdminOptions_set_require_stable_offsets()¶

public static rd_kafka_AdminOptions_set_require_stable_offsets ( 
    \FFI\CData|null $options, 
    int|null $true_or_false
 ): \FFI\CData|null

Whether broker should return stable offsets (transaction-committed).

Remarks: This option is valid for ListConsumerGroupOffsets.

Parameters: options \FFI\CData|null rd_kafka_AdminOptions_t* - Admin options.; true_or_false int|null int - Defaults to false.
Returns: \FFI\CData|null rd_kafka_error_t* - NULL on success, a new error instance that must be released with rd_kafka_error_destroy() in case of error.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a378186db06498feeb35e03a3345fc562

rd_kafka_AdminOptions_set_validate_only()¶

public static rd_kafka_AdminOptions_set_validate_only ( 
    \FFI\CData|null $options, 
    int|null $true_or_false, 
    \FFI\CData|null $errstr, 
    int|null $errstr_size
 ): int

Tell broker to only validate the request, without performing the requested operation (create topics, etc).

Remarks: This option is valid for CreateTopics, CreatePartitions, AlterConfigs.

Parameters: options \FFI\CData|null rd_kafka_AdminOptions_t* - Admin options.; true_or_false int|null int - Defaults to false.; errstr \FFI\CData|null char* - A human readable error string (nul-terminated) is written to this location that must be of at least errstr_size bytes. The errstr is only written in case of error. - Writable size in errstr.; errstr_size int|null size_t
Returns: int rd_kafka_resp_err_t - RD_KAFKA_RESP_ERR_NO_ERROR on success or an error code on failure in which case an error string will be written errstr.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ae94b1b0da81e43a4e928eea01952fb37

rd_kafka_AlterConfigs()¶

public static rd_kafka_AlterConfigs ( 
    \FFI\CData|null $rk, 
    \FFI\CData|null $configs, 
    int|null $config_cnt, 
    \FFI\CData|null $options, 
    \FFI\CData|null $rkqu
 ): void

Update the configuration for the specified resources. Updates are not transactional so they may succeed for a subset of the provided resources while the others fail. The configuration for a particular resource is updated atomically, replacing values using the provided ConfigEntrys and reverting unspecified ConfigEntrys to their default values.

Remarks: Requires broker version >=0.11.0.0

Warning: AlterConfigs will replace all existing configuration for the provided resources with the new configuration given, reverting all other configuration to their default values.

Remarks: Multiple resources and resource types may be set, but at most one resource of type RD_KAFKA_RESOURCE_BROKER is allowed per call since these resource requests must be sent to the broker specified in the resource.

Deprecated:: Use rd_kafka_IncrementalAlterConfigs().

Parameters: rk \FFI\CData|null rd_kafka_t*; configs \FFI\CData|null rd_kafka_ConfigResource_t**; config_cnt int|null size_t; options \FFI\CData|null const rd_kafka_AdminOptions_t*; rkqu \FFI\CData|null rd_kafka_queue_t*

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ade8d161dfb86a94179d286f36ec5b28e

rd_kafka_AlterConfigs_result_resources()¶

public static rd_kafka_AlterConfigs_result_resources ( 
    \FFI\CData|null $result, 
    \FFI\CData|null $cntp
 ): \FFI\CData|null

Get an array of resource results from a AlterConfigs result.

Use rd_kafka_ConfigResource_error() and rd_kafka_ConfigResource_error_string() to extract per-resource error results on the returned array elements.

The returned object life-times are the same as the result object.

Parameters: result \FFI\CData|null const rd_kafka_AlterConfigs_result_t* - Result object to get resource results from.; cntp \FFI\CData|null size_t* - is updated to the number of elements in the array.
Returns: \FFI\CData|null const rd_kafka_ConfigResource_t** - an array of ConfigResource elements, or NULL if not available.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#af477d5420ddcad9a0f09435de060dafb

rd_kafka_AlterConsumerGroupOffsets()¶

public static rd_kafka_AlterConsumerGroupOffsets ( 
    \FFI\CData|null $rk, 
    \FFI\CData|null $alter_grpoffsets, 
    int|null $alter_grpoffsets_cnt, 
    \FFI\CData|null $options, 
    \FFI\CData|null $rkqu
 ): void

Alter committed offsets for a set of partitions in a consumer group. This will succeed at the partition level only if the group is not actively subscribed to the corresponding topic.

Remarks: The result event type emitted on the supplied queue is of type RD_KAFKA_EVENT_ALTERCONSUMERGROUPOFFSETS_RESULT; The current implementation only supports one group per invocation.

Parameters: rk \FFI\CData|null rd_kafka_t* - Client instance.; alter_grpoffsets \FFI\CData|null rd_kafka_AlterConsumerGroupOffsets_t** - Array of group committed offsets to alter. MUST only be one single element.; alter_grpoffsets_cnt int|null size_t - Number of elements in alter_grpoffsets array. MUST always be 1.; options \FFI\CData|null const rd_kafka_AdminOptions_t* - Optional admin options, or NULL for defaults.; rkqu \FFI\CData|null rd_kafka_queue_t* - Queue to emit result on.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a3bebec377020469583f6c8e2f0b06ec8

rd_kafka_AlterConsumerGroupOffsets_destroy()¶

public static rd_kafka_AlterConsumerGroupOffsets_destroy ( 
    \FFI\CData|null $alter_grpoffsets
 ): void

Parameters: alter_grpoffsets \FFI\CData|null rd_kafka_AlterConsumerGroupOffsets_t*

rd_kafka_AlterConsumerGroupOffsets_destroy_array()¶

public static rd_kafka_AlterConsumerGroupOffsets_destroy_array ( 
    \FFI\CData|null $alter_grpoffsets, 
    int|null $alter_grpoffset_cnt
 ): void

Parameters: alter_grpoffsets \FFI\CData|null rd_kafka_AlterConsumerGroupOffsets_t**; alter_grpoffset_cnt int|null size_t

rd_kafka_AlterConsumerGroupOffsets_new()¶

public static rd_kafka_AlterConsumerGroupOffsets_new ( 
    string|null $group_id, 
    \FFI\CData|null $partitions
 ): \FFI\CData|null

Create a new AlterConsumerGroupOffsets object. This object is later passed to rd_kafka_AlterConsumerGroupOffsets().

Parameters: group_id string|null const char* - Consumer group id.; partitions \FFI\CData|null const rd_kafka_topic_partition_list_t* - Partitions to alter committed offsets for. Only the topic and partition fields are used.
Returns: \FFI\CData|null rd_kafka_AlterConsumerGroupOffsets_t* - a new allocated AlterConsumerGroupOffsets object. Use rd_kafka_AlterConsumerGroupOffsets_destroy() to free object when done.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#aa04df04ed898431c1d85e57e9dfb020e

rd_kafka_AlterConsumerGroupOffsets_result_groups()¶

public static rd_kafka_AlterConsumerGroupOffsets_result_groups ( 
    \FFI\CData|null $result, 
    \FFI\CData|null $cntp
 ): \FFI\CData|null

Get an array of results from a AlterConsumerGroupOffsets result.

The returned groups life-time is the same as the result object.

Remarks: The lifetime of the returned memory is the same as the lifetime of the result object.

Parameters: result \FFI\CData|null const rd_kafka_AlterConsumerGroupOffsets_result_t* - Result to get group results from.; cntp \FFI\CData|null size_t* - is updated to the number of elements in the array.
Returns: \FFI\CData|null const rd_kafka_group_result_t**

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a8b9eb384ca33b0e87606e9decd07d3eb

rd_kafka_AlterUserScramCredentials()¶

public static rd_kafka_AlterUserScramCredentials ( 
    \FFI\CData|null $rk, 
    \FFI\CData|null $alterations, 
    int|null $alteration_cnt, 
    \FFI\CData|null $options, 
    \FFI\CData|null $rkqu
 ): void

Alter SASL/SCRAM credentials. This operation is supported by brokers with version 2.7.0 or higher.

Remarks: For upsertions to be processed, librdkfka must be build with OpenSSL support. It's needed to calculate the HMAC.

Parameters: rk \FFI\CData|null rd_kafka_t* - Client instance.; alterations \FFI\CData|null rd_kafka_UserScramCredentialAlteration_t** - The alterations to be applied.; alteration_cnt int|null size_t - Number of elements in alterations array.; options \FFI\CData|null const rd_kafka_AdminOptions_t* - Optional admin options, or NULL for defaults.; rkqu \FFI\CData|null rd_kafka_queue_t* - Queue to emit result on.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ab02fa9f8f192f78c1ffb0111b0f5cb2f

rd_kafka_AlterUserScramCredentials_result_response_error()¶

public static rd_kafka_AlterUserScramCredentials_result_response_error ( 
    \FFI\CData|null $response
 ): \FFI\CData|null

Parameters: response \FFI\CData|null const rd_kafka_AlterUserScramCredentials_result_response_t*
Returns: \FFI\CData|null const rd_kafka_error_t*

rd_kafka_AlterUserScramCredentials_result_response_user()¶

public static rd_kafka_AlterUserScramCredentials_result_response_user ( 
    \FFI\CData|null $response
 ): string|null

Parameters: response \FFI\CData|null const rd_kafka_AlterUserScramCredentials_result_response_t*
Returns: string|null const char*

rd_kafka_AlterUserScramCredentials_result_responses()¶

public static rd_kafka_AlterUserScramCredentials_result_responses ( 
    \FFI\CData|null $result, 
    \FFI\CData|null $cntp
 ): \FFI\CData|null

Get an array of responses from a AlterUserScramCredentials result.

The returned value life-time is the same as the result object.

Parameters: result \FFI\CData|null const rd_kafka_AlterUserScramCredentials_result_t* - Result to get responses from.; cntp \FFI\CData|null size_t* - is updated to the number of elements in the array.
Returns: \FFI\CData|null const rd_kafka_AlterUserScramCredentials_result_response_t**

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#adb851385d7dba3b96468f2a3a4a5868f

rd_kafka_ConfigEntry_is_default()¶

public static rd_kafka_ConfigEntry_is_default ( 
    \FFI\CData|null $entry
 ): int|null

Remarks: Shall only be used on a DescribeConfigs result, otherwise returns -1.

Parameters: entry \FFI\CData|null const rd_kafka_ConfigEntry_t* - )
Returns: int|null int - 1 if the config property is set to its default value on the broker, else 0.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#abd5a9f49896cff71788bae6cbd60fed9

rd_kafka_ConfigEntry_is_read_only()¶

public static rd_kafka_ConfigEntry_is_read_only ( 
    \FFI\CData|null $entry
 ): int|null

Remarks: Shall only be used on a DescribeConfigs result, otherwise returns -1.

Parameters: entry \FFI\CData|null const rd_kafka_ConfigEntry_t* - )
Returns: int|null int - 1 if the config property is read-only on the broker, else 0.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#aa7474dc1258cceb041491d2b75e96bcb

rd_kafka_ConfigEntry_is_sensitive()¶

public static rd_kafka_ConfigEntry_is_sensitive ( 
    \FFI\CData|null $entry
 ): int|null

Remarks: An application should take care not to include the value of sensitive configuration entries in its output.; Shall only be used on a DescribeConfigs result, otherwise returns -1.

Parameters: entry \FFI\CData|null const rd_kafka_ConfigEntry_t* - )
Returns: int|null int - 1 if the config property contains sensitive information (such as security configuration), else 0.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a7cca5d473790759cb59b5fefdc992a02

rd_kafka_ConfigEntry_is_synonym()¶

public static rd_kafka_ConfigEntry_is_synonym ( 
    \FFI\CData|null $entry
 ): int|null

Parameters: entry \FFI\CData|null const rd_kafka_ConfigEntry_t* - )
Returns: int|null int - 1 if this entry is a synonym, else 0.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a1a4c6d3323beb8546fb9c0f7d13b2abb

rd_kafka_ConfigEntry_name()¶

public static rd_kafka_ConfigEntry_name ( 
    \FFI\CData|null $entry
 ): string|null

Parameters: entry \FFI\CData|null const rd_kafka_ConfigEntry_t* - )
Returns: string|null const char* - the configuration property name

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ab379f1b0d46879d4fdeb05ca818e5724

rd_kafka_ConfigEntry_source()¶

public static rd_kafka_ConfigEntry_source ( 
    \FFI\CData|null $entry
 ): int

Parameters: entry \FFI\CData|null const rd_kafka_ConfigEntry_t* - )
Returns: int rd_kafka_ConfigSource_t - the config source.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#aff8550b61387790dad381a6c1129d1b3

rd_kafka_ConfigEntry_synonyms()¶

public static rd_kafka_ConfigEntry_synonyms ( 
    \FFI\CData|null $entry, 
    \FFI\CData|null $cntp
 ): \FFI\CData|null

Remarks: The lifetime of the returned entry is the same as conf .; Shall only be used on a DescribeConfigs result, otherwise returns NULL.

Parameters: entry \FFI\CData|null const rd_kafka_ConfigEntry_t* - Entry to get synonyms for.; cntp \FFI\CData|null size_t* - is updated to the number of elements in the array.
Returns: \FFI\CData|null const rd_kafka_ConfigEntry_t** - the synonym config entry array.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a192933700fd215908d4bfd1e4e93ff51

rd_kafka_ConfigEntry_value()¶

public static rd_kafka_ConfigEntry_value ( 
    \FFI\CData|null $entry
 ): string|null

Parameters: entry \FFI\CData|null const rd_kafka_ConfigEntry_t* - )
Returns: string|null const char* - the configuration value, may be NULL for sensitive or unset properties.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#af1e740ad0e7ebf9c708b8e6cba7dd3e7

rd_kafka_ConfigResource_add_incremental_config()¶

public static rd_kafka_ConfigResource_add_incremental_config ( 
    \FFI\CData|null $config, 
    string|null $name, 
    int $op_type, 
    string|null $value
 ): \FFI\CData|null

Add the value of the configuration entry for a subsequent incremental alter config operation. APPEND and SUBTRACT are possible for list-type configuration entries only.

Parameters

config \FFI\CData|null rd_kafka_ConfigResource_t* - ConfigResource to add config property to.

name string|null const char* - Configuration name, depends on resource type.

op_type int rd_kafka_AlterConfigOpType_t - Operation type, one of rd_kafka_AlterConfigOpType_t.

value string|null const char* - Configuration value, depends on resource type and name. Set to NULL, only with with op_type set to DELETE, to revert configuration value to default.

Returns

\FFI\CData|null rd_kafka_error_t* - NULL on success, or an rd_kafka_error_t * with the corresponding error code and string. Error ownership belongs to the caller. Possible error codes:

RD_KAFKA_RESP_ERR__INVALID_ARG on invalid input.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ae989f95effcebe295a2a37c15d29b5ed

rd_kafka_ConfigResource_configs()¶

public static rd_kafka_ConfigResource_configs ( 
    \FFI\CData|null $config, 
    \FFI\CData|null $cntp
 ): \FFI\CData|null

Get an array of config entries from a ConfigResource object.

The returned object life-times are the same as the config object.

Parameters: config \FFI\CData|null const rd_kafka_ConfigResource_t* - ConfigResource to get configs from.; cntp \FFI\CData|null size_t* - is updated to the number of elements in the array.
Returns: \FFI\CData|null const rd_kafka_ConfigEntry_t**

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a3ee9b18e3b1dc3367f5ef3f3347bf098

rd_kafka_ConfigResource_destroy()¶

public static rd_kafka_ConfigResource_destroy ( 
    \FFI\CData|null $config
 ): void

Parameters: config \FFI\CData|null rd_kafka_ConfigResource_t*

rd_kafka_ConfigResource_destroy_array()¶

public static rd_kafka_ConfigResource_destroy_array ( 
    \FFI\CData|null $config, 
    int|null $config_cnt
 ): void

Parameters: config \FFI\CData|null rd_kafka_ConfigResource_t**; config_cnt int|null size_t

rd_kafka_ConfigResource_error()¶

public static rd_kafka_ConfigResource_error ( 
    \FFI\CData|null $config
 ): int

Parameters: config \FFI\CData|null const rd_kafka_ConfigResource_t* - )
Returns: int rd_kafka_resp_err_t - the error for this resource from an AlterConfigs request

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a6a4c8cf9e53472c30c6b1dd78e3ba560

rd_kafka_ConfigResource_error_string()¶

public static rd_kafka_ConfigResource_error_string ( 
    \FFI\CData|null $config
 ): string|null

Parameters: config \FFI\CData|null const rd_kafka_ConfigResource_t* - )
Returns: string|null const char* - the error string for this resource from an AlterConfigs request, or NULL if no error.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a96f9d507d6d89c21bd597b75fcd99c27

rd_kafka_ConfigResource_name()¶

public static rd_kafka_ConfigResource_name ( 
    \FFI\CData|null $config
 ): string|null

Parameters: config \FFI\CData|null const rd_kafka_ConfigResource_t* - )
Returns: string|null const char* - the name for config

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#abecdb6f1b926e529c5df5aa82874cb9d

rd_kafka_ConfigResource_new()¶

public static rd_kafka_ConfigResource_new ( 
    int $restype, 
    string|null $resname
 ): \FFI\CData|null

Create new ConfigResource object.

Parameters: restype int rd_kafka_ResourceType_t - The resource type (e.g., RD_KAFKA_RESOURCE_TOPIC); resname string|null const char* - The resource name (e.g., the topic name)
Returns: \FFI\CData|null rd_kafka_ConfigResource_t* - a newly allocated object

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#adedb3f1f695c5e5a90ee03fbdc7f6e4a

rd_kafka_ConfigResource_set_config()¶

public static rd_kafka_ConfigResource_set_config ( 
    \FFI\CData|null $config, 
    string|null $name, 
    string|null $value
 ): int

Set configuration name value pair.

This will overwrite the current value.

Parameters: config \FFI\CData|null rd_kafka_ConfigResource_t* - ConfigResource to set config property on.; name string|null const char* - Configuration name, depends on resource type.; value string|null const char* - Configuration value, depends on resource type and name. Set to NULL to revert configuration value to default.
Returns: int rd_kafka_resp_err_t - RD_KAFKA_RESP_ERR_NO_ERROR if config was added to resource, or RD_KAFKA_RESP_ERR__INVALID_ARG on invalid input.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#afbc1ffd0a5a938e6a9998365903010e5

rd_kafka_ConfigResource_type()¶

public static rd_kafka_ConfigResource_type ( 
    \FFI\CData|null $config
 ): int

Parameters: config \FFI\CData|null const rd_kafka_ConfigResource_t* - )
Returns: int rd_kafka_ResourceType_t - the ResourceType for config

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#afb2a6e896b74d2f07246ede8269eb8f6

rd_kafka_ConfigSource_name()¶

public static rd_kafka_ConfigSource_name ( 
    int $confsource
 ): string|null

Parameters: confsource int rd_kafka_ConfigSource_t - )
Returns: string|null const char* - a string representation of the confsource.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ac12e21fba3216ac6f1f1eb5aa2859b9c

rd_kafka_ConsumerGroupDescription_authorized_operations()¶

public static rd_kafka_ConsumerGroupDescription_authorized_operations ( 
    \FFI\CData|null $grpdesc, 
    \FFI\CData|null $cntp
 ): \FFI\CData|null

Gets the authorized ACL operations for the grpdesc group.

Remarks: The lifetime of the returned memory is the same as the lifetime of the grpdesc object.

Parameters: grpdesc \FFI\CData|null const rd_kafka_ConsumerGroupDescription_t* - The group description.; cntp \FFI\CData|null size_t* - is updated with authorized ACL operations count.
Returns: \FFI\CData|null const rd_kafka_AclOperation_t* - The group authorized operations. Is NULL if operations were not requested.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ac0e7847f00bf23095790e2d472416825

rd_kafka_ConsumerGroupDescription_coordinator()¶

public static rd_kafka_ConsumerGroupDescription_coordinator ( 
    \FFI\CData|null $grpdesc
 ): \FFI\CData|null

Gets the coordinator for the grpdesc group.

Remarks: The lifetime of the returned memory is the same as the lifetime of the grpdesc object.

Parameters: grpdesc \FFI\CData|null const rd_kafka_ConsumerGroupDescription_t* - ) - The group description.
Returns: \FFI\CData|null const rd_kafka_Node_t* - The group coordinator.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a5106552902a7666627ed96957b18b7f5

rd_kafka_ConsumerGroupDescription_error()¶

public static rd_kafka_ConsumerGroupDescription_error ( 
    \FFI\CData|null $grpdesc
 ): \FFI\CData|null

Gets the error for the grpdesc group.

Remarks: The lifetime of the returned memory is the same as the lifetime of the grpdesc object.

Parameters: grpdesc \FFI\CData|null const rd_kafka_ConsumerGroupDescription_t* - ) - The group description.
Returns: \FFI\CData|null const rd_kafka_error_t* - The group description error.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a20e364a289b27f317bb6badf792d258d

rd_kafka_ConsumerGroupDescription_group_id()¶

public static rd_kafka_ConsumerGroupDescription_group_id ( 
    \FFI\CData|null $grpdesc
 ): string|null

Gets the group id for the grpdesc group.

Remarks: The lifetime of the returned memory is the same as the lifetime of the grpdesc object.

Parameters: grpdesc \FFI\CData|null const rd_kafka_ConsumerGroupDescription_t* - ) - The group description.
Returns: string|null const char* - The group id.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a67ac9d914b5748579972cd83c52718b9

rd_kafka_ConsumerGroupDescription_is_simple_consumer_group()¶

public static rd_kafka_ConsumerGroupDescription_is_simple_consumer_group ( 
    \FFI\CData|null $grpdesc
 ): int|null

Is the grpdesc group a simple consumer group.

Parameters: grpdesc \FFI\CData|null const rd_kafka_ConsumerGroupDescription_t* - ) - The group description.
Returns: int|null int - 1 if the group is a simple consumer group, else 0.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#aa142302fb0912b8350254f22d1ebf0cf

rd_kafka_ConsumerGroupDescription_member()¶

public static rd_kafka_ConsumerGroupDescription_member ( 
    \FFI\CData|null $grpdesc, 
    int|null $idx
 ): \FFI\CData|null

Gets a member of grpdesc group.

Remarks: The lifetime of the returned memory is the same as the lifetime of the grpdesc object.

Parameters: grpdesc \FFI\CData|null const rd_kafka_ConsumerGroupDescription_t* - The group description.; idx int|null size_t - The member idx.
Returns: \FFI\CData|null const rd_kafka_MemberDescription_t* - A member at index idx, or NULL if idx is out of range.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a0ffb23c272f79cd548f71b7c0ad24fc4

rd_kafka_ConsumerGroupDescription_member_count()¶

public static rd_kafka_ConsumerGroupDescription_member_count ( 
    \FFI\CData|null $grpdesc
 ): int|null

Gets the members count of grpdesc group.

Parameters: grpdesc \FFI\CData|null const rd_kafka_ConsumerGroupDescription_t* - ) - The group description.
Returns: int|null size_t - The member count.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#aa508c92d434adb9027cdec9022b10acf

rd_kafka_ConsumerGroupDescription_partition_assignor()¶

public static rd_kafka_ConsumerGroupDescription_partition_assignor ( 
    \FFI\CData|null $grpdesc
 ): string|null

Gets the partition assignor for the grpdesc group.

Remarks: The lifetime of the returned memory is the same as the lifetime of the grpdesc object.

Parameters: grpdesc \FFI\CData|null const rd_kafka_ConsumerGroupDescription_t* - ) - The group description.
Returns: string|null const char* - The partition assignor.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a26883b4c05b244fc198e17cde819afa1

rd_kafka_ConsumerGroupDescription_state()¶

public static rd_kafka_ConsumerGroupDescription_state ( 
    \FFI\CData|null $grpdesc
 ): int

Gets state for the grpdesc group.

Parameters: grpdesc \FFI\CData|null const rd_kafka_ConsumerGroupDescription_t* - ) - The group description.
Returns: int rd_kafka_consumer_group_state_t - A group state.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#acc29475b069d8299cbc20b558fb2bb19

rd_kafka_ConsumerGroupListing_group_id()¶

public static rd_kafka_ConsumerGroupListing_group_id ( 
    \FFI\CData|null $grplist
 ): string|null

Gets the group id for the grplist group.

Remarks: The lifetime of the returned memory is the same as the lifetime of the grplist object.

Parameters: grplist \FFI\CData|null const rd_kafka_ConsumerGroupListing_t* - ) - The group listing.
Returns: string|null const char* - The group id.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a6a27124991b0decc2fb03078fa7b902d

rd_kafka_ConsumerGroupListing_is_simple_consumer_group()¶

public static rd_kafka_ConsumerGroupListing_is_simple_consumer_group ( 
    \FFI\CData|null $grplist
 ): int|null

Is the grplist group a simple consumer group.

Parameters: grplist \FFI\CData|null const rd_kafka_ConsumerGroupListing_t* - ) - The group listing.
Returns: int|null int - 1 if the group is a simple consumer group, else 0.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ab41e0d25c3a013426d97d0bceb22e91d

rd_kafka_ConsumerGroupListing_state()¶

public static rd_kafka_ConsumerGroupListing_state ( 
    \FFI\CData|null $grplist
 ): int

Gets state for the grplist group.

Parameters: grplist \FFI\CData|null const rd_kafka_ConsumerGroupListing_t* - ) - The group listing.
Returns: int rd_kafka_consumer_group_state_t - A group state.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a050b8eb40679af7564533793b42954e3

rd_kafka_ConsumerGroupListing_type()¶

public static rd_kafka_ConsumerGroupListing_type ( 
    \FFI\CData|null $grplist
 ): int

Gets type for the grplist group.

Parameters: grplist \FFI\CData|null const rd_kafka_ConsumerGroupListing_t* - ) - The group listing.
Returns: int rd_kafka_consumer_group_type_t - A group type.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ad8e4f9a805d98acc521a32ff585fff90

rd_kafka_CreateAcls()¶

public static rd_kafka_CreateAcls ( 
    \FFI\CData|null $rk, 
    \FFI\CData|null $new_acls, 
    int|null $new_acls_cnt, 
    \FFI\CData|null $options, 
    \FFI\CData|null $rkqu
 ): void

Create acls as specified by the new_acls array of size new_topic_cnt elements.

Supported admin options:

rd_kafka_AdminOptions_set_request_timeout() - default socket.timeout.ms

Remarks: The result event type emitted on the supplied queue is of type RD_KAFKA_EVENT_CREATEACLS_RESULT

Parameters: rk \FFI\CData|null rd_kafka_t* - Client instance.; new_acls \FFI\CData|null rd_kafka_AclBinding_t** - Array of new acls to create.; new_acls_cnt int|null size_t - Number of elements in new_acls array.; options \FFI\CData|null const rd_kafka_AdminOptions_t* - Optional admin options, or NULL for defaults.; rkqu \FFI\CData|null rd_kafka_queue_t* - Queue to emit result on.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a028d1a0ff870bcea561d3cf474aa7265

rd_kafka_CreateAcls_result_acls()¶

public static rd_kafka_CreateAcls_result_acls ( 
    \FFI\CData|null $result, 
    \FFI\CData|null $cntp
 ): \FFI\CData|null

Get an array of acl results from a CreateAcls result.

The returned acl result life-time is the same as the result object.

Parameters: result \FFI\CData|null const rd_kafka_CreateAcls_result_t* - CreateAcls result to get acl results from.; cntp \FFI\CData|null size_t* - is updated to the number of elements in the array.
Returns: \FFI\CData|null const rd_kafka_acl_result_t**

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a03ef006de8d9d739e33f1c6951e34872

rd_kafka_CreatePartitions()¶

public static rd_kafka_CreatePartitions ( 
    \FFI\CData|null $rk, 
    \FFI\CData|null $new_parts, 
    int|null $new_parts_cnt, 
    \FFI\CData|null $options, 
    \FFI\CData|null $rkqu
 ): void

Create additional partitions for the given topics, as specified by the new_parts array of size new_parts_cnt elements.

Supported admin options:

rd_kafka_AdminOptions_set_validate_only() - default false
rd_kafka_AdminOptions_set_operation_timeout() - default 60 seconds
rd_kafka_AdminOptions_set_request_timeout() - default socket.timeout.ms

Remarks: The result event type emitted on the supplied queue is of type RD_KAFKA_EVENT_CREATEPARTITIONS_RESULT

Parameters: rk \FFI\CData|null rd_kafka_t* - Client instance.; new_parts \FFI\CData|null rd_kafka_NewPartitions_t** - Array of topics for which new partitions are to be created.; new_parts_cnt int|null size_t - Number of elements in new_parts array.; options \FFI\CData|null const rd_kafka_AdminOptions_t* - Optional admin options, or NULL for defaults.; rkqu \FFI\CData|null rd_kafka_queue_t* - Queue to emit result on.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a1bed8947475ee683033d7988f0b09378

rd_kafka_CreatePartitions_result_topics()¶

public static rd_kafka_CreatePartitions_result_topics ( 
    \FFI\CData|null $result, 
    \FFI\CData|null $cntp
 ): \FFI\CData|null

Get an array of topic results from a CreatePartitions result.

The returned topics life-time is the same as the result object.

Parameters: result \FFI\CData|null const rd_kafka_CreatePartitions_result_t* - Result o get topic results from.; cntp \FFI\CData|null size_t* - is updated to the number of elements in the array.
Returns: \FFI\CData|null const rd_kafka_topic_result_t**

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#aeb762fa2b79cccb4e569c94b3c0c08db

rd_kafka_CreateTopics()¶

public static rd_kafka_CreateTopics ( 
    \FFI\CData|null $rk, 
    \FFI\CData|null $new_topics, 
    int|null $new_topic_cnt, 
    \FFI\CData|null $options, 
    \FFI\CData|null $rkqu
 ): void

Create topics in cluster as specified by the new_topics array of size new_topic_cnt elements.

Supported admin options:

rd_kafka_AdminOptions_set_validate_only() - default false
rd_kafka_AdminOptions_set_operation_timeout() - default 60 seconds
rd_kafka_AdminOptions_set_request_timeout() - default socket.timeout.ms

Remarks: The result event type emitted on the supplied queue is of type RD_KAFKA_EVENT_CREATETOPICS_RESULT

Parameters: rk \FFI\CData|null rd_kafka_t* - Client instance.; new_topics \FFI\CData|null rd_kafka_NewTopic_t** - Array of new topics to create.; new_topic_cnt int|null size_t - Number of elements in new_topics array.; options \FFI\CData|null const rd_kafka_AdminOptions_t* - Optional admin options, or NULL for defaults.; rkqu \FFI\CData|null rd_kafka_queue_t* - Queue to emit result on.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a6988b48e1a255fbb2badd6c6e11692f3

rd_kafka_CreateTopics_result_topics()¶

public static rd_kafka_CreateTopics_result_topics ( 
    \FFI\CData|null $result, 
    \FFI\CData|null $cntp
 ): \FFI\CData|null

Get an array of topic results from a CreateTopics result.

The returned topics life-time is the same as the result object.

Parameters: result \FFI\CData|null const rd_kafka_CreateTopics_result_t* - Result to get topics from.; cntp \FFI\CData|null size_t* - Updated to the number of elements in the array.
Returns: \FFI\CData|null const rd_kafka_topic_result_t**

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a8ee8ad354e6eb6689ad3e9025251b095

rd_kafka_DeleteAcls()¶

public static rd_kafka_DeleteAcls ( 
    \FFI\CData|null $rk, 
    \FFI\CData|null $del_acls, 
    int|null $del_acls_cnt, 
    \FFI\CData|null $options, 
    \FFI\CData|null $rkqu
 ): void

Delete acls matching the filteres provided in del_acls array of size del_acls_cnt.

Supported admin options:

rd_kafka_AdminOptions_set_operation_timeout() - default 0

Remarks: The result event type emitted on the supplied queue is of type RD_KAFKA_EVENT_DELETEACLS_RESULT

Parameters: rk \FFI\CData|null rd_kafka_t* - Client instance.; del_acls \FFI\CData|null rd_kafka_AclBindingFilter_t** - Filters for the acls to delete.; del_acls_cnt int|null size_t - Number of elements in del_acls array.; options \FFI\CData|null const rd_kafka_AdminOptions_t* - Optional admin options, or NULL for defaults.; rkqu \FFI\CData|null rd_kafka_queue_t* - Queue to emit result on.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a6118e40b9abfff686a61dc5e093468ef

rd_kafka_DeleteAcls_result_response_error()¶

public static rd_kafka_DeleteAcls_result_response_error ( 
    \FFI\CData|null $result_response
 ): \FFI\CData|null

Parameters: result_response \FFI\CData|null const rd_kafka_DeleteAcls_result_response_t* - )
Returns: \FFI\CData|null const rd_kafka_error_t* - the error object for the given DeleteAcls result response, or NULL on success.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a3a4767716acf53669f0259f72e63d4cc

rd_kafka_DeleteAcls_result_response_matching_acls()¶

public static rd_kafka_DeleteAcls_result_response_matching_acls ( 
    \FFI\CData|null $result_response, 
    \FFI\CData|null $matching_acls_cntp
 ): \FFI\CData|null

Remarks: lifetime of the returned acl bindings is the same as the result_response.

Parameters: result_response \FFI\CData|null const rd_kafka_DeleteAcls_result_response_t*; matching_acls_cntp \FFI\CData|null size_t*
Returns: \FFI\CData|null const rd_kafka_AclBinding_t** - the matching acls array for the given DeleteAcls result response.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#adb7705eb3f43feba306e857093e6f96c

rd_kafka_DeleteAcls_result_responses()¶

public static rd_kafka_DeleteAcls_result_responses ( 
    \FFI\CData|null $result, 
    \FFI\CData|null $cntp
 ): \FFI\CData|null

Get an array of DeleteAcls result responses from a DeleteAcls result.

The returned responses life-time is the same as the result object.

Parameters: result \FFI\CData|null const rd_kafka_DeleteAcls_result_t* - DeleteAcls result to get responses from.; cntp \FFI\CData|null size_t* - is updated to the number of elements in the array.
Returns: \FFI\CData|null const rd_kafka_DeleteAcls_result_response_t**

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a244823e75162a97908ef8a9ebe011ddf

rd_kafka_DeleteConsumerGroupOffsets()¶

public static rd_kafka_DeleteConsumerGroupOffsets ( 
    \FFI\CData|null $rk, 
    \FFI\CData|null $del_grpoffsets, 
    int|null $del_grpoffsets_cnt, 
    \FFI\CData|null $options, 
    \FFI\CData|null $rkqu
 ): void

Delete committed offsets for a set of partitions in a consumer group. This will succeed at the partition level only if the group is not actively subscribed to the corresponding topic.

Remarks: The result event type emitted on the supplied queue is of type RD_KAFKA_EVENT_DELETECONSUMERGROUPOFFSETS_RESULT; The current implementation only supports one group per invocation.

Parameters: rk \FFI\CData|null rd_kafka_t* - Client instance.; del_grpoffsets \FFI\CData|null rd_kafka_DeleteConsumerGroupOffsets_t** - Array of group committed offsets to delete. MUST only be one single element.; del_grpoffsets_cnt int|null size_t - Number of elements in del_grpoffsets array. MUST always be 1.; options \FFI\CData|null const rd_kafka_AdminOptions_t* - Optional admin options, or NULL for defaults.; rkqu \FFI\CData|null rd_kafka_queue_t* - Queue to emit result on.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#afa8e8de419157cf97a083b9355d3385f

rd_kafka_DeleteConsumerGroupOffsets_destroy()¶

public static rd_kafka_DeleteConsumerGroupOffsets_destroy ( 
    \FFI\CData|null $del_grpoffsets
 ): void

Parameters: del_grpoffsets \FFI\CData|null rd_kafka_DeleteConsumerGroupOffsets_t*

rd_kafka_DeleteConsumerGroupOffsets_destroy_array()¶

public static rd_kafka_DeleteConsumerGroupOffsets_destroy_array ( 
    \FFI\CData|null $del_grpoffsets, 
    int|null $del_grpoffset_cnt
 ): void

Parameters: del_grpoffsets \FFI\CData|null rd_kafka_DeleteConsumerGroupOffsets_t**; del_grpoffset_cnt int|null size_t

rd_kafka_DeleteConsumerGroupOffsets_new()¶

public static rd_kafka_DeleteConsumerGroupOffsets_new ( 
    string|null $group, 
    \FFI\CData|null $partitions
 ): \FFI\CData|null

Create a new DeleteConsumerGroupOffsets object. This object is later passed to rd_kafka_DeleteConsumerGroupOffsets().

Parameters: group string|null const char* - Consumer group id.; partitions \FFI\CData|null const rd_kafka_topic_partition_list_t* - Partitions to delete committed offsets for. Only the topic and partition fields are used.
Returns: \FFI\CData|null rd_kafka_DeleteConsumerGroupOffsets_t* - a new allocated DeleteConsumerGroupOffsets object. Use rd_kafka_DeleteConsumerGroupOffsets_destroy() to free object when done.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a8bb6df9dd6ce4e86dea385f90151d81f

rd_kafka_DeleteConsumerGroupOffsets_result_groups()¶

public static rd_kafka_DeleteConsumerGroupOffsets_result_groups ( 
    \FFI\CData|null $result, 
    \FFI\CData|null $cntp
 ): \FFI\CData|null

Get an array of results from a DeleteConsumerGroupOffsets result.

The returned groups life-time is the same as the result object.

Parameters: result \FFI\CData|null const rd_kafka_DeleteConsumerGroupOffsets_result_t* - Result to get group results from.; cntp \FFI\CData|null size_t* - is updated to the number of elements in the array.
Returns: \FFI\CData|null const rd_kafka_group_result_t**

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a039a9e287e641e3f017c94ab1c48b18b

rd_kafka_DeleteGroup_destroy()¶

public static rd_kafka_DeleteGroup_destroy ( 
    \FFI\CData|null $del_group
 ): void

Parameters: del_group \FFI\CData|null rd_kafka_DeleteGroup_t*

rd_kafka_DeleteGroup_destroy_array()¶

public static rd_kafka_DeleteGroup_destroy_array ( 
    \FFI\CData|null $del_groups, 
    int|null $del_group_cnt
 ): void

Parameters: del_groups \FFI\CData|null rd_kafka_DeleteGroup_t**; del_group_cnt int|null size_t

rd_kafka_DeleteGroup_new()¶

public static rd_kafka_DeleteGroup_new ( 
    string|null $group
 ): \FFI\CData|null

Create a new DeleteGroup object. This object is later passed to rd_kafka_DeleteGroups().

Parameters: group string|null const char* - ) - Name of group to delete.
Returns: \FFI\CData|null rd_kafka_DeleteGroup_t* - a new allocated DeleteGroup object. Use rd_kafka_DeleteGroup_destroy() to free object when done.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a6c3bb6e2b05f40bed55ffdfe2b4daa59

rd_kafka_DeleteGroups()¶

public static rd_kafka_DeleteGroups ( 
    \FFI\CData|null $rk, 
    \FFI\CData|null $del_groups, 
    int|null $del_group_cnt, 
    \FFI\CData|null $options, 
    \FFI\CData|null $rkqu
 ): void

Delete groups from cluster as specified by the del_groups array of size del_group_cnt elements.

Remarks: The result event type emitted on the supplied queue is of type RD_KAFKA_EVENT_DELETEGROUPS_RESULT; This function in called deleteConsumerGroups in the Java client.

Parameters: rk \FFI\CData|null rd_kafka_t* - Client instance.; del_groups \FFI\CData|null rd_kafka_DeleteGroup_t** - Array of groups to delete.; del_group_cnt int|null size_t - Number of elements in del_groups array.; options \FFI\CData|null const rd_kafka_AdminOptions_t* - Optional admin options, or NULL for defaults.; rkqu \FFI\CData|null rd_kafka_queue_t* - Queue to emit result on.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#af929e4f20999b43d7bd3724502c1b27a

rd_kafka_DeleteGroups_result_groups()¶

public static rd_kafka_DeleteGroups_result_groups ( 
    \FFI\CData|null $result, 
    \FFI\CData|null $cntp
 ): \FFI\CData|null

Get an array of group results from a DeleteGroups result.

The returned groups life-time is the same as the result object.

Parameters: result \FFI\CData|null const rd_kafka_DeleteGroups_result_t* - Result to get group results from.; cntp \FFI\CData|null size_t* - is updated to the number of elements in the array.
Returns: \FFI\CData|null const rd_kafka_group_result_t**

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a0246ba70addd9d3c8f8091ea433cabb7

rd_kafka_DeleteRecords()¶

public static rd_kafka_DeleteRecords ( 
    \FFI\CData|null $rk, 
    \FFI\CData|null $del_records, 
    int|null $del_record_cnt, 
    \FFI\CData|null $options, 
    \FFI\CData|null $rkqu
 ): void

Delete records (messages) in topic partitions older than the offsets provided.

Supported admin options:

rd_kafka_AdminOptions_set_operation_timeout() - default 60 seconds. Controls how long the brokers will wait for records to be deleted.
rd_kafka_AdminOptions_set_request_timeout() - default socket.timeout.ms. Controls how long rdkafka will wait for the request to complete.

Remarks: The result event type emitted on the supplied queue is of type RD_KAFKA_EVENT_DELETERECORDS_RESULT

Parameters: rk \FFI\CData|null rd_kafka_t* - Client instance.; del_records \FFI\CData|null rd_kafka_DeleteRecords_t** - The offsets to delete (up to). Currently only one DeleteRecords_t (but containing multiple offsets) is supported.; del_record_cnt int|null size_t - The number of elements in del_records, must be 1.; options \FFI\CData|null const rd_kafka_AdminOptions_t* - Optional admin options, or NULL for defaults.; rkqu \FFI\CData|null rd_kafka_queue_t* - Queue to emit result on.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#aad06345d1b4cd13e56d7253b889b2349

rd_kafka_DeleteRecords_destroy()¶

public static rd_kafka_DeleteRecords_destroy ( 
    \FFI\CData|null $del_records
 ): void

Parameters: del_records \FFI\CData|null rd_kafka_DeleteRecords_t*

rd_kafka_DeleteRecords_destroy_array()¶

public static rd_kafka_DeleteRecords_destroy_array ( 
    \FFI\CData|null $del_records, 
    int|null $del_record_cnt
 ): void

Parameters: del_records \FFI\CData|null rd_kafka_DeleteRecords_t**; del_record_cnt int|null size_t

rd_kafka_DeleteRecords_new()¶

public static rd_kafka_DeleteRecords_new ( 
    \FFI\CData|null $before_offsets
 ): \FFI\CData|null

Create a new DeleteRecords object. This object is later passed to rd_kafka_DeleteRecords().

before_offsets must contain topic, partition, and offset is the offset before which the messages will be deleted (exclusive). Set offset to RD_KAFKA_OFFSET_END (high-watermark) in order to delete all data in the partition.

Parameters: before_offsets \FFI\CData|null const rd_kafka_topic_partition_list_t* - ) - For each partition delete all messages up to but not including the specified offset.
Returns: \FFI\CData|null rd_kafka_DeleteRecords_t* - a new allocated DeleteRecords object. Use rd_kafka_DeleteRecords_destroy() to free object when done.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#adbbe46dc5bfe86a3ead89c130b13d9f8

rd_kafka_DeleteRecords_result_offsets()¶

public static rd_kafka_DeleteRecords_result_offsets ( 
    \FFI\CData|null $result
 ): \FFI\CData|null

Get a list of topic and partition results from a DeleteRecords result. The returned objects will contain topic, partition, offset and err. offset will be set to the post-deletion low-watermark (smallest available offset of all live replicas). err will be set per-partition if deletion failed.

The returned object's life-time is the same as the result object.

Parameters: result \FFI\CData|null const rd_kafka_DeleteRecords_result_t* - )
Returns: \FFI\CData|null const rd_kafka_topic_partition_list_t*

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#aadccd815e56ad7434bd0e7865ae5b4c5

rd_kafka_DeleteTopic_destroy()¶

public static rd_kafka_DeleteTopic_destroy ( 
    \FFI\CData|null $del_topic
 ): void

Parameters: del_topic \FFI\CData|null rd_kafka_DeleteTopic_t*

rd_kafka_DeleteTopic_destroy_array()¶

public static rd_kafka_DeleteTopic_destroy_array ( 
    \FFI\CData|null $del_topics, 
    int|null $del_topic_cnt
 ): void

Parameters: del_topics \FFI\CData|null rd_kafka_DeleteTopic_t**; del_topic_cnt int|null size_t

rd_kafka_DeleteTopic_new()¶

public static rd_kafka_DeleteTopic_new ( 
    string|null $topic
 ): \FFI\CData|null

Create a new DeleteTopic object. This object is later passed to rd_kafka_DeleteTopics().

Parameters: topic string|null const char* - ) - Topic name to delete.
Returns: \FFI\CData|null rd_kafka_DeleteTopic_t* - a new allocated DeleteTopic object. Use rd_kafka_DeleteTopic_destroy() to free object when done.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a1e0a19934a857ca8b59ddbe8dbe24b0e

rd_kafka_DeleteTopics()¶

public static rd_kafka_DeleteTopics ( 
    \FFI\CData|null $rk, 
    \FFI\CData|null $del_topics, 
    int|null $del_topic_cnt, 
    \FFI\CData|null $options, 
    \FFI\CData|null $rkqu
 ): void

Delete topics from cluster as specified by the topics array of size topic_cnt elements.

Remarks: The result event type emitted on the supplied queue is of type RD_KAFKA_EVENT_DELETETOPICS_RESULT

Parameters: rk \FFI\CData|null rd_kafka_t* - Client instance.; del_topics \FFI\CData|null rd_kafka_DeleteTopic_t** - Array of topics to delete.; del_topic_cnt int|null size_t - Number of elements in topics array.; options \FFI\CData|null const rd_kafka_AdminOptions_t* - Optional admin options, or NULL for defaults.; rkqu \FFI\CData|null rd_kafka_queue_t* - Queue to emit result on.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ae6f7fd92bb32f14c30bbcd22cbda2b4a

rd_kafka_DeleteTopics_result_topics()¶

public static rd_kafka_DeleteTopics_result_topics ( 
    \FFI\CData|null $result, 
    \FFI\CData|null $cntp
 ): \FFI\CData|null

Get an array of topic results from a DeleteTopics result.

The returned topics life-time is the same as the result object.

Parameters: result \FFI\CData|null const rd_kafka_DeleteTopics_result_t* - Result to get topic results from.; cntp \FFI\CData|null size_t* - is updated to the number of elements in the array.
Returns: \FFI\CData|null const rd_kafka_topic_result_t**

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a2bb352835e3d9f409377391ffbe27fc8

rd_kafka_DescribeAcls()¶

public static rd_kafka_DescribeAcls ( 
    \FFI\CData|null $rk, 
    \FFI\CData|null $acl_filter, 
    \FFI\CData|null $options, 
    \FFI\CData|null $rkqu
 ): void

Describe acls matching the filter provided in acl_filter.

Supported admin options:

rd_kafka_AdminOptions_set_operation_timeout() - default 0

Remarks: The result event type emitted on the supplied queue is of type RD_KAFKA_EVENT_DESCRIBEACLS_RESULT

Parameters: rk \FFI\CData|null rd_kafka_t* - Client instance.; acl_filter \FFI\CData|null rd_kafka_AclBindingFilter_t* - Filter for the returned acls.; options \FFI\CData|null const rd_kafka_AdminOptions_t* - Optional admin options, or NULL for defaults.; rkqu \FFI\CData|null rd_kafka_queue_t* - Queue to emit result on.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a7dcf8b0d43014b7412d9a5059006194b

rd_kafka_DescribeAcls_result_acls()¶

public static rd_kafka_DescribeAcls_result_acls ( 
    \FFI\CData|null $result, 
    \FFI\CData|null $cntp
 ): \FFI\CData|null

Get an array of resource results from a DescribeAcls result.

DescribeAcls - describe access control lists. The returned resources life-time is the same as the result object.

Parameters: result \FFI\CData|null const rd_kafka_DescribeAcls_result_t* - DescribeAcls result to get acls from.; cntp \FFI\CData|null size_t* - is updated to the number of elements in the array.
Returns: \FFI\CData|null const rd_kafka_AclBinding_t**

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a218f0d67fb21c4275df3dd5a030bb500

rd_kafka_DescribeCluster()¶

public static rd_kafka_DescribeCluster ( 
    \FFI\CData|null $rk, 
    \FFI\CData|null $options, 
    \FFI\CData|null $rkqu
 ): void

Describes the cluster.

Remarks: The result event type emitted on the supplied queue is of type RD_KAFKA_EVENT_DESCRIBECLUSTER_RESULT

Parameters

rk \FFI\CData|null rd_kafka_t* - Client instance.

options \FFI\CData|null const rd_kafka_AdminOptions_t* - Optional admin options, or NULL for defaults. Valid options:

include_authorized_operations

rkqu \FFI\CData|null rd_kafka_queue_t* - Queue to emit result on.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#aeb726c502cc8ae2bf8688c4b6222b928

rd_kafka_DescribeCluster_result_authorized_operations()¶

public static rd_kafka_DescribeCluster_result_authorized_operations ( 
    \FFI\CData|null $result, 
    \FFI\CData|null $cntp
 ): \FFI\CData|null

Gets the authorized ACL operations for the result cluster.

Remarks: The lifetime of the returned memory is the same as the lifetime of the result object.

Parameters: result \FFI\CData|null const rd_kafka_DescribeCluster_result_t* - The result of DescribeCluster.; cntp \FFI\CData|null size_t* - is updated with authorized ACL operations count.
Returns: \FFI\CData|null const rd_kafka_AclOperation_t* - The cluster authorized operations. Is NULL if operations were not requested.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#aa988aaac59fe7e1d2c6160a360a5d409

rd_kafka_DescribeCluster_result_cluster_id()¶

public static rd_kafka_DescribeCluster_result_cluster_id ( 
    \FFI\CData|null $result
 ): string|null

Gets the cluster id for the result cluster.

Remarks: The lifetime of the returned memory is the same as the lifetime of the result object.

Parameters: result \FFI\CData|null const rd_kafka_DescribeCluster_result_t* - ) - The result of DescribeCluster.
Returns: string|null const char* - The cluster id.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a942e7ebd44cea3347bd5f2a179ef4af0

rd_kafka_DescribeCluster_result_controller()¶

public static rd_kafka_DescribeCluster_result_controller ( 
    \FFI\CData|null $result
 ): \FFI\CData|null

Gets the current controller for the result cluster.

Parameters: result \FFI\CData|null const rd_kafka_DescribeCluster_result_t* - ) - The result of DescribeCluster.
Returns: \FFI\CData|null const rd_kafka_Node_t* - The cluster current controller.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ae3b6f12975ae0fdbdcc965c57fc93e09

rd_kafka_DescribeCluster_result_nodes()¶

public static rd_kafka_DescribeCluster_result_nodes ( 
    \FFI\CData|null $result, 
    \FFI\CData|null $cntp
 ): \FFI\CData|null

Gets the broker nodes for the result cluster.

Remarks: The lifetime of the returned memory is the same as the lifetime of the result object.

Parameters: result \FFI\CData|null const rd_kafka_DescribeCluster_result_t* - The result of DescribeCluster.; cntp \FFI\CData|null size_t* - is updated with the count of broker nodes.
Returns: \FFI\CData|null const rd_kafka_Node_t** - An array of broker nodes.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#abff01b7298dc6294e3e71cf68a8a030d

rd_kafka_DescribeConfigs()¶

public static rd_kafka_DescribeConfigs ( 
    \FFI\CData|null $rk, 
    \FFI\CData|null $configs, 
    int|null $config_cnt, 
    \FFI\CData|null $options, 
    \FFI\CData|null $rkqu
 ): void

Get configuration for the specified resources in configs.

The returned configuration includes default values and the rd_kafka_ConfigEntry_is_default() or rd_kafka_ConfigEntry_source() methods may be used to distinguish them from user supplied values.

The value of config entries where rd_kafka_ConfigEntry_is_sensitive() is true will always be NULL to avoid disclosing sensitive information, such as security settings.

Configuration entries where rd_kafka_ConfigEntry_is_read_only() is true can't be updated (with rd_kafka_AlterConfigs()).

Synonym configuration entries are returned if the broker supports it (broker version >= 1.1.0). See rd_kafka_ConfigEntry_synonyms().

Remarks: Requires broker version >=0.11.0.0; Multiple resources and resource types may be requested, but at most one resource of type RD_KAFKA_RESOURCE_BROKER is allowed per call since these resource requests must be sent to the broker specified in the resource.

Parameters: rk \FFI\CData|null rd_kafka_t*; configs \FFI\CData|null rd_kafka_ConfigResource_t**; config_cnt int|null size_t; options \FFI\CData|null const rd_kafka_AdminOptions_t*; rkqu \FFI\CData|null rd_kafka_queue_t*

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ac6c5d7be2cd16c6875ddc946c9918df2

rd_kafka_DescribeConfigs_result_resources()¶

public static rd_kafka_DescribeConfigs_result_resources ( 
    \FFI\CData|null $result, 
    \FFI\CData|null $cntp
 ): \FFI\CData|null

Get an array of resource results from a DescribeConfigs result.

The returned resources life-time is the same as the result object.

Parameters: result \FFI\CData|null const rd_kafka_DescribeConfigs_result_t* - Result object to get resource results from.; cntp \FFI\CData|null size_t* - is updated to the number of elements in the array.
Returns: \FFI\CData|null const rd_kafka_ConfigResource_t**

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a30da84abba0df9f93460d15dc064f3ef

rd_kafka_DescribeConsumerGroups()¶

public static rd_kafka_DescribeConsumerGroups ( 
    \FFI\CData|null $rk, 
    \FFI\CData|null $groups, 
    int|null $groups_cnt, 
    \FFI\CData|null $options, 
    \FFI\CData|null $rkqu
 ): void

Describe groups from cluster as specified by the groups array of size groups_cnt elements.

Remarks: The result event type emitted on the supplied queue is of type RD_KAFKA_EVENT_DESCRIBECONSUMERGROUPS_RESULT

Parameters

rk \FFI\CData|null rd_kafka_t* - Client instance.

groups \FFI\CData|null const char** - Array of groups to describe.

groups_cnt int|null size_t - Number of elements in groups array.

options \FFI\CData|null const rd_kafka_AdminOptions_t* - Optional admin options, or NULL for defaults. Valid options:

include_authorized_operations

rkqu \FFI\CData|null rd_kafka_queue_t* - Queue to emit result on.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a3c473e95da2231aaaeca990a6ff45ad1

rd_kafka_DescribeConsumerGroups_result_groups()¶

public static rd_kafka_DescribeConsumerGroups_result_groups ( 
    \FFI\CData|null $result, 
    \FFI\CData|null $cntp
 ): \FFI\CData|null

Get an array of group results from a DescribeConsumerGroups result.

The returned groups life-time is the same as the result object.

Remarks: The lifetime of the returned memory is the same as the lifetime of the result object.

Parameters: result \FFI\CData|null const rd_kafka_DescribeConsumerGroups_result_t* - Result to get group results from.; cntp \FFI\CData|null size_t* - is updated to the number of elements in the array.
Returns: \FFI\CData|null const rd_kafka_ConsumerGroupDescription_t**

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a804bc69aede27fdd90977971a16d228f

rd_kafka_DescribeTopics()¶

public static rd_kafka_DescribeTopics ( 
    \FFI\CData|null $rk, 
    \FFI\CData|null $topics, 
    \FFI\CData|null $options, 
    \FFI\CData|null $rkqu
 ): void

Describe topics as specified by the topics array of size topics_cnt elements.

Remarks: The result event type emitted on the supplied queue is of type RD_KAFKA_EVENT_DESCRIBETOPICS_RESULT

Parameters

rk \FFI\CData|null rd_kafka_t* - Client instance.

topics \FFI\CData|null const rd_kafka_TopicCollection_t* - Collection of topics to describe.

options \FFI\CData|null const rd_kafka_AdminOptions_t* - Optional admin options, or NULL for defaults. Valid options:

include_authorized_operations

rkqu \FFI\CData|null rd_kafka_queue_t* - Queue to emit result on.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a71e57916fc3936132289c81974c54c71

rd_kafka_DescribeTopics_result_topics()¶

public static rd_kafka_DescribeTopics_result_topics ( 
    \FFI\CData|null $result, 
    \FFI\CData|null $cntp
 ): \FFI\CData|null

Get an array of topic results from a DescribeTopics result.

Remarks: The lifetime of the returned memory is the same as the lifetime of the result object.

Parameters: result \FFI\CData|null const rd_kafka_DescribeTopics_result_t* - Result to get topics results from.; cntp \FFI\CData|null size_t* - is updated to the number of elements in the array.
Returns: \FFI\CData|null const rd_kafka_TopicDescription_t**

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ad05681eacf78ab2e1e6444638f753dfb

rd_kafka_DescribeUserScramCredentials()¶

public static rd_kafka_DescribeUserScramCredentials ( 
    \FFI\CData|null $rk, 
    \FFI\CData|null $users, 
    int|null $user_cnt, 
    \FFI\CData|null $options, 
    \FFI\CData|null $rkqu
 ): void

Describe SASL/SCRAM credentials. This operation is supported by brokers with version 2.7.0 or higher.

Parameters: rk \FFI\CData|null rd_kafka_t* - Client instance.; users \FFI\CData|null const char** - The users for which credentials are to be described. All users’ credentials are described if NULL.; user_cnt int|null size_t - Number of elements in users array.; options \FFI\CData|null const rd_kafka_AdminOptions_t* - Optional admin options, or NULL for defaults.; rkqu \FFI\CData|null rd_kafka_queue_t* - Queue to emit result on.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ac9d2f72dd1dddce0c7d24a4e413b3cf5

rd_kafka_DescribeUserScramCredentials_result_descriptions()¶

public static rd_kafka_DescribeUserScramCredentials_result_descriptions ( 
    \FFI\CData|null $result, 
    \FFI\CData|null $cntp
 ): \FFI\CData|null

Get an array of descriptions from a DescribeUserScramCredentials result.

The returned value life-time is the same as the result object.

Parameters: result \FFI\CData|null const rd_kafka_DescribeUserScramCredentials_result_t* - Result to get descriptions from.; cntp \FFI\CData|null size_t* - is updated to the number of elements in the array.
Returns: \FFI\CData|null const rd_kafka_UserScramCredentialsDescription_t**

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a6cff8d4ffdc15521a29993994904b4ef

rd_kafka_ElectLeaders()¶

public static rd_kafka_ElectLeaders ( 
    \FFI\CData|null $rk, 
    \FFI\CData|null $elect_leaders, 
    \FFI\CData|null $options, 
    \FFI\CData|null $rkqu
 ): void

Elect Leaders for the provided Topic Partitions according to the specified election type.

Supported admin options:

rd_kafka_AdminOptions_set_operation_timeout() - default 60 seconds. Controls how long the brokers will wait for records to be deleted.
rd_kafka_AdminOptions_set_request_timeout() - default socket.timeout.ms. Controls how long rdkafka will wait for the request to complete.

Remarks: The result event type emitted on the supplied queue is of type RD_KAFKA_EVENT_ELECTLEADERS_RESULT; If we are passing partitions as NULL, then the broker will attempt leader election for all partitions, but the results will contain only partitions for which there was an election or resulted in an error.

Parameters: rk \FFI\CData|null rd_kafka_t* - Client instance.; elect_leaders \FFI\CData|null rd_kafka_ElectLeaders_t* - The elect leaders request containing election type and partitions information.; options \FFI\CData|null const rd_kafka_AdminOptions_t* - Optional admin options, or NULL for defaults.; rkqu \FFI\CData|null rd_kafka_queue_t* - Queue to emit result on.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ac96e1dcd76d254a5b0c37f8ed5a62b61

rd_kafka_ElectLeaders_destroy()¶

public static rd_kafka_ElectLeaders_destroy ( 
    \FFI\CData|null $elect_leaders
 ): void

Destroy and free a rd_kafka_ElectLeaders_t object previously created with rd_kafka_ElectLeaders_new()

Parameters: elect_leaders \FFI\CData|null rd_kafka_ElectLeaders_t* - ) - The rd_kafka_ElectLeaders_t object to be destroyed.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a033c1190f2a18a34aa9d9051eb17a190

rd_kafka_ElectLeaders_new()¶

public static rd_kafka_ElectLeaders_new ( 
    int $election_type, 
    \FFI\CData|null $partitions
 ): \FFI\CData|null

Create a new rd_kafka_ElectLeaders_t object. This object is later passed to rd_kafka_ElectLeaders().

Parameters: election_type int rd_kafka_ElectionType_t - The election type that needs to be performed, preferred or unclean.; partitions \FFI\CData|null rd_kafka_topic_partition_list_t* - The topic partitions for which the leader election needs to be performed.
Returns: \FFI\CData|null rd_kafka_ElectLeaders_t* - a new allocated elect leaders object or returns NULL in case of invalid election_type. Use rd_kafka_ElectLeaders_destroy() to free object when done.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a059bcca58185c29fdf9908d7d11e8b22

rd_kafka_ElectLeaders_result_partitions()¶

public static rd_kafka_ElectLeaders_result_partitions ( 
    \FFI\CData|null $result, 
    \FFI\CData|null $cntp
 ): \FFI\CData|null

Get the array of topic partition result objects from the elect leaders result event and populates the size of the array in cntp.

Parameters: result \FFI\CData|null const rd_kafka_ElectLeaders_result_t* - The elect leaders result.; cntp \FFI\CData|null size_t* - The number of elements in the array.
Returns: \FFI\CData|null const rd_kafka_topic_partition_result_t** - the array of topic partition result objects from the elect leaders result event.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a0d79dcd7889ec3b02c2448a3d1486cf2

rd_kafka_IncrementalAlterConfigs()¶

public static rd_kafka_IncrementalAlterConfigs ( 
    \FFI\CData|null $rk, 
    \FFI\CData|null $configs, 
    int|null $config_cnt, 
    \FFI\CData|null $options, 
    \FFI\CData|null $rkqu
 ): void

Incrementally update the configuration for the specified resources. Updates are not transactional so they may succeed for some resources while fail for others. The configs for a particular resource are updated atomically, executing the corresponding incremental operations on the provided configurations.

Remarks: Requires broker version >=2.3.0; Multiple resources and resource types may be set, but at most one resource of type RD_KAFKA_RESOURCE_BROKER is allowed per call since these resource requests must be sent to the broker specified in the resource. Broker option will be ignored in this case.

Parameters: rk \FFI\CData|null rd_kafka_t* - Client instance.; configs \FFI\CData|null rd_kafka_ConfigResource_t** - Array of config entries to alter.; config_cnt int|null size_t - Number of elements in configs array.; options \FFI\CData|null const rd_kafka_AdminOptions_t* - Optional admin options, or NULL for defaults.; rkqu \FFI\CData|null rd_kafka_queue_t* - Queue to emit result on.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a36805ba8496fed43f6e87421c259804b

rd_kafka_IncrementalAlterConfigs_result_resources()¶

public static rd_kafka_IncrementalAlterConfigs_result_resources ( 
    \FFI\CData|null $result, 
    \FFI\CData|null $cntp
 ): \FFI\CData|null

Get an array of resource results from a IncrementalAlterConfigs result.

Use rd_kafka_ConfigResource_error() and rd_kafka_ConfigResource_error_string() to extract per-resource error results on the returned array elements.

The returned object life-times are the same as the result object.

Parameters: result \FFI\CData|null const rd_kafka_IncrementalAlterConfigs_result_t* - Result object to get resource results from.; cntp \FFI\CData|null size_t* - is updated to the number of elements in the array.
Returns: \FFI\CData|null const rd_kafka_ConfigResource_t** - an array of ConfigResource elements, or NULL if not available.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ae6b92f7bfcbc102ed47b463c8c6d7608

rd_kafka_ListConsumerGroupOffsets()¶

public static rd_kafka_ListConsumerGroupOffsets ( 
    \FFI\CData|null $rk, 
    \FFI\CData|null $list_grpoffsets, 
    int|null $list_grpoffsets_cnt, 
    \FFI\CData|null $options, 
    \FFI\CData|null $rkqu
 ): void

List committed offsets for a set of partitions in a consumer group.

Remarks: The result event type emitted on the supplied queue is of type RD_KAFKA_EVENT_LISTCONSUMERGROUPOFFSETS_RESULT; The current implementation only supports one group per invocation.

Parameters: rk \FFI\CData|null rd_kafka_t* - Client instance.; list_grpoffsets \FFI\CData|null rd_kafka_ListConsumerGroupOffsets_t** - Array of group committed offsets to list. MUST only be one single element.; list_grpoffsets_cnt int|null size_t - Number of elements in list_grpoffsets array. MUST always be 1.; options \FFI\CData|null const rd_kafka_AdminOptions_t* - Optional admin options, or NULL for defaults.; rkqu \FFI\CData|null rd_kafka_queue_t* - Queue to emit result on.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ab51163573f8a19f0ec240428fd8fca3e

rd_kafka_ListConsumerGroupOffsets_destroy()¶

public static rd_kafka_ListConsumerGroupOffsets_destroy ( 
    \FFI\CData|null $list_grpoffsets
 ): void

Parameters: list_grpoffsets \FFI\CData|null rd_kafka_ListConsumerGroupOffsets_t*

rd_kafka_ListConsumerGroupOffsets_destroy_array()¶

public static rd_kafka_ListConsumerGroupOffsets_destroy_array ( 
    \FFI\CData|null $list_grpoffsets, 
    int|null $list_grpoffset_cnt
 ): void

Parameters: list_grpoffsets \FFI\CData|null rd_kafka_ListConsumerGroupOffsets_t**; list_grpoffset_cnt int|null size_t

rd_kafka_ListConsumerGroupOffsets_new()¶

public static rd_kafka_ListConsumerGroupOffsets_new ( 
    string|null $group_id, 
    \FFI\CData|null $partitions
 ): \FFI\CData|null

Create a new ListConsumerGroupOffsets object. This object is later passed to rd_kafka_ListConsumerGroupOffsets().

Parameters: group_id string|null const char* - Consumer group id.; partitions \FFI\CData|null const rd_kafka_topic_partition_list_t* - Partitions to list committed offsets for. Only the topic and partition fields are used.
Returns: \FFI\CData|null rd_kafka_ListConsumerGroupOffsets_t* - a new allocated ListConsumerGroupOffsets object. Use rd_kafka_ListConsumerGroupOffsets_destroy() to free object when done.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#af96cc3e1031d498fdf46f5590d8a7ea2

rd_kafka_ListConsumerGroupOffsets_result_groups()¶

public static rd_kafka_ListConsumerGroupOffsets_result_groups ( 
    \FFI\CData|null $result, 
    \FFI\CData|null $cntp
 ): \FFI\CData|null

Get an array of results from a ListConsumerGroupOffsets result.

The returned groups life-time is the same as the result object.

Remarks: The lifetime of the returned memory is the same as the lifetime of the result object.

Parameters: result \FFI\CData|null const rd_kafka_ListConsumerGroupOffsets_result_t* - Result to get group results from.; cntp \FFI\CData|null size_t* - is updated to the number of elements in the array.
Returns: \FFI\CData|null const rd_kafka_group_result_t**

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a23b262447d3f65fc2ba52f5002d9c195

rd_kafka_ListConsumerGroups()¶

public static rd_kafka_ListConsumerGroups ( 
    \FFI\CData|null $rk, 
    \FFI\CData|null $options, 
    \FFI\CData|null $rkqu
 ): void

List the consumer groups available in the cluster.

Remarks: The result event type emitted on the supplied queue is of type RD_KAFKA_EVENT_LISTCONSUMERGROUPS_RESULT

Parameters: rk \FFI\CData|null rd_kafka_t* - Client instance.; options \FFI\CData|null const rd_kafka_AdminOptions_t* - Optional admin options, or NULL for defaults.; rkqu \FFI\CData|null rd_kafka_queue_t* - Queue to emit result on.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ad386f553c1b0a103bd4f891f48a516c2

rd_kafka_ListConsumerGroups_result_errors()¶

public static rd_kafka_ListConsumerGroups_result_errors ( 
    \FFI\CData|null $result, 
    \FFI\CData|null $cntp
 ): \FFI\CData|null

Get an array of errors from a ListConsumerGroups call result.

The returned errors life-time is the same as the result object.

Remarks: The lifetime of the returned memory is the same as the lifetime of the result object.

Parameters: result \FFI\CData|null const rd_kafka_ListConsumerGroups_result_t* - ListConsumerGroups result.; cntp \FFI\CData|null size_t* - Is updated to the number of elements in the array.
Returns: \FFI\CData|null const rd_kafka_error_t** - Array of errors in result.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a54dd847029c30daa85d90aa434ccb59c

rd_kafka_ListConsumerGroups_result_valid()¶

public static rd_kafka_ListConsumerGroups_result_valid ( 
    \FFI\CData|null $result, 
    \FFI\CData|null $cntp
 ): \FFI\CData|null

Get an array of valid list groups from a ListConsumerGroups result.

The returned groups life-time is the same as the result object.

Remarks: The lifetime of the returned memory is the same as the lifetime of the result object.

Parameters: result \FFI\CData|null const rd_kafka_ListConsumerGroups_result_t* - Result to get group results from.; cntp \FFI\CData|null size_t* - is updated to the number of elements in the array.
Returns: \FFI\CData|null const rd_kafka_ConsumerGroupListing_t**

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a70aed36558cd405af861a4dbeb6ccd21

rd_kafka_ListOffsets()¶

public static rd_kafka_ListOffsets ( 
    \FFI\CData|null $rk, 
    \FFI\CData|null $topic_partitions, 
    \FFI\CData|null $options, 
    \FFI\CData|null $rkqu
 ): void

List offsets for the specified topic_partitions. This operation enables to find the beginning offset, end offset as well as the offset matching a timestamp in partitions or the offset with max timestamp.

Supported admin options:

rd_kafka_AdminOptions_set_isolation_level() - default RD_KAFKA_ISOLATION_LEVEL_READ_UNCOMMITTED
rd_kafka_AdminOptions_set_request_timeout() - default socket.timeout.ms

Remarks: The result event type emitted on the supplied queue is of type RD_KAFKA_EVENT_LISTOFFSETS_RESULT

Parameters: rk \FFI\CData|null rd_kafka_t* - Client instance.; topic_partitions \FFI\CData|null rd_kafka_topic_partition_list_t* - topic_partition_list_t with the partitions and offsets to list. Each topic partition offset can be a value of the rd_kafka_OffsetSpec_t enum or a non-negative value, representing a timestamp, to query for the first offset after the given timestamp.; options \FFI\CData|null const rd_kafka_AdminOptions_t* - Optional admin options, or NULL for defaults.; rkqu \FFI\CData|null rd_kafka_queue_t* - Queue to emit result on.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a264a98c3d96233e68a05739baed9428f

rd_kafka_ListOffsetsResultInfo_timestamp()¶

public static rd_kafka_ListOffsetsResultInfo_timestamp ( 
    \FFI\CData|null $result_info
 ): int|null

Parameters: result_info \FFI\CData|null const rd_kafka_ListOffsetsResultInfo_t*
Returns: int|null int64_t

rd_kafka_ListOffsetsResultInfo_topic_partition()¶

public static rd_kafka_ListOffsetsResultInfo_topic_partition ( 
    \FFI\CData|null $result_info
 ): \FFI\CData|null

Parameters: result_info \FFI\CData|null const rd_kafka_ListOffsetsResultInfo_t*
Returns: \FFI\CData|null const rd_kafka_topic_partition_t*

rd_kafka_ListOffsets_result_infos()¶

public static rd_kafka_ListOffsets_result_infos ( 
    \FFI\CData|null $result, 
    \FFI\CData|null $cntp
 ): \FFI\CData|null

Parameters: result \FFI\CData|null const rd_kafka_ListOffsets_result_t*; cntp \FFI\CData|null size_t*
Returns: \FFI\CData|null const rd_kafka_ListOffsetsResultInfo_t**

rd_kafka_MemberAssignment_partitions()¶

public static rd_kafka_MemberAssignment_partitions ( 
    \FFI\CData|null $assignment
 ): \FFI\CData|null

Gets assigned partitions of a member assignment.

Remarks: The lifetime of the returned memory is the same as the lifetime of the assignment object.

Parameters: assignment \FFI\CData|null const rd_kafka_MemberAssignment_t* - ) - The group member assignment.
Returns: \FFI\CData|null const rd_kafka_topic_partition_list_t* - The assigned partitions.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a42f960ea967772f9d79a201abc507ac6

rd_kafka_MemberDescription_assignment()¶

public static rd_kafka_MemberDescription_assignment ( 
    \FFI\CData|null $member
 ): \FFI\CData|null

Gets assignment of member.

Remarks: The lifetime of the returned memory is the same as the lifetime of the member object.

Parameters: member \FFI\CData|null const rd_kafka_MemberDescription_t* - ) - The group member.
Returns: \FFI\CData|null const rd_kafka_MemberAssignment_t* - The member assignment.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a2e6070360cb854c549bc123222372eb2

rd_kafka_MemberDescription_client_id()¶

public static rd_kafka_MemberDescription_client_id ( 
    \FFI\CData|null $member
 ): string|null

Gets client id of member.

Remarks: The lifetime of the returned memory is the same as the lifetime of the member object.

Parameters: member \FFI\CData|null const rd_kafka_MemberDescription_t* - ) - The group member.
Returns: string|null const char* - The client id.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a7e553ceb0b76a8ef939a0339e9e861ad

rd_kafka_MemberDescription_consumer_id()¶

public static rd_kafka_MemberDescription_consumer_id ( 
    \FFI\CData|null $member
 ): string|null

Gets consumer id of member.

Remarks: The lifetime of the returned memory is the same as the lifetime of the member object.

Parameters: member \FFI\CData|null const rd_kafka_MemberDescription_t* - ) - The group member.
Returns: string|null const char* - The consumer id.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ac359a93ea6b7b7d9bd050cad1be55f21

rd_kafka_MemberDescription_group_instance_id()¶

public static rd_kafka_MemberDescription_group_instance_id ( 
    \FFI\CData|null $member
 ): string|null

Gets group instance id of member.

Remarks: The lifetime of the returned memory is the same as the lifetime of the member object.

Parameters: member \FFI\CData|null const rd_kafka_MemberDescription_t* - ) - The group member.
Returns: string|null const char* - The group instance id, or NULL if not available.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a0b746957ba9447dc2c73aae8df177e80

rd_kafka_MemberDescription_host()¶

public static rd_kafka_MemberDescription_host ( 
    \FFI\CData|null $member
 ): string|null

Gets host of member.

Remarks: The lifetime of the returned memory is the same as the lifetime of the member object.

Parameters: member \FFI\CData|null const rd_kafka_MemberDescription_t* - ) - The group member.
Returns: string|null const char* - The host.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#add167499632d1f617bb16802a5bb2d2b

rd_kafka_NewPartitions_destroy()¶

public static rd_kafka_NewPartitions_destroy ( 
    \FFI\CData|null $new_parts
 ): void

Parameters: new_parts \FFI\CData|null rd_kafka_NewPartitions_t*

rd_kafka_NewPartitions_destroy_array()¶

public static rd_kafka_NewPartitions_destroy_array ( 
    \FFI\CData|null $new_parts, 
    int|null $new_parts_cnt
 ): void

Parameters: new_parts \FFI\CData|null rd_kafka_NewPartitions_t**; new_parts_cnt int|null size_t

rd_kafka_NewPartitions_new()¶

public static rd_kafka_NewPartitions_new ( 
    string|null $topic, 
    int|null $new_total_cnt, 
    \FFI\CData|null $errstr, 
    int|null $errstr_size
 ): \FFI\CData|null

Create a new NewPartitions. This object is later passed to rd_kafka_CreatePartitions() to increase the number of partitions to new_total_cnt for an existing topic.

Parameters: topic string|null const char* - Topic name to create more partitions for.; new_total_cnt int|null size_t - Increase the topic’s partition count to this value.; errstr \FFI\CData|null char* - A human readable error string (nul-terminated) is written to this location that must be of at least errstr_size bytes. The errstr is only written in case of error. - Writable size in errstr.; errstr_size int|null size_t
Returns: \FFI\CData|null rd_kafka_NewPartitions_t* - a new allocated NewPartitions object, or NULL if the input parameters are invalid. Use rd_kafka_NewPartitions_destroy() to free object when done.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#abdda69e9215a7e41d5b97cb7ed0c6bd3

rd_kafka_NewPartitions_set_replica_assignment()¶

public static rd_kafka_NewPartitions_set_replica_assignment ( 
    \FFI\CData|null $new_parts, 
    int|null $new_partition_idx, 
    \FFI\CData|null $broker_ids, 
    int|null $broker_id_cnt, 
    \FFI\CData|null $errstr, 
    int|null $errstr_size
 ): int

Set the replica (broker id) assignment for new_partition_idx to the replica set in broker_ids (of broker_id_cnt elements).

Remarks: An application must either set the replica assignment for all new partitions, or none.; If called, this function must be called consecutively for each new partition being created, where new_partition_idx 0 is the first new partition, 1 is the second, and so on.; broker_id_cnt should match the topic's replication factor.; Use rd_kafka_metadata() to retrieve the list of brokers in the cluster.

See also: rd_kafka_AdminOptions_set_validate_only()

Parameters: new_parts \FFI\CData|null rd_kafka_NewPartitions_t*; new_partition_idx int|null int32_t; broker_ids \FFI\CData|null int32_t*; broker_id_cnt int|null size_t; errstr \FFI\CData|null char*; errstr_size int|null size_t
Returns: int rd_kafka_resp_err_t - RD_KAFKA_RESP_ERR_NO_ERROR on success, or an error code if the arguments were invalid.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a6b38e8b7f3357844a7ef9b31cdc4af3c

rd_kafka_NewTopic_destroy()¶

public static rd_kafka_NewTopic_destroy ( 
    \FFI\CData|null $new_topic
 ): void

Parameters: new_topic \FFI\CData|null rd_kafka_NewTopic_t*

rd_kafka_NewTopic_destroy_array()¶

public static rd_kafka_NewTopic_destroy_array ( 
    \FFI\CData|null $new_topics, 
    int|null $new_topic_cnt
 ): void

Parameters: new_topics \FFI\CData|null rd_kafka_NewTopic_t**; new_topic_cnt int|null size_t

rd_kafka_NewTopic_new()¶

public static rd_kafka_NewTopic_new ( 
    string|null $topic, 
    int|null $num_partitions, 
    int|null $replication_factor, 
    \FFI\CData|null $errstr, 
    int|null $errstr_size
 ): \FFI\CData|null

Create a new NewTopic object. This object is later passed to rd_kafka_CreateTopics().

Parameters: topic string|null const char* - Topic name to create.; num_partitions int|null int - Number of partitions in topic, or -1 to use the broker’s default partition count (>= 2.4.0).; replication_factor int|null int - Default replication factor for the topic’s partitions, or -1 to use the broker’s default replication factor (>= 2.4.0) or if set_replica_assignment() will be used.; errstr \FFI\CData|null char* - A human readable error string (nul-terminated) is written to this location that must be of at least errstr_size bytes. The errstr is only written in case of error. - Writable size in errstr.; errstr_size int|null size_t
Returns: \FFI\CData|null rd_kafka_NewTopic_t* - a new allocated NewTopic object, or NULL if the input parameters are invalid. Use rd_kafka_NewTopic_destroy() to free object when done.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a9f172cd394d605c9fabca3959e101f8b

rd_kafka_NewTopic_set_config()¶

public static rd_kafka_NewTopic_set_config ( 
    \FFI\CData|null $new_topic, 
    string|null $name, 
    string|null $value
 ): int

Set (broker-side) topic configuration name/value pair.

Remarks: The name and value are not validated by the client, the validation takes place on the broker.

See also: rd_kafka_AdminOptions_set_validate_only(); http://kafka.apache.org/documentation.html#topicconfigs

Parameters: new_topic \FFI\CData|null rd_kafka_NewTopic_t*; name string|null const char*; value string|null const char*
Returns: int rd_kafka_resp_err_t - RD_KAFKA_RESP_ERR_NO_ERROR on success, or an error code if the arguments were invalid.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a29ae721839f76830e7f7b8ba5df64bed

rd_kafka_NewTopic_set_replica_assignment()¶

public static rd_kafka_NewTopic_set_replica_assignment ( 
    \FFI\CData|null $new_topic, 
    int|null $partition, 
    \FFI\CData|null $broker_ids, 
    int|null $broker_id_cnt, 
    \FFI\CData|null $errstr, 
    int|null $errstr_size
 ): int

Set the replica (broker) assignment for partition to the replica set in broker_ids (of broker_id_cnt elements).

Remarks: When this method is used, rd_kafka_NewTopic_new() must have been called with a replication_factor of -1.; An application must either set the replica assignment for all new partitions, or none.; If called, this function must be called consecutively for each partition, starting at 0.; Use rd_kafka_metadata() to retrieve the list of brokers in the cluster.

See also: rd_kafka_AdminOptions_set_validate_only()

Parameters: new_topic \FFI\CData|null rd_kafka_NewTopic_t*; partition int|null int32_t; broker_ids \FFI\CData|null int32_t*; broker_id_cnt int|null size_t; errstr \FFI\CData|null char*; errstr_size int|null size_t
Returns: int rd_kafka_resp_err_t - RD_KAFKA_RESP_ERR_NO_ERROR on success, or an error code if the arguments were invalid.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ade3dabb32c5e0ed5edcbc038a9345144

rd_kafka_Node_host()¶

public static rd_kafka_Node_host ( 
    \FFI\CData|null $node
 ): string|null

Get the host of node.

Remarks: The lifetime of the returned memory is the same as the lifetime of the node object.

Parameters: node \FFI\CData|null const rd_kafka_Node_t* - ) - The Node instance.
Returns: string|null const char* - The node host.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a5669ca3bdf89fc5d473d42bd3edf1002

rd_kafka_Node_id()¶

public static rd_kafka_Node_id ( 
    \FFI\CData|null $node
 ): int|null

Get the id of node.

Parameters: node \FFI\CData|null const rd_kafka_Node_t* - ) - The Node instance.
Returns: int|null int - The node id.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ac0f59992ab0e0ae07b80163afa0ea685

rd_kafka_Node_port()¶

public static rd_kafka_Node_port ( 
    \FFI\CData|null $node
 ): int|null

Get the port of node.

Parameters: node \FFI\CData|null const rd_kafka_Node_t* - ) - The Node instance.
Returns: int|null uint16_t - The node port.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#abc3ff57cdfc63f694d7200e91570ab3a

rd_kafka_Node_rack()¶

public static rd_kafka_Node_rack ( 
    \FFI\CData|null $node
 ): string|null

Get the rack of node.

Parameters: node \FFI\CData|null const rd_kafka_Node_t* - ) - The Node instance
Returns: string|null const char* - The node rack id. May be NULL.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a8ec4583d6314400e4602007c9f8ae2da

rd_kafka_ResourcePatternType_name()¶

public static rd_kafka_ResourcePatternType_name ( 
    int $resource_pattern_type
 ): string|null

Parameters: resource_pattern_type int rd_kafka_ResourcePatternType_t - )
Returns: string|null const char* - a string representation of the resource_pattern_type

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a311aad04500432476964426971baf7de

rd_kafka_ResourceType_name()¶

public static rd_kafka_ResourceType_name ( 
    int $restype
 ): string|null

Parameters: restype int rd_kafka_ResourceType_t - )
Returns: string|null const char* - a string representation of the restype

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a731d80842dc9d8388abe94e7b27f053c

rd_kafka_ScramCredentialInfo_iterations()¶

public static rd_kafka_ScramCredentialInfo_iterations ( 
    \FFI\CData|null $scram_credential_info
 ): int|null

Parameters: scram_credential_info \FFI\CData|null const rd_kafka_ScramCredentialInfo_t*
Returns: int|null int32_t

rd_kafka_ScramCredentialInfo_mechanism()¶

public static rd_kafka_ScramCredentialInfo_mechanism ( 
    \FFI\CData|null $scram_credential_info
 ): int

Parameters: scram_credential_info \FFI\CData|null const rd_kafka_ScramCredentialInfo_t*
Returns: int rd_kafka_ScramMechanism_t

rd_kafka_TopicCollection_destroy()¶

public static rd_kafka_TopicCollection_destroy ( 
    \FFI\CData|null $topics
 ): void

Parameters: topics \FFI\CData|null rd_kafka_TopicCollection_t*

rd_kafka_TopicCollection_of_topic_names()¶

public static rd_kafka_TopicCollection_of_topic_names ( 
    \FFI\CData|null $topics, 
    int|null $topics_cnt
 ): \FFI\CData|null

Creates a new TopicCollection for passing to rd_kafka_DescribeTopics.

Parameters: topics \FFI\CData|null const char** - A list of topics.; topics_cnt int|null size_t - Count of topics.
Returns: \FFI\CData|null rd_kafka_TopicCollection_t* - a newly allocated TopicCollection object. Must be freed using rd_kafka_TopicCollection_destroy when done.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ab9af9e28d53872823af6702d1b01d378

rd_kafka_TopicDescription_authorized_operations()¶

public static rd_kafka_TopicDescription_authorized_operations ( 
    \FFI\CData|null $topicdesc, 
    \FFI\CData|null $cntp
 ): \FFI\CData|null

Gets the topic authorized ACL operations for the topicdesc topic.

Remarks: The lifetime of the returned memory is the same as the lifetime of the topicdesc object.

Parameters: topicdesc \FFI\CData|null const rd_kafka_TopicDescription_t* - The topic description.; cntp \FFI\CData|null size_t* - is updated with authorized ACL operations count.
Returns: \FFI\CData|null const rd_kafka_AclOperation_t* - The topic authorized operations. Is NULL if operations were not requested.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a848c8f05aa765d3caa943a5b5fb58bb4

rd_kafka_TopicDescription_error()¶

public static rd_kafka_TopicDescription_error ( 
    \FFI\CData|null $topicdesc
 ): \FFI\CData|null

Gets the error for the topicdesc topic.

Remarks: The lifetime of the returned memory is the same as the lifetime of the topicdesc object.

Parameters: topicdesc \FFI\CData|null const rd_kafka_TopicDescription_t* - ) - The topic description.
Returns: \FFI\CData|null const rd_kafka_error_t* - The topic description error.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a32ad6034f5b75c921bfa3a98d4f8f686

rd_kafka_TopicDescription_is_internal()¶

public static rd_kafka_TopicDescription_is_internal ( 
    \FFI\CData|null $topicdesc
 ): int|null

Gets if the topicdesc topic is internal.

Parameters: topicdesc \FFI\CData|null const rd_kafka_TopicDescription_t* - ) - The topic description.
Returns: int|null int - 1 if the topic is internal to Kafka, 0 otherwise.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#aec3f6b1edd182818266d79bf3a3d681f

rd_kafka_TopicDescription_name()¶

public static rd_kafka_TopicDescription_name ( 
    \FFI\CData|null $topicdesc
 ): string|null

Gets the topic name for the topicdesc topic.

Remarks: The lifetime of the returned memory is the same as the lifetime of the topicdesc object.

Parameters: topicdesc \FFI\CData|null const rd_kafka_TopicDescription_t* - ) - The topic description.
Returns: string|null const char* - The topic name.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a66dd715323222bcfbe161712bf69febe

rd_kafka_TopicDescription_partitions()¶

public static rd_kafka_TopicDescription_partitions ( 
    \FFI\CData|null $topicdesc, 
    \FFI\CData|null $cntp
 ): \FFI\CData|null

Gets an array of partitions for the topicdesc topic.

Remarks: The lifetime of the returned memory is the same as the lifetime of the topicdesc object.

Parameters: topicdesc \FFI\CData|null const rd_kafka_TopicDescription_t* - The topic description.; cntp \FFI\CData|null size_t* - is updated to the number of partitions in the array.
Returns: \FFI\CData|null const rd_kafka_TopicPartitionInfo_t** - An array of TopicPartitionInfos.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a78585749002fec9bc7c5f7199d2ce365

rd_kafka_TopicDescription_topic_id()¶

public static rd_kafka_TopicDescription_topic_id ( 
    \FFI\CData|null $topicdesc
 ): \FFI\CData|null

Gets the topic id for the topicdesc topic.

Remarks: The lifetime of the returned memory is the same as the lifetime of the topicdesc object.

Parameters: topicdesc \FFI\CData|null const rd_kafka_TopicDescription_t* - ) - The topic description.
Returns: \FFI\CData|null const rd_kafka_Uuid_t* - The topic id

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a4896084f819b95b9cc0fd5ee2082efdb

rd_kafka_TopicPartitionInfo_isr()¶

public static rd_kafka_TopicPartitionInfo_isr ( 
    \FFI\CData|null $partition, 
    \FFI\CData|null $cntp
 ): \FFI\CData|null

Gets the partition in-sync replicas for partition.

Remarks: The lifetime of the returned memory is the same as the lifetime of the partition object.

Parameters: partition \FFI\CData|null const rd_kafka_TopicPartitionInfo_t* - The partition info.; cntp \FFI\CData|null size_t* - is updated with in-sync replicas count.
Returns: \FFI\CData|null const rd_kafka_Node_t** - The in-sync replica nodes.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a78ca7c71358bb9ed387fa6384e87731c

rd_kafka_TopicPartitionInfo_leader()¶

public static rd_kafka_TopicPartitionInfo_leader ( 
    \FFI\CData|null $partition
 ): \FFI\CData|null

Gets the partition leader for partition.

Remarks: The lifetime of the returned memory is the same as the lifetime of the partition object.

Parameters: partition \FFI\CData|null const rd_kafka_TopicPartitionInfo_t* - ) - The partition info.
Returns: \FFI\CData|null const rd_kafka_Node_t* - The partition leader.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a1c6306ac9839416784f1cb2805e57132

rd_kafka_TopicPartitionInfo_partition()¶

public static rd_kafka_TopicPartitionInfo_partition ( 
    \FFI\CData|null $partition
 ): int|null

Gets the partition id for partition.

Parameters: partition \FFI\CData|null const rd_kafka_TopicPartitionInfo_t* - ) - The partition info.
Returns: int|null const int - The partition id.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a3e0bd5738c9af79beb40c3e6d1dd60a3

rd_kafka_TopicPartitionInfo_replicas()¶

public static rd_kafka_TopicPartitionInfo_replicas ( 
    \FFI\CData|null $partition, 
    \FFI\CData|null $cntp
 ): \FFI\CData|null

Gets the partition replicas for partition.

Remarks: The lifetime of the returned memory is the same as the lifetime of the partition object.

Parameters: partition \FFI\CData|null const rd_kafka_TopicPartitionInfo_t* - The partition info.; cntp \FFI\CData|null size_t* - is updated with partition replicas count.
Returns: \FFI\CData|null const rd_kafka_Node_t** - The partition replicas nodes.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#aa27f09e729ee3314a2a69a2966155bd5

rd_kafka_UserScramCredentialAlteration_destroy()¶

public static rd_kafka_UserScramCredentialAlteration_destroy ( 
    \FFI\CData|null $alteration
 ): void

Parameters: alteration \FFI\CData|null rd_kafka_UserScramCredentialAlteration_t*

rd_kafka_UserScramCredentialAlteration_destroy_array()¶

public static rd_kafka_UserScramCredentialAlteration_destroy_array ( 
    \FFI\CData|null $alterations, 
    int|null $alteration_cnt
 ): void

Parameters: alterations \FFI\CData|null rd_kafka_UserScramCredentialAlteration_t**; alteration_cnt int|null size_t

rd_kafka_UserScramCredentialDeletion_new()¶

public static rd_kafka_UserScramCredentialDeletion_new ( 
    string|null $username, 
    int $mechanism
 ): \FFI\CData|null

Allocates a new UserScramCredentialDeletion given its fields.

Parameters: username string|null const char* - The username (not empty).; mechanism int rd_kafka_ScramMechanism_t - SASL/SCRAM mechanism.
Returns: \FFI\CData|null rd_kafka_UserScramCredentialAlteration_t* - A newly created instance of rd_kafka_UserScramCredentialAlteration_t. Ownership belongs to the caller, use rd_kafka_UserScramCredentialAlteration_destroy to destroy.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a89e57d12d9415354fcbbf1d7b0072db2

rd_kafka_UserScramCredentialUpsertion_new()¶

public static rd_kafka_UserScramCredentialUpsertion_new ( 
    string|null $username, 
    int $mechanism, 
    int|null $iterations, 
    \FFI\CData|null $password, 
    int|null $password_size, 
    \FFI\CData|null $salt, 
    int|null $salt_size
 ): \FFI\CData|null

Allocates a new UserScramCredentialUpsertion given its fields. If salt isn't given a 64 B salt is generated using OpenSSL RAND_priv_bytes, if available.

Remarks: A random salt is generated, when NULL, only if OpenSSL >= 1.1.1. Otherwise it's a required param.

Parameters: username string|null const char* - The username (not empty).; mechanism int rd_kafka_ScramMechanism_t - SASL/SCRAM mechanism.; iterations int|null int32_t - SASL/SCRAM iterations.; password \FFI\CData|null const unsigned char* - Password bytes (not empty).; password_size int|null size_t - Size of password (greater than 0).; salt \FFI\CData|null const unsigned char* - Salt bytes (optional).; salt_size int|null size_t - Size of salt (optional).
Returns: \FFI\CData|null rd_kafka_UserScramCredentialAlteration_t* - A newly created instance of rd_kafka_UserScramCredentialAlteration_t. Ownership belongs to the caller, use rd_kafka_UserScramCredentialAlteration_destroy to destroy.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ae1707143331cd5b798d25cb8df33df5f

rd_kafka_UserScramCredentialsDescription_error()¶

public static rd_kafka_UserScramCredentialsDescription_error ( 
    \FFI\CData|null $description
 ): \FFI\CData|null

Parameters: description \FFI\CData|null const rd_kafka_UserScramCredentialsDescription_t*
Returns: \FFI\CData|null const rd_kafka_error_t*

rd_kafka_UserScramCredentialsDescription_scramcredentialinfo()¶

public static rd_kafka_UserScramCredentialsDescription_scramcredentialinfo ( 
    \FFI\CData|null $description, 
    int|null $idx
 ): \FFI\CData|null

Parameters: description \FFI\CData|null const rd_kafka_UserScramCredentialsDescription_t*; idx int|null size_t
Returns: \FFI\CData|null const rd_kafka_ScramCredentialInfo_t*

rd_kafka_UserScramCredentialsDescription_scramcredentialinfo_count()¶

public static rd_kafka_UserScramCredentialsDescription_scramcredentialinfo_count ( 
    \FFI\CData|null $description
 ): int|null

Parameters: description \FFI\CData|null const rd_kafka_UserScramCredentialsDescription_t*
Returns: int|null size_t

rd_kafka_UserScramCredentialsDescription_user()¶

public static rd_kafka_UserScramCredentialsDescription_user ( 
    \FFI\CData|null $description
 ): string|null

Parameters: description \FFI\CData|null const rd_kafka_UserScramCredentialsDescription_t*
Returns: string|null const char*

rd_kafka_Uuid_base64str()¶

public static rd_kafka_Uuid_base64str ( 
    \FFI\CData|null $uuid
 ): string|null

Computes base64 encoding for the given uuid string.

Parameters: uuid \FFI\CData|null const rd_kafka_Uuid_t* - ) - UUID for which base64 encoding is required.
Returns: string|null const char* - base64 encoded string for the given UUID or NULL in case of some issue with the conversion or the conversion is not supported.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a1186ff610c5c603461bafa1886c2f64a

rd_kafka_Uuid_copy()¶

public static rd_kafka_Uuid_copy ( 
    \FFI\CData|null $uuid
 ): \FFI\CData|null

Copies the given UUID.

Remarks: Must be freed after use using rd_kafka_Uuid_destroy()

Parameters: uuid \FFI\CData|null const rd_kafka_Uuid_t* - ) - UUID to be copied.
Returns: \FFI\CData|null rd_kafka_Uuid_t* - A newly allocated copy of the provided UUID.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#adb76dc69e22b2fd34b9dfb881f685a07

rd_kafka_Uuid_destroy()¶

public static rd_kafka_Uuid_destroy ( 
    \FFI\CData|null $uuid
 ): void

Destroy the provided uuid.

Parameters: uuid \FFI\CData|null rd_kafka_Uuid_t* - ) - UUID

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a04e21c3278dc96745bfb232df69dbfce

rd_kafka_Uuid_least_significant_bits()¶

public static rd_kafka_Uuid_least_significant_bits ( 
    \FFI\CData|null $uuid
 ): int|null

Gets least significant 64 bits for the given UUID.

Parameters: uuid \FFI\CData|null const rd_kafka_Uuid_t* - ) - UUID
Returns: int|null int64_t - least significant 64 bits for the given UUID.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#afda9d744c58d439823bd9e06f5fbf851

rd_kafka_Uuid_most_significant_bits()¶

public static rd_kafka_Uuid_most_significant_bits ( 
    \FFI\CData|null $uuid
 ): int|null

Gets most significant 64 bits for the given UUID.

Parameters: uuid \FFI\CData|null const rd_kafka_Uuid_t* - ) - UUID
Returns: int|null int64_t - most significant 64 bits for the given UUID.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a443577282d2071374f20896ce2f97a91

rd_kafka_Uuid_new()¶

public static rd_kafka_Uuid_new ( 
    int|null $most_significant_bits, 
    int|null $least_significant_bits
 ): \FFI\CData|null

Creates a new UUID.

Remarks: Must be freed after use using rd_kafka_Uuid_destroy()

Parameters: most_significant_bits int|null int64_t - most significant 64 bits of the 128 bits UUID.; least_significant_bits int|null int64_t - least significant 64 bits of the 128 bits UUID.
Returns: \FFI\CData|null rd_kafka_Uuid_t* - A newly allocated UUID.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a0462c0b4858b2c2df6506b123ee9358c

rd_kafka_abort_transaction()¶

public static rd_kafka_abort_transaction ( 
    \FFI\CData|null $rk, 
    int|null $timeout_ms
 ): \FFI\CData|null

Aborts the ongoing transaction.

   This function should also be used to recover from non-fatal abortable
   transaction errors.

Any outstanding messages will be purged and fail with
   RD_KAFKA_RESP_ERR__PURGE_INFLIGHT or RD_KAFKA_RESP_ERR__PURGE_QUEUE.
   See rd_kafka_purge() for details.

Remarks: It is strongly recommended to always pass -1 (remaining transaction time) as the timeout_ms. Using other values risk internal state desynchronization in case any of the underlying protocol requests fail.; This function will block until all outstanding messages are purged and the transaction abort request has been successfully handled by the transaction coordinator, or until timeout_ms expires, which ever comes first. On timeout the application may call the function again. If the application has enabled RD_KAFKA_EVENT_DR it must serve the event queue in a separate thread since rd_kafka_flush() will not serve delivery reports in this mode.; This call is resumable when a retriable timeout error is returned. Calling the function again will resume the operation that is progressing in the background.

Remarks: The returned error object (if not NULL) must be destroyed with rd_kafka_error_destroy().

Parameters: rk \FFI\CData|null rd_kafka_t* - Producer instance.; timeout_ms int|null int - The maximum time to block. On timeout the operation may continue in the background, depending on state, and it is okay to call this function again. Pass -1 to use the remaining transaction timeout, this is the recommended use.
Returns: \FFI\CData|null rd_kafka_error_t* - NULL on success or an error object on failure. Check whether the returned error object permits retrying by calling rd_kafka_error_is_retriable(), or whether a fatal error has been raised by calling rd_kafka_error_is_fatal(). Error codes: RD_KAFKA_RESP_ERR__STATE if not currently in a transaction, RD_KAFKA_RESP_ERR__TIMED_OUT if the transaction could not be complete commmitted within timeout_ms, this is a retriable error as the commit continues in the background, RD_KAFKA_RESP_ERR_INVALID_PRODUCER_EPOCH if the current producer transaction has been fenced by a newer producer instance, RD_KAFKA_RESP_ERR_TRANSACTIONAL_ID_AUTHORIZATION_FAILED if the producer is no longer authorized to perform transactional operations, RD_KAFKA_RESP_ERR__NOT_CONFIGURED if transactions have not been configured for the producer instance, RD_KAFKA_RESP_ERR__INVALID_ARG if rk is not a producer instance, Other error codes not listed here may be returned, depending on broker version.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a2e50d1043e1b16ed28ba6e372aa0909d

rd_kafka_acl_result_error()¶

public static rd_kafka_acl_result_error ( 
    \FFI\CData|null $aclres
 ): \FFI\CData|null

Parameters: aclres \FFI\CData|null const rd_kafka_acl_result_t* - )
Returns: \FFI\CData|null const rd_kafka_error_t* - the error object for the given acl result, or NULL on success.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a433383bc595e0d1fa028243ac2b2b5df

rd_kafka_assign()¶

public static rd_kafka_assign ( 
    \FFI\CData|null $rk, 
    \FFI\CData|null $partitions
 ): int

Atomic assignment of partitions to consume.

The new partitions will replace the existing assignment.

A zero-length partitions will treat the partitions as a valid, albeit empty assignment, and maintain internal state, while a NULL value for partitions will reset and clear the internal state.

When used from a rebalance callback, the application should pass the partition list passed to the callback (or a copy of it) even if the list is empty (i.e. should not pass NULL in this case) so as to maintain internal join state. This is not strictly required - the application may adjust the assignment provided by the group. However, this is rarely useful in practice.

Parameters: rk \FFI\CData|null rd_kafka_t*; partitions \FFI\CData|null const rd_kafka_topic_partition_list_t*
Returns: int rd_kafka_resp_err_t - An error code indicating if the new assignment was applied or not. RD_KAFKA_RESP_ERR__FATAL is returned if the consumer has raised a fatal error.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a0566419eff2001f8371e3b50aa7d26e9

rd_kafka_assignment()¶

public static rd_kafka_assignment ( 
    \FFI\CData|null $rk, 
    \FFI\CData|null $partitions
 ): int

Returns the current partition assignment as set by rd_kafka_assign() or rd_kafka_incremental_assign().

Remarks: The application is responsible for calling rd_kafka_topic_partition_list_destroy on the returned list.; This assignment represents the partitions assigned through the assign functions and not the partitions assigned to this consumer instance by the consumer group leader. They are usually the same following a rebalance but not necessarily since an application is free to assign any partitions.

Parameters: rk \FFI\CData|null rd_kafka_t*; partitions \FFI\CData|null rd_kafka_topic_partition_list_t**
Returns: int rd_kafka_resp_err_t - An error code on failure, otherwise partitions is updated to point to a newly allocated partition list (possibly empty).

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a10a00cc624a46209fe1192cfc56cce59

rd_kafka_assignment_lost()¶

public static rd_kafka_assignment_lost ( 
    \FFI\CData|null $rk
 ): int|null

Check whether the consumer considers the current assignment to have been lost involuntarily. This method is only applicable for use with a high level subscribing consumer. Assignments are revoked immediately when determined to have been lost, so this method is only useful when reacting to a RD_KAFKA_EVENT_REBALANCE event or from within a rebalance_cb. Partitions that have been lost may already be owned by other members in the group and therefore commiting offsets, for example, may fail.

Remarks: Calling rd_kafka_assign(), rd_kafka_incremental_assign() or rd_kafka_incremental_unassign() resets this flag.

Parameters: rk \FFI\CData|null rd_kafka_t* - )
Returns: int|null int - Returns 1 if the current partition assignment is considered lost, 0 otherwise.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a5383a36bacd08e9ef52bfe29accb34a1

rd_kafka_begin_transaction()¶

public static rd_kafka_begin_transaction ( 
    \FFI\CData|null $rk
 ): \FFI\CData|null

Begin a new transaction.

rd_kafka_init_transactions() must have been called successfully (once) before this function is called.

Upon successful return from this function the application has to perform at least one of the following operations within transaction.timeout.ms to avoid timing out the transaction on the broker:

rd_kafka_produce() (et.al)
rd_kafka_send_offsets_to_transaction()
rd_kafka_commit_transaction()
rd_kafka_abort_transaction()

Any messages produced, offsets sent (rd_kafka_send_offsets_to_transaction()), etc, after the successful return of this function will be part of the transaction and committed or aborted atomatically.

Finish the transaction by calling rd_kafka_commit_transaction() or abort the transaction by calling rd_kafka_abort_transaction().

Remarks: With the transactional producer, rd_kafka_produce(), rd_kafka_producev(), et.al, are only allowed during an on-going transaction, as started with this function. Any produce call outside an on-going transaction, or for a failed transaction, will fail.; The returned error object (if not NULL) must be destroyed with rd_kafka_error_destroy().

Parameters: rk \FFI\CData|null rd_kafka_t* - ) - Producer instance.
Returns: \FFI\CData|null rd_kafka_error_t* - NULL on success or an error object on failure. Check whether a fatal error has been raised by calling rd_kafka_error_is_fatal(). Error codes: RD_KAFKA_RESP_ERR__STATE if a transaction is already in progress or upon fatal error, RD_KAFKA_RESP_ERR__NOT_CONFIGURED if transactions have not been configured for the producer instance, RD_KAFKA_RESP_ERR__INVALID_ARG if rk is not a producer instance. Other error codes not listed here may be returned, depending on broker version.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a3c5338866b641957e9eeeaa9b60f5f9c

rd_kafka_brokers_add()¶

public static rd_kafka_brokers_add ( 
    \FFI\CData|null $rk, 
    string|null $brokerlist
 ): int|null

Adds one or more brokers to the kafka handle's list of initial bootstrap brokers.

Additional brokers will be discovered automatically as soon as rdkafka connects to a broker by querying the broker metadata.

If a broker name resolves to multiple addresses (and possibly address families) all will be used for connection attempts in round-robin fashion.

brokerlist is a ,-separated list of brokers in the format: <broker1>,<broker2>,.. Where each broker is in either the host or URL based format: <host>[:<port>] <proto>://<host>[:port] <proto> is either PLAINTEXT, SSL, SASL, SASL_PLAINTEXT The two formats can be mixed but ultimately the value of the security.protocol config property decides what brokers are allowed.

Example: brokerlist = "broker1:10000,broker2" brokerlist = "SSL://broker3:9000,ssl://broker2"

Remarks: Brokers may also be defined with the metadata.broker.list or bootstrap.servers configuration property (preferred method).

Deprecated:: Set bootstrap servers with the bootstrap.servers configuration property.

Parameters: rk \FFI\CData|null rd_kafka_t*; brokerlist string|null const char*
Returns: int|null int - the number of brokers successfully added.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ab83da8da989fe41693d78d982c7ae6b7

rd_kafka_clusterid()¶

public static rd_kafka_clusterid ( 
    \FFI\CData|null $rk, 
    int|null $timeout_ms
 ): \FFI\CData|null

Returns the ClusterId as reported in broker metadata.

Remarks: Requires broker version >=0.10.0 and api.version.request=true.; The application must free the returned pointer using rd_kafka_mem_free().

Parameters: rk \FFI\CData|null rd_kafka_t* - Client instance.; timeout_ms int|null int - If there is no cached value from metadata retrieval then this specifies the maximum amount of time (in milliseconds) the call will block waiting for metadata to be retrieved. Use 0 for non-blocking calls.
Returns: \FFI\CData|null char* - a newly allocated string containing the ClusterId, or NULL if no ClusterId could be retrieved in the allotted timespan.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a261ba8c649756fbc7fbcd442ae481a18

rd_kafka_commit()¶

public static rd_kafka_commit ( 
    \FFI\CData|null $rk, 
    \FFI\CData|null $offsets, 
    int|null $async
 ): int

Commit offsets on broker for the provided list of partitions.

offsets should contain topic, partition, offset and possibly metadata. The offset should be the offset where consumption will resume, i.e., the last processed offset + 1. If offsets is NULL the current partition assignment will be used instead.

If async is false this operation will block until the broker offset commit is done, returning the resulting success or error code.

If a rd_kafka_conf_set_offset_commit_cb() offset commit callback has been configured the callback will be enqueued for a future call to rd_kafka_poll(), rd_kafka_consumer_poll() or similar.

FIXME: Update below documentation.

RD_KAFKA_RESP_ERR_STALE_MEMBER_EPOCH is returned, when using group.protocol=consumer, if the commit failed because the member has switched to a new member epoch. This error code can be retried. Partition level error is also set in the offsets.

RD_KAFKA_RESP_ERR_UNKNOWN_MEMBER_ID is returned, when using group.protocol=consumer, if the member has been removed from the consumer group This error code is permanent, uncommitted messages will be reprocessed by this or a different member and committed there. Partition level error is also set in the offsets.

Parameters: rk \FFI\CData|null rd_kafka_t*; offsets \FFI\CData|null const rd_kafka_topic_partition_list_t*; async int|null int
Returns: int rd_kafka_resp_err_t - An error code indiciating if the commit was successful, or successfully scheduled if asynchronous, or failed. RD_KAFKA_RESP_ERR__FATAL is returned if the consumer has raised a fatal error.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ab96539928328f14c3c9177ea0c896c87

rd_kafka_commit_message()¶

public static rd_kafka_commit_message ( 
    \FFI\CData|null $rk, 
    \FFI\CData|null $rkmessage, 
    int|null $async
 ): int

Commit message's offset on broker for the message's partition. The committed offset is the message's offset + 1.

See also: rd_kafka_commit

Parameters: rk \FFI\CData|null rd_kafka_t*; rkmessage \FFI\CData|null const rd_kafka_message_t*; async int|null int
Returns: int rd_kafka_resp_err_t

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a99fb25d50216e4e20d303bf8a4a62883

rd_kafka_commit_queue()¶

public static rd_kafka_commit_queue ( 
    \FFI\CData|null $rk, 
    \FFI\CData|null $offsets, 
    \FFI\CData|null $rkqu, 
    \FFI\CData|\Closure $cb, 
    \FFI\CData|object|string|null $opaque
 ): int

Commit offsets on broker for the provided list of partitions.

See rd_kafka_commit for offsets semantics.

The result of the offset commit will be posted on the provided rkqu queue.

If the application uses one of the poll APIs (rd_kafka_poll(), rd_kafka_consumer_poll(), rd_kafka_queue_poll(), ..) to serve the queue the cb callback is required.

The commit_opaque argument is passed to the callback as commit_opaque, or if using the event API the callback is ignored and the offset commit result will be returned as an RD_KAFKA_EVENT_COMMIT event and the commit_opaque value will be available with rd_kafka_event_opaque().

If rkqu is NULL a temporary queue will be created and the callback will be served by this call.

See also: rd_kafka_commit(); rd_kafka_conf_set_offset_commit_cb()

Parameters: rk \FFI\CData|null rd_kafka_t*; offsets \FFI\CData|null const rd_kafka_topic_partition_list_t*; rkqu \FFI\CData|null rd_kafka_queue_t*; cb \FFI\CData|\Closure void()(rd_kafka_t, rd_kafka_resp_err_t, rd_kafka_topic_partition_list_t*, void*); opaque \FFI\CData|object|string|null void*
Returns: int rd_kafka_resp_err_t

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#af76a6a73baa9c2621536e3f6882a3c1a

rd_kafka_commit_transaction()¶

public static rd_kafka_commit_transaction ( 
    \FFI\CData|null $rk, 
    int|null $timeout_ms
 ): \FFI\CData|null

Commit the current transaction (as started with rd_kafka_begin_transaction()).

Any outstanding messages will be flushed (delivered) before actually committing the transaction.

If any of the outstanding messages fail permanently the current transaction will enter the abortable error state and this function will return an abortable error, in this case the application must call rd_kafka_abort_transaction() before attempting a new transaction with rd_kafka_begin_transaction().

Remarks: It is strongly recommended to always pass -1 (remaining transaction time) as the timeout_ms. Using other values risk internal state desynchronization in case any of the underlying protocol requests fail.; This function will block until all outstanding messages are delivered and the transaction commit request has been successfully handled by the transaction coordinator, or until timeout_ms expires, which ever comes first. On timeout the application may call the function again.; Will automatically call rd_kafka_flush() to ensure all queued messages are delivered before attempting to commit the transaction. If the application has enabled RD_KAFKA_EVENT_DR it must serve the event queue in a separate thread since rd_kafka_flush() will not serve delivery reports in this mode.; This call is resumable when a retriable timeout error is returned. Calling the function again will resume the operation that is progressing in the background.

Remarks: The returned error object (if not NULL) must be destroyed with rd_kafka_error_destroy().

Parameters: rk \FFI\CData|null rd_kafka_t* - Producer instance.; timeout_ms int|null int - The maximum time to block. On timeout the operation may continue in the background, depending on state, and it is okay to call this function again. Pass -1 to use the remaining transaction timeout, this is the recommended use.
Returns: \FFI\CData|null rd_kafka_error_t* - NULL on success or an error object on failure. Check whether the returned error object permits retrying by calling rd_kafka_error_is_retriable(), or whether an abortable or fatal error has been raised by calling rd_kafka_error_txn_requires_abort() or rd_kafka_error_is_fatal() respectively. Error codes: RD_KAFKA_RESP_ERR__STATE if not currently in a transaction, RD_KAFKA_RESP_ERR__TIMED_OUT if the transaction could not be complete commmitted within timeout_ms, this is a retriable error as the commit continues in the background, RD_KAFKA_RESP_ERR_INVALID_PRODUCER_EPOCH if the current producer transaction has been fenced by a newer producer instance, RD_KAFKA_RESP_ERR_TRANSACTIONAL_ID_AUTHORIZATION_FAILED if the producer is no longer authorized to perform transactional operations, RD_KAFKA_RESP_ERR__NOT_CONFIGURED if transactions have not been configured for the producer instance, RD_KAFKA_RESP_ERR__INVALID_ARG if rk is not a producer instance, Other error codes not listed here may be returned, depending on broker version.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a63a2d72bf9ba444bcea457bf47c4642a

rd_kafka_committed()¶

public static rd_kafka_committed ( 
    \FFI\CData|null $rk, 
    \FFI\CData|null $partitions, 
    int|null $timeout_ms
 ): int

Retrieve committed offsets for topics+partitions.

The offset field of each requested partition will either be set to stored offset or to RD_KAFKA_OFFSET_INVALID in case there was no stored offset for that partition.

Committed offsets will be returned according to the isolation.level configuration property, if set to read_committed (default) then only stable offsets for fully committed transactions will be returned, while read_uncommitted may return offsets for not yet committed transactions.

Parameters: rk \FFI\CData|null rd_kafka_t*; partitions \FFI\CData|null rd_kafka_topic_partition_list_t*; timeout_ms int|null int
Returns: int rd_kafka_resp_err_t - RD_KAFKA_RESP_ERR_NO_ERROR on success in which case the offset or err field of each partitions’ element is filled in with the stored offset, or a partition specific error. Else returns an error code.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a39846ae321a03c4679c9c659f18adf13

rd_kafka_conf()¶

public static rd_kafka_conf ( 
    \FFI\CData|null $rk
 ): \FFI\CData|null

Remarks: the returned object is read-only and its lifetime is the same as the rd_kafka_t object.

Parameters: rk \FFI\CData|null rd_kafka_t* - )
Returns: \FFI\CData|null const rd_kafka_conf_t* - the configuration object used by an rd_kafka_t instance. For use with rd_kafka_conf_get(), et.al., to extract configuration properties from a running client.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ac5497485329acb55ef3aa08ef00f6702

rd_kafka_conf_destroy()¶

public static rd_kafka_conf_destroy ( 
    \FFI\CData|null $conf
 ): void

Parameters: conf \FFI\CData|null rd_kafka_conf_t*

rd_kafka_conf_dump()¶

public static rd_kafka_conf_dump ( 
    \FFI\CData|null $conf, 
    \FFI\CData|null $cntp
 ): \FFI\CData|null

Dump the configuration properties and values of conf to an array with "key", "value" pairs.

The number of entries in the array is returned in *cntp.

The dump must be freed with rd_kafka_conf_dump_free().

Parameters: conf \FFI\CData|null rd_kafka_conf_t*; cntp \FFI\CData|null size_t*
Returns: \FFI\CData|null const char**

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a4f3a04ac20df2a36e1d750f71b6d7718

rd_kafka_conf_dump_free()¶

public static rd_kafka_conf_dump_free ( 
    \FFI\CData|null $arr, 
    int|null $cnt
 ): void

Parameters: arr \FFI\CData|null const char**; cnt int|null size_t

rd_kafka_conf_dup()¶

public static rd_kafka_conf_dup ( 
    \FFI\CData|null $conf
 ): \FFI\CData|null

Creates a copy/duplicate of configuration object conf.

Remarks: Interceptors are NOT copied to the new configuration object.

See also: rd_kafka_interceptor_f_on_conf_dup

Parameters: conf \FFI\CData|null const rd_kafka_conf_t* - )
Returns: \FFI\CData|null rd_kafka_conf_t*

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a8cbfe15c6978ff09870e82cb524c673d

rd_kafka_conf_dup_filter()¶

public static rd_kafka_conf_dup_filter ( 
    \FFI\CData|null $conf, 
    int|null $filter_cnt, 
    \FFI\CData|null $filter
 ): \FFI\CData|null

Parameters: conf \FFI\CData|null const rd_kafka_conf_t*; filter_cnt int|null size_t; filter \FFI\CData|null const char**
Returns: \FFI\CData|null rd_kafka_conf_t*

rd_kafka_conf_enable_sasl_queue()¶

public static rd_kafka_conf_enable_sasl_queue ( 
    \FFI\CData|null $conf, 
    int|null $enable
 ): void

Enable/disable creation of a queue specific to SASL events and callbacks.

For SASL mechanisms that trigger callbacks (currently OAUTHBEARER) this configuration API allows an application to get a dedicated queue for the SASL events/callbacks. After enabling the queue with this API the application can retrieve the queue by calling rd_kafka_queue_get_sasl() on the client instance. This queue may then be served directly by the application (with rd_kafka_queue_poll(), et.al) or forwarded to another queue, such as the background queue.

A convenience function is available to automatically forward the SASL queue to librdkafka's background thread, see rd_kafka_sasl_background_callbacks_enable().

By default (enable = 0) the main queue (as served by rd_kafka_poll(), et.al.) is used for SASL callbacks.

Remarks: The SASL queue is currently only used by the SASL OAUTHBEARER mechanism's token_refresh_cb().

See also: rd_kafka_queue_get_sasl(); rd_kafka_sasl_background_callbacks_enable()

Parameters: conf \FFI\CData|null rd_kafka_conf_t*; enable int|null int

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ad01f5e5a40eaebf133db5a2858198fbd

rd_kafka_conf_get()¶

public static rd_kafka_conf_get ( 
    \FFI\CData|null $conf, 
    string|null $name, 
    \FFI\CData|null $dest, 
    \FFI\CData|null $dest_size
 ): int

Retrieve configuration value for property name.

If dest is non-NULL the value will be written to dest with at most dest_size.

*dest_size is updated to the full length of the value, thus if *dest_size initially is smaller than the full length the application may reallocate dest to fit the returned *dest_size and try again.

If dest is NULL only the full length of the value is returned.

Fallthrough: Topic-level configuration properties from the default_topic_conf may be retrieved using this interface.

Parameters: conf \FFI\CData|null const rd_kafka_conf_t*; name string|null const char*; dest \FFI\CData|null char*; dest_size \FFI\CData|null size_t*
Returns: int rd_kafka_conf_res_t - RD_KAFKA_CONF_OK if the property name matched, else RD_KAFKA_CONF_UNKNOWN.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#abe9f0f77e9145eb1a62c3258ac495b97

rd_kafka_conf_get_default_topic_conf()¶

public static rd_kafka_conf_get_default_topic_conf ( 
    \FFI\CData|null $conf
 ): \FFI\CData|null

Gets the default topic configuration as previously set with rd_kafka_conf_set_default_topic_conf() or that was implicitly created by configuring a topic-level property on the global conf object.

Warning: The returned topic configuration object is owned by the conf object. It may be modified but not destroyed and its lifetime is the same as the conf object or the next call to rd_kafka_conf_set_default_topic_conf().

Parameters: conf \FFI\CData|null rd_kafka_conf_t* - )
Returns: \FFI\CData|null rd_kafka_topic_conf_t* - the conf’s default topic configuration (if any), or NULL.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a622ed908e64c21ba53449216400109ee

rd_kafka_conf_interceptor_add_on_conf_destroy()¶

public static rd_kafka_conf_interceptor_add_on_conf_destroy ( 
    \FFI\CData|null $conf, 
    string|null $ic_name, 
    \FFI\CData|\Closure $on_conf_destroy, 
    \FFI\CData|object|string|null $ic_opaque
 ): int

Append an on_conf_destroy() interceptor.

Remarks: Multiple on_conf_destroy() interceptors are allowed to be added to the same configuration object.

Parameters: conf \FFI\CData|null rd_kafka_conf_t* - Configuration object.; ic_name string|null const char* - Interceptor name, used in logging.; on_conf_destroy \FFI\CData|\Closure rd_kafka_resp_err_t(rd_kafka_interceptor_f_on_conf_destroy_t*)(void*) - Function pointer.; ic_opaque \FFI\CData|object|string|null void* - Opaque value that will be passed to the function.
Returns: int rd_kafka_resp_err_t - RD_KAFKA_RESP_ERR_NO_ERROR

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a919ebd487a2717d6cbdf0d25102ea8ff

rd_kafka_conf_interceptor_add_on_conf_dup()¶

public static rd_kafka_conf_interceptor_add_on_conf_dup ( 
    \FFI\CData|null $conf, 
    string|null $ic_name, 
    \FFI\CData|\Closure $on_conf_dup, 
    \FFI\CData|object|string|null $ic_opaque
 ): int

Append an on_conf_dup() interceptor.

Parameters: conf \FFI\CData|null rd_kafka_conf_t* - Configuration object.; ic_name string|null const char* - Interceptor name, used in logging.; on_conf_dup \FFI\CData|\Closure rd_kafka_resp_err_t(rd_kafka_interceptor_f_on_conf_dup_t*)(rd_kafka_conf_t*, const rd_kafka_conf_t*, size_t, const char**, void*) - Function pointer.; ic_opaque \FFI\CData|object|string|null void* - Opaque value that will be passed to the function.
Returns: int rd_kafka_resp_err_t - RD_KAFKA_RESP_ERR_NO_ERROR on success or RD_KAFKA_RESP_ERR__CONFLICT if an existing interceptor with the same ic_name and function has already been added to conf.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a375ce703f6247377305dc6a5dfc84429

rd_kafka_conf_interceptor_add_on_conf_set()¶

public static rd_kafka_conf_interceptor_add_on_conf_set ( 
    \FFI\CData|null $conf, 
    string|null $ic_name, 
    \FFI\CData|\Closure $on_conf_set, 
    \FFI\CData|object|string|null $ic_opaque
 ): int

Append an on_conf_set() interceptor.

Parameters: conf \FFI\CData|null rd_kafka_conf_t* - Configuration object.; ic_name string|null const char* - Interceptor name, used in logging.; on_conf_set \FFI\CData|\Closure rd_kafka_conf_res_t(rd_kafka_interceptor_f_on_conf_set_t*)(rd_kafka_conf_t*, const char*, const char*, char*, size_t, void*) - Function pointer.; ic_opaque \FFI\CData|object|string|null void* - Opaque value that will be passed to the function.
Returns: int rd_kafka_resp_err_t - RD_KAFKA_RESP_ERR_NO_ERROR on success or RD_KAFKA_RESP_ERR__CONFLICT if an existing interceptor with the same ic_name and function has already been added to conf.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a97bdeb12b99da10eff18767b3cadbfd2

rd_kafka_conf_interceptor_add_on_new()¶

public static rd_kafka_conf_interceptor_add_on_new ( 
    \FFI\CData|null $conf, 
    string|null $ic_name, 
    \FFI\CData|\Closure $on_new, 
    \FFI\CData|object|string|null $ic_opaque
 ): int

Append an on_new() interceptor.

Remarks: Since the on_new() interceptor is added to the configuration object it may be copied by rd_kafka_conf_dup(). An interceptor implementation must thus be able to handle the same interceptor,ic_opaque tuple to be used by multiple client instances.; An interceptor plugin should check the return value to make sure it has not already been added.

Parameters: conf \FFI\CData|null rd_kafka_conf_t* - Configuration object.; ic_name string|null const char* - Interceptor name, used in logging.; on_new \FFI\CData|\Closure rd_kafka_resp_err_t(rd_kafka_interceptor_f_on_new_t*)(rd_kafka_t*, const rd_kafka_conf_t*, void*, char*, size_t) - Function pointer.; ic_opaque \FFI\CData|object|string|null void* - Opaque value that will be passed to the function.
Returns: int rd_kafka_resp_err_t - RD_KAFKA_RESP_ERR_NO_ERROR on success or RD_KAFKA_RESP_ERR__CONFLICT if an existing interceptor with the same ic_name and function has already been added to conf.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a002ef1d350176725b6e9ba93548edf40

rd_kafka_conf_new()¶

public static rd_kafka_conf_new (  ): \FFI\CData|null

Create configuration object.

When providing your own configuration to the rd_kafka_*_new_*() calls the rd_kafka_conf_t objects needs to be created with this function which will set up the defaults. I.e.:

rd_kafka_conf_t *myconf;
rd_kafka_conf_res_t res;

myconf = rd_kafka_conf_new();
res = rd_kafka_conf_set(myconf, "socket.timeout.ms", "600",
                        errstr, sizeof(errstr));
if (res != RD_KAFKA_CONF_OK)
   die("%s\n", errstr);

rk = rd_kafka_new(..., myconf);

Please see CONFIGURATION.md for the default settings or use rd_kafka_conf_properties_show() to provide the information at runtime.

The properties are identical to the Apache Kafka configuration properties whenever possible.

Remarks: A successful call to rd_kafka_new() will assume ownership of the conf object and rd_kafka_conf_destroy() must not be called.

See also: rd_kafka_new(), rd_kafka_conf_set(), rd_kafka_conf_destroy()

Returns: \FFI\CData|null rd_kafka_conf_t* - ) - A new rd_kafka_conf_t object with defaults set.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#aa7459bd22e8cfa81aa8c2480a4a0304c

rd_kafka_conf_properties_show()¶

public static rd_kafka_conf_properties_show ( 
    \FFI\CData|null $fp
 ): void

Prints a table to fp of all supported configuration properties, their default values as well as a description.

Remarks: All properties and properties and values are shown, even those that have been disabled at build time due to missing dependencies.

Parameters: fp \FFI\CData|null FILE* - )

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#aa52f3a5a08207e14386739fe336e57be

rd_kafka_conf_set()¶

public static rd_kafka_conf_set ( 
    \FFI\CData|null $conf, 
    string|null $name, 
    string|null $value, 
    \FFI\CData|null $errstr, 
    int|null $errstr_size
 ): int

Sets a configuration property.

conf must have been previously created with rd_kafka_conf_new().

Fallthrough: Topic-level configuration properties may be set using this interface in which case they are applied on the default_topic_conf. If no default_topic_conf has been set one will be created. Any subsequent rd_kafka_conf_set_default_topic_conf() calls will replace the current default topic configuration.

Remarks: Setting properties or values that were disabled at build time due to missing dependencies will return RD_KAFKA_CONF_INVALID.

Parameters: conf \FFI\CData|null rd_kafka_conf_t*; name string|null const char*; value string|null const char*; errstr \FFI\CData|null char*; errstr_size int|null size_t
Returns: int rd_kafka_conf_res_t - rd_kafka_conf_res_t to indicate success or failure. In case of failure errstr is updated to contain a human readable error string.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#abb1b319278333e8cdee9442da7f135e8

rd_kafka_conf_set_background_event_cb()¶

public static rd_kafka_conf_set_background_event_cb ( 
    \FFI\CData|null $conf, 
    \FFI\CData|\Closure $event_cb
 ): void

Generic event callback to be used with the event API to trigger callbacks for rd_kafka_event_t objects from a background thread serving the background queue.

How to use:

First set the event callback on the configuration object with this function, followed by creating an rd_kafka_t instance with rd_kafka_new().
Get the instance's background queue with rd_kafka_queue_get_background() and pass it as the reply/response queue to an API that takes an event queue, such as rd_kafka_CreateTopics().
As the response event is ready and enqueued on the background queue the event callback will be triggered from the background thread.
Prior to destroying the client instance, loose your reference to the background queue by calling rd_kafka_queue_destroy().

The application must destroy the rkev passed to event cb using rd_kafka_event_destroy().

The event_cb opaque argument is the opaque set with rd_kafka_conf_set_opaque().

Remarks: This callback is a specialized alternative to the poll-based event API described in the Event interface section.; The event_cb will be called spontaneously from a background thread completely managed by librdkafka. Take care to perform proper locking of application objects.

Warning: The application MUST NOT call rd_kafka_destroy() from the event callback.

See also: rd_kafka_queue_get_background

Parameters: conf \FFI\CData|null rd_kafka_conf_t*; event_cb \FFI\CData|\Closure void()(rd_kafka_t, rd_kafka_event_t*, void*)

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a5ce6c329ca692674b1c42460f9bab521

rd_kafka_conf_set_closesocket_cb()¶

public static rd_kafka_conf_set_closesocket_cb ( 
    \FFI\CData|null $conf, 
    \FFI\CData|\Closure $closesocket_cb
 ): void

Set close socket callback.

Close a socket (optionally opened with socket_cb()).

The callback's opaque argument is the opaque set with rd_kafka_conf_set_opaque().

Remarks: The callback will be called from an internal librdkafka thread.

Parameters: conf \FFI\CData|null rd_kafka_conf_t*; closesocket_cb \FFI\CData|\Closure int()(int, void)

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ab55c7ddc46a354e3f57b5b209e5ec3c7

rd_kafka_conf_set_connect_cb()¶

public static rd_kafka_conf_set_connect_cb ( 
    \FFI\CData|null $conf, 
    \FFI\CData|\Closure $connect_cb
 ): void

Set connect callback.

The connect callback is responsible for connecting socket sockfd to peer address addr. The id field contains the broker identifier.

connect_cb shall return 0 on success (socket connected) or an error number (errno) on error.

The callback's opaque argument is the opaque set with rd_kafka_conf_set_opaque().

Remarks: The callback will be called from an internal librdkafka thread.

Parameters: conf \FFI\CData|null rd_kafka_conf_t*; connect_cb \FFI\CData|\Closure int()(int, const struct sockaddr, int, const char*, void*)

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a53dd1b77019324170d0168617fdaf040

rd_kafka_conf_set_consume_cb()¶

public static rd_kafka_conf_set_consume_cb ( 
    \FFI\CData|null $conf, 
    \FFI\CData|\Closure $consume_cb
 ): void

Consumer: Set consume callback for use with rd_kafka_consumer_poll()

The consume_cb opaque argument is the opaque set with rd_kafka_conf_set_opaque().

Parameters: conf \FFI\CData|null rd_kafka_conf_t*; consume_cb \FFI\CData|\Closure void()(rd_kafka_message_t, void*)

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a65eaf45e9b26bcb085f4651634ce06a5

rd_kafka_conf_set_default_topic_conf()¶

public static rd_kafka_conf_set_default_topic_conf ( 
    \FFI\CData|null $conf, 
    \FFI\CData|null $tconf
 ): void

Sets the default topic configuration to use for automatically subscribed topics (e.g., through pattern-matched topics). The topic config object is not usable after this call.

Warning: Any topic configuration settings that have been set on the global rd_kafka_conf_t object will be overwritten by this call since the implicitly created default topic config object is replaced by the user-supplied one.

Deprecated:: Set default topic level configuration on the global rd_kafka_conf_t object instead.

Parameters: conf \FFI\CData|null rd_kafka_conf_t*; tconf \FFI\CData|null rd_kafka_topic_conf_t*

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a138aa4881c8703dd6b69f22ddc454f63

rd_kafka_conf_set_dr_cb()¶

public static rd_kafka_conf_set_dr_cb ( 
    \FFI\CData|null $conf, 
    \FFI\CData|\Closure $dr_cb
 ): void

Deprecated:: See rd_kafka_conf_set_dr_msg_cb()

Parameters: conf \FFI\CData|null rd_kafka_conf_t*; dr_cb \FFI\CData|\Closure void()(rd_kafka_t, void*, size_t, rd_kafka_resp_err_t, void*, void*)

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a075b15c4141784fdc271de217005a41f

rd_kafka_conf_set_dr_msg_cb()¶

public static rd_kafka_conf_set_dr_msg_cb ( 
    \FFI\CData|null $conf, 
    \FFI\CData|\Closure $dr_msg_cb
 ): void

Producer: Set delivery report callback in provided conf object.

The delivery report callback will be called once for each message accepted by rd_kafka_produce() (et.al) with err set to indicate the result of the produce request.

The callback is called when a message is succesfully produced or if librdkafka encountered a permanent failure. Delivery errors occur when the retry count is exceeded, when the message.timeout.ms timeout is exceeded or there is a permanent error like RD_KAFKA_RESP_ERR_UNKNOWN_TOPIC_OR_PART.

An application must call rd_kafka_poll() at regular intervals to serve queued delivery report callbacks.

The broker-assigned offset can be retrieved with rkmessage->offset and the timestamp can be retrieved using rd_kafka_message_timestamp().

The dr_msg_cb opaque argument is the opaque set with rd_kafka_conf_set_opaque(). The per-message msg_opaque value is available in rd_kafka_message_t._private.

Remarks: The Idempotent Producer may return invalid timestamp (RD_KAFKA_TIMESTAMP_NOT_AVAILABLE), and and offset (RD_KAFKA_OFFSET_INVALID) for retried messages that were previously successfully delivered but not properly acknowledged.

Parameters: conf \FFI\CData|null rd_kafka_conf_t*; dr_msg_cb \FFI\CData|\Closure void()(rd_kafka_t, const rd_kafka_message_t*, void*)

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ac1c9946aee26e10de2661fcf2242ea8a

rd_kafka_conf_set_engine_callback_data()¶

public static rd_kafka_conf_set_engine_callback_data ( 
    \FFI\CData|null $conf, 
    \FFI\CData|object|string|null $callback_data
 ): void

Set callback_data for OpenSSL engine.

Remarks: The ssl.engine.location configuration must be set for this to have affect.; The memory pointed to by value must remain valid for the lifetime of the configuration object and any Kafka clients that use it.

Parameters: conf \FFI\CData|null rd_kafka_conf_t* - Configuration object.; callback_data \FFI\CData|object|string|null void* - passed to engine callbacks, e.g. ENGINE_load_ssl_client_cert.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a07871a230226c6acbdf3cd062545812b

rd_kafka_conf_set_error_cb()¶

public static rd_kafka_conf_set_error_cb ( 
    \FFI\CData|null $conf, 
    \FFI\CData|\Closure $error_cb
 ): void

Set error callback in provided conf object.

The error callback is used by librdkafka to signal warnings and errors back to the application.

These errors should generally be considered informational and non-permanent, the client will try to recover automatically from all type of errors. Given that the client and cluster configuration is correct the application should treat these as temporary errors.

error_cb will be triggered with err set to RD_KAFKA_RESP_ERR__FATAL if a fatal error has been raised; in this case use rd_kafka_fatal_error() to retrieve the fatal error code and error string, and then begin terminating the client instance.

If no error_cb is registered, or RD_KAFKA_EVENT_ERROR has not been set with rd_kafka_conf_set_events, then the errors will be logged instead.

The callback's opaque argument is the opaque set with rd_kafka_conf_set_opaque().

Parameters: conf \FFI\CData|null rd_kafka_conf_t*; error_cb \FFI\CData|\Closure void()(rd_kafka_t, int, const char*, void*)

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ace721ef3b7c22d0c111ec747ef039a90

rd_kafka_conf_set_events()¶

public static rd_kafka_conf_set_events ( 
    \FFI\CData|null $conf, 
    int|null $events
 ): void

Parameters: conf \FFI\CData|null rd_kafka_conf_t*; events int|null int

rd_kafka_conf_set_log_cb()¶

public static rd_kafka_conf_set_log_cb ( 
    \FFI\CData|null $conf, 
    \FFI\CData|\Closure $log_cb
 ): void

Set logger callback.

The default is to print to stderr, but a syslog logger is also available, see rd_kafka_log_print and rd_kafka_log_syslog for the builtin alternatives. Alternatively the application may provide its own logger callback. Or pass func as NULL to disable logging.

This is the configuration alternative to the deprecated rd_kafka_set_logger()

Remarks: The log_cb will be called spontaneously from librdkafka's internal threads unless logs have been forwarded to a poll queue through rd_kafka_set_log_queue(). An application MUST NOT call any librdkafka APIs or do any prolonged work in a non-forwarded log_cb.

Parameters: conf \FFI\CData|null rd_kafka_conf_t*; log_cb \FFI\CData|\Closure void()(const rd_kafka_t, int, const char*, const char*)

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a06ade2ca41f32eb82c6f7e3d4acbe19f

rd_kafka_conf_set_oauthbearer_token_refresh_cb()¶

public static rd_kafka_conf_set_oauthbearer_token_refresh_cb ( 
    \FFI\CData|null $conf, 
    \FFI\CData|\Closure $oauthbearer_token_refresh_cb
 ): void

Set SASL/OAUTHBEARER token refresh callback in provided conf object.

The SASL/OAUTHBEARER token refresh callback is triggered via rd_kafka_poll() whenever OAUTHBEARER is the SASL mechanism and a token needs to be retrieved, typically based on the configuration defined in sasl.oauthbearer.config.

The callback should invoke rd_kafka_oauthbearer_set_token() or rd_kafka_oauthbearer_set_token_failure() to indicate success or failure, respectively.

The refresh operation is eventable and may be received via rd_kafka_queue_poll() with an event type of RD_KAFKA_EVENT_OAUTHBEARER_TOKEN_REFRESH.

Note that before any SASL/OAUTHBEARER broker connection can succeed the application must call rd_kafka_oauthbearer_set_token() once – either directly or, more typically, by invoking either rd_kafka_poll(), rd_kafka_consumer_poll(), rd_kafka_queue_poll(), etc, in order to cause retrieval of an initial token to occur.

Alternatively, the application can enable the SASL queue by calling rd_kafka_conf_enable_sasl_queue() on the configuration object prior to creating the client instance, get the SASL queue with rd_kafka_queue_get_sasl(), and either serve the queue manually by calling rd_kafka_queue_poll(), or redirecting the queue to the background thread to have the queue served automatically. For the latter case the SASL queue must be forwarded to the background queue with rd_kafka_queue_forward(). A convenience function is available to automatically forward the SASL queue to librdkafka's background thread, see rd_kafka_sasl_background_callbacks_enable().

An unsecured JWT refresh handler is provided by librdkafka for development and testing purposes, it is enabled by setting the enable.sasl.oauthbearer.unsecure.jwt property to true and is mutually exclusive to using a refresh callback.

See also: rd_kafka_sasl_background_callbacks_enable(); rd_kafka_queue_get_sasl()

Parameters: conf \FFI\CData|null rd_kafka_conf_t* - the configuration to mutate.; oauthbearer_token_refresh_cb \FFI\CData|\Closure void()(rd_kafka_t, const char*, void*) - the callback to set; callback function arguments:
rk - Kafka handle
oauthbearer_config - Value of configuration property sasl.oauthbearer.config. opaque - Application-provided opaque set via rd_kafka_conf_set_opaque()

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a988395722598f63396d7a1bedb22adaf

rd_kafka_conf_set_offset_commit_cb()¶

public static rd_kafka_conf_set_offset_commit_cb ( 
    \FFI\CData|null $conf, 
    \FFI\CData|\Closure $offset_commit_cb
 ): void

Consumer: Set offset commit callback for use with consumer groups.

The results of automatic or manual offset commits will be scheduled for this callback and is served by rd_kafka_consumer_poll().

If no partitions had valid offsets to commit this callback will be called with err == RD_KAFKA_RESP_ERR__NO_OFFSET which is not to be considered an error.

The offsets list contains per-partition information:

offset: committed offset (attempted)
err: commit error

The callback's opaque argument is the opaque set with rd_kafka_conf_set_opaque().

Parameters: conf \FFI\CData|null rd_kafka_conf_t*; offset_commit_cb \FFI\CData|\Closure void()(rd_kafka_t, rd_kafka_resp_err_t, rd_kafka_topic_partition_list_t*, void*)

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a1ab8bb9e8d8cdd5906f9e060b506f2eb

rd_kafka_conf_set_opaque()¶

public static rd_kafka_conf_set_opaque ( 
    \FFI\CData|null $conf, 
    \FFI\CData|object|string|null $opaque
 ): void

Sets the application's opaque pointer that will be passed to callbacks.

See also: rd_kafka_opaque()

Parameters: conf \FFI\CData|null rd_kafka_conf_t*; opaque \FFI\CData|object|string|null void*

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a07cb7d91d9b7458a95ca6f1292763c24

rd_kafka_conf_set_rebalance_cb()¶

public static rd_kafka_conf_set_rebalance_cb ( 
    \FFI\CData|null $conf, 
    \FFI\CData|\Closure $rebalance_cb
 ): void

Consumer: Set rebalance callback for use with coordinated consumer group balancing.

The err field is set to either RD_KAFKA_RESP_ERR__ASSIGN_PARTITIONS or RD_KAFKA_RESP_ERR__REVOKE_PARTITIONS and 'partitions' contains the full partition set that was either assigned or revoked.

Registering a rebalance_cb turns off librdkafka's automatic partition assignment/revocation and instead delegates that responsibility to the application's rebalance_cb.

The rebalance callback is responsible for updating librdkafka's assignment set based on the two events: RD_KAFKA_RESP_ERR__ASSIGN_PARTITIONS and RD_KAFKA_RESP_ERR__REVOKE_PARTITIONS but should also be able to handle arbitrary rebalancing failures where err is neither of those.

Remarks: In this latter case (arbitrary error), the application must call rd_kafka_assign(rk, NULL) to synchronize state.

For eager/non-cooperative partition.assignment.strategy assignors, such as range and roundrobin, the application must use rd_kafka_assign() to set or clear the entire assignment. For the cooperative assignors, such as cooperative-sticky, the application must use rd_kafka_incremental_assign() for RD_KAFKA_RESP_ERR__ASSIGN_PARTITIONS and rd_kafka_incremental_unassign() for RD_KAFKA_RESP_ERR__REVOKE_PARTITIONS.

Without a rebalance callback this is done automatically by librdkafka but registering a rebalance callback gives the application flexibility in performing other operations along with the assigning/revocation, such as fetching offsets from an alternate location (on assign) or manually committing offsets (on revoke).

rebalance_cb is always triggered exactly once when a rebalance completes with a new assignment, even if that assignment is empty. If an eager/non-cooperative assignor is configured, there will eventually be exactly one corresponding call to rebalance_cb to revoke these partitions (even if empty), whether this is due to a group rebalance or lost partitions. In the cooperative case, rebalance_cb will never be called if the set of partitions being revoked is empty (whether or not lost).

The callback's opaque argument is the opaque set with rd_kafka_conf_set_opaque().

Remarks: The partitions list is destroyed by librdkafka on return return from the rebalance_cb and must not be freed or saved by the application.; Be careful when modifying the partitions list. Changing this list should only be done to change the initial offsets for each partition. But a function like rd_kafka_position() might have unexpected effects for instance when a consumer gets assigned a partition it used to consume at an earlier rebalance. In this case, the list of partitions will be updated with the old offset for that partition. In this case, it is generally better to pass a copy of the list (see rd_kafka_topic_partition_list_copy()). The result of rd_kafka_position() is typically outdated in RD_KAFKA_RESP_ERR__ASSIGN_PARTITIONS.

See also: rd_kafka_assign(); rd_kafka_incremental_assign(); rd_kafka_incremental_unassign(); rd_kafka_assignment_lost(); rd_kafka_rebalance_protocol()

The following example shows the application's responsibilities:

static void rebalance_cb (rd_kafka_t *rk, rd_kafka_resp_err_t err,
                          rd_kafka_topic_partition_list_t *partitions,
                          void *opaque) {

switch (err)
    {
      case RD_KAFKA_RESP_ERR__ASSIGN_PARTITIONS:
         // application may load offets from arbitrary external
         // storage here and update \p partitions
         if (!strcmp(rd_kafka_rebalance_protocol(rk), "COOPERATIVE"))
                 rd_kafka_incremental_assign(rk, partitions);
         else // EAGER
                 rd_kafka_assign(rk, partitions);
         break;

      case RD_KAFKA_RESP_ERR__REVOKE_PARTITIONS:
         if (manual_commits) // Optional explicit manual commit
             rd_kafka_commit(rk, partitions, 0); // sync commit

         if (!strcmp(rd_kafka_rebalance_protocol(rk), "COOPERATIVE"))
                 rd_kafka_incremental_unassign(rk, partitions);
         else // EAGER
                 rd_kafka_assign(rk, NULL);
         break;

      default:
         handle_unlikely_error(err);
         rd_kafka_assign(rk, NULL); // sync state
         break;
     }
}

Remarks: The above example lacks error handling for assign calls, see the examples/ directory.

Parameters: conf \FFI\CData|null rd_kafka_conf_t*; rebalance_cb \FFI\CData|\Closure void()(rd_kafka_t, rd_kafka_resp_err_t, rd_kafka_topic_partition_list_t*, void*)

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a10db731dc1a295bd9884e4f8cb199311

rd_kafka_conf_set_resolve_cb()¶

public static rd_kafka_conf_set_resolve_cb ( 
    \FFI\CData|null $conf, 
    \FFI\CData|\Closure $resolve_cb
 ): void

Set address resolution callback.

The callback is responsible for resolving the hostname node and the service service into a list of socket addresses as getaddrinfo(3) would. The hints and res parameters function as they do for getaddrinfo(3). The callback's opaque argument is the opaque set with rd_kafka_conf_set_opaque().

If the callback is invoked with a NULL node, service, and hints, the callback should instead free the addrinfo struct specified in res. In this case the callback must succeed; the return value will not be checked by the caller.

The callback's return value is interpreted as the return value of getaddrinfo(3).

Remarks: The callback will be called from an internal librdkafka thread.

Parameters: conf \FFI\CData|null rd_kafka_conf_t*; resolve_cb \FFI\CData|\Closure int()(const char, const char*, const struct addrinfo*, struct addrinfo**, void*)

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a12bbaef85d4168572eea006c5ce0d2eb

rd_kafka_conf_set_socket_cb()¶

public static rd_kafka_conf_set_socket_cb ( 
    \FFI\CData|null $conf, 
    \FFI\CData|\Closure $socket_cb
 ): void

Set socket callback.

The socket callback is responsible for opening a socket according to the supplied domain, type and protocol. The socket shall be created with CLOEXEC set in a racefree fashion, if possible.

The callback's opaque argument is the opaque set with rd_kafka_conf_set_opaque().

Default:

on linux: racefree CLOEXEC
others : non-racefree CLOEXEC

Remarks: The callback will be called from an internal librdkafka thread.

Parameters: conf \FFI\CData|null rd_kafka_conf_t*; socket_cb \FFI\CData|\Closure int()(int, int, int, void)

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a0467a6c20d5af69a29a63b530962ecbf

rd_kafka_conf_set_ssl_cert()¶

public static rd_kafka_conf_set_ssl_cert ( 
    \FFI\CData|null $conf, 
    int $cert_type, 
    int $cert_enc, 
    \FFI\CData|object|string|null $buffer, 
    int|null $size, 
    \FFI\CData|null $errstr, 
    int|null $errstr_size
 ): int

Set certificate/key cert_type from the cert_enc encoded memory at buffer of size bytes.

Remarks: Calling this method multiple times with the same cert_type will replace the previous value.; Calling this method with buffer set to NULL will clear the configuration for cert_type.; The private key may require a password, which must be specified with the ssl.key.password configuration property prior to calling this function.; Private and public keys in PEM format may also be set with the ssl.key.pem and ssl.certificate.pem configuration properties.; CA certificate in PEM format may also be set with the ssl.ca.pem configuration property.; When librdkafka is linked to OpenSSL 3.0 and the certificate is encoded using an obsolete cipher, it might be necessary to set up an OpenSSL configuration file to load the "legacy" provider and set the OPENSSL_CONF environment variable. See https://github.com/openssl/openssl/blob/master/README-PROVIDERS.md for more information.

Parameters: conf \FFI\CData|null rd_kafka_conf_t* - Configuration object.; cert_type int rd_kafka_cert_type_t - Certificate or key type to configure.; cert_enc int rd_kafka_cert_enc_t - Buffer encoding type.; buffer \FFI\CData|object|string|null const void* - Memory pointer to encoded certificate or key. The memory is not referenced after this function returns.; size int|null size_t - Size of memory at buffer.; errstr \FFI\CData|null char* - Memory were a human-readable error string will be written on failure.; errstr_size int|null size_t - Size of errstr, including space for nul-terminator.
Returns: int rd_kafka_conf_res_t - RD_KAFKA_CONF_OK on success or RD_KAFKA_CONF_INVALID if the memory in buffer is of incorrect encoding, or if librdkafka was not built with SSL support.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a55fa4d223e6214b7be94a87f9985177a

rd_kafka_conf_set_ssl_cert_verify_cb()¶

public static rd_kafka_conf_set_ssl_cert_verify_cb ( 
    \FFI\CData|null $conf, 
    \FFI\CData|\Closure $ssl_cert_verify_cb
 ): int

Sets the verification callback of the broker certificate.

The verification callback is triggered from internal librdkafka threads upon connecting to a broker. On each connection attempt the callback will be called for each certificate in the broker's certificate chain, starting at the root certification, as long as the application callback returns 1 (valid certificate). broker_name and broker_id correspond to the broker the connection is being made to. The x509_error argument indicates if OpenSSL's verification of the certificate succeed (0) or failed (an OpenSSL error code). The application may set the SSL context error code by returning 0 from the verify callback and providing a non-zero SSL context error code in x509_error. If the verify callback sets x509_error to 0, returns 1, and the original x509_error was non-zero, the error on the SSL context will be cleared. x509_error is always a valid pointer to an int.

depth is the depth of the current certificate in the chain, starting at the root certificate.

The certificate itself is passed in binary DER format in buf of size size.

The callback must return 1 if verification succeeds, or 0 if verification fails and then write a human-readable error message to errstr (limited to errstr_size bytes, including nul-term).

The callback's opaque argument is the opaque set with rd_kafka_conf_set_opaque().

Warning: This callback will be called from internal librdkafka threads.

Remarks: See <openssl/x509_vfy.h> in the OpenSSL source distribution for a list of x509_error codes.

Parameters: conf \FFI\CData|null rd_kafka_conf_t*; ssl_cert_verify_cb \FFI\CData|\Closure int()(rd_kafka_t, const char*, int32_t, int*, int, const char*, size_t, char*, size_t, void*)
Returns: int rd_kafka_conf_res_t - RD_KAFKA_CONF_OK if SSL is supported in this build, else RD_KAFKA_CONF_INVALID.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ae0b29e178bc565c9b8b3d5dfc60c18c5

rd_kafka_conf_set_stats_cb()¶

public static rd_kafka_conf_set_stats_cb ( 
    \FFI\CData|null $conf, 
    \FFI\CData|\Closure $stats_cb
 ): void

Set statistics callback in provided conf object.

The statistics callback is triggered from rd_kafka_poll() every statistics.interval.ms (needs to be configured separately). Function arguments:

rk - Kafka handle
json - String containing the statistics data in JSON format
json_len - Length of json string.
opaque - Application-provided opaque as set by rd_kafka_conf_set_opaque().

For more information on the format of json, see https://github.com/confluentinc/librdkafka/wiki/Statistics

If the application wishes to hold on to the json pointer and free it at a later time it must return 1 from the stats_cb. If the application returns 0 from the stats_cb then librdkafka will immediately free the json pointer.

See STATISTICS.md for a full definition of the JSON object.

Parameters: conf \FFI\CData|null rd_kafka_conf_t*; stats_cb \FFI\CData|\Closure int()(rd_kafka_t, char*, size_t, void*)

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a597d00432e3ca22174d18e7e348fb766

rd_kafka_conf_set_throttle_cb()¶

public static rd_kafka_conf_set_throttle_cb ( 
    \FFI\CData|null $conf, 
    \FFI\CData|\Closure $throttle_cb
 ): void

Set throttle callback.

The throttle callback is used to forward broker throttle times to the application for Produce and Fetch (consume) requests.

Callbacks are triggered whenever a non-zero throttle time is returned by the broker, or when the throttle time drops back to zero.

An application must call rd_kafka_poll() or rd_kafka_consumer_poll() at regular intervals to serve queued callbacks.

The callback's opaque argument is the opaque set with rd_kafka_conf_set_opaque().

Remarks: Requires broker version 0.9.0 or later.

Parameters: conf \FFI\CData|null rd_kafka_conf_t*; throttle_cb \FFI\CData|\Closure void()(rd_kafka_t, const char*, int32_t, int, void*)

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a04160826ad039d42c10edec456163fa7

rd_kafka_consume()¶

public static rd_kafka_consume ( 
    \FFI\CData|null $rkt, 
    int|null $partition, 
    int|null $timeout_ms
 ): \FFI\CData|null

Consume a single message from topic rkt and partition.

timeout_ms is maximum amount of time to wait for a message to be received. Consumer must have been previously started with rd_kafka_consume_start().

Errors (when returning NULL):

ETIMEDOUT - timeout_ms was reached with no new messages fetched.
ENOENT - rkt + partition is unknown. (no prior rd_kafka_consume_start() call)

NOTE: The returned message's ..->err must be checked for errors. NOTE: ..->err == RD_KAFKA_RESP_ERR__PARTITION_EOF signals that the end of the partition has been reached, which should typically not be considered an error. The application should handle this case (e.g., ignore).

Remarks: on_consume() interceptors may be called from this function prior to passing message to application.

Parameters: rkt \FFI\CData|null rd_kafka_topic_t*; partition int|null int32_t; timeout_ms int|null int
Returns: \FFI\CData|null rd_kafka_message_t* - a message object on success or NULL on error. The message object must be destroyed with rd_kafka_message_destroy() when the application is done with it.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#aa49d14e8b742365f9f25d35318ff0b7e

rd_kafka_consume_batch()¶

public static rd_kafka_consume_batch ( 
    \FFI\CData|null $rkt, 
    int|null $partition, 
    int|null $timeout_ms, 
    \FFI\CData|null $rkmessages, 
    int|null $rkmessages_size
 ): int|null

Consume up to rkmessages_size from topic rkt and partition putting a pointer to each message in the application provided array rkmessages (of size rkmessages_size entries).

rd_kafka_consume_batch() provides higher throughput performance than rd_kafka_consume().

timeout_ms is the maximum amount of time to wait for all of rkmessages_size messages to be put into rkmessages. If no messages were available within the timeout period this function returns 0 and rkmessages remains untouched. This differs somewhat from rd_kafka_consume().

The message objects must be destroyed with rd_kafka_message_destroy() when the application is done with it.

See also: rd_kafka_consume()

Remarks: on_consume() interceptors may be called from this function prior to passing message to application.

Parameters: rkt \FFI\CData|null rd_kafka_topic_t*; partition int|null int32_t; timeout_ms int|null int; rkmessages \FFI\CData|null rd_kafka_message_t**; rkmessages_size int|null size_t
Returns: int|null ssize_t - the number of rkmessages added in rkmessages, or -1 on error (same error codes as for rd_kafka_consume().

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a53511739a2cf498b8d88287fef6873ce

rd_kafka_consume_batch_queue()¶

public static rd_kafka_consume_batch_queue ( 
    \FFI\CData|null $rkqu, 
    int|null $timeout_ms, 
    \FFI\CData|null $rkmessages, 
    int|null $rkmessages_size
 ): int|null

Consume batch of messages from queue.

See also: rd_kafka_consume_batch()

Parameters: rkqu \FFI\CData|null rd_kafka_queue_t*; timeout_ms int|null int; rkmessages \FFI\CData|null rd_kafka_message_t**; rkmessages_size int|null size_t
Returns: int|null ssize_t

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a3d949238471993b18537855aad28fa23

rd_kafka_consume_callback()¶

public static rd_kafka_consume_callback ( 
    \FFI\CData|null $rkt, 
    int|null $partition, 
    int|null $timeout_ms, 
    \FFI\CData|\Closure $consume_cb, 
    \FFI\CData|object|string|null $opaque
 ): int|null

Consumes messages from topic rkt and partition, calling the provided callback for each consumed messsage.

rd_kafka_consume_callback() provides higher throughput performance than both rd_kafka_consume() and rd_kafka_consume_batch().

timeout_ms is the maximum amount of time to wait for one or more messages to arrive.

The provided consume_cb function is called for each message, the application MUST NOT call rd_kafka_message_destroy() on the provided rkmessage.

The commit_opaque argument is passed to the consume_cb as commit_opaque.

See also: rd_kafka_consume()

Remarks: on_consume() interceptors may be called from this function prior to passing message to application.; This function will return early if a transaction control message is received, these messages are not exposed to the application but still enqueued on the consumer queue to make sure their offsets are stored.

Deprecated:: This API is deprecated and subject for future removal. There is no new callback-based consume interface, use the poll/queue based alternatives.

Parameters: rkt \FFI\CData|null rd_kafka_topic_t*; partition int|null int32_t; timeout_ms int|null int; consume_cb \FFI\CData|\Closure void()(rd_kafka_message_t, void*); opaque \FFI\CData|object|string|null void*
Returns: int|null int - the number of messages processed or -1 on error.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a570e099baed990e9966e5e9a65eb7b00

rd_kafka_consume_callback_queue()¶

public static rd_kafka_consume_callback_queue ( 
    \FFI\CData|null $rkqu, 
    int|null $timeout_ms, 
    \FFI\CData|\Closure $consume_cb, 
    \FFI\CData|object|string|null $opaque
 ): int|null

Consume multiple messages from queue with callback.

See also: rd_kafka_consume_callback()

Deprecated:: This API is deprecated and subject for future removal. There is no new callback-based consume interface, use the poll/queue based alternatives.

Parameters: rkqu \FFI\CData|null rd_kafka_queue_t*; timeout_ms int|null int; consume_cb \FFI\CData|\Closure void()(rd_kafka_message_t, void*); opaque \FFI\CData|object|string|null void*
Returns: int|null int

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a4632ec35e579f9051164f7171940c243

rd_kafka_consume_queue()¶

public static rd_kafka_consume_queue ( 
    \FFI\CData|null $rkqu, 
    int|null $timeout_ms
 ): \FFI\CData|null

Consume from queue.

See also: rd_kafka_consume()

Parameters: rkqu \FFI\CData|null rd_kafka_queue_t*; timeout_ms int|null int
Returns: \FFI\CData|null rd_kafka_message_t*

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a8ff0b80fccb3a5bd31b1baaf20e4ca16

rd_kafka_consume_start()¶

public static rd_kafka_consume_start ( 
    \FFI\CData|null $rkt, 
    int|null $partition, 
    int|null $offset
 ): int|null

Start consuming messages for topic rkt and partition at offset offset which may either be an absolute (0..N) or one of the logical offsets:

RD_KAFKA_OFFSET_BEGINNING
RD_KAFKA_OFFSET_END
RD_KAFKA_OFFSET_STORED
RD_KAFKA_OFFSET_TAIL

rdkafka will attempt to keep queued.min.messages (config property) messages in the local queue by repeatedly fetching batches of messages from the broker until the threshold is reached.

The application shall use one of the rd_kafka_consume*() functions to consume messages from the local queue, each kafka message being represented as a rd_kafka_message_t * object.

rd_kafka_consume_start() must not be called multiple times for the same topic and partition without stopping consumption first with rd_kafka_consume_stop().

Use rd_kafka_errno2err() to convert sytem errno to rd_kafka_resp_err_t

Parameters

rkt \FFI\CData|null rd_kafka_topic_t*

partition int|null int32_t

offset int|null int64_t

Returns

int|null int - 0 on success or -1 on error in which case errno is set accordingly:

EBUSY - Conflicts with an existing or previous subscription (RD_KAFKA_RESP_ERR__CONFLICT)

EINVAL - Invalid offset, or incomplete configuration (lacking group.id) (RD_KAFKA_RESP_ERR__INVALID_ARG)

ESRCH - requested partition is invalid. (RD_KAFKA_RESP_ERR__UNKNOWN_PARTITION)

ENOENT - topic is unknown in the Kafka cluster. (RD_KAFKA_RESP_ERR__UNKNOWN_TOPIC)

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ae21dcd2d8c6195baf7f9f4952d7e12d4

rd_kafka_consume_start_queue()¶

public static rd_kafka_consume_start_queue ( 
    \FFI\CData|null $rkt, 
    int|null $partition, 
    int|null $offset, 
    \FFI\CData|null $rkqu
 ): int|null

Same as rd_kafka_consume_start() but re-routes incoming messages to the provided queue rkqu (which must have been previously allocated with rd_kafka_queue_new().

The application must use one of the rd_kafka_consume_*_queue() functions to receive fetched messages.

rd_kafka_consume_start_queue() must not be called multiple times for the same topic and partition without stopping consumption first with rd_kafka_consume_stop(). rd_kafka_consume_start() and rd_kafka_consume_start_queue() must not be combined for the same topic and partition.

Parameters: rkt \FFI\CData|null rd_kafka_topic_t*; partition int|null int32_t; offset int|null int64_t; rkqu \FFI\CData|null rd_kafka_queue_t*
Returns: int|null int

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a8e952d7961169471f69c7ddc87041258

rd_kafka_consume_stop()¶

public static rd_kafka_consume_stop ( 
    \FFI\CData|null $rkt, 
    int|null $partition
 ): int|null

Stop consuming messages for topic rkt and partition, purging all messages currently in the local queue.

NOTE: To enforce synchronisation this call will block until the internal fetcher has terminated and offsets are committed to configured storage method.

The application needs to be stop all consumers before calling rd_kafka_destroy() on the main object handle.

Parameters: rkt \FFI\CData|null rd_kafka_topic_t*; partition int|null int32_t
Returns: int|null int - 0 on success or -1 on error (see errno).

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#acf07475e5e85e63fc5321a1087288cd4

rd_kafka_consumer_close()¶

public static rd_kafka_consumer_close ( 
    \FFI\CData|null $rk
 ): int

Close the consumer.

This call will block until the consumer has revoked its assignment, calling the rebalance_cb if it is configured, committed offsets to broker, and left the consumer group (if applicable). The maximum blocking time is roughly limited to session.timeout.ms.

Remarks: The application still needs to call rd_kafka_destroy() after this call finishes to clean up the underlying handle resources.

Parameters: rk \FFI\CData|null rd_kafka_t* - )
Returns: int rd_kafka_resp_err_t - An error code indicating if the consumer close was succesful or not. RD_KAFKA_RESP_ERR__FATAL is returned if the consumer has raised a fatal error.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a37b54d329e12d745889defe96e7d043d

rd_kafka_consumer_close_queue()¶

public static rd_kafka_consumer_close_queue ( 
    \FFI\CData|null $rk, 
    \FFI\CData|null $rkqu
 ): \FFI\CData|null

Asynchronously close the consumer.

Performs the same actions as rd_kafka_consumer_close() but in a background thread.

Rebalance events/callbacks (etc) will be forwarded to the application-provided rkqu. The application must poll/serve this queue until rd_kafka_consumer_closed() returns true.

Remarks: Depending on consumer group join state there may or may not be rebalance events emitted on rkqu.

See also: rd_kafka_consumer_closed()

Parameters: rk \FFI\CData|null rd_kafka_t*; rkqu \FFI\CData|null rd_kafka_queue_t*
Returns: \FFI\CData|null rd_kafka_error_t* - an error object if the consumer close failed, else NULL.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a9dd5c18bdfed81c8847b259f0a8d498d

rd_kafka_consumer_closed()¶

public static rd_kafka_consumer_closed ( 
    \FFI\CData|null $rk
 ): int|null

Should be used in conjunction with rd_kafka_consumer_close_queue() to know when the consumer has been closed.

See also: rd_kafka_consumer_close_queue()

Parameters: rk \FFI\CData|null rd_kafka_t* - )
Returns: int|null int - 1 if the consumer is closed, else 0.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a88197205c61ed98b99f6442551a5e94f

rd_kafka_consumer_group_metadata()¶

public static rd_kafka_consumer_group_metadata ( 
    \FFI\CData|null $rk
 ): \FFI\CData|null

Remarks: The returned pointer must be freed by the application using rd_kafka_consumer_group_metadata_destroy().

See also: rd_kafka_send_offsets_to_transaction()

Parameters: rk \FFI\CData|null rd_kafka_t* - )
Returns: \FFI\CData|null rd_kafka_consumer_group_metadata_t* - the current consumer group metadata associated with this consumer, or NULL if rk is not a consumer configured with a group.id. This metadata object should be passed to the transactional producer’s rd_kafka_send_offsets_to_transaction() API.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a167fe52efc68d470291bf17757b62c2e

rd_kafka_consumer_group_metadata_destroy()¶

public static rd_kafka_consumer_group_metadata_destroy ( 
    \FFI\CData|null $arg0
 ): void

Parameters: arg0 \FFI\CData|null rd_kafka_consumer_group_metadata_t*

rd_kafka_consumer_group_metadata_member_id()¶

public static rd_kafka_consumer_group_metadata_member_id ( 
    \FFI\CData|null $group_metadata
 ): string|null

Get member id of a group metadata.

Remarks: The returned pointer has the same lifetime as group_metadata.

Parameters: group_metadata \FFI\CData|null const rd_kafka_consumer_group_metadata_t* - ) - The group metadata
Returns: string|null const char* - The member id contained in the passed group_metadata.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#abc50e7689e6e3975ef0dd3accacff87a

rd_kafka_consumer_group_metadata_new()¶

public static rd_kafka_consumer_group_metadata_new ( 
    string|null $group_id
 ): \FFI\CData|null

Create a new consumer group metadata object. This is typically only used for writing tests.

Remarks: The returned pointer must be freed by the application using rd_kafka_consumer_group_metadata_destroy().

Parameters: group_id string|null const char* - ) - The group id.
Returns: \FFI\CData|null rd_kafka_consumer_group_metadata_t*

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a30dc0292d9f172832451905fd6c28b22

rd_kafka_consumer_group_metadata_new_with_genid()¶

public static rd_kafka_consumer_group_metadata_new_with_genid ( 
    string|null $group_id, 
    int|null $generation_id, 
    string|null $member_id, 
    string|null $group_instance_id
 ): \FFI\CData|null

Create a new consumer group metadata object. This is typically only used for writing tests.

Remarks: The returned pointer must be freed by the application using rd_kafka_consumer_group_metadata_destroy().

Parameters: group_id string|null const char* - The group id.; generation_id int|null int32_t - The group generation id.; member_id string|null const char* - The group member id.; group_instance_id string|null const char* - The group instance id (may be NULL).
Returns: \FFI\CData|null rd_kafka_consumer_group_metadata_t*

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a679b7a0b807f69b72a4088bcee0e13c9

rd_kafka_consumer_group_metadata_read()¶

public static rd_kafka_consumer_group_metadata_read ( 
    \FFI\CData|null $cgmdp, 
    \FFI\CData|object|string|null $buffer, 
    int|null $size
 ): \FFI\CData|null

Reads serialized consumer group metadata and returns a consumer group metadata object. This is mainly for client binding use and not for application use.

Remarks: The serialized metadata format is private and is not compatible across different versions or even builds of librdkafka. It should only be used in the same process runtime and must only be passed to rd_kafka_consumer_group_metadata_read().

See also: rd_kafka_consumer_group_metadata_write()

Parameters: cgmdp \FFI\CData|null rd_kafka_consumer_group_metadata_t** - On success this pointer will be updated to point to a new consumer group metadata object which must be freed with rd_kafka_consumer_group_metadata_destroy().; buffer \FFI\CData|object|string|null const void* - Pointer to the serialized data.; size int|null size_t - Size of the serialized data.
Returns: \FFI\CData|null rd_kafka_error_t* - NULL on success or an error object on failure.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ad3719a32498a270c04a48d64f2f301b3

rd_kafka_consumer_group_metadata_write()¶

public static rd_kafka_consumer_group_metadata_write ( 
    \FFI\CData|null $cgmd, 
    \FFI\CData|object|string|null $bufferp, 
    \FFI\CData|null $sizep
 ): \FFI\CData|null

Serialize the consumer group metadata to a binary format. This is mainly for client binding use and not for application use.

Remarks: The serialized metadata format is private and is not compatible across different versions or even builds of librdkafka. It should only be used in the same process runtime and must only be passed to rd_kafka_consumer_group_metadata_read().

See also: rd_kafka_consumer_group_metadata_read()

Parameters: cgmd \FFI\CData|null const rd_kafka_consumer_group_metadata_t* - Metadata to be serialized.; bufferp \FFI\CData|object|string|null void** - On success this pointer will be updated to point to na allocated buffer containing the serialized metadata. The buffer must be freed with rd_kafka_mem_free().; sizep \FFI\CData|null size_t* - The pointed to size will be updated with the size of the serialized buffer.
Returns: \FFI\CData|null rd_kafka_error_t* - NULL on success or an error object on failure.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#aef280384f33889a4dfe02d92186f5928

rd_kafka_consumer_group_state_code()¶

public static rd_kafka_consumer_group_state_code ( 
    string|null $name
 ): int

Returns a code for a state name.

Parameters: name string|null const char* - ) - The state name.
Returns: int rd_kafka_consumer_group_state_t - The group state value corresponding to the provided group state name.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a5d7d4a9967f81749cf8bd2b898021d80

rd_kafka_consumer_group_state_name()¶

public static rd_kafka_consumer_group_state_name ( 
    int $state
 ): string|null

Returns a name for a state code.

Parameters: state int rd_kafka_consumer_group_state_t - ) - The state value.
Returns: string|null const char* - The group state name corresponding to the provided group state value.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a77bdc3f9d644c879f64ff033a5814284

rd_kafka_consumer_group_type_code()¶

public static rd_kafka_consumer_group_type_code ( 
    string|null $name
 ): int

Returns a code for a group type name.

Remarks: The comparison is case-insensitive.

Parameters: name string|null const char* - ) - The group type name.
Returns: int rd_kafka_consumer_group_type_t - The group type value corresponding to the provided group type name.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ac2557eeb2e89bce046100adbee25c3dc

rd_kafka_consumer_group_type_name()¶

public static rd_kafka_consumer_group_type_name ( 
    int $type
 ): string|null

Returns a name for a group type code.

Parameters: type int rd_kafka_consumer_group_type_t - ) - The group type value.
Returns: string|null const char* - The group type name corresponding to the provided group type value.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a2dd724a00756c8da5ceb24e11f580b6f

rd_kafka_consumer_poll()¶

public static rd_kafka_consumer_poll ( 
    \FFI\CData|null $rk, 
    int|null $timeout_ms
 ): \FFI\CData|null

Poll the consumer for messages or events.

Will block for at most timeout_ms milliseconds.

Remarks: An application should make sure to call consumer_poll() at regular intervals, even if no messages are expected, to serve any queued callbacks waiting to be called. This is especially important when a rebalance_cb has been registered as it needs to be called and handled properly to synchronize internal consumer state.

Remarks: on_consume() interceptors may be called from this function prior to passing message to application.; When subscribing to topics the application must call poll at least every max.poll.interval.ms to remain a member of the consumer group.

Noteworthy errors returned in ->err:

RD_KAFKA_RESP_ERR__MAX_POLL_EXCEEDED - application failed to call poll within max.poll.interval.ms.

See also: rd_kafka_message_t

Parameters: rk \FFI\CData|null rd_kafka_t*; timeout_ms int|null int
Returns: \FFI\CData|null rd_kafka_message_t* - A message object which is a proper message if ->err is RD_KAFKA_RESP_ERR_NO_ERROR, or an event or error for any other value.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a65cc6cb9bd72c4084f074af0361ceddf

rd_kafka_controllerid()¶

public static rd_kafka_controllerid ( 
    \FFI\CData|null $rk, 
    int|null $timeout_ms
 ): int|null

Returns the current ControllerId as reported in broker metadata.

Remarks: Requires broker version >=0.10.0 and api.version.request=true.

Parameters: rk \FFI\CData|null rd_kafka_t* - Client instance.; timeout_ms int|null int - If there is no cached value from metadata retrieval then this specifies the maximum amount of time (in milliseconds) the call will block waiting for metadata to be retrieved. Use 0 for non-blocking calls.
Returns: int|null int32_t - the controller broker id (>= 0), or -1 if no ControllerId could be retrieved in the allotted timespan.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#abcf5d443b9af5e6ac252dae1c94ea68f

rd_kafka_default_topic_conf_dup()¶

public static rd_kafka_default_topic_conf_dup ( 
    \FFI\CData|null $rk
 ): \FFI\CData|null

Parameters: rk \FFI\CData|null rd_kafka_t*
Returns: \FFI\CData|null rd_kafka_topic_conf_t*

rd_kafka_destroy()¶

public static rd_kafka_destroy ( 
    \FFI\CData|null $rk
 ): void

Destroy Kafka handle.

Remarks: This is a blocking operation.; rd_kafka_consumer_close() will be called from this function if the instance type is RD_KAFKA_CONSUMER, a group.id was configured, and the rd_kafka_consumer_close() was not explicitly called by the application. This in turn may trigger consumer callbacks, such as rebalance_cb. Use rd_kafka_destroy_flags() with RD_KAFKA_DESTROY_F_NO_CONSUMER_CLOSE to avoid this behaviour.

See also: rd_kafka_destroy_flags()

Parameters: rk \FFI\CData|null rd_kafka_t* - )

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ac052e92621dcaa3a336dbf826e0d7794

rd_kafka_destroy_flags()¶

public static rd_kafka_destroy_flags ( 
    \FFI\CData|null $rk, 
    int|null $flags
 ): void

Destroy Kafka handle according to specified destroy flags.

Parameters: rk \FFI\CData|null rd_kafka_t*; flags int|null int

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ab4249c99e6b06fbe126d85d09e4735f7

rd_kafka_dump()¶

public static rd_kafka_dump ( 
    \FFI\CData|null $fp, 
    \FFI\CData|null $rk
 ): void

Dumps rdkafka's internal state for handle rk to stream fp.

This is only useful for debugging rdkafka, showing state and statistics for brokers, topics, partitions, etc.

Parameters: fp \FFI\CData|null FILE*; rk \FFI\CData|null rd_kafka_t*

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a27a46f74ec4ccc9c0b36dbcf546908a1

rd_kafka_err2name()¶

public static rd_kafka_err2name ( 
    int $err
 ): string|null

Returns the error code name (enum name).

Parameters: err int rd_kafka_resp_err_t - ) - Error code to translate
Returns: string|null const char*

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a27b6629fddca10bf941a617b2c996321

rd_kafka_err2str()¶

public static rd_kafka_err2str ( 
    int $err
 ): string|null

Returns a human readable representation of a kafka error.

Parameters: err int rd_kafka_resp_err_t - ) - Error code to translate
Returns: string|null const char*

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a2610f668794c62a459d5c7e5c2880698

rd_kafka_errno()¶

public static rd_kafka_errno (  ): int|null

Returns the thread-local system errno.

On most platforms this is the same as errno but in case of different runtimes between library and application (e.g., Windows static DLLs) this provides a means for exposing the errno librdkafka uses.

Remarks: The value is local to the current calling thread.

Deprecated:: Use rd_kafka_last_error() to retrieve the last error code set by the legacy librdkafka APIs.

Returns: int|null int - )

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a8aa1b1a41d2fc0c487f519663609df4f

rd_kafka_errno2err()¶

public static rd_kafka_errno2err ( 
    int|null $errnox
 ): int

Converts the system errno value errnox to a rd_kafka_resp_err_t error code upon failure from the following functions:

rd_kafka_topic_new()
rd_kafka_consume_start()
rd_kafka_consume_stop()
rd_kafka_consume()
rd_kafka_consume_batch()
rd_kafka_consume_callback()
rd_kafka_consume_queue()
rd_kafka_produce()

Remarks: A better alternative is to call rd_kafka_last_error() immediately after any of the above functions return -1 or NULL.

Deprecated:: Use rd_kafka_last_error() to retrieve the last error code set by the legacy librdkafka APIs.

See also: rd_kafka_last_error()

Parameters: errnox int|null int - ) - System errno value to convert
Returns: int rd_kafka_resp_err_t - Appropriate error code for errnox

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#abeabf8589c657d7a3ec5a1411a7de91d

rd_kafka_error_code()¶

public static rd_kafka_error_code ( 
    \FFI\CData|null $error
 ): int

Parameters: error \FFI\CData|null const rd_kafka_error_t* - )
Returns: int rd_kafka_resp_err_t - the error code for error or RD_KAFKA_RESP_ERR_NO_ERROR if error is NULL.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a6b4f430e5cc4f8b89ec23aaa5063b739

rd_kafka_error_destroy()¶

public static rd_kafka_error_destroy ( 
    \FFI\CData|null $error
 ): void

Free and destroy an error object.

Remarks: As a conveniance it is permitted to pass a NULL error.

Parameters: error \FFI\CData|null rd_kafka_error_t* - )

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a3090ec84b9a8aa910d11f81f555d04da

rd_kafka_error_is_fatal()¶

public static rd_kafka_error_is_fatal ( 
    \FFI\CData|null $error
 ): int|null

Parameters: error \FFI\CData|null const rd_kafka_error_t* - )
Returns: int|null int - 1 if the error is a fatal error, indicating that the client instance is no longer usable, else 0 (also if error is NULL).

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a97ba623d3eadd7f6b64800c31e28b2d2

rd_kafka_error_is_retriable()¶

public static rd_kafka_error_is_retriable ( 
    \FFI\CData|null $error
 ): int|null

Parameters: error \FFI\CData|null const rd_kafka_error_t* - )
Returns: int|null int - 1 if the operation may be retried, else 0 (also if error is NULL).

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#acc4ee1ecb953e1a409528a99ab0c5451

rd_kafka_error_name()¶

public static rd_kafka_error_name ( 
    \FFI\CData|null $error
 ): string|null

Remarks: The lifetime of the returned pointer is the same as the error object.

See also: rd_kafka_err2name()

Parameters: error \FFI\CData|null const rd_kafka_error_t* - )
Returns: string|null const char* - the error code name for error, e.g, “ERR_UNKNOWN_MEMBER_ID”, or an empty string if error is NULL.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ab632db46f371bca77685da2e6245b5be

rd_kafka_error_new()¶

public static rd_kafka_error_new ( 
    int $code, 
    string|null $fmt, 
    mixed $args
 ): \FFI\CData|null

Create a new error object with error code and optional human readable error string in fmt.

This method is mainly to be used for mocking errors in application test code.

The returned object must be destroyed with rd_kafka_error_destroy().

Parameters: code int rd_kafka_resp_err_t; fmt string|null const char*; args mixed
Returns: \FFI\CData|null rd_kafka_error_t*

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#afd0d2df97ab446896ccf4ea87f709809

rd_kafka_error_string()¶

public static rd_kafka_error_string ( 
    \FFI\CData|null $error
 ): string|null

Remarks: The lifetime of the returned pointer is the same as the error object.

Parameters: error \FFI\CData|null const rd_kafka_error_t* - )
Returns: string|null const char* - a human readable error string for error, or an empty string if error is NULL.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ad45afa13cd9d23ed5ffade73b0c4272f

rd_kafka_error_txn_requires_abort()¶

public static rd_kafka_error_txn_requires_abort ( 
    \FFI\CData|null $error
 ): int|null

Remarks: The return value of this method is only valid for errors returned by the transactional API.

Parameters: error \FFI\CData|null const rd_kafka_error_t* - )
Returns: int|null int - 1 if the error is an abortable transaction error in which case the application must call rd_kafka_abort_transaction() and start a new transaction with rd_kafka_begin_transaction() if it wishes to proceed with transactions. Else returns 0 (also if error is NULL).

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ab07a417d941737db523808dec1c488dd

rd_kafka_event_AlterConfigs_result()¶

public static rd_kafka_event_AlterConfigs_result ( 
    \FFI\CData|null $rkev
 ): \FFI\CData|null

Get AlterConfigs result.

Event types: RD_KAFKA_EVENT_ALTERCONFIGS_RESULT

Parameters: rkev \FFI\CData|null rd_kafka_event_t* - )
Returns: \FFI\CData|null const rd_kafka_AlterConfigs_result_t* - the result of a AlterConfigs request, or NULL if event is of different type.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a2edf39234111a75b8cd7a6eb1e8de82c

rd_kafka_event_AlterConsumerGroupOffsets_result()¶

public static rd_kafka_event_AlterConsumerGroupOffsets_result ( 
    \FFI\CData|null $rkev
 ): \FFI\CData|null

Get AlterConsumerGroupOffsets result.

Remarks: The lifetime of the returned memory is the same as the lifetime of the rkev object.

Event types: RD_KAFKA_EVENT_ALTERCONSUMERGROUPOFFSETS_RESULT

Parameters: rkev \FFI\CData|null rd_kafka_event_t* - )
Returns: \FFI\CData|null const rd_kafka_AlterConsumerGroupOffsets_result_t* - the result of a AlterConsumerGroupOffsets request, or NULL if event is of different type.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ab13890c7914612fb1ac89b2352b84f3b

rd_kafka_event_AlterUserScramCredentials_result()¶

public static rd_kafka_event_AlterUserScramCredentials_result ( 
    \FFI\CData|null $rkev
 ): \FFI\CData|null

Get AlterUserScramCredentials result.

Remarks: The lifetime of the returned memory is the same as the lifetime of the rkev object.

Event types: RD_KAFKA_EVENT_ALTERUSERSCRAMCREDENTIALS_RESULT

Parameters: rkev \FFI\CData|null rd_kafka_event_t* - )
Returns: \FFI\CData|null const rd_kafka_AlterUserScramCredentials_result_t* - the result of a AlterUserScramCredentials request, or NULL if event is of different type.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a1f09d94a5a87834a917794450cd6cd46

rd_kafka_event_CreateAcls_result()¶

public static rd_kafka_event_CreateAcls_result ( 
    \FFI\CData|null $rkev
 ): \FFI\CData|null

Event types: RD_KAFKA_EVENT_CREATEACLS_RESULT

Parameters: rkev \FFI\CData|null rd_kafka_event_t* - )
Returns: \FFI\CData|null const rd_kafka_CreateAcls_result_t* - the result of a CreateAcls request, or NULL if event is of different type.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a24b0e95c5d86a9490daf8ca8a8122ed6

rd_kafka_event_CreatePartitions_result()¶

public static rd_kafka_event_CreatePartitions_result ( 
    \FFI\CData|null $rkev
 ): \FFI\CData|null

Get CreatePartitions result.

Event types: RD_KAFKA_EVENT_CREATEPARTITIONS_RESULT

Parameters: rkev \FFI\CData|null rd_kafka_event_t* - )
Returns: \FFI\CData|null const rd_kafka_CreatePartitions_result_t* - the result of a CreatePartitions request, or NULL if event is of different type.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#aa56b2b4df18fd4ce09c14b523c6435ca

rd_kafka_event_CreateTopics_result()¶

public static rd_kafka_event_CreateTopics_result ( 
    \FFI\CData|null $rkev
 ): \FFI\CData|null

Get CreateTopics result.

Event types: RD_KAFKA_EVENT_CREATETOPICS_RESULT

Parameters: rkev \FFI\CData|null rd_kafka_event_t* - )
Returns: \FFI\CData|null const rd_kafka_CreateTopics_result_t* - the result of a CreateTopics request, or NULL if event is of different type.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a28f75ccfca2dc17050fbb819dffd27bc

rd_kafka_event_DeleteAcls_result()¶

public static rd_kafka_event_DeleteAcls_result ( 
    \FFI\CData|null $rkev
 ): \FFI\CData|null

Event types: RD_KAFKA_EVENT_DELETEACLS_RESULT

Parameters: rkev \FFI\CData|null rd_kafka_event_t* - )
Returns: \FFI\CData|null const rd_kafka_DeleteAcls_result_t* - the result of a DeleteAcls request, or NULL if event is of different type.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a818f0a66803e94ed186747cef3d4b012

rd_kafka_event_DeleteConsumerGroupOffsets_result()¶

public static rd_kafka_event_DeleteConsumerGroupOffsets_result ( 
    \FFI\CData|null $rkev
 ): \FFI\CData|null

Get DeleteConsumerGroupOffsets result.

Event types: RD_KAFKA_EVENT_DELETECONSUMERGROUPOFFSETS_RESULT

Parameters: rkev \FFI\CData|null rd_kafka_event_t* - )
Returns: \FFI\CData|null const rd_kafka_DeleteConsumerGroupOffsets_result_t* - the result of a DeleteConsumerGroupOffsets request, or NULL if event is of different type.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#aa1d97f635157900a0a37e76818149125

rd_kafka_event_DeleteGroups_result()¶

public static rd_kafka_event_DeleteGroups_result ( 
    \FFI\CData|null $rkev
 ): \FFI\CData|null

Get DeleteGroups result.

Event types: RD_KAFKA_EVENT_DELETEGROUPS_RESULT

Parameters: rkev \FFI\CData|null rd_kafka_event_t* - )
Returns: \FFI\CData|null const rd_kafka_DeleteGroups_result_t* - the result of a DeleteGroups request, or NULL if event is of different type.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a4d60f12ec39f5d51399e35ff26160f37

rd_kafka_event_DeleteRecords_result()¶

public static rd_kafka_event_DeleteRecords_result ( 
    \FFI\CData|null $rkev
 ): \FFI\CData|null

Event types: RD_KAFKA_EVENT_DELETERECORDS_RESULT

Parameters: rkev \FFI\CData|null rd_kafka_event_t* - )
Returns: \FFI\CData|null const rd_kafka_DeleteRecords_result_t* - the result of a DeleteRecords request, or NULL if event is of different type.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a4f56557b7e82e145dca38d6f0409476c

rd_kafka_event_DeleteTopics_result()¶

public static rd_kafka_event_DeleteTopics_result ( 
    \FFI\CData|null $rkev
 ): \FFI\CData|null

Get DeleteTopics result.

Event types: RD_KAFKA_EVENT_DELETETOPICS_RESULT

Parameters: rkev \FFI\CData|null rd_kafka_event_t* - )
Returns: \FFI\CData|null const rd_kafka_DeleteTopics_result_t* - the result of a DeleteTopics request, or NULL if event is of different type.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#aae9b197ecfae378bb37d32b05488280a

rd_kafka_event_DescribeAcls_result()¶

public static rd_kafka_event_DescribeAcls_result ( 
    \FFI\CData|null $rkev
 ): \FFI\CData|null

Event types: RD_KAFKA_EVENT_DESCRIBEACLS_RESULT

Parameters: rkev \FFI\CData|null rd_kafka_event_t* - )
Returns: \FFI\CData|null const rd_kafka_DescribeAcls_result_t* - the result of a DescribeAcls request, or NULL if event is of different type.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a5f3c26dc9f796315211c8bf46cfb1753

rd_kafka_event_DescribeCluster_result()¶

public static rd_kafka_event_DescribeCluster_result ( 
    \FFI\CData|null $rkev
 ): \FFI\CData|null

Get DescribeCluster result.

Remarks: The lifetime of the returned memory is the same as the lifetime of the rkev object.

Event types: RD_KAFKA_EVENT_DESCRIBECLUSTER_RESULT

Parameters: rkev \FFI\CData|null rd_kafka_event_t* - )
Returns: \FFI\CData|null const rd_kafka_DescribeCluster_result_t* - the result of a DescribeCluster request, or NULL if event is of different type.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ad929f688a6f83e1a746f9671a3afca07

rd_kafka_event_DescribeConfigs_result()¶

public static rd_kafka_event_DescribeConfigs_result ( 
    \FFI\CData|null $rkev
 ): \FFI\CData|null

Get DescribeConfigs result.

Event types: RD_KAFKA_EVENT_DESCRIBECONFIGS_RESULT

Parameters: rkev \FFI\CData|null rd_kafka_event_t* - )
Returns: \FFI\CData|null const rd_kafka_DescribeConfigs_result_t* - the result of a DescribeConfigs request, or NULL if event is of different type.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a86331ff58f167ecaebbbb8c028fecd0d

rd_kafka_event_DescribeConsumerGroups_result()¶

public static rd_kafka_event_DescribeConsumerGroups_result ( 
    \FFI\CData|null $rkev
 ): \FFI\CData|null

Get DescribeConsumerGroups result.

Remarks: The lifetime of the returned memory is the same as the lifetime of the rkev object.

Event types: RD_KAFKA_EVENT_DESCRIBECONSUMERGROUPS_RESULT

Parameters: rkev \FFI\CData|null rd_kafka_event_t* - )
Returns: \FFI\CData|null const rd_kafka_DescribeConsumerGroups_result_t* - the result of a DescribeConsumerGroups request, or NULL if event is of different type.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a8cb01d10326bea4a31ebe173c56ee8e7

rd_kafka_event_DescribeTopics_result()¶

public static rd_kafka_event_DescribeTopics_result ( 
    \FFI\CData|null $rkev
 ): \FFI\CData|null

Get DescribeTopics result.

Remarks: The lifetime of the returned memory is the same as the lifetime of the rkev object.

Event types: RD_KAFKA_EVENT_DESCRIBETOPICS_RESULT

Parameters: rkev \FFI\CData|null rd_kafka_event_t* - )
Returns: \FFI\CData|null const rd_kafka_DescribeTopics_result_t* - the result of a DescribeTopics request, or NULL if event is of different type.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ae309867e52a99067ece1a7cadd99dd18

rd_kafka_event_DescribeUserScramCredentials_result()¶

public static rd_kafka_event_DescribeUserScramCredentials_result ( 
    \FFI\CData|null $rkev
 ): \FFI\CData|null

Get DescribeUserScramCredentials result.

Remarks: The lifetime of the returned memory is the same as the lifetime of the rkev object.

Event types: RD_KAFKA_EVENT_DESCRIBEUSERSCRAMCREDENTIALS_RESULT

Parameters: rkev \FFI\CData|null rd_kafka_event_t* - )
Returns: \FFI\CData|null const rd_kafka_DescribeUserScramCredentials_result_t* - the result of a DescribeUserScramCredentials request, or NULL if event is of different type.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a8c2dbdc07da30740430e66c527b05cf2

rd_kafka_event_ElectLeaders_result()¶

public static rd_kafka_event_ElectLeaders_result ( 
    \FFI\CData|null $rkev
 ): \FFI\CData|null

Get ElectLeaders result.

Remarks: The lifetime of the returned memory is the same as the lifetime of the rkev object.

Event types: RD_KAFKA_EVENT_ELECTLEADERS_RESULT

Parameters: rkev \FFI\CData|null rd_kafka_event_t* - )
Returns: \FFI\CData|null const rd_kafka_ElectLeaders_result_t* - the result of a ElectLeaders request, or NULL if event is of different type.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#accb1216ca1ee4ece892fa100c0979c6d

rd_kafka_event_IncrementalAlterConfigs_result()¶

public static rd_kafka_event_IncrementalAlterConfigs_result ( 
    \FFI\CData|null $rkev
 ): \FFI\CData|null

Get IncrementalAlterConfigs result.

Event types: RD_KAFKA_EVENT_INCREMENTALALTERCONFIGS_RESULT

Parameters: rkev \FFI\CData|null rd_kafka_event_t* - )
Returns: \FFI\CData|null const rd_kafka_IncrementalAlterConfigs_result_t* - the result of a IncrementalAlterConfigs request, or NULL if event is of different type.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a7005c1f446376c4e0d07c11b2ddc8918

rd_kafka_event_ListConsumerGroupOffsets_result()¶

public static rd_kafka_event_ListConsumerGroupOffsets_result ( 
    \FFI\CData|null $rkev
 ): \FFI\CData|null

Get ListConsumerGroupOffsets result.

Remarks: The lifetime of the returned memory is the same as the lifetime of the rkev object.

Event types: RD_KAFKA_EVENT_LISTCONSUMERGROUPOFFSETS_RESULT

Parameters: rkev \FFI\CData|null rd_kafka_event_t* - )
Returns: \FFI\CData|null const rd_kafka_ListConsumerGroupOffsets_result_t* - the result of a ListConsumerGroupOffsets request, or NULL if event is of different type.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a3b0211470e7ad47b7ddf6d88f46473ca

rd_kafka_event_ListConsumerGroups_result()¶

public static rd_kafka_event_ListConsumerGroups_result ( 
    \FFI\CData|null $rkev
 ): \FFI\CData|null

Get ListConsumerGroups result.

Remarks: The lifetime of the returned memory is the same as the lifetime of the rkev object.

Event types: RD_KAFKA_EVENT_LISTCONSUMERGROUPS_RESULT

Parameters: rkev \FFI\CData|null rd_kafka_event_t* - )
Returns: \FFI\CData|null const rd_kafka_ListConsumerGroups_result_t* - the result of a ListConsumerGroups request, or NULL if event is of different type.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ab7f0c4e335f10db1af2babab5b29dcd3

rd_kafka_event_ListOffsets_result()¶

public static rd_kafka_event_ListOffsets_result ( 
    \FFI\CData|null $rkev
 ): \FFI\CData|null

Get ListOffsets result.

Remarks: The lifetime of the returned memory is the same as the lifetime of the rkev object.

Event types: RD_KAFKA_EVENT_LISTOFFSETS_RESULT

Parameters: rkev \FFI\CData|null rd_kafka_event_t* - )
Returns: \FFI\CData|null const rd_kafka_ListOffsets_result_t* - the result of a ListOffsets request, or NULL if event is of different type.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a7235a4c443405ed3e2800c7154824451

rd_kafka_event_config_string()¶

public static rd_kafka_event_config_string ( 
    \FFI\CData|null $rkev
 ): string|null

The returned memory is read-only and its lifetime is the same as the event object.

Event types:

RD_KAFKA_EVENT_OAUTHBEARER_TOKEN_REFRESH: value of sasl.oauthbearer.config

Parameters: rkev \FFI\CData|null rd_kafka_event_t* - )
Returns: string|null const char* - the associated configuration string for the event, or NULL if the configuration property is not set or if not applicable for the given event type.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a79126bbee3e5c7930459469d6ee20952

rd_kafka_event_debug_contexts()¶

public static rd_kafka_event_debug_contexts ( 
    \FFI\CData|null $rkev, 
    \FFI\CData|null $dst, 
    int|null $dstsize
 ): int|null

Extract log debug context from event.

Event types:

RD_KAFKA_EVENT_LOG

Parameters: rkev \FFI\CData|null rd_kafka_event_t* - the event to extract data from.; dst \FFI\CData|null char* - destination string for comma separated list.; dstsize int|null size_t - size of provided dst buffer.
Returns: int|null int - 0 on success or -1 if unsupported event type.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a5c43c8164c856aeb3f3170808264458b

rd_kafka_event_destroy()¶

public static rd_kafka_event_destroy ( 
    \FFI\CData|null $rkev
 ): void

Destroy an event.

Remarks: Any references to this event, such as extracted messages, will not be usable after this call.; As a convenience it is okay to pass rkev as NULL in which case no action is performed.

Parameters: rkev \FFI\CData|null rd_kafka_event_t* - )

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#af1835c85aa202caf629861f29f475099

rd_kafka_event_error()¶

public static rd_kafka_event_error ( 
    \FFI\CData|null $rkev
 ): int

Use rd_kafka_event_error_is_fatal() to detect if this is a fatal error.

Event types:

all

Parameters: rkev \FFI\CData|null rd_kafka_event_t* - )
Returns: int rd_kafka_resp_err_t - the error code for the event.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#aa28b7d6bb4885843f9a8b9bafa0e15a5

rd_kafka_event_error_is_fatal()¶

public static rd_kafka_event_error_is_fatal ( 
    \FFI\CData|null $rkev
 ): int|null

Event types:

RD_KAFKA_EVENT_ERROR

See also: rd_kafka_fatal_error()

Parameters: rkev \FFI\CData|null rd_kafka_event_t* - )
Returns: int|null int - 1 if the error is a fatal error, else 0.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a1fe9d1e960a59774dbd5a0336927de7d

rd_kafka_event_error_string()¶

public static rd_kafka_event_error_string ( 
    \FFI\CData|null $rkev
 ): string|null

Event types:

all

Parameters: rkev \FFI\CData|null rd_kafka_event_t* - )
Returns: string|null const char* - the error string (if any). An application should check that rd_kafka_event_error() returns non-zero before calling this function.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a79a962de3831a077e687a8fe18d315ec

rd_kafka_event_log()¶

public static rd_kafka_event_log ( 
    \FFI\CData|null $rkev, 
    \FFI\CData|null $fac, 
    \FFI\CData|null $str, 
    \FFI\CData|null $level
 ): int|null

Extract log message from the event.

Event types:

RD_KAFKA_EVENT_LOG

Parameters: rkev \FFI\CData|null rd_kafka_event_t*; fac \FFI\CData|null const char**; str \FFI\CData|null const char**; level \FFI\CData|null int*
Returns: int|null int - 0 on success or -1 if unsupported event type.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a535efaa16772642d724bedca414c17c7

rd_kafka_event_message_array()¶

public static rd_kafka_event_message_array ( 
    \FFI\CData|null $rkev, 
    \FFI\CData|null $rkmessages, 
    int|null $size
 ): int|null

Extacts size message(s) from the event into the pre-allocated array rkmessages.

Event types:

RD_KAFKA_EVENT_FETCH (1 message)
RD_KAFKA_EVENT_DR (>=1 message(s))

Remarks: on_consume() interceptor may be called from this function prior to passing message to application.

Parameters: rkev \FFI\CData|null rd_kafka_event_t*; rkmessages \FFI\CData|null const rd_kafka_message_t**; size int|null size_t
Returns: int|null size_t - the number of messages extracted.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a18a17000ebe58eabcdafab37924442b8

rd_kafka_event_message_count()¶

public static rd_kafka_event_message_count ( 
    \FFI\CData|null $rkev
 ): int|null

Event types:

RD_KAFKA_EVENT_FETCH (1 message)
RD_KAFKA_EVENT_DR (>=1 message(s))

Parameters: rkev \FFI\CData|null rd_kafka_event_t* - )
Returns: int|null size_t - the number of remaining messages in the event.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a61d9d106c8956f379bb77d393b8acf90

rd_kafka_event_message_next()¶

public static rd_kafka_event_message_next ( 
    \FFI\CData|null $rkev
 ): \FFI\CData|null

Call repeatedly until it returns NULL.

Event types:

RD_KAFKA_EVENT_FETCH (1 message)
RD_KAFKA_EVENT_DR (>=1 message(s))

Remarks: The returned message(s) MUST NOT be freed with rd_kafka_message_destroy().; on_consume() interceptor may be called from this function prior to passing message to application.

Parameters: rkev \FFI\CData|null rd_kafka_event_t* - )
Returns: \FFI\CData|null const rd_kafka_message_t* - the next message from an event.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a0f7cdd0f4e8dd965249477553c3e476d

rd_kafka_event_name()¶

public static rd_kafka_event_name ( 
    \FFI\CData|null $rkev
 ): string|null

Remarks: As a convenience it is okay to pass rkev as NULL in which case the name for RD_KAFKA_EVENT_NONE is returned.

Parameters: rkev \FFI\CData|null const rd_kafka_event_t* - )
Returns: string|null const char* - the event type’s name for the given event.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a3767d551141115d2c7b0946c1b4ffb45

rd_kafka_event_opaque()¶

public static rd_kafka_event_opaque ( 
    \FFI\CData|null $rkev
 ): \FFI\CData|object|string|null

Event types:

RD_KAFKA_EVENT_OFFSET_COMMIT
RD_KAFKA_EVENT_CREATETOPICS_RESULT
RD_KAFKA_EVENT_DELETETOPICS_RESULT
RD_KAFKA_EVENT_CREATEPARTITIONS_RESULT
RD_KAFKA_EVENT_CREATEACLS_RESULT
RD_KAFKA_EVENT_DESCRIBEACLS_RESULT
RD_KAFKA_EVENT_DELETEACLS_RESULT
RD_KAFKA_EVENT_ALTERCONFIGS_RESULT
RD_KAFKA_EVENT_INCREMENTAL_ALTERCONFIGS_RESULT
RD_KAFKA_EVENT_DESCRIBECONFIGS_RESULT
RD_KAFKA_EVENT_DELETEGROUPS_RESULT
RD_KAFKA_EVENT_DELETECONSUMERGROUPOFFSETS_RESULT
RD_KAFKA_EVENT_DELETERECORDS_RESULT
RD_KAFKA_EVENT_LISTCONSUMERGROUPS_RESULT
RD_KAFKA_EVENT_DESCRIBECONSUMERGROUPS_RESULT
RD_KAFKA_EVENT_LISTCONSUMERGROUPOFFSETS_RESULT
RD_KAFKA_EVENT_ALTERCONSUMERGROUPOFFSETS_RESULT
RD_KAFKA_EVENT_DESCRIBETOPICS_RESULT
RD_KAFKA_EVENT_DESCRIBECLUSTER_RESULT
RD_KAFKA_EVENT_LISTOFFSETS_RESULT
RD_KAFKA_EVENT_ELECTLEADERS_RESULT

Parameters: rkev \FFI\CData|null rd_kafka_event_t* - )
Returns: \FFI\CData|object|string|null void* - the event opaque (if any) as passed to rd_kafka_commit() (et.al) or rd_kafka_AdminOptions_set_opaque(), depending on event type.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a8650ed2a19108d490a65c9aff3e66525

rd_kafka_event_stats()¶

public static rd_kafka_event_stats ( 
    \FFI\CData|null $rkev
 ): string|null

Extract stats from the event.

Event types:

RD_KAFKA_EVENT_STATS

Remarks: the returned string will be freed automatically along with the event object

Parameters: rkev \FFI\CData|null rd_kafka_event_t* - )
Returns: string|null const char* - stats json string.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a0d4cb79eb5ea2aeba252176df9504e8c

rd_kafka_event_topic_partition()¶

public static rd_kafka_event_topic_partition ( 
    \FFI\CData|null $rkev
 ): \FFI\CData|null

Remarks: The returned pointer MUST be freed with rd_kafka_topic_partition_destroy().

Event types: RD_KAFKA_EVENT_ERROR (for partition level errors)

Parameters: rkev \FFI\CData|null rd_kafka_event_t* - )
Returns: \FFI\CData|null rd_kafka_topic_partition_t* - a newly allocated topic_partition container, if applicable for the event type, else NULL.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#abf4cce46d6e566dd35865c0451b76afe

rd_kafka_event_topic_partition_list()¶

public static rd_kafka_event_topic_partition_list ( 
    \FFI\CData|null $rkev
 ): \FFI\CData|null

Remarks: The list MUST NOT be freed with rd_kafka_topic_partition_list_destroy()

Event types:

RD_KAFKA_EVENT_REBALANCE
RD_KAFKA_EVENT_OFFSET_COMMIT

Parameters: rkev \FFI\CData|null rd_kafka_event_t* - )
Returns: \FFI\CData|null rd_kafka_topic_partition_list_t* - the topic partition list from the event.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#abc8f98c9b35be497251fb8515e9e6633

rd_kafka_event_type()¶

public static rd_kafka_event_type ( 
    \FFI\CData|null $rkev
 ): int|null

Remarks: As a convenience it is okay to pass rkev as NULL in which case RD_KAFKA_EVENT_NONE is returned.

Parameters: rkev \FFI\CData|null const rd_kafka_event_t* - )
Returns: int|null rd_kafka_event_type_t - the event type for the given event.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a108de3729a4aa609a72a458a9de02d1d

rd_kafka_fatal_error()¶

public static rd_kafka_fatal_error ( 
    \FFI\CData|null $rk, 
    \FFI\CData|null $errstr, 
    int|null $errstr_size
 ): int

Returns the first fatal error set on this client instance, or RD_KAFKA_RESP_ERR_NO_ERROR if no fatal error has occurred.

This function is to be used with the Idempotent Producer and error_cb to detect fatal errors.

Generally all errors raised by error_cb are to be considered informational and temporary, the client will try to recover from all errors in a graceful fashion (by retrying, etc).

However, some errors should logically be considered fatal to retain consistency; in particular a set of errors that may occur when using the Idempotent Producer and the in-order or exactly-once producer guarantees can't be satisfied.

Parameters: rk \FFI\CData|null rd_kafka_t* - Client instance.; errstr \FFI\CData|null char* - A human readable error string (nul-terminated) is written to this location that must be of at least errstr_size bytes. The errstr is only written to if there is a fatal error. - Writable size in errstr.; errstr_size int|null size_t
Returns: int rd_kafka_resp_err_t - RD_KAFKA_RESP_ERR_NO_ERROR if no fatal error has been raised, else any other error code.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a44c976534da6f3877cc514826c71607c

rd_kafka_flush()¶

public static rd_kafka_flush ( 
    \FFI\CData|null $rk, 
    int|null $timeout_ms
 ): int

Wait until all outstanding produce requests, et.al, are completed. This should typically be done prior to destroying a producer instance to make sure all queued and in-flight produce requests are completed before terminating.

Remarks: This function will call rd_kafka_poll() and thus trigger callbacks.; The linger.ms time will be ignored for the duration of the call, queued messages will be sent to the broker as soon as possible.; If RD_KAFKA_EVENT_DR has been enabled (through rd_kafka_conf_set_events()) this function will not call rd_kafka_poll() but instead wait for the librdkafka-handled message count to reach zero. This requires the application to serve the event queue in a separate thread. In this mode only messages are counted, not other types of queued events.

See also: rd_kafka_outq_len()

Parameters: rk \FFI\CData|null rd_kafka_t*; timeout_ms int|null int
Returns: int rd_kafka_resp_err_t - RD_KAFKA_RESP_ERR__TIMED_OUT if timeout_ms was reached before all outstanding requests were completed, else RD_KAFKA_RESP_ERR_NO_ERROR

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#aaff06c4372bce917c17f3c1a5d8b205d

rd_kafka_get_debug_contexts()¶

public static rd_kafka_get_debug_contexts (  ): string|null

Retrieve supported debug contexts for use with the "debug" configuration property. (runtime)

Returns: string|null const char* - ) - Comma-separated list of available debugging contexts.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#aac378d7c442a6293754a6de4e2667ab8

rd_kafka_get_err_descs()¶

public static rd_kafka_get_err_descs ( 
    \FFI\CData|null $errdescs, 
    \FFI\CData|null $cntp
 ): void

Parameters: errdescs \FFI\CData|null const struct rd_kafka_err_desc**; cntp \FFI\CData|null size_t*

rd_kafka_get_watermark_offsets()¶

public static rd_kafka_get_watermark_offsets ( 
    \FFI\CData|null $rk, 
    string|null $topic, 
    int|null $partition, 
    \FFI\CData|null $low, 
    \FFI\CData|null $high
 ): int

Get last known low (oldest/beginning) and high (newest/end) offsets for partition.

The low offset is updated periodically (if statistics.interval.ms is set) while the high offset is updated on each fetched message set from the broker.

If there is no cached offset (either low or high, or both) then RD_KAFKA_OFFSET_INVALID will be returned for the respective offset.

Offsets are returned in *low and *high respectively.

Remarks: Shall only be used with an active consumer instance.

Parameters: rk \FFI\CData|null rd_kafka_t*; topic string|null const char*; partition int|null int32_t; low \FFI\CData|null int64_t*; high \FFI\CData|null int64_t*
Returns: int rd_kafka_resp_err_t - RD_KAFKA_RESP_ERR_NO_ERROR on success or an error code on failure.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ad1d338cebde98a76050e61301f631d82

rd_kafka_group_list_destroy()¶

public static rd_kafka_group_list_destroy ( 
    \FFI\CData|null $grplist
 ): void

Parameters: grplist \FFI\CData|null const struct rd_kafka_group_list*

rd_kafka_group_result_error()¶

public static rd_kafka_group_result_error ( 
    \FFI\CData|null $groupres
 ): \FFI\CData|null

Group result provides per-group operation result information.

Remarks: lifetime of the returned error is the same as the groupres.

Parameters: groupres \FFI\CData|null const rd_kafka_group_result_t* - )
Returns: \FFI\CData|null const rd_kafka_error_t* - the error for the given group result, or NULL on success.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a4b31907b1a13fbb6bdab1622aacce611

rd_kafka_group_result_name()¶

public static rd_kafka_group_result_name ( 
    \FFI\CData|null $groupres
 ): string|null

Remarks: lifetime of the returned string is the same as the groupres.

Parameters: groupres \FFI\CData|null const rd_kafka_group_result_t* - )
Returns: string|null const char* - the name of the group for the given group result.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ae0af23582029dd553ec3e6786e4aa0b7

rd_kafka_group_result_partitions()¶

public static rd_kafka_group_result_partitions ( 
    \FFI\CData|null $groupres
 ): \FFI\CData|null

Remarks: lifetime of the returned list is the same as the groupres.

Parameters: groupres \FFI\CData|null const rd_kafka_group_result_t* - )
Returns: \FFI\CData|null const rd_kafka_topic_partition_list_t* - the partitions/offsets for the given group result, if applicable to the request type, else NULL.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#afb53d17790ca12c4d945a9febf183409

rd_kafka_handle_mock_cluster()¶

public static rd_kafka_handle_mock_cluster ( 
    \FFI\CData|null $rk
 ): \FFI\CData|null

Parameters: rk \FFI\CData|null const rd_kafka_t*
Returns: \FFI\CData|null rd_kafka_mock_cluster_t*

rd_kafka_header_add()¶

public static rd_kafka_header_add ( 
    \FFI\CData|null $hdrs, 
    string|null $name, 
    int|null $name_size, 
    \FFI\CData|object|string|null $value, 
    int|null $value_size
 ): int

Add header with name name and value val (copied) of size size (not including null-terminator).

Parameters: hdrs \FFI\CData|null rd_kafka_headers_t* - Headers list.; name string|null const char* - Header name.; name_size int|null ssize_t - Header name size (not including the null-terminator). If -1 the name length is automatically acquired using strlen().; value \FFI\CData|object|string|null const void* - Pointer to header value, or NULL (set size to 0 or -1).; value_size int|null ssize_t - Size of header value. If -1 the value is assumed to be a null-terminated string and the length is automatically acquired using strlen().
Returns: int rd_kafka_resp_err_t - RD_KAFKA_RESP_ERR__READ_ONLY if the headers are read-only, else RD_KAFKA_RESP_ERR_NO_ERROR.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ad86e25f9787e647588fc2067705de10e

rd_kafka_header_cnt()¶

public static rd_kafka_header_cnt ( 
    \FFI\CData|null $hdrs
 ): int|null

Returns the number of header key/value pairs.

Parameters: hdrs \FFI\CData|null const rd_kafka_headers_t* - ) - Headers to count
Returns: int|null size_t

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#af8ce5228eef3ea0a9209965902b6fcdd

rd_kafka_header_get()¶

public static rd_kafka_header_get ( 
    \FFI\CData|null $hdrs, 
    int|null $idx, 
    string|null $name, 
    \FFI\CData|object|string|null $valuep, 
    \FFI\CData|null $sizep
 ): int

Iterator for headers matching name.

   Same semantics as rd_kafka_header_get_last()

Parameters: hdrs \FFI\CData|null const rd_kafka_headers_t* - Headers to iterate.; idx int|null size_t - Iterator index, start at 0 and increment by one for each call as long as RD_KAFKA_RESP_ERR_NO_ERROR is returned.; name string|null const char* - Header name to match.; valuep \FFI\CData|object|string|null const void** - (out) Set to a (null-terminated) const pointer to the value (may be NULL).; sizep \FFI\CData|null size_t* - (out) Set to the value’s size (not including null-terminator).
Returns: int rd_kafka_resp_err_t

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a5cf2d5ce4869203aaa9e18ad2c763bbf

rd_kafka_header_get_all()¶

public static rd_kafka_header_get_all ( 
    \FFI\CData|null $hdrs, 
    int|null $idx, 
    \FFI\CData|null $namep, 
    \FFI\CData|object|string|null $valuep, 
    \FFI\CData|null $sizep
 ): int

Iterator for all headers.

   Same semantics as rd_kafka_header_get()

See also: rd_kafka_header_get()

Parameters: hdrs \FFI\CData|null const rd_kafka_headers_t*; idx int|null size_t; namep \FFI\CData|null const char**; valuep \FFI\CData|object|string|null const void**; sizep \FFI\CData|null size_t*
Returns: int rd_kafka_resp_err_t

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a3a39136e1d13591f668158c0fa20961b

rd_kafka_header_get_last()¶

public static rd_kafka_header_get_last ( 
    \FFI\CData|null $hdrs, 
    string|null $name, 
    \FFI\CData|object|string|null $valuep, 
    \FFI\CData|null $sizep
 ): int

Find last header in list hdrs matching name.

Remarks: The returned pointer in valuep includes a trailing null-terminator that is not accounted for in sizep.; The returned pointer is only valid as long as the headers list and the header item is valid.

Parameters: hdrs \FFI\CData|null const rd_kafka_headers_t* - Headers list.; name string|null const char* - Header to find (last match).; valuep \FFI\CData|object|string|null const void** - (out) Set to a (null-terminated) const pointer to the value (may be NULL).; sizep \FFI\CData|null size_t* - (out) Set to the value’s size (not including null-terminator).
Returns: int rd_kafka_resp_err_t - RD_KAFKA_RESP_ERR_NO_ERROR if an entry was found, else RD_KAFKA_RESP_ERR__NOENT.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a6cb8628d390cd89a6d9daada8c70161a

rd_kafka_header_remove()¶

public static rd_kafka_header_remove ( 
    \FFI\CData|null $hdrs, 
    string|null $name
 ): int

Remove all headers for the given key (if any).

Parameters: hdrs \FFI\CData|null rd_kafka_headers_t*; name string|null const char*
Returns: int rd_kafka_resp_err_t - RD_KAFKA_RESP_ERR__READ_ONLY if the headers are read-only, RD_KAFKA_RESP_ERR__NOENT if no matching headers were found, else RD_KAFKA_RESP_ERR_NO_ERROR if headers were removed.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a8a8d23d274cf233b6b4b0a345c0180c1

rd_kafka_headers_copy()¶

public static rd_kafka_headers_copy ( 
    \FFI\CData|null $src
 ): \FFI\CData|null

Parameters: src \FFI\CData|null const rd_kafka_headers_t*
Returns: \FFI\CData|null rd_kafka_headers_t*

rd_kafka_headers_destroy()¶

public static rd_kafka_headers_destroy ( 
    \FFI\CData|null $hdrs
 ): void

Parameters: hdrs \FFI\CData|null rd_kafka_headers_t*

rd_kafka_headers_new()¶

public static rd_kafka_headers_new ( 
    int|null $initial_count
 ): \FFI\CData|null

Create a new headers list.

Parameters: initial_count int|null size_t - ) - Preallocate space for this number of headers. Any number of headers may be added, updated and removed regardless of the initial count.
Returns: \FFI\CData|null rd_kafka_headers_t*

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a9fdd55ee90816f38324f5d0af1b4fc1f

rd_kafka_incremental_assign()¶

public static rd_kafka_incremental_assign ( 
    \FFI\CData|null $rk, 
    \FFI\CData|null $partitions
 ): \FFI\CData|null

Incrementally add partitions to the current assignment.

If a COOPERATIVE assignor (i.e. incremental rebalancing) is being used, this method should be used in a rebalance callback to adjust the current assignment appropriately in the case where the rebalance type is RD_KAFKA_RESP_ERR__ASSIGN_PARTITIONS. The application must pass the partition list passed to the callback (or a copy of it), even if the list is empty. partitions must not be NULL. This method may also be used outside the context of a rebalance callback.

Remarks: The returned error object (if not NULL) must be destroyed with rd_kafka_error_destroy().

Parameters: rk \FFI\CData|null rd_kafka_t*; partitions \FFI\CData|null const rd_kafka_topic_partition_list_t*
Returns: \FFI\CData|null rd_kafka_error_t* - NULL on success, or an error object if the operation was unsuccessful.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a3bd9f42cf76b2a8cf2f4a4343abe8556

rd_kafka_incremental_unassign()¶

public static rd_kafka_incremental_unassign ( 
    \FFI\CData|null $rk, 
    \FFI\CData|null $partitions
 ): \FFI\CData|null

Incrementally remove partitions from the current assignment.

If a COOPERATIVE assignor (i.e. incremental rebalancing) is being used, this method should be used in a rebalance callback to adjust the current assignment appropriately in the case where the rebalance type is RD_KAFKA_RESP_ERR__REVOKE_PARTITIONS. The application must pass the partition list passed to the callback (or a copy of it), even if the list is empty. partitions must not be NULL. This method may also be used outside the context of a rebalance callback.

Remarks: The returned error object (if not NULL) must be destroyed with rd_kafka_error_destroy().

Parameters: rk \FFI\CData|null rd_kafka_t*; partitions \FFI\CData|null const rd_kafka_topic_partition_list_t*
Returns: \FFI\CData|null rd_kafka_error_t* - NULL on success, or an error object if the operation was unsuccessful.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a27f7bd18e42ed44f33932c2f9b6a4192

rd_kafka_init_transactions()¶

public static rd_kafka_init_transactions ( 
    \FFI\CData|null $rk, 
    int|null $timeout_ms
 ): \FFI\CData|null

Initialize transactions for the producer instance.

This function ensures any transactions initiated by previous instances of the producer with the same transactional.id are completed. If the previous instance failed with a transaction in progress the previous transaction will be aborted. This function needs to be called before any other transactional or produce functions are called when the transactional.id is configured.

If the last transaction had begun completion (following transaction commit) but not yet finished, this function will await the previous transaction's completion.

When any previous transactions have been fenced this function will acquire the internal producer id and epoch, used in all future transactional messages issued by this producer instance.

Remarks: This function may block up to timeout_ms milliseconds.; This call is resumable when a retriable timeout error is returned. Calling the function again will resume the operation that is progressing in the background.

Remarks: The returned error object (if not NULL) must be destroyed with rd_kafka_error_destroy().

Parameters: rk \FFI\CData|null rd_kafka_t* - Producer instance.; timeout_ms int|null int - The maximum time to block. On timeout the operation may continue in the background, depending on state, and it is okay to call init_transactions() again. If an infinite timeout (-1) is passed, the timeout will be adjusted to 2 * transaction.timeout.ms.
Returns: \FFI\CData|null rd_kafka_error_t* - NULL on success or an error object on failure. Check whether the returned error object permits retrying by calling rd_kafka_error_is_retriable(), or whether a fatal error has been raised by calling rd_kafka_error_is_fatal(). Error codes: RD_KAFKA_RESP_ERR__TIMED_OUT if the transaction coordinator could be not be contacted within timeout_ms (retriable), RD_KAFKA_RESP_ERR_COORDINATOR_NOT_AVAILABLE if the transaction coordinator is not available (retriable), RD_KAFKA_RESP_ERR_CONCURRENT_TRANSACTIONS if a previous transaction would not complete within timeout_ms (retriable), RD_KAFKA_RESP_ERR__STATE if transactions have already been started or upon fatal error, RD_KAFKA_RESP_ERR__UNSUPPORTED_FEATURE if the broker(s) do not support transactions (<Apache Kafka 0.11), this also raises a fatal error, RD_KAFKA_RESP_ERR_INVALID_TRANSACTION_TIMEOUT if the configured transaction.timeout.ms is outside the broker-configured range, this also raises a fatal error, RD_KAFKA_RESP_ERR__NOT_CONFIGURED if transactions have not been configured for the producer instance, RD_KAFKA_RESP_ERR__INVALID_ARG if rk is not a producer instance, or timeout_ms is out of range. Other error codes not listed here may be returned, depending on broker version.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#abf3e48791cf53ac2c7e30a17ce896f74

rd_kafka_interceptor_add_on_acknowledgement()¶

public static rd_kafka_interceptor_add_on_acknowledgement ( 
    \FFI\CData|null $rk, 
    string|null $ic_name, 
    \FFI\CData|\Closure $on_acknowledgement, 
    \FFI\CData|object|string|null $ic_opaque
 ): int

Append an on_acknowledgement() interceptor.

Parameters: rk \FFI\CData|null rd_kafka_t* - Client instance.; ic_name string|null const char* - Interceptor name, used in logging.; on_acknowledgement \FFI\CData|\Closure rd_kafka_resp_err_t(rd_kafka_interceptor_f_on_acknowledgement_t*)(rd_kafka_t*, rd_kafka_message_t*, void*) - Function pointer.; ic_opaque \FFI\CData|object|string|null void* - Opaque value that will be passed to the function.
Returns: int rd_kafka_resp_err_t - RD_KAFKA_RESP_ERR_NO_ERROR on success or RD_KAFKA_RESP_ERR__CONFLICT if an existing interceptor with the same ic_name and function has already been added to conf.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#abaf475ab47fff47ab796be1cecbbd370

rd_kafka_interceptor_add_on_broker_state_change()¶

public static rd_kafka_interceptor_add_on_broker_state_change ( 
    \FFI\CData|null $rk, 
    string|null $ic_name, 
    \FFI\CData|\Closure $on_broker_state_change, 
    \FFI\CData|object|string|null $ic_opaque
 ): int

Append an on_broker_state_change() interceptor.

Parameters: rk \FFI\CData|null rd_kafka_t* - Client instance.; ic_name string|null const char* - Interceptor name, used in logging.; on_broker_state_change \FFI\CData|\Closure rd_kafka_resp_err_t(rd_kafka_interceptor_f_on_broker_state_change_t*)(rd_kafka_t*, int32_t, const char*, const char*, int, const char*, void*); ic_opaque \FFI\CData|object|string|null void* - Opaque value that will be passed to the function.
Returns: int rd_kafka_resp_err_t - RD_KAFKA_RESP_ERR_NO_ERROR on success or RD_KAFKA_RESP_ERR__CONFLICT if an existing interceptor with the same ic_name and function has already been added to conf.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a2b53e29ee63067884bc8962e8637e82b

rd_kafka_interceptor_add_on_commit()¶

public static rd_kafka_interceptor_add_on_commit ( 
    \FFI\CData|null $rk, 
    string|null $ic_name, 
    \FFI\CData|\Closure $on_commit, 
    \FFI\CData|object|string|null $ic_opaque
 ): int

Append an on_commit() interceptor.

Parameters: rk \FFI\CData|null rd_kafka_t* - Client instance.; ic_name string|null const char* - Interceptor name, used in logging.; on_commit \FFI\CData|\Closure rd_kafka_resp_err_t(rd_kafka_interceptor_f_on_commit_t*)(rd_kafka_t*, const rd_kafka_topic_partition_list_t*, rd_kafka_resp_err_t, void*); ic_opaque \FFI\CData|object|string|null void* - Opaque value that will be passed to the function.
Returns: int rd_kafka_resp_err_t - RD_KAFKA_RESP_ERR_NO_ERROR on success or RD_KAFKA_RESP_ERR__CONFLICT if an existing interceptor with the same ic_name and function has already been added to conf.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a0d3e29337dbf11762b5a7e492b77b781

rd_kafka_interceptor_add_on_consume()¶

public static rd_kafka_interceptor_add_on_consume ( 
    \FFI\CData|null $rk, 
    string|null $ic_name, 
    \FFI\CData|\Closure $on_consume, 
    \FFI\CData|object|string|null $ic_opaque
 ): int

Append an on_consume() interceptor.

Parameters: rk \FFI\CData|null rd_kafka_t* - Client instance.; ic_name string|null const char* - Interceptor name, used in logging.; on_consume \FFI\CData|\Closure rd_kafka_resp_err_t(rd_kafka_interceptor_f_on_consume_t*)(rd_kafka_t*, rd_kafka_message_t*, void*) - Function pointer.; ic_opaque \FFI\CData|object|string|null void* - Opaque value that will be passed to the function.
Returns: int rd_kafka_resp_err_t - RD_KAFKA_RESP_ERR_NO_ERROR on success or RD_KAFKA_RESP_ERR__CONFLICT if an existing interceptor with the same ic_name and function has already been added to conf.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a0e722a9930897bba81b33de5fe95b6ed

rd_kafka_interceptor_add_on_destroy()¶

public static rd_kafka_interceptor_add_on_destroy ( 
    \FFI\CData|null $rk, 
    string|null $ic_name, 
    \FFI\CData|\Closure $on_destroy, 
    \FFI\CData|object|string|null $ic_opaque
 ): int

Append an on_destroy() interceptor.

Parameters: rk \FFI\CData|null rd_kafka_t* - Client instance.; ic_name string|null const char* - Interceptor name, used in logging.; on_destroy \FFI\CData|\Closure rd_kafka_resp_err_t(rd_kafka_interceptor_f_on_destroy_t*)(rd_kafka_t*, void*) - Function pointer.; ic_opaque \FFI\CData|object|string|null void* - Opaque value that will be passed to the function.
Returns: int rd_kafka_resp_err_t - RD_KAFKA_RESP_ERR_NO_ERROR on success or RD_KAFKA_RESP_ERR__CONFLICT if an existing interceptor with the same ic_name and function has already been added to conf.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a11b835cb99dc1cfa03c52465b9837a47

rd_kafka_interceptor_add_on_request_sent()¶

public static rd_kafka_interceptor_add_on_request_sent ( 
    \FFI\CData|null $rk, 
    string|null $ic_name, 
    \FFI\CData|\Closure $on_request_sent, 
    \FFI\CData|object|string|null $ic_opaque
 ): int

Append an on_request_sent() interceptor.

Parameters: rk \FFI\CData|null rd_kafka_t* - Client instance.; ic_name string|null const char* - Interceptor name, used in logging.; on_request_sent \FFI\CData|\Closure rd_kafka_resp_err_t(rd_kafka_interceptor_f_on_request_sent_t*)(rd_kafka_t*, int, const char*, int32_t, int16_t, int16_t, int32_t, size_t, void*); ic_opaque \FFI\CData|object|string|null void* - Opaque value that will be passed to the function.
Returns: int rd_kafka_resp_err_t - RD_KAFKA_RESP_ERR_NO_ERROR on success or RD_KAFKA_RESP_ERR__CONFLICT if an existing interceptor with the same ic_name and function has already been added to conf.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a444032455f98839bef2fb76d15f663c3

rd_kafka_interceptor_add_on_response_received()¶

public static rd_kafka_interceptor_add_on_response_received ( 
    \FFI\CData|null $rk, 
    string|null $ic_name, 
    \FFI\CData|\Closure $on_response_received, 
    \FFI\CData|object|string|null $ic_opaque
 ): int

Append an on_response_received() interceptor.

Parameters: rk \FFI\CData|null rd_kafka_t* - Client instance.; ic_name string|null const char* - Interceptor name, used in logging.; on_response_received \FFI\CData|\Closure rd_kafka_resp_err_t(rd_kafka_interceptor_f_on_response_received_t*)(rd_kafka_t*, int, const char*, int32_t, int16_t, int16_t, int32_t, size_t, int64_t, rd_kafka_resp_err_t, void*); ic_opaque \FFI\CData|object|string|null void* - Opaque value that will be passed to the function.
Returns: int rd_kafka_resp_err_t - RD_KAFKA_RESP_ERR_NO_ERROR on success or RD_KAFKA_RESP_ERR__CONFLICT if an existing interceptor with the same ic_name and function has already been added to conf.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a809061ceda162f8d8ad9663cabf66b3d

rd_kafka_interceptor_add_on_send()¶

public static rd_kafka_interceptor_add_on_send ( 
    \FFI\CData|null $rk, 
    string|null $ic_name, 
    \FFI\CData|\Closure $on_send, 
    \FFI\CData|object|string|null $ic_opaque
 ): int

Append an on_send() interceptor.

Parameters: rk \FFI\CData|null rd_kafka_t* - Client instance.; ic_name string|null const char* - Interceptor name, used in logging.; on_send \FFI\CData|\Closure rd_kafka_resp_err_t(rd_kafka_interceptor_f_on_send_t*)(rd_kafka_t*, rd_kafka_message_t*, void*) - Function pointer.; ic_opaque \FFI\CData|object|string|null void* - Opaque value that will be passed to the function.
Returns: int rd_kafka_resp_err_t - RD_KAFKA_RESP_ERR_NO_ERROR on success or RD_KAFKA_RESP_ERR__CONFLICT if an existing intercepted with the same ic_name and function has already been added to conf.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#af6fb1b8884444c63b6930a7bd6122cb6

rd_kafka_interceptor_add_on_thread_exit()¶

public static rd_kafka_interceptor_add_on_thread_exit ( 
    \FFI\CData|null $rk, 
    string|null $ic_name, 
    \FFI\CData|\Closure $on_thread_exit, 
    \FFI\CData|object|string|null $ic_opaque
 ): int

Append an on_thread_exit() interceptor.

Parameters: rk \FFI\CData|null rd_kafka_t* - Client instance.; ic_name string|null const char* - Interceptor name, used in logging.; on_thread_exit \FFI\CData|\Closure rd_kafka_resp_err_t(rd_kafka_interceptor_f_on_thread_exit_t*)(rd_kafka_t*, rd_kafka_thread_type_t, const char*, void*); ic_opaque \FFI\CData|object|string|null void* - Opaque value that will be passed to the function.
Returns: int rd_kafka_resp_err_t - RD_KAFKA_RESP_ERR_NO_ERROR on success or RD_KAFKA_RESP_ERR__CONFLICT if an existing interceptor with the same ic_name and function has already been added to conf.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a876a95f3d989ad7cbff048e3449674e6

rd_kafka_interceptor_add_on_thread_start()¶

public static rd_kafka_interceptor_add_on_thread_start ( 
    \FFI\CData|null $rk, 
    string|null $ic_name, 
    \FFI\CData|\Closure $on_thread_start, 
    \FFI\CData|object|string|null $ic_opaque
 ): int

Append an on_thread_start() interceptor.

Parameters: rk \FFI\CData|null rd_kafka_t* - Client instance.; ic_name string|null const char* - Interceptor name, used in logging.; on_thread_start \FFI\CData|\Closure rd_kafka_resp_err_t(rd_kafka_interceptor_f_on_thread_start_t*)(rd_kafka_t*, rd_kafka_thread_type_t, const char*, void*); ic_opaque \FFI\CData|object|string|null void* - Opaque value that will be passed to the function.
Returns: int rd_kafka_resp_err_t - RD_KAFKA_RESP_ERR_NO_ERROR on success or RD_KAFKA_RESP_ERR__CONFLICT if an existing interceptor with the same ic_name and function has already been added to conf.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#aa46a3bd81acc3861979f43b63f7ea1c8

rd_kafka_interceptor_f_on_acknowledgement_t()¶

public static rd_kafka_interceptor_f_on_acknowledgement_t ( 
    \FFI\CData|null $rk, 
    \FFI\CData|null $rkmessage, 
    \FFI\CData|object|string|null $ic_opaque
 ): int

on_acknowledgement() is called to inform interceptors that a message was succesfully delivered or permanently failed delivery. The interceptor chain is called from internal librdkafka background threads, or rd_kafka_produce*() if the partitioner failed.

Remarks: This interceptor is only used by producer instances.; The rkmessage object is NOT mutable and MUST NOT be modified by the interceptor.

Warning: The on_acknowledgement() method may be called from internal librdkafka threads. An on_acknowledgement() interceptor MUST NOT call any librdkafka API's associated with the rk, or perform any blocking or prolonged work.

Parameters: rk \FFI\CData|null rd_kafka_t* - The client instance.; rkmessage \FFI\CData|null rd_kafka_message_t* - The message being produced. Immutable.; ic_opaque \FFI\CData|object|string|null void* - The interceptor’s opaque pointer specified in ..add..().
Returns: int rd_kafka_resp_err_t - an error code on failure, the error is logged but otherwise ignored.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#aa654a84f20567004ab1df85f97f0ebf2

rd_kafka_interceptor_f_on_broker_state_change_t()¶

public static rd_kafka_interceptor_f_on_broker_state_change_t ( 
    \FFI\CData|null $rk, 
    int|null $broker_id, 
    string|null $secproto, 
    string|null $name, 
    int|null $port, 
    string|null $state, 
    \FFI\CData|object|string|null $ic_opaque
 ): int

on_broker_state_change() is called just after a broker has been created or its state has been changed.

Parameters: rk \FFI\CData|null rd_kafka_t* - The client instance.; broker_id int|null int32_t - The broker id (-1 is used for bootstrap brokers).; secproto string|null const char* - The security protocol.; name string|null const char* - The original name of the broker.; port int|null int - The port of the broker.; state string|null const char* - Broker state name.; ic_opaque \FFI\CData|object|string|null void* - The interceptor’s opaque pointer specified in ..add..().
Returns: int rd_kafka_resp_err_t - an error code on failure, the error is logged but otherwise ignored.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a50cb62229f969ac9d25d58c8d65950b9

rd_kafka_interceptor_f_on_commit_t()¶

public static rd_kafka_interceptor_f_on_commit_t ( 
    \FFI\CData|null $rk, 
    \FFI\CData|null $offsets, 
    int $err, 
    \FFI\CData|object|string|null $ic_opaque
 ): int

on_commit() is called on completed or failed offset commit. It is called from internal librdkafka threads.

Remarks: This interceptor is only used by consumer instances.

Warning: The on_commit() interceptor is called from internal librdkafka threads. An on_commit() interceptor MUST NOT call any librdkafka API's associated with the rk, or perform any blocking or prolonged work.

Parameters: rk \FFI\CData|null rd_kafka_t* - The client instance.; offsets \FFI\CData|null const rd_kafka_topic_partition_list_t* - List of topic+partition+offset+error that were committed. The error message of each partition should be checked for error.; err int rd_kafka_resp_err_t - The commit error, if any.; ic_opaque \FFI\CData|object|string|null void* - The interceptor’s opaque pointer specified in ..add..().
Returns: int rd_kafka_resp_err_t - an error code on failure, the error is logged but otherwise ignored.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a89c817cb2dd1a7b6a414a2f62c01fdcf

rd_kafka_interceptor_f_on_conf_destroy_t()¶

public static rd_kafka_interceptor_f_on_conf_destroy_t ( 
    \FFI\CData|object|string|null $ic_opaque
 ): int

on_conf_destroy() is called from rd_kafka_*_conf_destroy() in the order the interceptors were added.

Parameters: ic_opaque \FFI\CData|object|string|null void* - The interceptor’s opaque pointer specified in ..add..().
Returns: int rd_kafka_resp_err_t

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#afd1b354fab7374b77cf5e43c8a04c479

rd_kafka_interceptor_f_on_conf_dup_t()¶

public static rd_kafka_interceptor_f_on_conf_dup_t ( 
    \FFI\CData|null $new_conf, 
    \FFI\CData|null $old_conf, 
    int|null $filter_cnt, 
    \FFI\CData|null $filter, 
    \FFI\CData|object|string|null $ic_opaque
 ): int

on_conf_dup() is called from rd_kafka_conf_dup() in the order the interceptors were added and is used to let an interceptor re-register its conf interecptors with a new opaque value. The on_conf_dup() method is called prior to the configuration from old_conf being copied to new_conf.

Remarks: No on_conf_* interceptors are copied to the new configuration object on rd_kafka_conf_dup().

Parameters: new_conf \FFI\CData|null rd_kafka_conf_t* - New configuration object.; old_conf \FFI\CData|null const rd_kafka_conf_t* - Old configuration object to copy properties from.; filter_cnt int|null size_t - Number of property names to filter in filter. - Property names to filter out (ignore) when setting up new_conf.; filter \FFI\CData|null const char**; ic_opaque \FFI\CData|object|string|null void* - The interceptor’s opaque pointer specified in ..add..().
Returns: int rd_kafka_resp_err_t - RD_KAFKA_RESP_ERR_NO_ERROR on success or an error code on failure (which is logged but otherwise ignored).

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a166d8f2aea67064516b7995869af2411

rd_kafka_interceptor_f_on_conf_set_t()¶

public static rd_kafka_interceptor_f_on_conf_set_t ( 
    \FFI\CData|null $conf, 
    string|null $name, 
    string|null $val, 
    \FFI\CData|null $errstr, 
    int|null $errstr_size, 
    \FFI\CData|object|string|null $ic_opaque
 ): int

on_conf_set() is called from rd_kafka_*_conf_set() in the order the interceptors were added.

Parameters: conf \FFI\CData|null rd_kafka_conf_t* - Configuration object.; name string|null const char* - The configuration property to set.; val string|null const char* - The configuration value to set, or NULL for reverting to default in which case the previous value should be freed.; errstr \FFI\CData|null char* - A human readable error string in case the interceptor fails.; errstr_size int|null size_t - Maximum space (including \0) in errstr.; ic_opaque \FFI\CData|object|string|null void* - The interceptor’s opaque pointer specified in ..add..().
Returns: int rd_kafka_conf_res_t - RD_KAFKA_CONF_OK if the property was known and successfully handled by the interceptor, RD_KAFKA_CONF_INVALID if the property was handled by the interceptor but the value was invalid, or RD_KAFKA_CONF_UNKNOWN if the interceptor did not handle this property, in which case the property is passed on on the interceptor in the chain, finally ending up at the built-in configuration handler.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a6c1f90ab0ce78b28daa9ee27a682da10

rd_kafka_interceptor_f_on_consume_t()¶

public static rd_kafka_interceptor_f_on_consume_t ( 
    \FFI\CData|null $rk, 
    \FFI\CData|null $rkmessage, 
    \FFI\CData|object|string|null $ic_opaque
 ): int

on_consume() is called just prior to passing the message to the application in rd_kafka_consumer_poll(), rd_kafka_consume*(), the event interface, etc.

Remarks: This interceptor is only used by consumer instances.; The rkmessage object is NOT mutable and MUST NOT be modified by the interceptor.

Parameters: rk \FFI\CData|null rd_kafka_t* - The client instance.; rkmessage \FFI\CData|null rd_kafka_message_t* - The message being consumed. Immutable.; ic_opaque \FFI\CData|object|string|null void* - The interceptor’s opaque pointer specified in ..add..().
Returns: int rd_kafka_resp_err_t - an error code on failure, the error is logged but otherwise ignored.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ae31db94674004860fa545f3745497cfe

rd_kafka_interceptor_f_on_destroy_t()¶

public static rd_kafka_interceptor_f_on_destroy_t ( 
    \FFI\CData|null $rk, 
    \FFI\CData|object|string|null $ic_opaque
 ): int

on_destroy() is called from rd_kafka_destroy() or (rd_kafka_new() if rd_kafka_new() fails during initialization).

Parameters: rk \FFI\CData|null rd_kafka_t* - The client instance.; ic_opaque \FFI\CData|object|string|null void* - The interceptor’s opaque pointer specified in ..add..().
Returns: int rd_kafka_resp_err_t

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#aaea78073e1a749ee0a8eaedf2f7c21d4

rd_kafka_interceptor_f_on_new_t()¶

public static rd_kafka_interceptor_f_on_new_t ( 
    \FFI\CData|null $rk, 
    \FFI\CData|null $conf, 
    \FFI\CData|object|string|null $ic_opaque, 
    \FFI\CData|null $errstr, 
    int|null $errstr_size
 ): int

on_new() is called from rd_kafka_new() prior toreturning the newly created client instance to the application.

Warning: The rk client instance will not be fully set up when this interceptor is called and the interceptor MUST NOT call any other rk-specific APIs than rd_kafka_interceptor_add..().

Parameters: rk \FFI\CData|null rd_kafka_t* - The client instance.; conf \FFI\CData|null const rd_kafka_conf_t* - The client instance’s final configuration.; ic_opaque \FFI\CData|object|string|null void* - The interceptor’s opaque pointer specified in ..add..().; errstr \FFI\CData|null char* - A human readable error string in case the interceptor fails.; errstr_size int|null size_t - Maximum space (including \0) in errstr.
Returns: int rd_kafka_resp_err_t - an error code on failure, the error is logged but otherwise ignored.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a1dd51e3656e61b4a8d4475a3e0deaa10

rd_kafka_interceptor_f_on_request_sent_t()¶

public static rd_kafka_interceptor_f_on_request_sent_t ( 
    \FFI\CData|null $rk, 
    int|null $sockfd, 
    string|null $brokername, 
    int|null $brokerid, 
    int|null $ApiKey, 
    int|null $ApiVersion, 
    int|null $CorrId, 
    int|null $size, 
    \FFI\CData|object|string|null $ic_opaque
 ): int

on_request_sent() is called when a request has been fully written to a broker TCP connections socket.

Warning: The on_request_sent() interceptor is called from internal librdkafka broker threads. An on_request_sent() interceptor MUST NOT call any librdkafka API's associated with the rk, or perform any blocking or prolonged work.

Parameters: rk \FFI\CData|null rd_kafka_t* - The client instance.; sockfd int|null int - Socket file descriptor.; brokername string|null const char* - Broker request is being sent to.; brokerid int|null int32_t - Broker request is being sent to.; ApiKey int|null int16_t - Kafka protocol request type.; ApiVersion int|null int16_t - Kafka protocol request type version.; CorrId int|null int32_t - Kafka protocol request correlation id.; size int|null size_t - Size of request.; ic_opaque \FFI\CData|object|string|null void* - The interceptor’s opaque pointer specified in ..add..().
Returns: int rd_kafka_resp_err_t - an error code on failure, the error is logged but otherwise ignored.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a0b7f9b39e862802a6ccbac07bf848064

rd_kafka_interceptor_f_on_response_received_t()¶

public static rd_kafka_interceptor_f_on_response_received_t ( 
    \FFI\CData|null $rk, 
    int|null $sockfd, 
    string|null $brokername, 
    int|null $brokerid, 
    int|null $ApiKey, 
    int|null $ApiVersion, 
    int|null $CorrId, 
    int|null $size, 
    int|null $rtt, 
    int $err, 
    \FFI\CData|object|string|null $ic_opaque
 ): int

on_response_received() is called when a protocol response has been fully received from a broker TCP connection socket but before the response payload is parsed.

Warning: The on_response_received() interceptor is called from internal librdkafka broker threads. An on_response_received() interceptor MUST NOT call any librdkafka API's associated with the rk, or perform any blocking or prolonged work.

Parameters: rk \FFI\CData|null rd_kafka_t* - The client instance.; sockfd int|null int - Socket file descriptor (always -1).; brokername string|null const char* - Broker response was received from, possibly empty string on error.; brokerid int|null int32_t - Broker response was received from.; ApiKey int|null int16_t - Kafka protocol request type or -1 on error.; ApiVersion int|null int16_t - Kafka protocol request type version or -1 on error.; CorrId int|null int32_t - Kafka protocol request correlation id, possibly -1 on error.; size int|null size_t - Size of response, possibly 0 on error.; rtt int|null int64_t - Request round-trip-time in microseconds, possibly -1 on error.; err int rd_kafka_resp_err_t - Receive error.; ic_opaque \FFI\CData|object|string|null void* - The interceptor’s opaque pointer specified in ..add..().
Returns: int rd_kafka_resp_err_t - an error code on failure, the error is logged but otherwise ignored.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a8e6b3f288085b2495cec22bc912265b9

rd_kafka_interceptor_f_on_send_t()¶

public static rd_kafka_interceptor_f_on_send_t ( 
    \FFI\CData|null $rk, 
    \FFI\CData|null $rkmessage, 
    \FFI\CData|object|string|null $ic_opaque
 ): int

on_send() is called from rd_kafka_produce*() (et.al) prior to the partitioner being called.

Remarks: This interceptor is only used by producer instances.; The rkmessage object is NOT mutable and MUST NOT be modified by the interceptor.; If the partitioner fails or an unknown partition was specified, the on_acknowledgement() interceptor chain will be called from within the rd_kafka_produce*() call to maintain send-acknowledgement symmetry.

Parameters: rk \FFI\CData|null rd_kafka_t* - The client instance.; rkmessage \FFI\CData|null rd_kafka_message_t* - The message being produced. Immutable.; ic_opaque \FFI\CData|object|string|null void* - The interceptor’s opaque pointer specified in ..add..().
Returns: int rd_kafka_resp_err_t - an error code on failure, the error is logged but otherwise ignored.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a39c970fa80d4681d93332d3af4df5916

rd_kafka_interceptor_f_on_thread_exit_t()¶

public static rd_kafka_interceptor_f_on_thread_exit_t ( 
    \FFI\CData|null $rk, 
    int $thread_type, 
    string|null $thread_name, 
    \FFI\CData|object|string|null $ic_opaque
 ): int

on_thread_exit() is called just prior to a librdkafka-managed thread exiting from the exiting thread itself.

Remarks: Depending on the thread type, librdkafka may execute additional code on the thread after on_thread_exit() returns.

Warning: The on_thread_exit() interceptor is called from internal librdkafka threads. An on_thread_exit() interceptor MUST NOT call any librdkafka API's associated with the rk, or perform any blocking or prolonged work.

Parameters: rk \FFI\CData|null rd_kafka_t* - The client instance.; thread_type int rd_kafka_thread_type_t - Thread type.n; thread_name string|null const char* - Human-readable thread name, may not be unique.; ic_opaque \FFI\CData|object|string|null void* - The interceptor’s opaque pointer specified in ..add..().
Returns: int rd_kafka_resp_err_t - an error code on failure, the error is logged but otherwise ignored.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ae89a2054959ba519c3851889ee69576c

rd_kafka_interceptor_f_on_thread_start_t()¶

public static rd_kafka_interceptor_f_on_thread_start_t ( 
    \FFI\CData|null $rk, 
    int $thread_type, 
    string|null $thread_name, 
    \FFI\CData|object|string|null $ic_opaque
 ): int

on_thread_start() is called from a newly created librdkafka-managed thread.

Warning: The on_thread_start() interceptor is called from internal librdkafka threads. An on_thread_start() interceptor MUST NOT call any librdkafka API's associated with the rk, or perform any blocking or prolonged work.

Parameters: rk \FFI\CData|null rd_kafka_t* - The client instance.; thread_type int rd_kafka_thread_type_t - Thread type.; thread_name string|null const char* - Human-readable thread name, may not be unique.; ic_opaque \FFI\CData|object|string|null void* - The interceptor’s opaque pointer specified in ..add..().
Returns: int rd_kafka_resp_err_t - an error code on failure, the error is logged but otherwise ignored.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#aa882b123107dd0fecca114dea26a4c18

rd_kafka_last_error()¶

public static rd_kafka_last_error (  ): int

Returns the last error code generated by a legacy API call in the current thread.

The legacy APIs are the ones using errno to propagate error value, namely:

rd_kafka_topic_new()
rd_kafka_consume_start()
rd_kafka_consume_stop()
rd_kafka_consume()
rd_kafka_consume_batch()
rd_kafka_consume_callback()
rd_kafka_consume_queue()
rd_kafka_produce()

The main use for this function is to avoid converting system errno values to rd_kafka_resp_err_t codes for legacy APIs.

Remarks: The last error is stored per-thread, if multiple rd_kafka_t handles are used in the same application thread the developer needs to make sure rd_kafka_last_error() is called immediately after a failed API call.; errno propagation from librdkafka is not safe on Windows and should not be used, use rd_kafka_last_error() instead.

Returns: int rd_kafka_resp_err_t - )

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ae7b90c323d460e0276d79f6ab69e93b7

rd_kafka_list_groups()¶

public static rd_kafka_list_groups ( 
    \FFI\CData|null $rk, 
    string|null $group, 
    \FFI\CData|null $grplistp, 
    int|null $timeout_ms
 ): int

List and describe client groups in cluster.

group is an optional group name to describe, otherwise (NULL) all groups are returned.

timeout_ms is the (approximate) maximum time to wait for response from brokers and must be a positive value.

The grplistp remains untouched if any error code is returned, with the exception of RD_KAFKA_RESP_ERR__PARTIAL which behaves as RD_KAFKA_RESP_ERR__NO_ERROR (success) but with an incomplete group list.

See also: Use rd_kafka_group_list_destroy() to release list memory.

Deprecated:: Use rd_kafka_ListConsumerGroups() and rd_kafka_DescribeConsumerGroups() instead.

Parameters: rk \FFI\CData|null rd_kafka_t*; group string|null const char*; grplistp \FFI\CData|null const struct rd_kafka_group_list**; timeout_ms int|null int
Returns: int rd_kafka_resp_err_t - RD_KAFKA_RESP_ERR__NO_ERROR on success and grplistp is updated to point to a newly allocated list of groups. RD_KAFKA_RESP_ERR__PARTIAL if not all brokers responded in time but at least one group is returned in grplistlp. RD_KAFKA_RESP_ERR__TIMED_OUT if no groups were returned in the given timeframe but not all brokers have yet responded, or if the list of brokers in the cluster could not be obtained within the given timeframe. RD_KAFKA_RESP_ERR__TRANSPORT if no brokers were found. Other error codes may also be returned from the request layer.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a6cfc79819453ecd4aa94fbae6dbbea0a

rd_kafka_log_print()¶

public static rd_kafka_log_print ( 
    \FFI\CData|null $rk, 
    int|null $level, 
    string|null $fac, 
    string|null $buf
 ): void

Parameters: rk \FFI\CData|null const rd_kafka_t*; level int|null int; fac string|null const char*; buf string|null const char*

rd_kafka_log_syslog()¶

public static rd_kafka_log_syslog ( 
    \FFI\CData|null $rk, 
    int|null $level, 
    string|null $fac, 
    string|null $buf
 ): void

Builtin log sink: print to syslog.

Remarks: This logger is only available if librdkafka was built with syslog support.

Parameters: rk \FFI\CData|null const rd_kafka_t*; level int|null int; fac string|null const char*; buf string|null const char*

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a748d5eaca75f94bb4ff4217ae824385d

rd_kafka_mem_calloc()¶

public static rd_kafka_mem_calloc ( 
    \FFI\CData|null $rk, 
    int|null $num, 
    int|null $size
 ): \FFI\CData|object|string|null

Allocate and zero memory using the same allocator librdkafka uses.

This is typically an abstraction for the calloc(3) call and makes sure the application can use the same memory allocator as librdkafka for allocating pointers that are used by librdkafka.

rk can be set to return memory allocated by a specific rk instance otherwise pass NULL for rk.

Remarks: Memory allocated by rd_kafka_mem_calloc() must be freed using rd_kafka_mem_free()

Parameters: rk \FFI\CData|null rd_kafka_t*; num int|null size_t; size int|null size_t
Returns: \FFI\CData|object|string|null void*

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a74216ba5f5d1c1d8ec7936c225a73286

rd_kafka_mem_free()¶

public static rd_kafka_mem_free ( 
    \FFI\CData|null $rk, 
    \FFI\CData|object|string|null $ptr
 ): void

Free pointer returned by librdkafka.

This is typically an abstraction for the free(3) call and makes sure the application can use the same memory allocator as librdkafka for freeing pointers returned by librdkafka.

In standard setups it is usually not necessary to use this interface rather than the free(3) functione.

rk must be set for memory returned by APIs that take an rk argument, for other APIs pass NULL for rk.

Remarks: rd_kafka_mem_free() must only be used for pointers returned by APIs that explicitly mention using this function for freeing.

Parameters: rk \FFI\CData|null rd_kafka_t*; ptr \FFI\CData|object|string|null void*

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a50178b3d3266c9eeb0b5981377833572

rd_kafka_mem_malloc()¶

public static rd_kafka_mem_malloc ( 
    \FFI\CData|null $rk, 
    int|null $size
 ): \FFI\CData|object|string|null

Allocate memory using the same allocator librdkafka uses.

This is typically an abstraction for the malloc(3) call and makes sure the application can use the same memory allocator as librdkafka for allocating pointers that are used by librdkafka.

rk can be set to return memory allocated by a specific rk instance otherwise pass NULL for rk.

Remarks: Memory allocated by rd_kafka_mem_malloc() must be freed using rd_kafka_mem_free()

Parameters: rk \FFI\CData|null rd_kafka_t*; size int|null size_t
Returns: \FFI\CData|object|string|null void*

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a60f3ac40bed72542f68c93fa1bc16d3e

rd_kafka_memberid()¶

public static rd_kafka_memberid ( 
    \FFI\CData|null $rk
 ): \FFI\CData|null

Returns this client's broker-assigned group member id.

Remarks: This currently requires the high-level KafkaConsumer

Parameters: rk \FFI\CData|null const rd_kafka_t* - )
Returns: \FFI\CData|null char* - An allocated string containing the current broker-assigned group member id, or NULL if not available. The application must free the string with free() or rd_kafka_mem_free()

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a856d7ecba1aa64e5c89ac92b445cdda6

rd_kafka_message_broker_id()¶

public static rd_kafka_message_broker_id ( 
    \FFI\CData|null $rkmessage
 ): int|null

Returns the broker id of the broker the message was produced to or fetched from.

Parameters: rkmessage \FFI\CData|null const rd_kafka_message_t* - )
Returns: int|null int32_t - a broker id if known, else -1.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#aa3ea50bbfa8d7fce4de91a34b1377b52

rd_kafka_message_destroy()¶

public static rd_kafka_message_destroy ( 
    \FFI\CData|null $rkmessage
 ): void

Parameters: rkmessage \FFI\CData|null rd_kafka_message_t*

rd_kafka_message_detach_headers()¶

public static rd_kafka_message_detach_headers ( 
    \FFI\CData|null $rkmessage, 
    \FFI\CData|null $hdrsp
 ): int

Get the message header list and detach the list from the message making the application the owner of the headers. The application must eventually destroy the headers using rd_kafka_headers_destroy(). The message's headers will be set to NULL.

Otherwise same semantics as rd_kafka_message_headers()

See also: rd_kafka_message_headers

Parameters: rkmessage \FFI\CData|null rd_kafka_message_t*; hdrsp \FFI\CData|null rd_kafka_headers_t**
Returns: int rd_kafka_resp_err_t

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#af89ef912d3c1ff66ea612fda27c0a643

rd_kafka_message_errstr()¶

public static rd_kafka_message_errstr ( 
    \FFI\CData|null $rkmessage
 ): string|null

Returns the error string for an errored rd_kafka_message_t or NULL if there was no error.

Remarks: This function MUST NOT be used with the producer.

Parameters: rkmessage \FFI\CData|null const rd_kafka_message_t* - )
Returns: string|null const char*

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a4d06383f90911ab9257bc468053bfa36

rd_kafka_message_headers()¶

public static rd_kafka_message_headers ( 
    \FFI\CData|null $rkmessage, 
    \FFI\CData|null $hdrsp
 ): int

Get the message header list.

The returned pointer in *hdrsp is associated with the rkmessage and must not be used after destruction of the message object or the header list is replaced with rd_kafka_message_set_headers().

Remarks: Headers require broker version 0.11.0.0 or later.; As an optimization the raw protocol headers are parsed on the first call to this function.

Parameters: rkmessage \FFI\CData|null const rd_kafka_message_t*; hdrsp \FFI\CData|null rd_kafka_headers_t**
Returns: int rd_kafka_resp_err_t - RD_KAFKA_RESP_ERR_NO_ERROR if headers were returned, RD_KAFKA_RESP_ERR__NOENT if the message has no headers, or another error code if the headers could not be parsed.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#aaccd9ee7e1c73b89d86ed41db3b86e68

rd_kafka_message_latency()¶

public static rd_kafka_message_latency ( 
    \FFI\CData|null $rkmessage
 ): int|null

Returns the latency for a produced message measured from the produce() call.

Parameters: rkmessage \FFI\CData|null const rd_kafka_message_t* - )
Returns: int|null int64_t - the latency in microseconds, or -1 if not available.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#aba20435b42efef7a3c38dee3fb58c27b

rd_kafka_message_leader_epoch()¶

public static rd_kafka_message_leader_epoch ( 
    \FFI\CData|null $rkmessage
 ): int|null

Remarks: This API must only be used on consumed messages without error.; Requires broker version >= 2.10 (KIP-320).

Parameters: rkmessage \FFI\CData|null const rd_kafka_message_t* - )
Returns: int|null int32_t - the message’s partition leader epoch at the time the message was fetched and if known, else -1.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ad9afdf40e60628338c3efcacba4727a2

rd_kafka_message_produce_errstr()¶

public static rd_kafka_message_produce_errstr ( 
    \FFI\CData|null $rkmessage
 ): string|null

Returns the error string for an errored produced rd_kafka_message_t or NULL if there was no error.

Remarks: This function MUST used with the producer.

Parameters: rkmessage \FFI\CData|null const rd_kafka_message_t* - )
Returns: string|null const char*

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a93122a1eaa68bcc9ae33bf3f75cde040

rd_kafka_message_set_headers()¶

public static rd_kafka_message_set_headers ( 
    \FFI\CData|null $rkmessage, 
    \FFI\CData|null $hdrs
 ): void

Replace the message's current headers with a new list.

Remarks: The existing headers object, if any, will be destroyed.

Parameters: rkmessage \FFI\CData|null rd_kafka_message_t* - The message to set headers.; hdrs \FFI\CData|null rd_kafka_headers_t* - New header list. The message object assumes ownership of the list, the list will be destroyed automatically with the message object. The new headers list may be updated until the message object is passed or returned to librdkafka.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a99e46233e57fc4f5783d8ae374584bbe

rd_kafka_message_status()¶

public static rd_kafka_message_status ( 
    \FFI\CData|null $rkmessage
 ): int

Returns the message's persistence status in the topic log.

Remarks: The message status is not available in on_acknowledgement interceptors.

Parameters: rkmessage \FFI\CData|null const rd_kafka_message_t* - )
Returns: int rd_kafka_msg_status_t

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#af259b9c4216b74d4f750d93ff6396ce5

rd_kafka_message_timestamp()¶

public static rd_kafka_message_timestamp ( 
    \FFI\CData|null $rkmessage, 
    \FFI\CData|null $tstype
 ): int|null

Returns the message timestamp for a consumed message.

The timestamp is the number of milliseconds since the epoch (UTC).

tstype (if not NULL) is updated to indicate the type of timestamp.

Remarks: Message timestamps require broker version 0.10.0 or later.

Parameters: rkmessage \FFI\CData|null const rd_kafka_message_t*; tstype \FFI\CData|null rd_kafka_timestamp_type_t*
Returns: int|null int64_t - message timestamp, or -1 if not available.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a4371deba4afe6941cc5f9e80df5ca3e7

rd_kafka_metadata()¶

public static rd_kafka_metadata ( 
    \FFI\CData|null $rk, 
    int|null $all_topics, 
    \FFI\CData|null $only_rkt, 
    \FFI\CData|null $metadatap, 
    int|null $timeout_ms
 ): int

Request Metadata from broker.

Parameters:

all_topics if non-zero: request info about all topics in cluster, if zero: only request info about locally known topics.
only_rkt only request info about this topic
metadatap pointer to hold metadata result. The *metadatap pointer must be released with rd_kafka_metadata_destroy().
timeout_ms maximum response time before failing.

Remarks: Consumer: If all_topics is non-zero the Metadata response information may trigger a re-join if any subscribed topics have changed partition count or existence state.

Parameters: rk \FFI\CData|null rd_kafka_t*; all_topics int|null int; only_rkt \FFI\CData|null rd_kafka_topic_t*; metadatap \FFI\CData|null const struct rd_kafka_metadata**; timeout_ms int|null int
Returns: int rd_kafka_resp_err_t - RD_KAFKA_RESP_ERR_NO_ERROR on success (in which case *metadatap) will be set, else RD_KAFKA_RESP_ERR__TIMED_OUT on timeout or other error code on error.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a84bba4a4b13fdb515f1a22d6fd4f7344

rd_kafka_metadata_destroy()¶

public static rd_kafka_metadata_destroy ( 
    \FFI\CData|\Closure $metadata
 ): void

Parameters: metadata \FFI\CData|\Closure rd_kafka_resp_err_t(rd_kafka_metadata*)(rd_kafka_t*, int, rd_kafka_topic_t*, const struct rd_kafka_metadata**, int)

rd_kafka_mock_broker_error_stack_cnt()¶

public static rd_kafka_mock_broker_error_stack_cnt ( 
    \FFI\CData|null $mcluster, 
    int|null $broker_id, 
    int|null $ApiKey, 
    \FFI\CData|null $cntp
 ): int

Parameters: mcluster \FFI\CData|null rd_kafka_mock_cluster_t*; broker_id int|null int32_t; ApiKey int|null int16_t; cntp \FFI\CData|null size_t*
Returns: int rd_kafka_resp_err_t

rd_kafka_mock_broker_push_request_error_rtts()¶

public static rd_kafka_mock_broker_push_request_error_rtts ( 
    \FFI\CData|null $mcluster, 
    int|null $broker_id, 
    int|null $ApiKey, 
    int|null $cnt, 
    mixed $args
 ): int

Parameters: mcluster \FFI\CData|null rd_kafka_mock_cluster_t*; broker_id int|null int32_t; ApiKey int|null int16_t; cnt int|null size_t; args mixed
Returns: int rd_kafka_resp_err_t

rd_kafka_mock_broker_push_request_errors()¶

public static rd_kafka_mock_broker_push_request_errors ( 
    \FFI\CData|null $mcluster, 
    int|null $broker_id, 
    int|null $ApiKey, 
    int|null $cnt, 
    mixed $args
 ): int

Parameters: mcluster \FFI\CData|null rd_kafka_mock_cluster_t*; broker_id int|null int32_t; ApiKey int|null int16_t; cnt int|null size_t; args mixed
Returns: int rd_kafka_resp_err_t

rd_kafka_mock_broker_set_down()¶

public static rd_kafka_mock_broker_set_down ( 
    \FFI\CData|null $mcluster, 
    int|null $broker_id
 ): int

Parameters: mcluster \FFI\CData|null rd_kafka_mock_cluster_t*; broker_id int|null int32_t
Returns: int rd_kafka_resp_err_t

rd_kafka_mock_broker_set_rack()¶

public static rd_kafka_mock_broker_set_rack ( 
    \FFI\CData|null $mcluster, 
    int|null $broker_id, 
    string|null $rack
 ): int

Parameters: mcluster \FFI\CData|null rd_kafka_mock_cluster_t*; broker_id int|null int32_t; rack string|null const char*
Returns: int rd_kafka_resp_err_t

rd_kafka_mock_broker_set_rtt()¶

public static rd_kafka_mock_broker_set_rtt ( 
    \FFI\CData|null $mcluster, 
    int|null $broker_id, 
    int|null $rtt_ms
 ): int

Parameters: mcluster \FFI\CData|null rd_kafka_mock_cluster_t*; broker_id int|null int32_t; rtt_ms int|null int
Returns: int rd_kafka_resp_err_t

rd_kafka_mock_broker_set_up()¶

public static rd_kafka_mock_broker_set_up ( 
    \FFI\CData|null $mcluster, 
    int|null $broker_id
 ): int

Parameters: mcluster \FFI\CData|null rd_kafka_mock_cluster_t*; broker_id int|null int32_t
Returns: int rd_kafka_resp_err_t

rd_kafka_mock_clear_request_errors()¶

public static rd_kafka_mock_clear_request_errors ( 
    \FFI\CData|null $mcluster, 
    int|null $ApiKey
 ): void

Parameters: mcluster \FFI\CData|null rd_kafka_mock_cluster_t*; ApiKey int|null int16_t

rd_kafka_mock_clear_requests()¶

public static rd_kafka_mock_clear_requests ( 
    \FFI\CData|null $mcluster
 ): void

Parameters: mcluster \FFI\CData|null rd_kafka_mock_cluster_t*

rd_kafka_mock_cluster_bootstraps()¶

public static rd_kafka_mock_cluster_bootstraps ( 
    \FFI\CData|null $mcluster
 ): string|null

Parameters: mcluster \FFI\CData|null const rd_kafka_mock_cluster_t*
Returns: string|null const char*

rd_kafka_mock_cluster_destroy()¶

public static rd_kafka_mock_cluster_destroy ( 
    \FFI\CData|null $mcluster
 ): void

Parameters: mcluster \FFI\CData|null rd_kafka_mock_cluster_t*

rd_kafka_mock_cluster_handle()¶

public static rd_kafka_mock_cluster_handle ( 
    \FFI\CData|null $mcluster
 ): \FFI\CData|null

Parameters: mcluster \FFI\CData|null const rd_kafka_mock_cluster_t*
Returns: \FFI\CData|null rd_kafka_t*

rd_kafka_mock_cluster_new()¶

public static rd_kafka_mock_cluster_new ( 
    \FFI\CData|null $rk, 
    int|null $broker_cnt
 ): \FFI\CData|null

Parameters: rk \FFI\CData|null rd_kafka_t*; broker_cnt int|null int
Returns: \FFI\CData|null rd_kafka_mock_cluster_t*

rd_kafka_mock_coordinator_set()¶

public static rd_kafka_mock_coordinator_set ( 
    \FFI\CData|null $mcluster, 
    string|null $key_type, 
    string|null $key, 
    int|null $broker_id
 ): int

Parameters: mcluster \FFI\CData|null rd_kafka_mock_cluster_t*; key_type string|null const char*; key string|null const char*; broker_id int|null int32_t
Returns: int rd_kafka_resp_err_t

rd_kafka_mock_get_requests()¶

public static rd_kafka_mock_get_requests ( 
    \FFI\CData|null $mcluster, 
    \FFI\CData|null $cntp
 ): \FFI\CData|null

Parameters: mcluster \FFI\CData|null rd_kafka_mock_cluster_t*; cntp \FFI\CData|null size_t*
Returns: \FFI\CData|null rd_kafka_mock_request_t**

rd_kafka_mock_group_initial_rebalance_delay_ms()¶

public static rd_kafka_mock_group_initial_rebalance_delay_ms ( 
    \FFI\CData|null $mcluster, 
    int|null $delay_ms
 ): void

Parameters: mcluster \FFI\CData|null rd_kafka_mock_cluster_t*; delay_ms int|null int32_t

rd_kafka_mock_partition_push_leader_response()¶

public static rd_kafka_mock_partition_push_leader_response ( 
    \FFI\CData|null $mcluster, 
    string|null $topic, 
    int|null $partition, 
    int|null $leader_id, 
    int|null $leader_epoch
 ): int

Parameters: mcluster \FFI\CData|null rd_kafka_mock_cluster_t*; topic string|null const char*; partition int|null int; leader_id int|null int32_t; leader_epoch int|null int32_t
Returns: int rd_kafka_resp_err_t

rd_kafka_mock_partition_set_follower()¶

public static rd_kafka_mock_partition_set_follower ( 
    \FFI\CData|null $mcluster, 
    string|null $topic, 
    int|null $partition, 
    int|null $broker_id
 ): int

Parameters: mcluster \FFI\CData|null rd_kafka_mock_cluster_t*; topic string|null const char*; partition int|null int32_t; broker_id int|null int32_t
Returns: int rd_kafka_resp_err_t

rd_kafka_mock_partition_set_follower_wmarks()¶

public static rd_kafka_mock_partition_set_follower_wmarks ( 
    \FFI\CData|null $mcluster, 
    string|null $topic, 
    int|null $partition, 
    int|null $lo, 
    int|null $hi
 ): int

Parameters: mcluster \FFI\CData|null rd_kafka_mock_cluster_t*; topic string|null const char*; partition int|null int32_t; lo int|null int64_t; hi int|null int64_t
Returns: int rd_kafka_resp_err_t

rd_kafka_mock_partition_set_leader()¶

public static rd_kafka_mock_partition_set_leader ( 
    \FFI\CData|null $mcluster, 
    string|null $topic, 
    int|null $partition, 
    int|null $broker_id
 ): int

Parameters: mcluster \FFI\CData|null rd_kafka_mock_cluster_t*; topic string|null const char*; partition int|null int32_t; broker_id int|null int32_t
Returns: int rd_kafka_resp_err_t

rd_kafka_mock_push_request_errors()¶

public static rd_kafka_mock_push_request_errors ( 
    \FFI\CData|null $mcluster, 
    int|null $ApiKey, 
    int|null $cnt, 
    mixed $args
 ): void

Parameters: mcluster \FFI\CData|null rd_kafka_mock_cluster_t*; ApiKey int|null int16_t; cnt int|null size_t; args mixed

rd_kafka_mock_push_request_errors_array()¶

public static rd_kafka_mock_push_request_errors_array ( 
    \FFI\CData|null $mcluster, 
    int|null $ApiKey, 
    int|null $cnt, 
    \FFI\CData|null $errors
 ): void

Parameters: mcluster \FFI\CData|null rd_kafka_mock_cluster_t*; ApiKey int|null int16_t; cnt int|null size_t; errors \FFI\CData|null const rd_kafka_resp_err_t*

rd_kafka_mock_request_api_key()¶

public static rd_kafka_mock_request_api_key ( 
    \FFI\CData|null $mreq
 ): int|null

Parameters: mreq \FFI\CData|null rd_kafka_mock_request_t*
Returns: int|null int16_t

rd_kafka_mock_request_destroy()¶

public static rd_kafka_mock_request_destroy ( 
    \FFI\CData|null $mreq
 ): void

Parameters: mreq \FFI\CData|null rd_kafka_mock_request_t*

rd_kafka_mock_request_destroy_array()¶

public static rd_kafka_mock_request_destroy_array ( 
    \FFI\CData|null $mreqs, 
    int|null $mreq_cnt
 ): void

Parameters: mreqs \FFI\CData|null rd_kafka_mock_request_t**; mreq_cnt int|null size_t

rd_kafka_mock_request_id()¶

public static rd_kafka_mock_request_id ( 
    \FFI\CData|null $mreq
 ): int|null

Parameters: mreq \FFI\CData|null rd_kafka_mock_request_t*
Returns: int|null int32_t

rd_kafka_mock_request_timestamp()¶

public static rd_kafka_mock_request_timestamp ( 
    \FFI\CData|null $mreq
 ): int|null

Parameters: mreq \FFI\CData|null rd_kafka_mock_request_t*
Returns: int|null int64_t

rd_kafka_mock_set_apiversion()¶

public static rd_kafka_mock_set_apiversion ( 
    \FFI\CData|null $mcluster, 
    int|null $ApiKey, 
    int|null $MinVersion, 
    int|null $MaxVersion
 ): int

Parameters: mcluster \FFI\CData|null rd_kafka_mock_cluster_t*; ApiKey int|null int16_t; MinVersion int|null int16_t; MaxVersion int|null int16_t
Returns: int rd_kafka_resp_err_t

rd_kafka_mock_start_request_tracking()¶

public static rd_kafka_mock_start_request_tracking ( 
    \FFI\CData|null $mcluster
 ): void

Parameters: mcluster \FFI\CData|null rd_kafka_mock_cluster_t*

rd_kafka_mock_stop_request_tracking()¶

public static rd_kafka_mock_stop_request_tracking ( 
    \FFI\CData|null $mcluster
 ): void

Parameters: mcluster \FFI\CData|null rd_kafka_mock_cluster_t*

rd_kafka_mock_telemetry_set_push_interval()¶

public static rd_kafka_mock_telemetry_set_push_interval ( 
    \FFI\CData|null $mcluster, 
    int|null $push_interval_ms
 ): int

Parameters: mcluster \FFI\CData|null rd_kafka_mock_cluster_t*; push_interval_ms int|null int64_t
Returns: int rd_kafka_resp_err_t

rd_kafka_mock_telemetry_set_requested_metrics()¶

public static rd_kafka_mock_telemetry_set_requested_metrics ( 
    \FFI\CData|null $mcluster, 
    \FFI\CData|null $metrics, 
    int|null $metrics_cnt
 ): int

Parameters: mcluster \FFI\CData|null rd_kafka_mock_cluster_t*; metrics \FFI\CData|null char**; metrics_cnt int|null size_t
Returns: int rd_kafka_resp_err_t

rd_kafka_mock_topic_create()¶

public static rd_kafka_mock_topic_create ( 
    \FFI\CData|null $mcluster, 
    string|null $topic, 
    int|null $partition_cnt, 
    int|null $replication_factor
 ): int

Parameters: mcluster \FFI\CData|null rd_kafka_mock_cluster_t*; topic string|null const char*; partition_cnt int|null int; replication_factor int|null int
Returns: int rd_kafka_resp_err_t

rd_kafka_mock_topic_set_error()¶

public static rd_kafka_mock_topic_set_error ( 
    \FFI\CData|null $mcluster, 
    string|null $topic, 
    int $err
 ): void

Parameters: mcluster \FFI\CData|null rd_kafka_mock_cluster_t*; topic string|null const char*; err int rd_kafka_resp_err_t

rd_kafka_msg_partitioner_consistent()¶

public static rd_kafka_msg_partitioner_consistent ( 
    \FFI\CData|null $rkt, 
    \FFI\CData|object|string|null $key, 
    int|null $keylen, 
    int|null $partition_cnt, 
    \FFI\CData|object|string|null $opaque, 
    \FFI\CData|object|string|null $msg_opaque
 ): int|null

Consistent partitioner.

Uses consistent hashing to map identical keys onto identical partitions.

The rkt_opaque argument is the opaque set by rd_kafka_topic_conf_set_opaque(). The msg_opaque argument is the per-message opaque passed to produce().

Parameters: rkt \FFI\CData|null const rd_kafka_topic_t*; key \FFI\CData|object|string|null const void*; keylen int|null size_t; partition_cnt int|null int32_t; opaque \FFI\CData|object|string|null void*; msg_opaque \FFI\CData|object|string|null void*
Returns: int|null int32_t - a “random” partition between 0 and partition_cnt - 1 based on the CRC value of the key

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#aac74a45b5ce46035782198f683b22363

rd_kafka_msg_partitioner_consistent_random()¶

public static rd_kafka_msg_partitioner_consistent_random ( 
    \FFI\CData|null $rkt, 
    \FFI\CData|object|string|null $key, 
    int|null $keylen, 
    int|null $partition_cnt, 
    \FFI\CData|object|string|null $opaque, 
    \FFI\CData|object|string|null $msg_opaque
 ): int|null

Consistent-Random partitioner.

This is the default partitioner. Uses consistent hashing to map identical keys onto identical partitions, and messages without keys will be assigned via the random partitioner.

The rkt_opaque argument is the opaque set by rd_kafka_topic_conf_set_opaque(). The msg_opaque argument is the per-message opaque passed to produce().

Parameters: rkt \FFI\CData|null const rd_kafka_topic_t*; key \FFI\CData|object|string|null const void*; keylen int|null size_t; partition_cnt int|null int32_t; opaque \FFI\CData|object|string|null void*; msg_opaque \FFI\CData|object|string|null void*
Returns: int|null int32_t - a “random” partition between 0 and partition_cnt - 1 based on the CRC value of the key (if provided)

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#aed746103dc635aa591658f98a1707e57

rd_kafka_msg_partitioner_fnv1a()¶

public static rd_kafka_msg_partitioner_fnv1a ( 
    \FFI\CData|null $rkt, 
    \FFI\CData|object|string|null $key, 
    int|null $keylen, 
    int|null $partition_cnt, 
    \FFI\CData|object|string|null $rkt_opaque, 
    \FFI\CData|object|string|null $msg_opaque
 ): int|null

FNV-1a partitioner.

Uses consistent hashing to map identical keys onto identical partitions using FNV-1a hashing.

The rkt_opaque argument is the opaque set by rd_kafka_topic_conf_set_opaque(). The msg_opaque argument is the per-message opaque passed to produce().

Parameters: rkt \FFI\CData|null const rd_kafka_topic_t*; key \FFI\CData|object|string|null const void*; keylen int|null size_t; partition_cnt int|null int32_t; rkt_opaque \FFI\CData|object|string|null void*; msg_opaque \FFI\CData|object|string|null void*
Returns: int|null int32_t - a partition between 0 and partition_cnt - 1.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#abf216e03c718df36bb37e1affbc8c8f7

rd_kafka_msg_partitioner_fnv1a_random()¶

public static rd_kafka_msg_partitioner_fnv1a_random ( 
    \FFI\CData|null $rkt, 
    \FFI\CData|object|string|null $key, 
    int|null $keylen, 
    int|null $partition_cnt, 
    \FFI\CData|object|string|null $rkt_opaque, 
    \FFI\CData|object|string|null $msg_opaque
 ): int|null

Consistent-Random FNV-1a partitioner.

Uses consistent hashing to map identical keys onto identical partitions using FNV-1a hashing. Messages without keys will be assigned via the random partitioner.

The rkt_opaque argument is the opaque set by rd_kafka_topic_conf_set_opaque(). The msg_opaque argument is the per-message opaque passed to produce().

Parameters: rkt \FFI\CData|null const rd_kafka_topic_t*; key \FFI\CData|object|string|null const void*; keylen int|null size_t; partition_cnt int|null int32_t; rkt_opaque \FFI\CData|object|string|null void*; msg_opaque \FFI\CData|object|string|null void*
Returns: int|null int32_t - a partition between 0 and partition_cnt - 1.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ac6bbf5fabd7def78d9d0677af2d383b0

rd_kafka_msg_partitioner_murmur2()¶

public static rd_kafka_msg_partitioner_murmur2 ( 
    \FFI\CData|null $rkt, 
    \FFI\CData|object|string|null $key, 
    int|null $keylen, 
    int|null $partition_cnt, 
    \FFI\CData|object|string|null $rkt_opaque, 
    \FFI\CData|object|string|null $msg_opaque
 ): int|null

Murmur2 partitioner (Java compatible).

Uses consistent hashing to map identical keys onto identical partitions using Java-compatible Murmur2 hashing.

The rkt_opaque argument is the opaque set by rd_kafka_topic_conf_set_opaque(). The msg_opaque argument is the per-message opaque passed to produce().

Parameters: rkt \FFI\CData|null const rd_kafka_topic_t*; key \FFI\CData|object|string|null const void*; keylen int|null size_t; partition_cnt int|null int32_t; rkt_opaque \FFI\CData|object|string|null void*; msg_opaque \FFI\CData|object|string|null void*
Returns: int|null int32_t - a partition between 0 and partition_cnt - 1.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a009f294dc88a214850760216d3fe2d5f

rd_kafka_msg_partitioner_murmur2_random()¶

public static rd_kafka_msg_partitioner_murmur2_random ( 
    \FFI\CData|null $rkt, 
    \FFI\CData|object|string|null $key, 
    int|null $keylen, 
    int|null $partition_cnt, 
    \FFI\CData|object|string|null $rkt_opaque, 
    \FFI\CData|object|string|null $msg_opaque
 ): int|null

Consistent-Random Murmur2 partitioner (Java compatible).

Uses consistent hashing to map identical keys onto identical partitions using Java-compatible Murmur2 hashing. Messages without keys will be assigned via the random partitioner.

The rkt_opaque argument is the opaque set by rd_kafka_topic_conf_set_opaque(). The msg_opaque argument is the per-message opaque passed to produce().

Parameters: rkt \FFI\CData|null const rd_kafka_topic_t*; key \FFI\CData|object|string|null const void*; keylen int|null size_t; partition_cnt int|null int32_t; rkt_opaque \FFI\CData|object|string|null void*; msg_opaque \FFI\CData|object|string|null void*
Returns: int|null int32_t - a partition between 0 and partition_cnt - 1.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ab5dab15f3d0a293db43338f17544e26a

rd_kafka_msg_partitioner_random()¶

public static rd_kafka_msg_partitioner_random ( 
    \FFI\CData|null $rkt, 
    \FFI\CData|object|string|null $key, 
    int|null $keylen, 
    int|null $partition_cnt, 
    \FFI\CData|object|string|null $opaque, 
    \FFI\CData|object|string|null $msg_opaque
 ): int|null

Random partitioner.

Will try not to return unavailable partitions.

The rkt_opaque argument is the opaque set by rd_kafka_topic_conf_set_opaque(). The msg_opaque argument is the per-message opaque passed to produce().

Parameters: rkt \FFI\CData|null const rd_kafka_topic_t*; key \FFI\CData|object|string|null const void*; keylen int|null size_t; partition_cnt int|null int32_t; opaque \FFI\CData|object|string|null void*; msg_opaque \FFI\CData|object|string|null void*
Returns: int|null int32_t - a random partition between 0 and partition_cnt - 1.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a58ba8a3d1b491ecc32fe29e56d4142aa

rd_kafka_name()¶

public static rd_kafka_name ( 
    \FFI\CData|null $rk
 ): string|null

Parameters: rk \FFI\CData|null const rd_kafka_t*
Returns: string|null const char*

rd_kafka_new()¶

public static rd_kafka_new ( 
    int $type, 
    \FFI\CData|null $conf, 
    \FFI\CData|null $errstr, 
    int|null $errstr_size
 ): \FFI\CData|null

Creates a new Kafka handle and starts its operation according to the specified type (RD_KAFKA_CONSUMER or RD_KAFKA_PRODUCER).

conf is an optional struct created with rd_kafka_conf_new() that will be used instead of the default configuration. The conf object is freed by this function on success and must not be used or destroyed by the application subsequently. See rd_kafka_conf_set() et.al for more information.

errstr must be a pointer to memory of at least size errstr_size where rd_kafka_new() may write a human readable error message in case the creation of a new handle fails. In which case the function returns NULL.

Remarks: RD_KAFKA_CONSUMER: When a new RD_KAFKA_CONSUMER rd_kafka_t handle is created it may either operate in the legacy simple consumer mode using the rd_kafka_consume_start() interface, or the High-level KafkaConsumer API.; An application must only use one of these groups of APIs on a given rd_kafka_t RD_KAFKA_CONSUMER handle.

See also: To destroy the Kafka handle, use rd_kafka_destroy().

Parameters: type int rd_kafka_type_t; conf \FFI\CData|null rd_kafka_conf_t*; errstr \FFI\CData|null char*; errstr_size int|null size_t
Returns: \FFI\CData|null rd_kafka_t* - The Kafka handle on success or NULL on error (see errstr)

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a63d5cd86ab1f77772b2be170e1c09c24

rd_kafka_oauthbearer_set_token()¶

public static rd_kafka_oauthbearer_set_token ( 
    \FFI\CData|null $rk, 
    string|null $token_value, 
    int|null $md_lifetime_ms, 
    string|null $md_principal_name, 
    \FFI\CData|null $extensions, 
    int|null $extension_size, 
    \FFI\CData|null $errstr, 
    int|null $errstr_size
 ): int

Set SASL/OAUTHBEARER token and metadata.

The SASL/OAUTHBEARER token refresh callback or event handler should invoke this method upon success. The extension keys must not include the reserved key "`auth`", and all extension keys and values must conform to the required format as per https://tools.ietf.org/html/rfc7628#section-3.1:

key            = 1*(ALPHA)
value          = *(VCHAR / SP / HTAB / CR / LF )

See also: rd_kafka_oauthbearer_set_token_failure; rd_kafka_conf_set_oauthbearer_token_refresh_cb

Parameters: rk \FFI\CData|null rd_kafka_t* - Client instance.; token_value string|null const char* - the mandatory token value to set, often (but not necessarily) a JWS compact serialization as per https://tools.ietf.org/html/rfc7515#section-3.1.; md_lifetime_ms int|null int64_t - when the token expires, in terms of the number of milliseconds since the epoch.; md_principal_name string|null const char* - the mandatory Kafka principal name associated with the token.; extensions \FFI\CData|null const char** - optional SASL extensions key-value array with extensions_size elements (number of keys * 2), where [i] is the key and [i+1] is the key’s value, to be communicated to the broker as additional key-value pairs during the initial client response as per https://tools.ietf.org/html/rfc7628#section-3.1. The key-value pairs are copied.; extension_size int|null size_t - the number of SASL extension keys plus values, which must be a non-negative multiple of 2.; errstr \FFI\CData|null char* - A human readable error string (nul-terminated) is written to this location that must be of at least errstr_size bytes. The errstr is only written in case of error. - Writable size in errstr.; errstr_size int|null size_t
Returns: int rd_kafka_resp_err_t - RD_KAFKA_RESP_ERR_NO_ERROR on success, otherwise errstr set and:
RD_KAFKA_RESP_ERR__INVALID_ARG if any of the arguments are invalid;
RD_KAFKA_RESP_ERR__NOT_IMPLEMENTED if SASL/OAUTHBEARER is not supported by this build;
RD_KAFKA_RESP_ERR__STATE if SASL/OAUTHBEARER is supported but is not configured as the client’s authentication mechanism.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a16d208d8ccfeee3d7084402ae24b641f

rd_kafka_oauthbearer_set_token_failure()¶

public static rd_kafka_oauthbearer_set_token_failure ( 
    \FFI\CData|null $rk, 
    string|null $errstr
 ): int

SASL/OAUTHBEARER token refresh failure indicator.

The SASL/OAUTHBEARER token refresh callback or event handler should invoke this method upon failure.

See also: rd_kafka_oauthbearer_set_token; rd_kafka_conf_set_oauthbearer_token_refresh_cb

Parameters: rk \FFI\CData|null rd_kafka_t* - Client instance.; errstr string|null const char* - mandatory human readable error reason for failing to acquire a token.
Returns: int rd_kafka_resp_err_t - RD_KAFKA_RESP_ERR_NO_ERROR on success, otherwise:
RD_KAFKA_RESP_ERR__NOT_IMPLEMENTED if SASL/OAUTHBEARER is not supported by this build;
RD_KAFKA_RESP_ERR__STATE if SASL/OAUTHBEARER is supported but is not configured as the client’s authentication mechanism,
RD_KAFKA_RESP_ERR__INVALID_ARG if no error string is supplied.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a5a88c547172a961cea4c854f01740ce8

rd_kafka_offset_store()¶

public static rd_kafka_offset_store ( 
    \FFI\CData|null $rkt, 
    int|null $partition, 
    int|null $offset
 ): int

Store offset offset + 1 for topic rkt partition partition.

The offset + 1 will be committed (written) to broker (or file) according to auto.commit.interval.ms or manual offset-less commit()

Deprecated:: This API lacks support for partition leader epochs, which makes it at risk for unclean leader election log truncation issues. Use rd_kafka_offsets_store() and rd_kafka_offset_store_message() instead.

Warning: This method may only be called for partitions that are currently assigned. Non-assigned partitions will fail with RD_KAFKA_RESP_ERR__STATE. Since v1.9.0.; Avoid storing offsets after calling rd_kafka_seek() (et.al) as this may later interfere with resuming a paused partition, instead store offsets prior to calling seek.

Remarks: enable.auto.offset.store must be set to "false" when using this API.

Parameters: rkt \FFI\CData|null rd_kafka_topic_t*; partition int|null int32_t; offset int|null int64_t
Returns: int rd_kafka_resp_err_t - RD_KAFKA_RESP_ERR_NO_ERROR on success or an error code on error.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a784186db1d2cb6ceebcd5606d38db4c4

rd_kafka_offset_store_message()¶

public static rd_kafka_offset_store_message ( 
    \FFI\CData|null $rkmessage
 ): \FFI\CData|null

Store offset +1 for the consumed message.

The message offset + 1 will be committed to broker according to auto.commit.interval.ms or manual offset-less commit()

Warning: This method may only be called for partitions that are currently assigned. Non-assigned partitions will fail with RD_KAFKA_RESP_ERR__STATE. Since v1.9.0.; Avoid storing offsets after calling rd_kafka_seek() (et.al) as this may later interfere with resuming a paused partition, instead store offsets prior to calling seek.

Remarks: enable.auto.offset.store must be set to "false" when using this API.

Parameters: rkmessage \FFI\CData|null rd_kafka_message_t* - )
Returns: \FFI\CData|null rd_kafka_error_t* - NULL on success or an error object on failure.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a85d589ef6cb2d6a1d34e5594949bc9ee

rd_kafka_offsets_for_times()¶

public static rd_kafka_offsets_for_times ( 
    \FFI\CData|null $rk, 
    \FFI\CData|null $offsets, 
    int|null $timeout_ms
 ): int

Look up the offsets for the given partitions by timestamp.

The returned offset for each partition is the earliest offset whose timestamp is greater than or equal to the given timestamp in the corresponding partition.

The timestamps to query are represented as offset in offsets on input, and offset will contain the offset on output.

The function will block for at most timeout_ms milliseconds.

Remarks: Duplicate Topic+Partitions are not supported.; Per-partition errors may be returned in rd_kafka_topic_partition_t.err

Parameters: rk \FFI\CData|null rd_kafka_t*; offsets \FFI\CData|null rd_kafka_topic_partition_list_t*; timeout_ms int|null int
Returns: int rd_kafka_resp_err_t - RD_KAFKA_RESP_ERR_NO_ERROR if offsets were be queried (do note that per-partition errors might be set), RD_KAFKA_RESP_ERR__TIMED_OUT if not all offsets could be fetched within timeout_ms, RD_KAFKA_RESP_ERR__INVALID_ARG if the offsets list is empty, RD_KAFKA_RESP_ERR__UNKNOWN_PARTITION if all partitions are unknown, RD_KAFKA_RESP_ERR_LEADER_NOT_AVAILABLE if unable to query leaders for the given partitions.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ae308aaf534807cfd4c71e423fc214929

rd_kafka_offsets_store()¶

public static rd_kafka_offsets_store ( 
    \FFI\CData|null $rk, 
    \FFI\CData|null $offsets
 ): int

Store offsets for next auto-commit for one or more partitions.

The offset will be committed (written) to the offset store according to auto.commit.interval.ms or manual offset-less commit().

Per-partition success/error status propagated through each partition's .err for all return values (even NO_ERROR) except INVALID_ARG.

Warning: This method may only be called for partitions that are currently assigned. Non-assigned partitions will fail with RD_KAFKA_RESP_ERR__STATE. Since v1.9.0.; Avoid storing offsets after calling rd_kafka_seek() (et.al) as this may later interfere with resuming a paused partition, instead store offsets prior to calling seek.

Remarks: The .offset field is stored as is, it will NOT be + 1.; enable.auto.offset.store must be set to "false" when using this API.; The leader epoch, if set, will be used to fence outdated partition leaders. See rd_kafka_topic_partition_set_leader_epoch().

Parameters: rk \FFI\CData|null rd_kafka_t*; offsets \FFI\CData|null rd_kafka_topic_partition_list_t*
Returns: int rd_kafka_resp_err_t - RD_KAFKA_RESP_ERR_NO_ERROR on (partial) success, or RD_KAFKA_RESP_ERR__INVALID_ARG if enable.auto.offset.store is true, or RD_KAFKA_RESP_ERR__UNKNOWN_PARTITION or RD_KAFKA_RESP_ERR__STATE if none of the offsets could be stored.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a047b1e21236fba30898c7c563c2c6777

rd_kafka_opaque()¶

public static rd_kafka_opaque ( 
    \FFI\CData|null $rk
 ): \FFI\CData|object|string|null

Parameters: rk \FFI\CData|null const rd_kafka_t*
Returns: \FFI\CData|object|string|null void*

rd_kafka_outq_len()¶

public static rd_kafka_outq_len ( 
    \FFI\CData|null $rk
 ): int|null

Returns the current out queue length.

The out queue length is the sum of:

number of messages waiting to be sent to, or acknowledged by, the broker.
number of delivery reports (e.g., dr_msg_cb) waiting to be served by rd_kafka_poll() or rd_kafka_flush().
number of callbacks (e.g., error_cb, stats_cb, etc) waiting to be served by rd_kafka_poll(), rd_kafka_consumer_poll() or rd_kafka_flush().
number of events waiting to be served by background_event_cb() in the background queue (see rd_kafka_conf_set_background_event_cb).

An application should wait for the return value of this function to reach zero before terminating to make sure outstanding messages, requests (such as offset commits), callbacks and events are fully processed. See rd_kafka_flush().

See also: rd_kafka_flush()

Parameters: rk \FFI\CData|null rd_kafka_t* - )
Returns: int|null int - number of messages and events waiting in queues.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ad4b3b7659cf9a79d3353810d6b625bb7

rd_kafka_pause_partitions()¶

public static rd_kafka_pause_partitions ( 
    \FFI\CData|null $rk, 
    \FFI\CData|null $partitions
 ): int

Pause producing or consumption for the provided list of partitions.

Success or error is returned per-partition err in the partitions list.

Parameters: rk \FFI\CData|null rd_kafka_t*; partitions \FFI\CData|null rd_kafka_topic_partition_list_t*
Returns: int rd_kafka_resp_err_t - RD_KAFKA_RESP_ERR_NO_ERROR

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a293cb2aac290c157702d3b82f5c14fce

rd_kafka_plugin_f_conf_init_t()¶

public static rd_kafka_plugin_f_conf_init_t ( 
    \FFI\CData|null $conf, 
    \FFI\CData|object|string|null $plug_opaquep, 
    \FFI\CData|null $errstr, 
    int|null $errstr_size
 ): int

Plugin's configuration initializer method called each time the library is referenced from configuration (even if previously loaded by another client instance).

Remarks: This method MUST be implemented by plugins and have the symbol name conf_init

Remarks: A plugin may add an on_conf_destroy() interceptor to clean up plugin-specific resources created in the plugin's conf_init() method.

Parameters: conf \FFI\CData|null rd_kafka_conf_t* - Configuration set up to this point.; plug_opaquep \FFI\CData|object|string|null void** - Plugin can set this pointer to a per-configuration opaque pointer.; errstr \FFI\CData|null char* - String buffer of size errstr_size where plugin must write a human readable error string in the case the initializer fails (returns non-zero). - Maximum space (including \0) in errstr.; errstr_size int|null size_t
Returns: int rd_kafka_resp_err_t - RD_KAFKA_RESP_ERR_NO_ERROR on success or an error code on error.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a6d98d642466324e3b188accb2623387f

rd_kafka_poll()¶

public static rd_kafka_poll ( 
    \FFI\CData|null $rk, 
    int|null $timeout_ms
 ): int|null

Polls the provided kafka handle for events.

Events will cause application-provided callbacks to be called.

The timeout_ms argument specifies the maximum amount of time (in milliseconds) that the call will block waiting for events. For non-blocking calls, provide 0 as timeout_ms. To wait indefinitely for an event, provide -1.

Remarks: An application should make sure to call poll() at regular intervals to serve any queued callbacks waiting to be called.; If your producer doesn't have any callback set (in particular via rd_kafka_conf_set_dr_msg_cb or rd_kafka_conf_set_error_cb) you might choose not to call poll(), though this is not recommended.

Events:

delivery report callbacks (if dr_cb/dr_msg_cb is configured) [producer]
error callbacks (rd_kafka_conf_set_error_cb()) [all]
stats callbacks (rd_kafka_conf_set_stats_cb()) [all]
throttle callbacks (rd_kafka_conf_set_throttle_cb()) [all]
OAUTHBEARER token refresh callbacks (rd_kafka_conf_set_oauthbearer_token_refresh_cb()) [all]

Parameters: rk \FFI\CData|null rd_kafka_t*; timeout_ms int|null int
Returns: int|null int - the number of events served.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ad50c431e3a29d14da534db49bd0682a4

rd_kafka_poll_set_consumer()¶

public static rd_kafka_poll_set_consumer ( 
    \FFI\CData|null $rk
 ): int

Redirect the main (rd_kafka_poll()) queue to the KafkaConsumer's queue (rd_kafka_consumer_poll()).

Warning: It is not permitted to call rd_kafka_poll() after directing the main queue with rd_kafka_poll_set_consumer().

Parameters: rk \FFI\CData|null rd_kafka_t* - )
Returns: int rd_kafka_resp_err_t

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a9bfa0a1dd3f866cbf0c82fc089bd7904

rd_kafka_position()¶

public static rd_kafka_position ( 
    \FFI\CData|null $rk, 
    \FFI\CData|null $partitions
 ): int

Retrieve current positions (offsets) for topics+partitions.

The offset field of each requested partition will be set to the offset of the last consumed message + 1, or RD_KAFKA_OFFSET_INVALID in case there was no previous message.

Remarks: In this context the last consumed message is the offset consumed by the current librdkafka instance and, in case of rebalancing, not necessarily the last message fetched from the partition.

Parameters: rk \FFI\CData|null rd_kafka_t*; partitions \FFI\CData|null rd_kafka_topic_partition_list_t*
Returns: int rd_kafka_resp_err_t - RD_KAFKA_RESP_ERR_NO_ERROR on success in which case the offset or err field of each partitions’ element is filled in with the stored offset, or a partition specific error. Else returns an error code.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a6e9e36bd9e6bf84a9f3092fcbfa3a9ac

rd_kafka_produce()¶

public static rd_kafka_produce ( 
    \FFI\CData|null $rkt, 
    int|null $partition, 
    int|null $msgflags, 
    \FFI\CData|object|string|null $payload, 
    int|null $len, 
    \FFI\CData|object|string|null $key, 
    int|null $keylen, 
    \FFI\CData|object|string|null $msg_opaque
 ): int|null

Produce and send a single message to broker.

rkt is the target topic which must have been previously created with rd_kafka_topic_new().

rd_kafka_produce() is an asynchronous non-blocking API. See rd_kafka_conf_set_dr_msg_cb on how to setup a callback to be called once the delivery status (success or failure) is known. The delivery report is triggered by the application calling rd_kafka_poll() (at regular intervals) or rd_kafka_flush() (at termination).

Since producing is asynchronous, you should call rd_kafka_flush() before you destroy the producer. Otherwise, any outstanding messages will be silently discarded.

When temporary errors occur, librdkafka automatically retries to produce the messages. Retries are triggered after retry.backoff.ms and when the leader broker for the given partition is available. Otherwise, librdkafka falls back to polling the topic metadata to monitor when a new leader is elected (see the topic.metadata.refresh.fast.interval.ms and topic.metadata.refresh.interval.ms configurations) and then performs a retry. A delivery error will occur if the message could not be produced within message.timeout.ms.

See the "Message reliability" chapter in INTRODUCTION.md for more information.

partition is the target partition, either:

RD_KAFKA_PARTITION_UA (unassigned) for automatic partitioning using the topic's partitioner function, or
a fixed partition (0..N)

msgflags is zero or more of the following flags OR:ed together: RD_KAFKA_MSG_F_BLOCK - block produce*() call if queue.buffering.max.messages or queue.buffering.max.kbytes are exceeded. Messages are considered in-queue from the point they are accepted by produce() until their corresponding delivery report callback/event returns. It is thus a requirement to call rd_kafka_poll() (or equiv.) from a separate thread when F_BLOCK is used. See WARNING on RD_KAFKA_MSG_F_BLOCK above.

RD_KAFKA_MSG_F_FREE - rdkafka will free(3) payload when it is done with it. RD_KAFKA_MSG_F_COPY - the payload data will be copied and the payload pointer will not be used by rdkafka after the call returns. RD_KAFKA_MSG_F_PARTITION - produce_batch() will honour per-message partition, either set manually or by the configured partitioner.

.._F_FREE and .._F_COPY are mutually exclusive. If neither of these are set, the caller must ensure that the memory backing payload remains valid and is not modified or reused until the delivery callback is invoked. Other buffers passed to rd_kafka_produce() don't have this restriction on reuse, i.e. the memory backing the key or the topic name may be reused as soon as rd_kafka_produce() returns.

If the function returns -1 and RD_KAFKA_MSG_F_FREE was specified, then the memory associated with the payload is still the caller's responsibility.

payload is the message payload of size len bytes.

key is an optional message key of size keylen bytes, if non-NULL it will be passed to the topic partitioner as well as be sent with the message to the broker and passed on to the consumer.

msg_opaque is an optional application-provided per-message opaque pointer that will provided in the message's delivery report callback (dr_msg_cb or dr_cb) and the rd_kafka_message_t _private field.

Remarks: on_send() and on_acknowledgement() interceptors may be called from this function. on_acknowledgement() will only be called if the message fails partitioning.; If the producer is transactional (transactional.id is configured) producing is only allowed during an on-going transaction, namely after rd_kafka_begin_transaction() has been called.

See also: Use rd_kafka_errno2err() to convert errno to rdkafka error code.

Parameters

rkt \FFI\CData|null rd_kafka_topic_t*

partition int|null int32_t

msgflags int|null int

payload \FFI\CData|object|string|null void*

len int|null size_t

key \FFI\CData|object|string|null const void*

keylen int|null size_t

msg_opaque \FFI\CData|object|string|null void*

Returns

int|null int - 0 on success or -1 on error in which case errno is set accordingly:

ENOBUFS - maximum number of outstanding messages has been reached: "queue.buffering.max.messages" (RD_KAFKA_RESP_ERR__QUEUE_FULL)

EMSGSIZE - message is larger than configured max size: "messages.max.bytes". (RD_KAFKA_RESP_ERR_MSG_SIZE_TOO_LARGE)

ESRCH - requested partition is unknown in the Kafka cluster. (RD_KAFKA_RESP_ERR__UNKNOWN_PARTITION)

ENOENT - topic is unknown in the Kafka cluster. (RD_KAFKA_RESP_ERR__UNKNOWN_TOPIC)

ECANCELED - fatal error has been raised on producer, see rd_kafka_fatal_error(), (RD_KAFKA_RESP_ERR__FATAL).

ENOEXEC - transactional state forbids producing (RD_KAFKA_RESP_ERR__STATE)

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ae24d8ebf1ea15ed8ea0ea40f74662736

rd_kafka_produce_batch()¶

public static rd_kafka_produce_batch ( 
    \FFI\CData|null $rkt, 
    int|null $partition, 
    int|null $msgflags, 
    \FFI\CData|null $rkmessages, 
    int|null $message_cnt
 ): int|null

Produce multiple messages.

If partition is RD_KAFKA_PARTITION_UA the configured partitioner will be run for each message (slower), otherwise the messages will be enqueued to the specified partition directly (faster).

The messages are provided in the array rkmessages of count message_cnt elements. The partition and msgflags are used for all provided messages.

Honoured rkmessages[] fields are:

payload,len Message payload and length
key,key_len Optional message key
_private Message opaque pointer (msg_opaque)
err Will be set according to success or failure, see rd_kafka_produce() for possible error codes. Application only needs to check for errors if return value != message_cnt.

Remarks: If RD_KAFKA_MSG_F_PARTITION is set in msgflags, the .partition field of the rkmessages is used instead of partition.

Remarks: This interface does NOT support setting message headers on the provided rkmessages.

Parameters: rkt \FFI\CData|null rd_kafka_topic_t*; partition int|null int32_t; msgflags int|null int; rkmessages \FFI\CData|null rd_kafka_message_t*; message_cnt int|null int
Returns: int|null int - the number of messages succesfully enqueued for producing.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a7ad15c71f228c47946500a0e5c6f88ed

rd_kafka_producev()¶

public static rd_kafka_producev ( 
    \FFI\CData|null $rk, 
    mixed $args
 ): int

Produce and send a single message to broker.

The message is defined by a va-arg list using rd_kafka_vtype_t tag tuples which must be terminated with a single RD_KAFKA_V_END.

See also: rd_kafka_produce, rd_kafka_produceva, RD_KAFKA_V_END

Parameters: rk \FFI\CData|null rd_kafka_t*; args mixed
Returns: int rd_kafka_resp_err_t - RD_KAFKA_RESP_ERR_NO_ERROR on success, else an error code as described in rd_kafka_produce(). RD_KAFKA_RESP_ERR__CONFLICT is returned if _V_HEADER and _V_HEADERS are mixed.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ac3a111ec3e6729609d498fec7b619efc

rd_kafka_produceva()¶

public static rd_kafka_produceva ( 
    \FFI\CData|null $rk, 
    \FFI\CData|null $vus, 
    int|null $cnt
 ): \FFI\CData|null

Produce and send a single message to broker.

The message is defined by an array of rd_kafka_vu_t of count cnt.

See also: rd_kafka_produce, rd_kafka_producev, RD_KAFKA_V_END

Parameters: rk \FFI\CData|null rd_kafka_t*; vus \FFI\CData|null const rd_kafka_vu_t*; cnt int|null size_t
Returns: \FFI\CData|null rd_kafka_error_t* - an error object on failure or NULL on success. See rd_kafka_producev() for specific error codes.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a267a7eabf933733e542902533141bd47

rd_kafka_purge()¶

public static rd_kafka_purge ( 
    \FFI\CData|null $rk, 
    int|null $purge_flags
 ): int

Purge messages currently handled by the producer instance.

The application will need to call rd_kafka_poll() or rd_kafka_flush() afterwards to serve the delivery report callbacks of the purged messages.

Messages purged from internal queues fail with the delivery report error code set to RD_KAFKA_RESP_ERR__PURGE_QUEUE, while purged messages that are in-flight to or from the broker will fail with the error code set to RD_KAFKA_RESP_ERR__PURGE_INFLIGHT.

Warning: Purging messages that are in-flight to or from the broker will ignore any subsequent acknowledgement for these messages received from the broker, effectively making it impossible for the application to know if the messages were successfully produced or not. This may result in duplicate messages if the application retries these messages at a later time.

Remarks: This call may block for a short time while background thread queues are purged.

Parameters: rk \FFI\CData|null rd_kafka_t* - Client instance.; purge_flags int|null int - Tells which messages to purge and how.
Returns: int rd_kafka_resp_err_t - RD_KAFKA_RESP_ERR_NO_ERROR on success, RD_KAFKA_RESP_ERR__INVALID_ARG if the purge flags are invalid or unknown, RD_KAFKA_RESP_ERR__NOT_IMPLEMENTED if called on a non-producer client instance.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a59c28026ebf7a67df5954879ebab4707

rd_kafka_query_watermark_offsets()¶

public static rd_kafka_query_watermark_offsets ( 
    \FFI\CData|null $rk, 
    string|null $topic, 
    int|null $partition, 
    \FFI\CData|null $low, 
    \FFI\CData|null $high, 
    int|null $timeout_ms
 ): int

Query broker for low (oldest/beginning) and high (newest/end) offsets for partition.

Offsets are returned in *low and *high respectively.

Parameters: rk \FFI\CData|null rd_kafka_t*; topic string|null const char*; partition int|null int32_t; low \FFI\CData|null int64_t*; high \FFI\CData|null int64_t*; timeout_ms int|null int
Returns: int rd_kafka_resp_err_t - RD_KAFKA_RESP_ERR_NO_ERROR on success or an error code on failure.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a4550ff7d014f08406666124573f70495

rd_kafka_queue_cb_event_enable()¶

public static rd_kafka_queue_cb_event_enable ( 
    \FFI\CData|null $rkqu, 
    \FFI\CData|\Closure $event_cb, 
    \FFI\CData|object|string|null $opaque
 ): void

Enable callback event triggering for queue.

The callback will be called from an internal librdkafka thread when a new element is enqueued on a previously empty queue.

To remove event triggering call with event_cb = NULL.

The qev_opaque is passed to the callback's qev_opaque argument.

Remarks: IO and callback event triggering are mutually exclusive.; Since the callback may be triggered from internal librdkafka threads, the application must not perform any pro-longed work in the callback, or call any librdkafka APIs (for the same rd_kafka_t handle).

Parameters: rkqu \FFI\CData|null rd_kafka_queue_t*; event_cb \FFI\CData|\Closure void()(rd_kafka_t, void*); opaque \FFI\CData|object|string|null void*

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a411b31dede8e2d1f6a921ae4fb98413a

rd_kafka_queue_destroy()¶

public static rd_kafka_queue_destroy ( 
    \FFI\CData|null $rkqu
 ): void

Destroy a queue, purging all of its enqueued messages.

Parameters: rkqu \FFI\CData|null rd_kafka_queue_t* - )

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a9421b3d450f1489cf46f68d49c5ea61e

rd_kafka_queue_forward()¶

public static rd_kafka_queue_forward ( 
    \FFI\CData|null $src, 
    \FFI\CData|null $dst
 ): void

Forward/re-route queue src to dst. If dst is NULL the forwarding is removed.

The internal refcounts for both queues are increased.

Remarks: Regardless of whether dst is NULL or not, after calling this function, src will not forward it's fetch queue to the consumer queue.

Parameters: src \FFI\CData|null rd_kafka_queue_t*; dst \FFI\CData|null rd_kafka_queue_t*

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a5e2e5571d14636d289f963a270b8e338

rd_kafka_queue_get_background()¶

public static rd_kafka_queue_get_background ( 
    \FFI\CData|null $rk
 ): \FFI\CData|null

The background thread queue provides the application with an automatically polled queue that triggers the event callback in a background thread, this background thread is completely managed by librdkafka.

The background thread queue is automatically created if a generic event handler callback is configured with rd_kafka_conf_set_background_event_cb() or if rd_kafka_queue_get_background() is called.

The background queue is polled and served by librdkafka and MUST NOT be polled, forwarded, or otherwise managed by the application, it may only be used as the destination queue passed to queue-enabled APIs, such as the Admin API.

Use rd_kafka_queue_destroy() to loose the reference.

Warning: The background queue MUST NOT be read from (polled, consumed, etc), or forwarded from.

Parameters: rk \FFI\CData|null rd_kafka_t* - )
Returns: \FFI\CData|null rd_kafka_queue_t* - a reference to the background thread queue, or NULL if the background queue is not enabled.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a2ba0f4fa322165d33d7cd240a1a90c83

rd_kafka_queue_get_consumer()¶

public static rd_kafka_queue_get_consumer ( 
    \FFI\CData|null $rk
 ): \FFI\CData|null

Use rd_kafka_queue_destroy() to loose the reference.

Remarks: rd_kafka_queue_destroy() MUST be called on this queue prior to calling rd_kafka_consumer_close().; Polling the returned queue counts as a consumer poll, and will reset the timer for max.poll.interval.ms. If this queue is forwarded to a "destq", polling destq also counts as a consumer poll (this works for any number of forwards). However, even if this queue is unforwarded or forwarded elsewhere, polling destq will continue to count as a consumer poll.

Parameters: rk \FFI\CData|null rd_kafka_t* - )
Returns: \FFI\CData|null rd_kafka_queue_t* - a reference to the librdkafka consumer queue. This is the queue served by rd_kafka_consumer_poll().

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#acacdb55ae7cb6abfbde89621e512b078

rd_kafka_queue_get_main()¶

public static rd_kafka_queue_get_main ( 
    \FFI\CData|null $rk
 ): \FFI\CData|null

Use rd_kafka_queue_destroy() to loose the reference.

Parameters: rk \FFI\CData|null rd_kafka_t* - )
Returns: \FFI\CData|null rd_kafka_queue_t* - a reference to the main librdkafka event queue. This is the queue served by rd_kafka_poll().

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a7f3d675ee029a52bf85fb28f83c38863

rd_kafka_queue_get_partition()¶

public static rd_kafka_queue_get_partition ( 
    \FFI\CData|null $rk, 
    string|null $topic, 
    int|null $partition
 ): \FFI\CData|null

Use rd_kafka_queue_destroy() to loose the reference.

Remarks: rd_kafka_queue_destroy() MUST be called on this queue; This function only works on consumers.

Parameters: rk \FFI\CData|null rd_kafka_t*; topic string|null const char*; partition int|null int32_t
Returns: \FFI\CData|null rd_kafka_queue_t* - a reference to the partition’s queue, or NULL if partition is invalid.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ad5319a26efb9f843c6029f7dd54b742d

rd_kafka_queue_get_sasl()¶

public static rd_kafka_queue_get_sasl ( 
    \FFI\CData|null $rk
 ): \FFI\CData|null

Use rd_kafka_queue_destroy() to loose the reference.

See also: rd_kafka_sasl_background_callbacks_enable()

Parameters: rk \FFI\CData|null rd_kafka_t* - )
Returns: \FFI\CData|null rd_kafka_queue_t* - a reference to the SASL callback queue, if a SASL mechanism with callbacks is configured (currently only OAUTHBEARER), else returns NULL.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a56d2a479cb1e2fb540db1f25f45b7ece

rd_kafka_queue_io_event_enable()¶

public static rd_kafka_queue_io_event_enable ( 
    \FFI\CData|null $rkqu, 
    int|null $fd, 
    \FFI\CData|object|string|null $payload, 
    int|null $size
 ): void

Enable IO event triggering for queue.

To ease integration with IO based polling loops this API allows an application to create a separate file-descriptor that librdkafka will write payload (of size size) to whenever a new element is enqueued on a previously empty queue.

To remove event triggering call with fd = -1.

librdkafka will maintain a copy of the payload.

Remarks: IO and callback event triggering are mutually exclusive.; When using forwarded queues the IO event must only be enabled on the final forwarded-to (destination) queue.; The file-descriptor/socket must be set to non-blocking.

Parameters: rkqu \FFI\CData|null rd_kafka_queue_t*; fd int|null int; payload \FFI\CData|object|string|null const void*; size int|null size_t

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#acbdd13ab480f6320b2842981eebce784

rd_kafka_queue_length()¶

public static rd_kafka_queue_length ( 
    \FFI\CData|null $rkqu
 ): int|null

Parameters: rkqu \FFI\CData|null rd_kafka_queue_t* - )
Returns: int|null size_t - the current number of elements in queue.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a8f24368f4ff0e042907773f532f62e57

rd_kafka_queue_new()¶

public static rd_kafka_queue_new ( 
    \FFI\CData|null $rk
 ): \FFI\CData|null

Create a new message queue.

See rd_kafka_consume_start_queue(), rd_kafka_consume_queue(), et.al.

Parameters: rk \FFI\CData|null rd_kafka_t* - )
Returns: \FFI\CData|null rd_kafka_queue_t*

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a2b59178eb7e88d40510a89f3f2d98b44

rd_kafka_queue_poll()¶

public static rd_kafka_queue_poll ( 
    \FFI\CData|null $rkqu, 
    int|null $timeout_ms
 ): \FFI\CData|null

Poll a queue for an event for max timeout_ms.

Remarks: Use rd_kafka_event_destroy() to free the event.

See also: rd_kafka_conf_set_background_event_cb()

Parameters: rkqu \FFI\CData|null rd_kafka_queue_t*; timeout_ms int|null int
Returns: \FFI\CData|null rd_kafka_event_t* - an event, or NULL.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a2f147ed1c554c9048893fb1adde86dfa

rd_kafka_queue_poll_callback()¶

public static rd_kafka_queue_poll_callback ( 
    \FFI\CData|null $rkqu, 
    int|null $timeout_ms
 ): int|null

Poll a queue for events served through callbacks for max timeout_ms.

Remarks: This API must only be used for queues with callbacks registered for all expected event types. E.g., not a message queue.; Also see rd_kafka_conf_set_background_event_cb() for triggering event callbacks from a librdkafka-managed background thread.

See also: rd_kafka_conf_set_background_event_cb()

Parameters: rkqu \FFI\CData|null rd_kafka_queue_t*; timeout_ms int|null int
Returns: int|null int - the number of events served.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a13d80084f20a2800e863b97e465ce98e

rd_kafka_queue_yield()¶

public static rd_kafka_queue_yield ( 
    \FFI\CData|null $rkqu
 ): void

Cancels the current rd_kafka_queue_poll() on rkqu.

An application may use this from another thread to force an immediate return to the calling code (caller of rd_kafka_queue_poll()). Must not be used from signal handlers since that may cause deadlocks.

Parameters: rkqu \FFI\CData|null rd_kafka_queue_t* - )

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#af3f15671034a8a5c6d9a3b33cc1b6f3f

rd_kafka_rebalance_protocol()¶

public static rd_kafka_rebalance_protocol ( 
    \FFI\CData|null $rk
 ): string|null

The rebalance protocol currently in use. This will be "NONE" if the consumer has not (yet) joined a group, else it will match the rebalance protocol ("EAGER", "COOPERATIVE") of the configured and selected assignor(s). All configured assignors must have the same protocol type, meaning online migration of a consumer group from using one protocol to another (in particular upgading from EAGER to COOPERATIVE) without a restart is not currently supported.

Parameters: rk \FFI\CData|null rd_kafka_t* - )
Returns: string|null const char* - NULL on error, or one of “NONE”, “EAGER”, “COOPERATIVE” on success.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ae8c9ec99ace76e89a6b77b89ff15c970

rd_kafka_resume_partitions()¶

public static rd_kafka_resume_partitions ( 
    \FFI\CData|null $rk, 
    \FFI\CData|null $partitions
 ): int

Resume producing consumption for the provided list of partitions.

Success or error is returned per-partition err in the partitions list.

Parameters: rk \FFI\CData|null rd_kafka_t*; partitions \FFI\CData|null rd_kafka_topic_partition_list_t*
Returns: int rd_kafka_resp_err_t - RD_KAFKA_RESP_ERR_NO_ERROR

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ad05819f26887a916ad2047d96a7b4bf2

rd_kafka_sasl_background_callbacks_enable()¶

public static rd_kafka_sasl_background_callbacks_enable ( 
    \FFI\CData|null $rk
 ): \FFI\CData|null

Enable SASL OAUTHBEARER refresh callbacks on the librdkafka background thread.

This serves as an alternative for applications that do not call rd_kafka_poll() (et.al.) at regular intervals (or not at all), as a means of automatically trigger the refresh callbacks, which are needed to initiate connections to the brokers in the case a custom OAUTHBEARER refresh callback is configured.

See also: rd_kafka_queue_get_sasl(); rd_kafka_conf_set_oauthbearer_token_refresh_cb()

Parameters: rk \FFI\CData|null rd_kafka_t* - )
Returns: \FFI\CData|null rd_kafka_error_t* - NULL on success or an error object on error.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a383a661dc45191bccb3a2b50adbbfcdb

rd_kafka_sasl_set_credentials()¶

public static rd_kafka_sasl_set_credentials ( 
    \FFI\CData|null $rk, 
    string|null $username, 
    string|null $password
 ): \FFI\CData|null

Sets SASL credentials used for SASL PLAIN and SCRAM mechanisms by this Kafka client.

This function sets or resets the SASL username and password credentials used by this Kafka client. The new credentials will be used the next time this client needs to authenticate to a broker. This function will not disconnect existing connections that might have been made using the old credentials.

Remarks: This function only applies to the SASL PLAIN and SCRAM mechanisms.

Parameters: rk \FFI\CData|null rd_kafka_t*; username string|null const char*; password string|null const char*
Returns: \FFI\CData|null rd_kafka_error_t* - NULL on success or an error object on error.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a8bdca34710185cec1e42e500decbeb2d

rd_kafka_seek()¶

public static rd_kafka_seek ( 
    \FFI\CData|null $rkt, 
    int|null $partition, 
    int|null $offset, 
    int|null $timeout_ms
 ): int

Seek consumer for topic+partition to offset which is either an absolute or logical offset.

If timeout_ms is specified (not 0) the seek call will wait this long for the consumer to update its fetcher state for the given partition with the new offset. This guarantees that no previously fetched messages for the old offset (or fetch position) will be passed to the application.

If the timeout is reached the internal state will be unknown to the caller and this function returns RD_KAFKA_RESP_ERR__TIMED_OUT.

If timeout_ms is 0 it will initiate the seek but return immediately without any error reporting (e.g., async).

This call will purge all pre-fetched messages for the given partition, which may be up to queued.max.message.kbytes in size. Repeated use of seek may thus lead to increased network usage as messages are re-fetched from the broker.

Remarks: Seek must only be performed for already assigned/consumed partitions, use rd_kafka_assign() (et.al) to set the initial starting offset for a new assignmenmt.

Deprecated:: Use rd_kafka_seek_partitions().

Parameters: rkt \FFI\CData|null rd_kafka_topic_t*; partition int|null int32_t; offset int|null int64_t; timeout_ms int|null int
Returns: int rd_kafka_resp_err_t - RD_KAFKA_RESP_ERR__NO_ERROR on success else an error code.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a6667b162931982e9827e3d86ad22ec7d

rd_kafka_seek_partitions()¶

public static rd_kafka_seek_partitions ( 
    \FFI\CData|null $rk, 
    \FFI\CData|null $partitions, 
    int|null $timeout_ms
 ): \FFI\CData|null

Seek consumer for partitions in partitions to the per-partition offset in the .offset field of partitions.

The offset may be either absolute (>= 0) or a logical offset.

If timeout_ms is specified (not 0) the seek call will wait this long for the consumer to update its fetcher state for the given partition with the new offset. This guarantees that no previously fetched messages for the old offset (or fetch position) will be passed to the application.

If the timeout is reached the internal state will be unknown to the caller and this function returns RD_KAFKA_RESP_ERR__TIMED_OUT.

If timeout_ms is 0 it will initiate the seek but return immediately without any error reporting (e.g., async).

This call will purge all pre-fetched messages for the given partition, which may be up to queued.max.message.kbytes in size. Repeated use of seek may thus lead to increased network usage as messages are re-fetched from the broker.

Individual partition errors are reported in the per-partition .err field of partitions.

Remarks: Seek must only be performed for already assigned/consumed partitions, use rd_kafka_assign() (et.al) to set the initial starting offset for a new assignmenmt.

Parameters: rk \FFI\CData|null rd_kafka_t*; partitions \FFI\CData|null rd_kafka_topic_partition_list_t*; timeout_ms int|null int
Returns: \FFI\CData|null rd_kafka_error_t* - NULL on success or an error object on failure.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a7821331324eaab995d4a2baf42b78df5

rd_kafka_send_offsets_to_transaction()¶

public static rd_kafka_send_offsets_to_transaction ( 
    \FFI\CData|null $rk, 
    \FFI\CData|null $offsets, 
    \FFI\CData|null $cgmetadata, 
    int|null $timeout_ms
 ): \FFI\CData|null

Sends a list of topic partition offsets to the consumer group coordinator for cgmetadata, and marks the offsets as part part of the current transaction. These offsets will be considered committed only if the transaction is committed successfully.

The offsets should be the next message your application will consume, i.e., the last processed message's offset + 1 for each partition. Either track the offsets manually during processing or use rd_kafka_position() (on the consumer) to get the current offsets for the partitions assigned to the consumer.

Use this method at the end of a consume-transform-produce loop prior to committing the transaction with rd_kafka_commit_transaction().

Remarks: This function must be called on the transactional producer instance, not the consumer.; The consumer must disable auto commits (set enable.auto.commit to false on the consumer).; Logical and invalid offsets (such as RD_KAFKA_OFFSET_INVALID) in offsets will be ignored, if there are no valid offsets in offsets the function will return NULL and no action will be taken.; This call is retriable but not resumable, which means a new request with a new set of provided offsets and group metadata will be sent to the transaction coordinator if the call is retried.; It is highly recommended to retry the call (upon retriable error) with identical offsets and cgmetadata parameters. Failure to do so risks inconsistent state between what is actually included in the transaction and what the application thinks is included in the transaction.

Remarks: The returned error object (if not NULL) must be destroyed with rd_kafka_error_destroy().

Parameters: rk \FFI\CData|null rd_kafka_t* - Producer instance.; offsets \FFI\CData|null const rd_kafka_topic_partition_list_t* - List of offsets to commit to the consumer group upon successful commit of the transaction. Offsets should be the next message to consume, e.g., last processed message + 1.; cgmetadata \FFI\CData|null const rd_kafka_consumer_group_metadata_t* - The current consumer group metadata as returned by rd_kafka_consumer_group_metadata() on the consumer instance the provided offsets were consumed from.; timeout_ms int|null int - Maximum time allowed to register the offsets on the broker.
Returns: \FFI\CData|null rd_kafka_error_t* - NULL on success or an error object on failure. Check whether the returned error object permits retrying by calling rd_kafka_error_is_retriable(), or whether an abortable or fatal error has been raised by calling rd_kafka_error_txn_requires_abort() or rd_kafka_error_is_fatal() respectively. Error codes: RD_KAFKA_RESP_ERR__STATE if not currently in a transaction, RD_KAFKA_RESP_ERR_INVALID_PRODUCER_EPOCH if the current producer transaction has been fenced by a newer producer instance, RD_KAFKA_RESP_ERR_TRANSACTIONAL_ID_AUTHORIZATION_FAILED if the producer is no longer authorized to perform transactional operations, RD_KAFKA_RESP_ERR_GROUP_AUTHORIZATION_FAILED if the producer is not authorized to write the consumer offsets to the group coordinator, RD_KAFKA_RESP_ERR__NOT_CONFIGURED if transactions have not been configured for the producer instance, RD_KAFKA_RESP_ERR__INVALID_ARG if rk is not a producer instance, or if the consumer_group_id or offsets are empty. Other error codes not listed here may be returned, depending on broker version.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a288b31742a707ca14cf07312fbcca881

rd_kafka_set_log_level()¶

public static rd_kafka_set_log_level ( 
    \FFI\CData|null $rk, 
    int|null $level
 ): void

Specifies the maximum logging level emitted by internal kafka logging and debugging.

Deprecated:: Set the "log_level" configuration property instead.

Remarks: If the "debug" configuration property is set the log level is automatically adjusted to LOG_DEBUG (7).

Parameters: rk \FFI\CData|null rd_kafka_t*; level int|null int

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#acadeefced6bb60acd27e7a0dad553aa4

rd_kafka_set_log_queue()¶

public static rd_kafka_set_log_queue ( 
    \FFI\CData|null $rk, 
    \FFI\CData|null $rkqu
 ): int

Forward librdkafka logs (and debug) to the specified queue for serving with one of the ..poll() calls.

This allows an application to serve log callbacks (log_cb) in its thread of choice.

Remarks: The configuration property log.queue MUST also be set to true.; librdkafka maintains its own reference to the provided queue.

Parameters: rk \FFI\CData|null rd_kafka_t* - Client instance.; rkqu \FFI\CData|null rd_kafka_queue_t* - Queue to forward logs to. If the value is NULL the logs are forwarded to the main queue.
Returns: int rd_kafka_resp_err_t - RD_KAFKA_RESP_ERR_NO_ERROR on success or an error code on error, eg RD_KAFKA_RESP_ERR__NOT_CONFIGURED when log.queue is not set to true.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a5c8a3be2f797560b2a39bf56dbd7622d

rd_kafka_set_logger()¶

public static rd_kafka_set_logger ( 
    \FFI\CData|null $rk, 
    \FFI\CData|\Closure $func
 ): void

Set logger function.

The default is to print to stderr, but a syslog logger is also available, see rd_kafka_log_(print|syslog) for the builtin alternatives. Alternatively the application may provide its own logger callback. Or pass 'func' as NULL to disable logging.

Deprecated:: Use rd_kafka_conf_set_log_cb()

Remarks: rk may be passed as NULL in the callback.

Parameters: rk \FFI\CData|null rd_kafka_t*; func \FFI\CData|\Closure void()(const rd_kafka_t, int, const char*, const char*)

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a9e4af9adee414af74c7817403f7c4a53

rd_kafka_subscribe()¶

public static rd_kafka_subscribe ( 
    \FFI\CData|null $rk, 
    \FFI\CData|null $topics
 ): int

Subscribe to topic set using balanced consumer groups.

Wildcard (regex) topics are supported: any topic name in the topics list that is prefixed with "^" will be regex-matched to the full list of topics in the cluster and matching topics will be added to the subscription list.

The full topic list is retrieved every topic.metadata.refresh.interval.ms to pick up new or delete topics that match the subscription. If there is any change to the matched topics the consumer will immediately rejoin the group with the updated set of subscribed topics.

Regex and full topic names can be mixed in topics.

Remarks: Only the .topic field is used in the supplied topics list, all other fields are ignored.; subscribe() is an asynchronous method which returns immediately: background threads will (re)join the group, wait for group rebalance, issue any registered rebalance_cb, assign() the assigned partitions, and then start fetching messages. This cycle may take up to session.timeout.ms * 2 or more to complete.; After this call returns a consumer error will be returned by rd_kafka_consumer_poll (et.al) for each unavailable topic in the topics. The error will be RD_KAFKA_RESP_ERR_UNKNOWN_TOPIC_OR_PART for non-existent topics, and RD_KAFKA_RESP_ERR_TOPIC_AUTHORIZATION_FAILED for unauthorized topics. The consumer error will be raised through rd_kafka_consumer_poll() (et.al.) with the rd_kafka_message_t.err field set to one of the error codes mentioned above. The subscribe function itself is asynchronous and will not return an error on unavailable topics.

Parameters: rk \FFI\CData|null rd_kafka_t*; topics \FFI\CData|null const rd_kafka_topic_partition_list_t*
Returns: int rd_kafka_resp_err_t - RD_KAFKA_RESP_ERR_NO_ERROR on success or RD_KAFKA_RESP_ERR__INVALID_ARG if list is empty, contains invalid topics or regexes or duplicate entries, RD_KAFKA_RESP_ERR__FATAL if the consumer has raised a fatal error.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a0ebe15e9d0f39ccc84e9686f0fcf46f1

rd_kafka_subscription()¶

public static rd_kafka_subscription ( 
    \FFI\CData|null $rk, 
    \FFI\CData|null $topics
 ): int

Returns the current topic subscription.

Remarks: The application is responsible for calling rd_kafka_topic_partition_list_destroy on the returned list.

Parameters: rk \FFI\CData|null rd_kafka_t*; topics \FFI\CData|null rd_kafka_topic_partition_list_t**
Returns: int rd_kafka_resp_err_t - An error code on failure, otherwise topic is updated to point to a newly allocated topic list (possibly empty).

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ab66a2c014db2e652aa12466b137a6200

rd_kafka_test_fatal_error()¶

public static rd_kafka_test_fatal_error ( 
    \FFI\CData|null $rk, 
    int $err, 
    string|null $reason
 ): int

Trigger a fatal error for testing purposes.

Since there is no practical way to trigger real fatal errors in the idempotent producer, this method allows an application to trigger fabricated fatal errors in tests to check its error handling code.

Parameters: rk \FFI\CData|null rd_kafka_t* - Client instance.; err int rd_kafka_resp_err_t - The underlying error code.; reason string|null const char* - A human readable error reason. Will be prefixed with “test_fatal_error: ” to differentiate from real fatal errors.
Returns: int rd_kafka_resp_err_t - RD_KAFKA_RESP_ERR_NO_ERROR if a fatal error was triggered, or RD_KAFKA_RESP_ERR__PREV_IN_PROGRESS if a previous fatal error has already been triggered.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a2e603ee9942480165be3c48f006a7171

rd_kafka_thread_cnt()¶

public static rd_kafka_thread_cnt (  ): int|null

Retrieve the current number of threads in use by librdkafka.

Used by regression tests.

Returns: int|null int - )

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a0901699375c972b807ba5255773f017f

rd_kafka_topic_conf_destroy()¶

public static rd_kafka_topic_conf_destroy ( 
    \FFI\CData|null $topic_conf
 ): void

Parameters: topic_conf \FFI\CData|null rd_kafka_topic_conf_t*

rd_kafka_topic_conf_dump()¶

public static rd_kafka_topic_conf_dump ( 
    \FFI\CData|null $conf, 
    \FFI\CData|null $cntp
 ): \FFI\CData|null

Dump the topic configuration properties and values of conf to an array with "key", "value" pairs.

The number of entries in the array is returned in *cntp.

The dump must be freed with rd_kafka_conf_dump_free().

Parameters: conf \FFI\CData|null rd_kafka_topic_conf_t*; cntp \FFI\CData|null size_t*
Returns: \FFI\CData|null const char**

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#adc252b9f225f1fa6e1a1eb83a3560006

rd_kafka_topic_conf_dup()¶

public static rd_kafka_topic_conf_dup ( 
    \FFI\CData|null $conf
 ): \FFI\CData|null

Parameters: conf \FFI\CData|null const rd_kafka_topic_conf_t*
Returns: \FFI\CData|null rd_kafka_topic_conf_t*

rd_kafka_topic_conf_get()¶

public static rd_kafka_topic_conf_get ( 
    \FFI\CData|null $conf, 
    string|null $name, 
    \FFI\CData|null $dest, 
    \FFI\CData|null $dest_size
 ): int

Retrieve topic configuration value for property name.

See also: rd_kafka_conf_get()

Parameters: conf \FFI\CData|null const rd_kafka_topic_conf_t*; name string|null const char*; dest \FFI\CData|null char*; dest_size \FFI\CData|null size_t*
Returns: int rd_kafka_conf_res_t

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a56939e7f77106b9e810d59289443e25d

rd_kafka_topic_conf_new()¶

public static rd_kafka_topic_conf_new (  ): \FFI\CData|null

Create topic configuration object.

See also: Same semantics as for rd_kafka_conf_new().

Returns: \FFI\CData|null rd_kafka_topic_conf_t* - )

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a1a7032f87e7d868b80e38d0fd0ad119e

rd_kafka_topic_conf_set()¶

public static rd_kafka_topic_conf_set ( 
    \FFI\CData|null $conf, 
    string|null $name, 
    string|null $value, 
    \FFI\CData|null $errstr, 
    int|null $errstr_size
 ): int

Sets a single rd_kafka_topic_conf_t value by property name.

topic_conf should have been previously set up with rd_kafka_topic_conf_new().

Parameters: conf \FFI\CData|null rd_kafka_topic_conf_t*; name string|null const char*; value string|null const char*; errstr \FFI\CData|null char*; errstr_size int|null size_t
Returns: int rd_kafka_conf_res_t - rd_kafka_conf_res_t to indicate success or failure.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ac91b47f7733b324bf4159427e90ccd01

rd_kafka_topic_conf_set_msg_order_cmp()¶

public static rd_kafka_topic_conf_set_msg_order_cmp ( 
    \FFI\CData|null $topic_conf, 
    \FFI\CData|\Closure $msg_order_cmp
 ): void

Producer: Set message queueing order comparator callback.

The callback may be called in any thread at any time, it may be called multiple times for the same message.

Ordering comparator function constraints:

MUST be stable sort (same input gives same output).
MUST NOT call any rd_kafka_*() functions.
MUST NOT block or execute for prolonged periods of time.

The comparator shall compare the two messages and return:

< 0 if message a should be inserted before message b.
>=0 if message a should be inserted after message b.

Remarks: Insert sorting will be used to enqueue the message in the correct queue position, this comes at a cost of O(n).; If queuing.strategy=fifo new messages are enqueued to the tail of the queue regardless of msg_order_cmp, but retried messages are still affected by msg_order_cmp.

Warning: THIS IS AN EXPERIMENTAL API, SUBJECT TO CHANGE OR REMOVAL, DO NOT USE IN PRODUCTION.

Parameters: topic_conf \FFI\CData|null rd_kafka_topic_conf_t*; msg_order_cmp \FFI\CData|\Closure int()(const rd_kafka_message_t, const rd_kafka_message_t*)

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a760cee234c441d32f9421874a74e06d4

rd_kafka_topic_conf_set_opaque()¶

public static rd_kafka_topic_conf_set_opaque ( 
    \FFI\CData|null $conf, 
    \FFI\CData|object|string|null $opaque
 ): void

Sets the application's opaque pointer that will be passed to all topic callbacks as the rkt_opaque argument.

See also: rd_kafka_topic_opaque()

Parameters: conf \FFI\CData|null rd_kafka_topic_conf_t*; opaque \FFI\CData|object|string|null void*

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a227d943335cad18b55f8cf8024ba9943

rd_kafka_topic_conf_set_partitioner_cb()¶

public static rd_kafka_topic_conf_set_partitioner_cb ( 
    \FFI\CData|null $topic_conf, 
    \FFI\CData|\Closure $partitioner
 ): void

Producer: Set partitioner callback in provided topic conf object.

The partitioner may be called in any thread at any time, it may be called multiple times for the same message/key.

The callback's rkt_opaque argument is the opaque set by rd_kafka_topic_conf_set_opaque(). The callback's msg_opaque argument is the per-message opaque passed to produce().

Partitioner function constraints:

MUST NOT call any rd_kafka_*() functions except: rd_kafka_topic_partition_available()
MUST NOT block or execute for prolonged periods of time.
MUST return a value between 0 and partition_cnt-1, or the special RD_KAFKA_PARTITION_UA value if partitioning could not be performed.

Parameters: topic_conf \FFI\CData|null rd_kafka_topic_conf_t*; partitioner \FFI\CData|\Closure int32_t()(const rd_kafka_topic_t, const void*, size_t, int32_t, void*, void*)

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#abfc790b5e36c56ea6d79fdc32c57becf

rd_kafka_topic_destroy()¶

public static rd_kafka_topic_destroy ( 
    \FFI\CData|null $rkt
 ): void

Loose application's topic handle refcount as previously created with rd_kafka_topic_new().

Remarks: Since topic objects are refcounted (both internally and for the app) the topic object might not actually be destroyed by this call, but the application must consider the object destroyed.

Parameters: rkt \FFI\CData|null rd_kafka_topic_t* - )

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a91f46cd29d4f9abacd3ee3633c01d8ff

rd_kafka_topic_name()¶

public static rd_kafka_topic_name ( 
    \FFI\CData|null $rkt
 ): string|null

Parameters: rkt \FFI\CData|null const rd_kafka_topic_t*
Returns: string|null const char*

rd_kafka_topic_new()¶

public static rd_kafka_topic_new ( 
    \FFI\CData|null $rk, 
    string|null $topic, 
    \FFI\CData|null $conf
 ): \FFI\CData|null

Creates a new topic handle for topic named topic.

conf is an optional configuration for the topic created with rd_kafka_topic_conf_new() that will be used instead of the default topic configuration. The conf object is freed by this function and must not be used or destroyed by the application subsequently. See rd_kafka_topic_conf_set() et.al for more information.

Topic handles are refcounted internally and calling rd_kafka_topic_new() again with the same topic name will return the previous topic handle without updating the original handle's configuration. Applications must eventually call rd_kafka_topic_destroy() for each succesfull call to rd_kafka_topic_new() to clear up resources.

See also: rd_kafka_topic_destroy()

Parameters: rk \FFI\CData|null rd_kafka_t*; topic string|null const char*; conf \FFI\CData|null rd_kafka_topic_conf_t*
Returns: \FFI\CData|null rd_kafka_topic_t* - the new topic handle or NULL on error (use rd_kafka_errno2err() to convert system errno to an rd_kafka_resp_err_t error code.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ab1dcba74a35e8f3bfe3270ff600581d8

rd_kafka_topic_opaque()¶

public static rd_kafka_topic_opaque ( 
    \FFI\CData|null $rkt
 ): \FFI\CData|object|string|null

Parameters: rkt \FFI\CData|null const rd_kafka_topic_t*
Returns: \FFI\CData|object|string|null void*

rd_kafka_topic_partition_available()¶

public static rd_kafka_topic_partition_available ( 
    \FFI\CData|null $rkt, 
    int|null $partition
 ): int|null

Check if partition is available (has a leader broker).

Warning: This function must only be called from inside a partitioner function

Parameters: rkt \FFI\CData|null const rd_kafka_topic_t*; partition int|null int32_t
Returns: int|null int - 1 if the partition is available, else 0.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ad24c6cc7f37271e292f8105c64d77758

rd_kafka_topic_partition_destroy()¶

public static rd_kafka_topic_partition_destroy ( 
    \FFI\CData|null $rktpar
 ): void

Destroy a rd_kafka_topic_partition_t.

Remarks: This must not be called for elements in a topic partition list.

Parameters: rktpar \FFI\CData|null rd_kafka_topic_partition_t* - )

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ac5a7b02e3af816cfacbcfa6468c40c9a

rd_kafka_topic_partition_get_leader_epoch()¶

public static rd_kafka_topic_partition_get_leader_epoch ( 
    \FFI\CData|null $rktpar
 ): int|null

Remarks: See KIP-320 for more information.

Parameters: rktpar \FFI\CData|null const rd_kafka_topic_partition_t* - ) - Partition object.
Returns: int|null int32_t - the offset leader epoch, if relevant and known, else -1.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ad8ae250ddb522b220b64e0b1627ad8b8

rd_kafka_topic_partition_list_add()¶

public static rd_kafka_topic_partition_list_add ( 
    \FFI\CData|null $rktparlist, 
    string|null $topic, 
    int|null $partition
 ): \FFI\CData|null

Add topic+partition to list.

Parameters: rktparlist \FFI\CData|null rd_kafka_topic_partition_list_t* - List to extend; topic string|null const char* - Topic name (copied); partition int|null int32_t - Partition id
Returns: \FFI\CData|null rd_kafka_topic_partition_t* - The object which can be used to fill in additionals fields.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a123ce30e08b31d4ff0fcf6ebe876173d

rd_kafka_topic_partition_list_add_range()¶

public static rd_kafka_topic_partition_list_add_range ( 
    \FFI\CData|null $rktparlist, 
    string|null $topic, 
    int|null $start, 
    int|null $stop
 ): void

Add range of partitions from start to stop inclusive.

Parameters: rktparlist \FFI\CData|null rd_kafka_topic_partition_list_t* - List to extend; topic string|null const char* - Topic name (copied); start int|null int32_t - Start partition of range; stop int|null int32_t - Last partition of range (inclusive)

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a6365695de425e7866ddd0c59d704111b

rd_kafka_topic_partition_list_copy()¶

public static rd_kafka_topic_partition_list_copy ( 
    \FFI\CData|null $src
 ): \FFI\CData|null

Make a copy of an existing list.

Parameters: src \FFI\CData|null const rd_kafka_topic_partition_list_t* - ) - The existing list to copy.
Returns: \FFI\CData|null rd_kafka_topic_partition_list_t* - A new list fully populated to be identical to src

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a66fd3f8c00ffbd0ea740a638dd0a95f7

rd_kafka_topic_partition_list_del()¶

public static rd_kafka_topic_partition_list_del ( 
    \FFI\CData|null $rktparlist, 
    string|null $topic, 
    int|null $partition
 ): int|null

Delete partition from list.

Remarks: Any held indices to elems[] are unusable after this call returns 1.

Parameters: rktparlist \FFI\CData|null rd_kafka_topic_partition_list_t* - List to modify; topic string|null const char* - Topic name to match; partition int|null int32_t - Partition to match
Returns: int|null int - 1 if partition was found (and removed), else 0.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a94a8195aa5f0195d020494bced858a97

rd_kafka_topic_partition_list_del_by_idx()¶

public static rd_kafka_topic_partition_list_del_by_idx ( 
    \FFI\CData|null $rktparlist, 
    int|null $idx
 ): int|null

Delete partition from list by elems[] index.

See also: rd_kafka_topic_partition_list_del()

Parameters: rktparlist \FFI\CData|null rd_kafka_topic_partition_list_t*; idx int|null int
Returns: int|null int - 1 if partition was found (and removed), else 0.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a8476ebf3c2f54ddee53e0863feb85463

rd_kafka_topic_partition_list_destroy()¶

public static rd_kafka_topic_partition_list_destroy ( 
    \FFI\CData|null $rkparlist
 ): void

Parameters: rkparlist \FFI\CData|null rd_kafka_topic_partition_list_t*

rd_kafka_topic_partition_list_find()¶

public static rd_kafka_topic_partition_list_find ( 
    \FFI\CData|null $rktparlist, 
    string|null $topic, 
    int|null $partition
 ): \FFI\CData|null

Find element by topic and partition.

Parameters: rktparlist \FFI\CData|null rd_kafka_topic_partition_list_t*; topic string|null const char*; partition int|null int32_t
Returns: \FFI\CData|null rd_kafka_topic_partition_t* - a pointer to the first matching element, or NULL if not found.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a122c284913412e8e043fe7b51aebc0d7

rd_kafka_topic_partition_list_new()¶

public static rd_kafka_topic_partition_list_new ( 
    int|null $size
 ): \FFI\CData|null

Create a new list/vector Topic+Partition container.

Remarks: Use rd_kafka_topic_partition_list_destroy() to free all resources in use by a list and the list itself.

See also: rd_kafka_topic_partition_list_add()

Parameters: size int|null int - ) - Initial allocated size used when the expected number of elements is known or can be estimated. Avoids reallocation and possibly relocation of the elems array.
Returns: \FFI\CData|null rd_kafka_topic_partition_list_t* - A newly allocated Topic+Partition list.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#afb87d24333b6ad5a7415b06882f06b2a

rd_kafka_topic_partition_list_set_offset()¶

public static rd_kafka_topic_partition_list_set_offset ( 
    \FFI\CData|null $rktparlist, 
    string|null $topic, 
    int|null $partition, 
    int|null $offset
 ): int

Set offset to offset for topic and partition.

Parameters: rktparlist \FFI\CData|null rd_kafka_topic_partition_list_t*; topic string|null const char*; partition int|null int32_t; offset int|null int64_t
Returns: int rd_kafka_resp_err_t - RD_KAFKA_RESP_ERR_NO_ERROR on success or RD_KAFKA_RESP_ERR__UNKNOWN_PARTITION if partition was not found in the list.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a102b340b901babb247d2c0a8580a094d

rd_kafka_topic_partition_list_sort()¶

public static rd_kafka_topic_partition_list_sort ( 
    \FFI\CData|null $rktparlist, 
    \FFI\CData|\Closure $cmp, 
    \FFI\CData|object|string|null $opaque
 ): void

Sort list using comparator cmp.

If cmp is NULL the default comparator will be used that sorts by ascending topic name and partition.

cmp_opaque is provided as the cmp_opaque argument to cmp.

Parameters: rktparlist \FFI\CData|null rd_kafka_topic_partition_list_t*; cmp \FFI\CData|\Closure int()(const void, const void*, void*); opaque \FFI\CData|object|string|null void*

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#af56e41c6cb82d6ded5cd973976cd62df

rd_kafka_topic_partition_result_error()¶

public static rd_kafka_topic_partition_result_error ( 
    \FFI\CData|null $partition_result
 ): \FFI\CData|null

Remarks: lifetime of the returned string is the same as the partition_result.

Parameters: partition_result \FFI\CData|null const rd_kafka_topic_partition_result_t* - )
Returns: \FFI\CData|null const rd_kafka_error_t* - the error object from the topic partition result object.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#aef373e6e147ea24ccd9d581bf53d4609

rd_kafka_topic_partition_result_partition()¶

public static rd_kafka_topic_partition_result_partition ( 
    \FFI\CData|null $partition_result
 ): \FFI\CData|null

Topic Partition Result provides per-topic+partition operation result Consists of TopicPartition object and error object.

Remarks: lifetime of the returned string is the same as the partition_result. The error object is set inside the topic partition object. For the detailed error information, use rd_kafka_topic_partition_result_error()

Parameters: partition_result \FFI\CData|null const rd_kafka_topic_partition_result_t* - )
Returns: \FFI\CData|null const rd_kafka_topic_partition_t* - the topic partition object from the topic partition result object.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a2a72bc6dee45e2c291a4e4934d4f8ed3

rd_kafka_topic_partition_set_leader_epoch()¶

public static rd_kafka_topic_partition_set_leader_epoch ( 
    \FFI\CData|null $rktpar, 
    int|null $leader_epoch
 ): void

Sets the offset leader epoch (use -1 to clear).

Remarks: See KIP-320 for more information.

Parameters: rktpar \FFI\CData|null rd_kafka_topic_partition_t* - Partition object.; leader_epoch int|null int32_t - Offset leader epoch, use -1 to reset.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ab70804a35d1a6e8c21f276d75ef8ea6e

rd_kafka_topic_result_error()¶

public static rd_kafka_topic_result_error ( 
    \FFI\CData|null $topicres
 ): int

Topic result provides per-topic operation result information.

Parameters: topicres \FFI\CData|null const rd_kafka_topic_result_t* - )
Returns: int rd_kafka_resp_err_t - the error code for the given topic result.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a962bb4f4bcd8cf12a9aa9ef361ed7526

rd_kafka_topic_result_error_string()¶

public static rd_kafka_topic_result_error_string ( 
    \FFI\CData|null $topicres
 ): string|null

Remarks: lifetime of the returned string is the same as the topicres.

Parameters: topicres \FFI\CData|null const rd_kafka_topic_result_t* - )
Returns: string|null const char* - the human readable error string for the given topic result, or NULL if there was no error.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a7f04b553274f482e2886c0a22257cab3

rd_kafka_topic_result_name()¶

public static rd_kafka_topic_result_name ( 
    \FFI\CData|null $topicres
 ): string|null

Remarks: lifetime of the returned string is the same as the topicres.

Parameters: topicres \FFI\CData|null const rd_kafka_topic_result_t* - )
Returns: string|null const char* - the name of the topic for the given topic result.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a8c4abbefa7f716f3f35ad7927021e0da

rd_kafka_type()¶

public static rd_kafka_type ( 
    \FFI\CData|null $rk
 ): int

Parameters: rk \FFI\CData|null const rd_kafka_t*
Returns: int rd_kafka_type_t

rd_kafka_unittest()¶

public static rd_kafka_unittest (  ): int|null

Run librdkafka's built-in unit-tests.

Returns: int|null int - ) - the number of failures, or 0 if all tests passed.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#ab932d463be030a5e83ebfc5186ff20b8

rd_kafka_unsubscribe()¶

public static rd_kafka_unsubscribe ( 
    \FFI\CData|null $rk
 ): int

Parameters: rk \FFI\CData|null rd_kafka_t*
Returns: int rd_kafka_resp_err_t

rd_kafka_version()¶

public static rd_kafka_version (  ): int|null

Returns the librdkafka version as integer.

See also: See RD_KAFKA_VERSION for how to parse the integer format.; Use rd_kafka_version_str() to retreive the version as a string.

Returns: int|null int - ) - Version integer.

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a83e363606ef2da2e91b7429b229dbc8e

rd_kafka_version_str()¶

public static rd_kafka_version_str (  ): string|null

Returns the librdkafka version as string.

Returns: string|null const char* - ) - Version string

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a5b48bd8309abc31a7d2256baffb5957d

rd_kafka_wait_destroyed()¶

public static rd_kafka_wait_destroyed ( 
    int|null $timeout_ms
 ): int|null

Wait for all rd_kafka_t objects to be destroyed.

Returns 0 if all kafka objects are now destroyed, or -1 if the timeout was reached.

Remarks: This function is deprecated.

Parameters: timeout_ms int|null int - )
Returns: int|null int

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#aa90f2c92a382dbd0a090d40caa73356d

rd_kafka_yield()¶

public static rd_kafka_yield ( 
    \FFI\CData|null $rk
 ): void

Cancels the current callback dispatcher (rd_kafka_poll(), rd_kafka_consume_callback(), etc).

A callback may use this to force an immediate return to the calling code (caller of e.g. rd_kafka_poll()) without processing any further events.

Remarks: This function MUST ONLY be called from within a librdkafka callback.

Parameters: rk \FFI\CData|null rd_kafka_t* - )

See also

https://docs.confluent.io/platform/current/clients/librdkafka/html/rdkafka_8h.html#a111628df6c84716c4b550f8509ac6a6d

requireMethod()¶

public static requireMethod ( 
    string $name
 ): void

Method must be supported by current binding version otherwise an exception is thrown.

Parameters: name string

requireVersion()¶

public static requireVersion ( 
    string $operator, 
    string $version
 ): void

Version must match the current binding otherwise an exception is thrown.

Parameters: operator string; version string

type()¶

public static type ( 
    string|\FFI\CType $type
 ): \FFI\CType

Parameters: type string|\FFI\CType
Returns: \FFI\CType

versionMatches()¶

public static versionMatches ( 
    string $operator, 
    string $version
 ): bool

Whether version matches the current binding version

Parameters: operator string; version string
Returns: bool

Test Coverage 💛¶

💛 Lines: 81.82% (72 / 88)
🧡 Methods: 61.11% (11 / 18)