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