Lines Matching refs:be
50 static int _prep_pending_write(struct mcp_backendconn_s *be);
51 static void _post_pending_write(struct mcp_backendconn_s *be, ssize_t sent);
52 static int _flush_pending_write(struct mcp_backendconn_s *be);
53 static int _flush_pending_tls_write(struct mcp_backendconn_s *be);
54 static void _cleanup_backend(mcp_backend_t *be);
55 static void _reset_bad_backend(struct mcp_backendconn_s *be, enum proxy_be_failures err);
56 static void _set_main_event(struct mcp_backendconn_s *be, struct event_base *base, int flags, struc…
57 static void _stop_main_event(struct mcp_backendconn_s *be);
58 static void _start_write_event(struct mcp_backendconn_s *be);
59 static void _stop_write_event(struct mcp_backendconn_s *be);
60 static void _start_timeout_event(struct mcp_backendconn_s *be);
61 static void _stop_timeout_event(struct mcp_backendconn_s *be);
62 static int proxy_backend_drive_machine(struct mcp_backendconn_s *be);
68 static int _beconn_send_validate(struct mcp_backendconn_s *be) { in _beconn_send_validate() argument
72 ssize_t res = write(mcmc_fd(be->client), str, len); in _beconn_send_validate()
87 static int _proxy_beconn_checkconnect(struct mcp_backendconn_s *be) { in _proxy_beconn_checkconnect() argument
90 if (mcmc_check_nonblock_connect(be->client, &err) != MCMC_OK) { in _proxy_beconn_checkconnect()
91 …P_DEBUG("%s: backend failed to connect (%s:%s)\n", __func__, be->be_parent->name, be->be_parent->p… in _proxy_beconn_checkconnect()
95 _reset_bad_backend(be, P_BE_FAIL_CONNECTING); in _proxy_beconn_checkconnect()
98 … backend connected [fd: %d] (%s:%s)\n", __func__, mcmc_fd(be->client), be->be_parent->name, be->be… in _proxy_beconn_checkconnect()
99 be->connecting = false; in _proxy_beconn_checkconnect()
100 be->state = mcp_backend_read; in _proxy_beconn_checkconnect()
103 gettimeofday(&be->last_failed, NULL); in _proxy_beconn_checkconnect()
105 be->validating = true; in _proxy_beconn_checkconnect()
113 struct mcp_backendconn_s *proxy_choose_beconn(mcp_backend_t *be) { in proxy_choose_beconn() argument
114 struct mcp_backendconn_s *bec = &be->be[0]; in proxy_choose_beconn()
115 if (be->conncount != 1) { in proxy_choose_beconn()
124 for (int x = 0; x < be->conncount; x++) { in proxy_choose_beconn()
125 struct mcp_backendconn_s *bec_i = &be->be[x]; in proxy_choose_beconn()
162 mcp_backend_t *be = io->backend; in _proxy_event_handler_dequeue() local
163 STAILQ_INSERT_TAIL(&be->io_head, io, io_next); in _proxy_event_handler_dequeue()
164 assert(be->depth > -1); in _proxy_event_handler_dequeue()
165 be->depth++; in _proxy_event_handler_dequeue()
166 if (!be->stacked) { in _proxy_event_handler_dequeue()
167 be->stacked = true; in _proxy_event_handler_dequeue()
168 STAILQ_INSERT_TAIL(&t->be_head, be, be_next); in _proxy_event_handler_dequeue()
173 static void _cleanup_backend(mcp_backend_t *be) { in _cleanup_backend() argument
174 for (int x = 0; x < be->conncount; x++) { in _cleanup_backend()
175 struct mcp_backendconn_s *bec = &be->be[x]; in _cleanup_backend()
177 if (!be->tunables.down) { in _cleanup_backend()
208 free(be); in _cleanup_backend()
211 static void _setup_backend(mcp_backend_t *be) { in _setup_backend() argument
212 for (int x = 0; x < be->conncount; x++) { in _setup_backend()
213 struct mcp_backendconn_s *bec = &be->be[x]; in _setup_backend()
214 if (be->tunables.down) { in _setup_backend()
217 be->be[x].bad = true; in _setup_backend()
223 int status = mcmc_connect(bec->client, be->name, be->port, bec->connect_flags); in _setup_backend()
226 if (be->tunables.use_tls) { in _setup_backend()
281 mcp_backend_t *be = NULL; in proxy_event_beconn() local
284 be = STAILQ_FIRST(&head); in proxy_event_beconn()
286 if (be->transferred) { in proxy_event_beconn()
289 _cleanup_backend(be); in proxy_event_beconn()
291 be->transferred = true; in proxy_event_beconn()
292 _setup_backend(be); in proxy_event_beconn()
297 static void _proxy_flush_backend_queue(mcp_backend_t *be) { in _proxy_flush_backend_queue() argument
299 …fast failing request to bad backend (%s:%s) depth: %d\n", __func__, be->name, be->port, be->depth); in _proxy_flush_backend_queue()
301 while (!STAILQ_EMPTY(&be->io_head)) { in _proxy_flush_backend_queue()
302 io = STAILQ_FIRST(&be->io_head); in _proxy_flush_backend_queue()
303 STAILQ_REMOVE_HEAD(&be->io_head, io_next); in _proxy_flush_backend_queue()
307 be->depth--; in _proxy_flush_backend_queue()
308 assert(be->depth > -1); in _proxy_flush_backend_queue()
314 mcp_backend_t *be; in proxy_run_backend_queue() local
315 STAILQ_FOREACH(be, head, be_next) { in proxy_run_backend_queue()
316 be->stacked = false; in proxy_run_backend_queue()
318 struct mcp_backendconn_s *bec = proxy_choose_beconn(be); in proxy_run_backend_queue()
320 int limit = be->tunables.backend_depth_limit; in proxy_run_backend_queue()
323 _proxy_flush_backend_queue(be); in proxy_run_backend_queue()
327 STAT_INCR(ctx, request_failed_depth, be->depth); in proxy_run_backend_queue()
328 _proxy_flush_backend_queue(be); in proxy_run_backend_queue()
333 STAILQ_CONCAT(&bec->io_head, &be->io_head); in proxy_run_backend_queue()
334 bec->depth += be->depth; in proxy_run_backend_queue()
335 be->depth = 0; in proxy_run_backend_queue()
338 P_DEBUG("%s: deferring IO pending connecting (%s:%s)\n", __func__, be->name, be->port); in proxy_run_backend_queue()
404 static void _set_main_event(struct mcp_backendconn_s *be, struct event_base *base, int flags, struc… in _set_main_event() argument
405 int pending = event_pending(&be->main_event, EV_READ|EV_WRITE|EV_TIMEOUT, NULL); in _set_main_event()
407 event_del(&be->main_event); // replace existing event. in _set_main_event()
410 int fd = mcmc_fd(be->client); in _set_main_event()
415 event_assign(&be->main_event, base, fd, in _set_main_event()
416 flags, callback, be); in _set_main_event()
417 event_add(&be->main_event, t); in _set_main_event()
420 static void _stop_main_event(struct mcp_backendconn_s *be) { in _stop_main_event() argument
421 event_del(&be->main_event); in _stop_main_event()
424 static void _start_write_event(struct mcp_backendconn_s *be) { in _start_write_event() argument
425 int pending = event_pending(&be->write_event, EV_WRITE|EV_TIMEOUT, NULL); in _start_write_event()
430 event_add(&be->write_event, &be->tunables.read); in _start_write_event()
433 static void _stop_write_event(struct mcp_backendconn_s *be) { in _stop_write_event() argument
434 event_del(&be->write_event); in _stop_write_event()
439 static void _start_timeout_event(struct mcp_backendconn_s *be) { in _start_timeout_event() argument
440 int pending = event_pending(&be->timeout_event, EV_TIMEOUT, NULL); in _start_timeout_event()
444 event_add(&be->timeout_event, &be->tunables.read); in _start_timeout_event()
447 static void _stop_timeout_event(struct mcp_backendconn_s *be) { in _stop_timeout_event() argument
448 int pending = event_pending(&be->timeout_event, EV_TIMEOUT, NULL); in _stop_timeout_event()
452 event_del(&be->timeout_event); in _stop_timeout_event()
455 static void _drive_machine_next(struct mcp_backendconn_s *be, io_pending_proxy_t *p) { in _drive_machine_next() argument
457 STAILQ_REMOVE_HEAD(&be->io_head, io_next); in _drive_machine_next()
458 be->depth--; in _drive_machine_next()
459 assert(p != be->io_next); // don't remove what we need to flush. in _drive_machine_next()
460 assert(be->depth > -1); in _drive_machine_next()
461 be->pending_read--; in _drive_machine_next()
462 assert(be->pending_read > -1); in _drive_machine_next()
469 be->state = mcp_backend_read; in _drive_machine_next()
475 static int proxy_backend_drive_machine(struct mcp_backendconn_s *be) { in proxy_backend_drive_machine() argument
480 p = STAILQ_FIRST(&be->io_head); in proxy_backend_drive_machine()
496 switch(be->state) { in proxy_backend_drive_machine()
500 be->state = mcp_backend_parse; in proxy_backend_drive_machine()
504 r->status = mcmc_parse_buf(be->rbuf, be->rbufused, &r->resp); in proxy_backend_drive_machine()
515 be->state = mcp_backend_next; in proxy_backend_drive_machine()
522 be->state = mcp_backend_read_end; in proxy_backend_drive_machine()
530 be->rbufused -= r->resp.reslen; in proxy_backend_drive_machine()
531 if (be->rbufused > 0) { in proxy_backend_drive_machine()
532 memmove(be->rbuf, be->rbuf+r->resp.reslen, be->rbufused); in proxy_backend_drive_machine()
535 be->state = mcp_backend_next; in proxy_backend_drive_machine()
550 be->state = mcp_backend_next_close; in proxy_backend_drive_machine()
600 assert(be->rbufused == r->resp.reslen+r->resp.vlen_read); in proxy_backend_drive_machine()
603 memcpy(r->buf, be->rbuf, r->resp.reslen + r->resp.vlen_read); in proxy_backend_drive_machine()
605 be->rbufused = 0; in proxy_backend_drive_machine()
606 be->state = mcp_backend_want_read; in proxy_backend_drive_machine()
613 memcpy(r->buf, be->rbuf, r->resp.reslen+r->resp.vlen_read); in proxy_backend_drive_machine()
617 be->rbufused -= r->resp.reslen + r->resp.vlen_read; in proxy_backend_drive_machine()
618 if (be->rbufused > 0) { in proxy_backend_drive_machine()
619 memmove(be->rbuf, be->rbuf+r->resp.reslen+r->resp.vlen_read, be->rbufused); in proxy_backend_drive_machine()
628 if (be->rbufused >= ENDLEN) { in proxy_backend_drive_machine()
629 if (memcmp(be->rbuf, ENDSTR, ENDLEN) != 0) { in proxy_backend_drive_machine()
646 be->rbufused -= ENDLEN; in proxy_backend_drive_machine()
647 if (be->rbufused > 0) { in proxy_backend_drive_machine()
648 memmove(be->rbuf, be->rbuf+ENDLEN, be->rbufused); in proxy_backend_drive_machine()
657 be->state = mcp_backend_next; in proxy_backend_drive_machine()
666 assert(be->rbufused != 0); in proxy_backend_drive_machine()
667 size_t tocopy = be->rbufused < r->blen - r->bread ? in proxy_backend_drive_machine()
668 be->rbufused : r->blen - r->bread; in proxy_backend_drive_machine()
669 memcpy(r->buf+r->bread, be->rbuf, tocopy); in proxy_backend_drive_machine()
675 be->state = mcp_backend_read_end; in proxy_backend_drive_machine()
677 be->state = mcp_backend_next; in proxy_backend_drive_machine()
681 be->rbufused -= tocopy; in proxy_backend_drive_machine()
682 if (be->rbufused > 0) { in proxy_backend_drive_machine()
683 memmove(be->rbuf, be->rbuf+tocopy, be->rbufused); in proxy_backend_drive_machine()
686 assert(tocopy == be->rbufused); in proxy_backend_drive_machine()
688 be->rbufused = 0; in proxy_backend_drive_machine()
695 _drive_machine_next(be, p); in proxy_backend_drive_machine()
697 if (STAILQ_EMPTY(&be->io_head)) { in proxy_backend_drive_machine()
701 if (be->rbufused > 0) { in proxy_backend_drive_machine()
706 p = STAILQ_FIRST(&be->io_head); in proxy_backend_drive_machine()
712 P_DEBUG("%s: [next] remain: %lu\n", __func__, be->rbufused); in proxy_backend_drive_machine()
713 if (be->rbufused != 0) { in proxy_backend_drive_machine()
715 be->state = mcp_backend_parse; in proxy_backend_drive_machine()
724 _drive_machine_next(be, p); in proxy_backend_drive_machine()
733 fprintf(stderr, "%s: invalid backend state: %d\n", __func__, be->state); in proxy_backend_drive_machine()
741 static void _backend_reconnect(struct mcp_backendconn_s *be) { in _backend_reconnect() argument
742 …int status = mcmc_connect(be->client, be->be_parent->name, be->be_parent->port, be->connect_flags); in _backend_reconnect()
745 be->connecting = false; in _backend_reconnect()
746 be->can_write = true; in _backend_reconnect()
748 be->connecting = true; in _backend_reconnect()
749 be->can_write = false; in _backend_reconnect()
753 be->connecting = false; in _backend_reconnect()
754 be->can_write = true; in _backend_reconnect()
759 if (be->be_parent->tunables.use_tls) { in _backend_reconnect()
762 …event_assign(&be->write_event, be->event_thread->base, mcmc_fd(be->client), EV_WRITE|EV_TIMEOUT, _… in _backend_reconnect()
768 struct mcp_backendconn_s *be = arg; in proxy_backend_retry_handler() local
770 struct timeval tmp_time = be->tunables.connect; in proxy_backend_retry_handler()
771 _backend_reconnect(be); in proxy_backend_retry_handler()
773 if (be->be_parent->tunables.use_tls) { in proxy_backend_retry_handler()
776 _set_main_event(be, be->event_thread->base, EV_WRITE, &tmp_time, _backend_handler); in proxy_backend_retry_handler()
783 static void _backend_reschedule(struct mcp_backendconn_s *be) { in _backend_reschedule() argument
786 long int retry_time = be->tunables.retry.tv_sec; in _backend_reschedule()
788 if (be->flap_count > be->tunables.backend_failure_limit) { in _backend_reschedule()
791 for (int x = 0; x < be->flap_count; x++) { in _backend_reschedule()
792 backoff *= be->tunables.flap_backoff_ramp; in _backend_reschedule()
796 if (retry_time > be->tunables.flap_backoff_max) { in _backend_reschedule()
797 retry_time = be->tunables.flap_backoff_max; in _backend_reschedule()
801 } else if (be->failed_count > be->tunables.backend_failure_limit) { in _backend_reschedule()
807 if (!be->bad) { in _backend_reschedule()
809 STAT_INCR(be->event_thread->ctx, backend_marked_bad, 1); in _backend_reschedule()
810 mcp_sharedvm_delta(be->event_thread->ctx, SHAREDVM_BACKEND_IDX, in _backend_reschedule()
811 be->be_parent->label, 1); in _backend_reschedule()
812 …OG_PROXYEVENTS, LOGGER_PROXY_BE_ERROR, NULL, badtext, be->be_parent->name, be->be_parent->port, be… in _backend_reschedule()
814 be->bad = true; in _backend_reschedule()
815 … _set_main_event(be, be->event_thread->base, EV_TIMEOUT, &tmp_time, proxy_backend_retry_handler); in _backend_reschedule()
817 struct timeval tmp_time = be->tunables.connect; in _backend_reschedule()
818 STAT_INCR(be->event_thread->ctx, backend_failed, 1); in _backend_reschedule()
819 _backend_reconnect(be); in _backend_reschedule()
821 if (be->be_parent->tunables.use_tls) { in _backend_reschedule()
824 _set_main_event(be, be->event_thread->base, EV_WRITE, &tmp_time, _backend_handler); in _backend_reschedule()
828 static void _backend_flap_check(struct mcp_backendconn_s *be, enum proxy_be_failures err) { in _backend_flap_check() argument
830 struct timeval *flap = &be->tunables.flap; in _backend_flap_check()
841 delta.tv_sec = now.tv_sec - be->last_failed.tv_sec; in _backend_flap_check()
842 subsec = now.tv_usec - be->last_failed.tv_usec; in _backend_flap_check()
854 be->flap_count = 0; in _backend_flap_check()
857 be->flap_count++; in _backend_flap_check()
859 be->last_failed = now; in _backend_flap_check()
876 static void _reset_bad_backend(struct mcp_backendconn_s *be, enum proxy_be_failures err) { in _reset_bad_backend() argument
878 …P_DEBUG("%s: resetting bad backend: [fd: %d] %s\n", __func__, mcmc_fd(be->client), proxy_be_failur… in _reset_bad_backend()
881 int depth = be->depth; in _reset_bad_backend()
882 while (!STAILQ_EMPTY(&be->io_head)) { in _reset_bad_backend()
883 io = STAILQ_FIRST(&be->io_head); in _reset_bad_backend()
884 STAILQ_REMOVE_HEAD(&be->io_head, io_next); in _reset_bad_backend()
890 be->depth--; in _reset_bad_backend()
891 assert(be->depth > -1); in _reset_bad_backend()
895 STAILQ_INIT(&be->io_head); in _reset_bad_backend()
896 be->io_next = NULL; // also reset the write offset. in _reset_bad_backend()
899 if (!be->bad) { in _reset_bad_backend()
900 … NULL, proxy_be_failure_text[err], be->be_parent->name, be->be_parent->port, be->be_parent->label,… in _reset_bad_backend()
904 be->rbufused = 0; in _reset_bad_backend()
905 be->pending_read = 0; in _reset_bad_backend()
907 _stop_write_event(be); in _reset_bad_backend()
908 _stop_main_event(be); in _reset_bad_backend()
909 _stop_timeout_event(be); in _reset_bad_backend()
910 mcp_tls_shutdown(be); in _reset_bad_backend()
911 mcmc_disconnect(be->client); in _reset_bad_backend()
915 be->failed_count++; in _reset_bad_backend()
916 _backend_flap_check(be, err); in _reset_bad_backend()
917 _backend_reschedule(be); in _reset_bad_backend()
920 static int _prep_pending_write(struct mcp_backendconn_s *be) { in _prep_pending_write() argument
921 struct iovec *iovs = be->write_iovs; in _prep_pending_write()
924 if (be->io_next == NULL) { in _prep_pending_write()
926 io = STAILQ_FIRST(&be->io_head); in _prep_pending_write()
928 io = be->io_next; in _prep_pending_write()
948 static void _post_pending_write(struct mcp_backendconn_s *be, ssize_t sent) { in _post_pending_write() argument
949 io_pending_proxy_t *io = be->io_next; in _post_pending_write()
951 io = STAILQ_FIRST(&be->io_head); in _post_pending_write()
979 be->pending_read++; in _post_pending_write()
992 be->io_next = io; in _post_pending_write()
997 be->io_next = nio; in _post_pending_write()
999 be->io_next = NULL; in _post_pending_write()
1003 be->io_next = NULL; in _post_pending_write()
1007 static int _flush_pending_write(struct mcp_backendconn_s *be) { in _flush_pending_write() argument
1010 if (STAILQ_EMPTY(&be->io_head)) { in _flush_pending_write()
1014 int iovcnt = _prep_pending_write(be); in _flush_pending_write()
1016 ssize_t sent = writev(mcmc_fd(be->client), be->write_iovs, iovcnt); in _flush_pending_write()
1018 _post_pending_write(be, sent); in _flush_pending_write()
1020 if (be->io_next) { in _flush_pending_write()
1021 be->can_write = false; in _flush_pending_write()
1026 be->can_write = false; in _flush_pending_write()
1036 static int _flush_pending_tls_write(struct mcp_backendconn_s *be) { in _flush_pending_tls_write() argument
1039 if (STAILQ_EMPTY(&be->io_head)) { in _flush_pending_tls_write()
1043 int iovcnt = _prep_pending_write(be); in _flush_pending_tls_write()
1045 int sent = mcp_tls_writev(be, iovcnt); in _flush_pending_tls_write()
1047 _post_pending_write(be, sent); in _flush_pending_tls_write()
1050 if (be->io_next) { in _flush_pending_tls_write()
1051 be->can_write = false; in _flush_pending_tls_write()
1056 be->can_write = false; in _flush_pending_tls_write()
1069 struct mcp_backendconn_s *be = arg; in proxy_bevalidate_tls_handler() local
1071 struct timeval tmp_time = be->tunables.read; in proxy_bevalidate_tls_handler()
1074 P_DEBUG("%s: backend timed out while connecting [fd: %d]\n", __func__, mcmc_fd(be->client)); in proxy_bevalidate_tls_handler()
1075 if (be->connecting) { in proxy_bevalidate_tls_handler()
1076 _reset_bad_backend(be, P_BE_FAIL_CONNTIMEOUT); in proxy_bevalidate_tls_handler()
1078 _reset_bad_backend(be, P_BE_FAIL_READVALIDATE); in proxy_bevalidate_tls_handler()
1084 int read = mcp_tls_read(be); in proxy_bevalidate_tls_handler()
1089 int status = mcmc_parse_buf(be->rbuf, be->rbufused, &r); in proxy_bevalidate_tls_handler()
1094 … _set_main_event(be, be->event_thread->base, EV_READ, &tmp_time, proxy_bevalidate_tls_handler); in proxy_bevalidate_tls_handler()
1098 _reset_bad_backend(be, P_BE_FAIL_READVALIDATE); in proxy_bevalidate_tls_handler()
1103 _reset_bad_backend(be, P_BE_FAIL_BADVALIDATE); in proxy_bevalidate_tls_handler()
1107 be->validating = false; in proxy_bevalidate_tls_handler()
1108 be->rbufused = 0; in proxy_bevalidate_tls_handler()
1111 _reset_bad_backend(be, P_BE_FAIL_DISCONNECTED); in proxy_bevalidate_tls_handler()
1115 … _set_main_event(be, be->event_thread->base, EV_READ, &tmp_time, proxy_bevalidate_tls_handler); in proxy_bevalidate_tls_handler()
1119 _reset_bad_backend(be, P_BE_FAIL_READING); in proxy_bevalidate_tls_handler()
1124 int res = _flush_pending_tls_write(be); in proxy_bevalidate_tls_handler()
1126 _reset_bad_backend(be, P_BE_FAIL_WRITING); in proxy_bevalidate_tls_handler()
1130 _start_write_event(be); in proxy_bevalidate_tls_handler()
1132 if (be->pending_read) { in proxy_bevalidate_tls_handler()
1133 _start_timeout_event(be); in proxy_bevalidate_tls_handler()
1138 if (!be->validating) { in proxy_bevalidate_tls_handler()
1139 … _set_main_event(be, be->event_thread->base, EV_READ|EV_PERSIST, NULL, proxy_backend_tls_handler); in proxy_bevalidate_tls_handler()
1145 if (be->bad) { in proxy_bevalidate_tls_handler()
1147 mcp_sharedvm_delta(be->event_thread->ctx, SHAREDVM_BACKEND_IDX, in proxy_bevalidate_tls_handler()
1148 be->be_parent->label, -1); in proxy_bevalidate_tls_handler()
1150 be->bad = false; in proxy_bevalidate_tls_handler()
1151 be->failed_count = 0; in proxy_bevalidate_tls_handler()
1159 struct mcp_backendconn_s *be = arg; in proxy_beconn_tls_handler() local
1161 struct timeval tmp_time = be->tunables.read; in proxy_beconn_tls_handler()
1164 P_DEBUG("%s: backend timed out while connecting [fd: %d]\n", __func__, mcmc_fd(be->client)); in proxy_beconn_tls_handler()
1165 if (be->connecting) { in proxy_beconn_tls_handler()
1166 _reset_bad_backend(be, P_BE_FAIL_CONNTIMEOUT); in proxy_beconn_tls_handler()
1168 _reset_bad_backend(be, P_BE_FAIL_READVALIDATE); in proxy_beconn_tls_handler()
1174 be->can_write = true; in proxy_beconn_tls_handler()
1176 if (be->connecting) { in proxy_beconn_tls_handler()
1177 if (_proxy_beconn_checkconnect(be) == -1) { in proxy_beconn_tls_handler()
1181 mcp_tls_connect(be); in proxy_beconn_tls_handler()
1186 assert(be->validating); in proxy_beconn_tls_handler()
1187 int ret = mcp_tls_handshake(be); in proxy_beconn_tls_handler()
1190 _set_main_event(be, be->event_thread->base, EV_READ, &tmp_time, proxy_beconn_tls_handler); in proxy_beconn_tls_handler()
1194 if (mcp_tls_send_validate(be) != MCP_TLS_OK) { in proxy_beconn_tls_handler()
1195 _reset_bad_backend(be, P_BE_FAIL_BADVALIDATE); in proxy_beconn_tls_handler()
1200 … _set_main_event(be, be->event_thread->base, EV_READ, &tmp_time, proxy_bevalidate_tls_handler); in proxy_beconn_tls_handler()
1203 _reset_bad_backend(be, P_BE_FAIL_BADVALIDATE); in proxy_beconn_tls_handler()
1211 struct mcp_backendconn_s *be = arg; in proxy_beconn_handler() local
1213 struct timeval tmp_time = be->tunables.read; in proxy_beconn_handler()
1216 P_DEBUG("%s: backend timed out while connecting [fd: %d]\n", __func__, mcmc_fd(be->client)); in proxy_beconn_handler()
1217 if (be->connecting) { in proxy_beconn_handler()
1218 _reset_bad_backend(be, P_BE_FAIL_CONNTIMEOUT); in proxy_beconn_handler()
1220 _reset_bad_backend(be, P_BE_FAIL_READVALIDATE); in proxy_beconn_handler()
1226 be->can_write = true; in proxy_beconn_handler()
1228 if (be->connecting) { in proxy_beconn_handler()
1229 if (_proxy_beconn_checkconnect(be) == -1) { in proxy_beconn_handler()
1232 if (_beconn_send_validate(be) == -1) { in proxy_beconn_handler()
1233 _reset_bad_backend(be, P_BE_FAIL_BADVALIDATE); in proxy_beconn_handler()
1236 _set_main_event(be, be->event_thread->base, EV_READ, &tmp_time, proxy_beconn_handler); in proxy_beconn_handler()
1240 if (!be->validating) { in proxy_beconn_handler()
1241 int res = _flush_pending_write(be); in proxy_beconn_handler()
1243 _reset_bad_backend(be, P_BE_FAIL_WRITING); in proxy_beconn_handler()
1252 assert(be->validating); in proxy_beconn_handler()
1254 … int read = recv(mcmc_fd(be->client), be->rbuf + be->rbufused, READ_BUFFER_SIZE - be->rbufused, 0); in proxy_beconn_handler()
1257 be->rbufused += read; in proxy_beconn_handler()
1259 int status = mcmc_parse_buf(be->rbuf, be->rbufused, &r); in proxy_beconn_handler()
1264 … _set_main_event(be, be->event_thread->base, EV_READ, &tmp_time, proxy_beconn_handler); in proxy_beconn_handler()
1268 _reset_bad_backend(be, P_BE_FAIL_READVALIDATE); in proxy_beconn_handler()
1273 _reset_bad_backend(be, P_BE_FAIL_BADVALIDATE); in proxy_beconn_handler()
1277 be->validating = false; in proxy_beconn_handler()
1278 be->rbufused = 0; in proxy_beconn_handler()
1281 _reset_bad_backend(be, P_BE_FAIL_DISCONNECTED); in proxy_beconn_handler()
1286 _reset_bad_backend(be, P_BE_FAIL_READING); in proxy_beconn_handler()
1289 _set_main_event(be, be->event_thread->base, EV_READ, &tmp_time, proxy_beconn_handler); in proxy_beconn_handler()
1294 int res = _flush_pending_write(be); in proxy_beconn_handler()
1296 _reset_bad_backend(be, P_BE_FAIL_WRITING); in proxy_beconn_handler()
1300 _start_write_event(be); in proxy_beconn_handler()
1302 if (be->pending_read) { in proxy_beconn_handler()
1303 _start_timeout_event(be); in proxy_beconn_handler()
1308 if (!be->validating) { in proxy_beconn_handler()
1309 … _set_main_event(be, be->event_thread->base, EV_READ|EV_PERSIST, NULL, proxy_backend_handler); in proxy_beconn_handler()
1315 if (be->bad) { in proxy_beconn_handler()
1317 mcp_sharedvm_delta(be->event_thread->ctx, SHAREDVM_BACKEND_IDX, in proxy_beconn_handler()
1318 be->be_parent->label, -1); in proxy_beconn_handler()
1320 be->bad = false; in proxy_beconn_handler()
1321 be->failed_count = 0; in proxy_beconn_handler()
1326 struct mcp_backendconn_s *be = arg; in proxy_backend_tls_handler() local
1330 _reset_bad_backend(be, P_BE_FAIL_TIMEOUT); in proxy_backend_tls_handler()
1335 be->can_write = true; in proxy_backend_tls_handler()
1336 int res = _flush_pending_tls_write(be); in proxy_backend_tls_handler()
1338 _reset_bad_backend(be, P_BE_FAIL_WRITING); in proxy_backend_tls_handler()
1342 _start_write_event(be); in proxy_backend_tls_handler()
1348 _stop_timeout_event(be); in proxy_backend_tls_handler()
1351 int read = mcp_tls_read(be); in proxy_backend_tls_handler()
1353 int res = proxy_backend_drive_machine(be); in proxy_backend_tls_handler()
1355 _reset_bad_backend(be, res); in proxy_backend_tls_handler()
1360 _reset_bad_backend(be, P_BE_FAIL_DISCONNECTED); in proxy_backend_tls_handler()
1366 _reset_bad_backend(be, P_BE_FAIL_READING); in proxy_backend_tls_handler()
1371 if (!STAILQ_EMPTY(&be->io_head)) { in proxy_backend_tls_handler()
1372 P_DEBUG("backend has leftover IOs: %d\n", be->depth); in proxy_backend_tls_handler()
1377 if (be->pending_read) { in proxy_backend_tls_handler()
1378 _start_timeout_event(be); in proxy_backend_tls_handler()
1386 struct mcp_backendconn_s *be = arg; in proxy_backend_handler() local
1390 _reset_bad_backend(be, P_BE_FAIL_TIMEOUT); in proxy_backend_handler()
1395 be->can_write = true; in proxy_backend_handler()
1396 int res = _flush_pending_write(be); in proxy_backend_handler()
1398 _reset_bad_backend(be, P_BE_FAIL_WRITING); in proxy_backend_handler()
1402 _start_write_event(be); in proxy_backend_handler()
1408 _stop_timeout_event(be); in proxy_backend_handler()
1411 int read = recv(mcmc_fd(be->client), be->rbuf + be->rbufused, in proxy_backend_handler()
1412 READ_BUFFER_SIZE - be->rbufused, 0); in proxy_backend_handler()
1414 be->rbufused += read; in proxy_backend_handler()
1415 int res = proxy_backend_drive_machine(be); in proxy_backend_handler()
1417 _reset_bad_backend(be, res); in proxy_backend_handler()
1422 _reset_bad_backend(be, P_BE_FAIL_DISCONNECTED); in proxy_backend_handler()
1427 _reset_bad_backend(be, P_BE_FAIL_READING); in proxy_backend_handler()
1433 if (!STAILQ_EMPTY(&be->io_head)) { in proxy_backend_handler()
1434 P_DEBUG("backend has leftover IOs: %d\n", be->depth); in proxy_backend_handler()
1439 if (be->pending_read) { in proxy_backend_handler()
1440 _start_timeout_event(be); in proxy_backend_handler()