source/cache.hrev: 083bbd18b7 (latest)


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

/*
 * The front door to cgit's page cache. A caller hands over a key identifying
 * the request and a callback that renders the page, and gets back either the
 * copy already on disk or a freshly rendered one.
 */

#ifndef CGIT_CACHE_H
#define CGIT_CACHE_H

#include <stddef.h>

typedef void (*cache_fill_fn)(void);

/*
 * Write the page for key to stdout, taking it from the cache when a fresh
 * slot for that key is there and rendering it through fn when it is not. size
 * is how many slots the cache may use and path is the directory holding them.
 * ttl is how many minutes a slot for this key stays fresh, where a negative
 * ttl never expires and a ttl of zero skips the cache for this request. A
 * page larger than max_bytes is served but not kept, and zero sets no bound.
 * Returns 0 when the page was written, and an errno value when it was not.
 */
extern int cache_process(int size, const char *path, const char *key, int ttl,
	size_t max_bytes, cache_fill_fn fn);

/*
 * Write one line per cache slot to stdout, giving its path, modification time,
 * size and key.
 */
extern void cache_ls(const char *path);

/*
 * Give up on the slot being filled and put stdout back on the client, after
 * sending what was rendered into the slot so far. Anything that ends a request
 * part way through rendering has to call this before it writes what the
 * visitor should see, because until then stdout is the cache file. Returns
 * non-zero when a fill was abandoned and zero when none was in progress.
 */
extern int cache_abandon_fill(void);

extern unsigned long cache_hash_str(const char *str);

/*
 * Open the lock file at path, creating it if need be, then lock it without
 * waiting and empty it, leaving the descriptor in *fd. The lock holds until
 * the last descriptor on the file closes, and the caller renames or removes
 * the file before that. Returns 0, EAGAIN or EWOULDBLOCK when another process
 * holds the lock or has renamed the file away, or the errno of the step that
 * failed, which has been logged. *fd is -1 on failure.
 */
extern int cache_lock_file(const char *path, int *fd);

#endif // CGIT_CACHE_H