Some code to export repository metadata.
ts.run()
+ def provides(self, patterns):
+ pkgs = []
+
+ for pattern in patterns:
+ pkgs += self.repos.get_by_provides(pattern)
+
+ pkgs = packages.PackageListing(pkgs)
+ #pkgs.unique()
+
+ return pkgs
+
+ def repo_create(self, path):
+ if not os.path.exists(path) or not os.path.isdir(path):
+ raise PakfireError, "Given path is not existant or not a directory: %s" % path
+
+ repo = repository.RemoteRepository(
+ self,
+ name="new",
+ description="New repository.",
+ url="file://%s" % path,
+ gpgkey="XXX",
+ enabled=True,
+ )
+
+ repo.save_index()
+
import depsolve
import packages
+import repository
import transaction
import util
self.settings = {
"enable_loop_devices" : True,
- "enable_icecream" : False,
+ "enable_icecream" : True,
}
self.settings.update(settings)
self._packages = []
for pkg in pkgs:
- pkg = packages.VirtualPackage(self.pakfire, repo, pkg)
+ pkg = packages.VirtualPackage(self.pakfire, pkg) # XXX had to remove repo here?!
self._packages.append(pkg)
return self._packages
import sys
import packages
+import repository
from pakfire import Pakfire
self.parse_command_info()
self.parse_command_search()
self.parse_command_update()
+ self.parse_command_provides()
# Finally parse all arguments from the command line and save them.
self.args = self.parser.parse_args()
"update" : self.handle_update,
"info" : self.handle_info,
"search" : self.handle_search,
+ "provides" : self.handle_provides,
}
def parse_common_arguments(self):
help=_("A pattern to search for."))
sub_search.add_argument("action", action="store_const", const="search")
+ def parse_command_provides(self):
+ # Implement the "provides" command
+ sub_provides = self.sub_commands.add_parser("provides",
+ help=_("Get a list of packages that provide a given file or feature."))
+ sub_provides.add_argument("pattern", nargs="+",
+ help=_("File or feature to search for."))
+ sub_provides.add_argument("action", action="store_const", const="provides")
+
def run(self):
action = self.args.action
def handle_localinstall(self):
return self.handle_install(local=True)
+ def handle_provides(self):
+ pkgs = self.pakfire.provides(self.args.pattern)
+
+ for pkg in pkgs:
+ print pkg.dump()
+
class CliBuilder(Cli):
def __init__(self):
self.parse_command_search()
self.parse_command_shell()
self.parse_command_update()
+ self.parse_command_repo()
# Finally parse all arguments from the command line and save them.
self.args = self.parser.parse_args()
)
self.action2func = {
- "build" : self.handle_build,
- "dist" : self.handle_dist,
- "update" : self.handle_update,
- "info" : self.handle_info,
- "search" : self.handle_search,
- "shell" : self.handle_shell,
+ "build" : self.handle_build,
+ "dist" : self.handle_dist,
+ "update" : self.handle_update,
+ "info" : self.handle_info,
+ "search" : self.handle_search,
+ "shell" : self.handle_shell,
+ "repo_create" : self.handle_repo_create,
}
def parse_command_update(self):
sub_dist.add_argument("--resultdir", nargs="?",
help=_("Path were the output files should be copied to."))
+ def parse_command_repo(self):
+ sub_repo = self.sub_commands.add_parser("repo",
+ help=_("Repository management commands."))
+
+ sub_repo_commands = sub_repo.add_subparsers()
+
+ self.parse_command_repo_create(sub_repo_commands)
+
+ def parse_command_repo_create(self, sub_commands):
+ sub_create = sub_commands.add_parser("create",
+ help=_("Create a new repository index."))
+ sub_create.add_argument("path", nargs=1, help=_("Path to the packages."))
+ sub_create.add_argument("action", action="store_const", const="repo_create")
+
def handle_build(self):
print self.args
# Get the package descriptor from the command line options
self.pakfire.dist(pkg, self.args.resultdir)
+ def handle_repo_create(self):
+ path = self.args.path[0]
+
+ self.pakfire.repo_create(path)
+
CACHE_DIR = "/var/cache/pakfire"
PACKAGES_DB = "var/lib/pakfire/packages.db"
+REPOSITORY_DB = "index.db"
BUFFER_SIZE = 1024**2
def __del__(self):
if self._db:
- self._db.commit()
+ #self._db.commit()
self._db.close()
def create(self):
return self._db.cursor()
-class LocalPackageDatabase(Database):
+class PackageDatabase(Database):
def create(self):
c = self.cursor()
epoch INTEGER,
version TEXT,
release TEXT,
+ filename TEXT,
installed INTEGER,
reason TEXT,
repository TEXT,
c.close()
+ def package_exists(self, pkg):
+ return not self.get_id_by_pkg(pkg) is None
+
+ def get_id_by_pkg(self, pkg):
+ c = self.cursor()
+
+ c.execute("SELECT id FROM packages WHERE name = ? AND version = ? AND \
+ release = ? AND epoch = ? LIMIT 1", (pkg.name, pkg.version, pkg.release, pkg.epoch))
+
+ ret = None
+ for i in c:
+ ret = i["id"]
+ break
+
+ c.close()
+
+ return ret
+
+ def add_package(self, pkg):
+ if self.package_exists(pkg):
+ logging.debug("Skipping package which already exists in database: %s" % pkg.friendly_name)
+ return
+
+ logging.debug("Adding package to database: %s" % pkg.friendly_name)
+
+ c = self.cursor()
+ c.execute("""
+ INSERT INTO packages(
+ name,
+ epoch,
+ version,
+ release,
+ filename,
+ provides,
+ requires
+ ) VALUES(?, ?, ?, ?, ?, ?, ?)""",
+ (
+ pkg.name,
+ pkg.epoch,
+ pkg.version,
+ pkg.release,
+ pkg.filename,
+ " ".join(pkg.provides),
+ " ".join(pkg.requires),
+ )
+ )
+ c.close()
+ self.commit()
+
+ pkg_id = self.get_id_by_pkg(pkg)
+
+ c = self.cursor()
+ for file in pkg.filelist:
+ c.execute("INSERT INTO files(name, pkg) VALUES(?, ?)", (file, pkg_id))
+
+ c.close()
+ self.commit()
+
+
+class LocalPackageDatabase(PackageDatabase):
def add_package(self, pkg, installed=True):
c = self.cursor()
import logging
import os
+import database
import packages
from constants import *
Index.__init__(self, pakfire, repo)
+ # Always update this because it will otherwise contain no data
+ self.update(force=True)
+
def update(self, force=False):
logging.debug("Updating repository index '%s' (force=%s)" % (self.path, force))
+ # Do nothing if the update is not forced but populate the database
+ # if no packages are present.
+ if not force and self._packages:
+ return
+
+ # If we update the cache, we clear it first.
+ self._packages = []
+
for dir, subdirs, files in os.walk(self.path):
for file in files:
# Skip files that do not have the right extension
self._packages.append(package)
+ def save(self, path=None):
+ if not path:
+ path = self.path
+
+ path = os.path.join(path, "index.db")
+
+ db = database.PackageDatabase(self.pakfire, path)
-class InstalledIndex(Index):
+ for pkg in self.packages:
+ db.add_package(pkg)
+
+ db.close()
+
+
+class DatabaseIndex(Index):
def __init__(self, pakfire, repo, db):
self.db = db
Index.__init__(self, pakfire, repo)
+ def update(self, force=False):
+ """
+ Nothing to do here.
+ """
+ pass
+
def get_all_by_name(self, name):
c = self.db.cursor()
c.execute("SELECT * FROM packages WHERE name = ?", name)
for pkg in c:
- yield package.InstalledPackage(self.pakfire, self.db, pkg)
+ yield package.DatabasePackage(self.pakfire, self.db, pkg)
c.close()
c.execute("SELECT * FROM packages")
for pkg in c:
- yield packages.InstalledPackage(self.pakfire, self.db, pkg)
+ yield packages.DatabasePackage(self.pakfire, self.db, pkg)
c.close()
+
+# XXX maybe this can be removed later?
+class InstalledIndex(DatabaseIndex):
+ pass
+
#!/usr/bin/python
from binary import BinaryPackage
-from installed import InstalledPackage
+from installed import DatabasePackage, InstalledPackage
from source import SourcePackage
from virtual import VirtualPackage
from base import Package
-
-# XXX maybe this gets renamed to "DatabasePackage" or something similar.
-
-class InstalledPackage(Package):
- type = "installed"
+class DatabasePackage(Package):
+ type = "db"
def __init__(self, pakfire, db, data):
Package.__init__(self, pakfire, pakfire.repos.local)
(filename, self.id, size, type, hash1, time.time()))
c.close()
+
+# XXX maybe we can remove this later?
+class InstalledPackage(DatabasePackage):
+ type = "installed"
+
self.archive = None
self._tempfile = None
- self._uncompress_data()
+ if pkg.payload_compression == "XXX":
+ self.archive = tarfile.open(fileobj=self.data)
+ else:
+ self._uncompress_data()
def cleanup(self):
# XXX not called by anything
if member.isdir() and os.path.exists(target):
return
- if self.pakfire.config.get("debug"):
- msg = "Creating file (%s:%03d:%03d) " % \
- (tarfile.filemode(member.mode), member.uid, member.gid)
- if member.issym():
- msg += "/%s -> %s" % (member.name, member.linkname)
- elif member.islnk():
- msg += "/%s link to /%s" % (member.name, member.linkname)
- else:
- msg += "/%s" % member.name
- logging.debug(msg)
+ #if self.pakfire.config.get("debug"):
+ # msg = "Creating file (%s:%03d:%03d) " % \
+ # (tarfile.filemode(member.mode), member.uid, member.gid)
+ # if member.issym():
+ # msg += "/%s -> %s" % (member.name, member.linkname)
+ # elif member.islnk():
+ # msg += "/%s link to /%s" % (member.name, member.linkname)
+ # else:
+ # msg += "/%s" % member.name
+ # logging.debug(msg)
# Remove file if it has been existant
if not member.isdir() and os.path.exists(target):
if self.index:
self.index.update(force=force)
+ def save_index(self, path=None):
+ self.index.save(path)
+
#def get_all(self, requires):
# for pkg in self.index.get_all():
# if pkg.does_provide(requires):
s.append("")
print "\n".join(s)
+
projects / pakfire.git / commitdiff
