##############################################################################

#

# Copyright (c) 2005-2009 Zope Corporation and Contributors.

# All Rights Reserved.

#

# This software is subject to the provisions of the Zope Public License,

# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.

# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED

# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS

# FOR A PARTICULAR PURPOSE.

#

##############################################################################

"""Buildout main script

"""

from rmtree import rmtree

try:

    from hashlib import md5

except ImportError:

    # Python 2.4 and older

    from md5 import md5

import ConfigParser

import copy

import distutils.errors

import glob

import itertools

import logging

import os

import pkg_resources

import re

import shutil

import sys

import tempfile

import UserDict

import warnings

import zc.buildout

import zc.buildout.download

import zc.buildout.easy_install

realpath = zc.buildout.easy_install.realpath

pkg_resources_loc = pkg_resources.working_set.find(

    pkg_resources.Requirement.parse('setuptools')).location

_isurl = re.compile('([a-zA-Z0-9+.-]+)://').match

is_jython = sys.platform.startswith('java')

if is_jython:

    import subprocess

_sys_executable_has_broken_dash_S = (

    zc.buildout.easy_install._has_broken_dash_S(sys.executable))

class MissingOption(zc.buildout.UserError, KeyError):

    """A required option was missing.

    """

class MissingSection(zc.buildout.UserError, KeyError):

    """A required section is missing.

    """

    def __str__(self):

        return "The referenced section, %r, was not defined." % self[0]

def _annotate_section(section, note):

    for key in section:

        section[key] = (section[key], note)

    return section

def _annotate(data, note):

    for key in data:

        data[key] = _annotate_section(data[key], note)

    return data

def _print_annotate(data):

    sections = data.keys()

    sections.sort()

    print

    print "Annotated sections"

    print "="*len("Annotated sections")

    for section in sections:

        print

        print '[%s]' % section

        keys = data[section].keys()

        keys.sort()

        for key in keys:

            value, notes = data[section][key]

            keyvalue = "%s= %s" % (key, value)

            print keyvalue

            line = '   '

            for note in notes.split():

                if note == '[+]':

                    line = '+= '

                elif note == '[-]':

                    line = '-= '

                else:

                    print line, note

                    line = '   '

    print

def _unannotate_section(section):

    for key in section:

        value, note = section[key]

        section[key] = value

    return section

def _unannotate(data):

    for key in data:

        data[key] = _unannotate_section(data[key])

    return data

_buildout_default_options = _annotate_section({

    'accept-buildout-test-releases': 'false',

    'allow-hosts': '*',

    'allow-picked-versions': 'true',

    'allowed-eggs-from-site-packages': '*',

    'bin-directory': 'bin',

    'develop-eggs-directory': 'develop-eggs',

    'eggs-directory': 'eggs',

    'executable': sys.executable,

    'exec-sitecustomize': 'true',

    'find-links': '',

    'include-site-packages': 'true',

    'install-from-cache': 'false',

    'installed': '.installed.cfg',

    'log-format': '',

    'log-level': 'INFO',

    'newest': 'true',

    'offline': 'false',

    'parts-directory': 'parts',

    'prefer-final': 'false',

    'python': 'buildout',

    'relative-paths': 'false',

    'socket-timeout': '',

    'unzip': 'false',

    'use-dependency-links': 'true',

    }, 'DEFAULT_VALUE')

