Пример #1
0
class Task(object):
    def __init__(self, request):
        self._request = request
        self._cond = QWaitCondition()

    def getRequest(self):
        return self._request

    def waitForResponse(self):
        self._cond.wait(QMutex())
        x = self._response
        del self._response
        return x

    def addResponse(self, response):
        # Don't allow two responses to the same
        # request. Could possibly happen
        # if someone clicks accept/reject and simultaneously
        # closes the window, somehow, triggering
        # the closeEvent
        if self._cond:
            self._response = response
            self._cond.wakeAll()
            self._cond = None

    def setType(self, dialogType):
        """ Set what type of task this is. The dialogtype is 
        the construtor for the Dialog that is to be invoked, 
        when onSystrayActivated is invoked later on"""

        self.dialogType = dialogType

    def getType(self):
        return self.dialogType
Пример #2
0
 def __init__(self, ListView, ListModel):
   QThread.__init__(self)  
   self.mutex = QMutex()
   self.condition = QWaitCondition()
   self.ListView = ListView	
   self.ListModel = ListModel
   self.restart = False
   self.abort = False	
Пример #3
0
 def __init__(self, searcher, parent):
     QThread.__init__(self, parent)
     self._searcher = searcher
     self._quit = False
     self._mutex = QMutex()
     self._pending = QWaitCondition()
     self._collector = None
     self._query = None
     self._result = None
Пример #4
0
 def __init__(self, parent = None):
   super(WorkerThread, self).__init__(parent)
   self.mutex = QMutex()
   self.condition = QWaitCondition()
   self.restart = False
   self.abort = False
   self.timeline = parent
   self.countThread = parent.countThread
   self.populateThread = parent.populateThread
   self.maxOccThread = parent.maxOccThread
Пример #5
0
    def __init__( self, plugin, parent = None ):
        QThread.__init__( self, parent )

        self.__plugin = plugin
        self.__requestQueue = deque()

        self.__stopRequest = False
        self.__lock = QMutex()
        self.__condition = QWaitCondition()
        return
Пример #6
0
    def __init__(self, maxsize=0):
        self.maxsize = maxsize
        self.queue = deque()

        # Mutex using for accessing the deque
        self.mutex = QMutex()

        # Condition that will be held when the queue is empty and the consumer
        # needs to wait for a new item
        self.item_added = QWaitCondition()
        # Condition that will be held when the queue is full and the producer
        # needs to wait for a new place to insert the item
        self.item_removed = QWaitCondition()
Пример #7
0
class VCSPluginThread( QThread ):
    " Wrapper for the plugin thread "

    def __init__( self, plugin, parent = None ):
        QThread.__init__( self, parent )

        self.__plugin = plugin
        self.__requestQueue = deque()

        self.__stopRequest = False
        self.__lock = QMutex()
        self.__condition = QWaitCondition()
        return

    def run( self ):
        " Thread loop "
        while not self.__stopRequest:
            self.__lock.lock()
            while self.__requestQueue:
                path, flag = self.__requestQueue.pop()
                self.__lock.unlock()
                time.sleep( 0.01 )
                self.__processRequest( path, flag )
                if self.__stopRequest:
                    break
                self.__lock.lock()
            if self.__stopRequest:
                self.__lock.unlock()
                break
            self.__condition.wait( self.__lock )
            self.__lock.unlock()
        return

    def __processRequest( self, path, flag ):
        " Processes a single request. It must be exception safe. "
        try:
            statuses = self.__plugin.getObject().getStatus( path, flag )
            for status in statuses:
                if len( status ) == 3:
                    self.emit( SIGNAL( "VCSStatus" ), path + status[ 0 ],
                               status[ 1 ], status[ 2 ] )
                else:
                    self.emit( SIGNAL( "VCSStatus" ), path, IND_VCS_ERROR,
                               "The " + self.__plugin.getName() + " plugin "
                               "does not follow the getStatus() interface "
                               "agreement" )
        except Exception, exc:
            self.emit( SIGNAL( "VCSStatus" ), path, IND_VCS_ERROR,
                       "Exception in " + self.__plugin.getName() +
                       " plugin while retrieving VCS status: " + str( exc ) )
        except:
Пример #8
0
 def __init__(self, interval, projectDir, vcs, parent = None):
     """
     Constructor
     
     @param interval new interval in seconds (integer)
     @param projectDir project directory to monitor (string or QString)
     @param vcs reference to the version control object
     @param parent reference to the parent object (QObject)
     """
     QThread.__init__(self, parent)
     self.setObjectName("VcsStatusMonitorThread")
     
     self.setTerminationEnabled(True)
     
     self.projectDir = QString(projectDir)
     self.vcs = vcs
     
     self.interval = interval
     self.autoUpdate = False
     
     self.statusList = QStringList()
     self.reportedStates = {}
     self.shouldUpdate = False
     
     self.monitorMutex = QMutex()
     self.monitorCondition = QWaitCondition()
     self.__stopIt = False
Пример #9
0
 def __init__(self, searcher, parent):
     QThread.__init__(self, parent)
     self._searcher = searcher
     self._quit = False
     self._mutex = QMutex()
     self._pending = QWaitCondition()
     self._collector = None
     self._query = None
     self._result = None
Пример #10
0
    def __init__(self, parent=None):
        super().__init__()

        self.laberinto = Laberinto(parent=self)
        self.mutex = QMutex()
        self.waitWorker = QWaitCondition()
        self.waitController = QWaitCondition()

        self.parent = parent
        self.running = True
        self.solving = False
        self.timer = QTimer()
        self.delay = 20

        self.timer.timeout.connect(self.continue_)
        self.laberintoTerminado.connect(self.handleLaberintoTerminado)

        self.start()
