QueryData genOsqueryEvents(QueryContext& context) {
QueryData results;
auto publishers = EventFactory::publisherTypes();
for (const auto& publisher : publishers) {
Row r;
r["name"] = publisher;
r["publisher"] = publisher;
r["type"] = "publisher";
auto pubref = EventFactory::getEventPublisher(publisher);
if (pubref != nullptr) {
r["subscriptions"] = INTEGER(pubref->numSubscriptions());
r["events"] = INTEGER(pubref->numEvents());
r["restarts"] = INTEGER(pubref->restartCount());
r["active"] = (pubref->hasStarted() && !pubref->isEnding()) ? "1" : "0";
} else {
r["subscriptions"] = "0";
r["events"] = "0";
r["restarts"] = "0";
r["active"] = "-1";
}
results.push_back(r);
}
auto subscribers = EventFactory::subscriberNames();
for (const auto& subscriber : subscribers) {
Row r;
r["name"] = subscriber;
r["type"] = "subscriber";
// Subscribers will never 'restart'.
r["restarts"] = "0";
auto subref = EventFactory::getEventSubscriber(subscriber);
if (subref != nullptr) {
r["publisher"] = subref->getType();
r["subscriptions"] = INTEGER(subref->numSubscriptions());
r["events"] = INTEGER(subref->numEvents());
// Subscribers are always active, even if their publisher is not.
r["active"] = (subref->state() == SUBSCRIBER_RUNNING) ? "1" : "0";
} else {
r["subscriptions"] = "0";
r["events"] = "0";
r["active"] = "-1";
}
results.push_back(r);
}
return results;
}
int DefaultEventManager<Platform::POLL>::dispatch(int flags)
{
if (!numEvents()) {
return 0; // RETURN
}
int numCallbacks = 0; // number of callbacks dispatched
while (0 == numCallbacks) {
int rfds; // number of returned fds
int savedErrno = 0; // saved errno value set by 'poll'
do {
if (d_timeMetric_p) {
d_timeMetric_p->switchTo(TimeMetrics::e_IO_BOUND);
rfds = ::poll(&d_pollFds.front(),
d_pollFds.size(),
BTESO_EVENTMANAGERIMP_POLL_INF_TIMEOUT);
savedErrno = errno;
d_timeMetric_p->switchTo(TimeMetrics::e_CPU_BOUND);
}
else {
rfds = ::poll(&d_pollFds.front(),
d_pollFds.size(),
BTESO_EVENTMANAGERIMP_POLL_INF_TIMEOUT);
savedErrno = errno;
}
errno = 0;
} while ((0 > rfds && EINTR == savedErrno)
&& !(btlso::Flag::k_ASYNC_INTERRUPT & flags));
if (0 >= rfds) {
if (0 == rfds) {
// timed out, no events
return 0; // RETURN
}
else if (-1 == rfds && EINTR == savedErrno) {
// interrupted
return -1; // RETURN
}
else {
// According to the contract, we are to return any negative
// number other than -1. We might as well return '-savedErrno'
// to aid in debugging, except in the case where
// '-savedErrno >= -1', in which case it would be mistaken to
// have another meaning, so in that case, we return -10000.
return -savedErrno >= -1 ? -10000 : -savedErrno; // RETURN
}
}
numCallbacks += dispatchCallbacks(&d_signaled,
d_pollFds,
&d_callbacks);
}
return numCallbacks;
}
/**
* Event is removed from internal queue
* TODO: should not be blocking
* Virtual
*/
RawEvent EventMonitorMac::nextEvent() {
if ( numEvents() == 0 )
waitForEvents();
RawEvent re = events.front();
events.pop_front();
return re;
}
// MANIPULATORS
int DefaultEventManager<Platform::POLL>::dispatch(
const bsls::TimeInterval& timeout,
int flags)
{
bsls::TimeInterval now(bdlt::CurrentTime::now());
if (!numEvents()) {
if (timeout <= now) {
return 0; // RETURN
}
while (timeout > now) {
bsls::TimeInterval currTimeout(timeout - now);
struct timespec ts;
ts.tv_sec = static_cast<int>(currTimeout.seconds());
ts.tv_nsec = currTimeout.nanoseconds();
// Sleep till it's time.
if (d_timeMetric_p) {
d_timeMetric_p->switchTo(TimeMetrics::e_IO_BOUND);
bslmt::ThreadUtil::microSleep(
static_cast<int>(ts.tv_nsec / 1000),
static_cast<int>(ts.tv_sec));
d_timeMetric_p->switchTo(TimeMetrics::e_CPU_BOUND);
}
else {
bslmt::ThreadUtil::microSleep(
static_cast<int>(ts.tv_nsec / 1000),
static_cast<int>(ts.tv_sec));
}
now = bdlt::CurrentTime::now();
}
return 0; // RETURN
}
int numCallbacks = 0; // number of callbacks dispatched
do {
int relativeTimeout;
int rfds; // number of returned sockets
int savedErrno = 0; // saved errno value set by poll
do {
if (timeout > now) {
// Calculate the time remaining for the poll() call.
bsls::TimeInterval currTimeout(timeout - now);
// Convert this timeout to a 32 bit value in milliseconds.
relativeTimeout =
static_cast<int>(currTimeout.seconds()) * 1000
+ currTimeout.nanoseconds() / 1000000 + 1;
BSLS_ASSERT(relativeTimeout >= 0);
}
else {
relativeTimeout = BTESO_EVENTMANAGERIMP_POLL_NO_TIMEOUT;
}
if (d_timeMetric_p) {
d_timeMetric_p->switchTo(TimeMetrics::e_IO_BOUND);
rfds = ::poll(&d_pollFds.front(),
d_pollFds.size(),
relativeTimeout);
savedErrno = errno;
d_timeMetric_p->switchTo(TimeMetrics::e_CPU_BOUND);
}
else {
rfds = ::poll(&d_pollFds.front(),
d_pollFds.size(),
relativeTimeout);
savedErrno = errno;
}
errno = 0;
now = bdlt::CurrentTime::now();
} while ((0 > rfds && EINTR == savedErrno)
&& !(btlso::Flag::k_ASYNC_INTERRUPT & flags)
&& now < timeout);
if (0 >= rfds) {
if (0 == rfds) {
// timed out, no events
return 0; // RETURN
}
else if (-1 == rfds && EINTR == savedErrno) {
// interrupted
return -1; // RETURN
}
else {
// According to the contract, we are to return any negative
// number other than -1. We might as well return '-savedErrno'
// to aid in debugging, except in the case where
// '-savedErrno >= -1', in which case it would be mistaken to
// have another meaning, so in that case, we return -10000.
return -savedErrno >= -1 ? -10000 : -savedErrno; // RETURN
}
}
numCallbacks += dispatchCallbacks(&d_signaled,
d_pollFds,
&d_callbacks);
now = bdlt::CurrentTime::now();
} while (0 == numCallbacks && now < timeout);
return numCallbacks;
}
