MIRROR: javascript for 🐜's, a tiny runtime with big ambitions
dry up error handler
+57
-26
+57
-26
src/modules/server.c
+57
-26
src/modules/server.c
···
328
328
server_queue_write(conn, NULL, out, out_len, SERVER_WRITE_CLOSE_CLIENT);
329
329
}
330
330
331
+
static inline void server_send_text_response(
332
+
ant_conn_t *conn,
333
+
int status,
334
+
const char *status_text,
335
+
const char *body
336
+
) {
337
+
if (!body) body = "";
338
+
server_send_basic_response(
339
+
conn, status,
340
+
status_text,
341
+
"text/plain;charset=UTF-8",
342
+
(const uint8_t *)body,
343
+
strlen(body)
344
+
);
345
+
}
346
+
347
+
static inline void server_send_internal_error(ant_conn_t *conn, const char *body) {
348
+
server_send_text_response(
349
+
conn, 500,
350
+
"Internal Server Error",
351
+
body ? body : "Internal Server Error"
352
+
);
353
+
}
354
+
331
355
static void server_finish_with_response(server_request_t *req, ant_value_t response_obj) {
332
356
response_data_t *resp = response_get_data(response_obj);
333
357
ant_value_t headers = response_get_headers(response_obj);
···
344
368
345
369
if (!req->conn || ant_conn_is_closing(req->conn)) return;
346
370
if (!resp) {
347
-
server_send_basic_response(req->conn, 500, "Internal Server Error", "text/plain;charset=UTF-8", (const uint8_t *)"Invalid Response", 16);
371
+
server_send_internal_error(req->conn, "Invalid Response");
348
372
return;
349
373
}
350
374
···
383
407
384
408
if (req->conn && !ant_conn_is_closing(req->conn)) {
385
409
msg = js_str(js, reason);
386
-
server_send_basic_response(req->conn, 500, "Internal Server Error", "text/plain;charset=UTF-8", (const uint8_t *)(msg ? msg : "Internal Server Error"), strlen(msg ? msg : "Internal Server Error"));
410
+
server_send_internal_error(req->conn, msg);
387
411
}
388
412
389
413
server_request_release(req);
···
399
423
400
424
if (!response_get_data(value)) {
401
425
if (req->conn && !ant_conn_is_closing(req->conn))
402
-
server_send_basic_response(req->conn, 500, "Internal Server Error", "text/plain;charset=UTF-8", (const uint8_t *)"fetch handler must return a Response", 35);
426
+
server_send_internal_error(req->conn, "fetch handler must return a Response");
403
427
} else if (req->conn && !ant_conn_is_closing(req->conn)) {
404
428
server_finish_with_response(req, value);
405
429
}
···
414
438
if (is_err(result)) {
415
439
ant_value_t reason = server_exception_reason(js, result);
416
440
const char *msg = js_str(js, reason);
417
-
server_send_basic_response(req->conn, 500, "Internal Server Error", "text/plain;charset=UTF-8", (const uint8_t *)(msg ? msg : "Internal Server Error"), strlen(msg ? msg : "Internal Server Error"));
441
+
server_send_internal_error(req->conn, msg);
418
442
return;
419
443
}
420
444
···
431
455
}
432
456
433
457
if (!response_get_data(result)) {
434
-
server_send_basic_response(req->conn, 500, "Internal Server Error", "text/plain;charset=UTF-8", (const uint8_t *)"fetch handler must return a Response", 35);
458
+
server_send_internal_error(req->conn, "fetch handler must return a Response");
435
459
return;
436
460
}
437
461
···
440
464
441
465
static ant_value_t server_stream_read_reject(ant_t *js, ant_value_t *args, int nargs) {
442
466
server_request_t *req = server_current_request(js);
443
-
(void)args;
444
-
(void)nargs;
445
-
446
467
if (!req) return js_mkundef();
468
+
447
469
req->response_read_promise = js_mkundef();
448
470
if (req->conn && !ant_conn_is_closing(req->conn)) ant_conn_close(req->conn);
449
471
server_request_release(req);
472
+
450
473
return js_mkundef();
451
474
}
452
475
···
632
655
633
656
static void server_process_client_request(ant_conn_t *conn, ant_http1_parsed_request_t *parsed) {
634
657
server_runtime_t *server = (server_runtime_t *)ant_listener_get_user_data(ant_conn_listener(conn));
658
+
635
659
ant_t *js = server->js;
636
660
ant_value_t headers = 0;
637
661
ant_value_t request_obj = 0;
638
662
ant_value_t result = 0;
663
+
639
664
char *url = NULL;
640
665
server_request_t *req = NULL;
641
666
642
667
url = server_build_request_url(server, parsed);
643
668
if (!url) {
644
669
ant_http1_free_parsed_request(parsed);
645
-
server_send_basic_response(conn, 500, "Internal Server Error", "text/plain;charset=UTF-8", (const uint8_t *)"Internal Server Error", 21);
670
+
server_send_internal_error(conn, NULL);
646
671
return;
647
672
}
648
673
···
650
675
if (is_err(headers)) {
651
676
free(url);
652
677
ant_http1_free_parsed_request(parsed);
653
-
server_send_basic_response(conn, 500, "Internal Server Error", "text/plain;charset=UTF-8", (const uint8_t *)"Internal Server Error", 21);
678
+
server_send_internal_error(conn, NULL);
654
679
return;
655
680
}
656
681
···
659
684
ant_http1_free_parsed_request(parsed);
660
685
661
686
if (is_err(request_obj)) {
662
-
server_send_basic_response(conn, 500, "Internal Server Error", "text/plain;charset=UTF-8", (const uint8_t *)"Internal Server Error", 21);
687
+
server_send_internal_error(conn, NULL);
663
688
return;
664
689
}
665
690
666
691
req = calloc(1, sizeof(*req));
667
692
if (!req) {
668
-
server_send_basic_response(conn, 500, "Internal Server Error", "text/plain;charset=UTF-8", (const uint8_t *)"Internal Server Error", 21);
693
+
server_send_internal_error(conn, NULL);
669
694
return;
670
695
}
671
696
···
693
718
parse_result = ant_http1_parse_request(ant_conn_buffer(conn), ant_conn_buffer_len(conn), &parsed, NULL);
694
719
if (parse_result == ANT_HTTP1_PARSE_ERROR) {
695
720
ant_http1_free_parsed_request(&parsed);
696
-
server_send_basic_response(conn, 400, "Bad Request", "text/plain;charset=UTF-8", (const uint8_t *)"Bad Request", 11);
721
+
server_send_text_response(conn, 400, "Bad Request", "Bad Request");
697
722
return;
698
723
}
699
724
···
723
748
724
749
bool server_export_has_fetch_handler(ant_t *js, ant_value_t default_export, bool *looks_like_config) {
725
750
ant_value_t fetch = 0;
751
+
726
752
if (looks_like_config) *looks_like_config = false;
727
753
if (!is_object_type(default_export)) return false;
728
754
···
737
763
ant_value_t tls = js_get(js, default_export, "tls");
738
764
739
765
*looks_like_config =
740
-
vtype(fetch) != T_UNDEF ||
741
-
vtype(port) != T_UNDEF ||
742
-
vtype(hostname) != T_UNDEF ||
766
+
vtype(fetch) != T_UNDEF ||
767
+
vtype(port) != T_UNDEF ||
768
+
vtype(hostname) != T_UNDEF ||
743
769
vtype(idle_timeout) != T_UNDEF ||
744
-
vtype(unix_path) != T_UNDEF ||
745
-
vtype(tls) != T_UNDEF;
770
+
vtype(unix_path) != T_UNDEF ||
771
+
vtype(tls) != T_UNDEF;
746
772
}
747
773
748
774
return false;
···
750
776
751
777
ant_value_t server_start_from_export(ant_t *js, ant_value_t default_export) {
752
778
server_runtime_t *server = NULL;
779
+
753
780
ant_value_t port_v = 0;
754
781
ant_value_t hostname_v = 0;
755
782
ant_value_t timeout_v = 0;
756
783
ant_value_t unix_v = 0;
757
784
ant_value_t tls_v = 0;
785
+
758
786
ant_listener_callbacks_t callbacks = {0};
759
787
int rc = 0;
760
788
761
789
if (g_server) return js_mkerr(js, "server is already running");
762
790
if (!is_object_type(default_export)) return js_mkerr_typed(js, JS_ERR_TYPE, "Module does not export a fetch handler");
763
791
764
-
server = calloc(1, sizeof(*server));
792
+
server = malloc(sizeof(*server));
765
793
if (!server) return js_mkerr(js, "out of memory");
766
794
767
-
server->js = js;
768
-
server->export_obj = default_export;
769
-
server->fetch_fn = js_get(js, default_export, "fetch");
770
-
server->hostname = strdup("0.0.0.0");
771
-
server->port = 3000;
772
-
server->idle_timeout_secs = 10;
773
-
server->loop = uv_default_loop();
795
+
*server = (server_runtime_t){
796
+
.js = js,
797
+
.export_obj = default_export,
798
+
.fetch_fn = js_get(js, default_export, "fetch"),
799
+
.hostname = strdup("0.0.0.0"),
800
+
.port = 3000,
801
+
.idle_timeout_secs = 10,
802
+
.loop = uv_default_loop(),
803
+
};
774
804
775
805
if (!server->hostname) {
776
806
free(server);
···
784
814
free(server);
785
815
return js_mkerr_typed(js, JS_ERR_TYPE, "unix sockets are not implemented yet");
786
816
}
817
+
787
818
if (vtype(tls_v) != T_UNDEF && vtype(tls_v) != T_NULL) {
788
819
free(server->hostname);
789
820
free(server);