2019-05-24 12:16:36 +00:00
|
|
|
// Copyright (C) 2017 Author: Arun Raghavan <arun@arunraghavan.net>
|
|
|
|
//
|
2022-01-15 18:40:12 +00:00
|
|
|
// This Source Code Form is subject to the terms of the Mozilla Public License, v2.0.
|
|
|
|
// If a copy of the MPL was not distributed with this file, You can obtain one at
|
|
|
|
// <https://mozilla.org/MPL/2.0/>.
|
|
|
|
//
|
|
|
|
// SPDX-License-Identifier: MPL-2.0
|
2019-05-24 12:16:36 +00:00
|
|
|
|
2022-05-14 05:01:35 +00:00
|
|
|
use bytes::Bytes;
|
|
|
|
use futures::future;
|
|
|
|
use once_cell::sync::Lazy;
|
2019-05-24 12:16:36 +00:00
|
|
|
use std::sync::Mutex;
|
2022-03-16 07:10:28 +00:00
|
|
|
use std::time::Duration;
|
2019-05-24 12:16:36 +00:00
|
|
|
|
2023-03-31 08:43:36 +00:00
|
|
|
use aws_sdk_s3::{
|
|
|
|
config::{self, retry::RetryConfig, Credentials},
|
|
|
|
Client,
|
|
|
|
};
|
2019-05-24 12:16:36 +00:00
|
|
|
|
2021-06-03 18:20:54 +00:00
|
|
|
use gst::glib;
|
|
|
|
use gst::prelude::*;
|
2019-05-24 12:16:36 +00:00
|
|
|
use gst::subclass::prelude::*;
|
|
|
|
|
|
|
|
use gst_base::prelude::*;
|
2020-03-29 21:29:40 +00:00
|
|
|
use gst_base::subclass::base_src::CreateSuccess;
|
2019-05-24 12:16:36 +00:00
|
|
|
use gst_base::subclass::prelude::*;
|
|
|
|
|
|
|
|
use crate::s3url::*;
|
2022-05-14 05:01:35 +00:00
|
|
|
use crate::s3utils::{self, duration_from_millis, duration_to_millis, WaitError};
|
2019-05-24 12:16:36 +00:00
|
|
|
|
2022-05-14 05:01:35 +00:00
|
|
|
const DEFAULT_RETRY_ATTEMPTS: u32 = 5;
|
|
|
|
const DEFAULT_REQUEST_TIMEOUT_MSEC: u64 = 15000;
|
2022-03-16 07:10:28 +00:00
|
|
|
const DEFAULT_RETRY_DURATION_MSEC: u64 = 60_000;
|
|
|
|
|
2023-03-07 08:46:34 +00:00
|
|
|
#[derive(Default)]
|
2019-09-07 07:42:07 +00:00
|
|
|
#[allow(clippy::large_enum_variant)]
|
2019-05-24 12:16:36 +00:00
|
|
|
enum StreamingState {
|
2023-03-07 08:46:34 +00:00
|
|
|
#[default]
|
2019-05-24 12:16:36 +00:00
|
|
|
Stopped,
|
|
|
|
Started {
|
|
|
|
url: GstS3Url,
|
2022-05-14 05:01:35 +00:00
|
|
|
client: Client,
|
2019-05-24 12:16:36 +00:00
|
|
|
size: u64,
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
2021-09-27 13:49:12 +00:00
|
|
|
struct Settings {
|
|
|
|
url: Option<GstS3Url>,
|
|
|
|
access_key: Option<String>,
|
|
|
|
secret_access_key: Option<String>,
|
2022-06-16 07:16:28 +00:00
|
|
|
session_token: Option<String>,
|
2022-05-14 05:01:35 +00:00
|
|
|
retry_attempts: u32,
|
|
|
|
request_timeout: Duration,
|
2022-07-30 05:59:50 +00:00
|
|
|
endpoint_uri: Option<String>,
|
2022-05-14 05:01:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
impl Default for Settings {
|
|
|
|
fn default() -> Self {
|
|
|
|
let duration = Duration::from_millis(DEFAULT_REQUEST_TIMEOUT_MSEC);
|
|
|
|
Self {
|
|
|
|
url: None,
|
|
|
|
access_key: None,
|
|
|
|
secret_access_key: None,
|
2022-06-16 07:16:28 +00:00
|
|
|
session_token: None,
|
2022-05-14 05:01:35 +00:00
|
|
|
retry_attempts: DEFAULT_RETRY_ATTEMPTS,
|
|
|
|
request_timeout: duration,
|
2022-07-30 05:59:50 +00:00
|
|
|
endpoint_uri: None,
|
2022-05-14 05:01:35 +00:00
|
|
|
}
|
|
|
|
}
|
2021-09-27 13:49:12 +00:00
|
|
|
}
|
|
|
|
|
2021-03-07 16:22:24 +00:00
|
|
|
#[derive(Default)]
|
2019-05-24 12:16:36 +00:00
|
|
|
pub struct S3Src {
|
2021-09-27 13:49:12 +00:00
|
|
|
settings: Mutex<Settings>,
|
2019-05-24 12:16:36 +00:00
|
|
|
state: Mutex<StreamingState>,
|
2020-04-20 01:28:30 +00:00
|
|
|
canceller: Mutex<Option<future::AbortHandle>>,
|
2019-05-24 12:16:36 +00:00
|
|
|
}
|
|
|
|
|
2020-11-22 15:43:59 +00:00
|
|
|
static CAT: Lazy<gst::DebugCategory> = Lazy::new(|| {
|
|
|
|
gst::DebugCategory::new(
|
2022-05-26 09:52:42 +00:00
|
|
|
"awss3src",
|
2019-10-31 22:34:21 +00:00
|
|
|
gst::DebugColorFlags::empty(),
|
|
|
|
Some("Amazon S3 Source"),
|
2020-11-22 15:43:59 +00:00
|
|
|
)
|
|
|
|
});
|
2019-10-31 22:34:21 +00:00
|
|
|
|
2019-05-24 12:16:36 +00:00
|
|
|
impl S3Src {
|
|
|
|
fn cancel(&self) {
|
|
|
|
let mut canceller = self.canceller.lock().unwrap();
|
|
|
|
|
2020-04-20 01:28:30 +00:00
|
|
|
if let Some(c) = canceller.take() {
|
|
|
|
c.abort()
|
|
|
|
};
|
2019-05-24 12:16:36 +00:00
|
|
|
}
|
|
|
|
|
2022-05-14 05:01:35 +00:00
|
|
|
fn connect(self: &S3Src, url: &GstS3Url) -> Result<Client, gst::ErrorMessage> {
|
2021-09-27 13:49:12 +00:00
|
|
|
let settings = self.settings.lock().unwrap();
|
2022-05-14 05:01:35 +00:00
|
|
|
let timeout_config = s3utils::timeout_config(settings.request_timeout);
|
2021-09-27 13:49:12 +00:00
|
|
|
|
2022-05-14 05:01:35 +00:00
|
|
|
let cred = match (
|
2021-09-27 13:49:12 +00:00
|
|
|
settings.access_key.as_ref(),
|
|
|
|
settings.secret_access_key.as_ref(),
|
|
|
|
) {
|
2022-05-14 05:01:35 +00:00
|
|
|
(Some(access_key), Some(secret_access_key)) => Some(Credentials::new(
|
|
|
|
access_key.clone(),
|
|
|
|
secret_access_key.clone(),
|
2022-06-16 07:16:28 +00:00
|
|
|
settings.session_token.clone(),
|
2022-05-14 05:01:35 +00:00
|
|
|
None,
|
2022-05-26 09:52:42 +00:00
|
|
|
"aws-s3-src",
|
2022-05-14 05:01:35 +00:00
|
|
|
)),
|
|
|
|
_ => None,
|
|
|
|
};
|
|
|
|
|
|
|
|
let sdk_config =
|
|
|
|
s3utils::wait_config(&self.canceller, url.region.clone(), timeout_config, cred)
|
|
|
|
.map_err(|err| match err {
|
|
|
|
WaitError::FutureError(err) => gst::error_msg!(
|
|
|
|
gst::ResourceError::OpenWrite,
|
|
|
|
["Failed to create SDK config: {}", err]
|
|
|
|
),
|
|
|
|
WaitError::Cancelled => {
|
|
|
|
gst::error_msg!(
|
|
|
|
gst::LibraryError::Failed,
|
|
|
|
["SDK config request interrupted during start"]
|
|
|
|
)
|
|
|
|
}
|
|
|
|
})?;
|
|
|
|
|
2022-07-30 05:59:50 +00:00
|
|
|
let config_builder = config::Builder::from(&sdk_config)
|
2022-09-21 08:01:49 +00:00
|
|
|
.retry_config(RetryConfig::standard().with_max_attempts(settings.retry_attempts));
|
2022-07-30 05:59:50 +00:00
|
|
|
|
2023-01-14 16:58:30 +00:00
|
|
|
let config = if let Some(ref uri) = settings.endpoint_uri {
|
|
|
|
config_builder.endpoint_url(uri).build()
|
2022-07-30 05:59:50 +00:00
|
|
|
} else {
|
|
|
|
config_builder.build()
|
|
|
|
};
|
2022-05-14 05:01:35 +00:00
|
|
|
|
|
|
|
Ok(Client::from_conf(config))
|
2019-05-24 12:16:36 +00:00
|
|
|
}
|
|
|
|
|
2022-10-09 13:06:59 +00:00
|
|
|
fn set_uri(self: &S3Src, url_str: Option<&str>) -> Result<(), glib::Error> {
|
2019-05-24 12:16:36 +00:00
|
|
|
let state = self.state.lock().unwrap();
|
|
|
|
|
|
|
|
if let StreamingState::Started { .. } = *state {
|
2019-11-11 12:29:41 +00:00
|
|
|
return Err(glib::Error::new(
|
2019-05-24 12:16:36 +00:00
|
|
|
gst::URIError::BadState,
|
|
|
|
"Cannot set URI on a started s3src",
|
|
|
|
));
|
|
|
|
}
|
|
|
|
|
2021-09-27 13:49:12 +00:00
|
|
|
let mut settings = self.settings.lock().unwrap();
|
2019-05-24 12:16:36 +00:00
|
|
|
|
2019-08-12 22:45:36 +00:00
|
|
|
if url_str.is_none() {
|
2021-09-27 13:49:12 +00:00
|
|
|
settings.url = None;
|
2019-08-12 22:45:36 +00:00
|
|
|
return Ok(());
|
|
|
|
}
|
|
|
|
|
|
|
|
let url_str = url_str.unwrap();
|
|
|
|
match parse_s3_url(url_str) {
|
2019-05-25 17:23:55 +00:00
|
|
|
Ok(s3url) => {
|
2021-09-27 13:49:12 +00:00
|
|
|
settings.url = Some(s3url);
|
2019-05-24 12:16:36 +00:00
|
|
|
Ok(())
|
|
|
|
}
|
2019-11-11 12:29:41 +00:00
|
|
|
Err(_) => Err(glib::Error::new(
|
2019-05-25 17:23:55 +00:00
|
|
|
gst::URIError::BadUri,
|
|
|
|
"Could not parse URI",
|
|
|
|
)),
|
2019-05-24 12:16:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-10-09 13:06:59 +00:00
|
|
|
fn head(self: &S3Src, client: &Client, url: &GstS3Url) -> Result<u64, gst::ErrorMessage> {
|
2022-05-14 05:01:35 +00:00
|
|
|
let head_object = client
|
|
|
|
.head_object()
|
|
|
|
.set_bucket(Some(url.bucket.clone()))
|
|
|
|
.set_key(Some(url.object.clone()))
|
|
|
|
.set_version_id(url.version.clone());
|
|
|
|
let head_object_future = head_object.send();
|
|
|
|
|
|
|
|
let output =
|
|
|
|
s3utils::wait(&self.canceller, head_object_future).map_err(|err| match err {
|
|
|
|
WaitError::FutureError(err) => gst::error_msg!(
|
|
|
|
gst::ResourceError::NotFound,
|
|
|
|
["Failed to get HEAD object: {:?}", err]
|
|
|
|
),
|
|
|
|
WaitError::Cancelled => {
|
|
|
|
gst::error_msg!(
|
|
|
|
gst::LibraryError::Failed,
|
|
|
|
["Head object request interrupted"]
|
|
|
|
)
|
|
|
|
}
|
|
|
|
})?;
|
|
|
|
|
|
|
|
gst::info!(
|
|
|
|
CAT,
|
2022-10-09 13:06:59 +00:00
|
|
|
imp: self,
|
2022-05-14 05:01:35 +00:00
|
|
|
"HEAD success, content length = {}",
|
|
|
|
output.content_length
|
|
|
|
);
|
|
|
|
|
|
|
|
Ok(output.content_length as u64)
|
2019-05-24 12:16:36 +00:00
|
|
|
}
|
|
|
|
|
2023-04-10 11:34:46 +00:00
|
|
|
/* Returns the bytes, Some(error) if one occurred, or a None error if interrupted */
|
2022-10-09 13:06:59 +00:00
|
|
|
fn get(self: &S3Src, offset: u64, length: u64) -> Result<Bytes, Option<gst::ErrorMessage>> {
|
2019-05-24 12:16:36 +00:00
|
|
|
let state = self.state.lock().unwrap();
|
|
|
|
|
|
|
|
let (url, client) = match *state {
|
|
|
|
StreamingState::Started {
|
|
|
|
ref url,
|
|
|
|
ref client,
|
|
|
|
..
|
|
|
|
} => (url, client),
|
|
|
|
StreamingState::Stopped => {
|
2020-12-20 18:43:45 +00:00
|
|
|
return Err(Some(gst::error_msg!(
|
2019-05-24 12:16:36 +00:00
|
|
|
gst::LibraryError::Failed,
|
|
|
|
["Cannot GET before start()"]
|
|
|
|
)));
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2022-05-14 05:01:35 +00:00
|
|
|
let get_object = client
|
|
|
|
.get_object()
|
|
|
|
.set_bucket(Some(url.bucket.clone()))
|
|
|
|
.set_key(Some(url.object.clone()))
|
|
|
|
.set_range(Some(format!("bytes={}-{}", offset, offset + length - 1)))
|
|
|
|
.set_version_id(url.version.clone());
|
|
|
|
|
|
|
|
gst::debug!(
|
|
|
|
CAT,
|
2022-10-09 13:06:59 +00:00
|
|
|
imp: self,
|
2022-05-14 05:01:35 +00:00
|
|
|
"Requesting range: {}-{}",
|
|
|
|
offset,
|
|
|
|
offset + length - 1
|
|
|
|
);
|
|
|
|
|
|
|
|
let get_object_future = get_object.send();
|
|
|
|
|
|
|
|
let mut output =
|
|
|
|
s3utils::wait(&self.canceller, get_object_future).map_err(|err| match err {
|
|
|
|
WaitError::FutureError(err) => Some(gst::error_msg!(
|
|
|
|
gst::ResourceError::Read,
|
|
|
|
["Could not read: {}", err]
|
|
|
|
)),
|
|
|
|
WaitError::Cancelled => None,
|
|
|
|
})?;
|
|
|
|
|
2022-10-09 13:06:59 +00:00
|
|
|
gst::debug!(CAT, imp: self, "Read {} bytes", output.content_length);
|
2022-05-14 05:01:35 +00:00
|
|
|
|
|
|
|
s3utils::wait_stream(&self.canceller, &mut output.body).map_err(|err| match err {
|
2020-12-20 18:43:45 +00:00
|
|
|
WaitError::FutureError(err) => Some(gst::error_msg!(
|
2020-04-20 01:28:30 +00:00
|
|
|
gst::ResourceError::Read,
|
2022-05-14 05:01:35 +00:00
|
|
|
["Could not read: {}", err]
|
2020-04-20 01:28:30 +00:00
|
|
|
)),
|
|
|
|
WaitError::Cancelled => None,
|
|
|
|
})
|
2019-05-24 12:16:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-03-07 16:22:24 +00:00
|
|
|
#[glib::object_subclass]
|
2019-05-24 12:16:36 +00:00
|
|
|
impl ObjectSubclass for S3Src {
|
2022-10-23 15:42:58 +00:00
|
|
|
const NAME: &'static str = "GstAwsS3Src";
|
2020-11-14 17:24:01 +00:00
|
|
|
type Type = super::S3Src;
|
2019-05-24 12:16:36 +00:00
|
|
|
type ParentType = gst_base::BaseSrc;
|
2021-01-21 18:21:29 +00:00
|
|
|
type Interfaces = (gst::URIHandler,);
|
2019-05-24 12:16:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
impl ObjectImpl for S3Src {
|
2021-01-21 18:21:29 +00:00
|
|
|
fn properties() -> &'static [glib::ParamSpec] {
|
|
|
|
static PROPERTIES: Lazy<Vec<glib::ParamSpec>> = Lazy::new(|| {
|
2021-09-27 13:49:12 +00:00
|
|
|
vec![
|
2022-08-18 12:04:15 +00:00
|
|
|
glib::ParamSpecString::builder("uri")
|
|
|
|
.nick("URI")
|
|
|
|
.blurb("The S3 object URI")
|
|
|
|
.mutable_ready()
|
|
|
|
.build(),
|
|
|
|
glib::ParamSpecString::builder("access-key")
|
|
|
|
.nick("Access Key")
|
|
|
|
.blurb("AWS Access Key")
|
|
|
|
.mutable_ready()
|
|
|
|
.build(),
|
|
|
|
glib::ParamSpecString::builder("secret-access-key")
|
|
|
|
.nick("Secret Access Key")
|
|
|
|
.blurb("AWS Secret Access Key")
|
|
|
|
.mutable_ready()
|
|
|
|
.build(),
|
|
|
|
glib::ParamSpecString::builder("session-token")
|
|
|
|
.nick("Session Token")
|
|
|
|
.blurb("AWS temporary Session Token from STS")
|
|
|
|
.mutable_ready()
|
|
|
|
.build(),
|
|
|
|
glib::ParamSpecInt64::builder("request-timeout")
|
|
|
|
.nick("Request timeout")
|
|
|
|
.blurb("Timeout for each S3 request (in ms, set to -1 for infinity)")
|
|
|
|
.minimum(-1)
|
|
|
|
.default_value(DEFAULT_REQUEST_TIMEOUT_MSEC as i64)
|
|
|
|
.build(),
|
|
|
|
glib::ParamSpecInt64::builder("retry-duration")
|
|
|
|
.nick("Retry duration")
|
|
|
|
.blurb("How long we should retry S3 requests before giving up (in ms, set to -1 for infinity) (Deprecated. Use retry-attempts.)")
|
|
|
|
.minimum(-1)
|
|
|
|
.default_value(DEFAULT_RETRY_DURATION_MSEC as i64)
|
|
|
|
.build(),
|
|
|
|
glib::ParamSpecUInt::builder("retry-attempts")
|
|
|
|
.nick("Retry attempts")
|
|
|
|
.blurb("Number of times AWS SDK attempts a request before abandoning the request")
|
|
|
|
.minimum(1)
|
|
|
|
.maximum(10)
|
|
|
|
.default_value(DEFAULT_RETRY_ATTEMPTS)
|
|
|
|
.build(),
|
|
|
|
glib::ParamSpecString::builder("endpoint-uri")
|
|
|
|
.nick("S3 endpoint URI")
|
|
|
|
.blurb("The S3 endpoint URI to use")
|
|
|
|
.build(),
|
2021-09-27 13:49:12 +00:00
|
|
|
]
|
2021-01-21 18:21:29 +00:00
|
|
|
});
|
|
|
|
|
|
|
|
PROPERTIES.as_ref()
|
|
|
|
}
|
2019-05-24 12:16:36 +00:00
|
|
|
|
2022-10-09 13:06:59 +00:00
|
|
|
fn set_property(&self, _id: usize, value: &glib::Value, pspec: &glib::ParamSpec) {
|
2022-05-14 05:01:35 +00:00
|
|
|
let mut settings = self.settings.lock().unwrap();
|
|
|
|
|
2021-04-12 12:49:54 +00:00
|
|
|
match pspec.name() {
|
2021-01-21 18:21:29 +00:00
|
|
|
"uri" => {
|
2022-05-14 05:01:35 +00:00
|
|
|
drop(settings);
|
2022-10-09 13:06:59 +00:00
|
|
|
let _ = self.set_uri(value.get().expect("type checked upstream"));
|
2019-05-24 12:16:36 +00:00
|
|
|
}
|
2021-09-27 13:49:12 +00:00
|
|
|
"access-key" => {
|
|
|
|
settings.access_key = value.get().expect("type checked upstream");
|
|
|
|
}
|
|
|
|
"secret-access-key" => {
|
|
|
|
settings.secret_access_key = value.get().expect("type checked upstream");
|
|
|
|
}
|
2022-06-16 07:16:28 +00:00
|
|
|
"session-token" => {
|
|
|
|
settings.session_token = value.get().expect("type checked upstream");
|
|
|
|
}
|
2022-03-16 07:10:28 +00:00
|
|
|
"request-timeout" => {
|
2022-03-18 10:10:18 +00:00
|
|
|
settings.request_timeout =
|
|
|
|
duration_from_millis(value.get::<i64>().expect("type checked upstream"));
|
2022-03-16 07:10:28 +00:00
|
|
|
}
|
|
|
|
"retry-duration" => {
|
2022-05-14 05:01:35 +00:00
|
|
|
/*
|
|
|
|
* To maintain backwards compatibility calculate retry attempts
|
|
|
|
* by dividing the provided duration from request timeout.
|
|
|
|
*/
|
|
|
|
let value = value.get::<i64>().expect("type checked upstream");
|
|
|
|
let request_timeout = duration_to_millis(Some(settings.request_timeout));
|
|
|
|
let retry_attempts = if value > request_timeout {
|
|
|
|
value / request_timeout
|
|
|
|
} else {
|
2022-09-09 04:23:06 +00:00
|
|
|
1
|
2022-05-14 05:01:35 +00:00
|
|
|
};
|
|
|
|
settings.retry_attempts = retry_attempts as u32;
|
|
|
|
}
|
|
|
|
"retry-attempts" => {
|
|
|
|
settings.retry_attempts = value.get::<u32>().expect("type checked upstream");
|
2022-03-16 07:10:28 +00:00
|
|
|
}
|
2022-07-30 05:59:50 +00:00
|
|
|
"endpoint-uri" => {
|
|
|
|
settings.endpoint_uri = value
|
|
|
|
.get::<Option<String>>()
|
|
|
|
.expect("type checked upstream");
|
|
|
|
}
|
2019-05-24 12:16:36 +00:00
|
|
|
_ => unimplemented!(),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-10-09 13:06:59 +00:00
|
|
|
fn property(&self, _id: usize, pspec: &glib::ParamSpec) -> glib::Value {
|
2021-09-27 13:49:12 +00:00
|
|
|
let settings = self.settings.lock().unwrap();
|
|
|
|
|
2021-04-12 12:49:54 +00:00
|
|
|
match pspec.name() {
|
2021-01-21 18:21:29 +00:00
|
|
|
"uri" => {
|
2021-09-27 13:49:12 +00:00
|
|
|
let url = match settings.url {
|
2019-05-24 12:16:36 +00:00
|
|
|
Some(ref url) => url.to_string(),
|
|
|
|
None => "".to_string(),
|
|
|
|
};
|
|
|
|
|
2020-11-19 15:55:57 +00:00
|
|
|
url.to_value()
|
2019-05-24 12:16:36 +00:00
|
|
|
}
|
2021-09-27 13:49:12 +00:00
|
|
|
"access-key" => settings.access_key.to_value(),
|
|
|
|
"secret-access-key" => settings.secret_access_key.to_value(),
|
2022-06-16 07:16:28 +00:00
|
|
|
"session-token" => settings.session_token.to_value(),
|
2022-05-14 05:01:35 +00:00
|
|
|
"request-timeout" => duration_to_millis(Some(settings.request_timeout)).to_value(),
|
|
|
|
"retry-duration" => {
|
|
|
|
let request_timeout = duration_to_millis(Some(settings.request_timeout));
|
|
|
|
(settings.retry_attempts as i64 * request_timeout).to_value()
|
|
|
|
}
|
|
|
|
"retry-attempts" => settings.retry_attempts.to_value(),
|
2022-07-30 05:59:50 +00:00
|
|
|
"endpoint-uri" => settings.endpoint_uri.to_value(),
|
2019-05-24 12:16:36 +00:00
|
|
|
_ => unimplemented!(),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-10-09 13:06:59 +00:00
|
|
|
fn constructed(&self) {
|
|
|
|
self.parent_constructed();
|
2019-05-24 12:16:36 +00:00
|
|
|
|
2022-10-23 20:03:22 +00:00
|
|
|
let obj = self.obj();
|
2020-11-14 17:24:01 +00:00
|
|
|
obj.set_format(gst::Format::Bytes);
|
2019-05-24 12:16:36 +00:00
|
|
|
/* Set a larger default blocksize to make read more efficient */
|
2020-11-14 17:24:01 +00:00
|
|
|
obj.set_blocksize(256 * 1024);
|
2019-05-24 12:16:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-10-23 08:57:31 +00:00
|
|
|
impl GstObjectImpl for S3Src {}
|
|
|
|
|
2019-05-24 12:16:36 +00:00
|
|
|
impl ElementImpl for S3Src {
|
2021-01-21 18:21:29 +00:00
|
|
|
fn metadata() -> Option<&'static gst::subclass::ElementMetadata> {
|
|
|
|
static ELEMENT_METADATA: Lazy<gst::subclass::ElementMetadata> = Lazy::new(|| {
|
|
|
|
gst::subclass::ElementMetadata::new(
|
|
|
|
"Amazon S3 source",
|
|
|
|
"Source/Network",
|
|
|
|
"Reads an object from Amazon S3",
|
|
|
|
"Arun Raghavan <arun@arunraghavan.net>",
|
|
|
|
)
|
|
|
|
});
|
|
|
|
|
|
|
|
Some(&*ELEMENT_METADATA)
|
|
|
|
}
|
|
|
|
|
|
|
|
fn pad_templates() -> &'static [gst::PadTemplate] {
|
|
|
|
static PAD_TEMPLATES: Lazy<Vec<gst::PadTemplate>> = Lazy::new(|| {
|
|
|
|
let caps = gst::Caps::new_any();
|
|
|
|
let src_pad_template = gst::PadTemplate::new(
|
|
|
|
"src",
|
|
|
|
gst::PadDirection::Src,
|
|
|
|
gst::PadPresence::Always,
|
|
|
|
&caps,
|
|
|
|
)
|
|
|
|
.unwrap();
|
|
|
|
|
|
|
|
vec![src_pad_template]
|
|
|
|
});
|
|
|
|
|
|
|
|
PAD_TEMPLATES.as_ref()
|
|
|
|
}
|
2019-05-24 12:16:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
impl URIHandlerImpl for S3Src {
|
2021-01-21 18:21:29 +00:00
|
|
|
const URI_TYPE: gst::URIType = gst::URIType::Src;
|
|
|
|
|
2021-04-20 12:57:40 +00:00
|
|
|
fn protocols() -> &'static [&'static str] {
|
2021-01-21 18:21:29 +00:00
|
|
|
&["s3"]
|
|
|
|
}
|
|
|
|
|
2022-10-09 13:06:59 +00:00
|
|
|
fn uri(&self) -> Option<String> {
|
2021-09-27 13:49:12 +00:00
|
|
|
let settings = self.settings.lock().unwrap();
|
|
|
|
|
|
|
|
settings.url.as_ref().map(|s| s.to_string())
|
2019-05-24 12:16:36 +00:00
|
|
|
}
|
|
|
|
|
2022-10-09 13:06:59 +00:00
|
|
|
fn set_uri(&self, uri: &str) -> Result<(), glib::Error> {
|
|
|
|
self.set_uri(Some(uri))
|
2019-05-24 12:16:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl BaseSrcImpl for S3Src {
|
2022-10-09 13:06:59 +00:00
|
|
|
fn is_seekable(&self) -> bool {
|
2019-05-24 12:16:36 +00:00
|
|
|
true
|
|
|
|
}
|
|
|
|
|
2022-10-09 13:06:59 +00:00
|
|
|
fn size(&self) -> Option<u64> {
|
2022-06-30 12:44:07 +00:00
|
|
|
let state = self.state.lock().unwrap();
|
|
|
|
match *state {
|
2019-05-24 12:16:36 +00:00
|
|
|
StreamingState::Stopped => None,
|
|
|
|
StreamingState::Started { size, .. } => Some(size),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-10-09 13:06:59 +00:00
|
|
|
fn start(&self) -> Result<(), gst::ErrorMessage> {
|
2020-04-20 01:28:30 +00:00
|
|
|
let mut state = self.state.lock().unwrap();
|
2019-05-24 12:16:36 +00:00
|
|
|
|
|
|
|
if let StreamingState::Started { .. } = *state {
|
2022-06-25 05:59:51 +00:00
|
|
|
unreachable!("AwsS3Src is already started");
|
2019-05-24 12:16:36 +00:00
|
|
|
}
|
|
|
|
|
2021-09-27 13:49:12 +00:00
|
|
|
let settings = self.settings.lock().unwrap();
|
|
|
|
let s3url = match settings.url {
|
2019-05-24 12:16:36 +00:00
|
|
|
Some(ref url) => url.clone(),
|
|
|
|
None => {
|
2020-12-20 18:43:45 +00:00
|
|
|
return Err(gst::error_msg!(
|
2019-05-24 12:16:36 +00:00
|
|
|
gst::ResourceError::Settings,
|
|
|
|
["Cannot start without a URL being set"]
|
|
|
|
));
|
|
|
|
}
|
|
|
|
};
|
2021-09-27 13:49:12 +00:00
|
|
|
drop(settings);
|
2019-05-24 12:16:36 +00:00
|
|
|
|
2022-05-14 05:01:35 +00:00
|
|
|
if let Ok(s3client) = self.connect(&s3url) {
|
2022-10-09 13:06:59 +00:00
|
|
|
let size = self.head(&s3client, &s3url)?;
|
2019-05-24 12:16:36 +00:00
|
|
|
|
2022-05-14 05:01:35 +00:00
|
|
|
*state = StreamingState::Started {
|
|
|
|
url: s3url,
|
|
|
|
client: s3client,
|
|
|
|
size,
|
|
|
|
};
|
2019-05-24 12:16:36 +00:00
|
|
|
|
2022-05-14 05:01:35 +00:00
|
|
|
Ok(())
|
|
|
|
} else {
|
|
|
|
Err(gst::error_msg!(
|
|
|
|
gst::ResourceError::Failed,
|
|
|
|
["Cannot connect to S3 resource"]
|
|
|
|
))
|
|
|
|
}
|
2019-05-24 12:16:36 +00:00
|
|
|
}
|
|
|
|
|
2022-10-09 13:06:59 +00:00
|
|
|
fn stop(&self) -> Result<(), gst::ErrorMessage> {
|
2020-04-20 01:28:30 +00:00
|
|
|
// First, stop any asynchronous tasks if we're running, as they will have the state lock
|
|
|
|
self.cancel();
|
|
|
|
|
2019-05-24 12:16:36 +00:00
|
|
|
let mut state = self.state.lock().unwrap();
|
|
|
|
|
|
|
|
if let StreamingState::Stopped = *state {
|
|
|
|
unreachable!("Cannot stop before start");
|
|
|
|
}
|
|
|
|
|
|
|
|
*state = StreamingState::Stopped;
|
|
|
|
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
2022-10-09 13:06:59 +00:00
|
|
|
fn query(&self, query: &mut gst::QueryRef) -> bool {
|
2022-01-19 13:07:45 +00:00
|
|
|
if let gst::QueryViewMut::Scheduling(q) = query.view_mut() {
|
2019-11-24 22:00:27 +00:00
|
|
|
q.set(
|
|
|
|
gst::SchedulingFlags::SEQUENTIAL | gst::SchedulingFlags::BANDWIDTH_LIMITED,
|
|
|
|
1,
|
|
|
|
-1,
|
|
|
|
0,
|
|
|
|
);
|
|
|
|
q.add_scheduling_modes(&[gst::PadMode::Push, gst::PadMode::Pull]);
|
|
|
|
return true;
|
2019-05-24 12:16:36 +00:00
|
|
|
}
|
|
|
|
|
2022-10-09 13:06:59 +00:00
|
|
|
BaseSrcImplExt::parent_query(self, query)
|
2019-05-24 12:16:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
fn create(
|
|
|
|
&self,
|
|
|
|
offset: u64,
|
2020-03-29 21:29:40 +00:00
|
|
|
buffer: Option<&mut gst::BufferRef>,
|
2019-05-24 12:16:36 +00:00
|
|
|
length: u32,
|
2020-03-29 21:29:40 +00:00
|
|
|
) -> Result<CreateSuccess, gst::FlowError> {
|
2019-05-24 12:16:36 +00:00
|
|
|
// FIXME: sanity check on offset and length
|
2022-10-09 13:06:59 +00:00
|
|
|
let data = self.get(offset, u64::from(length));
|
2019-05-24 12:16:36 +00:00
|
|
|
|
|
|
|
match data {
|
|
|
|
/* Got data */
|
2020-03-29 21:29:40 +00:00
|
|
|
Ok(bytes) => {
|
|
|
|
if let Some(buffer) = buffer {
|
|
|
|
if let Err(copied_bytes) = buffer.copy_from_slice(0, bytes.as_ref()) {
|
|
|
|
buffer.set_size(copied_bytes);
|
|
|
|
}
|
|
|
|
Ok(CreateSuccess::FilledBuffer)
|
|
|
|
} else {
|
|
|
|
Ok(CreateSuccess::NewBuffer(gst::Buffer::from_slice(bytes)))
|
|
|
|
}
|
|
|
|
}
|
2019-05-24 12:16:36 +00:00
|
|
|
/* Interrupted */
|
|
|
|
Err(None) => Err(gst::FlowError::Flushing),
|
|
|
|
/* Actual Error */
|
|
|
|
Err(Some(err)) => {
|
2022-10-09 13:06:59 +00:00
|
|
|
gst::error!(CAT, imp: self, "Could not GET: {}", err);
|
2019-05-24 12:16:36 +00:00
|
|
|
Err(gst::FlowError::Error)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* FIXME: implement */
|
2022-10-09 13:06:59 +00:00
|
|
|
fn do_seek(&self, _: &mut gst::Segment) -> bool {
|
2019-05-24 12:16:36 +00:00
|
|
|
true
|
|
|
|
}
|
|
|
|
|
2022-10-09 13:06:59 +00:00
|
|
|
fn unlock(&self) -> Result<(), gst::ErrorMessage> {
|
2019-05-24 12:16:36 +00:00
|
|
|
self.cancel();
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
}
|