#!/usr/bin/python2.4

#

# CDDL HEADER START

#

# The contents of this file are subject to the terms of the

# Common Development and Distribution License (the "License").

# You may not use this file except in compliance with the License.

#

# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

# or http://www.opensolaris.org/os/licensing.

# See the License for the specific language governing permissions

# and limitations under the License.

#

# When distributing Covered Code, include this CDDL HEADER in each

# file and include the License file at usr/src/OPENSOLARIS.LICENSE.

# If applicable, add the following below this CDDL HEADER, with the

# fields enclosed by brackets "[]" replaced with your own identifying

# information: Portions Copyright [yyyy] [name of copyright owner]

#

# CDDL HEADER END

#

# Copyright 2009 Sun Microsystems, Inc.  All rights reserved.

# Use is subject to license terms.

#

import errno

import fnmatch

import os

import platform

import stat

import sys

import shutil

import re

import subprocess

import tarfile

import tempfile

import urllib

import py_compile

import sha

from distutils.errors import DistutilsError

from distutils.core import setup, Extension

from distutils.cmd import Command

from distutils.command.install import install as _install

from distutils.command.build import build as _build

from distutils.command.build_py import build_py as _build_py

from distutils.command.bdist import bdist as _bdist

from distutils.command.clean import clean as _clean

from distutils.sysconfig import get_python_inc

import distutils.file_util as file_util

import distutils.dir_util as dir_util

import distutils.util as util

# 3rd party software required for the build

CP = 'CherryPy'

CPIDIR = 'cherrypy'

CPVER = '3.1.1'

CPARC = '%s-%s.tar.gz' % (CP, CPVER)

CPDIR = '%s-%s' % (CP, CPVER)

CPURL = 'http://download.cherrypy.org/cherrypy/%s/%s' % (CPVER, CPARC)

CPHASH = '0a8aace00ea28adc05edd41e20dd910042e6d265'

PO = 'pyOpenSSL'

POIDIR = 'OpenSSL'

POVER = '0.7'

POARC = '%s-%s.tar.gz' % (PO, POVER)

PODIR = '%s-%s' % (PO, POVER)

POURL = 'http://downloads.sourceforge.net/pyopenssl/%s' % (POARC)

POHASH = 'bd072fef8eb36241852d25a9161282a051f0a63e'

FL = 'figleaf'

FLIDIR = 'figleaf'

FLVER = 'latest'

FLARC = '%s-%s.tar.gz' % (FL, FLVER)

FLDIR = '%s-%s' % (FL, FLVER)

FLURL = 'http://darcs.idyll.org/~t/projects/%s' % FLARC

# No hash, since we always fetch the latest

FLHASH = None

MAKO = 'Mako'

MAKOIDIR = 'mako'

MAKOVER = '0.2.2'

MAKOARC = '%s-%s.tar.gz' % (MAKO, MAKOVER)

MAKODIR = '%s-%s' % (MAKO, MAKOVER)

MAKOURL = 'http://www.makotemplates.org/downloads/%s' % (MAKOARC)

MAKOHASH = '85c04ab3a6a26a1cab47067449712d15a8b29790'

PLY = 'ply'

PLYIDIR = 'ply'

PLYVER = '3.1'

PLYARC = '%s-%s.tar.gz' % (PLY, PLYVER)

PLYDIR = '%s-%s' % (PLY, PLYVER)

PLYURL = 'http://www.dabeaz.com/ply/%s' % (PLYARC)

PLYHASH = '38efe9e03bc39d40ee73fa566eb9c1975f1a8003'

PC = 'pycurl'

PCIDIR = 'pycurl'

PCVER = '7.19.0'

PCARC = '%s-%s.tar.gz' % (PC, PCVER)

PCDIR = '%s-%s' % (PC, PCVER)

PCURL = 'http://pycurl.sourceforge.net/download/%s' % PCARC

PCHASH = '3fb59eca1461331bb9e9e8d6fe3b23eda961a416'

osname = platform.uname()[0].lower()

ostype = arch = 'unknown'

if osname == 'sunos':

        arch = platform.processor()

        ostype = "posix"

elif osname == 'linux':

        arch = "linux_" + platform.machine()

        ostype = "posix"

elif osname == 'windows':

        arch = osname

        ostype = "windows"

elif osname == 'darwin':

        arch = osname

        ostype = "posix"

pwd = os.path.normpath(sys.path[0])

