static int
start_unix_server(GError **error)
{
struct sockaddr_un local;
worker_data_t wdata;
memset(&wdata, 0x00, sizeof(wdata));
memset(&local, 0x00, sizeof(local));
memset(&worker_unix, 0, sizeof(worker_t));
/* Create ressources to monitor */
sock_unix = socket_nonblock(PF_UNIX, SOCK_STREAM, 0);
if (sock_unix < 0) {
GSETERROR(error, "Failed to create socket : %s", strerror(errno));
return(0);
}
/* Bind to file */
local.sun_family = AF_UNIX;
g_strlcpy(local.sun_path, unix_socket_path, sizeof(local.sun_path)-1);
if (-1 == bind(sock_unix, (struct sockaddr *)&local, sizeof(local))) {
GSETERROR(error, "Failed to bind socket %d to file %s : %s",
sock_unix, unix_socket_path, strerror(errno));
metautils_pclose(&sock_unix);
return(0);
}
/* Listen on that socket */
if (-1 == listen(sock_unix, unix_socket_backlog)) {
GSETERROR(error, "Failed to listen on socket %d : %s", sock_unix, strerror(errno));
metautils_pclose(&sock_unix);
return(0);
}
if (!set_unix_permissions(unix_socket_path, error)) {
GSETERROR(error, "Failed to set proper permissions on socket %d", sock_unix);
metautils_pclose(&sock_unix);
return(0);
}
/* Create worker */
wdata.fd = sock_unix;
wdata.sock_timeout = unix_socket_timeout;
worker_unix.func = accept_worker;
worker_unix.timeout.startup = 0;
worker_unix.timeout.activity = 0;
memcpy(&(worker_unix.data), &wdata, sizeof(worker_data_t));
/* Accept new connection */
if (!add_fd_to_io_scheduler(&worker_unix, EPOLLIN, error)) {
GSETERROR(error,"Failed to add server sock to io_scheduler");
metautils_pclose(&sock_unix);
return 0;
}
INFO("UNIX server started on socket %s", unix_socket_path);
return(1);
}
int
http_request_worker(worker_t *worker, GError **error)
{
int fd;
worker_data_t *data = NULL;
http_session_t *http_session = NULL;
TRACE("Executing http_request worker");
data = &(worker->data);
http_session = (http_session_t*)data->session;
if (0 > (fd = addrinfo_connect_nopoll(http_session->addr, 1000, error))) {
GSETERROR(error, "Connection to HTTP server failed");
goto error;
}
worker->func = write_request;
worker->data.fd = fd;
if (!add_fd_to_io_scheduler(worker, EPOLLOUT, error)) {
GSETERROR(error, "Failed to add socket to io_scheduler");
goto error;
}
return(1);
error:
return(0);
}
static int
start_inet_server(GError **error)
{
struct sockaddr_in sin;
worker_data_t wdata;
DEBUG("Starting an INET server bond on 127.0.0.1:%d", inet_socket_port);
memset(&wdata, 0x00, sizeof(wdata));
memset(&worker_inet, 0, sizeof(worker_t));
/* Create ressources to monitor */
sock_inet = socket_nonblock(PF_INET, SOCK_STREAM, 0);
if (sock_inet < 0) {
GSETERROR(error, "Failed to create socket : %s", strerror(errno));
return(0);
}
sock_set_reuseaddr(sock_inet, TRUE);
/* Bind to file */
memset(&sin, 0x00, sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_port = htons(inet_socket_port);
if (!inet_aton("127.0.0.1", &(sin.sin_addr))) {
GSETERROR(error,"Invalid address : 127.0.0.1 !!!");
return 0;
}
if (-1 == bind(sock_inet, (struct sockaddr *)&sin, sizeof(sin))) {
GSETERROR(error, "Failed to bind socket [%d] to address 127.0.0.1 : %s", sock_inet, strerror(errno));
return(0);
}
/* Listen on that socket */
if (-1 == listen(sock_inet, inet_socket_backlog)) {
GSETERROR(error, "Failed to listen on socket [%d] : %s", sock_inet, strerror(errno));
return(0);
}
/* Create worker */
wdata.fd = sock_inet;
wdata.sock_timeout = inet_socket_timeout;
worker_inet.func = accept_worker;
worker_inet.timeout.startup = 0;
worker_inet.timeout.activity = 0;
memcpy(&(worker_inet.data), &wdata, sizeof(worker_data_t));
/* Accept new connection */
if (!add_fd_to_io_scheduler(&worker_inet, EPOLLIN, error)) {
GSETERROR(error,"Failed to add server sock to io_scheduler");
return 0;
}
INFO("INET server started on socket fd=%d 127.0.0.1:%d",
sock_inet, inet_socket_port);
return(1);
}
/**
* Check the service still exists and start a worker that will
* just perform a TCP-connect test.
*/
static int
_check_tcp_service_task(gpointer udata, GError **error)
{
struct service_info_s *si;
struct namespace_data_s *ns_data;
struct taskdata_checksrv_s *task_data;
task_data = udata;
ns_data = g_hash_table_lookup(namespaces, task_data->ns_name);
if (!ns_data) {
task_done(task_data->task_name);
GSETERROR(error, "Namespace unavailable");
return 0;
}
/* if the service does not exists, the task itself is de-scheduled */
if (!(si=g_hash_table_lookup(ns_data->local_services, task_data->srv_key))
&& !(si=g_hash_table_lookup(ns_data->down_services, task_data->srv_key))) {
task_done(task_data->task_name);
task_stop(task_data->task_name);
INFO("Service [%s] does not exist, stopping task [%s]", task_data->srv_key, task_data->task_name);
return 1;
}
/* Now start a worker for this service. The worker has its own session_data,
* without hard reference to the task_t or the namespace_data_t */
do {
int fd = addrinfo_connect_nopoll(&(si->addr), 1000, error);
if (0 > fd) {
GSETERROR(error, "Connection to gridd server failed : (%d) %s",
errno, strerror(errno));
return 0;
}
sock_set_linger(fd, 1, 0);
struct workerdata_checksrv_s *wdata = g_malloc0(sizeof(*wdata));
g_strlcpy(wdata->task_name, task_data->task_name, sizeof(wdata->task_name)-1);
g_strlcpy(wdata->ns_name, task_data->ns_name, sizeof(wdata->ns_name)-1);
g_strlcpy(wdata->srv_key, task_data->srv_key, sizeof(wdata->srv_key)-1);
worker_t *worker = g_malloc0(sizeof(worker_t));
worker->func = _check_tcp_service_worker_func;
worker->clean = _check_tcp_service_worker_cleaner;
worker->timeout.startup = 1000;
worker->timeout.activity = 1000;
worker->data.sock_timeout = 1000;
worker->data.fd = fd;
worker->data.session = wdata;
if (!add_fd_to_io_scheduler(worker, EPOLLOUT, error)) {
_mark_service_state(task_data->ns_name, wdata->srv_key, FALSE);
task_done(task_data->task_name);
g_free(worker);
g_free(wdata);
GSETERROR(error, "Failed to add socket fd=%d to io_scheduler : %s", fd, strerror(errno));
return 0;
}
TRACE("TCP-connect tried to [%s] for [%s] (fd=%d)", task_data->srv_key, task_data->task_name, fd);
} while (0);
return 1;
}
