hyung-hwan/qse
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

renamed worker to connection in QSE::TcpServer

Browse Source
This commit is contained in:
hyung-hwan 2019-06-14 08:35:11 +00:00
parent d3a0140ab6
commit 1fd7626b2e
6 changed files with 299 additions and 234 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

142
qse/include/qse/si/TcpServer.hpp
View File

@ -52,48 +52,44 @@ public:
bool isServing () const QSE_CPP_NOEXCEPT bool isServing () const QSE_CPP_NOEXCEPT
{ {
return this->server_serving; return this->_server_serving;
} }
bool isStopRequested () const QSE_CPP_NOEXCEPT bool isStopRequested () const QSE_CPP_NOEXCEPT
{ {
return this->stop_requested; return this->_stop_requested;
} }
void setStopRequested (bool req) QSE_CPP_NOEXCEPT void setStopRequested (bool req) QSE_CPP_NOEXCEPT
{ {
this->stop_requested = req; this->_stop_requested = req;
} }
qse_size_t getMaxConnections () const QSE_CPP_NOEXCEPT qse_size_t getMaxConnections () const QSE_CPP_NOEXCEPT
{ {
return this->max_connections; return this->_max_connections;
} }
void setMaxConnections (qse_size_t mc) QSE_CPP_NOEXCEPT void setMaxConnections (qse_size_t mc) QSE_CPP_NOEXCEPT
{ {
// don't disconnect worker connections // don't disconnect connection connections
// establised before maxConn is set. // establised before maxConn is set.
// 0 means there's no restriction over // 0 means there's no restriction over
// the number of connection. // the number of connection.
this->max_connections = mc; this->_max_connections = mc;
} }
qse_size_t getWorkerCount () const QSE_CPP_NOEXCEPT
{
return this->worker_list[Worker::LIVE].getSize();
}
qse_size_t getConnectionCount () const QSE_CPP_NOEXCEPT qse_size_t getConnectionCount () const QSE_CPP_NOEXCEPT
{ {
return this->worker_list[Worker::LIVE].getSize(); return this->_connection_list[Connection::LIVE].getSize();
} }
qse_size_t getThreadStackSize () const QSE_CPP_NOEXCEPT qse_size_t getThreadStackSize () const QSE_CPP_NOEXCEPT
{ {
return this->thread_stack_size; return this->_thread_stack_size;
} }
void setThreadStackSize (qse_size_t tss) QSE_CPP_NOEXCEPT void setThreadStackSize (qse_size_t tss) QSE_CPP_NOEXCEPT
{ {
this->thread_stack_size = tss; this->_thread_stack_size = tss;
} }
protected: protected:
@ -108,7 +104,7 @@ protected:
}; };
public: public:
class Worker: public QSE::Thread class Connection: public QSE::Thread
{ {
public: public:
friend class TcpServer; friend class TcpServer;
@ -118,7 +114,7 @@ public:
DEAD = 0, DEAD = 0,
LIVE = 1 LIVE = 1
}; };
Worker (Listener* listener) QSE_CPP_NOEXCEPT: listener(listener), prev_worker(QSE_NULL), next_worker(QSE_NULL), claimed(false), wid(wid_map_t::WID_INVALID) {} Connection (Listener* listener) QSE_CPP_NOEXCEPT: listener(listener), prev_connection(QSE_NULL), next_connection(QSE_NULL), claimed(false), wid(_wid_map_t::WID_INVALID) {}
int main (); int main ();
int stop () QSE_CPP_NOEXCEPT; int stop () QSE_CPP_NOEXCEPT;
@ -129,45 +125,44 @@ public:
TcpServer* getServer() QSE_CPP_NOEXCEPT { return this->listener->server; } TcpServer* getServer() QSE_CPP_NOEXCEPT { return this->listener->server; }
const TcpServer* getServer() const QSE_CPP_NOEXCEPT { return this->listener->server; } const TcpServer* getServer() const QSE_CPP_NOEXCEPT { return this->listener->server; }
Connection* getNextConnection() { return this->next_connection; }
Worker* getNextWorker() { return this->next_worker; } Connection* getPrevConnection() { return this->prev_connection; }
Worker* getPrevWorker() { return this->prev_worker; }
qse_size_t getWid() const { return this->wid; } qse_size_t getWid() const { return this->wid; }
const QSE::SocketAddress& getSourceAddress() const { return this->address; } const QSE::SocketAddress& getSourceAddress() const { return this->address; }
const QSE::Socket& getSocket() const { return this->socket; } const QSE::Socket& getSocket() const { return this->socket; }
Listener* listener; Listener* listener;
Worker* prev_worker; Connection* prev_connection;
Worker* next_worker; Connection* next_connection;
bool claimed; bool claimed;
qse_size_t wid; qse_size_t wid;
QSE::Socket socket; QSE::Socket socket;
QSE::SocketAddress address; QSE::SocketAddress address;
QSE::SpinLock csspl; // spin lock for worker stop QSE::SpinLock csspl; // spin lock for connection stop
}; };
protected: private:
struct wid_map_data_t struct _wid_map_data_t
{ {
int used; int used;
union union
{ {
Worker* worker; Connection* connection;
qse_size_t next; qse_size_t next;
} u; } u;
}; };
struct wid_map_t struct _wid_map_t
{ {
enum enum
{ {
WID_INVALID = (qse_size_t)-1 WID_INVALID = (qse_size_t)-1
}; };
wid_map_t(): ptr(QSE_NULL), capa(0), free_first(WID_INVALID), free_last(WID_INVALID) {} _wid_map_t(): ptr(QSE_NULL), capa(0), free_first(WID_INVALID), free_last(WID_INVALID) {}
wid_map_data_t* ptr; _wid_map_data_t* ptr;
qse_size_t capa; qse_size_t capa;
qse_size_t free_first; qse_size_t free_first;
qse_size_t free_last; qse_size_t free_last;
@ -191,79 +186,78 @@ protected:
qse_size_t count; qse_size_t count;
}; };
struct WorkerList struct ConnectionList
{ {
WorkerList() QSE_CPP_NOEXCEPT: head(QSE_NULL), tail(QSE_NULL), count(0) {} ConnectionList() QSE_CPP_NOEXCEPT: head(QSE_NULL), tail(QSE_NULL), count(0) {}
qse_size_t getSize() const { return this->count; } qse_size_t getSize() const { return this->count; }
Worker* getHead() { return this->head; } Connection* getHead() { return this->head; }
Worker* getTail() { return this->tail; } Connection* getTail() { return this->tail; }
void append (Worker* worker) void append (Connection* connection)
{ {
worker->next_worker = QSE_NULL; connection->next_connection = QSE_NULL;
if (this->count == 0) if (this->count == 0)
{ {
this->head = this->tail = worker; this->head = this->tail = connection;
worker->prev_worker = QSE_NULL; connection->prev_connection = QSE_NULL;
} }
else else
{ {
worker->prev_worker = this->tail; connection->prev_connection = this->tail;
this->tail->next_worker = worker; this->tail->next_connection = connection;
this->tail = worker; this->tail = connection;
} }
this->count++; this->count++;
} }
void remove (Worker* worker) void remove (Connection* connection)
{ {
if (worker->next_worker) if (connection->next_connection)
worker->next_worker->prev_worker = worker->prev_worker; connection->next_connection->prev_connection = connection->prev_connection;
else else
this->tail = worker->prev_worker; this->tail = connection->prev_connection;
if (worker->prev_worker) if (connection->prev_connection)
worker->prev_worker->next_worker = worker->next_worker; connection->prev_connection->next_connection = connection->next_connection;
else else
this->head = worker->next_worker; this->head = connection->next_connection;
worker->prev_worker = QSE_NULL; connection->prev_connection = QSE_NULL;
worker->next_worker = QSE_NULL; connection->next_connection = QSE_NULL;
this->count--; this->count--;
} }
Worker* head; Connection* head;
Worker* tail; Connection* tail;
qse_size_t count; qse_size_t count;
}; };
wid_map_t wid_map; // worker's id map _wid_map_t _wid_map; // connection's id map
ListenerList listener_list; ListenerList _listener_list;
WorkerList worker_list[2]; ConnectionList _connection_list[2];
QSE::SpinLock worker_list_spl; QSE::SpinLock _connection_list_spl;
bool _stop_requested;
bool _server_serving;
qse_size_t _max_connections;
qse_size_t _thread_stack_size;
bool stop_requested; protected:
bool server_serving; friend class TcpServer::Connection;
qse_size_t max_connections; virtual int handle_connection (Connection* connection) = 0;
qse_size_t thread_stack_size;
friend class TcpServer::Worker;
virtual int handle_worker (Worker* worker) = 0;
virtual void errlogfmt (const qse_char_t* fmt, ...) { /* do nothing. subclasses may override this */ } virtual void errlogfmt (const qse_char_t* fmt, ...) { /* do nothing. subclasses may override this */ }
private: private:
void delete_all_workers (Worker::State state) QSE_CPP_NOEXCEPT; void delete_all_connections (Connection::State state) QSE_CPP_NOEXCEPT;
int setup_listeners (const qse_char_t* addrs) QSE_CPP_NOEXCEPT; int setup_listeners (const qse_char_t* addrs) QSE_CPP_NOEXCEPT;
void free_all_listeners () QSE_CPP_NOEXCEPT; void free_all_listeners () QSE_CPP_NOEXCEPT;
int prepare_to_acquire_wid () QSE_CPP_NOEXCEPT; int prepare_to_acquire_wid () QSE_CPP_NOEXCEPT;
void acquire_wid (Worker* worker) QSE_CPP_NOEXCEPT; void acquire_wid (Connection* connection) QSE_CPP_NOEXCEPT;
void release_wid (Worker* worker) QSE_CPP_NOEXCEPT; void release_wid (Connection* connection) QSE_CPP_NOEXCEPT;
void free_wid_map () QSE_CPP_NOEXCEPT; void free__wid_map () QSE_CPP_NOEXCEPT;
static void dispatch_mux_event (qse_mux_t* mux, const qse_mux_evt_t* evt) QSE_CPP_NOEXCEPT; static void dispatch_mux_event (qse_mux_t* mux, const qse_mux_evt_t* evt) QSE_CPP_NOEXCEPT;
}; };
@ -283,9 +277,9 @@ public:
private: private:
F __lfunc; F __lfunc;
int handle_worker (Worker* worker) int handle_connection (Connection* connection)
{ {
return this->__lfunc(this, worker); return this->__lfunc(this, connection);
} }
}; };
@ -305,9 +299,9 @@ public:
private: private:
F __lfunc; F __lfunc;
int handle_worker (Worker* worker) int handle_connection (Connection* connection)
{ {
return this->__lfunc(this, worker); return this->__lfunc(this, connection);
} }
}; };
@ -334,7 +328,7 @@ public:
catch (...) catch (...)
{ {
// upon failure, i set this->__lfunc to null. // upon failure, i set this->__lfunc to null.
// this->handle_worker() will return failure for this. // this->handle_connection() will return failure for this.
this->__lfunc = nullptr; this->__lfunc = nullptr;
} }
} }
@ -345,7 +339,7 @@ public:
} }
template <typename T> template <typename T>
int setWorkerHandler (T&& f) QSE_CPP_NOEXCEPT int setConnectionHandler (T&& f) QSE_CPP_NOEXCEPT
{ {
Callable* lf; Callable* lf;
@ -387,7 +381,7 @@ private:
Callable* __lfunc; Callable* __lfunc;
int handle_worker (Worker* worker) int handle_connection (Connection* connection)
{ {
if (!this->__lfunc) if (!this->__lfunc)
{ {
@ -395,7 +389,7 @@ private:
return -1; return -1;
} }
return this->__lfunc->invoke(worker); return this->__lfunc->invoke(connection);
} }
}; };

