def searchAsync(self, callback, waypoints, route_params=None):
"""Search for a route given by a list of points asynchronously
:param waypoints: 2 or more waypoints for route search
-> the first point is the start, the last one is the destination
-> any point in between are regarded as waypoints the route has to go through
NOTE: not all providers might support waypoints
:type waypoints: list
:param route_params: further parameters for the route search
:type route_params: RouteParameters instance
:param controller: task controller
:returns: a list of routes (Way objects), None if search failed
:rtype: list
"""
# lambda is used to pass all needed arguments to the search function
# and passing the result to the callback,
# but not actually executing it until the thread is started
thread = threads.ModRanaThread(name=self._threadName)
thread.target = lambda: self.search(
waypoints=waypoints, route_params=route_params, controller=thread)
thread.callback = callback
# and yet, this really works :)
# - we need to set the target, and it seems this can only be done in init
# - passing the thread itself as controller seems to work or at least does
# not raise any outright exception
# register the thread by the thread manager
# (this also starts the thread)
threads.threadMgr.add(thread)
def shutdown(self,
now=False,
join=False,
asynchronous=True,
callback=None):
"""Shutdown the lifo thread pool"""
with self._shutdownLock:
if self._shutdown:
# shutdown already in progress or not running
return False
else:
self._shutdown = True
# after shutdown is set, all submit calls
# will throw RuntimeError, so there should be
# no danger shutdown requests will get mixed up with
# work requests (not that it mattered BTW, as long as
# nr shutdown requests >= nr of threads)
# if the queue is bounded, the shutdown function may block
# so run it in a thread by default, with the possibility of
# triggering a callback once it is done
if asynchronous:
call = lambda: self._shutdownWrapper(now, join, callback)
t = threads.ModRanaThread(name=self.name + "Shutdown", target=call)
threads.threadMgr.add(t)
else:
self._shutdownWrapper(now, join, callback)
return True
def searchAsync(self, callback, term=None, around=None, **kwargs):
"""Perform asynchronous search
:param callback: result handler
:type term: a callable
:param term: search term
:type term: str
:param around: optional location bias
:type around: Point instance
"""
# lambda is used to pass all needed arguments to the search function
# and passing the result to the callback,
# but not actually executing it until the thread is started
thread = threads.ModRanaThread(name=self._threadName)
thread.target = lambda: self.search(
term=term, around=around, controller=thread, **kwargs)
thread.callback = callback
# and yet, this really works :)
# - we need to set the target, and it seems this can only be done in init
# - passing the thread itself as controller seems to work or at least does
# not raise any outright exception
# register the thread by the thread manager
# (this also starts the thread)
threads.threadMgr.add(thread)
def make(self, text):
"""Queue `text` for WAV file generation."""
if self._engine is None:
return
self._update_cache()
if text in self._cache:
# WAV file already generated, just update
# file modification time to prevent removal.
if self._cache[text] is not None:
os.utime(self._cache[text])
return
if self._worker_thread is None:
self._result_queue = queue.Queue()
self._task_queue = queue.Queue()
self._worker_thread = threads.ModRanaThread(
name=constants.THREAD_VOICE_WORKER,
target=lambda: voice_worker(task_queue=self._task_queue,
result_queue=self._result_queue,
engine=self._engine,
tmpdir=self._tmpdir),
daemon=True)
threads.threadMgr.add(self._worker_thread)
# Add an empty element into cache to ensure that we don't
# run the same voice direction twice through the engine.
self._cache[text] = None
self._task_queue.put(text)
self._clean_outdated_cache()
def _start(self):
"""Start the thread pool"""
for index in range(1, self._maxThreads + 1):
threadName = "%sWorker%d" % (self.name, index)
thread = threads.ModRanaThread(name=threadName,
target=self._worker)
# save the thread ID
self._workers.append(threads.threadMgr.add(thread))
def _start_tbt_worker(self):
with self._tbt_worker_lock:
# reuse previous thread or start new one
if self._tbt_worker_enabled:
self.log.info("reusing TBT worker thread")
else:
self.log.info("starting new TBT worker thread")
t = threads.ModRanaThread(name=constants.THREAD_TBT_WORKER,
target=self._tbt_worker)
threads.threadMgr.add(t)
self._tbt_worker_enabled = True
def _startTileLoadingThread(self):
"""Start the sqlite loading thread"""
t = threads.ModRanaThread(target=self._tileLoader,
name=constants.THREAD_TILE_STORAGE_LOADER)
# we need that the worker tidies up,
# (commits all "dirty" connections)
# so it should be not daemonic
# -> but we also cant afford that modRana wont
# terminate completely
# (all ModRanaThreads are daemonic by default)
threads.threadMgr.add(t)
def start(self, startMainLoop=False):
"""start the GPSD based location update method"""
self.connected = False
try:
self.GPSDConsumer = GPSDConsumer()
t = threads.ModRanaThread(name=constants.THREAD_GPSD_CONSUMER,
target=self.GPSDConsumer._start)
threads.threadMgr.add(t)
self.connected = True
self.setGPSDDebug(
self.debug) # check if verbose debugging is enabled
except Exception:
log.exception("connecting to GPSD failed")
self.status = "No GPSD running"
def startBatch(self, batch, **kwargs):
"""Process a batch"""
with self._mutex:
if self._running:
log.debug("can't start another batch - already running")
else:
self._running = True
self._batch = batch
self._pool = ThreadPool(name=self.name,
maxThreads=self._maxThreads())
# start the loading thread
t = threads.ModRanaThread(name=self.name+"Loader", target=self._loadItems)
self._loaderName = threads.threadMgr.add(t)
def _startTileLoadingManager(self):
"""Start the consumer thread for download requests"""
t = threads.ModRanaThread(name=constants.THREAD_TILE_DOWNLOAD_MANAGER,
target = self._tileLoadingManager)
threads.threadMgr.add(t)
# shutdown already in progress or not running
return False
else:
self._shutdown = True
# after shutdown is set, all submit calls
# will throw RuntimeError, so there should be
# no danger shutdown requests will get mixed up with
# work requests (not that it mattered BTW, as long as
# nr shutdown requests >= nr of threads)
# if the queue is bounded, the shutdown function may block
# so run it in a thread by default, with the possibility of
# triggering a callback once it is done
if async:
call = lambda : self._shutdownWrapper(now, join, callback)
t = threads.ModRanaThread(name=self.name+"Shutdown",
target=call)
threads.threadMgr.add(t)
else:
self._shutdownWrapper(now, join, callback)
return True
def _shutdownWrapper(self, now, join, callback):
self._shutdownHandler(now, join)
# is there a callback for when we are done ?
if callback:
# call it !
callback()
def _shutdownHandler(self, now, join):