rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
dst_filename = change_prefix(filename, src_prefix, dst_prefix) | dst_filename = change_prefix(filename, dst_prefix) | def copy_required_modules(src_prefix, dst_prefix): for modname in REQUIRED_MODULES: if modname in sys.builtin_module_names: logger.notify("Ignoring built-in bootstrap module: %s" % mod) continue try: mod = __import__(modname) except ImportError: logger.notify("Cannot import bootstrap module: %s" % modname) else: filena... |
copy_required_modules(prefix, home_dir) | copy_required_modules(home_dir) | def install_python(home_dir, lib_dir, inc_dir, bin_dir, site_packages, clear): """Install just the base environment, no distutils patches etc""" if sys.executable.startswith(bin_dir): print 'Please use the *system* python to run this script' return if clear: rmtree(lib_dir) ## FIXME: why not delete it? ## Maybe it sho... |
site_filename_dst = change_prefix(site_filename, prefix, home_dir) | site_filename_dst = change_prefix(site_filename, home_dir) | def install_python(home_dir, lib_dir, inc_dir, bin_dir, site_packages, clear): """Install just the base environment, no distutils patches etc""" if sys.executable.startswith(bin_dir): print 'Please use the *system* python to run this script' return if clear: rmtree(lib_dir) ## FIXME: why not delete it? ## Maybe it sho... |
if sys.platform == 'win32': name = '%PYTHONHOME%' else: name = '$PYTHONHOME' logger.warn('%s is set; this can cause problems creating environments' % name) | del os.environ['PYTHONHOME'] | def main(): parser = optparse.OptionParser( version=virtualenv_version, usage="%prog [OPTIONS] DEST_DIR") parser.add_option( '-v', '--verbose', action='count', dest='verbose', default=0, help="Increase verbosity") parser.add_option( '-q', '--quiet', action='count', dest='quiet', default=0, help='Decrease verbosity') ... |
shutil.copy( os.path.join( prefix, 'Resources/Python.app/Contents/MacOS/%s' % os.path.basename(sys.executable)), py_executable) | original_python = os.path.join( prefix, 'Resources/Python.app/Contents/MacOS/Python') shutil.copy(original_python, py_executable) | def install_python(home_dir, lib_dir, inc_dir, bin_dir, site_packages, clear): """Install just the base environment, no distutils patches etc""" if sys.executable.startswith(bin_dir): print 'Please use the *system* python to run this script' return if clear: rmtree(lib_dir) ## FIXME: why not delete it? ## Maybe it sho... |
return encoder.encode({'success': 'true', 'message': ''}) | return encoder.encode({'success': 'true', 'message': '', 'file': name}) | def __call__(self): request = self.request container = self.context.context image = request.form.get('image', '') |
{'success': 'true', 'message': '', 'file': image.filename}) | {'success': 'true', 'message': '', 'file': name}) | def __call__(self): request = self.request container = self.context.context image = request.form.get('image', '') |
return encoder.encode({'success': 'true', 'message': ''}) | return encoder.encode({'success': 'true', 'message': '', 'file': name}) | def __call__(self): request = self.request container = self.context.context media = request.form.get('image', '') description = request.form.get('description', '') if not media: return encoder.encode({'success': 'false', 'message': ''}) |
{'success': 'true', 'message': '', 'file': media.filename}) | {'success': 'true', 'message': '', 'file': name}) | def __call__(self): request = self.request container = self.context.context media = request.form.get('image', '') description = request.form.get('description', '') if not media: return encoder.encode({'success': 'false', 'message': ''}) |
daemon_pid_file=pid_file | daemon_pid_file=pid_file, | def main(): parser = OptionParser() parser.add_option("-c", "--config", help="Full path to config file to use") parser.add_option("-f", "--foreground", default=False, action="store_true", help="run in foreground (do not spawn a daemon)") parser.add_option("-p", "--pid-file", help="specify a pid file") (opts, args) = pa... |
<autopick random="False"/> | <autopick random="false"/> | def test_recipe_elements_in_different_order(self): self.assert_valid(''' <job> <recipeSet retention_tag="scratch"> <recipe kernel_options="" kernel_options_post="" ks_meta="" role="None" whiteboard=""> <partitions/> <task name="/distribution/install" role="STANDALONE"/> <repos/> <ks_appends/> <hostRequires> <system_typ... |
<autopick random="True"/> <autopick random="False"/> | <autopick random="true"/> <autopick random="false"/> | def test_duplicate_elements(self): self.assert_not_valid(''' <job> <recipeSet retention_tag="scratch"> <recipe kernel_options="" kernel_options_post="" ks_meta="" role="None" whiteboard=""> <autopick random="True"/> <autopick random="False"/> <watchdog panic="None"/> <watchdog panic="always"/> <packages/> <packages/> <... |
['Extra element watchdog in interleave', | ['Extra element autopick in interleave', | def test_duplicate_elements(self): self.assert_not_valid(''' <job> <recipeSet retention_tag="scratch"> <recipe kernel_options="" kernel_options_post="" ks_meta="" role="None" whiteboard=""> <autopick random="True"/> <autopick random="False"/> <watchdog panic="None"/> <watchdog panic="always"/> <packages/> <packages/> <... |
watchdog.logger.debug(80 * '-') | def main_loop(conf=None, foreground=False): """infinite daemon loop""" # define custom signal handlers signal.signal(signal.SIGTERM, daemon_shutdown) config = kobo.conf.PyConfigParser() # load default config default_config = os.path.abspath(os.path.join(os.path.dirname(__file__), "default.conf")) config.load_from_fi... | |
def test_can_sort_by_id(self): self.check_column_sort(1) | def test_can_sort_by_id(self): self.check_column_sort(1) | |
if TaskExclude(task=task,osmajor=osmajor.by_name(family.lstrip('-'))) not in task.excluded: task.excluded.append(TaskExclude(osmajor=osmajor.by_name(family.lstrip('-')))) | if family.lstrip('-') not in task.excluded_osmajor: task.excluded_osmajor.append(TaskExcludeOSMajor(osmajor=OSMajor.by_name_alias(family.lstrip('-')))) | def process_taskinfo(self, raw_taskinfo): tinfo = testinfo.parse_string(raw_taskinfo['desc']) |
task.excluded.append(TaskExclude(arch=Arch.by_name(arch))) | if arch not in task.excluded_arch: task.excluded_arch.append(TaskExcludeArch(arch=Arch.by_name(arch))) | def process_taskinfo(self, raw_taskinfo): tinfo = testinfo.parse_string(raw_taskinfo['desc']) |
search = su.System.search.search_on(table_field | search = su.System.search.search_on(table_field) | def get_search_options(self,table_field,**kw): return_dict = {} search = su.System.search.search_on(table_field #Determine what field type we are dealing with. If it is Boolean, convert our values to 0 for False # and 1 for True col_type = su.System.search.field_type(table_field) if col_type.lower() == 'boolean': se... |
def arch_stat_getter(cls,x): s = 'Pass:%s Fail:%s Warn:%s' % (x.Pass,x.Fail,x.Warn) return s def _job_grid_fields(self,**kw): fields = [DataGrid.Column(name='task', getter=lambda x: x.task_name, title='Task'), DataGrid.Column(name='i386', getter=lambda x: JobMatrix.arch_stat_getter(x), title='i386') ] | def arch_stat_getter(cls,this_arch): def f(x): try: if x.arch == this_arch: return 'Pass:%s Fail:%s Warn:%s' % (x.Pass,x.Fail,x.Warn) except Exception,(e): return 'opps exception %s' % e return f @classmethod def _job_grid_fields(self,arches_used,**kw): fields = [] fields.append(DataGrid.Column(name='task', getter=l... | def arch_stat_getter(cls,x): s = 'Pass:%s Fail:%s Warn:%s' % (x.Pass,x.Fail,x.Warn) return s |
grid = DataGrid(fields = self._job_grid_fields()) | arches_used = {} for grid in grid_data: arches_used[grid.arch] = 1 grid = DataGrid(fields = self._job_grid_fields(arches_used.keys())) | def generate(self,**kw): grid_data = self.generate_data(**kw) grid = DataGrid(fields = self._job_grid_fields()) return {'grid' : grid, 'data' : grid_data } |
recipe_table_alias.c.whiteboard.label('recipe_whiteboard'), arch_alias.c.arch.label('arch_arch'), | recipe_table_alias.c.whiteboard, arch_alias.c.arch, | def generate_data(self,**kw): jobs = [] whiteboard_data = {} if 'job_ids' in kw: jobs = kw['job_ids'].split() elif 'whiteboard' in kw: job_query = model.Job.query().filter(model.Job.whiteboard == kw['whiteboard']) for job in job_query: jobs.append(job.id) else: pass #raise AssertionError('Incorrect or no filter passed ... |
and_(model.recipe_set_table.c.job_id.in_(jobs), model.task_result_table.c.id == recipe_table_alias.c.result_id, recipe_table_alias.c.id == model.recipe_task_table.c.recipe_id, recipe_table_alias.c.distro_id == model.distro_table.c.id), from_obj=[model.task_result_table, model.distro_table.join(arch_alias), model.re... | and_( model.recipe_set_table.c.job_id.in_(jobs), arch_alias.c.arch == bindparam('arch'), recipe_table_alias.c.whiteboard == bindparam('recipe_whiteboard')), from_obj = [model.recipe_set_table.join(recipe_table_alias). join(model.task_result_table,model.task_result_table.c.id == recipe_table_alias.c.result_id). join(mo... | def generate_data(self,**kw): jobs = [] whiteboard_data = {} if 'job_ids' in kw: jobs = kw['job_ids'].split() elif 'whiteboard' in kw: job_query = model.Job.query().filter(model.Job.whiteboard == kw['whiteboard']) for job in job_query: jobs.append(job.id) else: pass #raise AssertionError('Incorrect or no filter passed ... |
class OuterDynamo(object): pass result_data = [] my_hash = {} | def generate_data(self,**kw): jobs = [] whiteboard_data = {} if 'job_ids' in kw: jobs = kw['job_ids'].split() elif 'whiteboard' in kw: job_query = model.Job.query().filter(model.Job.whiteboard == kw['whiteboard']) for job in job_query: jobs.append(job.id) else: pass #raise AssertionError('Incorrect or no filter passed ... | |
s1 = select([func.count(s2.c.result), func.sum(s2.c.rc0).label('New'), func.sum(s2.c.rc1).label('Pass'), func.sum(s2.c.rc2).label('Warn'), func.sum(s2.c.rc3).label('Fail'), func.sum(s2.c.rc4).label('Panic'), model.task_table.c.name.label('task_name'), s2.c.arch_arch, s2.c.recipe_whiteboard, s2.c.task_id.label('task_id_... | def generate_data(self,**kw): jobs = [] whiteboard_data = {} if 'job_ids' in kw: jobs = kw['job_ids'].split() elif 'whiteboard' in kw: job_query = model.Job.query().filter(model.Job.whiteboard == kw['whiteboard']) for job in job_query: jobs.append(job.id) else: pass #raise AssertionError('Incorrect or no filter passed ... | |
outer_recipe = recipe_table.alias() | def suspicious_abort(self): if self.type != SystemType.by_name(u'Machine'): return # Since its last status change, has this system had an # uninterrupted run of aborted recipes leading up to this one, with # at least two different STABLE distros? outer_recipe = recipe_table.alias() status_change_subquery = select([func... | |
system_activity_table.c.system_id == outer_recipe.c.system_id, | system_activity_table.c.system_id == self.id, | def suspicious_abort(self): if self.type != SystemType.by_name(u'Machine'): return # Since its last status change, has this system had an # uninterrupted run of aborted recipes leading up to this one, with # at least two different STABLE distros? outer_recipe = recipe_table.alias() status_change_subquery = select([func... |
recipe_table.c.system_id == outer_recipe.c.system_id)) query = select([func.count(outer_recipe.c.distro_id.distinct())], from_obj=outer_recipe.join(distro_table).join(distro_tag_map))\ | recipe_table.c.system_id == self.id)) query = select([func.count(recipe_table.c.distro_id.distinct())], from_obj=recipe_table.join(distro_table).join(distro_tag_map) .join(system_table, onclause=recipe_table.c.system_id == system_table.c.id))\ | def suspicious_abort(self): if self.type != SystemType.by_name(u'Machine'): return # Since its last status change, has this system had an # uninterrupted run of aborted recipes leading up to this one, with # at least two different STABLE distros? outer_recipe = recipe_table.alias() status_change_subquery = select([func... |
outer_recipe.c.start_time > status_change_subquery, outer_recipe.c.finish_time > nonaborted_recipe_subquery)) | recipe_table.c.start_time > status_change_subquery, recipe_table.c.finish_time > nonaborted_recipe_subquery)) | def suspicious_abort(self): if self.type != SystemType.by_name(u'Machine'): return # Since its last status change, has this system had an # uninterrupted run of aborted recipes leading up to this one, with # at least two different STABLE distros? outer_recipe = recipe_table.alias() status_change_subquery = select([func... |
return self.recipes(recipes=session.query(MachineRecipe),*args,**kw) | return self.recipes(recipes=session.query(MachineRecipe) .join('status').join('result').join('system') .join('distro').join(['distro', 'arch']), *args, **kw) | def index(self,*args,**kw): return self.recipes(recipes=session.query(MachineRecipe),*args,**kw) |
return self.recipes(recipes=MachineRecipe.mine(identity.current.user),action='./mine',*args,**kw) | return self.recipes(recipes=MachineRecipe.mine(identity.current.user) .join('status').join('result').join('system') .join('distro').join(['distro', 'arch']), action='./mine', *args, **kw) | def mine(self,*args,**kw): return self.recipes(recipes=MachineRecipe.mine(identity.current.user),action='./mine',*args,**kw) |
widgets.PaginateDataGrid.Column(name='arch', getter=lambda x:x.arch, title='Arch', options=dict(sortable=True)), widgets.PaginateDataGrid.Column(name='system', getter=lambda x: x.system and x.system.link, title='System', options=dict(sortable=True)), widgets.PaginateDataGrid.Column(name='distro', getter=lambda x: x.dis... | widgets.PaginateDataGrid.Column(name='distro.arch.arch', getter=lambda x:x.arch, title='Arch', options=dict(sortable=True)), widgets.PaginateDataGrid.Column(name='system.fqdn', getter=lambda x: x.system and x.system.link, title='System', options=dict(sortable=True)), widgets.PaginateDataGrid.Column(name='distro.install... | def recipes(self,recipes,action='.',*args, **kw): recipes_return = self._recipes(recipes,**kw) searchvalue = None search_options = {} if recipes_return: if 'recipes_found' in recipes_return: recipes = recipes_return['recipes_found'] if 'searchvalue' in recipes_return: searchvalue = recipes_return['searchvalue'] if 'sim... |
for recipe_id in self.hub.recipes.by_log_server(self.conf.get("ARCHIVE_SERVER")): self.transfer_recipe_log(recipe_id) | for recipe_id in self.hub.recipes.by_log_server(self.server): self.transfer_recipe_logs(recipe_id) | def transfer_logs(self): self.logger.info("Entering transfer_logs") for recipe_id in self.hub.recipes.by_log_server(self.conf.get("ARCHIVE_SERVER")): self.transfer_recipe_log(recipe_id) |
myPaginateDataGrid.Column(name='osmajor', getter=lambda x: make_link(url = './edit?id=%s' % x.id, text = x), title='OS Version', options=dict(sortable=True)), | myPaginateDataGrid.Column(name='osmajor', getter=lambda x: make_link(url = './edit_osmajor?id=%s' % x.osmajor.id, text = x.osmajor), title='OS Major', options=dict(sortable=True)), myPaginateDataGrid.Column(name='alias', getter=lambda x: x.osmajor.alias, title='Alias', options=dict(sortable=True)), myPaginateDataGrid.C... | def index(self,*args,**kw): osversions = session.query(OSVersion) list_by_letters = [] for elem in osversions: osmajor_name = elem.osmajor.osmajor if osmajor_name: list_by_letters.append(osmajor_name[0].capitalize()) list_by_letters = set(list_by_letters) results = self.process_search(**kw) if results: osversions = res... |
log.debug('arch:%s distro_family:%s method:%s tag:%s ' % (arch,distro_family,method,tag)) | def get_distro_options(self,arch,distro_family,method,tag): """ get_distro_options() will return all the distros for a given arch, distro_family,method and tag """ | |
options = [elem.install_name for elem in distro] log.debug(distro) | options = [elem.install_name for elem in distro] | def get_distro_options(self,arch,distro_family,method,tag): """ get_distro_options() will return all the distros for a given arch, distro_family,method and tag """ |
log.debug("recipe: %s labController: %s Removing system %s" % (recipe.id, l)controller, system)) | log.debug("recipe: %s labController: %s Removing system %s" % (recipe.id, l_controller, system)) | def processed_recipesets(*args): recipesets = RecipeSet.query()\ .join(['recipes','status'])\ .filter(Recipe.status==TaskStatus.by_name(u'Processed')) if not recipesets.count(): return False log.debug("Entering processed_recipes routine") for recipeset in recipesets: session.begin() try: bad_l_controllers = set() # We ... |
scheduled = scheduled_recipes(): | scheduled = scheduled_recipes() | def schedule(): bkr.server.scheduler._start_scheduler() log.debug("starting new recipes Thread") # Create new_recipes Thread add_onetime_task(action=new_recipes_loop, args=[lambda:datetime.now()]) log.debug("starting processed recipes Thread") # Create processed_recipes Thread add_onetime_task(action=processed_recipese... |
new = PowerType(name=kw['name']) | flash(_(u"Invalid Power Type entry")) redirect(".") | def save(self, **kw): if kw['id']: edit = PowerType.by_id(kw['id']) edit.name = kw['name'] else: new = PowerType(name=kw['name']) flash( _(u"OK") ) redirect(".") |
list_by_letters = set([elem.name[0].capitalize() for elem in powertypes]) | list_by_letters = set([elem.name[0].capitalize() for elem in powertypes if elem.name]) | def index(self,*args,**kw): powertypes = session.query(PowerType) list_by_letters = set([elem.name[0].capitalize() for elem in powertypes]) results = self.process_search(**kw) if results: powertypes = results |
seconds=self.task.avg_time) | seconds=self.task.avg_time + 1800) | def start(self, watchdog_override=None): """ Record the start of this task If watchdog_override is defined we will use that time instead of what the tasks default time is. This should be defined in number of seconds """ if not self.recipe.watchdog: raise BX(_('No watchdog exists for recipe %s' % self.recipe.id)) if no... |
line = self.strip_ansi.sub('',line.decode('ascii', 'ignore')) size = len(line) | line = self.strip_ansi.sub(' ',line.decode('ascii', 'replace').encode('ascii', 'replace')) | def update(self): """ If the log exists and the file has grown then upload the new piece """ if os.path.exists(self.log): file = open(self.log, "r") where = self.where file.seek(where) line = file.read(self.blocksize) if self.strip_ansi: line = self.strip_ansi.sub('',line.decode('ascii', 'ignore')) size = len(line) now... |
hwdict['model_ver'] = get_entry(tmpdict, 'revision') | revision = get_entry(tmpdict, 'revision') try: hwdict['model_number'], hwdict['model_ver'] = revision.split()[0].split('.')[:2] except (ValueError, IndexError): pass | def get_entry(a, entry): e = entry.lower() if not a.has_key(e): return "" return a[e] |
self.strip_ansi = re.compile("[^\t\n\x20-\x7E]+|\[[0-9]+\;[0-9]+H") | self.control_chars = ''.join(map(unichr, range(0,9) + range(11,32) + range(127,160))) self.strip_ansi = re.compile('[%s]' % re.escape(self.control_chars)) | def __init__(self, log, watchdog, proxy, panic, blocksize=65536): self.log = log self.watchdog = watchdog self.proxy = proxy self.blocksize = blocksize self.filename = os.path.basename(self.log) # If filename is the hostname then rename it to console.log if self.filename == self.watchdog['system']: self.filename="conso... |
line = self.strip_ansi.sub("\n", line) | line = self.strip_ansi.sub('',line.decode('ascii', 'ignore')) | def update(self): """ If the log exists and the file has grown then upload the new piece """ if os.path.exists(self.log): file = open(self.log, "r") where = self.where file.seek(where) line = file.read(self.blocksize) if self.strip_ansi: line = self.strip_ansi.sub("\n", line) size = len(line) now = file.tell() file.clo... |
def get_beaker_version(): return beaker. __version__ turbogears.view.variable_providers.append({"beaker_version" : get_beaker_version()}) | #def search(): | |
@classmethod def value_less_than_filter(cls,col,val,key_name): result = model.Key.by_name(key_name) int_table = result.numeric key_id = result.id return and_(model.Key_Value_Int.key_value < val, model.Key_Value_Int.key_id == key_id) | def value_contains_pre(cls,value,**kw): return cls.value_pre(value,**kw) | |
continue | break | def scheduled_recipes(*args): """ if All recipes in a recipeSet are in Scheduled state then move them to Running. """ recipesets = RecipeSet.query().from_statement( select([recipe_set_table.c.id, func.min(recipe_table.c.status_id)], from_obj=[recipe_set_table.join(recipe_table)])\ .group_by(RecipeSet.id)\ .having(func.... |
device = Device.query().filter_by(vendor_id = device['vendorID'], | mydevice = Device.query().filter_by(vendor_id = device['vendorID'], | def updateDevices(self, deviceinfo): for device in deviceinfo: try: device = Device.query().filter_by(vendor_id = device['vendorID'], device_id = device['deviceID'], subsys_vendor_id = device['subsysVendorID'], subsys_device_id = device['subsysDeviceID'], bus = device['bus'], driver = device['driver'], description = de... |
self.devices.append(device) | def updateDevices(self, deviceinfo): for device in deviceinfo: try: device = Device.query().filter_by(vendor_id = device['vendorID'], device_id = device['deviceID'], subsys_vendor_id = device['subsysVendorID'], subsys_device_id = device['subsysDeviceID'], bus = device['bus'], driver = device['driver'], description = de... | |
new_device = Device(vendor_id = device['vendorID'], | mydevice = Device(vendor_id = device['vendorID'], | def updateDevices(self, deviceinfo): for device in deviceinfo: try: device = Device.query().filter_by(vendor_id = device['vendorID'], device_id = device['deviceID'], subsys_vendor_id = device['subsysVendorID'], subsys_device_id = device['subsysDeviceID'], bus = device['bus'], driver = device['driver'], description = de... |
session.save(new_device) session.flush([new_device]) self.devices.append(new_device) | session.save(mydevice) session.flush([mydevice]) self.devices.append(mydevice) currentDevices.append(mydevice) for device in self.devices[:]: if device not in currentDevices: self.devices.remove(device) | def updateDevices(self, deviceinfo): for device in deviceinfo: try: device = Device.query().filter_by(vendor_id = device['vendorID'], device_id = device['deviceID'], subsys_vendor_id = device['subsysVendorID'], subsys_device_id = device['subsysDeviceID'], bus = device['bus'], driver = device['driver'], description = de... |
'url --url=$tree\n' + kickstart) | 'url --url=$tree\n | def test_provision(self): kickstart = ''' %%pre kickstart lol! do some stuff etc ''' system = data_setup.create_system( owner=User.by_user_name(data_setup.ADMIN_USER), status=u'Manual', shared=True) data_setup.configure_system_power(system, power_type=u'drac', address=u'nowhere.example.com', user=u'teh_powz0r', passwor... |
recipeSet.priority = TaskPriority.query().filter_by(priority = TaskPriority.default_priority).one() | recipeSet.priority = TaskPriority.query().filter_by(TaskPriority.priority == TaskPriority.default_priority).one() | def process_xmljob(self, xmljob, user): job = Job(whiteboard='%s' % xmljob.whiteboard, ttasks=0, owner=user) for xmlrecipeSet in xmljob.iter_recipeSets(): recipeSet = RecipeSet(ttasks=0) recipeset_priority = xmlrecipeSet.get_xml_attr('priority',str,None) if recipeset_priority is not None: try: my_priority = TaskPriorit... |
recipeSet.priority = TaskPriority.query().filter(priority = TaskPriority.default_priority).one() | recipeSet.priority = TaskPriority.query().filter(TaskPriority.priority == TaskPriority.default_priority).one() | def process_xmljob(self, xmljob, user): job = Job(whiteboard='%s' % xmljob.whiteboard, ttasks=0, owner=user) for xmlrecipeSet in xmljob.iter_recipeSets(): recipeSet = RecipeSet(ttasks=0) recipeset_priority = xmlrecipeSet.get_xml_attr('priority',str,None) if recipeset_priority is not None: try: my_priority = TaskPriorit... |
afterpackages = kickstart[packages_slot:] | if end: afterpackages = "%%end\n%s" % afterpackages | def provision(self, distro=None, kickstart=None, ks_meta=None, kernel_options=None, kernel_options_post=None, ks_appends=None): """ Provision the System make xmlrpc call to lab controller """ if not distro: return False |
%(end)s | def provision(self, distro=None, kickstart=None, ks_meta=None, kernel_options=None, kernel_options_post=None, ks_appends=None): """ Provision the System make xmlrpc call to lab controller """ if not distro: return False | |
key = peer.tasks[i].role task.roles[key].append(peer.system) | try: task.roles[peer.tasks[i].role].append(peer.system) except IndexError: pass | def scheduled_recipes(*args): """ if All recipes in a recipeSet are in Scheduled state then move them to Running. """ recipesets = RecipeSet.query().from_statement( select([recipe_set_table.c.id, func.min(recipe_table.c.status_id)], from_obj=[recipe_set_table.join(recipe_table)])\ .group_by(RecipeSet.id)\ .having(func.... |
mp = False | def kernel_inventory(): # get the data from SMOLT but modify it for how RHTS expects to see it # Eventually we'll switch over to SMOLT properly. data = {} data['VIRT_IOMMU'] = False ########################################## # check for virtual iommu/vt-d capability # if this passes, assume we pick up sr-iov for free ... | |
order_by=[model.job_table.c.id],distinct=True,limit=50) log.debug(s1) | order_by=[model.job_table.c.id],distinct=True,limit=50) | def get_whiteboard_options(self,filter): """ get_whiteboard_options() returns all whiteboards from the job_table if value is passed in for 'filter' it will perform an SQL 'like' operation against whiteboard """ if filter: where = model.job_table.c.whiteboard.like('%%%s%%' % filter) else: where = None s1 = select([model... |
systems = recipe.dyn_systems.filter(and_(System.user==None, System.status==automated)) | systems = recipe.dyn_systems.join(['lab_controller','_distros','distro']).\ filter(and_(System.user==None, Distro.id==recipe.distro_id, System.status==automated)) | def queued_recipes(*args): automated = SystemStatus.by_name(u'Automated') recipes = Recipe.query()\ .join('status')\ .join(['systems','lab_controller','_distros','distro'])\ .join(['recipeset','priority'])\ .join(['distro','lab_controller_assocs','lab_controller'])\ .filter( or_( and_(Recipe.status==TaskStatus.by_name(... |
properties = {'recipetask':relation(RecipeTask, uselist=False, backref='watchdog'), | properties = {'recipetask':relation(RecipeTask, uselist=False), | def __repr__(self): return self.package |
install_name = args[0] | if args: install_name = args[0] else: self.parser.print_help() sys.exit(1) | def run(self, *args, **kwargs): filter = dict() username = kwargs.pop("username", None) password = kwargs.pop("password", None) filter['types'] = kwargs.pop("type", None) filter['packages'] = kwargs.pop("package", None) params = kwargs.pop("params", []) xml = kwargs.pop("xml") |
for vendor in (u'Acer', u'Dell', u'HP'): for model in (u'slow model', u'fast model', u'big model'): for status in (u'Automated', u'Manual', u'Removed'): for type in (u'Machine', u'Virtual', u'Prototype'): for cores in (1, 4): system = data_setup.create_system( vendor=vendor, model=model, status=status, type=type) syste... | for cores in [1, 2, 3]: for vendor, model, status, type, user in zip( [u'Acer', u'Dell', u'HP'], [u'slow model', u'fast model', u'big model'], [u'Automated', u'Manual', u'Removed'], [u'Machine', u'Virtual', u'Prototype'], [data_setup.create_user() for _ in range(3)]): system = data_setup.create_system(vendor=vendor, mo... | def setUpClass(cls): try: session.begin() # ensure we have lots of systems for vendor in (u'Acer', u'Dell', u'HP'): for model in (u'slow model', u'fast model', u'big model'): for status in (u'Automated', u'Manual', u'Removed'): for type in (u'Machine', u'Virtual', u'Prototype'): for cores in (1, 4): system = data_setup... |
sel.click('link=Show all') | def check_column_sort(self, column): sel = self.selenium sel.click('link=Show all') sel.wait_for_page_to_load('30000') sel.click('//table[@id="widget"]/thead/th[%d]//a[@href]' % column) sel.wait_for_page_to_load('30000') row_count = int(sel.get_xpath_count( '//table[@id="widget"]/tbody/tr/td[%d]' % column)) cell_values... | |
self.removedirs(mylog['basepath']) | self.removedirs('%s/%s' % (mylog['basepath'], mylog['path'])) | def finish(self): """ If Cache is turned on then move the recipes logs to there final place """ if self.conf.get("CACHE",False): tmpdir = tempfile.mkdtemp(dir=self.basepath) # Move logs to tmp directory layout mylogs = self.hub.recipes.files(self.watchdog['recipe_id']) trlogs = [] for mylog in mylogs: server = '%s/%s' ... |
except exceptions.InvalidRequestError: | except InvalidRequestError: | def process_taskinfo(self, raw_taskinfo): tinfo = testinfo.parse_string(raw_taskinfo['desc']) |
output = open('/tmp/beakerlib_journal.%s' % id, 'wb') output.write(newdoc.toxml().encode('utf-8')) output.close() | journal = '/tmp/beakerlib-%s/journal.xml' % id try: output = open(journal, 'wb') output.write(newdoc.toxml().encode('utf-8')) output.close() except IOError: printLog('Failed to save journal to %s' % journal, 'BEAKERLIB_WARNING') sys.exit(1) | def saveJournal(newdoc, id): output = open('/tmp/beakerlib_journal.%s' % id, 'wb') output.write(newdoc.toxml().encode('utf-8')) output.close() |
jrnl = xml.dom.minidom.parse("/tmp/beakerlib_journal.%s" % id ) | jrnl = xml.dom.minidom.parse("/tmp/beakerlib-%s/journal.xml" % id ) | def _openJournal(id): jrnl = xml.dom.minidom.parse("/tmp/beakerlib_journal.%s" % id ) return jrnl |
print >> sys.stderr, score | def need(args): if None in args: print "need Blargh!" sys.exit(1) | |
print xml.dom.minidom.parseString(myxml).toprettyxml() | print parseString(myxml).toprettyxml() | def run(self, *args, **kwargs): username = kwargs.pop("username", None) password = kwargs.pop("password", None) prettyxml = kwargs.pop("prettyxml", None) |
@paginate('tasks',default_order='-id', limit=30) | @paginate('tasks',default_order='-id', limit=30, allow_limit_override=True) | def executed(self, hidden={}, **kw): tmp = self._do_search(hidden, **kw) tmp['form'] = self.task_form tmp['action'] = './do_search' tmp['value'] = None tmp['options'] = dict() return tmp |
logs = 1, | def _do_search(self, hidden={}, **kw): if 'recipe_id' in kw: #most likely we are coming here from a LinkRemoteFunction in recipe_widgets tasks = RecipeTask.query().join(['recipe']).filter(Recipe.id == kw['recipe_id']) | |
logs = 1) | ) | def _do_search(self, hidden={}, **kw): if 'recipe_id' in kw: #most likely we are coming here from a LinkRemoteFunction in recipe_widgets tasks = RecipeTask.query().join(['recipe']).filter(Recipe.id == kw['recipe_id']) |
Group.systems==None, | System.groups==None, | def available(cls, user,systems=None): """ Builds on all. Only systems which this user has permission to reserve. If a system is loaned then its only available for that person. """ if systems: query = systems else: query = System.all(user) return query.filter(and_( System.status==SystemStatus.by_name(u'Working'), or_... |
@paginate('list') | @paginate('list',default_order='fqdn',limit=10,allow_limit_override=True) | def by_name(self,name): name = name.lower() search = Arch.list_by_name(name) arches = [match.arch for match in search] return dict(arches=arches) |
systems = System.all(identity.current.user).join('devices').filter_by(id=id) | systems = System.all(identity.current.user).join('devices').filter_by(id=id).distinct() | def view(self, id): device = session.query(Device).get(id) systems = System.all(identity.current.user).join('devices').filter_by(id=id) device_grid = myPaginateDataGrid(fields=[ ('System', lambda x: make_link("/view/%s" % x.fqdn, x.fqdn)), ('Description', lambda x: device.description), ]) return dict(title="", grid = d... |
whiteboard_options = self.get_whiteboard_options(filter) whiteboard_options = [(w[0],w[0]) for w in whiteboard_options] | def index(self,**kw): self.col_call = 0 self.max_cols = 0 self.job_ids = [] matrix_options = {} if 'whiteboard_filter' in kw: filter = kw['whiteboard_filter'] else: filter = None | |
require = self.doc.createElement('distro_%s' % key.lower()) | if key in ['ARCH', 'FAMILY', 'NAME', 'VARIANT', 'METHOD']: require = self.doc.createElement('distro_%s' % key.lower()) require.setAttribute('value', '%s' % value) else: require = self.doc.createElement('distro_tag') require.setAttribute('value', '%s' % key) | def handle_distroRequires(self, requires): require = None requires_search = re.compile(r'([^\s]+)\s+([^\s]+)\s+([^\s]+)') if requires_search.match(requires): (dummy, key, op, value, dummy) = requires_search.split(requires) require = self.doc.createElement('distro_%s' % key.lower()) require.setAttribute('op', '%s' % op)... |
require.setAttribute('value', '%s' % value) | def handle_distroRequires(self, requires): require = None requires_search = re.compile(r'([^\s]+)\s+([^\s]+)\s+([^\s]+)') if requires_search.match(requires): (dummy, key, op, value, dummy) = requires_search.split(requires) require = self.doc.createElement('distro_%s' % key.lower()) require.setAttribute('op', '%s' % op)... | |
def to_xml(self, clone=False): | def to_xml(self, clone=False, from_recipeset=False): | def to_xml(self, clone=False): recipe = self.doc.createElement("guestrecipe") recipe.setAttribute("guestname", "%s" % self.guestname) recipe.setAttribute("guestargs", "%s" % self.guestargs) return Recipe.to_xml(self,recipe,clone) |
return Recipe.to_xml(self,recipe,clone) | return Recipe.to_xml(self, recipe, clone, from_recipeset) | def to_xml(self, clone=False): recipe = self.doc.createElement("guestrecipe") recipe.setAttribute("guestname", "%s" % self.guestname) recipe.setAttribute("guestargs", "%s" % self.guestargs) return Recipe.to_xml(self,recipe,clone) |
def to_xml(self, clone=False): | def to_xml(self, clone=False, from_recipeset=False): | def to_xml(self, clone=False): recipe = self.doc.createElement("recipe") for guest in self.guests: recipe.appendChild(guest.to_xml(clone)) return Recipe.to_xml(self,recipe,clone) |
return Recipe.to_xml(self,recipe,clone) | return Recipe.to_xml(self, recipe, clone, from_recipeset) | def to_xml(self, clone=False): recipe = self.doc.createElement("recipe") for guest in self.guests: recipe.appendChild(guest.to_xml(clone)) return Recipe.to_xml(self,recipe,clone) |
def __init__(self, is_default, tag, *args, **kw): | def __init__(self, tag, is_default=False, *args, **kw): | def __init__(self, is_default, tag, *args, **kw): self.set_default_val(is_default) super(RetentionTag, self).__init__(tag, *args, **kw) session.flush() |
super(RetentionTag, self).__init__(tag, *args, **kw) | super(RetentionTag, self).__init__(tag, **kw) | def __init__(self, is_default, tag, *args, **kw): self.set_default_val(is_default) super(RetentionTag, self).__init__(tag, *args, **kw) session.flush() |
start_time = report_time finish_time = report_time | def time(self): return self.report_time start_time = property(time) finish_time = property(time) | def no_value(self): return None |
if 'install_name' in filter: | if 'install_name' in filter and filter['install_name']: | def filter(self, filter=None): """ XMLRPC method to query all tasks that apply to this distro """ if 'install_name' in filter: try: distro = Distro.by_install_name(filter['install_name']) except InvalidRequestError, err: raise BX(_('Invalid Distro: %s ' % filter['install_name'])) tasks = distro.tasks() else: tasks = Ta... |
m = re.match('^(\d+)', value) | m = re.match('^(\d+)(.*)$', value) | def handle_testtime(self, key, value): if self.info.avg_test_time: self.handle_error("%s field already defined"%key) return |
if re.match('.*m$', value): | suffix = m.group(2) if suffix == '': pass elif suffix == 'm': | def handle_testtime(self, key, value): if self.info.avg_test_time: self.handle_error("%s field already defined"%key) return |
elif re.match('.*h$', value): | elif suffix == 'h': | def handle_testtime(self, key, value): if self.info.avg_test_time: self.handle_error("%s field already defined"%key) return |
warn = 'No Systems compatible with distro %s' % distro_install_name | warn = 'No Systems compatible with distro %s' % distro.install_name | def reserve_link(x,distro): if x.is_free(): return make_link("/reserveworkflow/reserve?system_id=%s&distro_id=%s" % (Utility.get_correct_system_column(x).id,distro), 'Reserve Now') else: return make_link("/reserveworkflow/reserve?system_id=%s&distro_id=%s" % (Utility.get_correct_system_column(x).id,distro), 'Queue Rese... |
distros = Distro.query() | distros = Distro.query().join('lab_controller_assocs') | def by_filter(cls, filter): """ <distro> <And> <Require name='ARCH' operator='=' value='i386'/> <Require name='FAMILY' operator='=' value='rhelserver5'/> <Require name='TAG' operator='=' value='released'/> </And> </distro> """ from needpropertyxml import ElementWrapper import xmltramp #FIXME Should validate XML before ... |
if not queued_recipes() and not scheduled_recipes(): | queued = queued_recipes() scheduled = scheduled_recipes(): if not queued and not scheduled: | def schedule(): bkr.server.scheduler._start_scheduler() log.debug("starting new recipes Thread") # Create new_recipes Thread add_onetime_task(action=new_recipes_loop, args=[lambda:datetime.now()]) log.debug("starting processed recipes Thread") # Create processed_recipes Thread add_onetime_task(action=processed_recipese... |
def install_start(self): | def install_start(self, system_name=None): | def install_start(self): """ Called from %pre of the test machine. We record a start result on the scheduler and extend the watchdog This is a little ugly.. but better than putting this logic in kickstart """ self.logger.info("install_start") # extend watchdog by 3 hours 60 * 60 * 3 kill_time = 10800 # look up system ... |
task = xmltramp.parse(self.get_recipe()).recipeSet.recipe.task() | task = xmltramp.parse(self.get_recipe(system_name)).recipeSet.recipe.task() | def install_start(self): """ Called from %pre of the test machine. We record a start result on the scheduler and extend the watchdog This is a little ugly.. but better than putting this logic in kickstart """ self.logger.info("install_start") # extend watchdog by 3 hours 60 * 60 * 3 kill_time = 10800 # look up system ... |
parser.add_option("-t","--threshold", default=3, | parser.add_option("-t","--threshold", default=3, type=int, | def get_parser(): usage = "usage: %prog [options]" parser = OptionParser(usage, description=__description__,version=__version__) parser.add_option("-s","--service", default='WEBUI', help="Report on this service (WEBUI,SCHEDULER), Default is WEBUI") parser.add_option("-t","--threshold", default=3, help="This is the numb... |
if date_reserved + threshold_delta > date_now: | if date_reserved + threshold_delta < date_now: | def identify_nags(threshold, service): sys_activities = System.reserved_via(service) for activity in sys_activities: date_reserved = activity.created date_now = datetime.fromtimestamp(time.time()) threshold_delta = timedelta(days=threshold) if date_reserved + threshold_delta > date_now: #Let's send them a reminder sys... |
task = xmltramp.parse(self.get_recipe(system_name)).recipeSet.recipe.task() | recipeset = xmltramp.parse(self.get_recipe(system_name)).recipeSet try: task = recipeset.recipe.task() except AttributeError: task = recipeset.guestrecipe.task() | def install_start(self, system_name=None): """ Called from %pre of the test machine. We record a start result on the scheduler and extend the watchdog This is a little ugly.. but better than putting this logic in kickstart """ self.logger.info("install_start") # extend watchdog by 3 hours 60 * 60 * 3 kill_time = 10800... |
job.appendChild(self.node("whiteboard", self.recipeset.job.whiteboard)) | job.appendChild(self.node("whiteboard", self.recipeset.job.whiteboard or '')) | def to_xml(self, recipe, clone=False, from_recipeset=False, from_machine=False): if not clone: recipe.setAttribute("id", "%s" % self.id) recipe.setAttribute("job_id", "%s" % self.recipeset.job_id) recipe.setAttribute("recipe_set_id", "%s" % self.recipe_set_id) recipe.setAttribute("whiteboard", "%s" % self.whiteboard an... |
.join(['recipes','status'])\ .filter(Recipe.status==TaskStatus.by_name(u'Processed')) | .join(['status'])\ .filter(RecipeSet.status==TaskStatus.by_name(u'Processed')) | def processed_recipesets(*args): recipesets = RecipeSet.query()\ .join(['recipes','status'])\ .filter(Recipe.status==TaskStatus.by_name(u'Processed')) if not recipesets.count(): return False log.debug("Entering processed_recipes routine") for recipeset in recipesets: session.begin() try: bad_l_controllers = set() # We ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.