def test_errorTraceToString(self):
"""ErrorTraceHelper errorTraceToString creates formatted message"""
rv = 'ErrorTrace (TimeStamp=Tue Feb 3 21:42:26 2009,\n File=myfile,\n Line=myline,\n Routine=myroutine,\n Host=myhost,\n Process=myprocess,\n Thread=mythread,\n Type=0,\n Code=0,\n ShortDescrip=Description,\n Severity=Routine,\n Data: )\n'
tu = TimeUtil()
et = ACSErr.ErrorTrace('myfile', 'myline', 'myroutine', 'myhost',
'myprocess', 'mythread',
tu.py2epoch(1233697346).value, 'mySourceObj', 0,
0, 'Routine', 'Description', [], None)
self.assertEqual(rv, self.eth.errorTraceToString(et, ' '))
def test_Print(self):
"""ErrorTraceHelper Print produces output for a single trace"""
tu = TimeUtil()
et = ACSErr.ErrorTrace('myfile', 'myline', 'myroutine', 'myhost',
'myprocess', 'mythread',
tu.py2epoch(1233697346).value, 'mySourceObj', 0,
0, 'Routine', 'Description', [], [])
self.eth = ET.ErrorTraceHelper(et)
self.eth.Print()
self.assertEqual('write', sys.stdout.method_calls[0][0])
def test_errorTraceToString(self):
"""ErrorTraceHelper errorTraceToString creates formatted message"""
rv = 'ErrorTrace (TimeStamp=Tue Feb 3 21:42:26 2009,\n File=myfile,\n Line=myline,\n Routine=myroutine,\n Host=myhost,\n Process=myprocess,\n Thread=mythread,\n Type=0,\n Code=0,\n ShortDescrip=Description,\n Severity=Routine,\n Data: )\n'
tu = TimeUtil()
et = ACSErr.ErrorTrace('myfile', 'myline', 'myroutine', 'myhost',
'myprocess', 'mythread',
tu.py2epoch(1233697346).value,
'mySourceObj', 0, 0, 'Routine', 'Description',
[], None)
self.assertEqual(rv, self.eth.errorTraceToString(et, ' '))
def test_Print(self):
"""ErrorTraceHelper Print produces output for a single trace"""
tu = TimeUtil()
et = ACSErr.ErrorTrace('myfile', 'myline', 'myroutine', 'myhost',
'myprocess', 'mythread',
tu.py2epoch(1233697346).value,
'mySourceObj', 0, 0, 'Routine', 'Description',
[], [])
self.eth = ET.ErrorTraceHelper(et)
self.eth.Print()
self.assertEqual('write', sys.stdout.method_calls[0][0])
def errorTraceToString(self, error_trace, ws):
'''
Converts an error trace to a human-readable string.
Parameters: error_trace is an errortrace
ws is whitespace
Returns: Nothing
Raises: Nothing
'''
#figure out a nice format for time first
epoch = acstime.Duration(
error_trace.timeStamp) #convert to an ACS epoch
timehelper = TimeUtil()
epoch = timehelper.epoch2py(epoch) #convert to Python time
epoch = gmtime(epoch) #convert to gm time
epoch = asctime(epoch) #convert to nice string format
nice_space = " "
for i in range(0, len(ws) / 4):
nice_space = nice_space + " "
message = "ErrorTrace ("
message = message + "TimeStamp=" + epoch + "," + linesep
message = message + nice_space + "File=" + str(
error_trace.file) + "," + linesep
message = message + nice_space + "Line=" + str(
error_trace.lineNum) + "," + linesep
message = message + nice_space + "Routine=" + str(
error_trace.routine) + "," + linesep
message = message + nice_space + "Host=" + str(
error_trace.host) + "," + linesep
message = message + nice_space + "Process=" + str(
error_trace.process) + "," + linesep
message = message + nice_space + "Thread=" + str(
error_trace.thread) + "," + linesep
message = message + nice_space + "Type=" + str(
error_trace.errorType) + "," + linesep
message = message + nice_space + "Code=" + str(
error_trace.errorCode) + "," + linesep
message = message + nice_space + "ShortDescrip=" + str(
error_trace.shortDescription) + "," + linesep
message = message + nice_space + "Severity=" + str(
error_trace.severity) + "," + linesep
message = message + nice_space + "Data: "
for i in error_trace.data:
message = message + "Name=" + str(i.name) + ", Value=" + str(
i.value) + "; "
message = message + ")" + linesep
return message
def test_log(self):
"""ErrorTraceHelper log records messages on stdout and ACS logger"""
rv = 'ErrorTrace (TimeStamp=Tue Feb 3 21:42:26 2009,\n File=myfile,\n Line=myline,\n Routine=myroutine,\n Host=myhost,\n Process=myprocess,\n Thread=mythread,\n Type=0,\n Code=0,\n ShortDescrip=Description,\n Severity=Routine,\n Data: )\n'
logger = mock.Mock(spec=Logger)
tu = TimeUtil()
et = ACSErr.ErrorTrace('myfile', 'myline', 'myroutine', 'myhost',
'myprocess', 'mythread',
tu.py2epoch(1233697346).value, 'mySourceObj', 0,
0, 'Routine', 'Description', [], [])
self.eth = ET.ErrorTraceHelper(et)
self.eth.log(logger, ACSLog.ACS_LOG_TRACE)
self.assertEqual('logErrorTrace', logger.method_calls[0][0])
self.assertEqual(2, len(sys.stdout.method_calls))
def test_log(self):
"""ErrorTraceHelper log records messages on stdout and ACS logger"""
rv = 'ErrorTrace (TimeStamp=Tue Feb 3 21:42:26 2009,\n File=myfile,\n Line=myline,\n Routine=myroutine,\n Host=myhost,\n Process=myprocess,\n Thread=mythread,\n Type=0,\n Code=0,\n ShortDescrip=Description,\n Severity=Routine,\n Data: )\n'
logger = mock.Mock(spec=Logger)
tu = TimeUtil()
et = ACSErr.ErrorTrace('myfile', 'myline', 'myroutine', 'myhost',
'myprocess', 'mythread',
tu.py2epoch(1233697346).value,
'mySourceObj', 0, 0, 'Routine', 'Description',
[], [])
self.eth = ET.ErrorTraceHelper(et)
self.eth.log(logger, ACSLog.ACS_LOG_TRACE)
self.assertEqual('logErrorTrace', logger.method_calls[0][0])
self.assertEqual(2, len(sys.stdout.method_calls))
def __init__(self,
error_type,
error_code,
exception=None,
description="None",
nvSeq=None,
create=1,
severity=None):
'''
The constructor basically allows the developer to specify any number of
parameters for an error trace, but requires none. Python is flexible enough
to let us do this.
Parameters:
- error_type is the error type (a long)
- error_code is the error code (a long)
- exception is a previous exception from the ACS Error System, or a Python
native exception, in which case, an ErrorTrace will be constructed. The traceback
should be ok in most cases, but if you find that it isn't, a possible workaround is
converting the python exception to an ACS exception using pyExceptionToCORBA()
before passing it to an ACSError constructor. Remember, that if you don't use
pyExceptionToCORBA(), if
you are dealing with a native exception, you must pass create=1 to the ACSError
constructor.
- description is a stringified description of the errror
- nvSeq is a name-value sequence describing the error condition. Each value
should be of the type ACSErr.NameValue
- create with a value of 1 implies error information will be added to the stack
- severity is the ACSErr severity of the error
Returns: Nothing
Raises: Nothing
'''
if nvSeq == None:
nvSeq = []
# Get a Logger instance
self.timehelper = TimeUtil()
#If create has not been changed by the developer we create a new error trace
#appending the old one if it exists
if create == 1:
self.errorTrace = ErrorTrace(error_type, error_code, exception,
description, nvSeq, 3, severity)
#Someone has caught a CORBA exception and is trying to convert it into
#this helper class.
elif exception != None:
#If the previous exception is an ACS Error System Exception
if hasattr(exception, "errorTrace"):
#We can use an error stack...
self.errorTrace = exception.errorTrace
#if the previous exception was actually an ACSErr.Completion with a
#non-empty error trace
elif hasattr(exception, "previousError") and (len(
exception.previousError) == 1):
self.errorTrace = exception.previousError[0]
def test_Print_nested(self):
"""ErrorTraceHelper Print produces output for a nested trace"""
tu = TimeUtil()
etg = ACSErr.ErrorTrace('myfile', 'myline', 'myroutine', 'myhost',
'grandson', 'mythread',
tu.py2epoch(1233697346).value, 'mySourceObj',
0, 0, 'Routine', 'Description', [], [])
ets = ACSErr.ErrorTrace('myfile', 'myline', 'myroutine', 'myhost',
'son', 'mythread',
tu.py2epoch(1233697346).value, 'mySourceObj',
0, 0, 'Routine', 'Description', [], [etg])
etf = ACSErr.ErrorTrace('myfile', 'myline', 'myroutine', 'myhost',
'father', 'mythread',
tu.py2epoch(1233697346).value, 'mySourceObj',
0, 0, 'Routine', 'Description', [], [ets])
self.eth = ET.ErrorTraceHelper(etf)
self.eth.Print()
self.assertEqual(6, len(sys.stdout.method_calls))
def test_Print_nested(self):
"""ErrorTraceHelper Print produces output for a nested trace"""
tu = TimeUtil()
etg = ACSErr.ErrorTrace('myfile', 'myline', 'myroutine', 'myhost',
'grandson', 'mythread',
tu.py2epoch(1233697346).value,
'mySourceObj', 0, 0, 'Routine', 'Description',
[], [])
ets = ACSErr.ErrorTrace('myfile', 'myline', 'myroutine', 'myhost',
'son', 'mythread',
tu.py2epoch(1233697346).value,
'mySourceObj', 0, 0, 'Routine', 'Description',
[], [etg])
etf = ACSErr.ErrorTrace('myfile', 'myline', 'myroutine', 'myhost',
'father', 'mythread',
tu.py2epoch(1233697346).value,
'mySourceObj', 0, 0, 'Routine', 'Description',
[], [ets])
self.eth = ET.ErrorTraceHelper(etf)
self.eth.Print()
self.assertEqual(6, len(sys.stdout.method_calls))
def errorTraceToString(self, error_trace, ws):
'''
Converts an error trace to a human-readable string.
Parameters: error_trace is an errortrace
ws is whitespace
Returns: Nothing
Raises: Nothing
'''
#figure out a nice format for time first
epoch = acstime.Duration(error_trace.timeStamp) #convert to an ACS epoch
timehelper = TimeUtil()
epoch = timehelper.epoch2py(epoch) #convert to Python time
epoch = gmtime(epoch) #convert to gm time
epoch = asctime(epoch) #convert to nice string format
nice_space = " "
for i in range(0, len(ws)/4):
nice_space = nice_space + " "
message = "ErrorTrace ("
message = message + "TimeStamp=" + epoch + "," + linesep
message = message + nice_space + "File=" + str(error_trace.file) + "," + linesep
message = message + nice_space + "Line=" + str(error_trace.lineNum) + "," + linesep
message = message + nice_space + "Routine=" + str(error_trace.routine) + "," + linesep
message = message + nice_space + "Host=" + str(error_trace.host) + "," + linesep
message = message + nice_space + "Process=" + str(error_trace.process) + "," + linesep
message = message + nice_space + "Thread=" + str(error_trace.thread) + "," + linesep
message = message + nice_space + "Type=" + str(error_trace.errorType) + "," + linesep
message = message + nice_space + "Code=" + str(error_trace.errorCode) + "," + linesep
message = message + nice_space + "ShortDescrip=" + str(error_trace.shortDescription) + "," + linesep
message = message + nice_space + "Severity=" + str(error_trace.severity) + "," + linesep
message = message + nice_space + "Data: "
for i in error_trace.data:
message = message + "Name=" + str(i.name) + ", Value=" + str(i.value) + "; "
message = message + ")" + linesep
return message
def to_posixtime(tm):
"""
Convert an ACS epoch to a POSIX timestamp...
...such as is returned by time.time().
@param tm: A time in 100 nanoseconds that have passed since
October 15, 1582.
@type tm: acstime.Epoch
@return: The POSIX timestamp.
@rtype: float
"""
return TimeUtil().epoch2py(tm)
def __init__(self, parent, eventAdminRef, filename):
'''
Standard Constructor
Paramters:
- parent is the parent widget of this class
- eventAdminRef is a reference to an ACSEventAdmin IDL interface
Returns: Nothing
Raises: ???
'''
self.archiveEventsFile = None
if filename != None:
self.archiveEventsFile = file(filename, "w")
#call superclass constructor
CBstring.__init__(self)
#time helper instance. used to format timestamps.
self.timehelper = TimeUtil()
#save the component reference
self.eventAdminRef = eventAdminRef
#activate ourself as a corba object
self.corbaRef = self._this()
#the fields that will be outputted for the Event browser
self.ebFields = ["Timestamp", "Channel", "Source", "SupplierEvent#", "ChannelEvent#", "Type", "TypeEvent#"]
#Layout of the columns
self.ebFormat = '%25s %12s %12s %16s %15s %20s %15s'
#Copy the parent widget
self.parent = parent
#place where we map events within the GUI to the real events
self.outputEventMap = {}
# Create and pack the MenuBar.
menuBar = Pmw.MenuBar(parent,
hull_relief = 'raised',
hull_borderwidth = 1)
menuBar.pack(fill = 'x')
self.menuBar = menuBar
menuBar.addmenu('Browser Options', 'Save, Clear, or Exit')
menuBar.addmenuitem('Browser Options',
'command',
'Save events to a file',
command = self.saveEvents,
label = 'Save Events')
menuBar.addmenuitem('Browser Options',
'command',
'Clear list of events from this browser',
command = self.clearEvents,
label = 'Clear Events')
#--This does not work unless the modules for the events have been imported
#--unfortunately. Commented out for now. DWF
#menuBar.addmenuitem('Browser Options',
# 'command',
# 'Saves the events so they can be reloaded later.',
# command = self.pickleEvents,
# label = 'Pickle Events')
#menuBar.addmenuitem('Browser Options',
# 'command',
# 'Loads pickled events into the browser.',
# command = self.loadPickledEvents,
# label = 'Load Pickled Events')
#create the event browser group
browserGroup = Pmw.Group(parent, tag_text='Event Browser')
browserGroup.pack(fill='x', expand='1', side = 'top', padx = 5, pady = 3)
headerLine = self.ebFormat % tuple(self.ebFields)
#create the channel group
channelGroup = Pmw.Group(parent, tag_text='Channels')
channelGroup.pack(side = 'left', padx = 5, pady = 3)
#create the admin group
eventViewerGroup = Pmw.Group(parent, tag_text='Event Viewer')
eventViewerGroup.pack(side = 'left', padx = 5, pady = 3)
#create the admin group
adminGroup = Pmw.Group(parent, tag_text='Channel Administration')
adminGroup.pack(fill='both', expand='1', side = 'left', padx = 5, pady = 3)
#-----------------------------------------------------------
#--Event viewer box
self.evST= Pmw.ScrolledText(eventViewerGroup.interior(),
borderframe = 0,
columnheader = 0,
usehullsize = 1,
hull_width = 300,
hull_height = 300,
text_wrap='none',
text_font = Pmw.logicalfont('Fixed'),
text_padx = 4,
text_pady = 4)
#make the scrolling text window big
self.evST.pack(padx = 5, pady = 5, fill = 'both', expand = 1)
# Prevent users' modifying text and headers
#self.evST.configure(text_state = 'disabled')
############################################################
##Event Browser#############################################
# Create the ScrolledText with headers.
self.ebST = Pmw.ScrolledListBox(browserGroup.interior(),
items=(),
labelpos='nw',
label_text = " " + headerLine,
usehullsize = 1,
hull_width = 1100,
hull_height = 300,
selectioncommand=self.displayEvent
)
#make the scrolling text window big
self.ebST.pack(padx = 5, pady = 5, fill = 'both', expand = 1)
############################################################
#Active Channels############################################
# Create and pack the simple ComboBox.
self.channelNames = tuple(self.eventAdminRef.getActiveChannels())
self.acScrolledLB = Pmw.ScrolledListBox(channelGroup.interior(),
selectioncommand = self.displayActiveChannel,
hscrollmode = 'dynamic',
vscrollmode = 'dynamic',
items = self.channelNames)
#make it big
self.acScrolledLB.pack(side = 'left',
fill = 'both',
expand = 0,
padx = 8,
pady = 8)
############################################################
##Admin Panel
self.adminChannelName = Pmw.EntryField(adminGroup.interior(),
labelpos = 'w',
label_text = 'Channel name:',
validate = None)
self.adminChannelName.pack(expand=0,
padx=10,
pady=5,
side = 'top')
self.adminChannelMethod = Pmw.OptionMenu(adminGroup.interior(),
labelpos = 'w',
label_text = 'Choose administrative option:',
items = ('Create', 'Destroy'), #items = ('Create', 'Destroy', 'Reconfigure'),
menubutton_width = 10)
self.adminChannelMethod.pack(anchor = 'w', padx = 10, pady = 10)
createChannelSubmit = Pmw.ButtonBox(adminGroup.interior())
createChannelSubmit.pack(side = 'bottom')
createChannelSubmit.add('Submit', text = 'Submit', command = self.submit)
############################################################
#finally we can begin receiving CORBA callbacks.
self.eventAdminRef.monitorEvents(self.corbaRef, CBDescIn(0L, 0L, 0L))
#constantly look for new channels
self.running = 1
start_new_thread(self.pollActiveChannels, ())
return
class ACSEventAdminGUI(CBstring):
'''
ACSEventAdminGUI, derived from the IDL interface CBstring, is the primary GUI panel
used with the ACSEventAdmin IDL interface.
'''
def __init__(self, parent, eventAdminRef, filename):
'''
Standard Constructor
Paramters:
- parent is the parent widget of this class
- eventAdminRef is a reference to an ACSEventAdmin IDL interface
Returns: Nothing
Raises: ???
'''
self.archiveEventsFile = None
if filename != None:
self.archiveEventsFile = file(filename, "w")
#call superclass constructor
CBstring.__init__(self)
#time helper instance. used to format timestamps.
self.timehelper = TimeUtil()
#save the component reference
self.eventAdminRef = eventAdminRef
#activate ourself as a corba object
self.corbaRef = self._this()
#the fields that will be outputted for the Event browser
self.ebFields = ["Timestamp", "Channel", "Source", "SupplierEvent#", "ChannelEvent#", "Type", "TypeEvent#"]
#Layout of the columns
self.ebFormat = '%25s %12s %12s %16s %15s %20s %15s'
#Copy the parent widget
self.parent = parent
#place where we map events within the GUI to the real events
self.outputEventMap = {}
# Create and pack the MenuBar.
menuBar = Pmw.MenuBar(parent,
hull_relief = 'raised',
hull_borderwidth = 1)
menuBar.pack(fill = 'x')
self.menuBar = menuBar
menuBar.addmenu('Browser Options', 'Save, Clear, or Exit')
menuBar.addmenuitem('Browser Options',
'command',
'Save events to a file',
command = self.saveEvents,
label = 'Save Events')
menuBar.addmenuitem('Browser Options',
'command',
'Clear list of events from this browser',
command = self.clearEvents,
label = 'Clear Events')
#--This does not work unless the modules for the events have been imported
#--unfortunately. Commented out for now. DWF
#menuBar.addmenuitem('Browser Options',
# 'command',
# 'Saves the events so they can be reloaded later.',
# command = self.pickleEvents,
# label = 'Pickle Events')
#menuBar.addmenuitem('Browser Options',
# 'command',
# 'Loads pickled events into the browser.',
# command = self.loadPickledEvents,
# label = 'Load Pickled Events')
#create the event browser group
browserGroup = Pmw.Group(parent, tag_text='Event Browser')
browserGroup.pack(fill='x', expand='1', side = 'top', padx = 5, pady = 3)
headerLine = self.ebFormat % tuple(self.ebFields)
#create the channel group
channelGroup = Pmw.Group(parent, tag_text='Channels')
channelGroup.pack(side = 'left', padx = 5, pady = 3)
#create the admin group
eventViewerGroup = Pmw.Group(parent, tag_text='Event Viewer')
eventViewerGroup.pack(side = 'left', padx = 5, pady = 3)
#create the admin group
adminGroup = Pmw.Group(parent, tag_text='Channel Administration')
adminGroup.pack(fill='both', expand='1', side = 'left', padx = 5, pady = 3)
#-----------------------------------------------------------
#--Event viewer box
self.evST= Pmw.ScrolledText(eventViewerGroup.interior(),
borderframe = 0,
columnheader = 0,
usehullsize = 1,
hull_width = 300,
hull_height = 300,
text_wrap='none',
text_font = Pmw.logicalfont('Fixed'),
text_padx = 4,
text_pady = 4)
#make the scrolling text window big
self.evST.pack(padx = 5, pady = 5, fill = 'both', expand = 1)
# Prevent users' modifying text and headers
#self.evST.configure(text_state = 'disabled')
############################################################
##Event Browser#############################################
# Create the ScrolledText with headers.
self.ebST = Pmw.ScrolledListBox(browserGroup.interior(),
items=(),
labelpos='nw',
label_text = " " + headerLine,
usehullsize = 1,
hull_width = 1100,
hull_height = 300,
selectioncommand=self.displayEvent
)
#make the scrolling text window big
self.ebST.pack(padx = 5, pady = 5, fill = 'both', expand = 1)
############################################################
#Active Channels############################################
# Create and pack the simple ComboBox.
self.channelNames = tuple(self.eventAdminRef.getActiveChannels())
self.acScrolledLB = Pmw.ScrolledListBox(channelGroup.interior(),
selectioncommand = self.displayActiveChannel,
hscrollmode = 'dynamic',
vscrollmode = 'dynamic',
items = self.channelNames)
#make it big
self.acScrolledLB.pack(side = 'left',
fill = 'both',
expand = 0,
padx = 8,
pady = 8)
############################################################
##Admin Panel
self.adminChannelName = Pmw.EntryField(adminGroup.interior(),
labelpos = 'w',
label_text = 'Channel name:',
validate = None)
self.adminChannelName.pack(expand=0,
padx=10,
pady=5,
side = 'top')
self.adminChannelMethod = Pmw.OptionMenu(adminGroup.interior(),
labelpos = 'w',
label_text = 'Choose administrative option:',
items = ('Create', 'Destroy'), #items = ('Create', 'Destroy', 'Reconfigure'),
menubutton_width = 10)
self.adminChannelMethod.pack(anchor = 'w', padx = 10, pady = 10)
createChannelSubmit = Pmw.ButtonBox(adminGroup.interior())
createChannelSubmit.pack(side = 'bottom')
createChannelSubmit.add('Submit', text = 'Submit', command = self.submit)
############################################################
#finally we can begin receiving CORBA callbacks.
self.eventAdminRef.monitorEvents(self.corbaRef, CBDescIn(0L, 0L, 0L))
#constantly look for new channels
self.running = 1
start_new_thread(self.pollActiveChannels, ())
return
#------------------------------------------------------------------------------
def displayEvent(self):
'''
Displays a single ICD-style event on the screen.
'''
#get the key
t_key = self.ebST.getcurselection()[0]
#get a textual representation
t_list = getTextRepresentation(self.outputEventMap[t_key])
#clear the box
self.evST.clear()
#write it to the box
for line in t_list:
self.evST.insert('end', line + '\n')
return
#------------------------------------------------------------------------------
def displayActiveChannel(self):
'''
When someone clicks on a channel, a new widget is spawned displaying various
pieces of information
Paramters: None
Returns: Nothing
Raises: ???
'''
#just depend on a helper class to do the real work
self.displayChannelHelper(list(self.acScrolledLB.getcurselection()))
#------------------------------------------------------------------------------
def displayChannelHelper(self, channelList):
'''
Responsibile for spawning a new widget displaying channel info. This is a
recursive method so end-users can highlight multiple channels at the same time.
Really this can never be the case given the current implementation though.
Parameters:
- channelList is a list of channel names
Returns: Nothing
Raises: ???
'''
#if this is the last call in the recursive chain...return control
if len(channelList) == 0:
return
#pop a channel name; create a new widget; and make a recursive call
else:
#last channelName from the list
channelName = channelList.pop()
#get the channel info
data = self.eventAdminRef.getChannelInfo(channelName)
#create a new widget
message = "Channel name: " + str(channelName) + '\n'
message += "Number of suppliers: " + str(data[0]) + '\n'
message += "Number of consumers: " + str(data[1]) + '\n'
message += "Total events recieved: " + str(data[2]) + '\n'
message += "EventTypeInfo:\n"
for eventType in data[5]:
message += " " + str(eventType) + '\n'
ChannelInfo(self.parent, message_text = message, icon_bitmap = 'info')
#recursive call
self.displayChannelHelper(channelList)
return
#------------------------------------------------------------------------------
def working (self, value, completion, desc):
'''
Overriden method from the CBstring class which is invoked each time an event
is received. The event is outputted to a scrolled textbox widget.
Parameters:
- value is the stringified event
- completion is a CORBA completion structure
- desc is callback struct description
Returns: Nothing
Raises: ???
'''
global EVENT_CACHE
#to make pychecker happy
del completion
#to make pychecker happy
del desc
#backup
orig_val = value
# Create a new data row
value = string.split(value)
#convert the time to something human-readable
epoch = acstime.Duration(long(value[0])) #convert to an ACS epoch
epoch = self.timehelper.epoch2py(epoch) #convert to Python time
epoch = gmtime(epoch) #convert to gm time
epoch = asctime(epoch) #convert to nice string format
dataLine = self.ebFormat % (epoch, value[1], value[2], value[3], value[4], value[5], value[6]) #tuple(value)
#output the line to the GUI
self.ebST.insert('end', dataLine)
#if we are logging events to a file, save the event
if self.archiveEventsFile != None:
self.archiveEventsFile.write(dataLine)
self.archiveEventsFile.write("\n")
self.archiveEventsFile.flush()
#save the original output for use with the cache
try:
self.outputEventMap[dataLine] = EVENT_CACHE[orig_val]
except:
self.outputEventMap[dataLine] = None
return
#------------------------------------------------------------------------------
def pollActiveChannels(self):
'''
Gets an updated list of all notification channels and outputs them to the GUI.
Designed to be invoked from a thread.
Parameters: None
Returns: Nothing
Raises: ???
'''
while self.running:
try:
#list of all the channels the administrator knows about
self.channelNames = tuple(self.eventAdminRef.getActiveChannels())
#update the GUI
self.acScrolledLB.setlist(self.channelNames)
except:
pass
#sleep for awhile
sleep(2)
#------------------------------------------------------------------------------
def saveEvents(self):
'''
Prompts user for a filename, then saves the entire list of all known events to the given text file.
Parameters: None
Returns: Nothing
Raises: ???
'''
#save the events to the text file specified in the GUI
filename = asksaveasfilename()
if filename!=():
# open the file
temp_file = file(filename, "w")
# write the events to the file, adding a new line after each event
temp_file.writelines('\n'.join(self.ebST.get()))
# close the file
temp_file.close()
#------------------------------------------------------------------------------
def clearEvents(self):
'''
Saves the entire list of all known events to a given text file.
Parameters: None
Returns: Nothing
Raises: ???
'''
global EVENT_CACHE
#save the events to the text file specified in the GUI
print dir(self.ebST)
self.ebST.clear()
self.evST.clear()
#clear the caches
EVENT_CACHE.clear()
self.outputEventMap.clear()
#------------------------------------------------------------------------------
def pickleEvents(self):
'''
Pickles the list of all known events to a given file.
Parameters: None
Returns: Nothing
Raises: ???
'''
#save the events to the text file specified in the GUI
filename = asksaveasfilename()
if filename!=():
#open it
temp_file = open(filename, "w")
#dump the cache into the file
pickle.dump(self.outputEventMap, temp_file)
#close it
temp_file.close()
#------------------------------------------------------------------------------
def loadPickledEvents(self):
'''
Loads a pickled list of all known events from a given file.
Parameters: None
Returns: Nothing
Raises: ???
'''
#get the file containing the pickled cache from the user
temp_file = askopenfile('r')
#create a temporary dictionary with the cache
t_cache = pickle.load(temp_file)
#cleanup
temp_file.close()
#wipe out all of the old events
self.clearEvents()
#fill the cache again
self.outputEventMap.update(t_cache)
#populate the GUI with the events
for key in self.outputEventMap.keys():
self.ebST.insert('end', key)
return
#------------------------------------------------------------------------------
def stopArchiving(self):
'''
Can be called to stop the archiving to a file.
'''
if self.archiveEventsFile != None:
self.archiveEventsFile.close()
self.archiveEventsFile = None
#------------------------------------------------------------------------------
def submit(self):
'''
Called each time the user tries to invoke some administrative function.
DWF - needs a lot of work still.
'''
method = str(self.adminChannelMethod.getcurselection())
parameter = str(self.adminChannelName.getvalue())
#('Create', 'Destroy', 'Reconfigure')
if method == 'Create':
self.eventAdminRef.createChannel(parameter, [], [])
elif method == 'Destroy':
self.eventAdminRef.destroyChannel(parameter)
elif method == 'Reconfigure':
self.eventAdminRef.configChannelProperties(parameter, [], [])
print "Reconfigure not yet implemented"
def sendLog(self, record):
'''
Method which sends logs to the real ACS logging service.
'''
if (not self.logThrottle.checkPublishLogRecord()):
if self.logThrottleAlarmSender != None and not self.logThrottleAlarmActive:
self.logThrottleAlarmActive = True
self.logThrottleAlarmSender.sendThrottleAlarm(True)
return
else:
if self.logThrottleAlarmSender != None and self.logThrottleAlarmActive:
self.logThrottleAlarmActive = False
self.logThrottleAlarmSender.sendThrottleAlarm(False)
# Create an RTContext object
rt_context = ACSLog.RTContext(
str(record.threadName).replace("<", "").replace(">", ""),
str(record.source).replace("<", "").replace(">", ""),
str(gethostname()).replace("<", "").replace(">", ""), "",
str(record.name).replace("<", "").replace(">", ""))
src_info = ACSLog.SourceInfo(
str(record.module).replace("<", "").replace(">", ""), "Unknown",
long(record.lineno))
# Put remaining keyword arguments into NVPairSeq
data = []
if TimeUtil().py2epoch(time()).value > TimeUtil().py2epoch(
record.created + self.timestampThreshold).value:
# Reformat the record
originalMsg = NVPair("Original message", record.getMessage())
data.append(originalMsg)
originalTimestamp = NVPair("Original timestamp", record.asctime)
data.append(originalTimestamp)
record = self.replaceOldRecord(record)
#timestamp
acs_timestamp = TimeUtil().py2epoch(record.created).value
if 'priority' in record.__dict__:
# The more exotic log functions have priority keyword arguments
if 'errortrace' in record.__dict__:
# The message is an ErrorTrace.
self.logSvc.logErrorWithPriority(record.errortrace,
record.priority)
elif 'data' in record.__dict__:
# The message is a type-safe log message
self.logSvc.logWithPriority(
record.priority, acs_timestamp, record.getMessage(),
record.rtCont if 'rtCont' in record.__dict__
and record.rtCont is not None else rt_context,
record.srcInfo if 'srcInfo' in record.__dict__
and record.srcInfo is not None else src_info, record.data,
record.audience, record.array, record.antenna)
else:
# The message is a not-so-type-safe message
self.logSvc.logWithAudience(record.priority, acs_timestamp,
record.getMessage(), rt_context,
src_info, record.audience,
record.array, record.antenna)
elif record.levelname == 'TRACE':
self.logSvc.logTrace(acs_timestamp, record.getMessage(),
rt_context, src_info, data)
elif record.levelname == 'DELOUSE':
self.logSvc.logDelouse(acs_timestamp, record.getMessage(),
rt_context, src_info, data)
elif record.levelname == 'DEBUG':
self.logSvc.logDebug(acs_timestamp, record.getMessage(),
rt_context, src_info, data)
elif record.levelname == 'INFO':
self.logSvc.logInfo(acs_timestamp, record.getMessage(), rt_context,
src_info, data)
elif record.levelname == 'NOTICE':
self.logSvc.logNotice(acs_timestamp, record.getMessage(),
rt_context, src_info, data)
elif record.levelname == 'WARNING' or record.levelname == 'WARN':
self.logSvc.logWarning(acs_timestamp, record.getMessage(),
rt_context, src_info, data)
#this is a special case because logError only takes
#in error traces
elif record.levelname == 'ERROR':
self.logSvc.logWithAudience(ACSLog.ACS_LOG_ERROR, acs_timestamp,
record.getMessage(), rt_context,
src_info, NO_AUDIENCE, "", "")
elif record.levelname == 'CRITICAL':
self.logSvc.logCritical(acs_timestamp, record.getMessage(),
rt_context, src_info, data)
elif record.levelname == 'ALERT':
self.logSvc.logAlert(acs_timestamp, record.getMessage(),
rt_context, src_info, data)
elif record.levelname == 'EMERGENCY':
self.logSvc.logEmergency(acs_timestamp, record.getMessage(),
rt_context, src_info, data)
#failsafe
else:
self.logSvc.logCritical(acs_timestamp, record.getMessage(),
rt_context, src_info, data)
def testLogTypeSafeInvalidPriority(self):
"""Logger class Type-safe logging with invalid priority"""
msg = "LogTypeSafe Message"
ts = TimeUtil().py2epoch(time.time()).value
self.assertRaises(KeyError, self.mylogger.logTypeSafe, 25, ts, msg,
None, None, None)
