gearman_server_con_st *gearman_server_con_add(gearman_server_thread_st *thread,
int fd, void *data)
{
gearman_server_con_st *con;
gearman_return_t ret;
con= gearman_server_con_create(thread);
if (con == NULL)
return NULL;
if (gearman_con_set_fd(&(con->con), fd) != GEARMAN_SUCCESS)
{
gearman_server_con_free(con);
return NULL;
}
con->con.data= data;
ret= gearman_con_set_events(&(con->con), POLLIN);
if (ret != GEARMAN_SUCCESS)
{
gearman_server_con_free(con);
return NULL;
}
return con;
}
void gearman_server_thread_free(gearman_server_thread_st *thread)
{
gearman_server_con_st *con;
gearman_server_packet_st *packet;
_proc_thread_kill(thread->server);
while (thread->con_list != NULL)
gearman_server_con_free(thread->con_list);
while (thread->free_con_list != NULL)
{
con= thread->free_con_list;
thread->free_con_list= con->next;
free(con);
}
while (thread->free_packet_list != NULL)
{
packet= thread->free_packet_list;
thread->free_packet_list= packet->next;
free(packet);
}
if (thread->gearman != NULL)
gearman_universal_free(thread->gearman);
pthread_mutex_destroy(&(thread->lock));
GEARMAN_LIST_DEL(thread->server->thread, thread,)
if (thread->options.allocated)
free(thread);
}
void gearman_server_thread_free(gearman_server_thread_st *thread)
{
_proc_thread_kill(Server);
while (thread->con_list != NULL)
{
gearman_server_con_free(thread->con_list);
}
while (thread->free_con_list != NULL)
{
gearman_server_con_st *con= thread->free_con_list;
thread->free_con_list= con->next;
destroy_gearman_server_con_st(con);
}
while (thread->free_packet_list != NULL)
{
gearman_server_packet_st *packet= thread->free_packet_list;
thread->free_packet_list= packet->next;
destroy_gearman_server_packet_st(packet);
}
if (thread->gearman != NULL)
{
gearman_connection_list_free(thread->gearman);
}
pthread_mutex_destroy(&(thread->lock));
GEARMAN_LIST_DEL(Server->thread, thread,)
}
static gearmand_error_t _con_add(gearmand_thread_st *thread,
gearmand_con_st *dcon)
{
gearmand_error_t ret= GEARMAN_SUCCESS;
dcon->server_con= gearman_server_con_add(&(thread->server_thread), dcon, &ret);
assert(dcon->server_con || ret != GEARMAN_SUCCESS);
assert(! dcon->server_con || ret == GEARMAN_SUCCESS);
if (dcon->server_con == NULL)
{
gearmand_sockfd_close(dcon->fd);
return ret;
}
if (dcon->add_fn)
{
ret= (*dcon->add_fn)(dcon->server_con);
if (gearmand_failed(ret))
{
gearman_server_con_free(dcon->server_con);
gearmand_sockfd_close(dcon->fd);
return ret;
}
}
GEARMAN_LIST_ADD(thread->dcon, dcon,)
return GEARMAN_SUCCESS;
}
gearman_server_con_st *gearman_server_con_add(gearman_server_thread_st *thread, gearmand_con_st *dcon, gearmand_error_t *ret)
{
gearman_server_con_st *con= _server_con_create(thread, dcon, ret);
if (con == NULL)
{
return NULL;
}
if ((*ret= gearman_io_set_fd(&(con->con), dcon->fd)) != GEARMAN_SUCCESS)
{
gearman_server_con_free(con);
return NULL;
}
*ret= gearmand_io_set_events(con, POLLIN);
if (*ret != GEARMAN_SUCCESS)
{
gearmand_gerror("gearmand_io_set_events", *ret);
gearman_server_con_free(con);
return NULL;
}
return con;
}
gearman_server_con_st *
gearman_server_thread_run(gearman_server_thread_st *thread,
gearman_return_t *ret_ptr)
{
gearman_connection_st *con;
gearman_server_con_st *server_con;
/* If we are multi-threaded, we may have packets to flush or connections that
should start reading again. */
if (thread->server->flags.threaded)
{
while ((server_con= gearman_server_con_io_next(thread)) != NULL)
{
if (server_con->is_dead)
{
if (server_con->proc_removed)
gearman_server_con_free(server_con);
continue;
}
if (server_con->ret != GEARMAN_SUCCESS)
{
*ret_ptr= server_con->ret;
return server_con;
}
/* See if any outgoing packets were queued. */
*ret_ptr= _thread_packet_flush(server_con);
if (*ret_ptr != GEARMAN_SUCCESS && *ret_ptr != GEARMAN_IO_WAIT)
return server_con;
}
}
/* Check for new activity on connections. */
while ((con= gearman_ready(thread->gearman)) != NULL)
{
/* Inherited classes anyone? Some people would call this a hack, I call
it clean (avoids extra ptrs). Brian, I'll give you your C99 0-byte
arrays at the ends of structs for this. :) */
server_con= (gearman_server_con_st *)con;
/* Try to read new packets. */
if (con->revents & POLLIN)
{
*ret_ptr= _thread_packet_read(server_con);
if (*ret_ptr != GEARMAN_SUCCESS && *ret_ptr != GEARMAN_IO_WAIT)
return server_con;
}
/* Flush existing outgoing packets. */
if (con->revents & POLLOUT)
{
*ret_ptr= _thread_packet_flush(server_con);
if (*ret_ptr != GEARMAN_SUCCESS && *ret_ptr != GEARMAN_IO_WAIT)
return server_con;
}
}
/* Start flushing new outgoing packets if we are single threaded. */
if (! (thread->server->flags.threaded))
{
while ((server_con= gearman_server_con_io_next(thread)) != NULL)
{
*ret_ptr= _thread_packet_flush(server_con);
if (*ret_ptr != GEARMAN_SUCCESS && *ret_ptr != GEARMAN_IO_WAIT)
return server_con;
}
}
/* Check for the two shutdown modes. */
if (thread->server->shutdown)
*ret_ptr= GEARMAN_SHUTDOWN;
else if (thread->server->shutdown_graceful)
{
if (thread->server->job_count == 0)
*ret_ptr= GEARMAN_SHUTDOWN;
else
*ret_ptr= GEARMAN_SHUTDOWN_GRACEFUL;
}
else
*ret_ptr= GEARMAN_SUCCESS;
return NULL;
}
gearmand_con_st *
gearman_server_thread_run(gearman_server_thread_st *thread,
gearmand_error_t *ret_ptr)
{
/* If we are multi-threaded, we may have packets to flush or connections that
should start reading again. */
if (Server->flags.threaded)
{
gearman_server_con_st *server_con;
while ((server_con= gearman_server_con_to_be_freed_next(thread)) != NULL)
{
if (server_con->is_dead && server_con->proc_removed)
gearman_server_con_free(server_con);
else
gearmand_log_error(GEARMAN_DEFAULT_LOG_PARAM, "con %llu isn't dead %d or proc removed %d, but is in to_be_freed_list",
server_con, server_con->is_dead, server_con->proc_removed);
}
while ((server_con= gearman_server_con_io_next(thread)) != NULL)
{
if (server_con->is_dead)
{
gearman_server_con_attempt_free(server_con);
continue;
}
if (server_con->ret != GEARMAN_SUCCESS)
{
*ret_ptr= server_con->ret;
return gearman_server_con_data(server_con);
}
/* See if any outgoing packets were queued. */
*ret_ptr= _thread_packet_flush(server_con);
if (*ret_ptr != GEARMAN_SUCCESS && *ret_ptr != GEARMAN_IO_WAIT)
{
return gearman_server_con_data(server_con);
}
}
}
/* Check for new activity on connections. */
{
gearman_server_con_st *server_con;
while ((server_con= gearmand_ready(thread->gearman)))
{
/* Try to read new packets. */
if (server_con->con.revents & POLLIN)
{
*ret_ptr= _thread_packet_read(server_con);
if (*ret_ptr != GEARMAN_SUCCESS && *ret_ptr != GEARMAN_IO_WAIT)
return gearman_server_con_data(server_con);
}
/* Flush existing outgoing packets. */
if (server_con->con.revents & POLLOUT)
{
*ret_ptr= _thread_packet_flush(server_con);
if (*ret_ptr != GEARMAN_SUCCESS && *ret_ptr != GEARMAN_IO_WAIT)
{
return gearman_server_con_data(server_con);
}
}
}
}
/* Start flushing new outgoing packets if we are single threaded. */
if (! (Server->flags.threaded))
{
gearman_server_con_st *server_con;
while ((server_con= gearman_server_con_io_next(thread)))
{
*ret_ptr= _thread_packet_flush(server_con);
if (*ret_ptr != GEARMAN_SUCCESS && *ret_ptr != GEARMAN_IO_WAIT)
{
return gearman_server_con_data(server_con);
}
}
}
/* Check for the two shutdown modes. */
if (Server->shutdown)
{
*ret_ptr= GEARMAN_SHUTDOWN;
}
else if (Server->shutdown_graceful)
{
if (Server->job_count == 0)
{
*ret_ptr= GEARMAN_SHUTDOWN;
}
else
{
*ret_ptr= GEARMAN_SHUTDOWN_GRACEFUL;
}
}
else
{
*ret_ptr= GEARMAN_SUCCESS;
}
return NULL;
}
