void Acceptor::handleEvent(int events)
{
std::cout << "acceptor::events" << std::endl;
assert(events && EPOLLIN); //we should make sure the events is epollin
while(true)
{
Socket* newsock = m_socket->accept();
std::cout << "newsock:" << newsock << std::endl;
if( newsock == NULL ){
if( errno == EINTR ) continue;
else if( errno == EWOULDBLOCK
|| errno == EAGAIN ){
return;
}else{
// should not execute here.
// TODO: log error
assert(false);
return;
}
}else{
m_connlist.push_back(newsock);
newsock->setNonBlock();
EventLoop* loop = getNextLoop();
Client* client = new Client(newsock, loop);
loop->registerHandle(client, EPOLLIN|EPOLLERR);
return;
}
}
}
int main(int argc, char* argv[])
{
#ifdef WIN32
WORD wVersionRequested;
WSADATA wsaData;
int err;
wVersionRequested = MAKEWORD(2, 2);
err = WSAStartup(wVersionRequested, &wsaData);
#endif
int numThreads = 0;
if(argc > 1)
{
benchmark = true;
//Logger::setLogLevel(Logger::WARN);
numThreads = atoi(argv[1]);
}
MuduoPlus::LogPrinter = LogPrint;
EventLoop loop;
HttpServer server(&loop, InetAddress("0.0.0.0", 8000), "dummy");
server.setHttpCallback(onRequest);
server.setThreadNum(numThreads);
server.start();
loop.loop();
}
int main()
{
EventLoop loop;
TcpServer s(&loop,true,8001);
s.start();
loop.loop();
}
int main(int argc, char* argv[])
{
int fd = timerfd_create(CLOCK_MONOTONIC,TFD_NONBLOCK | TFD_CLOEXEC);
ChannelPtr channel(new Channel(fd));
channel->setChannel2Read();
channel->setReadCallback(func);
EventLoop loop;
loop.updateChannel(channel);
elp = &loop;
struct itimerspec howlog;
bzero(&howlog, sizeof(howlog));
howlog.it_value.tv_sec = 5;
timerfd_settime(fd,0,&howlog,NULL);
cout << "begin" <<endl;
loop.Start();
close(fd);
return 0;
}
void jni_init()
{
try {
net_thread = std::thread([] {
if (!main_loop.init()) {
return;
}
JNIEnv *env;
bool attached = false;
int status = java_vm->GetEnv((void **)&env, JNI_VERSION_1_4);
if (status < 0) {
LOGE("callback_handler: failed to get JNI environment, assuming native thread");
status = java_vm->AttachCurrentThread(&env, NULL);
if (status < 0) {
LOGE("callback_handler: failed to attach current thread");
}
attached = true;
}
main_loop.loop();
if (attached) {
java_vm->DetachCurrentThread();
}
});
}
catch (...) {
}
}
void ScriptDebugServer::pauseIfNeeded(JSGlobalObject* dynamicGlobalObject)
{
if (m_paused)
return;
if (!getListenersForGlobalObject(dynamicGlobalObject))
return;
bool pauseNow = m_pauseOnNextStatement;
pauseNow |= (m_pauseOnCallFrame == m_currentCallFrame);
pauseNow |= hasBreakpoint(m_currentCallFrame->sourceID(), m_currentCallFrame->position());
if (!pauseNow)
return;
m_pauseOnCallFrame = 0;
m_pauseOnNextStatement = false;
m_paused = true;
dispatchFunctionToListeners(&ScriptDebugServer::dispatchDidPause, dynamicGlobalObject);
didPause(dynamicGlobalObject);
TimerBase::fireTimersInNestedEventLoop();
EventLoop loop;
m_doneProcessingDebuggerEvents = false;
while (!m_doneProcessingDebuggerEvents && !loop.ended())
loop.cycle();
didContinue(dynamicGlobalObject);
dispatchFunctionToListeners(&ScriptDebugServer::dispatchDidContinue, dynamicGlobalObject);
m_paused = false;
}
void TcpServer::newConnection(int sockfd, const InetAddress& peerAddr)
{
loop_->assertInLoopThread();
EventLoop* ioLoop = threadPool_->getNextLoop();
char buf[64];
snprintf(buf, sizeof buf, "-%s#%d", ipPort_.c_str(), nextConnId_);
++nextConnId_;
std::string connName = name_ + buf;
LOG_PRINT(LogType_Info, "TcpServer::newConnection [%s] - new connection [%s] from %s",
name_.c_str(), connName.c_str(), peerAddr.toIpPort().c_str());
InetAddress localAddr(SocketOps::getLocalAddr(sockfd));
// FIXME poll with zero timeout to double confirm the new connection
// FIXME use make_shared if necessary
TcpConnectionPtr conn(new TcpConnection(ioLoop,
connName,
sockfd,
localAddr,
peerAddr));
connections_[connName] = conn;
conn->setConnectionCallback(connectionCallback_);
conn->setMessageCallback(messageCallback_);
conn->setWriteCompleteCallback(writeCompleteCallback_);
conn->setCloseCallback(
std::bind(&TcpServer::removeConnection, this, std::placeholders::_1)); // FIXME: unsafe
ioLoop->runInLoop(std::bind(&TcpConnection::connectEstablished, conn));
}
VOD_SessionControl::~VOD_SessionControl()
{
LOG(DLOGL_REALLY_NOISY, " destruct mVodSessionId: %d ", mVodSessionId);
pthread_mutex_lock(&mVodSessionListMutex);
mActiveVodSessionMap.erase(mVodSessionId);
LOG(DLOGL_REALLY_NOISY, "sendMsgInfoList.size(): %d", sendMsgInfoList.size());
EventLoop* evtLoop = ptrOnDemand->GetEventLoop();
// Remove all event timers and messages from send list
if (!sendMsgInfoList.empty())
{
list<SendMsgInfo *>::iterator itr;
itr = sendMsgInfoList.begin();
while (itr != sendMsgInfoList.end())
{
EventTimer *evt = (*itr)->evtTimer;
LOG(DLOGL_REALLY_NOISY, "evtLoop->delTimer: %p", evt);
if (evtLoop)
{
evtLoop->delTimer(evt);
}
delete *itr;
itr = sendMsgInfoList.erase(itr);
}
}
pthread_mutex_unlock(&mVodSessionListMutex);
LOG(DLOGL_REALLY_NOISY, "exit");
}
int main(int argc, char* argv[])
{
if(argc < 2)
{
printf("Usage : %s <server_port>\n", argv[0]);
return 0;
}
EventLoop loop;
InetAddress serverAddr("127.0.0.1", atoi(argv[1]));
const static int flag = 2;
if (flag == 1)
{
TcpClient client(&loop, serverAddr);
client.enableRetry();
client.setConnectionCallback(test_client::clientConnectionCallback);
client.setMessageCallback(test_client::clientMessageCallback);
client.connect();
loop.addTimer(test_client::sendDataByClient, 1, true); //启动一个每1s运行一次的定时器
loop.loop();
}
else if (flag == 2)
{
test_client_stdin::TestTcpClient client(&loop, serverAddr);
client.connect();
loop.loop();
}
}
int main(int argc, char **argv)
{
plan_tests(1);
ScreenGlobalInit screen;
#ifdef ANDROID
TopWindow main_window;
EventLoop loop(*event_queue, main_window);
Event event;
#elif defined(ENABLE_SDL)
TopWindow main_window;
EventLoop loop(main_window);
SDL_Event event;
#else
EventLoop loop;
MSG event;
#endif
TestNotify notify;
TestThread thread(notify);
thread.Start();
#ifndef USE_GDI
while (!quit && loop.get(event))
loop.dispatch(event);
#else
while (!quit && loop.get(event))
loop.dispatch(event);
#endif
ok1(quit);
return exit_status();
}
int main(int argc, char* argv[])
{
uint16_t port = 9981;
if (argc > 1 )
{
port = static_cast<uint16_t>(atoi(argv[1]));
}
LOG_INFO << "pid=" << getpid() << ",tid=" << CurrentThread::tid();
InetAddress listenAddr(port);
EventLoop loop;
g_eventLoop = &loop;
TcpServer server(&loop, listenAddr, "socks4");
server.setConnectionCallback(onServerConnection);
server.setMessageCallback(onServerMessage);
server.start();
loop.loop();
}
int main(int argc, const char *argv[])
{
EventLoop loop;
g_loop = &loop;
loop.runAfter(30.0, boost::bind(&EventLoop::quit, &loop));
curl::Curl::initialize(curl::Curl::kCURLssl);
curl::Curl curl(&loop);
curl::RequestPtr req = curl.getUrl("http://chenshuo.com");
req->setDataCallback(onData);
req->setDoneCallback(done);
//curl::RequestPtr req2 = curl.getUrl("http://github.com");
// req2->allowRedirect(5);
//req2->setDataCallback(onData);
//req2->setDoneCallback(done);
//curl::RequestPtr req3 = curl.getUrl("http://example.com");
// req3->allowRedirect(5);
//req3->setDataCallback(onData);
//req3->setDoneCallback(done2);
loop.loop();
return 0;
}
// static methods
int BaseConn::SendPkt(net_handle_t handle, PktBase* pkt)
{
EventLoop* el = get_io_event_loop(handle);
PendingEventMgr* event_mgr = g_pending_event_mgr.GetIOResource(handle);
if (el->IsInLoopThread()) {
ConnMap_t::iterator it_conn = event_mgr->conn_map.find(handle);
if (it_conn != event_mgr->conn_map.end()) {
BaseConn* conn = it_conn->second;
if (conn->IsOpen()) {
conn->SendPkt(pkt);
delete pkt;
} else {
conn->AddToWaitPktList(pkt);
}
} else {
delete pkt;
}
} else {
event_mgr->mutex.Lock();
event_mgr->pkt_list.push_back(make_pair(handle, pkt));
event_mgr->mutex.Unlock();
el->Wakeup();
}
return 0;
}
int main(int argc, char *argv[])
{
if(argc != 7)
{
fprintf(stderr, "Usage: %s <host_ip> <port> <threads> <blocksize> <clients> <time>\n", argv[0]);
fprintf(stderr, "for example : %s 0.0.0.0 8888 10 100 1000 5. It means that:\n", argv[0]);
fprintf(stderr, "\tserver address is 0.0.0.0:8888, and\n");
fprintf(stderr, "\tcreate 10 threads, message size is 100 Byte, create 1000 clients, and run 5 seconds\n");
}
else
{
LOG_SET_PRIORITY(zl::base::ZL_LOG_PRIO_WARNING);
const char *ip = argv[1];
uint16_t port = static_cast<uint16_t>(atoi(argv[2]));
int threadCount = atoi(argv[3]);
int blockSize = atoi(argv[4]);
int sessionCount = atoi(argv[5]);
int timeout = atoi(argv[6]);
EventLoop loop;
InetAddress serverAddr(ip, port);
Client client(&loop, serverAddr, blockSize, sessionCount, timeout, threadCount);
loop.loop();
}
}
std::shared_ptr<TcpClient>
EventLoopGroup::creatTcpClient(const std::string &host,
const std::string &service) {
std::shared_ptr<TcpClient> tcpClient = std::make_shared<TcpClient>();
std::weak_ptr<TcpClient> weakTcpClient = tcpClient;
Resolver::async_resolve(
host, service, [this, weakTcpClient](std::list<Endpoint> eps) {
if (weakTcpClient.expired() || eps.empty())
return;
auto tcpClient = weakTcpClient.lock();
SockPtr sockPtr = std::make_shared<Socket>(eps.front());
sockPtr->connect();
EventLoop *loop = robinLoop1(sockPtr->fd());
tcpClient->setEventLoop(loop);
tcpClient->setSocket(sockPtr);
// BUG tcpClient与当前线程不在一个线程上时,可能会引起内存错误
// tcpClient->start();
// FIX
if (loop == EventLoop::curr_thread_loop()) {
tcpClient->start();
} else {
loop->runEventHandler([tcpClient] { tcpClient->start(); });
}
});
return tcpClient;
}
void JavaScriptDebugServer::pauseIfNeeded(Page* page)
{
if (m_paused)
return;
if (!page || !hasListenersInterestedInPage(page))
return;
bool pauseNow = m_pauseOnNextStatement;
pauseNow |= (m_pauseOnCallFrame == m_currentCallFrame);
pauseNow |= (m_currentCallFrame->line() > 0 && hasBreakpoint(m_currentCallFrame->sourceIdentifier(), m_currentCallFrame->line()));
if (!pauseNow)
return;
m_pauseOnCallFrame = 0;
m_pauseOnNextStatement = false;
m_paused = true;
dispatchFunctionToListeners(&JavaScriptDebugListener::didPause, page);
setJavaScriptPaused(page->group(), true);
TimerBase::fireTimersInNestedEventLoop();
EventLoop loop;
m_doneProcessingDebuggerEvents = false;
while (!m_doneProcessingDebuggerEvents && !loop.ended())
loop.cycle();
setJavaScriptPaused(page->group(), false);
m_paused = false;
}
int main(int argc, char** argv)
{
EventLoop mainLoop;
ssdb = std::make_shared<SSDBMultiClient>();
ssdb->startNetThread([&](){
mainLoop.wakeup();
});
ssdb->addProxyConnection(argv[1], atoi(argv[2]));
ssdb->redisGet("hello", [](const std::string& value, const Status& status){
cout << value << endl;
});
for (size_t i = 0; i < 1000; i++)
{
ssdb->redisGet("hello", async_get_callback);
}
ssdb->qpush("mlist", "a", nullptr);
while (true)
{
mainLoop.loop(1);
ssdb->pull();
ssdb->forceSyncRequest();
}
}
EventLoop::~EventLoop() {
uv_ref((uv_handle_t*) &deleteObjectsHandle);
uv_prepare_stop(&deleteObjectsHandle);
uv_close((uv_handle_t*) &deleteObjectsHandle, nullptr);
// Wait remaining handle to close
uv_run(&loop, UV_RUN_DEFAULT);
if(uv_loop_alive(&loop)) {
log(LL_Warning, "Loop still used but delete requested, handles:\n");
uv_walk(&loop,
[](uv_handle_t* handle, void* arg) {
EventLoop* self = (EventLoop*) arg;
const char* type;
switch(handle->type) {
#define X(uc, lc) \
case UV_##uc: \
type = #lc; \
break;
UV_HANDLE_TYPE_MAP(X)
#undef X
default:
type = "<unknown>";
}
self->log(LL_Warning, " [%08X] %s %p\n", handle->flags, type, handle);
},
this);
void VOD_SessionControl::RemoveMessageFromSendList(SendMsgInfo *msgInfo)
{
pthread_mutex_lock(&mVodSessionListMutex);
LOG(DLOGL_REALLY_NOISY, "RemoveMessageFromSendList sendMsgInfoList.size(): %d", sendMsgInfoList.size());
if (!sendMsgInfoList.empty())
{
list<SendMsgInfo *>::iterator itr;
for (itr = sendMsgInfoList.begin(); itr != sendMsgInfoList.end(); ++itr)
{
if ((*itr)->transId == msgInfo->transId)
{
EventLoop* evtLoop = ptrOnDemand->GetEventLoop();
if (evtLoop)
{
evtLoop->delTimer((*itr)->evtTimer);
}
LOG(DLOGL_REALLY_NOISY, "deleting Message with address: %p", *itr);
delete *itr;
*itr = NULL;
sendMsgInfoList.erase(itr);
break;
}
}
}
pthread_mutex_unlock(&mVodSessionListMutex);
}
int main(int argc, char **argv)
{
logging::Init(argv[0], "../../log/log_");
LOG_INFO << "this thread's tid = " << this_thread::get_id();
#ifdef WIN32 //windows
if(sockets::SocketStartUp() != 0){
LOG_SOCKET_FATAL << "Ì×½Ó×Ö³õʼ»¯Ê§°Ü!";
return -1;
}
#endif
const int port = 23;
EventLoop loop;
InetAddress listenAddr(port);
InetAddress peerAddr("127.0.0.1", port);
BaseSvr basesvr(&loop, listenAddr);
basesvr.Start();
basesvr.ConnectToPeer(peerAddr);
basesvr.ConnectToDB("tcp://127.0.0.1:3306", "root", "123456", "svr", 5);
loop.loop();
system("pause");
}
int main(int argc, char *argv[]) {
// Usage : MiniHttpd has two ways to initialize
// (1) simple way, just need one line of code like below
// But please remeber that in this way,
// program will be aborted if @port bind failed. Be care!!!!
//
// ::argus::common::MiniHttpd httpserver(&loop, port);
//
// (2) Second way is divided into two steps.
// firstly construct a MiniHttpd instance named httpserver;
// Secondly call httpserver.bind(port);
// bind() will fail and return false when @port already in use
//
// ::argus::common::MiniHttpd httpserver(&loop);
// bool success = httpserver.bind(port);
// if (!success) {
// LOG(ERROR) << "port bind failed";
// return EXIT_FAIURE;
// }
//
EventLoop loop;
MiniHttpd httpd(&loop, 8889);
httpd.enableLogging(false);
httpd.enableIpFilter(true);
bool succ = httpd.setCallBack("hellocb", callbackOne);
assert(succ);
int ret = loop.loop();
LOG(INFO) << "EventLoop::loop() returns " << ret;
}
void EventLoop::callback_activity(android_app* pApplication, int32_t pCommand)
{
Pegas_log_info_loop("EventLoop::callback_activity [pApplication: %X, pCommand: %d]", pApplication, pCommand);
EventLoop* pInstance = (EventLoop*)pApplication->userData;
pInstance->processActivityEvent(pCommand);
}
int main()
{
EventLoop loop;
TcpServer server(&loop, InetAddress(1079), "Finger");
server.setMessageCallback(onMessage);
server.start();
loop.loop();
}
void EventLoop::PrepareHandle(uv_prepare_t *handle, int status)
{
EventLoop *eventloop = static_cast<EventLoop *>(handle->data);
QGuiApplication *app = eventloop->GetApp();
// if (app->hasPendingEvents())
// app->processEvents();
}
void PageScriptDebugServer::runEventLoopWhilePausedInternal()
{
TimerBase::fireTimersInNestedEventLoop();
EventLoop loop;
while (!m_doneProcessingDebuggerEvents && !loop.ended())
loop.cycle();
}
int main()
{
EventLoop loop;
TestServer server(&loop, "testserver", "127.0.0.1", 5555);
server.start();
loop.loop();
return 0;
}
int main()
{
EventLoop loop;
InetAddress proxyAddr("127.0.0.1", 6001);
dbdky::cma_client::cma_client client(&loop, proxyAddr, "cma_client");
client.setGetSendDataCallback(boost::bind(getTestData, _1));
client.start();
loop.loop();
}
void test()
{
printf("main(): pid = %d, tid = %d\n", getpid(), this_thread::get_id().value());
EventLoop loop;
Thread t(threadFunc);
loop.loop();
t.join();
}
int main()
{
EventLoop el;
InetAddress ia("127.0.0.1", 9527);
TcpServer ts(&el, ia, "TcpServerTest", ServerOption_t::eReusePort);
ts.Start();
el.Loop();
return 0;
}
void runServer(uint16_t port)
{
EventLoop loop;
TcpServer server(&loop, InetAddress(port), "ClockServer");
server.setConnectionCallback(serverConnectionCallback);
server.setMessageCallback(serverMessageCallback);
server.start();
loop.loop();
}
