Enum WriteError 

#[non_exhaustive]
pub enum WriteError {
    UnexpectedRewind {
        offset: u64,
        persisted: u64,
    },
    TooMuchProgress {
        sent: u64,
        persisted: u64,
    },
    ChecksumMismatch {
        mismatch: ChecksumMismatch,
        object: Box<Object>,
    },
}

An unrecoverable problem in the upload protocol.

Example

use std::error::Error as _;
let writer = client
    .write_object("projects/_/buckets/my-bucket", "my-object", "hello world")
    .set_if_generation_not_match(0);
match writer.send_buffered().await {
    Ok(object) => println!("Successfully created the object {object:?}"),
    Err(error) if error.is_serialization() => {
        println!("Some problem {error:?} sending the data to the service");
        if let Some(m) = error.source().and_then(|e| e.downcast_ref::<WriteError>()) {
            println!("{m}");
        }
    },
    Err(e) => return Err(e.into()), // not handled in this example
}

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.

UnexpectedRewind

The service has “uncommitted” previously persisted bytes.

Troubleshoot

In the resumable upload protocol the service reports how many bytes are persisted. This error indicates that the service previously reported more bytes as persisted than in the latest report. This could indicate:

• a corrupted message from the service, either the earlier message reporting more bytes persisted than actually are, or the current message indicating fewer bytes persisted.
• a bug in the service, where it reported bytes as persisted when they were not.
• a bug in the client, maybe storing the incorrect byte count, or parsing the messages incorrectly.

All of these conditions indicate a bug, and in Rust it is idiomatic to panic!() when a bug is detected. However, in this case it seems more appropriate to report the problem, as the client library cannot determine the location of the bug.

Fields

offset: u64

persisted: u64

TooMuchProgress

The service reports more bytes persisted than sent.

Troubleshoot

Most likely this indicates that two concurrent uploads are using the same session. Review your application design to avoid concurrent uploads.

It is possible that this indicates a bug in the service, client, or messages corrupted in transit.

Fields

sent: u64

persisted: u64

ChecksumMismatch

The checksums reported by the service do not match the expected checksums.

Troubleshoot

The client library compares the CRC32C checksum and/or MD5 hash of the uploaded data against the hash reported by the service at the end of the upload. This error indicates the hashes did not match.

If you provided known values for these checksums verify those values are correct.

Otherwise, this is probably a data corruption problem. These are notoriously difficult to root cause. They probably indicate faulty equipment, such as the physical machine hosting your client, the network elements between your client and the service, or the physical machine hosting the service.

If possible, resend the data from a different machine.

Fields

mismatch: ChecksumMismatch

object: Box<Object>

Trait Implementations

impl Debug for WriteError

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

Formats the value using the given formatter.

impl Display for WriteError

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

Formats the value using the given formatter.

impl Error for WriteError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.