void
ServerApp::handleClientConnected(const Event&, void* vlistener)
{
ClientListener* listener = reinterpret_cast<ClientListener*>(vlistener);
ClientProxy* client = listener->getNextClient();
if (client != NULL) {
m_server->adoptClient(client);
updateStatus();
}
}
void
NetworkTests::sendToClient_mockFile_handleClientConnected(const Event&, void* vlistener)
{
ClientListener* listener = static_cast<ClientListener*>(vlistener);
Server* server = listener->getServer();
ClientProxy* client = listener->getNextClient();
if (client == NULL) {
throw runtime_error("client is null");
}
BaseClientProxy* bcp = client;
server->adoptClient(bcp);
server->setActive(bcp);
server->sendFileToClient(kMockFilename);
}
/* Called whenever a client is removed from the array list. */
static void remove_client_cb(void* v_sock_pack)
{
socket_package* sp = (socket_package*)v_sock_pack;
ClientListener* listener = (ClientListener*)sp->parent;
/* Call the server's client disconnected callback. */
if(listener->disconnected)
{
int rval = listener->disconnected(listener, sp);
if(rval & SCB_RVAL_STOP_SERVER)
{
flag_raise(&listener->flag_pole, THREAD_STOP);
close(listener->ep.efd);
listener->ep.efd = -1;
}
}
/* Free the socket package. */
close_and_free_socket_package(sp);
pthread_cond_broadcast(&listener->t_cond);
}
bool
ServerApp::startServer()
{
// skip if already started or starting
if (m_serverState == kStarting || m_serverState == kStarted) {
return true;
}
// initialize if necessary
if (m_serverState != kInitialized) {
if (!initServer()) {
// hard initialization failure
return false;
}
if (m_serverState == kInitializing) {
// not ready to start
m_serverState = kInitializingToStart;
return true;
}
assert(m_serverState == kInitialized);
}
double retryTime;
ClientListener* listener = NULL;
try {
listener = openClientListener(args().m_config->getSynergyAddress());
m_server = openServer(*args().m_config, m_primaryClient);
listener->setServer(m_server);
m_server->setListener(listener);
m_listener = listener;
updateStatus();
LOG((CLOG_NOTE "started server, waiting for clients"));
m_serverState = kStarted;
return true;
}
catch (XSocketAddressInUse& e) {
LOG((CLOG_WARN "cannot listen for clients: %s", e.what()));
closeClientListener(listener);
updateStatus(String("cannot listen for clients: ") + e.what());
retryTime = 10.0;
}
catch (XBase& e) {
LOG((CLOG_CRIT "failed to start server: %s", e.what()));
closeClientListener(listener);
return false;
}
if (args().m_restartable) {
// install a timer and handler to retry later
assert(m_timer == NULL);
LOG((CLOG_DEBUG "retry in %.0f seconds", retryTime));
m_timer = m_events->newOneShotTimer(retryTime, NULL);
m_events->adoptHandler(Event::kTimer, m_timer,
new TMethodEventJob<ServerApp>(this, &ServerApp::retryHandler));
m_serverState = kStarting;
return true;
}
else {
// don't try again
return false;
}
}
