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

# Use is subject to license terms.

#

import tarfile

import urllib

        arch = platform.processor()

        ostype = "posix"

        arch = "linux_" + platform.machine()

        ostype = "posix"

        arch = osname

        ostype = "windows"

        arch = osname

        ostype = "posix"

man5_dir = 'usr/share/man/cat5'

scripts_sunos = {

        scripts_dir: [   

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

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

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

                ],

        lib_dir: [

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

                ],

        }

        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_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'],

                ],

        }

scripts = { 

        "sunos": scripts_sunos,

        "linux": scripts_other_unix,

        "windows": scripts_windows,

        "darwin": scripts_other_unix,

        "unknown": scripts_sunos,

        }

man1_files = [

        'man/pkg.1.txt',

        'man/pkgsend.1.txt',

        'man/pkgrecv.1.txt',

        ]

man1m_files = [

        'man/pkg.depotd.1m.txt'

        ]

man5_files = [

        'man/pkg.5.txt'

        ]

packages = [

        'pkg',

        'pkg.actions',

        'pkg.bundle',

        'pkg.client',

        'pkg.portable',

        'pkg.publish',

        'pkg.server',

        ]

web_files = [

        'web/pkg-block-icon.png',

        'web/pkg-block-logo.png',

        'web/pkg.css',

        'web/robots.txt',

        ]

zones_files = [

        'brand/SUNWipkg.xml',

        ]

brand_files = [

        'brand/config.xml',

        'brand/platform.xml',

        'brand/pkgcreatezone',

        ]

smf_files = [

        'pkg-server.xml',

        ]

elf_srcs = [

        'modules/elf.c',

        'modules/elfextract.c',

        'modules/liblist.c',

        ]

        'modules/arch.c'

        ]

include_dirs = [ 'modules' ]

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

        def escape(astring):

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

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

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

                            arch_srcs

                            ["%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

                        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)

                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]))

class install_func(_install):

                _install.initialize_options(self)

                # It's OK to have /'s here, python figures it out when writing files

                self.install_purelib = py_install_dir

                self.install_platlib = py_install_dir

                self.root = root_dir

                self.prefix = '.'

                """

                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 is installed.

                """

                _install.run(self)

                if ostype == 'posix':

                        # only rename manpages if building for unix-derived OS

                        for (d, files) in [(man1_dir, man1_files), (man1m_dir,

                            man1m_files), (man5_dir, man5_files)]:

                                for f in files:

                                        src = util.change_root(self.root, 

                                            os.path.join(d, os.path.basename(f)))

                                        if src.endswith('.txt'):

                                                dst = src[:-4]

                                                os.rename(src, dst)

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

                        for (srcname, dstname) in files:

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

                                dst_path = util.change_root(self.root,

                                       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_IEXEC)

                install_cherrypy()              

CP = 'CherryPy'

CPVER = '3.0.3'

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

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

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

def install_cherrypy():

        if not os.path.exists(CPARC):

                print "downloading CherryPy"

                try:

                        fname, hdr = urllib.urlretrieve(CPURL, CPARC)

                except IOError:

                        pass

                if not os.path.exists(CPARC) or \

                    hdr.gettype() != "application/x-gzip":

                        print "Unable to retrieve %s.\nPlease retrieve the file " \

                            "and place it at: %s\n" % (CPURL, CPARC)

                        # remove a partial download or error message from proxy

                        remove_cherrypy()

                        sys.exit(1)

        if not os.path.exists(CPDIR):

                print "unpacking CherryPy"

                tar = tarfile.open(CPARC)

                # extractall doesn't exist until python 2.5

                for m in tar.getmembers():

                        tar.extract(m)

                tar.close()

        cherrypy_dir = os.path.join(root_dir, py_install_dir, "cherrypy")

        if not os.path.exists(cherrypy_dir):

                print "installing CherryPy"

                subprocess.Popen(['python', 'setup.py', 'install',

                        '--install-lib=%s' % os.path.join(root_dir, py_install_dir),

                        '--install-data=%s' % os.path.join(root_dir, py_install_dir)], 

                        cwd = CPDIR).wait()

def remove_cherrypy():

        if os.path.exists(CPARC):

                os.unlink(CPARC)

        shutil.rmtree(CPDIR, True)

                _build.initialize_options(self)

                self.build_base = build_dir

                p = subprocess.Popen(['hg', 'id', '-i'], stdout = subprocess.PIPE)

                _clean.initialize_options(self)

                self.build_base = build_dir

                print("deleting " + dist_dir)

                print("deleting " + build_dir)

                print("deleting " + root_dir)

                print("deleting cherrypy")

                remove_cherrypy()

                print "logging to %s" % testlogpath

                subprocess.call([sys.executable, "api-complete.py"], 

                    stdout = testlogfp)

                        subprocess.call([sys.executable, "cli-complete.py"], 

                            stdout = testlogfp)

                        subprocess.call(["/bin/ksh", "memleaks.ksh"], 

                            stdout = testlogfp)

                _bdist.initialize_options(self)            

                self.dist_dir = dist_dir

data_files = [ (resource_dir, web_files) ] 

cmdclasses = {

        'install': install_func,

        'build': build_func,

        'build_py': build_py_func,

        'bdist': dist_func,

        'lint': lint_func,

        'clean': clean_func,

        'clobber': clobber_func,

        'test': test_func,

        }

data_files += [

        (man1_dir, man1_files),

        (man1m_dir, man1m_files),

        (man5_dir, man5_files),

        ]

        # Solaris-specific extensions are added here

        data_files += [

                (zones_dir, zones_files),

                (brand_dir, brand_files),

                (smf_dir, smf_files),

                ]

        # Unix platforms which the elf extension has been ported to

        # are specified here, so they are built automatically

        elf_libraries = ['elf']

        ext_modules = [

                        'elf',

                        elf_srcs,

                        include_dirs = include_dirs,

                        libraries = elf_libraries,

                        extra_compile_args = compile_args,

                        extra_link_args = link_args

                        ),

                ]

        # Solaris has built-in md library and Solaris-specific arch extension

        # All others use OpenSSL and cross-platform arch module

        if osname == 'sunos':

            elf_libraries += [ 'md' ]

            ext_modules += [

                    Extension(

                            'arch', 

                            arch_srcs,

                            include_dirs = include_dirs,

                            extra_compile_args = compile_args,

                            extra_link_args = link_args,

                            define_macros = [('_FILE_OFFSET_BITS', '64')]

                            ),

                    ]

        else:

            elf_libraries += [ 'ssl' ]

setup(cmdclass = cmdclasses,

    name = 'ips',

    version = '1.0',

    package_dir = {'pkg':'modules'},

    packages = packages,

    data_files = data_files,

    ext_package = 'pkg',

    ext_modules = ext_modules,

    )