From e892cc8c764cb8773b7ee675552f6d61158b3872 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bar=C4=B1=C5=9F=20Metin?= Date: Sat, 16 Jul 2005 20:45:29 +0000 Subject: [PATCH] =?UTF-8?q?dizin=20yap=C4=B1m=C4=B1z=20tamam.=20InstallCon?= =?UTF-8?q?text=20d=C3=BCzeltildi.=20=C3=B6d=C3=BCl=20olarak=20install.py?= =?UTF-8?q?=20class=20yap=C4=B1s=C4=B1=20kazand=C4=B1...?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- pisi/cli/installhelper.py | 21 ++-- pisi/config.py | 9 -- pisi/constants.py | 11 ++- pisi/context.py | 51 +++++++--- pisi/install.py | 200 ++++++++++++++++++-------------------- 5 files changed, 150 insertions(+), 142 deletions(-) diff --git a/pisi/cli/installhelper.py b/pisi/cli/installhelper.py index 6694bd89..5f5482d0 100644 --- a/pisi/cli/installhelper.py +++ b/pisi/cli/installhelper.py @@ -1,13 +1,14 @@ -import sys -import pisi.install -from pisi.ui import ui +from pisi.install import PisiInstall +from pisi.context import InstallContext +from pisi.purl import PUrl def install(packagefile): - try: - ui.info('* Installing ' + packagefile + '\n') - pisi.install.install(packagefile) - except pisi.install.InstallError, e: - print '*** An installation error has occured:' - print '\t', e - sys.exit(1) + url = PUrl(packagefile) + if url.isRemoteFile(): + pass # bunu simdilik bosverelim, once bir calissin :) + else: + ctx = InstallContext(url.uri) + + pi = PisiInstall(ctx) + pi.install() diff --git a/pisi/config.py b/pisi/config.py index a614c218..1a68c318 100644 --- a/pisi/config.py +++ b/pisi/config.py @@ -42,15 +42,6 @@ class Config(object): def install_dir(self): return self.tmp_dir() + const.install_dir_suffix - def files_xml_dir(self): - return self.destdir + const.files_xml_dir_suffix - - def metadata_xml_dir(self): - return self.destdir + const.metadata_xml_dir_suffix - - def comar_files_dir(self): - return self.destdir + const.comar_files_dir_suffix - __configinstance = configimpl() def __init__(self): diff --git a/pisi/constants.py b/pisi/constants.py index 909b9aa6..fa1f14c2 100644 --- a/pisi/constants.py +++ b/pisi/constants.py @@ -41,14 +41,19 @@ class Constants: self.__c.db_dir_suffix = "/var/db/pisi" self.__c.archives_dir_suffix = "/var/cache/pisi/archives" self.__c.tmp_dir_suffix = "/var/tmp/pisi" - self.__c.comar_files_dir_suffix = "/var/lib/pisi/comar" - self.__c.files_xml_dir_suffix = "/var/lib/pisi/files" - self.__c.metadata_xml_dir_suffix = "/var/lib/pisi/metadata" # directory suffixes for build self.__c.work_dir_suffix = "/work" self.__c.install_dir_suffix = "/install" + # directory suffixes for intall. We'll use these directories + # for storing files related to the packages. Each package will + # have its own directory under lib_dir with has these + # sub-directories. + self.__c.comar_dir_suffix = "/comar" + self.__c.files_dir_suffix = "/files" + self.__c.metadata_dir_suffix = "/metadata" + # file/directory names self.__c.actions_file = "actions.py" self.__c.files_dir = "files" diff --git a/pisi/context.py b/pisi/context.py index 08093493..d6611955 100644 --- a/pisi/context.py +++ b/pisi/context.py @@ -3,9 +3,12 @@ # Authors: Baris Metin -from specfile import SpecFile from constants import const from config import Config +from specfile import SpecFile +from package import Package +from metadata import MetaData +from files import Files class BuildContext(object): """Build Context Singleton""" @@ -59,34 +62,56 @@ class InstallContext(object): def __init(self): super(ctximpl, self).__init__() - def setMetadataFile(self, metadatafile): - self.metadatafile = metadatafile + def setPackage(self, packagefile): + self.packagefile = packagefile + self.package = Package(packagefile, 'r') + + tmpdir = self.tmp_dir() + # extract control files + self.package.extract_PISI_files(tmpdir) + + # read files.xml and metadata.xml + mdxml = tmpdir + '/' + const.metadata_xml + self.setMetadataXML(mdxml) + filesxml = tmpdir + '/' + const.files_xml + self.setFilesXML(filesxml) + + def setMetadataXML(self, metadataxml): + self.metadataxml = metadataxml metadata = MetaData() - metadata.read(metadatafile) - metadata.verify() + metadata.read(metadataxml) + if not metadata.verify(): + raise InstallError("MetaData format wrong") self.metadata = metadata + def setFilesXML(self, filesxml): + self.filesxml = filesxml + files = Files() + files.read(filesxml) + + self.files = files + def pkg_dir(self): packageDir = self.metadata.package.name + '-' \ - + self.metadata.package.version + '-' + self.metadata.package.release + + self.metadata.package.version + '-' \ + + self.metadata.package.release - return self.destdir + config.lib_dir() \ - + '/' + packageDir + return self.lib_dir() + '/' + packageDir def files_dir(self): - return self.pkg_dir() + const.files_xml_dir_suffix + return self.pkg_dir() + const.files_dir_suffix def metadata_dir(self): - return self.pkg_dir() + const.metadata_xml_dir_suffix + return self.pkg_dir() + const.metadata_dir_suffix def comar_dir(self): - return self.pkg_dir() + const.comar_files_dir_suffix + return self.pkg_dir() + const.comar_dir_suffix __instance = ctximpl() # singleton implementation - def __init__(self, mdfile): - self.__instance.setMetadataFile(mdfile) + def __init__(self, packagefile): + self.__instance.setPackage(packagefile) def __getattr__(self, attr): return getattr(self.__instance, attr) diff --git a/pisi/install.py b/pisi/install.py index feab05fa..7737e50c 100644 --- a/pisi/install.py +++ b/pisi/install.py @@ -26,42 +26,8 @@ import comariface class InstallError(Exception): pass -from os.path import join, exists - -def get_pkg_info(package_fn): - package = Package(package_fn, 'r') - # extract control files - util.clean_dir(config.install_dir()) - package.extract_PISI_files(config.install_dir()) - - # verify package - - # check if we have all required files - if not exists(join(config.install_dir(), 'metadata.xml')): - raise InstallError('metadata.xml missing') - if not exists(join(config.install_dir(), 'files.xml')): - raise InstallError('files.xml missing') - - metadata = MetaData() - metadata.read(join(config.install_dir(), 'metadata.xml')) - - files = Files() - files.read(join(config.install_dir(), 'files.xml')) - - return metadata, files - -def extract_pkg_files(package_fn): - package = Package(package_fn, 'r') - - ui.info('Extracting files\n') - package.extract_dir_flat('install', config.destdir) - -def copy_from_pkg(package_fn, file, dest): - package = Package(package_fn, 'r') - - ui.info('Coping file %s to %s\n' %(file, dest)) - package.extract_file(file, dest) - +# bu fonksiyonun burada işi olmamalı. Silmeyi doğrudan install.py'nin +# içinde yapmamalıyız! def remove(package_name): """Remove a goddamn package""" ui.info('Removing package ' + package_name) @@ -72,91 +38,111 @@ def remove(package_name): os.unlink(fileinfo.path) installdb.remove(package_name) -def install(package_fn): - metadata, files = get_pkg_info(package_fn) +class PisiInstall: + "PisiInstall class, provides install rutines for pisi packages" + def __init__(self, installcontext): + self.ctx = installcontext + self.metadata = self.ctx.metadata + self.files = self.ctx.files + self.package = self.ctx.package + + def extractInstall(self): + ui.info('Extracting files\n') + self.package.extract_dir_flat('install', config.destdir) - # check package semantics - if not metadata.verify(): - raise InstallError("MetaData format wrong") + def storePisiFiles(self): + # put files.xml, metadata.xml, actions.py and COMAR scripts + # somewhere in the file system. We'll need these in future... - # check file system requirements - # what to do if / is split into /usr, /var, etc.? + ui.info('Storing %s\n' % const.files_xml) + self.package.extract_file(const.files_xml, self.ctx.files_dir()) - package = metadata.package + ui.info('Storing %s\n' % const.metadata_xml) + self.package.extract_file(const.metadata_xml, self.ctx.metadata_dir()) - # check if package is in database - if not packagedb.has_package(package.name): - packagedb.add_package(package) # terrible solution it seems + for pcomar in self.metadata.package.providesComar: + fpath = os.path.join(const.comar_dir, pcomar.script) + # comar prefix is added to the pkg_dir while extracting comar + # script file. so we'll use pkg_dir as destination. + ui.info('Storing %s\n' % fpath) + self.package.extract_file(fpath, self.ctx.pkg_dir()) + + def registerCOMARScripts(self): + # register COMAR scripts + for pcomar in self.metadata.package.providesComar: + scriptPath = os.path.join(self.ctx.comar_dir(),pcomar.script) + ui.info("Registering COMAR script %s\n" % pcomar.script) + ret = comariface.registerScript(pcomar.om, + self.metadata.package.name, + scriptPath) + if not ret: + ui.error("registerScript failed. Be sure that comard is running!\n") + + + def install(self): + + # check file system requirements + # what to do if / is split into /usr, /var, etc.? + + pkginfo = self.metadata.package + + # check if package is in database + if not packagedb.has_package(pkginfo.name): + packagedb.add_package(pkginfo) # terrible solution it seems - # check conflicts - for pkg in metadata.package.conflicts: - if installdb.has_package(package): - raise InstallError("Package conflicts " + pkg) + # check conflicts + for pkg in self.metadata.package.conflicts: + if installdb.has_package(pkginfo): + raise InstallError("Package conflicts " + pkg) - # check dependencies - if not dependency.installable(package.name): - raise InstallError("Package not installable") + # check dependencies + if not dependency.installable(pkginfo.name): + raise InstallError("Package not installable") - #TODO: - if installdb.is_installed(package.name): # is this a reinstallation? + #TODO: + if installdb.is_installed(pkginfo.name): # is this a reinstallation? + (iversion, irelease) = installdb.get_version(pkginfo.name) - (iversion, irelease) = installdb.get_version(package.name) + if pkginfo.version == iversion and pkginfo.release == irelease: + if not ui.confirm('Re-install same version package?'): + raise InstallError('Package re-install declined') - if package.version == iversion and package.release == irelease: - if not ui.confirm('Re-install same version package?'): - raise InstallError('Package re-install declined') + upgrade = False + # is this an upgrade? + # determine and report the kind of upgrade: version, release, build + if pkginfo.version > iversion: + ui.info('Upgrading to new upstream version') + upgrade = True + elif pkginfo.release > irelease: + ui.info('Upgrading to new distribution release') + upgrade = True - upgrade = False - # is this an upgrade? - # determine and report the kind of upgrade: version, release, build - if package.version > iversion: - ui.info('Upgrading to new upstream version') - upgrade = True - elif package.release > irelease: - ui.info('Upgrading to new distribution release') - upgrade = True + # is this a downgrade? confirm this action. + if not upgrade: + if pkginfo.version < iversion: + x = 'Downgrade to old upstream version?' + elif pkginfo.release < irelease: + x = 'Downgrade to old distribution release?' + if not ui.confirm(x): + raise InstallError('Package downgrade declined') - # is this a downgrade? confirm this action. - if not upgrade: - if package.version < iversion: - x = 'Downgrade to old upstream version?' - elif package.release < irelease: - x = 'Downgrade to old distribution release?' - if not ui.confirm(x): - raise InstallError('Package downgrade declined') + # remove old package then + remove(pkginfo.name) - # remove old package then - remove(package.name) + # unzip package in place + self.extractInstall() - # unzip package in place - extract_pkg_files(package_fn) + # store files.xml, metadata.xml and comar scripts for further usage + self.storePisiFiles() - # put files.xml, metadata.xml, actions.py and COMAR scripts - # somewhere in the file system. We'll need these in future... - copy_from_pkg(package_fn, const.files_xml , config.files_xml_dir()) - copy_from_pkg(package_fn, const.metadata_xml , config.metadata_xml_dir()) - for pcomar in package.providesComar: - fpath = os.path.join(const.comar_dir, pcomar.script) - # comar prefix is added to the libdir while extracting comar - # script file. so we'll use lib_dir as destination. - copy_from_pkg(package_fn, fpath, config.lib_dir()) - + # register comar scripts + self.registerCOMARScripts() - # register COMAR scripts - for pcomar in package.providesComar: - scriptPath = config.comar_files_dir() + pcomar.script - ui.info("Registering COMAR script %s\n" % pcomar.script) - ret = comariface.registerScript(pcomar.om, - package.name, - scriptPath) - if not ret: - ui.error("Unable to register COMAR script. Be sure that comard is running!\n") + # update databases - # update databases - - # installdb - installdb.install(metadata.package.name, - metadata.package.version, - metadata.package.release, - os.path.join(config.install_dir(), 'files.xml')) + # installdb + installdb.install(self.metadata.package.name, + self.metadata.package.version, + self.metadata.package.release, + os.path.join(self.ctx.files_dir(), 'files.xml'))