Initial shared instances backend (#3800)

* Create base shared instance migration and initial routes

* Fix build

* Add version uploads

* Add permissions field for shared instance users

* Actually use permissions field

* Add "public" flag to shared instances that allow GETing them without authorization

* Add the ability to get and list shared instance versions

* Add the ability to delete shared instance versions

* Fix build after merge

* Secured file hosting (#3784)

* Remove Backblaze-specific file-hosting backend

* Added S3_USES_PATH_STYLE_BUCKETS

* Remove unused file_id parameter from delete_file_version

* Add support for separate public and private buckets in labrinth::file_hosting

* Rename delete_file_version to delete_file

* Add (untested) get_url_for_private_file

* Remove url field from shared instance routes

* Remove url field from shared instance routes

* Use private bucket for shared instance versions

* Make S3 environment variables fully separate between public and private buckets

* Change file host expiry for shared instances to 180 seconds

* Fix lint

* Merge shared instance migrations into a single migration

* Replace shared instance owners with Ghost instead of deleting the instance

apps/labrinth/src/util/routes.rs

@@ -1,11 +1,14 @@
 use crate::routes::ApiError;
 use crate::routes::v3::project_creation::CreateError;
+use crate::util::validate::validation_errors_to_string;
 use actix_multipart::Field;
 use actix_web::web::Payload;
 use bytes::BytesMut;
 use futures::StreamExt;
+use serde::de::DeserializeOwned;
+use validator::Validate;
 
-pub async fn read_from_payload(
+pub async fn read_limited_from_payload(
     payload: &mut Payload,
     cap: usize,
     err_msg: &'static str,
@@ -25,6 +28,28 @@ pub async fn read_from_payload(
     Ok(bytes)
 }
 
+pub async fn read_typed_from_payload<T>(
+    payload: &mut Payload,
+) -> Result<T, ApiError>
+where
+    T: DeserializeOwned + Validate,
+{
+    let mut bytes = BytesMut::new();
+    while let Some(item) = payload.next().await {
+        bytes.extend_from_slice(&item.map_err(|_| {
+            ApiError::InvalidInput(
+                "Unable to parse bytes in payload sent!".to_string(),
+            )
+        })?);
+    }
+
+    let parsed: T = serde_json::from_slice(&bytes)?;
+    parsed.validate().map_err(|err| {
+        ApiError::InvalidInput(validation_errors_to_string(err, None))
+    })?;
+    Ok(parsed)
+}
+
 pub async fn read_from_field(
     field: &mut Field,
     cap: usize,