dizin yapımız tamam.

InstallContext düzeltildi.
ödül olarak install.py class yapısı kazandı...

pisi/cli/installhelper.py

@@ -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):
-    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

@@ -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):

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"

pisi/context.py

@@ -3,9 +3,12 @@
 # Authors: Baris Metin <baris@uludag.org.tr
 #          Eray Ozkural <eray@uludag.org.tr>
 
-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):
+        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.read(metadatafile)
+            metadata.read(metadataxml)
-            metadata.verify()
+            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() \
+            return self.lib_dir() + '/' + packageDir
-                + '/' + 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):
+    def __init__(self, packagefile):
-        self.__instance.setMetadataFile(mdfile)
+        self.__instance.setPackage(packagefile)
 
     def __getattr__(self, attr):
         return getattr(self.__instance, attr)

pisi/install.py

@@ -26,42 +26,8 @@ import comariface
 class InstallError(Exception):
     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):
     """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
 
-    # check package semantics
+    def extractInstall(self):
-    if not metadata.verify():
+        ui.info('Extracting files\n')
-        raise InstallError("MetaData format wrong")
+        self.package.extract_dir_flat('install', config.destdir)
+    
+    def storePisiFiles(self):
+        # put files.xml, metadata.xml, actions.py and COMAR scripts
+        # somewhere in the file system. We'll need these in future...
+
+        ui.info('Storing %s\n' % const.files_xml)
+        self.package.extract_file(const.files_xml, self.ctx.files_dir())
+
+        ui.info('Storing %s\n' % const.metadata_xml)
+        self.package.extract_file(const.metadata_xml, self.ctx.metadata_dir())
+
+        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.?
 
-    package = metadata.package
+        pkginfo = self.metadata.package
 
         # check if package is in database
-    if not packagedb.has_package(package.name):
+        if not packagedb.has_package(pkginfo.name):
-        packagedb.add_package(package) # terrible solution it seems
+            packagedb.add_package(pkginfo) # terrible solution it seems
     
         # 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)
     
         # check dependencies
-    if not dependency.installable(package.name):
+        if not dependency.installable(pkginfo.name):
             raise InstallError("Package not installable")
 
         #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 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 package.version > iversion:
+            if pkginfo.version > iversion:
                 ui.info('Upgrading to new upstream version')
                 upgrade = True
-        elif package.release > irelease:
+            elif pkginfo.release > irelease:
                 ui.info('Upgrading to new distribution release')
                 upgrade = True
 
             # is this a downgrade? confirm this action.
             if not upgrade:
-            if package.version < iversion:
+                if pkginfo.version < iversion:
                     x = 'Downgrade to old upstream version?'
-            elif package.release < irelease:
+                elif pkginfo.release < irelease:
                     x = 'Downgrade to old distribution release?'
                 if not ui.confirm(x):
                     raise InstallError('Package downgrade declined')
 
                 # remove old package then
-        remove(package.name)
+                remove(pkginfo.name)
 
         # unzip package in place
-    extract_pkg_files(package_fn)
+        self.extractInstall()
 
-    # put files.xml, metadata.xml, actions.py and COMAR scripts
+        # store files.xml, metadata.xml and comar scripts for further usage
-    # somewhere in the file system. We'll need these in future...
+        self.storePisiFiles()
-    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
-    # register COMAR scripts
+        self.registerCOMARScripts()
-    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(metadata.package.name,
+        installdb.install(self.metadata.package.name,
-                      metadata.package.version,
+                          self.metadata.package.version,
-                      metadata.package.release,
+                          self.metadata.package.release,
-                      os.path.join(config.install_dir(), 'files.xml'))
+                          os.path.join(self.ctx.files_dir(), 'files.xml'))