gout

cache.c (5547B)

---

 #include "cache.h"
 
 #include <assert.h>
 #include <err.h>
 #include <libgen.h>
 #include <stdbool.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <unistd.h>
 
 #include "git/git.h"
 #include "utils.h"
 
 static const char* kTempCacheTemplate = "cache.XXXXXXXXXXXX";
 static const mode_t kReadWriteAll =
     S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
 
 struct Cache {
   const FileSystem* fs;
   char* cache_path;
   char* temp_cache_path;
   bool owns_streams;
 
   bool can_add_commits;
   WriteCommitRow write_commit_row;
   FILE* cache_in;
   FILE* cache_out;
   char* lastoid_in;
   bool wrote_lastoid_out;
 };
 
 Cache* cache_create(FILE* cache_in,
                     FILE* cache_out,
                     WriteCommitRow write_func) {
   assert(cache_out != NULL);
   assert(write_func != NULL);
   Cache* cache = ecalloc(1, sizeof(Cache));
   cache->can_add_commits = true;
   cache->write_commit_row = write_func;
   cache->cache_in = cache_in;
   cache->cache_out = cache_out;
 
   // Read lastoid from previous cache, if it exists.
   cache->lastoid_in = ecalloc(GOUT_OID_MAX_SIZE, sizeof(char));
   if (cache->cache_in) {
     // Read into a local buffer that has extra space for \r\n.
     char line_buf[GOUT_OID_MAX_SIZE + 2];
     char* oid_str = fgets(line_buf, sizeof(line_buf), cache->cache_in);
     if (oid_str) {
       // Strip trailing newline/carriage return before copying.
       line_buf[strcspn(line_buf, "\r\n")] = '\0';
       estrlcpy(cache->lastoid_in, line_buf, GOUT_OID_MAX_SIZE);
     } else {
       warnx("corrupt cachefile");
     }
   }
   cache->wrote_lastoid_out = false;
 
   return cache;
 }
 
 Cache* cache_open(const FileSystem* fs,
                   const char* path,
                   WriteCommitRow write_func) {
   assert(fs != NULL);
   assert(path != NULL);
   assert(write_func != NULL);
 
   char* path_copy = estrdup(path);
   const char* dir = dirname(path_copy);
   char* temp_cache_path = path_concat(dir, kTempCacheTemplate);
   free(path_copy);
 
   FILE* cache_in = fs->fopen(path, "r");
   int out_fd = fs->mkstemp(temp_cache_path);
   if (out_fd == -1) {
     free(temp_cache_path);
     if (cache_in) {
       fs->fclose(cache_in);
     }
     err(1, "mkstemp: %s", temp_cache_path);
   }
   FILE* cache_out = fs->fdopen(out_fd, "w");
   if (!cache_out) {
     fs->close(out_fd);
     free(temp_cache_path);
     if (cache_in) {
       fs->fclose(cache_in);
     }
     err(1, "fdopen: %s", temp_cache_path);
   }
 
   Cache* cache = cache_create(cache_in, cache_out, write_func);
   cache->fs = fs;
   cache->cache_path = estrdup(path);
   cache->temp_cache_path = temp_cache_path;
   cache->owns_streams = true;
   return cache;
 }
 
 void cache_free(Cache* cache) {
   if (!cache) {
     return;
   }
   if (cache->owns_streams) {
     if (cache->cache_in) {
       cache->fs->fclose(cache->cache_in);
     }
     if (cache->cache_out) {
       cache->fs->fclose(cache->cache_out);
     }
   }
   free(cache->cache_path);
   free(cache->temp_cache_path);
   free(cache->lastoid_in);
   free(cache);
 }
 
 bool cache_can_add_commits(const Cache* cache) {
   assert(cache != NULL);
   return cache->can_add_commits;
 }
 
 void cache_add_commit_row(Cache* cache, const GitCommit* commit) {
   assert(cache != NULL);
   assert(commit != NULL);
   // The first row of the file is the last OID.
   if (!cache->wrote_lastoid_out) {
     fprintf(cache->cache_out, "%s\n", commit->oid);
     cache->wrote_lastoid_out = true;
   }
   // If all commits are already written; do nothing.
   if (!cache->can_add_commits ||
       strncmp(commit->oid, cache->lastoid_in, GOUT_OID_MAX_SIZE - 1) == 0) {
     cache->can_add_commits = false;
     return;
   }
   // The rest of the file is the log contents up to and including that commit.
   cache->write_commit_row(cache->cache_out, commit);
 }
 
 void cache_finish(Cache* cache) {
   assert(cache != NULL);
   if (cache->cache_in) {
     // If we didn't write any records, copy the previous cache lastoid.
     if (!cache->wrote_lastoid_out) {
       fprintf(cache->cache_out, "%s\n", cache->lastoid_in);
       cache->wrote_lastoid_out = true;
     }
     // append previous cached log to new cached log.
     char buf[BUFSIZ];
     size_t n;
     while ((n = fread(buf, 1, sizeof(buf), cache->cache_in)) > 0) {
       if (fwrite(buf, 1, n, cache->cache_out) != n) {
         break;
       }
     }
   }
 }
 
 void cache_close_and_replace(Cache* cache, FILE* out) {
   assert(cache != NULL);
   assert(cache->owns_streams);
   assert(out != NULL);
 
   cache_finish(cache);
 
   if (cache->cache_in) {
     cache->fs->fclose(cache->cache_in);
     cache->cache_in = NULL;
   }
   cache->fs->fclose(cache->cache_out);
   cache->cache_out = NULL;
 
   if (cache->fs->rename(cache->temp_cache_path, cache->cache_path)) {
     err(1, "rename: %s -> %s", cache->temp_cache_path, cache->cache_path);
   }
 
   mode_t mask = umask(0);
   umask(mask);
   if (cache->fs->chmod(cache->cache_path, kReadWriteAll & ~mask)) {
     err(1, "chmod: %s", cache->cache_path);
   }
 
   FILE* fcache = cache->fs->fopen(cache->cache_path, "r");
   if (!fcache) {
     err(1, "fopen: %s", cache->cache_path);
   }
   cache_copy_log(fcache, out);
   cache->fs->fclose(fcache);
 }
 
 void cache_copy_log(FILE* fcache, FILE* out) {
   assert(fcache != NULL);
   assert(out != NULL);
   // Copy the log lines to out.
   char* line = NULL;
   size_t len = 0;
   bool is_sha = true;
   while (getline(&line, &len, fcache) != -1) {
     // Skip the first line containing the commit SHA.
     if (is_sha) {
       is_sha = false;
       continue;
     }
     fprintf(out, "%s", line);
   }
   free(line);
 }