1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

use std::io;

use hdfs_types::common::RpcResponseHeaderProto;
use hdfs_types::hdfs::BlockOpResponseProto;
use prost::{DecodeError, EncodeError};

mod fs;
pub use fs::*;
pub use hdfs_types as types;
mod crc32;
pub mod data_transfer;
pub mod hrpc;

/// hdfs error
#[derive(Debug, thiserror::Error)]
pub enum HDFSError {
    #[error("{0}")]
    IOError(io::Error),
    #[error("{0}")]
    EncodeError(EncodeError),
    #[error("{0}")]
    DecodeError(DecodeError),
    #[error("")]
    ChecksumError,
    #[error("")]
    NoAvailableBlock,
    #[error("")]
    NoAvailableLocation,
    #[error("")]
    EmptyFS,
    #[error("{0:?}")]
    DataNodeError(Box<BlockOpResponseProto>),
    #[error("{0:?}")]
    NameNodeError(Box<RpcResponseHeaderProto>),
}

impl From<io::Error> for HDFSError {
    fn from(value: io::Error) -> Self {
        Self::IOError(value)
    }
}

impl From<EncodeError> for HDFSError {
    fn from(value: EncodeError) -> Self {
        Self::EncodeError(value)
    }
}

impl From<DecodeError> for HDFSError {
    fn from(value: DecodeError) -> Self {
        Self::DecodeError(value)
    }
}

impl From<HDFSError> for io::Error {
    fn from(value: HDFSError) -> Self {
        match value {
            HDFSError::IOError(e) => e,
            HDFSError::EncodeError(e) => io::Error::new(io::ErrorKind::InvalidData, e),
            HDFSError::DecodeError(e) => io::Error::new(io::ErrorKind::InvalidData, e),
            HDFSError::ChecksumError => {
                io::Error::new(io::ErrorKind::InvalidData, "mismatch checksum")
            }
            HDFSError::EmptyFS => {
                io::Error::new(io::ErrorKind::InvalidData, "name node return empty fs")
            }
            HDFSError::NoAvailableBlock => {
                io::Error::new(io::ErrorKind::UnexpectedEof, "no available block")
            }
            HDFSError::NoAvailableLocation => {
                io::Error::new(io::ErrorKind::UnexpectedEof, "no available location")
            }
            HDFSError::NameNodeError(e) => io::Error::new(
                io::ErrorKind::Other,
                format!("name node error response {e:?}"),
            ),
            HDFSError::DataNodeError(e) => io::Error::new(
                io::ErrorKind::Other,
                format!("block operation response {e:?}"),
            ),
        }
    }
}