def __init__(self):
if sys.platform == 'win32':
from qt import QMutex
self.mutex = QMutex(True)
elif sys.platform == 'darwin':
from Foundation import NSRecursiveLock
self.mutex = NSRecursiveLock.alloc().init()
class ThreadLock:
def __init__(self):
if sys.platform == 'win32':
from qt import QMutex
self.mutex = QMutex(True)
elif sys.platform == 'darwin':
from Foundation import NSRecursiveLock
self.mutex = NSRecursiveLock.alloc().init()
def lock(self): self.mutex.lock()
def unlock(self): self.mutex.unlock()
class SpellThread(QThread):
def __init__(self,parent):
self.parent = parent
self.mutex = QMutex()
QThread.__init__(self)
def run(self):
self.mutex.lock()
scin = self.parent.sourceEditor
text = unicode ( scin.text() )
if text :
self.parent.speller_result = self.parent.speller.load( unicode ( text ) )
else:
self.parent.speller_result = {}
self.postEvent(self.parent, OpCompleteEvent(doneSpell,self.parent))
self.mutex.unlock()
def __init__(self, handler=None, errHandler=None):
self.errHandler = errHandler
self.handler = handler
# package-manager sync
self.com_lock = QMutex()
if self.setupBusses():
self.setupSignals()
else:
self.errHandler()
return
def __init__(self,parent):
self.parent = parent
self.com = comar.Link()
# tray and package-manager synchronization
self.com_lock = QMutex()
# Notification
self.com.ask_notify("System.Manager.progress")
self.com.ask_notify("System.Manager.error")
self.com.ask_notify("System.Manager.warning")
self.com.ask_notify("System.Manager.info")
self.com.ask_notify("System.Manager.notify")
self.com.ask_notify("System.Manager.finished")
self.com.ask_notify("System.Manager.updatingRepo")
self.notifier = QSocketNotifier(self.com.sock.fileno(), QSocketNotifier.Read)
self.parent.connect(self.notifier, SIGNAL("activated(int)"), self.parent.slotComar)
def __init__(self, source=REPO):
if not self.initialized():
self.source = source
self.com_lock = QMutex()
self.initComar()
self.initDB()
class Iface(Singleton):
(SYSTEM, REPO) = range(2)
def __init__(self, source=REPO):
if not self.initialized():
self.source = source
self.com_lock = QMutex()
self.initComar()
self.initDB()
def initialized(self):
return "link" in self.__dict__
def initComar(self):
self.link = comar.Link()
self.link.setLocale()
self.link.listenSignals("System.Manager", self.signalHandler)
def initDB(self):
self.pdb = pisi.db.packagedb.PackageDB()
self.cdb = pisi.db.componentdb.ComponentDB()
self.idb = pisi.db.installdb.InstallDB()
self.rdb = pisi.db.repodb.RepoDB()
self.gdb = pisi.db.groupdb.GroupDB()
self.replaces = self.pdb.get_replaces()
def setHandler(self, handler):
self.link.listenSignals("System.Manager", handler)
def setExceptionHandler(self, handler):
self.exceptionHandler = handler
def invalidate_db_caches(self):
pisi.db.invalidate_caches()
self.initDB()
def signalHandler(self, package, signal, args):
if signal == "finished":
self.invalidate_db_caches()
def handler(self, package, exception, args):
if exception:
logger.debug("Exception caught by COMAR: %s" % exception)
self.invalidate_db_caches()
self.exceptionHandler(exception)
def installPackages(self, packages):
logger.debug("Installing packages: %s" % packages)
packages = string.join(packages,",")
self.com_lock.lock()
self.link.System.Manager["pisi"].installPackage(packages, async=self.handler, timeout=2**16-1)
def removePackages(self, packages):
logger.debug("Removing packages: %s" % packages)
packages = string.join(packages,",")
self.com_lock.lock()
self.link.System.Manager["pisi"].removePackage(packages, async=self.handler, timeout=2**16-1)
def upgradePackages(self, packages):
logger.debug("Upgrading packages: %s" % packages)
packages = string.join(packages,",")
self.com_lock.lock()
self.link.System.Manager["pisi"].updatePackage(packages, async=self.handler, timeout=2**16-1)
def removeRepository(self, repo):
logger.debug("Removing repository: %s" % repo)
self.com_lock.lock()
self.link.System.Manager["pisi"].removeRepository(repo, async=self.handler, timeout=2**16-1)
def updateRepositories(self):
logger.debug("Updating repositories...")
self.com_lock.lock()
self.link.System.Manager["pisi"].updateAllRepositories(async=self.handler, timeout=2**16-1)
def updateRepository(self, repo):
logger.debug("Updating %s..." % repo)
self.com_lock.lock()
self.link.System.Manager["pisi"].updateRepository(repo, async=self.handler, timeout=2**16-1)
def clearCache(self, limit):
logger.debug("Clearing cache with limit: %s" % limit)
self.com_lock.lock()
self.link.System.Manager["pisi"].clearCache("/var/cache/pisi/packages", limit)
def setRepositories(self, repos):
logger.debug("Re-setting repositories: %s" % repos)
self.com_lock.lock()
self.link.System.Manager["pisi"].setRepositories(repos)
def setRepoActivities(self, repos):
logger.debug("Re-setting repo activities: %s" % repos)
self.com_lock.lock()
self.link.System.Manager["pisi"].setRepoActivities(repos)
def __configChanged(self, category, name, value):
config = self.getConfig()
return not str(config.get(category, name)) == str(value)
def setCacheLimit(self, useCache, limit):
logger.debug("Use cache: %s - change limit to: %s" % (useCache, limit))
if not self.__configChanged("general", "package_cache", useCache) and not self.__configChanged("general", "package_cache_limit", limit):
return
self.link.System.Manager["pisi"].setCache(useCache, limit)
def setConfig(self, category, name, value):
logger.debug("Setting config... Category: %s, Name: %s, Value: %s" % (category, name, value))
if not self.__configChanged(category, name, value):
return
self.link.System.Manager["pisi"].setConfig(category, name, value)
def setSource(self, source):
self.source = source
def getUpdateType(self, pkg):
(version, release, build) = self.idb.get_version(pkg.name)
update_types = [i.type for i in pkg.history if pisi.version.Version(i.release) > pisi.version.Version(release)]
if "security" in update_types:
return "security"
elif "critical" in update_types:
return "critical"
return "normal"
def getPackageRepository(self, name):
try:
return self.pdb.which_repo(name)
except Exception:
return "N/A"
def calculate_download_size(self, packages):
try:
total, cached = pisi.api.calculate_download_size(packages)
return total - cached
except OSError, e:
return None
def __init__(self,parent):
self.parent = parent
self.mutex = QMutex()
QThread.__init__(self)
class ComarIface:
""" Comar Interface to communicate with Comar """
def __init__(self, handler=None, errHandler=None):
self.errHandler = errHandler
self.handler = handler
# package-manager sync
self.com_lock = QMutex()
if self.setupBusses():
self.setupSignals()
else:
self.errHandler()
return
def setupBusses(self):
try:
# get system and session busses
self.sysBus = dbus.SystemBus()
self.sesBus = dbus.SessionBus()
except dbus.DBusException:
self.errHandler(i18n("Cannot connect to dbus"))
return False
return True
def setupSignals(self):
self.sysBus.add_signal_receiver(self.handleSignals, dbus_interface="tr.org.pardus.comar.System.Manager", member_keyword="signal", path_keyword="path")
def handleSignals(self, *args, **kwargs):
signal = kwargs["signal"]
if self.handler:
self.handler(signal, args)
def busError(self, exception):
message = i18n("D-Bus Error") + str(exception)
self.setupBusses()
self.errHandler(message)
def comarAuthError(self, exception):
self.errHandler(i18n("COMAR Auth Error") + str(exception))
def comarError(self, exception):
message = ""
if not "urlopen error" in exception.message:
message += i18n("COMAR Error")
self.errHandler(message + "<br>" + str(exception))
def cancelError(self):
message = i18n("You are not authorized for this operation.")
self.errHandler(message)
def callMethod(self, method, action, handler, handleErrors, *args):
ch = CallHandler("System.Manager", method, action, self.sysBus, self.sesBus)
if handleErrors:
ch.registerError(self.comarError)
ch.registerAuthError(self.comarAuthError)
ch.registerDBusError(self.busError)
ch.registerCancel(self.cancelError)
if handler:
ch.registerDone(handler)
ch.call(*args)
def takeSnapshot(self):
self.com_lock.lock()
self.callMethod("takeSnapshot", "tr.org.pardus.comar.system.manager.takesnapshot", self.handler, True)
def takeBack(self, operation):
self.com_lock.lock()
self.callMethod("takeBack", "tr.org.pardus.comar.system.manager.takeback", None, True, int(operation))
def cancel(self):
obj = self.sysBus.get_object("tr.org.pardus.comar", "/", introspect=False)
obj.cancel(dbus_interface="tr.org.pardus.comar")
class ComarIface:
def __init__(self,parent):
self.parent = parent
self.com = comar.Link()
# tray and package-manager synchronization
self.com_lock = QMutex()
# Notification
self.com.ask_notify("System.Manager.progress")
self.com.ask_notify("System.Manager.error")
self.com.ask_notify("System.Manager.warning")
self.com.ask_notify("System.Manager.info")
self.com.ask_notify("System.Manager.notify")
self.com.ask_notify("System.Manager.finished")
self.com.ask_notify("System.Manager.updatingRepo")
self.notifier = QSocketNotifier(self.com.sock.fileno(), QSocketNotifier.Read)
self.parent.connect(self.notifier, SIGNAL("activated(int)"), self.parent.slotComar)
def installPackage(self, package):
self.com_lock.lock()
self.com.call("System.Manager.installPackage", ["package",package])
def removePackage(self, package):
self.com_lock.lock()
self.com.call("System.Manager.removePackage", ["package",package])
def updatePackage(self, package):
self.com_lock.lock()
self.com.call("System.Manager.updatePackage", ["package",package])
def updateRepo(self, repo):
self.com_lock.lock()
self.com.call("System.Manager.updateRepository", ["repository",repo])
def updateAllRepos(self, id=0):
self.com_lock.lock()
self.com.call("System.Manager.updateAllRepositories", id=id)
def addRepo(self, name, uri):
self.com_lock.lock()
self.com.call("System.Manager.addRepository", ["name",name,"uri",uri])
def removeRepo(self, repo):
self.com_lock.lock()
self.com.call("System.Manager.removeRepo", ["repository",repo])
def setRepositories(self, repos):
self.com_lock.lock()
self.com.call("System.Manager.setRepositories", ["repos",repos])
def clearCache(self, cacheDir, limit):
self.com.call("System.Manager.clearCache", ["cacheDir",cacheDir,"limit",limit])
def setCache(self, enabled=None, limit=None):
self.com.call("System.Manager.setCache", ["enabled",enabled,"limit",limit])
def cancel(self):
self.com.cancel()
