#include "event_client.h"
#include "ctdl_module.h"
+
+ConstStr IOStates[] = {
+ {HKEY("DB Queue")},
+ {HKEY("DB Q Next")},
+ {HKEY("DB Attach")},
+ {HKEY("DB Next")},
+ {HKEY("DB Stop")},
+ {HKEY("DB Exit")},
+ {HKEY("DB Terminate")},
+ {HKEY("IO Queue")},
+ {HKEY("IO Attach")},
+ {HKEY("IO Connect Socket")},
+ {HKEY("IO Abort")},
+ {HKEY("IO Timeout")},
+ {HKEY("IO ConnFail")},
+ {HKEY("IO ConnFail Now")},
+ {HKEY("IO Conn Now")},
+ {HKEY("IO Conn Wait")},
+ {HKEY("Curl Q")},
+ {HKEY("Curl Start")},
+ {HKEY("Curl Shotdown")},
+ {HKEY("Curl More IO")},
+ {HKEY("Curl Got IO")},
+ {HKEY("Curl Got Data")},
+ {HKEY("Curl Got Status")},
+ {HKEY("C-Ares Start")},
+ {HKEY("C-Ares IO Done")},
+ {HKEY("C-Ares Finished")},
+ {HKEY("C-Ares exit")},
+ {HKEY("Killing")},
+ {HKEY("Exit")}
+};
+
+void SetEVState(AsyncIO *IO, eIOState State)
+{
+
+ CitContext* CCC = IO->CitContext;
+ memcpy(CCC->lastcmdname, IOStates[State].Key, IOStates[State].len + 1);
+
+}
+
+
static void IO_Timeout_callback(struct ev_loop *loop, ev_timer *watcher, int revents);
static void IO_abort_shutdown_callback(struct ev_loop *loop,
ev_cleanup *watcher,
IOAddHandler *h;
int i;
+ SetEVState(IO, eDBQ);
h = (IOAddHandler*)malloc(sizeof(IOAddHandler));
h->IO = IO;
h->EvAttch = CB;
void StopDBWatchers(AsyncIO *IO)
{
+ SetEVState(IO, eDBStop);
ev_cleanup_stop(event_db, &IO->db_abort_by_shutdown);
ev_idle_stop(event_db, &IO->db_unwind_stack);
}
CitContext *Ctx =IO->CitContext;
become_session(Ctx);
+ SetEVState(IO, eDBTerm);
EVM_syslog(LOG_DEBUG, "DBEVENT Terminating.\n");
StopDBWatchers(IO);
DB_PerformNext(struct ev_loop *loop, ev_idle *watcher, int revents)
{
AsyncIO *IO = watcher->data;
+
+ SetEVState(IO, eDBNext);
IO->Now = ev_now(event_db);
EV_syslog(LOG_DEBUG, "%s()", __FUNCTION__);
become_session(IO->CitContext);
eNextState NextDBOperation(AsyncIO *IO, IO_CallBack CB)
{
+ SetEVState(IO, eQDBNext);
IO->NextDBOperation = CB;
ev_idle_init(&IO->db_unwind_stack,
DB_PerformNext);
int revents)
{
AsyncIO *IO = watcher->data;
+
+ SetEVState(IO, eIOAbort);
EV_syslog(LOG_DEBUG, "EVENT Q: %s\n", __FUNCTION__);
IO->Now = ev_now(event_base);
assert(IO->ShutdownAbort);
IOAddHandler *h;
int i;
+ SetEVState(IO, eIOQ);
h = (IOAddHandler*)malloc(sizeof(IOAddHandler));
h->IO = IO;
h->EvAttch = CB;
IOAddHandler *h;
int i;
+ SetEVState(IO, eCurlQ);
h = (IOAddHandler*)malloc(sizeof(IOAddHandler));
h->IO = IO;
h->EvAttch = evcurl_handle_start;
void ShutDownCLient(AsyncIO *IO)
{
CitContext *Ctx =IO->CitContext;
+
+ SetEVState(IO, eExit);
become_session(Ctx);
EVM_syslog(LOG_DEBUG, "EVENT Terminating \n");
{
AsyncIO *IO = watcher->data;
+ SetEVState(IO, eIOTimeout);
IO->Now = ev_now(event_base);
ev_timer_stop (event_base, &IO->rw_timeout);
become_session(IO->CitContext);
{
AsyncIO *IO = watcher->data;
+ SetEVState(IO, eIOConnfail);
IO->Now = ev_now(event_base);
ev_timer_stop (event_base, &IO->conn_fail);
{
AsyncIO *IO = watcher->data;
+ SetEVState(IO, eIOConnfailNow);
IO->Now = ev_now(event_base);
ev_idle_stop (event_base, &IO->conn_fail_immediate);
socklen_t lon = sizeof(so_err);
int err;
+ SetEVState(IO, eIOConnNow);
IO->Now = ev_now(event_base);
EVM_syslog(LOG_DEBUG, "connect() succeeded.\n");
IO_postdns_callback(struct ev_loop *loop, ev_idle *watcher, int revents)
{
AsyncIO *IO = watcher->data;
+
+ SetEVState(IO, eCaresFinished);
IO->Now = ev_now(event_base);
EV_syslog(LOG_DEBUG, "event: %s\n", __FUNCTION__);
become_session(IO->CitContext);
int fdflags;
int rc = -1;
+ SetEVState(IO, eIOConnectSock);
become_session(IO->CitContext);
if (ReadFirst) {
}
if (rc >= 0){
+ SetEVState(IO, eIOConnNow);
EV_syslog(LOG_DEBUG, "connect() = %d immediate success.\n", IO->SendBuf.fd);
set_start_callback(event_base, IO, 0);
return IO->NextState;
}
else if (errno == EINPROGRESS) {
+ SetEVState(IO, eIOConnWait);
EV_syslog(LOG_DEBUG, "connect() = %d have to wait now.\n", IO->SendBuf.fd);
ev_io_init(&IO->conn_event,
return IO->NextState;
}
else {
+ SetEVState(IO, eIOConnfail);
ev_idle_init(&IO->conn_fail_immediate,
IO_connfailimmediate_callback);
IO->conn_fail_immediate.data = IO;
void *pData,
int ReadFirst)
{
+ SetEVState(IO, eIOAttach);
IO->Data = pData;
become_session(IO->CitContext);
ev_cleanup_start(event_base, &IO->abort_by_shutdown);
{
KillOtherSessionContext *Ctx = IO->Data;
+ SetEVState(IO, eKill);
+
if (Ctx->OtherOne->ShutdownAbort != NULL)
Ctx->OtherOne->ShutdownAbort(Ctx->OtherOne);
return eTerminateConnection;
IO);
continue;
}
+ SetEVState(IO, eCurlGotStatus);
EVCURLM_syslog(LOG_DEBUG, "request complete\n");
"%s\n",
curl_multi_strerror(msta));
- ev_cleanup_stop(event_base, &IO->abort_by_shutdown);
+ ev_cleanup_stop(event_base, &IO->abort_by_shutdown);
IO->HttpReq.attached = 0;
switch(IO->SendDone(IO))
}
static size_t
-gotdata(void *data, size_t size, size_t nmemb, void *cglobal) {
+gotdata(void *data, size_t size, size_t nmemb, void *cglobal)
+{
AsyncIO *IO = (AsyncIO*) cglobal;
+ SetEVState(IO, eCurlGotData);
if (IO->HttpReq.ReplyData == NULL)
{
IO->HttpReq.ReplyData = NewStrBufPlain(NULL, SIZ);
return -1;
}
IO = (AsyncIO *) f;
+ SetEVState(IO, eCurlNewIO);
EVCURL_syslog(LOG_DEBUG,
"EVCURL: got socket for URL: %s\n",
IO->ConnectMe->PlainUrl);
curl_multi_assign(mhnd, fd, IO);
}
+ SetEVState(IO, eCurlGotIO);
IO->Now = ev_now(event_base);
Action = "";
if (IO == NULL)
return;
+
+ SetEVState(IO, eCurlShutdown);
IO->Now = ev_now(event_base);
EVCURL_syslog(LOG_DEBUG, "EVENT Curl: %s\n", __FUNCTION__);
CURLcode sta;
CURL *chnd;
+ SetEVState(IO, eCurlStart);
chnd = IO->HttpReq.chnd;
EVCURL_syslog(LOG_DEBUG,
"EVCURL: Loading URL: %s\n", IO->ConnectMe->PlainUrl);
if (h->IO->StartIO == 0.0)
h->IO->StartIO = Now;
+ SetEVState(h->IO, eIOAttach);
+
Ctx = h->IO->CitContext;
become_session(Ctx);
h->IO->StartDB = Now;
h->IO->Now = Now;
+ SetEVState(h->IO, eDBAttach);
Ctx = h->IO->CitContext;
become_session(Ctx);
ev_cleanup_start(event_db, &h->IO->db_abort_by_shutdown);