Пример #11
0
    def __init__(self, parent):
        QThread.__init__(self, parent)

        self.classObjectLock = QMutex(QMutex.Recursive)
        self.classParamDict = {}
        self.classInstanceDict = {}

        self.queueLock = QMutex(QMutex.Recursive)
        self.queueHasJobsLock = QMutex()      # lock lighter than queueLock
                                              #   while waiting for this lock no
                                              #   lock on the latter can be hold
        self.queueHasJobsCondition = QWaitCondition()
        self.renderQueue = []                 # contains all render requests
        self.newestId = 0                     # newest job Id

        self.renderingLock = QMutex(QMutex.Recursive)
        self.renderingFinishedLock = QMutex() # lock lighter than renderingLock
                                              #   while waiting for this lock no
                                              #   lock on the latter can be hold
        self.renderingFinishedCondition = QWaitCondition()
        self.currentlyRenderingJob = None
Пример #12
0
class SignalThread(QThread):
    def __init__(self, parent=None):
        QThread.__init__(self, parent)

        self.waitcond = QWaitCondition()
        self.mutex = QMutex()
        self.isstopped = False

    def trigger(self):
        """lock first to make sure the QThread is actually waiting for a signal"""
        self.mutex.lock()
        self.waitcond.wakeOne()
        self.mutex.unlock()

    def stopThread(self):
        self.mutex.lock()
        self.isstopped = True
        self.waitcond.wakeOne()
        self.mutex.unlock()

    def run(self):
        self.mutex.lock()
        while not self.isstopped:
            # just wait, and trigger every time we receive a signal
            self.waitcond.wait(self.mutex)
            if not self.isstopped:
                self.emit(SIGNAL("triggerSignal()"))
        self.mutex.unlock()
Пример #13
0
class SignalThread(QThread):
    def __init__(self, parent = None):
        QThread.__init__(self, parent)

        self.waitcond = QWaitCondition()
        self.mutex = QMutex()
        self.isstopped = False

    def trigger(self):
        """lock first to make sure the QThread is actually waiting for a signal"""
        self.mutex.lock()
        self.waitcond.wakeOne()
        self.mutex.unlock()

    def stopThread(self):
        self.mutex.lock()
        self.isstopped = True
        self.waitcond.wakeOne()
        self.mutex.unlock()

    def run(self):
        self.mutex.lock()
        while not self.isstopped:
            # just wait, and trigger every time we receive a signal
            self.waitcond.wait(self.mutex)
            if not self.isstopped:
                self.emit(SIGNAL("triggerSignal()"))
        self.mutex.unlock()
Пример #14
0
 def __init__(self, suite, items, stopOnError, stopOnFail, xmlRPCUrl):
     QThread.__init__(self)
     self.suite = suite
     self.items = items
     executionDelay = self.suite.sliderSpeed.value() / 1000 # convert to seconds
     self.sync = QMutex()
     self.pauseCond = QWaitCondition()
     self.executionPaused = False  
     self.autoPlayer = AutoPlayer(executionDelay, self.sync, self.pauseCond, xmlRPCUrl)
     self.executionStopped = False         
     self.stopOnError = stopOnError
     self.stopOnFail = stopOnFail
     self._connectSignals()
