def __init__(self, source=REPO, state=None):
if not self.initialized():
self.source = source
self.initComar()
self.odb = pisi.db.offlinedb.OfflineDB()
self.initDB()
self.offlineparser = OfflineParser()
def __init__(self, source=REPO, state=None):
if not self.initialized():
self.source = source
self.initComar()
self.odb = pisi.db.offlinedb.OfflineDB()
self.initDB()
self.offlineparser = OfflineParser()
def __init__(self):
QObject.__init__(self)
self.setExceptionHandler(self.exceptionHandler)
self.setActionHandler(self.handler)
self.offlineparser = OfflineParser()
class OfflineManager(QObject):
def __init__(self):
QObject.__init__(self)
self.setExceptionHandler(self.exceptionHandler)
self.setActionHandler(self.handler)
self.offlineparser = OfflineParser()
def setActionHandler(self, handler):
backend.pm.Iface().setHandler(handler)
def setExceptionHandler(self, handler):
backend.pm.Iface().setExceptionHandler(handler)
def updateExportingProgress(self):
try:
percent = (self.packageNo * 100) / self.totalPackages
except ZeroDivisionError:
percent = 0
self.emit(SIGNAL("exportingProgress(int)"), percent)
def updateTotalOperationPercent(self):
try:
percent = (self.operationNo * 100) / self.totalOperations
except ZeroDivisionError:
percent = 0
self.emit(SIGNAL("totalProgress(int)"), percent)
def updateOperationPercent(self):
try:
percent = (self.packageNo * 100) / self.totalPackages
except ZeroDivisionError:
percent = 0
self.emit(SIGNAL("currentProgress(int)"), percent)
def importIndex(self, filename):
backend.pm.Iface().setIndex(filename)
def exportIndex(self, filename):
iface = backend.pm.Iface()
source = iface.source # store current source
iface.setSource(None) # set source None
list_installed = iface.getPackageList() # get installed package list
packages = []
self.totalPackages = len(list_installed)
self.packageNo = 0
for name in list_installed:
packages.append(iface.getPackage(name))
self.packageNo += 1
self.updateExportingProgress()
session = SessionManager()
session.setSession(session.OFFLINE)
try:
backend.pm.Iface().writeIndex(packages, filename)
print "Index file is written successfully."
except:
print "Index file could not written!"
# set source and session to their previous states
session.setSession(session.NORMAL)
iface.setSource(source)
def saveSession(self, filename):
self.offlineparser.saveArchive(filename)
def openSession(self, filename):
self.offlineparser.extractArchive(filename)
self.initOperations()
self.getOperation()
def initOperations(self):
self.operations = self.offlineparser.parseOperations()
self.totalOperations = len(self.operations)
self.operationNo = 0
self.signalCounter = 0
def getOperation(self):
self.updateTotalOperationPercent()
self.operationNo += 1
try:
operation = self.operations[0][0]
packages = self.operations[0][1]
self.operations.pop(0)
self.startOperation(operation, packages)
except IndexError:
self.emit(SIGNAL("finished()"))
def startOperation(self, operation, packages):
self.totalPackages = len(packages)
self.packageNo = 0
if operation == "install":
backend.pm.Iface().installPackages(packages)
elif operation == "remove":
backend.pm.Iface().removePackages(packages)
else:
raise Exception("Unknown operation")
def exceptionHandler(self, exception):
self.emit(SIGNAL("exception(QString)"), str(exception))
def handler(self, package, signal, args):
if signal == "status":
signal = str(args[0])
args = args[1:]
packageName = args[0]
if signal == "installing":
self.emit(SIGNAL("operationChanged(QString)"),
i18n("Installing %s" % packageName))
elif signal == "removing":
self.emit(SIGNAL("operationChanged(QString)"),
i18n("Removing %s" % packageName))
elif signal in ["installed", "removed"]:
self.packageNo += 1
self.updateOperationPercent()
elif signal == "finished":
# it must wait for second finish signal to start next operation
if self.signalCounter == 1:
self.getOperation()
self.signalCounter = 0
else:
self.signalCounter += 1
class Iface(Singleton):
(SYSTEM, REPO) = range(2)
def __init__(self, source=REPO, state=None):
if not self.initialized():
self.source = source
self.initComar()
self.odb = pisi.db.offlinedb.OfflineDB()
self.initDB()
self.offlineparser = OfflineParser()
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.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):
all_packages = packages + self.depends_list
for pkg in all_packages:
self.odb.add_package(pkg)
self.offlineparser.saveOperation(all_packages, "install")
def removePackages(self, packages):
all_packages = packages + self.requires_list
for pkg in all_packages:
self.odb.remove_package(pkg)
self.offlineparser.saveOperation(all_packages, "remove")
def upgradePackages(self, packages):
self.installPackages(packages)
def updateRepositories(self):
self.link.System.Manager["pisi"].updateAllRepositories(
async=self.handler, timeout=2**16 - 1)
def updateRepository(self, repo):
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.link.System.Manager["pisi"].clearCache("/var/cache/pisi/packages",
limit)
def setRepositories(self, repos):
logger.debug("Re-setting repositories: %s" % repos)
self.link.System.Manager["pisi"].setRepositories(repos)
def setRepoActivities(self, repos):
logger.debug("Re-setting repo activities: %s" % repos)
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 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
class Iface(Singleton):
(SYSTEM, REPO) = range(2)
def __init__(self, source=REPO, state=None):
if not self.initialized():
self.source = source
self.initComar()
self.odb = pisi.db.offlinedb.OfflineDB()
self.initDB()
self.offlineparser = OfflineParser()
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.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):
all_packages = packages + self.depends_list
for pkg in all_packages:
self.odb.add_package(pkg)
self.offlineparser.saveOperation(all_packages, "install")
def removePackages(self, packages):
all_packages = packages + self.requires_list
for pkg in all_packages:
self.odb.remove_package(pkg)
self.offlineparser.saveOperation(all_packages, "remove")
def upgradePackages(self, packages):
self.installPackages(packages)
def updateRepositories(self):
self.link.System.Manager["pisi"].updateAllRepositories(async=self.handler, timeout=2**16-1)
def updateRepository(self, repo):
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.link.System.Manager["pisi"].clearCache("/var/cache/pisi/packages", limit)
def setRepositories(self, repos):
logger.debug("Re-setting repositories: %s" % repos)
self.link.System.Manager["pisi"].setRepositories(repos)
def setRepoActivities(self, repos):
logger.debug("Re-setting repo activities: %s" % repos)
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 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):
QObject.__init__(self)
self.setExceptionHandler(self.exceptionHandler)
self.setActionHandler(self.handler)
self.offlineparser = OfflineParser()
class OfflineManager(QObject):
def __init__(self):
QObject.__init__(self)
self.setExceptionHandler(self.exceptionHandler)
self.setActionHandler(self.handler)
self.offlineparser = OfflineParser()
def setActionHandler(self, handler):
backend.pm.Iface().setHandler(handler)
def setExceptionHandler(self, handler):
backend.pm.Iface().setExceptionHandler(handler)
def updateExportingProgress(self):
try:
percent = (self.packageNo * 100) / self.totalPackages
except ZeroDivisionError:
percent = 0
self.emit(SIGNAL("exportingProgress(int)"), percent)
def updateTotalOperationPercent(self):
try:
percent = (self.operationNo * 100) / self.totalOperations
except ZeroDivisionError:
percent = 0
self.emit(SIGNAL("totalProgress(int)"), percent)
def updateOperationPercent(self):
try:
percent = (self.packageNo * 100) / self.totalPackages
except ZeroDivisionError:
percent = 0
self.emit(SIGNAL("currentProgress(int)"), percent)
def importIndex(self, filename):
backend.pm.Iface().setIndex(filename)
def exportIndex(self, filename):
iface = backend.pm.Iface()
source = iface.source # store current source
iface.setSource(None) # set source None
list_installed = iface.getPackageList() # get installed package list
packages = []
self.totalPackages = len(list_installed)
self.packageNo = 0
for name in list_installed:
packages.append(iface.getPackage(name))
self.packageNo += 1
self.updateExportingProgress()
session = SessionManager()
session.setSession(session.OFFLINE)
try:
backend.pm.Iface().writeIndex(packages, filename)
print "Index file is written successfully."
except:
print "Index file could not written!"
# set source and session to their previous states
session.setSession(session.NORMAL)
iface.setSource(source)
def saveSession(self, filename):
self.offlineparser.saveArchive(filename)
def openSession(self, filename):
self.offlineparser.extractArchive(filename)
self.initOperations()
self.getOperation()
def initOperations(self):
self.operations = self.offlineparser.parseOperations()
self.totalOperations = len(self.operations)
self.operationNo = 0
self.signalCounter = 0
def getOperation(self):
self.updateTotalOperationPercent()
self.operationNo += 1
try:
operation = self.operations[0][0]
packages = self.operations[0][1]
self.operations.pop(0)
self.startOperation(operation, packages)
except IndexError:
self.emit(SIGNAL("finished()"))
def startOperation(self, operation, packages):
self.totalPackages = len(packages)
self.packageNo = 0
if operation == "install":
backend.pm.Iface().installPackages(packages)
elif operation == "remove":
backend.pm.Iface().removePackages(packages)
else:
raise Exception("Unknown operation")
def exceptionHandler(self, exception):
self.emit(SIGNAL("exception(QString)"), str(exception))
def handler(self, package, signal, args):
if signal == "status":
signal = str(args[0])
args = args[1:]
packageName = args[0]
if signal == "installing":
self.emit(SIGNAL("operationChanged(QString)"), i18n("Installing %s" % packageName))
elif signal == "removing":
self.emit(SIGNAL("operationChanged(QString)"), i18n("Removing %s" % packageName))
elif signal in ["installed", "removed"]:
self.packageNo += 1
self.updateOperationPercent()
elif signal == "finished":
# it must wait for second finish signal to start next operation
if self.signalCounter == 1:
self.getOperation()
self.signalCounter = 0
else:
self.signalCounter += 1
