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