1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
|
// file : mod/mod-ci-github-gq.cxx -*- C++ -*-
// license : MIT; see accompanying LICENSE file
#include <mod/mod-ci-github-gq.hxx>
#include <libbutl/json/parser.hxx>
#include <libbutl/json/serializer.hxx>
#include <mod/mod-ci-github-post.hxx>
using namespace std;
using namespace butl;
namespace brep
{
// GraphQL serialization functions (see definitions and documentation at the
// bottom).
//
static const string& gq_name (const string&);
static string gq_str (const string&);
static string gq_bool (bool);
static const string& gq_enum (const string&);
[[noreturn]] static void
throw_json (json::parser& p, const string& m)
{
throw json::invalid_json_input (
p.input_name,
p.line (), p.column (), p.position (),
m);
}
// Parse a JSON-serialized GraphQL response.
//
// Throw runtime_error if the response indicated errors and
// invalid_json_input if the GitHub response contained invalid JSON.
//
// The parse_data function should not throw anything but invalid_json_input.
//
// The response format is defined in the GraphQL spec:
// https://spec.graphql.org/October2021/#sec-Response.
//
// Example response:
//
// {
// "data": {...},
// "errors": {...}
// }
//
// The contents of `data`, including its opening and closing braces, are
// parsed by the `parse_data` function.
//
// If the `errors` field is present in the response, error(s) occurred
// before or during execution of the operation.
//
// If the `data` field is not present the errors are request errors which
// occur before execution and are typically the client's fault.
//
// If the `data` field is also present in the response the errors are field
// errors which occur during execution and are typically the GraphQL
// endpoint's fault, and some fields in `data` that should not be are likely
// to be null.
//
// Although the spec recommends that the errors field (if present) should
// come before the data field, GitHub places data before errors. Therefore
// we need to check that the errors field is not present before parsing the
// data field as it might contain nulls if errors is present.
//
static void
gq_parse_response (json::parser& p,
function<void (json::parser&)> parse_data)
{
using event = json::event;
// True if the data/errors fields are present.
//
bool dat (false), err (false);
// Because the errors field is likely to come before the data field,
// serialize data to a stringstream and only parse it later once we're
// sure there are no errors.
//
stringstream data; // The value of the data field.
p.next_expect (event::begin_object);
while (p.next_expect (event::name, event::end_object))
{
if (p.name () == "data")
{
dat = true;
// Serialize the data field to a string.
//
// Note that the JSON payload sent by GitHub is not pretty-printed so
// there is no need to worry about that.
//
json::stream_serializer s (data, 0 /* indentation */);
try
{
for (event e: p)
{
if (!s.next (e, p.data ()))
break; // Stop if data object is complete.
}
}
catch (const json::invalid_json_output& e)
{
throw_json (p,
string ("serializer rejected response 'data' field: ") +
e.what ());
}
}
else if (p.name () == "errors")
{
// Don't stop parsing because the error semantics depends on whether
// or not `data` is present.
//
err = true; // Handled below.
}
else
{
// The spec says the response will never contain any top-level fields
// other than data, errors, and extensions.
//
if (p.name () != "extensions")
{
throw_json (p,
"unexpected top-level GraphQL response field: '" +
p.name () + '\'');
}
p.next_expect_value_skip ();
}
}
if (!err)
{
if (!dat)
throw runtime_error ("no data received from GraphQL endpoint");
// Parse the data field now that we know there are no errors.
//
json::parser dp (data, p.input_name);
parse_data (dp);
}
else
{
if (dat)
{
throw runtime_error ("field error(s) received from GraphQL endpoint; "
"incomplete data received");
}
else
throw runtime_error ("request error(s) received from GraphQL endpoint");
}
}
// Parse a response to a check_run GraphQL mutation such as `createCheckRun`
// or `updateCheckRun`.
//
// Example response (only the part we need to parse here):
//
// {
// "cr0": {
// "checkRun": {
// "id": "CR_kwDOLc8CoM8AAAAFQ5GqPg",
// "name": "libb2/0.98.1+2/x86_64-linux-gnu/linux_debian_12-gcc_13.1-O3/default/dev/0.17.0-a.1",
// "status": "QUEUED"
// }
// },
// "cr1": {
// "checkRun": {
// "id": "CR_kwDOLc8CoM8AAAAFQ5GqhQ",
// "name": "libb2/0.98.1+2/x86_64-linux-gnu/linux_debian_12-gcc_13.1/default/dev/0.17.0-a.1",
// "status": "QUEUED"
// }
// }
// }
//
static vector<gh_check_run>
gq_parse_response_check_runs (json::parser& p)
{
using event = json::event;
vector<gh_check_run> r;
gq_parse_response (p, [&r] (json::parser& p)
{
p.next_expect (event::begin_object);
// Parse the "cr0".."crN" members (field aliases).
//
while (p.next_expect (event::name, event::end_object))
{
// Parse `"crN": { "checkRun":`.
//
if (p.name () != "cr" + to_string (r.size ()))
throw_json (p, "unexpected field alias: '" + p.name () + '\'');
p.next_expect (event::begin_object);
p.next_expect_name ("checkRun");
r.emplace_back (p); // Parse the check_run object.
p.next_expect (event::end_object); // Parse end of crN object.
}
});
// Our requests always operate on at least one check run so if there were
// none in the data field something went wrong.
//
if (r.empty ())
throw_json (p, "data object is empty");
return r;
}
// Send a GraphQL mutation request `rq` that operates on one or more check
// runs. Update the check runs in `crs` with the new state and the node ID
// if unset. Return false and issue diagnostics if the request failed.
//
static bool
gq_mutate_check_runs (vector<check_run>& crs,
const string& iat,
string rq,
build_state st,
const basic_mark& error) noexcept
{
vector<gh_check_run> rcrs;
try
{
// Response type which parses a GraphQL response containing multiple
// check_run objects.
//
struct resp
{
vector<gh_check_run> check_runs; // Received check runs.
resp (json::parser& p): check_runs (gq_parse_response_check_runs (p)) {}
resp () = default;
} rs;
uint16_t sc (github_post (rs,
"graphql", // API Endpoint.
strings {"Authorization: Bearer " + iat},
move (rq)));
if (sc == 200)
{
rcrs = move (rs.check_runs);
if (rcrs.size () == crs.size ())
{
for (size_t i (0); i != rcrs.size (); ++i)
{
// Validate the check run in the response against the build.
//
const gh_check_run& rcr (rcrs[i]); // Received check run.
build_state rst (gh_from_status (rcr.status)); // Received state.
if (rst != build_state::built && rst != st)
{
error << "unexpected check_run status: received '" << rcr.status
<< "' but expected '" << gh_to_status (st) << '\'';
return false; // Fail because something is clearly very wrong.
}
else
{
check_run& cr (crs[i]);
if (!cr.node_id)
cr.node_id = move (rcr.node_id);
cr.state = gh_from_status (rcr.status);
cr.state_synced = true;
}
}
return true;
}
else
error << "unexpected number of check_run objects in response";
}
else
error << "failed to update check run: error HTTP response status "
<< sc;
}
catch (const json::invalid_json_input& e)
{
// Note: e.name is the GitHub API endpoint.
//
error << "malformed JSON in response from " << e.name << ", line: "
<< e.line << ", column: " << e.column << ", byte offset: "
<< e.position << ", error: " << e;
}
catch (const invalid_argument& e)
{
error << "malformed header(s) in response: " << e;
}
catch (const system_error& e)
{
error << "unable to mutate check runs (errno=" << e.code () << "): "
<< e.what ();
}
catch (const runtime_error& e) // From gq_parse_response_check_runs().
{
// GitHub response contained error(s) (could be ours or theirs at this
// point).
//
error << "unable to mutate check runs: " << e;
}
return false;
}
// Serialize a GraphQL operation (query/mutation) into a GraphQL request.
//
// This is essentially a JSON object with a "query" string member containing
// the GraphQL operation. For example:
//
// { "query": "mutation { cr0:createCheckRun(... }" }
//
static string
gq_serialize_request (const string& o)
{
string b;
json::buffer_serializer s (b);
s.begin_object ();
s.member ("query", o);
s.end_object ();
return b;
}
// Serialize `createCheckRun` mutations for one or more builds to GraphQL.
//
static string
gq_mutation_create_check_runs (
const string& ri, // Repository ID
const string& hs, // Head SHA
const vector<reference_wrapper<const build>>& bs,
build_state st,
const build_queued_hints* bh)
{
ostringstream os;
os << "mutation {" << '\n';
// Serialize a `createCheckRun` for each build.
//
for (size_t i (0); i != bs.size (); ++i)
{
const build& b (bs[i]);
string al ("cr" + to_string (i)); // Field alias.
// Check run name.
//
string nm (gh_check_run_name (b, bh));
os << gq_name (al) << ":createCheckRun(input: {" << '\n'
<< " name: " << gq_str (nm) << ',' << '\n'
<< " repositoryId: " << gq_str (ri) << ',' << '\n'
<< " headSha: " << gq_str (hs) << ',' << '\n'
<< " status: " << gq_enum (gh_to_status (st)) << '\n'
<< "})" << '\n'
// Specify the selection set (fields to be returned).
//
<< "{" << '\n'
<< " checkRun {" << '\n'
<< " id," << '\n'
<< " name," << '\n'
<< " status" << '\n'
<< " }" << '\n'
<< "}" << '\n';
}
os << "}" << '\n';
return os.str ();
}
// Serialize an `updateCheckRun` mutation for one build to GraphQL.
//
static string
gq_mutation_update_check_run (const string& ri, // Repository ID.
const string& ni, // Node ID.
build_state st)
{
ostringstream os;
os << "mutation {" << '\n'
<< "cr0:updateCheckRun(input: {" << '\n'
<< " checkRunId: " << gq_str (ni) << ',' << '\n'
<< " repositoryId: " << gq_str (ri) << ',' << '\n'
<< " status: " << gq_enum (gh_to_status (st)) << '\n'
<< "})" << '\n'
// Specify the selection set (fields to be returned).
//
<< "{" << '\n'
<< " checkRun {" << '\n'
<< " id," << '\n'
<< " name," << '\n'
<< " status" << '\n'
<< " }" << '\n'
<< "}" << '\n'
<< "}" << '\n';
return os.str ();
}
bool
gq_create_check_runs (vector<check_run>& crs,
const string& iat,
const string& rid,
const string& hs,
const vector<reference_wrapper<const build>>& bs,
build_state st,
const build_queued_hints& bh,
const basic_mark& error)
{
string rq (gq_serialize_request (
gq_mutation_create_check_runs (rid, hs, bs, st, &bh)));
return gq_mutate_check_runs (crs, iat, move (rq), st, error);
}
bool
gq_create_check_run (check_run& cr,
const string& iat,
const string& rid,
const string& hs,
const build& b,
build_state st,
const build_queued_hints& bh,
const basic_mark& error)
{
vector<check_run> crs {move (cr)};
bool r (gq_create_check_runs (crs, iat, rid, hs, {b}, st, bh, error));
cr = move (crs[0]);
return r;
}
bool
gq_update_check_run (check_run& cr,
const string& iat,
const string& rid,
const string& nid,
build_state st,
const basic_mark& error)
{
string rq (
gq_serialize_request (gq_mutation_update_check_run (rid, nid, st)));
vector<check_run> crs {move (cr)};
bool r (gq_mutate_check_runs (crs, iat, move (rq), st, error));
cr = move (crs[0]);
return r;
}
// GraphQL serialization functions.
//
// The GraphQL spec:
// https://spec.graphql.org/
//
// The GitHub GraphQL API reference:
// https://docs.github.com/en/graphql/reference/
//
// Check that a string is a valid GraphQL name.
//
// GraphQL names can contain only alphanumeric characters and underscores
// and cannot begin with a digit (so basically a C identifier).
//
// Return the name or throw invalid_argument if it is invalid.
//
// @@ TODO: dangerous API.
//
static const string&
gq_name (const string& v)
{
if (v.empty () || digit (v[0]))
throw invalid_argument ("invalid GraphQL name: '" + v + '\'');
for (char c: v)
{
if (!alnum (c) && c != '_')
{
throw invalid_argument ("invalid character in GraphQL name: '" + c +
'\'');
}
}
return v;
}
// Serialize a string to GraphQL.
//
// Return the serialized string or throw invalid_argument if the string is
// invalid.
//
static string
gq_str (const string& v)
{
// GraphQL strings are the same as JSON strings so we use the JSON
// serializer.
//
string b;
json::buffer_serializer s (b);
try
{
s.value (v);
}
catch (const json::invalid_json_output&)
{
throw invalid_argument ("invalid GraphQL string: '" + v + '\'');
}
return b;
}
// Serialize an int to GraphQL.
//
#if 0
static string
gq_int (uint64_t v)
{
string b;
json::buffer_serializer s (b);
s.value (v);
return b;
}
#endif
// Serialize a boolean to GraphQL.
//
static inline string
gq_bool (bool v)
{
return v ? "true" : "false";
}
// Check that a string is a valid GraphQL enum value.
//
// GraphQL enum values can be any GraphQL name except for `true`, `false`,
// or `null`.
//
// Return the enum value or throw invalid_argument if it is invalid.
//
// @@ TODO: dangerous API.
//
static const string&
gq_enum (const string& v)
{
if (v == "true" || v == "false" || v == "null")
throw invalid_argument ("invalid GraphQL enum value: '" + v + '\'');
return gq_name (v);
}
}
|