485 lines
16 KiB
Python
Executable File
485 lines
16 KiB
Python
Executable File
#!/usr/bin/env python
|
|
|
|
"""buildpkg.py -- Build OS X packages for Apple's Installer.app.
|
|
|
|
This is an experimental command-line tool for building packages to be
|
|
installed with the Mac OS X Installer.app application.
|
|
|
|
It is much inspired by Apple's GUI tool called PackageMaker.app, that
|
|
seems to be part of the OS X developer tools installed in the folder
|
|
/Developer/Applications. But apparently there are other free tools to
|
|
do the same thing which are also named PackageMaker like Brian Hill's
|
|
one:
|
|
|
|
http://personalpages.tds.net/~brian_hill/packagemaker.html
|
|
|
|
Beware of the multi-package features of Installer.app (which are not
|
|
yet supported here) that can potentially screw-up your installation
|
|
and are discussed in these articles on Stepwise:
|
|
|
|
http://www.stepwise.com/Articles/Technical/Packages/InstallerWoes.html
|
|
http://www.stepwise.com/Articles/Technical/Packages/InstallerOnX.html
|
|
|
|
Beside using the PackageMaker class directly, by importing it inside
|
|
another module, say, there are additional ways of using this module:
|
|
the top-level buildPackage() function provides a shortcut to the same
|
|
feature and is also called when using this module from the command-
|
|
line.
|
|
|
|
****************************************************************
|
|
NOTE: For now you should be able to run this even on a non-OS X
|
|
system and get something similar to a package, but without
|
|
the real archive (needs pax) and bom files (needs mkbom)
|
|
inside! This is only for providing a chance for testing to
|
|
folks without OS X.
|
|
****************************************************************
|
|
|
|
TODO:
|
|
- test pre-process and post-process scripts (Python ones?)
|
|
- handle multi-volume packages (?)
|
|
- integrate into distutils (?)
|
|
|
|
Dinu C. Gherman,
|
|
gherman@europemail.com
|
|
November 2001
|
|
|
|
!! USE AT YOUR OWN RISK !!
|
|
"""
|
|
|
|
__version__ = 0.2
|
|
__license__ = "FreeBSD"
|
|
|
|
|
|
import os, sys, glob, fnmatch, shutil, string, copy, getopt
|
|
from os.path import basename, dirname, join, islink, isdir, isfile
|
|
|
|
Error = "buildpkg.Error"
|
|
|
|
PKG_INFO_FIELDS = """\
|
|
Title
|
|
Version
|
|
Description
|
|
DefaultLocation
|
|
DeleteWarning
|
|
NeedsAuthorization
|
|
DisableStop
|
|
UseUserMask
|
|
Application
|
|
Relocatable
|
|
Required
|
|
InstallOnly
|
|
RequiresReboot
|
|
RootVolumeOnly
|
|
LongFilenames
|
|
LibrarySubdirectory
|
|
AllowBackRev
|
|
OverwritePermissions
|
|
InstallFat\
|
|
"""
|
|
|
|
######################################################################
|
|
# Helpers
|
|
######################################################################
|
|
|
|
# Convenience class, as suggested by /F.
|
|
|
|
class GlobDirectoryWalker:
|
|
"A forward iterator that traverses files in a directory tree."
|
|
|
|
def __init__(self, directory, pattern="*"):
|
|
self.stack = [directory]
|
|
self.pattern = pattern
|
|
self.files = []
|
|
self.index = 0
|
|
|
|
|
|
def __getitem__(self, index):
|
|
while 1:
|
|
try:
|
|
file = self.files[self.index]
|
|
self.index = self.index + 1
|
|
except IndexError:
|
|
# pop next directory from stack
|
|
self.directory = self.stack.pop()
|
|
self.files = os.listdir(self.directory)
|
|
self.index = 0
|
|
else:
|
|
# got a filename
|
|
fullname = join(self.directory, file)
|
|
if isdir(fullname) and not islink(fullname):
|
|
self.stack.append(fullname)
|
|
if fnmatch.fnmatch(file, self.pattern):
|
|
return fullname
|
|
|
|
|
|
######################################################################
|
|
# The real thing
|
|
######################################################################
|
|
|
|
class PackageMaker:
|
|
"""A class to generate packages for Mac OS X.
|
|
|
|
This is intended to create OS X packages (with extension .pkg)
|
|
containing archives of arbitrary files that the Installer.app
|
|
will be able to handle.
|
|
|
|
As of now, PackageMaker instances need to be created with the
|
|
title, version and description of the package to be built.
|
|
The package is built after calling the instance method
|
|
build(root, **options). It has the same name as the constructor's
|
|
title argument plus a '.pkg' extension and is located in the same
|
|
parent folder that contains the root folder.
|
|
|
|
E.g. this will create a package folder /my/space/distutils.pkg/:
|
|
|
|
pm = PackageMaker("distutils", "1.0.2", "Python distutils.")
|
|
pm.build("/my/space/distutils")
|
|
"""
|
|
|
|
packageInfoDefaults = {
|
|
'Title': None,
|
|
'Version': None,
|
|
'Description': '',
|
|
'DefaultLocation': '/',
|
|
'DeleteWarning': '',
|
|
'NeedsAuthorization': 'NO',
|
|
'DisableStop': 'NO',
|
|
'UseUserMask': 'YES',
|
|
'Application': 'NO',
|
|
'Relocatable': 'YES',
|
|
'Required': 'NO',
|
|
'InstallOnly': 'NO',
|
|
'RequiresReboot': 'NO',
|
|
'RootVolumeOnly' : 'NO',
|
|
'InstallFat': 'NO',
|
|
'LongFilenames': 'YES',
|
|
'LibrarySubdirectory': 'Standard',
|
|
'AllowBackRev': 'YES',
|
|
'OverwritePermissions': 'NO',
|
|
}
|
|
|
|
|
|
def __init__(self, title, version, desc):
|
|
"Init. with mandatory title/version/description arguments."
|
|
|
|
info = {"Title": title, "Version": version, "Description": desc}
|
|
self.packageInfo = copy.deepcopy(self.packageInfoDefaults)
|
|
self.packageInfo.update(info)
|
|
|
|
# variables set later
|
|
self.packageRootFolder = None
|
|
self.packageResourceFolder = None
|
|
self.sourceFolder = None
|
|
self.resourceFolder = None
|
|
|
|
|
|
def build(self, root, resources=None, **options):
|
|
"""Create a package for some given root folder.
|
|
|
|
With no 'resources' argument set it is assumed to be the same
|
|
as the root directory. Option items replace the default ones
|
|
in the package info.
|
|
"""
|
|
|
|
# set folder attributes
|
|
self.sourceFolder = root
|
|
if resources is None:
|
|
self.resourceFolder = root
|
|
else:
|
|
self.resourceFolder = resources
|
|
|
|
# replace default option settings with user ones if provided
|
|
fields = self. packageInfoDefaults.keys()
|
|
for k, v in options.items():
|
|
if k in fields:
|
|
self.packageInfo[k] = v
|
|
elif not k in ["OutputDir"]:
|
|
raise Error, "Unknown package option: %s" % k
|
|
|
|
# Check where we should leave the output. Default is current directory
|
|
outputdir = options.get("OutputDir", os.getcwd())
|
|
packageName = self.packageInfo["Title"]
|
|
self.PackageRootFolder = os.path.join(outputdir, packageName + ".pkg")
|
|
|
|
# do what needs to be done
|
|
self._makeFolders()
|
|
self._addInfo()
|
|
self._addBom()
|
|
self._addArchive()
|
|
self._addResources()
|
|
self._addSizes()
|
|
self._addLoc()
|
|
|
|
|
|
def _makeFolders(self):
|
|
"Create package folder structure."
|
|
|
|
# Not sure if the package name should contain the version or not...
|
|
# packageName = "%s-%s" % (self.packageInfo["Title"],
|
|
# self.packageInfo["Version"]) # ??
|
|
|
|
contFolder = join(self.PackageRootFolder, "Contents")
|
|
self.packageResourceFolder = join(contFolder, "Resources")
|
|
os.mkdir(self.PackageRootFolder)
|
|
os.mkdir(contFolder)
|
|
os.mkdir(self.packageResourceFolder)
|
|
|
|
def _addInfo(self):
|
|
"Write .info file containing installing options."
|
|
|
|
# Not sure if options in PKG_INFO_FIELDS are complete...
|
|
|
|
info = ""
|
|
for f in string.split(PKG_INFO_FIELDS, "\n"):
|
|
if self.packageInfo.has_key(f):
|
|
info = info + "%s %%(%s)s\n" % (f, f)
|
|
info = info % self.packageInfo
|
|
base = self.packageInfo["Title"] + ".info"
|
|
path = join(self.packageResourceFolder, base)
|
|
f = open(path, "w")
|
|
f.write(info)
|
|
|
|
|
|
def _addBom(self):
|
|
"Write .bom file containing 'Bill of Materials'."
|
|
|
|
# Currently ignores if the 'mkbom' tool is not available.
|
|
|
|
try:
|
|
base = self.packageInfo["Title"] + ".bom"
|
|
bomPath = join(self.packageResourceFolder, base)
|
|
cmd = "mkbom %s %s" % (self.sourceFolder, bomPath)
|
|
res = os.system(cmd)
|
|
except:
|
|
pass
|
|
|
|
|
|
def _addArchive(self):
|
|
"Write .pax.gz file, a compressed archive using pax/gzip."
|
|
|
|
# Currently ignores if the 'pax' tool is not available.
|
|
|
|
cwd = os.getcwd()
|
|
|
|
# create archive
|
|
os.chdir(self.sourceFolder)
|
|
base = basename(self.packageInfo["Title"]) + ".pax"
|
|
self.archPath = join(self.packageResourceFolder, base)
|
|
cmd = "pax -w -f %s %s" % (self.archPath, ".")
|
|
res = os.system(cmd)
|
|
|
|
# compress archive
|
|
cmd = "gzip %s" % self.archPath
|
|
res = os.system(cmd)
|
|
os.chdir(cwd)
|
|
|
|
|
|
def _addResources(self):
|
|
"Add Welcome/ReadMe/License files, .lproj folders and scripts."
|
|
|
|
# Currently we just copy everything that matches the allowed
|
|
# filenames. So, it's left to Installer.app to deal with the
|
|
# same file available in multiple formats...
|
|
|
|
if not self.resourceFolder:
|
|
return
|
|
|
|
# find candidate resource files (txt html rtf rtfd/ or lproj/)
|
|
allFiles = []
|
|
for pat in string.split("*.txt *.html *.rtf *.rtfd *.lproj", " "):
|
|
pattern = join(self.resourceFolder, pat)
|
|
allFiles = allFiles + glob.glob(pattern)
|
|
|
|
# find pre-process and post-process scripts
|
|
# naming convention: packageName.{pre,post}_{upgrade,install}
|
|
# Alternatively the filenames can be {pre,post}_{upgrade,install}
|
|
# in which case we prepend the package name
|
|
packageName = self.packageInfo["Title"]
|
|
for pat in ("*upgrade", "*install", "*flight"):
|
|
pattern = join(self.resourceFolder, packageName + pat)
|
|
pattern2 = join(self.resourceFolder, pat)
|
|
allFiles = allFiles + glob.glob(pattern)
|
|
allFiles = allFiles + glob.glob(pattern2)
|
|
|
|
# check name patterns
|
|
files = []
|
|
for f in allFiles:
|
|
for s in ("Welcome", "License", "ReadMe"):
|
|
if string.find(basename(f), s) == 0:
|
|
files.append((f, f))
|
|
if f[-6:] == ".lproj":
|
|
files.append((f, f))
|
|
elif basename(f) in ["pre_upgrade", "pre_install", "post_upgrade", "post_install"]:
|
|
files.append((f, packageName+"."+basename(f)))
|
|
elif basename(f) in ["preflight", "postflight"]:
|
|
files.append((f, f))
|
|
elif f[-8:] == "_upgrade":
|
|
files.append((f,f))
|
|
elif f[-8:] == "_install":
|
|
files.append((f,f))
|
|
|
|
# copy files
|
|
for src, dst in files:
|
|
src = basename(src)
|
|
dst = basename(dst)
|
|
f = join(self.resourceFolder, src)
|
|
if isfile(f):
|
|
shutil.copy(f, os.path.join(self.packageResourceFolder, dst))
|
|
elif isdir(f):
|
|
# special case for .rtfd and .lproj folders...
|
|
d = join(self.packageResourceFolder, dst)
|
|
os.mkdir(d)
|
|
files = GlobDirectoryWalker(f)
|
|
for file in files:
|
|
shutil.copy(file, d)
|
|
|
|
|
|
def _addSizes(self):
|
|
"Write .sizes file with info about number and size of files."
|
|
|
|
# Not sure if this is correct, but 'installedSize' and
|
|
# 'zippedSize' are now in Bytes. Maybe blocks are needed?
|
|
# Well, Installer.app doesn't seem to care anyway, saying
|
|
# the installation needs 100+ MB...
|
|
|
|
numFiles = 0
|
|
installedSize = 0
|
|
zippedSize = 0
|
|
|
|
files = GlobDirectoryWalker(self.sourceFolder)
|
|
for f in files:
|
|
numFiles = numFiles + 1
|
|
installedSize = installedSize + os.lstat(f)[6]
|
|
|
|
try:
|
|
zippedSize = os.stat(self.archPath+ ".gz")[6]
|
|
except OSError: # ignore error
|
|
pass
|
|
base = self.packageInfo["Title"] + ".sizes"
|
|
f = open(join(self.packageResourceFolder, base), "w")
|
|
format = "NumFiles %d\nInstalledSize %d\nCompressedSize %d\n"
|
|
f.write(format % (numFiles, installedSize, zippedSize))
|
|
|
|
def _addLoc(self):
|
|
"Write .loc file."
|
|
base = self.packageInfo["Title"] + ".loc"
|
|
f = open(join(self.packageResourceFolder, base), "w")
|
|
f.write('/')
|
|
|
|
# Shortcut function interface
|
|
|
|
def buildPackage(*args, **options):
|
|
"A Shortcut function for building a package."
|
|
|
|
o = options
|
|
title, version, desc = o["Title"], o["Version"], o["Description"]
|
|
pm = PackageMaker(title, version, desc)
|
|
apply(pm.build, list(args), options)
|
|
|
|
|
|
######################################################################
|
|
# Tests
|
|
######################################################################
|
|
|
|
def test0():
|
|
"Vanilla test for the distutils distribution."
|
|
|
|
pm = PackageMaker("distutils2", "1.0.2", "Python distutils package.")
|
|
pm.build("/Users/dinu/Desktop/distutils2")
|
|
|
|
|
|
def test1():
|
|
"Test for the reportlab distribution with modified options."
|
|
|
|
pm = PackageMaker("reportlab", "1.10",
|
|
"ReportLab's Open Source PDF toolkit.")
|
|
pm.build(root="/Users/dinu/Desktop/reportlab",
|
|
DefaultLocation="/Applications/ReportLab",
|
|
Relocatable="YES")
|
|
|
|
def test2():
|
|
"Shortcut test for the reportlab distribution with modified options."
|
|
|
|
buildPackage(
|
|
"/Users/dinu/Desktop/reportlab",
|
|
Title="reportlab",
|
|
Version="1.10",
|
|
Description="ReportLab's Open Source PDF toolkit.",
|
|
DefaultLocation="/Applications/ReportLab",
|
|
Relocatable="YES")
|
|
|
|
|
|
######################################################################
|
|
# Command-line interface
|
|
######################################################################
|
|
|
|
def printUsage():
|
|
"Print usage message."
|
|
|
|
format = "Usage: %s <opts1> [<opts2>] <root> [<resources>]"
|
|
print format % basename(sys.argv[0])
|
|
print
|
|
print " with arguments:"
|
|
print " (mandatory) root: the package root folder"
|
|
print " (optional) resources: the package resources folder"
|
|
print
|
|
print " and options:"
|
|
print " (mandatory) opts1:"
|
|
mandatoryKeys = string.split("Title Version Description", " ")
|
|
for k in mandatoryKeys:
|
|
print " --%s" % k
|
|
print " (optional) opts2: (with default values)"
|
|
|
|
pmDefaults = PackageMaker.packageInfoDefaults
|
|
optionalKeys = pmDefaults.keys()
|
|
for k in mandatoryKeys:
|
|
optionalKeys.remove(k)
|
|
optionalKeys.sort()
|
|
maxKeyLen = max(map(len, optionalKeys))
|
|
for k in optionalKeys:
|
|
format = " --%%s:%s %%s"
|
|
format = format % (" " * (maxKeyLen-len(k)))
|
|
print format % (k, repr(pmDefaults[k]))
|
|
|
|
|
|
def main():
|
|
"Command-line interface."
|
|
|
|
shortOpts = ""
|
|
keys = PackageMaker.packageInfoDefaults.keys()
|
|
longOpts = map(lambda k: k+"=", keys)
|
|
|
|
try:
|
|
opts, args = getopt.getopt(sys.argv[1:], shortOpts, longOpts)
|
|
except getopt.GetoptError, details:
|
|
print details
|
|
printUsage()
|
|
return
|
|
|
|
optsDict = {}
|
|
for k, v in opts:
|
|
optsDict[k[2:]] = v
|
|
|
|
ok = optsDict.keys()
|
|
if not (1 <= len(args) <= 2):
|
|
print "No argument given!"
|
|
elif not ("Title" in ok and \
|
|
"Version" in ok and \
|
|
"Description" in ok):
|
|
print "Missing mandatory option!"
|
|
else:
|
|
apply(buildPackage, args, optsDict)
|
|
return
|
|
|
|
printUsage()
|
|
|
|
# sample use:
|
|
# buildpkg.py --Title=distutils \
|
|
# --Version=1.0.2 \
|
|
# --Description="Python distutils package." \
|
|
# /Users/dinu/Desktop/distutils
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|