Beispiel #1
0
static void
libev_ctx_del(void *ctx, const verto_ev *ev, void *evpriv)
{
    switch (verto_get_type(ev)) {
        case VERTO_EV_TYPE_IO:
            ev_io_stop(ctx, evpriv);
            break;
        case VERTO_EV_TYPE_TIMEOUT:
            ev_timer_stop(ctx, evpriv);
            break;
        case VERTO_EV_TYPE_IDLE:
            ev_idle_stop(ctx, evpriv);
            break;
        case VERTO_EV_TYPE_SIGNAL:
            ev_signal_stop(ctx, evpriv);
            break;
        case VERTO_EV_TYPE_CHILD:
            ev_child_stop(ctx, evpriv);
            break;
        default:
            break;
    }

    free(evpriv);
}
Beispiel #2
0
static void mon_child_cb(struct ev_loop* loop, ev_child* w, int revents V_UNUSED) {
    dmn_assert(loop); dmn_assert(w); dmn_assert(revents == EV_CHILD);

    ev_child_stop(loop, w); // always single-shot

    mon_t* this_mon = w->data;
    ev_timer_stop(loop, this_mon->cmd_timeout);
    this_mon->cmd_pid = 0;

    bool failed = true;
    int status = w->rstatus;
    if(WIFEXITED(status)) {
        if(!WEXITSTATUS(status))
           failed = false;
    }
    else {
        if(WIFSIGNALED(status))
            dmn_log_warn("Monitor child process for '%s' terminated by signal %u", this_mon->cmd->desc, WTERMSIG(status));
        else
            dmn_log_warn("Monitor child process for '%s' terminated abnormally...", this_mon->cmd->desc);
    }

    // If timeout already sent a failure, don't double-send
    //   here when we reap the SIGKILL'd child
    if(this_mon->result_pending) {
        if(!killed_by) {
            sendq_enq(emc_encode_mon(this_mon->cmd->idx, failed));
            ev_io_start(loop, plugin_write_watcher);
        }
        if (num_proc > 0) {
            num_proc--;
        }
        this_mon->result_pending = false;
    }
}
Beispiel #3
0
// Report that a child has exited
void child_cb(EV_P_ ev_child *w, int revents)
{
	char str[100];
	char format[] = 
	    "{\"processTerminated\" : "
	    "    {\"pid\" : %d, \"returnCode\" : %d, \"bySignal\" : %d, \"endTime\" : %ld }}";

	struct timeval tp;
	gettimeofday(&tp, NULL);
	long int time = (long int) tp.tv_sec * 1000 + tp.tv_usec;

	sprintf(str, format, w->rpid, WEXITSTATUS(w->rstatus), WSTOPSIG(w->rstatus), time);
	socket_t *s = w->data;

	ev_child_stop (EV_A_ w);

	frame_t *frame = malloc(sizeof(frame_t));
	frame->fin = 1;
	frame->opcode = WS_OP_BIN;
	frame->len = strlen(str);
	frame->payload = str;
	
	int fr_len;
	char *fr_str = write_frame(frame, &fr_len);
	socket_write(s, fr_str, fr_len);
	free(frame);
	free(fr_str);

	ilist_remove(processes, w->rpid);
}
Beispiel #4
0
static void child_cb(EV_P_ ev_child *w, int revents) {
    ev_child_stop(EV_A_ w);
    if (WIFEXITED(w->rstatus)) {
        exit(WEXITSTATUS(w->rstatus));
    } else {
        exit(WTERMSIG(w->rstatus) + 128);
    }
}
Beispiel #5
0
/**
 * Stops the child so it won't be called by the specified event loop.
 *
 * Usage:
 *     child:stop(loop)
 *
 * [+0, -0, e]
 */
static int child_stop(lua_State *L) {
    ev_child*       child  = check_child(L, 1);
    struct ev_loop* loop = *check_loop_and_init(L, 2);

    loop_stop_watcher(L, loop, GET_WATCHER_DATA(child), 1);
    ev_child_stop(loop, child);

    return 0;
}
Beispiel #6
0
Datei: core.c Projekt: ifzz/lem
static int
signal_child_unwatch(lua_State *T)
{
	if (signal_child_active()) {
		ev_ref(LEM);
		ev_child_stop(LEM_ &signal_child_watcher);
	}
	lua_pushboolean(T, 1);
	return 1;
}
Beispiel #7
0
/*
 * Handler which will be called when we get a SIGCHLD for the nagbar, meaning
 * it exited (or could not be started, depending on the exit code).
 *
 */
