From e4bb599887258fe5d1dc0bfd27433932ea7e4347 Mon Sep 17 00:00:00 2001 From: Robin Dunn Date: Mon, 8 Nov 2004 23:55:25 +0000 Subject: [PATCH] Revamped automated build system to use a Python script for the master control script, make parallel builds the only way to do it (facilitated by the taskrunner module) split out the guts of build-all into separate scripts, etc. git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@30377 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775 --- wxPython/distrib/all/README.txt | 21 +- wxPython/distrib/all/build-all | 711 ++++------ wxPython/distrib/all/build-docs | 36 + wxPython/distrib/all/build-finalize | 115 ++ wxPython/distrib/all/build-osx | 99 +- wxPython/distrib/all/build-rpm | 94 ++ wxPython/distrib/all/build-setup | 12 + wxPython/distrib/all/build-sources | 18 + wxPython/distrib/all/build-windows | 152 +-- wxPython/distrib/all/do-build-osx | 71 + .../distrib/all/{build-linux => do-build-rpm} | 6 +- wxPython/distrib/all/do-build-windows | 128 ++ wxPython/distrib/all/subprocess.py | 1158 +++++++++++++++++ wxPython/distrib/all/taskrunner.py | 231 ++++ 14 files changed, 2175 insertions(+), 677 deletions(-) create mode 100755 wxPython/distrib/all/build-docs create mode 100755 wxPython/distrib/all/build-finalize create mode 100755 wxPython/distrib/all/build-rpm create mode 100755 wxPython/distrib/all/build-setup create mode 100755 wxPython/distrib/all/build-sources create mode 100755 wxPython/distrib/all/do-build-osx rename wxPython/distrib/all/{build-linux => do-build-rpm} (95%) create mode 100755 wxPython/distrib/all/do-build-windows create mode 100644 wxPython/distrib/all/subprocess.py create mode 100644 wxPython/distrib/all/taskrunner.py diff --git a/wxPython/distrib/all/README.txt b/wxPython/distrib/all/README.txt index 1747624dba..ca45b8e9ae 100644 --- a/wxPython/distrib/all/README.txt +++ b/wxPython/distrib/all/README.txt @@ -1,8 +1,8 @@ The collection of scripts in this directory are an attempt to fully automate the build of the wxPython source and binary packages on all -build platforms. It does this through creative use of shared folders -on network drives, and ssh commands to the remote machines. So this -will likly only work in my somewhat unique environment. +build platforms. It does this through creative use of ssh and scp +commands to the remote build machines, so this will likely only work +in my somewhat unique environment. The goal here is to be able to start a build on one machine and have it take care of all the steps, including moving the source tarball to @@ -12,7 +12,7 @@ may be copied to a public server for others to play with. Types of builds: - dry-run + dryrun Nothing extra is done with the build, this is just for my own testing. @@ -21,14 +21,17 @@ Types of builds: datestamp, and if the build is successful the results are copied to a daily build folder on starship. - release-cantidate + release The results are uploaded to the previews foler on starship if the build is successful. -The master script in this folder is "make-all" which will setup and -control the whole process. The other scripts are what are run on each -build machine, most of which will also call out to other scripts that -already exist, etc. +The master script in this folder is build-all (written in Python) +which will setup and control the whole process. The other scripts +(using bash) are launched from build-all either to do specific tasks +locally, or to run on each individual build machine to manage the +build process there, usually by calling out to other scripts that +already exist. The build-all script uses the taskrunner.py and +subprocess Python modules. diff --git a/wxPython/distrib/all/build-all b/wxPython/distrib/all/build-all index 5c5955bc41..e2c132397f 100755 --- a/wxPython/distrib/all/build-all +++ b/wxPython/distrib/all/build-all @@ -1,501 +1,256 @@ -#!/bin/bash -# --------------------------------------------------------------------------- -# Master build script for building all the installers and such on all the -# build machines in my lab, and then distributing the results as needed. -# --------------------------------------------------------------------------- - -set -o errexit -#set -o xtrace - -# --------------------------------------------------------------------------- -# Some control variables... +#!/usr/bin/python +#---------------------------------------------------------------------- +# Name: build-all.py +# Purpose: Master build script for building all the installers and +# such on all the build machines in my lab, and then +# distributing the results as needed. +# +# This will replace the build-all bash script and is +# needed because the needs of the build have outgrown +# what I can do with bash. +# +# Author: Robin Dunn +# +# Created: 05-Nov-2004 +# RCS-ID: $Id$ +# Copyright: (c) 2004 by Total Control Software +# Licence: wxWindows license +#---------------------------------------------------------------------- + +import sys +import os +import time +from taskrunner import Job, Task, TaskRunner + +#---------------------------------------------------------------------- +# Configuration items + +class Config: + def write(self, filename="config", outfile=None): + if outfile is None: + f = file(filename, "w") + else: + f = outfile + for k, v in self.__dict__.items(): + f.write('%s="%s"\n' % (k, v)) + +config = Config() # the local spot that we put everything when done, before possibly copying # to remote hosts -STAGING_DIR=./BUILD +config.STAGING_DIR = "./BUILD" # host name of the machine to use for windows builds -WIN_HOST=beast +config.WIN_HOST = "beast" # Where is the build dir from the remote machine's perspective? -WIN_BUILD=/c/BUILD +config.WIN_BUILD = "/c/BUILD" # Just like the above -OSX_HOST_panther=bigmac -OSX_HOST_jaguar=whopper -OSX_BUILD=/BUILD +config.OSX_HOST_panther = "bigmac" +config.OSX_HOST_jaguar = "whopper" +config.OSX_BUILD = "/BUILD" # Alsmost the same... See below for hosts and other info -LINUX_BUILD=/tmp/BUILD +config.LINUX_BUILD = "/tmp/BUILD" # Upload server locations -UPLOAD_HOST=starship.python.net -UPLOAD_DAILY_ROOT=/home/crew/robind/public_html/wxPython/daily -UPLOAD_PREVIEW_ROOT=/home/crew/robind/public_html/wxPython/preview - - - -# --------------------------------------------------------------------------- -# functions - -function usage { - echo "" - echo "Usage: $0 [command flags...]" - echo "" - echo "build types:" - echo " dryrun Do the build, but don't copy anywhere (default)" - echo " daily Do a daily build, copy to starship" - echo " release Do a normal release (cantidate) build, copy to starship" - echo "" - echo "optional command flags:" - echo " 2.2 Build for Python 2.2 (default=off)" - echo " 2.3 Build for Python 2.3 (default=on)" - echo " all Build for all supported Python versions" - echo "" - echo " skipsource Don't build the source archives, use the ones" - echo " already in the staging dir." - echo " onlysource Exit after building the source and docs archives" - echo " skipdocs Don't rebuild the docs" - echo " skipwin Don't do the remote Windows build" - echo " skiposx Don't do the remote OSX build" - echo " skiplinux Don't do the remote Linux build" - echo " skipclean Don't do the cleanup step on the remote builds" - echo " skipupload Don't upload the builds to starship" - echo " parallel parallelize the builds where possible" - echo "" -} - - - -function PrefixLines { - label=$1 - tee tmp/$label.log | awk "{ print \"** $label: \" \$0; fflush(); }" -} - -# --------------------------------------------------------------------------- - -# Make sure we are running in the right directory. TODO: make this -# test more robust. Currenly we just test for the presence of -# 'wxPython' and 'wx' subdirs. -if [ ! -d wxPython -o ! -d wx ]; then - echo "Please run this script from the root wxPython directory." - exit 1 -fi - - - -# Set defaults and check the command line options -KIND=dryrun -PYVER=2.3 -skipsource=no -onlysource=no -skipdocs=no -skipwin=no -skiposx=no -skiplinux=no -skipclean=no -skipupload=no -parallel=no - -for flag in $*; do - case $flag in - dryrun) KIND=dryrun ;; - daily) KIND=daily ;; - release) KIND=release ;; - - 2.2) PYVER=2.2 ;; - 2.3) PYVER=2.3 ;; - all) PYVER="2.2 2.3" ;; - - skipsource) skipsource=yes ;; - onlysource) onlysource=yes ;; - skipdocs) skipdocs=yes ;; - skipwin) skipwin=yes ;; - skiposx) skiposx=yes ;; - skiplinux) skiplinux=yes ;; - skipclean) skipclean=yes ;; - skipupload) skipupload=yes ;; - parallel) parallel=yes ;; - noparallel) parallel=no ;; - - help) usage; exit 1 ;; - *) echo "Unknown flag \"$flag\"" - usage - exit 1 - esac -done - - -# ensure the staging area exists -if [ ! -d $STAGING_DIR ]; then - mkdir -p $STAGING_DIR -fi - -# Figure out the wxPython version number, possibly adjusted for being a daily build -if [ $KIND = daily ]; then - DAILY=`date +%Y%m%d` # should it include the hour too? 2-digit year? - echo $DAILY > DAILY_BUILD -fi -VERSION=`python -c "import setup;print setup.VERSION"` - - -#echo VERSION=$VERSION -#exit 0 - - -echo "Getting started at " `date` - -# --------------------------------------------------------------------------- -# Make the sources and other basic stuff. - -if [ $skipsource != yes -o $onlysource = yes ]; then - - # clean out the local dist dir - rm -f dist/* - - if [ $skipdocs != yes ]; then - # Regenerate the reST docs - echo "Regenerating the reST docs..." - cd docs - for x in *.txt; do - docutils-html $x `basename $x .txt`.html - done - cd - - - # build the doc and demo tarballs - distrib/makedemo - distrib/makedocs - - # build the new docs too - docs/bin/everything - fi - - # make the source tarball and srpm - distrib/makerpm 2.3 srpm - - # Copy everything to the staging dir - echo "Moving stuff to $STAGING_DIR..." - mv dist/* $STAGING_DIR - - if [ $skipdocs != yes ]; then - for doc in CHANGES BUILD INSTALL MigrationGuide default; do - cp docs/$doc.* $STAGING_DIR - done - fi - - # cleanup - echo "Cleaning up..." - rm -f dist/* -fi - -if [ $KIND = daily ]; then - rm DAILY_BUILD -fi - -if [ $onlysource = yes ]; then - exit 0 -fi - -# --------------------------------------------------------------------------- -# Windows build - -function DoWindowsBuild { - set -o errexit - - # test if the target machine is online - if ping -q -c1 -w1 $WIN_HOST > /dev/null; then - echo "-----------------------------------------------------------------" - echo " The $WIN_HOST machine is online, Windows build continuing..." - echo "-----------------------------------------------------------------" - else - echo "-----------------------------------------------------------------" - echo "The $WIN_HOST machine is offline, skipping the Windows build." - echo "-----------------------------------------------------------------" - return 0 - fi - echo "-=-=- Starting Windows build..." - - echo "Copying source file and build script..." - scp $STAGING_DIR/wxPython-src-$VERSION.tar.gz \ - distrib/all/build-windows \ - $WIN_HOST:$WIN_BUILD - - echo "Running build script on $WIN_HOST..." - wxdir=$WIN_BUILD/wxPython-src-$VERSION - cmd=./build-windows - ssh $WIN_HOST "cd $WIN_BUILD && $cmd $wxdir $WIN_BUILD $skipclean $VERSION $PYVER && rm $cmd" - - echo "Fetching the results..." - scp "$WIN_HOST:$WIN_BUILD/wxPython*-win32*" $STAGING_DIR - ssh $WIN_HOST "rm $WIN_BUILD/wxPython*-win32*" -} - -if [ $skipwin != yes ]; then - if [ $parallel = no ]; then - DoWindowsBuild - else - DoWindowsBuild 2>&1 | PrefixLines $WIN_HOST & - winPID=$! - fi -fi - - -# --------------------------------------------------------------------------- -# OSX build - -function DoOSXBuild { - local host=$1 - local flavor=$2 - - set -o errexit - - # test if the target machine is online - if ping -q -c1 -w1 $host > /dev/null; then - echo "-----------------------------------------------------------------" - echo " The $host machine is online, OSX-$flavor build continuing..." - echo "-----------------------------------------------------------------" - else - echo "-----------------------------------------------------------------" - echo "The $host machine is offline, skipping the OSX-$flavor build." - echo "-----------------------------------------------------------------" - return 0 - fi - - echo "-=-=- Starting OSX-$flavor build on $host..." - - echo "Copying source files and build script..." - ssh root@$host "mkdir -p $OSX_BUILD && rm -rf $OSX_BUILD/* || true" - #ssh root@$host "mkdir -p $OSX_BUILD || true" - scp $STAGING_DIR/wxPython-src-$VERSION.tar.gz \ - $STAGING_DIR/wxPython-docs-$VERSION.tar.gz \ - $STAGING_DIR/wxPython-demo-$VERSION.tar.gz \ - distrib/all/build-osx \ - root@$host:$OSX_BUILD - - echo "Running build script on $host..." - wxdir=$OSX_BUILD/wxPython-src-$VERSION - cmd=./build-osx - ssh root@$host "cd $OSX_BUILD && $cmd $wxdir $OSX_BUILD $skipclean $VERSION $flavor $PYVER && rm $cmd" - - echo "Fetching the results..." - scp "root@$host:$OSX_BUILD/wxPython*-osx*" $STAGING_DIR - ssh root@$host "rm $OSX_BUILD/wxPython*-osx*" - -} - - -if [ $skiposx != yes ]; then - if [ $parallel = no ]; then - DoOSXBuild $OSX_HOST_jaguar jaguar - DoOSXBuild $OSX_HOST_panther panther - else - DoOSXBuild $OSX_HOST_jaguar jaguar 2>&1 | PrefixLines $OSX_HOST_jaguar & - DoOSXBuild $OSX_HOST_panther panther 2>&1 | PrefixLines $OSX_HOST_panther & - fi -fi - - - -# --------------------------------------------------------------------------- -# Linux build - -# The remote Linux builds are different than those above. The source -# RPMs were already built in the source step, and so building the -# binary RPMs is a very simple followup step. But then add to that -# the fact that we need to build on more than one distro... - - - -function DoLinuxBuild { - local host=$1 - local reltag=$2 - shift;shift - local pyver=$@ - - set -o errexit - - # test if the target machine is online - if ping -q -c1 -w1 $host > /dev/null; then - echo "-----------------------------------------------------------------" - echo " The $host machine is online, build continuing..." - echo "-----------------------------------------------------------------" - else - echo "-----------------------------------------------------------------" - echo "The $host machine is offline, skipping the binary RPM build." - echo "-----------------------------------------------------------------" - return 0 - fi - - echo "Copying source files and build script..." - ssh root@$host "mkdir -p $LINUX_BUILD && rm -rf $LINUX_BUILD/*" - scp $STAGING_DIR/wxPython-src* $STAGING_DIR/wxPython.spec\ - distrib/all/build-linux \ - root@$host:$LINUX_BUILD - - echo "Running build script on $host..." - cmd=./build-linux - ssh root@$host "cd $LINUX_BUILD && ./build-linux $reltag $skipclean $VERSION $pyver" +config.UPLOAD_HOST = "starship.python.net" +config.UPLOAD_DAILY_ROOT = "/home/crew/robind/public_html/wxPython/daily" +config.UPLOAD_PREVIEW_ROOT = "/home/crew/robind/public_html/wxPython/preview" + +# defaults for build options +config.KIND = "dryrun" +config.PYVER = "2.3" +config.skipsource = "no" +config.onlysource = "no" +config.skipdocs = "no" +config.skipwin = "no" +config.skiposx = "no" +config.skiplinux = "no" +config.skipclean = "no" +config.skipupload = "no" +config.skipnewdocs = "no" + + +#---------------------------------------------------------------------- +# Define all the build tasks + +class Job(Job): + LOGBASE = "./tmp" + +CFGFILE = "./tmp/config" + + +# Things that need to be done before any of the builds +initialTask = Task([ Job("", ["distrib/all/build-setup", CFGFILE]), + Job("", ["distrib/all/build-docs", CFGFILE]), + Job("", ["distrib/all/build-sources", CFGFILE]), + ]) + +# Build tasks. Anything that can be done in parallel (depends greatly +# on the nature of the build machine configurations...) is a separate +# task. +windowsTask = Task( Job("beast", ["distrib/all/build-windows", CFGFILE]) ) + +jaguarTask = Task( Job(config.OSX_HOST_jaguar, + ["distrib/all/build-osx", CFGFILE, config.OSX_HOST_jaguar, "jaguar"]) ) + +pantherTask = Task( Job(config.OSX_HOST_panther, + ["distrib/all/build-osx", CFGFILE, config.OSX_HOST_panther, "panther"]) ) + +rpmTask = Task([ Job("co-rh9", ["distrib/all/build-rpm", CFGFILE, "none", "co-rh9", "rh9", config.PYVER]), + Job("co-fc2", ["distrib/all/build-rpm", CFGFILE, "beast", "co-fc2", "fc2", "2.3"]), + Job("co-mdk92", ["distrib/all/build-rpm", CFGFILE, "none", "co-mdk92", "mdk92", "2.3"]), + Job("co-mdk101", ["distrib/all/build-rpm", CFGFILE, "none", "co-mdk101","mdk101","2.3"]), + ]) + +buildTasks = [ windowsTask, + jaguarTask, + pantherTask, + rpmTask, + ] + +# Finalization. This is for things that must wait until all the +# builds are done, such as copying the isntallers someplace, sending +# emails, etc. +finalizationTask = Task( Job("", ["distrib/all/build-finalize", CFGFILE]) ) + + +#---------------------------------------------------------------------- + +def usage(): + print "" + print "Usage: build-all [command flags...]" + print "" + print "build types:" + print " dryrun Do the build, but don't copy anywhere (default)" + print " daily Do a daily build, copy to starship" + print " release Do a normal release (cantidate) build, copy to starship" + print "" + print "optional command flags:" + print " 2.2 Build for Python 2.2 (default=off)" + print " 2.3 Build for Python 2.3 (default=on)" + print " all Build for all supported Python versions" + print "" + print " skipsource Don't build the source archives, use the ones" + print " already in the staging dir." + print " onlysource Exit after building the source and docs archives" + print " skipdocs Don't rebuild the docs" + print " skipwin Don't do the remote Windows build" + print " skiposx Don't do the remote OSX build" + print " skiplinux Don't do the remote Linux build" + print " skipclean Don't do the cleanup step on the remote builds" + print " skipupload Don't upload the builds to starship" + print "" - echo "Fetching the results..." - scp "root@$host:$LINUX_BUILD/wxPython*.i[0-9]86.rpm" $STAGING_DIR - ssh root@$host "rm $LINUX_BUILD/wxPython*.i[0-9]86.rpm" - -} - - - - -if [ $skiplinux != yes ]; then - - if [ $parallel = no ]; then - DoLinuxBuild co-rh9 rh9 $PYVER - DoLinuxBuild co-fc2 fc2 2.3 - DoLinuxBuild co-mdk92 mdk92 2.3 - DoLinuxBuild co-mdk101 mdk101 2.3 - else - - # Since the linux builds are currently done in coLinux - # 'machines' running on the WIN_HOST let's wait for the - # windows build to be done before launching them - - #if [ -n $winPID ]; then - # wait $winPID - #fi - - DoLinuxBuild co-rh9 rh9 $PYVER 2>&1 | PrefixLines co-rh9 & - DoLinuxBuild co-fc2 fc2 2.3 2>&1 | PrefixLines co-fc2 & - - wait $! # wait for the previous two to complete before starting the next two - - DoLinuxBuild co-mdk92 mdk92 2.3 2>&1 | PrefixLines co-mdk92 & - DoLinuxBuild co-mdk101 mdk101 2.3 2>&1 | PrefixLines co-mdk101 & - fi -fi - - -# --------------------------------------------------------------------------- - -if [ $parallel = yes ]; then - - # TODO: Figure out how to test if all the builds were successful - - echo "***********************************" - echo " Waiting for builds to complete... " - echo "***********************************" - wait -fi - -# --------------------------------------------------------------------------- -# Final disposition of build results... - -chmod a+r $STAGING_DIR/* - -if [ $KIND = dryrun ]; then - # we're done - echo "Finished at " `date` - exit 0 -fi - - -if [ $KIND = daily ]; then - echo "Copying to the local file server..." - destdir=/stuff/temp/$VERSION - mkdir -p $destdir - cp $STAGING_DIR/* $destdir +#---------------------------------------------------------------------- + +def main(args): + # Make sure we are running in the right directory. TODO: make + # this test more robust. Currenly we just test for the presence + # of 'wxPython' and 'wx' subdirs. + if not os.path.isdir("wxPython") or not os.path.isdir("wx"): + print "Please run this script from the root wxPython directory." + sys.exit(1) + + # Check command line flags + for flag in args: + if flag in ["dryrun", "daily", "release"]: + config.KIND = flag + + elif flag in ["2.2", "2.3"]: + config.PYVER = flag + elif flag == "all": + config.PYVER = "2.2 2.3" + + elif flag == "skipsource": + config.skipsource = "yes" + + elif flag == "onlysource": + config.onlysource = "yes" + + elif flag == "skipdocs": + config.skipdocs = "yes" + + elif flag == "skipnewdocs": + config.skipnewdocs = "yes" + + elif flag == "skipwin": + config.skipwin = "yes" + + elif flag == "skiposx": + config.skiposx = "yes" + + elif flag == "skiplinux": + config.skiplinux = "yes" + + elif flag == "skipclean": + config.skipclean = "yes" + + elif flag == "skipupload": + config.skipupload = "yes" + + else: + print 'Unknown flag: "%s"' % flag + usage() + sys.exit(2) + + + # ensure the staging area exists + if not os.path.exists(config.STAGING_DIR): + os.makedirs(config.STAGING_DIR) + + # Figure out the wxPython version number, possibly adjusted for being a daily build + if config.KIND == "daily": + t = time.localtime() + config.DAILY = time.strftime("%Y%m%d") # should it include the hour too? 2-digit year? + file("DAILY_BUILD", "w").write(config.DAILY) + sys.path.append('.') + import setup + config.VERSION = setup.VERSION + + # write the config file where the build scripts can find it + config.write(CFGFILE) + print "Build getting started at: ", time.ctime() + + + # Run the first task, which will create the docs and sources tarballs + tr = TaskRunner(initialTask) + rc = tr.run() + + # cleanup the DAILY_BUILD file + if config.KIND == "daily": + os.unlink("DAILY_BUILD") + + # Quit now? + if rc != 0 or config.onlysource == "yes": + sys.exit(rc) + + + # Run the main build tasks + tr = TaskRunner(buildTasks) + rc = tr.run() + if rc != 0: + sys.exit(rc) + + + # when all the builds are done, run the finalization task + tr = TaskRunner(finalizationTask) + rc = tr.run() + if rc != 0: + sys.exit(rc) - if [ $skipupload != yes ]; then - destdir=$UPLOAD_DAILY_ROOT/$DAILY - echo "Copying to the starship at $destdir..." - ssh $UPLOAD_HOST "mkdir -p $destdir" - scp $STAGING_DIR/* $UPLOAD_HOST:/$destdir - ssh $UPLOAD_HOST "cd $destdir && ls -al" - - - # TODO: something to remove old builds from starship, keeping - # only N days worth - - # Send email to wxPython-dev - DATE=`date` - TO=wxPython-dev@lists.wxwidgets.org - - cat < -To: $TO -Subject: $DAILY test build uploaded -Date: $DATE - -Hi, - -A new test build of wxPython has been uploaded to starship. - - Version: $VERSION - URL: http://starship.python.net/crew/robind/wxPython/daily/$DAILY - Changes: http://starship.python.net/crew/robind/wxPython/daily/$DAILY/CHANGES.html - -Have fun! -R'bot - -EOF - fi - - echo "Cleaning up staging dir..." - rm $STAGING_DIR/* - rmdir $STAGING_DIR - - echo "Finished at " `date` - exit 0 -fi - - -if [ $KIND = release ]; then - - echo "Copying to the local file server..." - destdir=/stuff/Development/wxPython/dist/$VERSION - mkdir -p $destdir - cp $STAGING_DIR/* $destdir - - if [ $skipupload != yes ]; then - echo "Copying to the starship..." - destdir=$UPLOAD_PREVIEW_ROOT/$VERSION - ssh $UPLOAD_HOST "mkdir -p $destdir" - scp $STAGING_DIR/* $UPLOAD_HOST:/$destdir - - # Send email to wxPython-dev - DATE=`date` - TO=wxPython-dev@lists.wxwidgets.org - - cat < -To: $TO -Subject: $VERSION release candidate build uploaded -Date: $DATE - -Hi, - -A new RC build of wxPython has been uploaded to starship. - - Version: $VERSION - URL: http://starship.python.net/crew/robind/wxPython/preview/$VERSION - Changes: http://starship.python.net/crew/robind/wxPython/preview/$VERSION/CHANGES.html - -Have fun! -R'bot - -EOF - - fi + + print "Build finished at: ", time.ctime() + sys.exit(0) - echo "Cleaning up staging dir..." - rm $STAGING_DIR/* - rmdir $STAGING_DIR - echo "Finished at " `date` - exit 0 -fi -# --------------------------------------------------------------------------- +if __name__ == "__main__": + main(sys.argv[1:]) diff --git a/wxPython/distrib/all/build-docs b/wxPython/distrib/all/build-docs new file mode 100755 index 0000000000..24b72f3931 --- /dev/null +++ b/wxPython/distrib/all/build-docs @@ -0,0 +1,36 @@ +#!/bin/bash +#---------------------------------------------------------------------- + +set -o errexit + +# read the config variables from the file given on the command line +. $1 + + +if [ $skipdocs != yes ]; then + # Regenerate the reST docs + echo "Regenerating the reST docs..." + cd docs + for x in *.txt; do + docutils-html $x `basename $x .txt`.html + done + cd - + for doc in CHANGES BUILD INSTALL MigrationGuide default; do + cp docs/$doc.* $STAGING_DIR + done + + # build the doc and demo tarballs + distrib/makedemo + distrib/makedocs + mv dist/wxPython-docs-$VERSION.tar.gz $STAGING_DIR + mv dist/wxPython-demo-$VERSION.tar.gz $STAGING_DIR + + + # build the new docs too + if [ $skipnewdocs != yes ]; then + docs/bin/everything + mv dist/wxPython-newdocs-$VERSION.tar.gz $STAGING_DIR + fi +fi + +#---------------------------------------------------------------------- diff --git a/wxPython/distrib/all/build-finalize b/wxPython/distrib/all/build-finalize new file mode 100755 index 0000000000..63eceea5fb --- /dev/null +++ b/wxPython/distrib/all/build-finalize @@ -0,0 +1,115 @@ +#!/bin/bash +#---------------------------------------------------------------------- + +set -o errexit + +# read the config variables from the file given on the command line +. $1 + + + + +chmod a+r $STAGING_DIR/* + +if [ $KIND = dryrun ]; then + # we're done leave the files in the staging dir and quit + echo "Not uploading dryrun." + exit 0 +fi + + +if [ $KIND = daily ]; then + + echo "Copying to the local file server..." + destdir=/stuff/temp/$VERSION + mkdir -p $destdir + cp $STAGING_DIR/* $destdir + + if [ $skipupload != yes ]; then + destdir=$UPLOAD_DAILY_ROOT/$DAILY + echo "Copying to the starship at $destdir..." + ssh $UPLOAD_HOST "mkdir -p $destdir" + scp $STAGING_DIR/* $UPLOAD_HOST:/$destdir + ssh $UPLOAD_HOST "cd $destdir && ls -al" + + + # TODO: something to remove old builds from starship, keeping + # only N days worth + + # Send email to wxPython-dev + DATE=`date` + TO=wxPython-dev@lists.wxwidgets.org + + cat < +To: $TO +Subject: $DAILY test build uploaded +Date: $DATE + +Hi, + +A new test build of wxPython has been uploaded to starship. + + Version: $VERSION + URL: http://starship.python.net/crew/robind/wxPython/daily/$DAILY + Changes: http://starship.python.net/crew/robind/wxPython/daily/$DAILY/CHANGES.html + +Have fun! +R'bot + +EOF + fi + + echo "Cleaning up staging dir..." + rm $STAGING_DIR/* + rmdir $STAGING_DIR + + exit 0 +fi + + +if [ $KIND = release ]; then + + echo "Copying to the local file server..." + destdir=/stuff/Development/wxPython/dist/$VERSION + mkdir -p $destdir + cp $STAGING_DIR/* $destdir + + if [ $skipupload != yes ]; then + echo "Copying to the starship..." + destdir=$UPLOAD_PREVIEW_ROOT/$VERSION + ssh $UPLOAD_HOST "mkdir -p $destdir" + scp $STAGING_DIR/* $UPLOAD_HOST:/$destdir + + # Send email to wxPython-dev + DATE=`date` + TO=wxPython-dev@lists.wxwidgets.org + + cat < +To: $TO +Subject: $VERSION release candidate build uploaded +Date: $DATE + +Hi, + +A new RC build of wxPython has been uploaded to starship. + + Version: $VERSION + URL: http://starship.python.net/crew/robind/wxPython/preview/$VERSION + Changes: http://starship.python.net/crew/robind/wxPython/preview/$VERSION/CHANGES.html + +Have fun! +R'bot + +EOF + + fi + + echo "Cleaning up staging dir..." + rm $STAGING_DIR/* + rmdir $STAGING_DIR + + exit 0 +fi + diff --git a/wxPython/distrib/all/build-osx b/wxPython/distrib/all/build-osx index 02e7938e2a..3bbb287c26 100755 --- a/wxPython/distrib/all/build-osx +++ b/wxPython/distrib/all/build-osx @@ -1,71 +1,40 @@ #!/bin/bash -# --------------------------------------------------------------------------- -# Build wxWidgets and wxPython on a OSX box. This is normally -# called from build-all but it should be able to be used standalone too... -# -# The command line must have the following parameters: -# -# 1. the path to the base of the wx source tree -# 2. the path of where to put the resulting installers -# 3. skipclean flag (yes|no) -# 4. the VERSION -# 5. the KIND (panther or jaguar) -# *. the remaining args are the versions of Python to build for -# -# --------------------------------------------------------------------------- +#---------------------------------------------------------------------- set -o errexit -#set -o xtrace -echo "-=-=-=- Hello from $HOSTNAME -=-=-=-" - -if [ $# -lt 6 ]; then - echo "Usage: $0 WXDIR DESTDIR SKIPCLEAN VERSION KIND PYVER..." - exit 1 -fi - -WXDIR=$1 -DESTDIR=$2 -SKIPCLEAN=$3 -VERSION=$4 -KIND=$5 -shift;shift;shift;shift;shift -PYVER=$@ - - -#export PATH=/sw/bin:/usr/local/bin:$PATH -export PATH=/sw/bin:/sw/sbin:/usr/local/bin:/bin:/sbin:/usr/bin:/usr/sbin:.:/usr/X11R6/bin -echo "PATH =" $PATH -echo "which gcc = " `which gcc` -#exit 0 - -# untar the source -echo "Unarchiving wxPython-src-$VERSION.tar.gz" -cd $DESTDIR -tar xzf wxPython-src-$VERSION.tar.gz -rm wxPython-src-$VERSION.tar.gz - - -echo "Invoking wxPythonOSX build script..." -cd $WXDIR/wxPython -export TARBALLDIR=$DESTDIR -mkdir -p dist -if [ $KIND = panther ]; then - distrib/mac/wxPythonOSX/build $KIND inplace unicode -fi -distrib/mac/wxPythonOSX/build $KIND inplace - - -echo "Copying installers to $DESTDIR..." -cp dist/*.dmg $DESTDIR -cd $DESTDIR - - -if [ $SKIPCLEAN != yes ]; then - echo "Cleaning up..." - rm -r $WXDIR || true - rm wxPython-docs-$VERSION.tar.gz - rm wxPython-demo-$VERSION.tar.gz +# read the config variables from the file given on the command line +. $1 + + +host=$2 +flavor=$3 + +if [ $skiposx != yes ]; then + # test if the target machine is online + if ping -q -c1 -w1 $host > /dev/null; then + echo " The $host machine is online, OSX-$flavor build continuing..." + else + echo "The $host machine is **OFFLINE**, skipping the OSX-$flavor build." + exit 0 + fi + + echo "Copying source files and build script..." + ssh root@$host "mkdir -p $OSX_BUILD && rm -rf $OSX_BUILD/* || true" + + scp $STAGING_DIR/wxPython-src-$VERSION.tar.gz \ + $STAGING_DIR/wxPython-docs-$VERSION.tar.gz \ + $STAGING_DIR/wxPython-demo-$VERSION.tar.gz \ + distrib/all/do-build-osx \ + root@$host:$OSX_BUILD + + echo "Running build script on $host..." + wxdir=$OSX_BUILD/wxPython-src-$VERSION + cmd=./do-build-osx + ssh root@$host "cd $OSX_BUILD && $cmd $wxdir $OSX_BUILD $skipclean $VERSION $flavor $PYVER && rm $cmd" + + echo "Fetching the results..." + scp "root@$host:$OSX_BUILD/wxPython*-osx*" $STAGING_DIR + ssh root@$host "rm $OSX_BUILD/wxPython*-osx*" fi -echo "-=-=-=- Goodbye! -=-=-=-" diff --git a/wxPython/distrib/all/build-rpm b/wxPython/distrib/all/build-rpm new file mode 100755 index 0000000000..89b13e1e87 --- /dev/null +++ b/wxPython/distrib/all/build-rpm @@ -0,0 +1,94 @@ +#!/bin/bash +#---------------------------------------------------------------------- + +set -o errexit + +# read the config variables from the file given on the command line +. $1 + +coHost=$2 +host=$3 +reltag=$4 +shift;shift;shift;shift +pyver=$@ + + +function TestOnline { + local host=$1 + local message=$2 + + if ping -q -c1 -w1 $host > /dev/null; then + return 0 + else + return 1 + fi +} + + +if [ $skiplinux != yes ]; then + + startedCoHost=no + hostAvailable=no + + # test if the target machine is online + if TestOnline $host; then + hostAvailable=yes + else + # Attempt to start the host via it's coLinux host, if there is one + if [ $coHost != none ]; then + if TestOnline $coHost; then + echo "Attempting to start $host via coLinux on $coHost..." + ssh $coHost "/c/coLinux/VMs/$host.bat -d > /dev/null 2>&1 &" + + # Give it time to boot and be ready for conenctions, + # and then test with ssh, limiting retries. + for x in `seq 12`; do + sleep 5 + echo "checking..." + if ssh root@$host "true" >/dev/null 2>&1; then + # success! the host is ready so we can break out of the loop + break; + fi + done + + # test if the host is ready + if TestOnline $host; then + echo "coLinux start of $host on $coHost successful." + startedCoHost=yes + hostAvailable=yes + fi + else + echo "The $coHost machine is offline, unable to start coLinux for $host" + fi + fi + fi + + if [ $hostAvailable = yes ]; then + echo "The $host machine is online, build continuing..." + else + echo "The $host machine is **OFFLINE**, skipping the binary RPM build." + exit 0 + fi + + + echo "Copying source files and build script..." + ssh root@$host "mkdir -p $LINUX_BUILD && rm -rf $LINUX_BUILD/*" + scp $STAGING_DIR/wxPython-src* $STAGING_DIR/wxPython.spec\ + distrib/all/do-build-rpm \ + root@$host:$LINUX_BUILD + + echo "Running build script on $host..." + cmd=./do-build-rpm + ssh root@$host "cd $LINUX_BUILD && $cmd $reltag $skipclean $VERSION $pyver" + + echo "Fetching the results..." + scp "root@$host:$LINUX_BUILD/wxPython*.i[0-9]86.rpm" $STAGING_DIR + ssh root@$host "rm $LINUX_BUILD/wxPython*.i[0-9]86.rpm" + + + if [ $startedCoHost = yes ]; then + echo "Halting $host on $coHost..." + ssh root@$host "/sbin/halt" + sleep 10 + fi +fi diff --git a/wxPython/distrib/all/build-setup b/wxPython/distrib/all/build-setup new file mode 100755 index 0000000000..f8134cd151 --- /dev/null +++ b/wxPython/distrib/all/build-setup @@ -0,0 +1,12 @@ +#!/bin/bash +#---------------------------------------------------------------------- + +set -o errexit + +# read the config variables from the file given on the command line +. $1 + + +# clean out the local dist dir +rm -f dist/* + diff --git a/wxPython/distrib/all/build-sources b/wxPython/distrib/all/build-sources new file mode 100755 index 0000000000..22faacff51 --- /dev/null +++ b/wxPython/distrib/all/build-sources @@ -0,0 +1,18 @@ +#!/bin/bash +#---------------------------------------------------------------------- + +set -o errexit + +# read the config variables from the file given on the command line +. $1 + +if [ $skipsource != yes -o $onlysource = yes ]; then + + # make the source tarball and srpm + distrib/makerpm 2.3 srpm + + # Copy everything to the staging dir + echo "Moving stuff to $STAGING_DIR..." + mv dist/* $STAGING_DIR + +fi diff --git a/wxPython/distrib/all/build-windows b/wxPython/distrib/all/build-windows index cd40bdb2bf..d8b70d2db4 100755 --- a/wxPython/distrib/all/build-windows +++ b/wxPython/distrib/all/build-windows @@ -1,128 +1,32 @@ #!/bin/bash -# --------------------------------------------------------------------------- -# Build wxWidgets and wxPython on a Windows box. This is normally called -# from build-all but it should be able to be used standalone too... -# -# The command line must have the following parameters: -# -# 1. the path to the base of the wx source tree -# 2. the path of where to put the resulting installers -# 3. skipclean flag (yes|no) -# 4. the VERSION -# 5. the remaining args are the versions of Python to build for -# -# --------------------------------------------------------------------------- +#---------------------------------------------------------------------- set -o errexit -#set -o xtrace -echo "-=-=-=- Hello from $HOSTNAME -=-=-=-" - -if [ $# -lt 5 ]; then - echo "Usage: $0 WXDIR DESTDIR SKIPCLEAN VERSION PYVER..." - exit 1 -fi - -WXDIR=$1 -DESTDIR=$2 -SKIPCLEAN=$3 -VERSION=$4 -shift;shift;shift;shift -PYVER=$@ - - -# WXDIR is the cygwin path, WXWIN is the DOS path -WXWIN_OLD=$WXWIN -WXWIN=`cygpath -w $WXDIR` -export WXWIN - - -# # Fix the PATH. (Why is this needed??) -# PATH=/usr/local/bin:/usr/bin:/bin:/usr/X11R6/bin:/home/robind/bin:.:$WXDIR/lib/vc_dll:$PATH -# export PATH -# echo "-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=" -# echo $PATH -# echo "-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=" -# exit 0 - - -# untar the source -echo "Unarchiving wxPython-src-$VERSION.tar.gz" -cd $DESTDIR -tar xzf wxPython-src-$VERSION.tar.gz -rm wxPython-src-$VERSION.tar.gz - - -# Fix line endings -echo "Converting wxPython line endings to CRLF..." -cd $WXDIR -names=`find wxPython -name "*.py" -o -name "*.txt" -o -name "*.htm*" -o -name "*.css" -o -name "*.xml" ` -unix2dos -D $names - - -# change to the right spot in the source tree and copy our build scripts -echo "Setting up for the build..." -cd $WXDIR/build/msw -cp $WXDIR/wxPython/distrib/msw/.m* . - - -# replace some settings in setup0.h and write to setup.h -cat > .my.sedexpr < $WXDIR/include/wx/msw/setup.h -rm .my.sedexpr - - -echo "Building the wx DLLs..." -.make hybrid -.make hybrid-uni - - -#echo "Building the wx tools..." -#.make_tools - -# cheat and just copy the .CHM files from the regular project dir -# TODO: Copy over the wxPython-docs fle and run hhc on the contents of that. -mkdir -p $WXDIR/docs/htmlhelp -cp `cygpath $WXWIN_OLD/docs/htmlhelp`/*.chm $WXDIR/docs/htmlhelp - - -echo "Building wxPython and installers..." -cd $WXDIR/wxPython -mkdir -p dist - -for ver in $PYVER; do - echo $ver - b $ver d USE_SWIG=0 - b $ver h USE_SWIG=0 EP_ADD_OPTS=1 - b $ver r USE_SWIG=0 - b $ver d UNICODE=1 USE_SWIG=0 - b $ver h UNICODE=1 USE_SWIG=0 EP_ADD_OPTS=1 - b $ver r UNICODE=1 USE_SWIG=0 -done - -echo "Building the developer package..." -WXWIN=`cygpath -w $WXDIR` -export WXWIN -4nt /c distrib/makedev.bat $VERSION - - -echo "Copying installers to $DESTDIR..." -mv dist/wxPython* $DESTDIR -cd $DESTDIR - - -if [ $SKIPCLEAN != yes ]; then - echo "Cleaning up..." - rm -r $WXDIR || true -fi - -echo "-=-=-=- Goodbye! -=-=-=-" +# read the config variables from the file given on the command line +. $1 + + +if [ $skipwin != yes ]; then + # test if the target machine is online + if ping -q -c1 -w1 $WIN_HOST > /dev/null; then + echo " The $WIN_HOST machine is online, Windows build continuing..." + else + echo "The $WIN_HOST machine is **OFFLINE**, skipping the Windows build." + return 0 + fi + + echo "Copying source file and build script..." + scp $STAGING_DIR/wxPython-src-$VERSION.tar.gz \ + distrib/all/do-build-windows \ + $WIN_HOST:$WIN_BUILD + + echo "Running build script on $WIN_HOST..." + wxdir=$WIN_BUILD/wxPython-src-$VERSION + cmd=./do-build-windows + ssh $WIN_HOST "cd $WIN_BUILD && $cmd $wxdir $WIN_BUILD $skipclean $VERSION $PYVER && rm $cmd" + + echo "Fetching the results..." + scp "$WIN_HOST:$WIN_BUILD/wxPython*-win32*" $STAGING_DIR + ssh $WIN_HOST "rm $WIN_BUILD/wxPython*-win32*" +fi \ No newline at end of file diff --git a/wxPython/distrib/all/do-build-osx b/wxPython/distrib/all/do-build-osx new file mode 100755 index 0000000000..02e7938e2a --- /dev/null +++ b/wxPython/distrib/all/do-build-osx @@ -0,0 +1,71 @@ +#!/bin/bash +# --------------------------------------------------------------------------- +# Build wxWidgets and wxPython on a OSX box. This is normally +# called from build-all but it should be able to be used standalone too... +# +# The command line must have the following parameters: +# +# 1. the path to the base of the wx source tree +# 2. the path of where to put the resulting installers +# 3. skipclean flag (yes|no) +# 4. the VERSION +# 5. the KIND (panther or jaguar) +# *. the remaining args are the versions of Python to build for +# +# --------------------------------------------------------------------------- + +set -o errexit +#set -o xtrace + +echo "-=-=-=- Hello from $HOSTNAME -=-=-=-" + +if [ $# -lt 6 ]; then + echo "Usage: $0 WXDIR DESTDIR SKIPCLEAN VERSION KIND PYVER..." + exit 1 +fi + +WXDIR=$1 +DESTDIR=$2 +SKIPCLEAN=$3 +VERSION=$4 +KIND=$5 +shift;shift;shift;shift;shift +PYVER=$@ + + +#export PATH=/sw/bin:/usr/local/bin:$PATH +export PATH=/sw/bin:/sw/sbin:/usr/local/bin:/bin:/sbin:/usr/bin:/usr/sbin:.:/usr/X11R6/bin +echo "PATH =" $PATH +echo "which gcc = " `which gcc` +#exit 0 + +# untar the source +echo "Unarchiving wxPython-src-$VERSION.tar.gz" +cd $DESTDIR +tar xzf wxPython-src-$VERSION.tar.gz +rm wxPython-src-$VERSION.tar.gz + + +echo "Invoking wxPythonOSX build script..." +cd $WXDIR/wxPython +export TARBALLDIR=$DESTDIR +mkdir -p dist +if [ $KIND = panther ]; then + distrib/mac/wxPythonOSX/build $KIND inplace unicode +fi +distrib/mac/wxPythonOSX/build $KIND inplace + + +echo "Copying installers to $DESTDIR..." +cp dist/*.dmg $DESTDIR +cd $DESTDIR + + +if [ $SKIPCLEAN != yes ]; then + echo "Cleaning up..." + rm -r $WXDIR || true + rm wxPython-docs-$VERSION.tar.gz + rm wxPython-demo-$VERSION.tar.gz +fi + +echo "-=-=-=- Goodbye! -=-=-=-" diff --git a/wxPython/distrib/all/build-linux b/wxPython/distrib/all/do-build-rpm similarity index 95% rename from wxPython/distrib/all/build-linux rename to wxPython/distrib/all/do-build-rpm index 0a2e6b882e..910f09a6ca 100755 --- a/wxPython/distrib/all/build-linux +++ b/wxPython/distrib/all/do-build-rpm @@ -42,7 +42,11 @@ function DoRPMBuild { # $1 : python version # $2 : port # $3 : unicode - + + echo "-=-=-=-=-=-=-=-=-=-=-" + echo $1 $2 $3 + echo "-=-=-=-=-=-=-=-=-=-=-" + $RPMBUILD --define "_topdir $PWD/$rpmtop" \ --define "_tmppath $PWD/$rpmtop/tmp" \ --define "release ${RELEASE}_py$1" \ diff --git a/wxPython/distrib/all/do-build-windows b/wxPython/distrib/all/do-build-windows new file mode 100755 index 0000000000..cd40bdb2bf --- /dev/null +++ b/wxPython/distrib/all/do-build-windows @@ -0,0 +1,128 @@ +#!/bin/bash +# --------------------------------------------------------------------------- +# Build wxWidgets and wxPython on a Windows box. This is normally called +# from build-all but it should be able to be used standalone too... +# +# The command line must have the following parameters: +# +# 1. the path to the base of the wx source tree +# 2. the path of where to put the resulting installers +# 3. skipclean flag (yes|no) +# 4. the VERSION +# 5. the remaining args are the versions of Python to build for +# +# --------------------------------------------------------------------------- + +set -o errexit +#set -o xtrace + +echo "-=-=-=- Hello from $HOSTNAME -=-=-=-" + +if [ $# -lt 5 ]; then + echo "Usage: $0 WXDIR DESTDIR SKIPCLEAN VERSION PYVER..." + exit 1 +fi + +WXDIR=$1 +DESTDIR=$2 +SKIPCLEAN=$3 +VERSION=$4 +shift;shift;shift;shift +PYVER=$@ + + +# WXDIR is the cygwin path, WXWIN is the DOS path +WXWIN_OLD=$WXWIN +WXWIN=`cygpath -w $WXDIR` +export WXWIN + + +# # Fix the PATH. (Why is this needed??) +# PATH=/usr/local/bin:/usr/bin:/bin:/usr/X11R6/bin:/home/robind/bin:.:$WXDIR/lib/vc_dll:$PATH +# export PATH +# echo "-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=" +# echo $PATH +# echo "-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=" +# exit 0 + + +# untar the source +echo "Unarchiving wxPython-src-$VERSION.tar.gz" +cd $DESTDIR +tar xzf wxPython-src-$VERSION.tar.gz +rm wxPython-src-$VERSION.tar.gz + + +# Fix line endings +echo "Converting wxPython line endings to CRLF..." +cd $WXDIR +names=`find wxPython -name "*.py" -o -name "*.txt" -o -name "*.htm*" -o -name "*.css" -o -name "*.xml" ` +unix2dos -D $names + + +# change to the right spot in the source tree and copy our build scripts +echo "Setting up for the build..." +cd $WXDIR/build/msw +cp $WXDIR/wxPython/distrib/msw/.m* . + + +# replace some settings in setup0.h and write to setup.h +cat > .my.sedexpr < $WXDIR/include/wx/msw/setup.h +rm .my.sedexpr + + +echo "Building the wx DLLs..." +.make hybrid +.make hybrid-uni + + +#echo "Building the wx tools..." +#.make_tools + +# cheat and just copy the .CHM files from the regular project dir +# TODO: Copy over the wxPython-docs fle and run hhc on the contents of that. +mkdir -p $WXDIR/docs/htmlhelp +cp `cygpath $WXWIN_OLD/docs/htmlhelp`/*.chm $WXDIR/docs/htmlhelp + + +echo "Building wxPython and installers..." +cd $WXDIR/wxPython +mkdir -p dist + +for ver in $PYVER; do + echo $ver + b $ver d USE_SWIG=0 + b $ver h USE_SWIG=0 EP_ADD_OPTS=1 + b $ver r USE_SWIG=0 + b $ver d UNICODE=1 USE_SWIG=0 + b $ver h UNICODE=1 USE_SWIG=0 EP_ADD_OPTS=1 + b $ver r UNICODE=1 USE_SWIG=0 +done + +echo "Building the developer package..." +WXWIN=`cygpath -w $WXDIR` +export WXWIN +4nt /c distrib/makedev.bat $VERSION + + +echo "Copying installers to $DESTDIR..." +mv dist/wxPython* $DESTDIR +cd $DESTDIR + + +if [ $SKIPCLEAN != yes ]; then + echo "Cleaning up..." + rm -r $WXDIR || true +fi + +echo "-=-=-=- Goodbye! -=-=-=-" diff --git a/wxPython/distrib/all/subprocess.py b/wxPython/distrib/all/subprocess.py new file mode 100644 index 0000000000..3a3020d2ce --- /dev/null +++ b/wxPython/distrib/all/subprocess.py @@ -0,0 +1,1158 @@ +# subprocess - Subprocesses with accessible I/O streams +# +# For more information about this module, see PEP 324. +# +# Copyright (c) 2003-2004 by Peter Astrand +# +# By obtaining, using, and/or copying this software and/or its +# associated documentation, you agree that you have read, understood, +# and will comply with the following terms and conditions: +# +# Permission to use, copy, modify, and distribute this software and +# its associated documentation for any purpose and without fee is +# hereby granted, provided that the above copyright notice appears in +# all copies, and that both that copyright notice and this permission +# notice appear in supporting documentation, and that the name of the +# author not be used in advertising or publicity pertaining to +# distribution of the software without specific, written prior +# permission. +# +# THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, +# INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. +# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, INDIRECT OR +# CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS +# OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, +# NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION +# WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + +"""subprocess - Subprocesses with accessible I/O streams + +This module allows you to spawn processes and connect to their +input/output/error pipes and obtain their return codes under Unix. +This module intends to replace several other, older modules and +functions, like: + +os.system +os.spawn* +os.popen* +popen2.* +commands.* + +Information about how the subprocess module can be used to replace these +modules and functions can be found below. + + + +Using the subprocess module +=========================== +This module defines one class called Popen: + +class Popen(args, bufsize=0, executable=None, + stdin=None, stdout=None, stderr=None, + preexec_fn=None, close_fds=False, shell=False, + cwd=None, env=None, universal_newlines=False, + startupinfo=None, creationflags=0): + + +Arguments are: + +args should be a string, or a sequence of program arguments. The +program to execute is normally the first item in the args sequence or +string, but can be explicitly set by using the executable argument. + +On UNIX, with shell=False (default): In this case, the Popen class +uses os.execvp() to execute the child program. args should normally +be a sequence. A string will be treated as a sequence with the string +as the only item (the program to execute). + +On UNIX, with shell=True: If args is a string, it specifies the +command string to execute through the shell. If args is a sequence, +the first item specifies the command string, and any additional items +will be treated as additional shell arguments. + +On Windows: the Popen class uses CreateProcess() to execute the child +program, which operates on strings. If args is a sequence, it will be +converted to a string using the list2cmdline method. Please note that +not all MS Windows applications interpret the command line the same +way: The list2cmdline is designed for applications using the same +rules as the MS C runtime. + +bufsize, if given, has the same meaning as the corresponding argument +to the built-in open() function: 0 means unbuffered, 1 means line +buffered, any other positive value means use a buffer of +(approximately) that size. A negative bufsize means to use the system +default, which usually means fully buffered. The default value for +bufsize is 0 (unbuffered). + +stdin, stdout and stderr specify the executed programs' standard +input, standard output and standard error file handles, respectively. +Valid values are PIPE, an existing file descriptor (a positive +integer), an existing file object, and None. PIPE indicates that a +new pipe to the child should be created. With None, no redirection +will occur; the child's file handles will be inherited from the +parent. Additionally, stderr can be STDOUT, which indicates that the +stderr data from the applications should be captured into the same +file handle as for stdout. + +If preexec_fn is set to a callable object, this object will be called +in the child process just before the child is executed. + +If close_fds is true, all file descriptors except 0, 1 and 2 will be +closed before the child process is executed. + +if shell is true, the specified command will be executed through the +shell. + +If cwd is not None, the current directory will be changed to cwd +before the child is executed. + +If env is not None, it defines the environment variables for the new +process. + +If universal_newlines is true, the file objects stdout and stderr are +opened as a text files, but lines may be terminated by any of '\n', +the Unix end-of-line convention, '\r', the Macintosh convention or +'\r\n', the Windows convention. All of these external representations +are seen as '\n' by the Python program. Note: This feature is only +available if Python is built with universal newline support (the +default). Also, the newlines attribute of the file objects stdout, +stdin and stderr are not updated by the communicate() method. + +The startupinfo and creationflags, if given, will be passed to the +underlying CreateProcess() function. They can specify things such as +appearance of the main window and priority for the new process. +(Windows only) + + +This module also defines two shortcut functions: + +call(*args, **kwargs): + Run command with arguments. Wait for command to complete, then + return the returncode attribute. + + The arguments are the same as for the Popen constructor. Example: + + retcode = call(["ls", "-l"]) + + +Exceptions +---------- +Exceptions raised in the child process, before the new program has +started to execute, will be re-raised in the parent. Additionally, +the exception object will have one extra attribute called +'child_traceback', which is a string containing traceback information +from the childs point of view. + +The most common exception raised is OSError. This occurs, for +example, when trying to execute a non-existent file. Applications +should prepare for OSErrors. + +A ValueError will be raised if Popen is called with invalid arguments. + + +Security +-------- +Unlike some other popen functions, this implementation will never call +/bin/sh implicitly. This means that all characters, including shell +metacharacters, can safely be passed to child processes. + + +Popen objects +============= +Instances of the Popen class have the following methods: + +poll() + Check if child process has terminated. Returns returncode + attribute. + +wait() + Wait for child process to terminate. Returns returncode attribute. + +communicate(input=None) + Interact with process: Send data to stdin. Read data from stdout + and stderr, until end-of-file is reached. Wait for process to + terminate. The optional stdin argument should be a string to be + sent to the child process, or None, if no data should be sent to + the child. + + communicate() returns a tuple (stdout, stderr). + + Note: The data read is buffered in memory, so do not use this + method if the data size is large or unlimited. + +The following attributes are also available: + +stdin + If the stdin argument is PIPE, this attribute is a file object + that provides input to the child process. Otherwise, it is None. + +stdout + If the stdout argument is PIPE, this attribute is a file object + that provides output from the child process. Otherwise, it is + None. + +stderr + If the stderr argument is PIPE, this attribute is file object that + provides error output from the child process. Otherwise, it is + None. + +pid + The process ID of the child process. + +returncode + The child return code. A None value indicates that the process + hasn't terminated yet. A negative value -N indicates that the + child was terminated by signal N (UNIX only). + + +Replacing older functions with the subprocess module +==================================================== +In this section, "a ==> b" means that b can be used as a replacement +for a. + +Note: All functions in this section fail (more or less) silently if +the executed program cannot be found; this module raises an OSError +exception. + +In the following examples, we assume that the subprocess module is +imported with "from subprocess import *". + + +Replacing /bin/sh shell backquote +--------------------------------- +output=`mycmd myarg` +==> +output = Popen(["mycmd", "myarg"], stdout=PIPE).communicate()[0] + + +Replacing shell pipe line +------------------------- +output=`dmesg | grep hda` +==> +p1 = Popen(["dmesg"], stdout=PIPE) +p2 = Popen(["grep", "hda"], stdin=p1.stdout) +output = p2.communicate()[0] + + +Replacing os.system() +--------------------- +sts = os.system("mycmd" + " myarg") +==> +p = Popen("mycmd" + " myarg", shell=True) +sts = os.waitpid(p.pid, 0) + +Note: + +* Calling the program through the shell is usually not required. + +* It's easier to look at the returncode attribute than the + exitstatus. + +A more real-world example would look like this: + +try: + retcode = call("mycmd" + " myarg", shell=True) + if retcode < 0: + print >>sys.stderr, "Child was terminated by signal", -retcode + else: + print >>sys.stderr, "Child returned", retcode +except OSError, e: + print >>sys.stderr, "Execution failed:", e + + +Replacing os.spawn* +------------------- +P_NOWAIT example: + +pid = os.spawnlp(os.P_NOWAIT, "/bin/mycmd", "mycmd", "myarg") +==> +pid = Popen(["/bin/mycmd", "myarg"]).pid + + +P_WAIT example: + +retcode = os.spawnlp(os.P_WAIT, "/bin/mycmd", "mycmd", "myarg") +==> +retcode = call(["/bin/mycmd", "myarg"]) + + +Vector example: + +os.spawnvp(os.P_NOWAIT, path, args) +==> +Popen([path] + args[1:]) + + +Environment example: + +os.spawnlpe(os.P_NOWAIT, "/bin/mycmd", "mycmd", "myarg", env) +==> +Popen(["/bin/mycmd", "myarg"], env={"PATH": "/usr/bin"}) + + +Replacing os.popen* +------------------- +pipe = os.popen(cmd, mode='r', bufsize) +==> +pipe = Popen(cmd, shell=True, bufsize=bufsize, stdout=PIPE).stdout + +pipe = os.popen(cmd, mode='w', bufsize) +==> +pipe = Popen(cmd, shell=True, bufsize=bufsize, stdin=PIPE).stdin + + +(child_stdin, child_stdout) = os.popen2(cmd, mode, bufsize) +==> +p = Popen(cmd, shell=True, bufsize=bufsize, + stdin=PIPE, stdout=PIPE, close_fds=True) +(child_stdin, child_stdout) = (p.stdin, p.stdout) + + +(child_stdin, + child_stdout, + child_stderr) = os.popen3(cmd, mode, bufsize) +==> +p = Popen(cmd, shell=True, bufsize=bufsize, + stdin=PIPE, stdout=PIPE, stderr=PIPE, close_fds=True) +(child_stdin, + child_stdout, + child_stderr) = (p.stdin, p.stdout, p.stderr) + + +(child_stdin, child_stdout_and_stderr) = os.popen4(cmd, mode, bufsize) +==> +p = Popen(cmd, shell=True, bufsize=bufsize, + stdin=PIPE, stdout=PIPE, stderr=STDOUT, close_fds=True) +(child_stdin, child_stdout_and_stderr) = (p.stdin, p.stdout) + + +Replacing popen2.* +------------------ +Note: If the cmd argument to popen2 functions is a string, the command +is executed through /bin/sh. If it is a list, the command is directly +executed. + +(child_stdout, child_stdin) = popen2.popen2("somestring", bufsize, mode) +==> +p = Popen(["somestring"], shell=True, bufsize=bufsize + stdin=PIPE, stdout=PIPE, close_fds=True) +(child_stdout, child_stdin) = (p.stdout, p.stdin) + + +(child_stdout, child_stdin) = popen2.popen2(["mycmd", "myarg"], bufsize, mode) +==> +p = Popen(["mycmd", "myarg"], bufsize=bufsize, + stdin=PIPE, stdout=PIPE, close_fds=True) +(child_stdout, child_stdin) = (p.stdout, p.stdin) + +The popen2.Popen3 and popen3.Popen4 basically works as subprocess.Popen, +except that: + +* subprocess.Popen raises an exception if the execution fails +* the capturestderr argument is replaced with the stderr argument. +* stdin=PIPE and stdout=PIPE must be specified. +* popen2 closes all filedescriptors by default, but you have to specify + close_fds=True with subprocess.Popen. + + +""" + +import sys +mswindows = (sys.platform == "win32") + +import os +import types +import traceback + +if mswindows: + import threading + import msvcrt + if 0: # <-- change this to use pywin32 instead of the _subprocess driver + import pywintypes + from win32api import GetStdHandle, STD_INPUT_HANDLE, \ + STD_OUTPUT_HANDLE, STD_ERROR_HANDLE + from win32api import GetCurrentProcess, DuplicateHandle, \ + GetModuleFileName, GetVersion + from win32con import DUPLICATE_SAME_ACCESS + from win32pipe import CreatePipe + from win32process import CreateProcess, STARTUPINFO, \ + GetExitCodeProcess, STARTF_USESTDHANDLES, \ + CREATE_NEW_CONSOLE + from win32event import WaitForSingleObject, INFINITE, WAIT_OBJECT_0 + else: + from _subprocess import * + class STARTUPINFO: + dwFlags = 0 + hStdInput = None + hStdOutput = None + hStdError = None + class pywintypes: + error = IOError +else: + import select + import errno + import fcntl + import pickle + +__all__ = ["Popen", "PIPE", "STDOUT", "call"] + +try: + MAXFD = os.sysconf("SC_OPEN_MAX") +except: + MAXFD = 256 + +# True/False does not exist on 2.2.0 +try: + False +except NameError: + False = 0 + True = 1 + +_active = [] + +def _cleanup(): + for inst in _active[:]: + inst.poll() + +PIPE = -1 +STDOUT = -2 + + +def call(*args, **kwargs): + """Run command with arguments. Wait for command to complete, then + return the returncode attribute. + + The arguments are the same as for the Popen constructor. Example: + + retcode = call(["ls", "-l"]) + """ + return Popen(*args, **kwargs).wait() + + +def list2cmdline(seq): + """ + Translate a sequence of arguments into a command line + string, using the same rules as the MS C runtime: + + 1) Arguments are delimited by white space, which is either a + space or a tab. + + 2) A string surrounded by double quotation marks is + interpreted as a single argument, regardless of white space + contained within. A quoted string can be embedded in an + argument. + + 3) A double quotation mark preceded by a backslash is + interpreted as a literal double quotation mark. + + 4) Backslashes are interpreted literally, unless they + immediately precede a double quotation mark. + + 5) If backslashes immediately precede a double quotation mark, + every pair of backslashes is interpreted as a literal + backslash. If the number of backslashes is odd, the last + backslash escapes the next double quotation mark as + described in rule 3. + """ + + # See + # http://msdn.microsoft.com/library/en-us/vccelng/htm/progs_12.asp + result = [] + needquote = False + for arg in seq: + bs_buf = [] + + # Add a space to separate this argument from the others + if result: + result.append(' ') + + needquote = (" " in arg) or ("\t" in arg) + if needquote: + result.append('"') + + for c in arg: + if c == '\\': + # Don't know if we need to double yet. + bs_buf.append(c) + elif c == '"': + # Double backspaces. + result.append('\\' * len(bs_buf)*2) + bs_buf = [] + result.append('\\"') + else: + # Normal char + if bs_buf: + result.extend(bs_buf) + bs_buf = [] + result.append(c) + + # Add remaining backspaces, if any. + if bs_buf: + result.extend(bs_buf) + + if needquote: + result.append('"') + + return ''.join(result) + + +class Popen(object): + def __init__(self, args, bufsize=0, executable=None, + stdin=None, stdout=None, stderr=None, + preexec_fn=None, close_fds=False, shell=False, + cwd=None, env=None, universal_newlines=False, + startupinfo=None, creationflags=0): + """Create new Popen instance.""" + _cleanup() + + if mswindows: + if preexec_fn is not None: + raise ValueError("preexec_fn is not supported on Windows " + "platforms") + if close_fds: + raise ValueError("close_fds is not supported on Windows " + "platforms") + else: + # POSIX + if startupinfo is not None: + raise ValueError("startupinfo is only supported on Windows " + "platforms") + if creationflags != 0: + raise ValueError("creationflags is only supported on Windows " + "platforms") + + self.stdin = None + self.stdout = None + self.stderr = None + self.pid = None + self.returncode = None + self.universal_newlines = universal_newlines + + # Input and output objects. The general principle is like + # this: + # + # Parent Child + # ------ ----- + # p2cwrite ---stdin---> p2cread + # c2pread <--stdout--- c2pwrite + # errread <--stderr--- errwrite + # + # On POSIX, the child objects are file descriptors. On + # Windows, these are Windows file handles. The parent objects + # are file descriptors on both platforms. The parent objects + # are None when not using PIPEs. The child objects are None + # when not redirecting. + + (p2cread, p2cwrite, + c2pread, c2pwrite, + errread, errwrite) = self._get_handles(stdin, stdout, stderr) + + self._execute_child(args, executable, preexec_fn, close_fds, + cwd, env, universal_newlines, + startupinfo, creationflags, shell, + p2cread, p2cwrite, + c2pread, c2pwrite, + errread, errwrite) + + if p2cwrite: + self.stdin = os.fdopen(p2cwrite, 'wb', bufsize) + if c2pread: + if universal_newlines: + self.stdout = os.fdopen(c2pread, 'rU', bufsize) + else: + self.stdout = os.fdopen(c2pread, 'rb', bufsize) + if errread: + if universal_newlines: + self.stderr = os.fdopen(errread, 'rU', bufsize) + else: + self.stderr = os.fdopen(errread, 'rb', bufsize) + + _active.append(self) + + + def _translate_newlines(self, data): + data = data.replace("\r\n", "\n") + data = data.replace("\r", "\n") + return data + + + if mswindows: + # + # Windows methods + # + def _get_handles(self, stdin, stdout, stderr): + """Construct and return tupel with IO objects: + p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite + """ + if stdin == None and stdout == None and stderr == None: + return (None, None, None, None, None, None) + + p2cread, p2cwrite = None, None + c2pread, c2pwrite = None, None + errread, errwrite = None, None + + if stdin == None: + p2cread = GetStdHandle(STD_INPUT_HANDLE) + elif stdin == PIPE: + p2cread, p2cwrite = CreatePipe(None, 0) + # Detach and turn into fd + p2cwrite = p2cwrite.Detach() + p2cwrite = msvcrt.open_osfhandle(p2cwrite, 0) + elif type(stdin) == types.IntType: + p2cread = msvcrt.get_osfhandle(stdin) + else: + # Assuming file-like object + p2cread = msvcrt.get_osfhandle(stdin.fileno()) + p2cread = self._make_inheritable(p2cread) + + if stdout == None: + c2pwrite = GetStdHandle(STD_OUTPUT_HANDLE) + elif stdout == PIPE: + c2pread, c2pwrite = CreatePipe(None, 0) + # Detach and turn into fd + c2pread = c2pread.Detach() + c2pread = msvcrt.open_osfhandle(c2pread, 0) + elif type(stdout) == types.IntType: + c2pwrite = msvcrt.get_osfhandle(stdout) + else: + # Assuming file-like object + c2pwrite = msvcrt.get_osfhandle(stdout.fileno()) + c2pwrite = self._make_inheritable(c2pwrite) + + if stderr == None: + errwrite = GetStdHandle(STD_ERROR_HANDLE) + elif stderr == PIPE: + errread, errwrite = CreatePipe(None, 0) + # Detach and turn into fd + errread = errread.Detach() + errread = msvcrt.open_osfhandle(errread, 0) + elif stderr == STDOUT: + errwrite = c2pwrite + elif type(stderr) == types.IntType: + errwrite = msvcrt.get_osfhandle(stderr) + else: + # Assuming file-like object + errwrite = msvcrt.get_osfhandle(stderr.fileno()) + errwrite = self._make_inheritable(errwrite) + + return (p2cread, p2cwrite, + c2pread, c2pwrite, + errread, errwrite) + + + def _make_inheritable(self, handle): + """Return a duplicate of handle, which is inheritable""" + return DuplicateHandle(GetCurrentProcess(), handle, + GetCurrentProcess(), 0, 1, + DUPLICATE_SAME_ACCESS) + + + def _find_w9xpopen(self): + """Find and return absolut path to w9xpopen.exe""" + w9xpopen = os.path.join(os.path.dirname(GetModuleFileName(0)), + "w9xpopen.exe") + if not os.path.exists(w9xpopen): + # Eeek - file-not-found - possibly an embedding + # situation - see if we can locate it in sys.exec_prefix + w9xpopen = os.path.join(os.path.dirname(sys.exec_prefix), + "w9xpopen.exe") + if not os.path.exists(w9xpopen): + raise RuntimeError("Cannot locate w9xpopen.exe, which is " + "needed for Popen to work with your " + "shell or platform.") + return w9xpopen + + + def _execute_child(self, args, executable, preexec_fn, close_fds, + cwd, env, universal_newlines, + startupinfo, creationflags, shell, + p2cread, p2cwrite, + c2pread, c2pwrite, + errread, errwrite): + """Execute program (MS Windows version)""" + + if not isinstance(args, types.StringTypes): + args = list2cmdline(args) + + if shell: + comspec = os.environ.get("COMSPEC", "cmd.exe") + args = comspec + " /c " + args + if (GetVersion() >= 0x80000000L or + os.path.basename(comspec).lower() == "command.com"): + # Win9x, or using command.com on NT. We need to + # use the w9xpopen intermediate program. For more + # information, see KB Q150956 + # (http://web.archive.org/web/20011105084002/http://support.microsoft.com/support/kb/articles/Q150/9/56.asp) + w9xpopen = self._find_w9xpopen() + args = '"%s" %s' % (w9xpopen, args) + # Not passing CREATE_NEW_CONSOLE has been known to + # cause random failures on win9x. Specifically a + # dialog: "Your program accessed mem currently in + # use at xxx" and a hopeful warning about the + # stability of your system. Cost is Ctrl+C wont + # kill children. + creationflags |= CREATE_NEW_CONSOLE + + # Process startup details + if startupinfo == None: + startupinfo = STARTUPINFO() + if not None in (p2cread, c2pwrite, errwrite): + startupinfo.dwFlags |= STARTF_USESTDHANDLES + startupinfo.hStdInput = p2cread + startupinfo.hStdOutput = c2pwrite + startupinfo.hStdError = errwrite + + # Start the process + try: + hp, ht, pid, tid = CreateProcess(executable, args, + # no special security + None, None, + # must inherit handles to pass std + # handles + 1, + creationflags, + env, + cwd, + startupinfo) + except pywintypes.error, e: + # Translate pywintypes.error to WindowsError, which is + # a subclass of OSError. FIXME: We should really + # translate errno using _sys_errlist (or simliar), but + # how can this be done from Python? + raise WindowsError(*e.args) + + # Retain the process handle, but close the thread handle + self._handle = hp + self.pid = pid + ht.Close() + + # Child is launched. Close the parent's copy of those pipe + # handles that only the child should have open. You need + # to make sure that no handles to the write end of the + # output pipe are maintained in this process or else the + # pipe will not close when the child process exits and the + # ReadFile will hang. + if p2cread != None: + p2cread.Close() + if c2pwrite != None: + c2pwrite.Close() + if errwrite != None: + errwrite.Close() + + + def poll(self): + """Check if child process has terminated. Returns returncode + attribute.""" + if self.returncode == None: + if WaitForSingleObject(self._handle, 0) == WAIT_OBJECT_0: + self.returncode = GetExitCodeProcess(self._handle) + _active.remove(self) + return self.returncode + + + def wait(self): + """Wait for child process to terminate. Returns returncode + attribute.""" + if self.returncode == None: + obj = WaitForSingleObject(self._handle, INFINITE) + self.returncode = GetExitCodeProcess(self._handle) + _active.remove(self) + return self.returncode + + + def _readerthread(self, fh, buffer): + buffer.append(fh.read()) + + + def communicate(self, input=None): + """Interact with process: Send data to stdin. Read data from + stdout and stderr, until end-of-file is reached. Wait for + process to terminate. The optional input argument should be a + string to be sent to the child process, or None, if no data + should be sent to the child. + + communicate() returns a tuple (stdout, stderr).""" + stdout = None # Return + stderr = None # Return + + if self.stdout: + stdout = [] + stdout_thread = threading.Thread(target=self._readerthread, + args=(self.stdout, stdout)) + stdout_thread.setDaemon(True) + stdout_thread.start() + if self.stderr: + stderr = [] + stderr_thread = threading.Thread(target=self._readerthread, + args=(self.stderr, stderr)) + stderr_thread.setDaemon(True) + stderr_thread.start() + + if self.stdin: + if input != None: + self.stdin.write(input) + self.stdin.close() + + if self.stdout: + stdout_thread.join() + if self.stderr: + stderr_thread.join() + + # All data exchanged. Translate lists into strings. + if stdout != None: + stdout = stdout[0] + if stderr != None: + stderr = stderr[0] + + # Translate newlines, if requested. We cannot let the file + # object do the translation: It is based on stdio, which is + # impossible to combine with select (unless forcing no + # buffering). + if self.universal_newlines and hasattr(open, 'newlines'): + if stdout: + stdout = self._translate_newlines(stdout) + if stderr: + stderr = self._translate_newlines(stderr) + + self.wait() + return (stdout, stderr) + + else: + # + # POSIX methods + # + def _get_handles(self, stdin, stdout, stderr): + """Construct and return tupel with IO objects: + p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite + """ + p2cread, p2cwrite = None, None + c2pread, c2pwrite = None, None + errread, errwrite = None, None + + if stdin == None: + pass + elif stdin == PIPE: + p2cread, p2cwrite = os.pipe() + elif type(stdin) == types.IntType: + p2cread = stdin + else: + # Assuming file-like object + p2cread = stdin.fileno() + + if stdout == None: + pass + elif stdout == PIPE: + c2pread, c2pwrite = os.pipe() + elif type(stdout) == types.IntType: + c2pwrite = stdout + else: + # Assuming file-like object + c2pwrite = stdout.fileno() + + if stderr == None: + pass + elif stderr == PIPE: + errread, errwrite = os.pipe() + elif stderr == STDOUT: + errwrite = c2pwrite + elif type(stderr) == types.IntType: + errwrite = stderr + else: + # Assuming file-like object + errwrite = stderr.fileno() + + return (p2cread, p2cwrite, + c2pread, c2pwrite, + errread, errwrite) + + + def _set_cloexec_flag(self, fd): + try: + cloexec_flag = fcntl.FD_CLOEXEC + except AttributeError: + cloexec_flag = 1 + + old = fcntl.fcntl(fd, fcntl.F_GETFD) + fcntl.fcntl(fd, fcntl.F_SETFD, old | cloexec_flag) + + + def _close_fds(self, but): + for i in range(3, MAXFD): + if i == but: + continue + try: + os.close(i) + except: + pass + + + def _execute_child(self, args, executable, preexec_fn, close_fds, + cwd, env, universal_newlines, + startupinfo, creationflags, shell, + p2cread, p2cwrite, + c2pread, c2pwrite, + errread, errwrite): + """Execute program (POSIX version)""" + + if isinstance(args, types.StringTypes): + args = [args] + + if shell: + args = ["/bin/sh", "-c"] + args + + if executable == None: + executable = args[0] + + # For transferring possible exec failure from child to parent + # The first char specifies the exception type: 0 means + # OSError, 1 means some other error. + errpipe_read, errpipe_write = os.pipe() + self._set_cloexec_flag(errpipe_write) + + self.pid = os.fork() + if self.pid == 0: + # Child + try: + # Close parent's pipe ends + if p2cwrite: + os.close(p2cwrite) + if c2pread: + os.close(c2pread) + if errread: + os.close(errread) + os.close(errpipe_read) + + # Dup fds for child + if p2cread: + os.dup2(p2cread, 0) + if c2pwrite: + os.dup2(c2pwrite, 1) + if errwrite: + os.dup2(errwrite, 2) + + # Close pipe fds. Make sure we doesn't close the same + # fd more than once. + if p2cread: + os.close(p2cread) + if c2pwrite and c2pwrite not in (p2cread,): + os.close(c2pwrite) + if errwrite and errwrite not in (p2cread, c2pwrite): + os.close(errwrite) + + # Close all other fds, if asked for + if close_fds: + self._close_fds(but=errpipe_write) + + if cwd != None: + os.chdir(cwd) + + if preexec_fn: + apply(preexec_fn) + + if env == None: + os.execvp(executable, args) + else: + os.execvpe(executable, args, env) + + except: + exc_type, exc_value, tb = sys.exc_info() + # Save the traceback and attach it to the exception object + exc_lines = traceback.format_exception(exc_type, + exc_value, + tb) + exc_value.child_traceback = ''.join(exc_lines) + os.write(errpipe_write, pickle.dumps(exc_value)) + + # This exitcode won't be reported to applications, so it + # really doesn't matter what we return. + os._exit(255) + + # Parent + os.close(errpipe_write) + if p2cread and p2cwrite: + os.close(p2cread) + if c2pwrite and c2pread: + os.close(c2pwrite) + if errwrite and errread: + os.close(errwrite) + + # Wait for exec to fail or succeed; possibly raising exception + data = os.read(errpipe_read, 1048576) # Exceptions limited to 1 MB + os.close(errpipe_read) + if data != "": + child_exception = pickle.loads(data) + raise child_exception + + + def _handle_exitstatus(self, sts): + if os.WIFSIGNALED(sts): + self.returncode = -os.WTERMSIG(sts) + elif os.WIFEXITED(sts): + self.returncode = os.WEXITSTATUS(sts) + else: + # Should never happen + raise RuntimeError("Unknown child exit status!") + + _active.remove(self) + + + def poll(self): + """Check if child process has terminated. Returns returncode + attribute.""" + if self.returncode == None: + try: + pid, sts = os.waitpid(self.pid, os.WNOHANG) + if pid == self.pid: + self._handle_exitstatus(sts) + except os.error: + pass + return self.returncode + + + def wait(self): + """Wait for child process to terminate. Returns returncode + attribute.""" + if self.returncode == None: + pid, sts = os.waitpid(self.pid, 0) + self._handle_exitstatus(sts) + return self.returncode + + + def communicate(self, input=None): + """Interact with process: Send data to stdin. Read data from + stdout and stderr, until end-of-file is reached. Wait for + process to terminate. The optional input argument should be a + string to be sent to the child process, or None, if no data + should be sent to the child. + + communicate() returns a tuple (stdout, stderr).""" + read_set = [] + write_set = [] + stdout = None # Return + stderr = None # Return + + if self.stdin: + # Flush stdio buffer. This might block, if the user has + # been writing to .stdin in an uncontrolled fashion. + self.stdin.flush() + if input: + write_set.append(self.stdin) + else: + self.stdin.close() + if self.stdout: + read_set.append(self.stdout) + stdout = [] + if self.stderr: + read_set.append(self.stderr) + stderr = [] + + while read_set or write_set: + rlist, wlist, xlist = select.select(read_set, write_set, []) + + if self.stdin in wlist: + # When select has indicated that the file is writable, + # we can write up to PIPE_BUF bytes without risk + # blocking. POSIX defines PIPE_BUF >= 512 + bytes_written = os.write(self.stdin.fileno(), input[:512]) + input = input[bytes_written:] + if not input: + self.stdin.close() + write_set.remove(self.stdin) + + if self.stdout in rlist: + data = os.read(self.stdout.fileno(), 1024) + if data == "": + self.stdout.close() + read_set.remove(self.stdout) + stdout.append(data) + + if self.stderr in rlist: + data = os.read(self.stderr.fileno(), 1024) + if data == "": + self.stderr.close() + read_set.remove(self.stderr) + stderr.append(data) + + # All data exchanged. Translate lists into strings. + if stdout != None: + stdout = ''.join(stdout) + if stderr != None: + stderr = ''.join(stderr) + + # Translate newlines, if requested. We cannot let the file + # object do the translation: It is based on stdio, which is + # impossible to combine with select (unless forcing no + # buffering). + if self.universal_newlines and hasattr(open, 'newlines'): + if stdout: + stdout = self._translate_newlines(stdout) + if stderr: + stderr = self._translate_newlines(stderr) + + self.wait() + return (stdout, stderr) + + +def _demo_posix(): + # + # Example 1: Simple redirection: Get process list + # + plist = Popen(["ps"], stdout=PIPE).communicate()[0] + print "Process list:" + print plist + + # + # Example 2: Change uid before executing child + # + if os.getuid() == 0: + p = Popen(["id"], preexec_fn=lambda: os.setuid(100)) + p.wait() + + # + # Example 3: Connecting several subprocesses + # + print "Looking for 'hda'..." + p1 = Popen(["dmesg"], stdout=PIPE) + p2 = Popen(["grep", "hda"], stdin=p1.stdout, stdout=PIPE) + print repr(p2.communicate()[0]) + + # + # Example 4: Catch execution error + # + print + print "Trying a weird file..." + try: + print Popen(["/this/path/does/not/exist"]).communicate() + except OSError, e: + if e.errno == errno.ENOENT: + print "The file didn't exist. I thought so..." + print "Child traceback:" + print e.child_traceback + else: + print "Error", e.errno + else: + print >>sys.stderr, "Gosh. No error." + + +def _demo_windows(): + # + # Example 1: Connecting several subprocesses + # + print "Looking for 'PROMPT' in set output..." + p1 = Popen("set", stdout=PIPE, shell=True) + p2 = Popen('find "PROMPT"', stdin=p1.stdout, stdout=PIPE) + print repr(p2.communicate()[0]) + + # + # Example 2: Simple execution of program + # + print "Executing calc..." + p = Popen("calc") + p.wait() + + +if __name__ == "__main__": + if mswindows: + _demo_windows() + else: + _demo_posix() diff --git a/wxPython/distrib/all/taskrunner.py b/wxPython/distrib/all/taskrunner.py new file mode 100644 index 0000000000..677bf1f1ba --- /dev/null +++ b/wxPython/distrib/all/taskrunner.py @@ -0,0 +1,231 @@ +#---------------------------------------------------------------------- +# Name: taskrunner.py +# Purpose: Classes that can manage running of external processes, +# either consecutively, simultaneously, or both, and can +# log the output of those jobs +# +# Author: Robin Dunn +# +# Created: 05-Nov-2004 +# RCS-ID: $Id$ +# Copyright: (c) 2004 by Total Control Software +# Licence: wxWindows license +#---------------------------------------------------------------------- + +import sys +import os +import signal +import select +import fcntl +from subprocess import Popen, PIPE, STDOUT + + +__all__ = ["Job", "Task", "TaskRunner"] + +#---------------------------------------------------------------------- + + +class Job(object): + """ + Each Job is a monitor wrapped around an externally executing + process. It handles starting the process, polling if it is still + running, reading and logging it's output, and killing it if + needed. + """ + + LOGBASE="." + + def __init__(self, label, args): + self.label = label + self.args = args + self.proc = None + if self.label: + self.log = file("%s/%s.log" % (self.LOGBASE, label), "w", 0) + + def start(self): + self.proc = Popen(self.args, # the command and args to execute + stdout=PIPE, stderr=STDOUT, + bufsize=0, # line-buffered + ) + # put the file in non-blocking mode + #flags = fcntl.fcntl (self.proc.stdout, fcntl.F_GETFL, 0) + #flags = flags | os.O_NONBLOCK + #fcntl.fcntl (self.proc.stdout, fcntl.F_SETFL, flags) + + + def stop(self): + if self.proc is not None and self.proc.returncode is None: + os.kill(self.proc.pid, signal.SIGTERM) + self.logLines() + + + def fileno(self): + if self.proc is not None: + return self.proc.stdout.fileno() + else: + return -1 + + + def logLines(self): + if self.proc is not None: + while self.linesAvailable(): + line = self.proc.stdout.readline() + if not line: break + if self.label: + self.log.write(line) + line = "** %s: %s" % (self.label, line) + sys.stdout.write(line) + + + def linesAvailable(self): + if self.proc is None: + return False + ind, outd, err = select.select([self], [], [], 0) + if ind: + return True + else: + return False + + + def finished(self): + if self.proc is None:# or self.linesAvailable(): + return False + return self.proc.poll() is not None + + + def wait(self): + if self.proc is None: return None + return self.proc.wait() + + + def poll(self): + if self.proc is None: return None + return self.proc.poll() + + + def returnCode(self): + if self.proc is None: return None + return self.proc.returncode + + +#---------------------------------------------------------------------- + +class Task(object): + """ + This class helps manage the running of a Task, which is a simply a + sequence of one or more Jobs, where subesquent jobs are not + started until prior ones are completed. + """ + def __init__(self, jobs=[]): + if type(jobs) != list: + jobs = [jobs] + self.jobs = jobs[:] + self.active = 0 + + def append(self, job): + self.jobs.append(job) + + def activeJob(self): + if self.active > len(self.jobs)-1: + return None + else: + return self.jobs[self.active] + + def next(self): + self.active += 1 + if self.active < len(self.jobs): + self.jobs[self.active].start() + +#---------------------------------------------------------------------- + +class TaskRunner(object): + """ + Manages the running of multiple tasks. + """ + def __init__(self, tasks=[]): + if type(tasks) != list: + tasks = [tasks] + self.tasks = tasks[:] + + def append(self, task): + self.tasks.append(task) + + def run(self): + # start all the active jobs + for task in self.tasks: + task.activeJob().start() + + try: + # loop, getting output from the jobs, etc. + while True: + # get all active Jobs + jobs = [t.activeJob() for t in self.tasks if t.activeJob()] + if not jobs: + break + + # wait for a job to have output ready, then log it + input, output, err = select.select(jobs, [], [], 1) + for job in input: + job.logLines() + + # check for finished jobs + for task in self.tasks: + job = task.activeJob() + if job and job.finished(): + if job.returnCode() != 0: + rc = job.returnCode() + print "JOB RETURNED FAILURE CODE! (%d)" % rc + self.stopAllJobs() + return rc + else: + task.next() + except KeyboardInterrupt: + print "STOPPING JOBS..." + self.stopAllJobs() + + except: + print "Unknown exception..." + self.stopAllJobs() + raise + + return 0 + + + def stopAllJobs(self): + for task in self.tasks: + job = task.activeJob() + if job: + job.stop() + +#---------------------------------------------------------------------- + + +if __name__ == "__main__": + + j1 = Job("label1", ["./tmp/job-1.py", "TEST-1"]) + j2 = Job("label2", ["./tmp/job-2.sh", "TEST-2"]) + + t1 = Task() + t1.append(j1) + t1.append(j2) + + j3 = Job("task2a", ["./tmp/job-1.py", "TASK-2a"]) + j4 = Job("task2b", ["./tmp/job-2.sh", "TASK-2b"]) + + t2 = Task() + t2.append(j4) + t2.append(j3) + + t3 = Task([Job("error", ["./tmp/job-3.sh", "TASK-3"])]) + + tr = TaskRunner() + tr.append(t1) + tr.append(t2) + tr.append(t3) + + for task in tr.tasks: + for job in task.jobs: + print job.label + + print tr.run() + -- 2.45.2