def displayWorkflow(self):
if not sys.stdout.isatty():
return self._workflow.process(self._wait)
self._console = Console(sys.stdout)
self._new_stdout = GUIStream(sys.stdout, self._console, self._lock)
self._new_stderr = GUIStream(sys.stderr, self._console, self._lock)
Activity.callbacks.append(self._schedule_update_report_status)
try:
# Main cycle - GUI mode
(sys.stdout, sys.stderr) = (self._new_stdout, self._new_stderr)
self._console.erase()
self._schedule_update_layout()
self._workflow.process(self._wait)
finally:
(sys.stdout, sys.stderr) = (self._stored_stdout,
self._stored_stderr)
self._console.setscrreg()
self._console.erase()
self._update_all()
def __init__(self, jobDB, task, jobs=None, configString=''):
(self.maxY, self.maxX) = Console().getmaxyx()
self.maxX -= 10 # Padding
AdaptiveBaseReport.__init__(self, jobDB, task, jobs,
str(int(self.maxY / 5)))
def displayWorkflow(self):
gui = self
report = self._report
workflow = self._workflow
def wrapper(screen):
# Event handling for resizing
def onResize(sig, frame):
self._reportHeight = report.getHeight()
screen.savePos()
(sizey, sizex) = screen.getmaxyx()
screen.setscrreg(min(self.getHeight() + 2, sizey), sizey)
utils.printTabular.wraplen = sizex - 5
screen.loadPos()
screen.erase()
onResize(None, None)
def guiWait(timeout):
onResize(None, None)
oldHandler = signal.signal(signal.SIGWINCH, onResize)
result = utils.wait(timeout)
signal.signal(signal.SIGWINCH, oldHandler)
if (time.time() - guiWait.lastwait > 10) and not timeout:
tmp = utils.ActivityLog('') # force display update
tmp.finish()
guiWait.lastwait = time.time()
return result
guiWait.lastwait = 0
# Wrapping ActivityLog functionality
class GUILog(object):
def __init__(self, message):
self._message = '%s...' % message
self.show(self._message)
def finish(self):
if hasattr(sys.stdout, 'logged') and self._message:
self.show(' ' * len(self._message))
self._message = []
def __del__(self):
self.finish()
def show(self, message):
if gui.getHeight() != report.getHeight():
screen.erase()
onResize(None, None)
sys.stdout.dump()
screen.savePos()
screen.move(0, 0)
sys.stdout.logged = False
report.display()
screen.move(gui.getHeight() + 1, 0)
sys.stdout.write('%s\n' % message.center(65))
sys.stdout.logged = True
screen.loadPos()
# Main cycle - GUI mode
saved = (sys.stdout, sys.stderr, utils.ActivityLog)
try:
utils.ActivityLog = GUILog
sys.stdout = GUIStream(saved[0], screen)
sys.stderr = GUIStream(saved[1], screen)
workflow.jobCycle(guiWait)
finally:
sys.stdout, sys.stderr, utils.ActivityLog = saved
screen.setscrreg()
screen.move(1, 0)
screen.eraseDown()
report.display()
sys.stdout.write('\n')
try:
wrapper(Console())
finally:
GUIStream.dump()
def download_multithreaded(opts, workDir, jobList, incInfo, jobDB, token):
from grid_control_gui.ansi import Console
errorOutput = []
class ThreadDisplay:
def __init__(self):
self.output = []
def init(self, jobNum):
self.jobNum = jobNum
self.output = ['Job %5d' % jobNum, '']
def _infoline(self, fileIdx, msg=''):
return 'Job %5d [%i/%i] %s %s' % (self.jobNum, fileIdx + 1,
len(self._files),
self._files[fileIdx][2], msg)
def update_files(self, files):
(self._files, self.output, self.tr) = (files, self.output[1:],
[''] * len(files))
for x in irange(len(files)):
self.output.insert(2 * x, self._infoline(x))
self.output.insert(2 * x + 1, '')
def update_progress(self,
idx,
csize=None,
osize=None,
stime=None,
otime=None):
if otime:
trfun = lambda sref, tref: gcSupport.prettySize(
((csize - sref) / max(1,
time.time() - tref)))
self.tr[idx] = '%7s avg. - %7s/s inst.' % (
gcSupport.prettySize(csize), trfun(0, stime))
self.output[2 * idx] = self._infoline(
idx, '(%s - %7s/s)' % (self.tr[idx], trfun(osize, otime)))
def update_hash(self, idx, hashLocal=None):
file_hash = self._files[idx][0]
if hashLocal:
if file_hash == hashLocal:
result = Console.fmt('MATCH', [Console.COLOR_GREEN])
else:
result = Console.fmt('FAIL', [Console.COLOR_RED])
msg = '(R:%s L:%s) => %s' % (file_hash, hashLocal, result)
else:
msg = ''
self.output[2 * idx] = self._infoline(idx, '(%s)' % self.tr[idx])
self.output[2 * idx + 1] = msg
def error(self, msg):
errorOutput.append(msg)
def update_status(self, idx, msg):
self.output[2 * idx] = str.join(
' ', [self._infoline(idx, '(%s)' % self.tr[idx])] +
(msg or '').split())
def finish(self):
# self.output.append(str(self.jobNum) + 'FINISHED')
pass
download_multithreaded_main(opts, workDir, jobList, incInfo, jobDB, token,
ThreadDisplay, Console(), errorOutput)