Пример #15
0
class VcsStatusMonitorThread(QThread):
    """
    Class implementing the VCS status monitor thread base class.
    
    @signal vcsStatusMonitorData(QStringList) emitted to update the VCS status
    @signal vcsStatusMonitorStatus(QString, QString) emitted to signal the status of the
        monitoring thread (ok, nok, op) and a status message
    """
    def __init__(self, interval, projectDir, vcs, parent = None):
        """
        Constructor
        
        @param interval new interval in seconds (integer)
        @param projectDir project directory to monitor (string or QString)
        @param vcs reference to the version control object
        @param parent reference to the parent object (QObject)
        """
        QThread.__init__(self, parent)
        self.setObjectName("VcsStatusMonitorThread")
        
        self.setTerminationEnabled(True)
        
        self.projectDir = QString(projectDir)
        self.vcs = vcs
        
        self.interval = interval
        self.autoUpdate = False
        
        self.statusList = QStringList()
        self.reportedStates = {}
        self.shouldUpdate = False
        
        self.monitorMutex = QMutex()
        self.monitorCondition = QWaitCondition()
        self.__stopIt = False
    
    def run(self):
        """
        Protected method implementing the tasks action.
        """
        while not self.__stopIt:
            # perform the checking task
            self.statusList.clear()
            self.emit(SIGNAL("vcsStatusMonitorStatus(QString, QString)"), 
                      QString("wait"), self.trUtf8("Waiting for lock"))
            try:
                locked = self.vcs.vcsExecutionMutex.tryLock(5000)
            except TypeError:
                locked = self.vcs.vcsExecutionMutex.tryLock()
            if locked:
                try:
                    self.emit(SIGNAL("vcsStatusMonitorStatus(QString, QString)"), 
                              QString("op"), self.trUtf8("Checking repository status"))
                    res, statusMsg = self._performMonitor()
                finally:
                    self.vcs.vcsExecutionMutex.unlock()
                if res:
                    status = QString("ok")
                else:
                    status = QString("nok")
                self.emit(SIGNAL("vcsStatusMonitorStatus(QString, QString)"), 
                          QString("send"), self.trUtf8("Sending data"))
                self.emit(SIGNAL("vcsStatusMonitorData(QStringList)"), 
                          QStringList(self.statusList))
                self.emit(SIGNAL("vcsStatusMonitorStatus(QString, QString)"), 
                          status, statusMsg)
            else:
                self.emit(SIGNAL("vcsStatusMonitorStatus(QString, QString)"), 
                          QString("timeout"), self.trUtf8("Timed out waiting for lock"))
            
            if self.autoUpdate and self.shouldUpdate:
                try:
                    self.vcs.vcsUpdate(self.projectDir, True)
                    continue    # check again
                except TypeError:
                    pass    # compatibility for older VCS plugins
                self.shouldUpdate = False
            
            # wait until interval has expired checking for a stop condition
            self.monitorMutex.lock()
            if not self.__stopIt:
                self.monitorCondition.wait(self.monitorMutex, self.interval * 1000)
            self.monitorMutex.unlock()
        
        self.exit()
    
    def setInterval(self, interval):
        """
        Public method to change the monitor interval.
        
        @param interval new interval in seconds (integer)
        """
        locked = self.monitorMutex.tryLock()
        self.interval = interval
        self.monitorCondition.wakeAll()
        if locked:
            self.monitorMutex.unlock()
    
    def getInterval(self):
        """
        Public method to get the monitor interval.
        
        @return interval in seconds (integer)
        """
        return self.interval
    
    def setAutoUpdate(self, auto):
        """
        Public method to enable the auto update function.
        
        @param auto status of the auto update function (boolean)
        """
        self.autoUpdate = auto
    
    def getAutoUpdate(self):
        """
        Public method to retrieve the status of the auto update function.
        
        @return status of the auto update function (boolean)
        """
        return self.autoUpdate
    
    def checkStatus(self):
        """
        Public method to wake up the status monitor thread.
        """
        locked = self.monitorMutex.tryLock()
        self.monitorCondition.wakeAll()
        if locked:
            self.monitorMutex.unlock()
    
    def stop(self):
        """
        Public method to stop the monitor thread.
        """
        locked = self.monitorMutex.tryLock()
        self.__stopIt = True
        self.monitorCondition.wakeAll()
        if locked:
            self.monitorMutex.unlock()

    def clearCachedState(self, name):
        """
        Public method to clear the cached VCS state of a file/directory.
        
        @param name name of the entry to be cleared (QString or string)
        """
        project = e4App().getObject("Project")
        key = project.getRelativePath(unicode(name))
        try:
            del self.reportedStates[key]
        except KeyError:
            pass

    def _performMonitor(self):
        """
        Protected method implementing the real monitoring action.
        
        This method must be overridden and populate the statusList member variable
        with a list of strings giving the status in the first column and the
        path relative to the project directory starting with the third column.
        The allowed status flags are:
        <ul>
            <li>"A" path was added but not yet comitted</li>
            <li>"M" path has local changes</li>
            <li>"O" path was removed</li>
            <li>"R" path was deleted and then re-added</li>
            <li>"U" path needs an update</li>
            <li>"Z" path contains a conflict</li>
            <li>" " path is back at normal</li>
        </ul>
        
        @return tuple of flag indicating successful operation (boolean) and 
            a status message in case of non successful operation (QString)
        """
        raise RuntimeError('Not implemented')
Пример #16
0
import urllib
from bs4 import BeautifulSoup
import os
from PyQt4.QtCore import (QThread, QDir, QMutex, QWaitCondition, QSettings, QVariant, QStringList)
from PyQt4.QtGui import (QMainWindow, QMessageBox, QImage, QPixmap, QKeySequence, QDialog, QDialogButtonBox, QAction)
import datetime
from Gui import MangaDownloader, Dialog_Settings
from PyQt4.QtCore import pyqtSignal as Signal
import resource
import tempfile
import zipfile
import re

# Elements for waiting user confirmation for overriding file
waitCondition = QWaitCondition()
mutex = QMutex()

class MainWindow(QMainWindow, MangaDownloader.Ui_MainWindow):
    def __init__(self, parent=None):
        super(MainWindow, self).__init__(parent)
        self.setupUi(self)
        # self.mutex = QMutex()
        self.settings_dict = dict(recent=5, save_dir=QDir.homePath(), close_confirmation=True,
                              display_image=True, list_recent=[])
        self.pushbutton_stop.setEnabled(False)
        self.edit_url.setFocus()
        self.image = QImage()
        self.pushbutton_start.clicked.connect(self.startDownload)

        self.action_Quit.setShortcut(QKeySequence.Quit)
        self.action_Quit.triggered.connect(self.close)
Пример #17
0
 def __init__(self, request):
     self._request = request
     self._cond = QWaitCondition()
Пример #18
0
class LaberintoThread(QThread):
    laberintoTerminado = pyqtSignal(bool)

    def __init__(self, parent=None):
        super().__init__()

        self.laberinto = Laberinto(parent=self)
        self.mutex = QMutex()
        self.waitWorker = QWaitCondition()
        self.waitController = QWaitCondition()

        self.parent = parent
        self.running = True
        self.solving = False
        self.timer = QTimer()
        self.delay = 20

        self.timer.timeout.connect(self.continue_)
        self.laberintoTerminado.connect(self.handleLaberintoTerminado)

        self.start()

    def __del__(self):
        self.running = False
        self.waitWorker.wakeOne()
        self.wait()

    ##### interfaz que sobreescribo (métodos públicos)

    def tamano(self, *args):
        return self.laberinto.tamano(*args)

    def cargar(self, *args):
        self.laberinto.cargar(*args)

    def resolver(self):
        self.mutex.lock()
        if not self.solving:
            self.waitWorker.wakeOne()
        self.mutex.unlock()

    def resetear(self, *args):
        return self.laberinto.resetear(*args)

    def esPosicionRata(self, *args):
        return self.laberinto.esPosicionRata(*args)

    def esPosicionQueso(self, *args):
        return self.laberinto.esPosicionQueso(*args)

    def get(self, *args):
        return self.laberinto.get(*args)

    def getInfoCelda(self, *args):
        return self.laberinto.getInfoCelda(*args)

    def getPosicionRata(self, *args):
        return self.laberinto.getPosicionRata(*args)

    def getPosicionQueso(self, *args):
        return self.laberinto.getPosicionQueso(*args)

    def setPosicionRata(self, *args):
        return self.laberinto.setPosicionRata(*args)

    def setPosicionQueso(self, *args):
        return self.laberinto.setPosicionQueso(*args)

    ##### intefaz nueva

    def update(self):
        self.mutex.unlock()
        self.parent.update()
        self.mutex.lock()
        self.timer.stop()
        self.timer.start(self.delay)
        self.waitController.wait(self.mutex)

    def continue_(self):
        self.mutex.lock()
        self.timer.stop()
        self.waitController.wakeOne()
        self.mutex.unlock()

    def setAnimationDelay(self, delay):
        self.mutex.lock()
        self.delay = delay
        self.mutex.unlock()

    def handleLaberintoTerminado(self, e):
        if e:
            self.parent.laberintoResuelto()
        else:
            self.parent.laberintoIncompleto()

    def lock(self):
        self.mutex.lock()

    def unlock(self):
        self.mutex.unlock()

    ##### main del thread

    def run(self):
        while self.running:
            self.mutex.lock()
            self.waitWorker.wait(self.mutex)
            if self.running:
                self.solving = True
                self.res = self.laberinto.resolver()
                self.laberintoTerminado.emit(self.res)
                self.solving = False
            self.mutex.unlock()
