自学教程：C++ uv_default_loop函数代码示例

int main() {  int r;  id = 0;  loop = uv_default_loop();  struct sockaddr_in bind_addr;  r = uv_ip4_addr("0.0.0.0", PORT, &bind_addr);  CHECK(r, "get bind addr");  r = uv_tcp_init(loop, &server);  CHECK(r, "init server");  r = uv_tcp_bind(&server, (const struct sockaddr*) &bind_addr);  CHECK(r, "bind");  r = uv_listen((uv_stream_t*) &server, BACKLOG, on_connect);  CHECK(r, "listen");  log_info("listening on http://localhost:%d", PORT);  uv_run(loop, UV_RUN_DEFAULT);  return 0;}

static void make_many_connections(void) {  tcp_conn* conn;  struct sockaddr_in addr;  int r, i;  for (i = 0; i < CONN_COUNT; i++) {    conn = malloc(sizeof(*conn));    ASSERT(conn);    r = uv_tcp_init(uv_default_loop(), &conn->conn);    ASSERT(r == 0);    ASSERT(0 == uv_ip4_addr("127.0.0.1", TEST_PORT, &addr));    r = uv_tcp_connect(&conn->conn_req,                       (uv_tcp_t*) &conn->conn,                       (const struct sockaddr*) &addr,                       connect_cb);    ASSERT(r == 0);    conn->conn.data = conn;  }}

static void repeat_2_cb(uv_timer_t* handle, int status) {  ASSERT(handle == &repeat_2);  ASSERT(status == 0);  ASSERT(repeat_2_cb_allowed);  LOGF("repeat_2_cb called after %ld ms/n",      (long int)(uv_now(uv_default_loop()) - start_time));  repeat_2_cb_called++;  if (uv_timer_get_repeat(&repeat_2) == 0) {    ASSERT(0 == uv_is_active((uv_handle_t*) handle));    uv_close((uv_handle_t*)handle, close_cb);    return;  }  LOGF("uv_timer_get_repeat %ld ms/n",      (long int)uv_timer_get_repeat(&repeat_2));  ASSERT(uv_timer_get_repeat(&repeat_2) == 100);  /* This shouldn't take effect immediately. */  uv_timer_set_repeat(&repeat_2, 0);}

int main() {  int r = 0;  uv_loop_t *loop = uv_default_loop();  r = uv_tcp_init(loop, &tcp_server);  CHECK(r, "uv_tcp_init");  struct sockaddr_in addr;  r = uv_ip4_addr(HOST, PORT, &addr);  CHECK(r, "uv_ip4_addr");  r = uv_tcp_bind(&tcp_server, (const struct sockaddr*) &addr, 0);  CHECK(r, "uv_tcp_bind");  r = uv_listen((uv_stream_t*) &tcp_server, SOMAXCONN, onconnection);  CHECK(r, "uv_listen");  log_info("Listening on %s:%d", HOST, PORT);  uv_run(loop, UV_RUN_DEFAULT);  MAKE_VALGRIND_HAPPY();  return 0;}

int main(){	struct addrinfo hints;	uv_getaddrinfo_t resolver;	int r;	loop = uv_default_loop();	hints.ai_family   = PF_INET;	hints.ai_socktype = SOCK_STREAM;	hints.ai_protocol = IPPROTO_TCP;	hints.ai_flags    = 0;	fprintf(stderr, "irc.freenode.net is... ");	r = uv_getaddrinfo(loop, &resolver, on_resolved, "irc.freenode.net", "6667", &hints);	if (r)	{		fprintf(stderr, "getaddrinfo call error %s/n", uv_err_name(r));		return 1;	}	return uv_run(loop, UV_RUN_DEFAULT);}

static void repeat_1_cb(uv_timer_t* handle) {  int r;  ASSERT(handle == &repeat_1);  ASSERT(uv_timer_get_repeat((uv_timer_t*)handle) == 50);  fprintf(stderr, "repeat_1_cb called after %ld ms/n",          (long int)(uv_now(uv_default_loop()) - start_time));  fflush(stderr);  repeat_1_cb_called++;  r = uv_timer_again(&repeat_2);  ASSERT(r == 0);  if (repeat_1_cb_called == 10) {    uv_close((uv_handle_t*)handle, close_cb);    /* We're not calling uv_timer_again on repeat_2 any more, so after this */    /* timer_2_cb is expected. */    repeat_2_cb_allowed = 1;    return;  }}

