Enum Role 

#[non_exhaustive]
pub enum Role {
    Primary {
        replication_offset: u64,
        replicas: Vec<ReplicaInfo>,
    },
    Replica {
        primary_ip: String,
        primary_port: u16,
        replication_state: String,
        data_received: u64,
    },
    Sentinel {
        primary_names: Vec<String>,
    },
}

High level representation of response to the ROLE command.

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.

Primary

Represents a primary role, which is master in legacy Redis terminology.

Fields

replication_offset: u64

The current primary replication offset

replicas: Vec<ReplicaInfo>

List of replica, each represented by a tuple of IP, port and the last acknowledged replication offset.

Replica

Represents a replica role, which is slave in legacy Redis terminology.

Fields

primary_ip: String

The IP of the primary.

primary_port: u16

The port of the primary.

replication_state: String

The state of the replication from the point of view of the primary.

data_received: u64

The amount of data received from the replica so far in terms of primary replication offset.

Sentinel

Represents a sentinel role.

Fields

primary_names: Vec<String>

List of primary names monitored by this Sentinel instance.

Trait Implementations

impl Clone for Role

fn clone(&self) -> Role

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Role

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

Formats the value using the given formatter.

impl FromRedisValue for Role

fn from_redis_value_ref(v: &Value) -> Result<Self, ParsingError>

Given a redis Value this attempts to convert it into the given destination type. If that fails because it’s not compatible an appropriate error is generated.

fn from_redis_value(v: Value) -> Result<Self, ParsingError>

Given a redis Value this attempts to convert it into the given destination type. If that fails because it’s not compatible an appropriate error is generated.

fn from_redis_value_refs(items: &[Value]) -> Result<Vec<Self>, ParsingError>

Similar to from_redis_value_ref but constructs a vector of objects from another vector of values. This primarily exists internally to customize the behavior for vectors of tuples.

fn from_redis_values(items: Vec<Value>) -> Result<Vec<Self>, ParsingError>

The same as from_redis_value_refs, but takes a Vec<Value> instead of a &[Value].

fn from_each_redis_values(items: Vec<Value>) -> Vec<Result<Self, ParsingError>>

The same as from_redis_values, but returns a result for each conversion to make handling them case-by-case possible.

fn from_byte_slice(_vec: &[u8]) -> Option<Vec<Self>>

Convert bytes to a single element vector.

fn from_byte_vec(_vec: Vec<u8>) -> Result<Vec<Self>, ParsingError>

Convert bytes to a single element vector.

impl PartialEq for Role

fn eq(&self, other: &Role) -> 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 Eq for Role

impl StructuralPartialEq for Role