Пример #19
0
class _FTSearchThread(QThread):
    '''This thread performs full text search in the background'''

    searchFinished = pyqtSignal()
    searchError = pyqtSignal()

    def __init__(self, searcher, parent):
        QThread.__init__(self, parent)
        self._searcher = searcher
        self._quit = False
        self._mutex = QMutex()
        self._pending = QWaitCondition()
        self._collector = None
        self._query = None
        self._result = None

    def run(self):
        while not self._quit:
            self._mutex.lock()
            if not self._query:
                self._pending.wait(self._mutex)
            query = self._query
            self._query = None
            self._mutex.unlock()

            # search
            if query:
                (query_str1, query_str2, itemtypes,
                 limit, highlight, merge) = query

                self._mutex.lock()
                collector = self._searcher.make_collector(limit)
                self._collector = collector
                self._mutex.unlock()

                try:
                    result = self._searcher.search(
                        collector,
                        query_str1, query_str2,
                        itemtypes, highlight)
                except:
                    self._mutex.lock()
                    self._result = None
                    self._mutex.unlock()
                    self.searchError.emit()
                else:
                    if collector.aborted:
                        pass
                    else:
                        self._mutex.lock()
                        self._result = (merge, result)
                        self._mutex.unlock()
                        self.searchFinished.emit()

                self._mutex.lock()
                self._collector = None
                self._mutex.unlock()

    def cancel(self):
        self._mutex.lock()
        self._query = None
        if self._collector:
            self._collector.abort()
        self._mutex.unlock()

    def quit(self):
        self._mutex.lock()
        if self._collector:
            self._collector.abort()
        self._query = None
        self._quit = True
        self._mutex.unlock()
        self._pending.wakeAll()

    def update_query(self, query_str1=None, query_str2=None, itemtypes=(),
                     limit=1000, highlight=False, merge=False):
        self._mutex.lock()
        if self._collector:
            self._collector.abort()
        self._query = (query_str1, query_str2,
                       itemtypes, limit, highlight, merge)
        self._mutex.unlock()
        self._pending.wakeAll()

    def take_result(self):
        self._mutex.lock()
        r = self._result
        self._result = None
        self._mutex.unlock()
        return r
Пример #20
0
class WorkerThread(QThread):
  ''' Schedule things to do

  Wait all time or launch/wake other threads to recompute max amount of node to
  display with or without zoom, refresh/redraw paint area, etc. .
  '''
  def __init__(self, parent = None):
    super(WorkerThread, self).__init__(parent)
    self.mutex = QMutex()
    self.condition = QWaitCondition()
    self.restart = False
    self.abort = False
    self.timeline = parent
    self.countThread = parent.countThread
    self.populateThread = parent.populateThread
    self.maxOccThread = parent.maxOccThread
    
  def __del__(self):
    self.mutex.lock()
    self.abort = True
    self.condition.wakeOne()
    self.mutex.unlock()

    self.wait()

  def render(self):
    locker = QMutexLocker(self.mutex)
    if not self.isRunning() and not self.countThread.isRunning() and not self.populateThread.isRunning() and not self.maxOccThread.isRunning():
      self.start(QThread.LowPriority)
    else:
      self.restart = True
      self.condition.wakeOne()
      
  def run(self):
    while True:
      self.mutex.lock()
      # Fetch value from timeline
      nodeCount = self.timeline.nodeCount
      dataListsCreated = self.timeline.dataListsCreated
      if dataListsCreated:
        self.timeline.findMaxValue()
      xHop = self.timeline.xHop
      maxOcc = self.timeline.maxOcc
      self.mutex.unlock()

      if not nodeCount and not self.restart and not self.countThread.isRunning():
        self.countThread.start()
      elif nodeCount and not dataListsCreated and not self.restart and not self.populateThread.isRunning():
        self.populateThread.start()
      elif nodeCount and dataListsCreated and xHop and not maxOcc and not self.restart and not self.maxOccThread.isRunning():
        self.maxOccThread.start()
      elif nodeCount and dataListsCreated and xHop and maxOcc and not self.restart and not self.maxOccThread.isRunning():
        self.emit(SIGNAL('refresh'), True)
        
      if self.abort:
        return

      self.mutex.lock()
      if not self.restart:
        self.condition.wait(self.mutex)
      self.restart = False
      self.mutex.unlock()
