Package com.exoscale.sdk.model

Class JsonSchemaKafkaConnect

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

  • Field Details

    • JSON_PROPERTY_PRODUCER_BUFFER_MEMORY

      public static final String JSON_PROPERTY_PRODUCER_BUFFER_MEMORY
      See Also:

    • JSON_PROPERTY_CONSUMER_MAX_POLL_INTERVAL_MS

      public static final String JSON_PROPERTY_CONSUMER_MAX_POLL_INTERVAL_MS
      See Also:

    • JSON_PROPERTY_PRODUCER_COMPRESSION_TYPE

      public static final String JSON_PROPERTY_PRODUCER_COMPRESSION_TYPE
      See Also:

    • JSON_PROPERTY_CONNECTOR_CLIENT_CONFIG_OVERRIDE_POLICY

      public static final String JSON_PROPERTY_CONNECTOR_CLIENT_CONFIG_OVERRIDE_POLICY
      See Also:

    • JSON_PROPERTY_OFFSET_FLUSH_INTERVAL_MS

      public static final String JSON_PROPERTY_OFFSET_FLUSH_INTERVAL_MS
      See Also:

    • JSON_PROPERTY_SCHEDULED_REBALANCE_MAX_DELAY_MS

      public static final String JSON_PROPERTY_SCHEDULED_REBALANCE_MAX_DELAY_MS
      See Also:

    • JSON_PROPERTY_CONSUMER_FETCH_MAX_BYTES

      public static final String JSON_PROPERTY_CONSUMER_FETCH_MAX_BYTES
      See Also:

    • JSON_PROPERTY_CONSUMER_MAX_PARTITION_FETCH_BYTES

      public static final String JSON_PROPERTY_CONSUMER_MAX_PARTITION_FETCH_BYTES
      See Also:

    • JSON_PROPERTY_OFFSET_FLUSH_TIMEOUT_MS

      public static final String JSON_PROPERTY_OFFSET_FLUSH_TIMEOUT_MS
      See Also:

    • JSON_PROPERTY_CONSUMER_AUTO_OFFSET_RESET

      public static final String JSON_PROPERTY_CONSUMER_AUTO_OFFSET_RESET
      See Also:

    • JSON_PROPERTY_PRODUCER_MAX_REQUEST_SIZE

      public static final String JSON_PROPERTY_PRODUCER_MAX_REQUEST_SIZE
      See Also:

    • JSON_PROPERTY_PRODUCER_BATCH_SIZE

      public static final String JSON_PROPERTY_PRODUCER_BATCH_SIZE
      See Also:

    • JSON_PROPERTY_SESSION_TIMEOUT_MS

      public static final String JSON_PROPERTY_SESSION_TIMEOUT_MS
      See Also:

    • JSON_PROPERTY_PRODUCER_LINGER_MS

      public static final String JSON_PROPERTY_PRODUCER_LINGER_MS
      See Also:

    • JSON_PROPERTY_CONSUMER_ISOLATION_LEVEL

      public static final String JSON_PROPERTY_CONSUMER_ISOLATION_LEVEL
      See Also:

    • JSON_PROPERTY_CONSUMER_MAX_POLL_RECORDS

      public static final String JSON_PROPERTY_CONSUMER_MAX_POLL_RECORDS
      See Also:

  • Constructor Details

    • JsonSchemaKafkaConnect

      public JsonSchemaKafkaConnect()

  • Method Details

    • producerBufferMemory

      public JsonSchemaKafkaConnect producerBufferMemory(Integer producerBufferMemory)

    • getProducerBufferMemory

      @Nullable public Integer getProducerBufferMemory()
      The total bytes of memory the producer can use to buffer records waiting to be sent to the broker (defaults to 33554432). minimum: 5242880 maximum: 134217728
      Returns:
      producerBufferMemory

    • setProducerBufferMemory

      public void setProducerBufferMemory(Integer producerBufferMemory)

    • consumerMaxPollIntervalMs

      public JsonSchemaKafkaConnect consumerMaxPollIntervalMs(Integer consumerMaxPollIntervalMs)

    • getConsumerMaxPollIntervalMs

      @Nullable public Integer getConsumerMaxPollIntervalMs()
      The maximum delay in milliseconds between invocations of poll() when using consumer group management (defaults to 300000). minimum: 1 maximum: 2147483647
      Returns:
      consumerMaxPollIntervalMs

    • setConsumerMaxPollIntervalMs

      public void setConsumerMaxPollIntervalMs(Integer consumerMaxPollIntervalMs)

    • producerCompressionType

      public JsonSchemaKafkaConnect producerCompressionType(JsonSchemaKafkaConnect.ProducerCompressionTypeEnum producerCompressionType)

    • getProducerCompressionType

      @Nullable public JsonSchemaKafkaConnect.ProducerCompressionTypeEnum getProducerCompressionType()
      Specify the default compression type for producers. This configuration accepts the standard compression codecs ('gzip', 'snappy', 'lz4', 'zstd'). It additionally accepts 'none' which is the default and equivalent to no compression.
      Returns:
      producerCompressionType

    • setProducerCompressionType

      public void setProducerCompressionType(JsonSchemaKafkaConnect.ProducerCompressionTypeEnum producerCompressionType)

    • connectorClientConfigOverridePolicy

      public JsonSchemaKafkaConnect connectorClientConfigOverridePolicy(JsonSchemaKafkaConnect.ConnectorClientConfigOverridePolicyEnum connectorClientConfigOverridePolicy)

    • getConnectorClientConfigOverridePolicy

      @Nullable public JsonSchemaKafkaConnect.ConnectorClientConfigOverridePolicyEnum getConnectorClientConfigOverridePolicy()
      Defines what client configurations can be overridden by the connector. Default is None
      Returns:
      connectorClientConfigOverridePolicy

    • setConnectorClientConfigOverridePolicy

      public void setConnectorClientConfigOverridePolicy(JsonSchemaKafkaConnect.ConnectorClientConfigOverridePolicyEnum connectorClientConfigOverridePolicy)

    • offsetFlushIntervalMs

      public JsonSchemaKafkaConnect offsetFlushIntervalMs(Integer offsetFlushIntervalMs)

    • getOffsetFlushIntervalMs

      @Nullable public Integer getOffsetFlushIntervalMs()
      The interval at which to try committing offsets for tasks (defaults to 60000). minimum: 1 maximum: 100000000
      Returns:
      offsetFlushIntervalMs

    • setOffsetFlushIntervalMs

      public void setOffsetFlushIntervalMs(Integer offsetFlushIntervalMs)

    • scheduledRebalanceMaxDelayMs

      public JsonSchemaKafkaConnect scheduledRebalanceMaxDelayMs(Integer scheduledRebalanceMaxDelayMs)

    • getScheduledRebalanceMaxDelayMs

      @Nullable public Integer getScheduledRebalanceMaxDelayMs()
      The maximum delay that is scheduled in order to wait for the return of one or more departed workers before rebalancing and reassigning their connectors and tasks to the group. During this period the connectors and tasks of the departed workers remain unassigned. Defaults to 5 minutes. minimum: 0 maximum: 600000
      Returns:
      scheduledRebalanceMaxDelayMs

    • setScheduledRebalanceMaxDelayMs

      public void setScheduledRebalanceMaxDelayMs(Integer scheduledRebalanceMaxDelayMs)

    • consumerFetchMaxBytes

      public JsonSchemaKafkaConnect consumerFetchMaxBytes(Integer consumerFetchMaxBytes)

    • getConsumerFetchMaxBytes

      @Nullable public Integer getConsumerFetchMaxBytes()
      Records are fetched in batches by the consumer, 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 the consumer can make progress. As such, this is not a absolute maximum. minimum: 1048576 maximum: 104857600
      Returns:
      consumerFetchMaxBytes

    • setConsumerFetchMaxBytes

      public void setConsumerFetchMaxBytes(Integer consumerFetchMaxBytes)

    • consumerMaxPartitionFetchBytes

      public JsonSchemaKafkaConnect consumerMaxPartitionFetchBytes(Integer consumerMaxPartitionFetchBytes)

    • getConsumerMaxPartitionFetchBytes

      @Nullable public Integer getConsumerMaxPartitionFetchBytes()
      Records are fetched in batches by the consumer.If the first record batch in the first non-empty partition of the fetch is larger than this limit, the batch will still be returned to ensure that the consumer can make progress. minimum: 1048576 maximum: 104857600
      Returns:
      consumerMaxPartitionFetchBytes

    • setConsumerMaxPartitionFetchBytes

      public void setConsumerMaxPartitionFetchBytes(Integer consumerMaxPartitionFetchBytes)

    • offsetFlushTimeoutMs

      public JsonSchemaKafkaConnect offsetFlushTimeoutMs(Integer offsetFlushTimeoutMs)

    • getOffsetFlushTimeoutMs

      @Nullable public Integer getOffsetFlushTimeoutMs()
      Maximum number of milliseconds to wait for records to flush and partition offset data to be committed to offset storage before cancelling the process and restoring the offset data to be committed in a future attempt (defaults to 5000). minimum: 1 maximum: 2147483647
      Returns:
      offsetFlushTimeoutMs

    • setOffsetFlushTimeoutMs

      public void setOffsetFlushTimeoutMs(Integer offsetFlushTimeoutMs)

    • consumerAutoOffsetReset

      public JsonSchemaKafkaConnect consumerAutoOffsetReset(JsonSchemaKafkaConnect.ConsumerAutoOffsetResetEnum consumerAutoOffsetReset)

    • getConsumerAutoOffsetReset

      @Nullable public JsonSchemaKafkaConnect.ConsumerAutoOffsetResetEnum getConsumerAutoOffsetReset()
      What to do when there is no initial offset in Kafka or if the current offset does not exist any more on the server. Default is earliest
      Returns:
      consumerAutoOffsetReset

    • setConsumerAutoOffsetReset

      public void setConsumerAutoOffsetReset(JsonSchemaKafkaConnect.ConsumerAutoOffsetResetEnum consumerAutoOffsetReset)

    • producerMaxRequestSize

      public JsonSchemaKafkaConnect producerMaxRequestSize(Integer producerMaxRequestSize)

    • getProducerMaxRequestSize

      @Nullable public Integer getProducerMaxRequestSize()
      This setting will limit the number of record batches the producer will send in a single request to avoid sending huge requests. minimum: 131072 maximum: 67108864
      Returns:
      producerMaxRequestSize

    • setProducerMaxRequestSize

      public void setProducerMaxRequestSize(Integer producerMaxRequestSize)

    • producerBatchSize

      public JsonSchemaKafkaConnect producerBatchSize(Integer producerBatchSize)

    • getProducerBatchSize

      @Nullable public Integer getProducerBatchSize()
      This setting gives the upper bound of the batch size to be sent. If there are fewer than this many bytes accumulated for this partition, the producer will 'linger' for the linger.ms time waiting for more records to show up. A batch size of zero will disable batching entirely (defaults to 16384). minimum: 0 maximum: 5242880
      Returns:
      producerBatchSize

    • setProducerBatchSize

      public void setProducerBatchSize(Integer producerBatchSize)

    • sessionTimeoutMs

      public JsonSchemaKafkaConnect sessionTimeoutMs(Integer sessionTimeoutMs)

    • getSessionTimeoutMs

      @Nullable public Integer getSessionTimeoutMs()
      The timeout in milliseconds used to detect failures when using Kafka’s group management facilities (defaults to 10000). minimum: 1 maximum: 2147483647
      Returns:
      sessionTimeoutMs

    • setSessionTimeoutMs

      public void setSessionTimeoutMs(Integer sessionTimeoutMs)

    • producerLingerMs

      public JsonSchemaKafkaConnect producerLingerMs(Integer producerLingerMs)

    • getProducerLingerMs

      @Nullable public Integer getProducerLingerMs()
      This setting gives the upper bound on the delay for batching: once there is batch.size worth of records for a partition it will be sent immediately regardless of this setting, however if there are fewer than this many bytes accumulated for this partition the producer will 'linger' for the specified time waiting for more records to show up. Defaults to 0. minimum: 0 maximum: 5000
      Returns:
      producerLingerMs

    • setProducerLingerMs

      public void setProducerLingerMs(Integer producerLingerMs)

    • consumerIsolationLevel

      public JsonSchemaKafkaConnect consumerIsolationLevel(JsonSchemaKafkaConnect.ConsumerIsolationLevelEnum consumerIsolationLevel)

    • getConsumerIsolationLevel

      @Nullable public JsonSchemaKafkaConnect.ConsumerIsolationLevelEnum getConsumerIsolationLevel()
      Transaction read isolation level. read_uncommitted is the default, but read_committed can be used if consume-exactly-once behavior is desired.
      Returns:
      consumerIsolationLevel

    • setConsumerIsolationLevel

      public void setConsumerIsolationLevel(JsonSchemaKafkaConnect.ConsumerIsolationLevelEnum consumerIsolationLevel)

    • consumerMaxPollRecords

      public JsonSchemaKafkaConnect consumerMaxPollRecords(Integer consumerMaxPollRecords)

    • getConsumerMaxPollRecords

      @Nullable public Integer getConsumerMaxPollRecords()
      The maximum number of records returned in a single call to poll() (defaults to 500). minimum: 1 maximum: 10000
      Returns:
      consumerMaxPollRecords

    • setConsumerMaxPollRecords

      public void setConsumerMaxPollRecords(Integer consumerMaxPollRecords)

    • equals

      public boolean equals(Object o)
      Return true if this json-schema-kafka-connect 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