Package com.exoscale.sdk.model

Class JsonSchemaKafka

java.lang.Object
com.exoscale.sdk.model.JsonSchemaKafka
@Generated(value="org.openapitools.codegen.languages.JavaClientCodegen", comments="Generator version: 7.4.0") public class JsonSchemaKafka extends Object
JsonSchemaKafka

  • Field Details

    • JSON_PROPERTY_SASL_OAUTHBEARER_EXPECTED_AUDIENCE

      public static final String JSON_PROPERTY_SASL_OAUTHBEARER_EXPECTED_AUDIENCE
      See Also:

    • JSON_PROPERTY_GROUP_MAX_SESSION_TIMEOUT_MS

      public static final String JSON_PROPERTY_GROUP_MAX_SESSION_TIMEOUT_MS
      See Also:

    • JSON_PROPERTY_LOG_FLUSH_INTERVAL_MESSAGES

      public static final String JSON_PROPERTY_LOG_FLUSH_INTERVAL_MESSAGES
      See Also:

    • JSON_PROPERTY_SASL_OAUTHBEARER_JWKS_ENDPOINT_URL

      public static final String JSON_PROPERTY_SASL_OAUTHBEARER_JWKS_ENDPOINT_URL
      See Also:

    • JSON_PROPERTY_MAX_CONNECTIONS_PER_IP

      public static final String JSON_PROPERTY_MAX_CONNECTIONS_PER_IP
      See Also:

    • JSON_PROPERTY_SASL_OAUTHBEARER_EXPECTED_ISSUER

      public static final String JSON_PROPERTY_SASL_OAUTHBEARER_EXPECTED_ISSUER
      See Also:

    • JSON_PROPERTY_LOG_INDEX_SIZE_MAX_BYTES

      public static final String JSON_PROPERTY_LOG_INDEX_SIZE_MAX_BYTES
      See Also:

    • JSON_PROPERTY_AUTO_CREATE_TOPICS_ENABLE

      public static final String JSON_PROPERTY_AUTO_CREATE_TOPICS_ENABLE
      See Also:

    • JSON_PROPERTY_LOG_INDEX_INTERVAL_BYTES

      public static final String JSON_PROPERTY_LOG_INDEX_INTERVAL_BYTES
      See Also:

    • JSON_PROPERTY_REPLICA_FETCH_MAX_BYTES

      public static final String JSON_PROPERTY_REPLICA_FETCH_MAX_BYTES
      See Also:

    • JSON_PROPERTY_NUM_PARTITIONS

      public static final String JSON_PROPERTY_NUM_PARTITIONS
      See Also:

    • JSON_PROPERTY_TRANSACTION_STATE_LOG_SEGMENT_BYTES

      public static final String JSON_PROPERTY_TRANSACTION_STATE_LOG_SEGMENT_BYTES
      See Also:

    • JSON_PROPERTY_REPLICA_FETCH_RESPONSE_MAX_BYTES

      public static final String JSON_PROPERTY_REPLICA_FETCH_RESPONSE_MAX_BYTES
      See Also:

    • JSON_PROPERTY_LOG_MESSAGE_TIMESTAMP_TYPE

      public static final String JSON_PROPERTY_LOG_MESSAGE_TIMESTAMP_TYPE
      See Also:

    • JSON_PROPERTY_CONNECTIONS_MAX_IDLE_MS

      public static final String JSON_PROPERTY_CONNECTIONS_MAX_IDLE_MS
      See Also:

    • JSON_PROPERTY_LOG_FLUSH_INTERVAL_MS

      public static final String JSON_PROPERTY_LOG_FLUSH_INTERVAL_MS
      See Also:

    • JSON_PROPERTY_LOG_PREALLOCATE

      public static final String JSON_PROPERTY_LOG_PREALLOCATE
      See Also:

    • JSON_PROPERTY_LOG_SEGMENT_DELETE_DELAY_MS

      public static final String JSON_PROPERTY_LOG_SEGMENT_DELETE_DELAY_MS
      See Also:

    • JSON_PROPERTY_MESSAGE_MAX_BYTES

      public static final String JSON_PROPERTY_MESSAGE_MAX_BYTES
      See Also:

    • JSON_PROPERTY_GROUP_INITIAL_REBALANCE_DELAY_MS

      public static final String JSON_PROPERTY_GROUP_INITIAL_REBALANCE_DELAY_MS
      See Also:

    • JSON_PROPERTY_LOG_LOCAL_RETENTION_BYTES

      public static final String JSON_PROPERTY_LOG_LOCAL_RETENTION_BYTES
      See Also:

    • JSON_PROPERTY_LOG_ROLL_JITTER_MS

      public static final String JSON_PROPERTY_LOG_ROLL_JITTER_MS
      See Also:

    • JSON_PROPERTY_TRANSACTION_REMOVE_EXPIRED_TRANSACTION_CLEANUP_INTERVAL_MS

      public static final String JSON_PROPERTY_TRANSACTION_REMOVE_EXPIRED_TRANSACTION_CLEANUP_INTERVAL_MS
      See Also:

    • JSON_PROPERTY_TRANSACTION_PARTITION_VERIFICATION_ENABLE

      public static final String JSON_PROPERTY_TRANSACTION_PARTITION_VERIFICATION_ENABLE
      See Also:

    • JSON_PROPERTY_DEFAULT_REPLICATION_FACTOR

      public static final String JSON_PROPERTY_DEFAULT_REPLICATION_FACTOR
      See Also:

    • JSON_PROPERTY_LOG_ROLL_MS

      public static final String JSON_PROPERTY_LOG_ROLL_MS
      See Also:

    • JSON_PROPERTY_PRODUCER_PURGATORY_PURGE_INTERVAL_REQUESTS

      public static final String JSON_PROPERTY_PRODUCER_PURGATORY_PURGE_INTERVAL_REQUESTS
      See Also:

    • JSON_PROPERTY_LOG_RETENTION_BYTES

      public static final String JSON_PROPERTY_LOG_RETENTION_BYTES
      See Also:

    • JSON_PROPERTY_MIN_INSYNC_REPLICAS

      public static final String JSON_PROPERTY_MIN_INSYNC_REPLICAS
      See Also:

    • JSON_PROPERTY_COMPRESSION_TYPE

      public static final String JSON_PROPERTY_COMPRESSION_TYPE
      See Also:

    • JSON_PROPERTY_LOG_MESSAGE_TIMESTAMP_DIFFERENCE_MAX_MS

      public static final String JSON_PROPERTY_LOG_MESSAGE_TIMESTAMP_DIFFERENCE_MAX_MS
      See Also:

    • JSON_PROPERTY_LOG_LOCAL_RETENTION_MS

      public static final String JSON_PROPERTY_LOG_LOCAL_RETENTION_MS
      See Also:

    • JSON_PROPERTY_LOG_MESSAGE_DOWNCONVERSION_ENABLE

      public static final String JSON_PROPERTY_LOG_MESSAGE_DOWNCONVERSION_ENABLE
      See Also:

    • JSON_PROPERTY_SASL_OAUTHBEARER_SUB_CLAIM_NAME

      public static final String JSON_PROPERTY_SASL_OAUTHBEARER_SUB_CLAIM_NAME
      See Also:

    • JSON_PROPERTY_MAX_INCREMENTAL_FETCH_SESSION_CACHE_SLOTS

      public static final String JSON_PROPERTY_MAX_INCREMENTAL_FETCH_SESSION_CACHE_SLOTS
      See Also:

    • JSON_PROPERTY_LOG_RETENTION_HOURS

      public static final String JSON_PROPERTY_LOG_RETENTION_HOURS
      See Also:

    • JSON_PROPERTY_GROUP_MIN_SESSION_TIMEOUT_MS

      public static final String JSON_PROPERTY_GROUP_MIN_SESSION_TIMEOUT_MS
      See Also:

    • JSON_PROPERTY_SOCKET_REQUEST_MAX_BYTES

      public static final String JSON_PROPERTY_SOCKET_REQUEST_MAX_BYTES
      See Also:

    • JSON_PROPERTY_LOG_SEGMENT_BYTES

      public static final String JSON_PROPERTY_LOG_SEGMENT_BYTES
      See Also:

    • JSON_PROPERTY_LOG_CLEANUP_AND_COMPACTION

      public static final String JSON_PROPERTY_LOG_CLEANUP_AND_COMPACTION
      See Also:

    • JSON_PROPERTY_OFFSETS_RETENTION_MINUTES

      public static final String JSON_PROPERTY_OFFSETS_RETENTION_MINUTES
      See Also:

    • JSON_PROPERTY_LOG_RETENTION_MS

      public static final String JSON_PROPERTY_LOG_RETENTION_MS
      See Also:

  • Constructor Details

    • JsonSchemaKafka

      public JsonSchemaKafka()

  • Method Details

    • saslOauthbearerExpectedAudience

      public JsonSchemaKafka saslOauthbearerExpectedAudience(String saslOauthbearerExpectedAudience)

    • getSaslOauthbearerExpectedAudience

      @Nullable public String getSaslOauthbearerExpectedAudience()
      The (optional) comma-delimited setting for the broker to use to verify that the JWT was issued for one of the expected audiences.
      Returns:
      saslOauthbearerExpectedAudience

    • setSaslOauthbearerExpectedAudience

      public void setSaslOauthbearerExpectedAudience(String saslOauthbearerExpectedAudience)

    • groupMaxSessionTimeoutMs

      public JsonSchemaKafka groupMaxSessionTimeoutMs(Integer groupMaxSessionTimeoutMs)

    • getGroupMaxSessionTimeoutMs

      @Nullable public Integer getGroupMaxSessionTimeoutMs()
      The maximum allowed session timeout for registered consumers. Longer timeouts give consumers more time to process messages in between heartbeats at the cost of a longer time to detect failures. minimum: 0 maximum: 1800000
      Returns:
      groupMaxSessionTimeoutMs

    • setGroupMaxSessionTimeoutMs

      public void setGroupMaxSessionTimeoutMs(Integer groupMaxSessionTimeoutMs)

    • logFlushIntervalMessages

      public JsonSchemaKafka logFlushIntervalMessages(Integer logFlushIntervalMessages)

    • getLogFlushIntervalMessages

      @Nullable public Integer getLogFlushIntervalMessages()
      The number of messages accumulated on a log partition before messages are flushed to disk minimum: 1 maximum: 9223372036854775807
      Returns:
      logFlushIntervalMessages

    • setLogFlushIntervalMessages

      public void setLogFlushIntervalMessages(Integer logFlushIntervalMessages)

    • saslOauthbearerJwksEndpointUrl

      public JsonSchemaKafka saslOauthbearerJwksEndpointUrl(String saslOauthbearerJwksEndpointUrl)

    • getSaslOauthbearerJwksEndpointUrl

      @Nullable public String getSaslOauthbearerJwksEndpointUrl()
      OIDC JWKS endpoint URL. By setting this the SASL SSL OAuth2/OIDC authentication is enabled. See also other options for SASL OAuth2/OIDC.
      Returns:
      saslOauthbearerJwksEndpointUrl

    • setSaslOauthbearerJwksEndpointUrl

      public void setSaslOauthbearerJwksEndpointUrl(String saslOauthbearerJwksEndpointUrl)

    • maxConnectionsPerIp

      public JsonSchemaKafka maxConnectionsPerIp(Integer maxConnectionsPerIp)

    • getMaxConnectionsPerIp

      @Nullable public Integer getMaxConnectionsPerIp()
      The maximum number of connections allowed from each ip address (defaults to 2147483647). minimum: 256 maximum: 2147483647
      Returns:
      maxConnectionsPerIp

    • setMaxConnectionsPerIp

      public void setMaxConnectionsPerIp(Integer maxConnectionsPerIp)

    • saslOauthbearerExpectedIssuer

      public JsonSchemaKafka saslOauthbearerExpectedIssuer(String saslOauthbearerExpectedIssuer)

    • getSaslOauthbearerExpectedIssuer

      @Nullable public String getSaslOauthbearerExpectedIssuer()
      Optional setting for the broker to use to verify that the JWT was created by the expected issuer.
      Returns:
      saslOauthbearerExpectedIssuer

    • setSaslOauthbearerExpectedIssuer

      public void setSaslOauthbearerExpectedIssuer(String saslOauthbearerExpectedIssuer)

    • logIndexSizeMaxBytes

      public JsonSchemaKafka logIndexSizeMaxBytes(Integer logIndexSizeMaxBytes)

    • getLogIndexSizeMaxBytes

      @Nullable public Integer getLogIndexSizeMaxBytes()
      The maximum size in bytes of the offset index minimum: 1048576 maximum: 104857600
      Returns:
      logIndexSizeMaxBytes

    • setLogIndexSizeMaxBytes

      public void setLogIndexSizeMaxBytes(Integer logIndexSizeMaxBytes)

    • autoCreateTopicsEnable

      public JsonSchemaKafka autoCreateTopicsEnable(Boolean autoCreateTopicsEnable)

    • getAutoCreateTopicsEnable

      @Nullable public Boolean getAutoCreateTopicsEnable()
      Enable auto creation of topics
      Returns:
      autoCreateTopicsEnable

    • setAutoCreateTopicsEnable

      public void setAutoCreateTopicsEnable(Boolean autoCreateTopicsEnable)

    • logIndexIntervalBytes

      public JsonSchemaKafka logIndexIntervalBytes(Integer logIndexIntervalBytes)

    • getLogIndexIntervalBytes

      @Nullable public Integer getLogIndexIntervalBytes()
      The interval with which Kafka adds an entry to the offset index minimum: 0 maximum: 104857600
      Returns:
      logIndexIntervalBytes

    • setLogIndexIntervalBytes

      public void setLogIndexIntervalBytes(Integer logIndexIntervalBytes)

    • replicaFetchMaxBytes

      public JsonSchemaKafka replicaFetchMaxBytes(Integer replicaFetchMaxBytes)

    • getReplicaFetchMaxBytes

      @Nullable public Integer getReplicaFetchMaxBytes()
      The number of bytes of messages to attempt to fetch for each partition (defaults to 1048576). This is not an absolute maximum, if the first record batch in the first non-empty partition of the fetch is larger than this value, the record batch will still be returned to ensure that progress can be made. minimum: 1048576 maximum: 104857600
      Returns:
      replicaFetchMaxBytes

    • setReplicaFetchMaxBytes

      public void setReplicaFetchMaxBytes(Integer replicaFetchMaxBytes)

    • numPartitions

      public JsonSchemaKafka numPartitions(Integer numPartitions)

    • getNumPartitions

      @Nullable public Integer getNumPartitions()
      Number of partitions for autocreated topics minimum: 1 maximum: 1000
      Returns:
      numPartitions

    • setNumPartitions

      public void setNumPartitions(Integer numPartitions)

    • transactionStateLogSegmentBytes

      public JsonSchemaKafka transactionStateLogSegmentBytes(Integer transactionStateLogSegmentBytes)

    • getTransactionStateLogSegmentBytes

      @Nullable public Integer getTransactionStateLogSegmentBytes()
      The transaction topic segment bytes should be kept relatively small in order to facilitate faster log compaction and cache loads (defaults to 104857600 (100 mebibytes)). minimum: 1048576 maximum: 2147483647
      Returns:
      transactionStateLogSegmentBytes

    • setTransactionStateLogSegmentBytes

      public void setTransactionStateLogSegmentBytes(Integer transactionStateLogSegmentBytes)

    • replicaFetchResponseMaxBytes

      public JsonSchemaKafka replicaFetchResponseMaxBytes(Integer replicaFetchResponseMaxBytes)

    • getReplicaFetchResponseMaxBytes

      @Nullable public Integer getReplicaFetchResponseMaxBytes()
      Maximum bytes expected for the entire fetch response (defaults to 10485760). Records are fetched in batches, and if the first record batch in the first non-empty partition of the fetch is larger than this value, the record batch will still be returned to ensure that progress can be made. As such, this is not an absolute maximum. minimum: 10485760 maximum: 1048576000
      Returns:
      replicaFetchResponseMaxBytes

    • setReplicaFetchResponseMaxBytes

      public void setReplicaFetchResponseMaxBytes(Integer replicaFetchResponseMaxBytes)

    • logMessageTimestampType

      public JsonSchemaKafka logMessageTimestampType(JsonSchemaKafka.LogMessageTimestampTypeEnum logMessageTimestampType)

    • getLogMessageTimestampType

      @Nullable public JsonSchemaKafka.LogMessageTimestampTypeEnum getLogMessageTimestampType()
      Define whether the timestamp in the message is message create time or log append time.
      Returns:
      logMessageTimestampType

    • setLogMessageTimestampType

      public void setLogMessageTimestampType(JsonSchemaKafka.LogMessageTimestampTypeEnum logMessageTimestampType)

    • connectionsMaxIdleMs

      public JsonSchemaKafka connectionsMaxIdleMs(Integer connectionsMaxIdleMs)

    • getConnectionsMaxIdleMs

      @Nullable public Integer getConnectionsMaxIdleMs()
      Idle connections timeout: the server socket processor threads close the connections that idle for longer than this. minimum: 1000 maximum: 3600000
      Returns:
      connectionsMaxIdleMs

    • setConnectionsMaxIdleMs

      public void setConnectionsMaxIdleMs(Integer connectionsMaxIdleMs)

    • logFlushIntervalMs

      public JsonSchemaKafka logFlushIntervalMs(Integer logFlushIntervalMs)

    • getLogFlushIntervalMs

      @Nullable public Integer getLogFlushIntervalMs()
      The maximum time in ms that a message in any topic is kept in memory before flushed to disk. If not set, the value in log.flush.scheduler.interval.ms is used minimum: 0 maximum: 9223372036854775807
      Returns:
      logFlushIntervalMs

    • setLogFlushIntervalMs

      public void setLogFlushIntervalMs(Integer logFlushIntervalMs)

    • logPreallocate

      public JsonSchemaKafka logPreallocate(Boolean logPreallocate)

    • getLogPreallocate

      @Nullable public Boolean getLogPreallocate()
      Should pre allocate file when create new segment?
      Returns:
      logPreallocate

    • setLogPreallocate

      public void setLogPreallocate(Boolean logPreallocate)

    • logSegmentDeleteDelayMs

      public JsonSchemaKafka logSegmentDeleteDelayMs(Integer logSegmentDeleteDelayMs)

    • getLogSegmentDeleteDelayMs

      @Nullable public Integer getLogSegmentDeleteDelayMs()
      The amount of time to wait before deleting a file from the filesystem minimum: 0 maximum: 3600000
      Returns:
      logSegmentDeleteDelayMs

    • setLogSegmentDeleteDelayMs

      public void setLogSegmentDeleteDelayMs(Integer logSegmentDeleteDelayMs)

    • messageMaxBytes

      public JsonSchemaKafka messageMaxBytes(Integer messageMaxBytes)

    • getMessageMaxBytes

      @Nullable public Integer getMessageMaxBytes()
      The maximum size of message that the server can receive. minimum: 0 maximum: 100001200
      Returns:
      messageMaxBytes

    • setMessageMaxBytes

      public void setMessageMaxBytes(Integer messageMaxBytes)

    • groupInitialRebalanceDelayMs

      public JsonSchemaKafka groupInitialRebalanceDelayMs(Integer groupInitialRebalanceDelayMs)

    • getGroupInitialRebalanceDelayMs

      @Nullable public Integer getGroupInitialRebalanceDelayMs()
      The amount of time, in milliseconds, the group coordinator will wait for more consumers to join a new group before performing the first rebalance. A longer delay means potentially fewer rebalances, but increases the time until processing begins. The default value for this is 3 seconds. During development and testing it might be desirable to set this to 0 in order to not delay test execution time. minimum: 0 maximum: 300000
      Returns:
      groupInitialRebalanceDelayMs

    • setGroupInitialRebalanceDelayMs

      public void setGroupInitialRebalanceDelayMs(Integer groupInitialRebalanceDelayMs)

    • logLocalRetentionBytes

      public JsonSchemaKafka logLocalRetentionBytes(Integer logLocalRetentionBytes)

    • getLogLocalRetentionBytes

      @Nullable public Integer getLogLocalRetentionBytes()
      The maximum size of local log segments that can grow for a partition before it gets eligible for deletion. If set to -2, the value of log.retention.bytes is used. The effective value should always be less than or equal to log.retention.bytes value. minimum: -2 maximum: 9223372036854775807
      Returns:
      logLocalRetentionBytes

    • setLogLocalRetentionBytes

      public void setLogLocalRetentionBytes(Integer logLocalRetentionBytes)

    • logRollJitterMs

      public JsonSchemaKafka logRollJitterMs(Integer logRollJitterMs)

    • getLogRollJitterMs

      @Nullable public Integer getLogRollJitterMs()
      The maximum jitter to subtract from logRollTimeMillis (in milliseconds). If not set, the value in log.roll.jitter.hours is used minimum: 0 maximum: 9223372036854775807
      Returns:
      logRollJitterMs

    • setLogRollJitterMs

      public void setLogRollJitterMs(Integer logRollJitterMs)

    • transactionRemoveExpiredTransactionCleanupIntervalMs

      public JsonSchemaKafka transactionRemoveExpiredTransactionCleanupIntervalMs(Integer transactionRemoveExpiredTransactionCleanupIntervalMs)

    • getTransactionRemoveExpiredTransactionCleanupIntervalMs

      @Nullable public Integer getTransactionRemoveExpiredTransactionCleanupIntervalMs()
      The interval at which to remove transactions that have expired due to transactional.id.expiration.ms passing (defaults to 3600000 (1 hour)). minimum: 600000 maximum: 3600000
      Returns:
      transactionRemoveExpiredTransactionCleanupIntervalMs

    • setTransactionRemoveExpiredTransactionCleanupIntervalMs

      public void setTransactionRemoveExpiredTransactionCleanupIntervalMs(Integer transactionRemoveExpiredTransactionCleanupIntervalMs)

    • transactionPartitionVerificationEnable

      public JsonSchemaKafka transactionPartitionVerificationEnable(Boolean transactionPartitionVerificationEnable)

    • getTransactionPartitionVerificationEnable

      @Nullable public Boolean getTransactionPartitionVerificationEnable()
      Enable verification that checks that the partition has been added to the transaction before writing transactional records to the partition
      Returns:
      transactionPartitionVerificationEnable

    • setTransactionPartitionVerificationEnable

      public void setTransactionPartitionVerificationEnable(Boolean transactionPartitionVerificationEnable)

    • defaultReplicationFactor

      public JsonSchemaKafka defaultReplicationFactor(Integer defaultReplicationFactor)

    • getDefaultReplicationFactor

      @Nullable public Integer getDefaultReplicationFactor()
      Replication factor for autocreated topics minimum: 1 maximum: 10
      Returns:
      defaultReplicationFactor

    • setDefaultReplicationFactor

      public void setDefaultReplicationFactor(Integer defaultReplicationFactor)

    • logRollMs

      public JsonSchemaKafka logRollMs(Integer logRollMs)

    • getLogRollMs

      @Nullable public Integer getLogRollMs()
      The maximum time before a new log segment is rolled out (in milliseconds). minimum: 1 maximum: 9223372036854775807
      Returns:
      logRollMs

    • setLogRollMs

      public void setLogRollMs(Integer logRollMs)

    • producerPurgatoryPurgeIntervalRequests

      public JsonSchemaKafka producerPurgatoryPurgeIntervalRequests(Integer producerPurgatoryPurgeIntervalRequests)

    • getProducerPurgatoryPurgeIntervalRequests

      @Nullable public Integer getProducerPurgatoryPurgeIntervalRequests()
      The purge interval (in number of requests) of the producer request purgatory(defaults to 1000). minimum: 10 maximum: 10000
      Returns:
      producerPurgatoryPurgeIntervalRequests

    • setProducerPurgatoryPurgeIntervalRequests

      public void setProducerPurgatoryPurgeIntervalRequests(Integer producerPurgatoryPurgeIntervalRequests)

    • logRetentionBytes

      public JsonSchemaKafka logRetentionBytes(Integer logRetentionBytes)

    • getLogRetentionBytes

      @Nullable public Integer getLogRetentionBytes()
      The maximum size of the log before deleting messages minimum: -1 maximum: 9223372036854775807
      Returns:
      logRetentionBytes

    • setLogRetentionBytes

      public void setLogRetentionBytes(Integer logRetentionBytes)

    • minInsyncReplicas

      public JsonSchemaKafka minInsyncReplicas(Integer minInsyncReplicas)

    • getMinInsyncReplicas

      @Nullable public Integer getMinInsyncReplicas()
      When a producer sets acks to 'all' (or '-1'), min.insync.replicas specifies the minimum number of replicas that must acknowledge a write for the write to be considered successful. minimum: 1 maximum: 7
      Returns:
      minInsyncReplicas

    • setMinInsyncReplicas

      public void setMinInsyncReplicas(Integer minInsyncReplicas)

    • compressionType

      public JsonSchemaKafka compressionType(JsonSchemaKafka.CompressionTypeEnum compressionType)

    • getCompressionType

      @Nullable public JsonSchemaKafka.CompressionTypeEnum getCompressionType()
      Specify the final compression type for a given topic. This configuration accepts the standard compression codecs ('gzip', 'snappy', 'lz4', 'zstd'). It additionally accepts 'uncompressed' which is equivalent to no compression; and 'producer' which means retain the original compression codec set by the producer.
      Returns:
      compressionType

    • setCompressionType

      public void setCompressionType(JsonSchemaKafka.CompressionTypeEnum compressionType)

    • logMessageTimestampDifferenceMaxMs

      public JsonSchemaKafka logMessageTimestampDifferenceMaxMs(Integer logMessageTimestampDifferenceMaxMs)

    • getLogMessageTimestampDifferenceMaxMs

      @Nullable public Integer getLogMessageTimestampDifferenceMaxMs()
      The maximum difference allowed between the timestamp when a broker receives a message and the timestamp specified in the message minimum: 0 maximum: 9223372036854775807
      Returns:
      logMessageTimestampDifferenceMaxMs

    • setLogMessageTimestampDifferenceMaxMs

      public void setLogMessageTimestampDifferenceMaxMs(Integer logMessageTimestampDifferenceMaxMs)

    • logLocalRetentionMs

      public JsonSchemaKafka logLocalRetentionMs(Integer logLocalRetentionMs)

    • getLogLocalRetentionMs

      @Nullable public Integer getLogLocalRetentionMs()
      The number of milliseconds to keep the local log segments before it gets eligible for deletion. If set to -2, the value of log.retention.ms is used. The effective value should always be less than or equal to log.retention.ms value. minimum: -2 maximum: 9223372036854775807
      Returns:
      logLocalRetentionMs

    • setLogLocalRetentionMs

      public void setLogLocalRetentionMs(Integer logLocalRetentionMs)

    • logMessageDownconversionEnable

      public JsonSchemaKafka logMessageDownconversionEnable(Boolean logMessageDownconversionEnable)

    • getLogMessageDownconversionEnable

      @Nullable public Boolean getLogMessageDownconversionEnable()
      This configuration controls whether down-conversion of message formats is enabled to satisfy consume requests.
      Returns:
      logMessageDownconversionEnable

    • setLogMessageDownconversionEnable

      public void setLogMessageDownconversionEnable(Boolean logMessageDownconversionEnable)

    • saslOauthbearerSubClaimName

      public JsonSchemaKafka saslOauthbearerSubClaimName(String saslOauthbearerSubClaimName)

    • getSaslOauthbearerSubClaimName

      @Nullable public String getSaslOauthbearerSubClaimName()
      Name of the scope from which to extract the subject claim from the JWT. Defaults to sub.
      Returns:
      saslOauthbearerSubClaimName

    • setSaslOauthbearerSubClaimName

      public void setSaslOauthbearerSubClaimName(String saslOauthbearerSubClaimName)

    • maxIncrementalFetchSessionCacheSlots

      public JsonSchemaKafka maxIncrementalFetchSessionCacheSlots(Integer maxIncrementalFetchSessionCacheSlots)

    • getMaxIncrementalFetchSessionCacheSlots

      @Nullable public Integer getMaxIncrementalFetchSessionCacheSlots()
      The maximum number of incremental fetch sessions that the broker will maintain. minimum: 1000 maximum: 10000
      Returns:
      maxIncrementalFetchSessionCacheSlots

    • setMaxIncrementalFetchSessionCacheSlots

      public void setMaxIncrementalFetchSessionCacheSlots(Integer maxIncrementalFetchSessionCacheSlots)

    • logRetentionHours

      public JsonSchemaKafka logRetentionHours(Integer logRetentionHours)

    • getLogRetentionHours

      @Nullable public Integer getLogRetentionHours()
      The number of hours to keep a log file before deleting it minimum: -1 maximum: 2147483647
      Returns:
      logRetentionHours

    • setLogRetentionHours

      public void setLogRetentionHours(Integer logRetentionHours)

    • groupMinSessionTimeoutMs

      public JsonSchemaKafka groupMinSessionTimeoutMs(Integer groupMinSessionTimeoutMs)

    • getGroupMinSessionTimeoutMs

      @Nullable public Integer getGroupMinSessionTimeoutMs()
      The minimum allowed session timeout for registered consumers. Longer timeouts give consumers more time to process messages in between heartbeats at the cost of a longer time to detect failures. minimum: 0 maximum: 60000
      Returns:
      groupMinSessionTimeoutMs

    • setGroupMinSessionTimeoutMs

      public void setGroupMinSessionTimeoutMs(Integer groupMinSessionTimeoutMs)

    • socketRequestMaxBytes

      public JsonSchemaKafka socketRequestMaxBytes(Integer socketRequestMaxBytes)

    • getSocketRequestMaxBytes

      @Nullable public Integer getSocketRequestMaxBytes()
      The maximum number of bytes in a socket request (defaults to 104857600). minimum: 10485760 maximum: 209715200
      Returns:
      socketRequestMaxBytes

    • setSocketRequestMaxBytes

      public void setSocketRequestMaxBytes(Integer socketRequestMaxBytes)

    • logSegmentBytes

      public JsonSchemaKafka logSegmentBytes(Integer logSegmentBytes)

    • getLogSegmentBytes

      @Nullable public Integer getLogSegmentBytes()
      The maximum size of a single log file minimum: 10485760 maximum: 1073741824
      Returns:
      logSegmentBytes

    • setLogSegmentBytes

      public void setLogSegmentBytes(Integer logSegmentBytes)

    • logCleanupAndCompaction

      public JsonSchemaKafka logCleanupAndCompaction(ConfigureLogCleanerForTopicCompaction logCleanupAndCompaction)

    • getLogCleanupAndCompaction

      @Nullable public ConfigureLogCleanerForTopicCompaction getLogCleanupAndCompaction()
      Get logCleanupAndCompaction
      Returns:
      logCleanupAndCompaction

    • setLogCleanupAndCompaction

      public void setLogCleanupAndCompaction(ConfigureLogCleanerForTopicCompaction logCleanupAndCompaction)

    • offsetsRetentionMinutes

      public JsonSchemaKafka offsetsRetentionMinutes(Integer offsetsRetentionMinutes)

    • getOffsetsRetentionMinutes

      @Nullable public Integer getOffsetsRetentionMinutes()
      Log retention window in minutes for offsets topic minimum: 1 maximum: 2147483647
      Returns:
      offsetsRetentionMinutes

    • setOffsetsRetentionMinutes

      public void setOffsetsRetentionMinutes(Integer offsetsRetentionMinutes)

    • logRetentionMs

      public JsonSchemaKafka logRetentionMs(Integer logRetentionMs)

    • getLogRetentionMs

      @Nullable public Integer getLogRetentionMs()
      The number of milliseconds to keep a log file before deleting it (in milliseconds), If not set, the value in log.retention.minutes is used. If set to -1, no time limit is applied. minimum: -1 maximum: 9223372036854775807
      Returns:
      logRetentionMs

    • setLogRetentionMs

      public void setLogRetentionMs(Integer logRetentionMs)

    • equals

      public boolean equals(Object o)
      Return true if this json-schema-kafka object is equal to o.
      Overrides:
      equals in class Object

    • hashCode

      public int hashCode()
      Overrides:
      hashCode in class Object

    • toString

      public String toString()
      Overrides:
      toString in class Object

    • toUrlQueryString

      public String toUrlQueryString()
      Convert the instance into URL query string.
      Returns:
      URL query string

    • toUrlQueryString

      public String toUrlQueryString(String prefix)
      Convert the instance into URL query string.
      Parameters:
      prefix - prefix of the query string
      Returns:
      URL query string