Enum nakadion::consumer::complex_types::DispatchMode

#[non_exhaustive]
pub enum DispatchMode {
    AllSeq,
    EventTypePar,
    EventTypePartitionPar,
}

Defines how to dispatch batches to handlers.

The default is DispatchMode::AllSeq

FromStr

use nakadion::consumer::DispatchMode;

let strategy = "all_seq".parse::<DispatchMode>().unwrap();
assert_eq!(strategy, DispatchMode::AllSeq);

let strategy = "event_type_par".parse::<DispatchMode>().unwrap();
assert_eq!(strategy, DispatchMode::EventTypePar);

let strategy = "event_type_partition_par".parse::<DispatchMode>().unwrap();
assert_eq!(strategy, DispatchMode::EventTypePartitionPar);

JSON is also valid:

use nakadion::consumer::DispatchMode;

let strategy = "\"all_seq\"".parse::<DispatchMode>().unwrap();
assert_eq!(strategy, DispatchMode::AllSeq);

let strategy = "\"event_type_par\"".parse::<DispatchMode>().unwrap();
assert_eq!(strategy, DispatchMode::EventTypePar);

let strategy = "\"event_type_partition_par\"".parse::<DispatchMode>().unwrap();
assert_eq!(strategy, DispatchMode::EventTypePartitionPar);

Environment variables

Fetching values from the environment uses FromStr for parsing.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

AllSeq

Dispatch all batches to a single worker(handler)

This means batches all are processed sequentially by a single handler.

This will always request a handler with HandlerAssignment::Unspecified from the BatchHandlerFactory. This means that if multiple event types are consumed, the handler is responsible for determining the event type to be processed from BatchMeta.

It is suggested to not use this strategy if multiple event types are expected.

EventTypePar

Dispatch all batches to a dedicated worker for an event type.

This means batches are processed sequentially for each event type but the maximum parallelism is the number of event types.

This will always request a handler with HandlerAssignment::EventType(EventTypeName) from the BatchHandlerFactory.

This is the default DispatchMode.

EventTypePartitionPar

Dispatch all batches to a dedicated worker for an partition on each event type.

This means batches are processed sequentially for each individual partition of an event type. The maximum parallelism is the sum of each event type multiplied by its number of partitions.

This will always request a handler with HandlerAssignment::EventTypePartition(EventTypePartitionName) from the BatchHandlerFactory.

Implementations

impl DispatchMode

pub const ENV_TYPE_NAME: &'static str

The default name of the environment variable for this type. The name of the environment variable is “ DISPATCH_MODE “

pub fn try_from_env() -> Result<Option<Self>, Error>

Initialize from the environment. Returns None if the value was not found and fails if the value could not be parsed. The name of the environment variable is “NAKADION_ DISPATCH_MODE “

pub fn try_from_env_prefixed<T: Into<String>>(
    prefix: T
) -> Result<Option<Self>, Error>

Initialize from the environment. Returns None if the value was not found and fails if the value could not be parsed. The name of the environment variable is “prefix_ DISPATCH_MODE “ The underscore and prefix will be omitted if prefix is empty.

pub fn try_from_env_named<T: AsRef<str>>(
    var_name: T
) -> Result<Option<Self>, Error>

Initialize from the environment. Returns None if the value was not found and fails if the value could not be parsed. The name of the environment variable is var_name.

pub fn try_from_env_type_name() -> Result<Option<Self>, Error>

Initialize from the environment. Returns None if the value was not found and fails if the value could not be parsed. The name of the environment variable is “ DISPATCH_MODE “

pub fn from_env() -> Result<Self, Error>

Initialize from the environment. Fails if the value was not found or if the value could not be parsed. The name of the environment variable is “NAKADION_ DISPATCH_MODE “

pub fn from_env_prefixed<T: Into<String>>(prefix: T) -> Result<Self, Error>

Initialize from the environment. Fails if the value was not found or if the value could not be parsed. The name of the environment variable is “prefix_ DISPATCH_MODE “ The underscore and prefix will be omitted if prefix is empty.

pub fn from_env_named<T: AsRef<str>>(var_name: T) -> Result<Self, Error>

Initialize from the environment. Fails if the value was not found or if the value could not be parsed. The name of the environment variable is var_name.

pub fn from_env_type_name() -> Result<Self, Error>

Initialize from the environment. Fails if the value was not found or if the value could not be parsed. The name of the environment variable is “ DISPATCH_MODE “

pub fn from_env_opt() -> Option<Self>

Initialize from the environment. Returns None if the value could not be read for any reason. The name of the environment variable is “NAKADION_ DISPATCH_MODE “

pub fn from_env_opt_prefixed<T: Into<String>>(prefix: T) -> Option<Self>

Initialize from the environment. Returns None if the value could not be read for any reason. The name of the environment variable is “prefix_ DISPATCH_MODE “ The underscore and prefix will be omitted if prefix is empty.

pub fn from_env_opt_named<T: AsRef<str>>(var_name: T) -> Option<Self>

Initialize from the environment. Returns None if the value could not be read for any reason. The name of the environment variable is var_name.

pub fn from_env_opt_type_name() -> Option<Self>

Initialize from the environment. Returns None if the value could not be read for any reason. The name of the environment variable is “ DISPATCH_MODE “

Trait Implementations

impl Clone for DispatchMode

fn clone(&self) -> DispatchMode

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DispatchMode

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for DispatchMode

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for DispatchMode

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Display for DispatchMode

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl FromStr for DispatchMode

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl PartialEq<DispatchMode> for DispatchMode

fn eq(&self, other: &DispatchMode) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl Serialize for DispatchMode

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl Copy for DispatchMode

impl Eq for DispatchMode

impl StructuralEq for DispatchMode

impl StructuralPartialEq for DispatchMode