Exemple #1
0
static PyObject *
Idle_func_start(Idle *self, PyObject *args)
{
    int err;
    PyObject *tmp, *callback;

    tmp = NULL;

    RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL);
    RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL);

    if (!PyArg_ParseTuple(args, "O:start", &callback)) {
        return NULL;
    }

    if (!PyCallable_Check(callback)) {
        PyErr_SetString(PyExc_TypeError, "a callable is required");
        return NULL;
    }

    err = uv_idle_start(&self->idle_h, pyuv__idle_cb);
    if (err < 0) {
        RAISE_UV_EXCEPTION(err, PyExc_IdleError);
        return NULL;
    }

    tmp = self->callback;
    Py_INCREF(callback);
    self->callback = callback;
    Py_XDECREF(tmp);

    PYUV_HANDLE_INCREF(self);

    Py_RETURN_NONE;
}
Exemple #2
0
static void(loop_stop)()
{
   uv_stop(loop);
   uv_idle_t* idle = s_malloc0(sizeof(*idle));
   uv_idle_init(loop, idle);
   uv_idle_start(idle, loop_stop_cb);
}
Exemple #3
0
static void check_cb(uv_check_t* handle, int status) {
  int i, r;

  LOG("CHECK_CB\n");

  ASSERT(handle == &check_handle);
  ASSERT(status == 0);

  if (loop_iteration < ITERATIONS) {
    /* Make some idle watchers active */
    for (i = 0; i < 1 + (loop_iteration % IDLE_COUNT); i++) {
      r = uv_idle_start(&idle_1_handles[i], idle_1_cb);
      ASSERT(r == 0);
      idles_1_active++;
    }

  } else {
    /* End of the test - close all handles */
    uv_close((uv_handle_t*)&prepare_1_handle, prepare_1_close_cb);
    uv_close((uv_handle_t*)&check_handle, check_close_cb);
    uv_close((uv_handle_t*)&prepare_2_handle, prepare_2_close_cb);

    for (i = 0; i < IDLE_COUNT; i++) {
      uv_close((uv_handle_t*)&idle_1_handles[i], idle_1_close_cb);
    }

    /* This handle is closed/recreated every time, close it only if it is */
    /* active.*/
    if (idle_2_is_active) {
      uv_close((uv_handle_t*)&idle_2_handle, idle_2_close_cb);
    }
  }

  check_cb_called++;
}
Exemple #4
0
static void idle_1_cb(uv_handle_t* handle, int status) {
  int r;

  LOG("IDLE_1_CB\n");

  ASSERT(handle != NULL);
  ASSERT(status == 0);

  ASSERT(idles_1_active > 0);

  /* Init idle_2 and make it active */
  if (!idle_2_is_active) {
    r = uv_idle_init(&idle_2_handle, idle_2_close_cb, NULL);
    ASSERT(r == 0);
    r = uv_idle_start(&idle_2_handle, idle_2_cb);
    ASSERT(r == 0);
    idle_2_is_active = 1;
    idle_2_cb_started++;
  }

  idle_1_cb_called++;

  if (idle_1_cb_called % 5 == 0) {
    r = uv_idle_stop((uv_idle_t*)handle);
    ASSERT(r == 0);
    idles_1_active--;
  }
}
Exemple #5
0
static void frame_event_cb(cg_onscreen_t *onscreen, cg_frame_event_t event,
                           cg_frame_info_t *info, void *data) {
    if (event == CG_FRAME_EVENT_SYNC) {
        struct demo *demo = data;
        uv_idle_start(&demo->idle, paint_cb);
    }
}
Exemple #6
0
int main() {
    uv_loop_t* loop = uv_default_loop();
    uv_idle_t handler = idleHandler(loop);
    uv_idle_start(&handler, callback);
    uv_run(loop, UV_RUN_DEFAULT);
    uv_loop_close(loop);
    return 0;
}
Exemple #7
0
/// Starts watching for events from a `RStream` instance.
///
/// @param rstream The `RStream` instance
void rstream_start(RStream *rstream)
{
  if (rstream->file_type == UV_FILE) {
    uv_idle_start(rstream->fread_idle, fread_idle_cb);
  } else {
    uv_read_start(rstream->stream, alloc_cb, read_cb);
  }
}
Exemple #8
0
static void next_tick(uv_idle_t* handle, int status) {
  uv_loop_t* loop = handle->loop;
  uv_idle_stop(handle);
  uv_idle_init(loop, &idle_handle);
  uv_idle_start(&idle_handle, idle_cb);
  uv_timer_init(loop, &timer_handle);
  uv_timer_start(&timer_handle, timer_cb, 0, 0);
}
Exemple #9
0
    rust_uvtmp_thread() {
	task = rust_scheduler::get_task();
	stop_flag = false;
	loop = uv_loop_new();
	uv_idle_init(loop, &idle);
	idle.data = this;
	uv_idle_start(&idle, idle_cb);
    }