Пример #21
0
class Queue(object):
    """Create a queue object with a given maximum size.

    """
    def __init__(self, maxsize=0):
        self.maxsize = maxsize
        self.queue = deque()

        # Mutex using for accessing the deque
        self.mutex = QMutex()

        # Condition that will be held when the queue is empty and the consumer
        # needs to wait for a new item
        self.item_added = QWaitCondition()
        # Condition that will be held when the queue is full and the producer
        # needs to wait for a new place to insert the item
        self.item_removed = QWaitCondition()

    def put(self, item, block=True, timeout=None):
        """Put an item into the queue.

        Parameters
        ----------
        block : bool
            If True(default), the caller thread will block until the queue has
            a free space available for putting an new item. If False, the `Full`
            exception will be raised if there is no free space in the queue

        timeout : int
            The max time to wait for a new space to be avaible, in milliseconds.

        """
        self.mutex.lock()
        try:
            # Check if the queue has a limit (0 means not)
            if self.maxsize > 0:
                # Raise Full if block is False and the queue is at max cap.
                if not block:
                    if self._qsize() == self.maxsize:
                        raise Full
                # If a timeout is not provided, wait indefinitely
                elif timeout is None:
                    while self._qsize() == self.maxsize:
                        self.item_removed.wait(self.mutex)
                elif timeout < 0:
                    raise ValueError("'timeout' must be a non-negative number")
                else:
                    timer = QElapsedTimer()
                    timer.start()
                    while self._qsize() == self.maxsize:
                        remaining = timeout - timer.elapsed()
                        if remaining <= 0.0:
                            raise Full
                        self.item_removed.wait(self.mutex, remaining)
            self._put(item)
            self.item_added.wakeOne()
        finally:
            self.mutex.unlock()

    def get(self, block=True, timeout=None):
        """Remove and return an item from the queue.

        Parameters
        ----------
        block : bool
            If True(default), the caller thread will block until the queue has
            an item available for putting an new item. If False, the `Empty`
            exception will be raised if there is no item in the queue

        timeout : int
            The max time to wait for a new item to be avaible, in milliseconds.

        """
        self.mutex.lock()
        try:
            if not block:
                if not self._qsize():
                    raise Empty
            elif timeout is None:
                while not self._qsize():
                    self.item_added.wait(self.mutex)
            elif timeout < 0:
                raise ValueError("'timeout' must be a non-negative number")
            else:
                timer = QElapsedTimer()
                timer.start()
                while not self._qsize():
                    remaining = timeout - timer.elapsed()
                    if remaining <= 0.0:
                        raise Empty
                    self.item_added.wait(self.mutex, remaining)
            item = self._get()
            self.item_removed.wakeOne()
            return item
        finally:
            self.mutex.unlock()

    def _qsize(self, len=len):
        return len(self.queue)

    # Put a new item in the queue
    def _put(self, item):
        self.queue.append(item)

    # Get an item from the queue
    def _get(self):
        return self.queue.popleft()

    def _clear(self):
        self.queue.clear()
Пример #22
0
class ListThread(QThread):
  def __init__(self, ListView, ListModel):
    QThread.__init__(self)  
    self.mutex = QMutex()
    self.condition = QWaitCondition()
    self.ListView = ListView	
    self.ListModel = ListModel
    self.restart = False
    self.abort = False	

  def __del__(self):
    self.mutex.lock()
    self.abort = True
    self.condition.wakeOne()
    self.mutex.unlock()
    self.wait()				

  def renderList(self, list, nodeParent):
    locker = QMutexLocker(self.mutex)	
    self.list = list 
    self.nodeParent = nodeParent
    if not self.isRunning():
	self.start(QThread.LowPriority)
    else:
        self.restart = True
        self.condition.wakeOne()
 
  def run(self):
     while(True):
       self.mutex.lock()
       self.currentNodeDir = self.nodeParent
       list = self.list
       self.mutex.unlock()

       for itemVFS in list:
       	    items = []
	    if self.restart:
		break
	    if self.abort:
		return 

            items.append(NodeItem(itemVFS))
            items[0].setText(QApplication.translate("MainWindow", str(itemVFS.name), None, QApplication.UnicodeUTF8))
            if not itemVFS.next.empty() or not itemVFS.is_file:
#XXX
                if not itemVFS.is_file :
                    icon = ":folder.png"
                else :
                    icon = ":folder.png"
#                    items[0].setIcon(QIcon(":dff_partition.png"))
            else :
                    icon = ":file.png"
            items.append(QStandardItem())
            if itemVFS.is_file == 0 :
                items[1].setText(QApplication.translate("ListModel", "", None, QApplication.UnicodeUTF8))
            else :
                items[1].setText(DFF_Utils.formatSize(itemVFS.attr.size))
            items.append(QStandardItem(""))
            items.append(QStandardItem(""))
            items.append(QStandardItem(""))
            items.append(QStandardItem(""))
            time = itemVFS.attr.time
            for i in time :
                items[self.ListModel.timeHeader[str(i)]].setText(str(time[i].get_time()))
	    items[5].setText(itemVFS.fsobj.name)           
	    
            for i in range(0, 6):
              items[i].setEditable(False)
              items[i].setCheckable(False)
            
            self.emit(SIGNAL("addItem"), items, icon)
	    sleep(0.001)

       if not self.restart:
          self.emit(SIGNAL("resizeList"))

       self.mutex.lock()

       if not self.restart:
          self.condition.wait(self.mutex)

       self.restart = False
       self.mutex.unlock()		
