From e4392e6ae9655883635bb6c885cd1daa64b655a8 Mon Sep 17 00:00:00 2001
From: "Andrew A. de Laix" <alain@lindenlab.com>
Date: Fri, 14 Jan 2011 15:38:30 -0800
Subject: bye bye install.py...
---
scripts/install.py | 1150 ----------------------------------------------------
1 file changed, 1150 deletions(-)
delete mode 100755 scripts/install.py
(limited to 'scripts')
diff --git a/scripts/install.py b/scripts/install.py
deleted file mode 100755
index d3bdf52283..0000000000
--- a/scripts/install.py
+++ /dev/null
@@ -1,1150 +0,0 @@
-#!/usr/bin/env python
-"""\
-@file install.py
-@author Phoenix
-@date 2008-01-27
-@brief Install files into an indra checkout.
-
-Install files as specified by:
-https://wiki.lindenlab.com/wiki/User:Phoenix/Library_Installation
-
-
-$LicenseInfo:firstyear=2007&license=mit$
-
-Copyright (c) 2007-2009, Linden Research, Inc.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-$/LicenseInfo$
-"""
-
-import sys
-import os.path
-
-# Look for indra/lib/python in all possible parent directories ...
-# This is an improvement over the setup-path.py method used previously:
-# * the script may blocated anywhere inside the source tree
-# * it doesn't depend on the current directory
-# * it doesn't depend on another file being present.
-
-def add_indra_lib_path():
- root = os.path.realpath(__file__)
- # always insert the directory of the script in the search path
- dir = os.path.dirname(root)
- if dir not in sys.path:
- sys.path.insert(0, dir)
-
- # Now go look for indra/lib/python in the parent dies
- while root != os.path.sep:
- root = os.path.dirname(root)
- dir = os.path.join(root, 'indra', 'lib', 'python')
- if os.path.isdir(dir):
- if dir not in sys.path:
- sys.path.insert(0, dir)
- return root
- else:
- print >>sys.stderr, "This script is not inside a valid installation."
- sys.exit(1)
-
-base_dir = add_indra_lib_path()
-
-import copy
-import optparse
-import os
-import platform
-import pprint
-import shutil
-import tarfile
-import tempfile
-import urllib2
-import urlparse
-
-try:
- # Python 2.6
- from hashlib import md5
-except ImportError:
- # Python 2.5 and earlier
- from md5 import new as md5
-
-from indra.base import llsd
-from indra.util import helpformatter
-
-class InstallFile(object):
- "This is just a handy way to throw around details on a file in memory."
- def __init__(self, pkgname, url, md5sum, cache_dir, platform_path):
- self.pkgname = pkgname
- self.url = url
- self.md5sum = md5sum
- filename = urlparse.urlparse(url)[2].split('/')[-1]
- self.filename = os.path.join(cache_dir, filename)
- self.platform_path = platform_path
-
- def __str__(self):
- return "ifile{%s:%s}" % (self.pkgname, self.url)
-
- def _is_md5sum_match(self):
- hasher = md5(file(self.filename, 'rb').read())
- if hasher.hexdigest() == self.md5sum:
- return True
- return False
-
- def is_match(self, platform):
- """@brief Test to see if this ifile is part of platform
- @param platform The target platform. Eg, windows or linux/i686/gcc/3.3
- @return Returns True if the ifile is in the platform.
- """
- if self.platform_path[0] == 'common':
- return True
- req_platform_path = platform.split('/')
- #print "platform:",req_platform_path
- #print "path:",self.platform_path
- # to match, every path part much match
- match_count = min(len(req_platform_path), len(self.platform_path))
- for ii in range(0, match_count):
- if req_platform_path[ii] != self.platform_path[ii]:
- return False
- #print "match!"
- return True
-
- def fetch_local(self):
- #print "Looking for:",self.filename
- if not os.path.exists(self.filename):
- pass
- elif self.md5sum and not self._is_md5sum_match():
- print "md5 mismatch:", self.filename
- os.remove(self.filename)
- else:
- print "Found matching package:", self.filename
- return
- print "Downloading",self.url,"to local file",self.filename
- file(self.filename, 'wb').write(urllib2.urlopen(self.url).read())
- if self.md5sum and not self._is_md5sum_match():
- raise RuntimeError("Error matching md5 for %s" % self.url)
-
-class LicenseDefinition(object):
- def __init__(self, definition):
- #probably looks like:
- # { text : ...,
- # url : ...
- # blessed : ...
- # }
- self._definition = definition
-
-
-class InstallableDefinition(object):
- def __init__(self, definition):
- #probably looks like:
- # { packages : {platform...},
- # copyright : ...
- # license : ...
- # description: ...
- # }
- self._definition = definition
-
- def _ifiles_from(self, tree, pkgname, cache_dir):
- return self._ifiles_from_path(tree, pkgname, cache_dir, [])
-
- def _ifiles_from_path(self, tree, pkgname, cache_dir, path):
- ifiles = []
- if 'url' in tree:
- ifiles.append(InstallFile(
- pkgname,
- tree['url'],
- tree.get('md5sum', None),
- cache_dir,
- path))
- else:
- for key in tree:
- platform_path = copy.copy(path)
- platform_path.append(key)
- ifiles.extend(
- self._ifiles_from_path(
- tree[key],
- pkgname,
- cache_dir,
- platform_path))
- return ifiles
-
- def ifiles(self, pkgname, platform, cache_dir):
- """@brief return a list of appropriate InstallFile instances to install
- @param pkgname The name of the package to be installed, eg 'tut'
- @param platform The target platform. Eg, windows or linux/i686/gcc/3.3
- @param cache_dir The directory to cache downloads.
- @return Returns a list of InstallFiles which are part of this install
- """
- if 'packages' not in self._definition:
- return []
- all_ifiles = self._ifiles_from(
- self._definition['packages'],
- pkgname,
- cache_dir)
- if platform == 'all':
- return all_ifiles
- #print "Considering", len(all_ifiles), "packages for", pkgname
- # split into 2 lines because pychecker thinks it might return none.
- files = [ifile for ifile in all_ifiles if ifile.is_match(platform)]
- return files
-
-class InstalledPackage(object):
- def __init__(self, definition):
- # looks like:
- # { url1 : { files: [file1,file2,...], md5sum:... },
- # url2 : { files: [file1,file2,...], md5sum:... },...
- # }
- self._installed = {}
- for url in definition:
- self._installed[url] = definition[url]
-
- def urls(self):
- return self._installed.keys()
-
- def files_in(self, url):
- return self._installed[url].get('files', [])
-
- def get_md5sum(self, url):
- return self._installed[url].get('md5sum', None)
-
- def remove(self, url):
- self._installed.pop(url)
-
- def add_files(self, url, files):
- if url not in self._installed:
- self._installed[url] = {}
- self._installed[url]['files'] = files
-
- def set_md5sum(self, url, md5sum):
- if url not in self._installed:
- self._installed[url] = {}
- self._installed[url]['md5sum'] = md5sum
-
-class Installer(object):
- def __init__(self, install_filename, installed_filename, dryrun):
- self._install_filename = install_filename
- self._install_changed = False
- self._installed_filename = installed_filename
- self._installed_changed = False
- self._dryrun = dryrun
- self._installables = {}
- self._licenses = {}
- self._installed = {}
- self.load()
-
- def load(self):
- if os.path.exists(self._install_filename):
- install = llsd.parse(file(self._install_filename, 'rb').read())
- try:
- for name in install['installables']:
- self._installables[name] = InstallableDefinition(
- install['installables'][name])
- except KeyError:
- pass
- try:
- for name in install['licenses']:
- self._licenses[name] = LicenseDefinition(install['licenses'][name])
- except KeyError:
- pass
- if os.path.exists(self._installed_filename):
- installed = llsd.parse(file(self._installed_filename, 'rb').read())
- try:
- bins = installed['installables']
- for name in bins:
- self._installed[name] = InstalledPackage(bins[name])
- except KeyError:
- pass
-
- def _write(self, filename, state):
- print "Writing state to",filename
- if not self._dryrun:
- file(filename, 'wb').write(llsd.format_pretty_xml(state))
-
- def save(self):
- if self._install_changed:
- state = {}
- state['licenses'] = {}
- for name in self._licenses:
- state['licenses'][name] = self._licenses[name]._definition
- #print "self._installables:",self._installables
- state['installables'] = {}
- for name in self._installables:
- state['installables'][name] = \
- self._installables[name]._definition
- self._write(self._install_filename, state)
- if self._installed_changed:
- state = {}
- state['installables'] = {}
- bin = state['installables']
- for name in self._installed:
- #print "installed:",name,self._installed[name]._installed
- bin[name] = self._installed[name]._installed
- self._write(self._installed_filename, state)
-
- def is_valid_license(self, bin):
- "@brief retrun true if we have valid license info for installable."
- installable = self._installables[bin]._definition
- if 'license' not in installable:
- print >>sys.stderr, "No license info found for", bin
- print >>sys.stderr, 'Please add the license with the',
- print >>sys.stderr, '--add-installable option. See', \
- sys.argv[0], '--help'
- return False
- if installable['license'] not in self._licenses:
- lic = installable['license']
- print >>sys.stderr, "Missing license info for '" + lic + "'.",
- print >>sys.stderr, 'Please add the license with the',
- print >>sys.stderr, '--add-license option. See', sys.argv[0],
- print >>sys.stderr, '--help'
- return False
- return True
-
- def list_installables(self):
- "Return a list of all known installables."
- return sorted(self._installables.keys())
-
- def detail_installable(self, name):
- "Return a installable definition detail"
- return self._installables[name]._definition
-
- def list_licenses(self):
- "Return a list of all known licenses."
- return sorted(self._licenses.keys())
-
- def detail_license(self, name):
- "Return a license definition detail"
- return self._licenses[name]._definition
-
- def list_installed(self):
- "Return a list of installed packages."
- return sorted(self._installed.keys())
-
- def detail_installed(self, name):
- "Return file list for specific installed package."
- filelist = []
- for url in self._installed[name]._installed.keys():
- filelist.extend(self._installed[name].files_in(url))
- return filelist
-
- def _update_field(self, description, field, value, multiline=False):
- """Given a block and a field name, add or update it.
- @param description a dict containing all the details of a description.
- @param field the name of the field to update.
- @param value the value of the field to update; if omitted, interview
- will ask for value.
- @param multiline boolean specifying whether field is multiline or not.
- """
- if value:
- description[field] = value
- else:
- if field in description:
- print "Update value for '" + field + "'"
- print "(Leave blank to keep current value)"
- print "Current Value: '" + description[field] + "'"
- else:
- print "Specify value for '" + field + "'"
- if not multiline:
- new_value = raw_input("Enter New Value: ")
- else:
- print "Please enter " + field + ". End input with EOF (^D)."
- new_value = sys.stdin.read()
-
- if field in description and not new_value:
- pass
- elif new_value:
- description[field] = new_value
-
- self._install_changed = True
- return True
-
- def _update_installable(self, name, platform, url, md5sum):
- """Update installable entry with specific package information.
- @param installable[in,out] a dict containing installable details.
- @param platform Platform info, i.e. linux/i686, windows/i686 etc.
- @param url URL of tar file
- @param md5sum md5sum of tar file
- """
- installable = self._installables[name]._definition
- path = platform.split('/')
- if 'packages' not in installable:
- installable['packages'] = {}
- update = installable['packages']
- for child in path:
- if child not in update:
- update[child] = {}
- parent = update
- update = update[child]
- parent[child]['url'] = llsd.uri(url)
- parent[child]['md5sum'] = md5sum
-
- self._install_changed = True
- return True
-
-
- def add_installable_package(self, name, **kwargs):
- """Add an url for a platform path to the installable.
- @param installable[in,out] a dict containing installable details.
- """
- platform_help_str = """\
-Please enter a new package location and url. Some examples:
-common -- specify a package for all platforms
-linux -- specify a package for all arch and compilers on linux
-darwin/universal -- specify a mac os x universal
-windows/i686/vs/2003 -- specify a windows visual studio 2003 package"""
- if name not in self._installables:
- print "Error: must add library with --add-installable or " \
- +"--add-installable-metadata before using " \
- +"--add-installable-package option"
- return False
- else:
- print "Updating installable '" + name + "'."
- for arg in ('platform', 'url', 'md5sum'):
- if not kwargs[arg]:
- if arg == 'platform':
- print platform_help_str
- kwargs[arg] = raw_input("Package "+arg+":")
- #path = kwargs['platform'].split('/')
-
- return self._update_installable(name, kwargs['platform'],
- kwargs['url'], kwargs['md5sum'])
-
- def add_installable_metadata(self, name, **kwargs):
- """Interactively add (only) library metadata into install,
- w/o adding installable"""
- if name not in self._installables:
- print "Adding installable '" + name + "'."
- self._installables[name] = InstallableDefinition({})
- else:
- print "Updating installable '" + name + "'."
- installable = self._installables[name]._definition
- for field in ('copyright', 'license', 'description'):
- self._update_field(installable, field, kwargs[field])
- print "Added installable '" + name + "':"
- pprint.pprint(self._installables[name])
-
- return True
-
- def add_installable(self, name, **kwargs):
- "Interactively pull a new installable into the install"
- ret_a = self.add_installable_metadata(name, **kwargs)
- ret_b = self.add_installable_package(name, **kwargs)
- return (ret_a and ret_b)
-
- def remove_installable(self, name):
- self._installables.pop(name)
- self._install_changed = True
-
- def add_license(self, name, **kwargs):
- if name not in self._licenses:
- print "Adding license '" + name + "'."
- self._licenses[name] = LicenseDefinition({})
- else:
- print "Updating license '" + name + "'."
- the_license = self._licenses[name]._definition
- for field in ('url', 'text'):
- multiline = False
- if field == 'text':
- multiline = True
- self._update_field(the_license, field, kwargs[field], multiline)
- self._install_changed = True
- return True
-
- def remove_license(self, name):
- self._licenses.pop(name)
- self._install_changed = True
-
- def _uninstall(self, installables):
- """@brief Do the actual removal of files work.
- *NOTE: This method is not transactionally safe -- ie, if it
- raises an exception, internal state may be inconsistent. How
- should we address this?
- @param installables The package names to remove
- """
- remove_file_list = []
- for pkgname in installables:
- for url in self._installed[pkgname].urls():
- remove_file_list.extend(
- self._installed[pkgname].files_in(url))
- self._installed[pkgname].remove(url)
- if not self._dryrun:
- self._installed_changed = True
- if not self._dryrun:
- self._installed.pop(pkgname)
- remove_dir_set = set()
- for filename in remove_file_list:
- print "rm",filename
- if not self._dryrun:
- if os.path.lexists(filename):
- remove_dir_set.add(os.path.dirname(filename))
- try:
- os.remove(filename)
- except OSError:
- # This is just for cleanup, so we don't care
- # about normal failures.
- pass
- for dirname in remove_dir_set:
- try:
- os.removedirs(dirname)
- except OSError:
- # This is just for cleanup, so we don't care about
- # normal failures.
- pass
-
- def uninstall(self, installables, install_dir):
- """@brief Remove the packages specified.
- @param installables The package names to remove
- @param install_dir The directory to work from
- """
- print "uninstall",installables,"from",install_dir
- cwd = os.getcwdu()
- os.chdir(install_dir)
- try:
- self._uninstall(installables)
- finally:
- os.chdir(cwd)
-
- def _build_ifiles(self, platform, cache_dir):
- """@brief determine what files to install
- @param platform The target platform. Eg, windows or linux/i686/gcc/3.3
- @param cache_dir The directory to cache downloads.
- @return Returns the ifiles to install
- """
- ifiles = []
- for bin in self._installables:
- ifiles.extend(self._installables[bin].ifiles(bin,
- platform,
- cache_dir))
- to_install = []
- #print "self._installed",self._installed
- for ifile in ifiles:
- if ifile.pkgname not in self._installed:
- to_install.append(ifile)
- elif ifile.url not in self._installed[ifile.pkgname].urls():
- to_install.append(ifile)
- elif ifile.md5sum != \
- self._installed[ifile.pkgname].get_md5sum(ifile.url):
- # *TODO: We may want to uninstall the old version too
- # when we detect it is installed, but the md5 sum is
- # different.
- to_install.append(ifile)
- else:
- #print "Installation up to date:",
- # ifile.pkgname,ifile.platform_path
- pass
- #print "to_install",to_install
- return to_install
-
- def _install(self, to_install, install_dir):
- for ifile in to_install:
- tar = tarfile.open(ifile.filename, 'r')
- print "Extracting",ifile.filename,"to",install_dir
- if not self._dryrun:
- # *NOTE: try to call extractall, which first appears
- # in python 2.5. Phoenix 2008-01-28
- try:
- tar.extractall(path=install_dir)
- except AttributeError:
- _extractall(tar, path=install_dir)
- if ifile.pkgname in self._installed:
- self._installed[ifile.pkgname].add_files(
- ifile.url,
- tar.getnames())
- self._installed[ifile.pkgname].set_md5sum(
- ifile.url,
- ifile.md5sum)
- else:
- # *HACK: this understands the installed package syntax.
- definition = { ifile.url :
- {'files': tar.getnames(),
- 'md5sum' : ifile.md5sum } }
- self._installed[ifile.pkgname] = InstalledPackage(definition)
- self._installed_changed = True
-
- def install(self, installables, platform, install_dir, cache_dir):
- """@brief Do the installation for for the platform.
- @param installables The requested installables to install.
- @param platform The target platform. Eg, windows or linux/i686/gcc/3.3
- @param install_dir The root directory to install into. Created
- if missing.
- @param cache_dir The directory to cache downloads. Created if
- missing.
- """
- # The ordering of steps in the method is to help reduce the
- # likelihood that we break something.
- install_dir = os.path.realpath(install_dir)
- cache_dir = os.path.realpath(cache_dir)
- _mkdir(install_dir)
- _mkdir(cache_dir)
- to_install = self._build_ifiles(platform, cache_dir)
-
- # Filter for files which we actually requested to install.
- to_install = [ifl for ifl in to_install if ifl.pkgname in installables]
- for ifile in to_install:
- ifile.fetch_local()
- self._install(to_install, install_dir)
-
- def do_install(self, installables, platform, install_dir, cache_dir=None,
- check_license=True, scp=None):
- """Determine what installables should be installed. If they were
- passed in on the command line, use them, otherwise install
- all known installables.
- """
- if not cache_dir:
- cache_dir = _default_installable_cache()
- all_installables = self.list_installables()
- if not len(installables):
- install_installables = all_installables
- else:
- # passed in on the command line. We'll need to verify we
- # know about them here.
- install_installables = installables
- for installable in install_installables:
- if installable not in all_installables:
- raise RuntimeError('Unknown installable: %s' %
- (installable,))
- if check_license:
- # *TODO: check against a list of 'known good' licenses.
- # *TODO: check for urls which conflict -- will lead to
- # problems.
- for installable in install_installables:
- if not self.is_valid_license(installable):
- return 1
-
- # Set up the 'scp' handler
- opener = urllib2.build_opener()
- scp_or_http = SCPOrHTTPHandler(scp)
- opener.add_handler(scp_or_http)
- urllib2.install_opener(opener)
-
- # Do the work of installing the requested installables.
- self.install(
- install_installables,
- platform,
- install_dir,
- cache_dir)
- scp_or_http.cleanup()
-
- def do_uninstall(self, installables, install_dir):
- # Do not bother to check license if we're uninstalling.
- all_installed = self.list_installed()
- if not len(installables):
- uninstall_installables = all_installed
- else:
- # passed in on the command line. We'll need to verify we
- # know about them here.
- uninstall_installables = installables
- for installable in uninstall_installables:
- if installable not in all_installed:
- raise RuntimeError('Installable not installed: %s' %
- (installable,))
- self.uninstall(uninstall_installables, install_dir)
-
-class SCPOrHTTPHandler(urllib2.BaseHandler):
- """Evil hack to allow both the build system and developers consume
- proprietary binaries.
- To use http, export the environment variable:
- INSTALL_USE_HTTP_FOR_SCP=true
- """
- def __init__(self, scp_binary):
- self._scp = scp_binary
- self._dir = None
-
- def scp_open(self, request):
- #scp:codex.lindenlab.com:/local/share/install_pkgs/package.tar.bz2
- remote = request.get_full_url()[4:]
- if os.getenv('INSTALL_USE_HTTP_FOR_SCP', None) == 'true':
- return self.do_http(remote)
- try:
- return self.do_scp(remote)
- except:
- self.cleanup()
- raise
-
- def do_http(self, remote):
- url = remote.split(':',1)
- if not url[1].startswith('/'):
- # in case it's in a homedir or something
- url.insert(1, '/')
- url.insert(0, "http://")
- url = ''.join(url)
- print "Using HTTP:",url
- return urllib2.urlopen(url)
-
- def do_scp(self, remote):
- if not self._dir:
- self._dir = tempfile.mkdtemp()
- local = os.path.join(self._dir, remote.split('/')[-1:][0])
- command = []
- for part in (self._scp, remote, local):
- if ' ' in part:
- # I hate shell escaping.
- part.replace('\\', '\\\\')
- part.replace('"', '\\"')
- command.append('"%s"' % part)
- else:
- command.append(part)
- #print "forking:", command
- rv = os.system(' '.join(command))
- if rv != 0:
- raise RuntimeError("Cannot fetch: %s" % remote)
- return file(local, 'rb')
-
- def cleanup(self):
- if self._dir:
- shutil.rmtree(self._dir)
-
-
-#
-# *NOTE: PULLED FROM PYTHON 2.5 tarfile.py Phoenix 2008-01-28
-#
-def _extractall(tar, path=".", members=None):
- """Extract all members from the archive to the current working
- directory and set owner, modification time and permissions on
- directories afterwards. `path' specifies a different directory
- to extract to. `members' is optional and must be a subset of the
- list returned by getmembers().
- """
- directories = []
-
- if members is None:
- members = tar
-
- for tarinfo in members:
- if tarinfo.isdir():
- # Extract directory with a safe mode, so that
- # all files below can be extracted as well.
- try:
- os.makedirs(os.path.join(path, tarinfo.name), 0777)
- except EnvironmentError:
- pass
- directories.append(tarinfo)
- else:
- tar.extract(tarinfo, path)
-
- # Reverse sort directories.
- directories.sort(lambda a, b: cmp(a.name, b.name))
- directories.reverse()
-
- # Set correct owner, mtime and filemode on directories.
- for tarinfo in directories:
- path = os.path.join(path, tarinfo.name)
- try:
- tar.chown(tarinfo, path)
- tar.utime(tarinfo, path)
- tar.chmod(tarinfo, path)
- except tarfile.ExtractError, e:
- if tar.errorlevel > 1:
- raise
- else:
- tar._dbg(1, "tarfile: %s" % e)
-
-
-def _mkdir(directory):
- "Safe, repeatable way to make a directory."
- if not os.path.exists(directory):
- os.makedirs(directory)
-
-def _get_platform():
- "Return appropriate platform packages for the environment."
- platform_map = {
- 'darwin': 'darwin',
- 'linux2': 'linux',
- 'win32' : 'windows',
- 'cygwin' : 'windows',
- 'solaris' : 'solaris'
- }
- this_platform = platform_map[sys.platform]
- if this_platform == 'linux':
- if platform.architecture()[0] == '64bit':
- # TODO -- someday when install.py accepts a platform of the form
- # os/arch/compiler/compiler_version then we can replace the
- # 'linux64' platform with 'linux/x86_64/gcc/4.1'
- this_platform = 'linux'
- return this_platform
-
-def _getuser():
- "Get the user"
- try:
- # Unix-only.
- import getpass
- return getpass.getuser()
- except ImportError:
- import ctypes
- MAX_PATH = 260 # according to a recent WinDef.h
- name = ctypes.create_unicode_buffer(MAX_PATH)
- namelen = ctypes.c_int(len(name)) # len in chars, NOT bytes
- if not ctypes.windll.advapi32.GetUserNameW(name, ctypes.byref(namelen)):
- raise ctypes.WinError()
- return name.value
-
-def _default_installable_cache():
- """In general, the installable files do not change much, so find a
- host/user specific location to cache files."""
- user = _getuser()
- cache_dir = "/var/tmp/%s/install.cache" % user
- if _get_platform() == 'windows':
- cache_dir = os.path.join(tempfile.gettempdir(), \
- 'install.cache.%s' % user)
- return cache_dir
-
-def parse_args():
- parser = optparse.OptionParser(
- usage="usage: %prog [options] [installable1 [installable2...]]",
- formatter = helpformatter.Formatter(),
- description="""This script fetches and installs installable packages.
-It also handles uninstalling those packages and manages the mapping between
-packages and their license.
-
-The process is to open and read an install manifest file which specifies
-what files should be installed. For each installable to be installed.
- * make sure it has a license
- * check the installed version
- ** if not installed and needs to be, download and install
- ** if installed version differs, download & install
-
-If no installables are specified on the command line, then the defaut
-behavior is to install all known installables appropriate for the platform
-specified or uninstall all installables if --uninstall is set. You can specify
-more than one installable on the command line.
-
-When specifying a platform, you can specify 'all' to install all
-packages, or any platform of the form:
-
-OS[/arch[/compiler[/compiler_version]]]
-
-Where the supported values for each are:
-OS: darwin, linux, windows, solaris
-arch: i686, x86_64, ppc, universal
-compiler: vs, gcc
-compiler_version: 2003, 2005, 2008, 3.3, 3.4, 4.0, etc.
-
-No checks are made to ensure a valid combination of platform
-parts. Some exmples of valid platforms:
-
-windows
-windows/i686/vs/2005
-linux/x86_64/gcc/3.3
-linux/x86_64/gcc/4.0
-darwin/universal/gcc/4.0
-""")
- parser.add_option(
- '--dry-run',
- action='store_true',
- default=False,
- dest='dryrun',
- help='Do not actually install files. Downloads will still happen.')
- parser.add_option(
- '--install-manifest',
- type='string',
- default=os.path.join(base_dir, 'install.xml'),
- dest='install_filename',
- help='The file used to describe what should be installed.')
- parser.add_option(
- '--installed-manifest',
- type='string',
- default=os.path.join(base_dir, 'installed.xml'),
- dest='installed_filename',
- help='The file used to record what is installed.')
- parser.add_option(
- '--export-manifest',
- action='store_true',
- default=False,
- dest='export_manifest',
- help="Print the install manifest to stdout and exit.")
- parser.add_option(
- '-p', '--platform',
- type='string',
- default=_get_platform(),
- dest='platform',
- help="""Override the automatically determined platform. \
-You can specify 'all' to do a installation of installables for all platforms.""")
- parser.add_option(
- '--cache-dir',
- type='string',
- default=_default_installable_cache(),
- dest='cache_dir',
- help='Where to download files. Default: %s'% \
- (_default_installable_cache()))
- parser.add_option(
- '--install-dir',
- type='string',
- default=base_dir,
- dest='install_dir',
- help='Where to unpack the installed files.')
- parser.add_option(
- '--list-installed',
- action='store_true',
- default=False,
- dest='list_installed',
- help="List the installed package names and exit.")
- parser.add_option(
- '--skip-license-check',
- action='store_false',
- default=True,
- dest='check_license',
- help="Do not perform the license check.")
- parser.add_option(
- '--list-licenses',
- action='store_true',
- default=False,
- dest='list_licenses',
- help="List known licenses and exit.")
- parser.add_option(
- '--detail-license',
- type='string',
- default=None,
- dest='detail_license',
- help="Get detailed information on specified license and exit.")
- parser.add_option(
- '--add-license',
- type='string',
- default=None,
- dest='new_license',
- help="""Add a license to the install file. Argument is the name of \
-license. Specify --license-url if the license is remote or specify \
---license-text, otherwse the license text will be read from standard \
-input.""")
- parser.add_option(
- '--license-url',
- type='string',
- default=None,
- dest='license_url',
- help="""Put the specified url into an added license. \
-Ignored if --add-license is not specified.""")
- parser.add_option(
- '--license-text',
- type='string',
- default=None,
- dest='license_text',
- help="""Put the text into an added license. \
-Ignored if --add-license is not specified.""")
- parser.add_option(
- '--remove-license',
- type='string',
- default=None,
- dest='remove_license',
- help="Remove a named license.")
- parser.add_option(
- '--remove-installable',
- type='string',
- default=None,
- dest='remove_installable',
- help="Remove a installable from the install file.")
- parser.add_option(
- '--add-installable',
- type='string',
- default=None,
- dest='add_installable',
- help="""Add a installable into the install file. Argument is \
-the name of the installable to add.""")
- parser.add_option(
- '--add-installable-metadata',
- type='string',
- default=None,
- dest='add_installable_metadata',
- help="""Add package for library into the install file. Argument is \
-the name of the library to add.""")
- parser.add_option(
- '--installable-copyright',
- type='string',
- default=None,
- dest='installable_copyright',
- help="""Copyright for specified new package. Ignored if \
---add-installable is not specified.""")
- parser.add_option(
- '--installable-license',
- type='string',
- default=None,
- dest='installable_license',
- help="""Name of license for specified new package. Ignored if \
---add-installable is not specified.""")
- parser.add_option(
- '--installable-description',
- type='string',
- default=None,
- dest='installable_description',
- help="""Description for specified new package. Ignored if \
---add-installable is not specified.""")
- parser.add_option(
- '--add-installable-package',
- type='string',
- default=None,
- dest='add_installable_package',
- help="""Add package for library into the install file. Argument is \
-the name of the library to add.""")
- parser.add_option(
- '--package-platform',
- type='string',
- default=None,
- dest='package_platform',
- help="""Platform for specified new package. \
-Ignored if --add-installable or --add-installable-package is not specified.""")
- parser.add_option(
- '--package-url',
- type='string',
- default=None,
- dest='package_url',
- help="""URL for specified package. \
-Ignored if --add-installable or --add-installable-package is not specified.""")
- parser.add_option(
- '--package-md5',
- type='string',
- default=None,
- dest='package_md5',
- help="""md5sum for new package. \
-Ignored if --add-installable or --add-installable-package is not specified.""")
- parser.add_option(
- '--list',
- action='store_true',
- default=False,
- dest='list_installables',
- help="List the installables in the install manifest and exit.")
- parser.add_option(
- '--detail',
- type='string',
- default=None,
- dest='detail_installable',
- help="Get detailed information on specified installable and exit.")
- parser.add_option(
- '--detail-installed',
- type='string',
- default=None,
- dest='detail_installed',
- help="Get list of files for specified installed installable and exit.")
- parser.add_option(
- '--uninstall',
- action='store_true',
- default=False,
- dest='uninstall',
- help="""Remove the installables specified in the arguments. Just like \
-during installation, if no installables are listed then all installed \
-installables are removed.""")
- parser.add_option(
- '--scp',
- type='string',
- default='scp',
- dest='scp',
- help="Specify the path to your scp program.")
-
- return parser.parse_args()
-
-def main():
- options, args = parse_args()
- installer = Installer(
- options.install_filename,
- options.installed_filename,
- options.dryrun)
-
- #
- # Handle the queries for information
- #
- if options.list_installed:
- print "installed list:", installer.list_installed()
- return 0
- if options.list_installables:
- print "installable list:", installer.list_installables()
- return 0
- if options.detail_installable:
- try:
- detail = installer.detail_installable(options.detail_installable)
- print "Detail on installable",options.detail_installable+":"
- pprint.pprint(detail)
- except KeyError:
- print "Installable '"+options.detail_installable+"' not found in",
- print "install file."
- return 0
- if options.detail_installed:
- try:
- detail = installer.detail_installed(options.detail_installed)
- #print "Detail on installed",options.detail_installed+":"
- for line in detail:
- print line
- except:
- raise
- print "Installable '"+options.detail_installed+"' not found in ",
- print "install file."
- return 0
- if options.list_licenses:
- print "license list:", installer.list_licenses()
- return 0
- if options.detail_license:
- try:
- detail = installer.detail_license(options.detail_license)
- print "Detail on license",options.detail_license+":"
- pprint.pprint(detail)
- except KeyError:
- print "License '"+options.detail_license+"' not defined in",
- print "install file."
- return 0
- if options.export_manifest:
- # *HACK: just re-parse the install manifest and pretty print
- # it. easier than looking at the datastructure designed for
- # actually determining what to install
- install = llsd.parse(file(options.install_filename, 'rb').read())
- pprint.pprint(install)
- return 0
-
- #
- # Handle updates -- can only do one of these
- # *TODO: should this change the command line syntax?
- #
- if options.new_license:
- if not installer.add_license(
- options.new_license,
- text=options.license_text,
- url=options.license_url):
- return 1
- elif options.remove_license:
- installer.remove_license(options.remove_license)
- elif options.remove_installable:
- installer.remove_installable(options.remove_installable)
- elif options.add_installable:
- if not installer.add_installable(
- options.add_installable,
- copyright=options.installable_copyright,
- license=options.installable_license,
- description=options.installable_description,
- platform=options.package_platform,
- url=options.package_url,
- md5sum=options.package_md5):
- return 1
- elif options.add_installable_metadata:
- if not installer.add_installable_metadata(
- options.add_installable_metadata,
- copyright=options.installable_copyright,
- license=options.installable_license,
- description=options.installable_description):
- return 1
- elif options.add_installable_package:
- if not installer.add_installable_package(
- options.add_installable_package,
- platform=options.package_platform,
- url=options.package_url,
- md5sum=options.package_md5):
- return 1
- elif options.uninstall:
- installer.do_uninstall(args, options.install_dir)
- else:
- installer.do_install(args, options.platform, options.install_dir,
- options.cache_dir, options.check_license,
- options.scp)
-
- # save out any changes
- installer.save()
- return 0
-
-if __name__ == '__main__':
- #print sys.argv
- sys.exit(main())
--
cgit v1.2.3