def _Flush(self):
self._RecordedData = []
self._Bytes = 0
self._StartTime = Time.GetCurrMS()
self._StopTime = Time.GetCurrMS()
self._Stopped = True
self._Saved = True
def alternateCollectionProc(self):
if self.IsOnDemand():
Log.getLogger().error(
"On Demand Collector called with alternateCollectionProc")
if self.NeedsCollecting():
startCollectionTime = Time.GetCurrMS()
buffer = self.PerformCollection()
TimeToCollect = Time.GetCurrMS() - startCollectionTime
#print(TimeToCollect)
if None != buffer:
buffer = "<?xml version=\"1.0\" encoding=\"utf-8\"?>" + buffer
if not self._NamespaceObject.SendPacket(buffer):
return 0
#self._NamespaceObject.CheckMTU(len(buffer),self._MinionID)
if TimeToCollect > self._PollingInterval: # do a sanity check to see if collection time is longer than collector frequency
Log.getLogger().warning(
"Collector: " + self.GetID() +
" took longer to perform the actual collection than the specified frequency for it ("
+ str(self._PollingInterval) +
". It is suggested you change something to fix this.")
return len(buffer)
return 0
def updateGui(self):
if self._LastUpdate + self._Interval < Time.GetCurrMS():
self._LastUpdate = Time.GetCurrMS()
sm = Statistics.GetStatistics()
self.lblTotalPacketsDownstream.configure(
text=str(sm._TotalPacketsDownstream))
self.lblPacketDownstream.configure(
text=str(sm._UniquePacketsDownstream))
self.lblBytesTransmittedDownstream.configure(
text=str(sm._totalTxBytesDownstream))
self.lblBytesReceivedFromDownstream.configure(
text=str(sm._totalRxBytesDownstream))
self.lblTotalPacketsUpstream.configure(
text=str(sm._TotalPacketsUpstream))
self.lblPacketUpstream.configure(
text=str(sm._UniquePacketsUpstream))
self.lblBytesTransmittedUpstream.configure(
text=str(sm._totalTxBytesUpstream))
self.lblBytesReceivedFromUpstream.configure(
text=str(sm._totalRxBytesUpstream))
self.lblTotalDroppedPackets.configure(
text=str(sm._TotalPacketsDropped))
self.lblTotalMalformedPackets.configure(
text=str(sm._TotalMalformedPacketsReceived))
self.lblTotalChainedPackets.configure(
text=str(sm._TotalChainedDownstreamPackets))
self.lblTotalOscarTasks.configure(
text=str(sm._TotalOscarTasksReceived))
self.lblTotalMinionTasks.configure(
text=str(sm._TotalMinionTasksReceived))
self.lblTotalShuntedPackets.configure(
text=str(sm._TotalShuntedPackets))
def WorkerProc(self, fnKillSignalled, userData):
lastUpdate = 0
interval = Configuration.get().GetConnectionUpdateInterval()
buffer = "<?xml version=\"1.0\" encoding=\"utf-8\"?>"
buffer = buffer + "<Oscar Type=\"ConnectionInformation\">"
buffer = buffer + "<Version>1.0</Version>"
buffer = buffer + "<OscarVersion>" + VersionMgr.ReadVer(
) + "</OscarVersion>"
buffer = buffer + "<ID>" + Configuration.get().GetID() + "</ID>"
buffer = buffer + "<Port>" + str(Configuration.get(
).GetDownstreamConnection().getPort()) + "</Port>"
buffer = buffer + "</Oscar>"
#<?xml version="1.0" encoding="utf-8"?>
#<Oscar Type="ConnectionInformation">
# <Version>1.0</Version>
# <ID>Foo</Foo>
# <Port>Port</Port>
#</Oscar>
while not fnKillSignalled(
): # run until signalled to end - call passed function to check for the signal
if lastUpdate < Time.GetCurrMS() - interval:
TargetManager.GetTargetManager().BroadcastDownstream(
buffer, True, None
) # send Connection Data to all downstream things (Oscars & Marvins)
lastUpdate = Time.GetCurrMS()
Configuration.get().RescanTargets()
else:
Sleep.Sleep(0.25)
TargetManager.GetTargetManager(
).CheckForRemovalOfDynamicMarvins()
def alternateWorker(self): ## Maybe have one thread that goes and
self.m_objLockDict.acquire() # thread safety
if len(
self.m_SendList
) == 0: # rest if nothing to send, or sent a bunch of packets without a sleep
dataToProcess = False
else:
buffer = self.m_SendList[0]
del self.m_SendList[0]
dataToProcess = True
self.m_objLockDict.release()
if dataToProcess:
if None == self.m_IP_InUse:
Log.getLogger().info("Getting IP address for host: " +
self.ConfigurationDefinedTarget)
try:
self.m_LastDNSResolution = Time.GetCurrMS()
self.m_IP_InUse = socket.gethostbyname(
self.ConfigurationDefinedTarget
) #use this for looking at heartbeats
except Exception as _:
self.m_IP_InUse = self.ConfigurationDefinedTarget
try:
self.m_socket.sendto(bytes(buffer, 'utf-8'),
(self.m_IP_InUse, self.getPort()))
self.m_PacketsSent += 1
self.m_BytestSent += len(buffer)
except Exception as ex:
Log.getLogger().info("It appears that the target [" +
self.ConfigurationDefinedTarget +
"] has went away.")
self.m_objLockDict.acquire()
Statistics.GetStatistics().OnPacketDropped(
len(self.m_SendList) + 1)
self.m_SendList.clear()
self.m_objLockDict.release()
if self.m_LastDNSResolution + self.m_DNSResolutionPeriod < Time.GetCurrMS(
) and self.m_hasTimedOut == True:
self.m_IP_InUse = None # Force a DNS resolution, may help when move laptop and gets new address -
# eventually
# if self.m_hasTimedOut:
# Log.getLogger().error("Timed out" + str(ConnectionType.DynamicMarvin))
if self.m_hasTimedOut and (self.Type == ConnectionType.DynamicMarvin or
self.Type == ConnectionType.DynamicOscar):
self.MarkedForRemoval = True
self.Type += 1
return dataToProcess
def __init__(self):
if None != Recorder._instance:
return
Recorder._instance = self
self._RecordedData = []
self._Bytes = 0
self._StartTime = Time.GetCurrMS()
self._StopTime = Time.GetCurrMS()
self._Stopped = True
self._Saved = True
def StartupWorkerProc(fnKillSignalled, userData):
downstreamServer = userData[0]
upstreamServer = userData[1]
Sleep.SleepMs(500)
downstreamServer.Start()
upstreamServer.DropPackets(True)
upstreamServer.Start()
Watchdog.ConnectionUpdateTimer()
Watchdog.WatchdogTimer()
conf = Configuration.get()
if None != conf.GetAutorunFilename():
GuiMgr.OnStopLiveData()
#GuiMgr.OnStopPlayback()
#GuiMgr.OnStopRecording(True) #drop all recorded packets
GuiMgr.OnSetPlaybackSpeed(Configuration.get().GetPlaybackSpeed())
ss = Configuration.get().GetAutorunLocations()
#GuiMgr.OnEnablePlayback()
GuiMgr.ReadFromFile(Configuration.get().GetAutorunFilename())
GuiMgr.OnStopPlayback()
Sleep.SleepMs(
100) # let gui worker threads catch up, so gui updates properly
GuiMgr.OnStartPlayback()
GuiMgr.OnSetRepeatMode(Configuration.get().GetAutoRunMode(), ss[0],
ss[1])
else:
upstreamServer.DropPackets(False)
if None != conf.GetAutorunTime() and conf.GetAutorunTime(
) > 0: # specified a --time, so let's hang out for that long
endTime = Time.GetCurrMS() + conf.GetAutorunTime() * 60 * 1000
Log.getLogger().info("Waiting for " + str(conf.GetAutorunTime()) +
" minutes before auto shutdown")
if conf.GetRecordFilename():
GuiMgr.OnStartRecording()
while not fnKillSignalled() and endTime > Time.GetCurrMS():
Sleep.SleepMs(250)
Log.getLogger().info("Shutting down after time period")
if conf.GetRecordFilename(
): # was a recording session, so quit after that time
GuiMgr.OnStopRecording()
GuiMgr.WriteToFile(conf.GetRecordFilename())
Log.getLogger().info("Saving Recorded data to file: " +
conf.GetRecordFilename())
GuiMgr.Quit()
def Stop(self, flush):
self._StopTime = Time.GetCurrMS()
self._Stopped = True
if True == flush:
self._Flush()
if self._Bytes > 0:
Playback.get().SetData(self._RecordedData)
def __sendConnectionInfoProc(self,fnKillSignalled,userData):
buffer = "<?xml version=\"1.0\" encoding=\"utf-8\"?>"
buffer = buffer + "<Minion Type=\"ConnectionInformation\">"
buffer = buffer + "<Version>1.0</Version>"
buffer = buffer + "<MinionVersion>" + VersionMgr.ReadVer()+ "</MinionVersion>"
buffer += "<Namespace>" + str(self) + "</Namespace>"
buffer += "<Port>" + str(self._Server.getPort()) + "</Port>"
buffer = buffer + "</Minion>"
lastUpdate = 0
while not fnKillSignalled():
if lastUpdate + Namespace.ConnectionInfoUpdateInterval < Time.GetCurrMS():
if self.SendPacket(buffer):
Log.getLogger().debug("Sent announcement to Oscar")
lastUpdate = Time.GetCurrMS()
Sleep.SleepMs(Namespace.ConnectionUpdateThreadSleepinterval) # Don't want to sleep for Namespace.ConnectionInfoUpdateInterval in case
def test_split_time(self):
hrs = 10
mins = 11
sec = 12
ms = 13
total = hrs * 3600 + mins * 60 + sec + ms / 1000.0
expected = [hrs, mins, sec, ms]
actual = list(Time.split_time(total))
self.assertListEqual(actual, expected)
def test_split_time(self):
hrs = 10
mins = 11
sec = 12
ms = 13
total = hrs * 3600 + mins * 60 + sec + ms / 1000.0
expected = [hrs, mins, sec, ms]
actual = list(Time.split_time(total))
self.assertListEqual(actual, expected)
def test_combine_time(self):
hrs = 10
mins = 11
sec = 12
ms = 13
total = hrs * 3600 + mins * 60 + sec + ms / 1000.0
expected = total
actual = Time.combine_time(hrs, mins, sec, ms)
self.assertAlmostEqual(actual, expected, 5)
def test_combine_time(self):
hrs = 10
mins = 11
sec = 12
ms = 13
total = hrs * 3600 + mins * 60 + sec + ms / 1000.0
expected = total
actual = Time.combine_time(hrs, mins, sec, ms)
self.assertAlmostEqual(actual, expected, 5)
def PerformInsertBookmark(self,Params):
#<?xml version="1.0" encoding="utf-8"?>
#<Marvin Type="OscarTask">
# <Version>1.0</Version>
# <OscarID>DemoOscar</OscarID>
# <UniqueID>1233456</UniqueID>
# <Task>InsertBookmark</Task>
# <Param>Namespace=foo</Param>
# <Param>ID=TestMarker</Param>
# <Param>Data=StartTest</Param>
# <Param>Propagate=True</Param> -- if True, the data is sent back upstream towards Marvin
#</Marvin>
if len(Params) >= 3:
fPropagate = False
for param in Params:
parts = param.split("=")
if len(parts)==2:
if parts[0].lower()=='namespace':
namespace = Alias.Alias(parts[1])
elif parts[0].lower()=='id':
id = Alias.Alias(parts[1])
elif parts[0].lower()=='data':
data = Alias.Alias(parts[1])
elif parts[0].lower()=='propagate':
propagate = Alias.Alias(parts[1])
if propagate.lower() == "true":
fPropagate = True
else:
Log.getLogger().error("Received invalid InsertBookmark task parameter: " + str(param))
return
else:
Log.getLogger().error("Received invalid InsertBookmark task. Insufficient Parameters.")
return
if None == namespace:
Log.getLogger().error("Received invalid InsertBookmark task. Namespace not specified.")
return
if None == id:
Log.getLogger().error("Received invalid InsertBookmark task. ID not specified.")
return
if None == data:
Log.getLogger().error("Received invalid InsertBookmark task. Data not specified.")
return
eTime = Time.GetCurrMS()
objData = MarvinData.MarvinData(namespace,id,data,eTime,1.0)
if None != objData:
Recorder.get().AddData(objData)
GuiMgr.OnDataPacketSentDownstream(objData,"Minion")
if fPropagate:
TargetManager.GetTargetManager().BroadcastDownstream(objData.ToXML(),False,None)
def AddData(self, objData):
if True == self._Stopped:
return
if 0 == len(
self._RecordedData): # only start timing when get 1st packet
self._StartTime = Time.GetCurrMS()
self._RecordedData.append(objData)
self._Bytes += sys.getsizeof(objData)
self._Saved = False
def WatchdogProc(self, fnKillSignalled, userData):
lastUpdate = 0
interval = Configuration.get().GetTimeoutPeriod(
) * 0.25 # send a watchdog at 4x rate of timeout
buffer = "<?xml version=\"1.0\" encoding=\"utf-8\"?>"
buffer = buffer + "<Oscar Type=\"WatchdogTimer\">"
buffer = buffer + "<Version>1.0</Version>"
buffer = buffer + "<Port>" + str(
Configuration.get().GetUpstreamConnection().getPort()) + "</Port>"
buffer = buffer + "</Oscar>"
while not fnKillSignalled(
): # run until signalled to end - call passed function to check for the signal
if lastUpdate < Time.GetCurrMS() - interval:
TargetManager.GetTargetManager().BroadcastUpstreamToType(
buffer, ConnectionType.UpstreamOscar
) # send heartbeat to all upstream Oscars
lastUpdate = Time.GetCurrMS()
Sleep.Sleep(0.25) #snooze for 250 ms
def NeedsCollecting(self):
refresh = self._RefreshRequested
retVal = self._LastCollectionTime + self._PollingInterval < Time.GetCurrMS() or True == refresh
#a = self.GetID()
#b = self._RunOnce
if self._RunOnce and self._LastCollectionTime > 0:
retVal = False
if self.IsDynamicallyCreated and self.DynamicValueCollected:
retVal = False # Don't collect if it is a dynamic collector that hasn't been updated since last collect
return retVal
def SetCollectorValueFromPlugin(self,collectorID,Value,elapsedTime=None):
objCollector = self._NamespaceObject.GetCollector(self.__PrefixStr + collectorID + self.__SuffixStr)
if None == objCollector:
Log.getLogger().error("User defined DynamicCollector tried to Set a value to a collector that does not exist, with ID: " + collectorID)
return False
if None == elapsedTime:
elapsedTime = Time.GetCurrMS() - objCollector._LastCollectionTime
objCollector.SetDynamicData(Value,elapsedTime)
return True
def __init__(self,
ip=None,
Port=None,
ConnType=ConnectionType.Unknown,
canTimeout=True):
super(Target, self).__init__(ip, Port, ConnType)
self.ConfigurationDefinedTarget = ip
self.m_IP_InUse = None #m_ip could be DNS name
self.m_socket = None
self.m_lastHeartbeat = Time.GetCurrMS()
self.m_PacketsSent = 0
self.m_BytestSent = 0
self.m_InitialRefreshSent = False
self.m_objLockDict = threading.Lock()
self.m_SendList = []
self.m_hasTimedOut = False
self.m_LastDNSResolution = Time.GetCurrMS()
self.m_DNSResolutionPeriod = 30000 #30 seconds
self.m_CanTimeout = canTimeout
self.threadName = None
self.lastRefreshRequestID = 0
self.MarkedForRemoval = False
try:
self.m_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM,
socket.IPPROTO_UDP)
self.m_socket.setblocking(True)
self.m_socket.settimeout(0.001)
except Exception as _:
Log.getLogger().error("Error setting up Target Socket -->" +
str(super.m_Connection))
self.threadName = "Target:" + self.getIP() + "[" + str(
self.getPort()) + "]"
ThreadManager.GetThreadManager().CreateThread(self.threadName,
self.WorkerProc)
ThreadManager.GetThreadManager().StartThread(self.threadName)
def Collect(self):
if None == self._Interval:
collectors=self.GetCollectors()
self._Collector = collectors[0]
try:
self._Interval = int(collectors[1].GetLastValue()) * 1000 #make it seconds
except:
return "Operator Running Average must have time in seconds as 2nd <Input>"
oldestTime = Time.GetCurrMS() - self._Interval
validRangeStart=0
for index, dataPoint in enumerate(self._dataPointList):
val,time = dataPoint
if time < oldestTime:
validRangeStart = index +1
if validRangeStart > 0:
self._dataPointList = self._dataPointList[validRangeStart:]
try:
val = float(self._Collector.GetLastValue())
except:
return "Operator Running Average cannot average value {}".format(self._Collector.GetLastValue())
time = Time.GetCurrMS() - (self._Collector.GetElapsedTimeSinceLast() * 1000)
self._dataPointList.append((val,time))
tVal = 0.0
for val,_ in self._dataPointList:
tVal += float(val)
if len(self._dataPointList) > 0:
retVal = tVal/len(self._dataPointList)
else:
retVal = 0.0
return retVal
def __init__(self,Namespace,ID,Value,ElapsedTime,FormatVersion,isLive=True):
from Helpers import Configuration
self.FormatVersion=FormatVersion
self.Value = Value
if True == isLive:
self.ArrivalTime = Time.GetCurrMS() - MarvinData.__FirstTime # just a delta from start is fine, no need for a 10 digit string for time
else:
self.ArrivalTime = ElapsedTime
self.Namespace = Configuration.get().HandleBITWNamespace(Namespace) # if Bump in the Wire, change NS
self.ID = ID
self.Live = isLive
def reg(self, funtype, fun, deadtime = (2038, 1, 1), index = -1): ''' 注册一个回调函数 @param funtype:函数类型 @param fun:回调函数 @param deadtime:过期时间 @param index:索引 ''' # 判断过期 ddt = Time.as_datetime(deadtime) if ddt <= datetime.datetime.now(): return if funtype not in self.fundict: callback = self.fundict[funtype] = Callback() else: callback = self.fundict[funtype] callback.reg(fun, deadtime, index)
def __init__(self,
ID,
Value,
ElapsedTime,
Namespace,
ReceivedTime="NotFromFile"):
self.Value = Value
self.ArrivalTime = ElapsedTime
self.Namespace = Namespace
self.ID = ID
# self.PacketNumber = PacketNumber
# self.Normalized = False
if ReceivedTime == "NotFromFile":
#self.ArrivalTime = TimeUtils.GetTimeDeltaMS()
self.ArrivalTime = Time.GetCurrMS()
else:
self.ArrivalTime = ReceivedTime
def __CheckForTimeout(self):
from Helpers import Configuration
if not self.m_CanTimeout:
return False
if self.m_hasTimedOut:
return True
toPeriod = Configuration.get().GetTimeoutPeriod()
if toPeriod < Time.GetCurrMS(
) - self.m_lastHeartbeat: # a timeout has ocurred
self.m_hasTimedOut = True
Log.getLogger().info("Target [" + str(self) + "] has timed out.")
self.lastRefreshRequestID = 0
#self.ReArmRefreshRequest(123456789)
return self.m_hasTimedOut
def __init__(self,
Namespace,
ID,
Value,
ElapsedTime,
FormatVersion,
isLive=True):
#from Helpers import Configuration
self.FormatVersion = FormatVersion
self.Value = Value
if True == isLive:
self.ArrivalTime = Time.GetCurrMS()
else:
self.ArrivalTime = ElapsedTime
self.Namespace = Namespace
#self.Namespace = Configuration.get().HandleBITWNamespace(Namespace) # if Bump in the Wire, change NS
self.ID = ID
self.Live = isLive
def reg(self, fun, deadtime = (2038, 1, 1), index = -1): ''' 注册一个函数 @param fun:函数对象 @param deadtime:过期时间 @param index:索引 ''' # 判断过期 ddt = Time.as_datetime(deadtime) if ddt <= datetime.datetime.now(): return # 检测是否重复 if fun in self.fun_list: print "GE_EXC, repeat reg function(%s, %s)" % (fun.__module__, fun.__name__) return # 按照索引插入 if index < 0: self.fun_list.append(fun) else: self.fun_list.insert(index, fun)
def StrokeWatchdogTimer(self):
if True == self.m_CanTimeout:
self.m_lastHeartbeat = Time.GetCurrMS()
self.m_hasTimedOut = False
if False == self.m_InitialRefreshSent:
self.m_InitialRefreshSent = True
buffer = "<?xml version=\"1.0\" encoding=\"utf-8\"?>"
buffer = buffer + "<Oscar Type=\"Refresh\">"
buffer = buffer + "<Version>1.0</Version>"
uID = str(random.randint(0, 500000))
buffer = buffer + "<UniqueID>" + uID + "</UniqueID>"
buffer = buffer + "</Oscar>"
from Helpers import TargetManager
if TargetManager.GetTargetManager().BroadcastUpstream(buffer):
Log.getLogger().info("Sending Refresh Request to Minions [" +
uID + ']')
TargetManager.GetTargetManager().BroadcastUpstream(
buffer
) # is UDP, so send a couple more times, dups will be filtered on Minion
TargetManager.GetTargetManager().BroadcastUpstream(buffer)
class MarvinData(object):
__FirstTime = Time.GetCurrMS()
def __init__(self,Namespace,ID,Value,ElapsedTime,FormatVersion,isLive=True):
from Helpers import Configuration
self.FormatVersion=FormatVersion
self.Value = Value
if True == isLive:
self.ArrivalTime = Time.GetCurrMS() - MarvinData.__FirstTime # just a delta from start is fine, no need for a 10 digit string for time
else:
self.ArrivalTime = ElapsedTime
self.Namespace = Configuration.get().HandleBITWNamespace(Namespace) # if Bump in the Wire, change NS
self.ID = ID
self.Live = isLive
def ToXML(self,destIsFile=False):
startCDATA="<![CDATA["
endCDATA="]]>"
if False == destIsFile:
buffer = "<?xml version=\"1.0\" encoding=\"utf-8\"?>"
else:
buffer = ""
buffer = buffer + "<Oscar Type=\"Data\">"
buffer = buffer + "<Version>1</Version>"
buffer = buffer + "<Namespace>"+self.Namespace+"</Namespace>"
buffer = buffer + "<ID>"+self.ID+"</ID>"
if False == destIsFile:
buffer = buffer + "<Value LiveData=\""+str(self.Live)+"\">"+startCDATA+self.Value+endCDATA+"</Value>"
else:
buffer = buffer + "<Value>"+self.Value+"</Value>"
buffer = buffer + "</Oscar>"
return buffer
def PerformCollection(self):
#Get collected time after collection, can't be sure each collection take same amount of time
currMS = Time.GetCurrMS()
elapsedTime = currMS - self._LastCollectionTime
self._LastCollectionTime = currMS
retValue = None
collectedGroupData = ""
for collector in self._CollectorList:
id = collector.GetID()
if self._ForceCollectionEvenIfNoUpdate or collector.NeedsCollecting(
): # by default a group ALWAYS collects, but can override that with AlwaysCollect="False" as group attribute
collectorData = collector.PerformCollection()
if None != collectorData:
collectedGroupData += collectorData
if len(collectedGroupData) > 1:
retValue = "<MinionGroup>" + collectedGroupData + "</MinionGroup>"
if self._RefreshRequested:
self._RefreshRequested = False
return retValue
def __CollectSingleRange(self,fnKillSignalled,processThreadID):
from Helpers import Configuration
count = 0
currTotal = 0
maxTx = Configuration.GetMaxTransmitBufferBeforeRest()
startTime = Time.GetCurrMS()
collectorList = self.__GetCollectorListForThreadGroup(processThreadID)
for collector in collectorList:
if fnKillSignalled(): # get out of possible long loop if we are to exit
return
if not collector.IsInGroup() and not collector.IsOnDemand():
SizeOfSentData = collector.alternateCollectionProc()
if SizeOfSentData > 0:
self.IncrementSentBytes(SizeOfSentData)
count+=1
currTotal += SizeOfSentData
if currTotal > maxTx: # don't want to overload Oscar
Sleep.SleepMs(50)
currTotal = 0
#timeTaken = Time.GetCurrMS() - startTime
#print(processThreadID +": " + str(timeTaken))
#if Namespace._LogTimePerProcessLoop and timeTaken > 0:
# Log.getLogger().debug("Process Thread: " + collectorList[0].GetProcessThreadID() + " took " + str(timeTaken) + "ms to process one loop")
#if timeTaken > Namespace._LoopTimePeriodWarningThreshold and not Namespace._LogTimePerProcessLoop :
# Log.getLogger().warning("Process Thread: " + collectorList[0].GetProcessThreadID() + " took " + str(timeTaken) + "ms to process one loop - you may want to investigate.")
#if "Default" != processThreadID:
# print(processThreadID + " Collected " + str(count) +"/" + str(len(collectorList)))
return count
def test_log_fmt_time(self):
now = Time.time.localtime()
actual = Time.log_fmt_time(now)
expected = Time.time.strftime(Time.FMT_LOG_TIME, now)
self.assertEqual(expected, actual)
def GetTimeMS(self):
if None == self._SyncFile:
return Time.GetCurrMS()
return Time.GetFileTimestampMS(self._SyncFile)
def ResetStats(self):
self.m_lastHeartbeat = Time.GetCurrMS()
self.m_PacketsSent = 0
self.m_BytestSent = 0
self.m_hasTimedOut = False
self.LastPacket = None
def Collect(self):
AddedNewDynamicCollectors = False
try:
fname = FileCollector.convertPath(self.__FileName)
if None != self.__LockFileName:
lockName = self.__LockFileName
if False == WaitForLock(lockName ):
Log.getLogger().error("Timeout getting exclusive lockfile: " + self.__LockFileName)
return "HelenKeller"
elapsedTime = self.GetElapsedTimeSinceLast()
with open(self.__FileName,"rt") as inpFile:
data = inpFile.read()
if None != self.__LockFileName:
try :
os.remove(lockName)
except Exception as ex:
return "0"
except Exception as Ex:
if not self.__LoadWarningSent:
self.__LoadWarningSent = True
Log.getLogger().warn("Problem loading DynamicCollector File: " + self.__FileName +". No additional warnings after this")
return "HelenKeller"
#Entire file is now in Data and file is closed. So go parse it
lines = data.split('\n') # might need os.linesp here....
ts = Time.GetFileTimestampMS(fname)
timeDelta = ts - self.__PreviousTimestamp
self.__PreviousTimestamp = ts
# print("File Time Delta: " + str(timeDelta) + " Elapsed Time: " + str(elapsedTime) + "Entries: " + str(len(lines)))
#altTokens=['= ',': ',':',' ']
try:
for line in lines:
for firstToken in self.__TokenList:
dataPoint = line.split(firstToken,1)
if len(dataPoint) > 1:
break
if len(dataPoint) > 1: # filter out empties
ID = dataPoint[0]
Value = dataPoint[1]
ID = ID.strip()
Value = Value.strip()
ID = self.__PrefixStr + ID + self.__SuffixStr
objCollector = self._NamespaceObject.GetCollector(ID)
if None == objCollector:
objCollector = self.__createCollector(ID)
Log.getLogger().debug("Dynamic Collector found with token: '" + firstToken + "'")
objCollector.SetDynamicData(Value,elapsedTime)
except Exception as ex:
Log.getLogger().error("Something bad happened in DynamicCollector Collector(): " + str(ex))
return "HelenKeller"
def test_fmt_date(self):
now = Time.time.localtime()
actual = Time.file_fmt_date(now)
expected = Time.time.strftime(Time.FMT_DATE, now)
self.assertEqual(expected, actual)
def Start(self):
self._StartTime = Time.GetCurrMS()
self._Stopped = False
self._Saved = False
