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
44 *
55 * Licensed under GNU General Public License v2
66 * (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+ *
714 */
815
916 #include "cgit.h"
1017 #include "cache.h"
1118
12−const int NOLOCK = -1;
19+#define CACHE_BUFSIZE (1024 * 4)
1320
14−char *cache_safe_filename(const char *unsafe)
21+struct 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+ */
42+static int open_slot(struct cache_slot *slot)
1543 {
16− static char buf[4][PATH_MAX];
17− static int bufidx;
18− char *s;
19− char c;
20−
21− bufidx++;
22− bufidx &= 3;
23− s = buf[bufidx];
24−
25− while(unsafe && (c = *unsafe++) != 0) {
26− if (c == '/' || c == ' ' || c == '&' || c == '|' ||
27− c == '>' || c == '<' || c == '.')
28− c = '_';
29− *s++ = c;
30− }
31− *s = '\0';
32− return buf[bufidx];
44+ char *bufz;
45+ int bufkeylen = -1;
46+
47+ slot->cache_fd = open(slot->cache_name, O_RDONLY);
48+ if (slot->cache_fd == -1)
49+ return errno;
50+
51+ if (fstat(slot->cache_fd, &slot->cache_st))
52+ return errno;
53+
54+ slot->bufsize = read(slot->cache_fd, slot->buf, sizeof(slot->buf));
55+ if (slot->bufsize == 0)
56+ return errno;
57+
58+ bufz = memchr(slot->buf, 0, slot->bufsize);
59+ if (bufz)
60+ bufkeylen = bufz - slot->buf;
61+
62+ slot->match = bufkeylen == slot->keylen &&
63+ !memcmp(slot->key, slot->buf, bufkeylen + 1);
64+
65+ return 0;
3366 }
3467
35−int cache_exist(struct cacheitem *item)
68+/* Close the active cache slot */
69+static void close_slot(struct cache_slot *slot)
3670 {
37− if (stat(item->name, &item->st)) {
38− item->st.st_mtime = 0;
39− return 0;
71+ if (slot->cache_fd > 0) {
72+ close(slot->cache_fd);
73+ slot->cache_fd = -1;
4074 }
41− return 1;
4275 }
4376
44−int cache_create_dirs()
77+/* Print the content of the active cache slot (but skip the key). */
78+static int print_slot(struct cache_slot *slot)
4579 {
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);
4788
48− path = fmt("%s", ctx.cfg.cache_root);
49− if (mkdir(path, S_IRWXU) && errno!=EEXIST)
89+ if (j < 0)
90+ return errno;
91+ else
5092 return 0;
93+}
5194
52− if (!ctx.repo)
95+/* Check if the slot has expired */
96+static int is_expired(struct cache_slot *slot)
97+{
98+ if (slot->ttl < 0)
5399 return 0;
100+ else
101+ return slot->cache_st.st_mtime + slot->ttl*60 < time(NULL);
102+}
54103
55− path = fmt("%s/%s", ctx.cfg.cache_root,
56− cache_safe_filename(ctx.repo->url));
104+/* Check if the slot has been modified since we opened it.
105+ * NB: If stat() fails, we pretend the file is modified.
106+ */
107+static int is_modified(struct cache_slot *slot)
108+{
109+ struct stat st;
57110
58− if (mkdir(path, S_IRWXU) && errno!=EEXIST)
59− return 0;
111+ if (stat(slot->cache_name, &st))
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+}
60117
61− if (ctx.qry.page) {
62− path = fmt("%s/%s/%s", ctx.cfg.cache_root,
63− cache_safe_filename(ctx.repo->url),
64− ctx.qry.page);
65− if (mkdir(path, S_IRWXU) && errno!=EEXIST)
66− return 0;
118+/* Close an open lockfile */
119+static void close_lock(struct cache_slot *slot)
120+{
121+ if (slot->lock_fd > 0) {
122+ close(slot->lock_fd);
123+ slot->lock_fd = -1;
67124 }
68− return 1;
69125 }
70126
71−int 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+ */
131+static int lock_slot(struct cache_slot *slot)
72132 {
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+}
74140
75− if (stat(lockfile, &st))
76− return 0;
141+/* Release the current lockfile. If `replace_old_slot` is set the
142+ * lockfile replaces the old cache slot, otherwise the lockfile is
143+ * just deleted.
144+ */
145+static 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);
77151 else
78− return (time(NULL) - st.st_mtime > ctx.cfg.cache_max_create_time);
152+ err = unlink(slot->lock_name);
153+ return err;
79154 }
80155
81−int 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+ */
159+static int fill_slot(struct cache_slot *slot)
82160 {
83− int i = 0;
84− char *lockfile = xstrdup(fmt("%s.lock", item->name));
161+ int tmp;
85162
86− top:
87− if (++i > ctx.cfg.max_lock_attempts)
88− die("cache_lock: unable to lock %s: %s",
89− item->name, strerror(errno));
163+ /* Preserve stdout */
164+ tmp = dup(STDOUT_FILENO);
165+ if (tmp == -1)
166+ return errno;
90167
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;
92171
93− if (item->fd == NOLOCK && errno == ENOENT && cache_create_dirs())
94− goto top;
172+ /* Generate cache content */
173+ slot->fn(slot->cbdata);
95174
96− if (item->fd == NOLOCK && errno == EEXIST &&
97− cache_refill_overdue(lockfile) && !unlink(lockfile))
98− goto top;
175+ /* Restore stdout */
176+ if (dup2(tmp, STDOUT_FILENO) == -1)
177+ return errno;
99178
100− free(lockfile);
101− return (item->fd > 0);
179+ /* Close the temporary filedescriptor */
180+ close(tmp);
181+ return 0;
102182 }
103183
104−int 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+
191+unsigned long hash_str(const char *str)
105192 {
106− close(item->fd);
107− return (rename(fmt("%s.lock", item->name), item->name) == 0);
193+ unsigned long h = FNV_OFFSET;
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;
108204 }
109205
110−int cache_cancel_lock(struct cacheitem *item)
206+static int process_slot(struct cache_slot *slot)
111207 {
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;
113280 }
114281
115−int cache_expired(struct cacheitem *item)
282+/* Print cached content to stdout, generate the content if necessary. */
283+int cache_process(int size, const char *path, const char *key, int ttl,
284+ cache_fill_fn fn, void *cbdata)
116285 {
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);
118302 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);
120333 }
334+
335+/* Return a strftime formatted date/time
336+ * NB: the result from this function is to shared memory
337+ */
338+char *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+
350+int 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 */
404+void 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
66 #ifndef CGIT_CACHE_H
77 #define CGIT_CACHE_H
88
9−struct cacheitem {
10− char *name;
11− struct stat st;
12− int ttl;
13− int fd;
14−};
15−
16−extern char *cache_safe_filename(const char *unsafe);
17−extern int cache_lock(struct cacheitem *item);
18−extern int cache_unlock(struct cacheitem *item);
19−extern int cache_cancel_lock(struct cacheitem *item);
20−extern int cache_exist(struct cacheitem *item);
21−extern int cache_expired(struct cacheitem *item);
9+typedef void (*cache_fill_fn)(void *cbdata);
10+
11+
12+/* Print cached content to stdout, generate the content if necessary.
13+ *
14+ * Parameters
15+ * size max number of cache files
16+ * path directory used to store cache files
17+ * key the key used to lookup cache files
18+ * ttl max cache time in seconds for this key
19+ * fn content generator function for this key
20+ * cbdata user-supplied data to the content generator function
21+ *
22+ * Return value
23+ * 0 indicates success, everyting else is an error
24+ */
25+extern 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 */
30+extern int cache_ls(const char *path);
31+
32+/* Print a message to stdout */
33+extern void cache_log(const char *format, ...);
2234
2335 #endif /* CGIT_CACHE_H */
cgit.c+37−129
@@ -49,6 +49,8 @@ void config_cb(const char *name, const char *value) · 48 unmodified lines
4949 ctx.cfg.enable_log_filecount = atoi(value);
5050 else if (!strcmp(name, "enable-log-linecount"))
5151 ctx.cfg.enable_log_linecount = atoi(value);
52+ else if (!strcmp(name, "cache-size"))
53+ ctx.cfg.cache_size = atoi(value);
5254 else if (!strcmp(name, "cache-root"))
5355 ctx.cfg.cache_root = xstrdup(value);
5456 else if (!strcmp(name, "cache-root-ttl"))
@@ -147,6 +149,8 @@ static void prepare_context(struct cgit_context *ctx) · 92 unmodified lines
147149 {
148150 memset(ctx, 0, sizeof(ctx));
149151 ctx->cfg.agefile = "info/web/last-modified";
152+ ctx->cfg.nocache = 0;
153+ ctx->cfg.cache_size = 0;
150154 ctx->cfg.cache_dynamic_ttl = 5;
151155 ctx->cfg.cache_max_create_time = 5;
152156 ctx->cfg.cache_repo_ttl = 5;
@@ -168,47 +172,8 @@ static void prepare_context(struct cgit_context *ctx) · 15 unmodified lines
168172 ctx->page.mimetype = "text/html";
169173 ctx->page.charset = PAGE_ENCODING;
170174 ctx->page.filename = NULL;
171−}
172−
173−static 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;
175+ ctx->page.modified = time(NULL);
176+ ctx->page.expires = ctx->page.modified;
212177 }
213178
214179 struct refmatch {
@@ -293,8 +258,9 @@ static int prepare_repo_cmd(struct cgit_context *ctx) · 78 unmodified lines
293258 return 0;
294259 }
295260
296−static void process_request(struct cgit_context *ctx)
261+static void process_request(void *cbdata)
297262 {
263+ struct cgit_context *ctx = cbdata;
298264 struct cgit_cmd *cmd;
299265
300266 cmd = cgit_get_cmd(ctx);
@@ -333,82 +299,6 @@ static void process_request(struct cgit_context *ctx) · 32 unmodified lines
333299 cgit_print_docend();
334300 }
335301
336−static long ttl_seconds(long ttl)
337−{
338− if (ttl<0)
339− return 60 * 60 * 24 * 365;
340− else
341− return ttl * 60;
342−}
343−
344−static 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−
367−static 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−
397−static 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−
412302 static void cgit_parse_args(int argc, const char **argv)
413303 {
414304 int i;
@@ -443,13 +333,29 @@ static void cgit_parse_args(int argc, const char **argv) · 28 unmodified lines
443333 }
444334 }
445335
336+static 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+
446353 int main(int argc, const char **argv)
447354 {
448− struct cacheitem item;
449355 const char *cgit_config_env = getenv("CGIT_CONFIG");
356+ int err, ttl;
450357
451358 prepare_context(&ctx);
452− item.st.st_mtime = time(NULL);
453359 cgit_repolist.length = 0;
454360 cgit_repolist.count = 0;
455361 cgit_repolist.repos = NULL;
@@ -463,13 +369,15 @@ int main(int argc, const char **argv) · 7 unmodified lines
463369 ctx.qry.raw = xstrdup(getenv("QUERY_STRING"));
464370 cgit_parse_args(argc, argv);
465371 http_parse_querystring(ctx.qry.raw, querystring_cb);
466− if (!cgit_prepare_cache(&item))
467− return 0;
468− if (ctx.cfg.nocache) {
469− cgit_fill_cache(&item, 0);
470− } else {
471− cgit_check_cache(&item);
472− cgit_print_cache(&item);
473− }
474− return 0;
372+
373+ ttl = calc_ttl();
374+ ctx.page.expires += ttl*60;
375+ if (ctx.cfg.nocache)
376+ ctx.cfg.cache_size = 0;
377+ err = cache_process(ctx.cfg.cache_size, ctx.cfg.cache_root,
378+ ctx.qry.raw, ttl, process_request, &ctx);
379+ if (err)
380+ cache_log("[cgit] error %d - %s\n",
381+ err, strerror(err));
382+ return err;
475383 }
cgit.h+1−0
@@ -136,6 +136,7 @@ struct cgit_config { · 135 unmodified lines
136136 char *root_readme;
137137 char *script_name;
138138 char *virtual_root;
139+ int cache_size;
139140 int cache_dynamic_ttl;
140141 int cache_max_create_time;
141142 int cache_repo_ttl;
cmd.c+16−5
@@ -8,6 +8,8 @@ · 7 unmodified lines
88
99 #include "cgit.h"
1010 #include "cmd.h"
11+#include "cache.h"
12+#include "ui-shared.h"
1113 #include "ui-blob.h"
1214 #include "ui-commit.h"
1315 #include "ui-diff.h"
@@ -43,17 +45,25 @@ static void diff_fn(struct cgit_context *ctx) · 29 unmodified lines
4345 cgit_print_diff(ctx->qry.sha1, ctx->qry.sha2, ctx->qry.path);
4446 }
4547
46−static void repolist_fn(struct cgit_context *ctx)
47−{
48− cgit_print_repolist();
49−}
50−
5148 static void log_fn(struct cgit_context *ctx)
5249 {
5350 cgit_print_log(ctx->qry.sha1, ctx->qry.ofs, ctx->cfg.max_commit_count,
5451 ctx->qry.grep, ctx->qry.search, ctx->qry.path, 1);
5552 }
5653
54+static 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+
62+static void repolist_fn(struct cgit_context *ctx)
63+{
64+ cgit_print_repolist();
65+}
66+
5767 static void patch_fn(struct cgit_context *ctx)
5868 {
5969 cgit_print_patch(ctx->qry.sha1);
@@ -97,6 +107,7 @@ struct cgit_cmd *cgit_get_cmd(struct cgit_context *ctx) · 37 unmodified lines
97107 def_cmd(commit, 1, 1),
98108 def_cmd(diff, 1, 1),
99109 def_cmd(log, 1, 1),
110+ def_cmd(ls_cache, 0, 0),
100111 def_cmd(patch, 1, 0),
101112 def_cmd(refs, 1, 1),
102113 def_cmd(repolist, 0, 0),
tests/setup.sh+1−1
@@ -44,7 +44,7 @@ setup_repos() · 43 unmodified lines
4444 virtual-root=/
4545 cache-root=$PWD/trash/cache
4646
47−nocache=0
47+cache-size=1021
4848 snapshots=tar.gz tar.bz zip
4949 enable-log-filecount=1
5050 enable-log-linecount=1
tests/t0020-validate-cache.sh+67−0
@@ -0,0 +1,67 @@
1+#!/bin/sh
2+
3+. ./setup.sh
4+
5+prepare_tests 'Validate cache'
6+
7+run_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+
27+run_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+
47+run_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+
67+tests_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