* Caglar'in da geregini belirttigi gibi, reverse-depends db'si hazirla

* Bu database remove algoritmasinda kullaniliyor
* Bug'li da olsa basladik bir kere remove etmeye gerisi gelir :)

pisi/packagedb.py

@@ -23,15 +23,17 @@ class PackageDB(object):
     a delegated dbshelve object"""
     def __init__(self, id):
         util.check_dir(config.db_dir())
-        self.filename = os.path.join(config.db_dir(), 'package-' + id + '.bdb')
+        self.fname = os.path.join(config.db_dir(), 'package-%s.bdb' % id )
-        self.d = shelve.open(self.filename)
+        self.d = shelve.open(self.fname)
-        self.fdummy = file(self.filename + '.lock', 'w')
+        self.fname2 = os.path.join(config.db_dir(), 'revdep-%s.bdb'  % id )
+        self.dr = shelve.open(self.fname2)
+        self.fdummy = file(self.fname + '.lock', 'w')
         fcntl.flock(self.fdummy, fcntl.LOCK_EX)
 
     def __del__(self):
         #fcntl.flock(self.fdummy, fcntl.LOCK_UN)
         self.fdummy.close()
-        #os.unlink(self.filename + '.lock')
+        #os.unlink(self.fname + '.lock')
 
     def has_package(self, name):
         name = str(name)
@@ -41,9 +43,20 @@ class PackageDB(object):
         name = str(name)
         return self.d[name]
 
+    def get_rev_deps(self, name):
+        name = str(name)
+        a = self.dr[name]
+        return a
+
     def add_package(self, package_info):
         name = str(package_info.name)
         self.d[name] = package_info
+        for dep in package_info.runtimeDeps:
+            dep_name = str(dep.package)
+            if self.dr.has_key(dep_name):
+                self.dr[dep_name].append(dep)
+            else:
+                self.dr[dep_name] = [dep]
 
     def clear(self):
         self.d.clear()
@@ -83,6 +96,10 @@ def get_package(name):
             return get_db(repo).get_package(name)
     raise PackageDBError, 'get_package: package ' + name + ' not found'
 
+def get_rev_deps(name):
+    repo = which_repo(name)
+    return get_db(repo).get_rev_deps(name)
+
 #def remove_package
 
 inst_packagedb = PackageDB('local')

pisi/pgraph.py

@@ -27,6 +27,18 @@ class PGraph(digraph):
         self.add_edge(str(pkg), str(depinfo.package), ('d', depinfo),
                       pkg1data, pkg2data )
 
+    def add_rev_dep(self, depinfo, pkg):
+        pkg1data = None
+        if not pkg in self.vertices():
+            pkg1 = packagedb.get_package(depinfo.package)
+            pkg1data = (pkg1.version, pkg1.release)
+        pkg2data = None
+        if not depinfo.package in self.vertices():
+            pkg2 = packagedb.get_package(pkg)
+            pkg2data = (pkg2.version, pkg2.release) 
+        self.add_edge(str(depinfo.package), str(pkg), ('d', depinfo),
+                      pkg1data, pkg2data )
+
     def add_conflict(self, pkg, conflinfo):
         pkg1data = None
         if not pkg in self.vertices():

pisi/toplevel.py

@@ -100,10 +100,46 @@ def install_pkg_names(A):
         
     return True                         # everything went OK :)
 
-def remove(packages):
+def remove(A):
-    #TODO: this for loop is just a placeholder
+    """remove set A of packages from system"""
-    for x in packages:
+    
-        operations.remove_single(x)
+    if len(A)==0:
+        return True
+    
+    # try to construct a pisi graph of packages to
+    # install / reinstall
+
+    G_f = pgraph.PGraph()               # construct G_f
+
+    # find the "install closure" graph of G_f by package 
+    # set A using packagedb
+    print A
+    for x in A:
+        G_f.add_package(x)
+    B = A
+    #state = {}
+    while len(B) > 0:
+        Bp = set()
+        for x in B:
+            pkg = packagedb.get_package(x)
+            print pkg
+            rev_deps = packagedb.get_rev_deps(x)
+            for dep in rev_deps:
+                print 'checking ', dep
+                # we don't deal with satisfied dependencies
+                if not dependency.satisfiesDep(dep.package, dep):
+                    if not dep.package in G_f.vertices():
+                        Bp.add(str(dep.package))
+                        G_f.add_rev_dep(dep, x)
+        B = Bp
+    G_f.write_graphviz(sys.stdout)
+    l = G_f.topological_sort()
+    print l
+    for x in l:
+        #operations.remove_single_name(x)
+        pass
+        
+    return True                         # everything went OK :)
 
 
 def info(package_name):