tyler/proxmox-backup
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

src/api2/admin/datastore/upload.rs: remove unused upload api

Browse Source
This commit is contained in:
Dietmar Maurer
2019-06-07 07:39:41 +02:00
parent 4247fccb0f
commit 113898d7e9
2 changed files with 0 additions and 253 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/api2/admin/datastore.rs
View File

@ -19,7 +19,6 @@ use crate::backup::*;
use crate::server::WorkerTask;
mod pxar;
mod upload;
fn group_backups(backup_list: Vec<BackupInfo>) -> HashMap<String, Vec<BackupInfo>> {

252
src/api2/admin/datastore/upload.rs
View File

@ -1,252 +0,0 @@
use std::path::PathBuf;
use std::sync::Arc;
use failure::*;
use futures::future::{ok, poll_fn};
use futures::{Async, Future};
use hyper::header::{HeaderValue, UPGRADE};
use hyper::http::request::Parts;
use hyper::rt;
use hyper::{Body, Response, StatusCode};
use serde_json::Value;
use proxmox_protocol::protocol::DynamicChunk;
use proxmox_protocol::server as pmx_server;
use proxmox_protocol::{ChunkEntry, FixedChunk};
use crate::api_schema::router::*;
use crate::api_schema::*;
use crate::backup::{BackupDir, DataStore, DynamicIndexWriter, FixedIndexWriter, IndexFile};
use crate::tools;
type Result<T> = std::result::Result<T, Error>;
pub fn api_method_upgrade_upload() -> ApiAsyncMethod {
ApiAsyncMethod::new(
upgrade_upload,
ObjectSchema::new("Download .pxar backup file.")
.required("store", StringSchema::new("Datastore name.")),
)
}
fn upgrade_upload(
parts: Parts,
req_body: Body,
param: Value,
_info: &ApiAsyncMethod,
_rpcenv: Box<RpcEnvironment>,
) -> Result<BoxFut> {
let store = tools::required_string_param(&param, "store")?.to_string();
let expected_protocol: &'static str = "proxmox-backup-protocol-1";
let protocols = parts
.headers
.get("UPGRADE")
.ok_or_else(|| format_err!("missing Upgrade header"))?
.to_str()?;
if protocols != expected_protocol {
bail!("invalid protocol name");
}
rt::spawn(
req_body
.on_upgrade()
.map_err(|e| Error::from(e))
.and_then(move |conn| backup_protocol_handler(conn, &store))
.map_err(|e| eprintln!("error during upgrade: {}", e))
.flatten(),
);
Ok(Box::new(ok(Response::builder()
.status(StatusCode::SWITCHING_PROTOCOLS)
.header(UPGRADE, HeaderValue::from_static(expected_protocol))
.body(Body::empty())
.unwrap())))
}
struct BackupClientHandler {
store: Arc<DataStore>,
}
struct ChunkLister(Box<dyn IndexFile + Send>, usize);
impl pmx_server::ChunkList for ChunkLister {
fn next(&mut self) -> Result<Option<&[u8; 32]>> {
if self.1 == self.0.index_count() {
Ok(None)
} else {
let chunk = self.0.index_digest(self.1);
self.1 += 1;
Ok(chunk)
}
}
}
impl pmx_server::HandleClient for BackupClientHandler {
fn error(&self) {
eprintln!("There was an error!");
}
fn get_chunk_list(
&self,
backup_name: &str,
) -> Result<Box<dyn pmx_server::ChunkList>> {
Ok(Box::new(ChunkLister(self.store.open_index(backup_name)?, 0)))
}
fn upload_chunk(&self, chunk: &ChunkEntry, data: &[u8]) -> Result<bool> {
let (new, _csize) = self.store.insert_chunk_noverify(&chunk.hash, data)?;
Ok(new)
}
fn create_backup(
&self,
backup_type: &str,
backup_id: &str,
backup_timestamp: i64,
new: bool,
) -> Result<Box<dyn pmx_server::HandleBackup + Send>> {
let (path, is_new) = self.store.create_backup_dir(
&BackupDir::new(backup_type, backup_id, backup_timestamp)
)?;
if new && !is_new {
bail!("client requested to create a new backup, but it already existed");
}
Ok(Box::new(BackupHandler {
store: Arc::clone(&self.store),
path,
}))
}
}
struct BackupHandler {
store: Arc<DataStore>,
path: PathBuf,
}
impl pmx_server::HandleBackup for BackupHandler {
fn finish(&mut self) -> Result<()> {
bail!("TODO: finish");
}
fn create_file(
&self,
name: &str,
fixed_size: Option<u64>,
chunk_size: usize,
) -> Result<Box<dyn pmx_server::BackupFile + Send>> {
if name.find('/').is_some() {
bail!("invalid file name");
}
let mut path_str = self.path
.to_str()
.ok_or_else(|| format_err!("generated non-utf8 path"))?
.to_string();
path_str.push('/');
path_str.push_str(name);
match fixed_size {
None => {
path_str.push_str(".didx");
let path = PathBuf::from(path_str.as_str());
let writer = self.store.create_dynamic_writer(path)?;
Ok(Box::new(DynamicFile {
writer: Some(writer),
path: path_str,
}))
}
Some(file_size) => {
path_str.push_str(".fidx");
let path = PathBuf::from(path_str.as_str());
let writer = self.store.create_fixed_writer(path, file_size as usize, chunk_size)?;
Ok(Box::new(FixedFile {
writer: Some(writer),
path: path_str,
}))
}
}
}
}
struct DynamicFile {
writer: Option<DynamicIndexWriter>,
path: String,
}
impl pmx_server::BackupFile for DynamicFile {
fn relative_path(&self) -> &str {
self.path.as_str()
}
fn add_fixed_data(&mut self, _index: u64, _hash: &FixedChunk) -> Result<()> {
bail!("add_fixed_data data on dynamic index writer!");
}
fn add_dynamic_data(&mut self, chunk: &DynamicChunk) -> Result<()> {
self.writer.as_mut().unwrap()
.add_chunk(chunk.offset, &chunk.digest)
.map_err(Error::from)
}
fn finish(&mut self) -> Result<()> {
self.writer.take().unwrap().close()
}
}
struct FixedFile {
writer: Option<FixedIndexWriter>,
path: String,
}
impl pmx_server::BackupFile for FixedFile {
fn relative_path(&self) -> &str {
self.path.as_str()
}
fn add_fixed_data(&mut self, index: u64, hash: &FixedChunk) -> Result<()> {
self.writer.as_mut().unwrap()
.add_digest(index as usize, &hash.0)
}
fn add_dynamic_data(&mut self, _chunk: &DynamicChunk) -> Result<()> {
bail!("add_dynamic_data data on fixed index writer!");
}
fn finish(&mut self) -> Result<()> {
self.writer.take().unwrap().close()
}
}
fn backup_protocol_handler(
conn: hyper::upgrade::Upgraded,
store_name: &str,
) -> Result<Box<Future<Item = (), Error = ()> + Send>> {
let store = DataStore::lookup_datastore(store_name)?;
let handler = BackupClientHandler { store };
let mut protocol = pmx_server::Connection::new(conn, handler)?;
Ok(Box::new(poll_fn(move || {
match protocol.main() {
Ok(_) => {
if protocol.eof() {
eprintln!("is eof!");
}
Ok(Async::NotReady)
}
Err(e) => {
if let Some(e) = e.downcast_ref::<std::io::Error>() {
if e.kind() == std::io::ErrorKind::WouldBlock {
eprintln!("Got EWOULDBLOCK");
return Ok(Async::NotReady);
}
}
// end the future
eprintln!("Backup protocol error: {}", e);
Err(())
}
}
})))
}