2017-07-28 19:37:08 +00:00
|
|
|
#![allow(unknown_lints)]
|
|
|
|
|
2014-09-27 04:14:46 +00:00
|
|
|
extern crate curl;
|
2016-03-07 08:19:40 +00:00
|
|
|
extern crate url;
|
2017-05-24 04:35:54 +00:00
|
|
|
#[macro_use]
|
|
|
|
extern crate error_chain;
|
2017-02-10 20:01:52 +00:00
|
|
|
extern crate serde_json;
|
|
|
|
#[macro_use]
|
|
|
|
extern crate serde_derive;
|
2014-09-27 04:14:46 +00:00
|
|
|
|
|
|
|
use std::collections::HashMap;
|
2016-04-02 01:06:20 +00:00
|
|
|
use std::fs::File;
|
2015-02-27 01:04:25 +00:00
|
|
|
use std::io::prelude::*;
|
|
|
|
use std::io::{self, Cursor};
|
2014-09-27 04:14:46 +00:00
|
|
|
|
2016-05-18 17:01:40 +00:00
|
|
|
use curl::easy::{Easy, List};
|
2014-12-24 02:45:46 +00:00
|
|
|
|
2016-03-07 08:19:40 +00:00
|
|
|
use url::percent_encoding::{percent_encode, QUERY_ENCODE_SET};
|
|
|
|
|
2017-05-24 04:35:54 +00:00
|
|
|
error_chain! {
|
|
|
|
foreign_links {
|
|
|
|
Curl(curl::Error);
|
|
|
|
Io(io::Error);
|
|
|
|
Json(serde_json::Error);
|
|
|
|
}
|
|
|
|
|
|
|
|
errors {
|
|
|
|
NotOkResponse(code: u32, headers: Vec<String>, body: Vec<u8>){
|
|
|
|
description("failed to get a 200 OK response")
|
|
|
|
display("failed to get a 200 OK response, got {}
|
|
|
|
headers:
|
|
|
|
{}
|
|
|
|
body:
|
|
|
|
{}", code, headers.join("\n ", ), String::from_utf8_lossy(body))
|
|
|
|
}
|
|
|
|
NonUtf8Body {
|
|
|
|
description("response body was not utf-8")
|
|
|
|
display("response body was not utf-8")
|
|
|
|
}
|
|
|
|
Api(errs: Vec<String>) {
|
|
|
|
display("api errors: {}", errs.join(", "))
|
|
|
|
}
|
|
|
|
Unauthorized {
|
|
|
|
display("unauthorized API access")
|
|
|
|
}
|
|
|
|
TokenMissing{
|
|
|
|
display("no upload token found, please run `cargo login`")
|
|
|
|
}
|
|
|
|
NotFound {
|
|
|
|
display("cannot find crate")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-09-27 04:14:46 +00:00
|
|
|
pub struct Registry {
|
|
|
|
host: String,
|
2014-11-22 14:36:14 +00:00
|
|
|
token: Option<String>,
|
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>,
|
|
|
|
pub features: HashMap<String, Vec<String>>,
|
|
|
|
pub authors: Vec<String>,
|
|
|
|
pub description: Option<String>,
|
|
|
|
pub documentation: Option<String>,
|
|
|
|
pub homepage: Option<String>,
|
|
|
|
pub readme: Option<String>,
|
|
|
|
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-01-01 20:14:34 +00:00
|
|
|
pub badges: HashMap<String, HashMap<String, 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,
|
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>,
|
2016-12-05 17:36:44 +00:00
|
|
|
}
|
|
|
|
|
2017-02-10 20:01:52 +00:00
|
|
|
#[derive(Deserialize)] struct R { ok: bool }
|
|
|
|
#[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
|
|
|
}
|
|
|
|
|
2016-05-18 17:01:40 +00:00
|
|
|
pub fn new_handle(host: String,
|
|
|
|
token: Option<String>,
|
|
|
|
handle: Easy) -> Registry {
|
2014-09-27 04:14:46 +00:00
|
|
|
Registry {
|
|
|
|
host: host,
|
|
|
|
token: token,
|
|
|
|
handle: handle,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn add_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 })?;
|
2016-11-11 13:25:20 +00:00
|
|
|
let body = self.put(format!("/crates/{}/owners", krate),
|
|
|
|
body.as_bytes())?;
|
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 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 })?;
|
2016-11-11 13:25:20 +00:00
|
|
|
let body = self.delete(format!("/crates/{}/owners", krate),
|
|
|
|
Some(body.as_bytes()))?;
|
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(())
|
|
|
|
}
|
|
|
|
|
2014-11-13 06:15:41 +00:00
|
|
|
pub fn list_owners(&mut self, krate: &str) -> Result<Vec<User>> {
|
2016-11-11 13:25:20 +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
|
|
|
}
|
|
|
|
|
2016-11-29 18:19:07 +00:00
|
|
|
pub fn publish(&mut self, krate: &NewCrate, tarball: &File)
|
2016-12-05 17:36:44 +00:00
|
|
|
-> 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();
|
|
|
|
w.extend([
|
|
|
|
(json.len() >> 0) as u8,
|
|
|
|
(json.len() >> 8) as u8,
|
|
|
|
(json.len() >> 16) as u8,
|
|
|
|
(json.len() >> 24) as u8,
|
2015-03-09 18:30:37 +00:00
|
|
|
].iter().map(|x| *x));
|
|
|
|
w.extend(json.as_bytes().iter().map(|x| *x));
|
2015-02-27 01:04:25 +00:00
|
|
|
w.extend([
|
|
|
|
(stat.len() >> 0) as u8,
|
|
|
|
(stat.len() >> 8) as u8,
|
|
|
|
(stat.len() >> 16) as u8,
|
|
|
|
(stat.len() >> 24) as u8,
|
2015-03-09 18:30:37 +00:00
|
|
|
].iter().map(|x| *x));
|
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-05-24 04:35:54 +00:00
|
|
|
None => return Err(Error::from_kind(ErrorKind::TokenMissing)),
|
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
|
|
|
|
2016-11-29 21:09:00 +00:00
|
|
|
let response = if body.len() > 0 {
|
2017-02-10 20:01:52 +00:00
|
|
|
body.parse::<serde_json::Value>()?
|
2016-11-29 21:09:00 +00:00
|
|
|
} else {
|
2017-02-10 20:01:52 +00:00
|
|
|
"{}".parse()?
|
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
|
|
|
|
|
|
|
Ok(Warnings {
|
|
|
|
invalid_categories: invalid_categories,
|
|
|
|
invalid_badges: invalid_badges,
|
|
|
|
})
|
2014-09-27 04:14:46 +00:00
|
|
|
}
|
|
|
|
|
2016-03-07 08:19:40 +00:00
|
|
|
pub fn search(&mut self, query: &str, limit: u8) -> Result<(Vec<Crate>, u32)> {
|
|
|
|
let formated_query = percent_encode(query.as_bytes(), QUERY_ENCODE_SET);
|
2016-11-11 13:25:20 +00:00
|
|
|
let body = self.req(
|
2016-03-07 08:19:40 +00:00
|
|
|
format!("/crates?q={}&per_page={}", formated_query, limit),
|
2016-05-18 17:01:40 +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<()> {
|
2016-11-11 13:25:20 +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<()> {
|
2016-11-11 13:25:20 +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(())
|
|
|
|
}
|
|
|
|
|
|
|
|
fn put(&mut self, path: String, 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
|
|
|
}
|
|
|
|
|
|
|
|
fn get(&mut self, path: String) -> 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
|
|
|
}
|
|
|
|
|
|
|
|
fn delete(&mut self, path: String, 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
|
|
|
}
|
|
|
|
|
2016-05-18 17:01:40 +00:00
|
|
|
fn req(&mut self,
|
|
|
|
path: String,
|
|
|
|
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-05-24 04:35:54 +00:00
|
|
|
None => return Err(Error::from_kind(ErrorKind::TokenMissing)),
|
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
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-05-18 17:01:40 +00:00
|
|
|
fn handle(handle: &mut Easy,
|
|
|
|
read: &mut FnMut(&mut [u8]) -> usize) -> Result<String> {
|
|
|
|
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
|
|
|
}
|
|
|
|
|
2016-11-11 13:25:20 +00:00
|
|
|
match handle.response_code()? {
|
2014-09-27 04:14:46 +00:00
|
|
|
0 => {} // file upload url sometimes
|
|
|
|
200 => {}
|
2017-05-24 04:35:54 +00:00
|
|
|
403 => return Err(Error::from_kind(ErrorKind::Unauthorized)),
|
|
|
|
404 => return Err(Error::from_kind(ErrorKind::NotFound)),
|
|
|
|
code => return Err(Error::from_kind(ErrorKind::NotOkResponse(code, headers, body))),
|
2014-09-27 04:14:46 +00:00
|
|
|
}
|
|
|
|
|
2016-05-18 17:01:40 +00:00
|
|
|
let body = match String::from_utf8(body) {
|
2014-09-27 04:14:46 +00:00
|
|
|
Ok(body) => body,
|
2017-05-24 04:35:54 +00:00
|
|
|
Err(..) => return Err(Error::from_kind(ErrorKind::NonUtf8Body)),
|
2014-09-27 04:14:46 +00:00
|
|
|
};
|
2017-02-10 20:01:52 +00:00
|
|
|
match serde_json::from_str::<ApiErrorList>(&body) {
|
2014-09-27 04:14:46 +00:00
|
|
|
Ok(errors) => {
|
2017-05-24 04:35:54 +00:00
|
|
|
return Err(Error::from_kind(ErrorKind::Api(errors
|
|
|
|
.errors
|
|
|
|
.into_iter()
|
|
|
|
.map(|s| s.detail)
|
|
|
|
.collect())))
|
2014-09-27 04:14:46 +00:00
|
|
|
}
|
|
|
|
Err(..) => {}
|
|
|
|
}
|
|
|
|
Ok(body)
|
|
|
|
}
|