Pisilinux3/pisi
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

dizin yapımız tamam.

Browse Source 
InstallContext düzeltildi.
ödül olarak install.py class yapısı kazandı...
This commit is contained in:
Barış Metin
2005-07-16 20:45:29 +00:00
parent 1471651d3a
commit e892cc8c76
5 changed files with 150 additions and 142 deletions
Download Patch File Download Diff File Expand all files Collapse all files
pisi/cli/installhelper.py
+11 -10
View File
@@ -1,13 +1,14 @@
import sys
import pisi.install from pisi.install import PisiInstall
from pisi.ui import ui from pisi.context import InstallContext
from pisi.purl import PUrl
def install(packagefile): def install(packagefile):
try: url = PUrl(packagefile)
ui.info('* Installing ' + packagefile + '\n') if url.isRemoteFile():
pisi.install.install(packagefile) pass # bunu simdilik bosverelim, once bir calissin :)
except pisi.install.InstallError, e: else:
print '*** An installation error has occured:' ctx = InstallContext(url.uri)
print '\t', e
sys.exit(1) pi = PisiInstall(ctx)
pi.install()
pisi/config.py
-9
View File
@@ -42,15 +42,6 @@ class Config(object):
def install_dir(self): def install_dir(self):
return self.tmp_dir() + const.install_dir_suffix 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() __configinstance = configimpl()
def __init__(self): def __init__(self):
pisi/constants.py
+8 -3
View File
@@ -41,14 +41,19 @@ class Constants:
self.__c.db_dir_suffix = "/var/db/pisi" self.__c.db_dir_suffix = "/var/db/pisi"
self.__c.archives_dir_suffix = "/var/cache/pisi/archives" self.__c.archives_dir_suffix = "/var/cache/pisi/archives"
self.__c.tmp_dir_suffix = "/var/tmp/pisi" 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 # directory suffixes for build
self.__c.work_dir_suffix = "/work" self.__c.work_dir_suffix = "/work"
self.__c.install_dir_suffix = "/install" 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 # file/directory names
self.__c.actions_file = "actions.py" self.__c.actions_file = "actions.py"
self.__c.files_dir = "files" self.__c.files_dir = "files"
pisi/context.py
+38 -13
View File
@@ -3,9 +3,12 @@
# Authors: Baris Metin <baris@uludag.org.tr # Authors: Baris Metin <baris@uludag.org.tr
# Eray Ozkural <eray@uludag.org.tr> # Eray Ozkural <eray@uludag.org.tr>
from specfile import SpecFile
from constants import const from constants import const
from config import Config from config import Config
from specfile import SpecFile
from package import Package
from metadata import MetaData
from files import Files
class BuildContext(object): class BuildContext(object):
"""Build Context Singleton""" """Build Context Singleton"""
@@ -59,34 +62,56 @@ class InstallContext(object):
def __init(self): def __init(self):
super(ctximpl, self).__init__() super(ctximpl, self).__init__()
def setMetadataFile(self, metadatafile): def setPackage(self, packagefile):
self.metadatafile = metadatafile 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 = MetaData()
metadata.read(metadatafile) metadata.read(metadataxml)
metadata.verify() if not metadata.verify():
raise InstallError("MetaData format wrong")
self.metadata = metadata self.metadata = metadata
def setFilesXML(self, filesxml):
self.filesxml = filesxml
files = Files()
files.read(filesxml)
self.files = files
def pkg_dir(self): def pkg_dir(self):
packageDir = self.metadata.package.name + '-' \ 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() \ return self.lib_dir() + '/' + packageDir
+ '/' + packageDir
def files_dir(self): 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): 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): 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 __instance = ctximpl() # singleton implementation
def __init__(self, mdfile): def __init__(self, packagefile):
self.__instance.setMetadataFile(mdfile) self.__instance.setPackage(packagefile)
def __getattr__(self, attr): def __getattr__(self, attr):
return getattr(self.__instance, attr) return getattr(self.__instance, attr)
pisi/install.py
+93 -107
View File
@@ -26,42 +26,8 @@ import comariface
class InstallError(Exception): class InstallError(Exception):
pass pass
from os.path import join, exists # bu fonksiyonun burada işi olmamalı. Silmeyi doğrudan install.py'nin
# içinde yapmamalıyız!
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)
def remove(package_name): def remove(package_name):
"""Remove a goddamn package""" """Remove a goddamn package"""
ui.info('Removing package ' + package_name) ui.info('Removing package ' + package_name)
@@ -72,91 +38,111 @@ def remove(package_name):
os.unlink(fileinfo.path) os.unlink(fileinfo.path)
installdb.remove(package_name) 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 def storePisiFiles(self):
if not metadata.verify(): # put files.xml, metadata.xml, actions.py and COMAR scripts
raise InstallError("MetaData format wrong") # somewhere in the file system. We'll need these in future...
# check file system requirements ui.info('Storing %s\n' % const.files_xml)
# what to do if / is split into /usr, /var, etc.? 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 for pcomar in self.metadata.package.providesComar:
if not packagedb.has_package(package.name): fpath = os.path.join(const.comar_dir, pcomar.script)
packagedb.add_package(package) # terrible solution it seems # 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 # check conflicts
for pkg in metadata.package.conflicts: for pkg in self.metadata.package.conflicts:
if installdb.has_package(package): if installdb.has_package(pkginfo):
raise InstallError("Package conflicts " + pkg) raise InstallError("Package conflicts " + pkg)
# check dependencies # check dependencies
if not dependency.installable(package.name): if not dependency.installable(pkginfo.name):
raise InstallError("Package not installable") raise InstallError("Package not installable")
#TODO: #TODO:
if installdb.is_installed(package.name): # is this a reinstallation? 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: upgrade = False
if not ui.confirm('Re-install same version package?'): # is this an upgrade?
raise InstallError('Package re-install declined') # 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 a downgrade? confirm this action.
# is this an upgrade? if not upgrade:
# determine and report the kind of upgrade: version, release, build if pkginfo.version < iversion:
if package.version > iversion: x = 'Downgrade to old upstream version?'
ui.info('Upgrading to new upstream version') elif pkginfo.release < irelease:
upgrade = True x = 'Downgrade to old distribution release?'
elif package.release > irelease: if not ui.confirm(x):
ui.info('Upgrading to new distribution release') raise InstallError('Package downgrade declined')
upgrade = True
# is this a downgrade? confirm this action. # remove old package then
if not upgrade: remove(pkginfo.name)
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 # unzip package in place
remove(package.name) self.extractInstall()
# unzip package in place # store files.xml, metadata.xml and comar scripts for further usage
extract_pkg_files(package_fn) self.storePisiFiles()
# put files.xml, metadata.xml, actions.py and COMAR scripts # register comar scripts
# somewhere in the file system. We'll need these in future... self.registerCOMARScripts()
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 # update databases
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 # installdb
installdb.install(self.metadata.package.name,
# installdb self.metadata.package.version,
installdb.install(metadata.package.name, self.metadata.package.release,
metadata.package.version, os.path.join(self.ctx.files_dir(), 'files.xml'))
metadata.package.release,
os.path.join(config.install_dir(), 'files.xml'))