7
qse/include/qse/xli/xli.h
View File

@ -735,6 +735,13 @@ QSE_EXPORT qse_xli_pair_t* qse_xli_findpair (
const qse_char_t* fqpn const qse_char_t* fqpn
); );
QSE_EXPORT qse_xli_pair_t* qse_xli_findpairatindex (
qse_xli_t* xli,
const qse_xli_list_t* list,
const qse_char_t* fqpn,
qse_size_t index
);
/** /**
* The qse_xli_setpairwithstr() finds an existing pair with the fully qualified * The qse_xli_setpairwithstr() finds an existing pair with the fully qualified
* pair name and updates its value with a new string value. * pair name and updates its value with a new string value.

276
qse/lib/si/TcpServer.cpp
View File

@ -36,47 +36,47 @@
#define WID_MAP_ALIGN 128 #define WID_MAP_ALIGN 128
#define WID_MAX (wid_map_t::WID_INVALID - 1) #define WID_MAX (_wid_map_t::WID_INVALID - 1)
QSE_BEGIN_NAMESPACE(QSE) QSE_BEGIN_NAMESPACE(QSE)
#include "../cmn/syserr.h" #include "../cmn/syserr.h"
IMPLEMENT_SYSERR_TO_ERRNUM (TcpServer::ErrorNumber, TcpServer::) IMPLEMENT_SYSERR_TO_ERRNUM (TcpServer::ErrorNumber, TcpServer::)
int TcpServer::Worker::main () int TcpServer::Connection::main ()
{ {
int n; int n;
// blockAllSignals is called inside run because // blockAllSignals is called inside run because
// Worker is instantiated in the TcpServer thread. // Connection is instantiated in the TcpServer thread.
// so if it is called in the constructor of Worker, // so if it is called in the constructor of Connection,
// it would just block signals to the TcpProxy thread. // it would just block signals to the TcpProxy thread.
this->blockAllSignals (); // don't care about the result. this->blockAllSignals (); // don't care about the result.
try { n = this->listener->server->handle_worker(this); } try { n = this->listener->server->handle_connection(this); }
catch (...) { n = -1; } catch (...) { n = -1; }
TcpServer* server = this->getServer(); TcpServer* server = this->getServer();
server->worker_list_spl.lock (); server->_connection_list_spl.lock ();
this->csspl.lock (); this->csspl.lock ();
this->socket.close (); this->socket.close ();
this->csspl.unlock (); this->csspl.unlock ();
if (!this->claimed) if (!this->claimed)
{ {
server->worker_list[Worker::LIVE].remove (this); server->_connection_list[Connection::LIVE].remove (this);
server->worker_list[Worker::DEAD].append (this); server->_connection_list[Connection::DEAD].append (this);
} }
server->worker_list_spl.unlock (); server->_connection_list_spl.unlock ();
return n; return n;
} }
int TcpServer::Worker::stop () QSE_CPP_NOEXCEPT int TcpServer::Connection::stop () QSE_CPP_NOEXCEPT
{ {
// the receiver will be notified of the end of // the receiver will be notified of the end of
// the connection by the socket's closing. // the connection by the socket's closing.
// therefore, handle_worker() must return // therefore, handle_connection() must return
// when it detects the end of the connection. // when it detects the end of the connection.
this->csspl.lock (); this->csspl.lock ();
this->socket.shutdown (); this->socket.shutdown ();
@ -86,60 +86,60 @@ int TcpServer::Worker::stop () QSE_CPP_NOEXCEPT
TcpServer::TcpServer (Mmgr* mmgr) QSE_CPP_NOEXCEPT: TcpServer::TcpServer (Mmgr* mmgr) QSE_CPP_NOEXCEPT:
Mmged(mmgr), Mmged(mmgr),
stop_requested(false), _stop_requested(false),
server_serving(false), _server_serving(false),
max_connections(0), _max_connections(0),
thread_stack_size(0) _thread_stack_size(0)
{ {
} }
TcpServer::~TcpServer () QSE_CPP_NOEXCEPT TcpServer::~TcpServer () QSE_CPP_NOEXCEPT
{ {
// QSE_ASSERT (this->server_serving == false); // QSE_ASSERT (this->_server_serving == false);
this->delete_all_workers (Worker::LIVE); this->delete_all_connections (Connection::LIVE);
this->delete_all_workers (Worker::DEAD); this->delete_all_connections (Connection::DEAD);
} }
void TcpServer::free_all_listeners () QSE_CPP_NOEXCEPT void TcpServer::free_all_listeners () QSE_CPP_NOEXCEPT
{ {
Listener* lp; Listener* lp;
while (this->listener_list.head) while (this->_listener_list.head)
{ {
lp = this->listener_list.head; lp = this->_listener_list.head;
this->listener_list.head = lp->next_listener; this->_listener_list.head = lp->next_listener;
this->listener_list.count--; this->_listener_list.count--;
qse_mux_evt_t evt; qse_mux_evt_t evt;
evt.hnd = lp->getHandle(); evt.hnd = lp->getHandle();
qse_mux_delete (this->listener_list.mux, &evt); qse_mux_delete (this->_listener_list.mux, &evt);
lp->close (); lp->close ();
QSE_CPP_DELETE_WITH_MMGR (lp, Listener, this->getMmgr()); // delete lp QSE_CPP_DELETE_WITH_MMGR (lp, Listener, this->getMmgr()); // delete lp
} }
if (this->listener_list.mux_pipe[0] >= 0) if (this->_listener_list.mux_pipe[0] >= 0)
{ {
qse_mux_evt_t evt; qse_mux_evt_t evt;
evt.hnd = this->listener_list.mux_pipe[0]; evt.hnd = this->_listener_list.mux_pipe[0];
qse_mux_delete (this->listener_list.mux, &evt); qse_mux_delete (this->_listener_list.mux, &evt);
close (this->listener_list.mux_pipe[0]); close (this->_listener_list.mux_pipe[0]);
this->listener_list.mux_pipe[0] = -1; this->_listener_list.mux_pipe[0] = -1;
} }
this->listener_list.mux_pipe_spl.lock (); this->_listener_list.mux_pipe_spl.lock ();
if (this->listener_list.mux_pipe[1] >= 0) if (this->_listener_list.mux_pipe[1] >= 0)
{ {
close (this->listener_list.mux_pipe[1]); close (this->_listener_list.mux_pipe[1]);
this->listener_list.mux_pipe[1] = -1; this->_listener_list.mux_pipe[1] = -1;
} }
this->listener_list.mux_pipe_spl.unlock (); this->_listener_list.mux_pipe_spl.unlock ();
QSE_ASSERT (this->listener_list.mux != QSE_NULL); QSE_ASSERT (this->_listener_list.mux != QSE_NULL);
qse_mux_close (this->listener_list.mux); qse_mux_close (this->_listener_list.mux);
this->listener_list.mux = QSE_NULL; this->_listener_list.mux = QSE_NULL;
} }
struct mux_xtn_t struct mux_xtn_t
@ -156,7 +156,7 @@ void TcpServer::dispatch_mux_event (qse_mux_t* mux, const qse_mux_evt_t* evt) QS
if (mux_xtn->first_time) if (mux_xtn->first_time)
{ {
server->delete_all_workers(Worker::DEAD); server->delete_all_connections(Connection::DEAD);
mux_xtn->first_time = false; mux_xtn->first_time = false;
} }
@ -166,43 +166,43 @@ void TcpServer::dispatch_mux_event (qse_mux_t* mux, const qse_mux_evt_t* evt) QS
{ {
/* just consume data written by TcpServer::stop() */ /* just consume data written by TcpServer::stop() */
char tmp[128]; char tmp[128];
while (::read(server->listener_list.mux_pipe[0], tmp, QSE_SIZEOF(tmp)) > 0) /* nothing */; while (::read(server->_listener_list.mux_pipe[0], tmp, QSE_SIZEOF(tmp)) > 0) /* nothing */;
} }
else else
{ {
/* the reset should be the listener's socket */ /* the reset should be the listener's socket */
Listener* lsck = (Listener*)evt->data; Listener* lsck = (Listener*)evt->data;
if (server->max_connections > 0 && server->max_connections <= server->worker_list[Worker::LIVE].getSize()) if (server->_max_connections > 0 && server->_max_connections <= server->_connection_list[Connection::LIVE].getSize())
{ {
// too many connections. accept the connection and close it. // too many connections. accept the connection and close it.
server->errlogfmt (QSE_T("too many connections - %zu\n"), server->worker_list[Worker::LIVE].getSize()); server->errlogfmt (QSE_T("too many connections - %zu\n"), server->_connection_list[Connection::LIVE].getSize());
goto accept_and_drop; goto accept_and_drop;
} }
Worker* worker; Connection* connection;
// allocating the worker object before accept is // allocating the connection object before accept is
// a bit awkward. but socket.accept() can be passed // a bit awkward. but socket.accept() can be passed
// the socket field inside the worker object. // the socket field inside the connection object.
try { worker = new(server->getMmgr()) Worker(lsck); } try { connection = new(server->getMmgr()) Connection(lsck); }
catch (...) catch (...)
{ {
// memory alloc failed. accept the connection and close it. // memory alloc failed. accept the connection and close it.
server->errlogfmt (QSE_T("unable to instantiate worker\n")); server->errlogfmt (QSE_T("unable to instantiate connection\n"));
goto accept_and_drop; goto accept_and_drop;
} }
if (server->wid_map.free_first == wid_map_t::WID_INVALID && server->prepare_to_acquire_wid() <= -1) if (server->_wid_map.free_first == _wid_map_t::WID_INVALID && server->prepare_to_acquire_wid() <= -1)
{ {
server->errlogfmt (QSE_T("unable to assign id to worker\n")); server->errlogfmt (QSE_T("unable to assign id to connection\n"));
QSE_CPP_DELETE_WITH_MMGR (worker, Worker, server->getMmgr()); QSE_CPP_DELETE_WITH_MMGR (connection, Connection, server->getMmgr());
goto accept_and_drop; goto accept_and_drop;
} }
if (lsck->accept(&worker->socket, &worker->address, Socket::T_CLOEXEC) <= -1) if (lsck->accept(&connection->socket, &connection->address, Socket::T_CLOEXEC) <= -1)
{ {
server->errlogfmt (QSE_T("unable to accept connection - %hs\n"), strerror(errno)); server->errlogfmt (QSE_T("unable to accept connection - %hs\n"), strerror(errno));
QSE_CPP_DELETE_WITH_MMGR (worker, Worker, server->getMmgr()); QSE_CPP_DELETE_WITH_MMGR (connection, Connection, server->getMmgr());
if (server->isStopRequested()) return; /* normal termination requested */ if (server->isStopRequested()) return; /* normal termination requested */
@ -214,27 +214,27 @@ void TcpServer::dispatch_mux_event (qse_mux_t* mux, const qse_mux_evt_t* evt) QS
return; return;
} }
server->worker_list_spl.lock (); server->_connection_list_spl.lock ();
server->worker_list[Worker::LIVE].append (worker); server->_connection_list[Connection::LIVE].append (connection);
server->worker_list_spl.unlock (); server->_connection_list_spl.unlock ();
server->acquire_wid (worker); server->acquire_wid (connection);
worker->setStackSize (server->thread_stack_size); connection->setStackSize (server->_thread_stack_size);
#if defined(_WIN32) #if defined(_WIN32)
if (worker->start(Thread::DETACHED) <= -1) if (connection->start(Thread::DETACHED) <= -1)
#else #else
if (worker->start(0) <= -1) if (connection->start(0) <= -1)
#endif #endif
{ {
qse_char_t addrbuf[128]; qse_char_t addrbuf[128];
server->errlogfmt (QSE_T("unable to start worker for connection from %s\n"), worker->address.toStrBuf(addrbuf, QSE_COUNTOF(addrbuf))); server->errlogfmt (QSE_T("unable to start connection for connection from %s\n"), connection->address.toStrBuf(addrbuf, QSE_COUNTOF(addrbuf)));
server->worker_list_spl.lock (); server->_connection_list_spl.lock ();
server->worker_list[Worker::LIVE].remove (worker); server->_connection_list[Connection::LIVE].remove (connection);
server->worker_list_spl.unlock (); server->_connection_list_spl.unlock ();
server->release_wid (worker); server->release_wid (connection);
QSE_CPP_DELETE_WITH_MMGR (worker, Worker, server->getMmgr()); QSE_CPP_DELETE_WITH_MMGR (connection, Connection, server->getMmgr());
return; return;
} }
@ -363,9 +363,9 @@ int TcpServer::setup_listeners (const qse_char_t* addrs) QSE_CPP_NOEXCEPT
} }
lsck->address = sockaddr; lsck->address = sockaddr;
lsck->next_listener = this->listener_list.head; lsck->next_listener = this->_listener_list.head;
this->listener_list.head = lsck; this->_listener_list.head = lsck;
this->listener_list.count++; this->_listener_list.count++;
goto segment_done; // lsck has been added to the listener list. i must not close and destroy it goto segment_done; // lsck has been added to the listener list. i must not close and destroy it
skip_segment: skip_segment:
@ -381,7 +381,7 @@ int TcpServer::setup_listeners (const qse_char_t* addrs) QSE_CPP_NOEXCEPT
addr_ptr = comma + 1; addr_ptr = comma + 1;
} }
if (!this->listener_list.head) if (!this->_listener_list.head)
{ {
if (this->getErrorNumber() == E_ENOERR) if (this->getErrorNumber() == E_ENOERR)
{ {
@ -395,14 +395,14 @@ int TcpServer::setup_listeners (const qse_char_t* addrs) QSE_CPP_NOEXCEPT
goto oops; goto oops;
} }
this->listener_list.mux = mux; this->_listener_list.mux = mux;
this->listener_list.mux_pipe[0] = pfd[0]; this->_listener_list.mux_pipe[0] = pfd[0];
this->listener_list.mux_pipe[1] = pfd[1]; this->_listener_list.mux_pipe[1] = pfd[1];
return 0; return 0;
oops: oops:
if (this->listener_list.head) this->free_all_listeners (); if (this->_listener_list.head) this->free_all_listeners ();
if (pfd[0] >= 0) close (pfd[0]); if (pfd[0] >= 0) close (pfd[0]);
if (pfd[1] >= 0) close (pfd[1]); if (pfd[1] >= 0) close (pfd[1]);
if (mux) qse_mux_close (mux); if (mux) qse_mux_close (mux);
@ -413,19 +413,19 @@ int TcpServer::start (const qse_char_t* addrs) QSE_CPP_NOEXCEPT
{ {
int xret = 0; int xret = 0;
this->server_serving = true; this->_server_serving = true;
this->setStopRequested (false); this->setStopRequested (false);
try try
{ {
if (this->setup_listeners(addrs) <= -1) if (this->setup_listeners(addrs) <= -1)
{ {
this->server_serving = false; this->_server_serving = false;
this->setStopRequested (false); this->setStopRequested (false);
return -1; return -1;
} }
mux_xtn_t* mux_xtn = (mux_xtn_t*)qse_mux_getxtn(this->listener_list.mux); mux_xtn_t* mux_xtn = (mux_xtn_t*)qse_mux_getxtn(this->_listener_list.mux);
while (!this->isStopRequested()) while (!this->isStopRequested())
{ {
@ -433,10 +433,10 @@ int TcpServer::start (const qse_char_t* addrs) QSE_CPP_NOEXCEPT
mux_xtn->first_time = true; mux_xtn->first_time = true;
n = qse_mux_poll(this->listener_list.mux, QSE_NULL); n = qse_mux_poll(this->_listener_list.mux, QSE_NULL);
if (n <= -1) if (n <= -1)
{ {
qse_mux_errnum_t merr = qse_mux_geterrnum(this->listener_list.mux); qse_mux_errnum_t merr = qse_mux_geterrnum(this->_listener_list.mux);
if (merr != QSE_MUX_EINTR) if (merr != QSE_MUX_EINTR)
{ {
this->setErrorNumber (E_ESYSERR); // TODO: proper error code conversion this->setErrorNumber (E_ESYSERR); // TODO: proper error code conversion
@ -446,34 +446,34 @@ int TcpServer::start (const qse_char_t* addrs) QSE_CPP_NOEXCEPT
} }
} }
this->delete_all_workers (Worker::LIVE); this->delete_all_connections (Connection::LIVE);
this->delete_all_workers (Worker::DEAD); this->delete_all_connections (Connection::DEAD);
} }
catch (...) catch (...)
{ {
this->delete_all_workers (Worker::LIVE); this->delete_all_connections (Connection::LIVE);
this->delete_all_workers (Worker::DEAD); this->delete_all_connections (Connection::DEAD);
this->setErrorNumber (E_EEXCEPT); this->setErrorNumber (E_EEXCEPT);
this->server_serving = false; this->_server_serving = false;
this->setStopRequested (false); this->setStopRequested (false);
this->free_all_listeners (); this->free_all_listeners ();
this->free_wid_map (); this->free__wid_map ();
return -1; return -1;
} }
this->server_serving = false; this->_server_serving = false;
this->setStopRequested (false); this->setStopRequested (false);
this->free_all_listeners (); this->free_all_listeners ();
this->free_wid_map (); this->free__wid_map ();
return xret; return xret;
} }
int TcpServer::stop () QSE_CPP_NOEXCEPT int TcpServer::stop () QSE_CPP_NOEXCEPT
{ {
if (this->server_serving) if (this->_server_serving)
{ {
// set stop request before writing "Q" to avoid race condition. // set stop request before writing "Q" to avoid race condition.
// after qse_mux_poll() detects activity for "Q" written, // after qse_mux_poll() detects activity for "Q" written,
@ -483,37 +483,37 @@ int TcpServer::stop () QSE_CPP_NOEXCEPT
// doesn't see it set to true yet. // doesn't see it set to true yet.
this->setStopRequested (true); this->setStopRequested (true);
this->listener_list.mux_pipe_spl.lock (); this->_listener_list.mux_pipe_spl.lock ();
if (this->listener_list.mux_pipe[1] >= 0) if (this->_listener_list.mux_pipe[1] >= 0)
{ {
::write (this->listener_list.mux_pipe[1], "Q", 1); ::write (this->_listener_list.mux_pipe[1], "Q", 1);
} }
this->listener_list.mux_pipe_spl.unlock (); this->_listener_list.mux_pipe_spl.unlock ();
} }
return 0; return 0;
} }
void TcpServer::delete_all_workers (Worker::State state) QSE_CPP_NOEXCEPT void TcpServer::delete_all_connections (Connection::State state) QSE_CPP_NOEXCEPT
{ {
Worker* worker; Connection* connection;
while (1) while (1)
{ {
this->worker_list_spl.lock(); this->_connection_list_spl.lock();
worker = this->worker_list[state].getHead(); connection = this->_connection_list[state].getHead();
if (worker) if (connection)
{ {
this->worker_list[state].remove (worker); this->_connection_list[state].remove (connection);
worker->claimed = true; connection->claimed = true;
worker->stop(); connection->stop();
} }
this->worker_list_spl.unlock(); this->_connection_list_spl.unlock();
if (!worker) break; if (!connection) break;
worker->join (); connection->join ();
this->release_wid (worker); this->release_wid (connection);
QSE_CPP_DELETE_WITH_MMGR (worker, Worker, this->getMmgr()); // delete worker QSE_CPP_DELETE_WITH_MMGR (connection, Connection, this->getMmgr()); // delete connection
} }
} }
@ -521,15 +521,15 @@ int TcpServer::prepare_to_acquire_wid () QSE_CPP_NOEXCEPT
{ {
qse_size_t new_capa; qse_size_t new_capa;
qse_size_t i, j; qse_size_t i, j;
wid_map_data_t* tmp; _wid_map_data_t* tmp;
QSE_ASSERT (this->wid_map.free_first == wid_map_t::WID_INVALID); QSE_ASSERT (this->_wid_map.free_first == _wid_map_t::WID_INVALID);
QSE_ASSERT (this->wid_map.free_last == wid_map_t::WID_INVALID); QSE_ASSERT (this->_wid_map.free_last == _wid_map_t::WID_INVALID);
new_capa = QSE_ALIGNTO_POW2(this->wid_map.capa + 1, WID_MAP_ALIGN); new_capa = QSE_ALIGNTO_POW2(this->_wid_map.capa + 1, WID_MAP_ALIGN);
if (new_capa > WID_MAX) if (new_capa > WID_MAX)
{ {
if (this->wid_map.capa >= WID_MAX) if (this->_wid_map.capa >= WID_MAX)
{ {
this->setErrorNumber (E_ENOMEM); // TODO: proper error code this->setErrorNumber (E_ENOMEM); // TODO: proper error code
return -1; return -1;
@ -538,73 +538,73 @@ int TcpServer::prepare_to_acquire_wid () QSE_CPP_NOEXCEPT
new_capa = WID_MAX; new_capa = WID_MAX;
} }
tmp = (wid_map_data_t*)this->getMmgr()->reallocate(this->wid_map.ptr, QSE_SIZEOF(*tmp) * new_capa, false); tmp = (_wid_map_data_t*)this->getMmgr()->reallocate(this->_wid_map.ptr, QSE_SIZEOF(*tmp) * new_capa, false);
if (!tmp) if (!tmp)
{ {
this->setErrorNumber (E_ENOMEM); this->setErrorNumber (E_ENOMEM);
return -1; return -1;
} }
this->wid_map.free_first = this->wid_map.capa; this->_wid_map.free_first = this->_wid_map.capa;
for (i = this->wid_map.capa, j = this->wid_map.capa + 1; j < new_capa; i++, j++) for (i = this->_wid_map.capa, j = this->_wid_map.capa + 1; j < new_capa; i++, j++)
{ {
tmp[i].used = 0; tmp[i].used = 0;
tmp[i].u.next = j; tmp[i].u.next = j;
} }
tmp[i].used = 0; tmp[i].used = 0;
tmp[i].u.next = wid_map_t::WID_INVALID; tmp[i].u.next = _wid_map_t::WID_INVALID;
this->wid_map.free_last = i; this->_wid_map.free_last = i;
this->wid_map.ptr = tmp; this->_wid_map.ptr = tmp;
this->wid_map.capa = new_capa; this->_wid_map.capa = new_capa;
return 0; return 0;
} }
void TcpServer::acquire_wid (Worker* worker) QSE_CPP_NOEXCEPT void TcpServer::acquire_wid (Connection* connection) QSE_CPP_NOEXCEPT
{ {
qse_size_t wid; qse_size_t wid;
wid = this->wid_map.free_first; wid = this->_wid_map.free_first;
worker->wid = wid; connection->wid = wid;
this->wid_map.free_first = this->wid_map.ptr[wid].u.next; this->_wid_map.free_first = this->_wid_map.ptr[wid].u.next;
if (this->wid_map.free_first == wid_map_t::WID_INVALID) this->wid_map.free_last = wid_map_t::WID_INVALID; if (this->_wid_map.free_first == _wid_map_t::WID_INVALID) this->_wid_map.free_last = _wid_map_t::WID_INVALID;
this->wid_map.ptr[wid].used = 1; this->_wid_map.ptr[wid].used = 1;
this->wid_map.ptr[wid].u.worker = worker; this->_wid_map.ptr[wid].u.connection = connection;
} }
void TcpServer::release_wid (Worker* worker) QSE_CPP_NOEXCEPT void TcpServer::release_wid (Connection* connection) QSE_CPP_NOEXCEPT
{ {
qse_size_t wid; qse_size_t wid;
wid = worker->wid; wid = connection->wid;
QSE_ASSERT (wid < this->wid_map.capa && wid != wid_map_t::WID_INVALID); QSE_ASSERT (wid < this->_wid_map.capa && wid != _wid_map_t::WID_INVALID);
this->wid_map.ptr[wid].used = 0; this->_wid_map.ptr[wid].used = 0;
this->wid_map.ptr[wid].u.next = wid_map_t::WID_INVALID; this->_wid_map.ptr[wid].u.next = _wid_map_t::WID_INVALID;
if (this->wid_map.free_last == wid_map_t::WID_INVALID) if (this->_wid_map.free_last == _wid_map_t::WID_INVALID)
{ {
QSE_ASSERT (this->wid_map.free_first <= wid_map_t::WID_INVALID); QSE_ASSERT (this->_wid_map.free_first <= _wid_map_t::WID_INVALID);
this->wid_map.free_first = wid; this->_wid_map.free_first = wid;
} }
else else
{ {
this->wid_map.ptr[this->wid_map.free_last].u.next = wid; this->_wid_map.ptr[this->_wid_map.free_last].u.next = wid;
} }
this->wid_map.free_last = wid; this->_wid_map.free_last = wid;
worker->wid = wid_map_t::WID_INVALID; connection->wid = _wid_map_t::WID_INVALID;
} }
void TcpServer::free_wid_map () QSE_CPP_NOEXCEPT void TcpServer::free__wid_map () QSE_CPP_NOEXCEPT
{ {
if (this->wid_map.ptr) if (this->_wid_map.ptr)
{ {
this->getMmgr()->dispose (this->wid_map.ptr); this->getMmgr()->dispose (this->_wid_map.ptr);
this->wid_map.capa = 0; this->_wid_map.capa = 0;
this->wid_map.free_first = wid_map_t::WID_INVALID; this->_wid_map.free_first = _wid_map_t::WID_INVALID;
this->wid_map.free_last = wid_map_t::WID_INVALID; this->_wid_map.free_last = _wid_map_t::WID_INVALID;
} }
} }

64
qse/lib/xli/xli.c
View File

@ -886,6 +886,70 @@ noent:
return QSE_NULL; return QSE_NULL;
} }
#include <qse/si/sio.h>
qse_xli_pair_t* qse_xli_findpairatindex (qse_xli_t* xli, const qse_xli_list_t* list, const qse_char_t* fqpn, qse_size_t idx)
{
const qse_char_t* ptr;
const qse_xli_list_t* curlist;
fqpn_seg_t seg;
curlist = list? list: &xli->root->list;
ptr = fqpn;
while (1)
{
qse_xli_pair_t* pair;
ptr = get_next_fqpn_segment(xli, ptr, &seg);
if (ptr == QSE_NULL) return QSE_NULL;
if (curlist->type != QSE_XLI_LIST)
{
/* check the type of curlist. this check is needed
* because of the unconditional switching at the bottom of the
* this loop. this implementation strategy has been chosen
* to provide the segment name easily when setting the error. */
goto noent;
}
qse_printf (QSE_T(">>>> key [%js]\n"), seg.key);
switch (seg.idxtype)
{
case FQPN_SEG_IDX_NONE:
pair = find_pair_by_key_and_alias(xli, curlist, &seg.key, QSE_NULL);
break;
case FQPN_SEG_IDX_NUMBER:
pair = find_pair_by_key_and_index(xli, curlist, &seg.key, seg.idx.number);
break;
default: /*case FQPN_SEG_IDX_ALIAS:*/
pair = find_pair_by_key_and_alias(xli, curlist, &seg.key, &seg.idx.alias);
break;
}
if (pair == QSE_NULL) goto noent;
if (*ptr == QSE_T('\0')) return pair; /* no more segments */
/* more segments to handle */
QSE_ASSERT (*ptr == xli->opt.key_splitter);
ptr++; /* skip . */
/* switch to the value regardless of its type.
* check if it is a list in the beginning of the loop
* just after having gotten the next segment alias */
curlist = (qse_xli_list_t*)pair->val;
}
/* this part must never be reached */
qse_xli_seterrnum (xli, QSE_XLI_EINTERN, QSE_NULL);
return QSE_NULL;
noent:
qse_xli_seterrnum (xli, QSE_XLI_ENOENT, &seg.ki);
return QSE_NULL;
}
qse_xli_pair_t* qse_xli_setpairwithstr (qse_xli_t* xli, const qse_xli_list_t* list, const qse_char_t* fqpn, const qse_cstr_t* value, const qse_char_t* strtag) qse_xli_pair_t* qse_xli_setpairwithstr (qse_xli_t* xli, const qse_xli_list_t* list, const qse_char_t* fqpn, const qse_cstr_t* value, const qse_char_t* strtag)
{ {
qse_xli_pair_t* pair, * xpair; qse_xli_pair_t* pair, * xpair;

14
qse/samples/si/tcpsvr01.cpp
View File

@ -25,32 +25,32 @@
class ClientHandler class ClientHandler
{ {
public: public:
int operator() (QSE::TcpServer* server, QSE::TcpServer::Worker* worker) int operator() (QSE::TcpServer* server, QSE::TcpServer::Connection* connection)
{ {
qse_char_t addrbuf[128]; qse_char_t addrbuf[128];
qse_uint8_t bb[256]; qse_uint8_t bb[256];
qse_ssize_t n; qse_ssize_t n;
worker->address.toStrBuf(addrbuf, QSE_COUNTOF(addrbuf)); connection->address.toStrBuf(addrbuf, QSE_COUNTOF(addrbuf));
qse_printf (QSE_T("hello word..from %s -> wid %zu\n"), addrbuf, worker->getWid()); qse_printf (QSE_T("hello word..from %s -> wid %zu\n"), addrbuf, connection->getWid());
while (!server->isStopRequested()) while (!server->isStopRequested())
{ {
if ((n = worker->socket.receive(bb, QSE_COUNTOF(bb))) <= 0) if ((n = connection->socket.receive(bb, QSE_COUNTOF(bb))) <= 0)
{ {
qse_printf (QSE_T("%zd bytes received from %s\n"), n, addrbuf); qse_printf (QSE_T("%zd bytes received from %s\n"), n, addrbuf);
break; break;
} }
worker->socket.send (bb, n); connection->socket.send (bb, n);
} }
qse_printf (QSE_T("byte to %s -> wid %zu\n"), addrbuf, worker->getWid()); qse_printf (QSE_T("byte to %s -> wid %zu\n"), addrbuf, connection->getWid());
return 0; return 0;
} }
}; };
#if defined(QSE_LANG_CPP11) #if defined(QSE_LANG_CPP11)
static QSE::TcpServerL<int(QSE::TcpServer::Worker*)>* g_server; static QSE::TcpServerL<int(QSE::TcpServer::Connection*)>* g_server;
#else #else
static QSE::TcpServerF<ClientHandler>* g_server; static QSE::TcpServerF<ClientHandler>* g_server;
#endif #endif

30
qse/samples/si/tcpsvr02.cpp
View File

@ -18,29 +18,29 @@
#include <string.h> #include <string.h>
#if defined(QSE_LANG_CPP11) #if defined(QSE_LANG_CPP11)
QSE::TcpServerL<int(QSE::TcpServer::Worker*)>* g_server; QSE::TcpServerL<int(QSE::TcpServer::Connection*)>* g_server;
#else #else
class ClientHandler class ClientHandler
{ {
public: public:
int operator() (QSE::TcpServer* server, QSE::TcpServer::Worker* worker) int operator() (QSE::TcpServer* server, QSE::TcpServer::Connection* connection)
{ {
qse_char_t addrbuf[128]; qse_char_t addrbuf[128];
qse_uint8_t bb[256]; qse_uint8_t bb[256];
qse_ssize_t n; qse_ssize_t n;
worker->address.toStrBuf(addrbuf, QSE_COUNTOF(addrbuf)); connection->address.toStrBuf(addrbuf, QSE_COUNTOF(addrbuf));
qse_printf (QSE_T("hello word..from %s[%zu]\n"), addrbuf, worker->getWid()); qse_printf (QSE_T("hello word..from %s[%zu]\n"), addrbuf, connection->getWid());
QSE::Sttp sttp (&worker->socket); QSE::Sttp sttp (&connection->socket);
QSE::SttpCmd cmd; QSE::SttpCmd cmd;
while (!server->isStopRequested()) while (!server->isStopRequested())
{ {
int n = sttp.receiveCmd(&cmd); int n = sttp.receiveCmd(&cmd);
if (n <= -1) if (n <= -1)
{ {
qse_printf (QSE_T("%s[%zu] -> got error\n"), addrbuf, worker->getWid()); qse_printf (QSE_T("%s[%zu] -> got error\n"), addrbuf, connection->getWid());
break; break;
} }
else if (n == 0) break; else if (n == 0) break;
@ -51,7 +51,7 @@ public:
sttp.sendCmd(cmd); sttp.sendCmd(cmd);
} }
qse_printf (QSE_T("byte to %s -> wid %zu\n"), addrbuf, worker->getWid()); qse_printf (QSE_T("byte to %s -> wid %zu\n"), addrbuf, connection->getWid());
return 0; return 0;
} }
}; };
@ -65,36 +65,36 @@ static int test1 (void)
QSE::HeapMmgr heap_mmgr (30000, QSE::Mmgr::getDFL()); QSE::HeapMmgr heap_mmgr (30000, QSE::Mmgr::getDFL());
#if defined(QSE_LANG_CPP11) #if defined(QSE_LANG_CPP11)
QSE::TcpServerL<int(QSE::TcpServer::Worker*)> server ( QSE::TcpServerL<int(QSE::TcpServer::Connection*)> server (
// workload by lambda // workload by lambda
([&server](QSE::TcpServer::Worker* worker) { ([&server](QSE::TcpServer::Connection* connection) {
qse_char_t addrbuf[128]; qse_char_t addrbuf[128];
qse_uint8_t bb[256]; qse_uint8_t bb[256];
qse_ssize_t n; qse_ssize_t n;
worker->address.toStrBuf(addrbuf, QSE_COUNTOF(addrbuf)); connection->address.toStrBuf(addrbuf, QSE_COUNTOF(addrbuf));
qse_printf (QSE_T("hello word..from %s --> wid %zu\n"), addrbuf, worker->getWid()); qse_printf (QSE_T("hello word..from %s --> wid %zu\n"), addrbuf, connection->getWid());
QSE::Sttp sttp (&worker->socket); QSE::Sttp sttp (&connection->socket);
QSE::SttpCmd cmd; QSE::SttpCmd cmd;
while (!server.isStopRequested()) while (!server.isStopRequested())
{ {
int n = sttp.receiveCmd(&cmd); int n = sttp.receiveCmd(&cmd);
if (n <= -1) if (n <= -1)
{ {
qse_printf (QSE_T("%s<%zu> --> got error\n"), addrbuf, worker->getWid()); qse_printf (QSE_T("%s<%zu> --> got error\n"), addrbuf, connection->getWid());
break; break;
} }
else if (n == 0) break; else if (n == 0) break;
if (cmd.name == QSE_T("quit")) break; if (cmd.name == QSE_T("quit")) break;
qse_printf (QSE_T("%s<%zu> --> received command %s\n"), addrbuf, worker->getWid(), cmd.name.getBuffer()); qse_printf (QSE_T("%s<%zu> --> received command %s\n"), addrbuf, connection->getWid(), cmd.name.getBuffer());
sttp.sendCmd(cmd); sttp.sendCmd(cmd);
} }
qse_printf (QSE_T("byte to %s -> wid %zu\n"), addrbuf, worker->getWid()); qse_printf (QSE_T("byte to %s -> wid %zu\n"), addrbuf, connection->getWid());
return 0; return 0;
}), }),