➖ 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:
parent
a6d15ab211
commit
698b917fb1
11 changed files with 31 additions and 56 deletions
|
|
@ -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)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -36,7 +36,7 @@ use pagetop::prelude::*;
|
|||
|
||||
use crate::Email;
|
||||
|
||||
use std::sync::{Mutex, MutexGuard, PoisonError};
|
||||
use std::sync::Mutex;
|
||||
|
||||
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.
|
||||
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
|
||||
/// demás.
|
||||
pub fn take_to(address: &str) -> Vec<SentEmail> {
|
||||
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<SentEmail> {
|
|||
}
|
||||
|
||||
pub(crate) fn push(email: Email, envelope_to: Vec<String>, raw: Vec<u8>) {
|
||||
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<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
|
||||
// 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<Vec<(i32, Email)>> = 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<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)?;
|
||||
Some(queued.swap_remove(index).1)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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<AnonymousCache> = RwLock::new(AnonymousCache {
|
|||
/// a intentar en la siguiente petición.
|
||||
pub(crate) async fn anonymous_permissions() -> Arc<PermissionSet> {
|
||||
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<PermissionSet> {
|
|||
}
|
||||
};
|
||||
|
||||
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<PermissionSet> {
|
|||
/// 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;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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))
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue