mirrors/cgit
0
0
Fork 0
mirror of https://git.zx2c4.com/cgit synced 2024-12-22 23:21:52 +00:00
Code Issues Packages Projects Releases Wiki Activity

filter: allow for cleanup hook for filter types

Browse Source 
At some point, we're going to want to do lazy deallocation of filters.
For example, if we implement lua, we'll want to load the lua runtime
once for each filter, even if that filter is called many times.
Similarly, for persistent exec filters, we'll want to load it once,
despite many open_filter and close_filter calls, and only reap the child
process at the end of the cgit process. For this reason, we add here a
cleanup function that is called at the end of cgit's main().

Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
This commit is contained in:
Jason A. Donenfeld 2014-01-12 20:58:21 +01:00
parent 4bb87cbf17
commit d750c7a2c9
3 changed files with 66 additions and 27 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
cgit.c
View File

@ -951,6 +951,7 @@ int main(int argc, const char **argv)
ctx.cfg.cache_size = 0;
err = cache_process(ctx.cfg.cache_size, ctx.cfg.cache_root,
ctx.qry.raw, ttl, process_request, &ctx);
cgit_cleanup_filters();
if (err)
cgit_print_error("Error processing page: %s (%d)",
strerror(err), err);

2
cgit.h
View File

@ -60,6 +60,7 @@ struct cgit_filter {
int (*open)(struct cgit_filter *, va_list ap);
int (*close)(struct cgit_filter *);
void (*fprintf)(struct cgit_filter *, FILE *, const char *prefix);
void (*cleanup)(struct cgit_filter *);
};
struct cgit_exec_filter {
@ -355,6 +356,7 @@ extern int cgit_close_filter(struct cgit_filter *filter);
extern void cgit_fprintf_filter(struct cgit_filter *filter, FILE *f, const char *prefix);
extern void cgit_exec_filter_init(struct cgit_exec_filter *filter, char *cmd, char **argv);
extern struct cgit_filter *cgit_new_filter(const char *cmd, filter_type filtertype);
extern void cgit_cleanup_filters(void);
extern void cgit_prepare_repo_env(struct cgit_repo * repo);

90
filter.c
View File

@ -13,6 +13,25 @@
#include <string.h>
#include <stdlib.h>
static inline void reap_filter(struct cgit_filter *filter)
{
if (filter && filter->cleanup)
filter->cleanup(filter);
}
void cgit_cleanup_filters(void)
{
int i;
reap_filter(ctx.cfg.about_filter);
reap_filter(ctx.cfg.commit_filter);
reap_filter(ctx.cfg.source_filter);
for (i = 0; i < cgit_repolist.count; ++i) {
reap_filter(cgit_repolist.repos[i].about_filter);
reap_filter(cgit_repolist.repos[i].commit_filter);
reap_filter(cgit_repolist.repos[i].source_filter);
}
}
static int open_exec_filter(struct cgit_filter *base, va_list ap)
{
struct cgit_exec_filter *filter = (struct cgit_exec_filter *) base;
@ -67,34 +86,17 @@ static void fprintf_exec_filter(struct cgit_filter *base, FILE *f, const char *p
fprintf(f, "%sexec:%s\n", prefix, filter->cmd);
}
int cgit_open_filter(struct cgit_filter *filter, ...)
static void cleanup_exec_filter(struct cgit_filter *base)
{
int result;
va_list ap;
va_start(ap, filter);
result = filter->open(filter, ap);
va_end(ap);
return result;
}
int cgit_close_filter(struct cgit_filter *filter)
{
return filter->close(filter);
}
void cgit_fprintf_filter(struct cgit_filter *filter, FILE *f, const char *prefix)
{
filter->fprintf(filter, f, prefix);
}
void cgit_exec_filter_init(struct cgit_exec_filter *filter, char *cmd, char **argv)
{
memset(filter, 0, sizeof(*filter));
filter->base.open = open_exec_filter;
filter->base.close = close_exec_filter;
filter->base.fprintf = fprintf_exec_filter;
filter->cmd = cmd;
filter->argv = argv;
struct cgit_exec_filter *filter = (struct cgit_exec_filter *) base;
if (filter->argv) {
free(filter->argv);
filter->argv = NULL;
}
if (filter->cmd) {
free(filter->cmd);
filter->cmd = NULL;
}
}
static struct cgit_filter *new_exec_filter(const char *cmd, filter_type filtertype)
@ -125,6 +127,39 @@ static struct cgit_filter *new_exec_filter(const char *cmd, filter_type filterty
return &f->base;
}
void cgit_exec_filter_init(struct cgit_exec_filter *filter, char *cmd, char **argv)
{
memset(filter, 0, sizeof(*filter));
filter->base.open = open_exec_filter;
filter->base.close = close_exec_filter;
filter->base.fprintf = fprintf_exec_filter;
filter->base.cleanup = cleanup_exec_filter;
filter->cmd = cmd;
filter->argv = argv;
}
int cgit_open_filter(struct cgit_filter *filter, ...)
{
int result;
va_list ap;
va_start(ap, filter);
result = filter->open(filter, ap);
va_end(ap);
return result;
}
int cgit_close_filter(struct cgit_filter *filter)
{
return filter->close(filter);
}
void cgit_fprintf_filter(struct cgit_filter *filter, FILE *f, const char *prefix)
{
filter->fprintf(filter, f, prefix);
}
static const struct {
const char *prefix;
struct cgit_filter *(*ctor)(const char *cmd, filter_type filtertype);
@ -161,3 +196,4 @@ struct cgit_filter *cgit_new_filter(const char *cmd, filter_type filtertype)
die("Invalid filter type: %.*s", (int) len, cmd);
}