diff --git a/Cargo.lock b/Cargo.lock index 24ba63ca..67b1a195 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2174,7 +2174,6 @@ dependencies = [ "pagetop-macros", "pagetop-minimal", "pagetop-statics", - "parking_lot", "serde", "serde_json", "serde_qs", diff --git a/Cargo.toml b/Cargo.toml index b99f525d..b5b3d83a 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -46,7 +46,6 @@ itoa = "1.0" lettre = { version = "0.11", default-features = false } mime_guess = "2.0" minify-js = "0.6" -parking_lot = "0.12" pastey = "0.2" path-slash = "0.2" proc-macro2 = "1.0" @@ -131,7 +130,6 @@ fluent-templates.workspace = true getter-methods.workspace = true indexmap.workspace = true itoa.workspace = true -parking_lot.workspace = true pagetop-macros.workspace = true pagetop-minimal.workspace = true pagetop-statics.workspace = true diff --git a/extensions/pagetop-cron/src/scheduler.rs b/extensions/pagetop-cron/src/scheduler.rs index 772e408b..3eb27c0f 100644 --- a/extensions/pagetop-cron/src/scheduler.rs +++ b/extensions/pagetop-cron/src/scheduler.rs @@ -282,8 +282,9 @@ impl Entry { } } - // Un `panic!` sólo puede ocurrir fuera de la sección protegida (se ejecutan en otra tarea), - // así que el estado sigue siendo coherente aunque el `Mutex` quede envenenado. + // Los trabajos se ejecutan en otra tarea, fuera de la sección protegida. Dentro sólo podría + // fallar el cálculo de fechas de `take_due()`, que no deja el estado incoherente, así que un + // `Mutex` envenenado no debe detener el trabajo. fn state(&self) -> MutexGuard<'_, State> { self.state.lock().unwrap_or_else(PoisonError::into_inner) } diff --git a/extensions/pagetop-mail/src/outbox.rs b/extensions/pagetop-mail/src/outbox.rs index e1ae3bd5..6f3e1326 100644 --- a/extensions/pagetop-mail/src/outbox.rs +++ b/extensions/pagetop-mail/src/outbox.rs @@ -36,7 +36,7 @@ use pagetop::prelude::*; use crate::Email; -use std::sync::{Mutex, MutexGuard, PoisonError}; +use std::sync::Mutex; static OUTBOX: Mutex> = Mutex::new(Vec::new()); @@ -99,13 +99,13 @@ fn unescape(value: &str) -> String { /// Recoge todos los correos guardados, en el orden en que se enviaron. pub fn take() -> Vec { - std::mem::take(&mut *lock()) + std::mem::take(&mut *OUTBOX.lock().unwrap()) } /// Recoge los correos entregados a la dirección dada, en el orden en que se enviaron, y deja los /// demás. pub fn take_to(address: &str) -> Vec { - let mut outbox = lock(); + let mut outbox = OUTBOX.lock().unwrap(); let (taken, kept) = outbox .drain(..) .partition(|sent: &SentEmail| sent.is_delivered_to(address)); @@ -114,18 +114,13 @@ pub fn take_to(address: &str) -> Vec { } pub(crate) fn push(email: Email, envelope_to: Vec, raw: Vec) { - lock().push(SentEmail { + OUTBOX.lock().unwrap().push(SentEmail { email, envelope_to, raw: String::from_utf8_lossy(&raw).into_owned(), }); } -// Una prueba que falla con el bloqueo tomado no debe impedir que las demás sigan usándolo. -fn lock() -> MutexGuard<'static, Vec> { - OUTBOX.lock().unwrap_or_else(PoisonError::into_inner) -} - // Correos completos de la cola de envío pendientes de entregar con este transporte, por su // identificador en la cola. La cola sólo guarda el mensaje compuesto, y las pruebas necesitan el // correo completo para consultarlo con `SentEmail::email()`. @@ -134,15 +129,12 @@ static QUEUED: Mutex> = Mutex::new(Vec::new()); #[cfg(feature = "queue")] pub(crate) fn hold(id: i32, email: Email) { - QUEUED - .lock() - .unwrap_or_else(PoisonError::into_inner) - .push((id, email)); + QUEUED.lock().unwrap().push((id, email)); } #[cfg(feature = "queue")] pub(crate) fn release(id: i32) -> Option { - let mut queued = QUEUED.lock().unwrap_or_else(PoisonError::into_inner); + let mut queued = QUEUED.lock().unwrap(); let index = queued.iter().position(|(queued_id, _)| *queued_id == id)?; Some(queued.swap_remove(index).1) } diff --git a/extensions/pagetop-user/src/session.rs b/extensions/pagetop-user/src/session.rs index 12366581..00ddcf39 100644 --- a/extensions/pagetop-user/src/session.rs +++ b/extensions/pagetop-user/src/session.rs @@ -2,7 +2,7 @@ //! //! Incluye también los permisos del rol "anonymous", que se aplican a las peticiones sin sesión. -use std::sync::{Arc, PoisonError, RwLock}; +use std::sync::{Arc, RwLock}; use std::time::Instant; use pagetop::prelude::*; @@ -308,9 +308,7 @@ static ANONYMOUS_CACHE: RwLock = RwLock::new(AnonymousCache { /// a intentar en la siguiente petición. pub(crate) async fn anonymous_permissions() -> Arc { let generation = { - let cache = ANONYMOUS_CACHE - .read() - .unwrap_or_else(PoisonError::into_inner); + let cache = ANONYMOUS_CACHE.read().unwrap(); if let Some((loaded_at, permissions)) = &cache.loaded && loaded_at.elapsed() < ANONYMOUS_TTL { @@ -334,9 +332,7 @@ pub(crate) async fn anonymous_permissions() -> Arc { } }; - let mut cache = ANONYMOUS_CACHE - .write() - .unwrap_or_else(PoisonError::into_inner); + let mut cache = ANONYMOUS_CACHE.write().unwrap(); if cache.generation == generation { cache.loaded = Some((Instant::now(), Arc::clone(&permissions))); } @@ -346,9 +342,7 @@ pub(crate) async fn anonymous_permissions() -> Arc { /// Descarta los permisos de "anonymous" guardados en memoria, para que la siguiente petición sin /// sesión los vuelva a leer. Se llama al cambiar los permisos de ese rol. pub(crate) fn invalidate_anonymous_permissions() { - let mut cache = ANONYMOUS_CACHE - .write() - .unwrap_or_else(PoisonError::into_inner); + let mut cache = ANONYMOUS_CACHE.write().unwrap(); cache.generation = cache.generation.wrapping_add(1); cache.loaded = None; } diff --git a/extensions/pagetop-user/src/throttle.rs b/extensions/pagetop-user/src/throttle.rs index c14cb589..7d153de6 100644 --- a/extensions/pagetop-user/src/throttle.rs +++ b/extensions/pagetop-user/src/throttle.rs @@ -7,7 +7,7 @@ use crate::config::SETTINGS; use std::collections::{HashMap, VecDeque}; use std::net::{IpAddr, Ipv6Addr}; -use std::sync::{LazyLock, Mutex, PoisonError}; +use std::sync::{LazyLock, Mutex}; use std::time::{Duration as StdDuration, Instant}; // Momentos de las solicitudes de cada dirección dentro de la ventana, y última limpieza. @@ -41,7 +41,7 @@ pub(crate) fn allow(request: &HttpRequest) -> bool { return true; }; let allowed = allow_at( - &mut lock(&REQUESTS), + &mut REQUESTS.lock().unwrap(), network(ip), Instant::now(), SETTINGS.max_ip_requests, @@ -63,7 +63,7 @@ pub(crate) fn allow_login(request: &HttpRequest) -> bool { return true; }; let allowed = allow_at( - &mut lock(&FAILED_LOGINS), + &mut FAILED_LOGINS.lock().unwrap(), network(ip), Instant::now(), SETTINGS.max_ip_failed_logins, @@ -78,14 +78,10 @@ pub(crate) fn allow_login(request: &HttpRequest) -> bool { /// Retira un intento anotado por [`allow_login()`] que no ha resultado fallido. pub(crate) fn forget_login(request: &HttpRequest) { if let Some(ip) = request.client_ip() { - forget_at(&mut lock(&FAILED_LOGINS), network(ip)); + forget_at(&mut FAILED_LOGINS.lock().unwrap(), network(ip)); } } -fn lock(log: &Log) -> std::sync::MutexGuard<'_, Requests> { - log.lock().unwrap_or_else(PoisonError::into_inner) -} - fn window(secs: i64) -> StdDuration { StdDuration::from_secs(u64::try_from(secs).unwrap_or(0)) } diff --git a/src/core/component/context.rs b/src/core/component/context.rs index 654f2655..3a59368e 100644 --- a/src/core/component/context.rs +++ b/src/core/component/context.rs @@ -11,10 +11,9 @@ use crate::response::read_flash_messages; use crate::web::HttpRequest; use crate::{CowStr, util}; -use parking_lot::Mutex; - use std::any::{Any, TypeId}; use std::collections::HashMap; +use std::sync::Mutex; mod assets_op; pub use assets_op::AssetsOp; diff --git a/src/core/component/context/contextual.rs b/src/core/component/context/contextual.rs index b691a5e0..7587bb74 100644 --- a/src/core/component/context/contextual.rs +++ b/src/core/component/context/contextual.rs @@ -481,7 +481,7 @@ pub trait Contextual { segments }; let count = { - let mut map = self.context().id_counters.lock(); + let mut map = self.context().id_counters.lock().unwrap(); let n = map.entry(TypeId::of::()).or_insert(0); *n += 1; *n diff --git a/src/core/theme/all.rs b/src/core/theme/all.rs index 67542e61..8f9cfa65 100644 --- a/src/core/theme/all.rs +++ b/src/core/theme/all.rs @@ -1,9 +1,7 @@ use crate::core::theme::ThemeRef; use crate::{global, trace}; -use parking_lot::RwLock; - -use std::sync::LazyLock; +use std::sync::{LazyLock, RwLock}; // **< TEMAS >************************************************************************************** @@ -11,7 +9,7 @@ static THEMES: LazyLock>> = LazyLock::new(|| RwLock::new(Ve // Registra el tema si no lo estaba ya, para evitar duplicados. Devuelve `true` si lo ha añadido. pub(crate) fn register_theme(theme: ThemeRef) -> bool { - let mut themes = THEMES.write(); + let mut themes = THEMES.write().unwrap(); if themes.iter().any(|t| t.type_id() == theme.type_id()) { return false; } @@ -21,7 +19,7 @@ pub(crate) fn register_theme(theme: ThemeRef) -> bool { /// Devuelve los temas habilitados en la aplicación, en el orden en que se registraron. pub fn enabled_themes() -> Vec { - THEMES.read().clone() + THEMES.read().unwrap().clone() } /// Devuelve el tema identificado por su [`short_name()`](crate::core::AnyInfo::short_name). @@ -30,6 +28,7 @@ pub fn enabled_themes() -> Vec { pub fn theme_by_short_name(short_name: &str) -> Option { THEMES .read() + .unwrap() .iter() .find(|t| t.short_name().eq_ignore_ascii_case(short_name)) .copied() diff --git a/src/core/theme/regions.rs b/src/core/theme/regions.rs index db910f1e..718a7a11 100644 --- a/src/core/theme/regions.rs +++ b/src/core/theme/regions.rs @@ -2,10 +2,8 @@ use crate::core::component::{Child, ChildOp, Children, Component}; use crate::core::theme::{CoreRegions, RegionRef, ThemeRef}; use crate::{AutoDefault, UniqueId, builder_impl}; -use parking_lot::RwLock; - use std::collections::HashMap; -use std::sync::{Arc, LazyLock}; +use std::sync::{Arc, LazyLock, RwLock}; // Lista de prototipos de componentes por nombre de región. // @@ -90,7 +88,7 @@ impl ChildrenInRegions { let region_name = region.name(); // 1. Prototipos globales comunes. - if let Some(global_protos) = COMMON_REGIONS.read().get(region_name) { + if let Some(global_protos) = COMMON_REGIONS.read().unwrap().get(region_name) { result.add_many( global_protos .iter() @@ -102,7 +100,7 @@ impl ChildrenInRegions { result.add_many(page_children); } // 3. Prototipos del tema activo. - if let Some(theme_region) = THEME_REGIONS.read().get(&theme.type_id()) + if let Some(theme_region) = THEME_REGIONS.read().unwrap().get(&theme.type_id()) && let Some(theme_protos) = theme_region.get(region_name) { result.add_many( @@ -190,6 +188,7 @@ impl InRegion { InRegion::ForTheme(theme, region) => { THEME_REGIONS .write() + .unwrap() .entry(theme.type_id()) .or_default() .push((*region).name(), proto); @@ -200,6 +199,6 @@ impl InRegion { #[inline] fn add_to_common(region: RegionRef, proto: Arc) { - COMMON_REGIONS.write().push(region.name(), proto); + COMMON_REGIONS.write().unwrap().push(region.name(), proto); } } diff --git a/src/trace.rs b/src/trace.rs index 9b69e176..fe928788 100644 --- a/src/trace.rs +++ b/src/trace.rs @@ -22,8 +22,8 @@ pub use tracing::{debug_span, error_span, info_span, trace_span, warn_span}; use tracing_appender::non_blocking::WorkerGuard; use tracing_subscriber::EnvFilter; +use std::sync::Mutex; use std::sync::atomic::{AtomicBool, Ordering}; -use std::sync::{Mutex, PoisonError}; // Avisos generados antes de iniciar las trazas. La configuración se lee antes, porque las trazas // dependen de la sección `[log]`, así que sus avisos se guardan aquí y se emiten al iniciarlas. @@ -34,9 +34,7 @@ static DEFERRED_WARNINGS: Mutex>> = Mutex::new(Some(Vec::new( // basta para la configuración global, que `init()` lee antes de recoger los avisos. Usarla después // es un error de programación: se emite como `error!` con el aviso incluido, para que no se pierda. pub(crate) fn defer_warning(message: String) { - let mut deferred = DEFERRED_WARNINGS - .lock() - .unwrap_or_else(PoisonError::into_inner); + let mut deferred = DEFERRED_WARNINGS.lock().unwrap(); match deferred.as_mut() { Some(warnings) => warnings.push(message), None => { @@ -70,7 +68,7 @@ pub(crate) fn init() -> Option { // Al leer `SETTINGS` en la línea anterior ya se han guardado los avisos de la configuración. let mut warnings = DEFERRED_WARNINGS .lock() - .unwrap_or_else(PoisonError::into_inner) + .unwrap() .take() // Deja `None`, desde ahora, `defer_warning()` trata cualquier aviso como mal uso. .unwrap_or_default(); if !enabled {