Endpoint for audio uploading

This commit is contained in:
Brandon Thomas committed 2023-01-11 00:33:39 -05:00
1 parent 8591f74ff2
commit deb3671be6
20 files changed
+485 -6

No files matched your search

@@ -60,6 +60,8 @@ CREATE TABLE media_uploads (
-- ========== UPLOAD, TRANSCODING, AND TRUNCATION DETAILS ==========
-- TODO(bt, 2022-12-20): Before landing, rename this field be better and indicate this
-- is a *directory*. Add a second field to contain the default file name.
-- The directory this media is uploaded to will be exclusive for this file.
-- Only this given record will live in this bucket, but the directory may include
-- other transcodings or truncations.
@@ -6,12 +6,15 @@ use sqlx::error::Error::Database;
use sqlx::mysql::MySqlQueryResult;
use sqlx::{MySqlPool};
use std::sync::Arc;
use tokens::files::media_upload::MediaUploadToken;
use tokens::users::user::UserToken;
// TODO(bt, 2022-12-19): Convert this to a database 'enum'. Also, create an 'enums' package similar to 'tokens'.
#[derive(Debug, Clone, Copy)]
enum FirehoseEvent {
UserSignUp,
// We don't publish for all badges (eg. early user signup)
// NB: We don't publish for all badges (eg. early user signup)
UserBadgeGranted,
TtsModelUploadStarted,
@@ -27,6 +30,9 @@ enum FirehoseEvent {
GenericDownloadStarted,
GenericDownloadCompleted,
MediaUploaded,
// TODO(bt, 2022-12-19): Are the following unused, merely planned (?)
TwitterMention,
TwitterRetweet,
DiscordJoin,
@@ -48,14 +54,17 @@ impl FirehoseEvent {
FirehoseEvent::W2lTemplateUploadCompleted => "w2l_template_upload_completed",
FirehoseEvent::W2lInferenceStarted => "w2l_inference_started",
FirehoseEvent::W2lInferenceCompleted => "w2l_inference_completed",
FirehoseEvent::GenericDownloadStarted => "generic_download_started",
FirehoseEvent::GenericDownloadCompleted => "generic_download_completed",
FirehoseEvent::MediaUploaded => "media_uploaded",
// Are the following unused (?)
FirehoseEvent::TwitterMention => "twitter_mention",
FirehoseEvent::TwitterRetweet => "twitter_retweet",
FirehoseEvent::DiscordJoin => "discord_join",
FirehoseEvent::DiscordMessage => "discord_message",
FirehoseEvent::TwitchSubscribe => "twitch_subscribe",
FirehoseEvent::TwitchFollow => "twitch_follow",
FirehoseEvent::GenericDownloadStarted => "generic_download_started",
FirehoseEvent::GenericDownloadCompleted => "generic_download_completed",
}
}
}
@@ -198,6 +207,16 @@ impl FirehosePublisher {
Ok(())
}
pub async fn publish_media_uploaded(&self, maybe_user_token: Option<&UserToken>, upload_token: &MediaUploadToken) -> AnyhowResult<()> {
let _record_id = self.insert(
FirehoseEvent::MediaUploaded,
maybe_user_token.map(|u| u.as_str()),
Some(upload_token.as_str()),
Some(upload_token.as_str()),
).await?;
Ok(())
}
// =======================================================================
async fn insert(
@@ -237,6 +256,8 @@ SET
Ok(res) => {
res.last_insert_id()
},
// TODO(bt, 2022-12-20): I've never richly handled database errors/error codes.
// I should revisit these in the future and consider some kind of middleware.
Err(err) => {
warn!("Insert record DB error: {:?}", err);
@@ -0,0 +1,100 @@
use anyhow::anyhow;
use container_common::anyhow_result::AnyhowResult;
use reusable_types::db::enums::entity_visibility::EntityVisibility;
use reusable_types::db::enums::media_upload_type::MediaUploadType;
use sqlx::MySqlPool;
use reusable_types::db::payloads::MediaUploadDetails;
use tokens::files::media_upload::MediaUploadToken;
use tokens::users::user::UserToken;
pub struct Args <'a> {
pub token: &'a MediaUploadToken,
pub uuid_idempotency_token: &'a str,
pub media_type: MediaUploadType,
pub maybe_original_filename: Option<&'a str>,
pub original_file_size_bytes: u64,
pub original_duration_millis: u64,
pub maybe_original_mime_type: Option<&'a str>,
pub maybe_original_audio_encoding: Option<&'a str>,
pub maybe_original_video_encoding: Option<&'a str>,
pub maybe_original_frame_width: Option<u64>,
pub maybe_original_frame_height: Option<u64>,
pub checksum_sha2: &'a str,
pub public_bucket_directory_full_path: &'a str,
pub extra_file_modification_info: MediaUploadDetails,
pub maybe_creator_user_token: Option<&'a UserToken>,
pub maybe_creator_anonymous_visitor_token: Option<&'a str>,
pub creator_ip_address: &'a str,
pub creator_set_visibility: EntityVisibility,
pub maybe_creator_synthetic_id: Option<u64>,
pub mysql_pool: &'a MySqlPool,
}
pub async fn insert_media_upload(args: Args<'_>) -> AnyhowResult<u64> {
let query = sqlx::query!(
r#"
INSERT INTO media_uploads
SET
token = ?,
uuid_idempotency_token = ?,
media_type = ?,
maybe_original_filename = ?,
original_file_size_bytes = ?,
original_duration_millis = ?,
maybe_original_mime_type = ?,
maybe_original_audio_encoding = ?,
maybe_original_video_encoding = ?,
maybe_original_frame_width = ?,
maybe_original_frame_height = ?,
checksum_sha2 = ?,
public_bucket_directory_full_path = ?,
extra_file_modification_info = ?,
maybe_creator_user_token = ?,
maybe_creator_anonymous_visitor_token = ?,
creator_ip_address = ?,
creator_set_visibility = ?,
maybe_creator_synthetic_id = ?
"#,
args.token,
args.uuid_idempotency_token,
args.media_type,
args.maybe_original_filename,
args.original_file_size_bytes,
args.original_duration_millis,
args.maybe_original_mime_type,
args.maybe_original_audio_encoding,
args.maybe_original_video_encoding,
args.maybe_original_frame_width,
args.maybe_original_frame_height,
args.checksum_sha2,
args.public_bucket_directory_full_path,
"", // TODO: args.extra_file_modification_info,
args.maybe_creator_user_token,
args.maybe_creator_anonymous_visitor_token,
args.creator_ip_address,
args.creator_set_visibility,
args.maybe_creator_synthetic_id,
);
let query_result = query.execute(args.mysql_pool)
.await;
match query_result {
Ok(res) => Ok(res.last_insert_id()),
Err(err) => Err(anyhow!("error inserting new media upload: {:?}", err)),
}
}
@@ -0,0 +1 @@
pub mod insert_media_upload;
@@ -4,6 +4,7 @@ pub mod generic_download;
pub mod generic_inference;
pub mod health_check;
pub mod ip_bans;
pub mod media_uploads;
pub mod model_categories;
pub mod stats;
pub mod tts;
@@ -9,9 +9,10 @@ use crate::helpers::boolean_converters::{nullable_i8_to_optional_bool, i8_to_boo
use log::warn;
use sqlx::MySql;
use sqlx::pool::PoolConnection;
use tokens::users::user::UserToken;
pub struct SessionUserRecord {
pub user_token: String,
pub user_token: String, // TODO(bt, 2022-12-20): Convert to strongly-typed `UserToken`
pub username: String,
pub display_name: String,
@@ -65,6 +66,13 @@ pub struct SessionUserRecord {
pub can_delete_users: bool,
}
impl SessionUserRecord {
// TODO(bt, 2022-12-20): Convert all users of the bare record to using `UserToken`, then get rid of this method.
pub fn get_strongly_typed_user_token(&self) -> UserToken {
UserToken::new_from_str(&self.user_token)
}
}
pub async fn get_user_session_by_token(
mysql_connection: &mut PoolConnection<MySql>,
session_token: &str,
@@ -0,0 +1,53 @@
/// Used in the `media_uploads` table.
///
/// DO NOT CHANGE VALUES WITHOUT A MIGRATION STRATEGY.
#[derive(Clone, Copy, Eq, PartialEq, Debug, Deserialize, Serialize, sqlx::Type)]
#[serde(rename_all = "lowercase")]
#[sqlx(rename_all = "lowercase")]
pub enum MediaUploadType {
Audio,
Video,
}
/// NB: Legacy API for older code.
impl MediaUploadType {
pub fn to_str(&self) -> &'static str {
match self {
Self::Audio => "audio",
Self::Video => "video",
}
}
pub fn from_str(value: &str) -> Result<Self, String> {
match value {
"audio" => Ok(Self::Audio),
"video" => Ok(Self::Video),
_ => Err(format!("invalid value: {:?}", value)),
}
}
}
#[cfg(test)]
mod tests {
use crate::db::enums::media_upload_type::MediaUploadType;
use crate::test_helpers::assert_serialization;
#[test]
fn test_serialization() {
assert_serialization(MediaUploadType::Audio, "audio");
assert_serialization(MediaUploadType::Video, "video");
}
#[test]
fn test_to_str() {
assert_eq!(MediaUploadType::Audio.to_str(), "audio");
assert_eq!(MediaUploadType::Video.to_str(), "video");
}
#[test]
fn test_from_str() {
assert_eq!(MediaUploadType::from_str("audio").unwrap(), MediaUploadType::Audio);
assert_eq!(MediaUploadType::from_str("video").unwrap(), MediaUploadType::Video);
assert!(MediaUploadType::from_str("foo").is_err());
}
}
@@ -4,4 +4,5 @@
pub mod entity_visibility;
pub mod generic_download_type;
pub mod generic_inference_type;
pub mod media_upload_type;
pub mod vocoder_type;
Whitespace-only changes.
@@ -0,0 +1,5 @@
pub mod media_upload_details;
/// NB: All fields should be *optional*!
pub struct MediaUploadDetails {
}
@@ -0,0 +1,12 @@
use crate::prefixes::EntityType;
use serde::Deserialize;
use serde::Serialize;
use std::fmt::Debug;
/// The primary key for user media uploads (images, video, etc.)
#[derive(Clone, PartialEq, Eq, sqlx::Type, Debug, Serialize, Deserialize)]
#[sqlx(transparent)]
pub struct MediaUploadToken(String);
impl_string_token!(MediaUploadToken);
impl_crockford_generator!(MediaUploadToken, 32usize, EntityType::DownloadJob, CrockfordLower);
+1
View File
@@ -0,0 +1 @@
pub mod media_upload;
+1
View File
@@ -37,6 +37,7 @@ mod macros;
pub (crate) mod prefixes;
pub mod files;
pub mod jobs;
pub mod users;
pub mod voice_conversion;
+2
View File
@@ -15,6 +15,7 @@ use strum::EnumIter;
pub(crate) enum EntityType {
DownloadJob,
InferenceJob,
MediaUpload,
User,
VoiceConversionModel,
}
@@ -25,6 +26,7 @@ impl EntityType {
match self {
Self::DownloadJob => "jdown_", // NB: Was "JGUP:"
Self::InferenceJob => "jinf_",
Self::MediaUpload => "mu_",
Self::User => "U:", // NB: Old-style prefix.
Self::VoiceConversionModel => "voco_",
}
@@ -0,0 +1,57 @@
use actix_multipart::Field;
use actix_multipart::Multipart;
use actix_web::web::BytesMut;
use container_common::anyhow_result::AnyhowResult;
use crate::http_server::web_utils::read_multipart_field_bytes::{checked_read_multipart_bytes, read_multipart_field_as_text};
use futures::TryStreamExt;
use log::warn;
pub struct UploadMediaRequest {
pub uuid_idempotency_token: Option<String>,
pub file_name: Option<String>,
pub file_bytes: Option<BytesMut>,
}
/// Pull common parts out of multipart media HTTP requests, typically for handling file uploads.
pub async fn drain_multipart_request(mut multipart_payload: Multipart) -> AnyhowResult<UploadMediaRequest> {
let mut uuid_idempotency_token = None;
let mut file_bytes = None;
let mut file_name = None;
while let Ok(Some(mut field)) = multipart_payload.try_next().await {
let mut field_name = None;
let mut field_filename = None;
if let Some(content_disposition) = field.content_disposition() {
field_name = content_disposition.get_name()
.map(|s| s.to_string());
field_filename = content_disposition.get_filename() // NB: Only used for the file bytes.
.map(|s| s.to_string());
}
match field_name.as_deref() {
Some("uuid_idempotency_token") => {
uuid_idempotency_token = read_multipart_field_as_text(&mut field).await
.map_err(|e| {
warn!("Error reading idempotency token: {:}", e);
e
})?;
},
Some("file_bytes") => {
file_name = field_filename.clone();
file_bytes = checked_read_multipart_bytes(&mut field).await
.map_err(|e| {
warn!("Error reading audio upload: {:}", e);
e
})?;
},
_ => continue,
}
}
Ok(UploadMediaRequest {
uuid_idempotency_token,
file_name,
file_bytes,
})
}
@@ -0,0 +1,3 @@
pub mod drain_multipart_request;
pub mod upload_audio;
pub mod upload_video;
@@ -0,0 +1,187 @@
use actix_http::Error;
use actix_http::http::header;
use actix_multipart::Multipart;
use actix_web::HttpResponseBuilder;
use actix_web::cookie::Cookie;
use actix_web::error::ResponseError;
use actix_web::http::StatusCode;
use actix_web::{Responder, web, HttpResponse, error, HttpRequest};
use config::bad_urls::is_bad_tts_model_download_url;
use crate::http_server::endpoints::media_uploads::drain_multipart_request::drain_multipart_request;
use crate::http_server::web_utils::response_error_helpers::to_simple_json_error;
use crate::server_state::ServerState;
use crate::validations::model_uploads::validate_model_title;
use crate::validations::validate_idempotency_token_format::validate_idempotency_token_format;
use database_queries::column_types::record_visibility::RecordVisibility;
use database_queries::queries::media_uploads::insert_media_upload::{Args, insert_media_upload};
use database_queries::tokens::Tokens;
use http_server_common::request::get_request_ip::get_request_ip;
use http_server_common::response::serialize_as_json_error::serialize_as_json_error;
use log::{info, warn, log};
use regex::Regex;
use reusable_types::db::enums::entity_visibility::EntityVisibility;
use reusable_types::db::enums::generic_download_type::GenericDownloadType;
use reusable_types::db::enums::media_upload_type::MediaUploadType;
use reusable_types::db::payloads::MediaUploadDetails;
use sqlx::error::DatabaseError;
use sqlx::error::Error::Database;
use sqlx::mysql::MySqlDatabaseError;
use std::fmt;
use std::sync::Arc;
use tokens::files::media_upload::MediaUploadToken;
#[derive(Serialize)]
pub struct UploadAudioSuccessResponse {
pub success: bool,
pub upload_token: MediaUploadToken,
}
#[derive(Debug, Serialize)]
pub enum UploadAudioError {
BadInput(String),
NotAuthorized,
MustBeLoggedIn,
ServerError,
RateLimited,
}
impl ResponseError for UploadAudioError {
fn status_code(&self) -> StatusCode {
match *self {
UploadAudioError::BadInput(_) => StatusCode::BAD_REQUEST,
UploadAudioError::NotAuthorized => StatusCode::UNAUTHORIZED,
UploadAudioError::MustBeLoggedIn => StatusCode::UNAUTHORIZED,
UploadAudioError::ServerError => StatusCode::INTERNAL_SERVER_ERROR,
UploadAudioError::RateLimited => StatusCode::TOO_MANY_REQUESTS,
}
}
fn error_response(&self) -> HttpResponse {
serialize_as_json_error(self)
}
}
// NB: Not using derive_more::Display since Clion doesn't understand it.
impl fmt::Display for UploadAudioError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{:?}", self)
}
}
pub async fn upload_audio_handler(
http_request: HttpRequest,
server_state: web::Data<Arc<ServerState>>,
mut multipart_payload: Multipart,
) -> Result<HttpResponse, UploadAudioError> {
// ==================== READ SESSION ==================== //
let maybe_user_session = server_state
.session_checker
.maybe_get_user_session(&http_request, &server_state.mysql_pool)
.await
.map_err(|e| {
warn!("Session checker error: {:?}", e);
UploadAudioError::ServerError
})?;
// ==================== RATE LIMIT ==================== //
let rate_limiter = match maybe_user_session {
None => &server_state.redis_rate_limiters.logged_out,
Some(ref user) => {
if user.is_banned {
return Err(UploadAudioError::NotAuthorized);
}
&server_state.redis_rate_limiters.logged_in
},
};
if let Err(_err) = rate_limiter.rate_limit_request(&http_request) {
return Err(UploadAudioError::RateLimited);
}
if let Err(_err) = server_state.redis_rate_limiters.model_upload.rate_limit_request(&http_request) {
return Err(UploadAudioError::RateLimited);
}
// ==================== READ MULTIPART REQUEST ==================== //
let upload_media_request = drain_multipart_request(multipart_payload)
.await
.map_err(|e| {
// TODO: Error handling could be nicer.
UploadAudioError::BadInput("bad request".to_string())
})?;
let uuid_idempotency_token = upload_media_request.uuid_idempotency_token
.ok_or(UploadAudioError::BadInput("no uuid".to_string()))?;
if let Err(reason) = validate_idempotency_token_format(&uuid_idempotency_token) {
return Err(UploadAudioError::BadInput(reason));
}
let creator_set_visibility = maybe_user_session
.as_ref()
.map(|user_session| user_session.preferred_tts_result_visibility)
.unwrap_or(RecordVisibility::Public);
let ip_address = get_request_ip(&http_request);
let maybe_user_token = maybe_user_session
.map(|session| session.get_strongly_typed_user_token());
let token = MediaUploadToken::generate();
let record_id = insert_media_upload(Args {
token: &token,
uuid_idempotency_token: &uuid_idempotency_token,
media_type: MediaUploadType::Audio,
maybe_original_filename: upload_media_request.file_name.as_deref(),
original_file_size_bytes: 0,
original_duration_millis: 0,
maybe_original_mime_type: None,
maybe_original_audio_encoding: None,
maybe_original_video_encoding: None,
maybe_original_frame_width: None,
maybe_original_frame_height: None,
checksum_sha2: "",
public_bucket_directory_full_path: "",
extra_file_modification_info: MediaUploadDetails {}, // TODO
maybe_creator_user_token: maybe_user_token.as_ref(),
maybe_creator_anonymous_visitor_token: None,
creator_ip_address: &ip_address,
creator_set_visibility: EntityVisibility::Public, // TODO: Combine these two types.
maybe_creator_synthetic_id: None,
mysql_pool: &server_state.mysql_pool,
})
.await
.map_err(|err| {
warn!("New generic download creation DB error: {:?}", err);
UploadAudioError::ServerError
})?;
info!("new media upload id: {}", record_id);
server_state.firehose_publisher.publish_media_uploaded(
maybe_user_token.as_ref(),
&token)
.await
.map_err(|e| {
warn!("error publishing event: {:?}", e);
UploadAudioError::ServerError
})?;
let response = UploadAudioSuccessResponse {
success: true,
upload_token: token,
};
let body = serde_json::to_string(&response)
.map_err(|e| UploadAudioError::ServerError)?;
Ok(HttpResponse::Ok()
.content_type("application/json")
.body(body))
}
@@ -5,6 +5,7 @@ pub mod events;
pub mod flags;
pub mod investor_demo;
pub mod leaderboard;
pub mod media_uploads;
pub mod misc;
pub mod moderation;
pub mod service;
@@ -21,6 +21,7 @@ use crate::http_server::endpoints::flags::design_refresh_flag::enable_design_ref
use crate::http_server::endpoints::investor_demo::disable_demo_mode_handler::disable_demo_mode_handler;
use crate::http_server::endpoints::investor_demo::enable_demo_mode_handler::enable_demo_mode_handler;
use crate::http_server::endpoints::leaderboard::get_leaderboard::leaderboard_handler;
use crate::http_server::endpoints::media_uploads::upload_audio::upload_audio_handler;
use crate::http_server::endpoints::misc::default_route_404::default_route_404;
use crate::http_server::endpoints::misc::detect_locale_handler::detect_locale_handler;
use crate::http_server::endpoints::misc::enable_alpha_easy_handler::enable_alpha_easy_handler;
@@ -37,6 +38,7 @@ use crate::http_server::endpoints::moderation::ip_bans::list_ip_bans::list_ip_ba
use crate::http_server::endpoints::moderation::jobs::get_tts_inference_queue_count::get_tts_inference_queue_count_handler;
use crate::http_server::endpoints::moderation::jobs::get_w2l_inference_queue_count::get_w2l_inference_queue_count_handler;
use crate::http_server::endpoints::moderation::jobs::kill_tts_inference_jobs::kill_tts_inference_jobs_handler;
use crate::http_server::endpoints::moderation::stats::get_on_prem_worker_stats::get_on_prem_worker_stats_handler;
use crate::http_server::endpoints::moderation::stats::get_voice_count_stats::get_voice_count_stats_handler;
use crate::http_server::endpoints::moderation::user_bans::ban_user::ban_user_handler;
use crate::http_server::endpoints::moderation::user_bans::list_banned_users::list_banned_users_handler;
@@ -97,7 +99,6 @@ use crate::http_server::endpoints::w2l::set_w2l_template_mod_approval::set_w2l_t
use users_component::default_routes::add_suggested_api_v1_account_creation_and_session_routes;
use users_component::endpoints::edit_profile_handler::edit_profile_handler;
use users_component::endpoints::get_profile_handler::get_profile_handler;
use crate::http_server::endpoints::moderation::stats::get_on_prem_worker_stats::get_on_prem_worker_stats_handler;
pub fn add_routes<T, B> (app: App<T, B>) -> App<T, B>
where
@@ -122,7 +123,8 @@ pub fn add_routes<T, B> (app: App<T, B>) -> App<T, B>
app = add_twitch_routes(app); /* /twitch */ // TODO: MAYBE TEMPORARY
app = add_investor_demo_routes(app); /* /demo_mode */ // TODO: DEFINITELY TEMPORARY
app = add_flag_routes(app); /* /flag */
app = add_desktop_app_routes(app); /* /api/v1/vc/... */
app = add_desktop_app_routes(app); /* /v1/vc/... */
app = add_media_upload_routes(app); /* /v1/media_upload/... */
// From components
app = add_suggested_api_v1_account_creation_and_session_routes(app); // /create_account, /session, /login, /logout
@@ -776,6 +778,27 @@ fn add_desktop_app_routes<T, B> (app: App<T, B>) -> App<T, B>
)
}
// ==================== MEDIA UPLOAD ROUTES ====================
fn add_media_upload_routes<T, B> (app: App<T, B>) -> App<T, B>
where
B: MessageBody,
T: ServiceFactory<
ServiceRequest,
Config = (),
Response = ServiceResponse<B>,
Error = Error,
InitError = (),
>,
{
app.service(web::scope("/v1/media_upload")
.service(web::resource("/upload_audio")
.route(web::post().to(upload_audio_handler))
.route(web::head().to(|| HttpResponse::Ok()))
)
)
}
// ==================== TWITCH ROUTES ====================
// TODO: Maybe move these into an "oauth-gateway" type http service.