➖ Sustituye parking_lot por std::sync

PageTop ya no lo necesita como dependencia directa: `std::sync` cubre
los bloqueos del contexto, los temas y las trazas. No se detecta pérdida
de rendimiento en ningún caso.

Usa `unwrap()` en los bloqueos, también en las extensiones, porque sus
secciones exclusivas no pueden provocar panic. Sólo pagetop-cron ignora
el envenenamiento, porque calcula fechas con el bloqueo tomado.
This commit is contained in:
Manuel Cillero 2026-11-09 07:22:18 +01:00
parent a6d15ab211
commit 698b917fb1
11 changed files with 31 additions and 56 deletions

1
Cargo.lock generated
View file

@ -2174,7 +2174,6 @@ dependencies = [
"pagetop-macros", "pagetop-macros",
"pagetop-minimal", "pagetop-minimal",
"pagetop-statics", "pagetop-statics",
"parking_lot",
"serde", "serde",
"serde_json", "serde_json",
"serde_qs", "serde_qs",

View file

@ -46,7 +46,6 @@ itoa = "1.0"
lettre = { version = "0.11", default-features = false } lettre = { version = "0.11", default-features = false }
mime_guess = "2.0" mime_guess = "2.0"
minify-js = "0.6" minify-js = "0.6"
parking_lot = "0.12"
pastey = "0.2" pastey = "0.2"
path-slash = "0.2" path-slash = "0.2"
proc-macro2 = "1.0" proc-macro2 = "1.0"
@ -131,7 +130,6 @@ fluent-templates.workspace = true
getter-methods.workspace = true getter-methods.workspace = true
indexmap.workspace = true indexmap.workspace = true
itoa.workspace = true itoa.workspace = true
parking_lot.workspace = true
pagetop-macros.workspace = true pagetop-macros.workspace = true
pagetop-minimal.workspace = true pagetop-minimal.workspace = true
pagetop-statics.workspace = true pagetop-statics.workspace = true

View file

@ -282,8 +282,9 @@ impl Entry {
} }
} }
// Un `panic!` sólo puede ocurrir fuera de la sección protegida (se ejecutan en otra tarea), // Los trabajos se ejecutan en otra tarea, fuera de la sección protegida. Dentro sólo podría
// así que el estado sigue siendo coherente aunque el `Mutex` quede envenenado. // 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> { fn state(&self) -> MutexGuard<'_, State> {
self.state.lock().unwrap_or_else(PoisonError::into_inner) self.state.lock().unwrap_or_else(PoisonError::into_inner)
} }

View file

