}
}
-// outputs log message with IP and TCP port number prepended
-void
-LogWorker(const wxIPV4address& addr,
- const wxString& msg,
- wxLogLevel level = wxLOG_Info)
-{
- wxLogGeneric(level, "%s:%d %s", addr.IPAddress(), addr.Service(), msg);
-}
-
//event sent by workers to server class
//after client is served
const wxEventType wxEVT_WORKER = wxNewEventType();
DECLARE_APP(Server);
+// just some common things shared between ThreadWorker and EventWorker
+class WorkerBase
+{
+protected:
+ // outputs log message with IP and TCP port number prepended
+ void LogWorker(const wxString& msg, wxLogLevel level = wxLOG_Info)
+ {
+ wxLogGeneric(level,
+ "%s:%d %s", m_peer.IPAddress(), m_peer.Service(), msg);
+ }
+
+ wxIPV4address m_peer;
+};
+
//thread based worker reads signature and all data first from connected client
//and resends data to client after reading
-class ThreadWorker : public wxThread
+class ThreadWorker : public wxThread, private WorkerBase
{
public:
ThreadWorker(wxSocketBase* pSocket);
virtual ExitCode Entry();
+
private:
wxSocketBase* m_socket;
- wxIPV4address m_peer;
};
//event based worker reads signature and creates buffer for incoming data.
//When part of data arrives this worker resends it as soon as possible.
-class EventWorker : public wxEvtHandler
+class EventWorker : public wxEvtHandler, private WorkerBase
{
- DECLARE_EVENT_TABLE();
public:
EventWorker(wxSocketBase* pSock);
- ~EventWorker();
+ virtual ~EventWorker();
+
private:
wxSocketBase* m_socket;
- wxIPV4address m_peer;
unsigned char m_signature[2];
char* m_inbuf;
void OnSocketEvent(wxSocketEvent& pEvent);
void DoWrite();
void DoRead();
+
+ DECLARE_EVENT_TABLE();
};
/******************* Implementation ******************/
Server::OnInitCmdLine(wxCmdLineParser& pParser)
{
wxApp::OnInitCmdLine(pParser);
- pParser.AddSwitch("t","threads",_("Use thread based workers only"));
- pParser.AddSwitch("e","events",_("Use event based workers only"));
- pParser.AddOption("m","max",_("Exit after <n> connections"),wxCMD_LINE_VAL_NUMBER,wxCMD_LINE_PARAM_OPTIONAL);
- pParser.AddOption("p","port",_("listen on given port (default 3000)"),wxCMD_LINE_VAL_NUMBER,wxCMD_LINE_PARAM_OPTIONAL);
+ pParser.AddSwitch("t","threads","Use thread based workers only");
+ pParser.AddSwitch("e","events","Use event based workers only");
+ pParser.AddOption("m","max","Exit after <n> connections",
+ wxCMD_LINE_VAL_NUMBER);
+ pParser.AddOption("p","port","listen on given port (default 3000)",
+ wxCMD_LINE_VAL_NUMBER);
}
void
switch(m_workMode)
{
case EVENTS:
- mode = _("Event based workers");
+ mode = "Event based workers";
break;
case THREADS:
- mode = _("Thread based workers");
+ mode = "Thread based workers";
break;
case MIXED:
- mode = _("Event and thread based workers");
+ mode = "Event and thread based workers";
break;
}
wxLogMessage("Server mode: %s",mode);
bool
Server::OnCmdLineParsed(wxCmdLineParser& pParser)
{
- if (pParser.Found(_("verbose")))
+ if (pParser.Found("verbose"))
{
wxLog::AddTraceMask("wxSocket");
wxLog::AddTraceMask("epolldispatcher");
WorkerEvent e(this);
if (!m_socket->IsConnected())
{
- LogWorker(m_peer,"ThreadWorker: not connected",wxLOG_Error);
+ LogWorker("ThreadWorker: not connected",wxLOG_Error);
return 0;
}
int to_process = -1;
if (m_socket->IsConnected())
{
unsigned char signature[2];
- LogWorker(m_peer,"ThreadWorker: reading for data");
+ LogWorker("ThreadWorker: reading for data");
to_process = 2;
do
{
m_socket->Read(&signature,to_process);
if (m_socket->Error())
{
- LogWorker(m_peer,"ThreadWorker: Read error",wxLOG_Error);
+ LogWorker("ThreadWorker: Read error",wxLOG_Error);
wxGetApp().AddPendingEvent(e);
return 0;
}
to_process -= m_socket->LastCount();
- LogWorker(m_peer,wxString::Format("to_process: %d",to_process));
+ LogWorker(wxString::Format("to_process: %d",to_process));
}
while (!m_socket->Error() && to_process != 0);
if (signature[0] == 0xCE)
{
- LogWorker(m_peer,_("This server does not support test2 from GUI client"),wxLOG_Error);
+ LogWorker("This server does not support test2 from GUI client",wxLOG_Error);
e.m_workerFailed = true;
e.m_exit = true;
return 0;
}
int size = signature[1] * (signature[0] == 0xBE ? 1 : 1024);
char* buf = new char[size];
- LogWorker(m_peer,wxString::Format("Message signature: chunks: %d, kilobytes: %d, size: %d (bytes)",signature[0],signature[1],size));
+ LogWorker(wxString::Format("Message signature: chunks: %d, kilobytes: %d, size: %d (bytes)",signature[0],signature[1],size));
to_process = size;
- LogWorker(m_peer,wxString::Format("ThreadWorker: reading %d bytes of data",to_process));
+ LogWorker(wxString::Format("ThreadWorker: reading %d bytes of data",to_process));
do
{
m_socket->Read(buf,to_process);
if (m_socket->Error())
{
- LogWorker(m_peer,"ThreadWorker: Read error",wxLOG_Error);
+ LogWorker("ThreadWorker: Read error",wxLOG_Error);
wxGetApp().AddPendingEvent(e);
return 0;
}
to_process -= m_socket->LastCount();
- LogWorker(m_peer,wxString::Format("ThreadWorker: %d bytes readed, %d todo",m_socket->LastCount(),to_process));
+ LogWorker(wxString::Format("ThreadWorker: %d bytes readed, %d todo",m_socket->LastCount(),to_process));
}
while(!m_socket->Error() && to_process != 0);
m_socket->Write(buf,to_process);
if (m_socket->Error())
{
- LogWorker(m_peer,"ThreadWorker: Write error",wxLOG_Error);
+ LogWorker("ThreadWorker: Write error",wxLOG_Error);
break;
}
to_process -= m_socket->LastCount();
- LogWorker(m_peer,wxString::Format("ThreadWorker: %d bytes written, %d todo",m_socket->LastCount(),to_process));
+ LogWorker(wxString::Format("ThreadWorker: %d bytes written, %d todo",m_socket->LastCount(),to_process));
}
while(!m_socket->Error() && to_process != 0);
}
- LogWorker(m_peer,"ThreadWorker: done");
+ LogWorker("ThreadWorker: done");
e.m_workerFailed = to_process != 0;
m_socket->Destroy();
wxGetApp().AddPendingEvent(e);
{
if (m_socket->LastError() != wxSOCKET_WOULDBLOCK)
{
- LogWorker(m_peer,wxString::Format("Read error (%d): %s",m_socket->LastError(),GetSocketErrorMsg(m_socket->LastError())),wxLOG_Error);
+ LogWorker(wxString::Format("Read error (%d): %s",m_socket->LastError(),GetSocketErrorMsg(m_socket->LastError())),wxLOG_Error);
m_socket->Close();
}
}
unsigned char type = m_signature[0];
if (type == 0xCE)
{
- LogWorker(m_peer,_("This server does not support test2 from GUI client"),wxLOG_Error);
+ LogWorker("This server does not support test2 from GUI client",wxLOG_Error);
m_written = -1; //wxSOCKET_LOST will interpret this as failure
m_socket->Close();
}
m_infill = 0;
m_outfill = 0;
m_written = 0;
- LogWorker(m_peer,wxString::Format("Message signature: len: %d, type: %s, size: %d (bytes)",chunks,type == 0xBE ? "b" : "kB",m_size));
+ LogWorker(wxString::Format("Message signature: len: %d, type: %s, size: %d (bytes)",chunks,type == 0xBE ? "b" : "kB",m_size));
break;
} else
{
- LogWorker(m_peer,wxString::Format("Unknown test type %x",type));
+ LogWorker(wxString::Format("Unknown test type %x",type));
m_socket->Close();
}
}
{
if (m_socket->LastError() != wxSOCKET_WOULDBLOCK)
{
- LogWorker(
- m_peer,
- wxString::Format("Read error (%d): %s",
- m_socket->LastError(),
- GetSocketErrorMsg(m_socket->LastError())
- ),
- wxLOG_Error);
+ LogWorker(wxString::Format("Read error (%d): %s",
+ m_socket->LastError(),
+ GetSocketErrorMsg(m_socket->LastError())),
+ wxLOG_Error);
m_socket->Close();
}
break;
case wxSOCKET_CONNECTION:
- LogWorker(m_peer,wxString::Format("Unexpected wxSOCKET_CONNECTION in EventWorker"),wxLOG_Error);
+ LogWorker(wxString::Format("Unexpected wxSOCKET_CONNECTION in EventWorker"),wxLOG_Error);
break;
case wxSOCKET_LOST:
{
- LogWorker(m_peer,wxString::Format("Connection lost"));
+ LogWorker(wxString::Format("Connection lost"));
WorkerEvent e(this);
e.m_workerFailed = m_written != m_size;
wxGetApp().AddPendingEvent(e);
delete [] m_outbuf;
m_outbuf = NULL;
m_outfill = 0;
- LogWorker(m_peer, "All data written");
+ LogWorker( "All data written");
return;
}
if (m_outfill - m_written == 0)
{
if (m_socket->LastError() != wxSOCKET_WOULDBLOCK)
{
- LogWorker(m_peer,
+ LogWorker(
wxString::Format("Write error (%d): %s",
m_socket->LastError(),
GetSocketErrorMsg(m_socket->LastError())
}
else
{
- LogWorker(m_peer,"Write would block, waiting for OUTPUT event");
+ LogWorker("Write would block, waiting for OUTPUT event");
}
}
else
memmove(m_outbuf,m_outbuf+m_socket->LastCount(),m_outfill-m_socket->LastCount());
m_written += m_socket->LastCount();
}
- LogWorker(m_peer,wxString::Format("Written %d of %d bytes, todo %d",m_socket->LastCount(),m_size,m_size - m_written));
+ LogWorker(wxString::Format("Written %d of %d bytes, todo %d",
+ m_socket->LastCount(),m_size,m_size - m_written));
}
while (!m_socket->Error());
}
projects / wxWidgets.git / blobdiff