Connection* ConnectionFactoryCreate(Connection* factory, Address* address, aio4c_socket_t socket) {
ErrorCode code = AIO4C_ERROR_CODE_INITIALIZER;
Connection* connection = NULL;
void* data = NULL;
connection = NewConnection(factory->pool, address, true);
connection->socket = socket;
#ifndef AIO4C_WIN32
if (fcntl(connection->socket, F_SETFL, O_NONBLOCK) == -1) {
code.error = errno;
code.connection = connection;
Raise(AIO4C_LOG_LEVEL_ERROR, AIO4C_CONNECTION_ERROR_TYPE, AIO4C_FCNTL_ERROR, &code);
shutdown(connection->socket, SHUT_RDWR);
close(connection->socket);
#else /* AIO4C_WIN32 */
unsigned long ioctl = 1;
if (ioctlsocket(connection->socket, FIONBIO, &ioctl) != 0) {
code.source = AIO4C_ERRNO_SOURCE_WSA;
code.connection = connection;
Raise(AIO4C_LOG_LEVEL_ERROR, AIO4C_CONNECTION_ERROR_TYPE, AIO4C_FCNTL_ERROR, &code);
shutdown(connection->socket, SD_BOTH);
closesocket(connection->socket);
#endif /* AIO4C_WIN32 */
aio4c_free(connection);
return NULL;
}
data = factory->dataFactory(connection, factory->dataFactoryArg);
CopyEventQueue(connection->userHandlers, factory->userHandlers, data);
CopyEventQueue(connection->systemHandlers, factory->systemHandlers, NULL);
connection->closedBy[AIO4C_CONNECTION_OWNER_ACCEPTOR] = false;
connection->closedBy[AIO4C_CONNECTION_OWNER_CLIENT] = true;
return connection;
}
static void _ConnectionEventHandle(Connection* connection, Event event) {
Log(AIO4C_LOG_LEVEL_DEBUG, "handling event %d for connection %s", event, connection->string);
EventHandle(connection->systemHandlers, event, (EventSource)connection);
EventHandle(connection->userHandlers, event, (EventSource)connection);
}
StatusWith<EventHandle> RouterStageMerge::getNextEvent() {
// If we abandoned a previous event due to a mongoS-side timeout, wait for it first.
if (_leftoverEventFromLastTimeout) {
invariant(_params->tailableMode == TailableMode::kTailableAndAwaitData);
auto event = _leftoverEventFromLastTimeout;
_leftoverEventFromLastTimeout = EventHandle();
return event;
}
return _arm.nextEvent();
}
StatusWith<ReplicationExecutor::EventHandle> ReplicationExecutor::makeEvent_inlock() {
if (_inShutdown)
return StatusWith<EventHandle>(ErrorCodes::ShutdownInProgress, "Shutdown in progress");
if (_signaledEvents.empty())
_signaledEvents.push_back(Event());
const EventList::iterator iter = _signaledEvents.begin();
invariant(iter->waiters.empty());
iter->generation++;
iter->isSignaled = false;
_unsignaledEvents.splice(_unsignaledEvents.end(), _signaledEvents, iter);
return StatusWith<EventHandle>(EventHandle(iter, ++_nextId));
}
void ReplicationExecutor::finishShutdown() {
_dblockWorkers.join();
boost::unique_lock<boost::mutex> lk(_mutex);
invariant(_inShutdown);
invariant(_exclusiveLockInProgressQueue.empty());
invariant(_readyQueue.empty());
invariant(_sleepersQueue.empty());
while (!_unsignaledEvents.empty()) {
EventList::iterator event = _unsignaledEvents.begin();
invariant(event->waiters.empty());
signalEvent_inlock(EventHandle(event, ++_nextId));
}
while (_totalEventWaiters > 0)
_noMoreWaitingThreads.wait(lk);
invariant(_exclusiveLockInProgressQueue.empty());
invariant(_readyQueue.empty());
invariant(_sleepersQueue.empty());
invariant(_unsignaledEvents.empty());
}
