rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
def stop_type(rc): if rc==0: return "stop" return "cancel" stop_type = staticmethod(stop_type) | def stop_type(rc): if rc==0: return "stop" return "cancel" | |
self.proxy.callRemote(self.TASK_STOP, id, self.stop_type("Cancel"), self.mk_msg(reason="Harness could not run the task.", event=evt)) \ .addCallback(self.handle_Stop) | message = ("Harness could not run the task: %s rc=%s" % (evt.arg('message', 'no info'), rc)) self.proxy.callRemote(self.TASK_RESULT, id, RC.FAIL, "harness/run", 1, message) self.proxy.callRemote(self.TASK_STOP, id, "stop", message) \ .addCallback(self.handle_Stop) \ .addErrback(self.on_lc_failure) | def proc_evt_echo(self, evt): cmd = self.get_command(evt.arg('cmd_id')) if (cmd is not None and cmd.command()=='run'): rc = evt.arg('rc') if rc not in (ECHO.OK, ECHO.DUPLICATE): id = evt.task_id # FIXME: Start was not issued. Is it OK? self.task_set_finished(id) self.proxy.callRemote(self.TASK_STOP, id, # FIXME: This i... |
self.proxy.callRemote(self.TASK_STOP, id, self.stop_type(evt.arg("rc", None)), self.mk_msg(event=evt)) \ .addCallback(self.handle_Stop) | rc = int(evt.arg("rc", -1)) if rc != 0: message = "Task exited with non zero exit code. rc=%s" % rc self.proxy.callRemote(self.TASK_RESULT, id, RC.FAIL, "task/exit", rc, message) else: message = "OK" self.proxy.callRemote(self.TASK_STOP, id, "stop", message) \ .addCallback(self.handle_Stop) \ .addErrback(self.on_lc_fai... | def proc_evt_end(self, evt): id = evt.task_id self.close_writers(id) self.task_set_finished(id) self.proxy.callRemote(self.TASK_STOP, id, self.stop_type(evt.arg("rc", None)), self.mk_msg(event=evt)) \ .addCallback(self.handle_Stop) # FIXME: addErrback(...) needed! |
self.task_set_finished() | self.task_set_finished(id) | def proc_evt_echo(self, evt): cmd = self.get_command(evt.arg('cmd_id')) if (cmd is not None and cmd.command()=='run'): rc = evt.arg('rc') if rc not in (ECHO.OK, ECHO.DUPLICATE): # FIXME: Start was not issued. Is it OK? self.task_set_finished() self.proxy.callRemote(self.TASK_STOP, evt.task_id, # FIXME: This is not corr... |
evt.task_id, | id, | def proc_evt_echo(self, evt): cmd = self.get_command(evt.arg('cmd_id')) if (cmd is not None and cmd.command()=='run'): rc = evt.arg('rc') if rc not in (ECHO.OK, ECHO.DUPLICATE): # FIXME: Start was not issued. Is it OK? self.task_set_finished() self.proxy.callRemote(self.TASK_STOP, evt.task_id, # FIXME: This is not corr... |
if not self.task_has_started(): self.task_set_started() self.proxy.callRemote(self.TASK_START, evt.task_id, 0) | id = evt.task_id if not self.task_has_started(id): self.task_set_started(id) self.proxy.callRemote(self.TASK_START, id, 0) | def proc_evt_start(self, evt): if not self.task_has_started(): self.task_set_started() self.proxy.callRemote(self.TASK_START, evt.task_id, 0) # FIXME: start local watchdog |
self.task_set_finished() | self.task_set_finished(id) | def proc_evt_end(self, evt): id = evt.task_id self.close_writers(id) self.task_set_finished() self.proxy.callRemote(self.TASK_STOP, id, self.stop_type(evt.arg("rc", None)), self.mk_msg(event=evt)) \ .addCallback(self.handle_Stop) # FIXME: addErrback(...) needed! |
requirements = [] | requirements = [] version = "0.6.5" long_version = os.environ.get('BEAH_VER', version) + os.environ.get('BEAH_DEV', strftime(".dev%Y%m%d%H%M")) | def glob_to(prefix, new_prefix, dirs): if prefix and prefix[-1]!='/': prefix += '/' return list([(new_prefix+'/'+dir, glob_(prefix, dir+'/*')) for dir in dirs]) |
version="0.6.5", | version=long_version, | def glob_to(prefix, new_prefix, dirs): if prefix and prefix[-1]!='/': prefix += '/' return list([(new_prefix+'/'+dir, glob_(prefix, dir+'/*')) for dir in dirs]) |
env=self.env, path=self.env.get('TESTPATH', '/tmp'), usePTY=True) | env=self.env, path=self.env.get('TESTPATH', '/tmp')) | def server_started(self): # FIXME: Install rhts-test-runner.sh somewhere! self.process = reactor.callLater(2, reactor.spawnProcess, self.task, self.TEST_RUNNER, args=[self.TEST_RUNNER], env=self.env, path=self.env.get('TESTPATH', '/tmp'), usePTY=True) |
log.info("parse_recipe_xml: No recipe for %s." % hostname) return None | for er in root.getElementsByTagName('guestrecipe'): system = xml_attr(er, 'system') if system == hostname: break else: log.info("parse_recipe_xml: No recipe for %s." % hostname) return None | def parse_recipe_xml(input_xml, hostname): root = minidom.parseString(input_xml) for er in root.getElementsByTagName('recipe'): system = xml_attr(er, 'system') if system == hostname: break else: log.info("parse_recipe_xml: No recipe for %s." % hostname) return None task_env = {} rs = xml_attr(er, 'status') if rs not ... |
task_env = {} | def parse_recipe_xml(input_xml, hostname): root = minidom.parseString(input_xml) for er in root.getElementsByTagName('recipe'): system = xml_attr(er, 'system') if system == hostname: break else: for er in root.getElementsByTagName('guestrecipe'): system = xml_attr(er, 'system') if system == hostname: break else: log.i... | |
task_env['RECIPE_ROLE'] = xml_attr(er, 'role') | task_env['RECIPE_ROLE'] = xml_attr(er, 'role', '') | def parse_recipe_xml(input_xml, hostname): root = minidom.parseString(input_xml) for er in root.getElementsByTagName('recipe'): system = xml_attr(er, 'system') if system == hostname: break else: for er in root.getElementsByTagName('guestrecipe'): system = xml_attr(er, 'system') if system == hostname: break else: log.i... |
ROLE=xml_attr(task, 'role')) | ROLE=xml_attr(task, 'role', '')) | def parse_recipe_xml(input_xml, hostname): root = minidom.parseString(input_xml) for er in root.getElementsByTagName('recipe'): system = xml_attr(er, 'system') if system == hostname: break else: for er in root.getElementsByTagName('guestrecipe'): system = xml_attr(er, 'system') if system == hostname: break else: log.i... |
if type == 'job': | msg = evt.arg('msg', '') if msg: msg = " aborted by task %s: %s" % (evt.task_id, msg) else: msg = " aborted by task %s" % (evt.task_id,) if type == 'recipeset': target = self.find_recipeset_id(target) if target is not None: d = self.proxy.callRemote('recipeset_stop', target, 'abort', "RecipeSet"+msg) elif type == 'job'... | def proc_evt_abort(self, evt): type = evt.arg('type', '') if not type: log.error("No abort type specified.") raise exceptions.RuntimeError("No abort type specified.") target = evt.arg('target', None) d = None if type == 'job': target = self.find_job_id(target) if target is not None: d = self.proxy.callRemote('job_stop'... |
d = self.proxy.callRemote('job_stop', target, 'abort', 'Aborted by task.') | d = self.proxy.callRemote('job_stop', target, 'abort', "Job"+msg) | def proc_evt_abort(self, evt): type = evt.arg('type', '') if not type: log.error("No abort type specified.") raise exceptions.RuntimeError("No abort type specified.") target = evt.arg('target', None) d = None if type == 'job': target = self.find_job_id(target) if target is not None: d = self.proxy.callRemote('job_stop'... |
d = self.proxy.callRemote('recipe_stop', target, 'abort', 'Aborted by task.') | d = self.proxy.callRemote('recipe_stop', target, 'abort', "Recipe"+msg) | def proc_evt_abort(self, evt): type = evt.arg('type', '') if not type: log.error("No abort type specified.") raise exceptions.RuntimeError("No abort type specified.") target = evt.arg('target', None) d = None if type == 'job': target = self.find_job_id(target) if target is not None: d = self.proxy.callRemote('job_stop'... |
_VERBOSE = ('remote_backend', 'reconnect', 'remote_call', | _VERBOSE = ('stop_remote', 'remote_backend', 'remote_call', | def __init__(self): self.__remotes = {} ExtBackend.__init__(self) self.def_port = config.get_conf('beah-backend').get('DEFAULT', 'PORT') |
start_backend(rb, host=dest[0], port=dest[1]) | start_backend(rb, host=dest[0], port=dest[1], byef=lambda evt: None) | def remote_backend(self, dest): dest_s = '%s:%s' % dest rb = self.__remotes.get(dest_s, None) if rb is None: rb = _RemoteBackend(self, dest) start_backend(rb, host=dest[0], port=dest[1]) self.__remotes[dest_s] = rb return rb |
def reconnect(self, remote_be): rb = remote_be.clone() dest = rb.dest() dest_s = '%s:%s' % dest del remote_be del self.__remotes[dest_s] start_backend(rb, host=dest[0], port=dest[1]) self.__remotes[dest_s] = rb | def remote_backend(self, dest): dest_s = '%s:%s' % dest rb = self.__remotes.get(dest_s, None) if rb is None: rb = _RemoteBackend(self, dest) start_backend(rb, host=dest[0], port=dest[1]) self.__remotes[dest_s] = rb return rb | |
_VERBOSE = ('send_cmd', 'done', 'more', 'set_controller', 'clone', | _VERBOSE = ('send_cmd', 'done', 'more', 'set_controller', | def __init__(self, caller, dest, queue=None, pending=None): self.__caller = caller self.__dest = dest self.__queue = queue or [] self.__pending = pending or {} self.__status = self._NEW ExtBackend.__init__(self) |
def clone(self): return _RemoteBackend(self.__caller, self.__dest, self.__queue, self.__pending) | def clone(self): return _RemoteBackend(self.__caller, self.__dest, self.__queue, self.__pending) | |
from beah.core import event | def main(): config.backend_conf( defaults={'NAME':'beah_forwarder_backend'}, overrides=config.backend_opts()) log_handler() start_forwarder_backend() reactor.run() | |
GUEST_ATTRS = ('system', 'mac_address', 'location', 'guestargs', 'install_name') | GUEST_ATTRS = ('system', 'mac_address', 'location', 'guestargs', 'guestname') | def parse_recipe_xml(input_xml, hostname): root = minidom.parseString(input_xml) for er in root.getElementsByTagName('recipe'): system = xml_attr(er, 'system') if system == hostname: break else: for er in root.getElementsByTagName('guestrecipe'): system = xml_attr(er, 'system') if system == hostname: break else: log.i... |
if self.link_warn > 1: | if not self.alive: | def check_link(self): if self.link_warn > 1: return False return self._check_link() and self.owner.parent.check_link() |
return self._check_link() and self.owner.parent.check_link() | self.alive = self._check_link() and self.owner.parent.check_link() return self.alive | def check_link(self): if self.link_warn > 1: return False return self._check_link() and self.owner.parent.check_link() |
self.upload_alive = self.size_warn < 2 and self.upload_warn < 2 | self.upload_alive = alive | def __init__(self, owner): """ Class to check amount of data uploaded to server. |
if not self.upload_warn: self.owner.parent_task().send_result('warn', 'upload_limit', size, "%s has reached upload limit!" % self.owner.name()) | if self.upload_warn < 2: self.owner.parent_task().send_result('warn', 'upload_limit', amt, "%s has reached upload limit!" % self.owner.name()) | def check_upload_amount(self, size): sd = self.owner.stored_data amt = sd.get('upload_total', 0) + size sd['upload_total'] = amt limit = self.upload_limits[1] if limit > 0 and amt > limit: if not self.upload_warn: self.owner.parent_task().send_result('warn', 'upload_limit', size, "%s has reached upload limit!" % self.o... |
if limit > 0 and amt > limit and not self.upload_warn: self.owner.parent_task().send_result('warn', 'upload_limit/soft', size, "%s has reached soft upload limit!" % self.owner.name()) | if limit > 0 and amt > limit and self.upload_warn < 1: self.owner.parent_task().send_result('warn', 'upload_limit/soft', amt, "%s has reached soft upload limit!" % self.owner.name()) | def check_upload_amount(self, size): sd = self.owner.stored_data amt = sd.get('upload_total', 0) + size sd['upload_total'] = amt limit = self.upload_limits[1] if limit > 0 and amt > limit: if not self.upload_warn: self.owner.parent_task().send_result('warn', 'upload_limit', size, "%s has reached upload limit!" % self.o... |
if not self.size_warn < 2: | if self.size_warn < 2: | def _check_file_size(self, size_total): limit = self.size_limits[1] if limit > 0 and size_total > limit: if not self.size_warn < 2: self.owner.parent_task().send_result('warn', 'size_limit', size_total, "%s has reached size limit!" % self.owner.name()) self.size_warn = 2 self.owner.stored_data['size_warn'] = 2 return F... |
if defaults is None: defaults = {} conf = ConfigParser(defaults=defaults) | conf = ConfigParserFix(defaults) | def config(conf_env_var='BEAH_CONF', conf_filename='beah.conf', defaults=None, **opts): """ Configure harness for the first time. opts -- parsed options (e.g. from command line and env.variables) returns instance of ConfigParser.ConfigParser. If configuration file was parsed already, it will return existing object. ... |
cfg_defaults.update(conf.items('BACKEND')) | dict_update(cfg_defaults, conf.items('BACKEND')) | def __init__(self): cfg_defaults = dict(conf.items('DEFAULT')) cfg_defaults.update(conf.items('BACKEND')) cfg_defaults['HOSTNAME'] = os.getenv('HOSTNAME') cfg_defaults['LAB_CONTROLLER'] = os.getenv('LAB_CONTROLLER') or \ 'http://%s:8000/server' % os.getenv('COBBLER_SERVER', 'localhost') self.conf = config.config('BEAH_... |
self.on_error(self, "Given offset (%s) does not match calculated (%s)." | self.on_error("Given offset (%s) does not match calculated (%s)." | def proc_evt_file_write(self, evt): fid = evt.arg('file_id') finfo = addict(self.get_file_info(fid)) finfo['codec'] = evt.arg('codec', None) codec = finfo.get('codec', None) offset = evt.arg('offset', None) seqoff = finfo.get('offset', 0) if offset is None: offset = seqoff elif offset != seqoff: self.on_error(self, "Gi... |
pprint.pprint(evt) | self.pprinter.pprint(list(evt.printable())) | def pre_proc(self, evt): pprint.pprint(evt) return False |
def trhostname(hostname): if hostname == os.environ['HOSTNAME']: | self.localhosts = (main.env.get('HOSTNAME', ''), os.environ.get('HOSTNAME', '')) def trhostname(self, hostname): if hostname in self.localhosts: | def __init__(self, main): self.main = main |
trhostname = staticmethod(trhostname) | def trhostname(hostname): if hostname == os.environ['HOSTNAME']: return '' return hostname | |
log.setLevel(str2log_level(os.environ.get('BEAH_TASK_LOG', "warning"))) | ll = self.env.get('BEAH_TASK_LOG', "warning") log.setLevel(str2log_level(ll)) try: from rhts import testinfo ti = testinfo.parse_file(os.path.join(self.env['TESTPATH'], 'testinfo.desc'), raise_errors=False) except: log.error("Error in tasks metadata: %s" % format_exc()) ti = None if ti is not None: for k,v in getattr... | def __init__(self, task_path, env): self.process = None self.listener = None self.task_path = task_path self.__done = False self.__waits_for = [] |
port = self.variables.setdefault('port', os.environ.get('RHTS_PORT', random.randint(7080, 7099))) | port = self.variables.setdefault('port', self.env.get('RHTS_PORT', random.randint(7080, 7099))) | def __init__(self, task_path, env): self.process = None self.listener = None self.task_path = task_path self.__done = False self.__waits_for = [] |
if localhost_(host): | if not localhost_(host): | def start_backend(backend, host=None, port=None, adaptor=ControllerAdaptor_Backend_JSON, byef=None): conf = config.get_conf('beah-backend') host = host or conf.get('DEFAULT', 'INTERFACE') port = port or conf.get('DEFAULT', 'PORT') if os.name == 'posix': socket = conf.get('DEFAULT', 'SOCKET') # 0. check SOCKET_OPT (sock... |
return cls.get_constructor(evt[Event.EVENT])(*evt) | return cls.get_constructor(evt[Event.EVENT])(evt) | def make(cls, evt): return cls.get_constructor(evt[Event.EVENT])(*evt) |
print file_write('FID', 'DATA').__str__() print file_write('FID', 'DATA').__repr__() | s = "Data to be written but not displayed" fw = file_write('FID', s) assert fw.__str__().find(s) == -1 assert fw.__repr__().find(s) == -1 def test_copy(e, copy): assert copy.same_as(e) assert copy.id() == e.id() def test_constructors(e): test_copy(e, Event(e)) test_copy(e, Event(list(e))) test_copy(e, event(list(e))... | def test(expected, evt, origin={}, timestamp=None, cls=Event, **kwargs): try: answ = Event(evt, origin=origin, timestamp=timestamp, **kwargs) if not isinstance(answ, cls): print >> sys.stderr, \ "--- ERROR: Event(%r, %r) is a %s != %s" % (evt, kwargs, answ.__class__.__name__, cls.__name__) answ = list(answ) if answ != ... |
if type not in ('recipe', 'recipeset', 'job'): | if type not in ('task', 'recipe', 'recipeset', 'job'): | def abort(type, target=None, message=None, origin={}, timestamp=None): """ Abort given {recipe,recipeset,job}. Abort currently running recipe, recipeset or job, if no target is specified. """ if type not in ('recipe', 'recipeset', 'job'): raise exceptions.NotImplementedError('type must be recipe, recipeset or job. %r ... |
self.on_error("Can not open a writer(%r, %r)", id, name) | self.on_error("Can not open a writer(%r, %r)" % (id, name)) | def close_writers(self, id): wrargs = self.__writer_args.get(id, None) if wrargs is not None: writers = self.__writers.get(id, {}) for name in list(wrargs.keys()): args = wrargs[name] writer = self.get_writer(id, name, args[0], args[1]) if not writer: self.on_error("Can not open a writer(%r, %r)", id, name) else: write... |
writer = BeakerWriter(journal, offs, filename=name, id=id, | writer = BeakerWriter(journal, offs, id=id, filename=os.path.basename(name), path=os.path.dirname(name), | def get_writer(self, id, name, args=(), kwargs={}): writer = self.__writers.setdefault(id, {}).get(name, None) if writer is None: offss = self.__offsets.get(id, None) if offss is None: offss = self.__offsets[id] = runtimes.TypeDict(self.runtime, 'offsets/%s' % id) offs = offss.get(name, 0) wrargs = self.__writer_args.g... |
self.get_writer(id, '.task_beah_raw').write(jsonln(evt)) | self.get_writer(id, 'debug/.task_beah_raw').write(jsonln(evt)) | def pre_proc(self, evt): id = evt.task_id = self.get_evt_task_id(evt) if id is None: return True if evt.event() == 'file_write': evt = event.Event(evt) evt.args()['data'] = '...hidden...' self.get_writer(id, '.task_beah_raw').write(jsonln(evt)) return False |
self.get_writer(evt.task_id, 'task_output_%s' % evt.arg('out_handle')) \ | self.get_writer(evt.task_id, 'debug/task_output_%s' % evt.arg('out_handle')) \ | def proc_evt_output(self, evt): self.get_writer(evt.task_id, 'task_output_%s' % evt.arg('out_handle')) \ .write(str(evt.arg('data'))) |
f = self.get_writer(evt.task_id, 'task_beah_unexpected') | f = self.get_writer(evt.task_id, 'debug/task_beah_unexpected') | def proc_evt_lose_item(self, evt): f = self.get_writer(evt.task_id, 'task_beah_unexpected') f.write(str(evt.arg('data')) + "\n") |
self.get_writer(evt.task_id, 'task_log').write(message) | self.get_writer(evt.task_id, 'debug/task_log').write(message) | def proc_evt_log(self, evt): message = evt.arg('message', '') reason = evt.arg('reason', '') join = '' if reason: reason = 'reason=%s' % reason if message: message = "%s; %s" % (message, reason) else: message = reason message = "LOG:%s(%s): %s\n" % (evt.arg('log_handle', ''), self.log_type(evt.arg('log_level')), messag... |
self.get_writer(evt.task_id, 'task_log').write(log_msg) | self.get_writer(evt.task_id, 'debug/task_log').write(log_msg) | def proc_evt_result(self, evt): try: type = self.result_type(evt.arg("rc", None)) handle = evt.arg("handle", "%s/%s" % \ (self.task_data['task_env']['TASKNAME'], evt.id())) score = evt.arg("statistics", {}).get("score", 0) message = evt.arg('message', '') or self.mk_msg(event=evt) log_msg = "%s:%s: %s score=%s\n" % (ty... |
task_env['LAB_CONTROLLER'] = config.get_conf('beah-backend').get('DEFAULT', 'LAB_CONTROLLER') | task_env['LAB_CONTROLLER'] = config.get_conf('beah-backend').get('DEFAULT', 'COBBLER_SERVER') | def parse_recipe_xml(input_xml, hostname): root = minidom.parseString(input_xml) for er in root.getElementsByTagName('recipe'): system = xml_attr(er, 'system') if system == hostname: break else: log.info("parse_recipe_xml: No recipe for %s." % hostname) return None task_env = {} rs = xml_attr(er, 'status') if rs not ... |
lc = os.getenv('COBBLER_SERVER', '') if lc: lc = 'http://%s:8000/server' % lc | if cs: lc = 'http://%s:8000/server' % cs | def defaults(): d = config.backend_defaults() lc = os.getenv('LAB_CONTROLLER', '') if not lc: lc = os.getenv('COBBLER_SERVER', '') if lc: lc = 'http://%s:8000/server' % lc else: lc = 'http://localhost:5222/' d.update({ 'NAME':'beah_beaker_backend', 'LAB_CONTROLLER':lc, 'HOSTNAME':os.getenv('HOSTNAME') }) return d |
run_cmd, _ = self.__tasks_by_id.get(id, (None, None)) | run_cmd, _ = self.__tasks_by_id.get(task_id, (None, None)) | def handle_new_task(self, result): |
digest = digests.make_digest(evt.arg('digest', None)) if digest is None or digest[0] != digest_method: d = digests.DigestConstructor(digest_method) d.update(cdata) digest = (digest_method, d.hexdigest()) | dm, digest = digests.make_digest(evt.arg('digest', None)) or (None, None) if dm != digest_method: digest = digests.DigestConstructor(digest_method)(cdata).hexdigest() | def proc_evt_file_write(self, evt): fid = evt.arg('file_id') finfo = self.get_file_info(fid) if finfo is None: self.on_error("File with given id (%s) does not exist." % fid) return # NOTE: be careful here. finfo is not ordinary dict! It never rewrites # existing items with None's. finfo['codec'] = evt.arg('codec', None... |
str(size), digest[1], str(offset), data) | str(size), digest, str(offset), data) | def proc_evt_file_write(self, evt): fid = evt.arg('file_id') finfo = self.get_file_info(fid) if finfo is None: self.on_error("File with given id (%s) does not exist." % fid) return # NOTE: be careful here. finfo is not ordinary dict! It never rewrites # existing items with None's. finfo['codec'] = evt.arg('codec', None... |
url = self.conf.get('DEFAULT', 'LAB_CONTROLLER') self.proxy = repeatingproxy.RepeatingProxy(url, allowNone=True) try: rpc_timeout = float(self.conf.get('DEFAULT', 'RPC_TIMEOUT')) self.proxy.set_timeout(repeatingproxy.IncreasingTimeout(rpc_timeout, max=300)) except: self.proxy.set_timeout(None) self.proxy.serializing = ... | def runtime_sync(type=None): """ Synchronize the runtime to disk. Original sync method will be called only when called explicitly i.e. with type == None. """ if type is None: runtime_sync_orig() | |
if evev == 'extend_watchdog': tio = evt.arg('timeout') id = evt.task.beaker_id log.info('Extending Watchdog for task %s by %s..', id, tio) self.proxy.callRemote('extend_watchdog', id, tio) elif evev == 'end': id = evt.task.beaker_id log.info('Task %s done. Submitting logs...', id) self.proxy.callRemote('extend_wat... | self.async_proc(evt, flags) | def proc_evt(self, evt, **flags): evev = evt.event() if evev == 'echo': cid = evt.arg('cmd_id', None) cb = self.__command_callbacks.get(cid, None) if cb: del self.__command_callbacks[cid] if evt.arg('rc') == ECHO.OK: cb.callback(evt.args) else: cb.errback(evt.args) elif evev == 'flush': self.flush() return # store the ... |
yum -y --disablerepo=* --enablerepo=beaker-* install "$TESTRPMNAME" if ! rpm -q "$TESTRPMNAME"; then echo "ERROR: $TESTRPMNAME was not installed." >&2 exit 1 | if rpm -q "$TESTRPMNAME"; then beahsh INFO -H wrapper "$TESTRPMNAME is already installed." else beahsh INFO -H wrapper "Installing the task $TESTRPMNAME" beahsh extend_watchdog 20m yum -y --disablerepo=* --enablerepo=beaker-* install "$TESTRPMNAME" for iteration in $(seq 6); do if ! rpm -q "$TESTRPMNAME"; then beahsh... | def content(self): self.write_line(""" |
if sys.prefix not in ['', '/']: | if sys.prefix not in ['', '/', '/usr']: | def _get_conf_file(conf_env_var, fname, opt=None): """Find a configuration file or raise an exception.""" conf_list = [] conf_list.append(opt) conf_list.append(os.environ.get(conf_env_var)) # used in devel.environment only: if os.environ.has_key('BEAH_ROOT'): conf_list.append(os.environ.get('BEAH_ROOT')+'/'+fname) conf... |
'set_file_info', 'get_result_id', 'handle_Result'] | 'set_file_info', 'get_result_id', 'handle_Result', 'set_task_info', 'get_task_info'] | def open_(name, mode): pre_open(name) return open(name, mode) |
self.proxy.callRemote(self.TASK_START, evt.task_id, 0) | if not self.task_has_started(): self.task_set_started() self.proxy.callRemote(self.TASK_START, evt.task_id, 0) | def proc_evt_start(self, evt): self.proxy.callRemote(self.TASK_START, evt.task_id, 0) # FIXME: start local watchdog |
if result.beaker_id == self.PENDING_RESULT: | if result.beaker_id == cls.PENDING_RESULT: | def read_object(cls, id, parent, args={}): result = cls(id, parent) if result.beaker_id == self.PENDING_RESULT: raise KeyError("The result '%s' did not get through." % id) |
cat >/etc/yum.repos.d/beaker-tests.repo <<REPO_END | cat >/tmp/etc/yum.repos.d/beaker-tests.repo <<REPO_END | def content(self): self.write_line(""" |
reactor.stop() | self.done() | def do_beah_cmd(self): #self.dbg("do_beah_cmd called") |
reactor.stop() | self.done() | def proc_evt_echo(self, evt): if evt.arg('cmd_id', '') == self.__cmd.id(): if evt.args()['rc'] == ECHO.OK: self.do_beah_cmd() return if evt.args()['rc'] == ECHO.NOT_IMPLEMENTED: print "--- ERROR: Command is not implemented." reactor.stop() return if evt.args()['rc'] == ECHO.EXCEPTION: print "--- ERROR: Command raised a... |
def beah_run(coro): | def beah_run(coro, **kwargs): | def beah_run(coro): """ This is a Backend to issue script to Controller. Type help on the prompt for help o commands. You might not see any output here - run out_backend. Known issues: * Type <Ctrl-C> to finish. I do not want to stop reactor directly, but would like if it stopped when there are no more protocols. ... |
start_backend(backend) | start_backend(backend, **kwargs) | def beah_run(coro): """ This is a Backend to issue script to Controller. Type help on the prompt for help o commands. You might not see any output here - run out_backend. Known issues: * Type <Ctrl-C> to finish. I do not want to stop reactor directly, but would like if it stopped when there are no more protocols. ... |
self.proxy.callRemote(self.TASK_RESULT, id, RC.FAIL, | self.proxy.callRemote(self.TASK_RESULT, id, "fail", | def proc_evt_echo(self, evt): cmd = self.get_command(evt.arg('cmd_id')) if (cmd is not None and cmd.command()=='run'): rc = evt.arg('rc') if rc not in (ECHO.OK, ECHO.DUPLICATE): id = evt.task_id # FIXME: Start was not issued. Is it OK? self.task_set_finished(id) message = ("Harness could not run the task: %s rc=%s" % (... |
rc = int(evt.arg("rc", -1)) if rc != 0: | rc = evt.arg("rc", None) if rc is None: score = 999 else: score = int(rc) if score != 0: | def proc_evt_end(self, evt): id = evt.task_id self.close_writers(id) self.task_set_finished(id) rc = int(evt.arg("rc", -1)) if rc != 0: message = "Task exited with non zero exit code. rc=%s" % rc self.proxy.callRemote(self.TASK_RESULT, id, RC.FAIL, "task/exit", rc, message) else: message = "OK" self.proxy.callRemote(se... |
self.proxy.callRemote(self.TASK_RESULT, id, RC.FAIL, "task/exit", rc, message) | self.proxy.callRemote(self.TASK_RESULT, id, "fail", "task/exit", score, message) | def proc_evt_end(self, evt): id = evt.task_id self.close_writers(id) self.task_set_finished(id) rc = int(evt.arg("rc", -1)) if rc != 0: message = "Task exited with non zero exit code. rc=%s" % rc self.proxy.callRemote(self.TASK_RESULT, id, RC.FAIL, "task/exit", rc, message) else: message = "OK" self.proxy.callRemote(se... |
log.on_error("Can not parse following line from journal: %r", ln) | self.on_exception("Can not parse a line from journal.", line=ln) | def __init__(self): self.conf = config.get_conf('beah-backend') self.hostname = self.conf.get('DEFAULT', 'HOSTNAME') self.waiting_for_lc = False self.runtime = runtimes.ShelveRuntime(self.conf.get('DEFAULT', 'RUNTIME_FILE_NAME')) self.__commands = {} self.__results_by_uuid = runtimes.TypeDict(self.runtime, 'results_by_... |
self.on_exception("parse_recipe_xml Failed: %s", format_exc()) | self.on_exception("parse_recipe_xml Failed.") | def handle_new_task(self, result): |
def on_warning(self, msg, *args, **kwargs): self.__on_error("WARNING", msg, traceback.format_stack(), *args, **kwargs) | def on_warning(self, msg, *args, **kwargs): self.__on_error("WARNING", msg, traceback.format_stack(), *args, **kwargs) | |
self.on_warning("Given offset (%s) does not match calculated (%s)." % (offset, seqoff)) | log.warning("Given offset (%s) does not match calculated (%s).", offset, seqoff) | def proc_evt_file_write(self, evt): fid = evt.arg('file_id') finfo = self.get_file_info(fid) if finfo is None: self.on_error("File with given id (%s) does not exist." % fid) return # NOTE: be careful here. finfo is not ordinary dict! It never rewrites # existing items with None's. finfo['codec'] = evt.arg('codec', None... |
self.proxy.callRemote('extend_watchdog', evt.task_id, timeout) | self.proxy.callRemote('extend_watchdog', id, timeout) | def proc_evt_extend_watchdog(self, evt): timeout = evt.arg('timeout') self.proxy.callRemote('extend_watchdog', evt.task_id, timeout) |
for state in states: if state in value: log.debug("state %r found in value %r", state, value) answ.append(state) break | if value is not None: for state in states: if state in value: log.debug("state %r found in value %r", state, value) answ.append(state) break else: answ = None | def handle_variable_value(self, cmd): log.debug("handling variable_value.") log.debug("...waiting for: %r", self.__waits_for) err = cmd.arg('error') if err: log.debug("variable_value error: %s", err) return cmd_name = cmd.arg('key') cmd_handle = cmd.arg('handle') cmd_dest = cmd.arg('dest') cmd_value = cmd.arg('value') ... |
'beah-data-root = beah.tools:mina_data_root', | 'beah-data-root = beah.tools:main_data_root', | def glob_to(prefix, new_prefix, dirs): if prefix and prefix[-1]!='/': prefix += '/' return list([(new_prefix+'/'+dir, glob_(prefix, dir+'/*')) for dir in dirs]) |
if rc not in (ECHO.OK, ECHO.DUPLICATE): id = evt.task_id | id = evt.task_id if rc not in (ECHO.OK, ECHO.DUPLICATE) and not self.task_has_finished(id): | def proc_evt_echo(self, evt): cmd = self.get_command(evt.arg('cmd_id')) if (cmd is not None and cmd.command()=='run'): rc = evt.arg('rc') if rc not in (ECHO.OK, ECHO.DUPLICATE): id = evt.task_id self.task_set_finished(id) message = ("Harness could not run the task: %s rc=%s" % (evt.arg('message', 'no info'), rc)) self.... |
d = self.proxy.callRemote('task_stop', target, 'abort', "Task"+msg) if target == evt.task_id: | if target == id and not self.task_has_finished(id): d = self.proxy.callRemote('task_stop', target, 'abort', "Task"+msg) self.close_writers(id) self.task_set_finished(id) | def proc_evt_abort(self, evt): type = evt.arg('type', '') if not type: log.error("No abort type specified.") raise exceptions.RuntimeError("No abort type specified.") self.flush_writers(id) target = evt.arg('target', None) d = None msg = evt.arg('msg', '') if msg: msg = " aborted by task %s: %s" % (evt.task_id, msg) el... |
env=self.env, path=self.env.get('TESTPATH', '/tmp')) | env=self.env, path=self.env.get('TESTPATH', '/tmp'), usePTY=True) | def server_started(self): # FIXME: Install rhts-test-runner.sh somewhere! self.process = reactor.callLater(2, reactor.spawnProcess, self.task, self.TEST_RUNNER, args=[self.TEST_RUNNER], env=self.env, path=self.env.get('TESTPATH', '/tmp')) |
self._queue_evt_int(evt, flags, len(ln)) | self._queue_evt_int(evt, flags, evt_len) evt_len = 0 | def runtime_sync(type=None): """ Synchronize the runtime to disk. Original sync method will be called only when called explicitly i.e. with type == None. """ if type is None: runtime_sync_orig() |
if not re.search(r'(\.jar$|\.java$|\.doc(x)?$)', extension): raise forms.ValidationError("Must be a Jar, Java, or Doc") | if not re.search(r'(\.jar$|\.java$|)', extension.lower()): raise forms.ValidationError("Must be a Jar or a Java file") | def clean_test_file(self): import os.path, re tf = self.cleaned_data['test_file'] name, extension = os.path.splitext(tf.name) if not re.search(r'(\.jar$|\.java$|\.doc(x)?$)', extension): raise forms.ValidationError("Must be a Jar, Java, or Doc") return tf |
@models.permalink | def __unicode__(self): return "{0} {1} {2}".format(self.course_num, self.term, self.year) | |
return ('view_course', (), { 'year': self.year, 'term':self.term, 'course_id':self.course_num,}) | return "/{0}/{1}/{2}".format(self.year, self.term, self.course_num) | def get_absolute_url(self): return ('view_course', (), { 'year': self.year, 'term':self.term, 'course_id':self.course_num,}) |
@models.permalink | def __unicode__(self): #return "{0}: {1}".format(self.course.__unicode__(), self.name) return self.name | |
return ('view_assignment', (), { 'year': self.course.year, 'term':self.course.term, 'course_id':self.course.course_num, 'assn_name':self.name}) | return "/{0}/{1}/{2}/{3}".format(self.course.year, self.course.term, self.course.course_num, self.name) | def get_absolute_url(self): return ('view_assignment', (), { 'year': self.course.year, 'term':self.course.term, 'course_id':self.course.course_num, 'assn_name':self.name}) |
@models.permalink | def __unicode__(self): return "{0} {1}: {2} #{3}".format(self.last_name, self.first_name, self.assignment.__unicode__(), self.submission_number) | |
return ('collector.views.view_submission', [], { 'year': self.assignment.course.year, 'term':self.assignment.course.term, 'course_id':self.assignment.course.course_num, 'assn_name':self.assignment.name, 'sub_id':self.id}) | return "/{0}/{1}/{2}/{3}/submissions/{4}".format(self.assignment.course.year, self.assignment.course.term, self.assignment.course.course_num, self.assignment.name, self.id) | def get_absolute_url(self): return ('collector.views.view_submission', [], { 'year': self.assignment.course.year, 'term':self.assignment.course.term, 'course_id':self.assignment.course.course_num, 'assn_name':self.assignment.name, 'sub_id':self.id}) |
grader_output = sub.grade_log.read() | if sub.grade_log: grader_output = sub.grade_log.read() else: grader_output = "No grade log." | def view_submission(request, year, term, course_id, assn_name, sub_id): c = get_object_or_404(Course, year=year, term=term.lower(), course_num=course_id) assn = get_object_or_404(Assignment, course=c.pk, name=assn_name) sub = get_object_or_404(Submission, id=sub_id) grader_output = sub.grade_log.read() return render_... |
if v and i != 'txt' and i != 'close': | if i != 'txt' and i != 'open': | def tag(**kw): "Core function to generate tags" selfClose = ['input', 'img', 'link'] onlyOne = ['html', 'body', 'head'] noNewLine = ['td', 'th', 'input'] _name = kw.get('tagname', None) if not _name: _name = _getframe(1).f_code.co_name #if _name in onlyOne and nOpen.get(_name,0) : print 'WARNING: tag %s already open an... |
br = '<br />' | def html(**kw): return tag(**kw) | |
raise NetworkAddressError("The name '%s' could not be resolved." % name) except TypeError: raise ArgumentError("gethostbyname() takes a string as argument.") | raise NetworkAddressError("The hostname '"+name+"' could not be resolved.") | def gethostbyname(name): """ <Purpose> Provides information about a hostname. Calls socket.gethostbyname(). Translate a host name to IPv4 address format. The IPv4 address is returned as a string, such as '100.50.200.5'. If the host name is an IPv4 address itself it is returned unchanged. <Arguments> name: The host nam... |
message, addr = socket.recvfrom(4096) | message, addr = socket.recvfrom(65535) | def getmessage(self): """ <Purpose> Obtains an incoming message that was sent to an IP and port. |
if type(destip) is not str or type(destport) is not int or type(message) \ is not str: raise RepyArgumentError("Invalid type of one or more arguments " + \ "to sendmessage().") if not _is_valid_network_port(destport): raise RepyArgumentError("Destination port number must be an " + \ "integer, between 1 and 65535.") ... | def sendmessage(destip, destport, message, localip, localport): """ <Purpose> Send a message to a host / port <Arguments> destip: The host to send a message to destport: The port to send the message to message: The message to send localhost: The local IP to send the message from localport: The local port to send the m... | |
raise RepyArgumentError("Provided localport must be a int!") | raise RepyArgumentError("Provided localport must be an int!") if type(message) is not str: raise RepyArgumentError("Provided message must be a string!") | def _bind_udp_socket(localip, localport, tattle_item): # Conrad: entirely stolen from listenforconnection(). Some of this input # verification stuff especially could probably be combined as a shared # function. Even the rest of the functions are similar enough to be worth # consolidating. # Check the input arguments (... |
raise ResourceForbiddenError("Provided localip is not allowed! IP: '"+localip+"'") | raise ResourceForbiddenError("Provided localip is not allowed! IP: "+localip) | def _bind_udp_socket(localip, localport, tattle_item): # Conrad: entirely stolen from listenforconnection(). Some of this input # verification stuff especially could probably be combined as a shared # function. Even the rest of the functions are similar enough to be worth # consolidating. # Check the input arguments (... |
normal_identity = ("UDP", localip, localport, False, None) | identity = ("UDP", localip, localport, destip, destport) | def _bind_udp_socket(localip, localport, tattle_item): # Conrad: entirely stolen from listenforconnection(). Some of this input # verification stuff especially could probably be combined as a shared # function. Even the rest of the functions are similar enough to be worth # consolidating. # Check the input arguments (... |
if normal_identity in OPEN_SOCKET_INFO or listen_identity in OPEN_SOCKET_INFO: | if identity in OPEN_SOCKET_INFO or listen_identity in OPEN_SOCKET_INFO: | def _bind_udp_socket(localip, localport, tattle_item): # Conrad: entirely stolen from listenforconnection(). Some of this input # verification stuff especially could probably be combined as a shared # function. Even the rest of the functions are similar enough to be worth # consolidating. # Check the input arguments (... |
is_listensock = tattle_item == "insockets" if is_listensock: identity = listen_identity else: identity = normal_identity | def _bind_udp_socket(localip, localport, tattle_item): # Conrad: entirely stolen from listenforconnection(). Some of this input # verification stuff especially could probably be combined as a shared # function. Even the rest of the functions are similar enough to be worth # consolidating. # Check the input arguments (... | |
if normal_identity in PENDING_SOCKETS or listen_identity in PENDING_SOCKETS: | if identity in PENDING_SOCKETS: raise AlreadyListeningError("Concurrent sendmessage with the localip and localport in progress!") elif listen_identity in PENDING_SOCKETS: | def _bind_udp_socket(localip, localport, tattle_item): # Conrad: entirely stolen from listenforconnection(). Some of this input # verification stuff especially could probably be combined as a shared # function. Even the rest of the functions are similar enough to be worth # consolidating. # Check the input arguments (... |
nanny.tattle_add_item(tattle_item, identity) | nanny.tattle_add_item("outsockets", identity) | def _bind_udp_socket(localip, localport, tattle_item): # Conrad: entirely stolen from listenforconnection(). Some of this input # verification stuff especially could probably be combined as a shared # function. Even the rest of the functions are similar enough to be worth # consolidating. # Check the input arguments (... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.