Annotation of pkgsrc/pkgtools/pkg_rolling-replace/files/pkg_rolling-replace.sh, revision 1.1

1.1     ! gdt         1: #!/bin/sh
        !             2: 
        !             3: # $NetBSD: pkg_rolling-replace.sh,v 1.16 2006/11/23 15:36:55 gdt Exp $
        !             4: #<license>
        !             5: # Copyright (c) 2006 BBN Technologies Corp.  All rights reserved.
        !             6: #
        !             7: # Redistribution and use in source and binary forms, with or without
        !             8: # modification, are permitted provided that the following conditions
        !             9: # are met:
        !            10: # 1. Redistributions of source code must retain the above copyright
        !            11: #    notice, this list of conditions and the following disclaimer.
        !            12: # 2. Redistributions in binary form must reproduce the above copyright
        !            13: #    notice, this list of conditions and the following disclaimer in the
        !            14: #    documentation and/or other materials provided with the distribution.
        !            15: # 3. Neither the name of BBN Technologies nor the names of its contributors
        !            16: #    may be used to endorse or promote products derived from this software
        !            17: #    without specific prior written permission.
        !            18: #
        !            19: # THIS SOFTWARE IS PROVIDED BY BBN TECHNOLOGIES AND CONTRIBUTORS ``AS IS''
        !            20: # AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
        !            21: # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
        !            22: # ARE DISCLAIMED.  IN NO EVENT SHALL BBN TECHNOLOGIES OR CONTRIBUTORS BE
        !            23: # LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
        !            24: # CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
        !            25: # SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
        !            26: # INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
        !            27: # CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
        !            28: # ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
        !            29: # POSSIBILITY OF SUCH DAMAGE.
        !            30: #
        !            31: # Effort sponsored in part by the Defense Advanced Research Projects
        !            32: # Agency (DARPA) and the Department of the Interior National Business
        !            33: # Center under agreement number NBCHC050166.
        !            34: #</license>
        !            35: 
        !            36: # REVIEW NOTATION LEGEND
        !            37: #   XXX marks things that are broken/kludgy
        !            38: #   TODO marks things that need to be done
        !            39: #   FIXED marks items fixed, needs review and deletion of FIXED comment
        !            40: 
        !            41: # Items to be completed for initial release:
        !            42: 
        !            43: # TODO: move bulk of help into a real man page.
        !            44: 
        !            45: # Items for future work (some imply changes in pkgsrc, not necessarily here)
        !            46: #
        !            47: #   Make a pass over all packages for build depends, and rememeber
        !            48: # which packages have been so checked.  Check newly unsafe packages.
        !            49: # The current lazy evaluation can perhaps fail to do things in the
        !            50: # right order.  Alternatively, explain why the current scheme is safe
        !            51: # and preferred.
        !            52: #
        !            53: #   Consider expansion to update via binary packages.  This raises
        !            54: # interesting questions about ABIs and binary builds
        !            55: #
        !            56: #   Deal with conflicts in a smarter way, perhaps more automatically.
        !            57: # This is hard because just removing packages is not ok.
        !            58: #
        !            59: #   Handle foo being split into foo and foo-share.  Now, make replace
        !            60: # of foo pulls in foo-share which conflicts with foo.  This needlessly
        !            61: # loses.
        !            62: #
        !            63: #   Parse mk.conf for PKGSRCDIR, etc.
        !            64: 
        !            65: test -n "$PKG_DBDIR" || PKG_DBDIR=/var/db/pkg
        !            66: test -n "$PKGSRCDIR" || PKGSRCDIR=/usr/pkgsrc
        !            67: 
        !            68: unset PKG_PATH || true  #or pkgsrc makefiles will complain
        !            69: 
        !            70: MAKE=make
        !            71: # XXX Find BSD make at package build time.
        !            72: UNAME=`uname`
        !            73: case "$UNAME" in
        !            74:     Darwin)
        !            75:     MAKE=bmake
        !            76:     ;;
        !            77: esac
        !            78: 
        !            79: usage()
        !            80: {
        !            81:     echo "Usage: pkg_rolling-replace [opts]
        !            82:         -h         This help
        !            83:         -n         Don't actually do make replace
        !            84:         -u         Update mismatched packages
        !            85:         -v         Verbose
        !            86:         -x <pkg>   exclude <pkg> from update check
        !            87: 
        !            88: pkg_rolling-replace does 'make replace' on one package at a time,
        !            89: tsorting the packages being replaced according to their
        !            90: interdependencies, which avoids most duplicate rebuilds.
        !            91: 
        !            92: pkg_rolling-replace can be used in one of two ways:
        !            93: 
        !            94:     - 'make replace' is unsafe in that, if the replaced package's ABI
        !            95:       changes, its dependent packages may break.  If this happens, run
        !            96:       'pkg_rolling-replace' (no arguments) to rebuild them against the
        !            97:       new version.
        !            98: 
        !            99:     - 'pkg_chk -u' will delete all your mismatched (outdated)
        !           100:       packages, then reinstall them one at a time, leaving you without
        !           101:       those packages in the meantime.  'pkg_rolling-replace -u' will
        !           102:       instead upgrade them in place, allowing you to keep using your
        !           103:       system in the meantime (maybe...if you're lucky...because
        !           104:       pkg_rolling-replace replaces the \"deepest\" dependency first,
        !           105:       things could still break if that happens to be a fundamental
        !           106:       library whose ABI has changed).
        !           107: "
        !           108:     exit 1
        !           109: }
        !           110: 
        !           111: # pkg_rolling-replace's output is intermingled with pkgsrc make
        !           112: # output.  Thus, we use a different prefix.  pkgsrc uses '===>' for
        !           113: # major steps, and '=>' for minor ones.  Thus, we use 'RR>'.
        !           114: 
        !           115: OPI='RR>'
        !           116: OPC='rr>' # continuation
        !           117: 
        !           118: 
        !           119: # Echo the names of packages needing updates, versions stripped.  This
        !           120: # has been tested with pkg_chk 1.76.  Older versions are not
        !           121: # supported.  Newer versions may or may not work (patches welcome).
        !           122: check_packages_mismatched()
        !           123: {
        !           124:     pkg_chk -u -q | while read line; do
        !           125:         # duplicate output of pkg_chk to stderr (bypass $(...) or `...`)
        !           126:         echo "${OPC} $line" > /dev/stderr
        !           127:        # Look for the first thing that looks like pkg-version rather
        !           128:        # than category/pkg and remove the version.
        !           129:         for word in $line; do
        !           130:             if [ "$(echo $word | egrep '^[^/]+-[0-9][^/]*$')" ]; then
        !           131:                 echo $word | sed 's/-[0-9].*//'
        !           132:                 break  #done with this line
        !           133:             fi
        !           134:         done
        !           135:     done
        !           136: }
        !           137: 
        !           138: # usage: check_packages_w_flag flag
        !           139: # echo packages with flag=YES
        !           140: check_packages_w_flag()
        !           141: {
        !           142:     _flag=$1; shift
        !           143:     for pkgver in $(pkg_info -e '*'); do
        !           144:         if pkg_info -Bq $pkgver \
        !           145:                 | egrep "^$_flag=[Yy][Ee][Ss]" > /dev/null; then
        !           146:             echo $pkgver | sed 's/-[0-9].*//'
        !           147:         fi
        !           148:     done
        !           149: }
        !           150: 
        !           151: # echo dep->pkg edges for all installed packages
        !           152: depgraph_installed()
        !           153: {
        !           154:     for pkgver in $(pkg_info -e '*'); do
        !           155:         pkg=$(echo $pkgver | sed 's/-[0-9].*//')
        !           156:        # Include $pkg as a node without dependencies in case it has none.
        !           157:         echo $pkg $pkg
        !           158:         for depver in $(pkg_info -Nq $pkg); do
        !           159:             dep=$(echo $depver | sed 's/-[0-9].*//')
        !           160:             echo $dep $pkg
        !           161:         done
        !           162:     done
        !           163: }
        !           164: 
        !           165: # usage: who_requires pkg --in-graph DEPGRAPH
        !           166: who_requires()
        !           167: {
        !           168:     _target=$1; shift
        !           169:     test "$1" = '--in-graph' && shift || return $((false))
        !           170: 
        !           171:     while [ $# -gt 0 ]; do
        !           172:         _dep=$1; _pkg=$2; shift 2;
        !           173:         if [ $_dep = $_target -a $_dep != $_pkg ]; then
        !           174:             echo $_pkg
        !           175:         fi
        !           176:     done
        !           177: }
        !           178: 
        !           179: # usage: is_member x list
        !           180: # return true (0) if x appears in list, false (1) otherwise
        !           181: is_member()
        !           182: {
        !           183:     _x="$1"; shift;
        !           184:     while [ $# -gt 0 -a "$1" != "$_x" ]; do
        !           185:         shift
        !           186:     done
        !           187: 
        !           188:     test $# -gt 0
        !           189: }
        !           190: 
        !           191: # usage: exclude list1 --from list2
        !           192: # echo list2 with items from list1 excluded
        !           193: exclude()
        !           194: {
        !           195:     _excl=
        !           196:     while [ $# -gt 0 -a $1 != "--from" ]; do
        !           197:         _excl="$_excl $1"
        !           198:         shift
        !           199:     done
        !           200:     if [ $# -gt 0 ]; then
        !           201:         shift  #discard '--from'
        !           202:     fi
        !           203:     while [ $# -gt 0 ]; do
        !           204:         is_member $1 $_excl || echo $1
        !           205:         shift
        !           206:     done
        !           207: }
        !           208: 
        !           209: # usage: uniquify list
        !           210: # just does sort -u on list (equiv. to sort | uniq)
        !           211: # CAUTION: reorders list
        !           212: uniqify()
        !           213: {
        !           214:     for _x in $*; do echo $_x; done | sort -u
        !           215: }
        !           216: 
        !           217: verbose()
        !           218: {
        !           219:     if [ -n "$opt_v" ]; then
        !           220:         echo "$@"
        !           221:     fi
        !           222: }
        !           223: 
        !           224: vsleep()
        !           225: {
        !           226:     if [ -n "$opt_v" ]; then
        !           227:         sleep $1
        !           228:     fi
        !           229: }
        !           230: 
        !           231: ######################################################################
        !           232: ##
        !           233: ## main()
        !           234: ##
        !           235: 
        !           236: EXCLUDE=
        !           237: 
        !           238: args=$(getopt hnuvx: $*)
        !           239: if [ $? -ne 0 ]; then
        !           240:     opt_h=1
        !           241: fi
        !           242: set -- $args
        !           243: while [ $# -gt 0 ]; do
        !           244:     case "$1" in
        !           245:         -h) opt_h=1 ;;
        !           246:         -n) opt_n=1 ;;
        !           247:         -u) opt_u=1 ;;
        !           248:         -v) opt_v=1 ;;
        !           249:         -x) EXCLUDE="$EXCLUDE $(echo $2 | sed 's/,/ /g')" ; shift ;;
        !           250:         --) shift; break ;;
        !           251:     esac
        !           252:     shift
        !           253: done
        !           254: 
        !           255: if [ -n "$opt_h" ]; then
        !           256:     usage
        !           257: fi
        !           258: 
        !           259: MISMATCH_TODO=
        !           260: if [ -n "$opt_u" ]; then
        !           261:     echo "${OPI} Checking for mismatched installed packages using pkg_chk"
        !           262:     MISMATCH_TODO=$(check_packages_mismatched)
        !           263:     echo "${OPI} Excluding the following mismatched packages:"
        !           264:     echo "${OPC} EXCLUDE=[$EXCLUDE]"
        !           265:     MISMATCH_TODO=$(exclude $EXCLUDE --from $MISMATCH_TODO)
        !           266: fi
        !           267: 
        !           268: echo "${OPI} Checking for rebuild-requested installed packages (rebuild=YES)"
        !           269: REBUILD_TODO=$(check_packages_w_flag 'rebuild')
        !           270: 
        !           271: echo "${OPI} Checking for unsafe installed packages (unsafe_depends=YES)"
        !           272: UNSAFE_TODO=$(check_packages_w_flag 'unsafe_depends')
        !           273: 
        !           274: # DEPGRAPH_INSTALLED is rebuilt each round.  DEPGRAPH_SRC will collect
        !           275: # edges that we discover using 'make show-depends', but that weren't
        !           276: # listed as depends by the installed version of a package, and
        !           277: # DEPENDS_CHECKED lists packages for which we've already done that
        !           278: # check.
        !           279: DEPGRAPH_INSTALLED=
        !           280: DEPGRAPH_SRC=
        !           281: DEPENDS_CHECKED=
        !           282: 
        !           283: verbose "${OPI} Packages to rebuild:"
        !           284: verbose "${OPC} MISMATCH_TODO=[$(echo $MISMATCH_TODO)]"  #strip newlines
        !           285: verbose "${OPC} REBUILD_TODO=[$(echo $REBUILD_TODO)]"
        !           286: verbose "${OPC} UNSAFE_TODO=[$(echo $UNSAFE_TODO)]"
        !           287: vsleep 2
        !           288: 
        !           289: REPLACE_TODO=$(uniqify $MISMATCH_TODO $REBUILD_TODO $UNSAFE_TODO)
        !           290: depgraph_built=0
        !           291: 
        !           292: while [ -n "$REPLACE_TODO" ]; do
        !           293:     # don't rebuild depgraph if we continued from new-depends step below
        !           294:     if [ "$depgraph_built" -eq 0 ]; then
        !           295:         echo "${OPI} Building dependency graph for installed packages"
        !           296:         DEPGRAPH_INSTALLED=$(depgraph_installed)
        !           297:         depgraph_built=1
        !           298:     fi
        !           299: 
        !           300:     echo "${OPI} Tsorting dependency graph"
        !           301:     TSORTED=$(echo $DEPGRAPH_INSTALLED $DEPGRAPH_SRC | tsort)
        !           302:     for pkg in $TSORTED; do
        !           303:         if is_member $pkg $REPLACE_TODO; then
        !           304:             break;
        !           305:         fi
        !           306:     done
        !           307:     pkgdir=$(pkg_info -Bq $pkg | awk -F= '/PKGPATH=/{print $2}')
        !           308:     echo "${OPI} Selecting $pkg ($pkgdir) as next package to replace"
        !           309:     sleep 1
        !           310: 
        !           311:     # Newer versions in pkgsrc sometimes have more depends than are
        !           312:     # recorded for the installed version (this is entirely to be
        !           313:     # expected as packages are split, renamed, and add new features).
        !           314:     # When this happens, add the new edges to the graph and re-tsort.
        !           315:     # Don't re-tsort if the new edges were already installed once
        !           316:     # (otherwise we'll go into a loop).
        !           317: 
        !           318:     # XXX I'm not sure that DEPENDS_CHECKED is necessary, or whether
        !           319:     # simply ignoring new deps that aren't in $REPLACE_TODO would have
        !           320:     # been sufficient.  The DEPENDS_CHECKED approach causes one extra
        !           321:     # tsort in some cases, which isn't overly expensive.
        !           322: 
        !           323:     # XXX After tsorting and choosing what to 'make replace', we
        !           324:     # filter out packages that aren't already installed and marked for
        !           325:     # replacement.  This is safe, since uninstalled depends will be
        !           326:     # pulled in automatically by 'make replace'; but in rare cases it
        !           327:     # might be non-optimal, leading to a duplicate rebuild that we
        !           328:     # would have avoided had we selected the uninstalled package in
        !           329:     # tsorted order and run 'make install' on it.  This seems like
        !           330:     # such a rare case that the added complexity isn't worth it.
        !           331: 
        !           332:     if ! is_member $pkg $DEPENDS_CHECKED; then
        !           333:        echo "${OPI} Checking if $pkg has new depends..."
        !           334:        OLD_DEPENDS=$(pkg_info -Nq $pkg | sed 's/-[0-9].*[[:>:]]//g')
        !           335:        NEW_DEPENDS=
        !           336:        cd "$PKGSRCDIR/$pkgdir"
        !           337:        bdeps=$(${MAKE} show-depends VARNAME=BUILD_DEPENDS)
        !           338:        rdeps=$(${MAKE} show-depends)
        !           339:        for depver in $bdeps $rdeps; do
        !           340:            dep=$(echo $depver | sed -e 's/-[0-9].*//' -e 's/[<>]=[0-9].*//' \
        !           341:                -e 's/-[][].*//')
        !           342:            if ! is_member $dep $OLD_DEPENDS $NEW_DEPENDS; then
        !           343:                NEW_DEPENDS="$NEW_DEPENDS $dep"
        !           344:                DEPGRAPH_SRC="$DEPGRAPH_SRC $dep $pkg"
        !           345:            fi
        !           346:        done
        !           347:        DEPENDS_CHECKED="$DEPENDS_CHECKED $pkg"
        !           348:        if [ -n "$NEW_DEPENDS" ]; then
        !           349:            echo "${OPI} $pkg has the following new depends (need to re-tsort):"
        !           350:            echo "${OPC} [$(echo $NEW_DEPENDS)]"
        !           351:            sleep 2
        !           352:            continue
        !           353:        fi
        !           354:     fi
        !           355: 
        !           356:     # Do make replace, with clean before, and package and clean afterwards.
        !           357:     echo "${OPI} Replacing $(pkg_info -e $pkg)"
        !           358:     FAIL=
        !           359:     if [ -z "$opt_n" ]; then
        !           360:        cd "$PKGSRCDIR/$pkgdir" \
        !           361:            && ${MAKE} clean && ${MAKE} replace && ${MAKE} package && ${MAKE} clean \
        !           362:            || FAIL=1
        !           363:     else
        !           364:        echo "cd $PKGSRCDIR/$pkgdir && ${MAKE} clean && ${MAKE} replace && ${MAKE} package && ${MAKE} clean"
        !           365:     fi
        !           366:     if [ -n "$FAIL" ]; then
        !           367:         echo "*** 'make replace' failed for package $pkg."
        !           368:         echo "*** Please read the errors listed above, fix the problem,"
        !           369:         echo "*** then re-run pkg_rolling-replace to continue."
        !           370:         exit 1
        !           371:     fi
        !           372:     sleep 1
        !           373: 
        !           374:     # remove just-replaced package from all *_TODO lists
        !           375:     MISMATCH_TODO=$(exclude $pkg --from $MISMATCH_TODO)
        !           376:     REBUILD_TODO=$(exclude $pkg --from $REBUILD_TODO)
        !           377:     UNSAFE_TODO=$(exclude $pkg --from $UNSAFE_TODO)
        !           378: 
        !           379:     echo "${OPI} Re-checking for unsafe installed packages (unsafe_depends=YES)"
        !           380:     if [ -n "$opt_n" ]; then
        !           381:        # With -n, the replace didn't happen, and thus the packages that would
        !           382:        # have been marked unsafe_depends=YES were not.  Add the set that
        !           383:        # would have been marked so we can watch what pkg_rolling-replace
        !           384:        # would have done (approximately).
        !           385:         UNSAFE_TODO=$(uniqify $UNSAFE_TODO \
        !           386:             $(who_requires $pkg --in-graph $DEPGRAPH_INSTALLED))
        !           387:         sleep 1
        !           388:     else
        !           389:         UNSAFE_TODO=$(check_packages_w_flag 'unsafe_depends')
        !           390:     fi
        !           391: 
        !           392:     verbose "${OPI} Packages to rebuild:"
        !           393:     verbose "${OPC} MISMATCH_TODO=[$(echo $MISMATCH_TODO)]"  #strips newlines
        !           394:     verbose "${OPC} REBUILD_TODO=[$(echo $REBUILD_TODO)]"
        !           395:     verbose "${OPC} UNSAFE_TODO=[$(echo $UNSAFE_TODO)]"
        !           396:     vsleep 4
        !           397: 
        !           398:     REPLACE_TODO=$(uniqify $MISMATCH_TODO $REBUILD_TODO $UNSAFE_TODO)
        !           399:     depgraph_built=0
        !           400: done
        !           401: 
        !           402: echo "${OPI} No more packages to replace; done."

CVSweb <webmaster@jp.NetBSD.org>