Пример #23
0
class RenderThread(QThread):
    """
    Thread object that takes control over an actual object exposing thoses
    methods with immediate return with delayed responses.
    """
    def __init__(self, parent):
        QThread.__init__(self, parent)

        self.classObjectLock = QMutex(QMutex.Recursive)
        self.classParamDict = {}
        self.classInstanceDict = {}

        self.queueLock = QMutex(QMutex.Recursive)
        self.queueHasJobsLock = QMutex()      # lock lighter than queueLock
                                              #   while waiting for this lock no
                                              #   lock on the latter can be hold
        self.queueHasJobsCondition = QWaitCondition()
        self.renderQueue = []                 # contains all render requests
        self.newestId = 0                     # newest job Id

        self.renderingLock = QMutex(QMutex.Recursive)
        self.renderingFinishedLock = QMutex() # lock lighter than renderingLock
                                              #   while waiting for this lock no
                                              #   lock on the latter can be hold
        self.renderingFinishedCondition = QWaitCondition()
        self.currentlyRenderingJob = None

    def quit(self):
        self.dequeueAll()

        while self.classInstanceDict:
            classObject = self.classInstanceDict.keys()[0]
            self.removeObject(classObject)

        # enqueue meta command
        self.enqueue(None, 'quit')
        self.wait()

    def setObject(self, classObject, *args, **param):
        """Add or reset a class handled by this render thread."""
        if not self.isRunning():
            raise Exception(
                "Thread needs to be running before objects can be created.")

        self.classObjectLock.lock()
        if classObject in self.classParamDict:
            # TODO remove, or change reloadObject()
            #if self.classParamDict[classObject] == (args, param):
                #self.classObjectLock.unlock()
                ## no changes done
                #return

            self.removeObject(classObject)

        self.classParamDict[classObject] = (args, param)
        self.classInstanceDict[classObject] = None

        self.enqueueWait(classObject, '__init__', *args, **param)
        #self.enqueue(classObject, '__init__', *args, **param)

        ## return only once object is created
        #self.renderingFinishedLock.lock()
        #while not self.classInstanceDict[classObject]:
            #self.renderingFinishedCondition.wait(self.renderingFinishedLock)
        #self.renderingFinishedLock.unlock()
        #self.classObjectLock.unlock()

    def reloadObject(self, classObject):
        """Reloads a class object."""
        self.classObjectLock.lock()
        if classObject not in self.classParamDict:
            self.classObjectLock.unlock()
            raise Exception("Object not set")

        args, param = self.classParamDict[classObject]
        self.setObject(classObject, *args, **param)
        self.classObjectLock.unlock()

    def hasObject(self, classObject):
        """returns the object's instance created by the thread."""
        QMutexLocker(self.classObjectLock)
        return classObject in self.classInstanceDict

    def getObjectInstance(self, classObject):
        """returns the object's instance created by the thread."""
        QMutexLocker(self.classObjectLock)
        return self.classInstanceDict[classObject]

    def removeObject(self, classObject):
        """
        Removes the given object's instance from the render thread, removing all
        affiliated jobs from the queue and canceling an eventually current
        rendered method.
        """
        self.classObjectLock.lock()
        self.queueHasJobsLock.lock()
        self.queueLock.lock()
        # clear all not yet rendered content from the queue
        newQueue = []
        for entry in self.renderQueue:
            jobId, entryClassObject, _, _, _ = entry
            if classObject != entryClassObject:
                newQueue.append(entry)
            else:
                self.emit(SIGNAL("jobDequeued"), jobId)

        self.renderQueue = newQueue

        # interrupt currently rendering
        self.renderingLock.lock()
        if self.currentlyRenderingJob:
            _, entryClassObject, _, _, _ = self.currentlyRenderingJob
            if classObject == entryClassObject:
                self.cancelCurrentJob()
        self.renderingLock.unlock()

        del self.classParamDict[classObject]
        del self.classInstanceDict[classObject]

        self.queueHasJobsLock.unlock()
        self.queueLock.unlock()
        self.classObjectLock.unlock()

    def enqueue(self, classObject, method, *args, **param):
        self.classObjectLock.lock()
        if classObject and classObject not in self.classParamDict:
            self.classObjectLock.unlock()
            raise Exception("Object not set")

        self.queueHasJobsLock.lock()
        self.queueLock.lock()

        self.newestId = (self.newestId + 1) % sys.maxint

        jobId = self.newestId
        self.renderQueue.append((jobId, classObject, method, args, param))

        self.queueLock.unlock()

        self.queueHasJobsCondition.wakeAll()
        self.queueHasJobsLock.unlock()
        self.classObjectLock.unlock()

        if classObject:
            self.emit(SIGNAL("jobEnqueued"), jobId)
            return jobId

    def enqueueWait(self, classObject, method, *args, **param):
        """Enqueues a job and waits until it finishes."""
        def inQueue(jobId):
            QMutexLocker(self.queueLock)
            for qjobId, _, _, _, _ in self.renderQueue:
                if jobId == qjobId:
                    return True

            QMutexLocker(self.renderingLock)
            if self.currentlyRenderingJob:
                qjobId, _, _, _, _ = self.currentlyRenderingJob
                if jobId == qjobId:
                    return True
            return False

        jobId = self.enqueue(classObject, method, *args, **param)
        if jobId == None:
            return

        # return only once method has finished
        self.renderingFinishedLock.lock()
        while inQueue(jobId):
            self.renderingFinishedCondition.wait(self.renderingFinishedLock)
        self.renderingFinishedLock.unlock()
        return jobId

    def getJobEntry(self, jobId):
        self.queueLock.lock()
        for idx, entry in enumerate(self.renderQueue):
            entryJobId, _, _, _, _ = entry
            if entryJobId == jobId:
                break
        else:
            entryJobId = None

        self.queueLock.unlock()
        return entryJobId

    def dequeue(self, jobId):
        QMutexLocker(self.queueHasJobsLock)
        QMutexLocker(self.queueLock)
        # search for entry
        jobEntry = self.getJobEntry(jobId)
        if jobEntry:
            idx = self.renderQueue.index(jobEntry)
            del self.renderQueue[idx]
            self.emit(SIGNAL("jobDequeued"), jobId)

            return True
        else:
            # interrupt currently rendering
            QMutexLocker(self.renderingLock)
            if self.currentlyRenderingJob:
                entryJobId, _, _, _, _ = self.currentlyRenderingJob
                if entryJobId == jobId:
                    self.cancelCurrentJob()
                    return True

            return False

    def dequeueMethod(self, classObject, method):
        self.queueHasJobsLock.lock()
        self.queueLock.lock()
        # clear all not yet rendered content from the queue
        newQueue = []

        for entry in self.renderQueue:
            jobId, entryClassObject, entryMethod, _, _ = entry
            if classObject != entryClassObject or method != entryMethod:
                newQueue.append(entry)
            else:
                self.emit(SIGNAL("jobDequeued"), jobId)

        self.renderQueue = newQueue

        # interrupt currently rendering
        self.renderingLock.lock()
        if self.currentlyRenderingJob:
            _, entryClassObject, entryMethod, _, _ = self.currentlyRenderingJob
            if classObject == entryClassObject and method == entryMethod:
                self.cancelCurrentJob()
        self.renderingLock.unlock()

        self.queueLock.unlock()
        self.queueHasJobsLock.unlock()

    def dequeueAll(self):
        self.queueHasJobsLock.lock()
        self.queueLock.lock()
        # signal all
        for jobId, _, _, _, _ in self.renderQueue:
            self.emit(SIGNAL("jobDequeued"), jobId)

        self.renderQueue = []

        # interrupt currently rendering
        self.renderingLock.lock()
        if self.currentlyRenderingJob:
            self.cancelCurrentJob()

        self.renderingLock.unlock()
        self.queueLock.unlock()
        self.queueHasJobsLock.unlock()

    def isRendering(self):
        self.queueLock.lock()
        self.renderingLock.lock()
        rendering = len(self.renderQueue) > 0 \
            or self.currentlyRenderingJob != None
        self.renderingLock.unlock()
        self.queueLock.unlock()
        return rendering

    def cancelCurrentJob(self):
        """
        This method is called when the currently rendered job should be
        canceled. The default implementation doesn't handle any object specific
        cancel operations and by default returns False. An actual implementation
        should call the current object's cancel routine and then call
        clearCurrentJob() to clear the current job and finally return True.
        """
        return False

    def clearCurrentJob(self):
        """
        This method needs to be called before the current job is canceled.
        """
        self.renderingLock.lock()
        self.currentlyRenderingJob = None
        self.renderingLock.unlock()

    def run(self):
        while True:
            self.queueHasJobsLock.lock()

            hasJobWaiting = len(self.renderQueue) > 0
            while not hasJobWaiting:
                self.emit(SIGNAL("queueEmpty"))
                self.queueHasJobsCondition.wait(self.queueHasJobsLock)
                hasJobWaiting = len(self.renderQueue) > 0

            self.queueLock.lock()
            self.renderingLock.lock()
            self.currentlyRenderingJob = self.renderQueue.pop(0)
            jobId, entryClassObject, method, args, param \
                = self.currentlyRenderingJob

            self.renderingLock.unlock()
            self.queueLock.unlock()
            self.queueHasJobsLock.unlock()

            if entryClassObject != None:
                if method == '__init__':
                    classInstance = entryClassObject(*args, **param)
                    self.classInstanceDict[entryClassObject] = classInstance

                    self.emit(SIGNAL("objectCreated"), jobId, entryClassObject)
                else:
                    classInstance = self.classInstanceDict[entryClassObject]
                    try:
                        content = getattr(classInstance, method)(*args, **param)
                        self.finishJob(jobId, entryClassObject, method, args,
                            param, content)
                    except BaseException, e:
                        if self.currentlyRenderingJob:
                            stacktrace = traceback.format_exc()
                            self.emit(SIGNAL("jobErrorneous"), jobId,
                                entryClassObject, method, args, param, e,
                                stacktrace)
                        else:
                            # job got canceled
                            self.emit(SIGNAL("jobCanceled"), jobId,
                                entryClassObject, method, args, param)

            self.renderingFinishedLock.lock()
            self.clearCurrentJob()
            self.renderingFinishedCondition.wakeAll()
            self.renderingFinishedLock.unlock()

            if entryClassObject == None and method == 'quit':
                return
