stubs for engine persistence endpoints

This commit is contained in:
Brandon Thomas committed 2024-02-17 23:22:13 -05:00
1 parent 98c087116b
commit c9c4fd59d9
6 files changed
+283 -5

No files matched your search

@@ -0,0 +1,39 @@
use std::collections::HashSet;
use std::sync::Arc;
use actix_multipart::Multipart;
use actix_web::{HttpRequest, HttpResponse, web};
use once_cell::sync::Lazy;
use tokens::tokens::media_files::MediaFileToken;
use crate::http_server::endpoints::media_uploads::common::handle_upload::handle_upload;
use crate::http_server::endpoints::media_uploads::common::upload_error::UploadError;
use crate::server_state::ServerState;
#[derive(Serialize)]
pub struct CreateSceneSuccessResponse {
pub success: bool,
pub media_file_token: MediaFileToken,
}
pub async fn create_scene_handler(
http_request: HttpRequest,
server_state: web::Data<Arc<ServerState>>,
mut multipart_payload: Multipart,
) -> Result<HttpResponse, UploadError> {
// TODO(bt): Handle upload / save.
let response = CreateSceneSuccessResponse {
success: true,
media_file_token: MediaFileToken::new_from_str("TODO"),
};
let body = serde_json::to_string(&response)
.map_err(|e| UploadError::ServerError)?;
return Ok(HttpResponse::Ok()
.content_type("application/json")
.body(body));
}
@@ -0,0 +1,167 @@
use std::fmt;
use std::sync::Arc;
use actix_web::{HttpMessage, HttpRequest, HttpResponse, web};
use actix_web::error::ResponseError;
use actix_web::http::StatusCode;
use actix_web::web::Path;
use chrono::{DateTime, Utc};
use log::warn;
use utoipa::ToSchema;
use buckets::public::media_files::bucket_file_path::MediaFileBucketPath;
use enums::by_table::media_files::media_file_type::MediaFileType;
use enums::by_table::model_weights::weights_category::WeightsCategory;
use enums::by_table::model_weights::weights_types::WeightsType;
use enums::common::visibility::Visibility;
use mysql_queries::queries::media_files::get_media_file::get_media_file;
use mysql_queries::queries::tts::tts_results::query_tts_result::select_tts_result_by_token;
use tokens::tokens::media_files::MediaFileToken;
use tokens::tokens::model_weights::ModelWeightToken;
use users_component::common_responses::user_details_lite::UserDetailsLight;
use crate::http_server::common_responses::simple_entity_stats::SimpleEntityStats;
use crate::http_server::web_utils::response_error_helpers::to_simple_json_error;
use crate::server_state::ServerState;
/// For the URL PathInfo
#[derive(Deserialize, ToSchema)]
pub struct GetScenePathInfo {
token: MediaFileToken,
}
#[derive(Serialize, ToSchema)]
pub struct GetSceneSuccessResponse {
pub success: bool,
pub media_file: MediaFileInfo,
}
#[derive(Serialize, ToSchema)]
pub struct MediaFileInfo {
pub token: MediaFileToken,
/// Type of media will dictate which fields are populated and what
/// the frontend should display (eg. video player vs audio player).
pub media_type: MediaFileType,
/// URL to the media file
pub public_bucket_path: String,
pub created_at: DateTime<Utc>,
pub updated_at: DateTime<Utc>,
}
#[derive(Debug, ToSchema)]
pub enum GetSceneError {
ServerError,
NotFound,
}
impl ResponseError for GetSceneError {
fn status_code(&self) -> StatusCode {
match *self {
GetSceneError::ServerError => StatusCode::INTERNAL_SERVER_ERROR,
GetSceneError::NotFound => StatusCode::NOT_FOUND,
}
}
fn error_response(&self) -> HttpResponse {
let error_reason = match self {
GetSceneError::ServerError => "server error".to_string(),
GetSceneError::NotFound => "not found".to_string(),
};
to_simple_json_error(&error_reason, self.status_code())
}
}
// NB: Not using derive_more::Display since Clion doesn't understand it.
impl fmt::Display for GetSceneError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{:?}", self)
}
}
#[utoipa::path(
get,
path = "/v1/engine/scene/{token}",
responses(
(status = 200, description = "Found", body = GetSceneSuccessResponse),
(status = 404, description = "Not found", body = GetSceneError),
(status = 500, description = "Server error", body = GetSceneError),
),
params(
("path" = GetScenePathInfo, description = "Path for Request")
)
)]
pub async fn get_scene_handler(
http_request: HttpRequest,
path: Path<GetScenePathInfo>,
server_state: web::Data<Arc<ServerState>>) -> Result<HttpResponse, GetSceneError>
{
let media_file_token = path.into_inner().token;
let response = modern_media_file_lookup(&media_file_token,
false, &server_state).await?;
let body = serde_json::to_string(&response)
.map_err(|e| GetSceneError::ServerError)?;
Ok(HttpResponse::Ok()
.content_type("application/json")
.body(body))
}
async fn modern_media_file_lookup(
media_file_token: &MediaFileToken,
show_deleted_results: bool,
server_state: &ServerState,
) -> Result<GetSceneSuccessResponse, GetSceneError> {
let result = get_media_file(
media_file_token,
show_deleted_results,
&server_state.mysql_pool
).await;
let result = match result {
Err(e) => {
warn!("query error: {:?}", e);
return Err(GetSceneError::ServerError);
}
Ok(None) => return Err(GetSceneError::NotFound),
Ok(Some(result)) => result,
};
let public_bucket_path = MediaFileBucketPath::from_object_hash(
&result.public_bucket_directory_hash,
result.maybe_public_bucket_prefix.as_deref(),
result.maybe_public_bucket_extension.as_deref())
.get_full_object_path_str()
.to_string();
let maybe_cover_image_public_bucket_path = match result.maybe_model_cover_image_public_bucket_hash
.as_deref()
{
None => None,
Some(hash) => Some(MediaFileBucketPath::from_object_hash(
&hash,
result.maybe_model_cover_image_public_bucket_prefix.as_deref(),
result.maybe_model_cover_image_public_bucket_extension.as_deref())
.get_full_object_path_str()
.to_string()
)
};
Ok(GetSceneSuccessResponse {
success: true,
media_file: MediaFileInfo {
token: result.token,
media_type: result.media_type,
public_bucket_path,
created_at: result.created_at,
updated_at: result.updated_at,
},
})
}
@@ -0,0 +1,3 @@
pub mod create_scene_handler;
pub mod get_scene_handler;
pub mod update_scene_handler;
@@ -0,0 +1,39 @@
use std::collections::HashSet;
use std::sync::Arc;
use actix_multipart::Multipart;
use actix_web::{HttpRequest, HttpResponse, web};
use once_cell::sync::Lazy;
use tokens::tokens::media_files::MediaFileToken;
use crate::http_server::endpoints::media_uploads::common::handle_upload::handle_upload;
use crate::http_server::endpoints::media_uploads::common::upload_error::UploadError;
use crate::server_state::ServerState;
#[derive(Serialize)]
pub struct UpdateSceneSuccessResponse {
pub success: bool,
pub media_file_token: MediaFileToken,
}
pub async fn update_scene_handler(
http_request: HttpRequest,
server_state: web::Data<Arc<ServerState>>,
mut multipart_payload: Multipart,
) -> Result<HttpResponse, UploadError> {
// TODO(bt): Handle upload / save.
let response = UpdateSceneSuccessResponse {
success: true,
media_file_token: MediaFileToken::new_from_str("TODO"),
};
let body = serde_json::to_string(&response)
.map_err(|e| UploadError::ServerError)?;
return Ok(HttpResponse::Ok()
.content_type("application/json")
.body(body));
}
@@ -4,6 +4,7 @@ pub mod categories;
pub mod comments;
pub mod conversion;
pub mod download_job;
pub mod engine;
pub mod events;
pub mod flags;
pub mod image_gen;
@@ -13,6 +14,7 @@ pub mod leaderboard;
pub mod media_files;
pub mod media_uploads;
pub mod misc;
pub mod mocap;
pub mod moderation;
pub mod service;
pub mod stats;
@@ -29,5 +31,4 @@ pub mod voice_conversion;
pub mod voice_designer;
pub mod w2l;
pub mod weights;
pub(crate) mod mocap;
pub(crate) mod workflows;
pub mod workflows;
@@ -30,6 +30,9 @@ use crate::http_server::endpoints::conversion::enqueue_bvh_to_workflow_handler::
use crate::http_server::endpoints::conversion::enqueue_fbx_to_gltf_handler::enqueue_fbx_to_gltf_handler;
use crate::http_server::endpoints::download_job::enqueue_generic_download::enqueue_generic_download_handler;
use crate::http_server::endpoints::download_job::get_generic_upload_job_status::get_generic_download_job_status_handler;
use crate::http_server::endpoints::engine::create_scene_handler::create_scene_handler;
use crate::http_server::endpoints::engine::get_scene_handler::get_scene_handler;
use crate::http_server::endpoints::engine::update_scene_handler::update_scene_handler;
use crate::http_server::endpoints::events::list_events::list_events_handler;
use crate::http_server::endpoints::flags::design_refresh_flag::disable_design_refresh_flag_handler::disable_design_refresh_flag_handler;
use crate::http_server::endpoints::flags::design_refresh_flag::enable_design_refresh_flag_handler::enable_design_refresh_flag_handler;
@@ -202,8 +205,10 @@ pub fn add_routes<T, B> (app: App<T>, server_environment: ServerEnvironment) ->
app = add_user_rating_routes(app); /* /v1/user_rating/... */
app = add_subscription_routes(app); /* /v1/subscriptions/... */
app = add_voice_designer_routes(app); /* /v1/voice_designer */
app = add_image_gen_routes(app);
app = add_weights_routes(app);
app = add_image_gen_routes(app);
app = add_weights_routes(app);
app = add_engine_routes(app); /* /v1/engine/... */
// if server_environment == ServerEnvironment::Development {
//
// }
@@ -1352,4 +1357,28 @@ fn add_weights_routes<T, B>(app: App<T>) -> App<T>
.route("/list", web::get().to(list_available_weights_handler))
.route("/list_featured", web::get().to(list_featured_weights_handler))
)
}
}
// ==================== Engine Routes ====================
fn add_engine_routes<T, B>(app: App<T>) -> App<T>
where
B: MessageBody,
T: ServiceFactory<
ServiceRequest,
Config = (),
Response = ServiceResponse<B>,
Error = Error,
InitError = ()
>
{
app.service(web::scope("/v1/engine")
.service(web::resource("/create_scene")
.route(web::post().to(create_scene_handler))
.route(web::head().to(|| HttpResponse::Ok()))
)
.service(web::resource("/scene/{token}")
.route(web::get().to(get_scene_handler))
.route(web::post().to(update_scene_handler))
)
)
}