static void nagbar_exited(EV_P_ ev_child *watcher, int revents) {
    ev_child_stop(EV_A_ watcher);

    if (!WIFEXITED(watcher->rstatus)) {
        ELOG("ERROR: i3-nagbar did not exit normally.\n");
        return;
    }

    int exitcode = WEXITSTATUS(watcher->rstatus);
    DLOG("i3-nagbar process exited with status %d\n", exitcode);
    if (exitcode == 2) {
        ELOG("ERROR: i3-nagbar could not be found. Is it correctly installed on your system?\n");
    }

    *((pid_t *)watcher->data) = -1;
}
Beispiel #8
0
static void event_child_cb(struct ev_loop *loop, ev_child *w, int revents) {
	liEventChild *child = LI_CONTAINER_OF(w, liEventChild, libevmess.child);
	liEventLoop *my_loop = child->base.link_watchers.data;
	UNUSED(revents);

	LI_FORCE_ASSERT(NULL != my_loop);
	LI_FORCE_ASSERT(loop == my_loop->loop);

	if (ev_is_active(w)) {
		if (!child->base.keep_loop_alive) ev_ref(loop);
		ev_child_stop(loop, w);
	}
	child->base.active = 0;

	child->base.callback(&child->base, LI_EV_WAKEUP);
}
Beispiel #9
0
static void
worker_exited_cb(EV_P_ ev_child *w, int revents)
{
    struct worker *worker = CONTAINER_OF(w, struct worker, child_watcher);

    LOGF(3, "=== %d: worker ended, status=%d\n", worker_pid(worker),
         w->rstatus);

    ev_child_stop(EV_A_ w);
    worker->f_alive = false;

    if (worker->session == NULL) {
        printf("WARNING: worker without session!\n");
        return;
    }

    session_on_worker_exited_cb(EV_A_ worker->session, w->rstatus);
}
Beispiel #10
0
static void child_died(struct ev_loop *loop, ev_child *w, int revents) {
	child *c = (child*) w->data;
	UNUSED(revents);

	ev_child_stop(loop, w);
	c->d->running--;
	c->pid = -1;

	if (c->d->shutdown) return;

	if (ev_now(c->d->loop) - c->last_spawn > (opts.retry_timeout_ms / (ev_tstamp) 1000)) {
		g_printerr("Child[%i] died, respawn\n", c->id);
		c->tries = 0;
	} else {
		g_printerr("Spawning child[%i] failed, next try\n", c->id);
	}

	spawn(c);
}
Beispiel #11
0
void child_proc_cb(EV_P_ ev_child *watcher, int revents) {
  ev_child_stop(EV_A_ watcher);
  process_t *process = watcher->data;
  struct proc_data *procdata = process->data;

  pn_proc_exited(process, watcher->rstatus);
  printf("process %s[%d] - ", pn_proc_program(process)->name, 
         pn_proc_pid(process));
  pn_proc_print(stdout, process, 0, 0);

  //publish_proc_event(process, "exited");
  if (procdata->running_state_timer != NULL) {
    ev_timer_stop(EV_A_ (ev_timer *)procdata->running_state_timer);
    free(procdata->running_state_timer);
    //running_state_timer_cb(EV_A_ procdata->running_state_timer, 0);
  }

  restart_child(process, 2.0);
  /* We allocate a new watcher for each pid, so this one is done. */
  free(watcher);
} /* child_proc_cb */
Beispiel #12
0
static void uv__chld(EV_P_ ev_child* watcher, int revents) {
  int status = watcher->rstatus;
  int exit_status = 0;
  int term_signal = 0;
  uv_process_t *process = watcher->data;

  assert(&process->child_watcher == watcher);
  assert(revents & EV_CHILD);

  ev_child_stop(EV_A_ &process->child_watcher);

  if (WIFEXITED(status)) {
    exit_status = WEXITSTATUS(status);
  }

  if (WIFSIGNALED(status)) {
    term_signal = WTERMSIG(status);
  }

  if (process->exit_cb) {
    process->exit_cb((uv_handle_t *)process, exit_status, term_signal);
  }
}
Beispiel #13
0
void
worker_stop(EV_P_ struct worker *worker)
{
    LOGF(3, "=== %d: worker stopped\n", worker_pid(worker));

    if (worker->f_alive) {
        LOGF(1, "=== %d: worker still alive - sending SIGKILL\n",
             worker_pid(worker));
        kill(worker_pid(worker), SIGKILL);
    }
    writeq_uninit(&worker->stdin_writeq);
    writeq_uninit(&worker->msgin_writeq);
    if (ev_is_active(&worker->child_watcher)) {
        ev_child_stop(EV_A_ &worker->child_watcher);
    }
    if (ev_is_active(&worker->stdin_w)) {
        ev_io_stop(EV_A_ &worker->stdin_w);
    }
    if (ev_is_active(&worker->stdout_w)) {
        ev_io_stop(EV_A_ &worker->stdout_w);
    }
    if (ev_is_active(&worker->stderr_w)) {
        ev_io_stop(EV_A_ &worker->stderr_w);
    }
    if (ev_is_active(&worker->msgin_w)) {
        ev_io_stop(EV_A_ &worker->msgin_w);
    }
    if (ev_is_active(&worker->msgout_w)) {
        ev_io_stop(EV_A_ &worker->msgout_w);
    }
    close(worker->stdin_w.fd);
    close(worker->stdout_w.fd);
    close(worker->stderr_w.fd);
    close(worker->msgin_w.fd);
    close(worker->msgout_w.fd);
    free(worker);
}
Beispiel #14
0
void exit_cb(struct ev_loop* loop, struct ev_child* cwatcher, int status) {
    struct worker_s* worker = container_of(cwatcher, struct worker_s, cwatcher);
    ev_child_stop(loop, cwatcher);

    err("worker[pid:%d] exit with status:%d, stop_moniter:%d", worker->pid, cwatcher->rstatus, worker->listener->stop_moniter);

    struct timeval tv;
    gettimeofday(&tv, 0);

    if (worker->listener->stop_moniter || 2 > ((int)tv.tv_sec - worker->starttime)) {
        return;
    }

    worker->pid = spawn_worker(worker);
    if (-1 == worker->pid) {
        err("spawn worker failed, worker_id:%d", worker->worker_id);
        exit(EXIT_FAILURE);
    }

    err("worker %d restart, new pid: %d", worker->worker_id, worker->pid);

    ev_child_set(cwatcher, worker->pid, 0);
    ev_child_start(loop, cwatcher);
}
Beispiel #15
0
static void
child_cb (EV_P_ ev_child *w, int revents)
{
  ev_child_stop (EV_A_ w);
  printf ("Process %d changed status to %x\n", w->rpid, w->rstatus);
}
Beispiel #16
0
static void child_cb (EV_P_ ev_child *w, int revents)
{
    ev_child_stop (EV_A_ w);
    printf ("process %d exited with status %x\n", w->rpid, w->rstatus);
}
Beispiel #17
0
static void child_stop (void *impl, flux_watcher_t *w)
{
    assert (w->signature == CHILD_SIG);
    ev_child_stop (w->r->loop, (ev_child *)impl);
}
Beispiel #18
0
void uv__process_close(uv_process_t* handle) {
  ev_child_stop(handle->loop->ev, &handle->child_watcher);
}
Beispiel #19
0
void uv_close(uv_handle_t* handle, uv_close_cb close_cb) {
  uv_async_t* async;
  uv_stream_t* stream;
  uv_process_t* process;

  handle->close_cb = close_cb;

  switch (handle->type) {
    case UV_NAMED_PIPE:
      uv_pipe_cleanup((uv_pipe_t*)handle);
      /* Fall through. */

    case UV_TTY:
    case UV_TCP:
      stream = (uv_stream_t*)handle;

      uv_read_stop(stream);
      ev_io_stop(stream->loop->ev, &stream->write_watcher);

      uv__close(stream->fd);
      stream->fd = -1;

      if (stream->accepted_fd >= 0) {
        uv__close(stream->accepted_fd);
        stream->accepted_fd = -1;
      }

      assert(!ev_is_active(&stream->read_watcher));
      assert(!ev_is_active(&stream->write_watcher));
      break;

    case UV_UDP:
      uv__udp_start_close((uv_udp_t*)handle);
      break;

    case UV_PREPARE:
      uv_prepare_stop((uv_prepare_t*) handle);
      break;

    case UV_CHECK:
      uv_check_stop((uv_check_t*) handle);
      break;

    case UV_IDLE:
      uv_idle_stop((uv_idle_t*) handle);
      break;

    case UV_ASYNC:
      async = (uv_async_t*)handle;
      ev_async_stop(async->loop->ev, &async->async_watcher);
      ev_ref(async->loop->ev);
      break;

    case UV_TIMER:
      uv_timer_stop((uv_timer_t*)handle);
      break;

    case UV_PROCESS:
      process = (uv_process_t*)handle;
      ev_child_stop(process->loop->ev, &process->child_watcher);
      break;

    case UV_FS_EVENT:
      uv__fs_event_destroy((uv_fs_event_t*)handle);
      break;

    default:
      assert(0);
  }

  handle->flags |= UV_CLOSING;

  /* This is used to call the on_close callback in the next loop. */
  ev_idle_start(handle->loop->ev, &handle->next_watcher);
  ev_feed_event(handle->loop->ev, &handle->next_watcher, EV_IDLE);
  assert(ev_is_pending(&handle->next_watcher));
}
Beispiel #20
0
void feng_stop_child_watcher(struct feng  *srv)
{
    ev_child_stop (srv->loop, &cw);    
}