def next_stage(self, stage):
"""
Report stage completion.
Switch to the next test stage if allowed.
Run it or skip it
"""
while not common.is_A_earlier_than_B(stage, self.break_at):
# We have reached the set break
# Waiting until another, later, break is set by manager
self.get_next_break()
self.stage = stage
self.report_status('running', False)
if stage == common.TEST_STAGE_ORDER[0] or common.TEST_STAGE_DEPS[stage] in self.done_stages:
try:
self._execute_stage(stage)
except InterruptTest as exc:
self.retcode = self.retcode or 1
self.process_failure("Interrupted")
if exc.remove_break:
self.break_at = 'finished'
except Exception as ex:
self.retcode = self.retcode or 1
self.log.exception(
"Exception occured, trying to exit gracefully...")
self.process_failure("Exception:" + traceback.format_exc(ex))
else:
self.done_stages.add(stage)
else:
self.process_failure("skipped")
self.report_status('running', True)
def get_next_break(self):
"""
Read the next break from tank queue
Check it for sanity
"""
while True:
msg = self.tank_queue.get()
# Check that there is a break in the message
if 'break' not in msg:
self.log.error(
"No break specified in the recieved message from manager")
continue
brk = msg['break']
# Check taht the name is valid
if brk not in common.test_stage_order:
self.log.error(
"Manager requested break at an unknown stage: %s", brk)
# Check that the break is later than br
elif common.is_A_earlier_than_B(brk, self.break_at):
self.log.error(
"Recieved break %s which is earlier than "
"current next break %s", brk, self.break_at)
else:
self.log.info(
"Changing the next break from %s to %s", self.break_at, brk)
self.break_at = brk
return
def get_next_break(self):
"""
Read the next break from tank queue
Check it for sanity
"""
while True:
msg = self.tank_queue.get()
# Check that there is a break in the message
if 'break' not in msg:
self.log.error(
"No break specified in the recieved message from manager")
continue
brk = msg['break']
# Check taht the name is valid
if not common.is_valid_break(brk):
self.log.error(
"Manager requested break at an unknown stage: %s", brk)
# Check that the break is later than br
elif common.is_A_earlier_than_B(brk, self.break_at):
self.log.error(
"Recieved break %s which is earlier than "
"current next break %s", brk, self.break_at)
else:
self.log.info(
"Changing the next break from %s to %s", self.break_at, brk)
self.break_at = brk
return
def get(self):
breakpoint = self.get_argument("break", "finished")
session_id = self.get_argument("session")
hb_timeout = self.get_argument("heartbeat", None)
self.set_header("Content-type", "application/json")
# 400 if invalid breakpoint
if not common.is_valid_break(breakpoint):
self.reply_json(
400, {
'reason':
'Specified break is not a valid test stage name.',
'hint': {
'breakpoints': common.get_valid_breaks()
}
})
return
# 404 if no such session
try:
status_dict = self.srv.status(session_id)
except KeyError:
self.reply_reason(404, 'No session with this ID.')
return
if session_id != self.srv.running_id:
self.reply_reason(
418,
"I'm a teapot! Can't set break for session that's not running!"
)
return
# 418 if in higher state
if common.is_A_earlier_than_B(breakpoint, status_dict['break']):
reply = {
'reason': 'I am a teapot! I know nothing of time-travel!',
'hint': {
'breakpoints': common.get_valid_breaks()
}
}
reply.update(status_dict)
self.reply_json(418, reply)
return
# Post run command to manager queue
self.srv.cmd({
'session': session_id,
'cmd': 'run',
'break': breakpoint
})
self.srv.heartbeat(session_id, hb_timeout)
self.reply_reason(200, "Will try to set break before " + breakpoint)
def next_stage(self, stage, dump_status=True):
"""
Report stage completion.
Switch to the next test stage if allowed.
"""
self.report_status(
'running', dump_status=dump_status, stage_completed=True)
while not common.is_A_earlier_than_B(stage, self.break_at):
# We have reached the set break
# Waiting until another, later, break is set by manager
self.get_next_break()
self.set_stage(stage, dump_status=dump_status)
def get(self):
breakpoint = self.get_argument("break", "finished")
session_id = self.get_argument("session")
hb_timeout = self.get_argument("heartbeat", None)
self.set_header("Content-type", "application/json")
# 400 if invalid breakpoint
if not common.is_valid_break(breakpoint):
self.reply_json(
400, {
'reason': 'Specified break is not a valid test stage name.',
'hint':
{'breakpoints': common.get_valid_breaks()}
})
return
# 404 if no such session
try:
status_dict = self.srv.status(session_id)
except KeyError:
self.reply_reason(404, 'No session with this ID.')
return
if session_id!=self.srv.running_id:
self.reply_reason(418,
"I'm a teapot! Can't set break for session that's not running!")
return
# 418 if in higher state
if common.is_A_earlier_than_B(breakpoint, status_dict['break']):
reply = {'reason': 'I am a teapot! I know nothing of time-travel!',
'hint': {'breakpoints': common.get_valid_breaks()}}
reply.update(status_dict)
self.reply_json(418, reply)
return
# Post run command to manager queue
self.srv.cmd({
'session': session_id,
'cmd': 'run',
'break': breakpoint})
self.srv.heartbeat(session_id, hb_timeout)
self.reply_reason(200, "Will try to set break before " + breakpoint)
def get(self):
session_id = self.get_argument("session")
filename = self.get_argument("filename", None)
maxsize = self.get_argument("maxsize", None)
# look for test directory
if not os.path.exists(self.srv.session_dir(session_id)):
self.reply_reason(404, 'No session with this ID found')
return
# look for status.json (any test that went past lock stage should have
# it)
if self.srv.is_empty_session(session_id):
self.reply_reason(404, 'Test was not performed, no artifacts.')
return
if not filename:
basepath = self.srv.session_dir(session_id)
onlyfiles = [
f for f in os.listdir(basepath)
if os.path.isfile(os.path.join(basepath, f))
]
self.reply_json(200, onlyfiles)
return
filepath = self.srv.session_file(session_id, filename)
if not os.path.exists(filepath):
self.reply_reason(404, 'No such file in test artifacts')
return
file_size = os.stat(filepath).st_size
if maxsize is not None and file_size > maxsize:
self.reply_json(409,
{'reason': "File does not fit into the size limit specified by the client.",
'filesize': file_size})
return
if file_size > TRANSFER_SIZE_LIMIT:
try:
cur_stage = self.srv.running_status['current_stage']
except KeyError:
pass
else:
if common.is_A_earlier_than_B(cur_stage, 'postprocess'):
self.reply_json(503, {
'reason':
'File is too large and a session is running',
'running_session': self.srv.running_id,
'filesize': file_size,
'limit': TRANSFER_SIZE_LIMIT
})
return
self.set_header("Content-type", "application/octet-stream")
with open(filepath, 'rb') as artifact_file:
while True:
data = artifact_file.read(TRANSFER_SIZE_LIMIT)
if not data:
break
self.write(data)
self.flush()
self.finish()
self.srv.heartbeat(session_id)
def get(self):
session_id = self.get_argument("session")
filename = self.get_argument("filename", None)
maxsize = self.get_argument("maxsize", None)
# look for test directory
if not os.path.exists(self.srv.session_dir(session_id)):
self.reply_reason(404, 'No session with this ID found')
return
# look for status.json (any test that went past lock stage should have
# it)
if self.srv.is_empty_session(session_id):
self.reply_reason(404, 'Test was not performed, no artifacts.')
return
if not filename:
basepath = self.srv.session_dir(session_id)
onlyfiles = [
f for f in os.listdir(basepath)
if os.path.isfile(os.path.join(basepath, f))
]
self.reply_json(200, onlyfiles)
return
filepath = self.srv.session_file(session_id, filename)
if not os.path.exists(filepath):
self.reply_reason(404, 'No such file in test artifacts')
return
file_size = os.stat(filepath).st_size
if maxsize is not None and file_size > maxsize:
self.reply_json(
409, {
'reason':
"File does not fit into the size limit specified by the client.",
'filesize': file_size
})
return
if file_size > TRANSFER_SIZE_LIMIT:
try:
cur_stage = self.srv.running_status['current_stage']
except KeyError:
pass
else:
if common.is_A_earlier_than_B(cur_stage, 'postprocess'):
self.reply_json(
503, {
'reason':
'File is too large and a session is running',
'running_session': self.srv.running_id,
'filesize': file_size,
'limit': TRANSFER_SIZE_LIMIT
})
return
self.set_header("Content-type", "application/octet-stream")
with open(filepath, 'rb') as artifact_file:
while True:
data = artifact_file.read(TRANSFER_SIZE_LIMIT)
if not data:
break
self.write(data)
self.flush()
self.finish()
self.srv.heartbeat(session_id)
