error.hpp

Go to the documentation of this file.

#pragma once
 
#include "http.hpp"
 
namespace edjx {
 
namespace error {
 
    enum class HttpError {
        Success = 0,
        SystemError,
        UnknownError,
        HeaderInvalidName,
        HeaderInvalidValue,
        HeaderTooLargeName,
        HeaderTooLargeValue,
        HTTPBodyTooLarge,
        UriInvalid,
        UriTooLarge,
        HTTPInvalidMethod,
        HTTPInvalidStatusCode,
        HTTPInvalidVersion,
 
        HTTPFetchResponseNotFound,
        HTTPFetchRequestFailed,
        HTTPChannelClosed
    };
 
    inline std::string to_string(HttpError e) {
        switch (e) {
            case HttpError::Success:
                return "HTTP: success";
            case HttpError::UnknownError:
                return "HTTP: unknown error";
            case HttpError::SystemError:
                return "HTTP: error in SDK function";
            case HttpError::HeaderInvalidName:
                return "HTTP: invalid header name";
            case HttpError::HeaderInvalidValue:
                return "HTTP: invalid header value";
            case HttpError::HeaderTooLargeName:
                return "HTTP: header name length exceeds limit";
            case HttpError::HeaderTooLargeValue:
                return "HTTP: header value length exceeds limit";
            case HttpError::HTTPBodyTooLarge:
                return "HTTP: http body too large error";
            case HttpError::UriInvalid:
                return "HTTP: URI value invalid";
            case HttpError::UriTooLarge:
                return "HTTP: URI value exceeds limit";
            case HttpError::HTTPInvalidMethod:
                return "HTTP: invalid fetch HTTP method";
            case HttpError::HTTPInvalidStatusCode:
                return "HTTP: invalid response status code";
            case HttpError::HTTPInvalidVersion:
                return "HTTP: invalid HTTP version";
 
            case HttpError::HTTPFetchResponseNotFound:
                return "Fetch: HTTP fetch response not found";
            case HttpError::HTTPFetchRequestFailed:
                return "Fetch: HTTP fetch request failed";
            case HttpError::HTTPChannelClosed:
                return "HTTP: Channel closed";
        }
    }
 
    enum class KVError {
        Success = 0,
        Unknown,
        NotFound,
        UnAuthorized
    };
 
    inline std::string to_string(KVError e) {
        switch (e) {
            case KVError::Success:
                return "KV: success";
            case KVError::Unknown:
                return "KV: unknown";
            case KVError::NotFound:
                return "KV: key not found";
            case KVError::UnAuthorized:
                return "KV: unauthorized";
        }
    }
 
    enum class StorageError {
        Success = 0,
        SystemError,
        EmptyContent,
        MissingFileName,
        DeletedBucketID,
        MissingBucketID,
        InternalError,
        ContentNotFound,
        UnAuthorized,
        MissingAttributes,
        ContentDeleted,
        InvalidAttributes,
        ResourceLimit,
 
        StorageResponseNotFound,
        StorageChannelClosed
    };
 
    inline std::string to_string(StorageError e) {
        switch (e) {
            case StorageError::Success:
                return "Storage: success";
            case StorageError::SystemError:
                return "Storage: error occured in SDK library";
            case StorageError::EmptyContent:
                return "Storage: empty content";
            case StorageError::MissingFileName:
                return "Storage: missing query param 'file_name'";
            case StorageError::DeletedBucketID:
                return "Storage: bucket_id is deleted";
            case StorageError::MissingBucketID:
                return "Storage: missing query param 'bucket_id'";
            case StorageError::InternalError:
                return "Storage: internal error";
            case StorageError::ContentNotFound:
                return "Storage: bucket/content not found";
            case StorageError::UnAuthorized:
                return "Storage: unauthorized";
            case StorageError::MissingAttributes:
                return "Storage: missing attributes";
            case StorageError::ContentDeleted:
                return "Storage: content does not exist or was deleted";
            case StorageError::InvalidAttributes:
                return "Storage: invalid attributes";
            case StorageError::ResourceLimit:
                return "Storage: Resource limit exceeded";
 
            case StorageError::StorageResponseNotFound:
                return "Storage: Storage response not found";
            case StorageError::StorageChannelClosed:
                return "Storage: Storage channel closed";
        }
    }
 
    inline edjx::http::HttpStatusCode to_http_status_code(StorageError e) {
        switch (e) {
            case StorageError::Success:
                return 200;
            case StorageError::EmptyContent:
            case StorageError::MissingFileName:
            case StorageError::MissingBucketID:
            case StorageError::MissingAttributes:
            case StorageError::InvalidAttributes:
                return 400; //HTTP_STATUS_BAD_REQUEST;
            case StorageError::ContentNotFound:
            case StorageError::ContentDeleted:
            case StorageError::StorageResponseNotFound:
                return 404; //HTTP_STATUS_NOT_FOUND;
            case StorageError::UnAuthorized:
                return 403; //HTTP_STATUS_FORBIDDEN;
            case StorageError::ResourceLimit:
                return 422; //HTTP_STATUS_UNPROCESSABLE_ENTITY,
            case StorageError::DeletedBucketID:
            case StorageError::InternalError:
            case StorageError::SystemError:
            case StorageError::StorageChannelClosed:
                return 500; //HTTP_STATUS_INTERNAL_SERVER_ERROR;
        }
    }
 
    enum class StreamError {
        Success = 0,
        EndOfStream,
        Unknown,
        SystemError,
        StreamNotFound,
        StreamChannelClosed,
        ReadOnWriteStream,
        WriteOnReadStream,
        StreamClosed,
        StreamChunkTooLarge
    };
 
    inline std::string to_string(StreamError e) {
        switch (e) {
            case StreamError::Success:
                return "Stream: success";
            case StreamError::EndOfStream:
                return "Stream: end of stream";
            case StreamError::Unknown:
                return "Stream: unknown error";
            case StreamError::SystemError:
                return "Stream: system error";
            case StreamError::StreamNotFound:
                return "Stream: stream not found";
            case StreamError::StreamChannelClosed:
                return "Stream: stream channel is closed";
            case StreamError::ReadOnWriteStream:
                return "Stream: read attempted on write stream";
            case StreamError::WriteOnReadStream:
                return "Stream: write attempted on read stream";
            case StreamError::StreamClosed:
                return "Stream: stream is closed";
            case StreamError::StreamChunkTooLarge:
                return "Stream: stream chunk is too large";
        }
    }
 
}}