/* same ping-pong test, but using IPv6 connection */static void tcp_pinger_v6_new() {  int r;  struct sockaddr_in6 server_addr = uv_ip6_addr("::1", TEST_PORT);  pinger_t *pinger;  pinger = (pinger_t*)malloc(sizeof(*pinger));  pinger->state = 0;  pinger->pongs = 0;  /* Try to connec to the server and do NUM_PINGS ping-pongs. */  r = uv_tcp_init(uv_default_loop(), &pinger->stream.tcp);  pinger->stream.tcp.data = pinger;  ASSERT(!r);  /* We are never doing multiple reads/connects at a time anyway. */  /* so these handles can be pre-initialized. */  r = uv_tcp_connect6(&pinger->connect_req, &pinger->stream.tcp, server_addr,      pinger_on_connect);  ASSERT(!r);  /* Synchronous connect callbacks are not allowed. */  ASSERT(pinger_on_connect_count == 0);}

void TCPServer::IncomingConnection(uv_stream_t * listener, int status){    LogTrace(LOG_NETWORKING, "Incoming connection");    if (status < 0)    {        LogError(LOG_NETWORKING, "Incoming connection - failure, reason: %s", uv_err_name(status));        return;    }    uv_tcp_t * client = (uv_tcp_t *) malloc(sizeof(uv_tcp_t));    uv_tcp_init(uv_default_loop(), client);    if (uv_accept(listener, (uv_stream_t *) client) == 0)    {        LogTrace(LOG_NETWORKING, "Incoming connection - success");        uv_read_start((uv_stream_t *) client, AllocBuffer, IncomingData);    }    else    {        LogError(LOG_NETWORKING, "Incoming connection - failure, reason: %s", uv_err_name(status));        uv_close((uv_handle_t *) client, NULL);    }}

int main() {    uv_loop_t *loop = uv_default_loop();    int port = 8000, r = 0;    evt_ctx_t ctx;    struct sockaddr_in bind_local;    evt_ctx_init_ex(&ctx, "server-cert.pem", "server-key.pem");    evt_ctx_set_nio(&ctx, NULL, uv_tls_writer);    uv_tcp_t listener_local;    uv_tcp_init(loop, &listener_local);    listener_local.data = &ctx;    uv_ip4_addr("127.0.0.1", port, &bind_local);    if ((r = uv_tcp_bind(&listener_local, (struct sockaddr*)&bind_local, 0)))        fprintf( stderr, "bind: %s/n", uv_strerror(r));    if ((r = uv_listen((uv_stream_t*)&listener_local, 128, on_connect_cb)))        fprintf( stderr, "listen: %s/n", uv_strerror(r));    printf("Listening on %d/n", port);    uv_run(loop, UV_RUN_DEFAULT);    evt_ctx_free(&ctx);    return 0;}