Exemple #10
0
static int luv_idle_start(lua_State* L) {
  uv_idle_t* handle = luv_check_idle(L, 1);
  int ret;
  luv_check_callback(L, (luv_handle_t *)handle->data, LUV_IDLE, 2);
  ret = uv_idle_start(handle, luv_idle_cb);
  if (ret < 0) return luv_error(L, ret);
  lua_pushinteger(L, ret);
  return 1;
}
Exemple #11
0
void run_UVloop(void *arg)
{
    uv_idle_t idler;
    uv_idle_init(UV_loop,&idler);
    //uv_async_init(UV_loop,&Tasks_async,async_handler);
    uv_idle_start(&idler,SuperNET_idler);
    uv_run(UV_loop,UV_RUN_DEFAULT);
    printf("end of uv_run\n");
}
Exemple #12
0
void wait_for_next_input() {
  int r;
  // Note: the example in the uvbook contains a small mistake  IMO since it's reading from fd: 1 which is stdout,
  //       however it works either way
  r = uv_fs_read(loop, &stdin_watcher, STDIN, buffer, 1024, -1, stdin_fs_cb);
  if (r) ERROR("reading stdin", r);

  r = uv_idle_start(&idler, idle_cb);
  if (r) ERROR("starting idler", r);
}
Exemple #13
0
static void enter_loop(MVMThreadContext *tc, MVMCallsite *callsite, MVMRegister *args) {
    uv_idle_t idle;
    if (uv_idle_init(tc->loop, &idle) != 0)
        MVM_panic(1, "Unable to initialize idle worker for event loop");
    idle.data = tc;
    if (uv_idle_start(&idle, idle_handler) != 0)
        MVM_panic(1, "Unable to start idle worker for event loop");
    uv_run(tc->loop, UV_RUN_DEFAULT);
    MVM_panic(1, "Supposedly unending event loop thread ended");
}
/** @internal Schedule deferred continuation. */
static int l_ffi_defer(lua_State *L)
{
    uv_idle_t *check = malloc(sizeof(*check));
    if (!check) {
        return kr_error(ENOMEM);
    }
    uv_idle_init(uv_default_loop(), check);
    check->data = L;
    return uv_idle_start(check, l_ffi_resume_cb);
}
Exemple #15
0
int main() {
    uv_idle_t idler;

    uv_idle_init(uv_default_loop(), &idler);
    uv_idle_start(&idler, wait_for_a_while);

    printf("Idling...\n");
    uv_run(uv_default_loop(), UV_RUN_DEFAULT);

    return 0;
}
Exemple #16
0
 static int64_t HHVM_METHOD(UVIdle, start, const Variant &idle_cb) {
     auto* data = Native::data<UVNativeData>(this_);
     uv_idle_ext_t *idle_handle = fetchResource(data);
     data->callback = idle_cb;
     int64_t ret = uv_idle_start(idle_handle, (uv_idle_cb) idle_handle_callback);
     if(ret == 0){
         idle_handle->start = true;
         idle_handle->idle_object_data = this_;
         this_->incRefCount();
     }
     return ret;
 }