Пример #24
0
class _FTSearchThread(QThread):
    '''This thread performs full text search in the background'''

    searchFinished = pyqtSignal()
    searchError = pyqtSignal()

    def __init__(self, searcher, parent):
        QThread.__init__(self, parent)
        self._searcher = searcher
        self._quit = False
        self._mutex = QMutex()
        self._pending = QWaitCondition()
        self._collector = None
        self._query = None
        self._result = None

    def run(self):
        while not self._quit:
            self._mutex.lock()
            if not self._query:
                self._pending.wait(self._mutex)
            query = self._query
            self._query = None
            self._mutex.unlock()

            # search
            if query:
                (query_str1, query_str2, itemtypes, limit, highlight,
                 merge) = query

                self._mutex.lock()
                collector = self._searcher.make_collector(limit)
                self._collector = collector
                self._mutex.unlock()

                try:
                    result = self._searcher.search(collector, query_str1,
                                                   query_str2, itemtypes,
                                                   highlight)
                except:
                    self._mutex.lock()
                    self._result = None
                    self._mutex.unlock()
                    self.searchError.emit()
                else:
                    if collector.aborted:
                        pass
                    else:
                        self._mutex.lock()
                        self._result = (merge, result)
                        self._mutex.unlock()
                        self.searchFinished.emit()

                self._mutex.lock()
                self._collector = None
                self._mutex.unlock()

    def cancel(self):
        self._mutex.lock()
        self._query = None
        if self._collector:
            self._collector.abort()
        self._mutex.unlock()

    def quit(self):
        self._mutex.lock()
        if self._collector:
            self._collector.abort()
        self._query = None
        self._quit = True
        self._mutex.unlock()
        self._pending.wakeAll()

    def update_query(self,
                     query_str1=None,
                     query_str2=None,
                     itemtypes=(),
                     limit=1000,
                     highlight=False,
                     merge=False):
        self._mutex.lock()
        if self._collector:
            self._collector.abort()
        self._query = (query_str1, query_str2, itemtypes, limit, highlight,
                       merge)
        self._mutex.unlock()
        self._pending.wakeAll()

    def take_result(self):
        self._mutex.lock()
        r = self._result
        self._result = None
        self._mutex.unlock()
        return r