#

# Unbuffer stdout and stderr.  This helps to ensure that subprocess output

# is properly interleaved with output from this program.

#

sys.stdout = os.fdopen(sys.stdout.fileno(), "w", 0)

sys.stderr = os.fdopen(sys.stderr.fileno(), "w", 0)

dist_dir = os.path.normpath(os.path.join(pwd, os.pardir, "proto", "dist_" + arch))

build_dir = os.path.normpath(os.path.join(pwd, os.pardir, "proto", "build_" + arch))

if "ROOT" in os.environ and os.environ["ROOT"] != "":

        root_dir = os.environ["ROOT"]

else:

        root_dir = os.path.normpath(os.path.join(pwd, os.pardir, "proto", "root_" + arch))

pkgs_dir = os.path.normpath(os.path.join(pwd, os.pardir, "packages", arch))

extern_dir = os.path.normpath(os.path.join(pwd, "extern"))

cacert_dir = os.path.normpath(os.path.join(pwd, "cacert"))

cacert_install_dir = 'usr/share/pkg/cacert'

py_install_dir = 'usr/lib/python2.4/vendor-packages'

scripts_dir = 'usr/bin'

lib_dir = 'usr/lib'

svc_method_dir = 'lib/svc/method'

man1_dir = 'usr/share/man/cat1'

man1m_dir = 'usr/share/man/cat1m'

man5_dir = 'usr/share/man/cat5'

resource_dir = 'usr/share/lib/pkg'

smf_dir = 'var/svc/manifest/application'

zones_dir = 'etc/zones'

brand_dir = 'usr/lib/brand/ipkg'

scripts_sunos = {

        scripts_dir: [

                ['client.py', 'pkg'],

                ['publish.py', 'pkgsend'],

                ['pull.py', 'pkgrecv'],

                ['packagemanager.py', 'packagemanager'],

                ['updatemanager.py', 'pm-updatemanager'],

                ],

        lib_dir: [

                ['depot.py', 'pkg.depotd'],

                ['updatemanagernotifier.py', 'updatemanagernotifier'],

                ['checkforupdates.py', 'pm-checkforupdates'],

                ['launch.py', 'pm-launch'],

                ],

        svc_method_dir: [

                ['svc/svc-pkg-depot', 'svc-pkg-depot'],

                ],

        }

scripts_windows = {

        scripts_dir: [

                ['client.py', 'client.py'],

                ['publish.py', 'publish.py'],

                ['pull.py', 'pull.py'],

                ['scripts/pkg.bat', 'pkg.bat'],

                ['scripts/pkgsend.bat', 'pkgsend.bat'],

                ['scripts/pkgrecv.bat', 'pkgrecv.bat'],

                ],

        lib_dir: [

                ['depot.py', 'depot.py'],

                ['scripts/pkg.depotd.bat', 'pkg.depotd.bat'],

                ],

        }

scripts_other_unix = {

        scripts_dir: [

                ['client.py', 'client.py'],

                ['pull.py', 'pull.py'],

                ['publish.py', 'publish.py'],

                ['scripts/pkg.sh', 'pkg'],

                ['scripts/pkgsend.sh', 'pkgsend'],

                ['scripts/pkgrecv.sh', 'pkgrecv'],

                ],

        lib_dir: [

                ['depot.py', 'depot.py'],

                ['scripts/pkg.depotd.sh', 'pkg.depotd'],

                ],

        }

# indexed by 'osname'

scripts = {

        "sunos": scripts_sunos,

        "linux": scripts_other_unix,

        "windows": scripts_windows,

        "darwin": scripts_other_unix,

        "unknown": scripts_sunos,

        }

man1_files = [

        'man/packagemanager.1',

        'man/pkg.1',

        'man/pkgsend.1',

        'man/pkgrecv.1',

        'man/pm-updatemanager.1',

        ]

man1m_files = [

        'man/pkg.depotd.1m'

        ]

man5_files = [

        'man/pkg.5'

        ]

packages = [

        'pkg',

        'pkg.actions',

        'pkg.bundle',

        'pkg.client',

        'pkg.client.transport',

        'pkg.portable',

        'pkg.publish',

        'pkg.server'

        ]

web_files = []

for entry in os.walk("web"):

        web_dir, dirs, files = entry

        if not files:

                continue

        web_files.append((os.path.join(resource_dir, web_dir), [

            os.path.join(web_dir, f) for f in files

            if f != "Makefile"

            ]))