@ -36,7 +36,7 @@ use pagetop::prelude::*;
use crate::Email; use crate::Email;
use std::sync::{Mutex, MutexGuard, PoisonError}; use std::sync::Mutex;
static OUTBOX: Mutex<Vec<SentEmail>> = Mutex::new(Vec::new()); static OUTBOX: Mutex<Vec<SentEmail>> = 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. /// Recoge todos los correos guardados, en el orden en que se enviaron.
pub fn take() -> Vec<SentEmail> { pub fn take() -> Vec<SentEmail> {
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 /// Recoge los correos entregados a la dirección dada, en el orden en que se enviaron, y deja los
/// demás. /// demás.
pub fn take_to(address: &str) -> Vec<SentEmail> { pub fn take_to(address: &str) -> Vec<SentEmail> {
let mut outbox = lock(); let mut outbox = OUTBOX.lock().unwrap();
let (taken, kept) = outbox let (taken, kept) = outbox
.drain(..) .drain(..)
.partition(|sent: &SentEmail| sent.is_delivered_to(address)); .partition(|sent: &SentEmail| sent.is_delivered_to(address));
@ -114,18 +114,13 @@ pub fn take_to(address: &str) -> Vec<SentEmail> {
} }
pub(crate) fn push(email: Email, envelope_to: Vec<String>, raw: Vec<u8>) { pub(crate) fn push(email: Email, envelope_to: Vec<String>, raw: Vec<u8>) {
lock().push(SentEmail { OUTBOX.lock().unwrap().push(SentEmail {
email, email,
envelope_to, envelope_to,
raw: String::from_utf8_lossy(&raw).into_owned(), 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<SentEmail>> {
OUTBOX.lock().unwrap_or_else(PoisonError::into_inner)
}
// Correos completos de la cola de envío pendientes de entregar con este transporte, por su // 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 // identificador en la cola. La cola sólo guarda el mensaje compuesto, y las pruebas necesitan el
// correo completo para consultarlo con `SentEmail::email()`. // correo completo para consultarlo con `SentEmail::email()`.
@ -134,15 +129,12 @@ static QUEUED: Mutex<Vec<(i32, Email)>> = Mutex::new(Vec::new());
#[cfg(feature = "queue")] #[cfg(feature = "queue")]
pub(crate) fn hold(id: i32, email: Email) { pub(crate) fn hold(id: i32, email: Email) {
QUEUED QUEUED.lock().unwrap().push((id, email));
.lock()
.unwrap_or_else(PoisonError::into_inner)
.push((id, email));
} }
#[cfg(feature = "queue")] #[cfg(feature = "queue")]
pub(crate) fn release(id: i32) -> Option<Email> { pub(crate) fn release(id: i32) -> Option<Email> {
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)?; let index = queued.iter().position(|(queued_id, _)| *queued_id == id)?;
Some(queued.swap_remove(index).1) Some(queued.swap_remove(index).1)
} }

View file

@ -2,7 +2,7 @@
//! //!
//! Incluye también los permisos del rol "anonymous", que se aplican a las peticiones sin sesión. //! 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 std::time::Instant;
use pagetop::prelude::*; use pagetop::prelude::*;
@ -308,9 +308,7 @@ static ANONYMOUS_CACHE: RwLock<AnonymousCache> = RwLock::new(AnonymousCache {
/// a intentar en la siguiente petición. /// a intentar en la siguiente petición.
pub(crate) async fn anonymous_permissions() -> Arc<PermissionSet> { pub(crate) async fn anonymous_permissions() -> Arc<PermissionSet> {
let generation = { let generation = {
let cache = ANONYMOUS_CACHE let cache = ANONYMOUS_CACHE.read().unwrap();
.read()
.unwrap_or_else(PoisonError::into_inner);
if let Some((loaded_at, permissions)) = &cache.loaded if let Some((loaded_at, permissions)) = &cache.loaded
&& loaded_at.elapsed() < ANONYMOUS_TTL && loaded_at.elapsed() < ANONYMOUS_TTL
{ {
@ -334,9 +332,7 @@ pub(crate) async fn anonymous_permissions() -> Arc<PermissionSet> {
} }
}; };
let mut cache = ANONYMOUS_CACHE let mut cache = ANONYMOUS_CACHE.write().unwrap();
.write()
.unwrap_or_else(PoisonError::into_inner);
if cache.generation == generation { if cache.generation == generation {
cache.loaded = Some((Instant::now(), Arc::clone(&permissions))); cache.loaded = Some((Instant::now(), Arc::clone(&permissions)));
} }
@ -346,9 +342,7 @@ pub(crate) async fn anonymous_permissions() -> Arc<PermissionSet> {
/// Descarta los permisos de "anonymous" guardados en memoria, para que la siguiente petición sin /// 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. /// sesión los vuelva a leer. Se llama al cambiar los permisos de ese rol.
pub(crate) fn invalidate_anonymous_permissions() { pub(crate) fn invalidate_anonymous_permissions() {
let mut cache = ANONYMOUS_CACHE let mut cache = ANONYMOUS_CACHE.write().unwrap();
.write()
.unwrap_or_else(PoisonError::into_inner);
cache.generation = cache.generation.wrapping_add(1); cache.generation = cache.generation.wrapping_add(1);
cache.loaded = None; cache.loaded = None;
} }

View file

@ -7,7 +7,7 @@ use crate::config::SETTINGS;
use std::collections::{HashMap, VecDeque}; use std::collections::{HashMap, VecDeque};
use std::net::{IpAddr, Ipv6Addr}; use std::net::{IpAddr, Ipv6Addr};
use std::sync::{LazyLock, Mutex, PoisonError}; use std::sync::{LazyLock, Mutex};
use std::time::{Duration as StdDuration, Instant}; use std::time::{Duration as StdDuration, Instant};
// Momentos de las solicitudes de cada dirección dentro de la ventana, y última limpieza. // 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; return true;
}; };
let allowed = allow_at( let allowed = allow_at(
&mut lock(&REQUESTS), &mut REQUESTS.lock().unwrap(),
network(ip), network(ip),
Instant::now(), Instant::now(),
SETTINGS.max_ip_requests, SETTINGS.max_ip_requests,
@ -63,7 +63,7 @@ pub(crate) fn allow_login(request: &HttpRequest) -> bool {
return true; return true;
}; };
let allowed = allow_at( let allowed = allow_at(
&mut lock(&FAILED_LOGINS), &mut FAILED_LOGINS.lock().unwrap(),
network(ip), network(ip),
Instant::now(), Instant::now(),
SETTINGS.max_ip_failed_logins, 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. /// Retira un intento anotado por [`allow_login()`] que no ha resultado fallido.
pub(crate) fn forget_login(request: &HttpRequest) { pub(crate) fn forget_login(request: &HttpRequest) {
if let Some(ip) = request.client_ip() { 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 { fn window(secs: i64) -> StdDuration {
StdDuration::from_secs(u64::try_from(secs).unwrap_or(0)) StdDuration::from_secs(u64::try_from(secs).unwrap_or(0))
} }

View file

@ -11,10 +11,9 @@ use crate::response::read_flash_messages;
use crate::web::HttpRequest; use crate::web::HttpRequest;
use crate::{CowStr, util}; use crate::{CowStr, util};
use parking_lot::Mutex;
use std::any::{Any, TypeId}; use std::any::{Any, TypeId};
use std::collections::HashMap; use std::collections::HashMap;
use std::sync::Mutex;
mod assets_op; mod assets_op;
pub use assets_op::AssetsOp; pub use assets_op::AssetsOp;

View file

@ -481,7 +481,7 @@ pub trait Contextual {
segments segments
}; };
let count = { 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::<C>()).or_insert(0); let n = map.entry(TypeId::of::<C>()).or_insert(0);
*n += 1; *n += 1;
*n *n

View file

@ -1,9 +1,7 @@
use crate::core::theme::ThemeRef; use crate::core::theme::ThemeRef;
use crate::{global, trace}; use crate::{global, trace};
use parking_lot::RwLock; use std::sync::{LazyLock, RwLock};
use std::sync::LazyLock;
// **< TEMAS >************************************************************************************** // **< TEMAS >**************************************************************************************
@ -11,7 +9,7 @@ static THEMES: LazyLock<RwLock<Vec<ThemeRef>>> = LazyLock::new(|| RwLock::new(Ve
// Registra el tema si no lo estaba ya, para evitar duplicados. Devuelve `true` si lo ha añadido. // 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 { 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()) { if themes.iter().any(|t| t.type_id() == theme.type_id()) {
return false; 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. /// Devuelve los temas habilitados en la aplicación, en el orden en que se registraron.
pub fn enabled_themes() -> Vec<ThemeRef> { pub fn enabled_themes() -> Vec<ThemeRef> {
THEMES.read().clone() THEMES.read().unwrap().clone()
} }
/// Devuelve el tema identificado por su [`short_name()`](crate::core::AnyInfo::short_name). /// Devuelve el tema identificado por su [`short_name()`](crate::core::AnyInfo::short_name).
@ -30,6 +28,7 @@ pub fn enabled_themes() -> Vec<ThemeRef> {
pub fn theme_by_short_name(short_name: &str) -> Option<ThemeRef> { pub fn theme_by_short_name(short_name: &str) -> Option<ThemeRef> {
THEMES THEMES
.read() .read()
.unwrap()
.iter() .iter()
.find(|t| t.short_name().eq_ignore_ascii_case(short_name)) .find(|t| t.short_name().eq_ignore_ascii_case(short_name))
.copied() .copied()

View file

@ -2,10 +2,8 @@ use crate::core::component::{Child, ChildOp, Children, Component};
use crate::core::theme::{CoreRegions, RegionRef, ThemeRef}; use crate::core::theme::{CoreRegions, RegionRef, ThemeRef};
use crate::{AutoDefault, UniqueId, builder_impl}; use crate::{AutoDefault, UniqueId, builder_impl};
use parking_lot::RwLock;
use std::collections::HashMap; 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. // Lista de prototipos de componentes por nombre de región.
// //
@ -90,7 +88,7 @@ impl ChildrenInRegions {
let region_name = region.name(); let region_name = region.name();
// 1. Prototipos globales comunes. // 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( result.add_many(
global_protos global_protos
.iter() .iter()
@ -102,7 +100,7 @@ impl ChildrenInRegions {
result.add_many(page_children); result.add_many(page_children);
} }
// 3. Prototipos del tema activo. // 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) && let Some(theme_protos) = theme_region.get(region_name)
{ {
result.add_many( result.add_many(
@ -190,6 +188,7 @@ impl InRegion {
InRegion::ForTheme(theme, region) => { InRegion::ForTheme(theme, region) => {
THEME_REGIONS THEME_REGIONS
.write() .write()
.unwrap()
.entry(theme.type_id()) .entry(theme.type_id())
.or_default() .or_default()
.push((*region).name(), proto); .push((*region).name(), proto);
@ -200,6 +199,6 @@ impl InRegion {
#[inline] #[inline]
fn add_to_common(region: RegionRef, proto: Arc<dyn Component>) { fn add_to_common(region: RegionRef, proto: Arc<dyn Component>) {
COMMON_REGIONS.write().push(region.name(), proto); COMMON_REGIONS.write().unwrap().push(region.name(), proto);
} }
} }

View file

@ -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_appender::non_blocking::WorkerGuard;
use tracing_subscriber::EnvFilter; use tracing_subscriber::EnvFilter;
use std::sync::Mutex;
use std::sync::atomic::{AtomicBool, Ordering}; 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 // 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. // 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<Option<Vec<String>>> = Mutex::new(Some(Vec::new(
// basta para la configuración global, que `init()` lee antes de recoger los avisos. Usarla después // 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. // 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) { pub(crate) fn defer_warning(message: String) {
let mut deferred = DEFERRED_WARNINGS let mut deferred = DEFERRED_WARNINGS.lock().unwrap();
.lock()
.unwrap_or_else(PoisonError::into_inner);
match deferred.as_mut() { match deferred.as_mut() {
Some(warnings) => warnings.push(message), Some(warnings) => warnings.push(message),
None => { None => {
@ -70,7 +68,7 @@ pub(crate) fn init() -> Option<WorkerGuard> {
// Al leer `SETTINGS` en la línea anterior ya se han guardado los avisos de la configuración. // Al leer `SETTINGS` en la línea anterior ya se han guardado los avisos de la configuración.
let mut warnings = DEFERRED_WARNINGS let mut warnings = DEFERRED_WARNINGS
.lock() .lock()
.unwrap_or_else(PoisonError::into_inner) .unwrap()
.take() // Deja `None`, desde ahora, `defer_warning()` trata cualquier aviso como mal uso. .take() // Deja `None`, desde ahora, `defer_warning()` trata cualquier aviso como mal uso.
.unwrap_or_default(); .unwrap_or_default();
if !enabled { if !enabled {