Enum hedwig::publish::GooglePubSubError[−][src]

#[non_exhaustive]
pub enum GooglePubSubError {
Show 14 variants
    GetAuthToken(Arc<Error>),
    PostMessages(Arc<Error>),
    ConstructRequestUri(Arc<InvalidUri>),
    ConstructRequest(Arc<Error>),
    ResponseStatus(Option<Arc<PubSubPublishError>>, StatusCode),
    ResponseParse(Arc<Error>),
    ResponseBodyReceive(Arc<Error>),
    MessageTooManyHeaders,
    MessageHeaderKeysTooLarge,
    MessageHeaderKeysReserved(Arc<str>),
    MessageHeaderValuesTooLarge,
    MessageDataTooLong,
    MessageTimestampTooOld(SystemTimeError),
    SerializeMessageData(Arc<Error>),
}

This is supported on crate features publish and google only.

Expand description

Error messages that occur when publishing to Google PubSub.

Variants (Non-exhaustive)

This enum is marked as 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.

GetAuthToken(Arc<Error>)

Could not get authentication token.

Tuple Fields of GetAuthToken

0: Arc<Error>

PostMessages(Arc<Error>)

Could not POST the request with messages.

Tuple Fields of PostMessages

0: Arc<Error>

ConstructRequestUri(Arc<InvalidUri>)

Could not construct the request URI.

Tuple Fields of ConstructRequestUri

0: Arc<InvalidUri>

ConstructRequest(Arc<Error>)

Could not construct the request.

Tuple Fields of ConstructRequest

0: Arc<Error>

ResponseStatus(Option<Arc<PubSubPublishError>>, StatusCode)

Publish request failed with a bad HTTP status code.

Tuple Fields of ResponseStatus

0: Option<Arc<PubSubPublishError>>1: StatusCode

ResponseParse(Arc<Error>)

Could not parse the response body.

Tuple Fields of ResponseParse

0: Arc<Error>

ResponseBodyReceive(Arc<Error>)

Could not receive the response body.

Tuple Fields of ResponseBodyReceive

0: Arc<Error>

MessageTooManyHeaders

Message contains too many headers.

MessageHeaderKeysTooLarge

Message contains a header key that’s too large.

MessageHeaderKeysReserved(Arc<str>)

Message contains a header with {0} key which is reserved.

Tuple Fields of MessageHeaderKeysReserved

0: Arc<str>

MessageHeaderValuesTooLarge

Message contains a header value that’s too large.

MessageDataTooLong

Encoded message data is too long.

MessageTimestampTooOld(SystemTimeError)

Message timestamp is too far in the past.

Tuple Fields of MessageTimestampTooOld

0: SystemTimeError

SerializeMessageData(Arc<Error>)

Could not serialize message data.

Tuple Fields of SerializeMessageData

0: Arc<Error>

Implementations

[src]

impl GooglePubSubError

[src]

pub fn is_transient(&self) -> bool

Can this error be considered recoverable.

Some examples of transient errors include errors such as failure to make a network request or authenticate with the API endpoint.

In these instances there is a good chance that retrying publishing of a message may succeed.

Examples

This function is useful when deciding whether to re-queue message for publishing.

use futures_util::stream::StreamExt;

let publisher: GooglePubSubPublisher<hyper::client::HttpConnector> = unimplemented!();
let mut batch = hedwig::publish::PublishBatch::new();
// add messages
let mut stream = batch.publish(&publisher);
let mut next_batch = hedwig::publish::PublishBatch::new();
async {
    while let Some(result) = stream.next().await {
        match result {
            (Ok(id), _, msg) => {
                println!("message {} published successfully: {:?}", msg.uuid(), id);
            }
            (Err(e), topic, msg) if e.is_transient() => {
                // Retry
                next_batch.push(topic, msg);
            }
            (Err(e), _, msg) => {
                eprintln!("failed to publish {}: {}", msg.uuid(), e);
            }
        }
    }
};