Struct Fragment

pub struct Fragment {
    pub fragment_id: u32,
    pub fragment_type_mask: u32,
    pub distribution_type: i32,
    pub actors: Vec<StreamActor>,
    pub state_table_ids: Vec<u32>,
    pub upstream_fragment_ids: Vec<u32>,
    pub maybe_vnode_count: Option<u32>,
    pub nodes: Option<StreamNode>,
}

Fields

fragment_id: u32

fragment_type_mask: u32

Bitwise-OR of FragmentTypeFlags

distribution_type: i32

actors: Vec<StreamActor>

state_table_ids: Vec<u32>

upstream_fragment_ids: Vec<u32>

Note that this can be derived backwards from the upstream actors of the Actor held by the Fragment, but in some scenarios (e.g. Scaling) it will lead to a lot of duplicate code, so we pre-generate and store it here, this member will only be initialized when creating the Fragment and modified when creating the mv-on-mv

maybe_vnode_count: Option<u32>

Total vnode count of the fragment (then all internal tables). Duplicated from the length of the vnode bitmap in any actor of the fragment.

Can be unset if the fragment is created in older versions where variable vnode count is not supported, in which case a default value of 256 (or 1 for singleton) should be used. Use VnodeCountCompat::vnode_count to access it.

nodes: Option<StreamNode>

Implementations

impl Fragment

pub fn distribution_type(&self) -> FragmentDistributionType

Returns the enum value of distribution_type, or the default if the field is set to an invalid enum value.

pub fn set_distribution_type(&mut self, value: FragmentDistributionType)

Sets distribution_type to the provided enum value.

pub fn maybe_vnode_count(&self) -> u32

Returns the value of maybe_vnode_count, or the default value if maybe_vnode_count is unset.

impl Fragment

pub fn get_fragment_id(&self) -> u32

pub fn get_fragment_type_mask(&self) -> u32

pub fn get_distribution_type( &self, ) -> Result<FragmentDistributionType, PbFieldNotFound>

pub fn get_actors(&self) -> &Vec<StreamActor>

pub fn get_state_table_ids(&self) -> &Vec<u32>

pub fn get_upstream_fragment_ids(&self) -> &Vec<u32>

pub fn get_maybe_vnode_count(&self) -> Result<&u32, PbFieldNotFound>

pub fn get_nodes(&self) -> Result<&StreamNode, PbFieldNotFound>

Trait Implementations

impl Clone for Fragment

fn clone(&self) -> Fragment

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Fragment

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

Formats the value using the given formatter.

impl Default for Fragment

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Fragment

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Message for Fragment

fn encoded_len(&self) -> usize

Returns the encoded length of the message without a length delimiter.

fn clear(&mut self)

Clears the message, resetting all fields to their default.

fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>

where Self: Sized,

Encodes the message to a buffer.

fn encode_to_vec(&self) -> Vec<u8>

where Self: Sized,

Encodes the message to a newly allocated buffer.

fn encode_length_delimited( &self, buf: &mut impl BufMut, ) -> Result<(), EncodeError>

where Self: Sized,

Encodes the message with a length-delimiter to a buffer.

fn encode_length_delimited_to_vec(&self) -> Vec<u8>

where Self: Sized,

Encodes the message with a length-delimiter to a newly allocated buffer.

fn decode(buf: impl Buf) -> Result<Self, DecodeError>

where Self: Default,

Decodes an instance of the message from a buffer.

fn decode_length_delimited(buf: impl Buf) -> Result<Self, DecodeError>

where Self: Default,

Decodes a length-delimited instance of the message from the buffer.

fn merge(&mut self, buf: impl Buf) -> Result<(), DecodeError>

where Self: Sized,

Decodes an instance of the message from a buffer, and merges it into self.

fn merge_length_delimited(&mut self, buf: impl Buf) -> Result<(), DecodeError>

where Self: Sized,

Decodes a length-delimited instance of the message from buffer, and merges it into self.

impl PartialEq for Fragment

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Fragment

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Fragment