azure_cosmos::Error & azure_storage::Error (#285)

Author: ctaggart

sdk/core/src/errors.rs

@@ -16,9 +16,9 @@ pub enum ParsingError {
 #[non_exhaustive]
 #[derive(Debug, Clone, PartialEq, thiserror::Error)]
 pub enum ParseError {
-    #[error("Expected token \"{}\" not found", 0)]
+    #[error("Expected token \"{0}\" not found")]
     TokenNotFound(String),
-    #[error("Expected split char \'{}\' not found", 0)]
+    #[error("Expected split char \'{0}\' not found")]
     SplitNotFound(char),
     #[error("Parse int error {0}")]
     ParseIntError(std::num::ParseIntError),
@@ -174,30 +174,10 @@ pub enum Error {
     GetTokenError(Box<dyn std::error::Error + Send + Sync>),
     #[error("http error: {0}")]
     HttpError(#[from] HttpError),
-    #[error("{}-{} is not 512 byte aligned", start, end)]
-    PageNot512ByteAlignedError { start: u64, end: u64 },
-    #[error("{} is not 512 byte aligned", size)]
-    Not512ByteAlignedError { size: u64 },
-    #[error("Operation not supported. Operation == {0}, reason == {1}")]
-    OperationNotSupported(String, String),
     #[error("parse bool error: {0}")]
     ParseBoolError(#[from] std::str::ParseBoolError),
     #[error("to str error: {0}")]
     ToStrError(#[from] http::header::ToStrError),
-    #[error("json error: {0}")]
-    JSONError(#[from] serde_json::Error),
-    #[error("Permission error: {0}")]
-    PermissionError(#[from] PermissionError),
-    #[error("IO error: {0}")]
-    IOError(#[from] std::io::Error),
-    #[error("UnexpectedXMLError: {0}")]
-    UnexpectedXMLError(String),
-    #[error("Azure Path parse error: {0}")]
-    AzurePathParseError(#[from] AzurePathParseError),
-    #[error("UnexpectedHTTPResult error: {0:?}")]
-    UnexpectedHTTPResult(UnexpectedHTTPResult),
-    #[error("UnexpectedValue error: {0:?}")]
-    UnexpectedValue(UnexpectedValue),
     #[error("Header not found: {0}")]
     HeaderNotFound(String),
     #[error("At least one of these headers must be present: {0:?}")]
@@ -211,45 +191,14 @@ pub enum Error {
         expected_parameter: String,
         url: url::Url,
     },
-    #[error("Traversing error: {0}")]
-    ResponseParsingError(#[from] TraversingError),
     #[error("Parse int error: {0}")]
     ParseIntError(#[from] std::num::ParseIntError),
-    #[error("Parse float error: {0}")]
-    ParseFloatError(#[from] std::num::ParseFloatError),
-    #[error("Parse error: {0}")]
-    ParseError(#[from] ParseError),
-    #[error("Parsing error: {0}")]
-    ParsingError(#[from] ParsingError),
-    #[error("Input parameters error: {0}")]
-    InputParametersError(String),
-    #[error("URL parse error: {0}")]
-    UrlParseError(#[from] url::ParseError),
     #[error("Error preparing HTTP request: {0}")]
     HttpPrepareError(#[from] http::Error),
     #[error("uuid error: {0}")]
     ParseUuidError(#[from] uuid::Error),
     #[error("Chrono parser error: {0}")]
     ChronoParserError(#[from] chrono::ParseError),
-    #[error("UTF8 conversion error: {0}")]
-    Utf8Error(#[from] std::str::Utf8Error),
-    #[error("FromUTF8 error: {0}")]
-    FromUtf8Error(#[from] std::string::FromUtf8Error),
-    #[error("A required header is missing: {0}")]
-    MissingHeaderError(String),
-    #[error(
-        "An expected JSON node is missing: {} of expected type {}",
-        value,
-        expected_type
-    )]
-    MissingValueError {
-        value: String,
-        expected_type: String,
-    },
-    #[error("Invalid status code: {:?}", 0)]
-    InvalidStatusCode(#[from] http::status::InvalidStatusCode),
-    #[error("Error parsing the transaction response: {:?}", 0)]
-    TransactionResponseParseError(String),
 }
 
 #[non_exhaustive]
@@ -273,7 +222,7 @@ pub enum TraversingError {
     ParseIntError(#[from] std::num::ParseIntError),
     #[error("Generic parse error: {0}")]
     GenericParseError(String),
-    #[error("Parsing error: {:?}", 0)]
+    #[error("Parsing error: {0:?}")]
     ParsingError(#[from] ParsingError),
 }
 

sdk/cosmos/examples/collection.rs

@@ -12,8 +12,8 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
     // This is how you construct an authorization token.
     // Remember to pick the correct token type.
     // Here we assume master.
-    // Most methods return a ```Result<_, CosmosError>```.
-    // ```CosmosError``` is an enum union of all the possible underlying
+    // Most methods return a ```Result<_, azure_cosmos::Error```.
+    // ```azure_cosmos::Error``` is an enum union of all the possible underlying
     // errors, plus Azure specific ones. For example if a REST call returns the
     // unexpected result (ie NotFound instead of Ok) we return an Err telling
     // you that.

sdk/cosmos/examples/create_delete_database.rs

@@ -21,8 +21,8 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
     // This is how you construct an authorization token.
     // Remember to pick the correct token type.
     // Here we assume master.
-    // Most methods return a ```Result<_, CosmosError>```.
-    // ```CosmosError``` is an enum union of all the possible underlying
+    // Most methods return a ```Result<_, azure_cosmos::Error```.
+    // ```azure_cosmos::Error``` is an enum union of all the possible underlying
     // errors, plus Azure specific ones. For example if a REST call returns the
     // unexpected result (ie NotFound instead of Ok) we return an Err telling
     // you that.

sdk/cosmos/examples/document_00.rs

@@ -57,7 +57,7 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
 
     // list_databases will give us the databases available in our account. If there is
     // an error (for example, the given key is not valid) you will receive a
-    // specific CosmosError. In this example we will look for a specific database
+    // specific azure_cosmos::Error. In this example we will look for a specific database
     // so we chain a filter operation.
     let db = client
         .list_databases()

sdk/cosmos/src/clients/cosmos_client.rs

@@ -1,8 +1,8 @@
 use super::DatabaseClient;
+use crate::headers::*;
 use crate::operations::*;
 use crate::resources::permission::AuthorizationToken;
 use crate::resources::ResourceType;
-use crate::{headers::*, CosmosError};
 use crate::{requests, ReadonlyString};
 
 use azure_core::pipeline::Pipeline;
@@ -163,15 +163,15 @@ impl CosmosClient {
         ctx: Context,
         database_name: S,
         options: CreateDatabaseOptions,
-    ) -> Result<CreateDatabaseResponse, CosmosError> {
+    ) -> Result<CreateDatabaseResponse, crate::Error> {
         let mut request = self.prepare_request2("dbs", http::Method::POST, ResourceType::Databases);
         let mut ctx = ctx.clone();
         options.decorate_request(&mut request, database_name.as_ref())?;
         let response = self
             .pipeline()
             .send(&mut ctx, &mut request)
             .await
-            .map_err(CosmosError::PolicyError)?;
+            .map_err(crate::Error::PolicyError)?;
 
         Ok(CreateDatabaseResponse::try_from(response).await?)
     }

sdk/cosmos/src/clients/database_client.rs

@@ -2,7 +2,6 @@ use super::*;
 use crate::operations::*;
 use crate::requests;
 use crate::resources::ResourceType;
-use crate::CosmosError;
 use crate::ReadonlyString;
 use azure_core::pipeline::Pipeline;
 use azure_core::{Context, HttpClient, Request};
@@ -56,7 +55,7 @@ impl DatabaseClient {
         ctx: Context,
         collection_name: S,
         options: CreateCollectionOptions,
-    ) -> Result<CreateCollectionResponse, CosmosError> {
+    ) -> Result<CreateCollectionResponse, crate::Error> {
         let request = self.cosmos_client().prepare_request(
             &format!("dbs/{}/colls", self.database_name()),
             http::Method::POST,
@@ -70,7 +69,7 @@ impl DatabaseClient {
             .pipeline()
             .send(&mut ctx, &mut request)
             .await
-            .map_err(CosmosError::PolicyError)?;
+            .map_err(crate::Error::PolicyError)?;
 
         Ok(CreateCollectionResponse::try_from(response).await?)
     }

sdk/cosmos/src/errors.rs

@@ -2,7 +2,7 @@
 #[allow(missing_docs)]
 #[non_exhaustive]
 #[derive(Debug, thiserror::Error)]
-pub enum CosmosError {
+pub enum Error {
     #[error(transparent)]
     AzureCoreError(#[from] azure_core::Error),
     #[error("Resource quota parsing error: {0}")]
@@ -35,10 +35,6 @@ pub enum CosmosError {
     Utf8Error(#[from] std::str::Utf8Error),
     #[error("base64 decode error: {0}")]
     DecodeError(#[from] base64::DecodeError),
-}
-
-#[derive(Debug, thiserror::Error)]
-pub enum ConversionToDocumentError {
     #[error("Conversion to document failed because at lease one element is raw.")]
-    RawElementFound,
+    RawElementError,
 }