zeroinstall/injector/distro.py

   1 """
   2 Integration with native distribution package managers.
   3 @since: 0.28
   4 """
   5
   6 # Copyright (C) 2009, Thomas Leonard
   7 # See the README file for details, or visit http://0install.net.
   8
   9 from zeroinstall import _
  10 import os, platform, re, subprocess, sys
  11 from logging import warn, info
  12 from zeroinstall.injector import namespaces, model, arch
  13 from zeroinstall.support import basedir
  14
  15 _dotted_ints = '[0-9]+(?:\.[0-9]+)*'
  16
  17 # This matches a version number that would be a valid Zero Install version without modification
  18 _zeroinstall_regexp = '(?:%s)(?:-(?:pre|rc|post|)(?:%s))*' % (_dotted_ints, _dotted_ints)
  19
  20 # This matches the interesting bits of distribution version numbers
  21 # (first bit is for Java-style 6b17 syntax)
  22 _version_regexp = '({ints}b)?({zero})(-r{ints})?'.format(zero = _zeroinstall_regexp, ints = _dotted_ints)
  23
  24 # We try to do updates atomically without locking, but we don't worry too much about
  25 # duplicate entries or being a little out of sync with the on-disk copy.
  26 class Cache(object):
  27         def __init__(self, cache_leaf, source, format):
  28                 """Maintain a cache file (e.g. ~/.cache/0install.net/injector/$name).
  29                 If the size or mtime of $source has changed, or the cache
  30                 format version if different, reset the cache first."""
  31                 self.cache_leaf = cache_leaf
  32                 self.source = source
  33                 self.format = format
  34                 self.cache_dir = basedir.save_cache_path(namespaces.config_site,
  35                                                          namespaces.config_prog)
  36                 self.cached_for = {}            # Attributes of source when cache was created
  37                 try:
  38                         self._load_cache()
  39                 except Exception as ex:
  40                         info(_("Failed to load cache (%s). Flushing..."), ex)
  41                         self.flush()
  42
  43         def flush(self):
  44                 # Wipe the cache
  45                 try:
  46                         info = os.stat(self.source)
  47                         mtime = int(info.st_mtime)
  48                         size = info.st_size
  49                 except Exception as ex:
  50                         warn("Failed to stat %s: %s", self.source, ex)
  51                         mtime = size = 0
  52                 self.cache = {}
  53                 import tempfile
  54                 tmp, tmp_name = tempfile.mkstemp(dir = self.cache_dir)
  55                 data = "mtime=%d\nsize=%d\nformat=%d\n\n" % (mtime, size, self.format)
  56                 while data:
  57                         wrote = os.write(tmp, data)
  58                         data = data[wrote:]
  59                 os.rename(tmp_name, os.path.join(self.cache_dir, self.cache_leaf))
  60
  61                 self._load_cache()
  62
  63         # Populate self.cache from our saved cache file.
  64         # Throws an exception if the cache doesn't exist or has the wrong format.
  65         def _load_cache(self):
  66                 self.cache = cache = {}
  67                 stream = file(os.path.join(self.cache_dir, self.cache_leaf))
  68                 try:
  69                         for line in stream:
  70                                 line = line.strip()
  71                                 if not line:
  72                                         break
  73                                 key, value = line.split('=', 1)
  74                                 if key in ('mtime', 'size', 'format'):
  75                                         self.cached_for[key] = int(value)
  76
  77                         self._check_valid()
  78
  79                         for line in stream:
  80                                 key, value = line.split('=', 1)
  81                                 cache[key] = value[:-1]
  82                 finally:
  83                         stream.close()
  84
  85         # Check the source file hasn't changed since we created the cache
  86         def _check_valid(self):
  87                 info = os.stat(self.source)
  88                 if self.cached_for['mtime'] != int(info.st_mtime):
  89                         raise Exception("Modification time of %s has changed" % self.source)
  90                 if self.cached_for['size'] != info.st_size:
  91                         raise Exception("Size of %s has changed" % self.source)
  92                 if self.cached_for.get('format', None) != self.format:
  93                         raise Exception("Format of cache has changed")
  94
  95         def get(self, key):
  96                 try:
  97                         self._check_valid()
  98                 except Exception as ex:
  99                         info(_("Cache needs to be refreshed: %s"), ex)
 100                         self.flush()
 101                         return None
 102                 else:
 103                         return self.cache.get(key, None)
 104
 105         def put(self, key, value):
 106                 cache_path = os.path.join(self.cache_dir, self.cache_leaf)
 107                 self.cache[key] = value
 108                 try:
 109                         stream = file(cache_path, 'a')
 110                         try:
 111                                 stream.write('%s=%s\n' % (key, value))
 112                         finally:
 113                                 stream.close()
 114                 except Exception as ex:
 115                         warn("Failed to write to cache %s: %s=%s: %s", cache_path, key, value, ex)
 116
 117 def try_cleanup_distro_version(version):
 118         """Try to turn a distribution version string into one readable by Zero Install.
 119         We do this by stripping off anything we can't parse.
 120         @return: the part we understood, or None if we couldn't parse anything
 121         @rtype: str"""
 122         if ':' in version:
 123                 version = version.split(':')[1] # Skip 'epoch'
 124         version = version.replace('_', '-')
 125         match = re.match(_version_regexp, version)
 126         if match:
 127                 major, version, revision = match.groups()
 128                 if major is not None:
 129                         version = major[:-1] + '.' + version
 130                 if revision is None:
 131                         return version
 132                 else:
 133                         return '%s-%s' % (version, revision[2:])
 134         return None
 135
 136 class Distribution(object):
 137         """Represents a distribution with which we can integrate.
 138         Sub-classes should specialise this to integrate with the package managers of
 139         particular distributions. This base class ignores the native package manager.
 140         @since: 0.28
 141         """
 142         _packagekit = None
 143
 144         def get_package_info(self, package, factory):
 145                 """Get information about the given package.
 146                 Add zero or more implementations using the factory (typically at most two
 147                 will be added; the currently installed version and the latest available).
 148                 @param package: package name (e.g. "gimp")
 149                 @type package: str
 150                 @param factory: function for creating new DistributionImplementation objects from IDs
 151                 @type factory: str -> L{model.DistributionImplementation}
 152                 """
 153                 return
 154
 155         def get_score(self, distribution):
 156                 """Indicate how closely the host distribution matches this one.
 157                 The <package-implementation> with the highest score is passed
 158                 to L{Distribution.get_package_info}. If several elements get
 159                 the same score, get_package_info is called for all of them.
 160                 @param distribution: a distribution name
 161                 @type distribution: str
 162                 @return: an integer, or None if there is no match at all
 163                 @rtype: int | None
 164                 """
 165                 return 0
 166
 167         def get_feed(self, master_feed):
 168                 """Generate a feed containing information about distribution packages.
 169                 This should immediately return a feed containing an implementation for the
 170                 package if it's already installed. Information about versions that could be
 171                 installed using the distribution's package manager can be added asynchronously
 172                 later (see L{fetch_candidates}).
 173                 @param master_feed: feed containing the <package-implementation> elements
 174                 @type master_feed: L{model.ZeroInstallFeed}
 175                 @rtype: L{model.ZeroInstallFeed}"""
 176
 177                 feed = model.ZeroInstallFeed(None)
 178                 feed.url = 'distribution:' + master_feed.url
 179
 180                 for item, item_attrs in master_feed.get_package_impls(self):
 181                         package = item_attrs.get('package', None)
 182                         if package is None:
 183                                 raise model.InvalidInterface(_("Missing 'package' attribute on %s") % item)
 184
 185                         def factory(id, only_if_missing = False, installed = True):
 186                                 assert id.startswith('package:')
 187                                 if id in feed.implementations:
 188                                         if only_if_missing:
 189                                                 return None
 190                                         warn(_("Duplicate ID '%s' for DistributionImplementation"), id)
 191                                 impl = model.DistributionImplementation(feed, id, self)
 192                                 feed.implementations[id] = impl
 193
 194                                 impl.installed = installed
 195                                 impl.metadata = item_attrs
 196
 197                                 item_main = item_attrs.get('main', None)
 198                                 if item_main and not item_main.startswith('/'):
 199                                         raise model.InvalidInterface(_("'main' attribute must be absolute, but '%s' doesn't start with '/'!") %
 200                                                                 item_main)
 201                                 impl.main = item_main
 202                                 impl.upstream_stability = model.packaged
 203
 204                                 return impl
 205
 206                         self.get_package_info(package, factory)
 207
 208                 if master_feed.url == 'http://repo.roscidus.com/python/python' and all(not impl.installed for impl in feed.implementations.values()):
 209                         # Hack: we can support Python on platforms with unsupported package managers
 210                         # by adding the implementation of Python running us now to the list.
 211                         python_version = '.'.join([str(v) for v in sys.version_info if isinstance(v, int)])
 212                         impl_id = 'package:host:python:' + python_version
 213                         assert impl_id not in feed.implementations
 214                         impl = model.DistributionImplementation(feed, impl_id, self)
 215                         impl.installed = True
 216                         impl.version = model.parse_version(python_version)
 217                         impl.main = sys.executable
 218                         impl.upstream_stability = model.packaged
 219                         impl.machine = host_machine     # (hopefully)
 220                         feed.implementations[impl_id] = impl
 221
 222                 return feed
 223
 224         def fetch_candidates(self, master_feed):
 225                 """Collect information about versions we could install using
 226                 the distribution's package manager. On success, the distribution
 227                 feed in iface_cache is updated.
 228                 @return: a L{tasks.Blocker} if the task is in progress, or None if not"""
 229                 if self.packagekit.available:
 230                         package_names = [item.getAttribute("package") for item, item_attrs in master_feed.get_package_impls(self)]
 231                         return self.packagekit.fetch_candidates(package_names)
 232
 233         @property
 234         def packagekit(self):
 235                 """For use by subclasses.
 236                 @rtype: L{packagekit.PackageKit}"""
 237                 if not self._packagekit:
 238                         from zeroinstall.injector import packagekit
 239                         self._packagekit = packagekit.PackageKit()
 240                 return self._packagekit
 241
 242 class CachedDistribution(Distribution):
 243         """For distributions where querying the package database is slow (e.g. requires running
 244         an external command), we cache the results.
 245         @since: 0.39
 246         @deprecated: use Cache instead
 247         """
 248
 249         def __init__(self, db_status_file):
 250                 """@param db_status_file: update the cache when the timestamp of this file changes"""
 251                 self._status_details = os.stat(db_status_file)
 252
 253                 self.versions = {}
 254                 self.cache_dir = basedir.save_cache_path(namespaces.config_site,
 255                                                          namespaces.config_prog)
 256
 257                 try:
 258                         self._load_cache()
 259                 except Exception as ex:
 260                         info(_("Failed to load distribution database cache (%s). Regenerating..."), ex)
 261                         try:
 262                                 self.generate_cache()
 263                                 self._load_cache()
 264                         except Exception as ex:
 265                                 warn(_("Failed to regenerate distribution database cache: %s"), ex)
 266
 267         def _load_cache(self):
 268                 """Load {cache_leaf} cache file into self.versions if it is available and up-to-date.
 269                 Throws an exception if the cache should be (re)created."""
 270                 stream = file(os.path.join(self.cache_dir, self.cache_leaf))
 271
 272                 cache_version = None
 273                 for line in stream:
 274                         if line == '\n':
 275                                 break
 276                         name, value = line.split(': ')
 277                         if name == 'mtime' and int(value) != int(self._status_details.st_mtime):
 278                                 raise Exception(_("Modification time of package database file has changed"))
 279                         if name == 'size' and int(value) != self._status_details.st_size:
 280                                 raise Exception(_("Size of package database file has changed"))
 281                         if name == 'version':
 282                                 cache_version = int(value)
 283                 else:
 284                         raise Exception(_('Invalid cache format (bad header)'))
 285
 286                 if cache_version is None:
 287                         raise Exception(_('Old cache format'))
 288
 289                 versions = self.versions
 290                 for line in stream:
 291                         package, version, zi_arch = line[:-1].split('\t')
 292                         versionarch = (version, intern(zi_arch))
 293                         if package not in versions:
 294                                 versions[package] = [versionarch]
 295                         else:
 296                                 versions[package].append(versionarch)
 297
 298         def _write_cache(self, cache):
 299                 #cache.sort()   # Might be useful later; currently we don't care
 300                 import tempfile
 301                 fd, tmpname = tempfile.mkstemp(prefix = 'zeroinstall-cache-tmp',
 302                                                dir = self.cache_dir)
 303                 try:
 304                         stream = os.fdopen(fd, 'wb')
 305                         stream.write('version: 2\n')
 306                         stream.write('mtime: %d\n' % int(self._status_details.st_mtime))
 307                         stream.write('size: %d\n' % self._status_details.st_size)
 308                         stream.write('\n')
 309                         for line in cache:
 310                                 stream.write(line + '\n')
 311                         stream.close()
 312
 313                         os.rename(tmpname,
 314                                   os.path.join(self.cache_dir,
 315                                                self.cache_leaf))
 316                 except:
 317                         os.unlink(tmpname)
 318                         raise
 319
 320 # Maps machine type names used in packages to their Zero Install versions
 321 _canonical_machine = {
 322         'all' : '*',
 323         'any' : '*',
 324         'noarch' : '*',
 325         '(none)' : '*',
 326         'amd64': 'x86_64',
 327         'i386': 'i386',
 328         'i486': 'i486',
 329         'i586': 'i586',
 330         'i686': 'i686',
 331         'ppc64': 'ppc64',
 332         'ppc': 'ppc',
 333 }
 334
 335 host_machine = arch.canonicalize_machine(platform.uname()[4])
 336 def canonical_machine(package_machine):
 337         machine = _canonical_machine.get(package_machine, None)
 338         if machine is None:
 339                 # Safe default if we can't understand the arch
 340                 return host_machine
 341         return machine
 342
 343 class DebianDistribution(Distribution):
 344         """A dpkg-based distribution."""
 345
 346         cache_leaf = 'dpkg-status.cache'
 347
 348         def __init__(self, dpkg_status, pkgcache):
 349                 self.dpkg_cache = Cache('dpkg-status.cache', dpkg_status, 2)
 350                 self.apt_cache = {}
 351
 352         def _query_installed_package(self, package):
 353                 null = os.open('/dev/null', os.O_WRONLY)
 354                 child = subprocess.Popen(["dpkg-query", "-W", "--showformat=${Version}\t${Architecture}\t${Status}\n", "--", package],
 355                                                 stdout = subprocess.PIPE, stderr = null)
 356                 os.close(null)
 357                 stdout, stderr = child.communicate()
 358                 child.wait()
 359                 for line in stdout.split('\n'):
 360                         if not line: continue
 361                         version, debarch, status = line.split('\t', 2)
 362                         if not status.endswith(' installed'): continue
 363                         clean_version = try_cleanup_distro_version(version)
 364                         if clean_version:
 365                                 return '%s\t%s' % (clean_version, canonical_machine(debarch.strip()))
 366                         else:
 367                                 warn(_("Can't parse distribution version '%(version)s' for package '%(package)s'"), {'version': version, 'package': package})
 368
 369                 return '-'
 370
 371         def get_package_info(self, package, factory):
 372                 # Add any already-installed package...
 373                 installed_cached_info = self._get_dpkg_info(package)
 374
 375                 if installed_cached_info != '-':
 376                         installed_version, machine = installed_cached_info.split('\t')
 377                         impl = factory('package:deb:%s:%s:%s' % (package, installed_version, machine))
 378                         impl.version = model.parse_version(installed_version)
 379                         if machine != '*':
 380                                 impl.machine = machine
 381                 else:
 382                         installed_version = None
 383
 384                 # Add any uninstalled candidates (note: only one of these two methods will add anything)
 385
 386                 # From PackageKit...
 387                 self.packagekit.get_candidates(package, factory, 'package:deb')
 388
 389                 # From apt-cache...
 390                 cached = self.apt_cache.get(package, None)
 391                 if cached:
 392                         candidate_version = cached['version']
 393                         candidate_arch = cached['arch']
 394                         if candidate_version and candidate_version != installed_version:
 395                                 impl = factory('package:deb:%s:%s:%s' % (package, candidate_version, candidate_arch), installed = False)
 396                                 impl.version = model.parse_version(candidate_version)
 397                                 if candidate_arch != '*':
 398                                         impl.machine = candidate_arch
 399                                 def install(handler):
 400                                         raise model.SafeException(_("This program depends on '%s', which is a package that is available through your distribution. "
 401                                                         "Please install it manually using your distribution's tools and try again.") % package)
 402                                 impl.download_sources.append(model.DistributionSource(package, cached['size'], install, needs_confirmation = False))
 403
 404         def get_score(self, disto_name):
 405                 return int(disto_name == 'Debian')
 406
 407         def _get_dpkg_info(self, package):
 408                 installed_cached_info = self.dpkg_cache.get(package)
 409                 if installed_cached_info == None:
 410                         installed_cached_info = self._query_installed_package(package)
 411                         self.dpkg_cache.put(package, installed_cached_info)
 412
 413                 return installed_cached_info
 414
 415         def fetch_candidates(self, master_feed):
 416                 package_names = [item.getAttribute("package") for item, item_attrs in master_feed.get_package_impls(self)]
 417
 418                 if self.packagekit.available:
 419                         return self.packagekit.fetch_candidates(package_names)
 420
 421                 # No PackageKit. Use apt-cache directly.
 422                 for package in package_names:
 423                         # Check to see whether we could get a newer version using apt-get
 424                         try:
 425                                 null = os.open('/dev/null', os.O_WRONLY)
 426                                 child = subprocess.Popen(['apt-cache', 'show', '--no-all-versions', '--', package], stdout = subprocess.PIPE, stderr = null)
 427                                 os.close(null)
 428
 429                                 arch = version = size = None
 430                                 for line in child.stdout:
 431                                         line = line.strip()
 432                                         if line.startswith('Version: '):
 433                                                 version = line[9:]
 434                                                 version = try_cleanup_distro_version(version)
 435                                         elif line.startswith('Architecture: '):
 436                                                 arch = canonical_machine(line[14:].strip())
 437                                         elif line.startswith('Size: '):
 438                                                 size = int(line[6:].strip())
 439                                 if version and arch:
 440                                         cached = {'version': version, 'arch': arch, 'size': size}
 441                                 else:
 442                                         cached = None
 443                                 child.wait()
 444                         except Exception as ex:
 445                                 warn("'apt-cache show %s' failed: %s", package, ex)
 446                                 cached = None
 447                         # (multi-arch support? can there be multiple candidates?)
 448                         self.apt_cache[package] = cached
 449
 450 class RPMDistribution(CachedDistribution):
 451         """An RPM-based distribution."""
 452
 453         cache_leaf = 'rpm-status.cache'
 454
 455         def generate_cache(self):
 456                 cache = []
 457
 458                 for line in os.popen("rpm -qa --qf='%{NAME}\t%{VERSION}-%{RELEASE}\t%{ARCH}\n'"):
 459                         package, version, rpmarch = line.split('\t', 2)
 460                         if package == 'gpg-pubkey':
 461                                 continue
 462                         zi_arch = canonical_machine(rpmarch.strip())
 463                         clean_version = try_cleanup_distro_version(version)
 464                         if clean_version:
 465                                 cache.append('%s\t%s\t%s' % (package, clean_version, zi_arch))
 466                         else:
 467                                 warn(_("Can't parse distribution version '%(version)s' for package '%(package)s'"), {'version': version, 'package': package})
 468
 469                 self._write_cache(cache)
 470
 471         def get_package_info(self, package, factory):
 472                 # Add installed versions...
 473                 versions = self.versions.get(package, [])
 474
 475                 for version, machine in versions:
 476                         impl = factory('package:rpm:%s:%s:%s' % (package, version, machine))
 477                         impl.version = model.parse_version(version)
 478                         if machine != '*':
 479                                 impl.machine = machine
 480
 481                 # Add any uninstalled candidates found by PackageKit
 482                 self.packagekit.get_candidates(package, factory, 'package:rpm')
 483
 484         def get_score(self, disto_name):
 485                 return int(disto_name == 'RPM')
 486
 487 class SlackDistribution(Distribution):
 488         """A Slack-based distribution."""
 489
 490         def __init__(self, packages_dir):
 491                 self._packages_dir = packages_dir
 492
 493         def get_package_info(self, package, factory):
 494                 # Add installed versions...
 495                 for entry in os.listdir(self._packages_dir):
 496                         name, version, arch, build = entry.rsplit('-', 3)
 497                         if name == package:
 498                                 zi_arch = canonical_machine(arch)
 499                                 clean_version = try_cleanup_distro_version("%s-%s" % (version, build))
 500                                 if not clean_version:
 501                                         warn(_("Can't parse distribution version '%(version)s' for package '%(package)s'"), {'version': version, 'package': name})
 502                                         continue
 503
 504                                 impl = factory('package:slack:%s:%s:%s' % \
 505                                                 (package, clean_version, zi_arch))
 506                                 impl.version = model.parse_version(clean_version)
 507                                 if zi_arch != '*':
 508                                         impl.machine = zi_arch
 509
 510                 # Add any uninstalled candidates found by PackageKit
 511                 self.packagekit.get_candidates(package, factory, 'package:slack')
 512
 513         def get_score(self, disto_name):
 514                 return int(disto_name == 'Slack')
 515
 516 class GentooDistribution(Distribution):
 517
 518         def __init__(self, pkgdir):
 519                 self._pkgdir = pkgdir
 520
 521         def get_package_info(self, package, factory):
 522                 # Add installed versions...
 523                 _version_start_reqexp = '-[0-9]'
 524
 525                 if package.count('/') != 1: return
 526
 527                 category, leafname = package.split('/')
 528                 category_dir = os.path.join(self._pkgdir, category)
 529                 match_prefix = leafname + '-'
 530
 531                 if not os.path.isdir(category_dir): return
 532
 533                 for filename in os.listdir(category_dir):
 534                         if filename.startswith(match_prefix) and filename[len(match_prefix)].isdigit():
 535                                 name = file(os.path.join(category_dir, filename, 'PF')).readline().strip()
 536
 537                                 match = re.search(_version_start_reqexp, name)
 538                                 if match is None:
 539                                         warn(_('Cannot parse version from Gentoo package named "%(name)s"'), {'name': name})
 540                                         continue
 541                                 else:
 542                                         version = try_cleanup_distro_version(name[match.start() + 1:])
 543
 544                                 if category == 'app-emulation' and name.startswith('emul-'):
 545                                         __, __, machine, __ = name.split('-', 3)
 546                                 else:
 547                                         machine, __ = file(os.path.join(category_dir, filename, 'CHOST')).readline().split('-', 1)
 548                                 machine = arch.canonicalize_machine(machine)
 549
 550                                 impl = factory('package:gentoo:%s:%s:%s' % \
 551                                                 (package, version, machine))
 552                                 impl.version = model.parse_version(version)
 553                                 impl.machine = machine
 554
 555                 # Add any uninstalled candidates found by PackageKit
 556                 self.packagekit.get_candidates(package, factory, 'package:gentoo')
 557
 558         def get_score(self, disto_name):
 559                 return int(disto_name == 'Gentoo')
 560
 561 class PortsDistribution(Distribution):
 562
 563         def __init__(self, pkgdir):
 564                 self._pkgdir = pkgdir
 565
 566         def get_package_info(self, package, factory):
 567                 _name_version_regexp = '^(.+)-([^-]+)$'
 568
 569                 nameversion = re.compile(_name_version_regexp)
 570                 for pkgname in os.listdir(self._pkgdir):
 571                         pkgdir = os.path.join(self._pkgdir, pkgname)
 572                         if not os.path.isdir(pkgdir): continue
 573
 574                         #contents = file(os.path.join(pkgdir, '+CONTENTS')).readline().strip()
 575
 576                         match = nameversion.search(pkgname)
 577                         if match is None:
 578                                 warn(_('Cannot parse version from Ports package named "%(pkgname)s"'), {'pkgname': pkgname})
 579                                 continue
 580                         else:
 581                                 name = match.group(1)
 582                                 if name != package:
 583                                         continue
 584                                 version = try_cleanup_distro_version(match.group(2))
 585
 586                         machine = host_machine
 587
 588                         impl = factory('package:ports:%s:%s:%s' % \
 589                                                 (package, version, machine))
 590                         impl.version = model.parse_version(version)
 591                         impl.machine = machine
 592
 593         def get_score(self, disto_name):
 594                 return int(disto_name == 'Ports')
 595
 596 _host_distribution = None
 597 def get_host_distribution():
 598         """Get a Distribution suitable for the host operating system.
 599         Calling this twice will return the same object.
 600         @rtype: L{Distribution}"""
 601         global _host_distribution
 602         if not _host_distribution:
 603                 dpkg_db_status = '/var/lib/dpkg/status'
 604                 pkgcache = '/var/cache/apt/pkgcache.bin'
 605                 _rpm_db = '/var/lib/rpm/Packages'
 606                 _slack_db = '/var/log/packages'
 607                 _pkg_db = '/var/db/pkg'
 608
 609                 if os.path.isdir(_pkg_db):
 610                         if sys.platform.startswith("linux"):
 611                                 _host_distribution = GentooDistribution(_pkg_db)
 612                         elif sys.platform.startswith("freebsd"):
 613                                 _host_distribution = PortsDistribution(_pkg_db)
 614                 elif os.access(dpkg_db_status, os.R_OK):
 615                         _host_distribution = DebianDistribution(dpkg_db_status, pkgcache)
 616                 elif os.path.isfile(_rpm_db):
 617                         _host_distribution = RPMDistribution(_rpm_db)
 618                 elif os.path.isdir(_slack_db):
 619                         _host_distribution = SlackDistribution(_slack_db)
 620                 else:
 621                         _host_distribution = Distribution()
 622
 623         return _host_distribution