zones_files = [

        'brand/SUNWipkg.xml',

        ]

brand_files = [

        'brand/config.xml',

        'brand/platform.xml',

        'brand/pkgcreatezone',

        'brand/attach',

        'brand/clone',

        'brand/detach',

        'brand/prestate',

        'brand/poststate',

        'brand/query',

        'brand/uninstall',

        'brand/common.ksh',

        ]

smf_files = [

        'svc/pkg-server.xml',

        'svc/pkg-update.xml',

        ]

pspawn_srcs = [

        'modules/pspawn.c'

        ]

elf_srcs = [

        'modules/elf.c',

        'modules/elfextract.c',

        'modules/liblist.c',

        ]

arch_srcs = [

        'modules/arch.c'

        ]

_actions_srcs = [

        'modules/actions/_actions.c'

        ]

include_dirs = [ 'modules' ]

lint_flags = [ '-u', '-axms', '-erroff=E_NAME_DEF_NOT_USED2' ]

# Runs the test suite with the code coverage suite (figleaf) turned on, and

# outputs a coverage report.

# TODO: Make the cov report format an option (html, ast, cov, etc)

class cov_func(Command):

        description = "Runs figleaf code coverage suite"

        user_options = []

        def initialize_options(self):

                pass

        def finalize_options(self):

                pass

        def run(self):

                if not os.path.isdir(FLDIR):

                        install_sw(FL, FLVER, FLARC, FLDIR, FLURL, FLIDIR,

                            FLHASH)

                # Run the test suite with coverage enabled

                os.putenv('PYEXE', sys.executable)

                os.chdir(os.path.join(pwd, "tests"))

                # Reconstruct the cmdline and send that to run.py

                os.environ["PKGCOVERAGE"] = "1"

                cmd = [sys.executable, "run.py"]

                subprocess.call(cmd)

                print "Generating coverage report in directory: '%s/cov_report'" % \

                    pwd

                os.system("figleaf2html -d cov_report .figleaf")

# Runs lint on the extension module source code

class lint_func(Command):

        description = "Runs various lint tools over IPS extension source code"

        user_options = []

        def initialize_options(self):

                pass

        def finalize_options(self):

                pass

        # Make string shell-friendly

        @staticmethod

        def escape(astring):

                return astring.replace(' ', '\\ ')

        def run(self):

                # assumes lint is on the $PATH

                if osname == 'sunos' or osname == "linux":

                        archcmd = ['lint'] + lint_flags + ['-D_FILE_OFFSET_BITS=64'] + \

                            ["%s%s" % ("-I", k) for k in include_dirs] + \

                            ['-I' + self.escape(get_python_inc())] + \

                            arch_srcs

                        elfcmd = ['lint'] + lint_flags + \

                            ["%s%s" % ("-I", k) for k in include_dirs] + \

                            ['-I' + self.escape(get_python_inc())] + \

                            ["%s%s" % ("-l", k) for k in elf_libraries] + \

                            elf_srcs

                        _actionscmd = ['lint'] + lint_flags + \

                            ["%s%s" % ("-I", k) for k in include_dirs] + \

                            ['-I' + self.escape(get_python_inc())] + \

                            _actions_srcs

                        pspawncmd = ['lint'] + lint_flags + ['-D_FILE_OFFSET_BITS=64'] + \

                            ["%s%s" % ("-I", k) for k in include_dirs] + \

                            ['-I' + self.escape(get_python_inc())] + \

                            pspawn_srcs

                        print(" ".join(archcmd))

                        os.system(" ".join(archcmd))

                        print(" ".join(elfcmd))

                        os.system(" ".join(elfcmd))

                        print(" ".join(_actionscmd))

                        os.system(" ".join(_actionscmd))

                        print(" ".join(pspawncmd))

                        os.system(" ".join(pspawncmd))

                        proto = os.path.join(root_dir, py_install_dir)

                        sys.path.insert(0, proto)

                        # Insert tests directory onto sys.path so any custom checkers

                        # can be found.

                        sys.path.insert(0, os.path.join(pwd, 'tests'))

                        print(sys.path)

                # assumes pylint is accessible on the sys.path

                from pylint import lint

                scriptlist = [ 'setup.py' ]

                for d, m in scripts_sunos.items():

                        for a in m:

                                # specify the filenames of the scripts, in addition

                                # to the package names themselves

                                scriptlist.append(os.path.join(root_dir, d, a[1]))

                # For some reason, the load-plugins option, when used in the

                # rcfile, does not work, so we put it here instead, to load

                # our custom checkers.

                lint.Run(['--load-plugins=multiplatform', '--rcfile',

                          os.path.join(pwd, 'tests', 'pylintrc')] +

                          scriptlist + packages)

