Deuxfleurs/garage
42
39
Fork 55
Code Issues 73 Pull requests 7 Releases 29 Wiki Activity
garage/src/api_server.rs

226 lines
6.1 KiB
Rust
Raw Normal View History

Some more basic work
2020-04-06 17:55:39 +00:00
use std::sync::Arc;
Basic workflow for client PUT, next is do actual storage
2020-04-07 22:39:07 +00:00
use std::net::SocketAddr;
use std::collections::VecDeque;
Some more basic work
2020-04-06 17:55:39 +00:00
Basic workflow for client PUT, next is do actual storage
2020-04-07 22:39:07 +00:00
use futures::stream::StreamExt;
First commit: skeleton for something great
2020-04-05 21:33:42 +00:00
use hyper::service::{make_service_fn, service_fn};
Basic workflow for client PUT, next is do actual storage
2020-04-07 22:39:07 +00:00
use hyper::server::conn::AddrStream;
First commit: skeleton for something great
2020-04-05 21:33:42 +00:00
use hyper::{Body, Method, Request, Response, Server, StatusCode};
use futures::future::Future;
use crate::error::Error;
Basic workflow for client PUT, next is do actual storage
2020-04-07 22:39:07 +00:00
use crate::data::*;
use crate::proto::*;
use crate::rpc_client::*;
Some work in actually storing things
2020-04-08 20:00:41 +00:00
use crate::server::Garage;
First commit: skeleton for something great
2020-04-05 21:33:42 +00:00
Some work in actually storing things
2020-04-08 20:00:41 +00:00
pub async fn run_api_server(garage: Arc<Garage>, shutdown_signal: impl Future<Output=()>) -> Result<(), hyper::Error> {
let addr = ([0, 0, 0, 0], garage.system.config.api_port).into();
First commit: skeleton for something great
2020-04-05 21:33:42 +00:00
Basic workflow for client PUT, next is do actual storage
2020-04-07 22:39:07 +00:00
let service = make_service_fn(|conn: &AddrStream| {
Some work in actually storing things
2020-04-08 20:00:41 +00:00
let garage = garage.clone();
Basic workflow for client PUT, next is do actual storage
2020-04-07 22:39:07 +00:00
let client_addr = conn.remote_addr();
Some more basic work
2020-04-06 17:55:39 +00:00
async move {
Ok::<_, Error>(service_fn(move |req: Request<Body>| {
Some work in actually storing things
2020-04-08 20:00:41 +00:00
let garage = garage.clone();
handler(garage, req, client_addr)
Some more basic work
2020-04-06 17:55:39 +00:00
}))
}
});
First commit: skeleton for something great
2020-04-05 21:33:42 +00:00
let server = Server::bind(&addr).serve(service);
let graceful = server.with_graceful_shutdown(shutdown_signal);
Some more basic work
2020-04-06 17:55:39 +00:00
println!("API server listening on http://{}", addr);
First commit: skeleton for something great
2020-04-05 21:33:42 +00:00
graceful.await
}
Basic workflow for client PUT, next is do actual storage
2020-04-07 22:39:07 +00:00
Some work in actually storing things
2020-04-08 20:00:41 +00:00
async fn handler(garage: Arc<Garage>, req: Request<Body>, addr: SocketAddr) -> Result<Response<Body>, Error> {
match handler_inner(garage, req, addr).await {
Basic workflow for client PUT, next is do actual storage
2020-04-07 22:39:07 +00:00
Ok(x) => Ok(x),
Err(e) => {
Some progress
2020-04-09 15:32:28 +00:00
let mut http_error = Response::new(Body::from(format!("{}\n", e)));
*http_error.status_mut() = e.http_status_code();
Ok(http_error)
Basic workflow for client PUT, next is do actual storage
2020-04-07 22:39:07 +00:00
}
}
}
Some work in actually storing things
2020-04-08 20:00:41 +00:00
async fn handler_inner(garage: Arc<Garage>, req: Request<Body>, addr: SocketAddr) -> Result<Response<Body>, Error> {
Basic workflow for client PUT, next is do actual storage
2020-04-07 22:39:07 +00:00
eprintln!("{} {} {}", addr, req.method(), req.uri());
let bucket = req.headers()
.get(hyper::header::HOST)
.map(|x| x.to_str().map_err(Error::from))
.unwrap_or(Err(Error::BadRequest(format!("Host: header missing"))))?
.to_lowercase();
let key = req.uri().path().to_string();
match req.method() {
&Method::GET => {
Some progress
2020-04-09 15:32:28 +00:00
Ok(handle_get(garage, &bucket, &key).await?)
Basic workflow for client PUT, next is do actual storage
2020-04-07 22:39:07 +00:00
}
&Method::PUT => {
let mime_type = req.headers()
.get(hyper::header::CONTENT_TYPE)
.map(|x| x.to_str())
.unwrap_or(Ok("blob"))?
.to_string();
Some work in actually storing things
2020-04-08 20:00:41 +00:00
let version_uuid = handle_put(garage, &mime_type, &bucket, &key, req.into_body()).await?;
Basic workflow for client PUT, next is do actual storage
2020-04-07 22:39:07 +00:00
Ok(Response::new(Body::from(
format!("Version UUID: {:?}", version_uuid),
)))
}
_ => Err(Error::BadRequest(format!("Invalid method"))),
}
}
Some work in actually storing things
2020-04-08 20:00:41 +00:00
async fn handle_put(garage: Arc<Garage>,
Basic workflow for client PUT, next is do actual storage
2020-04-07 22:39:07 +00:00
mime_type: &str,
bucket: &str, key: &str, body: Body)
-> Result<UUID, Error>
{
let version_uuid = gen_uuid();
Some work in actually storing things
2020-04-08 20:00:41 +00:00
let mut chunker = BodyChunker::new(body, garage.system.config.block_size);
Basic workflow for client PUT, next is do actual storage
2020-04-07 22:39:07 +00:00
let first_block = match chunker.next().await? {
Some(x) => x,
None => return Err(Error::BadRequest(format!("Empty body"))),
};
Some progress
2020-04-09 15:32:28 +00:00
let mut object = Object {
Reorganize table API
2020-04-09 14:16:27 +00:00
bucket: bucket.into(),
key: key.into(),
Some progress
2020-04-09 15:32:28 +00:00
versions: Vec::new(),
};
object.versions.push(Box::new(Version{
Basic workflow for client PUT, next is do actual storage
2020-04-07 22:39:07 +00:00
uuid: version_uuid.clone(),
Some progress
2020-04-09 15:32:28 +00:00
timestamp: now_msec(),
Basic workflow for client PUT, next is do actual storage
2020-04-07 22:39:07 +00:00
mime_type: mime_type.to_string(),
size: first_block.len() as u64,
is_complete: false,
data: VersionData::DeleteMarker,
Some progress
2020-04-09 15:32:28 +00:00
}));
Basic workflow for client PUT, next is do actual storage
2020-04-07 22:39:07 +00:00
if first_block.len() < INLINE_THRESHOLD {
Some progress
2020-04-09 15:32:28 +00:00
object.versions[0].data = VersionData::Inline(first_block);
object.versions[0].is_complete = true;
garage.object_table.insert(&object).await?;
Basic workflow for client PUT, next is do actual storage
2020-04-07 22:39:07 +00:00
return Ok(version_uuid)
}
let first_block_hash = hash(&first_block[..]);
Some progress
2020-04-09 15:32:28 +00:00
object.versions[0].data = VersionData::FirstBlock(first_block_hash);
garage.object_table.insert(&object).await?;
Basic workflow for client PUT, next is do actual storage
2020-04-07 22:39:07 +00:00
let block_meta = BlockMeta{
version_uuid: version_uuid.clone(),
offset: 0,
hash: hash(&first_block[..]),
};
let mut next_offset = first_block.len();
Some work in actually storing things
2020-04-08 20:00:41 +00:00
let mut put_curr_block = put_block(garage.clone(), block_meta, first_block);
Basic workflow for client PUT, next is do actual storage
2020-04-07 22:39:07 +00:00
loop {
let (_, next_block) = futures::try_join!(put_curr_block, chunker.next())?;
if let Some(block) = next_block {
let block_meta = BlockMeta{
version_uuid: version_uuid.clone(),
offset: next_offset as u64,
hash: hash(&block[..]),
};
next_offset += block.len();
Some work in actually storing things
2020-04-08 20:00:41 +00:00
put_curr_block = put_block(garage.clone(), block_meta, block);
Basic workflow for client PUT, next is do actual storage
2020-04-07 22:39:07 +00:00
} else {
break;
}
}
// TODO: if at any step we have an error, we should undo everything we did
Some progress
2020-04-09 15:32:28 +00:00
object.versions[0].is_complete = true;
object.versions[0].size = next_offset as u64;
garage.object_table.insert(&object).await?;
Basic workflow for client PUT, next is do actual storage
2020-04-07 22:39:07 +00:00
Ok(version_uuid)
}
Some work in actually storing things
2020-04-08 20:00:41 +00:00
async fn put_block(garage: Arc<Garage>, meta: BlockMeta, data: Vec<u8>) -> Result<(), Error> {
let who = garage.system.members.read().await
.walk_ring(&meta.hash, garage.system.config.meta_replication_factor);
rpc_try_call_many(garage.system.clone(),
Basic workflow for client PUT, next is do actual storage
2020-04-07 22:39:07 +00:00
&who[..],
&Message::PutBlock(PutBlockMessage{
meta,
data,
}),
Some work in actually storing things
2020-04-08 20:00:41 +00:00
(garage.system.config.meta_replication_factor+1)/2,
Basic workflow for client PUT, next is do actual storage
2020-04-07 22:39:07 +00:00
DEFAULT_TIMEOUT).await?;
Ok(())
}
struct BodyChunker {
body: Body,
block_size: usize,
buf: VecDeque<u8>,
}
impl BodyChunker {
fn new(body: Body, block_size: usize) -> Self {
Self{
body,
block_size,
buf: VecDeque::new(),
}
}
async fn next(&mut self) -> Result<Option<Vec<u8>>, Error> {
while self.buf.len() < self.block_size {
if let Some(block) = self.body.next().await {
let bytes = block?;
self.buf.extend(&bytes[..]);
} else {
break;
}
}
if self.buf.len() == 0 {
Ok(None)
} else if self.buf.len() <= self.block_size {
let block = self.buf.drain(..)
.collect::<Vec<u8>>();
Ok(Some(block))
} else {
let block = self.buf.drain(..self.block_size)
.collect::<Vec<u8>>();
Ok(Some(block))
}
}
}
Some progress
2020-04-09 15:32:28 +00:00
async fn handle_get(garage: Arc<Garage>, bucket: &str, key: &str) -> Result<Response<Body>, Error> {
let mut object = match garage.object_table.get(&bucket.to_string(), &key.to_string()).await? {
None => return Err(Error::NotFound),
Some(o) => o
};
let last_v = match object.versions.drain(..)
.rev().filter(|v| v.is_complete)
.next() {
Some(v) => v,
None => return Err(Error::NotFound),
};
let resp_builder = Response::builder()
.header("Content-Type", last_v.mime_type)
.status(StatusCode::OK);
match last_v.data {
VersionData::DeleteMarker => Err(Error::NotFound),
VersionData::Inline(bytes) => {
Ok(resp_builder.body(bytes.into())?)
}
VersionData::FirstBlock(hash) => {
// TODO
unimplemented!()
}
}
}
Reference in a new issue Copy permalink