|
19
|
1 /* |
|
|
2 * db.c -- scid database access |
|
|
3 * |
|
|
4 * Copyright (c) 2021 David Demelier <markand@malikania.fr> |
|
|
5 * |
|
|
6 * Permission to use, copy, modify, and/or distribute this software for any |
|
|
7 * purpose with or without fee is hereby granted, provided that the above |
|
|
8 * copyright notice and this permission notice appear in all copies. |
|
|
9 * |
|
|
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
|
|
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
|
|
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR |
|
|
13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
|
|
14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN |
|
|
15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF |
|
|
16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
|
|
17 */ |
|
|
18 |
|
|
19 #include <assert.h> |
|
|
20 #include <stdlib.h> |
|
|
21 #include <string.h> |
|
|
22 |
|
|
23 #include <sqlite3.h> |
|
|
24 |
|
|
25 #include <utlist.h> |
|
|
26 |
|
|
27 #include "db.h" |
|
|
28 #include "log.h" |
|
|
29 #include "types.h" |
|
|
30 #include "util.h" |
|
|
31 |
|
|
32 #include "sql/init.h" |
|
|
33 #include "sql/job-add.h" |
|
|
34 #include "sql/job-todo.h" |
|
|
35 #include "sql/jobresult-add.h" |
|
|
36 #include "sql/project-add.h" |
|
|
37 #include "sql/project-update.h" |
|
|
38 #include "sql/project-find.h" |
|
|
39 #include "sql/project-find-id.h" |
|
|
40 #include "sql/project-list.h" |
|
|
41 #include "sql/worker-add.h" |
|
|
42 #include "sql/worker-find.h" |
|
|
43 #include "sql/worker-find-id.h" |
|
|
44 #include "sql/worker-list.h" |
|
|
45 |
|
|
46 #define CHAR(v) (const char *)(v) |
|
|
47 |
|
|
48 static sqlite3 *db; |
|
|
49 |
|
|
50 struct list { |
|
20
|
51 void (*unpack)(sqlite3_stmt *, void *); |
|
19
|
52 void *data; |
|
|
53 size_t datasz; |
|
|
54 size_t elemwidth; |
|
|
55 }; |
|
|
56 |
|
20
|
57 static void |
|
|
58 project_unpacker(sqlite3_stmt *stmt, void *data) |
|
19
|
59 { |
|
20
|
60 struct project *project = data; |
|
19
|
61 |
|
20
|
62 project->id = sqlite3_column_int(stmt, 0); |
|
|
63 project->name = util_strdup(CHAR(sqlite3_column_text(stmt, 1))); |
|
|
64 project->desc = util_strdup(CHAR(sqlite3_column_text(stmt, 2))); |
|
|
65 project->url = util_strdup(CHAR(sqlite3_column_text(stmt, 3))); |
|
|
66 project->script = util_strdup(CHAR(sqlite3_column_text(stmt, 4))); |
|
19
|
67 } |
|
|
68 |
|
|
69 static void |
|
20
|
70 worker_unpacker(sqlite3_stmt *stmt, void *data) |
|
19
|
71 { |
|
20
|
72 struct worker *w = data; |
|
19
|
73 |
|
20
|
74 w->id = sqlite3_column_int(stmt, 0); |
|
|
75 w->name = util_strdup(CHAR(sqlite3_column_text(stmt, 1))); |
|
|
76 w->desc = util_strdup(CHAR(sqlite3_column_text(stmt, 2))); |
|
19
|
77 } |
|
|
78 |
|
|
79 static void |
|
20
|
80 job_unpacker(sqlite3_stmt *stmt, void *data) |
|
19
|
81 { |
|
20
|
82 struct job *job = data; |
|
19
|
83 |
|
|
84 job->id = sqlite3_column_int(stmt, 0); |
|
20
|
85 job->tag = util_strdup(CHAR(sqlite3_column_text(stmt, 1))); |
|
19
|
86 job->project_id = sqlite3_column_int(stmt, 2); |
|
|
87 } |
|
|
88 |
|
|
89 static void |
|
|
90 vbind(sqlite3_stmt *stmt, const char *fmt, va_list ap) |
|
|
91 { |
|
|
92 for (int index = 1; *fmt; ++fmt) { |
|
|
93 switch (*fmt) { |
|
|
94 case 'i': |
|
|
95 sqlite3_bind_int(stmt, index++, va_arg(ap, int)); |
|
|
96 break; |
|
20
|
97 case 'j': |
|
|
98 sqlite3_bind_int64(stmt, index++, va_arg(ap, intmax_t)); |
|
|
99 break; |
|
19
|
100 case 's': |
|
|
101 sqlite3_bind_text(stmt, index++, va_arg(ap, const char *), -1, SQLITE_STATIC); |
|
|
102 break; |
|
|
103 case 'z': |
|
|
104 sqlite3_bind_int64(stmt, index++, va_arg(ap, size_t)); |
|
|
105 break; |
|
|
106 default: |
|
|
107 break; |
|
|
108 } |
|
|
109 } |
|
|
110 } |
|
|
111 |
|
|
112 static int |
|
|
113 insert(const char *sql, const char *fmt, ...) |
|
|
114 { |
|
|
115 assert(sql); |
|
|
116 assert(fmt); |
|
|
117 |
|
|
118 sqlite3_stmt *stmt = NULL; |
|
|
119 va_list ap; |
|
|
120 int ret = -1; |
|
|
121 |
|
|
122 if (sqlite3_prepare(db, sql, -1, &stmt, NULL) != SQLITE_OK) |
|
|
123 return log_warn("db: %s", sqlite3_errmsg(db)), -1; |
|
|
124 |
|
|
125 va_start(ap, fmt); |
|
|
126 vbind(stmt, fmt, ap); |
|
|
127 va_end(ap); |
|
|
128 |
|
|
129 if (sqlite3_step(stmt) != SQLITE_DONE) |
|
|
130 log_warn("db: %s", sqlite3_errmsg(db)); |
|
|
131 else |
|
|
132 ret = sqlite3_last_insert_rowid(db); |
|
|
133 |
|
|
134 sqlite3_finalize(stmt); |
|
|
135 |
|
|
136 return ret; |
|
|
137 } |
|
|
138 |
|
|
139 static int |
|
|
140 update(const char *sql, const char *fmt, ...) |
|
|
141 { |
|
|
142 assert(sql); |
|
|
143 assert(fmt); |
|
|
144 |
|
|
145 sqlite3_stmt *stmt = NULL; |
|
|
146 va_list ap; |
|
|
147 int ret = 1; |
|
|
148 |
|
|
149 if (sqlite3_prepare(db, sql, -1, &stmt, NULL) != SQLITE_OK) |
|
|
150 return log_warn("db: %s", sqlite3_errmsg(db)), -1; |
|
|
151 |
|
|
152 va_start(ap, fmt); |
|
|
153 vbind(stmt, fmt, ap); |
|
|
154 va_end(ap); |
|
|
155 |
|
|
156 if (sqlite3_step(stmt) != SQLITE_DONE) |
|
|
157 log_warn("db: %s", sqlite3_errmsg(db)); |
|
|
158 else |
|
|
159 ret = 0; |
|
|
160 |
|
|
161 sqlite3_finalize(stmt); |
|
|
162 |
|
|
163 return ret; |
|
|
164 } |
|
|
165 |
|
|
166 static ssize_t |
|
|
167 list(struct list *sel, const char *sql, const char *args, ...) |
|
|
168 { |
|
|
169 sqlite3_stmt *stmt = NULL; |
|
|
170 |
|
|
171 va_list ap; |
|
|
172 int step; |
|
|
173 ssize_t ret = -1; |
|
|
174 size_t tot = 0; |
|
|
175 |
|
|
176 if (sqlite3_prepare(db, sql, -1, &stmt, NULL) != SQLITE_OK) |
|
|
177 return log_warn("db: %s", sqlite3_errmsg(db)), -1; |
|
|
178 |
|
|
179 va_start(ap, args); |
|
|
180 vbind(stmt, args, ap); |
|
|
181 va_end(ap); |
|
|
182 |
|
|
183 while (tot < sel->datasz && (step = sqlite3_step(stmt)) == SQLITE_ROW) |
|
20
|
184 sel->unpack(stmt, (unsigned char *)sel->data + (tot++ * sel->elemwidth)); |
|
19
|
185 |
|
|
186 if (step == SQLITE_OK || step == SQLITE_DONE || step == SQLITE_ROW) |
|
|
187 ret = tot; |
|
20
|
188 else |
|
19
|
189 memset(sel->data, 0, sel->datasz * sel->elemwidth); |
|
|
190 |
|
|
191 sqlite3_finalize(stmt); |
|
|
192 |
|
|
193 return ret; |
|
|
194 } |
|
|
195 |
|
|
196 int |
|
|
197 db_open(const char *path) |
|
|
198 { |
|
|
199 assert(path); |
|
|
200 |
|
|
201 if (sqlite3_open(path, &db) != SQLITE_OK) |
|
|
202 return log_warn("db: open error: %s", sqlite3_errmsg(db)), -1; |
|
|
203 |
|
|
204 /* Wait for 30 seconds to lock the database. */ |
|
|
205 sqlite3_busy_timeout(db, 30000); |
|
|
206 |
|
|
207 if (sqlite3_exec(db, CHAR(sql_init), NULL, NULL, NULL) != SQLITE_OK) |
|
|
208 return log_warn("db: initialization error: %s", sqlite3_errmsg(db)), -1; |
|
|
209 |
|
|
210 return 0; |
|
|
211 } |
|
|
212 |
|
|
213 int |
|
|
214 db_project_add(struct project *p) |
|
|
215 { |
|
|
216 return (p->id = insert(CHAR(sql_project_add), "ssss", p->name, p->desc, |
|
|
217 p->url, p->script)) < 0 ? -1 : 0; |
|
|
218 } |
|
|
219 |
|
|
220 int |
|
|
221 db_project_update(const struct project *p) |
|
|
222 { |
|
|
223 assert(p); |
|
|
224 |
|
|
225 return update(CHAR(sql_project_update), "ssssi", p->name, p->desc, |
|
|
226 p->url, p->script, p->id); |
|
|
227 } |
|
|
228 |
|
|
229 ssize_t |
|
20
|
230 db_project_list(struct project *projects, size_t projectsz) |
|
19
|
231 { |
|
|
232 struct list sel = { |
|
20
|
233 .unpack = project_unpacker, |
|
19
|
234 .data = projects, |
|
|
235 .datasz = projectsz, |
|
|
236 .elemwidth = sizeof (*projects), |
|
|
237 }; |
|
|
238 |
|
|
239 return list(&sel, CHAR(sql_project_list), "z", projectsz); |
|
|
240 } |
|
|
241 |
|
|
242 int |
|
20
|
243 db_project_find(struct project *project, const char *name) |
|
19
|
244 { |
|
|
245 struct list sel = { |
|
20
|
246 .unpack = project_unpacker, |
|
19
|
247 .data = project, |
|
|
248 .datasz = 1, |
|
|
249 .elemwidth = sizeof (*project), |
|
|
250 }; |
|
|
251 |
|
20
|
252 return list(&sel, CHAR(sql_project_find), "s", name) == 1 ? 0 : -1; |
|
19
|
253 } |
|
|
254 |
|
|
255 int |
|
20
|
256 db_project_find_id(struct project *project, intmax_t id) |
|
19
|
257 { |
|
|
258 struct list sel = { |
|
20
|
259 .unpack = project_unpacker, |
|
19
|
260 .data = project, |
|
|
261 .datasz = 1, |
|
|
262 .elemwidth = sizeof (*project), |
|
|
263 }; |
|
|
264 |
|
20
|
265 return list(&sel, CHAR(sql_project_find_id), "i", id) == 1 ? 0 : -1; |
|
19
|
266 } |
|
|
267 |
|
|
268 int |
|
|
269 db_worker_add(struct worker *wk) |
|
|
270 { |
|
|
271 assert(wk); |
|
|
272 |
|
|
273 return (wk->id = insert(CHAR(sql_worker_add), "ss", wk->name, wk->desc)) < 0 ? -1 : 0; |
|
|
274 } |
|
|
275 |
|
|
276 ssize_t |
|
20
|
277 db_worker_list(struct worker *wk, size_t wksz) |
|
19
|
278 { |
|
|
279 assert(wk); |
|
|
280 |
|
|
281 struct list sel = { |
|
20
|
282 .unpack = worker_unpacker, |
|
19
|
283 .data = wk, |
|
|
284 .datasz = wksz, |
|
|
285 .elemwidth = sizeof (*wk), |
|
|
286 }; |
|
|
287 |
|
|
288 return list(&sel, CHAR(sql_worker_list), "z", wksz); |
|
|
289 } |
|
|
290 |
|
|
291 int |
|
20
|
292 db_worker_find(struct worker *wk, const char *name) |
|
19
|
293 { |
|
|
294 struct list sel = { |
|
20
|
295 .unpack = worker_unpacker, |
|
19
|
296 .data = wk, |
|
|
297 .datasz = 1, |
|
|
298 .elemwidth = sizeof (*wk), |
|
|
299 }; |
|
|
300 |
|
20
|
301 return list(&sel, CHAR(sql_worker_find), "s", name) == 1 ? 0 : -1; |
|
19
|
302 } |
|
|
303 |
|
|
304 int |
|
20
|
305 db_worker_find_id(struct worker *wk, intmax_t id) |
|
19
|
306 { |
|
|
307 struct list sel = { |
|
20
|
308 .unpack = worker_unpacker, |
|
19
|
309 .data = wk, |
|
|
310 .datasz = 1, |
|
|
311 .elemwidth = sizeof (*wk), |
|
|
312 }; |
|
|
313 |
|
20
|
314 return list(&sel, CHAR(sql_worker_find_id), "i", id) == 1 ? 0 : -1; |
|
19
|
315 } |
|
|
316 |
|
|
317 int |
|
|
318 db_job_add(struct job *job) |
|
|
319 { |
|
|
320 assert(job); |
|
|
321 |
|
|
322 return (job->id = insert(CHAR(sql_job_add), |
|
|
323 "si", job->tag, job->project_id)) < 0 ? -1 : 0; |
|
|
324 } |
|
|
325 |
|
|
326 ssize_t |
|
20
|
327 db_job_todo(struct job *jobs, size_t jobsz, int worker_id) |
|
19
|
328 { |
|
|
329 assert(jobs); |
|
|
330 |
|
|
331 struct list sel = { |
|
20
|
332 .unpack = job_unpacker, |
|
19
|
333 .data = jobs, |
|
|
334 .datasz = jobsz, |
|
|
335 .elemwidth = sizeof (*jobs), |
|
|
336 }; |
|
|
337 |
|
|
338 return list(&sel, CHAR(sql_job_todo), "iiz", worker_id, worker_id, jobsz); |
|
|
339 } |
|
|
340 |
|
|
341 int |
|
|
342 db_jobresult_add(struct jobresult *r) |
|
|
343 { |
|
|
344 assert(r); |
|
|
345 |
|
|
346 return (r->id = insert(CHAR(sql_jobresult_add), "iiis", r->job_id, |
|
|
347 r->worker_id, r->exitcode, r->log)) < 0 ? -1 : 0; |
|
|
348 } |
|
|
349 |
|
|
350 void |
|
|
351 db_finish(void) |
|
|
352 { |
|
|
353 if (db) { |
|
|
354 sqlite3_close(db); |
|
|
355 db = NULL; |
|
|
356 } |
|
|
357 } |
