diff --git a/prudpv1/src/prudp/socket.rs b/prudpv1/src/prudp/socket.rs index c04f106..c6f5faa 100644 --- a/prudpv1/src/prudp/socket.rs +++ b/prudpv1/src/prudp/socket.rs @@ -16,6 +16,7 @@ use std::io::Cursor; use std::marker::PhantomData; use std::ops::Deref; use std::sync::{Arc, Weak}; +use tokio::spawn; use v_byte_helpers::ReadExtensions; use v_byte_helpers::little_endian::read_u16; @@ -68,6 +69,33 @@ impl InternalConnection { prev_val } + async fn close_connection(&mut self) { + let mut packet = PRUDPV1Packet { + header: PRUDPV1Header { + sequence_id: self.next_server_count(), + substream_id: 0, + session_id: self.session_id, + types_and_flags: TypesFlags::default().types(DISCONNECT), + destination_port: self.common.socket_addr.virtual_port, + source_port: self.server_port, + ..Default::default() + }, + payload: Vec::new(), + options: vec![FragmentId(0)], + ..Default::default() + }; + + // no need for encryption the, the payload is empty + + packet.set_sizes(); + + self.crypto_handler_instance.sign_packet(&mut packet); + + self.send_raw_packet(&packet).await; + + self.delete_connection().await; + } + /// Sends a raw packet to a given client on the connection /// /// a raw packet is one which does not get processed any further(other than to send it @@ -103,7 +131,7 @@ pub struct ExternalConnection { #[derive(Clone)] pub struct SendingConnection { common: Arc, - internal: Weak>, + internal: Weak, } pub struct CommonSocket { @@ -166,80 +194,67 @@ pub(super) trait AnyInternalSocket: } #[async_trait] -pub(super) trait AnyInternalConnection: - Send + Sync + Deref + 'static -{ - async fn send_data_packet(&mut self, data: Vec); +pub(super) trait AnyInternalConnection: Send + Sync + 'static { + async fn send_data_packet(&self, data: Vec); - async fn close_connection(&mut self); + async fn close_connection(&self); } #[async_trait] -impl AnyInternalConnection for InternalConnection { - async fn send_data_packet(&mut self, data: Vec) { +impl AnyInternalConnection for Mutex> { + async fn send_data_packet(&self, data: Vec) { let pieces = data.chunks(600); let max_piece = pieces.len() - 1; let mut piece_num = 1; - for (i, piece) in pieces.enumerate() { - let mut packet = PRUDPV1Packet { - header: PRUDPV1Header { - sequence_id: self.next_server_count(), - substream_id: 0, - session_id: self.session_id, - types_and_flags: TypesFlags::default().types(DATA).flags(RELIABLE | NEED_ACK), - destination_port: self.common.socket_addr.virtual_port, - source_port: self.server_port, + let mut locked = self.lock().await; + let packets: Vec<_> = pieces + .enumerate() + .map(|(i, piece)| { + let mut packet = PRUDPV1Packet { + header: PRUDPV1Header { + sequence_id: locked.next_server_count(), + substream_id: 0, + session_id: locked.session_id, + types_and_flags: TypesFlags::default() + .types(DATA) + .flags(RELIABLE | NEED_ACK), + destination_port: locked.common.socket_addr.virtual_port, + source_port: locked.server_port, + ..Default::default() + }, + payload: piece.to_owned(), + options: vec![FragmentId(if i == max_piece { 0 } else { piece_num })], ..Default::default() - }, - payload: piece.to_owned(), - options: vec![FragmentId(if i == max_piece { 0 } else { piece_num })], - ..Default::default() - }; + }; - self.crypto_handler_instance - .encrypt_outgoing(0, &mut packet.payload[..]); + locked + .crypto_handler_instance + .encrypt_outgoing(0, &mut packet.payload[..]); - packet.set_sizes(); + packet.set_sizes(); - self.crypto_handler_instance.sign_packet(&mut packet); + locked.crypto_handler_instance.sign_packet(&mut packet); - self.send_raw_packet(&packet).await; + piece_num += 1; + packet + }) + .collect(); + drop(locked); - self.unacknowleged_packets.push((Instant::now(), packet)); + for packet in packets { + let mut locked = self.lock().await; + locked.send_raw_packet(&packet).await; + locked.unacknowleged_packets.push((Instant::now(), packet)); + drop(locked); sleep(Duration::from_secs(16)).await; - - piece_num += 1; } } - async fn close_connection(&mut self) { - // jon confirmed that this should be a safe way to dc a client + async fn close_connection(&self) { + let mut locked = self.lock().await; - let mut packet = PRUDPV1Packet { - header: PRUDPV1Header { - sequence_id: self.next_server_count(), - substream_id: 0, - session_id: self.session_id, - types_and_flags: TypesFlags::default().types(DISCONNECT), - destination_port: self.common.socket_addr.virtual_port, - source_port: self.server_port, - ..Default::default() - }, - payload: Vec::new(), - options: vec![FragmentId(0)], - ..Default::default() - }; - - // no need for encryption the, the payload is empty - - packet.set_sizes(); - - self.crypto_handler_instance.sign_packet(&mut packet); - - self.send_raw_packet(&packet).await; - - self.delete_connection().await; + locked.close_connection().await; } } @@ -403,7 +418,7 @@ impl InternalSocket { let internal = Arc::new(Mutex::new(internal)); - let dyn_internal: Arc> = internal.clone(); + let dyn_internal: Arc = internal.clone(); let external = ExternalConnection { sending: SendingConnection { @@ -884,10 +899,9 @@ impl ExternalConnection { impl SendingConnection { pub async fn send(&self, data: Vec) -> Option<()> { let internal = self.internal.upgrade()?; - - let mut internal = internal.lock().await; - - internal.send_data_packet(data).await; + spawn(async move { + internal.send_data_packet(data).await; + }); Some(()) } @@ -896,8 +910,6 @@ impl SendingConnection { return; }; - let mut internal = internal.lock().await; - internal.close_connection().await; } } diff --git a/rnex-core/src/executables/common.rs b/rnex-core/src/executables/common.rs index b2ea50d..c94a463 100644 --- a/rnex-core/src/executables/common.rs +++ b/rnex-core/src/executables/common.rs @@ -22,6 +22,7 @@ const IP_REQ_SERVICE_URL: &str = "https://ipinfo.io/ip"; cfg_if! { if #[cfg(feature = "datastore")] { + use std::sync::{LazyLock, OnceLock}; pub static RNEX_DATASTORE_DATABASE_URL: LazyLock = LazyLock::new(|| { std::env::var("RNEX_DATASTORE_DATABASE_URL") .expect("RNEX_DATASTORE_DATABASE_URL must be set") diff --git a/rnex-core/src/nex/datastore.rs b/rnex-core/src/nex/datastore.rs index 763bc3e..fad7300 100644 --- a/rnex-core/src/nex/datastore.rs +++ b/rnex-core/src/nex/datastore.rs @@ -1,140 +1,144 @@ -use cfg_if::cfg_if; -cfg_if! { - if #[cfg(feature = "datastore")] { - use crate::define_rmc_proto; - use macros::rmc_struct; - use rnex_core::prudp::socket_addr::PRUDPSockAddr; - use std::sync::{Weak}; - use chrono::Utc; - use sqlx::types::time; - use sqlx::types::time::PrimitiveDateTime; - use rnex_core::PID; - use rnex_core::nex::remote_console::RemoteConsole; - use rnex_core::nex::s3presigner::S3Presigner; - use rnex_core::rmc::response::ErrorCode; - use rnex_core::rmc::protocols::secure::{Secure, RawSecure, RawSecureInfo, RemoteSecure}; - use rnex_core::rmc::protocols::datastore::{BufferQueueParam, CompletePostParam, DataStoreCustomRankingResult, DataStoreGetCustomRankingByDataIDParam, DataStorePrepareGetParam, DataStoreReqGetInfo, DataStoreSearchParam, GetMetaInfo, GetMetaParam, KeyValue, Permission, PersistenceTarget, RateCustomRankingParam, RatingInfo, RatingInfoWithSlot}; - use rnex_core::rmc::protocols::datastore::{DataStore, RawDataStore, RawDataStoreInfo, RemoteDataStore, PreparePostParam, ReqPostInfo}; - use crate::nex::user::User; - use rnex_core::executables::common::{RNEX_DATASTORE_S3_BUCKET, RNEX_DATASTORE_S3_ENDPOINT, get_db}; - use rnex_core::rmc::structures::qbuffer::QBuffer; - use sqlx::types::chrono::DateTime; - use rnex_core::kerberos::KerberosDateTime; - use rnex_core::rmc::structures::qresult::QResult; +use crate::nex::user::User; +use rnex_core::executables::common::{ + RNEX_DATASTORE_S3_BUCKET, RNEX_DATASTORE_S3_ENDPOINT, get_db, +}; +use rnex_core::kerberos::KerberosDateTime; +use rnex_core::nex::s3presigner::S3Presigner; +use rnex_core::rmc::protocols::datastore::{ + BufferQueueParam, CompletePostParam, DataStoreCustomRankingResult, + DataStoreGetCustomRankingByDataIDParam, DataStorePrepareGetParam, DataStoreReqGetInfo, + DataStoreSearchParam, GetMetaInfo, GetMetaParam, KeyValue, Permission, PersistenceTarget, + RateCustomRankingParam, RatingInfo, RatingInfoWithSlot, +}; +use rnex_core::rmc::protocols::datastore::{DataStore, PreparePostParam, ReqPostInfo}; +use rnex_core::rmc::response::ErrorCode; +use rnex_core::rmc::structures::qbuffer::QBuffer; +use rnex_core::rmc::structures::qresult::QResult; +use sqlx::types::time; - fn map_row_to_meta_info( - row_data_id: i64, - row_owner: i32, - row_size: i32, - row_name: String, - row_data_type: i16, - row_meta_binary: Vec, - row_permission: i16, - row_permission_recipients: Vec, - row_delete_permission: i16, - row_delete_permission_recipients: Vec, - row_period: i16, - row_refer_data_id: i64, - row_flag: i32, - row_tags: Vec, - row_creation_date: chrono::NaiveDateTime, - row_update_date: chrono::NaiveDateTime, - ratings: Vec - ) -> GetMetaInfo { - GetMetaInfo { - dataid: row_data_id as u64, - owner: row_owner as u32, - size: row_size as u32, - name: row_name, - data_type: row_data_type as u16, - meta_binary: QBuffer(row_meta_binary), - permission: Permission { - permission: row_permission as u8, - recipient_ids: row_permission_recipients.into_iter().map(|id| id as u32).collect(), - }, - del_permission: Permission { - permission: row_delete_permission as u8, - recipient_ids: row_delete_permission_recipients.into_iter().map(|id| id as u32).collect(), - }, - period: row_period as u16, - status: 0, - referred_count: 0, - refer_dat_id: row_refer_data_id as u32, - flag: row_flag as u32, - tags: row_tags, - expire_time: KerberosDateTime::from_u64(0x9C3F3E0000), - created_time: KerberosDateTime::from_naive(row_creation_date), - updated_time: KerberosDateTime::from_naive(row_update_date), - referred_time: KerberosDateTime::from_naive(row_creation_date), - ratings, - } - } +fn map_row_to_meta_info( + row_data_id: i64, + row_owner: i32, + row_size: i32, + row_name: String, + row_data_type: i16, + row_meta_binary: Vec, + row_permission: i16, + row_permission_recipients: Vec, + row_delete_permission: i16, + row_delete_permission_recipients: Vec, + row_period: i16, + row_refer_data_id: i64, + row_flag: i32, + row_tags: Vec, + row_creation_date: chrono::NaiveDateTime, + row_update_date: chrono::NaiveDateTime, + ratings: Vec, +) -> GetMetaInfo { + GetMetaInfo { + dataid: row_data_id as u64, + owner: row_owner as u32, + size: row_size as u32, + name: row_name, + data_type: row_data_type as u16, + meta_binary: QBuffer(row_meta_binary), + permission: Permission { + permission: row_permission as u8, + recipient_ids: row_permission_recipients + .into_iter() + .map(|id| id as u32) + .collect(), + }, + del_permission: Permission { + permission: row_delete_permission as u8, + recipient_ids: row_delete_permission_recipients + .into_iter() + .map(|id| id as u32) + .collect(), + }, + period: row_period as u16, + status: 0, + referred_count: 0, + refer_dat_id: row_refer_data_id as u32, + flag: row_flag as u32, + tags: row_tags, + expire_time: KerberosDateTime::from_u64(0x9C3F3E0000), + created_time: KerberosDateTime::from_naive(row_creation_date), + updated_time: KerberosDateTime::from_naive(row_update_date), + referred_time: KerberosDateTime::from_naive(row_creation_date), + ratings, + } +} - async fn check_object_availability(data_id: u64, password: u64) -> Result<(), ErrorCode> { - let row = sqlx::query!( - r#" +async fn check_object_availability(data_id: u64, password: u64) -> Result<(), ErrorCode> { + let row = sqlx::query!( + r#" SELECT under_review, access_password FROM datastore.objects WHERE data_id = $1 AND upload_completed = TRUE AND deleted = FALSE "#, - data_id as i64 - ) - .fetch_optional(get_db()) - .await - .map_err(|e| { - eprintln!("Availability check DB error: {:?}", e); - ErrorCode::DataStore_SystemFileError - })? - .ok_or(ErrorCode::DataStore_NotFound)?; + data_id as i64 + ) + .fetch_optional(get_db()) + .await + .map_err(|e| { + eprintln!("Availability check DB error: {:?}", e); + ErrorCode::DataStore_SystemFileError + })? + .ok_or(ErrorCode::DataStore_NotFound)?; - let access_password = row.access_password as u64; - if access_password != 0 && access_password != password { - return Err(ErrorCode::DataStore_InvalidPassword); - } + let access_password = row.access_password as u64; + if access_password != 0 && access_password != password { + return Err(ErrorCode::DataStore_InvalidPassword); + } - if row.under_review { - return Err(ErrorCode::DataStore_UnderReviewing); - } + if row.under_review { + return Err(ErrorCode::DataStore_UnderReviewing); + } - Ok(()) - } + Ok(()) +} - async fn get_object_ratings(data_id: u64, password: u64) -> Result, ErrorCode> { - check_object_availability(data_id, password).await?; +async fn get_object_ratings( + data_id: u64, + password: u64, +) -> Result, ErrorCode> { + check_object_availability(data_id, password).await?; - let rows = sqlx::query!( - r#" + let rows = sqlx::query!( + r#" SELECT slot, total_value, count, initial_value FROM datastore.object_ratings WHERE data_id = $1 "#, - data_id as i64 - ) - .fetch_all(get_db()) - .await - .map_err(|e| { - eprintln!("Ratings fetch error: {:?}", e); - ErrorCode::DataStore_SystemFileError - })?; + data_id as i64 + ) + .fetch_all(get_db()) + .await + .map_err(|e| { + eprintln!("Ratings fetch error: {:?}", e); + ErrorCode::DataStore_SystemFileError + })?; - let ratings = rows.into_iter().map(|row| { - RatingInfoWithSlot { - slot: row.slot as i8, - rating: RatingInfo { - total_value: row.total_value.unwrap_or(0), - count: row.count as u32, - initial_value: row.initial_value.unwrap_or(0), - }, - } - }).collect(); + let ratings = rows + .into_iter() + .map(|row| RatingInfoWithSlot { + slot: row.slot as i8, + rating: RatingInfo { + total_value: row.total_value.unwrap_or(0), + count: row.count as u32, + initial_value: row.initial_value.unwrap_or(0), + }, + }) + .collect(); - Ok(ratings) - } + Ok(ratings) +} - async fn get_object_info_by_data_id(data_id: u64, password: u64) -> Result { - check_object_availability(data_id, password).await?; +async fn get_object_info_by_data_id(data_id: u64, password: u64) -> Result { + check_object_availability(data_id, password).await?; - let row = sqlx::query!( + let row = sqlx::query!( r#"SELECT data_id, owner, size, name, data_type, meta_binary, permission, permission_recipients, delete_permission, delete_permission_recipients, period, refer_data_id, flag, tags, creation_date, update_date @@ -146,37 +150,68 @@ cfg_if! { .map_err(|_| ErrorCode::DataStore_SystemFileError)? .ok_or(ErrorCode::DataStore_NotFound)?; - let ratings = get_object_ratings(data_id, password).await?; + let ratings = get_object_ratings(data_id, password).await?; - Ok(map_row_to_meta_info( - row.data_id, - row.owner.unwrap_or(0), - row.size.unwrap_or(0), - row.name.unwrap_or_default(), - row.data_type.unwrap_or(0) as i16, - row.meta_binary.unwrap_or_default(), - row.permission.unwrap_or(0) as i16, - row.permission_recipients.unwrap_or_default().into_iter().map(|id| id as i64).collect(), - row.delete_permission.unwrap_or(0) as i16, - row.delete_permission_recipients.unwrap_or_default().into_iter().map(|id| id as i64).collect(), - row.period.unwrap_or(0) as i16, - row.refer_data_id.unwrap_or(0), - row.flag.unwrap_or(0), - row.tags.unwrap_or_default(), - row.creation_date.map(|dt| chrono::NaiveDateTime::new( - chrono::NaiveDate::from_ymd_opt(dt.year(), dt.month() as u32, dt.day() as u32).unwrap(), - chrono::NaiveTime::from_hms_opt(dt.hour() as u32, dt.minute() as u32, dt.second() as u32).unwrap() - )).unwrap_or_default(), - row.update_date.map(|dt| chrono::NaiveDateTime::new( - chrono::NaiveDate::from_ymd_opt(dt.year(), dt.month() as u32, dt.day() as u32).unwrap(), - chrono::NaiveTime::from_hms_opt(dt.hour() as u32, dt.minute() as u32, dt.second() as u32).unwrap() - )).unwrap_or_default(), - ratings - )) - } + Ok(map_row_to_meta_info( + row.data_id, + row.owner.unwrap_or(0), + row.size.unwrap_or(0), + row.name.unwrap_or_default(), + row.data_type.unwrap_or(0) as i16, + row.meta_binary.unwrap_or_default(), + row.permission.unwrap_or(0) as i16, + row.permission_recipients + .unwrap_or_default() + .into_iter() + .map(|id| id as i64) + .collect(), + row.delete_permission.unwrap_or(0) as i16, + row.delete_permission_recipients + .unwrap_or_default() + .into_iter() + .map(|id| id as i64) + .collect(), + row.period.unwrap_or(0) as i16, + row.refer_data_id.unwrap_or(0), + row.flag.unwrap_or(0), + row.tags.unwrap_or_default(), + row.creation_date + .map(|dt| { + chrono::NaiveDateTime::new( + chrono::NaiveDate::from_ymd_opt(dt.year(), dt.month() as u32, dt.day() as u32) + .unwrap(), + chrono::NaiveTime::from_hms_opt( + dt.hour() as u32, + dt.minute() as u32, + dt.second() as u32, + ) + .unwrap(), + ) + }) + .unwrap_or_default(), + row.update_date + .map(|dt| { + chrono::NaiveDateTime::new( + chrono::NaiveDate::from_ymd_opt(dt.year(), dt.month() as u32, dt.day() as u32) + .unwrap(), + chrono::NaiveTime::from_hms_opt( + dt.hour() as u32, + dt.minute() as u32, + dt.second() as u32, + ) + .unwrap(), + ) + }) + .unwrap_or_default(), + ratings, + )) +} - async fn get_object_info_by_persistence_target(target: PersistenceTarget, password: u64) -> Result { - let row = sqlx::query!( +async fn get_object_info_by_persistence_target( + target: PersistenceTarget, + password: u64, +) -> Result { + let row = sqlx::query!( r#"SELECT data_id, owner, size, name, data_type, meta_binary, permission, permission_recipients, delete_permission, delete_permission_recipients, period, refer_data_id, flag, tags, creation_date, update_date, @@ -192,124 +227,146 @@ cfg_if! { .map_err(|_| ErrorCode::DataStore_SystemFileError)? .ok_or(ErrorCode::DataStore_NotFound)?; - let db_password = row.access_password as u64; - if db_password != 0 && db_password != password { - return Err(ErrorCode::DataStore_InvalidPassword); - } + let db_password = row.access_password as u64; + if db_password != 0 && db_password != password { + return Err(ErrorCode::DataStore_InvalidPassword); + } - if row.under_review { - return Err(ErrorCode::DataStore_UnderReviewing); - } + if row.under_review { + return Err(ErrorCode::DataStore_UnderReviewing); + } - let ratings = get_object_ratings(row.data_id as u64, password).await?; + let ratings = get_object_ratings(row.data_id as u64, password).await?; - Ok(map_row_to_meta_info( - row.data_id, - row.owner.unwrap_or(0), - row.size.unwrap_or(0), - row.name.unwrap_or_default(), - row.data_type.unwrap_or(0) as i16, - row.meta_binary.unwrap_or_default(), - row.permission.unwrap_or(0) as i16, - row.permission_recipients.unwrap_or_default().into_iter().map(|id| id as i64).collect(), - row.delete_permission.unwrap_or(0) as i16, - row.delete_permission_recipients.unwrap_or_default().into_iter().map(|id| id as i64).collect(), - row.period.unwrap_or(0) as i16, - row.refer_data_id.unwrap_or(0), - row.flag.unwrap_or(0), - row.tags.unwrap_or_default(), - row.creation_date.map(|dt| chrono::NaiveDateTime::new( - chrono::NaiveDate::from_ymd_opt(dt.year(), dt.month() as u32, dt.day() as u32).unwrap(), - chrono::NaiveTime::from_hms_opt(dt.hour() as u32, dt.minute() as u32, dt.second() as u32).unwrap() - )).unwrap_or_default(), - row.update_date.map(|dt| chrono::NaiveDateTime::new( - chrono::NaiveDate::from_ymd_opt(dt.year(), dt.month() as u32, dt.day() as u32).unwrap(), - chrono::NaiveTime::from_hms_opt(dt.hour() as u32, dt.minute() as u32, dt.second() as u32).unwrap() - )).unwrap_or_default(), - ratings - )) - } + Ok(map_row_to_meta_info( + row.data_id, + row.owner.unwrap_or(0), + row.size.unwrap_or(0), + row.name.unwrap_or_default(), + row.data_type.unwrap_or(0) as i16, + row.meta_binary.unwrap_or_default(), + row.permission.unwrap_or(0) as i16, + row.permission_recipients + .unwrap_or_default() + .into_iter() + .map(|id| id as i64) + .collect(), + row.delete_permission.unwrap_or(0) as i16, + row.delete_permission_recipients + .unwrap_or_default() + .into_iter() + .map(|id| id as i64) + .collect(), + row.period.unwrap_or(0) as i16, + row.refer_data_id.unwrap_or(0), + row.flag.unwrap_or(0), + row.tags.unwrap_or_default(), + row.creation_date + .map(|dt| { + chrono::NaiveDateTime::new( + chrono::NaiveDate::from_ymd_opt(dt.year(), dt.month() as u32, dt.day() as u32) + .unwrap(), + chrono::NaiveTime::from_hms_opt( + dt.hour() as u32, + dt.minute() as u32, + dt.second() as u32, + ) + .unwrap(), + ) + }) + .unwrap_or_default(), + row.update_date + .map(|dt| { + chrono::NaiveDateTime::new( + chrono::NaiveDate::from_ymd_opt(dt.year(), dt.month() as u32, dt.day() as u32) + .unwrap(), + chrono::NaiveTime::from_hms_opt( + dt.hour() as u32, + dt.minute() as u32, + dt.second() as u32, + ) + .unwrap(), + ) + }) + .unwrap_or_default(), + ratings, + )) +} - async fn get_buffer_queues_by_data_id_and_slot( - data_id: u64, - slot: u32 - ) -> Result, ErrorCode> { - check_object_availability(data_id, 0).await?; +async fn get_buffer_queues_by_data_id_and_slot( + data_id: u64, + slot: u32, +) -> Result, ErrorCode> { + check_object_availability(data_id, 0).await?; - let rows = sqlx::query!( - r#" + let rows = sqlx::query!( + r#" SELECT buffer FROM datastore.buffer_queues WHERE data_id = $1 AND slot = $2 ORDER BY creation_date ASC "#, - data_id as i64, - slot as i32 - ) - .fetch_all(get_db()) - .await - .map_err(|e| { - log::error!("Buffer queue fetch error: {:?}", e); - ErrorCode::DataStore_SystemFileError - })?; + data_id as i64, + slot as i32 + ) + .fetch_all(get_db()) + .await + .map_err(|e| { + log::error!("Buffer queue fetch error: {:?}", e); + ErrorCode::DataStore_SystemFileError + })?; - let buffer_queues = rows - .into_iter() - .map(|row| QBuffer(row.buffer)) - .collect(); + let buffer_queues = rows.into_iter().map(|row| QBuffer(row.buffer)).collect(); - Ok(buffer_queues) - } + Ok(buffer_queues) +} - fn verify_object_permission( - owner_id: u32, - viewer_id: u32, - permission: &Permission, - ) -> Result<(), ErrorCode> { - if owner_id == viewer_id { - return Ok(()); - } +fn verify_object_permission( + owner_id: u32, + viewer_id: u32, + permission: &Permission, +) -> Result<(), ErrorCode> { + if owner_id == viewer_id { + return Ok(()); + } - match permission.permission { - 0 => Ok(()), // All can read - 1 => Err(ErrorCode::DataStore_PermissionDenied), // Friends only, unimplemented - 2 => { - // Recipient IDs can read - if permission.recipient_ids.contains(&viewer_id) { - Ok(()) - } else { - Err(ErrorCode::DataStore_PermissionDenied) - } - } - 3 => Err(ErrorCode::DataStore_PermissionDenied), // Owner only, redundant - _ => Err(ErrorCode::DataStore_InvalidArgument), // ??? haxx0r + match permission.permission { + 0 => Ok(()), // All can read + 1 => Err(ErrorCode::DataStore_PermissionDenied), // Friends only, unimplemented + 2 => { + // Recipient IDs can read + if permission.recipient_ids.contains(&viewer_id) { + Ok(()) + } else { + Err(ErrorCode::DataStore_PermissionDenied) } } + 3 => Err(ErrorCode::DataStore_PermissionDenied), // Owner only, redundant + _ => Err(ErrorCode::DataStore_InvalidArgument), // ??? haxx0r + } +} - fn filter_properties_by_result_option( - meta_info: &mut GetMetaInfo, - result_option: u8, - ) { - if (result_option & 0x01) == 0 { - meta_info.meta_binary = QBuffer(Vec::new()); - } +fn filter_properties_by_result_option(meta_info: &mut GetMetaInfo, result_option: u8) { + if (result_option & 0x01) == 0 { + meta_info.meta_binary = QBuffer(Vec::new()); + } - if (result_option & 0x04) == 0 { - meta_info.ratings = Vec::new(); - } + if (result_option & 0x04) == 0 { + meta_info.ratings = Vec::new(); + } - // No idea what the other things do. :shrug: - } + // No idea what the other things do. :shrug: +} - // Dawg... - async fn get_custom_rankings_by_data_ids( - application_id: u32, - data_ids: Vec - ) -> Vec { - let mut results = Vec::with_capacity(data_ids.len()); +// Dawg... +async fn get_custom_rankings_by_data_ids( + application_id: u32, + data_ids: Vec, +) -> Vec { + let mut results = Vec::with_capacity(data_ids.len()); - let rows = sqlx::query!( - r#" + let rows = sqlx::query!( + r#" SELECT rankings.data_id, rankings.value @@ -319,124 +376,263 @@ cfg_if! { AND rankings.application_id = $2 ORDER BY rows.ord "#, - &data_ids.iter().map(|&id| id as i64).collect::>(), - application_id as i32 - ) - .fetch_all(get_db()) - .await; + &data_ids.iter().map(|&id| id as i64).collect::>(), + application_id as i32 + ) + .fetch_all(get_db()) + .await; - let rows = match rows { - Ok(r) => r, - Err(e) => { - log::error!("Custom ranking query error: {:?}", e); - return results; - } - }; - - for row in rows { - let data_id = row.data_id as u64; - let score = row.value.unwrap_or(0) as u32; - - if let Ok(meta) = get_object_info_by_data_id(data_id, 0).await { - results.push(DataStoreCustomRankingResult { - order: 0, - score, - meta_info: meta, - }); - } else { - log::warn!("Could not find metadata for ranked object {}", data_id); - } - } - - results + let rows = match rows { + Ok(r) => r, + Err(e) => { + log::error!("Custom ranking query error: {:?}", e); + return results; } + }; - async fn get_user_course_object_ids(owner_pid: u32) -> Result, ErrorCode> { - let rows = sqlx::query!( - r#" + for row in rows { + let data_id = row.data_id as u64; + let score = row.value.unwrap_or(0) as u32; + + if let Ok(meta) = get_object_info_by_data_id(data_id, 0).await { + results.push(DataStoreCustomRankingResult { + order: 0, + score, + meta_info: meta, + }); + } else { + log::warn!("Could not find metadata for ranked object {}", data_id); + } + } + + results +} + +async fn get_user_course_object_ids(owner_pid: u32) -> Result, ErrorCode> { + let rows = sqlx::query!( + r#" SELECT data_id FROM datastore.objects WHERE owner = $1 AND data_type > 2 AND data_type < 50 "#, - owner_pid as i64 + owner_pid as i64 + ) + .fetch_all(get_db()) + .await + .map_err(|e| { + log::error!("error fetching course IDs for PID {}: {:?}", owner_pid, e); + ErrorCode::DataStore_SystemFileError + })?; + + let mut valid_ids = Vec::new(); + for row in rows { + let data_id = row.data_id as u64; + // always check avail + if check_object_availability(data_id, 0).await.is_ok() { + valid_ids.push(data_id); + } + } + + Ok(valid_ids) +} + +fn get_blacklist_1() -> Vec { + vec![ + "けされ", + "消され", + "削除され", + "リセットされ", + "BANされ", + "ＢＡＮされ", + "キミのコース", + "君のコース", + "きみのコース", + "い い ね", + "遊びます", + "地震", + "震災", + "被災", + "津波", + "バンされ", + "い~ね", + "震度", + "じしん", + "banされ", + "くわしくは", + "詳しくは", + "ちんちん", + "ち0こ", + "bicth", + "い.い．ね", + "ナイ～ス", + "い&い", + "い-いね", + "いぃね", + "nigger", + "ngger", + "star if u", + "Star if u", + "Star if you", + "star if you", + "PENlS", + "マンコ", + "butthole", + "LILI", + "vagina", + "vagyna", + "うんち", + "うんこ", + "ウンコ", + "Ｉｉｎｅ", + "EENE", + "まんこ", + "ウンチ", + "niglet", + "nigglet", + "please like", + "きんたま", + "Butthole", + "llね", + "iいね", + "give a star", + "ちんぽ", + "亀頭", + "penis", + "ｳﾝｺ", + "plz more stars", + "star plz", + "い()ね", + "PLEASE star", + "Bitte Sterne", + ] + .into_iter() + .map(String::from) + .collect() +} + +fn get_blacklist_2() -> Vec { + vec![ + "ゼロから", + "０から", + "0から", + "い　　い　　ね", + "いい", + "東日本", + "大震", + ] + .into_iter() + .map(String::from) + .collect() +} + +fn get_blacklist_3() -> Vec { + vec![ + "いいね", + "下さい", + "ください", + "押して", + "おして", + "返す", + "かえす", + "星", + "してくれ", + "するよ", + "☆くれたら", + "☆あげます", + "★くれたら", + "★あげます", + "しね", + "ころす", + "ころされた", + "アナル", + "ファック", + "キンタマ", + "○ね", + "キチガイ", + "うんこ", + "KITIGAI", + "金玉", + "おっぱい", + "☆おす", + "☆押す", + "★おす", + "★押す", + "いいする", + "いいよ", + "イイネ", + "ケツ", + "うんち", + "かくせいざい", + "覚せい剤", + "シャブ", + "きんたま", + "ちんちん", + "おしっこ", + "ちんぽこ", + "ころして", + "グッド", + "グット", + "レ●プ", + "バーカ", + "きちがい", + "ちんげ", + "マンコ", + "まんこ", + "チンポ", + "クズ", + "ウンコ", + "ナイスおねがいします", + "penis", + "イイね", + "☆よろ", + "ナイス!して", + "ま/んこ", + "まん/こ", + ] + .into_iter() + .map(String::from) + .collect() +} + +impl DataStore for User { + async fn get_meta(&self, mut metaparam: GetMetaParam) -> Result { + let mut meta_info = if metaparam.dataid != 0 { + get_object_info_by_data_id(metaparam.dataid, metaparam.access_password).await? + } else { + get_object_info_by_persistence_target( + metaparam.persistence_target, + metaparam.access_password, ) - .fetch_all(get_db()) - .await - .map_err(|e| { - log::error!("error fetching course IDs for PID {}: {:?}", owner_pid, e); - ErrorCode::DataStore_SystemFileError - })?; + .await? + }; - let mut valid_ids = Vec::new(); - for row in rows { - let data_id = row.data_id as u64; - // always check avail - if check_object_availability(data_id, 0).await.is_ok() { - valid_ids.push(data_id); - } - } + let current_pid = self.pid; + verify_object_permission(meta_info.owner, current_pid, &meta_info.permission)?; - Ok(valid_ids) - } + filter_properties_by_result_option(&mut meta_info, metaparam.result_option); - fn get_blacklist_1() -> Vec { - vec![ - "けされ", "消され", "削除され", "リセットされ", "BANされ", "ＢＡＮされ", - "キミのコース", "君のコース", "きみのコース", "い い ね", "遊びます", "地震", - "震災", "被災", "津波", "バンされ", "い~ね", "震度", "じしん", "banされ", - "くわしくは", "詳しくは", "ちんちん", "ち0こ", "bicth", "い.い．ね", - "ナイ～ス", "い&い", "い-いね", "いぃね", "nigger", "ngger", "star if u", - "Star if u", "Star if you", "star if you", "PENlS", "マンコ", "butthole", - "LILI", "vagina", "vagyna", "うんち", "うんこ", "ウンコ", "Ｉｉｎｅ", - "EENE", "まんこ", "ウンチ", "niglet", "nigglet", "please like", "きんたま", - "Butthole", "llね", "iいね", "give a star", "ちんぽ", "亀頭", "penis", - "ｳﾝｺ", "plz more stars", "star plz", "い()ね", "PLEASE star", "Bitte Sterne", - ].into_iter().map(String::from).collect() - } + Ok(meta_info) + } - fn get_blacklist_2() -> Vec { - vec![ - "ゼロから", "０から", "0から", "い　　い　　ね", "いい", "東日本", "大震", - ].into_iter().map(String::from).collect() - } + async fn prepare_post_object( + &self, + postparam: PreparePostParam, + ) -> Result { + let recipient_ids: Vec = postparam + .permission + .recipient_ids + .iter() + .map(|&id| id as i32) + .collect(); + let del_recipient_ids: Vec = postparam + .del_permission + .recipient_ids + .iter() + .map(|&id| id as i32) + .collect(); + let now = time::OffsetDateTime::now_utc(); - fn get_blacklist_3() -> Vec { - vec![ - "いいね", "下さい", "ください", "押して", "おして", "返す", "かえす", - "星", "してくれ", "するよ", "☆くれたら", "☆あげます", "★くれたら", - "★あげます", "しね", "ころす", "ころされた", "アナル", "ファック", - "キンタマ", "○ね", "キチガイ", "うんこ", "KITIGAI", "金玉", "おっぱい", - "☆おす", "☆押す", "★おす", "★押す", "いいする", "いいよ", "イイネ", - "ケツ", "うんち", "かくせいざい", "覚せい剤", "シャブ", "きんたま", - "ちんちん", "おしっこ", "ちんぽこ", "ころして", "グッド", "グット", - "レ●プ", "バーカ", "きちがい", "ちんげ", "マンコ", "まんこ", "チンポ", - "クズ", "ウンコ", "ナイスおねがいします", "penis", "イイね", "☆よろ", - "ナイス!して", "ま/んこ", "まん/こ", - ].into_iter().map(String::from).collect() - } - - impl DataStore for User { - async fn get_meta(&self, mut metaparam: GetMetaParam) -> Result { - let mut meta_info = if metaparam.dataid != 0 { - get_object_info_by_data_id(metaparam.dataid, metaparam.access_password).await? - } else { - get_object_info_by_persistence_target(metaparam.persistence_target, metaparam.access_password).await? - }; - - let current_pid = self.pid; - verify_object_permission(meta_info.owner, current_pid, &meta_info.permission)?; - - filter_properties_by_result_option(&mut meta_info, metaparam.result_option); - - Ok(meta_info) - } - - async fn prepare_post_object(&self, postparam: PreparePostParam) -> Result { - let recipient_ids: Vec = postparam.permission.recipient_ids.iter().map(|&id| id as i32).collect(); - let del_recipient_ids: Vec = postparam.del_permission.recipient_ids.iter().map(|&id| id as i32).collect(); - let now = time::OffsetDateTime::now_utc(); - - let row = sqlx::query!( + let row = sqlx::query!( r#" INSERT INTO datastore.objects ( owner, size, name, data_type, meta_binary, @@ -473,87 +669,95 @@ cfg_if! { ErrorCode::DataStore_SystemFileError })?; - let data_id = row.data_id as u64; - let presigner = S3Presigner::new( - &format!("https://{}", *RNEX_DATASTORE_S3_ENDPOINT), - format!("{}", *RNEX_DATASTORE_S3_BUCKET) - ).await; + let data_id = row.data_id as u64; + let presigner = S3Presigner::new( + &format!("https://{}", *RNEX_DATASTORE_S3_ENDPOINT), + format!("{}", *RNEX_DATASTORE_S3_BUCKET), + ) + .await; - let key = format!("data/{}.bin", data_id); + let key = format!("data/{}.bin", data_id); - let (upload_url, fields) = presigner.generate_presigned_post(&key).await; + let (upload_url, fields) = presigner.generate_presigned_post(&key).await; - let form_fields = fields.into_iter().map(|(k, v)| { - KeyValue { key: k, value: v } - }).collect(); + let form_fields = fields + .into_iter() + .map(|(k, v)| KeyValue { key: k, value: v }) + .collect(); - Ok(ReqPostInfo { - dataid: data_id, - url: upload_url, - request_headers: vec![], - form_fields, - root_ca_cert: vec![], - }) + Ok(ReqPostInfo { + dataid: data_id, + url: upload_url, + request_headers: vec![], + form_fields, + root_ca_cert: vec![], + }) + } + + async fn complete_post_object( + &self, + completeparam: CompletePostParam, + ) -> Result<(), ErrorCode> { + log::info!("Data ID: {:?}", completeparam.dataid); + log::info!("Success: {:?}", completeparam.success); + + let record = sqlx::query!( + r#"SELECT owner, under_review FROM datastore.objects WHERE data_id = $1"#, + completeparam.dataid as i64 + ) + .fetch_optional(get_db()) + .await + .map_err(|e| { + eprintln!("select error: {:?}", e); + ErrorCode::DataStore_SystemFileError + })?; + + let record = record.ok_or(ErrorCode::DataStore_NotFound)?; + + if record.under_review { + return Err(ErrorCode::DataStore_UnderReviewing); + } + + if record.owner.unwrap_or(0) as u32 != self.pid { + return Err(ErrorCode::DataStore_PermissionDenied); + } + + if completeparam.success { + sqlx::query!( + r#"UPDATE datastore.objects SET upload_completed = true WHERE data_id = $1"#, + completeparam.dataid as i64 + ) + .execute(get_db()) + .await + .map_err(|e| { + eprintln!("update error: {:?}", e); + ErrorCode::DataStore_SystemFileError + })?; + } else { + return Err(ErrorCode::Transport_TemporaryServerError); + } + + Ok(()) + } + + async fn rate_custom_ranking( + &self, + rankingparam: Vec, + ) -> Result<(), ErrorCode> { + for abcparam in rankingparam { + let exists = sqlx::query_scalar!( + r#"SELECT EXISTS(SELECT 1 FROM datastore.objects WHERE data_id = $1)"#, + abcparam.dataid as i64 + ) + .fetch_one(get_db()) + .await + .map_err(|_| ErrorCode::DataStore_SystemFileError)?; + + if !exists.unwrap_or(false) { + return Err(ErrorCode::DataStore_NotFound); } - async fn complete_post_object(&self, completeparam: CompletePostParam) -> Result<(), ErrorCode> { - log::info!("Data ID: {:?}", completeparam.dataid); - log::info!("Success: {:?}", completeparam.success); - - let record = sqlx::query!( - r#"SELECT owner, under_review FROM datastore.objects WHERE data_id = $1"#, - completeparam.dataid as i64 - ) - .fetch_optional(get_db()) - .await - .map_err(|e| { - eprintln!("select error: {:?}", e); - ErrorCode::DataStore_SystemFileError - })?; - - let record = record.ok_or(ErrorCode::DataStore_NotFound)?; - - if record.under_review { - return Err(ErrorCode::DataStore_UnderReviewing); - } - - if record.owner.unwrap_or(0) as u32 != self.pid { - return Err(ErrorCode::DataStore_PermissionDenied); - } - - if completeparam.success { - sqlx::query!( - r#"UPDATE datastore.objects SET upload_completed = true WHERE data_id = $1"#, - completeparam.dataid as i64 - ) - .execute(get_db()) - .await - .map_err(|e| { - eprintln!("update error: {:?}", e); - ErrorCode::DataStore_SystemFileError - })?; - } else { - return Err(ErrorCode::Transport_TemporaryServerError); - } - - Ok(()) - } - - async fn rate_custom_ranking(&self, rankingparam: Vec) -> Result<(), ErrorCode> { - for abcparam in rankingparam { - let exists = sqlx::query_scalar!( - r#"SELECT EXISTS(SELECT 1 FROM datastore.objects WHERE data_id = $1)"#, - abcparam.dataid as i64 - ) - .fetch_one(get_db()) - .await - .map_err(|_| ErrorCode::DataStore_SystemFileError)?; - - if !exists.unwrap_or(false) { - return Err(ErrorCode::DataStore_NotFound); - } - - sqlx::query!( + sqlx::query!( r#" INSERT INTO datastore.object_custom_rankings (data_id, application_id, value) VALUES ($1, $2, $3) @@ -570,216 +774,269 @@ cfg_if! { log::error!("update/insert error: {:?}", e); ErrorCode::DataStore_SystemFileError })?; + } + + Ok(()) + } + + async fn get_application_config(&self, appid: u32) -> Result, ErrorCode> { + const MAX_COURSE_UPLOADS: i32 = 100; + + let config = match appid { + 0 => vec![ + 0x00000001, + 0x00000032, + 0x00000096, + 0x0000012c, + 0x000001f4, + 0x00000320, + 0x00000514, + 0x000007d0, + 0x00000bb8, + 0x00001388, + MAX_COURSE_UPLOADS, + 0x00000014, + 0x0000001e, + 0x00000028, + 0x00000032, + 0x0000003c, + 0x00000046, + 0x00000050, + 0x0000005a, + 0x00000064, + 0x00000023, + 0x0000004b, + 0x00000023, + 0x0000004b, + 0x00000032, + 0x00000000, + 0x00000003, + 0x00000003, + 0x00000064, + 0x00000006, + 0x00000001, + 0x00000060, + 0x00000005, + 0x00000060, + 0x00000000, + 0x000007e4, + 0x00000001, + 0x00000001, + 0x0000000c, + 0x00000000, + ], + 1 => vec![ + 2, 1770179696, 1770179664, 1770179640, 1770180827, 1770180777, 1770180745, + 1770177625, 1770177590, + ], + 2 => vec![0x000007df, 0x0000000c, 0x00000016, 0x00000005, 0x00000000], + 10 => vec![35, 75, 96, 40, 5, 6], + _ => { + log::error!("unknown SMM app id: {}", appid); + return Err(ErrorCode::DataStore_Unknown); + } + }; + + Ok(config) + } + + async fn get_custom_ranking_by_data_id( + &self, + custom_ranking_param: DataStoreGetCustomRankingByDataIDParam, + ) -> Result<(Vec, Vec), ErrorCode> { + println!("appid: {:?}", custom_ranking_param.application_id); + println!("dataid list: {:?}", custom_ranking_param.data_id_list); + println!("result option: {:?}", custom_ranking_param.result_option); + + let mut ranking_results = get_custom_rankings_by_data_ids( + custom_ranking_param.application_id, + custom_ranking_param.data_id_list, + ) + .await; + + let mut q_results = Vec::with_capacity(ranking_results.len()); + + for result in &mut ranking_results { + if (custom_ranking_param.result_option & 0x01) == 0 { + result.meta_info.tags = Vec::new(); + } + + if (custom_ranking_param.result_option & 0x02) == 0 { + result.meta_info.ratings = Vec::new(); + } + + if (custom_ranking_param.result_option & 0x04) == 0 { + result.meta_info.meta_binary = QBuffer(Vec::new()); + } + + if (custom_ranking_param.result_option & 0x20) == 0 { + result.score = 0; + } + + q_results.push(QResult::success(ErrorCode::Core_Unknown)); + } + + Ok((ranking_results, q_results)) + } + + async fn get_buffer_queue( + &self, + bufferparam: BufferQueueParam, + ) -> Result, ErrorCode> { + // log::info!("GetBufferQueue: dataid={}, slot={}", param.dataid, param.slot); + + let buffers = + get_buffer_queues_by_data_id_and_slot(bufferparam.dataid, bufferparam.slot).await?; + + Ok(buffers) + } + + async fn prepare_get_object( + &self, + prepare_get_param: DataStorePrepareGetParam, + ) -> Result { + let meta_info = if prepare_get_param.dataid != 0 { + get_object_info_by_data_id(prepare_get_param.dataid, prepare_get_param.access_password) + .await? + } else { + get_object_info_by_persistence_target( + prepare_get_param.persistence_target, + prepare_get_param.access_password, + ) + .await? + }; + + verify_object_permission(meta_info.owner, self.pid, &meta_info.permission)?; + + let presigner = S3Presigner::new( + &format!("https://{}", *RNEX_DATASTORE_S3_ENDPOINT), + format!("{}", *RNEX_DATASTORE_S3_BUCKET), + ) + .await; + + let key = format!("data/{}.bin", meta_info.dataid); + let download_url = presigner.generate_presigned_get(&key); + + Ok(DataStoreReqGetInfo { + url: download_url, + request_headers: vec![], + size: meta_info.size, + root_ca_cert: vec![], + dataid: meta_info.dataid, + }) + } + + async fn followings_latest_course_search_object( + &self, + course_search_param: DataStoreSearchParam, + _extra_data: Vec, + ) -> Result, ErrorCode> { + let mut all_results = Vec::new(); + + for &owner_pid in &course_search_param.owner_ids { + let course_ids = get_user_course_object_ids(owner_pid).await?; + + if course_ids.is_empty() { + continue; + } + + let mut results = get_custom_rankings_by_data_ids(0, course_ids).await; + + // Flag 0x1: Return Tags + // Flag 0x2: Return Ratings + // Flag 0x4: Return MetaBinary + // Flag 0x20: Return Score + for res in &mut results { + if course_search_param.result_option & 0x1 == 0 { + res.meta_info.tags = Vec::new(); } - - Ok(()) - } - - async fn get_application_config(&self, appid: u32) -> Result, ErrorCode> { - const MAX_COURSE_UPLOADS: i32 = 100; - - let config = match appid { - 0 => vec![ - 0x00000001, 0x00000032, 0x00000096, 0x0000012c, 0x000001f4, - 0x00000320, 0x00000514, 0x000007d0, 0x00000bb8, 0x00001388, - MAX_COURSE_UPLOADS, 0x00000014, 0x0000001e, 0x00000028, 0x00000032, - 0x0000003c, 0x00000046, 0x00000050, 0x0000005a, 0x00000064, - 0x00000023, 0x0000004b, 0x00000023, 0x0000004b, 0x00000032, - 0x00000000, 0x00000003, 0x00000003, 0x00000064, 0x00000006, - 0x00000001, 0x00000060, 0x00000005, 0x00000060, 0x00000000, - 0x000007e4, 0x00000001, 0x00000001, 0x0000000c, 0x00000000, - ], - 1 => vec![ - 2, - 1770179696, - 1770179664, - 1770179640, - 1770180827, - 1770180777, - 1770180745, - 1770177625, - 1770177590, - ], - 2 => vec![0x000007df, 0x0000000c, 0x00000016, 0x00000005, 0x00000000], - 10 => vec![35, 75, 96, 40, 5, 6], - _ => { - log::error!("unknown SMM app id: {}", appid); - return Err(ErrorCode::DataStore_Unknown); - } - }; - - Ok(config) - } - - async fn get_custom_ranking_by_data_id( - &self, - custom_ranking_param: DataStoreGetCustomRankingByDataIDParam - ) -> Result<(Vec, Vec), ErrorCode> { - println!("appid: {:?}", custom_ranking_param.application_id); - println!("dataid list: {:?}", custom_ranking_param.data_id_list); - println!("result option: {:?}", custom_ranking_param.result_option); - - let mut ranking_results = get_custom_rankings_by_data_ids(custom_ranking_param.application_id, custom_ranking_param.data_id_list).await; - - let mut q_results = Vec::with_capacity(ranking_results.len()); - - for result in &mut ranking_results { - if (custom_ranking_param.result_option & 0x01) == 0 { - result.meta_info.tags = Vec::new(); - } - - if (custom_ranking_param.result_option & 0x02) == 0 { - result.meta_info.ratings = Vec::new(); - } - - if (custom_ranking_param.result_option & 0x04) == 0 { - result.meta_info.meta_binary = QBuffer(Vec::new()); - } - - if (custom_ranking_param.result_option & 0x20) == 0 { - result.score = 0; - } - - q_results.push(QResult::success(ErrorCode::Core_Unknown)); + if course_search_param.result_option & 0x2 == 0 { + res.meta_info.ratings = Vec::new(); } - - Ok((ranking_results, q_results)) - } - - async fn get_buffer_queue(&self, bufferparam: BufferQueueParam) -> Result, ErrorCode> { - // log::info!("GetBufferQueue: dataid={}, slot={}", param.dataid, param.slot); - - let buffers = get_buffer_queues_by_data_id_and_slot(bufferparam.dataid, bufferparam.slot).await?; - - Ok(buffers) - } - - async fn prepare_get_object(&self, prepare_get_param: DataStorePrepareGetParam) -> Result { - let meta_info = if prepare_get_param.dataid != 0 { - get_object_info_by_data_id(prepare_get_param.dataid, prepare_get_param.access_password).await? - } else { - get_object_info_by_persistence_target(prepare_get_param.persistence_target, prepare_get_param.access_password).await? - }; - - verify_object_permission(meta_info.owner, self.pid, &meta_info.permission)?; - - let presigner = S3Presigner::new( - &format!("https://{}", *RNEX_DATASTORE_S3_ENDPOINT), - format!("{}", *RNEX_DATASTORE_S3_BUCKET) - ).await; - - let key = format!("data/{}.bin", meta_info.dataid); - let download_url = presigner.generate_presigned_get(&key); - - Ok(DataStoreReqGetInfo { - url: download_url, - request_headers: vec![], - size: meta_info.size, - root_ca_cert: vec![], - dataid: meta_info.dataid, - }) - } - - async fn followings_latest_course_search_object( - &self, - course_search_param: DataStoreSearchParam, - _extra_data: Vec - ) -> Result, ErrorCode> { - let mut all_results = Vec::new(); - - for &owner_pid in &course_search_param.owner_ids { - let course_ids = get_user_course_object_ids(owner_pid).await?; - - if course_ids.is_empty() { - continue; - } - - let mut results = get_custom_rankings_by_data_ids(0, course_ids).await; - - // Flag 0x1: Return Tags - // Flag 0x2: Return Ratings - // Flag 0x4: Return MetaBinary - // Flag 0x20: Return Score - for res in &mut results { - if course_search_param.result_option & 0x1 == 0 { - res.meta_info.tags = Vec::new(); - } - if course_search_param.result_option & 0x2 == 0 { - res.meta_info.ratings = Vec::new(); - } - if course_search_param.result_option & 0x4 == 0 { - res.meta_info.meta_binary = rnex_core::rmc::structures::qbuffer::QBuffer(Vec::new()); - } - if course_search_param.result_option & 0x20 == 0 { - res.score = 0; - } - } - - all_results.extend(results); + if course_search_param.result_option & 0x4 == 0 { + res.meta_info.meta_binary = + rnex_core::rmc::structures::qbuffer::QBuffer(Vec::new()); + } + if course_search_param.result_option & 0x20 == 0 { + res.score = 0; } - - // note: we assume the client sorts the data lol - - Ok(all_results) } - async fn get_application_config_string(&self, application_id: u32) -> Result, ErrorCode> { - let config = match application_id { - 128 => get_blacklist_1(), - 129 => get_blacklist_2(), - 130 => get_blacklist_3(), - _ => { - log::warn!("unsupported application_id in GetApplicationConfigString: {}", application_id); - Vec::new() - } - }; + all_results.extend(results); + } - Ok(config) + // note: we assume the client sorts the data lol + + Ok(all_results) + } + + async fn get_application_config_string( + &self, + application_id: u32, + ) -> Result, ErrorCode> { + let config = match application_id { + 128 => get_blacklist_1(), + 129 => get_blacklist_2(), + 130 => get_blacklist_3(), + _ => { + log::warn!( + "unsupported application_id in GetApplicationConfigString: {}", + application_id + ); + Vec::new() } + }; - async fn get_metas_multiple_param( - &self, - params: Vec - ) -> Result<(Vec, Vec), ErrorCode> { - let mut metas = Vec::with_capacity(params.len()); - let mut results = Vec::with_capacity(params.len()); + Ok(config) + } - for param in params { - let info_result = if param.dataid != 0 { - get_object_info_by_data_id(param.dataid, param.access_password).await + async fn get_metas_multiple_param( + &self, + params: Vec, + ) -> Result<(Vec, Vec), ErrorCode> { + let mut metas = Vec::with_capacity(params.len()); + let mut results = Vec::with_capacity(params.len()); + + for param in params { + let info_result = if param.dataid != 0 { + get_object_info_by_data_id(param.dataid, param.access_password).await + } else { + get_object_info_by_persistence_target( + param.persistence_target, + param.access_password, + ) + .await + }; + + match info_result { + Ok(mut meta) => { + if let Err(e) = verify_object_permission(meta.owner, self.pid, &meta.permission) + { + metas.push(GetMetaInfo::default()); + results.push(QResult::error(e)); } else { - get_object_info_by_persistence_target(param.persistence_target, param.access_password).await - }; - - match info_result { - Ok(mut meta) => { - if let Err(e) = verify_object_permission(meta.owner, self.pid, &meta.permission) { - metas.push(GetMetaInfo::default()); - results.push(QResult::error(e)); - } else { - if param.result_option & 0x1 == 0 { - meta.tags = Vec::new(); - } - if param.result_option & 0x2 == 0 { - meta.ratings = Vec::new(); - } - if param.result_option & 0x4 == 0 { - meta.meta_binary = rnex_core::rmc::structures::qbuffer::QBuffer(Vec::new()); - } - - metas.push(meta); - results.push(QResult::success(ErrorCode::Core_Unknown)); - } + if param.result_option & 0x1 == 0 { + meta.tags = Vec::new(); } - Err(e) => { - metas.push(GetMetaInfo::default()); - results.push(QResult::error(e)); + if param.result_option & 0x2 == 0 { + meta.ratings = Vec::new(); } + if param.result_option & 0x4 == 0 { + meta.meta_binary = + rnex_core::rmc::structures::qbuffer::QBuffer(Vec::new()); + } + + metas.push(meta); + results.push(QResult::success(ErrorCode::Core_Unknown)); } } - - Ok((metas, results)) + Err(e) => { + metas.push(GetMetaInfo::default()); + results.push(QResult::error(e)); + } } } + + Ok((metas, results)) } -} \ No newline at end of file +}