github.com/treeverse/lakefs@v1.24.1-0.20240520134607-95648127bfb0/clients/rust/src/apis/mod.rs (about)

     1  use std::error;
     2  use std::fmt;
     3  
     4  #[derive(Debug, Clone)]
     5  pub struct ResponseContent<T> {
     6      pub status: reqwest::StatusCode,
     7      pub content: String,
     8      pub entity: Option<T>,
     9  }
    10  
    11  #[derive(Debug)]
    12  pub enum Error<T> {
    13      Reqwest(reqwest::Error),
    14      Serde(serde_json::Error),
    15      Io(std::io::Error),
    16      ResponseError(ResponseContent<T>),
    17  }
    18  
    19  impl <T> fmt::Display for Error<T> {
    20      fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    21          let (module, e) = match self {
    22              Error::Reqwest(e) => ("reqwest", e.to_string()),
    23              Error::Serde(e) => ("serde", e.to_string()),
    24              Error::Io(e) => ("IO", e.to_string()),
    25              Error::ResponseError(e) => ("response", format!("status code {}", e.status)),
    26          };
    27          write!(f, "error in {}: {}", module, e)
    28      }
    29  }
    30  
    31  impl <T: fmt::Debug> error::Error for Error<T> {
    32      fn source(&self) -> Option<&(dyn error::Error + 'static)> {
    33          Some(match self {
    34              Error::Reqwest(e) => e,
    35              Error::Serde(e) => e,
    36              Error::Io(e) => e,
    37              Error::ResponseError(_) => return None,
    38          })
    39      }
    40  }
    41  
    42  impl <T> From<reqwest::Error> for Error<T> {
    43      fn from(e: reqwest::Error) -> Self {
    44          Error::Reqwest(e)
    45      }
    46  }
    47  
    48  impl <T> From<serde_json::Error> for Error<T> {
    49      fn from(e: serde_json::Error) -> Self {
    50          Error::Serde(e)
    51      }
    52  }
    53  
    54  impl <T> From<std::io::Error> for Error<T> {
    55      fn from(e: std::io::Error) -> Self {
    56          Error::Io(e)
    57      }
    58  }
    59  
    60  pub fn urlencode<T: AsRef<str>>(s: T) -> String {
    61      ::url::form_urlencoded::byte_serialize(s.as_ref().as_bytes()).collect()
    62  }
    63  
    64  pub fn parse_deep_object(prefix: &str, value: &serde_json::Value) -> Vec<(String, String)> {
    65      if let serde_json::Value::Object(object) = value {
    66          let mut params = vec![];
    67  
    68          for (key, value) in object {
    69              match value {
    70                  serde_json::Value::Object(_) => params.append(&mut parse_deep_object(
    71                      &format!("{}[{}]", prefix, key),
    72                      value,
    73                  )),
    74                  serde_json::Value::Array(array) => {
    75                      for (i, value) in array.iter().enumerate() {
    76                          params.append(&mut parse_deep_object(
    77                              &format!("{}[{}][{}]", prefix, key, i),
    78                              value,
    79                          ));
    80                      }
    81                  },
    82                  serde_json::Value::String(s) => params.push((format!("{}[{}]", prefix, key), s.clone())),
    83                  _ => params.push((format!("{}[{}]", prefix, key), value.to_string())),
    84              }
    85          }
    86  
    87          return params;
    88      }
    89  
    90      unimplemented!("Only objects are supported with style=deepObject")
    91  }
    92  
    93  pub mod actions_api;
    94  pub mod auth_api;
    95  pub mod branches_api;
    96  pub mod commits_api;
    97  pub mod config_api;
    98  pub mod experimental_api;
    99  pub mod external_api;
   100  pub mod health_check_api;
   101  pub mod import_api;
   102  pub mod internal_api;
   103  pub mod metadata_api;
   104  pub mod objects_api;
   105  pub mod refs_api;
   106  pub mod repositories_api;
   107  pub mod staging_api;
   108  pub mod tags_api;
   109  
   110  pub mod configuration;