class Buildout(UserDict.DictMixin):

    def __init__(self, config_file, cloptions,

                 user_defaults=True, windows_restart=False, command=None):

        __doing__ = 'Initializing.'

        self.__windows_restart = windows_restart

        # default options

        data = dict(buildout=_buildout_default_options.copy())

        self._buildout_dir = os.getcwd()

        if not _isurl(config_file):

            config_file = os.path.abspath(config_file)

            base = os.path.dirname(config_file)

            if not os.path.exists(config_file):

                if command == 'init':

                    print 'Creating %r.' % config_file

                    open(config_file, 'w').write('[buildout]\nparts = \n')

                elif command == 'setup':

                    # Sigh. This model of a buildout instance

                    # with methods is breaking down. :(

                    config_file = None

                    data['buildout']['directory'] = ('.', 'COMPUTED_VALUE')

                else:

                    raise zc.buildout.UserError(

                        "Couldn't open %s" % config_file)

            if config_file:

                data['buildout']['directory'] = (os.path.dirname(config_file),

                    'COMPUTED_VALUE')

        else:

            base = None

        cloptions = dict(

            (section, dict((option, (value, 'COMMAND_LINE_VALUE'))

                           for (_, option, value) in v))

            for (section, v) in itertools.groupby(sorted(cloptions),

                                                  lambda v: v[0])

            )

        override = cloptions.get('buildout', {}).copy()

        # load user defaults, which override defaults

        if user_defaults:

            user_config = os.path.join(os.path.expanduser('~'),

                                       '.buildout', 'default.cfg')

            if os.path.exists(user_config):

                _update(data, _open(os.path.dirname(user_config), user_config,

                                    [], data['buildout'].copy(), override))

        # load configuration files

        if config_file:

            _update(data, _open(os.path.dirname(config_file), config_file, [],

                                data['buildout'].copy(), override))

        # apply command-line options

        _update(data, cloptions)

        self._annotated = copy.deepcopy(data)

        self._raw = _unannotate(data)

        self._data = {}

        self._parts = []

        # provide some defaults before options are parsed

        # because while parsing options those attributes might be

        # used already (Gottfried Ganssauge)

        buildout_section = data['buildout']

        # Try to make sure we have absolute paths for standard

        # directories. We do this before doing substitutions, in case

        # a one of these gets read by another section.  If any

        # variable references are used though, we leave it as is in

        # _buildout_path.

        if 'directory' in buildout_section:

            self._buildout_dir = buildout_section['directory']

            for name in ('bin', 'parts', 'eggs', 'develop-eggs'):

                d = self._buildout_path(buildout_section[name+'-directory'])

                buildout_section[name+'-directory'] = d

        # Attributes on this buildout object shouldn't be used by

        # recipes in their __init__.  It can cause bugs, because the

        # recipes will be instantiated below (``options = self['buildout']``)

        # before this has completed initializing.  These attributes are

        # left behind for legacy support but recipe authors should

        # beware of using them.  A better practice is for a recipe to

        # use the buildout['buildout'] options.

        links = buildout_section['find-links']

        self._links = links and links.split() or ()

        allow_hosts = buildout_section['allow-hosts'].split('\n')

        self._allow_hosts = tuple([host.strip() for host in allow_hosts

                                   if host.strip() != ''])

        self._logger = logging.getLogger('zc.buildout')

        self.offline = (buildout_section['offline'] == 'true')

        self.newest = (buildout_section['newest'] == 'true')

        self.accept_buildout_test_releases = (

            buildout_section['accept-buildout-test-releases'] == 'true')

        ##################################################################

        ## WARNING!!!

        ## ALL ATTRIBUTES MUST HAVE REASONABLE DEFAULTS AT THIS POINT

        ## OTHERWISE ATTRIBUTEERRORS MIGHT HAPPEN ANY TIME FROM RECIPES.

        ## RECIPES SHOULD GENERALLY USE buildout['buildout'] OPTIONS, NOT

        ## BUILDOUT ATTRIBUTES.

        ##################################################################

        # initialize some attrs and buildout directories.

        options = self['buildout']

        # now reinitialize

        links = options.get('find-links', '')

        self._links = links and links.split() or ()

        allow_hosts = options['allow-hosts'].split('\n')

        self._allow_hosts = tuple([host.strip() for host in allow_hosts

                                   if host.strip() != ''])

        self._buildout_dir = options['directory']

        # Make sure we have absolute paths for standard directories.  We do this

        # a second time here in case someone overrode these in their configs.

        for name in ('bin', 'parts', 'eggs', 'develop-eggs'):

            d = self._buildout_path(options[name+'-directory'])

            options[name+'-directory'] = d

        if options['installed']:

            options['installed'] = os.path.join(options['directory'],

                                                options['installed'])

        self._setup_logging()

        versions = options.get('versions')

        if versions:

            zc.buildout.easy_install.default_versions(dict(self[versions]))

        self.offline = options.get_bool('offline')

        if self.offline:

            options['newest'] = 'false'

        self.newest = options.get_bool('newest')

        zc.buildout.easy_install.prefer_final(

            options.get_bool('prefer-final'))

        self.accept_buildout_test_releases = options.get_bool(

            'accept-buildout-test-releases')

        zc.buildout.easy_install.use_dependency_links(

            options.get_bool('use-dependency-links'))

        zc.buildout.easy_install.allow_picked_versions(

            options.get_bool('allow-picked-versions'))

        zc.buildout.easy_install.install_from_cache(

            options.get_bool('install-from-cache'))

        zc.buildout.easy_install.always_unzip(options.get_bool('unzip'))

        allowed_eggs = tuple(name.strip() for name in options[

            'allowed-eggs-from-site-packages'].split('\n'))

        self.include_site_packages = options.get_bool('include-site-packages')

        self.exec_sitecustomize = options.get_bool('exec-sitecustomize')

        if (_sys_executable_has_broken_dash_S and

            (not self.include_site_packages or allowed_eggs != ('*',))):

            # We can't do this if the executable has a broken -S.

            warnings.warn(zc.buildout.easy_install.BROKEN_DASH_S_WARNING)

            self.include_site_packages = True

        zc.buildout.easy_install.allowed_eggs_from_site_packages(allowed_eggs)

        zc.buildout.easy_install.include_site_packages(

            self.include_site_packages)

        download_cache = options.get('download-cache')

        if download_cache:

            download_cache = os.path.join(options['directory'], download_cache)

            if not os.path.isdir(download_cache):

                raise zc.buildout.UserError(

                    'The specified download cache:\n'

                    '%r\n'

                    "Doesn't exist.\n"

                    % download_cache)

            download_cache = os.path.join(download_cache, 'dist')

            if not os.path.isdir(download_cache):

                os.mkdir(download_cache)

            zc.buildout.easy_install.download_cache(download_cache)

        # "Use" each of the defaults so they aren't reported as unused options.

        for name in _buildout_default_options:

            options[name]

        # Do the same for extends-cache which is not among the defaults but

        # wasn't recognized as having been used since it was used before

        # tracking was turned on.

        options.get('extends-cache')

        os.chdir(options['directory'])

    def _buildout_path(self, name):

        if '${' in name:

            return name

        return os.path.join(self._buildout_dir, name)

    def bootstrap(self, args):

        __doing__ = 'Bootstrapping.'

        self._setup_directories()

        options = self['buildout']

        # Get a base working set for our distributions that corresponds to the

        # stated desires in the configuration.

        distributions = ['setuptools', 'zc.buildout']

        if options.get('offline') == 'true':

            ws = zc.buildout.easy_install.working_set(

                distributions, options['executable'],

                [options['develop-eggs-directory'],

                 options['eggs-directory']],

                prefer_final=not self.accept_buildout_test_releases,

                )

        else:

            ws = zc.buildout.easy_install.install(

                distributions, options['eggs-directory'],

                links=self._links,

                index=options.get('index'),

                executable=options['executable'],

                path=[options['develop-eggs-directory']],

                newest=self.newest,

                allow_hosts=self._allow_hosts,

                prefer_final=not self.accept_buildout_test_releases,

                )

        # Now copy buildout and setuptools eggs, and record destination eggs:

        entries = []

        for name in 'setuptools', 'zc.buildout':

            r = pkg_resources.Requirement.parse(name)

            dist = ws.find(r)

            if dist.precedence == pkg_resources.DEVELOP_DIST:

                dest = os.path.join(self['buildout']['develop-eggs-directory'],

                                    name+'.egg-link')

                open(dest, 'w').write(dist.location)

                entries.append(dist.location)

            else:

                dest = os.path.join(self['buildout']['eggs-directory'],

                                    os.path.basename(dist.location))

                entries.append(dest)

                if not os.path.exists(dest):

                    if os.path.isdir(dist.location):

                        shutil.copytree(dist.location, dest)

                    else:

                        shutil.copy2(dist.location, dest)

        # Create buildout script.

        # Ideally the (possibly) new version of buildout would get a

        # chance to write the script.  Not sure how to do that.

        ws = pkg_resources.WorkingSet(entries)

        ws.require('zc.buildout')

        partsdir = os.path.join(options['parts-directory'], 'buildout')

        if not os.path.exists(partsdir):

            os.mkdir(partsdir)

        # (Honor the relative-paths option.)

        relative_paths = options.get('relative-paths', 'false')

        if relative_paths == 'true':

            relative_paths = options['directory']

        else:

            assert relative_paths == 'false'

            relative_paths = ''

        if (self.accept_buildout_test_releases and

            self._annotated['buildout']['accept-buildout-test-releases'][1] ==

            'COMMAND_LINE_VALUE'):

            # Bootstrap was called with '--accept-buildout-test-releases'.

            # Continue to honor that setting.

            script_initialization = _early_release_initialization_code

        else:

            script_initialization = ''

        zc.buildout.easy_install.sitepackage_safe_scripts(

            options['bin-directory'], ws, options['executable'], partsdir,

            reqs=['zc.buildout'], relative_paths=relative_paths,

            include_site_packages=self.include_site_packages,

            script_initialization=script_initialization,

            exec_sitecustomize=self.exec_sitecustomize,

            )

    init = bootstrap

    def install(self, install_args):

        __doing__ = 'Installing.'

        self._load_extensions()

        self._setup_directories()

        # Add develop-eggs directory to path so that it gets searched

        # for eggs:

        sys.path.insert(0, self['buildout']['develop-eggs-directory'])

        # Check for updates. This could cause the process to be restarted.

        self._maybe_upgrade()

        # load installed data

        (installed_part_options, installed_exists

         )= self._read_installed_part_options()

        # Remove old develop eggs

        self._uninstall(

            installed_part_options['buildout'].get(

                'installed_develop_eggs', '')

            )

        # Build develop eggs

        installed_develop_eggs = self._develop()

        installed_part_options['buildout']['installed_develop_eggs'

                                           ] = installed_develop_eggs

        if installed_exists:

            self._update_installed(

                installed_develop_eggs=installed_develop_eggs)

        # get configured and installed part lists

        conf_parts = self['buildout']['parts']

        conf_parts = conf_parts and conf_parts.split() or []

        installed_parts = installed_part_options['buildout']['parts']

        installed_parts = installed_parts and installed_parts.split() or []

        if install_args:

            install_parts = install_args

            uninstall_missing = False

        else:

            install_parts = conf_parts

            uninstall_missing = True

        # load and initialize recipes

        [self[part]['recipe'] for part in install_parts]

        if not install_args:

            install_parts = self._parts

        if self._log_level < logging.DEBUG:

            sections = list(self)

            sections.sort()

            print

            print 'Configuration data:'

            for section in self._data:

                _save_options(section, self[section], sys.stdout)

            print

        # compute new part recipe signatures

        self._compute_part_signatures(install_parts)

        # uninstall parts that are no-longer used or whose configs

        # have changed

        for part in reversed(installed_parts):

            if part in install_parts:

                old_options = installed_part_options[part].copy()

                installed_files = old_options.pop('__buildout_installed__')

                new_options = self.get(part)

                if old_options == new_options:

                    # The options are the same, but are all of the

                    # installed files still there?  If not, we should

                    # reinstall.

                    if not installed_files:

                        continue

                    for f in installed_files.split('\n'):

                        if not os.path.exists(self._buildout_path(f)):

                            break

                    else:

                        continue

                # output debugging info

                if self._logger.getEffectiveLevel() < logging.DEBUG:

                    for k in old_options:

                        if k not in new_options:

                            self._logger.debug("Part %s, dropped option %s.",

                                               part, k)

                        elif old_options[k] != new_options[k]:

                            self._logger.debug(

                                "Part %s, option %s changed:\n%r != %r",

                                part, k, new_options[k], old_options[k],

                                )

                    for k in new_options:

                        if k not in old_options:

                            self._logger.debug("Part %s, new option %s.",

                                               part, k)

            elif not uninstall_missing:

                continue

            self._uninstall_part(part, installed_part_options)

            installed_parts = [p for p in installed_parts if p != part]

            if installed_exists:

                self._update_installed(parts=' '.join(installed_parts))

        # Check for unused buildout options: