openstack_sdk 0.22.5

// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX-License-Identifier: Apache-2.0

use std::any;
use std::error::Error;

use bytes::Bytes;
use http::{Response, Uri};
use thiserror::Error;

use crate::api::PaginationError;

/// Errors which may occur when creating form data.
#[derive(Debug, Error)]
#[non_exhaustive]
pub enum BodyError {
    /// Body data could not be serialized from form parameters.
    #[error("failed to URL encode form parameters: {}", source)]
    UrlEncoded {
        /// The source of the error.
        #[from]
        source: serde_urlencoded::ser::Error,
    },
    #[error("failed to serialize request body: {}", source)]
    Serialize {
        /// The source of the error.
        #[from]
        source: serde_json::Error,
    },
}

/// Errors which may occur when using API endpoints.
#[derive(Debug, Error)]
#[non_exhaustive]
pub enum ApiError<E>
where
    E: Error + Send + Sync + 'static,
{
    /// The client encountered an error.
    #[error("client error: {}", source)]
    Client {
        /// The client error.
        source: E,
    },
    /// The URL failed to parse.
    #[error("failed to parse url: {}", source)]
    UrlParse {
        /// The source of the error.
        #[from]
        source: url::ParseError,
    },
    /// Body data could not be created.
    #[error("failed to create form data: {}", source)]
    Body {
        /// The source of the error.
        #[from]
        source: BodyError,
    },
    /// JSON deserialization from OpenStack failed.
    #[error("could not parse JSON response: {}", source)]
    Json {
        /// The source of the error.
        #[from]
        source: serde_json::Error,
    },
    /// Resource can not be found using known locations.
    #[error("resource cannot be found")]
    ResourceNotFound,
    /// Too many candidates to identitfy resource by identifier
    #[error("cannot find unambiguous resource by identifier")]
    IdNotUnique,
    /// OpenStack session error.
    #[error("openstack session error: {}", msg)]
    Session {
        /// The error message from OpenStack.
        msg: String,
    },
    /// OpenStack returned understandable error message
    #[error(
        "openstack server error:\n\turi: `{}`\n\tstatus: `{}`\n\tmessage: `{}`\n\trequest-id: `{}`",
        uri,
        status,
        msg,
        req_id.as_deref().unwrap_or("")
    )]
    OpenStack {
        /// The status code for the return.
        status: http::StatusCode,
        /// The URI of the request
        uri: Uri,
        /// The error message from OpenStack.
        msg: String,
        /// Request ID
        req_id: Option<String>,
    },
    /// OpenStack returned an error without JSON information.
    #[error(
        "openstack internal server error:\n\turi: `{}`\n\tstatus: `{}`\n\trequest-id: `{}`",
        uri,
        status,
        req_id.as_deref().unwrap_or("")
    )]
    OpenStackService {
        /// The status code for the return.
        status: http::StatusCode,
        /// The URI of the request
        uri: Uri,
        /// The error data from OpenStack.
        data: String,
        /// Request ID
        req_id: Option<String>,
    },
    /// OpenStack returned an HTTP error with JSON we did not recognize.
    #[error(
        "openstack server error:\n\turi: `{}`\n\tstatus: `{}`\n\tdata: `{}`\n\trequest-id: `{}`",
        uri,
        status,
        obj,
        req_id.as_deref().unwrap_or("")
    )]
    OpenStackUnrecognized {
        /// The status code for the return.
        status: http::StatusCode,
        /// The URI of the request
        uri: Uri,
        /// The full object from OpenStack.
        obj: serde_json::Value,
        /// Request ID
        req_id: Option<String>,
    },
    /// Failed to parse an expected data type from JSON.
    #[error("could not parse {} data from JSON: {}", typename, source)]
    DataType {
        /// The source of the error.
        source: serde_json::Error,
        /// The name of the type that could not be deserialized.
        typename: &'static str,
    },
    /// An error with pagination occurred.
    #[error("failed to handle pagination: {}", source)]
    Pagination {
        /// The source of the error.
        #[from]
        source: PaginationError,
    },
    #[error("service catalog error: {}", source)]
    Catalog {
        /// The source of the error.
        #[from]
        source: crate::catalog::CatalogError,
    },

    /// Poisoned guard lock in the internal processing.
    #[error("internal error: poisoned lock: {}", context)]
    PoisonedLock {
        /// The source of the error.
        context: String,
    },

    /// Endpoint builder error.
    #[error("endpoint builder error: {}", message)]
    EndpointBuilder {
        /// The error message,
        message: String,
    },

    /// Invalid response header.
    #[error("invalid header {}: {}", header, message)]
    InvalidHeader {
        /// The error message,
        header: String,
        /// The error message,
        message: String,
    },

    /// Invalid URL.
    #[error("invalid url: {}", source)]
    InvalidUri {
        /// The source of the error.
        #[from]
        source: http::uri::InvalidUri,
    },
}

impl<E> ApiError<E>
where
    E: Error + Send + Sync + 'static,
{
    /// Create an API error in a client error.
    pub fn client(source: E) -> Self {
        ApiError::Client { source }
    }
    /// Create an API error in a catalog error.
    pub fn catalog(source: crate::catalog::CatalogError) -> Self {
        ApiError::Catalog { source }
    }

    /// Process server response with no Json body
    pub(crate) fn server_error(
        uri: Option<Uri>,
        rsp: &Response<Bytes>,
        body: &bytes::Bytes,
    ) -> Self {
        // Non Json body response ends in this function
        let status = rsp.status();
        let req_id = rsp
            .headers()
            .get("x-openstack-request-id")
            .and_then(|x| x.to_str().ok().map(Into::into));

        if http::StatusCode::NOT_FOUND.as_u16() == status {
            return Self::OpenStack {
                status,
                uri: uri.unwrap_or(Uri::from_static("/")),
                msg: String::new(),
                req_id,
            };
        };

        Self::OpenStackService {
            status,
            uri: uri.unwrap_or(Uri::from_static("/")),
            data: String::from_utf8_lossy(body).into(),
            req_id,
        }
    }

    /// Process server error response with Json body
    pub(crate) fn from_openstack(
        uri: Option<Uri>,
        rsp: &Response<Bytes>,
        value: serde_json::Value,
    ) -> Self {
        let status = rsp.status();
        let req_id = rsp
            .headers()
            .get("x-openstack-request-id")
            .and_then(|x| x.to_str().ok().map(Into::into));

        if http::StatusCode::NOT_FOUND.as_u16() == status {
            return Self::OpenStack {
                status,
                uri: uri.unwrap_or(Uri::from_static("/")),
                msg: value.to_string(),
                req_id,
            };
        };

        let error_value = value
            .pointer("/message")
            .or_else(|| value.pointer("/error"))
            .or_else(|| value.pointer("/faultstring"));

        if let Some(error_value) = error_value {
            if let Some(msg) = error_value.as_str() {
                // Error we know how to parse (string)
                ApiError::OpenStack {
                    status,
                    uri: uri.unwrap_or(Uri::from_static("/")),
                    msg: msg.into(),
                    req_id,
                }
            } else {
                // Error we do not know how to parse (perhaps an object)
                ApiError::OpenStackUnrecognized {
                    status,
                    uri: uri.unwrap_or(Uri::from_static("/")),
                    obj: error_value.clone(),
                    req_id,
                }
            }
        } else {
            ApiError::OpenStackUnrecognized {
                status,
                uri: uri.unwrap_or(Uri::from_static("/")),
                obj: value,
                req_id,
            }
        }
    }

    pub(crate) fn data_type<T>(source: serde_json::Error) -> Self {
        ApiError::DataType {
            source,
            typename: any::type_name::<T>(),
        }
    }

    pub(crate) fn poisoned_lock<CTX: AsRef<str>>(context: CTX) -> Self {
        ApiError::PoisonedLock {
            context: context.as_ref().into(),
        }
    }

    /// Create EndpointBuilder error with the message.
    pub(crate) fn endpoint_builder<EX: Error + Send>(error: EX) -> Self {
        ApiError::EndpointBuilder {
            message: error.to_string(),
        }
    }
}

#[cfg(test)]
mod tests {
    use bytes::Bytes;
    use http::{Response, Uri};
    use serde_json::json;
    use thiserror::Error;

    use crate::api::ApiError;

    #[derive(Debug, Error)]
    #[error("my error")]
    enum MyError {}

    #[test]
    fn openstack_error_error() {
        let obj = json!({
            "error": "error contents",
        });

        let err: ApiError<MyError> = ApiError::from_openstack(
            Some(Uri::from_static("http://foo.bar")),
            &Response::builder()
                .status(http::StatusCode::CONFLICT)
                .header("x-openstack-request-id", "reqid")
                .body(Bytes::from(serde_json::to_vec(&obj).unwrap()))
                .unwrap(),
            obj.clone(),
        );
        if let ApiError::OpenStack {
            status,
            uri,
            msg,
            req_id,
        } = err
        {
            assert_eq!(uri, Uri::from_static("http://foo.bar"));
            assert_eq!(msg, "error contents");
            assert_eq!(status, http::StatusCode::CONFLICT);
            assert_eq!(req_id, Some("reqid".into()));
        } else {
            panic!("unexpected error: {err}");
        }
    }

