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 finish(self: Arc<Self>) -> Result<(), Error> {
 605         let h2 = self.h2.clone();
 606
 607         h2.post("finish", None)
 608             .map_ok(move |_| {
 609                 self.canceller.cancel();
 610             })
 611             .await
 612     }
 613
 614     pub fn force_close(self) {
 615         self.canceller.cancel();
 616     }
 617
 618     pub async fn upload_blob<R: std::io::Read>(
 619         &self,
 620         mut reader: R,
 621         file_name: &str,
 622      ) -> Result<BackupStats, Error> {
 623         let mut raw_data = Vec::new();
 624         // fixme: avoid loading into memory
 625         reader.read_to_end(&mut raw_data)?;
 626
 627         let csum = openssl::sha::sha256(&raw_data);
 628         let param = json!({"encoded-size": raw_data.len(), "file-name": file_name });
 629         let size = raw_data.len() as u64; // fixme: should be decoded size instead??
 630         let _value = self.h2.upload("blob", Some(param), raw_data).await?;
 631         Ok(BackupStats { size, csum })
 632     }
 633
 634     pub async fn upload_blob_from_data(
 635         &self,
 636         data: Vec<u8>,
 637         file_name: &str,
 638         crypt_config: Option<Arc<CryptConfig>>,
 639         compress: bool,
 640         sign_only: bool,
 641      ) -> Result<BackupStats, Error> {
 642
 643         let size = data.len() as u64;
 644
 645         let blob = if let Some(crypt_config) = crypt_config {
 646             if sign_only {
 647                 DataBlob::create_signed(&data, crypt_config, compress)?
 648             } else {
 649                 DataBlob::encode(&data, Some(crypt_config.clone()), compress)?
 650             }
 651         } else {
 652             DataBlob::encode(&data, None, compress)?
 653         };
 654
 655         let raw_data = blob.into_inner();
 656
 657         let csum = openssl::sha::sha256(&raw_data);
 658         let param = json!({"encoded-size": raw_data.len(), "file-name": file_name });
 659         let _value = self.h2.upload("blob", Some(param), raw_data).await?;
 660         Ok(BackupStats { size, csum })
 661     }
 662
 663     pub async fn upload_blob_from_file<P: AsRef<std::path::Path>>(
 664         &self,
 665         src_path: P,
 666         file_name: &str,
 667         crypt_config: Option<Arc<CryptConfig>>,
 668         compress: bool,
 669      ) -> Result<BackupStats, Error> {
 670
 671         let src_path = src_path.as_ref();
 672
 673         let mut file = tokio::fs::File::open(src_path)
 674             .await
 675             .map_err(|err| format_err!("unable to open file {:?} - {}", src_path, err))?;
 676
 677         let mut contents = Vec::new();
 678
 679         file.read_to_end(&mut contents)
 680             .await
 681             .map_err(|err| format_err!("unable to read file {:?} - {}", src_path, err))?;
 682
 683         let size: u64 = contents.len() as u64;
 684         let blob = DataBlob::encode(&contents, crypt_config, compress)?;
 685         let raw_data = blob.into_inner();
 686         let csum = openssl::sha::sha256(&raw_data);
 687         let param = json!({
 688             "encoded-size": raw_data.len(),
 689             "file-name": file_name,
 690         });
 691         self.h2.upload("blob", Some(param), raw_data).await?;
 692         Ok(BackupStats { size, csum })
 693     }
 694
 695     pub async fn upload_stream(
 696         &self,
 697         archive_name: &str,
 698         stream: impl Stream<Item = Result<bytes::BytesMut, Error>>,
 699         prefix: &str,
 700         fixed_size: Option<u64>,
 701         crypt_config: Option<Arc<CryptConfig>>,
 702     ) -> Result<BackupStats, Error> {
 703         let known_chunks = Arc::new(Mutex::new(HashSet::new()));
 704
 705         let mut param = json!({ "archive-name": archive_name });
 706         if let Some(size) = fixed_size {
 707             param["size"] = size.into();
 708         }
 709
 710         let index_path = format!("{}_index", prefix);
 711         let close_path = format!("{}_close", prefix);
 712
 713         self.download_chunk_list(&index_path, archive_name, known_chunks.clone()).await?;
 714
 715         let wid = self.h2.post(&index_path, Some(param)).await?.as_u64().unwrap();
 716
 717         let (chunk_count, size, _speed, csum) =
 718             Self::upload_chunk_info_stream(
 719                 self.h2.clone(),
 720                 wid,
 721                 stream,
 722                 &prefix,
 723                 known_chunks.clone(),
 724                 crypt_config,
 725             )
 726             .await?;
 727
 728         let param = json!({
 729             "wid": wid ,
 730             "chunk-count": chunk_count,
 731             "size": size,
 732         });
 733         let _value = self.h2.post(&close_path, Some(param)).await?;
 734         Ok(BackupStats {
 735             size: size as u64,
 736             csum,
 737         })
 738     }
 739
 740     fn response_queue() -> (
 741         mpsc::Sender<h2::client::ResponseFuture>,
 742         oneshot::Receiver<Result<(), Error>>
 743     ) {
 744         let (verify_queue_tx, verify_queue_rx) = mpsc::channel(100);
 745         let (verify_result_tx, verify_result_rx) = oneshot::channel();
 746
 747         hyper::rt::spawn(
 748             verify_queue_rx
 749                 .map(Ok::<_, Error>)
 750                 .try_for_each(|response: h2::client::ResponseFuture| {
 751                     response
 752                         .map_err(Error::from)
 753                         .and_then(H2Client::h2api_response)
 754                         .map_ok(|result| println!("RESPONSE: {:?}", result))
 755                         .map_err(|err| format_err!("pipelined request failed: {}", err))
 756                 })
 757                 .map(|result| {
 758                       let _ignore_closed_channel = verify_result_tx.send(result);
 759                 })
 760         );
 761
 762         (verify_queue_tx, verify_result_rx)
 763     }
 764
 765     fn append_chunk_queue(h2: H2Client, wid: u64, path: String) -> (
 766         mpsc::Sender<(MergedChunkInfo, Option<h2::client::ResponseFuture>)>,
 767         oneshot::Receiver<Result<(), Error>>
 768     ) {
 769         let (verify_queue_tx, verify_queue_rx) = mpsc::channel(64);
 770         let (verify_result_tx, verify_result_rx) = oneshot::channel();
 771
 772         let h2_2 = h2.clone();
 773
 774         hyper::rt::spawn(
 775             verify_queue_rx
 776                 .map(Ok::<_, Error>)
 777                 .and_then(move |(merged_chunk_info, response): (MergedChunkInfo, Option<h2::client::ResponseFuture>)| {
 778                     match (response, merged_chunk_info) {
 779                         (Some(response), MergedChunkInfo::Known(list)) => {
 780                             future::Either::Left(
 781                                 response
 782                                     .map_err(Error::from)
 783                                     .and_then(H2Client::h2api_response)
 784                                     .and_then(move |_result| {
 785                                         future::ok(MergedChunkInfo::Known(list))
 786                                     })
 787                             )
 788                         }
 789                         (None, MergedChunkInfo::Known(list)) => {
 790                             future::Either::Right(future::ok(MergedChunkInfo::Known(list)))
 791                         }
 792                         _ => unreachable!(),
 793                     }
 794                 })
 795                 .merge_known_chunks()
 796                 .and_then(move |merged_chunk_info| {
 797                     match merged_chunk_info {
 798                         MergedChunkInfo::Known(chunk_list) => {
 799                             let mut digest_list = vec![];
 800                             let mut offset_list = vec![];
 801                             for (offset, digest) in chunk_list {
 802                                 //println!("append chunk {} (offset {})", proxmox::tools::digest_to_hex(&digest), offset);
 803                                 digest_list.push(digest_to_hex(&digest));
 804                                 offset_list.push(offset);
 805                             }
 806                             println!("append chunks list len ({})", digest_list.len());
 807                             let param = json!({ "wid": wid, "digest-list": digest_list, "offset-list": offset_list });
 808                             let mut request = H2Client::request_builder("localhost", "PUT", &path, None).unwrap();
 809                             request.headers_mut().insert(hyper::header::CONTENT_TYPE,  HeaderValue::from_static("application/json"));
 810                             let param_data = bytes::Bytes::from(param.to_string().as_bytes());
 811                             let upload_data = Some(param_data);
 812                             h2_2.send_request(request, upload_data)
 813                                 .and_then(move |response| {
 814                                     response
 815                                         .map_err(Error::from)
 816                                         .and_then(H2Client::h2api_response)
 817                                         .map_ok(|_| ())
 818                                 })
 819                                 .map_err(|err| format_err!("pipelined request failed: {}", err))
 820                         }
 821                         _ => unreachable!(),
 822                     }
 823                 })
 824                 .try_for_each(|_| future::ok(()))
 825                 .map(|result| {
 826                       let _ignore_closed_channel = verify_result_tx.send(result);
 827                 })
 828         );
 829
 830         (verify_queue_tx, verify_result_rx)
 831     }
 832
 833     pub async fn download_chunk_list(
 834         &self,
 835         path: &str,
 836         archive_name: &str,
 837         known_chunks: Arc<Mutex<HashSet<[u8;32]>>>,
 838     ) -> Result<(), Error> {
 839
 840         let param = json!({ "archive-name": archive_name });
 841         let request = H2Client::request_builder("localhost", "GET", path, Some(param)).unwrap();
 842
 843         let h2request = self.h2.send_request(request, None).await?;
 844         let resp = h2request.await?;
 845
 846         let status = resp.status();
 847
 848         if !status.is_success() {
 849             H2Client::h2api_response(resp).await?; // raise error
 850             unreachable!();
 851         }
 852
 853         let mut body = resp.into_body();
 854         let mut release_capacity = body.release_capacity().clone();
 855
 856         let mut stream = DigestListDecoder::new(body.map_err(Error::from));
 857
 858         while let Some(chunk) = stream.try_next().await? {
 859             let _ = release_capacity.release_capacity(chunk.len());
 860             println!("GOT DOWNLOAD {}", digest_to_hex(&chunk));
 861             known_chunks.lock().unwrap().insert(chunk);
 862         }
 863
 864         Ok(())
 865     }
 866
 867     fn upload_chunk_info_stream(
 868         h2: H2Client,
 869         wid: u64,
 870         stream: impl Stream<Item = Result<bytes::BytesMut, Error>>,
 871         prefix: &str,
 872         known_chunks: Arc<Mutex<HashSet<[u8;32]>>>,
 873         crypt_config: Option<Arc<CryptConfig>>,
 874     ) -> impl Future<Output = Result<(usize, usize, usize, [u8; 32]), Error>> {
 875
 876         let repeat = Arc::new(AtomicUsize::new(0));
 877         let repeat2 = repeat.clone();
 878
 879         let stream_len = Arc::new(AtomicUsize::new(0));
 880         let stream_len2 = stream_len.clone();
 881
 882         let append_chunk_path = format!("{}_index", prefix);
 883         let upload_chunk_path = format!("{}_chunk", prefix);
 884
 885         let (upload_queue, upload_result) =
 886             Self::append_chunk_queue(h2.clone(), wid, append_chunk_path.to_owned());
 887
 888         let start_time = std::time::Instant::now();
 889
 890         let index_csum = Arc::new(Mutex::new(Some(openssl::sha::Sha256::new())));
 891         let index_csum_2 = index_csum.clone();
 892
 893         stream
 894             .and_then(move |data| {
 895
 896                 let chunk_len = data.len();
 897
 898                 repeat.fetch_add(1, Ordering::SeqCst);
 899                 let offset = stream_len.fetch_add(chunk_len, Ordering::SeqCst) as u64;
 900
 901                 let mut chunk_builder = DataChunkBuilder::new(data.as_ref())
 902                     .compress(true);
 903
 904                 if let Some(ref crypt_config) = crypt_config {
 905                     chunk_builder = chunk_builder.crypt_config(crypt_config);
 906                 }
 907
 908                 let mut known_chunks = known_chunks.lock().unwrap();
 909                 let digest = chunk_builder.digest();
 910
 911                 let mut guard = index_csum.lock().unwrap();
 912                 let csum = guard.as_mut().unwrap();
 913
 914                 let chunk_end = offset + chunk_len as u64;
 915
 916                 csum.update(&chunk_end.to_le_bytes());
 917                 csum.update(digest);
 918
 919                 let chunk_is_known = known_chunks.contains(digest);
 920                 if chunk_is_known {
 921                     future::ok(MergedChunkInfo::Known(vec![(offset, *digest)]))
 922                 } else {
 923                     known_chunks.insert(*digest);
 924                     future::ready(chunk_builder
 925                         .build()
 926                         .map(move |chunk| MergedChunkInfo::New(ChunkInfo {
 927                             chunk,
 928                             chunk_len: chunk_len as u64,
 929                             offset,
 930                         }))
 931                     )
 932                 }
 933             })
 934             .merge_known_chunks()
 935             .try_for_each(move |merged_chunk_info| {
 936
 937                 if let MergedChunkInfo::New(chunk_info) = merged_chunk_info {
 938                     let offset = chunk_info.offset;
 939                     let digest = *chunk_info.chunk.digest();
 940                     let digest_str = digest_to_hex(&digest);
 941
 942                     println!("upload new chunk {} ({} bytes, offset {})", digest_str,
 943                              chunk_info.chunk_len, offset);
 944
 945                     let chunk_data = chunk_info.chunk.raw_data();
 946                     let param = json!({
 947                         "wid": wid,
 948                         "digest": digest_str,
 949                         "size": chunk_info.chunk_len,
 950                         "encoded-size": chunk_data.len(),
 951                     });
 952
 953                     let request = H2Client::request_builder("localhost", "POST", &upload_chunk_path, Some(param)).unwrap();
 954                     let upload_data = Some(bytes::Bytes::from(chunk_data));
 955
 956                     let new_info = MergedChunkInfo::Known(vec![(offset, digest)]);
 957
 958                     let mut upload_queue = upload_queue.clone();
 959                     future::Either::Left(h2
 960                         .send_request(request, upload_data)
 961                         .and_then(move |response| async move {
 962                             upload_queue
 963                                 .send((new_info, Some(response)))
 964                                 .await
 965                                 .map_err(Error::from)
 966                         })
 967                     )
 968                 } else {
 969                     let mut upload_queue = upload_queue.clone();
 970                     future::Either::Right(async move {
 971                         upload_queue
 972                             .send((merged_chunk_info, None))
 973                             .await
 974                             .map_err(Error::from)
 975                     })
 976                 }
 977             })
 978             .then(move |result| async move {
 979                 upload_result.await?.and(result)
 980             }.boxed())
 981             .and_then(move |_| {
 982                 let repeat = repeat2.load(Ordering::SeqCst);
 983                 let stream_len = stream_len2.load(Ordering::SeqCst);
 984                 let speed = ((stream_len*1000000)/(1024*1024))/(start_time.elapsed().as_micros() as usize);
 985                 println!("Uploaded {} chunks in {} seconds ({} MB/s).", repeat, start_time.elapsed().as_secs(), speed);
 986                 if repeat > 0 {
 987                     println!("Average chunk size was {} bytes.", stream_len/repeat);
 988                     println!("Time per request: {} microseconds.", (start_time.elapsed().as_micros())/(repeat as u128));
 989                 }
 990
 991                 let mut guard = index_csum_2.lock().unwrap();
 992                 let csum = guard.take().unwrap().finish();
 993
 994                 futures::future::ok((repeat, stream_len, speed, csum))
 995             })
 996     }
 997
 998     pub async fn upload_speedtest(&self) -> Result<usize, Error> {
 999
1000         let mut data = vec![];
1001         // generate pseudo random byte sequence
1002         for i in 0..1024*1024 {
1003             for j in 0..4 {
1004                 let byte = ((i >> (j<<3))&0xff) as u8;
1005                 data.push(byte);
1006             }
1007         }
1008
1009         let item_len = data.len();
1010
1011         let mut repeat = 0;
1012
1013         let (upload_queue, upload_result) = Self::response_queue();
1014
1015         let start_time = std::time::Instant::now();
1016
1017         loop {
1018             repeat += 1;
1019             if start_time.elapsed().as_secs() >= 5 {
1020                 break;
1021             }
1022
1023             let mut upload_queue = upload_queue.clone();
1024
1025             println!("send test data ({} bytes)", data.len());
1026             let request = H2Client::request_builder("localhost", "POST", "speedtest", None).unwrap();
1027             let request_future = self.h2.send_request(request, Some(bytes::Bytes::from(data.clone()))).await?;
1028
1029             upload_queue.send(request_future).await?;
1030         }
1031
1032         drop(upload_queue); // close queue
1033
1034         let _ = upload_result.await?;
1035
1036         println!("Uploaded {} chunks in {} seconds.", repeat, start_time.elapsed().as_secs());
1037         let speed = ((item_len*1000000*(repeat as usize))/(1024*1024))/(start_time.elapsed().as_micros() as usize);
1038         println!("Time per request: {} microseconds.", (start_time.elapsed().as_micros())/(repeat as u128));
1039
1040         Ok(speed)
1041     }
1042 }
1043
1044 #[derive(Clone)]
1045 pub struct H2Client {
1046     h2: h2::client::SendRequest<bytes::Bytes>,
1047 }
1048
1049 impl H2Client {
1050
1051     pub fn new(h2: h2::client::SendRequest<bytes::Bytes>) -> Self {
1052         Self { h2 }
1053     }
1054
1055     pub async fn get(
1056         &self,
1057         path: &str,
1058         param: Option<Value>
1059     ) -> Result<Value, Error> {
1060         let req = Self::request_builder("localhost", "GET", path, param).unwrap();
1061         self.request(req).await
1062     }
1063
1064     pub async fn put(
1065         &self,
1066         path: &str,
1067         param: Option<Value>
1068     ) -> Result<Value, Error> {
1069         let req = Self::request_builder("localhost", "PUT", path, param).unwrap();
1070         self.request(req).await
1071     }
1072
1073     pub async fn post(
1074         &self,
1075         path: &str,
1076         param: Option<Value>
1077     ) -> Result<Value, Error> {
1078         let req = Self::request_builder("localhost", "POST", path, param).unwrap();
1079         self.request(req).await
1080     }
1081
1082     pub async fn download<W: Write + Send>(
1083         &self,
1084         path: &str,
1085         param: Option<Value>,
1086         mut output: W,
1087     ) -> Result<W, Error> {
1088         let request = Self::request_builder("localhost", "GET", path, param).unwrap();
1089
1090         let response_future = self.send_request(request, None).await?;
1091
1092         let resp = response_future.await?;
1093
1094         let status = resp.status();
1095         if !status.is_success() {
1096             H2Client::h2api_response(resp).await?; // raise error
1097             unreachable!();
1098         }
1099
1100         let mut body = resp.into_body();
1101         let mut release_capacity = body.release_capacity().clone();
1102
1103         while let Some(chunk) = body.try_next().await? {
1104             let _ = release_capacity.release_capacity(chunk.len());
1105             output.write_all(&chunk)?;
1106         }
1107
1108         Ok(output)
1109     }
1110
1111     pub async fn upload(
1112         &self,
1113         path: &str,
1114         param: Option<Value>,
1115         data: Vec<u8>,
1116     ) -> Result<Value, Error> {
1117         let request = Self::request_builder("localhost", "POST", path, param).unwrap();
1118
1119         let mut send_request = self.h2.clone().ready().await?;
1120
1121         let (response, stream) = send_request.send_request(request, false).unwrap();
1122
1123         PipeToSendStream::new(bytes::Bytes::from(data), stream).await?;
1124
1125         response
1126             .map_err(Error::from)
1127             .and_then(Self::h2api_response)
1128             .await
1129     }
1130
1131     async fn request(
1132         &self,
1133         request: Request<()>,
1134     ) -> Result<Value, Error> {
1135
1136         self.send_request(request, None)
1137             .and_then(move |response| {
1138                 response
1139                     .map_err(Error::from)
1140                     .and_then(Self::h2api_response)
1141             })
1142             .await
1143     }
1144
1145     fn send_request(
1146         &self,
1147         request: Request<()>,
1148         data: Option<bytes::Bytes>,
1149     ) -> impl Future<Output = Result<h2::client::ResponseFuture, Error>> {
1150
1151         self.h2.clone()
1152             .ready()
1153             .map_err(Error::from)
1154             .and_then(move |mut send_request| async move {
1155                 if let Some(data) = data {
1156                     let (response, stream) = send_request.send_request(request, false).unwrap();
1157                     PipeToSendStream::new(data, stream).await?;
1158                     Ok(response)
1159                 } else {
1160                     let (response, _stream) = send_request.send_request(request, true).unwrap();
1161                     Ok(response)
1162                 }
1163             })
1164     }
1165
1166     async fn h2api_response(
1167         response: Response<h2::RecvStream>,
1168     ) -> Result<Value, Error> {
1169         let status = response.status();
1170
1171         let (_head, mut body) = response.into_parts();
1172
1173         // The `release_capacity` handle allows the caller to manage
1174         // flow control.
1175         //
1176         // Whenever data is received, the caller is responsible for
1177         // releasing capacity back to the server once it has freed
1178         // the data from memory.
1179         let mut release_capacity = body.release_capacity().clone();
1180
1181         let mut data = Vec::new();
1182         while let Some(chunk) = body.try_next().await? {
1183             // Let the server send more data.
1184             let _ = release_capacity.release_capacity(chunk.len());
1185             data.extend(chunk);
1186         }
1187
1188         let text = String::from_utf8(data.to_vec()).unwrap();
1189         if status.is_success() {
1190             if text.len() > 0 {
1191                 let mut value: Value = serde_json::from_str(&text)?;
1192                 if let Some(map) = value.as_object_mut() {
1193                     if let Some(data) = map.remove("data") {
1194                         return Ok(data);
1195                     }
1196                 }
1197                 bail!("got result without data property");
1198             } else {
1199                 Ok(Value::Null)
1200             }
1201         } else {
1202             bail!("HTTP Error {}: {}", status, text);
1203         }
1204     }
1205
1206     // Note: We always encode parameters with the url
1207     pub fn request_builder(server: &str, method: &str, path: &str, data: Option<Value>) -> Result<Request<()>, Error> {
1208         let path = path.trim_matches('/');
1209
1210         if let Some(data) = data {
1211             let query = tools::json_object_to_query(data)?;
1212             // We detected problem with hyper around 6000 characters - seo we try to keep on the safe side
1213             if query.len() > 4096 { bail!("h2 query data too large ({} bytes) - please encode data inside body", query.len()); }
1214             let url: Uri = format!("https://{}:8007/{}?{}", server, path, query).parse()?;
1215              let request = Request::builder()
1216                 .method(method)
1217                 .uri(url)
1218                 .header("User-Agent", "proxmox-backup-client/1.0")
1219                 .header(hyper::header::CONTENT_TYPE, "application/x-www-form-urlencoded")
1220                 .body(())?;
1221             return Ok(request);
1222         } else {
1223             let url: Uri = format!("https://{}:8007/{}", server, path).parse()?;
1224             let request = Request::builder()
1225                 .method(method)
1226                 .uri(url)
1227                 .header("User-Agent", "proxmox-backup-client/1.0")
1228                 .header(hyper::header::CONTENT_TYPE, "application/x-www-form-urlencoded")
1229                 .body(())?;
1230
1231             Ok(request)
1232         }
1233     }
1234 }
1235
1236 pub struct HttpsConnector {
1237     http: HttpConnector,
1238     ssl_connector: SslConnector,
1239 }
1240
1241 impl HttpsConnector {
1242     pub fn with_connector(mut http: HttpConnector, ssl_connector: SslConnector) -> Self {
1243         http.enforce_http(false);
1244
1245         Self {
1246             http,
1247             ssl_connector,
1248         }
1249     }
1250 }
1251
1252 type MaybeTlsStream = EitherStream<
1253     tokio::net::TcpStream,
1254     tokio_openssl::SslStream<tokio::net::TcpStream>,
1255 >;
1256
1257 impl hyper::client::connect::Connect for HttpsConnector {
1258     type Transport = MaybeTlsStream;
1259     type Error = Error;
1260     type Future = Box<dyn Future<Output = Result<(
1261         Self::Transport,
1262         hyper::client::connect::Connected,
1263     ), Error>> + Send + Unpin + 'static>;
1264
1265     fn connect(&self, dst: hyper::client::connect::Destination) -> Self::Future {
1266         let is_https = dst.scheme() == "https";
1267         let host = dst.host().to_string();
1268
1269         let config = self.ssl_connector.configure();
1270         let conn = self.http.connect(dst);
1271
1272         Box::new(Box::pin(async move {
1273             let (conn, connected) = conn.await?;
1274             if is_https {
1275                 let conn = tokio_openssl::connect(config?, &host, conn).await?;
1276                 Ok((MaybeTlsStream::Right(conn), connected))
1277             } else {
1278                 Ok((MaybeTlsStream::Left(conn), connected))
1279             }
1280         }))
1281     }
1282 }