tools/blerglatest.c

   1 /* Blerg is (C) 2011 The Dominion of Awesome, and is distributed under a
   2  * BSD-style license.  Please see the COPYING file for details.
   3  */
   4 #include <stdio.h>
   5 #include <string.h>
   6 #include <stdlib.h>
   7 #include <sys/types.h>
   8 #include <sys/stat.h>
   9 #include <unistd.h>
  10 #include <dirent.h>
  11 #include <yajl/yajl_gen.h>
  12 #include "database.h"
  13 #include "json.h"
  14 #include "config.h"
  15
  16 yajl_gen_config yajl_config = {0, 0};
  17
  18 struct thing {
  19         time_t t;
  20         char *name;
  21         int len;
  22 };
  23
  24 struct things {
  25         struct thing *arr;
  26         unsigned int len;
  27         unsigned int size;
  28 };
  29
  30 struct things * things_alloc() {
  31         struct things *things = malloc(sizeof(struct things));
  32         things->len = 0;
  33         things->size = 65536;
  34         things->arr = malloc(sizeof(struct thing) * things->size);
  35 }
  36
  37 void things_free(struct things *things) {
  38         int i;
  39
  40         for (i = 0; i < things->len; i++) {
  41                 free(things->arr[i].name);
  42         }
  43
  44         free(things->arr);
  45         free(things);
  46 }
  47
  48 void things_add(struct things *things, time_t t, char *name) {
  49         things->arr[things->len].t = t;
  50         things->arr[things->len].len = strlen(name);
  51         things->arr[things->len].name = malloc(things->arr[things->len].len + 1);
  52         strcpy(things->arr[things->len].name, name);
  53         things->len++;
  54         if (things->len == things->size) {
  55                 things->size *= 2;
  56                 things->arr = realloc(things->arr, sizeof(struct thing) * things->size);
  57         }
  58 }
  59
  60 int thing_compare(const void *a, const void *b) {
  61         struct thing * aa = (struct thing *) a;
  62         struct thing * bb = (struct thing *) b;
  63
  64         if (aa->t == bb->t)
  65                 return 0;
  66         else if (aa->t > bb->t)
  67                 return -1;
  68         else
  69                 return 1;
  70 }
  71
  72 void things_sort(struct things *things) {
  73         qsort(things->arr, things->len, sizeof(struct thing), thing_compare);
  74 }
  75
  76 struct things * latest_things(const char *path, const char *file, int minlen) {
  77         DIR* d;
  78         struct dirent *f;
  79         struct things * things = things_alloc();
  80         char filename[512];
  81         struct stat st;
  82         int i;
  83
  84         d = opendir(path);
  85         while (f = readdir(d)) {
  86                 if (f->d_name[0] == '.') continue;
  87                 if (minlen > 0 && strlen(f->d_name) < minlen) continue;
  88                 if (file) {
  89                         snprintf(filename, 512, "%s/%s/%s", path, f->d_name, file);
  90                 } else {
  91                         snprintf(filename, 512, "%s/%s", path, f->d_name);
  92                 }
  93                 stat(filename, &st);
  94                 things_add(things, st.st_mtime, f->d_name);
  95         }
  96         closedir(d);
  97
  98         things_sort(things);
  99
 100         return things;
 101 }
 102
 103 void latest_tags(yajl_gen g) {
 104         int i;
 105         struct things * things = latest_things(HASH_TAGS_PATH, NULL, 3);
 106
 107         unsigned int count = (things->len >= 50 ? 50 : things->len);
 108         yajl_gen_array_open(g);
 109         for (i = 0; i < count; i++) {
 110                 yajl_gen_string(g, things->arr[i].name, things->arr[i].len);
 111         }
 112         yajl_gen_array_close(g);
 113
 114         things_free(things);
 115 }
 116
 117 void latest_records(yajl_gen g) {
 118         int i;
 119         struct things * things = latest_things(DATA_PATH, "meta", 0);
 120
 121         unsigned int count = (things->len >= 50 ? 50 : things->len);
 122         yajl_gen_array_open(g);
 123         for (i = 0; i < count; i++) {
 124                 struct blerg * b = blerg_open(things->arr[i].name);
 125                 if (b == NULL) {
 126                         fprintf(stderr, "Could not open blerg for %s\n", things->arr[i].name);
 127                         continue;
 128                 }
 129                 uint64_t record_count = blerg_get_record_count(b);
 130                 if (record_count > 0)
 131                         json_generate_one_record(g, things->arr[i].name, b, record_count - 1, 1);
 132                 blerg_close(b);
 133         }
 134         yajl_gen_array_close(g);
 135         things_free(things);
 136 }
 137
 138 int main(int argc, char *argv[]) {
 139         const unsigned char *buf;
 140         unsigned int len;
 141
 142         yajl_gen g = yajl_gen_alloc(&yajl_config, NULL);
 143
 144         yajl_gen_map_open(g);
 145         yajl_gen_string(g, "tags", 4);
 146
 147         latest_tags(g);
 148
 149         yajl_gen_get_buf(g, &buf, &len);
 150         fwrite(buf, len, 1, stdout);
 151         yajl_gen_clear(g);
 152
 153         yajl_gen_string(g, "records", 7);
 154
 155         latest_records(g);
 156
 157         yajl_gen_map_close(g);
 158         yajl_gen_get_buf(g, &buf, &len);
 159         fwrite(buf, len, 1, stdout);
 160
 161         yajl_gen_free(g);
 162 }