fix warnings and errors when building with no features

Signed-off-by: strawberry <strawberry@puppygock.gay>

src/main/runtime.rs

@@ -8,13 +8,11 @@ use std::{
 	time::Duration,
 };
 
+#[cfg(all(not(target_env = "msvc"), feature = "jemalloc"))]
+use conduwuit::result::LogDebugErr;
 use conduwuit::{
 	is_true,
-	result::LogDebugErr,
-	utils::{
-		available_parallelism,
-		sys::compute::{nth_core_available, set_affinity},
-	},
+	utils::sys::compute::{nth_core_available, set_affinity},
 	Result,
 };
 use tokio::runtime::Builder;
@@ -25,6 +23,7 @@ const WORKER_NAME: &str = "conduwuit:worker";
 const WORKER_MIN: usize = 2;
 const WORKER_KEEPALIVE: u64 = 36;
 const MAX_BLOCKING_THREADS: usize = 1024;
+#[cfg(all(not(target_env = "msvc"), feature = "jemalloc"))]
 const DISABLE_MUZZY_THRESHOLD: usize = 4;
 
 static WORKER_AFFINITY: OnceLock<bool> = OnceLock::new();
@@ -137,7 +136,7 @@ fn set_worker_mallctl(id: usize) {
 		.get()
 		.expect("GC_MUZZY initialized by runtime::new()");
 
-	let muzzy_auto_disable = available_parallelism() >= DISABLE_MUZZY_THRESHOLD;
+	let muzzy_auto_disable = conduwuit::utils::available_parallelism() >= DISABLE_MUZZY_THRESHOLD;
 	if matches!(muzzy_option, Some(false) | None if muzzy_auto_disable) {
 		set_muzzy_decay(-1).log_debug_err().ok();
 	}

src/service/media/blurhash.rs

@@ -1,20 +1,30 @@
-use std::{error::Error, ffi::OsStr, fmt::Display, io::Cursor, path::Path};
-
-use conduwuit::{config::BlurhashConfig as CoreBlurhashConfig, err, implement, Result};
-use image::{DynamicImage, ImageDecoder, ImageError, ImageFormat, ImageReader};
+#[cfg(feature = "blurhashing")]
+use conduwuit::config::BlurhashConfig as CoreBlurhashConfig;
+use conduwuit::{implement, Result};
 
 use super::Service;
+
 #[implement(Service)]
+#[cfg(not(feature = "blurhashing"))]
+pub fn create_blurhash(
+	&self,
+	_file: &[u8],
+	_content_type: Option<&str>,
+	_file_name: Option<&str>,
+) -> Result<Option<String>> {
+	conduwuit::debug_warn!("blurhashing on upload support was not compiled");
+
+	Ok(None)
+}
+
+#[implement(Service)]
+#[cfg(feature = "blurhashing")]
 pub fn create_blurhash(
 	&self,
 	file: &[u8],
 	content_type: Option<&str>,
 	file_name: Option<&str>,
 ) -> Result<Option<String>> {
-	if !cfg!(feature = "blurhashing") {
-		return Ok(None);
-	}
-
 	let config = BlurhashConfig::from(self.services.server.config.blurhashing);
 
 	// since 0 means disabled blurhashing, skipped blurhashing
@@ -23,7 +33,7 @@ pub fn create_blurhash(
 	}
 
 	get_blurhash_from_request(file, content_type, file_name, config)
-		.map_err(|e| err!(debug_error!("blurhashing error: {e}")))
+		.map_err(|e| conduwuit::err!(debug_error!("blurhashing error: {e}")))
 		.map(Some)
 }
 
@@ -36,6 +46,7 @@ pub fn create_blurhash(
 		bytes = data.len(),
 	),
 )]
+#[cfg(feature = "blurhashing")]
 fn get_blurhash_from_request(
 	data: &[u8],
 	mime: Option<&str>,
@@ -53,8 +64,7 @@ fn get_blurhash_from_request(
 		return Err(BlurhashingError::ImageTooLarge);
 	}
 
-	// decode the image finally
-	let image = DynamicImage::from_decoder(decoder)?;
+	let image = image::DynamicImage::from_decoder(decoder)?;
 
 	blurhash_an_image(&image, config)
 }
@@ -64,31 +74,34 @@ fn get_blurhash_from_request(
 /// Then it checks if the filename has a format, otherwise just guess based on
 /// the binary data Assumes that mime and filename extension won't be for a
 /// different file format than file.
+#[cfg(feature = "blurhashing")]
 fn get_format_from_data_mime_and_filename(
 	data: &[u8],
 	mime: Option<&str>,
 	filename: Option<&str>,
-) -> Result<ImageFormat, BlurhashingError> {
+) -> Result<image::ImageFormat, BlurhashingError> {
 	let extension = filename
-		.map(Path::new)
-		.and_then(Path::extension)
-		.map(OsStr::to_string_lossy);
+		.map(std::path::Path::new)
+		.and_then(std::path::Path::extension)
+		.map(std::ffi::OsStr::to_string_lossy);
 
 	mime.or(extension.as_deref())
-		.and_then(ImageFormat::from_mime_type)
+		.and_then(image::ImageFormat::from_mime_type)
 		.map_or_else(|| image::guess_format(data).map_err(Into::into), Ok)
 }
 
+#[cfg(feature = "blurhashing")]
 fn get_image_decoder_with_format_and_data(
-	image_format: ImageFormat,
+	image_format: image::ImageFormat,
 	data: &[u8],
-) -> Result<Box<dyn ImageDecoder + '_>, BlurhashingError> {
-	let mut image_reader = ImageReader::new(Cursor::new(data));
+) -> Result<Box<dyn image::ImageDecoder + '_>, BlurhashingError> {
+	let mut image_reader = image::ImageReader::new(std::io::Cursor::new(data));
 	image_reader.set_format(image_format);
 	Ok(Box::new(image_reader.into_decoder()?))
 }
 
