Datasets:

h4iku
/

coconut_python2010_preprocessed

Dataset card Data Studio Files Files and versions Community

Split (1)

train · 303k rows

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.

rem stringlengths 0 322k	add stringlengths 0 2.05M	context stringlengths 8 228k
'{outbound} method %s()", not found' % (action)	'{outbound} method %s()", not found' % action	def outbound(cls, action): """ Find the handler B{outbound} method for the specified I{action}. @param action: The I{action} part of an event subject. @type action: str @return: The handler instance method. @rtype: instancemethod """ mutex.acquire() try: method = cls.outbounds.get(action) if method is None: raise Exception,\ '{outbound} method %s()", not found' % (action) else: return method finally: mutex.release()
raise threading.ThreadError('Thread is not active')	raise _ThreadInterruptionError('Thread is not active')	def _tid(thread): """ Determine a thread's id. """ if not thread.is_alive(): raise threading.ThreadError('Thread is not active') if hasattr(thread, '_thread_id'): return thread._thread_id for tid, tobj in threading._active.items(): if tobj is thread: thread._thread_id = tid return tid raise AssertionError('Could not determine thread id')
raise AssertionError('Could not determine thread id')	raise _ThreadInterruptionError('Could not determine thread id')	def _tid(thread): """ Determine a thread's id. """ if not thread.is_alive(): raise threading.ThreadError('Thread is not active') if hasattr(thread, '_thread_id'): return thread._thread_id for tid, tobj in threading._active.items(): if tobj is thread: thread._thread_id = tid return tid raise AssertionError('Could not determine thread id')
raise ValueError('Invalid thread id')	raise _ThreadInterruptionError('Invalid thread id')	def _raise_exception_in_thread(tid, exc_type): """ Raises an exception in the threads with id tid. """ assert inspect.isclass(exc_type) # NOTE this returns the number of threads that it modified, which should # only be 1 or 0 (if the thread id wasn't found) long_tid = ctypes.c_long(tid) exc_ptr = ctypes.py_object(exc_type) num = ctypes.pythonapi.PyThreadState_SetAsyncExc(long_tid, exc_ptr) if num == 1: return if num == 0: raise ValueError('Invalid thread id') # NOTE if it returns a number greater than one, you're in trouble, # and you should call it again with exc=NULL to revert the effect null_ptr = ctypes.py_object() ctypes.pythonapi.PyThreadState_SetAsyncExc(long_tid, null_ptr) raise SystemError('PyThreadState_SetAsyncExc failed')
raise SystemError('PyThreadState_SetAsyncExc failed')	raise _ThreadInterruptionError('PyThreadState_SetAsyncExc failed')	def _raise_exception_in_thread(tid, exc_type): """ Raises an exception in the threads with id tid. """ assert inspect.isclass(exc_type) # NOTE this returns the number of threads that it modified, which should # only be 1 or 0 (if the thread id wasn't found) long_tid = ctypes.c_long(tid) exc_ptr = ctypes.py_object(exc_type) num = ctypes.pythonapi.PyThreadState_SetAsyncExc(long_tid, exc_ptr) if num == 1: return if num == 0: raise ValueError('Invalid thread id') # NOTE if it returns a number greater than one, you're in trouble, # and you should call it again with exc=NULL to revert the effect null_ptr = ctypes.py_object() ctypes.pythonapi.PyThreadState_SetAsyncExc(long_tid, null_ptr) raise SystemError('PyThreadState_SetAsyncExc failed')
_raise_exception_in_thread(_tid(self), exc_type)	_raise_exception_in_thread(_tid(thread), exc_type)	def raise_exception(self, exc_type): """ Raise and exception in this thread. NOTE this is executed in the context of the calling thread and blocks until the exception has been delivered to this thread and this thread exists. """ # first, kill off all the descendants for thread in get_descendants(self): while thread.is_alive(): try: _raise_exception_in_thread(_tid(self), exc_type) time.sleep(self.__default_timeout) except (threading.ThreadError, AssertionError, ValueError, SystemError), e: _log.error('Failed to deliver exception %s to thread[%s]: %s' % (exc_type.__name__, str(self.ident), e.message)) break remove_subtree(self) # then kill and wait for the task thread while not self.__exception_event.is_set(): try: _raise_exception_in_thread(_tid(self), exc_type) self.__exception_event.wait(self.__default_timeout) except (threading.ThreadError, AssertionError, ValueError, SystemError), e: _log.error('Failed to deliver exception %s to thread[%s]: %s' % (exc_type.__name__, str(self.ident), e.message)) break
except (threading.ThreadError, AssertionError, ValueError, SystemError), e:	except _ThreadInterruptionError, e:	def raise_exception(self, exc_type): """ Raise and exception in this thread. NOTE this is executed in the context of the calling thread and blocks until the exception has been delivered to this thread and this thread exists. """ # first, kill off all the descendants for thread in get_descendants(self): while thread.is_alive(): try: _raise_exception_in_thread(_tid(self), exc_type) time.sleep(self.__default_timeout) except (threading.ThreadError, AssertionError, ValueError, SystemError), e: _log.error('Failed to deliver exception %s to thread[%s]: %s' % (exc_type.__name__, str(self.ident), e.message)) break remove_subtree(self) # then kill and wait for the task thread while not self.__exception_event.is_set(): try: _raise_exception_in_thread(_tid(self), exc_type) self.__exception_event.wait(self.__default_timeout) except (threading.ThreadError, AssertionError, ValueError, SystemError), e: _log.error('Failed to deliver exception %s to thread[%s]: %s' % (exc_type.__name__, str(self.ident), e.message)) break
repo = self.pconn.repository(id)	repo = self.get_repo(id)	def run(self): id = self.get_required_option('id') repo = self.pconn.repository(id) syncs = self.pconn.sync_list(id) print_header(_('Status for %s') % id) print _('Repository: %s') % repo['id'] print _('Number of Packages: %d') % repo['package_count'] last_sync = repo['last_sync'] if last_sync is None: last_sync = 'never' else: last_sync = str(parse_date(last_sync)) print _('Last Sync: %s') % last_sync if not syncs or syncs[0]['state'] not in ('waiting', 'running'): return print _('Currently syncing:'), if syncs[0]['progress'] is None: print _('progress unknown') else: pkgs_left = syncs[0]['progress']['items_left'] pkgs_total = syncs[0]['progress']['items_total'] bytes_left = float(syncs[0]['progress']['size_left']) bytes_total = float(syncs[0]['progress']['size_total']) percent = (bytes_total - bytes_left) / bytes_total print _('%d%% done (%d of %d packages downloaded)') % \ (int(percent), (pkgs_total - pkgs_left), pkgs_total)
repo = self.pconn.repository(id)	repo = self.get_repo(id)	def run(self): id = self.get_required_option('id') repo = self.pconn.repository(id) files = repo['files'] packages = self.pconn.packages(id) print_header(_('Contents of %s') % id) print _('files in %s:') % id if not files: print _(' none') else: for f in sorted(repo['files']): print ' ' + f print _('packages in %s:') % id if not packages: print _(' none') else: for p in sorted(packages, key=lambda p: p['filename']): print ' ' + p['filename']
repo = self.pconn.repository(id) if not repo: system_exit(os.EX_DATAERR, _("Repository with id: [%s] not found") % id)	repo = self.get_repo(id)	def run(self): id = self.get_required_option('id') repo = self.pconn.repository(id) if not repo: system_exit(os.EX_DATAERR, _("Repository with id: [%s] not found") % id) optdict = vars(self.opts) for k, v in optdict.items(): if not v: continue method = self.find(k) if method: # special method stale = method(repo, v) if stale: repo = self.pconn.repository(id) continue if k in repo: repo[k] = v self.pconn.update(repo) print _("Successfully updated repository [ %s ]") % repo['id']
if relative_path is None and r['source'] is not None : url_parse = urlparse(str(r['source']["url"])) r['relative_path'] = url_parse.path	if relative_path is None: if r['source'] is not None : url_parse = urlparse(str(r['source']["url"])) r['relative_path'] = url_parse.path else: r['relative_path'] = r['id']	def create(self, id, name, arch, feed=None, symlinks=False, sync_schedule=None, cert_data=None, groupid=None, relative_path=None): """ Create a new Repository object and return it """ repo = self.repository(id) if repo is not None: raise PulpException("A Repo with id %s already exists" % id) self._validate_schedule(sync_schedule)
self.objectdb.remove(repo, safe=True)	self.objectdb.remove({'id' : id}, safe=True)	def delete(self, id): repo = self._get_existing_repo(id) repo_sync.delete_schedule(repo) repo_location = "%s/%s" % (config.config.get('paths', 'local_storage'), "repos") #delete any data associated to this repo for field in ['relative_path', 'cert', 'key', 'ca']: if field == 'relative_path' and repo[field]: fpath = os.path.join(repo_location, repo[field]) else: fpath = repo[field] if fpath and os.path.exists(fpath): try: if os.path.isfile(fpath): os.remove(fpath) else: # os.path.isdir(fpath): shutil.rmtree(fpath) log.error("removing repo files .... %s" % fpath) except: #file removal failed raise log.error("Unable to cleanup file %s " % fpath) continue self.objectdb.remove(repo, safe=True)
default_to_publish = config.config.get('repos', 'default_to_published')	default_to_publish = \ config.config.getboolean('repos', 'default_to_published')	def create(self, id, name, arch, feed=None, symlinks=False, sync_schedule=None, cert_data=None, groupid=None, relative_path=None, gpgkeys=[]): """ Create a new Repository object and return it """ repo = self.repository(id) if repo is not None: raise PulpException("A Repo with id %s already exists" % id) self._validate_schedule(sync_schedule)
log.debug("Skipping update of groups metadata since missing repomd file: '%s'" %	log.warn("Skipping update of groups metadata since missing repomd file: '%s'" %	def _update_groups_metadata(self, repoid): """ Updates the groups metadata (example: comps.xml) for a given repo @param repoid: repo id @return: True if metadata was successfully updated, otherwise False """ repo = self._get_existing_repo(repoid) try: # If the repomd file is not valid, or if we are missingg # a group metadata file, no point in continuing. if not os.path.exists(repo["repomd_xml_path"]): log.debug("Skipping update of groups metadata since missing repomd file: '%s'" % (repo["repomd_xml_path"])) return False xml = comps_util.form_comps_xml(repo['packagegroupcategories'], repo['packagegroups']) if repo["group_xml_path"] == "": repo["group_xml_path"] = os.path.dirname(repo["repomd_xml_path"]) repo["group_xml_path"] = os.path.join(os.path.dirname(repo["repomd_xml_path"]), "comps.xml") self.update(repo) f = open(repo["group_xml_path"], "w") f.write(xml.encode("utf-8")) f.close() if repo["group_gz_xml_path"]: gz = gzip.open(repo["group_gz_xml_path"], "wb") gz.write(xml.encode("utf-8")) gz.close() return comps_util.update_repomd_xml_file(repo["repomd_xml_path"], repo["group_xml_path"], repo["group_gz_xml_path"]) except Exception, e: log.debug("_update_groups_metadata exception caught: %s" % (e)) log.debug("Traceback: %s" % (traceback.format_exc())) return False
log.debug("_update_groups_metadata exception caught: %s" % (e)) log.debug("Traceback: %s" % (traceback.format_exc()))	log.warn("_update_groups_metadata exception caught: %s" % (e)) log.warn("Traceback: %s" % (traceback.format_exc()))	def _update_groups_metadata(self, repoid): """ Updates the groups metadata (example: comps.xml) for a given repo @param repoid: repo id @return: True if metadata was successfully updated, otherwise False """ repo = self._get_existing_repo(repoid) try: # If the repomd file is not valid, or if we are missingg # a group metadata file, no point in continuing. if not os.path.exists(repo["repomd_xml_path"]): log.debug("Skipping update of groups metadata since missing repomd file: '%s'" % (repo["repomd_xml_path"])) return False xml = comps_util.form_comps_xml(repo['packagegroupcategories'], repo['packagegroups']) if repo["group_xml_path"] == "": repo["group_xml_path"] = os.path.dirname(repo["repomd_xml_path"]) repo["group_xml_path"] = os.path.join(os.path.dirname(repo["repomd_xml_path"]), "comps.xml") self.update(repo) f = open(repo["group_xml_path"], "w") f.write(xml.encode("utf-8")) f.close() if repo["group_gz_xml_path"]: gz = gzip.open(repo["group_gz_xml_path"], "wb") gz.write(xml.encode("utf-8")) gz.close() return comps_util.update_repomd_xml_file(repo["repomd_xml_path"], repo["group_xml_path"], repo["group_gz_xml_path"]) except Exception, e: log.debug("_update_groups_metadata exception caught: %s" % (e)) log.debug("Traceback: %s" % (traceback.format_exc())) return False
help=_("Package filename to remove to this repository"))	help=_("Package filename to remove from this repository"))	def setup_parser(self): super(RemovePackages, self).setup_parser() self.parser.add_option("-p", "--package", action="append", dest="pkgname", help=_("Package filename to remove to this repository"))
help=_("Errata Id to delete to this repository"))	help=_("Errata Id to delete from this repository"))	def setup_parser(self): super(RemoveErrata, self).setup_parser() self.parser.add_option("-e", "--errata", action="append", dest="errataid", help=_("Errata Id to delete to this repository"))
self.assertTrue(False)		def test_update_delete_schedule(self): ''' Tests multiple updates to a repo's sync schedule and the case where multiple updates are created with no schedules. '''
rmd = yum.repoMDObject.RepoMD("temp_pulp", repomd_path)	rmd = yum.repoMDObject.RepoMD("temp_pulp", path)	def get_repomd_filetype_path(path, filetype): """ @param path: path to repo @param filetype: metadata type to query, example "group", "primary", etc @return: Path for filetype, or None """ rmd = yum.repoMDObject.RepoMD("temp_pulp", repomd_path) if rmd: data = rmd.getData(filetype) return data.location[1] return None
def POST(self):	def POST(self, id):	def POST(self): """ @return: True on successful update or repository meta data """ repo = self.input() API.update(repo) return self.output(True)
@return: True on successful update or repository meta data	@return: True on successful update of repository meta data	def POST(self): """ @return: True on successful update or repository meta data """ repo = self.input() API.update(repo) return self.output(True)
user = api.create(login=user_data['login'], password=user_data['password'], name=user_data['name'])	user = api.create(user_data['login'], user_data['password'], user_data['name'])	def PUT(self): """ Create a new user @return: user that was created """ user_data = self.params() user = api.create(login=user_data['login'], password=user_data['password'], name=user_data['name']) return self.created(user['id'], user)
def _raise_exception_in_thread(tid, exctype):	def _raise_exception_in_thread(tid, exc_type):	def _raise_exception_in_thread(tid, exctype): """ Raises an exception in the threads with id tid. """ if not inspect.isclass(exctype): raise TypeError('Only types can be raised (not instances)') # NOTE this returns the number of threads that it modified, which should # only be 1 or 0 (if the thread id wasn't found) excptr = ctypes.py_object(exctype) num = ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, excptr) if num == 1: return if num == 0: raise ValueError('Invalid thread id') # NOTE if it returns a number greater than one, you're in trouble, # and you should call it again with exc=NULL to revert the effect nullptr = ctypes.py_object() ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, nullptr) raise SystemError('PyThreadState_SetAsyncExc failed')
if not inspect.isclass(exctype): raise TypeError('Only types can be raised (not instances)')	assert inspect.isclass(exc_type)	def _raise_exception_in_thread(tid, exctype): """ Raises an exception in the threads with id tid. """ if not inspect.isclass(exctype): raise TypeError('Only types can be raised (not instances)') # NOTE this returns the number of threads that it modified, which should # only be 1 or 0 (if the thread id wasn't found) excptr = ctypes.py_object(exctype) num = ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, excptr) if num == 1: return if num == 0: raise ValueError('Invalid thread id') # NOTE if it returns a number greater than one, you're in trouble, # and you should call it again with exc=NULL to revert the effect nullptr = ctypes.py_object() ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, nullptr) raise SystemError('PyThreadState_SetAsyncExc failed')
excptr = ctypes.py_object(exctype) num = ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, excptr)	long_tid = ctypes.c_long(tid) exc_ptr = ctypes.py_object(exc_type) num = ctypes.pythonapi.PyThreadState_SetAsyncExc(long_tid, exc_ptr)	def _raise_exception_in_thread(tid, exctype): """ Raises an exception in the threads with id tid. """ if not inspect.isclass(exctype): raise TypeError('Only types can be raised (not instances)') # NOTE this returns the number of threads that it modified, which should # only be 1 or 0 (if the thread id wasn't found) excptr = ctypes.py_object(exctype) num = ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, excptr) if num == 1: return if num == 0: raise ValueError('Invalid thread id') # NOTE if it returns a number greater than one, you're in trouble, # and you should call it again with exc=NULL to revert the effect nullptr = ctypes.py_object() ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, nullptr) raise SystemError('PyThreadState_SetAsyncExc failed')
nullptr = ctypes.py_object() ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, nullptr)	null_ptr = ctypes.py_object() ctypes.pythonapi.PyThreadState_SetAsyncExc(long_tid, null_ptr)	def _raise_exception_in_thread(tid, exctype): """ Raises an exception in the threads with id tid. """ if not inspect.isclass(exctype): raise TypeError('Only types can be raised (not instances)') # NOTE this returns the number of threads that it modified, which should # only be 1 or 0 (if the thread id wasn't found) excptr = ctypes.py_object(exctype) num = ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, excptr) if num == 1: return if num == 0: raise ValueError('Invalid thread id') # NOTE if it returns a number greater than one, you're in trouble, # and you should call it again with exc=NULL to revert the effect nullptr = ctypes.py_object() ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, nullptr) raise SystemError('PyThreadState_SetAsyncExc failed')
def raise_exception(self, exctype):	def raise_exception(self, exc_type):	def _tid(self): """ Determine this thread's id.
Raises the given exception type in the context of this thread. If the thread is busy in a system call (time.sleep(), socket.accept(), ...) the exception is simply ignored. If you are sure that your exception should terminate the thread, one way to ensure that it works is: t = InterruptableThread(...) ... t.raise_exception(SomeException) while t.isAlive(): time.sleep(0.1) t.raise_exception(SomeException) If the exception is to be caught by the thread, you need a way to check that your thread has caught it. CAREFUL : this method is executed in the context of the caller thread, to raise an exception in the context of the thread represented by this instance.		def raise_exception(self, exctype): """ Raises the given exception type in the context of this thread.
_raise_exception_in_thread(self._tid, exctype)	try: while self.is_alive(): _raise_exception_in_thread(self._tid, exc_type) self.join(self._default_timeout) except threading.ThreadError: pass	def raise_exception(self, exctype): """ Raises the given exception type in the context of this thread.
_default_sleep = 0.0005 def _ensure_exception(self, exctype): """ Ensure that the exception gets raised in the thread or that the thread is already dead. @type exctype: type or class @param exctype: type or class of exception to raise in the tread """ try: while self.is_alive(): self.raise_exception(exctype) time.sleep(self._default_sleep) except threading.ThreadError: pass		def raise_exception(self, exctype): """ Raises the given exception type in the context of this thread.
self._ensure_exception(TimeoutException)	self.raise_exception(TimeoutException)	def timeout(self): """ Raise a TimeoutException in the thread. """ self._ensure_exception(TimeoutException)
help="common repository name")	help="Common repository name")	def generate_options(self):
help="package arch the repo should support.")	help="Package arch the repo should support.")	def generate_options(self):
if "updateinfo" in ftypes and not skip.has_key('errata') or skip['errata'] != 1:	if "updateinfo" in ftypes and (not skip.has_key('errata') or skip['errata'] != 1):	def add_packages_from_dir(self, dir, repo, skip={}): added_packages = {} added_errataids = [] if not skip.has_key('packages') or skip['packages'] != 1: startTime = time.time() log.debug("Begin to add packages from %s into %s" % (dir, repo['id'])) package_list = pulp.server.util.get_repo_packages(dir) log.debug("Processing %s potential packages" % (len(package_list))) for package in package_list: package = self.import_package(package, repo, repo_defined=True) if (package is not None): added_packages[package["id"]] = package endTime = time.time() log.debug("Repo: %s read [%s] packages took %s seconds" % (repo['id'], len(added_packages), endTime - startTime)) else: log.info("Skipping package imports from sync process") if not skip.has_key('distribution') or skip['distribution'] != 1: # process kickstart files/images part of the repo self._process_repo_images(dir, repo) else: log.info("skipping distribution imports from sync process") # Import groups metadata if present repomd_xml_path = os.path.join(dir.encode("ascii", "ignore"), 'repodata/repomd.xml') if os.path.isfile(repomd_xml_path): repo["repomd_xml_path"] = repomd_xml_path ftypes = pulp.server.util.get_repomd_filetypes(repomd_xml_path) log.debug("repodata has filetypes of %s" % (ftypes)) if "group" in ftypes: group_xml_path = pulp.server.util.get_repomd_filetype_path(repomd_xml_path, "group") group_xml_path = os.path.join(dir.encode("ascii", "ignore"), group_xml_path) if os.path.isfile(group_xml_path): groupfile = open(group_xml_path, "r") repo['group_xml_path'] = group_xml_path self.sync_groups_data(groupfile, repo) log.info("Loaded group info from %s" % (group_xml_path)) else: log.info("Group info not found at file: %s" % (group_xml_path)) if "group_gz" in ftypes: group_gz_xml_path = pulp.server.util.get_repomd_filetype_path( repomd_xml_path, "group_gz") group_gz_xml_path = os.path.join(dir.encode("ascii", "ignore"), group_gz_xml_path) repo['group_gz_xml_path'] = group_gz_xml_path if "updateinfo" in ftypes and not skip.has_key('errata') or skip['errata'] != 1: updateinfo_xml_path = pulp.server.util.get_repomd_filetype_path( repomd_xml_path, "updateinfo") updateinfo_xml_path = os.path.join(dir.encode("ascii", "ignore"), updateinfo_xml_path) log.info("updateinfo is found in repomd.xml, it's path is %s" % \ (updateinfo_xml_path)) added_errataids = self.sync_updateinfo_data(updateinfo_xml_path, repo) log.debug("Loaded updateinfo from %s for %s" % \ (updateinfo_xml_path, repo["id"])) else: log.info("Skipping errata imports from sync process") return added_packages, added_errataids
log.debug("%s" % (traceback.format_exc()))	log.error("%s" % (traceback.format_exc()))	def import_package(self, package, repo): try: retval = None file_name = package.relativepath hashtype = "sha256" checksum = package.checksum found = self.package_api.packages(name=package.name, epoch=package.epoch, version=package.version, release=package.release, arch=package.arch, filename=file_name, checksum_type=hashtype, checksum=checksum) if len(found) == 1: retval = found[0] else: retval = self.package_api.create(package.name, package.epoch, package.version, package.release, package.arch, package.description, hashtype, checksum, file_name) for dep in package.requires: retval.requires.append(dep[0]) for prov in package.provides: retval.provides.append(prov[0]) retval.download_url = config.config.get('server', 'base_url') + "/" + \ config.config.get('server', 'relative_url') + "/" + \ repo["id"] + "/" + file_name self.package_api.update(retval) return retval except Exception, e: log.error("error reading package %s" % (file_name)) log.debug("%s" % (traceback.format_exc()))
self.parser.add_option("--name", dest="name", help="Consumer group name")	self.parser.add_option("--id", dest="id", help="Consumer group id")	def generate_options(self):
self.options.label)	self.options.id)	def _delete(self): (self.options, self.args) = self.parser.parse_args() if not self.options.id: print("Group id required. Try --help") sys.exit(0) try: self.cgconn.delete(id=self.options.id) print _(" Successful deleted Consumer Group [ %s ] " % self.options.id) except RestlibException, re: print _(" Deleted operation failed Consumer Group [ %s ] " % \ self.options.label) log.error("Error: %s" % re) sys.exit(-1) except Exception, e: print _(" Deleted operation failed on Consumer Group [ %s ]. " % \ self.options.label) log.error("Error: %s" % e) sys.exit(-1)
repo_source.url)	repo_source['url'])	def sync(self, repo, repo_source): # Parse the repo source for necessary pieces # Expected format: <server>/<channel> pieces = repo_source['url'].split('/') if len(pieces) < 2: raise PulpException('Feed format for RHN type must be <server>/<channel>. Feed: %s', repo_source.url)
self.repo_api.create('repo-1', 'repo-1', 'i386', 'yum:localhost', '1 * * * ') self.repo_api.create('repo-2', 'repo-2', 'i386', 'yum:localhost', '2 * * *') self.repo_api.create('repo-3', 'repo-3', 'i386', 'yum:localhost', None)	self.repo_api.create('repo-1', 'repo-1', 'i386', 'yum:localhost', sync_schedule='1 * * * ') self.repo_api.create('repo-2', 'repo-2', 'i386', 'yum:localhost', sync_schedule='2 * * *') self.repo_api.create('repo-3', 'repo-3', 'i386', 'yum:localhost', sync_schedule=None)	def test_all_schedules(self): # Setup self.repo_api.create('repo-1', 'repo-1', 'i386', 'yum:localhost', '1 * * * ') self.repo_api.create('repo-2', 'repo-2', 'i386', 'yum:localhost', '2 * * *') self.repo_api.create('repo-3', 'repo-3', 'i386', 'yum:localhost', None) self.repo_api.create('repo-4', 'repo-4', 'i386', 'yum:localhost')
if now - task.start_time < self.timeout:	if task.start_time is None or now - task.start_time < self.timeout:	def _timeout_tasks(self): """ Stop tasks that have met or exceeded the queue's timeout length. """ if self.timeout is None: return running_tasks = self.__storage.running_tasks() if not running_tasks: return now = datetime.now() for task in running_tasks: if now - task.start_time < self.timeout: continue thread = self.__threads[task] thread.timeout() while task.state not in task_complete_states: time.sleep(self._default_sleep) task.timeout()