src/client/http_client.rs

   1 use std::collections::HashSet;
   2 use std::io::Write;
   3 use std::sync::atomic::{AtomicUsize, Ordering};
   4 use std::sync::{Arc, Mutex};
   5
   6 use chrono::{DateTime, Utc};
   7 use failure::*;
   8 use futures::*;
   9 use futures::stream::Stream;
  10 use http::Uri;
  11 use http::header::HeaderValue;
  12 use http::{Request, Response};
  13 use hyper::Body;
  14 use hyper::client::{Client, HttpConnector};
  15 use openssl::ssl::{SslConnector, SslMethod};
  16 use serde_json::{json, Value};
  17 use tokio::io::AsyncReadExt;
  18 use tokio::sync::{mpsc, oneshot};
  19 use url::percent_encoding::{percent_encode,  DEFAULT_ENCODE_SET};
  20 use xdg::BaseDirectories;
  21
  22 use proxmox::tools::{
  23     digest_to_hex,
  24     fs::{file_get_json, file_set_contents},
  25 };
  26
  27 use super::merge_known_chunks::{MergedChunkInfo, MergeKnownChunks};
  28 use super::pipe_to_stream::PipeToSendStream;
  29 use crate::backup::*;
  30 use crate::tools::async_io::EitherStream;
  31 use crate::tools::futures::{cancellable, Canceller};
  32 use crate::tools::{self, tty, BroadcastFuture};
  33
  34 #[derive(Clone)]
  35 pub struct AuthInfo {
  36     username: String,
  37     ticket: String,
  38     token: String,
  39 }
  40
  41 /// HTTP(S) API client
  42 pub struct HttpClient {
  43     client: Client<HttpsConnector>,
  44     server: String,
  45     auth: BroadcastFuture<AuthInfo>,
  46 }
  47
  48 /// Delete stored ticket data (logout)
  49 pub fn delete_ticket_info(server: &str, username: &str) -> Result<(), Error> {
  50
  51     let base = BaseDirectories::with_prefix("proxmox-backup")?;
  52
  53     // usually /run/user/<uid>/...
  54     let path = base.place_runtime_file("tickets")?;
  55
  56     let mode = nix::sys::stat::Mode::from_bits_truncate(0o0600);
  57
  58     let mut data = file_get_json(&path, Some(json!({})))?;
  59
  60     if let Some(map) = data[server].as_object_mut() {
  61         map.remove(username);
  62     }
  63
  64     file_set_contents(path, data.to_string().as_bytes(), Some(mode))?;
  65
  66     Ok(())
  67 }
  68
  69 fn store_ticket_info(server: &str, username: &str, ticket: &str, token: &str) -> Result<(), Error> {
  70
  71     let base = BaseDirectories::with_prefix("proxmox-backup")?;
  72
  73     // usually /run/user/<uid>/...
  74     let path = base.place_runtime_file("tickets")?;
  75
  76     let mode = nix::sys::stat::Mode::from_bits_truncate(0o0600);
  77
  78     let mut data = file_get_json(&path, Some(json!({})))?;
  79
  80     let now = Utc::now().timestamp();
  81
  82     data[server][username] = json!({ "timestamp": now, "ticket": ticket, "token": token});
  83
  84     let mut new_data = json!({});
  85
  86     let ticket_lifetime = tools::ticket::TICKET_LIFETIME - 60;
  87
  88     let empty = serde_json::map::Map::new();
  89     for (server, info) in data.as_object().unwrap_or(&empty) {
  90         for (_user, uinfo) in info.as_object().unwrap_or(&empty) {
  91             if let Some(timestamp) = uinfo["timestamp"].as_i64() {
  92                 let age = now - timestamp;
  93                 if age < ticket_lifetime {
  94                     new_data[server][username] = uinfo.clone();
  95                 }
  96             }
  97         }
  98     }
  99
 100     file_set_contents(path, new_data.to_string().as_bytes(), Some(mode))?;
 101
 102     Ok(())
 103 }
 104
 105 fn load_ticket_info(server: &str, username: &str) -> Option<(String, String)> {
 106     let base = BaseDirectories::with_prefix("proxmox-backup").ok()?;
 107
 108     // usually /run/user/<uid>/...
 109     let path = base.place_runtime_file("tickets").ok()?;
 110     let data = file_get_json(&path, None).ok()?;
 111     let now = Utc::now().timestamp();
 112     let ticket_lifetime = tools::ticket::TICKET_LIFETIME - 60;
 113     let uinfo = data[server][username].as_object()?;
 114     let timestamp = uinfo["timestamp"].as_i64()?;
 115     let age = now - timestamp;
 116
 117     if age < ticket_lifetime {
 118         let ticket = uinfo["ticket"].as_str()?;
 119         let token = uinfo["token"].as_str()?;
 120         Some((ticket.to_owned(), token.to_owned()))
 121     } else {
 122         None
 123     }
 124 }
 125
 126 impl HttpClient {
 127
 128     pub fn new(server: &str, username: &str, password: Option<String>) -> Result<Self, Error> {
 129         let client = Self::build_client();
 130
 131         let password = if let Some(password) = password {
 132             password
 133         } else if let Some((ticket, _token)) = load_ticket_info(server, username) {
 134             ticket
 135         } else {
 136             Self::get_password(&username)?
 137         };
 138
 139         let login_future = Self::credentials(client.clone(), server.to_owned(), username.to_owned(), password);
 140
 141         Ok(Self {
 142             client,
 143             server: String::from(server),
 144             auth: BroadcastFuture::new(Box::new(login_future)),
 145         })
 146     }
 147
 148     /// Login
 149     ///
 150     /// Login is done on demand, so this is onyl required if you need
 151     /// access to authentication data in 'AuthInfo'.
 152     pub async fn login(&self) -> Result<AuthInfo, Error> {
 153         self.auth.listen().await
 154     }
 155
 156     fn get_password(_username: &str) -> Result<String, Error> {
 157         use std::env::VarError::*;
 158         match std::env::var("PBS_PASSWORD") {
 159             Ok(p) => return Ok(p),
 160             Err(NotUnicode(_)) => bail!("PBS_PASSWORD contains bad characters"),
 161             Err(NotPresent) => {
 162                 // Try another method
 163             }
 164         }
 165
 166         // If we're on a TTY, query the user for a password
 167         if tty::stdin_isatty() {
 168             return Ok(String::from_utf8(tty::read_password("Password: ")?)?);
 169         }
 170
 171         bail!("no password input mechanism available");
 172     }
 173
 174     fn build_client() -> Client<HttpsConnector> {
 175
 176         let mut ssl_connector_builder = SslConnector::builder(SslMethod::tls()).unwrap();
 177
 178         ssl_connector_builder.set_verify(openssl::ssl::SslVerifyMode::NONE); // fixme!
 179
 180         let mut httpc = hyper::client::HttpConnector::new();
 181         httpc.set_nodelay(true); // important for h2 download performance!
 182         httpc.set_recv_buffer_size(Some(1024*1024)); //important for h2 download performance!
 183         httpc.enforce_http(false); // we want https...
 184
 185         let https = HttpsConnector::with_connector(httpc, ssl_connector_builder.build());
 186
 187         Client::builder()
 188         //.http2_initial_stream_window_size( (1 << 31) - 2)
 189         //.http2_initial_connection_window_size( (1 << 31) - 2)
 190             .build::<_, Body>(https)
 191     }
 192
 193     pub async fn request(&self, mut req: Request<Body>) -> Result<Value, Error> {
 194
 195         let client = self.client.clone();
 196
 197         let auth =  self.login().await?;
 198
 199         let enc_ticket = format!("PBSAuthCookie={}", percent_encode(auth.ticket.as_bytes(), DEFAULT_ENCODE_SET));
 200         req.headers_mut().insert("Cookie", HeaderValue::from_str(&enc_ticket).unwrap());
 201         req.headers_mut().insert("CSRFPreventionToken", HeaderValue::from_str(&auth.token).unwrap());
 202
 203         Self::api_request(client, req).await
 204     }
 205
 206     pub async fn get(
 207         &self,
 208         path: &str,
 209         data: Option<Value>,
 210     ) -> Result<Value, Error> {
 211         let req = Self::request_builder(&self.server, "GET", path, data).unwrap();
 212         self.request(req).await
 213     }
 214
 215     pub async fn delete(
 216         &mut self,
 217         path: &str,
 218         data: Option<Value>,
 219     ) -> Result<Value, Error> {
 220         let req = Self::request_builder(&self.server, "DELETE", path, data).unwrap();
 221         self.request(req).await
 222     }
 223
 224     pub async fn post(
 225         &mut self,
 226         path: &str,
 227         data: Option<Value>,
 228     ) -> Result<Value, Error> {
 229         let req = Self::request_builder(&self.server, "POST", path, data).unwrap();
 230         self.request(req).await
 231     }
 232
 233     pub async fn download(
 234         &mut self,
 235         path: &str,
 236         output: &mut (dyn Write + Send),
 237     ) ->  Result<(), Error> {
 238         let mut req = Self::request_builder(&self.server, "GET", path, None).unwrap();
 239
 240         let client = self.client.clone();
 241
 242         let auth = self.login().await?;
 243
 244         let enc_ticket = format!("PBSAuthCookie={}", percent_encode(auth.ticket.as_bytes(), DEFAULT_ENCODE_SET));
 245         req.headers_mut().insert("Cookie", HeaderValue::from_str(&enc_ticket).unwrap());
 246
 247         let resp = client.request(req).await?;
 248         let status = resp.status();
 249         if !status.is_success() {
 250             HttpClient::api_response(resp)
 251                 .map(|_| Err(format_err!("unknown error")))
 252                 .await?
 253         } else {
 254             resp.into_body()
 255                 .map_err(Error::from)
 256                 .try_fold(output, move |acc, chunk| async move {
 257                     acc.write_all(&chunk)?;
 258                     Ok::<_, Error>(acc)
 259                 })
 260                 .await?;
 261         }
 262         Ok(())
 263     }
 264
 265     pub async fn upload(
 266         &mut self,
 267         content_type: &str,
 268         body: Body,
 269         path: &str,
 270         data: Option<Value>,
 271     ) -> Result<Value, Error> {
 272
 273         let path = path.trim_matches('/');
 274         let mut url = format!("https://{}:8007/{}", &self.server, path);
 275
 276         if let Some(data) = data {
 277             let query = tools::json_object_to_query(data).unwrap();
 278             url.push('?');
 279             url.push_str(&query);
 280         }
 281
 282         let url: Uri = url.parse().unwrap();
 283
 284         let req = Request::builder()
 285             .method("POST")
 286             .uri(url)
 287             .header("User-Agent", "proxmox-backup-client/1.0")
 288             .header("Content-Type", content_type)
 289             .body(body).unwrap();
 290
 291         self.request(req).await
 292     }
 293
 294     pub async fn start_backup(
 295         &self,
 296         datastore: &str,
 297         backup_type: &str,
 298         backup_id: &str,
 299         backup_time: DateTime<Utc>,
 300         debug: bool,
 301     ) -> Result<Arc<BackupClient>, Error> {
 302
 303         let param = json!({
 304             "backup-type": backup_type,
 305             "backup-id": backup_id,
 306             "backup-time": backup_time.timestamp(),
 307             "store": datastore,
 308             "debug": debug
 309         });
 310
 311         let req = Self::request_builder(&self.server, "GET", "/api2/json/backup", Some(param)).unwrap();
 312
 313         let (h2, canceller) = self.start_h2_connection(req, String::from(PROXMOX_BACKUP_PROTOCOL_ID_V1!())).await?;
 314
 315         Ok(BackupClient::new(h2, canceller))
 316     }
 317
 318     pub async fn start_backup_reader(
 319         &self,
 320         datastore: &str,
 321         backup_type: &str,
 322         backup_id: &str,
 323         backup_time: DateTime<Utc>,
 324         debug: bool,
 325     ) -> Result<Arc<BackupReader>, Error> {
 326
 327         let param = json!({
 328             "backup-type": backup_type,
 329             "backup-id": backup_id,
 330             "backup-time": backup_time.timestamp(),
 331             "store": datastore,
 332             "debug": debug,
 333         });
 334         let req = Self::request_builder(&self.server, "GET", "/api2/json/reader", Some(param)).unwrap();
 335
 336         let (h2, canceller) = self.start_h2_connection(req, String::from(PROXMOX_BACKUP_READER_PROTOCOL_ID_V1!())).await?;
 337
 338         Ok(BackupReader::new(h2, canceller))
 339     }
 340
 341     pub async fn start_h2_connection(
 342         &self,
 343         mut req: Request<Body>,
 344         protocol_name: String,
 345     ) -> Result<(H2Client, Canceller), Error> {
 346
 347         let auth = self.login().await?;
 348         let client = self.client.clone();
 349
 350         let enc_ticket = format!("PBSAuthCookie={}", percent_encode(auth.ticket.as_bytes(), DEFAULT_ENCODE_SET));
 351         req.headers_mut().insert("Cookie", HeaderValue::from_str(&enc_ticket).unwrap());
 352         req.headers_mut().insert("UPGRADE", HeaderValue::from_str(&protocol_name).unwrap());
 353
 354         let resp = client.request(req).await?;
 355         let status = resp.status();
 356
 357         if status != http::StatusCode::SWITCHING_PROTOCOLS {
 358             Self::api_response(resp)
 359                 .map(|_| Err(format_err!("unknown error")))
 360                 .await?;
 361             unreachable!();
 362         }
 363
 364         let upgraded = resp
 365             .into_body()
 366             .on_upgrade()
 367             .await?;
 368
 369         let max_window_size = (1 << 31) - 2;
 370
 371         let (h2, connection) = h2::client::Builder::new()
 372             .initial_connection_window_size(max_window_size)
 373             .initial_window_size(max_window_size)
 374             .max_frame_size(4*1024*1024)
 375             .handshake(upgraded)
 376             .await?;
 377
 378         let connection = connection
 379             .map_err(|_| panic!("HTTP/2.0 connection failed"));
 380
 381         let (connection, canceller) = cancellable(connection)?;
 382         // A cancellable future returns an Option which is None when cancelled and
 383         // Some when it finished instead, since we don't care about the return type we
 384         // need to map it away:
 385         let connection = connection.map(|_| ());
 386
 387         // Spawn a new task to drive the connection state
 388         hyper::rt::spawn(connection);
 389
 390         // Wait until the `SendRequest` handle has available capacity.
 391         let c = h2.ready().await?;
 392         Ok((H2Client::new(c), canceller))
 393     }
 394
 395     async fn credentials(
 396         client: Client<HttpsConnector>,
 397         server: String,
 398         username: String,
 399         password: String,
 400     ) -> Result<AuthInfo, Error> {
 401         let data = json!({ "username": username, "password": password });
 402         let req = Self::request_builder(&server, "POST", "/api2/json/access/ticket", Some(data)).unwrap();
 403         let cred = Self::api_request(client, req).await?;
 404         let auth = AuthInfo {
 405             username: cred["data"]["username"].as_str().unwrap().to_owned(),
 406             ticket: cred["data"]["ticket"].as_str().unwrap().to_owned(),
 407             token: cred["data"]["CSRFPreventionToken"].as_str().unwrap().to_owned(),
 408         };
 409
 410         let _ = store_ticket_info(&server, &auth.username, &auth.ticket, &auth.token);
 411
 412         Ok(auth)
 413     }
 414
 415     async fn api_response(response: Response<Body>) -> Result<Value, Error> {
 416         let status = response.status();
 417         let data = response
 418             .into_body()
 419             .try_concat()
 420             .await?;
 421
 422         let text = String::from_utf8(data.to_vec()).unwrap();
 423         if status.is_success() {
 424             if text.len() > 0 {
 425                 let value: Value = serde_json::from_str(&text)?;
 426                 Ok(value)
 427             } else {
 428                 Ok(Value::Null)
 429             }
 430         } else {
 431             bail!("HTTP Error {}: {}", status, text);
 432         }
 433     }
 434
 435     async fn api_request(
 436         client: Client<HttpsConnector>,
 437         req: Request<Body>
 438     ) -> Result<Value, Error> {
 439
 440         client.request(req)
 441             .map_err(Error::from)
 442             .and_then(Self::api_response)
 443             .await
 444     }
 445
 446     pub fn request_builder(server: &str, method: &str, path: &str, data: Option<Value>) -> Result<Request<Body>, Error> {
 447         let path = path.trim_matches('/');
 448         let url: Uri = format!("https://{}:8007/{}", server, path).parse()?;
 449
 450         if let Some(data) = data {
 451             if method == "POST" {
 452                 let request = Request::builder()
 453                     .method(method)
 454                     .uri(url)
 455                     .header("User-Agent", "proxmox-backup-client/1.0")
 456                     .header(hyper::header::CONTENT_TYPE, "application/json")
 457                     .body(Body::from(data.to_string()))?;
 458                 return Ok(request);
 459             } else {
 460                 let query = tools::json_object_to_query(data)?;
 461                 let url: Uri = format!("https://{}:8007/{}?{}", server, path, query).parse()?;
 462                 let request = Request::builder()
 463                     .method(method)
 464                     .uri(url)
 465                     .header("User-Agent", "proxmox-backup-client/1.0")
 466                     .header(hyper::header::CONTENT_TYPE, "application/x-www-form-urlencoded")
 467                     .body(Body::empty())?;
 468                 return Ok(request);
 469             }
 470         }
 471
 472         let request = Request::builder()
 473             .method(method)
 474             .uri(url)
 475             .header("User-Agent", "proxmox-backup-client/1.0")
 476             .header(hyper::header::CONTENT_TYPE, "application/x-www-form-urlencoded")
 477             .body(Body::empty())?;
 478
 479         Ok(request)
 480     }
 481 }
 482
 483
 484 pub struct BackupReader {
 485     h2: H2Client,
 486     canceller: Canceller,
 487 }
 488
 489 impl Drop for BackupReader {
 490
 491     fn drop(&mut self) {
 492         self.canceller.cancel();
 493     }
 494 }
 495
 496 impl BackupReader {
 497
 498     pub fn new(h2: H2Client, canceller: Canceller) -> Arc<Self> {
 499         Arc::new(Self { h2, canceller })
 500     }
 501
 502     pub async fn get(
 503         &self,
 504         path: &str,
 505         param: Option<Value>,
 506     ) -> Result<Value, Error> {
 507         self.h2.get(path, param).await
 508     }
 509
 510     pub async fn put(
 511         &self,
 512         path: &str,
 513         param: Option<Value>,
 514     ) -> Result<Value, Error> {
 515         self.h2.put(path, param).await
 516     }
 517
 518     pub async fn post(
 519         &self,
 520         path: &str,
 521         param: Option<Value>,
 522     ) -> Result<Value, Error> {
 523         self.h2.post(path, param).await
 524     }
 525
 526     pub async fn download<W: Write + Send>(
 527         &self,
 528         file_name: &str,
 529         output: W,
 530     ) -> Result<W, Error> {
 531         let path = "download";
 532         let param = json!({ "file-name": file_name });
 533         self.h2.download(path, Some(param), output).await
 534     }
 535
 536     pub async fn speedtest<W: Write + Send>(
 537         &self,
 538         output: W,
 539     ) -> Result<W, Error> {
 540         self.h2.download("speedtest", None, output).await
 541     }
 542
 543     pub async fn download_chunk<W: Write + Send>(
 544         &self,
 545         digest: &[u8; 32],
 546         output: W,
 547     ) -> Result<W, Error> {
 548         let path = "chunk";
 549         let param = json!({ "digest": digest_to_hex(digest) });
 550         self.h2.download(path, Some(param), output).await
 551     }
 552
 553     pub fn force_close(self) {
 554         self.canceller.cancel();
 555     }
 556 }
 557
 558 pub struct BackupClient {
 559     h2: H2Client,
 560     canceller: Canceller,
 561 }
 562
 563 impl Drop for BackupClient {
 564
 565     fn drop(&mut self) {
 566         self.canceller.cancel();
 567     }
 568 }
 569
 570 pub struct BackupStats {
 571     pub size: u64,
 572     pub csum: [u8; 32],
 573 }
 574
 575 impl BackupClient {
 576     pub fn new(h2: H2Client, canceller: Canceller) -> Arc<Self> {
 577         Arc::new(Self { h2, canceller })
 578     }
 579
 580     pub async fn get(
 581         &self,
 582         path: &str,
 583         param: Option<Value>,
 584     ) -> Result<Value, Error> {
 585         self.h2.get(path, param).await
 586     }
 587
 588     pub async fn put(
 589         &self,
 590         path: &str,
 591         param: Option<Value>,
 592     ) -> Result<Value, Error> {
 593         self.h2.put(path, param).await
 594     }
 595
 596     pub async fn post(
 597         &self,
 598         path: &str,
 599         param: Option<Value>,
 600     ) -> Result<Value, Error> {
 601         self.h2.post(path, param).await
 602     }
 603
 604     pub async fn upload_post(
 605         &self,
 606         path: &str,
 607         param: Option<Value>,
 608         content_type: &str,
 609         data: Vec<u8>,
 610     ) -> Result<Value, Error> {
 611         self.h2.upload("POST", path, param, content_type, data).await
 612     }
 613
 614     pub async fn send_upload_request(
 615         &self,
 616         method: &str,
 617         path: &str,
 618         param: Option<Value>,
 619         content_type: &str,
 620         data: Vec<u8>,
 621     ) -> Result<h2::client::ResponseFuture, Error> {
 622
 623         let request = H2Client::request_builder("localhost", method, path, param, Some(content_type)).unwrap();
 624         let response_future = self.h2.send_request(request, Some(bytes::Bytes::from(data.clone()))).await?;
 625         Ok(response_future)
 626     }
 627
 628     pub async fn upload_put(
 629         &self,
 630         path: &str,
 631         param: Option<Value>,
 632         content_type: &str,
 633         data: Vec<u8>,
 634     ) -> Result<Value, Error> {
 635         self.h2.upload("PUT", path, param, content_type, data).await
 636     }
 637
 638     pub async fn finish(self: Arc<Self>) -> Result<(), Error> {
 639         let h2 = self.h2.clone();
 640
 641         h2.post("finish", None)
 642             .map_ok(move |_| {
 643                 self.canceller.cancel();
 644             })
 645             .await
 646     }
 647
 648     pub fn force_close(self) {
 649         self.canceller.cancel();
 650     }
 651
 652     pub async fn upload_blob<R: std::io::Read>(
 653         &self,
 654         mut reader: R,
 655         file_name: &str,
 656      ) -> Result<BackupStats, Error> {
 657         let mut raw_data = Vec::new();
 658         // fixme: avoid loading into memory
 659         reader.read_to_end(&mut raw_data)?;
 660
 661         let csum = openssl::sha::sha256(&raw_data);
 662         let param = json!({"encoded-size": raw_data.len(), "file-name": file_name });
 663         let size = raw_data.len() as u64; // fixme: should be decoded size instead??
 664         let _value = self.h2.upload("POST", "blob", Some(param), "application/octet-stream", raw_data).await?;
 665         Ok(BackupStats { size, csum })
 666     }
 667
 668     pub async fn upload_blob_from_data(
 669         &self,
 670         data: Vec<u8>,
 671         file_name: &str,
 672         crypt_config: Option<Arc<CryptConfig>>,
 673         compress: bool,
 674         sign_only: bool,
 675      ) -> Result<BackupStats, Error> {
 676
 677         let size = data.len() as u64;
 678
 679         let blob = if let Some(crypt_config) = crypt_config {
 680             if sign_only {
 681                 DataBlob::create_signed(&data, crypt_config, compress)?
 682             } else {
 683                 DataBlob::encode(&data, Some(crypt_config.clone()), compress)?
 684             }
 685         } else {
 686             DataBlob::encode(&data, None, compress)?
 687         };
 688
 689         let raw_data = blob.into_inner();
 690
 691         let csum = openssl::sha::sha256(&raw_data);
 692         let param = json!({"encoded-size": raw_data.len(), "file-name": file_name });
 693         let _value = self.h2.upload("POST", "blob", Some(param), "application/octet-stream", raw_data).await?;
 694         Ok(BackupStats { size, csum })
 695     }
 696
 697     pub async fn upload_blob_from_file<P: AsRef<std::path::Path>>(
 698         &self,
 699         src_path: P,
 700         file_name: &str,
 701         crypt_config: Option<Arc<CryptConfig>>,
 702         compress: bool,
 703      ) -> Result<BackupStats, Error> {
 704
 705         let src_path = src_path.as_ref();
 706
 707         let mut file = tokio::fs::File::open(src_path)
 708             .await
 709             .map_err(|err| format_err!("unable to open file {:?} - {}", src_path, err))?;
 710
 711         let mut contents = Vec::new();
 712
 713         file.read_to_end(&mut contents)
 714             .await
 715             .map_err(|err| format_err!("unable to read file {:?} - {}", src_path, err))?;
 716
 717         let size: u64 = contents.len() as u64;
 718         let blob = DataBlob::encode(&contents, crypt_config, compress)?;
 719         let raw_data = blob.into_inner();
 720         let csum = openssl::sha::sha256(&raw_data);
 721         let param = json!({
 722             "encoded-size": raw_data.len(),
 723             "file-name": file_name,
 724         });
 725         self.h2.upload("POST", "blob", Some(param), "application/octet-stream", raw_data).await?;
 726         Ok(BackupStats { size, csum })
 727     }
 728
 729     pub async fn upload_stream(
 730         &self,
 731         archive_name: &str,
 732         stream: impl Stream<Item = Result<bytes::BytesMut, Error>>,
 733         prefix: &str,
 734         fixed_size: Option<u64>,
 735         crypt_config: Option<Arc<CryptConfig>>,
 736     ) -> Result<BackupStats, Error> {
 737         let known_chunks = Arc::new(Mutex::new(HashSet::new()));
 738
 739         let mut param = json!({ "archive-name": archive_name });
 740         if let Some(size) = fixed_size {
 741             param["size"] = size.into();
 742         }
 743
 744         let index_path = format!("{}_index", prefix);
 745         let close_path = format!("{}_close", prefix);
 746
 747         self.download_chunk_list(&index_path, archive_name, known_chunks.clone()).await?;
 748
 749         let wid = self.h2.post(&index_path, Some(param)).await?.as_u64().unwrap();
 750
 751         let (chunk_count, size, _speed, csum) =
 752             Self::upload_chunk_info_stream(
 753                 self.h2.clone(),
 754                 wid,
 755                 stream,
 756                 &prefix,
 757                 known_chunks.clone(),
 758                 crypt_config,
 759             )
 760             .await?;
 761
 762         let param = json!({
 763             "wid": wid ,
 764             "chunk-count": chunk_count,
 765             "size": size,
 766             "csum": proxmox::tools::digest_to_hex(&csum),
 767         });
 768         let _value = self.h2.post(&close_path, Some(param)).await?;
 769         Ok(BackupStats {
 770             size: size as u64,
 771             csum,
 772         })
 773     }
 774
 775     fn response_queue() -> (
 776         mpsc::Sender<h2::client::ResponseFuture>,
 777         oneshot::Receiver<Result<(), Error>>
 778     ) {
 779         let (verify_queue_tx, verify_queue_rx) = mpsc::channel(100);
 780         let (verify_result_tx, verify_result_rx) = oneshot::channel();
 781
 782         hyper::rt::spawn(
 783             verify_queue_rx
 784                 .map(Ok::<_, Error>)
 785                 .try_for_each(|response: h2::client::ResponseFuture| {
 786                     response
 787                         .map_err(Error::from)
 788                         .and_then(H2Client::h2api_response)
 789                         .map_ok(|result| println!("RESPONSE: {:?}", result))
 790                         .map_err(|err| format_err!("pipelined request failed: {}", err))
 791                 })
 792                 .map(|result| {
 793                       let _ignore_closed_channel = verify_result_tx.send(result);
 794                 })
 795         );
 796
 797         (verify_queue_tx, verify_result_rx)
 798     }
 799
 800     fn append_chunk_queue(h2: H2Client, wid: u64, path: String) -> (
 801         mpsc::Sender<(MergedChunkInfo, Option<h2::client::ResponseFuture>)>,
 802         oneshot::Receiver<Result<(), Error>>
 803     ) {
 804         let (verify_queue_tx, verify_queue_rx) = mpsc::channel(64);
 805         let (verify_result_tx, verify_result_rx) = oneshot::channel();
 806
 807         let h2_2 = h2.clone();
 808
 809         hyper::rt::spawn(
 810             verify_queue_rx
 811                 .map(Ok::<_, Error>)
 812                 .and_then(move |(merged_chunk_info, response): (MergedChunkInfo, Option<h2::client::ResponseFuture>)| {
 813                     match (response, merged_chunk_info) {
 814                         (Some(response), MergedChunkInfo::Known(list)) => {
 815                             future::Either::Left(
 816                                 response
 817                                     .map_err(Error::from)
 818                                     .and_then(H2Client::h2api_response)
 819                                     .and_then(move |_result| {
 820                                         future::ok(MergedChunkInfo::Known(list))
 821                                     })
 822                             )
 823                         }
 824                         (None, MergedChunkInfo::Known(list)) => {
 825                             future::Either::Right(future::ok(MergedChunkInfo::Known(list)))
 826                         }
 827                         _ => unreachable!(),
 828                     }
 829                 })
 830                 .merge_known_chunks()
 831                 .and_then(move |merged_chunk_info| {
 832                     match merged_chunk_info {
 833                         MergedChunkInfo::Known(chunk_list) => {
 834                             let mut digest_list = vec![];
 835                             let mut offset_list = vec![];
 836                             for (offset, digest) in chunk_list {
 837                                 //println!("append chunk {} (offset {})", proxmox::tools::digest_to_hex(&digest), offset);
 838                                 digest_list.push(digest_to_hex(&digest));
 839                                 offset_list.push(offset);
 840                             }
 841                             println!("append chunks list len ({})", digest_list.len());
 842                             let param = json!({ "wid": wid, "digest-list": digest_list, "offset-list": offset_list });
 843                             let request = H2Client::request_builder("localhost", "PUT", &path, None, Some("application/json")).unwrap();
 844                             let param_data = bytes::Bytes::from(param.to_string().as_bytes());
 845                             let upload_data = Some(param_data);
 846                             h2_2.send_request(request, upload_data)
 847                                 .and_then(move |response| {
 848                                     response
 849                                         .map_err(Error::from)
 850                                         .and_then(H2Client::h2api_response)
 851                                         .map_ok(|_| ())
 852                                 })
 853                                 .map_err(|err| format_err!("pipelined request failed: {}", err))
 854                         }
 855                         _ => unreachable!(),
 856                     }
 857                 })
 858                 .try_for_each(|_| future::ok(()))
 859                 .map(|result| {
 860                       let _ignore_closed_channel = verify_result_tx.send(result);
 861                 })
 862         );
 863
 864         (verify_queue_tx, verify_result_rx)
 865     }
 866
 867     pub async fn download_chunk_list(
 868         &self,
 869         path: &str,
 870         archive_name: &str,
 871         known_chunks: Arc<Mutex<HashSet<[u8;32]>>>,
 872     ) -> Result<(), Error> {
 873
 874         let param = json!({ "archive-name": archive_name });
 875         let request = H2Client::request_builder("localhost", "GET", path, Some(param), None).unwrap();
 876
 877         let h2request = self.h2.send_request(request, None).await?;
 878         let resp = h2request.await?;
 879
 880         let status = resp.status();
 881
 882         if !status.is_success() {
 883             H2Client::h2api_response(resp).await?; // raise error
 884             unreachable!();
 885         }
 886
 887         let mut body = resp.into_body();
 888         let mut release_capacity = body.release_capacity().clone();
 889
 890         let mut stream = DigestListDecoder::new(body.map_err(Error::from));
 891
 892         while let Some(chunk) = stream.try_next().await? {
 893             let _ = release_capacity.release_capacity(chunk.len());
 894             println!("GOT DOWNLOAD {}", digest_to_hex(&chunk));
 895             known_chunks.lock().unwrap().insert(chunk);
 896         }
 897
 898         Ok(())
 899     }
 900
 901     fn upload_chunk_info_stream(
 902         h2: H2Client,
 903         wid: u64,
 904         stream: impl Stream<Item = Result<bytes::BytesMut, Error>>,
 905         prefix: &str,
 906         known_chunks: Arc<Mutex<HashSet<[u8;32]>>>,
 907         crypt_config: Option<Arc<CryptConfig>>,
 908     ) -> impl Future<Output = Result<(usize, usize, usize, [u8; 32]), Error>> {
 909
 910         let repeat = Arc::new(AtomicUsize::new(0));
 911         let repeat2 = repeat.clone();
 912
 913         let stream_len = Arc::new(AtomicUsize::new(0));
 914         let stream_len2 = stream_len.clone();
 915
 916         let append_chunk_path = format!("{}_index", prefix);
 917         let upload_chunk_path = format!("{}_chunk", prefix);
 918         let is_fixed_chunk_size = prefix == "fixed";
 919
 920         let (upload_queue, upload_result) =
 921             Self::append_chunk_queue(h2.clone(), wid, append_chunk_path.to_owned());
 922
 923         let start_time = std::time::Instant::now();
 924
 925         let index_csum = Arc::new(Mutex::new(Some(openssl::sha::Sha256::new())));
 926         let index_csum_2 = index_csum.clone();
 927
 928         stream
 929             .and_then(move |data| {
 930
 931                 let chunk_len = data.len();
 932
 933                 repeat.fetch_add(1, Ordering::SeqCst);
 934                 let offset = stream_len.fetch_add(chunk_len, Ordering::SeqCst) as u64;
 935
 936                 let mut chunk_builder = DataChunkBuilder::new(data.as_ref())
 937                     .compress(true);
 938
 939                 if let Some(ref crypt_config) = crypt_config {
 940                     chunk_builder = chunk_builder.crypt_config(crypt_config);
 941                 }
 942
 943                 let mut known_chunks = known_chunks.lock().unwrap();
 944                 let digest = chunk_builder.digest();
 945
 946                 let mut guard = index_csum.lock().unwrap();
 947                 let csum = guard.as_mut().unwrap();
 948
 949                 let chunk_end = offset + chunk_len as u64;
 950
 951                 if !is_fixed_chunk_size { csum.update(&chunk_end.to_le_bytes()); }
 952                 csum.update(digest);
 953
 954                 let chunk_is_known = known_chunks.contains(digest);
 955                 if chunk_is_known {
 956                     future::ok(MergedChunkInfo::Known(vec![(offset, *digest)]))
 957                 } else {
 958                     known_chunks.insert(*digest);
 959                     future::ready(chunk_builder
 960                         .build()
 961                         .map(move |chunk| MergedChunkInfo::New(ChunkInfo {
 962                             chunk,
 963                             chunk_len: chunk_len as u64,
 964                             offset,
 965                         }))
 966                     )
 967                 }
 968             })
 969             .merge_known_chunks()
 970             .try_for_each(move |merged_chunk_info| {
 971
 972                 if let MergedChunkInfo::New(chunk_info) = merged_chunk_info {
 973                     let offset = chunk_info.offset;
 974                     let digest = *chunk_info.chunk.digest();
 975                     let digest_str = digest_to_hex(&digest);
 976
 977                     println!("upload new chunk {} ({} bytes, offset {})", digest_str,
 978                              chunk_info.chunk_len, offset);
 979
 980                     let chunk_data = chunk_info.chunk.raw_data();
 981                     let param = json!({
 982                         "wid": wid,
 983                         "digest": digest_str,
 984                         "size": chunk_info.chunk_len,
 985                         "encoded-size": chunk_data.len(),
 986                     });
 987
 988                     let ct = "application/octet-stream";
 989                     let request = H2Client::request_builder("localhost", "POST", &upload_chunk_path, Some(param), Some(ct)).unwrap();
 990                     let upload_data = Some(bytes::Bytes::from(chunk_data));
 991
 992                     let new_info = MergedChunkInfo::Known(vec![(offset, digest)]);
 993
 994                     let mut upload_queue = upload_queue.clone();
 995                     future::Either::Left(h2
 996                         .send_request(request, upload_data)
 997                         .and_then(move |response| async move {
 998                             upload_queue
 999                                 .send((new_info, Some(response)))
1000                                 .await
1001                                 .map_err(Error::from)
1002                         })
1003                     )
1004                 } else {
1005                     let mut upload_queue = upload_queue.clone();
1006                     future::Either::Right(async move {
1007                         upload_queue
1008                             .send((merged_chunk_info, None))
1009                             .await
1010                             .map_err(Error::from)
1011                     })
1012                 }
1013             })
1014             .then(move |result| async move {
1015                 upload_result.await?.and(result)
1016             }.boxed())
1017             .and_then(move |_| {
1018                 let repeat = repeat2.load(Ordering::SeqCst);
1019                 let stream_len = stream_len2.load(Ordering::SeqCst);
1020                 let speed = ((stream_len*1000000)/(1024*1024))/(start_time.elapsed().as_micros() as usize);
1021                 println!("Uploaded {} chunks in {} seconds ({} MB/s).", repeat, start_time.elapsed().as_secs(), speed);
1022                 if repeat > 0 {
1023                     println!("Average chunk size was {} bytes.", stream_len/repeat);
1024                     println!("Time per request: {} microseconds.", (start_time.elapsed().as_micros())/(repeat as u128));
1025                 }
1026
1027                 let mut guard = index_csum_2.lock().unwrap();
1028                 let csum = guard.take().unwrap().finish();
1029
1030                 futures::future::ok((repeat, stream_len, speed, csum))
1031             })
1032     }
1033
1034     pub async fn upload_speedtest(&self) -> Result<usize, Error> {
1035
1036         let mut data = vec![];
1037         // generate pseudo random byte sequence
1038         for i in 0..1024*1024 {
1039             for j in 0..4 {
1040                 let byte = ((i >> (j<<3))&0xff) as u8;
1041                 data.push(byte);
1042             }
1043         }
1044
1045         let item_len = data.len();
1046
1047         let mut repeat = 0;
1048
1049         let (upload_queue, upload_result) = Self::response_queue();
1050
1051         let start_time = std::time::Instant::now();
1052
1053         loop {
1054             repeat += 1;
1055             if start_time.elapsed().as_secs() >= 5 {
1056                 break;
1057             }
1058
1059             let mut upload_queue = upload_queue.clone();
1060
1061             println!("send test data ({} bytes)", data.len());
1062             let request = H2Client::request_builder("localhost", "POST", "speedtest", None, None).unwrap();
1063             let request_future = self.h2.send_request(request, Some(bytes::Bytes::from(data.clone()))).await?;
1064
1065             upload_queue.send(request_future).await?;
1066         }
1067
1068         drop(upload_queue); // close queue
1069
1070         let _ = upload_result.await?;
1071
1072         println!("Uploaded {} chunks in {} seconds.", repeat, start_time.elapsed().as_secs());
1073         let speed = ((item_len*1000000*(repeat as usize))/(1024*1024))/(start_time.elapsed().as_micros() as usize);
1074         println!("Time per request: {} microseconds.", (start_time.elapsed().as_micros())/(repeat as u128));
1075
1076         Ok(speed)
1077     }
1078 }
1079
1080 #[derive(Clone)]
1081 pub struct H2Client {
1082     h2: h2::client::SendRequest<bytes::Bytes>,
1083 }
1084
1085 impl H2Client {
1086
1087     pub fn new(h2: h2::client::SendRequest<bytes::Bytes>) -> Self {
1088         Self { h2 }
1089     }
1090
1091     pub async fn get(
1092         &self,
1093         path: &str,
1094         param: Option<Value>
1095     ) -> Result<Value, Error> {
1096         let req = Self::request_builder("localhost", "GET", path, param, None).unwrap();
1097         self.request(req).await
1098     }
1099
1100     pub async fn put(
1101         &self,
1102         path: &str,
1103         param: Option<Value>
1104     ) -> Result<Value, Error> {
1105         let req = Self::request_builder("localhost", "PUT", path, param, None).unwrap();
1106         self.request(req).await
1107     }
1108
1109     pub async fn post(
1110         &self,
1111         path: &str,
1112         param: Option<Value>
1113     ) -> Result<Value, Error> {
1114         let req = Self::request_builder("localhost", "POST", path, param, None).unwrap();
1115         self.request(req).await
1116     }
1117
1118     pub async fn download<W: Write + Send>(
1119         &self,
1120         path: &str,
1121         param: Option<Value>,
1122         mut output: W,
1123     ) -> Result<W, Error> {
1124         let request = Self::request_builder("localhost", "GET", path, param, None).unwrap();
1125
1126         let response_future = self.send_request(request, None).await?;
1127
1128         let resp = response_future.await?;
1129
1130         let status = resp.status();
1131         if !status.is_success() {
1132             H2Client::h2api_response(resp).await?; // raise error
1133             unreachable!();
1134         }
1135
1136         let mut body = resp.into_body();
1137         let mut release_capacity = body.release_capacity().clone();
1138
1139         while let Some(chunk) = body.try_next().await? {
1140             let _ = release_capacity.release_capacity(chunk.len());
1141             output.write_all(&chunk)?;
1142         }
1143
1144         Ok(output)
1145     }
1146
1147     pub async fn upload(
1148         &self,
1149         method: &str, // POST or PUT
1150         path: &str,
1151         param: Option<Value>,
1152         content_type: &str,
1153         data: Vec<u8>,
1154     ) -> Result<Value, Error> {
1155         let request = Self::request_builder("localhost", method, path, param, Some(content_type)).unwrap();
1156
1157         let mut send_request = self.h2.clone().ready().await?;
1158
1159         let (response, stream) = send_request.send_request(request, false).unwrap();
1160
1161         PipeToSendStream::new(bytes::Bytes::from(data), stream).await?;
1162
1163         response
1164             .map_err(Error::from)
1165             .and_then(Self::h2api_response)
1166             .await
1167     }
1168
1169     async fn request(
1170         &self,
1171         request: Request<()>,
1172     ) -> Result<Value, Error> {
1173
1174         self.send_request(request, None)
1175             .and_then(move |response| {
1176                 response
1177                     .map_err(Error::from)
1178                     .and_then(Self::h2api_response)
1179             })
1180             .await
1181     }
1182
1183     fn send_request(
1184         &self,
1185         request: Request<()>,
1186         data: Option<bytes::Bytes>,
1187     ) -> impl Future<Output = Result<h2::client::ResponseFuture, Error>> {
1188
1189         self.h2.clone()
1190             .ready()
1191             .map_err(Error::from)
1192             .and_then(move |mut send_request| async move {
1193                 if let Some(data) = data {
1194                     let (response, stream) = send_request.send_request(request, false).unwrap();
1195                     PipeToSendStream::new(data, stream).await?;
1196                     Ok(response)
1197                 } else {
1198                     let (response, _stream) = send_request.send_request(request, true).unwrap();
1199                     Ok(response)
1200                 }
1201             })
1202     }
1203
1204     pub async fn h2api_response(
1205         response: Response<h2::RecvStream>,
1206     ) -> Result<Value, Error> {
1207         let status = response.status();
1208
1209         let (_head, mut body) = response.into_parts();
1210
1211         // The `release_capacity` handle allows the caller to manage
1212         // flow control.
1213         //
1214         // Whenever data is received, the caller is responsible for
1215         // releasing capacity back to the server once it has freed
1216         // the data from memory.
1217         let mut release_capacity = body.release_capacity().clone();
1218
1219         let mut data = Vec::new();
1220         while let Some(chunk) = body.try_next().await? {
1221             // Let the server send more data.
1222             let _ = release_capacity.release_capacity(chunk.len());
1223             data.extend(chunk);
1224         }
1225
1226         let text = String::from_utf8(data.to_vec()).unwrap();
1227         if status.is_success() {
1228             if text.len() > 0 {
1229                 let mut value: Value = serde_json::from_str(&text)?;
1230                 if let Some(map) = value.as_object_mut() {
1231                     if let Some(data) = map.remove("data") {
1232                         return Ok(data);
1233                     }
1234                 }
1235                 bail!("got result without data property");
1236             } else {
1237                 Ok(Value::Null)
1238             }
1239         } else {
1240             bail!("HTTP Error {}: {}", status, text);
1241         }
1242     }
1243
1244     // Note: We always encode parameters with the url
1245     pub fn request_builder(
1246         server: &str,
1247         method: &str,
1248         path: &str,
1249         param: Option<Value>,
1250         content_type: Option<&str>,
1251     ) -> Result<Request<()>, Error> {
1252         let path = path.trim_matches('/');
1253
1254         let content_type = content_type.unwrap_or("application/x-www-form-urlencoded");
1255
1256         if let Some(param) = param {
1257             let query = tools::json_object_to_query(param)?;
1258             // We detected problem with hyper around 6000 characters - seo we try to keep on the safe side
1259             if query.len() > 4096 { bail!("h2 query data too large ({} bytes) - please encode data inside body", query.len()); }
1260             let url: Uri = format!("https://{}:8007/{}?{}", server, path, query).parse()?;
1261              let request = Request::builder()
1262                 .method(method)
1263                 .uri(url)
1264                 .header("User-Agent", "proxmox-backup-client/1.0")
1265                 .header(hyper::header::CONTENT_TYPE, content_type)
1266                 .body(())?;
1267             return Ok(request);
1268         } else {
1269             let url: Uri = format!("https://{}:8007/{}", server, path).parse()?;
1270             let request = Request::builder()
1271                 .method(method)
1272                 .uri(url)
1273                 .header("User-Agent", "proxmox-backup-client/1.0")
1274                 .header(hyper::header::CONTENT_TYPE, content_type)
1275                 .body(())?;
1276
1277             Ok(request)
1278         }
1279     }
1280 }
1281
1282 pub struct HttpsConnector {
1283     http: HttpConnector,
1284     ssl_connector: SslConnector,
1285 }
1286
1287 impl HttpsConnector {
1288     pub fn with_connector(mut http: HttpConnector, ssl_connector: SslConnector) -> Self {
1289         http.enforce_http(false);
1290
1291         Self {
1292             http,
1293             ssl_connector,
1294         }
1295     }
1296 }
1297
1298 type MaybeTlsStream = EitherStream<
1299     tokio::net::TcpStream,
1300     tokio_openssl::SslStream<tokio::net::TcpStream>,
1301 >;
1302
1303 impl hyper::client::connect::Connect for HttpsConnector {
1304     type Transport = MaybeTlsStream;
1305     type Error = Error;
1306     type Future = Box<dyn Future<Output = Result<(
1307         Self::Transport,
1308         hyper::client::connect::Connected,
1309     ), Error>> + Send + Unpin + 'static>;
1310
1311     fn connect(&self, dst: hyper::client::connect::Destination) -> Self::Future {
1312         let is_https = dst.scheme() == "https";
1313         let host = dst.host().to_string();
1314
1315         let config = self.ssl_connector.configure();
1316         let conn = self.http.connect(dst);
1317
1318         Box::new(Box::pin(async move {
1319             let (conn, connected) = conn.await?;
1320             if is_https {
1321                 let conn = tokio_openssl::connect(config?, &host, conn).await?;
1322                 Ok((MaybeTlsStream::Right(conn), connected))
1323             } else {
1324                 Ok((MaybeTlsStream::Left(conn), connected))
1325             }
1326         }))
1327     }
1328 }