use std::sync::Arc;
use std::time::Duration;
use prost::Message;
use tokio::sync::Mutex;
use storj_proto::metainfo::{
self, BatchRequest, BatchRequestItem, BeginCopyObjectRequest, BeginDeleteObjectRequest,
BeginMoveObjectRequest, BeginObjectRequest, BeginSegmentRequest, CommitObjectRequest,
CommitSegmentRequest, CompressedBatchResponse, CreateBucketRequest, DeleteBucketRequest,
DownloadObjectRequest, DownloadSegmentRequest, FinishCopyObjectRequest,
FinishMoveObjectRequest, GetBucketObjectLockConfigurationRequest, GetBucketRequest,
GetObjectLegalHoldRequest, GetObjectRequest, GetObjectRetentionRequest, ListBucketsRequest,
ListObjectsRequest, ListPendingObjectStreamsRequest, ListSegmentsRequest,
MakeInlineSegmentRequest, ObjectListItemIncludes, ProjectInfoRequest, ProjectInfoResponse,
Range, RequestHeader, RetryBeginSegmentPiecesRequest, RevokeApiKeyRequest, SegmentPosition,
SetBucketObjectLockConfigurationRequest, SetObjectLegalHoldRequest, SetObjectRetentionRequest,
UpdateObjectMetadataRequest, batch_request_item, batch_response_item,
};
use storj_proto::rpc;
use storj_rpc::transport::{ConnectionOptions, Transport, dial_with_options};
use storj_rpc::{Conn, Identity, NodeUrl, parse_node_url};
use crate::bucket::{bucket_from_list_item, bucket_from_proto, proto_timestamp};
use crate::error::{Error, ErrorKind, Result};
use crate::object_lock::{
lock_config_from_proto, lock_config_to_proto, retention_from_proto, retention_to_proto,
};
use crate::types::{
Bucket, BucketObjectLockConfiguration, Config, CreateBucketOptions, CustomMetadata, Object,
ObjectChecksum, Retention, SystemMetadata,
};
use storj_proto::{decode_batch_response, encode_batch_request};
pub(crate) const RPC_CANCELED: u64 = 1;
pub(crate) const RPC_INVALID_ARGUMENT: u64 = 3;
pub(crate) const RPC_NOT_FOUND: u64 = 5;
pub(crate) const RPC_ALREADY_EXISTS: u64 = 6;
pub(crate) const RPC_PERMISSION_DENIED: u64 = 7;
pub(crate) const RPC_RESOURCE_EXHAUSTED: u64 = 8;
pub(crate) const RPC_FAILED_PRECONDITION: u64 = 9;
pub(crate) const RPC_UNAVAILABLE: u64 = 14;
pub(crate) const RPC_OBJECT_LOCK_ENDPOINTS_DISABLED: u64 = 10000;
pub(crate) const RPC_OBJECT_LOCK_DISABLED_FOR_PROJECT: u64 = 10001;
pub(crate) const RPC_OBJECT_LOCK_INVALID_BUCKET_STATE: u64 = 10002;
pub(crate) const RPC_OBJECT_LOCK_BUCKET_CONFIG_MISSING: u64 = 10003;
pub(crate) const RPC_OBJECT_LOCK_OBJECT_RETENTION_MISSING: u64 = 10004;
pub(crate) const RPC_OBJECT_LOCK_OBJECT_PROTECTED: u64 = 10005;
pub(crate) const RPC_OBJECT_LOCK_INVALID_OBJECT_STATE: u64 = 10006;
pub(crate) const RPC_OBJECT_LOCK_INVALID_BUCKET_CONFIG: u64 = 10007;
pub(crate) const RPC_OBJECT_LOCK_UPLOAD_WITH_TTL: u64 = 10008;
pub(crate) const RPC_OBJECT_LOCK_UPLOAD_WITH_TTL_API_KEY: u64 = 10009;
pub(crate) const RPC_OBJECT_LOCK_UPLOAD_WITH_TTL_AND_DEFAULT_RETENTION: u64 = 10010;
pub(crate) const RPC_OBJECT_LOCK_UPLOAD_WITH_TTL_API_KEY_AND_DEFAULT_RETENTION: u64 = 10011;
const RETENTION_NOT_FOUND_MSG: &str = "object has no retention configuration";
const SATELLITE_ATTEMPTS: u32 = 3;
const LIST_BUCKETS_LIMIT: i32 = 1000;
const LIST_OBJECTS_LIMIT: i32 = 1000;
pub(crate) struct ListObjectsParams {
pub encrypted_prefix: Vec<u8>,
pub encrypted_cursor: Vec<u8>,
pub recursive: bool,
pub include_custom: bool,
pub include_system: bool,
pub arbitrary_prefix: bool,
}
type SatelliteStream = Transport;
const MAX_SATELLITE_CONNS: usize = 8;
pub(crate) struct MetainfoClient {
node: NodeUrl,
api_key: Vec<u8>,
user_agent: Vec<u8>,
identity: Identity,
dial_timeout: Duration,
message_timeout: Duration,
connection_options: ConnectionOptions,
satellite_cert: Mutex<Vec<u8>>,
idle: std::sync::Mutex<Vec<Conn<SatelliteStream>>>,
slots: Arc<tokio::sync::Semaphore>,
}
impl MetainfoClient {
pub(crate) fn satellite_label(&self) -> String {
self.node.to_string()
}
pub(crate) async fn connect(node: NodeUrl, api_key: Vec<u8>, config: &Config) -> Result<Self> {
let identity = match &config.tls_identity {
Some(identity) => identity.identity().clone(),
None => Identity::generate().map_err(map_identity_err)?,
};
let client = Self {
node,
api_key,
user_agent: config
.user_agent
.as_deref()
.unwrap_or("")
.as_bytes()
.to_vec(),
identity,
dial_timeout: config.dial_timeout_or_default(),
message_timeout: config.message_timeout_or_default(),
connection_options: config.connection_options(),
satellite_cert: Mutex::new(Vec::new()),
idle: std::sync::Mutex::new(Vec::new()),
slots: Arc::new(tokio::sync::Semaphore::new(MAX_SATELLITE_CONNS)),
};
client.ensure_connected().await?;
Ok(client)
}
pub(crate) async fn close(&self) {
self.idle_guard().clear();
}
fn idle_guard(&self) -> std::sync::MutexGuard<'_, Vec<Conn<SatelliteStream>>> {
self.idle.lock().unwrap_or_else(|e| e.into_inner())
}
#[cfg(test)]
pub(crate) fn disconnected_placeholder() -> Self {
Self {
node: NodeUrl {
id: storj_rpc::NodeId::ZERO,
address: "127.0.0.1:1".into(),
},
api_key: Vec::new(),
user_agent: Vec::new(),
identity: Identity::generate().expect("ephemeral identity"),
dial_timeout: Duration::from_secs(1),
message_timeout: Duration::from_secs(1),
connection_options: ConnectionOptions::default(),
satellite_cert: Mutex::new(Vec::new()),
idle: std::sync::Mutex::new(Vec::new()),
slots: Arc::new(tokio::sync::Semaphore::new(MAX_SATELLITE_CONNS)),
}
}
pub(crate) fn identity(&self) -> &Identity {
&self.identity
}
pub(crate) fn api_key(&self) -> &[u8] {
&self.api_key
}
pub(crate) async fn satellite_cert(&self) -> Vec<u8> {
self.satellite_cert.lock().await.clone()
}
fn header(&self) -> RequestHeader {
RequestHeader::new(self.api_key.clone(), self.user_agent.clone())
}
async fn ensure_connected(&self) -> Result<()> {
let empty = self.idle_guard().is_empty();
if empty {
let conn = self.dial().await?;
self.idle_guard().push(conn);
}
Ok(())
}
async fn dial(&self) -> Result<Conn<SatelliteStream>> {
let transport = dial_with_options(
&self.identity,
self.node.id,
&self.node.address,
self.dial_timeout,
&self.connection_options,
)
.await?;
*self.satellite_cert.lock().await = transport.peer_cert.clone();
Ok(Conn::new(transport).with_timeout(self.message_timeout))
}
async fn invoke(&self, rpc: &str, request: &[u8], bucket: &str, key: &str) -> Result<Vec<u8>> {
self.invoke_with(rpc, request, bucket, key, is_idempotent_rpc(rpc))
.await
}
async fn invoke_with(
&self,
rpc: &str,
request: &[u8],
bucket: &str,
key: &str,
idempotent: bool,
) -> Result<Vec<u8>> {
let attempts = if idempotent { SATELLITE_ATTEMPTS } else { 1 };
let mut last_err = None;
for attempt in 0..attempts {
match self.invoke_once(rpc, request).await {
Ok(body) => return Ok(body),
Err(e) if attempt + 1 < attempts && is_retryable(&e) => {
last_err = Some(e);
let base = 200 * 2u64.pow(attempt);
let jitter = rand::random::<u64>() % (base / 2 + 1);
let backoff = Duration::from_millis(base + jitter);
tokio::time::sleep(backoff.min(Duration::from_secs(2))).await;
}
Err(e) => return Err(map_rpc_error(rpc, e, bucket, key)),
}
}
Err(map_rpc_error(
rpc,
last_err.expect("retry loop ran"),
bucket,
key,
))
}
async fn invoke_once(
&self,
rpc: &str,
request: &[u8],
) -> std::result::Result<Vec<u8>, storj_rpc::Error> {
let _permit = self
.slots
.acquire()
.await
.map_err(|_| storj_rpc::Error::Closed)?;
let idle = self.idle_guard().pop();
let mut conn = match idle {
Some(c) => c,
None => self
.dial()
.await
.map_err(|e| storj_rpc::Error::Io(std::io::Error::other(e.to_string())))?,
};
let result = conn.invoke(rpc, request).await;
let keep = match &result {
Ok(_) => !conn.is_poisoned(),
Err(e) => !is_conn_dead(e) && !conn.is_poisoned(),
};
if keep {
self.idle_guard().push(conn);
}
result
}
pub(crate) async fn project_info(&self) -> Result<ProjectInfoResponse> {
let req = ProjectInfoRequest {
header: Some(self.header()),
};
let body = self
.invoke(rpc::PROJECT_INFO, &req.encode_to_vec(), "", "")
.await?;
ProjectInfoResponse::decode(body.as_slice()).map_err(map_decode)
}
pub(crate) async fn create_bucket(
&self,
name: &str,
opts: CreateBucketOptions,
) -> Result<Bucket> {
let req = CreateBucketRequest {
header: Some(self.header()),
name: name.as_bytes().to_vec(),
object_lock_enabled: opts.object_lock_enabled,
placement: opts.placement,
..Default::default()
};
let body = self
.invoke(rpc::CREATE_BUCKET, &req.encode_to_vec(), name, "")
.await?;
let resp = metainfo::CreateBucketResponse::decode(body.as_slice()).map_err(map_decode)?;
bucket_from_proto(resp.bucket, name)
}
pub(crate) async fn get_bucket(&self, name: &str) -> Result<Bucket> {
let req = GetBucketRequest {
header: Some(self.header()),
name: name.as_bytes().to_vec(),
};
let body = self
.invoke(rpc::GET_BUCKET, &req.encode_to_vec(), name, "")
.await?;
let resp = metainfo::GetBucketResponse::decode(body.as_slice()).map_err(map_decode)?;
bucket_from_proto(resp.bucket, name)
}
pub(crate) async fn delete_bucket(&self, name: &str, delete_all: bool) -> Result<Bucket> {
let req = DeleteBucketRequest {
header: Some(self.header()),
name: name.as_bytes().to_vec(),
delete_all,
bypass_governance_retention: false,
};
let body = self
.invoke(rpc::DELETE_BUCKET, &req.encode_to_vec(), name, "")
.await?;
let resp = metainfo::DeleteBucketResponse::decode(body.as_slice()).map_err(map_decode)?;
match resp.bucket {
Some(b) if !b.name.is_empty() => bucket_from_proto(Some(b), name),
_ => Ok(Bucket {
name: name.to_owned(),
created: proto_timestamp(None),
}),
}
}
pub(crate) async fn list_buckets_page(
&self,
cursor: &str,
limit: i32,
) -> Result<(Vec<Bucket>, bool)> {
let req = ListBucketsRequest {
header: Some(self.header()),
cursor: cursor.as_bytes().to_vec(),
limit: if limit == 0 {
LIST_BUCKETS_LIMIT
} else {
limit
},
direction: metainfo::ListDirection::After as i32,
};
let body = self
.invoke(rpc::LIST_BUCKETS, &req.encode_to_vec(), "", "")
.await?;
let resp = metainfo::ListBucketsResponse::decode(body.as_slice()).map_err(map_decode)?;
let items = resp
.items
.into_iter()
.map(bucket_from_list_item)
.collect::<Result<Vec<_>>>()?;
Ok((items, resp.more))
}
async fn compressed_batch(
&self,
requests: Vec<BatchRequestItem>,
bucket: &str,
key: &str,
) -> Result<Vec<batch_response_item::Response>> {
let batch = BatchRequest {
header: Some(self.header()),
requests,
};
let idempotent = batch.requests.iter().all(is_idempotent_batch_item);
let wrapped = encode_batch_request(&batch);
let body = self
.invoke_with(
rpc::COMPRESSED_BATCH,
&wrapped.encode_to_vec(),
bucket,
key,
idempotent,
)
.await?;
let resp = CompressedBatchResponse::decode(body.as_slice()).map_err(map_decode)?;
let decoded = decode_batch_response(&resp)
.map_err(|e| Error::new(ErrorKind::Protocol, format!("CompressedBatch: {e}")))?;
decoded
.responses
.into_iter()
.map(|item| {
item.response.ok_or_else(|| {
Error::new(ErrorKind::Protocol, "empty CompressedBatch response item")
})
})
.collect()
}
fn expect_one(
mut items: Vec<batch_response_item::Response>,
what: &str,
) -> Result<batch_response_item::Response> {
if items.len() != 1 {
return Err(Error::new(
ErrorKind::Protocol,
format!("{what}: expected 1 batch response, got {}", items.len()),
));
}
Ok(items.remove(0))
}
#[allow(clippy::too_many_arguments)]
pub(crate) async fn begin_object(
&self,
bucket: &str,
encrypted_object_key: Vec<u8>,
expires: Option<std::time::SystemTime>,
encryption_parameters: Option<storj_proto::encryption::EncryptionParameters>,
retention: Option<metainfo::Retention>,
legal_hold: bool,
checksum: Option<&ObjectChecksum>,
) -> Result<metainfo::BeginObjectResponse> {
let (checksum_algorithm, is_checksum_composite) = checksum_header(checksum);
let req = BeginObjectRequest {
header: Some(self.header()),
bucket: bucket.as_bytes().to_vec(),
encrypted_object_key,
expires_at: expires.map(system_time_to_proto),
encryption_parameters,
retention,
legal_hold,
checksum_algorithm,
is_checksum_composite,
..Default::default()
};
let items = self
.compressed_batch(
vec![BatchRequestItem {
request: Some(batch_request_item::Request::ObjectBegin(req)),
}],
bucket,
"",
)
.await?;
match Self::expect_one(items, "BeginObject")? {
batch_response_item::Response::ObjectBegin(r) => Ok(r),
_ => Err(Error::new(
ErrorKind::Protocol,
"unexpected BeginObject response",
)),
}
}
pub(crate) async fn commit_object(
&self,
bucket: &str,
key: &str,
stream_id: Vec<u8>,
user: storj_uplink::upload::EncryptedUserData,
checksum: Option<&ObjectChecksum>,
) -> Result<metainfo::CommitObjectResponse> {
let (checksum_algorithm, is_checksum_composite) = checksum_header(checksum);
let req = CommitObjectRequest {
header: Some(self.header()),
stream_id,
encrypted_metadata: user.encrypted_metadata,
encrypted_metadata_nonce: user.encrypted_metadata_nonce.to_vec(),
encrypted_metadata_encrypted_key: user.encrypted_metadata_encrypted_key,
encrypted_etag: user.encrypted_etag,
skip_override_encrypted_metadata: false,
checksum_algorithm,
is_checksum_composite,
encrypted_checksum: user.encrypted_checksum,
..Default::default()
};
let items = self
.compressed_batch(
vec![BatchRequestItem {
request: Some(batch_request_item::Request::ObjectCommit(req)),
}],
bucket,
key,
)
.await?;
match Self::expect_one(items, "CommitObject")? {
batch_response_item::Response::ObjectCommit(r) => Ok(r),
_ => Err(Error::new(
ErrorKind::Protocol,
"unexpected CommitObject response",
)),
}
}
pub(crate) async fn begin_segment(
&self,
bucket: &str,
key: &str,
stream_id: Vec<u8>,
position: SegmentPosition,
max_order_limit: i64,
) -> Result<metainfo::BeginSegmentResponse> {
let req = BeginSegmentRequest {
header: Some(self.header()),
stream_id,
position: Some(position),
max_order_limit,
lite_request: false,
};
let items = self
.compressed_batch(
vec![BatchRequestItem {
request: Some(batch_request_item::Request::SegmentBegin(req)),
}],
bucket,
key,
)
.await?;
match Self::expect_one(items, "BeginSegment")? {
batch_response_item::Response::SegmentBegin(r) => Ok(r),
_ => Err(Error::new(
ErrorKind::Protocol,
"unexpected BeginSegment response",
)),
}
}
pub(crate) async fn retry_begin_segment_pieces(
&self,
bucket: &str,
key: &str,
segment_id: Vec<u8>,
retry_piece_numbers: Vec<i32>,
) -> Result<metainfo::RetryBeginSegmentPiecesResponse> {
let req = RetryBeginSegmentPiecesRequest {
header: Some(self.header()),
segment_id,
retry_piece_numbers,
};
let items = self
.compressed_batch(
vec![BatchRequestItem {
request: Some(batch_request_item::Request::SegmentBeginRetryPieces(req)),
}],
bucket,
key,
)
.await?;
match Self::expect_one(items, "RetryBeginSegmentPieces")? {
batch_response_item::Response::SegmentBeginRetryPieces(r) => Ok(r),
_ => Err(Error::new(
ErrorKind::Protocol,
"unexpected RetryBeginSegmentPieces response",
)),
}
}
pub(crate) async fn commit_segment(
&self,
bucket: &str,
key: &str,
req: CommitSegmentRequest,
) -> Result<metainfo::CommitSegmentResponse> {
let mut req = req;
req.header = Some(self.header());
let items = self
.compressed_batch(
vec![BatchRequestItem {
request: Some(batch_request_item::Request::SegmentCommit(req)),
}],
bucket,
key,
)
.await?;
match Self::expect_one(items, "CommitSegment")? {
batch_response_item::Response::SegmentCommit(r) => Ok(r),
_ => Err(Error::new(
ErrorKind::Protocol,
"unexpected CommitSegment response",
)),
}
}
pub(crate) async fn make_inline_segment(
&self,
bucket: &str,
key: &str,
req: MakeInlineSegmentRequest,
) -> Result<()> {
let mut req = req;
req.header = Some(self.header());
let items = self
.compressed_batch(
vec![BatchRequestItem {
request: Some(batch_request_item::Request::SegmentMakeInline(req)),
}],
bucket,
key,
)
.await?;
match Self::expect_one(items, "MakeInlineSegment")? {
batch_response_item::Response::SegmentMakeInline(_) => Ok(()),
_ => Err(Error::new(
ErrorKind::Protocol,
"unexpected MakeInlineSegment response",
)),
}
}
pub(crate) async fn download_object(
&self,
bucket: &str,
key: &str,
encrypted_object_key: Vec<u8>,
range: Option<Range>,
object_version: &[u8],
) -> Result<metainfo::DownloadObjectResponse> {
let req = DownloadObjectRequest {
header: Some(self.header()),
bucket: bucket.as_bytes().to_vec(),
encrypted_object_key,
range,
limit: 0,
object_version: object_version.to_vec(),
..Default::default()
};
let items = self
.compressed_batch(
vec![BatchRequestItem {
request: Some(batch_request_item::Request::ObjectDownload(req)),
}],
bucket,
key,
)
.await?;
match Self::expect_one(items, "DownloadObject")? {
batch_response_item::Response::ObjectDownload(r) => Ok(r),
_ => Err(Error::new(
ErrorKind::Protocol,
"unexpected DownloadObject response",
)),
}
}
pub(crate) async fn download_segment(
&self,
bucket: &str,
key: &str,
stream_id: Vec<u8>,
position: SegmentPosition,
) -> Result<metainfo::DownloadSegmentResponse> {
let req = DownloadSegmentRequest {
header: Some(self.header()),
stream_id,
cursor_position: Some(position),
..Default::default()
};
let items = self
.compressed_batch(
vec![BatchRequestItem {
request: Some(batch_request_item::Request::SegmentDownload(req)),
}],
bucket,
key,
)
.await?;
match Self::expect_one(items, "DownloadSegment")? {
batch_response_item::Response::SegmentDownload(r) => Ok(r),
_ => Err(Error::new(
ErrorKind::Protocol,
"unexpected DownloadSegment response",
)),
}
}
pub(crate) async fn list_segments(
&self,
bucket: &str,
key: &str,
stream_id: Vec<u8>,
cursor: Option<SegmentPosition>,
range: Option<Range>,
) -> Result<metainfo::ListSegmentsResponse> {
let req = ListSegmentsRequest {
header: Some(self.header()),
stream_id,
cursor_position: cursor,
limit: 0,
range,
};
let items = self
.compressed_batch(
vec![BatchRequestItem {
request: Some(batch_request_item::Request::SegmentList(req)),
}],
bucket,
key,
)
.await?;
match Self::expect_one(items, "ListSegments")? {
batch_response_item::Response::SegmentList(r) => Ok(r),
_ => Err(Error::new(
ErrorKind::Protocol,
"unexpected ListSegments response",
)),
}
}
pub(crate) async fn list_all_segments(
&self,
bucket: &str,
key: &str,
stream_id: Vec<u8>,
) -> Result<metainfo::ListSegmentsResponse> {
let mut out = self
.list_segments(bucket, key, stream_id.clone(), None, None)
.await?;
while out.more {
let cursor = out.items.last().and_then(|i| i.position);
let page = self
.list_segments(bucket, key, stream_id.clone(), cursor, None)
.await?;
if page.items.is_empty() {
break;
}
out.more = page.more;
if out.encryption_parameters.is_none() {
out.encryption_parameters = page.encryption_parameters;
}
out.items.extend(page.items);
}
Ok(out)
}
pub(crate) async fn list_pending_uploads(
&self,
bucket: &str,
encrypted_prefix: Vec<u8>,
encrypted_cursor: Vec<u8>,
arbitrary_prefix: bool,
opts: &crate::types::ListUploadsOptions,
) -> Result<metainfo::ListObjectsResponse> {
let req = ListObjectsRequest {
header: Some(self.header()),
bucket: bucket.as_bytes().to_vec(),
delimiter: if opts.recursive {
Vec::new()
} else {
b"/".to_vec()
},
encrypted_prefix,
encrypted_cursor,
arbitrary_prefix,
recursive: opts.recursive,
limit: 0,
status: metainfo::object::Status::Uploading as i32,
object_includes: Some(metainfo::ObjectListItemIncludes {
metadata: opts.custom,
exclude_system_metadata: !opts.system,
..Default::default()
}),
use_object_includes: true,
..Default::default()
};
let items = self
.compressed_batch(
vec![BatchRequestItem {
request: Some(batch_request_item::Request::ObjectList(req)),
}],
bucket,
"",
)
.await?;
match Self::expect_one(items, "ListObjects")? {
batch_response_item::Response::ObjectList(r) => Ok(r),
_ => Err(Error::new(
ErrorKind::Protocol,
"unexpected ListObjects response",
)),
}
}
pub(crate) async fn list_pending_object_streams(
&self,
bucket: &str,
encrypted_object_key: Vec<u8>,
stream_id_cursor: Vec<u8>,
) -> Result<metainfo::ListPendingObjectStreamsResponse> {
let req = ListPendingObjectStreamsRequest {
header: Some(self.header()),
bucket: bucket.as_bytes().to_vec(),
encrypted_object_key,
stream_id_cursor,
limit: 0,
};
let items = self
.compressed_batch(
vec![BatchRequestItem {
request: Some(batch_request_item::Request::ObjectListPendingStreams(req)),
}],
bucket,
"",
)
.await?;
match Self::expect_one(items, "ListPendingObjectStreams")? {
batch_response_item::Response::ObjectListPendingStreams(r) => Ok(r),
_ => Err(Error::new(
ErrorKind::Protocol,
"unexpected ListPendingObjectStreams response",
)),
}
}
pub(crate) async fn begin_delete_object(
&self,
bucket: &str,
encrypted_object_key: Vec<u8>,
stream_id: Vec<u8>,
status: i32,
) -> Result<metainfo::BeginDeleteObjectResponse> {
let req = BeginDeleteObjectRequest {
header: Some(self.header()),
bucket: bucket.as_bytes().to_vec(),
encrypted_object_key,
stream_id,
status,
..Default::default()
};
let items = self
.compressed_batch(
vec![BatchRequestItem {
request: Some(batch_request_item::Request::ObjectBeginDelete(req)),
}],
bucket,
"",
)
.await?;
match Self::expect_one(items, "BeginDeleteObject")? {
batch_response_item::Response::ObjectBeginDelete(r) => Ok(r),
_ => Err(Error::new(
ErrorKind::Protocol,
"unexpected BeginDeleteObject response",
)),
}
}
pub(crate) async fn get_object(
&self,
bucket: &str,
key: &str,
encrypted_object_key: Vec<u8>,
) -> Result<metainfo::GetObjectResponse> {
let req = GetObjectRequest {
header: Some(self.header()),
bucket: bucket.as_bytes().to_vec(),
encrypted_object_key,
redundancy_scheme_per_segment: true,
..Default::default()
};
let items = self
.compressed_batch(
vec![BatchRequestItem {
request: Some(batch_request_item::Request::ObjectGet(req)),
}],
bucket,
key,
)
.await?;
match Self::expect_one(items, "GetObject")? {
batch_response_item::Response::ObjectGet(r) => Ok(r),
_ => Err(Error::new(
ErrorKind::Protocol,
"unexpected GetObject response",
)),
}
}
pub(crate) async fn list_objects(
&self,
bucket: &str,
params: ListObjectsParams,
) -> Result<metainfo::ListObjectsResponse> {
let req = ListObjectsRequest {
header: Some(self.header()),
bucket: bucket.as_bytes().to_vec(),
delimiter: if params.recursive {
Vec::new()
} else {
b"/".to_vec()
},
encrypted_prefix: params.encrypted_prefix,
encrypted_cursor: params.encrypted_cursor,
recursive: params.recursive,
limit: LIST_OBJECTS_LIMIT,
object_includes: Some(ObjectListItemIncludes {
metadata: params.include_custom,
exclude_system_metadata: !params.include_system,
..Default::default()
}),
use_object_includes: true,
arbitrary_prefix: params.arbitrary_prefix,
..Default::default()
};
let items = self
.compressed_batch(
vec![BatchRequestItem {
request: Some(batch_request_item::Request::ObjectList(req)),
}],
bucket,
"",
)
.await?;
match Self::expect_one(items, "ListObjects")? {
batch_response_item::Response::ObjectList(r) => Ok(r),
_ => Err(Error::new(
ErrorKind::Protocol,
"unexpected ListObjects response",
)),
}
}
pub(crate) async fn begin_copy_object(
&self,
src_bucket: &str,
src_key: &str,
encrypted_object_key: Vec<u8>,
new_bucket: &str,
new_encrypted_object_key: Vec<u8>,
) -> Result<metainfo::BeginCopyObjectResponse> {
let req = BeginCopyObjectRequest {
header: Some(self.header()),
bucket: src_bucket.as_bytes().to_vec(),
encrypted_object_key,
new_bucket: new_bucket.as_bytes().to_vec(),
new_encrypted_object_key,
..Default::default()
};
let body = self
.invoke(
rpc::BEGIN_COPY_OBJECT,
&req.encode_to_vec(),
src_bucket,
src_key,
)
.await?;
metainfo::BeginCopyObjectResponse::decode(body.as_slice()).map_err(map_decode)
}
pub(crate) async fn finish_copy_object(
&self,
dst_bucket: &str,
dst_key: &str,
mut req: FinishCopyObjectRequest,
) -> Result<metainfo::FinishCopyObjectResponse> {
req.header = Some(self.header());
let body = self
.invoke(
rpc::FINISH_COPY_OBJECT,
&req.encode_to_vec(),
dst_bucket,
dst_key,
)
.await?;
metainfo::FinishCopyObjectResponse::decode(body.as_slice()).map_err(map_decode)
}
pub(crate) async fn begin_move_object(
&self,
src_bucket: &str,
src_key: &str,
encrypted_object_key: Vec<u8>,
new_bucket: &str,
new_encrypted_object_key: Vec<u8>,
) -> Result<metainfo::BeginMoveObjectResponse> {
let req = BeginMoveObjectRequest {
header: Some(self.header()),
bucket: src_bucket.as_bytes().to_vec(),
encrypted_object_key,
new_bucket: new_bucket.as_bytes().to_vec(),
new_encrypted_object_key,
};
let body = self
.invoke(
rpc::BEGIN_MOVE_OBJECT,
&req.encode_to_vec(),
src_bucket,
src_key,
)
.await?;
metainfo::BeginMoveObjectResponse::decode(body.as_slice()).map_err(map_decode)
}
pub(crate) async fn finish_move_object(
&self,
src_bucket: &str,
src_key: &str,
mut req: FinishMoveObjectRequest,
) -> Result<()> {
req.header = Some(self.header());
let body = self
.invoke(
rpc::FINISH_MOVE_OBJECT,
&req.encode_to_vec(),
src_bucket,
src_key,
)
.await?;
let _ = metainfo::FinishMoveObjectResponse::decode(body.as_slice()).map_err(map_decode)?;
Ok(())
}
pub(crate) async fn update_object_metadata(
&self,
bucket: &str,
key: &str,
encrypted_object_key: Vec<u8>,
stream_id: Vec<u8>,
user: storj_uplink::upload::EncryptedUserData,
checksum: (i32, bool),
) -> Result<()> {
let req = UpdateObjectMetadataRequest {
header: Some(self.header()),
bucket: bucket.as_bytes().to_vec(),
encrypted_object_key,
stream_id,
encrypted_metadata: user.encrypted_metadata,
encrypted_metadata_nonce: user.encrypted_metadata_nonce.to_vec(),
encrypted_metadata_encrypted_key: user.encrypted_metadata_encrypted_key,
encrypted_etag: user.encrypted_etag,
set_encrypted_etag: false,
includes: Some(metainfo::ObjectMetadataIncludes {
custom: true,
checksum: true,
etag: false,
}),
checksum_algorithm: checksum.0,
is_checksum_composite: checksum.1,
encrypted_checksum: user.encrypted_checksum,
..Default::default()
};
let body = self
.invoke(
rpc::UPDATE_OBJECT_METADATA,
&req.encode_to_vec(),
bucket,
key,
)
.await?;
let _ =
metainfo::UpdateObjectMetadataResponse::decode(body.as_slice()).map_err(map_decode)?;
Ok(())
}
pub(crate) async fn revoke_api_key(&self, api_key: Vec<u8>) -> Result<()> {
let req = RevokeApiKeyRequest {
header: Some(self.header()),
api_key,
};
let body = self
.invoke(rpc::REVOKE_API_KEY, &req.encode_to_vec(), "", "")
.await?;
let _ = metainfo::RevokeApiKeyResponse::decode(body.as_slice()).map_err(map_decode)?;
Ok(())
}
pub(crate) async fn get_object_retention(
&self,
bucket: &str,
encrypted_object_key: &[u8],
object_version: &[u8],
key: &str,
) -> Result<Option<Retention>> {
let req = GetObjectRetentionRequest {
header: Some(self.header()),
bucket: bucket.as_bytes().to_vec(),
encrypted_object_key: encrypted_object_key.to_vec(),
object_version: object_version.to_vec(),
};
match self
.invoke(rpc::GET_OBJECT_RETENTION, &req.encode_to_vec(), bucket, key)
.await
{
Ok(body) => {
let resp = metainfo::GetObjectRetentionResponse::decode(body.as_slice())
.map_err(map_decode)?;
match resp.retention {
Some(r) => Ok(Some(retention_from_proto(r)?)),
None => Ok(None),
}
}
Err(e) if is_retention_not_found(&e) => Ok(None),
Err(e) => Err(e),
}
}
pub(crate) async fn set_object_retention(
&self,
bucket: &str,
encrypted_object_key: &[u8],
object_version: &[u8],
retention: &Retention,
bypass_governance_retention: bool,
key: &str,
) -> Result<()> {
let req = SetObjectRetentionRequest {
header: Some(self.header()),
bucket: bucket.as_bytes().to_vec(),
encrypted_object_key: encrypted_object_key.to_vec(),
object_version: object_version.to_vec(),
retention: Some(retention_to_proto(retention)),
bypass_governance_retention,
};
self.invoke(rpc::SET_OBJECT_RETENTION, &req.encode_to_vec(), bucket, key)
.await?;
Ok(())
}
pub(crate) async fn get_object_legal_hold(
&self,
bucket: &str,
encrypted_object_key: &[u8],
object_version: &[u8],
key: &str,
) -> Result<bool> {
let req = GetObjectLegalHoldRequest {
header: Some(self.header()),
bucket: bucket.as_bytes().to_vec(),
encrypted_object_key: encrypted_object_key.to_vec(),
object_version: object_version.to_vec(),
};
let body = self
.invoke(
rpc::GET_OBJECT_LEGAL_HOLD,
&req.encode_to_vec(),
bucket,
key,
)
.await?;
let resp =
metainfo::GetObjectLegalHoldResponse::decode(body.as_slice()).map_err(map_decode)?;
Ok(resp.enabled)
}
pub(crate) async fn set_object_legal_hold(
&self,
bucket: &str,
encrypted_object_key: &[u8],
object_version: &[u8],
enabled: bool,
key: &str,
) -> Result<()> {
let req = SetObjectLegalHoldRequest {
header: Some(self.header()),
bucket: bucket.as_bytes().to_vec(),
encrypted_object_key: encrypted_object_key.to_vec(),
object_version: object_version.to_vec(),
enabled,
};
self.invoke(
rpc::SET_OBJECT_LEGAL_HOLD,
&req.encode_to_vec(),
bucket,
key,
)
.await?;
Ok(())
}
pub(crate) async fn get_bucket_object_lock_configuration(
&self,
bucket: &str,
) -> Result<BucketObjectLockConfiguration> {
let req = GetBucketObjectLockConfigurationRequest {
header: Some(self.header()),
name: bucket.as_bytes().to_vec(),
};
let body = self
.invoke(
rpc::GET_BUCKET_OBJECT_LOCK_CONFIGURATION,
&req.encode_to_vec(),
bucket,
"",
)
.await?;
let resp = metainfo::GetBucketObjectLockConfigurationResponse::decode(body.as_slice())
.map_err(map_decode)?;
let Some(cfg) = resp.configuration else {
return Err(Error::new(
ErrorKind::Protocol,
"satellite returned no Object Lock configuration",
));
};
lock_config_from_proto(cfg)
}
pub(crate) async fn set_bucket_object_lock_configuration(
&self,
bucket: &str,
config: &BucketObjectLockConfiguration,
) -> Result<()> {
let req = SetBucketObjectLockConfigurationRequest {
header: Some(self.header()),
name: bucket.as_bytes().to_vec(),
configuration: Some(lock_config_to_proto(config)),
};
self.invoke(
rpc::SET_BUCKET_OBJECT_LOCK_CONFIGURATION,
&req.encode_to_vec(),
bucket,
"",
)
.await?;
Ok(())
}
}
fn checksum_header(checksum: Option<&ObjectChecksum>) -> (i32, bool) {
checksum
.map(|cs| (cs.algorithm.to_proto(), cs.composite))
.unwrap_or_default()
}
fn system_time_to_proto(t: std::time::SystemTime) -> prost_types::Timestamp {
let d = t.duration_since(std::time::UNIX_EPOCH).unwrap_or_default();
prost_types::Timestamp {
seconds: d.as_secs() as i64,
nanos: d.subsec_nanos() as i32,
}
}
pub(crate) fn object_from_proto(pb: Option<metainfo::Object>, plaintext_key: &str) -> Object {
let (created, expires, content_length, version) = match &pb {
Some(o) => (
o.created_at.map(|t| proto_timestamp(Some(t))),
o.expires_at.map(|t| proto_timestamp(Some(t))),
o.plain_size,
o.object_version.clone(),
),
None => (None, None, 0, Vec::new()),
};
Object {
key: plaintext_key.to_owned(),
is_prefix: false,
version,
system: SystemMetadata {
created,
expires,
content_length,
},
custom: CustomMetadata::new(),
}
}
fn is_idempotent_rpc(rpc: &str) -> bool {
matches!(
rpc,
rpc::PROJECT_INFO
| rpc::GET_BUCKET
| rpc::LIST_BUCKETS
| rpc::GET_OBJECT_RETENTION
| rpc::GET_OBJECT_LEGAL_HOLD
| rpc::GET_BUCKET_OBJECT_LOCK_CONFIGURATION
)
}
fn is_idempotent_batch_item(item: &BatchRequestItem) -> bool {
use batch_request_item::Request as R;
matches!(
item.request,
Some(
R::BucketGet(_)
| R::BucketList(_)
| R::ObjectGet(_)
| R::ObjectList(_)
| R::ObjectListPendingStreams(_)
| R::ObjectDownload(_)
| R::SegmentDownload(_)
| R::SegmentList(_)
)
)
}
fn is_retryable(err: &storj_rpc::Error) -> bool {
match err {
storj_rpc::Error::Io(_)
| storj_rpc::Error::Truncated
| storj_rpc::Error::Closed
| storj_rpc::Error::MuxPrefix { .. } => true,
storj_rpc::Error::Remote { code, message } => {
*code == RPC_UNAVAILABLE
|| (*code == RPC_RESOURCE_EXHAUSTED && message.contains("Too Many Requests"))
}
_ => false,
}
}
fn is_conn_dead(err: &storj_rpc::Error) -> bool {
!matches!(err, storj_rpc::Error::Remote { .. })
}
fn map_decode(e: prost::DecodeError) -> Error {
Error::new(ErrorKind::Protocol, format!("metainfo decode: {e}")).with_source(e)
}
pub(crate) fn map_identity_err(e: storj_rpc::IdentityError) -> Error {
match e {
storj_rpc::IdentityError::NodeIdRequired
| storj_rpc::IdentityError::NodeId
| storj_rpc::IdentityError::NodeUrl(_) => {
Error::new(ErrorKind::InvalidGrant, e.to_string()).with_source(e)
}
storj_rpc::IdentityError::Certificate(_) | storj_rpc::IdentityError::Signature => {
Error::new(ErrorKind::Protocol, e.to_string()).with_source(e)
}
}
}
pub(crate) fn parse_satellite_url(address: &str) -> Result<NodeUrl> {
parse_node_url(address).map_err(map_identity_err)
}
pub(crate) fn map_rpc_error(rpc: &str, err: storj_rpc::Error, bucket: &str, key: &str) -> Error {
match err {
storj_rpc::Error::Remote { code, message } => map_remote(rpc, code, &message, bucket, key),
storj_rpc::Error::Io(e) => Error::from(e),
other => Error::new(ErrorKind::Protocol, other.to_string()).with_source(other),
}
}
const RPC_UNAUTHENTICATED: u64 = 16;
fn map_remote(rpc: &str, code: u64, message: &str, bucket: &str, key: &str) -> Error {
let lower = message.to_ascii_lowercase();
match code {
RPC_CANCELED => Error::new(ErrorKind::Canceled, message),
RPC_INVALID_ARGUMENT if rpc == rpc::CREATE_BUCKET || lower.contains("bucket name") => {
Error::new(
ErrorKind::BucketNameInvalid,
format!("bucket name invalid ({bucket:?})"),
)
}
RPC_INVALID_ARGUMENT
if !key.is_empty()
&& (lower.contains("object key") || lower.contains("encrypted path")) =>
{
Error::new(
ErrorKind::ObjectKeyInvalid,
format!("object key invalid ({key:?})"),
)
}
RPC_INVALID_ARGUMENT => Error::new(ErrorKind::Protocol, message),
RPC_NOT_FOUND => {
if lower.starts_with("bucket not found") {
let name = bucket_from_not_found(message).unwrap_or(bucket);
Error::new(
ErrorKind::BucketNotFound,
format!("bucket not found ({name:?})"),
)
} else if lower.starts_with("object not found") {
Error::new(
ErrorKind::ObjectNotFound,
format!("object not found ({key:?})"),
)
} else if rpc == rpc::GET_BUCKET || rpc == rpc::DELETE_BUCKET {
Error::new(
ErrorKind::BucketNotFound,
format!("bucket not found ({bucket:?})"),
)
} else {
Error::new(ErrorKind::Protocol, message)
}
}
RPC_ALREADY_EXISTS => Error::new(
ErrorKind::BucketAlreadyExists,
format!("bucket already exists ({bucket:?})"),
),
RPC_PERMISSION_DENIED => Error::new(
ErrorKind::PermissionDenied,
format!("permission denied ({message})"),
),
RPC_RESOURCE_EXHAUSTED => {
if message.ends_with("Exceeded Usage Limit") {
Error::new(ErrorKind::BandwidthLimitExceeded, message)
} else if message.ends_with("Too Many Requests") {
Error::new(ErrorKind::TooManyRequests, message)
} else if message.contains("Exceeded Storage Limit") {
Error::new(ErrorKind::StorageLimitExceeded, message)
} else if message.contains("Exceeded Segments Limit") {
Error::new(ErrorKind::SegmentsLimitExceeded, message)
} else {
Error::new(ErrorKind::Protocol, message)
}
}
RPC_FAILED_PRECONDITION if rpc == rpc::DELETE_BUCKET || lower.contains("not empty") => {
Error::new(
ErrorKind::BucketNotEmpty,
format!("bucket not empty ({bucket:?})"),
)
}
RPC_UNAUTHENTICATED => Error::new(
ErrorKind::PermissionDenied,
format!("permission denied ({message})"),
),
RPC_OBJECT_LOCK_ENDPOINTS_DISABLED => {
Error::new(ErrorKind::Protocol, "object lock is not enabled")
}
RPC_OBJECT_LOCK_DISABLED_FOR_PROJECT => Error::new(
ErrorKind::Protocol,
"object lock is not enabled for this project",
),
RPC_OBJECT_LOCK_INVALID_BUCKET_STATE => Error::new(
ErrorKind::Protocol,
"object lock requires bucket versioning to be enabled",
),
RPC_OBJECT_LOCK_BUCKET_CONFIG_MISSING => Error::new(
ErrorKind::Protocol,
"object lock is not enabled for this bucket",
),
RPC_OBJECT_LOCK_OBJECT_RETENTION_MISSING => {
Error::new(ErrorKind::Protocol, RETENTION_NOT_FOUND_MSG)
}
RPC_OBJECT_LOCK_OBJECT_PROTECTED => Error::new(
ErrorKind::Protocol,
"object is protected by Object Lock settings",
),
RPC_OBJECT_LOCK_INVALID_OBJECT_STATE => Error::new(
ErrorKind::Protocol,
"object state is invalid for Object Lock",
),
RPC_OBJECT_LOCK_INVALID_BUCKET_CONFIG => Error::new(
ErrorKind::Protocol,
"bucket object lock configuration is invalid",
),
RPC_OBJECT_LOCK_UPLOAD_WITH_TTL => Error::new(
ErrorKind::Protocol,
"cannot specify an object expiration time when uploading into an Object Lock enabled bucket",
),
RPC_OBJECT_LOCK_UPLOAD_WITH_TTL_API_KEY => Error::new(
ErrorKind::Protocol,
"cannot upload into an Object Lock enabled bucket using an API key that enforces an object expiration time",
),
RPC_OBJECT_LOCK_UPLOAD_WITH_TTL_AND_DEFAULT_RETENTION => Error::new(
ErrorKind::Protocol,
"cannot specify an object expiration time when uploading into a bucket with default retention settings",
),
RPC_OBJECT_LOCK_UPLOAD_WITH_TTL_API_KEY_AND_DEFAULT_RETENTION => Error::new(
ErrorKind::Protocol,
"cannot upload into a bucket with default retention settings using an API key that enforces an object expiration time",
),
_ => Error::new(
ErrorKind::Protocol,
format!("DRPC remote error (code {code}): {message}"),
),
}
}
fn is_retention_not_found(err: &Error) -> bool {
err.kind() == ErrorKind::Protocol && err.to_string().ends_with(RETENTION_NOT_FOUND_MSG)
}
fn bucket_from_not_found(message: &str) -> Option<&str> {
const PREFIX: &str = "bucket not found";
message
.strip_prefix(PREFIX)
.map(|rest| rest.trim_start_matches([':', ' ']))
.filter(|s| !s.is_empty())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn remote_not_found_is_bucket() {
let e = map_remote("", RPC_NOT_FOUND, "bucket not found: logs", "logs", "");
assert_eq!(e.kind(), ErrorKind::BucketNotFound);
assert!(e.to_string().contains("logs"));
}
#[test]
fn remote_already_exists() {
let e = map_remote("", RPC_ALREADY_EXISTS, "exists", "photos", "");
assert_eq!(e.kind(), ErrorKind::BucketAlreadyExists);
assert!(e.to_string().contains("photos"));
}
#[test]
fn remote_failed_precondition_not_empty() {
let e = map_remote("", RPC_FAILED_PRECONDITION, "not empty", "b", "");
assert_eq!(e.kind(), ErrorKind::BucketNotEmpty);
}
#[test]
fn remote_resource_exhausted_kinds() {
assert_eq!(
map_remote("", RPC_RESOURCE_EXHAUSTED, "Exceeded Usage Limit", "", "").kind(),
ErrorKind::BandwidthLimitExceeded
);
assert_eq!(
map_remote("", RPC_RESOURCE_EXHAUSTED, "Too Many Requests", "", "").kind(),
ErrorKind::TooManyRequests
);
assert_eq!(
map_remote(
"",
RPC_RESOURCE_EXHAUSTED,
"project Exceeded Storage Limit",
"",
""
)
.kind(),
ErrorKind::StorageLimitExceeded
);
assert_eq!(
map_remote(
"",
RPC_RESOURCE_EXHAUSTED,
"project Exceeded Segments Limit",
"",
""
)
.kind(),
ErrorKind::SegmentsLimitExceeded
);
}
#[test]
fn node_id_required_is_invalid_grant() {
let e = parse_satellite_url("us1.storj.io:7777").unwrap_err();
assert_eq!(e.kind(), ErrorKind::InvalidGrant);
assert!(
e.to_string()
.contains("node id is required in satelliteNodeURL")
);
}
#[test]
fn known_tardigrade_fills_id() {
let url = parse_satellite_url("us-central-1.tardigrade.io:7777").unwrap();
assert_eq!(
url.id.to_string(),
"12EayRS2V1kEsWESU9QMRseFhdxYxKicsiFmxrsLZHeLUtdps3S"
);
}
#[test]
fn object_lock_rpc_codes() {
assert_eq!(
map_remote("", RPC_OBJECT_LOCK_OBJECT_RETENTION_MISSING, "", "b", "k").kind(),
ErrorKind::Protocol
);
let e = map_remote("", RPC_OBJECT_LOCK_OBJECT_RETENTION_MISSING, "", "b", "k");
assert!(is_retention_not_found(&e), "{e}");
assert_eq!(
map_remote("", RPC_OBJECT_LOCK_BUCKET_CONFIG_MISSING, "", "b", "").to_string(),
"protocol: object lock is not enabled for this bucket"
);
assert_eq!(
map_remote("", RPC_OBJECT_LOCK_INVALID_BUCKET_CONFIG, "", "b", "").kind(),
ErrorKind::Protocol
);
assert_eq!(
map_remote("", RPC_OBJECT_LOCK_OBJECT_PROTECTED, "", "b", "k").kind(),
ErrorKind::Protocol
);
assert_eq!(
map_remote("", RPC_OBJECT_LOCK_UPLOAD_WITH_TTL, "", "b", "k").to_string(),
"protocol: cannot specify an object expiration time when uploading into an Object Lock enabled bucket"
);
assert_eq!(
map_remote("", RPC_OBJECT_LOCK_UPLOAD_WITH_TTL_API_KEY, "", "b", "k").to_string(),
"protocol: cannot upload into an Object Lock enabled bucket using an API key that enforces an object expiration time"
);
assert_eq!(
map_remote(
"",
RPC_OBJECT_LOCK_UPLOAD_WITH_TTL_AND_DEFAULT_RETENTION,
"",
"b",
"k"
)
.to_string(),
"protocol: cannot specify an object expiration time when uploading into a bucket with default retention settings"
);
assert_eq!(
map_remote(
"",
RPC_OBJECT_LOCK_UPLOAD_WITH_TTL_API_KEY_AND_DEFAULT_RETENTION,
"",
"b",
"k"
)
.to_string(),
"protocol: cannot upload into a bucket with default retention settings using an API key that enforces an object expiration time"
);
}
}