appypod-rattail/bin/new.py

#!/usr/bin/python2.4.4
'''This script allows to create a brand new read-to-use Plone/Zone instance.
   As prerequisite, you must have installed Plone through the Unifier installer
   available at http://plone.org.'''

# ------------------------------------------------------------------------------
import os, os.path, sys, shutil
from optparse import OptionParser
from appy.shared.utils import cleanFolder

# ------------------------------------------------------------------------------
class NewError(Exception): pass
ERROR_CODE = 1
WRONG_NB_OF_ARGS = 'Wrong number of args.'
WRONG_PLONE_VERSION = 'Plone version must be among %s.'
WRONG_PLONE_PATH = 'Path "%s" is not an existing folder.'
PYTHON_NOT_FOUND = 'Python interpreter was not found in "%s". Are you sure ' \
    'we are in the folder hierarchy created by the Plone installer?'
PYTHON_EXE_NOT_FOUND = '"%s" does not exist.'
MKZOPE_NOT_FOUND = 'Script mkzopeinstance.py not found in "%s and ' \
    'subfolders. Are you sure we are in the folder hierarchy created by ' \
    'the Plone installer?'
WRONG_INSTANCE_PATH = '"%s" must be an existing folder for creating the ' \
    'instance in it.'

# ------------------------------------------------------------------------------
class NewScript:
    '''usage: %prog ploneVersion plonePath instancePath

       "ploneVersion"  can be plone25 or plone3
       
       "plonePath"     is the (absolute) path to you plone installation.
                       Plone 2.5 is typically installed in /opt/Plone-2.5.5,
                       while Plone 3 is typically installed in /usr/local/Plone.
       "instancePath"  is the (absolute) path where you want to create your
                       instance (should not already exist).'''
    ploneVersions = ('plone25', 'plone3')

    def createInstance(self, linksForProducts):
        '''Calls the Zope script that allows to create a Zope instance and copy
           into it all the Plone packages and products.'''
        # Find the Python interpreter running Zope
        for elem in os.listdir(self.plonePath):
            pythonPath = None
            elemPath = os.path.join(self.plonePath, elem)
            if elem.startswith('Python-') and os.path.isdir(elemPath):
                pythonPath = elemPath + '/bin/python'
                if not os.path.exists(pythonPath):
                    raise NewError(PYTHON_EXE_NOT_FOUND % pythonPath)
                break
        if not pythonPath:
            raise NewError(PYTHON_NOT_FOUND % self.plonePath)
        # Find the Zope script mkzopeinstance.py
        makeInstancePath = None
        for dirname, dirs, files in os.walk(self.plonePath):
            # Do not browse the buildout-cache
            for fileName in files:
                if (fileName == 'mkzopeinstance.py') and \
                   ('/buildout-cache/' not in dirname):
                    makeInstancePath = os.path.join(dirname, fileName)
        if not makeInstancePath:
            raise NewError(MKZOPE_NOT_FOUND % self.plonePath)
        # Execute mkzopeinstance.py with the right Python interpreter
        cmd = '%s %s -d %s' % (pythonPath, makeInstancePath, self.instancePath)
        print cmd
        os.system(cmd)
        # Now, make the instance Plone-ready
        productsFolder = os.path.join(self.instancePath, 'Products')
        libFolder = os.path.join(self.instancePath, 'lib/python')
        print 'Copying Plone stuff in the Zope instance...'
        if self.ploneVersion == 'plone25':
            self.installPlone25Stuff(productsFolder,libFolder,linksForProducts)
        elif self.ploneVersion == 'plone3':
            self.installPlone3Stuff(productsFolder, libFolder)
        # Clean the copied folders
        cleanFolder(productsFolder)
        cleanFolder(libFolder)

    def installPlone25Stuff(self, productsFolder, libFolder, linksForProducts):
        '''Here, we will copy all Plone2-related stuff in the Zope instance
           we've created, to get a full Plone-ready Zope instance. If
           p_linksForProducts is True, we do not perform a real copy: we will
           create symlinks to products lying within Plone installer files.'''
        installerProducts = os.path.join(self.plonePath, 'zeocluster/Products')
        for name in os.listdir(installerProducts):
            folderName = os.path.join(installerProducts, name)
            if os.path.isdir(folderName):
                destFolder = os.path.join(productsFolder, name)
                # This is a Plone product. Copy it to the instance.
                if (self.ploneVersion == 'plone25') and linksForProducts:
                    # Create a symlink to this product in the instance
                    cmd = 'ln -s %s %s' % (folderName, destFolder)
                    os.system(cmd)
                else:
                    # Copy thre product into the instance
                    shutil.copytree(folderName, destFolder)

    uglyChunks = ('pkg_resources', '.declare_namespace(')
    def findPythonPackageInEgg(self, currentFolder):
        '''Finds the Python package that is deeply hidden into the egg.'''
        # Find the file __init__.py
        isFinalPackage = False
        for elem in os.listdir(currentFolder):
            elemPath = os.path.join(currentFolder, elem)
            if elem == '__init__.py':
                f = file(elemPath)
                content = f.read()
                f.close()
                # Is it a awful egg init ?
                for chunk in self.uglyChunks:
                    if content.find(chunk) == -1:
                        isFinalPackage = True # It is not an ugly egg init.
                        break
        if not isFinalPackage:
            # Maybe we are wrong: our way to identify egg-viciated __init__
            # files is approximative. If we believe it is not the final package,
            # but we find other Python files in the folder, we must admit that
            # we've nevertheless found the final Python package.
            otherPythonFiles = False
            for elem in os.listdir(currentFolder):
                if elem.endswith('.py') and (elem != '__init__.py'):
                    otherPythonFiles = True
                    break
            if otherPythonFiles:
                # Ok, this is the final Python package
                return currentFolder
            # Find the subfolder and find the Python package into it.
            for elem in os.listdir(currentFolder):
                elemPath = os.path.join(currentFolder, elem)
                if os.path.isdir(elemPath):
                    return self.findPythonPackageInEgg(elemPath)
        else:
            return currentFolder

    def getSubFolder(self, folder):
        '''In p_folder, we now that there is only one subfolder. This method
           returns the subfolder's absolute path.'''
        for elem in os.listdir(folder):
            elemPath = os.path.join(folder, elem)
            if (elem != 'EGG-INFO') and os.path.isdir(elemPath):
                return elemPath
        return None

    viciatedFiles = {'meta.zcml':      'includePlugins',
                     'configure.zcml': 'includePlugins',
                     'overrides.zcml': 'includePluginsOverrides'}
    def patchPlone(self, productsFolder, libFolder):
        '''Auto-proclaimed ugly code in z3c forces us to patch some files
           in Products.CMFPlone because these guys make the assumption that
           "plone.xxx" packages are within eggs when they've implemented their
           ZCML directives "includePlugins" and "includePluginsOverrides".
           So in this method, I remove every call to those directives in
           CMFPlone files. It does not seem to affect Plone behaviour. Indeed,
           these directives seem to be useful only when adding sad (ie, non
           Appy) Plone plug-ins.'''
        ploneFolder = os.path.join(productsFolder, 'CMFPlone')
        # Patch viciated files
        for fileName, uglyDirective in self.viciatedFiles.iteritems():
            filePath = os.path.join(ploneFolder, fileName)
            f = file(filePath)
            fileContent = f.read()
            f.close()
            if fileContent.find(uglyDirective) != -1:
                toReplace = '<%s package="plone" file="%s" />' % \
                            (uglyDirective, fileName)
                fileContent = fileContent.replace(toReplace, '')
                f = file(filePath, 'w')
                f.write(fileContent)
                f.close()

    def installPlone3Stuff(self, productsFolder, libFolder):
        '''Here, we will copy all Plone3-related stuff in the Zope instance
           we've created, to get a full Plone-ready Zope instance.'''
        # All Plone 3 eggs are in buildout-cache/eggs. We will extract from
        # those silly overstructured folder hierarchies the standard Python
        # packages that lie in it, and copy them in the instance. Within these
        # eggs, we need to distinguish:
        # - standard Python packages that will be copied in
        #   <zopeInstance>/lib/python (ie, like Appy applications)
        # - Zope products that will be copied in
        #   <zopeInstance>/Products (ie, like Appy generated Zope products)
        eggsFolder = os.path.join(self.plonePath, 'buildout-cache/eggs')
        for name in os.listdir(eggsFolder):
            eggMainFolder = os.path.join(eggsFolder, name)
            if name.startswith('Products.'):
                # A Zope product. Copy its content in Products.
                innerFolder= self.getSubFolder(self.getSubFolder(eggMainFolder))
                destFolder = os.path.join(productsFolder,
                                          os.path.basename(innerFolder))
                shutil.copytree(innerFolder, destFolder)
            else:
                # A standard Python package. Copy its content in lib/python.
                # Go into the subFolder that is not EGG-INFO.
                eggFolder = self.getSubFolder(eggMainFolder)
                if not eggFolder:
                    # This egg is malformed and contains basic Python files.
                    # Copy those files directly in libFolder.
                    for fileName in os.listdir(eggMainFolder):
                        if fileName.endswith('.py'):
                            fullFileName= os.path.join(eggMainFolder, fileName)
                            shutil.copy(fullFileName, libFolder)
                    continue
                eggFolderName = os.path.basename(eggFolder)
                if eggFolderName == 'Products':
                    # Goddamned. This should go in productsFolder and not in
                    # libFolder.
                    innerFolder = self.getSubFolder(eggFolder)
                    destFolder = os.path.join(productsFolder,
                                              os.path.basename(innerFolder))
                    shutil.copytree(innerFolder, destFolder)
                else:
                    packageFolder = self.findPythonPackageInEgg(eggFolder)
                    # Create the destination folder(s) in the instance,
                    # within libFolder
                    destFolders = []
                    if packageFolder != eggFolder:
                        destFolders = [eggFolderName]
                        remFolders = packageFolder[len(eggFolder):]
                        remFolders = remFolders.strip(os.sep)
                        if remFolders.find(os.sep) != -1:
                            # There are more subfolders
                            destFolders += remFolders.split(os.sep)[:-1]
                    if destFolders:
                        # We must create the subfolders (if not yet created)
                        # before copying the Python package.
                        baseFolder = libFolder
                        for subFolder in destFolders:
                            subFolderPath=os.path.join(baseFolder,subFolder)
                            if not os.path.exists(subFolderPath):
                                os.mkdir(subFolderPath)
                                # Create an empty __init__.py in it.
                                init = os.path.join(subFolderPath,'__init__.py')
                                f = file(init, 'w')
                                f.write('# Makes me a Python package.')
                                f.close()
                            baseFolder = subFolderPath
                        destFolder = os.sep.join(destFolders)
                        destFolder = os.path.join(libFolder, destFolder)
                        if not os.path.exists(destFolder):
                            os.makedirs(destFolder)
                    else:
                        destFolder = libFolder
                    destFolder = os.path.join(
                        destFolder, os.path.basename(packageFolder))
                    shutil.copytree(packageFolder, destFolder)
        self.patchPlone(productsFolder, libFolder)

    def manageArgs(self, args):
        '''Ensures that the script was called with the right parameters.'''
        if len(args) != 3: raise NewError(WRONG_NB_OF_ARGS)
        self.ploneVersion, self.plonePath, self.instancePath = args
        # Check Plone version
        if self.ploneVersion not in self.ploneVersions:
            raise NewError(WRONG_PLONE_VERSION % str(self.ploneVersions))
        # Check Plone path
        if not os.path.exists(self.plonePath) \
           or not os.path.isdir(self.plonePath):
            raise NewError(WRONG_PLONE_PATH % self.plonePath)
        # Check instance path
        parentFolder = os.path.dirname(self.instancePath)
        if not os.path.exists(parentFolder) or not os.path.isdir(parentFolder):
            raise NewError(WRONG_INSTANCE_PATH % parentFolder)

    def run(self):
        optParser = OptionParser(usage=NewScript.__doc__)
        optParser.add_option("-l", "--links", action="store_true",
            help="[Linux, plone25 only] Within the created instance, symlinks "\
                 "to Products lying within the Plone installer files are " \
                 "created instead of copying them into the instance. This " \
                 "avoids duplicating the Products source code and is " \
                 "interesting if you create a lot of Zope instances.")
        (options, args) = optParser.parse_args()
        linksForProducts = options.links
        try:
            self.manageArgs(args)
            print 'Creating new %s instance...' % self.ploneVersion
            self.createInstance(linksForProducts)
        except NewError, ne:
            optParser.print_help()
            print
            sys.stderr.write(str(ne))
            sys.stderr.write('\n')
            sys.exit(ERROR_CODE)

# ------------------------------------------------------------------------------
if __name__ == '__main__':
    NewScript().run()
# ------------------------------------------------------------------------------