    #[test]
    fn openstack_error_message_string() {
        let obj = json!({
            "message": "error contents",
        });

        let err: ApiError<MyError> = ApiError::from_openstack(
            Some(Uri::from_static("http://foo.bar")),
            &Response::builder()
                .status(http::StatusCode::CONFLICT)
                .header("x-openstack-request-id", "reqid")
                .body(Bytes::from(serde_json::to_vec(&obj).unwrap()))
                .unwrap(),
            obj.clone(),
        );
        if let ApiError::OpenStack {
            status,
            uri,
            msg,
            req_id,
        } = err
        {
            assert_eq!(uri, Uri::from_static("http://foo.bar"));
            assert_eq!(msg, "error contents");
            assert_eq!(status, http::StatusCode::CONFLICT);
            assert_eq!(req_id, Some("reqid".into()));
        } else {
            panic!("unexpected error: {err}");
        }
    }

    #[test]
    fn openstack_error_message_object() {
        let err_obj = json!({
            "blah": "foo",
        });
        let obj = json!({
            "message": err_obj,
        });

        let err: ApiError<MyError> = ApiError::from_openstack(
            Some(Uri::from_static("http://foo.bar")),
            &Response::builder()
                .status(http::StatusCode::CONFLICT)
                .header("x-openstack-request-id", "reqid")
                .body(Bytes::from(serde_json::to_vec(&obj).unwrap()))
                .unwrap(),
            obj.clone(),
        );
        if let ApiError::OpenStackUnrecognized {
            status,
            uri,
            obj,
            req_id,
        } = err
        {
            assert_eq!(uri, Uri::from_static("http://foo.bar"));
            assert_eq!(obj, err_obj);
            assert_eq!(status, http::StatusCode::CONFLICT);
            assert_eq!(req_id, Some("reqid".into()));
        } else {
            panic!("unexpected error: {err}");
        }
    }

    #[test]
    fn openstack_error_message_unrecognized() {
        let err_obj = json!({
            "some_weird_key": "an even weirder value",
        });

        let err: ApiError<MyError> = ApiError::from_openstack(
            Some(Uri::from_static("http://foo.bar")),
            &Response::builder()
                .status(http::StatusCode::CONFLICT)
                .header("x-openstack-request-id", "reqid")
                .body(Bytes::from(serde_json::to_vec(&err_obj).unwrap()))
                .unwrap(),
            err_obj.clone(),
        );
        if let ApiError::OpenStackUnrecognized {
            status,
            uri,
            obj,
            req_id,
        } = err
        {
            assert_eq!(uri, Uri::from_static("http://foo.bar"));
            assert_eq!(obj, err_obj);
            assert_eq!(status, http::StatusCode::CONFLICT);
            assert_eq!(req_id, Some("reqid".into()));
        } else {
            panic!("unexpected error: {err}");
        }
    }

    #[test]
    fn openstack_error_not_found() {
        let err_obj = json!({
            "some_weird_key": "an even weirder value",
        });

        let err: ApiError<MyError> = ApiError::from_openstack(
            Some(Uri::from_static("http://foo.bar")),
            &Response::builder()
                .status(http::StatusCode::NOT_FOUND)
                .header("x-openstack-request-id", "reqid")
                .body(Bytes::from(serde_json::to_vec(&err_obj).unwrap()))
                .unwrap(),
            err_obj.clone(),
        );
        if let ApiError::OpenStack {
            status,
            uri,
            msg,
            req_id,
        } = err
        {
            assert_eq!(uri, Uri::from_static("http://foo.bar"));
            assert_eq!(msg, err_obj.to_string());
            assert_eq!(status, http::StatusCode::NOT_FOUND);
            assert_eq!(req_id, Some("reqid".into()));
        } else {
            panic!("unexpected error: {err}");
        }
    }

    #[test]
    fn openstack_error_message_octavia() {
        let obj = json!({
            "faultstring": "foo",
            "debuginfo": null
        });

        let err: ApiError<MyError> = ApiError::from_openstack(
            Some(Uri::from_static("http://foo.bar")),
            &Response::builder()
                .status(http::StatusCode::CONFLICT)
                .header("x-openstack-request-id", "reqid")
                .body(Bytes::from(serde_json::to_vec(&obj).unwrap()))
                .unwrap(),
            obj.clone(),
        );
        if let ApiError::OpenStack {
            status,
            uri,
            msg,
            req_id,
        } = err
        {
            assert_eq!(uri, Uri::from_static("http://foo.bar"));
            assert_eq!(obj["faultstring"], msg);
            assert_eq!(status, http::StatusCode::CONFLICT);
            assert_eq!(req_id, Some("reqid".into()));
        } else {
            panic!("unexpected error: {err}");
        }
    }
}