void Socket::translate(Socket::Option option, int& level, int& optname) {
switch (option) {
case NO_DELAY:
SBL_THROW_IF(is_unix(), "unable to set option %s for local sockets", option_name[optname]);
level = IPPROTO_TCP; optname = TCP_NODELAY;
break;
case CORK:
SBL_THROW_IF(is_unix(), "unable to set option %s for local sockets", option_name[optname]);
#ifdef __APPLE__
SBL_THROW("Illegal option CORK");
#else
level = IPPROTO_TCP; optname = TCP_CORK;
#endif
break;
case SEND_BUFF_SIZE:
level = SOL_SOCKET; optname = SO_SNDBUF;
break;
case RECV_BUFF_SIZE:
level = SOL_SOCKET; optname = SO_RCVBUF;
break;
case BROADCAST:
level = SOL_SOCKET, optname = SO_BROADCAST;
break;
default: SBL_ASSERT(0);
}
}
void fm_store(struct file_mode *dest, int host_os, int mode)
{
if(host_os==OS_SPECIAL)
dest->dos=dest->native=mode;
if(is_unix(OS))
{
dest->native=mode;
dest->dos=FATTR_ARCH;
if(is_unix(OS)&&!(mode&FATTR_IWUSR))
dest->dos|=FATTR_RDONLY;
}
else /* Assume a DOS-style system */
dest->dos=dest->native=mode;
}
int
static test7(CSSM_DL_HANDLE dl)
{
int pass = 1;
CSSM_DL_DB_HANDLE dldb = { dl };
/* Case 7 non autocommit create delete rollback then close. */
pass &= ok_status(CSSM_DL_DbCreate(dldb.DLHandle, DBNAME,
NULL /* DbLocation */,
&dbInfo,
CSSM_DB_ACCESS_READ | CSSM_DB_ACCESS_WRITE,
NULL /* CredAndAclEntry */,
&openParameters,
&dldb.DBHandle),
"CSSM_DL_DbCreate");
pass &= ok_status(CSSM_DL_DbDelete(dldb.DLHandle, DBNAME,
NULL /* DbLocation */, NULL /* AccessCred */), "CSSM_DL_DbDelete");
pass &= ok_status(CSSM_DL_PassThrough(dldb, CSSM_APPLEFILEDL_ROLLBACK,
NULL, NULL), "CSSM_APPLEFILEDL_ROLLBACK");
pass &= ok_status(CSSM_DL_DbClose(dldb), "CSSM_DL_DbClose");
pass &= is_unix(unlink(DBNAME), ENOENT, "unlink");
return pass;
}
int Socket::local_address(char* ip_addr) const {
SBL_ASSERT(is_valid() && !is_unix());
struct sockaddr_in addr;
socklen_t addr_len = sizeof addr;
SBL_PERROR(::getsockname(id(), (struct sockaddr*) &addr, &addr_len) != 0);
if (ip_addr)
SBL_PERROR(::inet_ntop(AF_INET, &addr.sin_addr, ip_addr, IP_ADDR_BUFF_SIZE) == 0);
return ntohs(addr.sin_port);
}
void Socket::connect(const char* filename) {
SBL_ASSERT(is_valid() && is_unix());
struct sockaddr_un addr;
memset(&addr, 0, sizeof(addr));
addr.sun_family = AF_UNIX;
SBL_ASSERT(strlen(filename) < sizeof(addr.sun_path));
strcpy(addr.sun_path, filename);
int len = strlen(addr.sun_path) + sizeof(addr.sun_family);
SBL_PERROR(::connect(id(), (struct sockaddr*) &addr, len) < 0);
}
Socket& Socket::bind(const short int port) {
SBL_ASSERT(is_valid() && !is_unix());
struct sockaddr_in addr;
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = INADDR_ANY;
addr.sin_port = htons(port);
SBL_PERROR(::bind(id(), (struct sockaddr *) &addr, sizeof(addr)) < 0);
return *this;
}
int Socket::recv(void* buffer, int len, char* from_ip, int* from_port) {
SBL_ASSERT(is_valid() && !is_unix());
struct sockaddr_in addr;
socklen_t addr_len = sizeof addr;
int recv = ::recvfrom(id(), buffer, len, 0, (struct sockaddr*) &addr, &addr_len);
SBL_PERROR(recv < 0);
SBL_PERROR(::inet_ntop(AF_INET, &addr.sin_addr, from_ip, IP_ADDR_BUFF_SIZE) == NULL);
if (from_port)
*from_port = ntohs(addr.sin_port);
return recv;
}
void socket_disconnect(struct socket *sk)
{
if (sk->fd > 0) {
trace("%s: %-32s %s", "socket", socket_print(sk),
"disconnected");
close(sk->fd);
sk->fd = -1;
if (is_unix(sk))
unlink(sk->u.un.sun_path);
}
}
Socket& Socket::bind(const char* filename) {
SBL_ASSERT(is_valid() && is_unix());
struct sockaddr_un addr;
memset(&addr, 0, sizeof(addr));
addr.sun_family = AF_UNIX;
SBL_ASSERT(strlen(filename) < sizeof(addr.sun_path));
strcpy(addr.sun_path, filename);
unlink(filename);
int len = strlen(addr.sun_path) + sizeof(addr.sun_family) + 1;
SBL_PERROR(::bind(id(), (struct sockaddr*) &addr, len) < 0);
return *this;
}
void Socket::connect(const char* ip_addr, const short int port) {
SBL_ASSERT(is_valid() && !is_unix());
struct sockaddr_in addr;
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
int status = ::inet_pton(AF_INET, ip_addr, &addr.sin_addr);
if (status == 0)
SBL_THROW("Invalid network address: %s:%d", ip_addr, port);
SBL_PERROR(status != 1);
SBL_PERROR(::connect(id(), (struct sockaddr*) &addr, sizeof(addr)) != 0);
}
void ts_store(struct timestamp *dest, int host_os, unsigned long value)
{
if(host_os==OS_SPECIAL)
dest->dos=dest->unixtime=value;
else if(is_unix(host_os))
{
dest->unixtime=value;
dest->dos=ts_unix2dos(value);
}
else
{
dest->dos=value;
dest->unixtime=ts_dos2unix(value);
}
}
bool Socket::send(const void* buffer, int len, const char* filename, bool abort) {
SBL_ASSERT(is_valid() && is_unix());
SBL_MSG(SBL_MSG_SOCKET, "sending %d bytes, socket %d to %s", len, id(), filename);
if (len < 0)
len = strlen((char*) buffer) + 1;
struct sockaddr_un addr;
memset(&addr, 0, sizeof(addr));
addr.sun_family = AF_UNIX;
SBL_ASSERT(strlen(filename) < sizeof(addr.sun_path));
strcpy(addr.sun_path, filename);
int addr_len = strlen(addr.sun_path) + sizeof(addr.sun_family) + 1;
int sent_bytes = ::sendto(id(), buffer, len, MSG_NOSIGNAL, (struct sockaddr*) &addr, addr_len);
if (sent_bytes != len) {
Exception ex(-1, __PRETTY_FUNCTION__, __FILE__, __LINE__, "Socket %d, send error: ", id());
ex.perror();
if (abort)
throw ex;
return false;
}
return true;
}
bool Socket::send(const void* buffer, int len, const char* ip_addr, int port, bool abort) {
SBL_ASSERT(is_valid() && !is_unix());
SBL_MSG(SBL_MSG_SOCKET, "sending %d bytes, socket %d to %s:%d", len, id(), ip_addr, port);
if (len < 0)
len = strlen((char*) buffer) + 1;
struct sockaddr_in addr;
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
int status = ::inet_pton(AF_INET, ip_addr, &addr.sin_addr);
if (status == 0)
SBL_THROW("Invalid network address: %s:%d", ip_addr, port);
SBL_PERROR(status != 1);
int sent_bytes = ::sendto(id(), buffer, len, MSG_NOSIGNAL, (struct sockaddr*) &addr, sizeof(addr));
if (sent_bytes != len) {
Exception ex(-1, __PRETTY_FUNCTION__, __FILE__, __LINE__, "Socket %d, send error: ", id());
ex.perror();
if (abort)
throw ex;
return false;
}
return true;
}
int
static test2(CSSM_DL_HANDLE dl)
{
int pass = 1;
CSSM_DL_DB_HANDLE dldb = { dl };
/* Case 2 regular create delete then close. */
pass &= ok_status(CSSM_DL_DbCreate(dldb.DLHandle, DBNAME,
NULL /* DbLocation */,
&dbInfo,
CSSM_DB_ACCESS_READ | CSSM_DB_ACCESS_WRITE,
NULL /* CredAndAclEntry */,
NULL /* &openParameters */,
&dldb.DBHandle),
"CSSM_DL_DbCreate");
pass &= ok_status(CSSM_DL_DbDelete(dldb.DLHandle, DBNAME,
NULL /* DbLocation */,
NULL /* AccessCred */), "CSSM_DL_DbDelete");
pass &= ok_status(CSSM_DL_DbClose(dldb), "CSSM_DL_DbClose");
pass &= is_unix(unlink(DBNAME), ENOENT, "unlink");
return pass;
}
void fastrouter_loop() {
int nevents;
int interesting_fd;
int new_connection;
ssize_t len;
int i;
time_t delta;
char bbuf[UMAX16];
char *tcp_port;
char *tmp_socket_name;
int tmp_socket_name_len;
struct uwsgi_subscribe_req usr;
char *magic_table[0xff];
struct uwsgi_rb_timer *min_timeout;
void *events;
struct msghdr msg;
union {
struct cmsghdr cmsg;
char control [CMSG_SPACE (sizeof (int))];
} msg_control;
struct cmsghdr *cmsg;
struct sockaddr_un fr_addr;
socklen_t fr_addr_len = sizeof(struct sockaddr_un);
struct fastrouter_session *fr_session;
struct fastrouter_session *fr_table[2048];
struct iovec iov[2];
int soopt;
socklen_t solen = sizeof(int);
int ufr_subserver = -1;
for(i=0;i<2048;i++) {
fr_table[i] = NULL;
}
ufr.queue = event_queue_init();
struct uwsgi_fastrouter_socket *ufr_sock = ufr.sockets;
while(ufr_sock) {
if (ufr_sock->name[0] == '=') {
int shared_socket = atoi(ufr_sock->name+1);
if (shared_socket >= 0) {
ufr_sock->fd = uwsgi_get_shared_socket_fd_by_num(shared_socket);
if (ufr_sock->fd == -1) {
uwsgi_log("unable to use shared socket %d\n", shared_socket);
}
}
}
else {
tcp_port = strchr(ufr_sock->name, ':');
if (tcp_port) {
ufr_sock->fd = bind_to_tcp(ufr_sock->name, uwsgi.listen_queue, tcp_port);
}
else {
ufr_sock->fd = bind_to_unix(ufr_sock->name, uwsgi.listen_queue, uwsgi.chmod_socket, uwsgi.abstract_socket);
}
}
uwsgi_log("uwsgi fastrouter/proxy bound on %s\n", ufr_sock->name);
if (!ufr.cheap) {
event_queue_add_fd_read(ufr.queue, ufr_sock->fd);
}
else {
uwsgi_log("[uwsgi-fastrouter] cheap mode requested. Waiting for subscriptions...\n");
ufr.i_am_cheap = 1;
}
ufr_sock = ufr_sock->next;
}
events = event_queue_alloc(ufr.nevents);
ufr.timeouts = uwsgi_init_rb_timer();
if (!ufr.socket_timeout) ufr.socket_timeout = 30;
if (ufr.subscription_server) {
ufr_subserver = bind_to_udp(ufr.subscription_server, 0, 0);
event_queue_add_fd_read(ufr.queue, ufr_subserver);
if (!ufr.subscription_slot) ufr.subscription_slot = 30;
// check for node status every 10 seconds
//ufr.subscriptions_check = add_check_timeout(10);
}
if (ufr.pattern) {
init_magic_table(magic_table);
}
for (;;) {
min_timeout = uwsgi_min_rb_timer(ufr.timeouts);
if (min_timeout == NULL ) {
delta = -1;
}
else {
delta = min_timeout->key - time(NULL);
if (delta <= 0) {
expire_timeouts(fr_table);
delta = 0;
}
}
nevents = event_queue_wait_multi(ufr.queue, delta, events, ufr.nevents);
if (nevents == 0) {
expire_timeouts(fr_table);
}
for (i=0;i<nevents;i++) {
tmp_socket_name = NULL;
interesting_fd = event_queue_interesting_fd(events, i);
int taken = 0;
struct uwsgi_fastrouter_socket *uwsgi_sock = ufr.sockets;
while(uwsgi_sock) {
if (interesting_fd == uwsgi_sock->fd) {
new_connection = accept(interesting_fd, (struct sockaddr *) &fr_addr, &fr_addr_len);
if (new_connection < 0) {
continue;
}
fr_table[new_connection] = alloc_fr_session();
fr_table[new_connection]->fd = new_connection;
fr_table[new_connection]->instance_fd = -1;
fr_table[new_connection]->status = FASTROUTER_STATUS_RECV_HDR;
fr_table[new_connection]->h_pos = 0;
fr_table[new_connection]->pos = 0;
fr_table[new_connection]->un = NULL;
fr_table[new_connection]->instance_failed = 0;
fr_table[new_connection]->instance_address_len = 0;
fr_table[new_connection]->hostname_len = 0;
fr_table[new_connection]->hostname = NULL;
fr_table[new_connection]->timeout = add_timeout(fr_table[new_connection]);
event_queue_add_fd_read(ufr.queue, new_connection);
taken = 1;
break;
}
uwsgi_sock = uwsgi_sock->next;
}
if (taken) {
continue;
}
if (interesting_fd == ufr_subserver) {
len = recv(ufr_subserver, bbuf, 4096, 0);
#ifdef UWSGI_EVENT_USE_PORT
event_queue_add_fd_read(ufr.queue, ufr_subserver);
#endif
if (len > 0) {
memset(&usr, 0, sizeof(struct uwsgi_subscribe_req));
uwsgi_hooked_parse(bbuf+4, len-4, fastrouter_manage_subscription, &usr);
if (uwsgi_add_subscribe_node(&ufr.subscriptions, &usr, ufr.subscription_regexp) && ufr.i_am_cheap) {
struct uwsgi_fastrouter_socket *ufr_sock = ufr.sockets;
while(ufr_sock) {
event_queue_add_fd_read(ufr.queue, ufr_sock->fd);
ufr_sock = ufr_sock->next;
}
ufr.i_am_cheap = 0;
uwsgi_log("[uwsgi-fastrouter] leaving cheap mode...\n");
}
}
}
else {
fr_session = fr_table[interesting_fd];
// something is going wrong...
if (fr_session == NULL) continue;
if (event_queue_interesting_fd_has_error(events, i)) {
close_session(fr_table, fr_session);
continue;
}
fr_session->timeout = reset_timeout(fr_session);
switch(fr_session->status) {
case FASTROUTER_STATUS_RECV_HDR:
len = recv(fr_session->fd, (char *)(&fr_session->uh) + fr_session->h_pos, 4-fr_session->h_pos, 0);
if (len <= 0) {
uwsgi_error("recv()");
close_session(fr_table, fr_session);
break;
}
fr_session->h_pos += len;
if (fr_session->h_pos == 4) {
#ifdef UWSGI_DEBUG
uwsgi_log("modifier1: %d pktsize: %d modifier2: %d\n", fr_session->uh.modifier1, fr_session->uh.pktsize, fr_session->uh.modifier2);
#endif
fr_session->status = FASTROUTER_STATUS_RECV_VARS;
}
break;
case FASTROUTER_STATUS_RECV_VARS:
len = recv(fr_session->fd, fr_session->buffer + fr_session->pos, fr_session->uh.pktsize - fr_session->pos, 0);
if (len <= 0) {
uwsgi_error("recv()");
close_session(fr_table, fr_session);
break;
}
fr_session->pos += len;
if (fr_session->pos == fr_session->uh.pktsize) {
if (uwsgi_hooked_parse(fr_session->buffer, fr_session->uh.pktsize, fr_get_hostname, (void *) fr_session)) {
close_session(fr_table, fr_session);
break;
}
if (fr_session->hostname_len == 0) {
close_session(fr_table, fr_session);
break;
}
#ifdef UWSGI_DEBUG
//uwsgi_log("requested domain %.*s\n", fr_session->hostname_len, fr_session->hostname);
#endif
if (ufr.use_cache) {
fr_session->instance_address = uwsgi_cache_get(fr_session->hostname, fr_session->hostname_len, &fr_session->instance_address_len);
char *cs_mod = uwsgi_str_contains(fr_session->instance_address, fr_session->instance_address_len, ',');
if (cs_mod) {
fr_session->modifier1 = uwsgi_str_num(cs_mod+1, (fr_session->instance_address_len - (cs_mod - fr_session->instance_address))-1);
fr_session->instance_address_len = (cs_mod - fr_session->instance_address);
}
}
else if (ufr.pattern) {
magic_table['s'] = uwsgi_concat2n(fr_session->hostname, fr_session->hostname_len, "", 0);
tmp_socket_name = magic_sub(ufr.pattern, ufr.pattern_len, &tmp_socket_name_len, magic_table);
free(magic_table['s']);
fr_session->instance_address_len = tmp_socket_name_len;
fr_session->instance_address = tmp_socket_name;
}
else if (ufr.subscription_server) {
fr_session->un = uwsgi_get_subscribe_node(&ufr.subscriptions, fr_session->hostname, fr_session->hostname_len, ufr.subscription_regexp);
if (fr_session->un && fr_session->un->len) {
fr_session->instance_address = fr_session->un->name;
fr_session->instance_address_len = fr_session->un->len;
fr_session->modifier1 = fr_session->un->modifier1;
}
}
else if (ufr.base) {
tmp_socket_name = uwsgi_concat2nn(ufr.base, ufr.base_len, fr_session->hostname, fr_session->hostname_len, &tmp_socket_name_len);
fr_session->instance_address_len = tmp_socket_name_len;
fr_session->instance_address = tmp_socket_name;
}
else if (ufr.code_string_code && ufr.code_string_function) {
if (uwsgi.p[ufr.code_string_modifier1]->code_string) {
fr_session->instance_address = uwsgi.p[ufr.code_string_modifier1]->code_string("uwsgi_fastrouter", ufr.code_string_code, ufr.code_string_function, fr_session->hostname, fr_session->hostname_len);
if (fr_session->instance_address) {
fr_session->instance_address_len = strlen(fr_session->instance_address);
char *cs_mod = uwsgi_str_contains(fr_session->instance_address, fr_session->instance_address_len, ',');
if (cs_mod) {
fr_session->modifier1 = uwsgi_str_num(cs_mod+1, (fr_session->instance_address_len - (cs_mod - fr_session->instance_address))-1);
fr_session->instance_address_len = (cs_mod - fr_session->instance_address);
}
}
}
}
// no address found
if (!fr_session->instance_address_len) {
close_session(fr_table, fr_session);
break;
}
fr_session->pass_fd = is_unix(fr_session->instance_address, fr_session->instance_address_len);
fr_session->instance_fd = uwsgi_connectn(fr_session->instance_address, fr_session->instance_address_len, 0, 1);
if (tmp_socket_name) free(tmp_socket_name);
if (fr_session->instance_fd < 0) {
/*
if (ufr.subscription_server) {
if (fr_session->un && fr_session->un->len > 0) {
uwsgi_log("[uwsgi-fastrouter] %.*s => marking %.*s as failed\n", (int) fr_session->hostname_len, fr_session->hostname, (int) fr_session->instance_address_len,fr_session->instance_address);
uwsgi_remove_subscribe_node(&ufr.subscriptions, fr_session->un);
if (ufr.subscriptions == NULL && ufr.cheap && !ufr.i_am_cheap) {
uwsgi_log("[uwsgi-fastrouter] no more nodes available. Going cheap...\n");
struct uwsgi_fastrouter_socket *ufr_sock = ufr.sockets;
while(ufr_sock) {
event_queue_del_fd(ufr.queue, ufr_sock->fd, event_queue_read());
ufr_sock = ufr_sock->next;
}
ufr.i_am_cheap = 1;
}
}
}
*/
fr_session->instance_failed = 1;
close_session(fr_table, fr_session);
break;
}
fr_session->status = FASTROUTER_STATUS_CONNECTING;
fr_table[fr_session->instance_fd] = fr_session;
event_queue_add_fd_write(ufr.queue, fr_session->instance_fd);
}
break;
case FASTROUTER_STATUS_CONNECTING:
if (interesting_fd == fr_session->instance_fd) {
if (getsockopt(fr_session->instance_fd, SOL_SOCKET, SO_ERROR, (void *) (&soopt), &solen) < 0) {
uwsgi_error("getsockopt()");
fr_session->instance_failed = 1;
close_session(fr_table, fr_session);
break;
}
if (soopt) {
uwsgi_log("unable to connect() to uwsgi instance: %s\n", strerror(soopt));
fr_session->instance_failed = 1;
close_session(fr_table, fr_session);
break;
}
fr_session->uh.modifier1 = fr_session->modifier1;
iov[0].iov_base = &fr_session->uh;
iov[0].iov_len = 4;
iov[1].iov_base = fr_session->buffer;
iov[1].iov_len = fr_session->uh.pktsize;
// increment node requests counter
if (fr_session->un)
fr_session->un->requests++;
// fd passing: PERFORMANCE EXTREME BOOST !!!
if (fr_session->pass_fd && !uwsgi.no_fd_passing) {
msg.msg_name = NULL;
msg.msg_namelen = 0;
msg.msg_iov = iov;
msg.msg_iovlen = 2;
msg.msg_flags = 0;
msg.msg_control = &msg_control;
msg.msg_controllen = sizeof (msg_control);
cmsg = CMSG_FIRSTHDR (&msg);
cmsg->cmsg_len = CMSG_LEN (sizeof (int));
cmsg->cmsg_level = SOL_SOCKET;
cmsg->cmsg_type = SCM_RIGHTS;
memcpy(CMSG_DATA(cmsg), &fr_session->fd, sizeof(int));
if (sendmsg(fr_session->instance_fd, &msg, 0) < 0) {
uwsgi_error("sendmsg()");
}
close_session(fr_table, fr_session);
break;
}
if (writev(fr_session->instance_fd, iov, 2) < 0) {
uwsgi_error("writev()");
close_session(fr_table, fr_session);
break;
}
event_queue_fd_write_to_read(ufr.queue, fr_session->instance_fd);
fr_session->status = FASTROUTER_STATUS_RESPONSE;
}
break;
case FASTROUTER_STATUS_RESPONSE:
// data from instance
if (interesting_fd == fr_session->instance_fd) {
len = recv(fr_session->instance_fd, fr_session->buffer, 0xffff, 0);
if (len <= 0) {
if (len < 0) uwsgi_error("recv()");
close_session(fr_table, fr_session);
break;
}
len = send(fr_session->fd, fr_session->buffer, len, 0);
if (len <= 0) {
if (len < 0) uwsgi_error("send()");
close_session(fr_table, fr_session);
break;
}
// update transfer statistics
if (fr_session->un)
fr_session->un->transferred += len;
}
// body from client
else if (interesting_fd == fr_session->fd) {
//uwsgi_log("receiving body...\n");
len = recv(fr_session->fd, fr_session->buffer, 0xffff, 0);
if (len <= 0) {
if (len < 0) uwsgi_error("recv()");
close_session(fr_table, fr_session);
break;
}
len = send(fr_session->instance_fd, fr_session->buffer, len, 0);
if (len <= 0) {
if (len < 0) uwsgi_error("send()");
close_session(fr_table, fr_session);
break;
}
}
break;
// fallback to destroy !!!
default:
uwsgi_log("unknown event: closing session\n");
close_session(fr_table, fr_session);
break;
}
}
}
}
}
void corerouter_close_session(struct uwsgi_corerouter *ucr, struct corerouter_session *cr_session) {
if (cr_session->instance_fd != -1) {
close(cr_session->instance_fd);
ucr->cr_table[cr_session->instance_fd] = NULL;
}
if (ucr->subscriptions && cr_session->un && cr_session->un->len > 0) {
// decrease reference count
#ifdef UWSGI_DEBUG
uwsgi_log("[1] node %.*s refcnt: %llu\n", cr_session->un->len, cr_session->un->name, cr_session->un->reference);
#endif
cr_session->un->reference--;
#ifdef UWSGI_DEBUG
uwsgi_log("[2] node %.*s refcnt: %llu\n", cr_session->un->len, cr_session->un->name, cr_session->un->reference);
#endif
}
if (cr_session->instance_failed) {
if (cr_session->soopt) {
if (!ucr->quiet)
uwsgi_log("unable to connect() to uwsgi instance \"%.*s\": %s\n", (int) cr_session->instance_address_len, cr_session->instance_address, strerror(cr_session->soopt));
}
else if (cr_session->timed_out) {
if (cr_session->instance_address_len > 0) {
if (cr_session->status == COREROUTER_STATUS_CONNECTING) {
if (!ucr->quiet)
uwsgi_log("unable to connect() to uwsgi instance \"%.*s\": timeout\n", (int) cr_session->instance_address_len, cr_session->instance_address);
}
else if (cr_session->status == COREROUTER_STATUS_RESPONSE) {
uwsgi_log("timeout waiting for instance \"%.*s\"\n", (int) cr_session->instance_address_len, cr_session->instance_address);
}
}
}
// now check for dead nodes
if (ucr->subscriptions && cr_session->un && cr_session->un->len > 0) {
if (cr_session->un->death_mark == 0)
uwsgi_log("[uwsgi-%s] %.*s => marking %.*s as failed\n", ucr->short_name, (int) cr_session->hostname_len, cr_session->hostname, (int) cr_session->instance_address_len, cr_session->instance_address);
cr_session->un->failcnt++;
cr_session->un->death_mark = 1;
// check if i can remove the node
if (cr_session->un->reference == 0) {
uwsgi_remove_subscribe_node(ucr->subscriptions, cr_session->un);
}
if (ucr->cheap && !ucr->i_am_cheap && !ucr->fallback && uwsgi_no_subscriptions(ucr->subscriptions)) {
uwsgi_gateway_go_cheap(ucr->name, ucr->queue, &ucr->i_am_cheap);
}
}
else if (cr_session->static_node) {
cr_session->static_node->custom = uwsgi_now();
uwsgi_log("[uwsgi-%s] %.*s => marking %.*s as failed\n", ucr->short_name, (int) cr_session->hostname_len, cr_session->hostname, (int) cr_session->instance_address_len, cr_session->instance_address);
}
if (cr_session->tmp_socket_name) {
free(cr_session->tmp_socket_name);
cr_session->tmp_socket_name = NULL;
}
if (ucr->fallback) {
// ok let's try with the fallback nodes
if (!cr_session->fallback) {
cr_session->fallback = ucr->fallback;
}
else {
cr_session->fallback = cr_session->fallback->next;
if (!cr_session->fallback) goto end;
}
cr_session->instance_address = cr_session->fallback->value;
cr_session->instance_address_len = cr_session->fallback->len;
// reset error and timeout
cr_session->timeout = corerouter_reset_timeout(ucr, cr_session);
cr_session->timed_out = 0;
cr_session->soopt = 0;
// reset nodes
cr_session->un = NULL;
cr_session->static_node = NULL;
cr_session->pass_fd = is_unix(cr_session->instance_address, cr_session->instance_address_len);
cr_session->instance_fd = uwsgi_connectn(cr_session->instance_address, cr_session->instance_address_len, 0, 1);
if (cr_session->instance_fd < 0) {
cr_session->instance_failed = 1;
cr_session->soopt = errno;
corerouter_close_session(ucr, cr_session);
return;
}
ucr->cr_table[cr_session->instance_fd] = cr_session;
cr_session->status = COREROUTER_STATUS_CONNECTING;
ucr->cr_table[cr_session->instance_fd] = cr_session;
event_queue_add_fd_write(ucr->queue, cr_session->instance_fd);
return;
}
}
end:
if (cr_session->tmp_socket_name) {
free(cr_session->tmp_socket_name);
}
if (cr_session->buf_file)
fclose(cr_session->buf_file);
if (cr_session->buf_file_name) {
if (unlink(cr_session->buf_file_name)) {
uwsgi_error("unlink()");
}
free(cr_session->buf_file_name);
}
// could be used to free additional resources
if (cr_session->close)
cr_session->close(ucr, cr_session);
if (cr_session->keepalive) {
cr_session->keepalive = 0;
return;
}
close(cr_session->fd);
ucr->cr_table[cr_session->fd] = NULL;
cr_del_timeout(ucr, cr_session);
free(cr_session);
}
unsigned int fm_native(struct file_mode *fm, int host_os)
{
return(is_unix(host_os)?fm->native:fm->dos);
}
unsigned long ts_native(struct timestamp *ts, int host_os)
{
return(is_unix(host_os)?ts->unixtime:ts->dos);
}