class install_func(_install):

        def initialize_options(self):

                _install.initialize_options(self)

                # PRIVATE_BUILD set in the environment tells us to put the build

                # directory into the .pyc files, rather than the final

                # installation directory.

                private_build = os.getenv("PRIVATE_BUILD", None)

                if private_build is None:

                        self.install_lib = py_install_dir

                        self.install_data = os.path.sep

                        self.root = root_dir

                else:

                        self.install_lib = os.path.join(root_dir, py_install_dir)

                        self.install_data = root_dir

                # This is used when installing scripts, below, but it isn't a

                # standard distutils variable.

                self.root_dir = root_dir

        def run(self):

                """

                At the end of the install function, we need to rename some files

                because distutils provides no way to rename files as they are

                placed in their install locations.

                Also, make sure that cherrypy and other external dependencies

                are installed.

                """

                for f in man1_files + man1m_files + man5_files:

                        file_util.copy_file(f + ".txt", f, update=1)

                _install.run(self)

                for d, files in scripts[osname].iteritems():

                        for (srcname, dstname) in files:

                                dst_dir = util.change_root(self.root_dir, d)

                                dst_path = util.change_root(self.root_dir,

                                       os.path.join(d, dstname))

                                dir_util.mkpath(dst_dir, verbose = True)

                                file_util.copy_file(srcname, dst_path, update = True)

                                # make scripts executable

                                os.chmod(dst_path,

                                    os.stat(dst_path).st_mode

                                    | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)

                # Take cacerts in cacert_dir and install them in

                # proto-area-relative cacert_install_dir

                install_cacerts()

                install_sw(CP, CPVER, CPARC, CPDIR, CPURL, CPIDIR, CPHASH)

		if "BUILD_PYOPENSSL" in os.environ and \

                    os.environ["BUILD_PYOPENSSL"] != "":

                        #

                        # Include /usr/sfw/lib in the build environment

                        # to ensure that this builds and runs on older

                        # nevada builds, before openssl moved out of /usr/sfw.

                        #

                        saveenv = os.environ.copy()

                        if osname == "sunos":

                                os.environ["CFLAGS"] = "-I/usr/sfw/include " + \

                                    os.environ.get("CFLAGS", "")

                                os.environ["LDFLAGS"] = \

                                    "-L/usr/sfw/lib -R/usr/sfw/lib " + \

                                    os.environ.get("LDFLAGS", "")

                        install_sw(PO, POVER, POARC, PODIR, POURL, POIDIR,

                            POHASH)

                        os.environ = saveenv

                install_sw(MAKO, MAKOVER, MAKOARC, MAKODIR, MAKOURL, MAKOIDIR,

                    MAKOHASH)

                install_sw(PLY, PLYVER, PLYARC, PLYDIR, PLYURL, PLYIDIR,

                    PLYHASH)

                install_sw(PC, PCVER, PCARC, PCDIR, PCURL, PCIDIR, PCHASH)

                # Remove some bits that we're not going to package, but be sure

                # not to complain if we try to remove them twice.

                def onerror(func, path, exc_info):

                        if exc_info[1].errno != errno.ENOENT:

                                raise

                for dir in ("cherrypy/scaffold", "cherrypy/test",

                    "cherrypy/tutorial"):

                        shutil.rmtree(os.path.join(root_dir, py_install_dir, dir),

                            onerror=onerror)

                try:

                        os.remove(os.path.join(root_dir, "usr/bin/mako-render"))

                except EnvironmentError, e:

                        if e.errno != errno.ENOENT:

                                raise

def hash_sw(swname, swarc, swhash):

        if swhash == None:

                return True

        print "checksumming %s" % swname

        hash = sha.new()

        f = open(swarc, 'r')

        while True:

                data = f.read(65536)

                if data == "":

                        break

                hash.update(data)

        f.close()

        if hash.hexdigest() == swhash:

                return True

        else:

                print >> sys.stderr, "bad checksum! %s != %s" % \

                    (swhash, hash.hexdigest())

                return False