void tracker_heartbeat(Tracker* tracker) {
MAGIC_ASSERT(tracker);
/* prefer our level over the global config */
GLogLevelFlags level = tracker->loglevel;
if(!level) {
Worker* w = worker_getPrivate();
if(w->cached_engine) {
Configuration* c = engine_getConfig(w->cached_engine);
level = configuration_getHeartbeatLogLevel(c);
}
}
/* prefer our interval over the global config */
SimulationTime interval = tracker->interval;
if(!interval) {
Worker* w = worker_getPrivate();
if(w->cached_engine) {
Configuration* c = engine_getConfig(w->cached_engine);
interval = configuration_getHearbeatInterval(c);
}
}
guint seconds = (guint) (interval / SIMTIME_ONE_SECOND);
double in = (double) (tracker->inputBytesLastInterval);
double out = (double)(tracker->outputBytesLastInterval);
double alloc = (double)(((double)tracker->allocatedBytesLastInterval) / 1024.0);
double dealloc = (double)(((double)tracker->deallocatedBytesLastInterval) / 1024.0);
double mem = (double)(((double)tracker->allocatedBytesTotal) / 1024.0);
double cpuutil = (double)(((double)tracker->processingTimeLastInterval) / interval);
double avedelayms = 0.0;
if(tracker->numDelayedLastInterval > 0) {
double delayms = (double) (((double)tracker->delayTimeLastInterval) / ((double)SIMTIME_ONE_MILLISECOND));
avedelayms = (double) (delayms / ((double) tracker->numDelayedLastInterval));
}
/* log the things we are tracking */
logging_log(G_LOG_DOMAIN, level, __FUNCTION__,
"[shadow-heartbeat] CPU %f \%, MEM %f KiB, interval %u seconds, alloc %f KiB, dealloc %f KiB, Rx %f B, Tx %f B, avgdelay %f milliseconds",
cpuutil, mem, seconds, alloc, dealloc, in, out, avedelayms);
/* clear interval stats */
tracker->processingTimeLastInterval = 0;
tracker->delayTimeLastInterval = 0;
tracker->numDelayedLastInterval = 0;
tracker->inputBytesLastInterval = 0;
tracker->outputBytesLastInterval = 0;
tracker->allocatedBytesLastInterval = 0;
tracker->deallocatedBytesLastInterval = 0;
/* schedule the next heartbeat */
tracker->lastHeartbeat = worker_getPrivate()->clock_now;
HeartbeatEvent* heartbeat = heartbeat_new(tracker);
worker_scheduleEvent((Event*)heartbeat, interval, 0);
}
void tracker_heartbeat(Tracker* tracker) {
MAGIC_ASSERT(tracker);
TrackerFlags flags = _tracker_getFlags(tracker);
GLogLevelFlags level = _tracker_getLogLevel(tracker);
SimulationTime interval = _tracker_getLogInterval(tracker);
/* check to see if node info is being logged */
if(flags & TRACKER_FLAGS_NODE) {
_tracker_logNode(tracker, level, interval);
}
/* check to see if socket buffer info is being logged */
if(flags & TRACKER_FLAGS_SOCKET) {
_tracker_logSocket(tracker, level, interval);
}
/* check to see if ram info is being logged */
if(flags & TRACKER_FLAGS_RAM) {
_tracker_logRAM(tracker, level, interval);
}
/* make sure we have the latest global configured flags */
tracker->globalFlags = _tracker_parseGlobalFlags();
/* clear interval stats */
tracker->processingTimeLastInterval = 0;
tracker->delayTimeLastInterval = 0;
tracker->numDelayedLastInterval = 0;
tracker->allocatedBytesLastInterval = 0;
tracker->deallocatedBytesLastInterval = 0;
/* clear the counters */
memset(&tracker->local, 0, sizeof(IFaceCounters));
memset(&tracker->remote, 0, sizeof(IFaceCounters));
SocketStats* ss = NULL;
GHashTableIter socketIterator;
g_hash_table_iter_init(&socketIterator, tracker->socketStats);
while (g_hash_table_iter_next(&socketIterator, NULL, (gpointer*)&ss)) {
if(ss) {
memset(&ss->local, 0, sizeof(IFaceCounters));
memset(&ss->remote, 0, sizeof(IFaceCounters));
}
}
/* schedule the next heartbeat */
tracker->lastHeartbeat = worker_getCurrentTime();
HeartbeatEvent* heartbeat = heartbeat_new(tracker);
worker_scheduleEvent((Event*)heartbeat, interval, 0);
}
rdpRdp* rdp_new(rdpContext* context)
{
rdpRdp* rdp;
DWORD flags;
rdp = (rdpRdp*) malloc(sizeof(rdpRdp));
if (rdp)
{
ZeroMemory(rdp, sizeof(rdpRdp));
rdp->context = context;
rdp->instance = context->instance;
flags = 0;
if (context->ServerMode)
flags |= FREERDP_SETTINGS_SERVER_MODE;
if (!context->settings)
context->settings = freerdp_settings_new(flags);
rdp->settings = context->settings;
rdp->settings->instance = context->instance;
if (context->instance)
context->instance->settings = rdp->settings;
rdp->extension = extension_new(context->instance);
rdp->transport = transport_new(rdp->settings);
rdp->transport->rdp = rdp;
rdp->license = license_new(rdp);
rdp->input = input_new(rdp);
rdp->update = update_new(rdp);
rdp->fastpath = fastpath_new(rdp);
rdp->nego = nego_new(rdp->transport);
rdp->mcs = mcs_new(rdp->transport);
rdp->redirection = redirection_new();
rdp->autodetect = autodetect_new();
rdp->heartbeat = heartbeat_new();
rdp->multitransport = multitransport_new();
rdp->bulk = bulk_new(context);
}
return rdp;
}
rdpRdp* rdp_new(rdpContext* context)
{
rdpRdp* rdp;
DWORD flags;
BOOL newSettings = FALSE;
rdp = (rdpRdp*) calloc(1, sizeof(rdpRdp));
if (!rdp)
return NULL;
rdp->context = context;
rdp->instance = context->instance;
flags = 0;
if (context->ServerMode)
flags |= FREERDP_SETTINGS_SERVER_MODE;
if (!context->settings)
{
context->settings = freerdp_settings_new(flags);
if (!context->settings)
goto out_free;
newSettings = TRUE;
}
rdp->settings = context->settings;
rdp->settings->instance = context->instance;
if (context->instance)
context->instance->settings = rdp->settings;
rdp->transport = transport_new(rdp->settings);
if (!rdp->transport)
goto out_free_settings;
rdp->transport->rdp = rdp;
rdp->license = license_new(rdp);
if (!rdp->license)
goto out_free_transport;
rdp->input = input_new(rdp);
if (!rdp->input)
goto out_free_license;
rdp->update = update_new(rdp);
if (!rdp->update)
goto out_free_input;
rdp->fastpath = fastpath_new(rdp);
if (!rdp->fastpath)
goto out_free_update;
rdp->nego = nego_new(rdp->transport);
if (!rdp->nego)
goto out_free_fastpath;
rdp->mcs = mcs_new(rdp->transport);
if (!rdp->mcs)
goto out_free_nego;
rdp->redirection = redirection_new();
if (!rdp->redirection)
goto out_free_mcs;
rdp->autodetect = autodetect_new();
if (!rdp->autodetect)
goto out_free_redirection;
rdp->heartbeat = heartbeat_new();
if (!rdp->heartbeat)
goto out_free_autodetect;
rdp->multitransport = multitransport_new();
if (!rdp->multitransport)
goto out_free_heartbeat;
rdp->bulk = bulk_new(context);
if (!rdp->bulk)
goto out_free_multitransport;
return rdp;
out_free_multitransport:
multitransport_free(rdp->multitransport);
out_free_heartbeat:
heartbeat_free(rdp->heartbeat);
out_free_autodetect:
autodetect_free(rdp->autodetect);
out_free_redirection:
redirection_free(rdp->redirection);
out_free_mcs:
mcs_free(rdp->mcs);
out_free_nego:
nego_free(rdp->nego);
out_free_fastpath:
fastpath_free(rdp->fastpath);
out_free_update:
update_free(rdp->update);
out_free_input:
input_free(rdp->input);
out_free_license:
license_free(rdp->license);
out_free_transport:
transport_free(rdp->transport);
out_free_settings:
if (newSettings)
freerdp_settings_free(rdp->settings);
out_free:
free(rdp);
return NULL;
}
