2021-03-26 21:32:09 +00:00
|
|
|
//! Function related to GET and HEAD requests
|
2020-04-24 18:47:11 +00:00
|
|
|
use std::sync::Arc;
|
|
|
|
|
use std::time::{Duration, UNIX_EPOCH};
|
|
|
|
|
|
2022-09-19 10:16:38 +00:00
|
|
|
use futures::future;
|
|
|
|
|
use futures::stream::{self, StreamExt};
|
2022-01-12 11:43:33 +00:00
|
|
|
use http::header::{
|
|
|
|
|
ACCEPT_RANGES, CONTENT_LENGTH, CONTENT_RANGE, CONTENT_TYPE, ETAG, IF_MODIFIED_SINCE,
|
2022-01-13 14:29:39 +00:00
|
|
|
IF_NONE_MATCH, LAST_MODIFIED, RANGE,
|
2022-01-12 11:43:33 +00:00
|
|
|
};
|
2020-05-04 13:09:23 +00:00
|
|
|
use hyper::{Body, Request, Response, StatusCode};
|
2022-09-19 10:16:38 +00:00
|
|
|
use tokio::sync::mpsc;
|
2020-04-24 18:47:11 +00:00
|
|
|
|
2022-09-13 13:13:07 +00:00
|
|
|
use garage_rpc::rpc_helper::{netapp::stream::ByteStream, OrderTag};
|
2020-04-24 18:47:11 +00:00
|
|
|
use garage_table::EmptyKey;
|
2021-12-14 12:55:11 +00:00
|
|
|
use garage_util::data::*;
|
2022-09-19 10:16:38 +00:00
|
|
|
use garage_util::error::OkOrMessage;
|
2020-04-24 18:47:11 +00:00
|
|
|
|
2020-07-07 11:59:22 +00:00
|
|
|
use garage_model::garage::Garage;
|
2022-05-10 11:16:57 +00:00
|
|
|
use garage_model::s3::object_table::*;
|
|
|
|
|
use garage_model::s3::version_table::*;
|
2020-04-24 18:47:11 +00:00
|
|
|
|
2022-05-24 10:16:39 +00:00
|
|
|
use crate::s3::error::*;
|
2020-11-08 14:04:30 +00:00
|
|
|
|
2022-01-25 10:29:21 +00:00
|
|
|
const X_AMZ_MP_PARTS_COUNT: &str = "x-amz-mp-parts-count";
|
|
|
|
|
|
2020-07-08 15:34:37 +00:00
|
|
|
fn object_headers(
|
|
|
|
|
version: &ObjectVersion,
|
|
|
|
|
version_meta: &ObjectVersionMeta,
|
|
|
|
|
) -> http::response::Builder {
|
2021-02-19 11:38:22 +00:00
|
|
|
debug!("Version meta: {:?}", version_meta);
|
|
|
|
|
|
2020-04-24 18:47:11 +00:00
|
|
|
let date = UNIX_EPOCH + Duration::from_millis(version.timestamp);
|
|
|
|
|
let date_str = httpdate::fmt_http_date(date);
|
|
|
|
|
|
2020-07-09 15:04:43 +00:00
|
|
|
let mut resp = Response::builder()
|
2022-01-12 11:43:33 +00:00
|
|
|
.header(CONTENT_TYPE, version_meta.headers.content_type.to_string())
|
|
|
|
|
.header(LAST_MODIFIED, date_str)
|
|
|
|
|
.header(ACCEPT_RANGES, "bytes".to_string());
|
2020-07-09 15:04:43 +00:00
|
|
|
|
2020-12-05 18:23:46 +00:00
|
|
|
if !version_meta.etag.is_empty() {
|
2022-01-12 11:43:33 +00:00
|
|
|
resp = resp.header(ETAG, format!("\"{}\"", version_meta.etag));
|
2020-12-05 18:23:46 +00:00
|
|
|
}
|
|
|
|
|
|
2020-07-15 13:31:13 +00:00
|
|
|
for (k, v) in version_meta.headers.other.iter() {
|
|
|
|
|
resp = resp.header(k, v.to_string());
|
|
|
|
|
}
|
2020-07-09 15:04:43 +00:00
|
|
|
|
2020-07-15 13:31:13 +00:00
|
|
|
resp
|
2020-04-24 18:47:11 +00:00
|
|
|
}
|
|
|
|
|
|
2021-03-18 14:46:33 +00:00
|
|
|
fn try_answer_cached(
|
|
|
|
|
version: &ObjectVersion,
|
|
|
|
|
version_meta: &ObjectVersionMeta,
|
|
|
|
|
req: &Request<Body>,
|
|
|
|
|
) -> Option<Response<Body>> {
|
2021-03-18 18:46:43 +00:00
|
|
|
// <trinity> It is possible, and is even usually the case, [that both If-None-Match and
|
|
|
|
|
// If-Modified-Since] are present in a request. In this situation If-None-Match takes
|
|
|
|
|
// precedence and If-Modified-Since is ignored (as per 6.Precedence from rfc7232). The rational
|
|
|
|
|
// being that etag based matching is more accurate, it has no issue with sub-second precision
|
|
|
|
|
// for instance (in case of very fast updates)
|
2022-01-12 11:43:33 +00:00
|
|
|
let cached = if let Some(none_match) = req.headers().get(IF_NONE_MATCH) {
|
2021-03-18 14:46:33 +00:00
|
|
|
let none_match = none_match.to_str().ok()?;
|
|
|
|
|
let expected = format!("\"{}\"", version_meta.etag);
|
|
|
|
|
let found = none_match
|
|
|
|
|
.split(',')
|
|
|
|
|
.map(str::trim)
|
|
|
|
|
.any(|etag| etag == expected || etag == "\"*\"");
|
|
|
|
|
found
|
2022-01-12 11:43:33 +00:00
|
|
|
} else if let Some(modified_since) = req.headers().get(IF_MODIFIED_SINCE) {
|
2021-03-18 14:46:33 +00:00
|
|
|
let modified_since = modified_since.to_str().ok()?;
|
|
|
|
|
let client_date = httpdate::parse_http_date(modified_since).ok()?;
|
|
|
|
|
let server_date = UNIX_EPOCH + Duration::from_millis(version.timestamp);
|
|
|
|
|
client_date >= server_date
|
|
|
|
|
} else {
|
|
|
|
|
false
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
if cached {
|
|
|
|
|
Some(
|
|
|
|
|
Response::builder()
|
|
|
|
|
.status(StatusCode::NOT_MODIFIED)
|
|
|
|
|
.body(Body::empty())
|
|
|
|
|
.unwrap(),
|
|
|
|
|
)
|
|
|
|
|
} else {
|
|
|
|
|
None
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2021-03-26 21:32:09 +00:00
|
|
|
/// Handle HEAD request
|
2020-04-24 18:47:11 +00:00
|
|
|
pub async fn handle_head(
|
|
|
|
|
garage: Arc<Garage>,
|
2021-03-18 14:46:33 +00:00
|
|
|
req: &Request<Body>,
|
2021-12-14 12:55:11 +00:00
|
|
|
bucket_id: Uuid,
|
2020-04-24 18:47:11 +00:00
|
|
|
key: &str,
|
2022-01-12 11:43:33 +00:00
|
|
|
part_number: Option<u64>,
|
2020-07-07 15:15:53 +00:00
|
|
|
) -> Result<Response<Body>, Error> {
|
2020-11-11 15:12:42 +00:00
|
|
|
let object = garage
|
2020-04-24 18:47:11 +00:00
|
|
|
.object_table
|
2021-12-14 12:55:11 +00:00
|
|
|
.get(&bucket_id, &key.to_string())
|
2020-04-24 18:47:11 +00:00
|
|
|
.await?
|
2022-01-05 16:07:36 +00:00
|
|
|
.ok_or(Error::NoSuchKey)?;
|
2020-04-24 18:47:11 +00:00
|
|
|
|
2022-01-12 11:43:33 +00:00
|
|
|
let object_version = object
|
2020-04-24 18:47:11 +00:00
|
|
|
.versions()
|
|
|
|
|
.iter()
|
|
|
|
|
.rev()
|
2021-04-23 20:18:00 +00:00
|
|
|
.find(|v| v.is_data())
|
2022-01-05 16:07:36 +00:00
|
|
|
.ok_or(Error::NoSuchKey)?;
|
2020-11-11 15:12:42 +00:00
|
|
|
|
2022-01-12 11:43:33 +00:00
|
|
|
let version_data = match &object_version.state {
|
|
|
|
|
ObjectVersionState::Complete(c) => c,
|
|
|
|
|
_ => unreachable!(),
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
let version_meta = match version_data {
|
|
|
|
|
ObjectVersionData::Inline(meta, _) => meta,
|
|
|
|
|
ObjectVersionData::FirstBlock(meta, _) => meta,
|
2020-07-08 15:34:37 +00:00
|
|
|
_ => unreachable!(),
|
|
|
|
|
};
|
2020-04-24 18:47:11 +00:00
|
|
|
|
2022-01-12 11:43:33 +00:00
|
|
|
if let Some(cached) = try_answer_cached(object_version, version_meta, req) {
|
2021-03-18 14:46:33 +00:00
|
|
|
return Ok(cached);
|
|
|
|
|
}
|
|
|
|
|
|
2022-01-12 11:43:33 +00:00
|
|
|
if let Some(pn) = part_number {
|
2022-01-25 10:29:21 +00:00
|
|
|
match version_data {
|
|
|
|
|
ObjectVersionData::Inline(_, bytes) => {
|
|
|
|
|
if pn != 1 {
|
|
|
|
|
return Err(Error::InvalidPart);
|
|
|
|
|
}
|
|
|
|
|
Ok(object_headers(object_version, version_meta)
|
|
|
|
|
.header(CONTENT_LENGTH, format!("{}", bytes.len()))
|
|
|
|
|
.header(
|
|
|
|
|
CONTENT_RANGE,
|
|
|
|
|
format!("bytes 0-{}/{}", bytes.len() - 1, bytes.len()),
|
|
|
|
|
)
|
|
|
|
|
.header(X_AMZ_MP_PARTS_COUNT, "1")
|
|
|
|
|
.status(StatusCode::PARTIAL_CONTENT)
|
|
|
|
|
.body(Body::empty())?)
|
|
|
|
|
}
|
|
|
|
|
ObjectVersionData::FirstBlock(_, _) => {
|
|
|
|
|
let version = garage
|
|
|
|
|
.version_table
|
|
|
|
|
.get(&object_version.uuid, &EmptyKey)
|
|
|
|
|
.await?
|
|
|
|
|
.ok_or(Error::NoSuchKey)?;
|
|
|
|
|
|
|
|
|
|
let (part_offset, part_end) =
|
|
|
|
|
calculate_part_bounds(&version, pn).ok_or(Error::InvalidPart)?;
|
|
|
|
|
|
|
|
|
|
Ok(object_headers(object_version, version_meta)
|
|
|
|
|
.header(CONTENT_LENGTH, format!("{}", part_end - part_offset))
|
|
|
|
|
.header(
|
|
|
|
|
CONTENT_RANGE,
|
|
|
|
|
format!(
|
|
|
|
|
"bytes {}-{}/{}",
|
|
|
|
|
part_offset,
|
|
|
|
|
part_end - 1,
|
|
|
|
|
version_meta.size
|
|
|
|
|
),
|
|
|
|
|
)
|
2023-05-03 10:02:59 +00:00
|
|
|
.header(X_AMZ_MP_PARTS_COUNT, format!("{}", version.n_parts()?))
|
2022-01-25 10:29:21 +00:00
|
|
|
.status(StatusCode::PARTIAL_CONTENT)
|
|
|
|
|
.body(Body::empty())?)
|
|
|
|
|
}
|
|
|
|
|
_ => unreachable!(),
|
2022-01-12 11:43:33 +00:00
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
Ok(object_headers(object_version, version_meta)
|
|
|
|
|
.header(CONTENT_LENGTH, format!("{}", version_meta.size))
|
|
|
|
|
.status(StatusCode::OK)
|
|
|
|
|
.body(Body::empty())?)
|
|
|
|
|
}
|
2020-04-24 18:47:11 +00:00
|
|
|
}
|
|
|
|
|
|
2021-03-26 21:32:09 +00:00
|
|
|
/// Handle GET request
|
2020-04-24 18:47:11 +00:00
|
|
|
pub async fn handle_get(
|
|
|
|
|
garage: Arc<Garage>,
|
2020-05-04 13:09:23 +00:00
|
|
|
req: &Request<Body>,
|
2021-12-14 12:55:11 +00:00
|
|
|
bucket_id: Uuid,
|
2020-04-24 18:47:11 +00:00
|
|
|
key: &str,
|
2022-01-12 11:43:33 +00:00
|
|
|
part_number: Option<u64>,
|
2020-07-07 15:15:53 +00:00
|
|
|
) -> Result<Response<Body>, Error> {
|
2020-11-11 15:12:42 +00:00
|
|
|
let object = garage
|
2020-04-24 18:47:11 +00:00
|
|
|
.object_table
|
2021-12-14 12:55:11 +00:00
|
|
|
.get(&bucket_id, &key.to_string())
|
2020-04-24 18:47:11 +00:00
|
|
|
.await?
|
2022-01-05 16:07:36 +00:00
|
|
|
.ok_or(Error::NoSuchKey)?;
|
2020-04-24 18:47:11 +00:00
|
|
|
|
2020-11-11 15:12:42 +00:00
|
|
|
let last_v = object
|
2020-04-24 18:47:11 +00:00
|
|
|
.versions()
|
|
|
|
|
.iter()
|
|
|
|
|
.rev()
|
2021-04-23 20:18:00 +00:00
|
|
|
.find(|v| v.is_complete())
|
2022-01-05 16:07:36 +00:00
|
|
|
.ok_or(Error::NoSuchKey)?;
|
2020-11-11 15:12:42 +00:00
|
|
|
|
2020-07-08 15:34:37 +00:00
|
|
|
let last_v_data = match &last_v.state {
|
|
|
|
|
ObjectVersionState::Complete(x) => x,
|
|
|
|
|
_ => unreachable!(),
|
|
|
|
|
};
|
|
|
|
|
let last_v_meta = match last_v_data {
|
2022-01-05 16:07:36 +00:00
|
|
|
ObjectVersionData::DeleteMarker => return Err(Error::NoSuchKey),
|
2020-07-08 15:34:37 +00:00
|
|
|
ObjectVersionData::Inline(meta, _) => meta,
|
|
|
|
|
ObjectVersionData::FirstBlock(meta, _) => meta,
|
|
|
|
|
};
|
2020-04-24 18:47:11 +00:00
|
|
|
|
2021-10-26 08:20:05 +00:00
|
|
|
if let Some(cached) = try_answer_cached(last_v, last_v_meta, req) {
|
2021-03-18 14:46:33 +00:00
|
|
|
return Ok(cached);
|
|
|
|
|
}
|
|
|
|
|
|
2022-01-25 10:29:21 +00:00
|
|
|
match (part_number, parse_range_header(req, last_v_meta.size)?) {
|
|
|
|
|
(Some(_), Some(_)) => {
|
2022-05-24 10:16:39 +00:00
|
|
|
return Err(Error::bad_request(
|
|
|
|
|
"Cannot specify both partNumber and Range header",
|
2022-01-25 10:29:21 +00:00
|
|
|
));
|
|
|
|
|
}
|
|
|
|
|
(Some(pn), None) => {
|
|
|
|
|
return handle_get_part(garage, last_v, last_v_data, last_v_meta, pn).await;
|
|
|
|
|
}
|
|
|
|
|
(None, Some(range)) => {
|
|
|
|
|
return handle_get_range(
|
|
|
|
|
garage,
|
|
|
|
|
last_v,
|
|
|
|
|
last_v_data,
|
|
|
|
|
last_v_meta,
|
|
|
|
|
range.start,
|
|
|
|
|
range.start + range.length,
|
|
|
|
|
)
|
|
|
|
|
.await;
|
|
|
|
|
}
|
|
|
|
|
(None, None) => (),
|
2020-05-04 13:09:23 +00:00
|
|
|
}
|
|
|
|
|
|
2021-10-26 08:20:05 +00:00
|
|
|
let resp_builder = object_headers(last_v, last_v_meta)
|
2022-01-12 11:43:33 +00:00
|
|
|
.header(CONTENT_LENGTH, format!("{}", last_v_meta.size))
|
2020-12-05 18:20:07 +00:00
|
|
|
.status(StatusCode::OK);
|
2020-04-24 18:47:11 +00:00
|
|
|
|
2020-07-08 15:33:24 +00:00
|
|
|
match &last_v_data {
|
|
|
|
|
ObjectVersionData::DeleteMarker => unreachable!(),
|
|
|
|
|
ObjectVersionData::Inline(_, bytes) => {
|
2020-07-07 15:15:53 +00:00
|
|
|
let body: Body = Body::from(bytes.to_vec());
|
2020-04-24 18:47:11 +00:00
|
|
|
Ok(resp_builder.body(body)?)
|
|
|
|
|
}
|
2020-07-08 15:33:24 +00:00
|
|
|
ObjectVersionData::FirstBlock(_, first_block_hash) => {
|
2022-09-19 10:16:38 +00:00
|
|
|
let (tx, rx) = mpsc::channel(2);
|
|
|
|
|
|
2022-09-01 10:58:20 +00:00
|
|
|
let order_stream = OrderTag::stream();
|
2022-09-19 10:16:38 +00:00
|
|
|
let first_block_hash = *first_block_hash;
|
|
|
|
|
let version_uuid = last_v.uuid;
|
|
|
|
|
|
|
|
|
|
tokio::spawn(async move {
|
|
|
|
|
match async {
|
|
|
|
|
let garage2 = garage.clone();
|
|
|
|
|
let version_fut = tokio::spawn(async move {
|
|
|
|
|
garage2.version_table.get(&version_uuid, &EmptyKey).await
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
let stream_block_0 = garage
|
|
|
|
|
.block_manager
|
|
|
|
|
.rpc_get_block_streaming(&first_block_hash, Some(order_stream.order(0)))
|
|
|
|
|
.await?;
|
|
|
|
|
tx.send(stream_block_0)
|
|
|
|
|
.await
|
|
|
|
|
.ok_or_message("channel closed")?;
|
|
|
|
|
|
|
|
|
|
let version = version_fut.await.unwrap()?.ok_or(Error::NoSuchKey)?;
|
|
|
|
|
for (i, (_, vb)) in version.blocks.items().iter().enumerate().skip(1) {
|
|
|
|
|
let stream_block_i = garage
|
|
|
|
|
.block_manager
|
|
|
|
|
.rpc_get_block_streaming(&vb.hash, Some(order_stream.order(i as u64)))
|
|
|
|
|
.await?;
|
|
|
|
|
tx.send(stream_block_i)
|
|
|
|
|
.await
|
|
|
|
|
.ok_or_message("channel closed")?;
|
|
|
|
|
}
|
2022-09-01 10:58:20 +00:00
|
|
|
|
2022-09-19 10:16:38 +00:00
|
|
|
Ok::<(), Error>(())
|
|
|
|
|
}
|
|
|
|
|
.await
|
|
|
|
|
{
|
|
|
|
|
Ok(()) => (),
|
|
|
|
|
Err(e) => {
|
|
|
|
|
let err = std::io::Error::new(
|
|
|
|
|
std::io::ErrorKind::Other,
|
|
|
|
|
format!("Error while getting object data: {}", e),
|
|
|
|
|
);
|
|
|
|
|
let _ = tx
|
|
|
|
|
.send(Box::pin(stream::once(future::ready(Err(err)))))
|
|
|
|
|
.await;
|
2020-04-24 18:47:11 +00:00
|
|
|
}
|
2022-09-19 10:16:38 +00:00
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
let body_stream = tokio_stream::wrappers::ReceiverStream::new(rx).flatten();
|
2020-12-05 15:37:59 +00:00
|
|
|
|
2020-07-08 11:33:02 +00:00
|
|
|
let body = hyper::body::Body::wrap_stream(body_stream);
|
2020-04-24 18:47:11 +00:00
|
|
|
Ok(resp_builder.body(body)?)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2020-05-04 13:09:23 +00:00
|
|
|
|
2021-03-26 21:32:09 +00:00
|
|
|
async fn handle_get_range(
|
2020-05-04 13:09:23 +00:00
|
|
|
garage: Arc<Garage>,
|
|
|
|
|
version: &ObjectVersion,
|
2020-07-08 15:34:37 +00:00
|
|
|
version_data: &ObjectVersionData,
|
|
|
|
|
version_meta: &ObjectVersionMeta,
|
2020-05-04 13:09:23 +00:00
|
|
|
begin: u64,
|
|
|
|
|
end: u64,
|
2020-07-07 15:15:53 +00:00
|
|
|
) -> Result<Response<Body>, Error> {
|
2020-12-05 18:20:07 +00:00
|
|
|
let resp_builder = object_headers(version, version_meta)
|
2022-01-12 11:43:33 +00:00
|
|
|
.header(CONTENT_LENGTH, format!("{}", end - begin))
|
2020-05-04 13:09:23 +00:00
|
|
|
.header(
|
2022-01-12 11:43:33 +00:00
|
|
|
CONTENT_RANGE,
|
2020-12-05 15:37:59 +00:00
|
|
|
format!("bytes {}-{}/{}", begin, end - 1, version_meta.size),
|
2020-05-04 13:09:23 +00:00
|
|
|
)
|
|
|
|
|
.status(StatusCode::PARTIAL_CONTENT);
|
|
|
|
|
|
2020-07-08 15:33:24 +00:00
|
|
|
match &version_data {
|
|
|
|
|
ObjectVersionData::DeleteMarker => unreachable!(),
|
|
|
|
|
ObjectVersionData::Inline(_meta, bytes) => {
|
2020-05-04 13:09:23 +00:00
|
|
|
if end as usize <= bytes.len() {
|
2020-07-08 11:33:02 +00:00
|
|
|
let body: Body = Body::from(bytes[begin as usize..end as usize].to_vec());
|
2020-05-04 13:09:23 +00:00
|
|
|
Ok(resp_builder.body(body)?)
|
|
|
|
|
} else {
|
2022-05-24 10:16:39 +00:00
|
|
|
Err(Error::internal_error(
|
2020-11-08 14:04:30 +00:00
|
|
|
"Requested range not present in inline bytes when it should have been",
|
2022-05-24 10:16:39 +00:00
|
|
|
))
|
2020-05-04 13:09:23 +00:00
|
|
|
}
|
|
|
|
|
}
|
2020-07-08 15:33:24 +00:00
|
|
|
ObjectVersionData::FirstBlock(_meta, _first_block_hash) => {
|
2022-01-13 14:29:39 +00:00
|
|
|
let version = garage
|
|
|
|
|
.version_table
|
|
|
|
|
.get(&version.uuid, &EmptyKey)
|
|
|
|
|
.await?
|
|
|
|
|
.ok_or(Error::NoSuchKey)?;
|
2020-05-04 13:09:23 +00:00
|
|
|
|
2022-01-13 14:29:39 +00:00
|
|
|
let body = body_from_blocks_range(garage, version.blocks.items(), begin, end);
|
2020-05-04 13:09:23 +00:00
|
|
|
Ok(resp_builder.body(body)?)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2022-01-13 14:29:39 +00:00
|
|
|
|
|
|
|
|
async fn handle_get_part(
|
|
|
|
|
garage: Arc<Garage>,
|
|
|
|
|
object_version: &ObjectVersion,
|
|
|
|
|
version_data: &ObjectVersionData,
|
|
|
|
|
version_meta: &ObjectVersionMeta,
|
|
|
|
|
part_number: u64,
|
|
|
|
|
) -> Result<Response<Body>, Error> {
|
2022-01-25 10:29:21 +00:00
|
|
|
let resp_builder =
|
|
|
|
|
object_headers(object_version, version_meta).status(StatusCode::PARTIAL_CONTENT);
|
2022-01-13 14:29:39 +00:00
|
|
|
|
2022-01-25 10:29:21 +00:00
|
|
|
match version_data {
|
|
|
|
|
ObjectVersionData::Inline(_, bytes) => {
|
|
|
|
|
if part_number != 1 {
|
|
|
|
|
return Err(Error::InvalidPart);
|
|
|
|
|
}
|
|
|
|
|
Ok(resp_builder
|
|
|
|
|
.header(CONTENT_LENGTH, format!("{}", bytes.len()))
|
|
|
|
|
.header(
|
|
|
|
|
CONTENT_RANGE,
|
|
|
|
|
format!("bytes {}-{}/{}", 0, bytes.len() - 1, bytes.len()),
|
|
|
|
|
)
|
|
|
|
|
.header(X_AMZ_MP_PARTS_COUNT, "1")
|
|
|
|
|
.body(Body::from(bytes.to_vec()))?)
|
|
|
|
|
}
|
|
|
|
|
ObjectVersionData::FirstBlock(_, _) => {
|
|
|
|
|
let version = garage
|
|
|
|
|
.version_table
|
|
|
|
|
.get(&object_version.uuid, &EmptyKey)
|
|
|
|
|
.await?
|
|
|
|
|
.ok_or(Error::NoSuchKey)?;
|
2022-01-13 14:29:39 +00:00
|
|
|
|
2022-01-25 10:29:21 +00:00
|
|
|
let (begin, end) =
|
|
|
|
|
calculate_part_bounds(&version, part_number).ok_or(Error::InvalidPart)?;
|
2022-01-13 14:29:39 +00:00
|
|
|
|
2022-01-25 10:29:21 +00:00
|
|
|
let body = body_from_blocks_range(garage, version.blocks.items(), begin, end);
|
2022-01-13 14:29:39 +00:00
|
|
|
|
2022-01-25 10:29:21 +00:00
|
|
|
Ok(resp_builder
|
|
|
|
|
.header(CONTENT_LENGTH, format!("{}", end - begin))
|
|
|
|
|
.header(
|
|
|
|
|
CONTENT_RANGE,
|
|
|
|
|
format!("bytes {}-{}/{}", begin, end - 1, version_meta.size),
|
|
|
|
|
)
|
2023-05-03 10:02:59 +00:00
|
|
|
.header(X_AMZ_MP_PARTS_COUNT, format!("{}", version.n_parts()?))
|
2022-01-25 10:29:21 +00:00
|
|
|
.body(body)?)
|
|
|
|
|
}
|
|
|
|
|
_ => unreachable!(),
|
2022-01-13 14:29:39 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn parse_range_header(
|
|
|
|
|
req: &Request<Body>,
|
|
|
|
|
total_size: u64,
|
|
|
|
|
) -> Result<Option<http_range::HttpRange>, Error> {
|
|
|
|
|
let range = match req.headers().get(RANGE) {
|
|
|
|
|
Some(range) => {
|
|
|
|
|
let range_str = range.to_str()?;
|
|
|
|
|
let mut ranges =
|
|
|
|
|
http_range::HttpRange::parse(range_str, total_size).map_err(|e| (e, total_size))?;
|
|
|
|
|
if ranges.len() > 1 {
|
|
|
|
|
// garage does not support multi-range requests yet, so we respond with the entire
|
|
|
|
|
// object when multiple ranges are requested
|
|
|
|
|
None
|
|
|
|
|
} else {
|
|
|
|
|
ranges.pop()
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
None => None,
|
|
|
|
|
};
|
|
|
|
|
Ok(range)
|
|
|
|
|
}
|
|
|
|
|
|
2022-01-25 10:29:21 +00:00
|
|
|
fn calculate_part_bounds(v: &Version, part_number: u64) -> Option<(u64, u64)> {
|
|
|
|
|
let mut offset = 0;
|
|
|
|
|
for (i, (bk, bv)) in v.blocks.items().iter().enumerate() {
|
|
|
|
|
if bk.part_number == part_number {
|
|
|
|
|
let size: u64 = v.blocks.items()[i..]
|
|
|
|
|
.iter()
|
|
|
|
|
.take_while(|(k, _)| k.part_number == part_number)
|
|
|
|
|
.map(|(_, v)| v.size)
|
|
|
|
|
.sum();
|
|
|
|
|
return Some((offset, offset + size));
|
|
|
|
|
}
|
|
|
|
|
offset += bv.size;
|
|
|
|
|
}
|
|
|
|
|
None
|
|
|
|
|
}
|
|
|
|
|
|
2022-01-13 14:29:39 +00:00
|
|
|
fn body_from_blocks_range(
|
|
|
|
|
garage: Arc<Garage>,
|
|
|
|
|
all_blocks: &[(VersionBlockKey, VersionBlock)],
|
|
|
|
|
begin: u64,
|
|
|
|
|
end: u64,
|
|
|
|
|
) -> Body {
|
|
|
|
|
// We will store here the list of blocks that have an intersection with the requested
|
|
|
|
|
// range, as well as their "true offset", which is their actual offset in the complete
|
|
|
|
|
// file (whereas block.offset designates the offset of the block WITHIN THE PART
|
|
|
|
|
// block.part_number, which is not the same in the case of a multipart upload)
|
|
|
|
|
let mut blocks: Vec<(VersionBlock, u64)> = Vec::with_capacity(std::cmp::min(
|
|
|
|
|
all_blocks.len(),
|
|
|
|
|
4 + ((end - begin) / std::cmp::max(all_blocks[0].1.size as u64, 1024)) as usize,
|
|
|
|
|
));
|
2022-09-13 13:13:07 +00:00
|
|
|
let mut block_offset: u64 = 0;
|
2022-01-13 14:29:39 +00:00
|
|
|
for (_, b) in all_blocks.iter() {
|
2022-09-13 13:13:07 +00:00
|
|
|
if block_offset >= end {
|
2022-01-13 14:29:39 +00:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
// Keep only blocks that have an intersection with the requested range
|
2022-09-13 13:13:07 +00:00
|
|
|
if block_offset < end && block_offset + b.size > begin {
|
|
|
|
|
blocks.push((*b, block_offset));
|
2022-01-13 14:29:39 +00:00
|
|
|
}
|
2022-09-13 13:13:07 +00:00
|
|
|
block_offset += b.size as u64;
|
2022-01-13 14:29:39 +00:00
|
|
|
}
|
|
|
|
|
|
2022-09-01 10:58:20 +00:00
|
|
|
let order_stream = OrderTag::stream();
|
2022-01-13 14:29:39 +00:00
|
|
|
let body_stream = futures::stream::iter(blocks)
|
2022-09-01 10:58:20 +00:00
|
|
|
.enumerate()
|
2022-09-13 13:13:07 +00:00
|
|
|
.map(move |(i, (block, block_offset))| {
|
2022-01-13 14:29:39 +00:00
|
|
|
let garage = garage.clone();
|
|
|
|
|
async move {
|
2022-09-13 13:13:07 +00:00
|
|
|
garage
|
2022-09-01 10:58:20 +00:00
|
|
|
.block_manager
|
2022-09-13 13:13:07 +00:00
|
|
|
.rpc_get_block_streaming(&block.hash, Some(order_stream.order(i as u64)))
|
|
|
|
|
.await
|
|
|
|
|
.unwrap_or_else(|e| error_stream(i, e))
|
|
|
|
|
.scan(block_offset, move |chunk_offset, chunk| {
|
|
|
|
|
let r = match chunk {
|
|
|
|
|
Ok(chunk_bytes) => {
|
|
|
|
|
let chunk_len = chunk_bytes.len() as u64;
|
|
|
|
|
let r = if *chunk_offset >= end {
|
|
|
|
|
// The current chunk is after the part we want to read.
|
|
|
|
|
// Returning None here will stop the scan, the rest of the
|
|
|
|
|
// stream will be ignored
|
|
|
|
|
None
|
|
|
|
|
} else if *chunk_offset + chunk_len <= begin {
|
|
|
|
|
// The current chunk is before the part we want to read.
|
|
|
|
|
// We return a None that will be removed by the filter_map
|
|
|
|
|
// below.
|
|
|
|
|
Some(None)
|
|
|
|
|
} else {
|
|
|
|
|
// The chunk has an intersection with the requested range
|
|
|
|
|
let start_in_chunk = if *chunk_offset > begin {
|
|
|
|
|
0
|
|
|
|
|
} else {
|
|
|
|
|
begin - *chunk_offset
|
|
|
|
|
};
|
|
|
|
|
let end_in_chunk = if *chunk_offset + chunk_len < end {
|
|
|
|
|
chunk_len
|
|
|
|
|
} else {
|
|
|
|
|
end - *chunk_offset
|
|
|
|
|
};
|
|
|
|
|
Some(Some(Ok(chunk_bytes
|
|
|
|
|
.slice(start_in_chunk as usize..end_in_chunk as usize))))
|
|
|
|
|
};
|
|
|
|
|
*chunk_offset += chunk_bytes.len() as u64;
|
|
|
|
|
r
|
|
|
|
|
}
|
|
|
|
|
Err(e) => Some(Some(Err(e))),
|
|
|
|
|
};
|
|
|
|
|
futures::future::ready(r)
|
|
|
|
|
})
|
|
|
|
|
.filter_map(futures::future::ready)
|
2022-01-13 14:29:39 +00:00
|
|
|
}
|
|
|
|
|
})
|
2022-09-13 13:13:07 +00:00
|
|
|
.buffered(2)
|
|
|
|
|
.flatten();
|
2022-01-13 14:29:39 +00:00
|
|
|
|
|
|
|
|
hyper::body::Body::wrap_stream(body_stream)
|
|
|
|
|
}
|
2022-09-13 13:13:07 +00:00
|
|
|
|
|
|
|
|
fn error_stream(i: usize, e: garage_util::error::Error) -> ByteStream {
|
|
|
|
|
Box::pin(futures::stream::once(async move {
|
|
|
|
|
Err(std::io::Error::new(
|
|
|
|
|
std::io::ErrorKind::Other,
|
|
|
|
|
format!("Could not get block {}: {}", i, e),
|
|
|
|
|
))
|
|
|
|
|
}))
|
|
|
|
|
}
|