-fn is_image_above_size_limit<T: ImageDecoder>(
+#[cfg(feature = "blurhashing")]
+fn is_image_above_size_limit<T: image::ImageDecoder>(
 	decoder: &T,
 	blurhash_config: BlurhashConfig,
 ) -> bool {
@@ -99,7 +112,7 @@ fn is_image_above_size_limit<T: ImageDecoder>(
 #[tracing::instrument(name = "encode", level = "debug", skip_all)]
 #[inline]
 fn blurhash_an_image(
-	image: &DynamicImage,
+	image: &image::DynamicImage,
 	blurhash_config: BlurhashConfig,
 ) -> Result<String, BlurhashingError> {
 	Ok(blurhash::encode_image(
@@ -109,15 +122,6 @@ fn blurhash_an_image(
 	)?)
 }
 
-#[cfg(not(feature = "blurhashing"))]
-#[inline]
-fn blurhash_an_image(
-	_image: &DynamicImage,
-	_blurhash_config: BlurhashConfig,
-) -> Result<String, BlurhashingError> {
-	Err(BlurhashingError::Unavailable)
-}
-
 #[derive(Clone, Copy, Debug)]
 pub struct BlurhashConfig {
 	pub components_x: u32,
@@ -127,6 +131,7 @@ pub struct BlurhashConfig {
 	pub size_limit: u64,
 }
 
+#[cfg(feature = "blurhashing")]
 impl From<CoreBlurhashConfig> for BlurhashConfig {
 	fn from(value: CoreBlurhashConfig) -> Self {
 		Self {
@@ -138,17 +143,17 @@ impl From<CoreBlurhashConfig> for BlurhashConfig {
 }
 
 #[derive(Debug)]
+#[cfg(feature = "blurhashing")]
 pub enum BlurhashingError {
-	HashingLibError(Box<dyn Error + Send>),
-	ImageError(Box<ImageError>),
+	HashingLibError(Box<dyn std::error::Error + Send>),
+	#[cfg(feature = "blurhashing")]
+	ImageError(Box<image::ImageError>),
 	ImageTooLarge,
-
-	#[cfg(not(feature = "blurhashing"))]
-	Unavailable,
 }
 
-impl From<ImageError> for BlurhashingError {
-	fn from(value: ImageError) -> Self { Self::ImageError(Box::new(value)) }
+#[cfg(feature = "blurhashing")]
+impl From<image::ImageError> for BlurhashingError {
+	fn from(value: image::ImageError) -> Self { Self::ImageError(Box::new(value)) }
 }
 
 #[cfg(feature = "blurhashing")]
@@ -156,19 +161,17 @@ impl From<blurhash::Error> for BlurhashingError {
 	fn from(value: blurhash::Error) -> Self { Self::HashingLibError(Box::new(value)) }
 }
 
-impl Display for BlurhashingError {
+#[cfg(feature = "blurhashing")]
+impl std::fmt::Display for BlurhashingError {
 	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 		write!(f, "Blurhash Error:")?;
 		match &self {
 			| Self::ImageTooLarge => write!(f, "Image was too large to blurhash")?,
 			| Self::HashingLibError(e) =>
 				write!(f, "There was an error with the blurhashing library => {e}")?,
-
+			#[cfg(feature = "blurhashing")]
 			| Self::ImageError(e) =>
 				write!(f, "There was an error with the image loading library => {e}")?,
-
-			#[cfg(not(feature = "blurhashing"))]
-			| Self::Unavailable => write!(f, "Blurhashing is not supported")?,
 		};
 
 		Ok(())

src/service/media/migrations.rs

@@ -13,7 +13,7 @@ use conduwuit::{
 	warn, Config, Result,
 };
 
-use crate::{migrations, Services};
+use crate::Services;
 
 /// Migrates a media directory from legacy base64 file names to sha2 file names.
 /// All errors are fatal. Upon success the database is keyed to not perform this
@@ -48,12 +48,6 @@ pub(crate) async fn migrate_sha256_media(services: &Services) -> Result<()> {
 		}
 	}
 
-	// Apply fix from when sha256_media was backward-incompat and bumped the schema
-	// version from 13 to 14. For users satisfying these conditions we can go back.
-	if services.globals.db.database_version().await == 14 && migrations::DATABASE_VERSION == 13 {
-		services.globals.db.bump_database_version(13)?;
-	}
-
 	db["global"].insert(b"feat_sha256_media", []);
 	info!("Finished applying sha256_media");
 	Ok(())