int main(int argc, char **argv)
{
printf("libuev..\r\n");
xloop = uv_default_loop();
// uv_loop_init(&xloop);
uv_watch_init(xloop, &watch1);
uv_watch_start(&watch1, watch1_func, get_state, 5010);
uv_timer_init(xloop, &timer1);
uv_timer_start(&timer1, time1_func, 1000, 1000);
uv_timer_init(xloop, &timer2);
uv_timer_start(&timer2, time2_func, 5011, 0);
// uv_timer_init(xloop, &timer3);
// uv_timer_start(&timer3, time3_func, 0, 5000);
// uv_timer_init(xloop, &timer4);
// uv_timer_start(&timer4, time4_func, 5000, 0);
uv_run(xloop);
}
static void poll_cb(uv_fs_poll_t* handle,
int status,
const uv_stat_t* prev,
const uv_stat_t* curr) {
uv_stat_t zero_statbuf;
memset(&zero_statbuf, 0, sizeof(zero_statbuf));
ASSERT(handle == &poll_handle);
ASSERT(1 == uv_is_active((uv_handle_t*) handle));
ASSERT(prev != NULL);
ASSERT(curr != NULL);
switch (poll_cb_called++) {
case 0:
ASSERT(status == UV_ENOENT);
ASSERT(0 == memcmp(prev, &zero_statbuf, sizeof(zero_statbuf)));
ASSERT(0 == memcmp(curr, &zero_statbuf, sizeof(zero_statbuf)));
touch_file(FIXTURE);
break;
case 1:
ASSERT(status == 0);
ASSERT(0 == memcmp(prev, &zero_statbuf, sizeof(zero_statbuf)));
ASSERT(0 != memcmp(curr, &zero_statbuf, sizeof(zero_statbuf)));
ASSERT(0 == uv_timer_start(&timer_handle, timer_cb, 20, 0));
break;
case 2:
ASSERT(status == 0);
ASSERT(0 != memcmp(prev, &zero_statbuf, sizeof(zero_statbuf)));
ASSERT(0 != memcmp(curr, &zero_statbuf, sizeof(zero_statbuf)));
ASSERT(0 == uv_timer_start(&timer_handle, timer_cb, 200, 0));
break;
case 3:
ASSERT(status == 0);
ASSERT(0 != memcmp(prev, &zero_statbuf, sizeof(zero_statbuf)));
ASSERT(0 != memcmp(curr, &zero_statbuf, sizeof(zero_statbuf)));
remove(FIXTURE);
break;
case 4:
ASSERT(status == UV_ENOENT);
ASSERT(0 != memcmp(prev, &zero_statbuf, sizeof(zero_statbuf)));
ASSERT(0 == memcmp(curr, &zero_statbuf, sizeof(zero_statbuf)));
uv_close((uv_handle_t*)handle, close_cb);
break;
default:
ASSERT(0);
}
}
void Initialize()
{
uv_timer_init(uv_default_loop(), &G_ThreadTimer);
G_pGateCore = new class CGateCore();
if (G_pGateCore->bInit() == false) {
std::fprintf(stderr, "ERROR: Init fail!\n");
std::exit(1);
return;
}
G_pListenSock = new class XSocket(300);
if (!G_pListenSock->bListen(G_pGateCore->m_cGateServerAddr, G_pGateCore->m_iGateServerPort, WM_USER_ACCEPT))
{
OnDestroy();
std::exit(1);
return;
}
// 서버 검사용 타이머 시작
uv_timer_init(uv_default_loop(), &G_mmTimer0);
uv_timer_start(&G_mmTimer0, &_TimerFunc, 0, 3000);
PutLogList("(!) Gate Server Listening...");
}
static void timer_prepare_cb(uv_prepare_t *handle)
{
TimerData *data = handle->data;
assert(data->ms > 0);
uv_timer_start(data->timer, timer_cb, (uint32_t)data->ms, 0);
uv_prepare_stop(handle);
}
static int event_sched(lua_State *L, unsigned timeout, unsigned repeat)
{
uv_timer_t *timer = malloc(sizeof(*timer));
if (!timer) {
format_error(L, "out of memory");
lua_error(L);
}
/* Start timer with the reference */
uv_loop_t *loop = uv_default_loop();
uv_timer_init(loop, timer);
int ret = uv_timer_start(timer, event_callback, timeout, repeat);
if (ret != 0) {
free(timer);
format_error(L, "couldn't start the event");
lua_error(L);
}
/* Save callback and timer in registry */
lua_newtable(L);
lua_pushvalue(L, 2);
lua_rawseti(L, -2, 1);
lua_pushlightuserdata(L, timer);
lua_rawseti(L, -2, 2);
int ref = luaL_ref(L, LUA_REGISTRYINDEX);
/* Save reference to the timer */
timer->data = (void *) (intptr_t)ref;
lua_pushinteger(L, ref);
return 1;
}
void
reset_timer(struct remote_context *remote) {
if (remote->timer != NULL) {
remote->timer->data = remote;
uv_timer_start(remote->timer, remote_timer_expire, remote->idle_timeout, 0);
}
}
int loq_timer(lua_State *L)
{
int time = luaL_checkinteger(L, 1);
int r = 0;
uv_loop_t* loop = uv_default_loop();
// Create a timer callback and fill it up with what we need.
loq_timer_t *timer = (loq_timer_t*)loq_malloc(sizeof(loq_timer_t));
r = uv_timer_init(loop, &timer->handle);
if(r) {
loq_free(timer);
uv_err_t err = loop->last_err;
return luaL_error(L, uv_strerror(err));
}
timer->L = L;
timer->handle.data = timer;
// Stash the callback in lua.
lua_pushlightuserdata(L, timer);
lua_pushvalue(L, 2);
lua_rawset(L, LUA_REGISTRYINDEX);
// Tell uv we want the timer to start
r = uv_timer_start(&timer->handle, timer_cb, time, 0);
if(r) {
uv_close((uv_handle_t*)&timer->handle, timer_close_cb);
uv_err_t err = loop->last_err;
return luaL_error(L, uv_strerror(err));
}
return 0;
}
static void eof_timer_start(uv_pipe_t* pipe) {
assert(pipe->flags & UV_HANDLE_CONNECTION);
if (pipe->eof_timer != NULL) {
uv_timer_start(pipe->eof_timer, eof_timer_cb, eof_timeout, 0);
}
}
/* u3_temp_io_poll(): update temp IO state.
*/
void
u3_temp_io_poll(void)
{
u3_temp* teh_u = &u3_Host.teh_u;
u3_noun wen = u3v_keep(u3nt(u3_blip, c3__temp, u3_nul));
if ( (u3_nul != wen) &&
(c3y == u3du(wen)) &&
(c3y == u3ud(u3t(wen))) )
{
c3_d gap_d = u3_time_gap_ms(u3k(u3A->now), u3k(u3t(wen)));
#if 0
fprintf(stderr, "gap_d %llu, plus %llu\r\n",
gap_d, gap_d + (c3_d)teh_u->run_w);
#endif
gap_d += teh_u->run_w;
if ( c3y == teh_u->alm ) {
uv_timer_stop(&teh_u->tim_u);
}
else teh_u->alm = c3y;
uv_timer_start(&teh_u->tim_u, _temp_time_cb, gap_d, 0);
}
else {
if ( c3y == teh_u->alm ) {
uv_timer_stop(&teh_u->tim_u);
}
teh_u->alm = c3n;
}
u3z(wen);
}
static void connect_timer_reset_(wsn_client_ctx_t *client)
{
uv_timer_start(&client->timer_handle,
on_connect_timer_expire_,
(unsigned int)client->connect_timeout,
0);
}
void TCPClient::AfterConnect(uv_connect_t* handle, int status)
{
TcpClientCtx* theclass = (TcpClientCtx*)handle->handle->data;
TCPClient* parent = (TCPClient*)theclass->parent_server;
if (status) {
parent->connectstatus_ = CONNECT_ERROR;
parent->errmsg_ = GetUVError(status);
LOG(ERROR)<<"client(" << parent << ") connect error:" << parent->errmsg_;
fprintf(stdout, "connect error:%s\n", parent->errmsg_.c_str());
if (parent->isreconnecting_) {//reconnect failure, restart timer to trigger reconnect.
uv_timer_stop(&parent->reconnect_timer_);
parent->repeat_time_ *= 2;
uv_timer_start(&parent->reconnect_timer_, TCPClient::ReconnectTimer, parent->repeat_time_, parent->repeat_time_);
}
return;
}
int iret = uv_read_start(handle->handle, AllocBufferForRecv, AfterRecv);
if (iret) {
parent->errmsg_ = GetUVError(status);
LOG(ERROR)<<"client(" << parent << ") uv_read_start error:" << parent->errmsg_;
fprintf(stdout, "uv_read_start error:%s\n", parent->errmsg_.c_str());
parent->connectstatus_ = CONNECT_ERROR;
} else {
parent->connectstatus_ = CONNECT_FINISH;
LOG(INFO) << "client(" << parent << ")run";
}
if (parent->isreconnecting_) {
fprintf(stdout, "reconnect succeed\n");
parent->StopReconnect();//reconnect succeed.
if (parent->reconnectcb_) {
parent->reconnectcb_(NET_EVENT_TYPE_RECONNECT, parent->reconnect_userdata_);
}
}
}
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
melo_log_init(&mlog, 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 fs_event_unlink_files_in_subdir(uv_timer_t* handle) {
int r;
int i;
/* NOTE: handle might be NULL if invoked not as timer callback */
if (handle == NULL) {
/* Unlink all files */
for (i = 0; i < 16; i++) {
r = remove(fs_event_get_filename_in_subdir(i));
if (handle != NULL)
ASSERT(r == 0);
}
} else {
/* Make sure we're not attempting to remove files we do not intend */
ASSERT(fs_event_removed < fs_event_file_count);
/* Remove the file */
ASSERT(0 == remove(fs_event_get_filename_in_subdir(fs_event_removed)));
if (++fs_event_removed < fs_event_file_count) {
/* Remove another file on a different event loop tick. We do it this way
* to avoid fs events coalescing into one fs event. */
ASSERT(0 == uv_timer_start(&timer, fs_event_unlink_files_in_subdir, 1, 0));
}
}
}
void curl_perform(uv_poll_t *si, int status, int events) {
int running_handles;
int flags = 0;
Socket_Info *s = (Socket_Info *) si->data;
Mathilda *m = (Mathilda *) s->m;
uv_timer_stop(&m->timeout);
if(status < 0) {
flags = CURL_CSELECT_ERR;
}
if(!status && events & UV_READABLE) {
flags |= CURL_CSELECT_IN;
}
if(!status && events & UV_WRITABLE) {
flags |= CURL_CSELECT_OUT;
}
curl_multi_socket_action(m->multi_handle, s->sock_fd, flags, &running_handles);
check_multi_info(m);
uv_timer_start(&m->timeout, (uv_timer_cb) on_timeout, 0, 0);
}
/* u2_unix_io_poll(): update unix IO state.
*/
void
u2_unix_io_poll(void)
{
u2_unix* unx_u = &u2_Host.unx_u;
u2_noun wen = u2_reck_keep(u2A, u2nt(u2_blip, c3__clay, u2_nul));
if ( (u2_nul != wen) &&
(u2_yes == u2du(wen)) &&
(u2_yes == u2ud(u2t(wen))) )
{
c3_d gap_d = u2_time_gap_ms(u2k(u2A->now), u2k(u2t(wen)));
if ( u2_yes == unx_u->alm ) {
uv_timer_stop(&unx_u->tim_u);
}
else unx_u->alm = u2_yes;
if ( gap_d < 1000 ) { gap_d = 1000; } // band-aid on an unknown clay timer bug
uv_timer_start(&unx_u->tim_u, _unix_time_cb, gap_d, 0);
}
else {
if ( u2_yes == unx_u->alm ) {
uv_timer_stop(&unx_u->tim_u);
}
unx_u->alm = u2_no;
}
u2z(wen);
}
void start_timeout(CURLM *multi, long timeout_ms, void *userp)
{
if (timeout_ms <= 0)
timeout_ms = 1; /* 0 means directly call socket_action, but we'll do it in
a bit */
uv_timer_start(&timeout, on_timeout, timeout_ms, 0);
}
void http_request_cache_configure_listener(uv_loop_t* loop, uv_async_t* handle)
{
uv_timer_t* cache_invalidation_timer = malloc(sizeof(uv_timer_t));
uv_timer_init(loop, cache_invalidation_timer);
uv_timer_start(cache_invalidation_timer, http_request_cache_timer, 500, 500);
uv_unref((uv_handle_t*) cache_invalidation_timer);
}
static void tcp_recv(uv_stream_t *handle, ssize_t nread, const uv_buf_t *buf)
{
uv_loop_t *loop = handle->loop;
struct session *s = handle->data;
struct worker_ctx *worker = loop->data;
/* TCP pipelining is rather complicated and requires cooperation from the worker
* so the whole message reassembly and demuxing logic is inside worker */
int ret = 0;
if (s->has_tls) {
ret = tls_process(worker, handle, (const uint8_t *)buf->base, nread);
} else {
ret = worker_process_tcp(worker, handle, (const uint8_t *)buf->base, nread);
}
if (ret < 0) {
worker_end_tcp(worker, (uv_handle_t *)handle);
/* Exceeded per-connection quota for outstanding requests
* stop reading from stream and close after last message is processed. */
if (!s->outgoing && !uv_is_closing((uv_handle_t *)&s->timeout)) {
uv_timer_stop(&s->timeout);
if (s->tasks.len == 0) {
uv_close((uv_handle_t *)&s->timeout, tcp_timeout);
} else { /* If there are tasks running, defer until they finish. */
uv_timer_start(&s->timeout, tcp_timeout_trigger, 1, KR_CONN_RTT_MAX/2);
}
}
/* Connection spawned more than one request, reset its deadline for next query. */
} else if (ret > 0 && !s->outgoing) {
uv_timer_again(&s->timeout);
}
mp_flush(worker->pkt_pool.ctx);
}
/// Terminates a job. This is a non-blocking operation, but if the job exists
/// it's guaranteed to succeed(SIGKILL will eventually be sent)
///
/// @param job The Job instance
void job_stop(Job *job)
{
if (job->stopped_time) {
return;
}
job->stopped_time = os_hrtime();
if (job->opts.pty) {
// close all streams for pty jobs to send SIGHUP to the process
job_close_streams(job);
pty_process_close_master(job);
} else {
// Close the job's stdin. If the job doesn't close its own stdout/stderr,
// they will be closed when the job exits(possibly due to being terminated
// after a timeout)
close_job_in(job);
}
if (!stop_requests++) {
// When there's at least one stop request pending, start a timer that
// will periodically check if a signal should be send to a to the job
DLOG("Starting job kill timer");
uv_timer_start(&job_stop_timer, job_stop_timer_cb, 100, 100);
}
}
static void _tcp_accept(uv_stream_t *master, int status, bool tls)
{
if (status != 0) {
return;
}
uv_stream_t *client = handle_alloc(master->loop);
if (!client) {
return;
}
memset(client, 0, sizeof(*client));
io_create(master->loop, (uv_handle_t *)client, SOCK_STREAM);
if (uv_accept(master, client) != 0) {
uv_close((uv_handle_t *)client, io_free);
return;
}
/* Set deadlines for TCP connection and start reading.
* It will re-check every half of a request time limit if the connection
* is idle and should be terminated, this is an educated guess. */
struct session *session = client->data;
session->has_tls = tls;
if (tls && !session->tls_ctx) {
session->tls_ctx = tls_new(master->loop->data);
}
uv_timer_t *timer = &session->timeout;
uv_timer_init(master->loop, timer);
timer->data = client;
uv_timer_start(timer, tcp_timeout_trigger, KR_CONN_RTT_MAX/2, KR_CONN_RTT_MAX/2);
io_start_read((uv_handle_t *)client);
}
void SyncWorker::start()
{
uv_timer_start( &this->timer_ ,
SyncWorker::uv_process_timer_tick_callback ,
0 ,
this->loop_time_ );
}
static void(timer_start)(void* t, unsigned int ms)
{
struct LwqqAsyncTimer_* t_ = (struct LwqqAsyncTimer_*)t;
t_->h.data = t;
uv_timer_init(loop, &t_->h);
uv_timer_start(&t_->h, timer_cb_wrap, ms / 10, ms / 10);
}
static void connect_cb(uv_connect_t* req, int status) {
ASSERT(0 == status);
ASSERT(0 == uv_timer_start(&timer_handle, timer_cb, 50, 0));
ASSERT(0 == uv_read_start((uv_stream_t*) &tcp_handle,
(uv_alloc_cb) fail_cb,
(uv_read_cb) fail_cb));
}
Network::Network(const Options *options) :
m_options(options),
m_donate(nullptr)
{
srand(time(0) ^ (uintptr_t) this);
Workers::setListener(this);
const std::vector<Url*> &pools = options->pools();
#ifndef XMRIG_NO_TLS
ssl_init();
#endif
if (pools.size() > 1) {
m_strategy = new FailoverStrategy(pools, Platform::userAgent(), this);
}
else {
m_strategy = new SinglePoolStrategy(pools.front(), Platform::userAgent(), this);
}
if (m_options->donateLevel() > 0) {
m_donate = new DonateStrategy(Platform::userAgent(), this);
}
m_timer.data = this;
uv_timer_init(uv_default_loop(), &m_timer);
uv_timer_start(&m_timer, Network::onTick, kTickInterval, kTickInterval);
}
void loop_poll_events(Loop *loop, int ms)
{
if (loop->recursive++) {
abort(); // Should not re-enter uv_run
}
uv_run_mode mode = UV_RUN_ONCE;
if (ms > 0) {
// Use a repeating timeout of ms milliseconds to make sure
// we do not block indefinitely for I/O.
uv_timer_start(&loop->poll_timer, timer_cb, (uint64_t)ms, (uint64_t)ms);
} else if (ms == 0) {
// For ms == 0, we need to do a non-blocking event poll by
// setting the run mode to UV_RUN_NOWAIT.
mode = UV_RUN_NOWAIT;
}
uv_run(&loop->uv, mode);
if (ms > 0) {
uv_timer_stop(&loop->poll_timer);
}
loop->recursive--; // Can re-enter uv_run now
multiqueue_process_events(loop->fast_events);
}
/**
* When receive connect_frontend command from frontend, change client status that
* the account and password are stored to property, and start timer.
* @param client Frontend that passed this request.
* @param param Parameter contain account, password, frontend type.
*/
void FrontendConnector::recv_connect_frontend(uv_pipe_t& client, picojson::object& param) {
const std::string& type = param.at("type").get<std::string>();
const std::string& account = param.at("account").get<std::string>();
const std::string& password = param.at("password").get<std::string>();
FrontendProperty& property = properties.at(&client);
assert(property.status == PipeStatus::SETUP);
assert(!account.empty() && !password.empty());
if (type == "gui") {
property.type = FrontendType::GUI;
} else if (type == "cui") {
property.type = FrontendType::CUI;
} else {
/// @todo error
assert(false);
}
property.account = account;
property.password = password;
if (!connect_timer_enable) {
uv_timer_start(&connect_timer, on_connect_timer, 0, 1000);
connect_timer_enable = true;
}
}
void HTTPRequest::retryHTTPRequest(std::unique_ptr<Response> &&res, uint64_t timeout) {
assert(uv_thread_self() == thread_id);
assert(!backoff_timer);
backoff_timer = new uv_timer_t();
uv_timer_init(loop, backoff_timer);
backoff_timer->data = new RetryBaton(this, std::move(res));
#if UV_VERSION_MAJOR == 0 && UV_VERSION_MINOR <= 10
uv_timer_start(backoff_timer, [](uv_timer_t *timer, int) {
#else
uv_timer_start(backoff_timer, [](uv_timer_t *timer) {
#endif
std::unique_ptr<RetryBaton> pair { static_cast<RetryBaton *>(timer->data) };
pair->first->startHTTPRequest(std::move(pair->second));
pair->first->backoff_timer = nullptr;
uv_timer_stop(timer);
uv_close((uv_handle_t *)timer, [](uv_handle_t *handle) { delete (uv_timer_t *)handle; });
}, timeout, 0);
}
void HTTPRequest::removeHTTPBaton() {
assert(uv_thread_self() == thread_id);
if (http_baton) {
http_baton->request = nullptr;
HTTPRequestBaton::stop(http_baton);
http_baton.reset();
}
}
grpc_error *grpc_pollset_work(grpc_exec_ctx *exec_ctx, grpc_pollset *pollset,
grpc_pollset_worker **worker_hdl,
gpr_timespec now, gpr_timespec deadline) {
uint64_t timeout;
GRPC_UV_ASSERT_SAME_THREAD();
gpr_mu_unlock(&grpc_polling_mu);
if (grpc_pollset_work_run_loop) {
if (gpr_time_cmp(deadline, now) >= 0) {
timeout = (uint64_t)gpr_time_to_millis(gpr_time_sub(deadline, now));
} else {
timeout = 0;
}
/* We special-case timeout=0 so that we don't bother with the timer when
the loop won't block anyway */
if (timeout > 0) {
uv_timer_start(&pollset->timer, timer_run_cb, timeout, 0);
/* Run until there is some I/O activity or the timer triggers. It doesn't
matter which happens */
uv_run(uv_default_loop(), UV_RUN_ONCE);
uv_timer_stop(&pollset->timer);
} else {
uv_run(uv_default_loop(), UV_RUN_NOWAIT);
}
}
if (!grpc_closure_list_empty(exec_ctx->closure_list)) {
grpc_exec_ctx_flush(exec_ctx);
}
gpr_mu_lock(&grpc_polling_mu);
return GRPC_ERROR_NONE;
}
/* u2_unix_io_poll(): update unix IO state.
*/
void
u2_unix_io_poll(void)
{
u2_unix* unx_u = &u2_Host.unx_u;
u2_noun wen = u2_reck_keep(u2A, u2nt(c3__gold, c3__clay, u2_nul));
if ( (u2_nul != wen) &&
(u2_yes == u2du(wen)) &&
(u2_yes == u2ud(u2t(wen))) )
{
c3_d gap_d = u2_time_gap_ms(u2k(u2A->now), u2k(u2t(wen)));
if ( u2_yes == unx_u->alm ) {
uv_timer_stop(&unx_u->tim_u);
}
else unx_u->alm = u2_yes;
uv_timer_start(&unx_u->tim_u, _unix_time_cb, gap_d, 0);
}
else {
if ( u2_yes == unx_u->alm ) {
uv_timer_stop(&unx_u->tim_u);
}
unx_u->alm = u2_no;
}
u2z(wen);
}
int main(int argc,char** argv) {
loop = uv_default_loop();
if (argc != 2) {
printf("./tdial localaddr");
return -1;
}
msg_len = htonl(132);
//uv_ip4_addr("192.168.8.90", 0, &addr);
if (UV_EINVAL == uv_ip4_addr(argv[1], 0, &addr)) {
printf("bind error: %s\n",argv[1]);
return -1;
}
addr_str = argv[1];
uv_ip4_addr("192.168.3.99", 8999, &addr1);
size_t i;
for(i=0;i<CONN_NUM;i++) {
uv_tcp_init(loop, &c[i].ts);
c[i].ts.data = (void*)i;
c[i].status = STATUS_NOT_CONNECT;
}
uv_timer_t timer_req;
timer_req.data = (void*)0;
uv_timer_init(loop, &timer_req);
uv_timer_start(&timer_req, timer_cb, CONNECT_INTERVAL, CONNECT_INTERVAL);
return uv_run(loop, UV_RUN_DEFAULT);
}