Пример #25
0
    def __init__(self, parent=None):
        QThread.__init__(self, parent)

        self.waitcond = QWaitCondition()
        self.mutex = QMutex()
        self.isstopped = False
Пример #26
0
class TestThread(QThread):
    
    def __init__(self, suite, items, stopOnError, stopOnFail, xmlRPCUrl):
        QThread.__init__(self)
        self.suite = suite
        self.items = items
        executionDelay = self.suite.sliderSpeed.value() / 1000 # convert to seconds
        self.sync = QMutex()
        self.pauseCond = QWaitCondition()
        self.executionPaused = False  
        self.autoPlayer = AutoPlayer(executionDelay, self.sync, self.pauseCond, xmlRPCUrl)
        self.executionStopped = False         
        self.stopOnError = stopOnError
        self.stopOnFail = stopOnFail
        self._connectSignals()
               
    def _connectSignals(self):
        self.connect(self.suite,SIGNAL("pauseExecution"), self.pauseExecution)
        self.connect(self.suite,SIGNAL("unpauseExecution"), self.unpauseExecution)
        self.connect(self.suite,SIGNAL("executionStopped"), self.stopExecution)
        self.connect(self.autoPlayer,SIGNAL("logMessage"), self.suite.logMessage)
        self.connect(self.suite.sliderSpeed, SIGNAL('valueChanged(int)'), self.updateExecutionSpeed)
        
    def checkForPause(self):
        """ Check if the pause flag has been set"""
        self.sync.lock()
        if(self.executionPaused):
            self.pauseCond.wait(self.sync)
        self.sync.unlock()

    def run(self):
        self.emit(SIGNAL('updateExecutionButtons'), False)
        # set default icon for all items
        for item in self.items:
            self.emit(SIGNAL('updateItemStatus'), item, TestCaseStatus.UNTESTED, False)
        
        # parse and execute test caeses 
        handNumber = 1  
        failedTc = 0
        successfulTc = 0
        errorTc = 0 
        for item in self.items:     
            try:
                
                self.checkForPause()    
                if self.executionStopped:
                    return
                
                self.emit(SIGNAL('logMessage'), " => Test case : " + item.text(),LogStyle.TITLE)
                self.emit(SIGNAL('updateItemStatus'), item, TestCaseStatus.UNTESTED, True)
                tc = item.data(Qt.UserRole) # get file name
                
                #parse test case 
                tcp = TestCaseParser(tc.file)
                tcp.parse()
                
                #start test
                successful = self.autoPlayer.startTest(tcp, handNumber)
                
                self.checkForPause()
                if self.executionStopped:
                    return
                
                if successful:
                    self.emit(SIGNAL('updateItemStatus'), item, TestCaseStatus.SUCCESS, True)
                    successfulTc += 1
                else:
                    self.emit(SIGNAL('updateItemStatus'), item, TestCaseStatus.FAILED, True)
                    failedTc += 1
                    if(self.stopOnFail):
                        break
                handNumber += 1
            except ParserException as e:
                self.emit(SIGNAL('updateItemStatus'), item, TestCaseStatus.ERROR, True)
                self.emit(SIGNAL('logMessage'),"Parsing error: " + str(e),LogStyle.WARNING)
                errorTc += 1
                if(self.stopOnError):
                    break
            except socket.error:
                self.emit(SIGNAL('logMessage'),"Can't connect to player",LogStyle.ERROR)
                self.stopExecution()
                self.emit(SIGNAL('updateExecutionButtons'), True) 
                return
            except Exception as e:
                self.emit(SIGNAL('logMessage'),"Unknown error: " + str(e),LogStyle.ERROR)
                raise         
        
        self.emit(SIGNAL('logMessage'), " => Execution finished",LogStyle.TITLE)
        if(len(self.items) > 1):                 
            self.emit(SIGNAL('logMessage'), "Result => Total: {0}, Successful: {1}, Failed: {2}, Error: {3}"
                      .format(len(self.items),successfulTc,failedTc,errorTc),LogStyle.TITLE)
                
        self.emit(SIGNAL('updateExecutionButtons'), True) 
        
    def pauseExecution(self):
        """ Pause test case execution """
        self.sync.lock()
        self.executionPaused = True
        self.autoPlayer.pause()
        self.sync.unlock()
      
    def unpauseExecution(self):
        """ Unpause test case execution """
        self.sync.lock()
        self.executionPaused = False
        self.autoPlayer.unpause()
        self.pauseCond.wakeAll()
        self.sync.unlock()
        
    def stopExecution(self):   
        """ Stop test case execution """ 
        if(self.executionPaused):
            self.unpauseExecution()
        self.executionStopped = True
        self.autoPlayer.stop()
        
    def updateExecutionSpeed(self, value):
        executionDelay = value / 1000 # convert to seconds
        self.autoPlayer.executionDelay = executionDelay
Пример #27
0
    def __init__(self, parent = None):
        QThread.__init__(self, parent)

        self.waitcond = QWaitCondition()
        self.mutex = QMutex()
        self.isstopped = False
Пример #28
0
 def __init__(self):
     QThread.__init__(self)
     self.cond = QWaitCondition()