History

Merge branch 'lh/cache'

* lh/cache: Add page 'ls_cache' Redesign the caching layer

Lars Hjemli committed 18 years ago

Commit e19683b2 parents 112b208 9000bbf7 files · +506 −216Browse files

Unified · Split

7 files
  1. cache.c +359 −68
  2. cache.h +25 −13
  3. cgit.c +37 −129
  4. cgit.h +1 −0
  5. cmd.c +16 −5
  6. tests/setup.sh +1 −1
  7. tests/t0020-validate-cache.sh +67 −0
cache.c+359−68
@@ -4,117 +4,408 @@ · 3 unmodified lines
4 *4 *
5 * Licensed under GNU General Public License v25 * Licensed under GNU General Public License v2
6 * (see COPYING for full license text)6 * (see COPYING for full license text)
7 *
8 *
9 * The cache is just a directory structure where each file is a cache slot,
10 * and each filename is based on the hash of some key (e.g. the cgit url).
11 * Each file contains the full key followed by the cached content for that
12 * key.
13 *
7 */14 */
8 15
9#include "cgit.h"16#include "cgit.h"
10#include "cache.h"17#include "cache.h"
11 18
12const int NOLOCK = -1;19#define CACHE_BUFSIZE (1024 * 4)
13 20
14char *cache_safe_filename(const char *unsafe)21struct cache_slot {
22 const char *key;
23 int keylen;
24 int ttl;
25 cache_fill_fn fn;
26 void *cbdata;
27 int cache_fd;
28 int lock_fd;
29 const char *cache_name;
30 const char *lock_name;
31 int match;
32 struct stat cache_st;
33 struct stat lock_st;
34 int bufsize;
35 char buf[CACHE_BUFSIZE];
36};
37
38/* Open an existing cache slot and fill the cache buffer with
39 * (part of) the content of the cache file. Return 0 on success
40 * and errno otherwise.
41 */
42static int open_slot(struct cache_slot *slot)
15{43{
16 static char buf[4][PATH_MAX];44 char *bufz;
17 static int bufidx;45 int bufkeylen = -1;
18 char *s;46
19 char c;47 slot->cache_fd = open(slot->cache_name, O_RDONLY);
20 48 if (slot->cache_fd == -1)
21 bufidx++;49 return errno;
22 bufidx &= 3;50
23 s = buf[bufidx];51 if (fstat(slot->cache_fd, &slot->cache_st))
24 52 return errno;
25 while(unsafe && (c = *unsafe++) != 0) {53
26 if (c == '/' || c == ' ' || c == '&' || c == '|' ||54 slot->bufsize = read(slot->cache_fd, slot->buf, sizeof(slot->buf));
27 c == '>' || c == '<' || c == '.')55 if (slot->bufsize == 0)
28 c = '_';56 return errno;
29 *s++ = c;57
30 }58 bufz = memchr(slot->buf, 0, slot->bufsize);
31 *s = '\0';59 if (bufz)
32 return buf[bufidx];60 bufkeylen = bufz - slot->buf;
61
62 slot->match = bufkeylen == slot->keylen &&
63 !memcmp(slot->key, slot->buf, bufkeylen + 1);
64
65 return 0;
33}66}
34 67
35int cache_exist(struct cacheitem *item)68/* Close the active cache slot */
69static void close_slot(struct cache_slot *slot)
36{70{
37 if (stat(item->name, &item->st)) {71 if (slot->cache_fd > 0) {
38 item->st.st_mtime = 0;72 close(slot->cache_fd);
39 return 0;73 slot->cache_fd = -1;
40 }74 }
41 return 1;
42}75}
43 76
44int cache_create_dirs()77/* Print the content of the active cache slot (but skip the key). */
78static int print_slot(struct cache_slot *slot)
45{79{
46 char *path;80 ssize_t i, j = 0;
81
82 i = lseek(slot->cache_fd, slot->keylen + 1, SEEK_SET);
83 if (i != slot->keylen + 1)
84 return errno;
85
86 while((i=read(slot->cache_fd, slot->buf, sizeof(slot->buf))) > 0)
87 j = write(STDOUT_FILENO, slot->buf, i);
47 88
48 path = fmt("%s", ctx.cfg.cache_root);89 if (j < 0)
49 if (mkdir(path, S_IRWXU) && errno!=EEXIST)90 return errno;
91 else
50 return 0;92 return 0;
93}
51 94
52 if (!ctx.repo)95/* Check if the slot has expired */
96static int is_expired(struct cache_slot *slot)
97{
98 if (slot->ttl < 0)
53 return 0;99 return 0;
100 else
101 return slot->cache_st.st_mtime + slot->ttl*60 < time(NULL);
102}
54 103
55 path = fmt("%s/%s", ctx.cfg.cache_root,104/* Check if the slot has been modified since we opened it.
56 cache_safe_filename(ctx.repo->url));105 * NB: If stat() fails, we pretend the file is modified.
106 */
107static int is_modified(struct cache_slot *slot)
108{
109 struct stat st;
57 110
58 if (mkdir(path, S_IRWXU) && errno!=EEXIST)111 if (stat(slot->cache_name, &st))
59 return 0;112 return 1;
113 return (st.st_ino != slot->cache_st.st_ino ||
114 st.st_mtime != slot->cache_st.st_mtime ||
115 st.st_size != slot->cache_st.st_size);
116}
60 117
61 if (ctx.qry.page) {118/* Close an open lockfile */
62 path = fmt("%s/%s/%s", ctx.cfg.cache_root,119static void close_lock(struct cache_slot *slot)
63 cache_safe_filename(ctx.repo->url),120{
64 ctx.qry.page);121 if (slot->lock_fd > 0) {
65 if (mkdir(path, S_IRWXU) && errno!=EEXIST)122 close(slot->lock_fd);
66 return 0;123 slot->lock_fd = -1;
67 }124 }
68 return 1;
69}125}
70 126
71int cache_refill_overdue(const char *lockfile)127/* Create a lockfile used to store the generated content for a cache
128 * slot, and write the slot key + \0 into it.
129 * Returns 0 on success and errno otherwise.
130 */
131static int lock_slot(struct cache_slot *slot)
72{132{
73 struct stat st;133 slot->lock_fd = open(slot->lock_name, O_RDWR|O_CREAT|O_EXCL,
134 S_IRUSR|S_IWUSR);
135 if (slot->lock_fd == -1)
136 return errno;
137 write(slot->lock_fd, slot->key, slot->keylen + 1);
138 return 0;
139}
74 140
75 if (stat(lockfile, &st))141/* Release the current lockfile. If `replace_old_slot` is set the
76 return 0;142 * lockfile replaces the old cache slot, otherwise the lockfile is
143 * just deleted.
144 */
145static int unlock_slot(struct cache_slot *slot, int replace_old_slot)
146{
147 int err;
148
149 if (replace_old_slot)
150 err = rename(slot->lock_name, slot->cache_name);
77 else151 else
78 return (time(NULL) - st.st_mtime > ctx.cfg.cache_max_create_time);152 err = unlink(slot->lock_name);
153 return err;
79}154}
80 155
81int cache_lock(struct cacheitem *item)156/* Generate the content for the current cache slot by redirecting
157 * stdout to the lock-fd and invoking the callback function
158 */
159static int fill_slot(struct cache_slot *slot)
82{160{
83 int i = 0;161 int tmp;
84 char *lockfile = xstrdup(fmt("%s.lock", item->name));
85 162
86 top:163 /* Preserve stdout */
87 if (++i > ctx.cfg.max_lock_attempts)164 tmp = dup(STDOUT_FILENO);
88 die("cache_lock: unable to lock %s: %s",165 if (tmp == -1)
89 item->name, strerror(errno));166 return errno;
90 167
91 item->fd = open(lockfile, O_WRONLY|O_CREAT|O_EXCL, S_IRUSR|S_IWUSR);168 /* Redirect stdout to lockfile */
169 if (dup2(slot->lock_fd, STDOUT_FILENO) == -1)
170 return errno;
92 171
93 if (item->fd == NOLOCK && errno == ENOENT && cache_create_dirs())172 /* Generate cache content */
94 goto top;173 slot->fn(slot->cbdata);
95 174
96 if (item->fd == NOLOCK && errno == EEXIST &&175 /* Restore stdout */
97 cache_refill_overdue(lockfile) && !unlink(lockfile))176 if (dup2(tmp, STDOUT_FILENO) == -1)
98 goto top;177 return errno;
99 178
100 free(lockfile);179 /* Close the temporary filedescriptor */
101 return (item->fd > 0);180 close(tmp);
181 return 0;
102}182}
103 183
104int cache_unlock(struct cacheitem *item)184/* Crude implementation of 32-bit FNV-1 hash algorithm,
185 * see http://www.isthe.com/chongo/tech/comp/fnv/ for details
186 * about the magic numbers.
187 */
188#define FNV_OFFSET 0x811c9dc5
189#define FNV_PRIME 0x01000193
190
191unsigned long hash_str(const char *str)
105{192{
106 close(item->fd);193 unsigned long h = FNV_OFFSET;
107 return (rename(fmt("%s.lock", item->name), item->name) == 0);194 unsigned char *s = (unsigned char *)str;
195
196 if (!s)
197 return h;
198
199 while(*s) {
200 h *= FNV_PRIME;
201 h ^= *s++;
202 }
203 return h;
108}204}
109 205
110int cache_cancel_lock(struct cacheitem *item)206static int process_slot(struct cache_slot *slot)
111{207{
112 return (unlink(fmt("%s.lock", item->name)) == 0);208 int err;
209
210 err = open_slot(slot);
211 if (!err && slot->match) {
212 if (is_expired(slot)) {
213 if (!lock_slot(slot)) {
214 /* If the cachefile has been replaced between
215 * `open_slot` and `lock_slot`, we'll just
216 * serve the stale content from the original
217 * cachefile. This way we avoid pruning the
218 * newly generated slot. The same code-path
219 * is chosen if fill_slot() fails for some
220 * reason.
221 *
222 * TODO? check if the new slot contains the
223 * same key as the old one, since we would
224 * prefer to serve the newest content.
225 * This will require us to open yet another
226 * file-descriptor and read and compare the
227 * key from the new file, so for now we're
228 * lazy and just ignore the new file.
229 */
230 if (is_modified(slot) || fill_slot(slot)) {
231 unlock_slot(slot, 0);
232 close_lock(slot);
233 } else {
234 close_slot(slot);
235 unlock_slot(slot, 1);
236 slot->cache_fd = slot->lock_fd;
237 }
238 }
239 }
240 print_slot(slot);
241 close_slot(slot);
242 return 0;
243 }
244
245 /* If the cache slot does not exist (or its key doesn't match the
246 * current key), lets try to create a new cache slot for this
247 * request. If this fails (for whatever reason), lets just generate
248 * the content without caching it and fool the caller to belive
249 * everything worked out (but print a warning on stdout).
250 */
251
252 close_slot(slot);
253 if ((err = lock_slot(slot)) != 0) {
254 cache_log("[cgit] Unable to lock slot %s: %s (%d)\n",
255 slot->lock_name, strerror(err), err);
256 slot->fn(slot->cbdata);
257 return 0;
258 }
259
260 if ((err = fill_slot(slot)) != 0) {
261 cache_log("[cgit] Unable to fill slot %s: %s (%d)\n",
262 slot->lock_name, strerror(err), err);
263 unlock_slot(slot, 0);
264 close_lock(slot);
265 slot->fn(slot->cbdata);
266 return 0;
267 }
268 // We've got a valid cache slot in the lock file, which
269 // is about to replace the old cache slot. But if we
270 // release the lockfile and then try to open the new cache
271 // slot, we might get a race condition with a concurrent
272 // writer for the same cache slot (with a different key).
273 // Lets avoid such a race by just printing the content of
274 // the lock file.
275 slot->cache_fd = slot->lock_fd;
276 unlock_slot(slot, 1);
277 err = print_slot(slot);
278 close_slot(slot);
279 return err;
113}280}
114 281
115int cache_expired(struct cacheitem *item)282/* Print cached content to stdout, generate the content if necessary. */
283int cache_process(int size, const char *path, const char *key, int ttl,
284 cache_fill_fn fn, void *cbdata)
116{285{
117 if (item->ttl < 0)286 unsigned long hash;
287 int len, i;
288 char filename[1024];
289 char lockname[1024 + 5]; /* 5 = ".lock" */
290 struct cache_slot slot;
291
292 /* If the cache is disabled, just generate the content */
293 if (size <= 0) {
294 fn(cbdata);
295 return 0;
296 }
297
298 /* Verify input, calculate filenames */
299 if (!path) {
300 cache_log("[cgit] Cache path not specified, caching is disabled\n");
301 fn(cbdata);
118 return 0;302 return 0;
119 return item->st.st_mtime + item->ttl * 60 < time(NULL);303 }
304 len = strlen(path);
305 if (len > sizeof(filename) - 10) { /* 10 = "/01234567\0" */
306 cache_log("[cgit] Cache path too long, caching is disabled: %s\n",
307 path);
308 fn(cbdata);
309 return 0;
310 }
311 if (!key)
312 key = "";
313 hash = hash_str(key) % size;
314 strcpy(filename, path);
315 if (filename[len - 1] != '/')
316 filename[len++] = '/';
317 for(i = 0; i < 8; i++) {
318 sprintf(filename + len++, "%x",
319 (unsigned char)(hash & 0xf));
320 hash >>= 4;
321 }
322 filename[len] = '\0';
323 strcpy(lockname, filename);
324 strcpy(lockname + len, ".lock");
325 slot.fn = fn;
326 slot.cbdata = cbdata;
327 slot.ttl = ttl;
328 slot.cache_name = filename;
329 slot.lock_name = lockname;
330 slot.key = key;
331 slot.keylen = strlen(key);
332 return process_slot(&slot);
120}333}
334
335/* Return a strftime formatted date/time
336 * NB: the result from this function is to shared memory
337 */
338char *sprintftime(const char *format, time_t time)
339{
340 static char buf[64];
341 struct tm *tm;
342
343 if (!time)
344 return NULL;
345 tm = gmtime(&time);
346 strftime(buf, sizeof(buf)-1, format, tm);
347 return buf;
348}
349
350int cache_ls(const char *path)
351{
352 DIR *dir;
353 struct dirent *ent;
354 int err = 0;
355 struct cache_slot slot;
356 char fullname[1024];
357 char *name;
358
359 if (!path) {
360 cache_log("[cgit] cache path not specified\n");
361 return -1;
362 }
363 if (strlen(path) > 1024 - 10) {
364 cache_log("[cgit] cache path too long: %s\n",
365 path);
366 return -1;
367 }
368 dir = opendir(path);
369 if (!dir) {
370 err = errno;
371 cache_log("[cgit] unable to open path %s: %s (%d)\n",
372 path, strerror(err), err);
373 return err;
374 }
375 strcpy(fullname, path);
376 name = fullname + strlen(path);
377 if (*(name - 1) != '/') {
378 *name++ = '/';
379 *name = '\0';
380 }
381 slot.cache_name = fullname;
382 while((ent = readdir(dir)) != NULL) {
383 if (strlen(ent->d_name) != 8)
384 continue;
385 strcpy(name, ent->d_name);
386 if ((err = open_slot(&slot)) != 0) {
387 cache_log("[cgit] unable to open path %s: %s (%d)\n",
388 fullname, strerror(err), err);
389 continue;
390 }
391 printf("%s %s %10lld %s\n",
392 name,
393 sprintftime("%Y-%m-%d %H:%M:%S",
394 slot.cache_st.st_mtime),
395 slot.cache_st.st_size,
396 slot.buf);
397 close_slot(&slot);
398 }
399 closedir(dir);
400 return 0;
401}
402
403/* Print a message to stdout */
404void cache_log(const char *format, ...)
405{
406 va_list args;
407 va_start(args, format);
408 vfprintf(stderr, format, args);
409 va_end(args);
410}
411
cache.h+25−13
@@ -6,18 +6,30 @@ · 5 unmodified lines
6#ifndef CGIT_CACHE_H6#ifndef CGIT_CACHE_H
7#define CGIT_CACHE_H7#define CGIT_CACHE_H
8 8
9struct cacheitem {9typedef void (*cache_fill_fn)(void *cbdata);
10 char *name;10
11 struct stat st;11
12 int ttl;12/* Print cached content to stdout, generate the content if necessary.
13 int fd;13 *
14};14 * Parameters
15 15 * size max number of cache files
16extern char *cache_safe_filename(const char *unsafe);16 * path directory used to store cache files
17extern int cache_lock(struct cacheitem *item);17 * key the key used to lookup cache files
18extern int cache_unlock(struct cacheitem *item);18 * ttl max cache time in seconds for this key
19extern int cache_cancel_lock(struct cacheitem *item);19 * fn content generator function for this key
20extern int cache_exist(struct cacheitem *item);20 * cbdata user-supplied data to the content generator function
21extern int cache_expired(struct cacheitem *item);21 *
22 * Return value
23 * 0 indicates success, everyting else is an error
24 */
25extern int cache_process(int size, const char *path, const char *key, int ttl,
26 cache_fill_fn fn, void *cbdata);
27
28
29/* List info about all cache entries on stdout */
30extern int cache_ls(const char *path);
31
32/* Print a message to stdout */
33extern void cache_log(const char *format, ...);
22 34
23#endif /* CGIT_CACHE_H */35#endif /* CGIT_CACHE_H */
cgit.c+37−129
@@ -49,6 +49,8 @@ void config_cb(const char *name, const char *value) · 48 unmodified lines
49 ctx.cfg.enable_log_filecount = atoi(value);49 ctx.cfg.enable_log_filecount = atoi(value);
50 else if (!strcmp(name, "enable-log-linecount"))50 else if (!strcmp(name, "enable-log-linecount"))
51 ctx.cfg.enable_log_linecount = atoi(value);51 ctx.cfg.enable_log_linecount = atoi(value);
52 else if (!strcmp(name, "cache-size"))
53 ctx.cfg.cache_size = atoi(value);
52 else if (!strcmp(name, "cache-root"))54 else if (!strcmp(name, "cache-root"))
53 ctx.cfg.cache_root = xstrdup(value);55 ctx.cfg.cache_root = xstrdup(value);
54 else if (!strcmp(name, "cache-root-ttl"))56 else if (!strcmp(name, "cache-root-ttl"))
@@ -147,6 +149,8 @@ static void prepare_context(struct cgit_context *ctx) · 92 unmodified lines
147{149{
148 memset(ctx, 0, sizeof(ctx));150 memset(ctx, 0, sizeof(ctx));
149 ctx->cfg.agefile = "info/web/last-modified";151 ctx->cfg.agefile = "info/web/last-modified";
152 ctx->cfg.nocache = 0;
153 ctx->cfg.cache_size = 0;
150 ctx->cfg.cache_dynamic_ttl = 5;154 ctx->cfg.cache_dynamic_ttl = 5;
151 ctx->cfg.cache_max_create_time = 5;155 ctx->cfg.cache_max_create_time = 5;
152 ctx->cfg.cache_repo_ttl = 5;156 ctx->cfg.cache_repo_ttl = 5;
@@ -168,47 +172,8 @@ static void prepare_context(struct cgit_context *ctx) · 15 unmodified lines
168 ctx->page.mimetype = "text/html";172 ctx->page.mimetype = "text/html";
169 ctx->page.charset = PAGE_ENCODING;173 ctx->page.charset = PAGE_ENCODING;
170 ctx->page.filename = NULL;174 ctx->page.filename = NULL;
171}175 ctx->page.modified = time(NULL);
172 176 ctx->page.expires = ctx->page.modified;
173static int cgit_prepare_cache(struct cacheitem *item)
174{
175 if (!ctx.repo && ctx.qry.repo) {
176 ctx.page.title = fmt("%s - %s", ctx.cfg.root_title,
177 "Bad request");
178 cgit_print_http_headers(&ctx);
179 cgit_print_docstart(&ctx);
180 cgit_print_pageheader(&ctx);
181 cgit_print_error(fmt("Unknown repo: %s", ctx.qry.repo));
182 cgit_print_docend();
183 return 0;
184 }
185
186 if (!ctx.repo) {
187 item->name = xstrdup(fmt("%s/index.%s.html",
188 ctx.cfg.cache_root,
189 cache_safe_filename(ctx.qry.raw)));
190 item->ttl = ctx.cfg.cache_root_ttl;
191 return 1;
192 }
193
194 if (!ctx.qry.page) {
195 item->name = xstrdup(fmt("%s/%s/index.%s.html", ctx.cfg.cache_root,
196 cache_safe_filename(ctx.repo->url),
197 cache_safe_filename(ctx.qry.raw)));
198 item->ttl = ctx.cfg.cache_repo_ttl;
199 } else {
200 item->name = xstrdup(fmt("%s/%s/%s/%s.html", ctx.cfg.cache_root,
201 cache_safe_filename(ctx.repo->url),
202 ctx.qry.page,
203 cache_safe_filename(ctx.qry.raw)));
204 if (ctx.qry.has_symref)
205 item->ttl = ctx.cfg.cache_dynamic_ttl;
206 else if (ctx.qry.has_sha1)
207 item->ttl = ctx.cfg.cache_static_ttl;
208 else
209 item->ttl = ctx.cfg.cache_repo_ttl;
210 }
211 return 1;
212}177}
213 178
214struct refmatch {179struct refmatch {
@@ -293,8 +258,9 @@ static int prepare_repo_cmd(struct cgit_context *ctx) · 78 unmodified lines
293 return 0;258 return 0;
294}259}
295 260
296static void process_request(struct cgit_context *ctx)261static void process_request(void *cbdata)
297{262{
263 struct cgit_context *ctx = cbdata;
298 struct cgit_cmd *cmd;264 struct cgit_cmd *cmd;
299 265
300 cmd = cgit_get_cmd(ctx);266 cmd = cgit_get_cmd(ctx);
@@ -333,82 +299,6 @@ static void process_request(struct cgit_context *ctx) · 32 unmodified lines
333 cgit_print_docend();299 cgit_print_docend();
334}300}
335 301
336static long ttl_seconds(long ttl)
337{
338 if (ttl<0)
339 return 60 * 60 * 24 * 365;
340 else
341 return ttl * 60;
342}
343
344static void cgit_fill_cache(struct cacheitem *item, int use_cache)
345{
346 int stdout2;
347
348 if (use_cache) {
349 stdout2 = chk_positive(dup(STDOUT_FILENO),
350 "Preserving STDOUT");
351 chk_zero(close(STDOUT_FILENO), "Closing STDOUT");
352 chk_positive(dup2(item->fd, STDOUT_FILENO), "Dup2(cachefile)");
353 }
354
355 ctx.page.modified = time(NULL);
356 ctx.page.expires = ctx.page.modified + ttl_seconds(item->ttl);
357 process_request(&ctx);
358
359 if (use_cache) {
360 chk_zero(close(STDOUT_FILENO), "Close redirected STDOUT");
361 chk_positive(dup2(stdout2, STDOUT_FILENO),
362 "Restoring original STDOUT");
363 chk_zero(close(stdout2), "Closing temporary STDOUT");
364 }
365}
366
367static void cgit_check_cache(struct cacheitem *item)
368{
369 int i = 0;
370
371 top:
372 if (++i > ctx.cfg.max_lock_attempts) {
373 die("cgit_refresh_cache: unable to lock %s: %s",
374 item->name, strerror(errno));
375 }
376 if (!cache_exist(item)) {
377 if (!cache_lock(item)) {
378 sleep(1);
379 goto top;
380 }
381 if (!cache_exist(item)) {
382 cgit_fill_cache(item, 1);
383 cache_unlock(item);
384 } else {
385 cache_cancel_lock(item);
386 }
387 } else if (cache_expired(item) && cache_lock(item)) {
388 if (cache_expired(item)) {
389 cgit_fill_cache(item, 1);
390 cache_unlock(item);
391 } else {
392 cache_cancel_lock(item);
393 }
394 }
395}
396
397static void cgit_print_cache(struct cacheitem *item)
398{
399 static char buf[4096];
400 ssize_t i;
401
402 int fd = open(item->name, O_RDONLY);
403 if (fd<0)
404 die("Unable to open cached file %s", item->name);
405
406 while((i=read(fd, buf, sizeof(buf))) > 0)
407 write(STDOUT_FILENO, buf, i);
408
409 close(fd);
410}
411
412static void cgit_parse_args(int argc, const char **argv)302static void cgit_parse_args(int argc, const char **argv)
413{303{
414 int i;304 int i;
@@ -443,13 +333,29 @@ static void cgit_parse_args(int argc, const char **argv) · 28 unmodified lines
443 }333 }
444}334}
445 335
336static int calc_ttl()
337{
338 if (!ctx.repo)
339 return ctx.cfg.cache_root_ttl;
340
341 if (!ctx.qry.page)
342 return ctx.cfg.cache_repo_ttl;
343
344 if (ctx.qry.has_symref)
345 return ctx.cfg.cache_dynamic_ttl;
346
347 if (ctx.qry.has_sha1)
348 return ctx.cfg.cache_static_ttl;
349
350 return ctx.cfg.cache_repo_ttl;
351}
352
446int main(int argc, const char **argv)353int main(int argc, const char **argv)
447{354{
448 struct cacheitem item;
449 const char *cgit_config_env = getenv("CGIT_CONFIG");355 const char *cgit_config_env = getenv("CGIT_CONFIG");
356 int err, ttl;
450 357
451 prepare_context(&ctx);358 prepare_context(&ctx);
452 item.st.st_mtime = time(NULL);
453 cgit_repolist.length = 0;359 cgit_repolist.length = 0;
454 cgit_repolist.count = 0;360 cgit_repolist.count = 0;
455 cgit_repolist.repos = NULL;361 cgit_repolist.repos = NULL;
@@ -463,13 +369,15 @@ int main(int argc, const char **argv) · 7 unmodified lines
463 ctx.qry.raw = xstrdup(getenv("QUERY_STRING"));369 ctx.qry.raw = xstrdup(getenv("QUERY_STRING"));
464 cgit_parse_args(argc, argv);370 cgit_parse_args(argc, argv);
465 http_parse_querystring(ctx.qry.raw, querystring_cb);371 http_parse_querystring(ctx.qry.raw, querystring_cb);
466 if (!cgit_prepare_cache(&item))372
467 return 0;373 ttl = calc_ttl();
468 if (ctx.cfg.nocache) {374 ctx.page.expires += ttl*60;
469 cgit_fill_cache(&item, 0);375 if (ctx.cfg.nocache)
470 } else {376 ctx.cfg.cache_size = 0;
471 cgit_check_cache(&item);377 err = cache_process(ctx.cfg.cache_size, ctx.cfg.cache_root,
472 cgit_print_cache(&item);378 ctx.qry.raw, ttl, process_request, &ctx);
473 }379 if (err)
474 return 0;380 cache_log("[cgit] error %d - %s\n",
381 err, strerror(err));
382 return err;
475}383}
cgit.h+1−0
@@ -136,6 +136,7 @@ struct cgit_config { · 135 unmodified lines
136 char *root_readme;136 char *root_readme;
137 char *script_name;137 char *script_name;
138 char *virtual_root;138 char *virtual_root;
139 int cache_size;
139 int cache_dynamic_ttl;140 int cache_dynamic_ttl;
140 int cache_max_create_time;141 int cache_max_create_time;
141 int cache_repo_ttl;142 int cache_repo_ttl;
cmd.c+16−5
@@ -8,6 +8,8 @@ · 7 unmodified lines
8 8
9#include "cgit.h"9#include "cgit.h"
10#include "cmd.h"10#include "cmd.h"
11#include "cache.h"
12#include "ui-shared.h"
11#include "ui-blob.h"13#include "ui-blob.h"
12#include "ui-commit.h"14#include "ui-commit.h"
13#include "ui-diff.h"15#include "ui-diff.h"
@@ -43,17 +45,25 @@ static void diff_fn(struct cgit_context *ctx) · 29 unmodified lines
43 cgit_print_diff(ctx->qry.sha1, ctx->qry.sha2, ctx->qry.path);45 cgit_print_diff(ctx->qry.sha1, ctx->qry.sha2, ctx->qry.path);
44}46}
45 47
46static void repolist_fn(struct cgit_context *ctx)
47{
48 cgit_print_repolist();
49}
50
51static void log_fn(struct cgit_context *ctx)48static void log_fn(struct cgit_context *ctx)
52{49{
53 cgit_print_log(ctx->qry.sha1, ctx->qry.ofs, ctx->cfg.max_commit_count,50 cgit_print_log(ctx->qry.sha1, ctx->qry.ofs, ctx->cfg.max_commit_count,
54 ctx->qry.grep, ctx->qry.search, ctx->qry.path, 1);51 ctx->qry.grep, ctx->qry.search, ctx->qry.path, 1);
55}52}
56 53
54static void ls_cache_fn(struct cgit_context *ctx)
55{
56 ctx->page.mimetype = "text/plain";
57 ctx->page.filename = "ls-cache.txt";
58 cgit_print_http_headers(ctx);
59 cache_ls(ctx->cfg.cache_root);
60}
61
62static void repolist_fn(struct cgit_context *ctx)
63{
64 cgit_print_repolist();
65}
66
57static void patch_fn(struct cgit_context *ctx)67static void patch_fn(struct cgit_context *ctx)
58{68{
59 cgit_print_patch(ctx->qry.sha1);69 cgit_print_patch(ctx->qry.sha1);
@@ -97,6 +107,7 @@ struct cgit_cmd *cgit_get_cmd(struct cgit_context *ctx) · 37 unmodified lines
97 def_cmd(commit, 1, 1),107 def_cmd(commit, 1, 1),
98 def_cmd(diff, 1, 1),108 def_cmd(diff, 1, 1),
99 def_cmd(log, 1, 1),109 def_cmd(log, 1, 1),
110 def_cmd(ls_cache, 0, 0),
100 def_cmd(patch, 1, 0),111 def_cmd(patch, 1, 0),
101 def_cmd(refs, 1, 1),112 def_cmd(refs, 1, 1),
102 def_cmd(repolist, 0, 0),113 def_cmd(repolist, 0, 0),
tests/setup.sh+1−1
@@ -44,7 +44,7 @@ setup_repos() · 43 unmodified lines
44virtual-root=/44virtual-root=/
45cache-root=$PWD/trash/cache45cache-root=$PWD/trash/cache
46 46
47nocache=047cache-size=1021
48snapshots=tar.gz tar.bz zip48snapshots=tar.gz tar.bz zip
49enable-log-filecount=149enable-log-filecount=1
50enable-log-linecount=150enable-log-linecount=1
tests/t0020-validate-cache.sh+67−0
@@ -0,0 +1,67 @@
1#!/bin/sh
2
3. ./setup.sh
4
5prepare_tests 'Validate cache'
6
7run_test 'verify cache-size=0' '
8
9 rm -f trash/cache/* &&
10 sed -i -e "s/cache-size=1021$/cache-size=0/" trash/cgitrc &&
11 cgit_url "" &&
12 cgit_url "foo" &&
13 cgit_url "foo/refs" &&
14 cgit_url "foo/tree" &&
15 cgit_url "foo/log" &&
16 cgit_url "foo/diff" &&
17 cgit_url "foo/patch" &&
18 cgit_url "bar" &&
19 cgit_url "bar/refs" &&
20 cgit_url "bar/tree" &&
21 cgit_url "bar/log" &&
22 cgit_url "bar/diff" &&
23 cgit_url "bar/patch" &&
24 test 0 -eq $(ls trash/cache | wc -l)
25'
26
27run_test 'verify cache-size=1' '
28
29 rm -f trash/cache/* &&
30 sed -i -e "s/cache-size=0$/cache-size=1/" trash/cgitrc &&
31 cgit_url "" &&
32 cgit_url "foo" &&
33 cgit_url "foo/refs" &&
34 cgit_url "foo/tree" &&
35 cgit_url "foo/log" &&
36 cgit_url "foo/diff" &&
37 cgit_url "foo/patch" &&
38 cgit_url "bar" &&
39 cgit_url "bar/refs" &&
40 cgit_url "bar/tree" &&
41 cgit_url "bar/log" &&
42 cgit_url "bar/diff" &&
43 cgit_url "bar/patch" &&
44 test 1 -eq $(ls trash/cache | wc -l)
45'
46
47run_test 'verify cache-size=1021' '
48
49 rm -f trash/cache/* &&
50 sed -i -e "s/cache-size=1$/cache-size=1021/" trash/cgitrc &&
51 cgit_url "" &&
52 cgit_url "foo" &&
53 cgit_url "foo/refs" &&
54 cgit_url "foo/tree" &&
55 cgit_url "foo/log" &&
56 cgit_url "foo/diff" &&
57 cgit_url "foo/patch" &&
58 cgit_url "bar" &&
59 cgit_url "bar/refs" &&
60 cgit_url "bar/tree" &&
61 cgit_url "bar/log" &&
62 cgit_url "bar/diff" &&
63 cgit_url "bar/patch" &&
64 test 13 -eq $(ls trash/cache | wc -l)
65'
66
67tests_done

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t