1 #!/usr/bin/env python

     2 

     3 """buildpkg.py -- Build OS X packages for Apple's Installer.app.

     4 

     5 This is an experimental command-line tool for building packages to be

     6 installed with the Mac OS X Installer.app application.

     7 

     8 It is much inspired by Apple's GUI tool called PackageMaker.app, that

     9 seems to be part of the OS X developer tools installed in the folder

    10 /Developer/Applications. But apparently there are other free tools to

    11 do the same thing which are also named PackageMaker like Brian Hill's

    12 one:

    13 

    14   http://personalpages.tds.net/~brian_hill/packagemaker.html

    15 

    16 Beware of the multi-package features of Installer.app (which are not

    17 yet supported here) that can potentially screw-up your installation

    18 and are discussed in these articles on Stepwise:

    19 

    20   http://www.stepwise.com/Articles/Technical/Packages/InstallerWoes.html

    21   http://www.stepwise.com/Articles/Technical/Packages/InstallerOnX.html

    22 

    23 Beside using the PackageMaker class directly, by importing it inside

    24 another module, say, there are additional ways of using this module:

    25 the top-level buildPackage() function provides a shortcut to the same

    26 feature and is also called when using this module from the command-

    27 line.

    28 

    29     ****************************************************************

    30     NOTE: For now you should be able to run this even on a non-OS X

    31           system and get something similar to a package, but without

    32           the real archive (needs pax) and bom files (needs mkbom)

    33           inside! This is only for providing a chance for testing to

    34           folks without OS X.

    35     ****************************************************************

    36 

    37 TODO:

    38   - test pre-process and post-process scripts (Python ones?)

    39   - handle multi-volume packages (?)

    40   - integrate into distutils (?)

    41 

    42 Dinu C. Gherman,

    43 gherman@europemail.com

    44 November 2001

    45 

    46 !! USE AT YOUR OWN RISK !!

    47 """

    48 

    49 __version__ = 0.2

    50 __license__ = "FreeBSD"

    51 

    52 

    53 import os, sys, glob, fnmatch, shutil, string, copy, getopt

    54 from os.path import basename, dirname, join, islink, isdir, isfile

    55 

    56 Error = "buildpkg.Error"

    57 

    58 PKG_INFO_FIELDS = """\

    59 Title

    60 Version

    61 Description

    62 DefaultLocation

    63 DeleteWarning

    64 NeedsAuthorization

    65 DisableStop

    66 UseUserMask

    67 Application

    68 Relocatable

    69 Required

    70 InstallOnly

    71 RequiresReboot

    72 RootVolumeOnly

    73 LongFilenames

    74 LibrarySubdirectory

    75 AllowBackRev

    76 OverwritePermissions

    77 InstallFat\

    78 """

    79 

    80 ######################################################################

    81 # Helpers

    82 ######################################################################

    83 

    84 # Convenience class, as suggested by /F.

    85 

    86 class GlobDirectoryWalker:

    87     "A forward iterator that traverses files in a directory tree."

    88 

    89     def __init__(self, directory, pattern="*"):

    90         self.stack = [directory]

    91         self.pattern = pattern

    92         self.files = []

    93         self.index = 0

    94 

    95 

    96     def __getitem__(self, index):

    97         while 1:

    98             try:

    99                 file = self.files[self.index]

   100                 self.index = self.index + 1

   101             except IndexError:

   102                 # pop next directory from stack

   103                 self.directory = self.stack.pop()

   104                 self.files = os.listdir(self.directory)

   105                 self.index = 0

   106             else:

   107                 # got a filename

   108                 fullname = join(self.directory, file)

   109                 if isdir(fullname) and not islink(fullname):

   110                     self.stack.append(fullname)

   111                 if fnmatch.fnmatch(file, self.pattern):

   112                     return fullname

   113 

   114 

   115 ######################################################################

   116 # The real thing

   117 ######################################################################

   118 

   119 class PackageMaker:

   120     """A class to generate packages for Mac OS X.

   121 

   122     This is intended to create OS X packages (with extension .pkg)

   123     containing archives of arbitrary files that the Installer.app

   124     will be able to handle.

   125 

   126     As of now, PackageMaker instances need to be created with the

   127     title, version and description of the package to be built.

   128     The package is built after calling the instance method

   129     build(root, **options). It has the same name as the constructor's

   130     title argument plus a '.pkg' extension and is located in the same

   131     parent folder that contains the root folder.

   132 

   133     E.g. this will create a package folder /my/space/distutils.pkg/:

   134 

   135       pm = PackageMaker("distutils", "1.0.2", "Python distutils.")

   136       pm.build("/my/space/distutils")

   137     """

   138 

   139     packageInfoDefaults = {

   140         'Title': None,

   141         'Version': None,

   142         'Description': '',

   143         'DefaultLocation': '/',

   144         'DeleteWarning': '',

   145         'NeedsAuthorization': 'NO',

   146         'DisableStop': 'NO',

   147         'UseUserMask': 'YES',

   148         'Application': 'NO',

   149         'Relocatable': 'YES',

   150         'Required': 'NO',

   151         'InstallOnly': 'NO',

   152         'RequiresReboot': 'NO',

   153         'RootVolumeOnly' : 'NO',

   154         'InstallFat': 'NO',

   155         'LongFilenames': 'YES',

   156         'LibrarySubdirectory': 'Standard',

   157         'AllowBackRev': 'YES',

   158         'OverwritePermissions': 'NO',

   159         }

   160 

   161 

   162     def __init__(self, title, version, desc):

   163         "Init. with mandatory title/version/description arguments."

   164 

   165         info = {"Title": title, "Version": version, "Description": desc}

   166         self.packageInfo = copy.deepcopy(self.packageInfoDefaults)

   167         self.packageInfo.update(info)

   168 

   169         # variables set later

   170         self.packageRootFolder = None

   171         self.packageResourceFolder = None

   172         self.sourceFolder = None

   173         self.resourceFolder = None

   174 

   175 

   176     def build(self, root, resources=None, **options):

   177         """Create a package for some given root folder.

   178 

   179         With no 'resources' argument set it is assumed to be the same

   180         as the root directory. Option items replace the default ones

   181         in the package info.

   182         """

   183 

   184         # set folder attributes

   185         self.sourceFolder = root

   186         if resources is None:

   187             self.resourceFolder = root

   188         else:

   189             self.resourceFolder = resources

   190 

   191         # replace default option settings with user ones if provided

   192         fields = self. packageInfoDefaults.keys()

   193         for k, v in options.items():

   194             if k in fields:

   195                 self.packageInfo[k] = v

   196             elif not k in ["OutputDir"]:

   197                 raise Error, "Unknown package option: %s" % k

   198 

   199         # Check where we should leave the output. Default is current directory

   200         outputdir = options.get("OutputDir", os.getcwd())

   201         packageName = self.packageInfo["Title"]

   202         self.PackageRootFolder = os.path.join(outputdir, packageName + ".pkg")

   203 

   204         # do what needs to be done

   205         self._makeFolders()

   206         self._addInfo()

   207         self._addBom()

   208         self._addArchive()

   209         self._addResources()

   210         self._addSizes()

   211         self._addLoc()

   212 

   213 

   214     def _makeFolders(self):

   215         "Create package folder structure."

   216 

   217         # Not sure if the package name should contain the version or not...

   218         # packageName = "%s-%s" % (self.packageInfo["Title"],

   219         #                          self.packageInfo["Version"]) # ??

   220 

   221         contFolder = join(self.PackageRootFolder, "Contents")

   222         self.packageResourceFolder = join(contFolder, "Resources")

   223         os.mkdir(self.PackageRootFolder)

   224         os.mkdir(contFolder)

   225         os.mkdir(self.packageResourceFolder)

   226 

   227     def _addInfo(self):

   228         "Write .info file containing installing options."

   229 

   230         # Not sure if options in PKG_INFO_FIELDS are complete...

   231 

   232         info = ""

   233         for f in string.split(PKG_INFO_FIELDS, "\n"):

   234             if self.packageInfo.has_key(f):

   235                 info = info + "%s %%(%s)s\n" % (f, f)

   236         info = info % self.packageInfo

   237         base = self.packageInfo["Title"] + ".info"

   238         path = join(self.packageResourceFolder, base)

   239         f = open(path, "w")

   240         f.write(info)

   241 

   242 

   243     def _addBom(self):

   244         "Write .bom file containing 'Bill of Materials'."

   245 

   246         # Currently ignores if the 'mkbom' tool is not available.

   247 

   248         try:

   249             base = self.packageInfo["Title"] + ".bom"

   250             bomPath = join(self.packageResourceFolder, base)

   251             cmd = "mkbom %s %s" % (self.sourceFolder, bomPath)

   252             res = os.system(cmd)

   253         except:

   254             pass

   255 

   256 

   257     def _addArchive(self):

   258         "Write .pax.gz file, a compressed archive using pax/gzip."

   259 

   260         # Currently ignores if the 'pax' tool is not available.

   261 

   262         cwd = os.getcwd()

   263 

   264         # create archive

   265         os.chdir(self.sourceFolder)

   266         base = basename(self.packageInfo["Title"]) + ".pax"

   267         self.archPath = join(self.packageResourceFolder, base)

   268         cmd = "pax -w -f %s %s" % (self.archPath, ".")

   269         res = os.system(cmd)

   270 

   271         # compress archive

   272         cmd = "gzip %s" % self.archPath

   273         res = os.system(cmd)

   274         os.chdir(cwd)

   275 

   276 

   277     def _addResources(self):

   278         "Add Welcome/ReadMe/License files, .lproj folders and scripts."

   279 

   280         # Currently we just copy everything that matches the allowed

   281         # filenames. So, it's left to Installer.app to deal with the

   282         # same file available in multiple formats...

   283 

   284         if not self.resourceFolder:

   285             return

   286 

   287         # find candidate resource files (txt html rtf rtfd/ or lproj/)

   288         allFiles = []

   289         for pat in string.split("*.txt *.html *.rtf *.rtfd *.lproj", " "):

   290             pattern = join(self.resourceFolder, pat)

   291             allFiles = allFiles + glob.glob(pattern)

   292 

   293         # find pre-process and post-process scripts

   294         # naming convention: packageName.{pre,post}_{upgrade,install}

   295         # Alternatively the filenames can be {pre,post}_{upgrade,install}

   296         # in which case we prepend the package name

   297         packageName = self.packageInfo["Title"]

   298         for pat in ("*upgrade", "*install", "*flight"):

   299             pattern = join(self.resourceFolder, packageName + pat)

   300             pattern2 = join(self.resourceFolder, pat)

   301             allFiles = allFiles + glob.glob(pattern)

   302             allFiles = allFiles + glob.glob(pattern2)

   303 

   304         # check name patterns

   305         files = []

   306         for f in allFiles:

   307             for s in ("Welcome", "License", "ReadMe"):

   308                 if string.find(basename(f), s) == 0:

   309                     files.append((f, f))

   310             if f[-6:] == ".lproj":

   311                 files.append((f, f))

   312             elif basename(f) in ["pre_upgrade", "pre_install", "post_upgrade", "post_install"]:

   313                 files.append((f, packageName+"."+basename(f)))

   314             elif basename(f) in ["preflight", "postflight"]:

   315                 files.append((f, f))

   316             elif f[-8:] == "_upgrade":

   317                 files.append((f,f))

   318             elif f[-8:] == "_install":

   319                 files.append((f,f))

   320 

   321         # copy files

   322         for src, dst in files:

   323             src = basename(src)

   324             dst = basename(dst)

   325             f = join(self.resourceFolder, src)

   326             if isfile(f):

   327                 shutil.copy(f, os.path.join(self.packageResourceFolder, dst))

   328             elif isdir(f):

   329                 # special case for .rtfd and .lproj folders...

   330                 d = join(self.packageResourceFolder, dst)

   331                 os.mkdir(d)

   332                 files = GlobDirectoryWalker(f)

   333                 for file in files:

   334                     shutil.copy(file, d)

   335 

   336 

   337     def _addSizes(self):

   338         "Write .sizes file with info about number and size of files."

   339 

   340         # Not sure if this is correct, but 'installedSize' and

   341         # 'zippedSize' are now in Bytes. Maybe blocks are needed?

   342         # Well, Installer.app doesn't seem to care anyway, saying

   343         # the installation needs 100+ MB...

   344 

   345         numFiles = 0

   346         installedSize = 0

   347         zippedSize = 0

   348 

   349         files = GlobDirectoryWalker(self.sourceFolder)

   350         for f in files:

   351             numFiles = numFiles + 1

   352             installedSize = installedSize + os.lstat(f)[6]

   353 

   354         try:

   355             zippedSize = os.stat(self.archPath+ ".gz")[6]

   356         except OSError: # ignore error

   357             pass

   358         base = self.packageInfo["Title"] + ".sizes"

   359         f = open(join(self.packageResourceFolder, base), "w")

   360         format = "NumFiles %d\nInstalledSize %d\nCompressedSize %d\n"

   361         f.write(format % (numFiles, installedSize, zippedSize))

   362 

   363     def _addLoc(self):

   364         "Write .loc file."

   365         base = self.packageInfo["Title"] + ".loc"

   366         f = open(join(self.packageResourceFolder, base), "w")

   367         f.write('/')

   368 

   369 # Shortcut function interface

   370 

   371 def buildPackage(*args, **options):

   372     "A Shortcut function for building a package."

   373 

   374     o = options

   375     title, version, desc = o["Title"], o["Version"], o["Description"]

   376     pm = PackageMaker(title, version, desc)

   377     apply(pm.build, list(args), options)

   378 

   379 

   380 ######################################################################

   381 # Tests

   382 ######################################################################

   383 

   384 def test0():

   385     "Vanilla test for the distutils distribution."

   386 

   387     pm = PackageMaker("distutils2", "1.0.2", "Python distutils package.")

   388     pm.build("/Users/dinu/Desktop/distutils2")

   389 

   390 

   391 def test1():

   392     "Test for the reportlab distribution with modified options."

   393 

   394     pm = PackageMaker("reportlab", "1.10",

   395                       "ReportLab's Open Source PDF toolkit.")

   396     pm.build(root="/Users/dinu/Desktop/reportlab",

   397              DefaultLocation="/Applications/ReportLab",

   398              Relocatable="YES")

   399 

   400 def test2():

   401     "Shortcut test for the reportlab distribution with modified options."

   402 

   403     buildPackage(

   404         "/Users/dinu/Desktop/reportlab",

   405         Title="reportlab",

   406         Version="1.10",

   407         Description="ReportLab's Open Source PDF toolkit.",

   408         DefaultLocation="/Applications/ReportLab",

   409         Relocatable="YES")

   410 

   411 

   412 ######################################################################

   413 # Command-line interface

   414 ######################################################################

   415 

   416 def printUsage():

   417     "Print usage message."

   418 

   419     format = "Usage: %s <opts1> [<opts2>] <root> [<resources>]"

   420     print format % basename(sys.argv[0])

   421     print

   422     print "       with arguments:"

   423     print "           (mandatory) root:         the package root folder"

   424     print "           (optional)  resources:    the package resources folder"

   425     print

   426     print "       and options:"

   427     print "           (mandatory) opts1:"

   428     mandatoryKeys = string.split("Title Version Description", " ")

   429     for k in mandatoryKeys:

   430         print "               --%s" % k

   431     print "           (optional) opts2: (with default values)"

   432 

   433     pmDefaults = PackageMaker.packageInfoDefaults

   434     optionalKeys = pmDefaults.keys()

   435     for k in mandatoryKeys:

   436         optionalKeys.remove(k)

   437     optionalKeys.sort()

   438     maxKeyLen = max(map(len, optionalKeys))

   439     for k in optionalKeys:

   440         format = "               --%%s:%s %%s"

   441         format = format % (" " * (maxKeyLen-len(k)))

   442         print format % (k, repr(pmDefaults[k]))

   443 

   444 

   445 def main():

   446     "Command-line interface."

   447 

   448     shortOpts = ""

   449     keys = PackageMaker.packageInfoDefaults.keys()

   450     longOpts = map(lambda k: k+"=", keys)

   451 

   452     try:

   453         opts, args = getopt.getopt(sys.argv[1:], shortOpts, longOpts)

   454     except getopt.GetoptError, details:

   455         print details

   456         printUsage()

   457         return

   458 

   459     optsDict = {}

   460     for k, v in opts:

   461         optsDict[k[2:]] = v

   462 

   463     ok = optsDict.keys()

   464     if not (1 <= len(args) <= 2):

   465         print "No argument given!"

   466     elif not ("Title" in ok and \

   467               "Version" in ok and \

   468               "Description" in ok):

   469         print "Missing mandatory option!"

   470     else:

   471         apply(buildPackage, args, optsDict)

   472         return

   473 

   474     printUsage()

   475 

   476     # sample use:

   477     # buildpkg.py --Title=distutils \

   478     #             --Version=1.0.2 \

   479     #             --Description="Python distutils package." \

   480     #             /Users/dinu/Desktop/distutils

   481 

   482 

   483 if __name__ == "__main__":

   484     main()