Commit add01553 authored by Andreas Gustafsson's avatar Andreas Gustafsson
Browse files

added isc_ratelimiter_t, a helper object that lets you

dispatch events to a task with a guaranteed minimum interval
parent 672893c2
......@@ -47,7 +47,8 @@ OBJS = @ISC_EXTRA_OBJS@ \
assertions.@O@ base64.@O@ bitstring.@O@ buffer.@O@ \
bufferlist.@O@ commandline.@O@ error.@O@ event.@O@ heap.@O@ \
lex.@O@ lib.@O@ log.@O@ \
mem.@O@ mutexblock.@O@ random.@O@ result.@O@ rwlock.@O@ \
mem.@O@ mutexblock.@O@ random.@O@ \
ratelimiter.@O@ result.@O@ rwlock.@O@ \
serial.@O@ sockaddr.@O@ str.@O@ symtab.@O@ \
task.@O@ taskpool.@O@ timer.@O@ version.@O@ \
${UNIXOBJS} ${NLSOBJS} ${PTHREADOBJS}
......@@ -57,7 +58,8 @@ SRCS = @ISC_EXTRA_SRCS@ \
assertions.c base64.c bitstring.c buffer.c \
bufferlist.c commandline.c error.c event.c heap.c \
lex.c lib.c log.c \
mem.c mutexblock.c random.c result.c rwlock.c \
mem.c mutexblock.c random.c \
ratelimiter.c result.c rwlock.c \
serial.c sockaddr.c str.c symtab.c \
task.c taskpool.c timer.c version.c
......
/*
* Copyright (C) 1999 Internet Software Consortium.
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS
* ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
* CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
* ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
* SOFTWARE.
*/
#ifndef ISC_RATELIMITER_H
#define ISC_RATELIMITER_H 1
/*****
***** Module Info
*****/
/*
* A rate limiter is a mechanism for dispatching events at a limited
* rate. This is intended to be used when sending zone maintenance
* SOA queries, NOTIFY messages, etc.
*/
/***
*** Imports.
***/
#include <isc/task.h>
#include <isc/timer.h>
ISC_LANG_BEGINDECLS
/*****
***** Types.
*****/
typedef struct isc_ratelimiter isc_ratelimiter_t;
typedef enum {
isc_ratelimiter_ratelimited,
isc_ratelimiter_worklimited
} isc_ratelimiter_state_t;
/*****
***** Functions.
*****/
isc_result_t
isc_ratelimiter_create(isc_mem_t *mctx, isc_timermgr_t *timermgr,
isc_task_t *task, isc_ratelimiter_t **ratelimiterp);
/*
* Create a rate limiter. It will execute events in the context
* of 'task' with a guaranteed minimum interval, initially zero.
*/
isc_result_t
isc_ratelimiter_setinterval(isc_ratelimiter_t *rl, isc_interval_t *interval);
/*
* Set the mininum interval between event executions.
* The interval value is copied, so the caller need not preserve it.
*/
isc_result_t
isc_ratelimiter_enqueue(isc_ratelimiter_t *rl, isc_event_t **eventp);
/*
* Queue an event for rate-limited execution. This is similar
* to doing an isc_task_send() to the rate limiter's task, except
* that the execution may be delayed to achieve the desired rate
* of execution.
*/
void
isc_ratelimiter_destroy(isc_ratelimiter_t **ratelimiterp);
/*
* Destroy a rate limiter. All events that have not yet been
* dispatched to the task are freed immedately.
* Does not destroy the task or events already queued on it.
*/
#endif /* ISC_RATELIMITER_H */
/*
* Copyright (C) 1999 Internet Software Consortium.
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS
* ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
* CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
* PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
* ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
* SOFTWARE.
*/
#include <config.h>
#include <isc/assertions.h>
#include <isc/boolean.h>
#include <isc/error.h>
#include <isc/ratelimiter.h>
#include "util.h"
struct isc_ratelimiter {
isc_mem_t * mctx;
isc_mutex_t lock;
isc_task_t * task;
isc_timer_t * timer;
isc_interval_t interval;
isc_ratelimiter_state_t state;
ISC_LIST(isc_event_t) pending;
};
static void ratelimiter_tick(isc_task_t *task, isc_event_t *event);
isc_result_t
isc_ratelimiter_create(isc_mem_t *mctx, isc_timermgr_t *timermgr,
isc_task_t *task, isc_ratelimiter_t **ratelimiterp)
{
isc_result_t result;
isc_ratelimiter_t *rl;
INSIST(ratelimiterp != NULL && *ratelimiterp == NULL);
rl = isc_mem_get(mctx, sizeof(*rl));
if (rl == NULL)
return ISC_R_NOMEMORY;
rl->mctx = mctx;
rl->task = task;
isc_interval_set(&rl->interval, 0, 0);
rl->timer = NULL;
rl->state = isc_ratelimiter_worklimited;
ISC_LIST_INIT(rl->pending);
result = isc_mutex_init(&rl->lock);
if (result != ISC_R_SUCCESS)
goto free_mem;
result = isc_timer_create(timermgr, isc_timertype_inactive,
NULL, NULL, rl->task, ratelimiter_tick,
rl, &rl->timer);
if (result != ISC_R_SUCCESS)
goto free_mutex;
*ratelimiterp = rl;
return (ISC_R_SUCCESS);
free_mutex:
isc_mutex_destroy(&rl->lock);
free_mem:
isc_mem_put(mctx, rl, sizeof(*rl));
return (result);
}
isc_result_t
isc_ratelimiter_setinterval(isc_ratelimiter_t *rl, isc_interval_t *interval)
{
isc_result_t result = ISC_R_SUCCESS;
LOCK(&rl->lock);
rl->interval = *interval;
/*
* If the timer is currently running, change its rate.
*/
if (rl->state == isc_ratelimiter_ratelimited) {
result = isc_timer_reset(rl->timer, isc_timertype_ticker, NULL,
&rl->interval, ISC_FALSE);
}
UNLOCK(&rl->lock);
return (result);
}
isc_result_t
isc_ratelimiter_enqueue(isc_ratelimiter_t *rl, isc_event_t **eventp)
{
isc_result_t result = ISC_R_SUCCESS;
INSIST(eventp != NULL && *eventp != NULL);
LOCK(&rl->lock);
if (rl->state == isc_ratelimiter_ratelimited) {
isc_event_t *ev = *eventp;
ISC_LIST_APPEND(rl->pending, ev, link);
*eventp = NULL;
} else {
result = isc_timer_reset(rl->timer, isc_timertype_ticker, NULL,
&rl->interval, ISC_FALSE);
if (result == ISC_R_SUCCESS)
rl->state = isc_ratelimiter_ratelimited;
}
UNLOCK(&rl->lock);
if (*eventp != NULL)
isc_task_send(rl->task, eventp);
ENSURE(*eventp == NULL);
return (result);
}
static void
ratelimiter_tick(isc_task_t *task, isc_event_t *event)
{
isc_result_t result = ISC_R_SUCCESS;
isc_ratelimiter_t *rl = (isc_ratelimiter_t *) event->arg;
isc_event_t *p;
(void) task; /* Unused */
LOCK(&rl->lock);
p = ISC_LIST_HEAD(rl->pending);
if (p != NULL) {
/*
* There is work to do. Let's do it after unlocking.
*/
ISC_LIST_UNLINK(rl->pending, p, link);
} else {
/*
* No work left to do. Stop the timer so that we don't
* waste resources by having it fire periodically.
*/
result = isc_timer_reset(rl->timer, isc_timertype_inactive,
NULL, NULL, ISC_FALSE);
RUNTIME_CHECK(result == ISC_R_SUCCESS);
rl->state = isc_ratelimiter_worklimited;
}
UNLOCK(&rl->lock);
isc_event_free(&event);
/*
* If we have an event, dispatch it.
* There is potential for optimization here since
* we are already executing in the context of "task".
*/
if (p != NULL)
isc_task_send(rl->task, &p);
INSIST(p == NULL);
}
void
isc_ratelimiter_destroy(isc_ratelimiter_t **ratelimiterp)
{
isc_ratelimiter_t *rl = *ratelimiterp;
isc_event_t *p;
(void) isc_timer_reset(rl->timer, isc_timertype_inactive,
NULL, NULL, ISC_FALSE);
isc_timer_detach(&rl->timer);
while ((p = ISC_LIST_HEAD(rl->pending)) != NULL) {
ISC_LIST_UNLINK(rl->pending, p, link);
isc_event_free(&p);
}
isc_mutex_destroy(&rl->lock);
isc_mem_put(rl->mctx, rl, sizeof(*rl));
*ratelimiterp = NULL;
}
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment