about summary refs log tree commit diff stats
diff options
context:
space:
mode:
authorLars Hjemli2008-05-03 10:10:07 +0200
committerLars Hjemli2008-05-03 10:10:07 +0200
commite19683bedebc74593cb4c4518e47a334a5478e1e (patch)
tree8b4f231327d27b9451a6d9ab4b2af47558c61352
parentPrint an error if filename is not found in html_include. (diff)
parentAdd page 'ls_cache' (diff)
downloadcgit-e19683bedebc74593cb4c4518e47a334a5478e1e.tar.gz
cgit-e19683bedebc74593cb4c4518e47a334a5478e1e.zip
Merge branch 'lh/cache'
* lh/cache:
  Add page 'ls_cache'
  Redesign the caching layer
-rw-r--r--cache.c427
-rw-r--r--cache.h38
-rw-r--r--cgit.c166
-rw-r--r--cgit.h1
-rw-r--r--cmd.c21
-rwxr-xr-xtests/setup.sh2
-rwxr-xr-xtests/t0020-validate-cache.sh67
7 files changed, 506 insertions, 216 deletions
diff --git a/cache.c b/cache.c index 89f7ecd..b701e13 100644 --- a/cache.c +++ b/cache.c
@@ -4,117 +4,408 @@
4 * 4 *
5 * Licensed under GNU General Public License v2 5 * 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 else 151 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
diff --git a/cache.h b/cache.h index 4dcbea3..66cc41f 100644 --- a/cache.h +++ b/cache.h
@@ -6,18 +6,30 @@
6#ifndef CGIT_CACHE_H 6#ifndef CGIT_CACHE_H
7#define CGIT_CACHE_H 7#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 */
diff --git a/cgit.c b/cgit.c index a402758..ccd61f4 100644 --- a/cgit.c +++ b/cgit.c
@@ -49,6 +49,8 @@ void config_cb(const char *name, const char *value)
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)
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)
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)
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)
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)
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)
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}
diff --git a/cgit.h b/cgit.h index daebeff..bbb404e 100644 --- a/cgit.h +++ b/cgit.h
@@ -136,6 +136,7 @@ struct cgit_config {
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;
diff --git a/cmd.c b/cmd.c index 6cc91e6..4edca6b 100644 --- a/cmd.c +++ b/cmd.c
@@ -8,6 +8,8 @@
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)
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)
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),
diff --git a/tests/setup.sh b/tests/setup.sh index 66bf406..e37306e 100755 --- a/tests/setup.sh +++ b/tests/setup.sh
@@ -44,7 +44,7 @@ setup_repos()
44virtual-root=/ 44virtual-root=/
45cache-root=$PWD/trash/cache 45cache-root=$PWD/trash/cache
46 46
47nocache=0 47cache-size=1021
48snapshots=tar.gz tar.bz zip 48snapshots=tar.gz tar.bz zip
49enable-log-filecount=1 49enable-log-filecount=1
50enable-log-linecount=1 50enable-log-linecount=1
diff --git a/tests/t0020-validate-cache.sh b/tests/t0020-validate-cache.sh new file mode 100755 index 0000000..53ec2eb --- /dev/null +++ b/tests/t0020-validate-cache.sh
@@ -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