http-client-queue.c revision 57d86b6fd46cb6d37bfc28f67ae4be80296ad35a
/* Copyright (c) 2013-2016 Dovecot authors, see the included COPYING file */
#include "lib.h"
#include "net.h"
#include "str.h"
#include "hash.h"
#include "array.h"
#include "bsearch-insert-pos.h"
#include "llist.h"
#include "ioloop.h"
#include "istream.h"
#include "ostream.h"
#include "time-util.h"
#include "dns-lookup.h"
#include "http-response-parser.h"
#include "http-client-private.h"
#define TIMEOUT_CMP_MARGIN_USECS 2000
static void
static void
/*
* Logging
*/
static inline void
static inline void
const char *format, ...)
{
i_debug("http-client: queue %s: %s",
}
}
/*
* Queue object
*/
static struct http_client_queue *
const struct http_client_peer_addr *addr)
{
struct http_client_queue *const *queue_idx;
return queue;
}
return NULL;
}
struct http_client_queue *
const struct http_client_peer_addr *addr)
{
struct http_client_queue *queue;
break;
break;
break;
break;
default:
i_unreached();
}
queue->ips_connect_idx = 0;
}
return queue;
}
{
struct http_client_peer *const *peer_idx;
/* unlink all peers */
}
}
/* abort all requests */
/* cancel timeouts */
/* free */
}
/*
* Error handling
*/
{
struct http_client_request **req_idx;
/* abort all pending requests */
}
/* all queues should be empty now... unless new requests were submitted
from the callback. this invariant captures it all: */
}
/*
* Connection management
*/
static bool
{
const struct http_client_settings *set =
/* if a maximum connect attempts > 1 is set, enforce it directly */
return TRUE;
/* otherwise, we'll always go through all the IPs. we don't necessarily
start connecting from the first IP, so we'll need to treat the IPs as
a ring buffer where we automatically wrap back to the first IP
when necessary. */
}
static void
{
const char *https_name;
/* no more IPs to try */
return;
}
/* if our our previous connection attempt takes longer than the
soft_connect_timeout, we start a connection attempt to the next IP in
parallel */
"starting parallel connection attempt to next IP",
/* next IP */
/* setup connection to new peer (can start new soft timeout) */
}
static struct http_client_peer *
{
struct http_client_peer *peer;
unsigned int num_requests =
const char *ssl = "";
if (num_requests == 0)
return NULL;
/* update our peer address */
}
/* already got a peer? */
/* is it still the one we want? */
/* is it still connected? */
/* yes */
"Using existing connection to %s%s "
"(%u requests pending)",
/* handle requests; */
}
/* no */
} else {
/* peer is not relevant to this queue anymore */
}
}
/* create provisional link between queue and peer */
if (http_client_peer_is_connected(peer)) {
/* drop any pending peers */
struct http_client_peer *const *peer_idx;
}
}
} else {
unsigned int msecs;
/* not already connected, wait for connections */
} else {
struct http_client_peer *const *peer_idx;
/* we may be waiting for this peer already */
break;
}
}
}
if (new_peer) {
if (queue->connect_attempts++ == 0)
}
/* start soft connect time-out (but only if we have another IP left) */
queue->to_connect =
}
}
}
return peer;
}
{
}
void
const struct http_client_peer_addr *addr)
{
/* we achieved at least one connection the the addr->ip */
}
/* reset attempt counter */
queue->connect_attempts = 0;
/* stop soft connect time-out */
/* drop all other attempts to the hport. note that we get here whenever
a connection is successfully created, so pending_peers array
may be empty. */
struct http_client_peer *const *peer_idx;
/* don't drop any connections to the successfully
connected peer, even if some of the connections
are pending. they may be intended for urgent
requests. */
continue;
}
peer will be freed, closing all connections.
*/
}
}
}
void
{
const struct http_client_settings *set =
struct http_client_peer *failed_peer;
struct http_client_peer *const *peer_idx;
"Failed to set up connection to %s%s: %s "
"(%u peers pending, %u requests pending)",
/* we're still doing the initial connections to this hport. if
we're also doing parallel connections with soft timeouts
(pending_peer_count>1), wait for them to finish
first. */
failed_peer = NULL;
failed_peer = *peer_idx;
break;
}
}
"Waiting for remaining pending peers.");
return;
}
/* one of the connections failed. if we're not using soft timeouts,
we need to try to connect to the next IP. if we are using soft
timeouts, we've already tried all of the IPs by now. */
return;
}
/* all IPs failed, but retry all of them again if we have more
connect attempts left or on the next request. */
if (set->max_connect_attempts == 0 ||
"Failed to set up any connection; failing all queued requests");
unsigned int total_msecs =
}
queue->connect_attempts = 0;
return;
}
} else {
}
return;
}
void
struct http_client_peer *peer)
{
struct http_client_peer *const *peer_idx;
return;
}
return;
break;
}
}
}
/*
* Main request queue
*/
void
struct http_client_request *req)
{
struct http_client_request **reqs;
unsigned int count, i;
/* drop from queue */
for (i = 0; i < count; i++) {
break;
}
}
} else {
for (i = 0; i < count; i++) {
break;
}
}
}
/* drop from delay queue */
for (i = 0; i < count; i++) {
break;
}
if (i < count) {
if (i == 0) {
if (count > 1) {
}
}
}
}
}
/* drop from main request list */
for (i = 0; i < count; i++) {
break;
}
if (i == 0) {
}
}
return;
}
static void
{
struct http_client_request *const *reqs;
unsigned int count, i;
/* collect failed requests */
for (i = 0; i < count; i++) {
&ioloop_timeval, TIMEOUT_CMP_MARGIN_USECS) > 0) {
break;
}
}
/* update timout */
if (i < count)
/* abort all failed request */
for (i = 0; i < count; i++) {
"Timed out");
}
}
}
static void
{
"Set request timeout to %s.%03lu (now: %s.%03lu)",
}
/* set timer */
}
static int
struct http_client_request *const *req2)
{
int ret;
/* 0 means no timeout */
/* sort by age */
return ret;
} else {
return 1;
}
return -1;
/* sort by timeout */
} else if
return ret;
}
/* sort by minumum attempts for fairness */
}
struct http_client_request *req)
{
else
/* enqueue */
/* no timeout; enqueue at end */
/* pretty much already timed out; don't bother */
} else {
unsigned int insert_idx;
/* keep transmission queue sorted earliest timeout first */
}
}
/*
* Delayed request queue
*/
static void
{
struct http_client_request *const *reqs;
finished = 0;
for (i = 0; i < count; i++) {
&ioloop_timeval, TIMEOUT_CMP_MARGIN_USECS) > 0) {
break;
}
"Activated delayed request %s%s",
finished++;
}
if (i < count) {
}
}
static void
{
int msecs;
/* round up to nearest microsecond */
/* set timer */
}
static int
struct http_client_request *const *req2)
{
}
/*
* Request submission
*/
struct http_client_request *req)
{
unsigned int insert_idx;
/* check delay vs timeout */
/* release time is later than absolute timeout */
/* timeout rightaway */
"Delayed request %s%s already timed out",
}
/* add to main request list */
/* no timeout; just append */
} else {
unsigned int insert_idx;
/* keep main request list sorted earliest timeout first */
/* now first in queue; update timer */
if (insert_idx == 0)
}
/* handle delay */
&ioloop_timeval, TIMEOUT_CMP_MARGIN_USECS) > 0) {
"Delayed request %s%s submitted (time remaining: %d msecs)",
if (insert_idx == 0)
return;
}
}
}
/*
* Request retrieval
*/
struct http_client_request *
{
struct http_client_request *const *requests;
struct http_client_request *req;
unsigned int i, count;
count = 0;
if (!no_urgent)
if (count == 0)
if (count == 0)
return NULL;
i = 0;
else
"Connection to peer %s claimed request %s %s",
return req;
}
unsigned int
unsigned int *num_urgent_r)
{
if (num_urgent_r != NULL)
}
/*
* ioloop
*/
{
}