Exemple #17
0
int main()
{
	uv_idle_t idler;

    uv_idle_init(get_loop(), &idler);
    uv_idle_start(&idler, wait_for_a_while);


    printf("Now quitting.\n");
    uv_run(get_loop(), UV_RUN_DEFAULT);

    return 0;
}
Exemple #18
0
int main(int argc, char **argv) {
    uv_idle_t idler;
    uv_idle_init(uv_default_loop(), &idler);
    uv_idle_start(&idler, waitForAWhile);

    printf(".. idling...");

    uv_run(uv_default_loop(), UV_RUN_DEFAULT);
    uv_loop_close(uv_default_loop());


    return 0;
}
Exemple #19
0
int main(int argc, char **argv)
{
    cg_onscreen_t *onscreen;
    cg_error_t *error = NULL;
    struct demo demo;
    float fovy, aspect, z_near, z_2d, z_far;
    uv_loop_t *loop = uv_default_loop();

    demo.dev = cg_device_new ();
    if (!demo.dev || error != NULL)
        c_error("Failed to create Cogl context\n");

    onscreen = cg_onscreen_new(demo.dev, WIDTH, HEIGHT);

    demo.fb = onscreen;
    demo.width = cg_framebuffer_get_width(demo.fb);
    demo.height = cg_framebuffer_get_height(demo.fb);

    cg_onscreen_show(onscreen);
    cg_framebuffer_set_viewport(demo.fb, 0, 0, demo.width, demo.height);

    fovy = 45;
    aspect = (float)demo.width / (float)demo.height;
    z_near = 0.1;
    z_2d = 1000;
    z_far = 2000;

    cg_framebuffer_perspective(demo.fb, fovy, aspect, z_near, z_far);
    c_matrix_init_identity(&demo.view);
    c_matrix_view_2d_in_perspective(&demo.view, fovy, aspect, z_near, z_2d,
                                     demo.width, demo.height);
    cg_framebuffer_set_modelview_matrix(demo.fb, &demo.view);
    demo.swap_ready = true;

    cg_onscreen_add_frame_callback(demo.fb, frame_event_cb, &demo, NULL);

    init_particle_emitters(&demo);

    demo.timer = c_timer_new();
    demo.spin_rate = 0;
    demo.angle_between_emitters = 2 * M_PI / C_N_ELEMENTS(demo.emitter);

    uv_idle_init(loop, &demo.idle);
    demo.idle.data = &demo;
    uv_idle_start(&demo.idle, paint_cb);

    cg_uv_set_mainloop(demo.dev, loop);
    uv_run(loop, UV_RUN_DEFAULT);

    return 0;
}
Exemple #20
0
unsigned int lcbuv_close_socket(lcb_io_opt_t iobase, lcb_sockdata_t *sockbase)
{
    dCOMMON_VARS(iobase, sockbase)
    uv_idle_t *idle = calloc(1, sizeof(*idle));

    assert(sock->lcb_close_called == 0);

    sock->lcb_close_called = 1;
    idle->data = sock;
    uv_idle_init(io->loop, idle);
    uv_idle_start(idle, socket_closing_cb);

    (void)io;
    return 0;
}
Exemple #21
0
int 
main(int argc, char* argv[])
{
  uv_idle_t idle;
  uv_loop_t* loop = uv_default_loop();

  uv_idle_init(loop, &idle);
  uv_idle_start(&idle, idle_routine);

  fprintf(stdout, "[%lu]Idling begin ...\n", clock());
  uv_run(loop, UV_RUN_DEFAULT);
  fprintf(stdout, "[%lu]Idling finish ...\n", clock());

  return 0;
}
Exemple #22
0
static void run(void) {
   uv_idle_t runner;
   uv_idle_init(uv_default_loop(), &runner);
   uv_idle_start(&runner, do_run);

   uv_run(uv_default_loop(), UV_RUN_DEFAULT);
   uv_loop_close(uv_default_loop());
   log_info(LOG, "Client stopped.");

   automaton->free(automaton);
   ch->free(ch);
   cgi_channel->free(cgi_channel);
   mh->free(mh);
   zmq_channel->free(zmq_channel);
}
Exemple #23
0
static unsigned int close_socket(lcb_io_opt_t iobase, lcb_sockdata_t *sockbase)
{
    my_sockdata_t *sock = (my_sockdata_t *)sockbase;
    my_iops_t *io = (my_iops_t *)iobase;

    uv_idle_t *idle = calloc(1, sizeof(*idle));

    lcb_assert(sock->lcb_close_called == 0);

    sock->lcb_close_called = 1;
    idle->data = sock;
    uv_idle_init(io->loop, idle);
    uv_idle_start(idle, socket_closing_cb);

    return 0;
}
Exemple #24
0
int main() {
   uv_idle_t idler;

   LOG = circus_new_log_file_descriptor(stdlib_memory, LOG_INFO, 1);

   uv_idle_init(uv_default_loop(), &idler);
   uv_idle_start(&idler, wait_for_a_while);

   LOG->set_format(LOG, "[%T] %O:%G\n");

   uv_run(uv_default_loop(), UV_RUN_DEFAULT);
   uv_loop_close(uv_default_loop());

   LOG->free(LOG);
   return 0;
}
Exemple #25
0
static void
lws_io_cb(uv_poll_t *watcher, int status, int revents)
{
	struct lws_io_watcher *lws_io = lws_container_of(watcher,
					struct lws_io_watcher, uv_watcher);
	struct lws *wsi = lws_container_of(lws_io, struct lws, w_read);
	struct lws_context *context = wsi->context;
	struct lws_pollfd eventfd;

#if defined(WIN32) || defined(_WIN32)
	eventfd.fd = watcher->socket;
#else
	eventfd.fd = watcher->io_watcher.fd;
#endif
	eventfd.events = 0;
	eventfd.revents = 0;

	if (status < 0) {
		/*
		 * At this point status will be an UV error, like UV_EBADF,
		 * we treat all errors as LWS_POLLHUP
		 *
		 * You might want to return; instead of servicing the fd in
		 * some cases */
		if (status == UV_EAGAIN)
			return;

		eventfd.events |= LWS_POLLHUP;
		eventfd.revents |= LWS_POLLHUP;
	} else {
		if (revents & UV_READABLE) {
			eventfd.events |= LWS_POLLIN;
			eventfd.revents |= LWS_POLLIN;
		}
		if (revents & UV_WRITABLE) {
			eventfd.events |= LWS_POLLOUT;
			eventfd.revents |= LWS_POLLOUT;
		}
	}
	lws_service_fd(context, &eventfd);

	uv_idle_start(&context->pt[(int)wsi->tsi].uv_idle, lws_uv_idle);
}
Exemple #26
0
int main() {
    /* our reference to the default loop */
    uv_loop_t *loop;

    /* a idler of uv_idle_t struct type */
    uv_idle_t idler;

    /* let uv return the default loop */
    loop = uv_default_loop();

    /* initialize a idle handle with the default loop and the reference of our idle type */
    uv_idle_init(loop, &idler);
    /* start executing the idle handler and call the wait_for_a_while callback */
    uv_idle_start(&idler, wait_for_a_while);

    printf("Idling ...\n");

    /* start runing the loop in default mode */
    uv_run(loop, UV_RUN_DEFAULT);
}
Exemple #27
0
static void send_error(lcb_io_opt_t iobase, lcb_sockdata_t *sockbase,
                       lcb_io_error_cb callback)
{
    my_sockdata_t *sock = (my_sockdata_t *)sockbase;
    my_iops_t *io = (my_iops_t *)iobase;
    my_uvreq_t *uvr;

    if (!sock) {
        return;
    }

    uvr = alloc_uvreq(sock, (generic_callback_t)callback);

    if (!uvr) {
        return;
    }

    uv_idle_init(io->loop, &uvr->uvreq.idle);
    uv_idle_start(&uvr->uvreq.idle, err_idle_cb);
    incref_sock(sock);
}
Exemple #28
0
int main() {
    uv_idle_t idler;
    uv_loop_t *loop = uv_default_loop();

    // 初始化 idle handle
    uv_idle_init(loop, &idler);
    // 启用 idle handle 并传入回调
    uv_idle_start(&idler, wait_for_a_while);

    printf("Idling... \n");

    // ==========================================
    // http://docs.libuv.org/en/v1.x/loop.html
    // ==========================================

    // int uv_run(uv_loop_t* loop, uv_run_mode mode)
    // This function runs the event loop. It will act differently depending on the specified mode:

    // UV_RUN_DEFAULT: Runs the event loop until there are no more active and referenced handles or requests.
    // Returns non-zero if uv_stop() was called and there are still active handles or requests. Returns zero in all other cases.
    //
    // UV_RUN_ONCE: Poll for i/o once. Note that this function blocks if there are no pending callbacks.
    // Returns zero when done (no active handles or requests left), or non-zero if more callbacks
    // are expected (meaning you should run the event loop again sometime in the future).
    //
    // UV_RUN_NOWAIT: Poll for i/o once but don’t block if there are no pending callbacks.
    // Returns zero if done (no active handles or requests left), or non-zero if more callbacks
    // are expected (meaning you should run the event loop again sometime in the future).

    // 开始轮询,直到该loop中没有活动的引用
    // 在此例中,当uv_idle_stop(handle)调用后,所有的活动执行完成
    // 此时将会停止loop
    uv_run(loop, UV_RUN_DEFAULT);

    // 关闭轮询
    // Releases all internal loop resources.
    uv_loop_close(loop);

    return 0;
}
Exemple #29
0
/* for libuv */
static void on_uv_timer_cb(uv_timer_t * handle)
{
    sg_etp_session_t * session = handle->data;
    IUINT32 now = 0;

    /*LOG_D("update %d", client->conv);*/

    /* update ikcp */
    now = (IUINT32)uv_now(session->loop);
    sg_etp_update_speed((sg_etp_t *)session, now);
    if (now >= session->kcp_update_time)
    {
        ikcp_update(session->kcp, now);
        session->kcp_update_time = ikcp_check(session->kcp, now);

        LOG_D("update %lu @ %lu, timeout: %lu", session->conv, session->kcp_update_time, session->recv_data_time);

        /* check received data and add to work queue */
        //recv_data_check(session);
        if (ikcp_peeksize(session->kcp) > 0)
        {
            uv_idle_start(&(session->idle), on_uv_idle_cb);
        }
    }

    /* check if session is timeout */
    if (session->recv_data_time < now)
    {
        session->to_close = true; /* mark to close this session. */
        ikcp_flush(session->kcp);
        LOG_I("session %lu timeout, will be closed", session->conv);
    }

    /* check if should close this session */
    if (session->to_close)
    {
        sg_etp_session_close(session);
    }
}
Exemple #30
0
void uv_eio_init(uv_loop_t* loop) {
  if (loop->flags & UV_LOOP_EIO_INITIALIZED) return;
  loop->flags |= UV_LOOP_EIO_INITIALIZED;

  uv_idle_init(loop, &loop->uv_eio_poller);
  uv_idle_start(&loop->uv_eio_poller, uv_eio_do_poll);
  loop->uv_eio_poller.flags |= UV__HANDLE_INTERNAL;

  loop->uv_eio_want_poll_notifier.data = loop;
  uv_async_init(loop,
                &loop->uv_eio_want_poll_notifier,
                uv_eio_want_poll_notifier_cb);
  loop->uv_eio_want_poll_notifier.flags |= UV__HANDLE_INTERNAL;
  uv__handle_unref(&loop->uv_eio_want_poll_notifier);

  uv_async_init(loop,
                &loop->uv_eio_done_poll_notifier,
                uv_eio_done_poll_notifier_cb);
  loop->uv_eio_done_poll_notifier.flags |= UV__HANDLE_INTERNAL;
  uv__handle_unref(&loop->uv_eio_done_poll_notifier);

  uv_once(&uv__eio_init_once_guard, uv__eio_init);
}