2017-07-28 19:37:08 +00:00
|
|
|
#![allow(unknown_lints)]
|
2018-12-12 21:20:55 +00:00
|
|
|
#![allow(clippy::identity_op)] // used for vertical alignment
|
2018-12-06 19:21:24 +00:00
|
|
|
|
2017-10-02 10:04:02 +00:00
|
|
|
use std::collections::BTreeMap;
|
2016-04-02 01:06:20 +00:00
|
|
|
use std::fs::File;
|
2015-02-27 01:04:25 +00:00
|
|
|
use std::io::prelude::*;
|
2017-12-08 19:31:17 +00:00
|
|
|
use std::io::Cursor;
|
2014-09-27 04:14:46 +00:00
|
|
|
|
2016-05-18 17:01:40 +00:00
|
|
|
use curl::easy::{Easy, List};
|
2018-12-12 21:20:44 +00:00
|
|
|
use failure::bail;
|
Always nicely show errors from crates.io if possible
Currently if Cargo ever gets a non-200 response, it will either not show
the error at all (if it was a 403 or 404), or spit out the entire
response body. Historically crates.io has served a 200 for most errors
to work around this, but we've stopped doing this as it causes problems
for other clients.
Additionally, we're starting to server more errors that have semantic
meaning (429 for rate limiting, 503 when we're in read only mode). If
the request specifies "Accept: application/json", we should ideally
return the errors formatted nicely. This isn't always true, but it's
what we'd like to do going forward.
While the output that Cargo puts out at least contains the actual
message, it's buried under a ton of useless info. This changes the
behavior so that if the response was valid JSON in the format that Cargo
expects, it just shows that (along with a description of the response
status), and only falls back to spitting out everything if it can't
parse the response body.
I'd love to add some more tests for this, but I've had trouble finding
anywhere in the test suite that exercises these paths.
2019-03-21 18:10:43 +00:00
|
|
|
use http::status::StatusCode;
|
2018-12-12 21:20:44 +00:00
|
|
|
use serde::{Deserialize, Serialize};
|
|
|
|
use serde_json;
|
2016-03-07 08:19:40 +00:00
|
|
|
use url::percent_encoding::{percent_encode, QUERY_ENCODE_SET};
|
|
|
|
|
2017-12-08 19:31:17 +00:00
|
|
|
pub type Result<T> = std::result::Result<T, failure::Error>;
|
2017-05-24 04:35:54 +00:00
|
|
|
|
2014-09-27 04:14:46 +00:00
|
|
|
pub struct Registry {
|
2018-12-20 01:40:01 +00:00
|
|
|
/// The base URL for issuing API requests.
|
2014-09-27 04:14:46 +00:00
|
|
|
host: String,
|
2018-12-20 01:40:01 +00:00
|
|
|
/// Optional authorization token.
|
|
|
|
/// If None, commands requiring authorization will fail.
|
2014-11-22 14:36:14 +00:00
|
|
|
token: Option<String>,
|
2018-12-20 01:40:01 +00:00
|
|
|
/// Curl handle for issuing requests.
|
2016-05-18 17:01:40 +00:00
|
|
|
handle: Easy,
|
2014-09-27 04:14:46 +00:00
|
|
|
}
|
|
|
|
|
2015-04-05 07:00:01 +00:00
|
|
|
#[derive(PartialEq, Clone, Copy)]
|
2014-11-22 14:36:14 +00:00
|
|
|
pub enum Auth {
|
|
|
|
Authorized,
|
2014-09-27 04:14:46 +00:00
|
|
|
Unauthorized,
|
2016-05-18 17:01:40 +00:00
|
|
|
}
|
|
|
|
|
2017-02-10 20:01:52 +00:00
|
|
|
#[derive(Deserialize)]
|
2014-11-22 14:36:14 +00:00
|
|
|
pub struct Crate {
|
|
|
|
pub name: String,
|
|
|
|
pub description: Option<String>,
|
2017-05-24 04:35:54 +00:00
|
|
|
pub max_version: String,
|
2014-11-22 14:36:14 +00:00
|
|
|
}
|
|
|
|
|
2017-02-10 20:01:52 +00:00
|
|
|
#[derive(Serialize)]
|
2014-09-27 04:14:46 +00:00
|
|
|
pub struct NewCrate {
|
|
|
|
pub name: String,
|
|
|
|
pub vers: String,
|
|
|
|
pub deps: Vec<NewCrateDependency>,
|
2017-10-02 10:04:02 +00:00
|
|
|
pub features: BTreeMap<String, Vec<String>>,
|
2014-09-27 04:14:46 +00:00
|
|
|
pub authors: Vec<String>,
|
|
|
|
pub description: Option<String>,
|
|
|
|
pub documentation: Option<String>,
|
|
|
|
pub homepage: Option<String>,
|
|
|
|
pub readme: Option<String>,
|
2017-10-17 05:04:33 +00:00
|
|
|
pub readme_file: Option<String>,
|
2014-09-27 04:14:46 +00:00
|
|
|
pub keywords: Vec<String>,
|
2016-11-18 21:49:55 +00:00
|
|
|
pub categories: Vec<String>,
|
2014-09-27 04:14:46 +00:00
|
|
|
pub license: Option<String>,
|
2014-11-25 06:18:54 +00:00
|
|
|
pub license_file: Option<String>,
|
2014-09-27 04:14:46 +00:00
|
|
|
pub repository: Option<String>,
|
2017-10-02 10:04:02 +00:00
|
|
|
pub badges: BTreeMap<String, BTreeMap<String, String>>,
|
2018-12-20 01:40:01 +00:00
|
|
|
#[serde(default)]
|
|
|
|
pub links: Option<String>,
|
2014-09-27 04:14:46 +00:00
|
|
|
}
|
|
|
|
|
2017-02-10 20:01:52 +00:00
|
|
|
#[derive(Serialize)]
|
2014-09-27 04:14:46 +00:00
|
|
|
pub struct NewCrateDependency {
|
|
|
|
pub optional: bool,
|
|
|
|
pub default_features: bool,
|
|
|
|
pub name: String,
|
|
|
|
pub features: Vec<String>,
|
|
|
|
pub version_req: String,
|
|
|
|
pub target: Option<String>,
|
2014-11-21 02:17:31 +00:00
|
|
|
pub kind: String,
|
2018-09-07 16:37:06 +00:00
|
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
|
|
pub registry: Option<String>,
|
|
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
|
|
pub explicit_name_in_toml: Option<String>,
|
2014-09-27 04:14:46 +00:00
|
|
|
}
|
|
|
|
|
2017-02-10 20:01:52 +00:00
|
|
|
#[derive(Deserialize)]
|
2014-11-13 06:15:41 +00:00
|
|
|
pub struct User {
|
2015-01-13 16:41:04 +00:00
|
|
|
pub id: u32,
|
2014-11-13 06:15:41 +00:00
|
|
|
pub login: String,
|
2015-08-05 18:33:56 +00:00
|
|
|
pub avatar: Option<String>,
|
2014-11-13 06:15:41 +00:00
|
|
|
pub email: Option<String>,
|
|
|
|
pub name: Option<String>,
|
|
|
|
}
|
|
|
|
|
2016-12-05 17:36:44 +00:00
|
|
|
pub struct Warnings {
|
|
|
|
pub invalid_categories: Vec<String>,
|
2017-01-01 20:14:34 +00:00
|
|
|
pub invalid_badges: Vec<String>,
|
2018-10-31 12:34:04 +00:00
|
|
|
pub other: Vec<String>,
|
2016-12-05 17:36:44 +00:00
|
|
|
}
|
|
|
|
|
2018-03-14 15:17:44 +00:00
|
|
|
#[derive(Deserialize)]
|
|
|
|
struct R {
|
|
|
|
ok: bool,
|
|
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
|
|
struct OwnerResponse {
|
|
|
|
ok: bool,
|
|
|
|
msg: String,
|
|
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
|
|
struct ApiErrorList {
|
|
|
|
errors: Vec<ApiError>,
|
|
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
|
|
struct ApiError {
|
|
|
|
detail: String,
|
|
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
|
|
struct OwnersReq<'a> {
|
|
|
|
users: &'a [&'a str],
|
|
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
|
|
struct Users {
|
|
|
|
users: Vec<User>,
|
|
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
|
|
struct TotalCrates {
|
|
|
|
total: u32,
|
|
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
|
|
struct Crates {
|
|
|
|
crates: Vec<Crate>,
|
|
|
|
meta: TotalCrates,
|
|
|
|
}
|
2014-09-27 04:14:46 +00:00
|
|
|
impl Registry {
|
2014-11-22 14:36:14 +00:00
|
|
|
pub fn new(host: String, token: Option<String>) -> Registry {
|
2016-05-18 17:01:40 +00:00
|
|
|
Registry::new_handle(host, token, Easy::new())
|
2014-09-27 04:14:46 +00:00
|
|
|
}
|
|
|
|
|
2018-03-14 15:17:44 +00:00
|
|
|
pub fn new_handle(host: String, token: Option<String>, handle: Easy) -> Registry {
|
2014-09-27 04:14:46 +00:00
|
|
|
Registry {
|
2018-02-23 23:27:53 +00:00
|
|
|
host,
|
|
|
|
token,
|
|
|
|
handle,
|
2014-09-27 04:14:46 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-12-20 01:40:01 +00:00
|
|
|
pub fn host(&self) -> &str {
|
|
|
|
&self.host
|
|
|
|
}
|
|
|
|
|
2017-09-26 21:01:50 +00:00
|
|
|
pub fn add_owners(&mut self, krate: &str, owners: &[&str]) -> Result<String> {
|
2017-02-10 20:01:52 +00:00
|
|
|
let body = serde_json::to_string(&OwnersReq { users: owners })?;
|
2018-07-20 19:39:05 +00:00
|
|
|
let body = self.put(&format!("/crates/{}/owners", krate), body.as_bytes())?;
|
2017-09-28 19:23:48 +00:00
|
|
|
assert!(serde_json::from_str::<OwnerResponse>(&body)?.ok);
|
|
|
|
Ok(serde_json::from_str::<OwnerResponse>(&body)?.msg)
|
2014-09-27 04:14:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn remove_owners(&mut self, krate: &str, owners: &[&str]) -> Result<()> {
|
2017-02-10 20:01:52 +00:00
|
|
|
let body = serde_json::to_string(&OwnersReq { users: owners })?;
|
2018-07-20 19:39:05 +00:00
|
|
|
let body = self.delete(&format!("/crates/{}/owners", krate), Some(body.as_bytes()))?;
|
2017-09-28 19:23:48 +00:00
|
|
|
assert!(serde_json::from_str::<OwnerResponse>(&body)?.ok);
|
2014-09-27 04:14:46 +00:00
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
2014-11-13 06:15:41 +00:00
|
|
|
pub fn list_owners(&mut self, krate: &str) -> Result<Vec<User>> {
|
2018-07-20 19:39:05 +00:00
|
|
|
let body = self.get(&format!("/crates/{}/owners", krate))?;
|
2017-02-10 20:01:52 +00:00
|
|
|
Ok(serde_json::from_str::<Users>(&body)?.users)
|
2014-11-13 06:15:41 +00:00
|
|
|
}
|
|
|
|
|
2018-03-14 15:17:44 +00:00
|
|
|
pub fn publish(&mut self, krate: &NewCrate, tarball: &File) -> Result<Warnings> {
|
2017-02-10 20:01:52 +00:00
|
|
|
let json = serde_json::to_string(krate)?;
|
2014-09-27 04:14:46 +00:00
|
|
|
// Prepare the body. The format of the upload request is:
|
|
|
|
//
|
|
|
|
// <le u32 of json>
|
|
|
|
// <json request> (metadata for the package)
|
|
|
|
// <le u32 of tarball>
|
|
|
|
// <source tarball>
|
2017-05-24 04:35:54 +00:00
|
|
|
let stat = tarball.metadata()?;
|
2014-09-27 04:14:46 +00:00
|
|
|
let header = {
|
2015-02-27 01:04:25 +00:00
|
|
|
let mut w = Vec::new();
|
2018-03-14 15:17:44 +00:00
|
|
|
w.extend(
|
|
|
|
[
|
|
|
|
(json.len() >> 0) as u8,
|
|
|
|
(json.len() >> 8) as u8,
|
|
|
|
(json.len() >> 16) as u8,
|
|
|
|
(json.len() >> 24) as u8,
|
2018-04-04 21:06:26 +00:00
|
|
|
].iter().cloned(),
|
2018-03-14 15:17:44 +00:00
|
|
|
);
|
2018-04-04 21:06:26 +00:00
|
|
|
w.extend(json.as_bytes().iter().cloned());
|
2018-03-14 15:17:44 +00:00
|
|
|
w.extend(
|
|
|
|
[
|
|
|
|
(stat.len() >> 0) as u8,
|
|
|
|
(stat.len() >> 8) as u8,
|
|
|
|
(stat.len() >> 16) as u8,
|
|
|
|
(stat.len() >> 24) as u8,
|
2018-04-04 21:06:26 +00:00
|
|
|
].iter().cloned(),
|
2018-03-14 15:17:44 +00:00
|
|
|
);
|
2015-02-27 01:04:25 +00:00
|
|
|
w
|
2014-09-27 04:14:46 +00:00
|
|
|
};
|
2015-02-27 01:04:25 +00:00
|
|
|
let size = stat.len() as usize + header.len();
|
|
|
|
let mut body = Cursor::new(header).chain(tarball);
|
2014-09-27 04:14:46 +00:00
|
|
|
|
|
|
|
let url = format!("{}/api/v1/crates/new", self.host);
|
2014-11-22 14:36:14 +00:00
|
|
|
|
2015-03-09 18:30:37 +00:00
|
|
|
let token = match self.token.as_ref() {
|
|
|
|
Some(s) => s,
|
2017-12-08 19:31:17 +00:00
|
|
|
None => bail!("no upload token found, please run `cargo login`"),
|
2015-03-09 18:30:37 +00:00
|
|
|
};
|
2016-11-11 13:25:20 +00:00
|
|
|
self.handle.put(true)?;
|
|
|
|
self.handle.url(&url)?;
|
|
|
|
self.handle.in_filesize(size as u64)?;
|
2016-05-18 17:01:40 +00:00
|
|
|
let mut headers = List::new();
|
2016-11-11 13:25:20 +00:00
|
|
|
headers.append("Accept: application/json")?;
|
|
|
|
headers.append(&format!("Authorization: {}", token))?;
|
|
|
|
self.handle.http_headers(headers)?;
|
2016-05-18 17:01:40 +00:00
|
|
|
|
2017-05-24 04:35:54 +00:00
|
|
|
let body = handle(&mut self.handle, &mut |buf| body.read(buf).unwrap_or(0))?;
|
2017-01-01 20:14:34 +00:00
|
|
|
|
2018-04-04 21:06:26 +00:00
|
|
|
let response = if body.is_empty() {
|
2017-02-10 20:01:52 +00:00
|
|
|
"{}".parse()?
|
2018-04-04 21:06:26 +00:00
|
|
|
} else {
|
|
|
|
body.parse::<serde_json::Value>()?
|
2016-11-29 21:09:00 +00:00
|
|
|
};
|
2017-01-01 20:14:34 +00:00
|
|
|
|
2017-05-24 04:35:54 +00:00
|
|
|
let invalid_categories: Vec<String> = response
|
|
|
|
.get("warnings")
|
|
|
|
.and_then(|j| j.get("invalid_categories"))
|
|
|
|
.and_then(|j| j.as_array())
|
|
|
|
.map(|x| x.iter().flat_map(|j| j.as_str()).map(Into::into).collect())
|
|
|
|
.unwrap_or_else(Vec::new);
|
|
|
|
|
|
|
|
let invalid_badges: Vec<String> = response
|
|
|
|
.get("warnings")
|
|
|
|
.and_then(|j| j.get("invalid_badges"))
|
|
|
|
.and_then(|j| j.as_array())
|
|
|
|
.map(|x| x.iter().flat_map(|j| j.as_str()).map(Into::into).collect())
|
|
|
|
.unwrap_or_else(Vec::new);
|
2017-01-01 20:14:34 +00:00
|
|
|
|
2018-10-31 12:34:04 +00:00
|
|
|
let other: Vec<String> = response
|
|
|
|
.get("warnings")
|
|
|
|
.and_then(|j| j.get("other"))
|
|
|
|
.and_then(|j| j.as_array())
|
|
|
|
.map(|x| x.iter().flat_map(|j| j.as_str()).map(Into::into).collect())
|
|
|
|
.unwrap_or_else(Vec::new);
|
|
|
|
|
2017-01-01 20:14:34 +00:00
|
|
|
Ok(Warnings {
|
2018-02-23 23:27:53 +00:00
|
|
|
invalid_categories,
|
|
|
|
invalid_badges,
|
2018-10-31 12:34:04 +00:00
|
|
|
other,
|
2017-01-01 20:14:34 +00:00
|
|
|
})
|
2014-09-27 04:14:46 +00:00
|
|
|
}
|
|
|
|
|
2018-03-10 14:42:08 +00:00
|
|
|
pub fn search(&mut self, query: &str, limit: u32) -> Result<(Vec<Crate>, u32)> {
|
|
|
|
let formatted_query = percent_encode(query.as_bytes(), QUERY_ENCODE_SET);
|
2016-11-11 13:25:20 +00:00
|
|
|
let body = self.req(
|
2018-07-20 19:39:05 +00:00
|
|
|
&format!("/crates?q={}&per_page={}", formatted_query, limit),
|
2018-03-14 15:17:44 +00:00
|
|
|
None,
|
|
|
|
Auth::Unauthorized,
|
2016-11-11 13:25:20 +00:00
|
|
|
)?;
|
2014-11-22 14:36:14 +00:00
|
|
|
|
2017-02-10 20:01:52 +00:00
|
|
|
let crates = serde_json::from_str::<Crates>(&body)?;
|
2016-03-07 08:19:40 +00:00
|
|
|
Ok((crates.crates, crates.meta.total))
|
2014-11-22 14:36:14 +00:00
|
|
|
}
|
|
|
|
|
2014-09-27 04:14:46 +00:00
|
|
|
pub fn yank(&mut self, krate: &str, version: &str) -> Result<()> {
|
2018-07-20 19:39:05 +00:00
|
|
|
let body = self.delete(&format!("/crates/{}/{}/yank", krate, version), None)?;
|
2017-02-10 20:01:52 +00:00
|
|
|
assert!(serde_json::from_str::<R>(&body)?.ok);
|
2014-09-27 04:14:46 +00:00
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn unyank(&mut self, krate: &str, version: &str) -> Result<()> {
|
2018-07-20 19:39:05 +00:00
|
|
|
let body = self.put(&format!("/crates/{}/{}/unyank", krate, version), &[])?;
|
2017-02-10 20:01:52 +00:00
|
|
|
assert!(serde_json::from_str::<R>(&body)?.ok);
|
2014-09-27 04:14:46 +00:00
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
2018-07-20 19:39:05 +00:00
|
|
|
fn put(&mut self, path: &str, b: &[u8]) -> Result<String> {
|
2016-11-11 13:25:20 +00:00
|
|
|
self.handle.put(true)?;
|
2016-05-18 17:01:40 +00:00
|
|
|
self.req(path, Some(b), Auth::Authorized)
|
2014-11-13 06:15:41 +00:00
|
|
|
}
|
|
|
|
|
2018-07-20 19:39:05 +00:00
|
|
|
fn get(&mut self, path: &str) -> Result<String> {
|
2016-11-11 13:25:20 +00:00
|
|
|
self.handle.get(true)?;
|
2016-05-18 17:01:40 +00:00
|
|
|
self.req(path, None, Auth::Authorized)
|
2014-09-27 04:14:46 +00:00
|
|
|
}
|
|
|
|
|
2018-07-20 19:39:05 +00:00
|
|
|
fn delete(&mut self, path: &str, b: Option<&[u8]>) -> Result<String> {
|
2016-11-11 13:25:20 +00:00
|
|
|
self.handle.custom_request("DELETE")?;
|
2016-05-18 17:01:40 +00:00
|
|
|
self.req(path, b, Auth::Authorized)
|
2014-11-13 06:15:41 +00:00
|
|
|
}
|
|
|
|
|
2018-07-20 19:39:05 +00:00
|
|
|
fn req(&mut self, path: &str, body: Option<&[u8]>, authorized: Auth) -> Result<String> {
|
2016-11-11 13:25:20 +00:00
|
|
|
self.handle.url(&format!("{}/api/v1{}", self.host, path))?;
|
2016-05-18 17:01:40 +00:00
|
|
|
let mut headers = List::new();
|
2016-11-11 13:25:20 +00:00
|
|
|
headers.append("Accept: application/json")?;
|
|
|
|
headers.append("Content-Type: application/json")?;
|
2014-11-22 14:36:14 +00:00
|
|
|
|
|
|
|
if authorized == Auth::Authorized {
|
2015-03-09 18:30:37 +00:00
|
|
|
let token = match self.token.as_ref() {
|
|
|
|
Some(s) => s,
|
2017-12-08 19:31:17 +00:00
|
|
|
None => bail!("no upload token found, please run `cargo login`"),
|
2015-03-09 18:30:37 +00:00
|
|
|
};
|
2016-11-11 13:25:20 +00:00
|
|
|
headers.append(&format!("Authorization: {}", token))?;
|
2014-11-22 14:36:14 +00:00
|
|
|
}
|
2016-11-11 13:25:20 +00:00
|
|
|
self.handle.http_headers(headers)?;
|
2014-11-13 06:15:41 +00:00
|
|
|
match body {
|
2016-05-18 17:01:40 +00:00
|
|
|
Some(mut body) => {
|
2016-11-11 13:25:20 +00:00
|
|
|
self.handle.upload(true)?;
|
|
|
|
self.handle.in_filesize(body.len() as u64)?;
|
2016-05-18 17:01:40 +00:00
|
|
|
handle(&mut self.handle, &mut |buf| body.read(buf).unwrap_or(0))
|
|
|
|
}
|
|
|
|
None => handle(&mut self.handle, &mut |_| 0),
|
2014-09-27 04:14:46 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-12-06 19:21:24 +00:00
|
|
|
fn handle(handle: &mut Easy, read: &mut dyn FnMut(&mut [u8]) -> usize) -> Result<String> {
|
2016-05-18 17:01:40 +00:00
|
|
|
let mut headers = Vec::new();
|
|
|
|
let mut body = Vec::new();
|
|
|
|
{
|
|
|
|
let mut handle = handle.transfer();
|
2016-11-11 13:25:20 +00:00
|
|
|
handle.read_function(|buf| Ok(read(buf)))?;
|
|
|
|
handle.write_function(|data| {
|
2016-05-18 17:01:40 +00:00
|
|
|
body.extend_from_slice(data);
|
|
|
|
Ok(data.len())
|
2016-11-11 13:25:20 +00:00
|
|
|
})?;
|
|
|
|
handle.header_function(|data| {
|
2016-05-18 17:01:40 +00:00
|
|
|
headers.push(String::from_utf8_lossy(data).into_owned());
|
|
|
|
true
|
2016-11-11 13:25:20 +00:00
|
|
|
})?;
|
|
|
|
handle.perform()?;
|
2016-05-18 17:01:40 +00:00
|
|
|
}
|
|
|
|
|
Always nicely show errors from crates.io if possible
Currently if Cargo ever gets a non-200 response, it will either not show
the error at all (if it was a 403 or 404), or spit out the entire
response body. Historically crates.io has served a 200 for most errors
to work around this, but we've stopped doing this as it causes problems
for other clients.
Additionally, we're starting to server more errors that have semantic
meaning (429 for rate limiting, 503 when we're in read only mode). If
the request specifies "Accept: application/json", we should ideally
return the errors formatted nicely. This isn't always true, but it's
what we'd like to do going forward.
While the output that Cargo puts out at least contains the actual
message, it's buried under a ton of useless info. This changes the
behavior so that if the response was valid JSON in the format that Cargo
expects, it just shows that (along with a description of the response
status), and only falls back to spitting out everything if it can't
parse the response body.
I'd love to add some more tests for this, but I've had trouble finding
anywhere in the test suite that exercises these paths.
2019-03-21 18:10:43 +00:00
|
|
|
let body = match String::from_utf8(body) {
|
|
|
|
Ok(body) => body,
|
|
|
|
Err(..) => bail!("response body was not valid utf-8"),
|
|
|
|
};
|
|
|
|
let errors = serde_json::from_str::<ApiErrorList>(&body).ok().map(|s| {
|
|
|
|
s.errors.into_iter().map(|s| s.detail).collect::<Vec<_>>()
|
|
|
|
});
|
|
|
|
|
|
|
|
match (handle.response_code()?, errors) {
|
|
|
|
(0, None) | (200, None) => {},
|
|
|
|
(code, Some(errors)) => {
|
|
|
|
let code = StatusCode::from_u16(code as _)?;
|
|
|
|
bail!("api errors (status {}): {}", code, errors.join(", "))
|
|
|
|
}
|
|
|
|
(code, None) => bail!(
|
2018-03-14 15:17:44 +00:00
|
|
|
"failed to get a 200 OK response, got {}\n\
|
|
|
|
headers:\n\
|
|
|
|
\t{}\n\
|
|
|
|
body:\n\
|
|
|
|
{}",
|
Always nicely show errors from crates.io if possible
Currently if Cargo ever gets a non-200 response, it will either not show
the error at all (if it was a 403 or 404), or spit out the entire
response body. Historically crates.io has served a 200 for most errors
to work around this, but we've stopped doing this as it causes problems
for other clients.
Additionally, we're starting to server more errors that have semantic
meaning (429 for rate limiting, 503 when we're in read only mode). If
the request specifies "Accept: application/json", we should ideally
return the errors formatted nicely. This isn't always true, but it's
what we'd like to do going forward.
While the output that Cargo puts out at least contains the actual
message, it's buried under a ton of useless info. This changes the
behavior so that if the response was valid JSON in the format that Cargo
expects, it just shows that (along with a description of the response
status), and only falls back to spitting out everything if it can't
parse the response body.
I'd love to add some more tests for this, but I've had trouble finding
anywhere in the test suite that exercises these paths.
2019-03-21 18:10:43 +00:00
|
|
|
code,
|
|
|
|
headers.join("\n\t"),
|
|
|
|
body,
|
2018-03-14 15:17:44 +00:00
|
|
|
),
|
2014-09-27 04:14:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
Ok(body)
|
|
|
|
}
|