jl_module_t *jl_new_module(jl_sym_t *name){    jl_module_t *m = (jl_module_t*)jl_gc_allocobj(sizeof(jl_module_t));    jl_set_typeof(m, jl_module_type);    JL_GC_PUSH1(&m);    assert(jl_is_symbol(name));    m->name = name;    m->parent = NULL;    m->constant_table = NULL;    m->call_func = NULL;    m->istopmod = 0;    m->uuid = uv_now(uv_default_loop());    htable_new(&m->bindings, 0);    arraylist_new(&m->usings, 0);    if (jl_core_module) {        jl_module_using(m, jl_core_module);    }    // export own name, so "using Foo" makes "Foo" itself visible    jl_set_const(m, name, (jl_value_t*)m);    jl_module_export(m, name);    JL_GC_POP();    return m;}

static void on_cm_event_read(uv_pipe_t* cm, ssize_t nread, uv_buf_t buf, uv_handle_type pending) {    printf("on_cm_event_read/n");    write_req_t* write_req;    int r;    uv_err_t err = uv_last_error(uv_default_loop());    assert(nread > 0 || err.code == UV_EOF);    printf("nread = %ld/n", nread);    if (nread > 0) {        output_used += nread;        if (output_used == 12) {            assert(memcmp("hello world/n", output, 12) == 0);            write_req = (write_req_t*)malloc(sizeof(*write_req));            write_req->buf = uv_buf_init(output, output_used);            r = uv_write(&write_req->req, (uv_stream_t*)&in, &write_req->buf, 1, after_write);            assert(r == 0);        }    }    on_read_cb_called++;}

static int pipe_echo_start(char* pipeName) {  int r;#ifndef _WIN32  {    uv_fs_t req;    uv_fs_unlink(uv_default_loop(), &req, pipeName, NULL);    uv_fs_req_cleanup(&req);  }#endif  server = (uv_handle_t*)&pipeServer;  serverType = PIPE;  r = uv_pipe_init(loop, &pipeServer, 0);  if (r) {    fprintf(stderr, "uv_pipe_init: %s/n",        uv_strerror(uv_last_error(loop)));    return 1;  }  r = uv_pipe_bind(&pipeServer, pipeName);  if (r) {    fprintf(stderr, "uv_pipe_bind: %s/n",        uv_strerror(uv_last_error(loop)));    return 1;  }  r = uv_listen((uv_stream_t*)&pipeServer, SOMAXCONN, on_connection);  if (r) {    fprintf(stderr, "uv_pipe_listen: %s/n",        uv_strerror(uv_last_error(loop)));    return 1;  }  return 0;}

v8::Handle<v8::Value> Write(const v8::Arguments& args) {  v8::HandleScope scope;  // file descriptor  if(!args[0]->IsInt32()) {    return scope.Close(v8::ThrowException(v8::Exception::TypeError(v8::String::New("First argument must be an int"))));  }  int fd = args[0]->ToInt32()->Int32Value();  // buffer  if(!args[1]->IsObject() || !node::Buffer::HasInstance(args[1])) {    return scope.Close(v8::ThrowException(v8::Exception::TypeError(v8::String::New("Second argument must be a buffer"))));  }  v8::Persistent<v8::Object> buffer = v8::Persistent<v8::Object>::New(args[1]->ToObject());  char* bufferData = node::Buffer::Data(buffer);  size_t bufferLength = node::Buffer::Length(buffer);  // callback  if(!args[2]->IsFunction()) {    return scope.Close(v8::ThrowException(v8::Exception::TypeError(v8::String::New("Third argument must be a function"))));  }  v8::Local<v8::Value> callback = args[2];  WriteBaton* baton = new WriteBaton();  memset(baton, 0, sizeof(WriteBaton));  baton->fd = fd;  baton->buffer = buffer;  baton->bufferData = bufferData;  baton->bufferLength = bufferLength;  baton->callback = v8::Persistent<v8::Value>::New(callback);  uv_work_t* req = new uv_work_t();  req->data = baton;  uv_queue_work(uv_default_loop(), req, EIO_Write, EIO_AfterWrite);  return scope.Close(v8::Undefined());}

  int DirWatcher::init(std::string dir, dirwatch_on_rename_callback cb, void* usr) {    int r = 0;    directory = dir;    if (NULL != loop) {      RX_ERROR("Looks like we're already initialize, call shutdown() first.");      return -1;    }    if (false == rx_is_dir(directory)) {      RX_ERROR("Not a directory: %s", directory.c_str());      return -2;    }    loop = uv_default_loop();    r = uv_fs_event_init(loop, &fs_event);    if (0 != r) {      RX_ERROR("Cannot initialize the fs event: %s", uv_strerror(r));      loop = NULL;      return -3;    }    r = uv_fs_event_start(&fs_event, on_dir_change, directory.c_str(), 0);    if (0 != r) {      RX_ERROR("Cannot start the fs event: %s", uv_strerror(r));      loop = NULL;      return -4;    }    fs_event.data = this;    on_rename = cb;    user = usr;    return 0;  }

void signal_init(void){  uv_signal_init(uv_default_loop(), &sint);  uv_signal_init(uv_default_loop(), &spipe);  uv_signal_init(uv_default_loop(), &shup);  uv_signal_init(uv_default_loop(), &squit);  uv_signal_init(uv_default_loop(), &sterm);  uv_signal_init(uv_default_loop(), &swinch);  uv_signal_start(&sint, signal_cb, SIGINT);  uv_signal_start(&spipe, signal_cb, SIGPIPE);  uv_signal_start(&shup, signal_cb, SIGHUP);  uv_signal_start(&squit, signal_cb, SIGQUIT);  uv_signal_start(&sterm, signal_cb, SIGTERM);  if (!embedded_mode) {    // TODO(tarruda): There must be an API function for resizing window    uv_signal_start(&swinch, signal_cb, SIGWINCH);  }#ifdef SIGPWR  uv_signal_init(uv_default_loop(), &spwr);  uv_signal_start(&spwr, signal_cb, SIGPWR);#endif}

int spawn_tcp_server_helper(void) {  uv_tcp_t tcp;  uv_os_sock_t handle;  int r;  r = uv_tcp_init(uv_default_loop(), &tcp);  ASSERT(r == 0);#ifdef _WIN32  handle = _get_osfhandle(3);#else  handle = 3;#endif  r = uv_tcp_open(&tcp, handle);  ASSERT(r == 0);  /* Make sure that we can listen on a socket that was   * passed down from the parent process   */  r = uv_listen((uv_stream_t*)&tcp, SOMAXCONN, NULL);  ASSERT(r == 0);  return 1;}

int Start(int argc, char** argv) {  InitDebugSettings();  // Initalize JerryScript engine.  if (!InitJerry()) {    DLOG("InitJerry failed");    return 1;  }  // Create environtment.  Environment* env = Environment::GetEnv();  // Init environment with argument and uv loop.  env->Init(argc, argv, uv_default_loop());  // Start IoT.js  if (!StartIoTjs(env)) {    DLOG("StartIoTJs failed");    return 1;  }  // close uv loop.  //uv_stop(env->loop());  uv_walk(env->loop(), UvWalkToCloseCallback, NULL);  uv_run(env->loop(), UV_RUN_DEFAULT);  int res = uv_loop_close(env->loop());  IOTJS_ASSERT(res == 0);  // Release JerryScript engine.  ReleaseJerry();  ReleaseDebugSettings();  return 0;}

/** * @details This is an asynchronous factory method creating a new `Map` * instance from a mapserver mapfile. * * `args` should contain the following parameters: * * @param mapfile A string representing the mapfile path. * * @param callback A function that is called on error or when the map has been * created. It should have the signature `callback(err, map)`. */Handle<Value> Map::FromFileAsync(const Arguments& args) {  HandleScope scope;  if (args.Length() != 2) {    THROW_CSTR_ERROR(Error, "usage: Map.FromFile(mapfile, callback)");  }  REQ_STR_ARG(0, mapfile);  REQ_FUN_ARG(1, callback);  MapfileBaton *baton = new MapfileBaton();  baton->request.data = baton;  baton->map = NULL;  baton->callback = Persistent<Function>::New(callback);  baton->error = NULL;  baton->mapfile = *mapfile;  uv_queue_work(uv_default_loop(),                &baton->request,                FromFileWork,                (uv_after_work_cb) FromFileAfter);  return Undefined();}

intuvm_start_client(uvm_read_callback_t cb,                  char* host, int port, void* data){    struct sockaddr_in sin;    uv_tcp_t* sock = malloc(sizeof(uv_tcp_t));    uv_connect_t* connect_req = malloc(sizeof(uv_connect_t));    connection_request_t* req = malloc(sizeof(connection_request_t));    if(!req){        /* FIXME: set error here */        return -1;    }    connect_req->data = req;    req->cb = cb;    req->data = data;    /* Resolve name */    sin = uv_ip4_addr(host,port);    /* Init connection state */    uv_tcp_init(uv_default_loop(), sock);    /* Enqueue connection request */    return uv_tcp_connect(connect_req, sock, sin, cb_connect);}

        static v8::Handle<v8::Value> call(v8::Arguments const& args)        {            typedef Worker Instance::* member_ptr_t;                    v8::HandleScope scope;                    // get member pointer            uint32_t member_ptr_value = args.Data()->NumberValue();            member_ptr_t member_ptr = *reinterpret_cast<member_ptr_t *>(&member_ptr_value);                        // get instance            Instance & instance = get_wrapped_object<Instance>(args);                        // get derived worker ref            Worker & worker = instance.*member_ptr;                        // get the work request            uv_work_t * work_req = worker.get_work_request();            if (!work_req)            {                // error in arguments, return undefined                return scope.Close(v8::Undefined());            }            // store the arguments            worker.store_arguments(args);            // queue work function            work_req->data = &worker;            uv_queue_work(uv_default_loop(),                          work_req,                          &worker_base::process_impl<Instance, Worker>,                          &worker_base::after_impl<Instance, Worker>);                        return scope.Close(v8::Undefined());        }

void main(int argc, char** argv) {    loop = uv_default_loop();    if(argc > 1) {        bench = atoi(argv[1]);    }    if(argc > 2) {        interval = atoi(argv[2]); // Seconds    }    // init log client    uvx_log_init(&xlog, loop, "127.0.0.1", 8004, "xlog-test");    // some small tests    test_shorten_path();    test_serialize_log();    // start a timer    uv_timer_t timer;    uv_timer_init(loop, &timer);    uv_timer_start(&timer, on_timer, 0, interval/*seconds*/ * 1000);    uv_run(loop, UV_RUN_DEFAULT);}

static void do_newuser(MyMSG* msg, CMsgSocket* s){    printf("received new user: id: %d; room: %d/n", msg->body.userinfo.userid, msg->body.userinfo.roomid);    s->dis_connect();	cnt++;	if (cnt > 6){		s1->dis_connect();		s2->dis_connect();		return;	}    CMsgSocket* s11 = dynamic_cast<CMsgSocket*>(CResourcePool::GetInstance()->Get(e_rsc_msgsocket));	if (s == s1) s1 = s11;	else s2 = s11;	cc_userinfo_t userinfo = { 0 };	userinfo.roomid = msg->body.userinfo.roomid;	userinfo.userid = !msg->body.userinfo.userid;	s11->set_local_user(&userinfo);	s11->on_received(s11, on_msg);	s11->on_received_frame(s11, on_frame);    uv_work_t* req = (uv_work_t*)malloc(sizeof(uv_work_t));    req->data = s11;    int ret = uv_queue_work(uv_default_loop(), req, do_nothing, reconn);    printf("queue reconn return %d/n", ret);}

uni::CallbackType OracleClient::Connect(const uni::FunctionCallbackInfo& args) {  UNI_SCOPE(scope);  REQ_OBJECT_ARG(0, settings);  REQ_FUN_ARG(1, callback);  OracleClient* client = ObjectWrap::Unwrap<OracleClient>(args.This());  ConnectBaton* baton = new ConnectBaton(client, client->m_environment, &callback);  OBJ_GET_STRING(settings, "hostname", baton->hostname);  OBJ_GET_STRING(settings, "user", baton->user);  OBJ_GET_STRING(settings, "password", baton->password);  OBJ_GET_STRING(settings, "database", baton->database);  OBJ_GET_NUMBER(settings, "port", baton->port, 1521);  OBJ_GET_STRING(settings, "tns", baton->tns);  client->Ref();  uv_work_t* req = new uv_work_t();  req->data = baton;  uv_queue_work(uv_default_loop(), req, EIO_Connect, (uv_after_work_cb)EIO_AfterConnect);  UNI_RETURN(scope, args, NanUndefined());}

cspider_t *init_cspider() {  cspider_t *spider = (cspider_t *)malloc(sizeof(cspider_t));  PANIC(spider);  //init task queue  spider->task_queue = initTaskQueue();  PANIC(spider->task_queue);  spider->task_queue_doing = initTaskQueue();  PANIC(spider->task_queue_doing);  //init data queue  spider->data_queue = initDataQueue();  PANIC(spider->data_queue);  spider->data_queue_doing = initDataQueue();  PANIC(spider->data_queue_doing);    spider->threadpool_size = 4;  spider->process = NULL;  spider->save = NULL;  spider->process_user_data = NULL;  spider->save_user_data = NULL;  spider->loop = uv_default_loop();    spider->idler = (uv_idle_t*)malloc(sizeof(uv_idle_t));  spider->lock = (uv_rwlock_t*)malloc(sizeof(uv_rwlock_t));  uv_rwlock_init(spider->lock);  spider->save_lock = (uv_rwlock_t*)malloc(sizeof(uv_rwlock_t));  uv_rwlock_init(spider->save_lock);  spider->idler->data = spider;  spider->site = (site_t*)malloc(sizeof(site_t));  spider->site->user_agent = NULL;  spider->site->proxy = NULL;  spider->site->cookie = NULL;  spider->site->timeout = 0;  spider->log = NULL;  spider->bloom = init_Bloom();  return spider;}

intmain(int argc, char *argv[]){    serverstate_set_event_loop(uv_default_loop());    config_init();    listener_init();    client_init();    module_init();    server_init();    command_init();    connection_init();    process_commandline(argv, argc);    config_load();    listener_start_listeners();    module_load_all_modules();    connection_init_tls();    uv_run(serverstate_get_event_loop(), UV_RUN_DEFAULT);    return 0;}

Handle<Value> OracleClient::Connect(const Arguments& args) {  HandleScope scope;  REQ_OBJECT_ARG(0, settings);  REQ_FUN_ARG(1, callback);  OracleClient* client = ObjectWrap::Unwrap<OracleClient>(args.This());  ConnectBaton* baton = new ConnectBaton(client, client->m_environment, &callback);  OBJ_GET_STRING(settings, "hostname", baton->hostname);  OBJ_GET_STRING(settings, "user", baton->user);  OBJ_GET_STRING(settings, "password", baton->password);  OBJ_GET_STRING(settings, "database", baton->database);  OBJ_GET_NUMBER(settings, "port", baton->port, 1521);  OBJ_GET_STRING(settings, "tns", baton->tns);  client->Ref();  uv_work_t* req = new uv_work_t();  req->data = baton;  uv_queue_work(uv_default_loop(), req, EIO_Connect, (uv_after_work_cb)EIO_AfterConnect);  return scope.Close(Undefined());}

//call client signal callbackstatic void signal_cb (std::string subscriber_name,	   std::string quiddity_name, 	   std::string signal_name, 	   std::vector<std::string> params, 	   void *user_data){  if (g_strcmp0 (signal_name.c_str (), "on-quiddity-created") == 0      && switcher_is_loading == false)    g_thread_create (set_runtime_invoker, 		     g_strdup (params[0].c_str ()),		     FALSE,		     NULL);    async_req_signal *req = new async_req_signal ();  req->req.data = req;  req->quiddity_name = quiddity_name;  req->signal_name = signal_name;  req->params = params;  uv_queue_work (uv_default_loop(),		 &req->req,		 DoNothingAsync,		 (uv_after_work_cb)NotifySignal);}

static void pinger_read_cb(uv_stream_t* stream, ssize_t nread, uv_buf_t buf) {  ssize_t i;  pinger_t* pinger;  pinger = (pinger_t*)stream->data;  if (nread < 0) {    ASSERT(uv_last_error(uv_default_loop()).code == UV_EOF);    puts("got EOF");    if (buf.base) {      free(buf.base);    }    uv_close((uv_handle_t*)(&pinger->stream.tcp), pinger_on_close);    return;  }  /* Now we count the pings */  for (i = 0; i < nread; i++) {    ASSERT(buf.base[i] == PING[pinger->state]);    pinger->state = (pinger->state + 1) % (sizeof(PING) - 1);    if (pinger->state == 0) {      printf("PONG %d/n", pinger->pongs);      pinger->pongs++;      if (pinger->pongs < NUM_PINGS) {        pinger_write_ping(pinger);      } else {        uv_close((uv_handle_t*)(&pinger->stream.tcp), pinger_on_close);        return;      }    }  }}

int main(int argc, char *argv[]){  sockaddr_in addr;  int r;   resbuf.base = RESPONSE;  resbuf.len = sizeof(RESPONSE);  uv_loop = uv_default_loop();  addr = uv_ip4_addr("127.0.0.1", 8089);  r = uv_tcp_init(uv_loop, &tcp_server);  assert(r == 0);  r = uv_tcp_bind(&tcp_server, addr);  assert(r == 0);  r = uv_listen((uv_stream_t*)&tcp_server, 128, connection_cb);  assert(r == 0);  printf("start/n");  r = uv_run(uv_loop);  assert(0 && "Blackhole server dropped out of event loop.");}