| import sys |
| import os |
| import urllib |
| import urlparse |
| import plistlib |
| import distutils.util |
| import md5 |
| |
| _scriptExc_NotInstalled = "pimp._scriptExc_NotInstalled" |
| _scriptExc_OldInstalled = "pimp._scriptExc_OldInstalled" |
| _scriptExc_BadInstalled = "pimp._scriptExc_BadInstalled" |
| |
| NO_EXECUTE=0 |
| |
| DEFAULT_FLAVORORDER=['source', 'binary'] |
| DEFAULT_DOWNLOADDIR='/tmp' |
| DEFAULT_BUILDDIR='/tmp' |
| DEFAULT_INSTALLDIR=os.path.join(sys.prefix, "Lib", "site-packages") |
| DEFAULT_PIMPDATABASE="http://www.cwi.nl/~jack/pimp/pimp-%s.plist" % distutils.util.get_platform() |
| |
| ARCHIVE_FORMATS = [ |
| (".tar.Z", "zcat \"%s\" | tar xf -"), |
| (".taz", "zcat \"%s\" | tar xf -"), |
| (".tar.gz", "zcat \"%s\" | tar xf -"), |
| (".tgz", "zcat \"%s\" | tar xf -"), |
| (".tar.bz", "bzcat \"%s\" | tar xf -"), |
| ] |
| |
| class MyURLopener(urllib.FancyURLopener): |
| """Like FancyURLOpener, but we do want to get errors as exceptions""" |
| def http_error_default(self, url, fp, errcode, errmsg, headers): |
| urllib.URLopener.http_error_default(self, url, fp, errcode, errmsg, headers) |
| |
| class PimpPreferences: |
| def __init__(self, |
| flavorOrder=None, |
| downloadDir=None, |
| buildDir=None, |
| installDir=None, |
| pimpDatabase=None): |
| if not flavorOrder: |
| flavorOrder = DEFAULT_FLAVORORDER |
| if not downloadDir: |
| downloadDir = DEFAULT_DOWNLOADDIR |
| if not buildDir: |
| buildDir = DEFAULT_BUILDDIR |
| if not installDir: |
| installDir = DEFAULT_INSTALLDIR |
| if not pimpDatabase: |
| pimpDatabase = DEFAULT_PIMPDATABASE |
| self.flavorOrder = flavorOrder |
| self.downloadDir = downloadDir |
| self.buildDir = buildDir |
| self.installDir = installDir |
| self.pimpDatabase = pimpDatabase |
| |
| def check(self): |
| rv = "" |
| RWX_OK = os.R_OK|os.W_OK|os.X_OK |
| if not os.path.exists(self.downloadDir): |
| rv += "Warning: Download directory \"%s\" does not exist\n" % self.downloadDir |
| elif not os.access(self.downloadDir, RWX_OK): |
| rv += "Warning: Download directory \"%s\" is not writable or not readable\n" % self.downloadDir |
| if not os.path.exists(self.buildDir): |
| rv += "Warning: Build directory \"%s\" does not exist\n" % self.buildDir |
| elif not os.access(self.buildDir, RWX_OK): |
| rv += "Warning: Build directory \"%s\" is not writable or not readable\n" % self.buildDir |
| if not os.path.exists(self.installDir): |
| rv += "Warning: Install directory \"%s\" does not exist\n" % self.installDir |
| elif not os.access(self.installDir, RWX_OK): |
| rv += "Warning: Install directory \"%s\" is not writable or not readable\n" % self.installDir |
| else: |
| installDir = os.path.realpath(self.installDir) |
| for p in sys.path: |
| try: |
| realpath = os.path.realpath(p) |
| except: |
| pass |
| if installDir == realpath: |
| break |
| else: |
| rv += "Warning: Install directory \"%s\" is not on sys.path\n" % self.installDir |
| return rv |
| |
| def compareFlavors(self, left, right): |
| if left in self.flavorOrder: |
| if right in self.flavorOrder: |
| return cmp(self.flavorOrder.index(left), self.flavorOrder.index(right)) |
| return -1 |
| if right in self.flavorOrder: |
| return 1 |
| return cmp(left, right) |
| |
| class PimpDatabase: |
| def __init__(self, prefs): |
| self._packages = [] |
| self.preferences = prefs |
| self._urllist = [] |
| self._version = "" |
| self._maintainer = "" |
| self._description = "" |
| |
| def appendURL(self, url, included=0): |
| if url in self._urllist: |
| return |
| self._urllist.append(url) |
| fp = urllib.urlopen(url).fp |
| dict = plistlib.Plist.fromFile(fp) |
| # Test here for Pimp version, etc |
| if not included: |
| self._version = dict.get('version', '0.1') |
| self._maintainer = dict.get('maintainer', '') |
| self._description = dict.get('description', '') |
| self.appendPackages(dict['packages']) |
| others = dict.get('include', []) |
| for url in others: |
| self.appendURL(url, included=1) |
| |
| def appendPackages(self, packages): |
| for p in packages: |
| pkg = PimpPackage(self, **dict(p)) |
| self._packages.append(pkg) |
| |
| def list(self): |
| return self._packages |
| |
| def listnames(self): |
| rv = [] |
| for pkg in self._packages: |
| rv.append(_fmtpackagename(pkg)) |
| return rv |
| |
| def dump(self, pathOrFile): |
| packages = [] |
| for pkg in self._packages: |
| packages.append(pkg.dump()) |
| dict = { |
| 'version': self._version, |
| 'maintainer': self._maintainer, |
| 'description': self._description, |
| 'packages': packages |
| } |
| plist = plistlib.Plist(**dict) |
| plist.write(pathOrFile) |
| |
| def find(self, ident): |
| if type(ident) == str: |
| # Remove ( and ) for pseudo-packages |
| if ident[0] == '(' and ident[-1] == ')': |
| ident = ident[1:-1] |
| # Split into name-version-flavor |
| fields = ident.split('-') |
| if len(fields) < 1 or len(fields) > 3: |
| return None |
| name = fields[0] |
| if len(fields) > 1: |
| version = fields[1] |
| else: |
| version = None |
| if len(fields) > 2: |
| flavor = fields[2] |
| else: |
| flavor = None |
| else: |
| name = ident['name'] |
| version = ident.get('version') |
| flavor = ident.get('flavor') |
| found = None |
| for p in self._packages: |
| if name == p.name and \ |
| (not version or version == p.version) and \ |
| (not flavor or flavor == p.flavor): |
| if not found or found < p: |
| found = p |
| return found |
| |
| class PimpPackage: |
| def __init__(self, db, name, |
| version=None, |
| flavor=None, |
| description=None, |
| longdesc=None, |
| downloadURL=None, |
| installTest=None, |
| prerequisites=None, |
| preInstall=None, |
| postInstall=None, |
| MD5Sum=None): |
| self._db = db |
| self.name = name |
| self.version = version |
| self.flavor = flavor |
| self.description = description |
| self.longdesc = longdesc |
| self.downloadURL = downloadURL |
| self._installTest = installTest |
| self._prerequisites = prerequisites |
| self._preInstall = preInstall |
| self._postInstall = postInstall |
| self._MD5Sum = MD5Sum |
| |
| def dump(self): |
| dict = { |
| 'name': self.name, |
| } |
| if self.version: |
| dict['version'] = self.version |
| if self.flavor: |
| dict['flavor'] = self.flavor |
| if self.description: |
| dict['description'] = self.description |
| if self.longdesc: |
| dict['longdesc'] = self.longdesc |
| if self.downloadURL: |
| dict['downloadURL'] = self.downloadURL |
| if self._installTest: |
| dict['installTest'] = self._installTest |
| if self._prerequisites: |
| dict['prerequisites'] = self._prerequisites |
| if self._preInstall: |
| dict['preInstall'] = self._preInstall |
| if self._postInstall: |
| dict['postInstall'] = self._postInstall |
| if self._MD5Sum: |
| dict['MD5Sum'] = self._MD5Sum |
| return dict |
| |
| def __cmp__(self, other): |
| if not isinstance(other, PimpPackage): |
| return cmp(id(self), id(other)) |
| if self.name != other.name: |
| return cmp(self.name, other.name) |
| if self.version != other.version: |
| return cmp(self.version, other.version) |
| return self._db.preferences.compareFlavors(self.flavor, other.flavor) |
| |
| def installed(self): |
| namespace = { |
| "NotInstalled": _scriptExc_NotInstalled, |
| "OldInstalled": _scriptExc_OldInstalled, |
| "BadInstalled": _scriptExc_BadInstalled, |
| "os": os, |
| "sys": sys, |
| } |
| installTest = self._installTest.strip() + '\n' |
| try: |
| exec installTest in namespace |
| except ImportError, arg: |
| return "no", str(arg) |
| except _scriptExc_NotInstalled, arg: |
| return "no", str(arg) |
| except _scriptExc_OldInstalled, arg: |
| return "old", str(arg) |
| except _scriptExc_BadInstalled, arg: |
| return "bad", str(arg) |
| except: |
| print 'TEST:', repr(self._installTest) |
| return "bad", "Package install test got exception" |
| return "yes", "" |
| |
| def prerequisites(self): |
| rv = [] |
| if not self.downloadURL: |
| return [(None, "This package needs to be installed manually")] |
| if not self._prerequisites: |
| return [] |
| for item in self._prerequisites: |
| if type(item) == str: |
| pkg = None |
| descr = str(item) |
| else: |
| pkg = self._db.find(item) |
| if not pkg: |
| descr = "Requires unknown %s"%_fmtpackagename(item) |
| else: |
| descr = pkg.description |
| rv.append((pkg, descr)) |
| return rv |
| |
| def _cmd(self, output, dir, *cmditems): |
| cmd = ("cd \"%s\"; " % dir) + " ".join(cmditems) |
| if output: |
| output.write("+ %s\n" % cmd) |
| if NO_EXECUTE: |
| return 0 |
| fp = os.popen(cmd, "r") |
| while 1: |
| line = fp.readline() |
| if not line: |
| break |
| if output: |
| output.write(line) |
| rv = fp.close() |
| return rv |
| |
| def downloadSinglePackage(self, output): |
| scheme, loc, path, query, frag = urlparse.urlsplit(self.downloadURL) |
| path = urllib.url2pathname(path) |
| filename = os.path.split(path)[1] |
| self.archiveFilename = os.path.join(self._db.preferences.downloadDir, filename) |
| if not self._archiveOK(): |
| if self._cmd(output, self._db.preferences.downloadDir, |
| "curl", |
| "--output", self.archiveFilename, |
| self.downloadURL): |
| return "download command failed" |
| if not os.path.exists(self.archiveFilename) and not NO_EXECUTE: |
| return "archive not found after download" |
| if not self._archiveOK(): |
| return "archive does not have correct MD5 checksum" |
| |
| def _archiveOK(self): |
| if not os.path.exists(self.archiveFilename): |
| return 0 |
| if not self._MD5Sum: |
| sys.stderr.write("Warning: no MD5Sum for %s\n" % _fmtpackagename(self)) |
| return 1 |
| data = open(self.archiveFilename, 'rb').read() |
| checksum = md5.new(data).hexdigest() |
| return checksum == self._MD5Sum |
| |
| def unpackSinglePackage(self, output): |
| filename = os.path.split(self.archiveFilename)[1] |
| for ext, cmd in ARCHIVE_FORMATS: |
| if filename[-len(ext):] == ext: |
| break |
| else: |
| return "unknown extension for archive file: %s" % filename |
| basename = filename[:-len(ext)] |
| cmd = cmd % self.archiveFilename |
| self._buildDirname = os.path.join(self._db.preferences.buildDir, basename) |
| if self._cmd(output, self._db.preferences.buildDir, cmd): |
| return "unpack command failed" |
| setupname = os.path.join(self._buildDirname, "setup.py") |
| if not os.path.exists(setupname) and not NO_EXECUTE: |
| return "no setup.py found after unpack of archive" |
| |
| def installSinglePackage(self, output): |
| if not self.downloadURL: |
| return "%s: This package needs to be installed manually" % _fmtpackagename(self) |
| msg = self.downloadSinglePackage(output) |
| if msg: |
| return "download %s: %s" % (_fmtpackagename(self), msg) |
| msg = self.unpackSinglePackage(output) |
| if msg: |
| return "unpack %s: %s" % (_fmtpackagename(self), msg) |
| if self._preInstall: |
| if self._cmd(output, self._buildDirname, self._preInstall): |
| return "pre-install %s: running \"%s\" failed" % \ |
| (_fmtpackagename(self), self._preInstall) |
| if self._cmd(output, self._buildDirname, sys.executable, "setup.py install"): |
| return "install %s: running \"setup.py install\" failed" % _fmtpackagename(self) |
| if self._postInstall: |
| if self._cmd(output, self._buildDirname, self._postInstall): |
| return "post-install %s: running \"%s\" failed" % \ |
| (_fmtpackagename(self), self._postInstall) |
| return None |
| |
| class PimpInstaller: |
| def __init__(self, db): |
| self._todo = [] |
| self._db = db |
| self._curtodo = [] |
| self._curmessages = [] |
| |
| def __contains__(self, package): |
| return package in self._todo |
| |
| def _addPackages(self, packages): |
| for package in packages: |
| if not package in self._todo: |
| self._todo.insert(0, package) |
| |
| def _prepareInstall(self, package, force=0, recursive=1): |
| if not force: |
| status, message = package.installed() |
| if status == "yes": |
| return |
| if package in self._todo or package in self._curtodo: |
| return |
| self._curtodo.insert(0, package) |
| if not recursive: |
| return |
| prereqs = package.prerequisites() |
| for pkg, descr in prereqs: |
| if pkg: |
| self._prepareInstall(pkg, force, recursive) |
| else: |
| self._curmessages.append("Requires: %s" % descr) |
| |
| def prepareInstall(self, package, force=0, recursive=1): |
| self._curtodo = [] |
| self._curmessages = [] |
| self._prepareInstall(package, force, recursive) |
| rv = self._curtodo, self._curmessages |
| self._curtodo = [] |
| self._curmessages = [] |
| return rv |
| |
| def install(self, packages, output): |
| self._addPackages(packages) |
| status = [] |
| for pkg in self._todo: |
| msg = pkg.installSinglePackage(output) |
| if msg: |
| status.append(msg) |
| return status |
| |
| |
| def _fmtpackagename(dict): |
| if isinstance(dict, PimpPackage): |
| dict = dict.dump() |
| rv = dict['name'] |
| if dict.has_key('version'): |
| rv = rv + '-%s' % dict['version'] |
| if dict.has_key('flavor'): |
| rv = rv + '-%s' % dict['flavor'] |
| if not dict.get('downloadURL'): |
| # Pseudo-package, show in parentheses |
| rv = '(%s)' % rv |
| return rv |
| |
| def _run(mode, verbose, force, args): |
| prefs = PimpPreferences() |
| prefs.check() |
| db = PimpDatabase(prefs) |
| db.appendURL(prefs.pimpDatabase) |
| |
| if mode == 'dump': |
| db.dump(sys.stdout) |
| elif mode =='list': |
| if not args: |
| args = db.listnames() |
| print "%-20.20s\t%s" % ("Package", "Description") |
| print |
| for pkgname in args: |
| pkg = db.find(pkgname) |
| if pkg: |
| description = pkg.description |
| pkgname = _fmtpackagename(pkg) |
| else: |
| description = 'Error: no such package' |
| print "%-20.20s\t%s" % (pkgname, description) |
| if verbose: |
| print "\tHome page:\t", pkg.longdesc |
| print "\tDownload URL:\t", pkg.downloadURL |
| elif mode =='status': |
| if not args: |
| args = db.listnames() |
| print "%-20.20s\t%s\t%s" % ("Package", "Installed", "Message") |
| print |
| for pkgname in args: |
| pkg = db.find(pkgname) |
| if pkg: |
| status, msg = pkg.installed() |
| pkgname = _fmtpackagename(pkg) |
| else: |
| status = 'error' |
| msg = 'No such package' |
| print "%-20.20s\t%-9.9s\t%s" % (pkgname, status, msg) |
| if verbose and status == "no": |
| prereq = pkg.prerequisites() |
| for pkg, msg in prereq: |
| if not pkg: |
| pkg = '' |
| else: |
| pkg = _fmtpackagename(pkg) |
| print "%-20.20s\tRequirement: %s %s" % ("", pkg, msg) |
| elif mode == 'install': |
| if not args: |
| print 'Please specify packages to install' |
| sys.exit(1) |
| inst = PimpInstaller(db) |
| for pkgname in args: |
| pkg = db.find(pkgname) |
| if not pkg: |
| print '%s: No such package' % pkgname |
| continue |
| list, messages = inst.prepareInstall(pkg, force) |
| if messages and not force: |
| print "%s: Not installed:" % pkgname |
| for m in messages: |
| print "\t", m |
| else: |
| if verbose: |
| output = sys.stdout |
| else: |
| output = None |
| messages = inst.install(list, output) |
| if messages: |
| print "%s: Not installed:" % pkgname |
| for m in messages: |
| print "\t", m |
| |
| def main(): |
| import getopt |
| def _help(): |
| print "Usage: pimp [-v] -s [package ...] List installed status" |
| print " pimp [-v] -l [package ...] Show package information" |
| print " pimp [-vf] -i package ... Install packages" |
| print " pimp -d Dump database to stdout" |
| print "Options:" |
| print " -v Verbose" |
| print " -f Force installation" |
| sys.exit(1) |
| |
| try: |
| opts, args = getopt.getopt(sys.argv[1:], "slifvd") |
| except getopt.Error: |
| _help() |
| if not opts and not args: |
| _help() |
| mode = None |
| force = 0 |
| verbose = 0 |
| for o, a in opts: |
| if o == '-s': |
| if mode: |
| _help() |
| mode = 'status' |
| if o == '-l': |
| if mode: |
| _help() |
| mode = 'list' |
| if o == '-d': |
| if mode: |
| _help() |
| mode = 'dump' |
| if o == '-i': |
| mode = 'install' |
| if o == '-f': |
| force = 1 |
| if o == '-v': |
| verbose = 1 |
| if not mode: |
| _help() |
| _run(mode, verbose, force, args) |
| |
| if __name__ == '__main__': |
| main() |
| |
| |