Browse Source

RateLimit: remove unupdated test

jmap-eventsource
Manos Pitsidianakis 1 year ago
parent
commit
023afbaae3
Signed by: epilys GPG Key ID: 73627C2F690DF710
  1. 72
      src/types.rs

72
src/types.rs

@ -321,7 +321,6 @@ pub struct RateLimit {
pub active: bool,
}
//FIXME: tests.
impl RateLimit {
pub fn new(reqs: u64, millis: u64, job_executor: Arc<JobExecutor>) -> Self {
RateLimit {
@ -359,52 +358,17 @@ impl RateLimit {
self.timer.id()
}
}
#[test]
fn test_rate_limit() {
use std::sync::{Arc, Condvar, Mutex};
/* RateLimit sends a SIGALRM with its timer value in siginfo_t. */
let pair = Arc::new((Mutex::new(None), Condvar::new()));
let pair2 = pair.clone();
/* self-pipe trick:
* since we can only use signal-safe functions in the signal handler, make a pipe and
* write one byte to it from the handler. Counting the number of bytes in the pipe can tell
* us how many times the handler was called */
let (alarm_pipe_r, alarm_pipe_w) = nix::unistd::pipe().unwrap();
nix::fcntl::fcntl(
alarm_pipe_r,
nix::fcntl::FcntlArg::F_SETFL(nix::fcntl::OFlag::O_NONBLOCK),
)
.expect("Could not set pipe to NONBLOCK?");
let alarm_handler = move |info: &nix::libc::siginfo_t| {
let value = unsafe { info.si_value().sival_ptr as u8 };
let (lock, cvar) = &*pair2;
let mut started = lock.lock().unwrap();
/* set mutex to timer value */
*started = Some(value);
/* notify condvar in order to wake up the test thread */
cvar.notify_all();
nix::unistd::write(alarm_pipe_w, &[value]).expect("Could not write inside alarm handler?");
};
unsafe {
signal_hook_registry::register_sigaction(signal_hook::SIGALRM, alarm_handler).unwrap();
}
/*
let (sender, receiver) =
crossbeam::channel::bounded(4096 * ::std::mem::size_of::<ThreadEvent>());
use std::sync::Arc;
let job_executor = Arc::new(JobExecutor::new(sender));
/* Accept at most one request per 3 milliseconds */
let mut rt = RateLimit::new(1, 3);
let mut rt = RateLimit::new(1, 3, job_executor.clone());
std::thread::sleep(std::time::Duration::from_millis(2000));
let (lock, cvar) = &*pair;
let started = lock.lock().unwrap();
let result = cvar
.wait_timeout(started, std::time::Duration::from_millis(100))
.unwrap();
/* assert that the handler was called with rt's timer id */
assert_eq!(*result.0, Some(rt.id()));
drop(result);
drop(pair);
let mut buf = [0; 1];
nix::unistd::read(alarm_pipe_r, buf.as_mut()).expect("Could not read from self-pipe?");
/* assert that only one request per 3 milliseconds is accepted */
for _ in 0..5 {
assert!(rt.tick());
@ -416,16 +380,15 @@ fn test_rate_limit() {
/* How many times was the signal handler called? We've slept for at least 3
* milliseconds, so it should have been called once */
let mut ctr = 0;
while nix::unistd::read(alarm_pipe_r, buf.as_mut())
.map(|s| s > 0)
.unwrap_or(false)
{
while receiver.try_recv().is_ok() {
ctr += 1;
println!("got {}", ctr);
}
println!("ctr = {} {}", ctr, ctr == 1);
assert_eq!(ctr, 1);
}
/* next, test at most 100 requests per second */
let mut rt = RateLimit::new(100, 1000);
let mut rt = RateLimit::new(100, 1000, job_executor.clone());
for _ in 0..5 {
let mut ctr = 0;
for _ in 0..500 {
@ -441,16 +404,13 @@ fn test_rate_limit() {
std::thread::sleep(std::time::Duration::from_millis(1000));
/* How many times was the signal handler called? */
ctr = 0;
while nix::unistd::read(alarm_pipe_r, buf.as_mut())
.map(|s| s > 0)
.unwrap_or(false)
{
while receiver.try_recv().is_ok() {
ctr += 1;
}
assert_eq!(ctr, 1);
}
/* next, test at most 500 requests per second */
let mut rt = RateLimit::new(500, 1000);
let mut rt = RateLimit::new(500, 1000, job_executor.clone());
for _ in 0..5 {
let mut ctr = 0;
for _ in 0..500 {
@ -465,14 +425,12 @@ fn test_rate_limit() {
std::thread::sleep(std::time::Duration::from_millis(1000));
/* How many times was the signal handler called? */
ctr = 0;
while nix::unistd::read(alarm_pipe_r, buf.as_mut())
.map(|s| s > 0)
.unwrap_or(false)
{
while receiver.try_recv().is_ok() {
ctr += 1;
}
assert_eq!(ctr, 1);
}
*/
}
#[derive(Debug)]

Loading…
Cancel
Save