2 files changed, 74 insertions, 0 deletions

diff --git a/cgit.c b/cgit.c
index db96905..594b950 100644
--- a/cgit.c
+++ b/cgit.c
@@ -37,12 +37,14 @@ struct cgit_filter *new_filter(const char *cmd, int extra_args)
         f->argv = xmalloc((2 + extra_args) * sizeof(char *));
         f->argv[0] = f->cmd;
         f->argv[1] = NULL;
         return f;
 }
 
+static void process_cached_repolist(const char *path);
+
 void config_cb(const char *name, const char *value)
 {
         if (!strcmp(name, "root-title"))
                 ctx.cfg.root_title = xstrdup(value);
         else if (!strcmp(name, "root-desc"))
                 ctx.cfg.root_desc = xstrdup(value);
@@ -93,12 +95,14 @@ void config_cb(const char *name, const char *value)
         else if (!strcmp(name, "cache-root"))
                 ctx.cfg.cache_root = xstrdup(value);
         else if (!strcmp(name, "cache-root-ttl"))
                 ctx.cfg.cache_root_ttl = atoi(value);
         else if (!strcmp(name, "cache-repo-ttl"))
                 ctx.cfg.cache_repo_ttl = atoi(value);
+        else if (!strcmp(name, "cache-scanrc-ttl"))
+                ctx.cfg.cache_scanrc_ttl = atoi(value);
         else if (!strcmp(name, "cache-static-ttl"))
                 ctx.cfg.cache_static_ttl = atoi(value);
         else if (!strcmp(name, "cache-dynamic-ttl"))
                 ctx.cfg.cache_dynamic_ttl = atoi(value);
         else if (!strcmp(name, "about-filter"))
                 ctx.cfg.about_filter = new_filter(value, 0);
@@ -134,12 +138,15 @@ void config_cb(const char *name, const char *value)
                 ctx.cfg.local_time = atoi(value);
         else if (!prefixcmp(name, "mimetype."))
                 add_mimetype(name + 9, value);
         else if (!strcmp(name, "repo.group"))
                 ctx.cfg.repo_group = xstrdup(value);
         else if (!strcmp(name, "repo.scan"))
+                if (!ctx.cfg.nocache && ctx.cfg.cache_size)
+                        process_cached_repolist(value);
+                else
                 scan_tree(value);
         else if (!strcmp(name, "repo.url"))
                 ctx.repo = cgit_add_repo(value);
         else if (!strcmp(name, "repo.name"))
                 ctx.repo->name = xstrdup(value);
         else if (ctx.repo && !strcmp(name, "repo.path"))
@@ -233,12 +240,13 @@ static void prepare_context(struct cgit_context *ctx)
         ctx->cfg.cache_size = 0;
         ctx->cfg.cache_dynamic_ttl = 5;
         ctx->cfg.cache_max_create_time = 5;
         ctx->cfg.cache_repo_ttl = 5;
         ctx->cfg.cache_root = CGIT_CACHE_ROOT;
         ctx->cfg.cache_root_ttl = 5;
+        ctx->cfg.cache_scanrc_ttl = 15;
         ctx->cfg.cache_static_ttl = -1;
         ctx->cfg.css = "/cgit.css";
         ctx->cfg.logo = "/cgit.png";
         ctx->cfg.local_time = 0;
         ctx->cfg.max_repo_count = 50;
         ctx->cfg.max_commit_count = 50;
@@ -435,12 +443,77 @@ void print_repolist(FILE *f, struct cgit_repolist *list, int start)
         int i;
 
         for(i = start; i < list->count; i++)
                 print_repo(f, &list->repos[i]);
 }
 
+/* Scan 'path' for git repositories, save the resulting repolist in 'cached_rc'
+ * and return 0 on success.
+ */
+static int generate_cached_repolist(const char *path, const char *cached_rc)
+{
+        char *locked_rc;
+        int idx;
+        FILE *f;
+
+        locked_rc = xstrdup(fmt("%s.lock", cached_rc));
+        f = fopen(locked_rc, "wx");
+        if (!f) {
+                /* Inform about the error unless the lockfile already existed,
+                 * since that only means we've got concurrent requests.
+                 */
+                if (errno != EEXIST)
+                        fprintf(stderr, "[cgit] Error opening %s: %s (%d)\n",
+                                locked_rc, strerror(errno), errno);
+                return errno;
+        }
+        idx = cgit_repolist.count;
+        scan_tree(path);
+        print_repolist(f, &cgit_repolist, idx);
+        if (rename(locked_rc, cached_rc))
+                fprintf(stderr, "[cgit] Error renaming %s to %s: %s (%d)\n",
+                        locked_rc, cached_rc, strerror(errno), errno);
+        fclose(f);
+        return 0;
+}
+
+static void process_cached_repolist(const char *path)
+{
+        struct stat st;
+        char *cached_rc;
+        time_t age;
+
+        cached_rc = xstrdup(fmt("%s/rc-%8x", ctx.cfg.cache_root,
+                hash_str(path)));
+
+        if (stat(cached_rc, &st)) {
+                /* Nothing is cached, we need to scan without forking. And
+                 * if we fail to generate a cached repolist, we need to
+                 * invoke scan_tree manually.
+                 */
+                if (generate_cached_repolist(path, cached_rc))
+                        scan_tree(path);
+                return;
+        }
+
+        parse_configfile(cached_rc, config_cb);
+
+        /* If the cached configfile hasn't expired, lets exit now */
+        age = time(NULL) - st.st_mtime;
+        if (age <= (ctx.cfg.cache_scanrc_ttl * 60))
+                return;
+
+        /* The cached repolist has been parsed, but it was old. So lets
+         * rescan the specified path and generate a new cached repolist
+         * in a child-process to avoid latency for the current request.
+         */
+        if (fork())
+                return;
+
+        exit(generate_cached_repolist(path, cached_rc));
+}
 
 static void cgit_parse_args(int argc, const char **argv)
 {
         int i;
         int scan = 0;
 
diff --git a/cgit.h b/cgit.h
index adb8da4..5659580 100644
--- a/cgit.h
+++ b/cgit.h
@@ -165,12 +165,13 @@ struct cgit_config {
         char *virtual_root;
         int cache_size;
         int cache_dynamic_ttl;
         int cache_max_create_time;
         int cache_repo_ttl;
         int cache_root_ttl;
+        int cache_scanrc_ttl;
         int cache_static_ttl;
         int embedded;
         int enable_index_links;
         int enable_log_filecount;
         int enable_log_linecount;
         int local_time;