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

1.1       gdt         1: #!/bin/sh
                      2: 
1.44    ! pho         3: # $NetBSD: pkg_rolling-replace.sh,v 1.43 2021/04/13 17:51:21 rhialto Exp $
1.1       gdt         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: 
1.3       tnn        64: # Substituted by pkgsrc at pre-configure time.
1.4       tnn        65: MAKE="@MAKE@"
1.15      tnn        66: AWK="@AWK@"
1.3       tnn        67: 
1.19      apb        68: if [ -z "$MAKECONF" ] ; then
                     69:     for mkconf in "@MAKECONF@" "@PREFIX@/etc/mk.conf" /etc/mk.conf ; do
                     70:        if [ -f "$mkconf" ] ; then
                     71:            MAKECONF="$mkconf"
                     72:            break
                     73:        fi
                     74:     done
                     75: fi
                     76: if [ -z "$MAKECONF" -o ! -f "$MAKECONF" ] ; then
                     77:     MAKECONF=/dev/null
                     78: fi
1.7       tnn        79: test -f "$MAKECONF" && test -z "$PKGSRCDIR" && PKGSRCDIR="` \
                     80:     printf '.include "%s"\n_print_pkgsrcdir:\n\t@echo "${PKGSRCDIR}"\n' \
1.8       tnn        81:     "$MAKECONF" | "$MAKE" -f - BSD_PKG_MK=1 _print_pkgsrcdir`"
1.19      apb        82: if [ -z "$PKGSRCDIR" ] ; then
                     83:     for dir in . .. ../.. /usr/pkgsrc ; do
                     84:        if [ -f "${dir}/mk/bsd.pkg.mk" ]; then
                     85:            case "${dir}" in
                     86:            /*) PKGSRCDIR="${dir}" ;;
                     87:            *)  PKGSRCDIR="$( cd "${dir}" >/dev/null 2>&1 && pwd )" ;;
                     88:            esac
                     89:            break
                     90:        fi
                     91:     done
                     92: fi
                     93: test -z "$PKGSRCDIR" && echo >&2 "Please set PKGSRCDIR" && exit 1
1.12      tnn        94: test -z "$PKG_CHK" && PKG_CHK="@PKG_CHK@"
1.42      tnn        95: test -z "$PKG_ADMIN" && PKG_ADMIN="@PKG_ADMIN_CMD@"
1.12      tnn        96: test -z "$PKG_INFO" && PKG_INFO="@PKG_INFO_CMD@"
1.1       gdt        97: 
1.19      apb        98: export PKGSRCDIR
                     99: 
1.1       gdt       100: unset PKG_PATH || true  #or pkgsrc makefiles will complain
                    101: 
                    102: usage()
                    103: {
                    104:     echo "Usage: pkg_rolling-replace [opts]
                    105:         -h         This help
1.34      abs       106:         -B         Pass -B to pkg_chk (only applies with -u)
1.22      sno       107:         -F         Fetch sources (including depends) only, don't build
                    108:         -k         Keep running, even on error
1.1       gdt       109:         -n         Don't actually do make replace
1.13      tnn       110:         -r         Just replace, don't create binary packages
                    111:         -s         Replace even if the ABIs are still compatible ("strict")
1.41      rhialto   112:         -u         Update mismatched packages
1.1       gdt       113:         -v         Verbose
1.25      sno       114:        -D VAR=VAL Passes given variables and values to make
1.22      sno       115:         -L <path>  Log to path (<path>/pkgdir/pkg)
1.20      wiz       116:         -X <pkg>   exclude <pkg> from being rebuilt
1.41      rhialto   117:         -x <pkg>   exclude <pkg> from mismatch check
1.1       gdt       118: 
                    119: pkg_rolling-replace does 'make replace' on one package at a time,
                    120: tsorting the packages being replaced according to their
                    121: interdependencies, which avoids most duplicate rebuilds.
                    122: 
                    123: pkg_rolling-replace can be used in one of two ways:
                    124: 
                    125:     - 'make replace' is unsafe in that, if the replaced package's ABI
                    126:       changes, its dependent packages may break.  If this happens, run
                    127:       'pkg_rolling-replace' (no arguments) to rebuild them against the
                    128:       new version.
                    129: 
1.41      rhialto   130:     - 'pkg_chk -u' will delete all your mismatched packages (where the
                    131:       package version does not match the pkgsrc version), then reinstall
                    132:       them one at a time, leaving you without those packages in the
                    133:       meantime.  'pkg_rolling-replace -u' will instead upgrade them in
                    134:       place, allowing you to keep using your system in the meantime
                    135:       (maybe...if you're lucky...because pkg_rolling-replace replaces
                    136:       the \"deepest\" dependency first, things could still break if that
                    137:       happens to be a fundamental library whose ABI has changed).
1.1       gdt       138: "
                    139:     exit 1
                    140: }
                    141: 
                    142: # pkg_rolling-replace's output is intermingled with pkgsrc make
                    143: # output.  Thus, we use a different prefix.  pkgsrc uses '===>' for
                    144: # major steps, and '=>' for minor ones.  Thus, we use 'RR>'.
                    145: 
                    146: OPI='RR>'
                    147: OPC='rr>' # continuation
                    148: 
                    149: 
                    150: # Echo the names of packages needing updates, versions stripped.  This
                    151: # has been tested with pkg_chk 1.76.  Older versions are not
                    152: # supported.  Newer versions may or may not work (patches welcome).
                    153: check_packages_mismatched()
                    154: {
1.43      rhialto   155:     warned_once=""
                    156: 
1.39      gdt       157:     ${PKG_CHK} -u -q $opt_B | egrep -v missing | while read line; do
1.1       gdt       158:         # duplicate output of pkg_chk to stderr (bypass $(...) or `...`)
1.11      tnn       159:         echo "${OPC} $line" 1>&2
1.1       gdt       160:        # Look for the first thing that looks like pkg-version rather
                    161:        # than category/pkg and remove the version.
                    162:         for word in $line; do
1.5       tnn       163:             if [ "$(echo $word | egrep '^[^/]+-[0-9][^-/]*$')" ]; then
1.41      rhialto   164:                if [ -z "$opt_F" ]; then
1.44    ! pho       165:                    ${PKG_ADMIN} set mismatch=YES "$word" >/dev/null 2>&1 || {
1.43      rhialto   166:                        if [ -z "$warned_once" ]; then
                    167:                            echo 1>&2 "$OPC WARNING: mismatch variable not set due to permissions;"
                    168:                            echo 1>&2 "$OPC          mismatch status will not persist."
                    169:                            warned_once=1
                    170:                        fi
                    171:                    }
1.41      rhialto   172:                fi
1.5       tnn       173:                 echo $word | sed 's/-[0-9][^-]*$//'
1.1       gdt       174:                 break  #done with this line
                    175:             fi
                    176:         done
                    177:     done
                    178: }
                    179: 
                    180: # usage: check_packages_w_flag flag
                    181: # echo packages with flag=YES
                    182: check_packages_w_flag()
                    183: {
                    184:     _flag=$1; shift
1.12      tnn       185:     for pkgver in $(${PKG_INFO} -e '*'); do
                    186:         if ${PKG_INFO} -Bq $pkgver \
1.1       gdt       187:                 | egrep "^$_flag=[Yy][Ee][Ss]" > /dev/null; then
1.5       tnn       188:             echo $pkgver | sed 's/-[0-9][^-]*$//'
1.1       gdt       189:         fi
                    190:     done
                    191: }
                    192: 
                    193: # echo dep->pkg edges for all installed packages
                    194: depgraph_installed()
                    195: {
1.15      tnn       196:        ${PKG_INFO} -N '*' | ${AWK} '                                   \
                    197:                /^Information for/ {                                    \
                    198:                        pkg=$3; sub("-[0-9][^-]*:$", "", pkg);          \
                    199:                        print pkg" "pkg;                                \
                    200:                        state=1;                                        \
                    201:                }                                                       \
1.16      gdt       202:                /^\** PACKAGE MAY NOT BE DELETED \**$/ { state=3; }     \
1.15      tnn       203:                /^./ {                                                  \
                    204:                        if (state == 2) {                               \
                    205:                                dep=$1; sub("-[0-9][^-]*$", "", dep);   \
                    206:                                print dep" "pkg;                        \
                    207:                        }                                               \
                    208:                }                                                       \
                    209:                /^Built using/ {                                        \
                    210:                        state=2                                         \
                    211:                }                                                       \
                    212:        '
1.1       gdt       213: }
                    214: 
                    215: # usage: who_requires pkg --in-graph DEPGRAPH
                    216: who_requires()
                    217: {
                    218:     _target=$1; shift
                    219:     test "$1" = '--in-graph' && shift || return $((false))
                    220: 
                    221:     while [ $# -gt 0 ]; do
                    222:         _dep=$1; _pkg=$2; shift 2;
                    223:         if [ $_dep = $_target -a $_dep != $_pkg ]; then
                    224:             echo $_pkg
                    225:         fi
                    226:     done
                    227: }
                    228: 
                    229: # usage: is_member x list
                    230: # return true (0) if x appears in list, false (1) otherwise
                    231: is_member()
                    232: {
                    233:     _x="$1"; shift;
                    234:     while [ $# -gt 0 -a "$1" != "$_x" ]; do
                    235:         shift
                    236:     done
                    237: 
                    238:     test $# -gt 0
                    239: }
                    240: 
                    241: # usage: exclude list1 --from list2
                    242: # echo list2 with items from list1 excluded
                    243: exclude()
                    244: {
                    245:     _excl=
                    246:     while [ $# -gt 0 -a $1 != "--from" ]; do
                    247:         _excl="$_excl $1"
                    248:         shift
                    249:     done
                    250:     if [ $# -gt 0 ]; then
                    251:         shift  #discard '--from'
                    252:     fi
                    253:     while [ $# -gt 0 ]; do
                    254:         is_member $1 $_excl || echo $1
                    255:         shift
                    256:     done
                    257: }
                    258: 
                    259: # usage: uniquify list
                    260: # just does sort -u on list (equiv. to sort | uniq)
                    261: # CAUTION: reorders list
                    262: uniqify()
                    263: {
                    264:     for _x in $*; do echo $_x; done | sort -u
                    265: }
                    266: 
                    267: verbose()
                    268: {
                    269:     if [ -n "$opt_v" ]; then
                    270:         echo "$@"
                    271:     fi
                    272: }
                    273: 
                    274: vsleep()
                    275: {
                    276:     if [ -n "$opt_v" ]; then
                    277:         sleep $1
                    278:     fi
                    279: }
                    280: 
1.22      sno       281: report()
                    282: {
1.26      tnn       283:     for a in $SUCCEEDED; do
1.22      sno       284:         verbose "+ $a"
                    285:     done
                    286: 
                    287:     for a in $FAILED; do
                    288:         verbose "- $a"
                    289:     done
                    290: }
                    291: 
1.13      tnn       292: abort()
                    293: {
1.26      tnn       294:     echo "*** $1"
                    295:     echo "*** Please read the errors listed above, fix the problem,"
                    296:     echo "*** then re-run pkg_rolling-replace to continue."
                    297:     report
                    298:     exit 1
                    299: }
                    300: 
                    301: error()
                    302: {
1.28      tnn       303:     if [ -z "$opt_k" ]; then
1.26      tnn       304:         abort "$1"
                    305:     fi
                    306:     echo "*** $1"
                    307: }
                    308: 
                    309: mark_as_succeeded()
                    310: {
1.27      tnn       311:     SUCCEEDED=$(uniqify $SUCCEEDED $1)
1.26      tnn       312: }
                    313: 
                    314: mark_as_failed()
                    315: {
1.27      tnn       316:     FAILED=$(uniqify $FAILED $1)
1.13      tnn       317: }
                    318: 
1.22      sno       319: todo()
                    320: {
                    321:     if [ -z "$opt_F" ]; then
                    322:         verbose "${OPI} Packages to rebuild:"
                    323:         verbose "${OPC} MISMATCH_TODO=[$(echo $MISMATCH_TODO)]"  #strip newlines
                    324:         verbose "${OPC} REBUILD_TODO=[$(echo $REBUILD_TODO)]"
                    325:         verbose "${OPC} UNSAFE_TODO=[$(echo $UNSAFE_TODO)]"
                    326:         REPLACE_TODO=$(uniqify $MISMATCH_TODO $REBUILD_TODO $UNSAFE_TODO)
                    327:     else
                    328:         REPLACE_TODO=$(uniqify $MISMATCH_TODO)
                    329:         verbose "${OPI} Packages to fetch:"
                    330:         verbose "${OPC} MISMATCH_TODO=[$(echo $MISMATCH_TODO)]"  #strip newlines
                    331:     fi
                    332:     REPLACE_TODO=$(exclude $REALLYEXCLUDE --from $REPLACE_TODO)
                    333:     if [ -n "$FAILED" ]; then
                    334:         REPLACE_TODO=$(exclude $FAILED --from $REPLACE_TODO)
                    335:     fi
                    336:     vsleep 2
                    337: }
                    338: 
1.1       gdt       339: ######################################################################
                    340: ##
                    341: ## main()
                    342: ##
                    343: 
                    344: EXCLUDE=
1.25      sno       345: MAKE_VAR="IN_PKG_ROLLING_REPLACE=1"
                    346: MAKE_VAR_SEP=" "
1.1       gdt       347: 
1.34      abs       348: args=$(getopt BFhknursvD:x:X:L: $*)
1.1       gdt       349: if [ $? -ne 0 ]; then
                    350:     opt_h=1
                    351: fi
                    352: set -- $args
                    353: while [ $# -gt 0 ]; do
                    354:     case "$1" in
1.34      abs       355:         -B) opt_B=-B ;;
1.22      sno       356:         -F) opt_F=1 ;;
1.1       gdt       357:         -h) opt_h=1 ;;
1.22      sno       358:         -k) opt_k=1 ;;
1.1       gdt       359:         -n) opt_n=1 ;;
1.13      tnn       360:         -r) opt_r=1 ;;
                    361:         -s) opt_s=1 ;;
1.1       gdt       362:         -u) opt_u=1 ;;
                    363:         -v) opt_v=1 ;;
1.25      sno       364:        -D) MAKE_VAR="${MAKE_VAR}${MAKE_VAR_SEP}$2"; MAKE_VAR_SEP=" "; shift ;;
1.1       gdt       365:         -x) EXCLUDE="$EXCLUDE $(echo $2 | sed 's/,/ /g')" ; shift ;;
1.17      apb       366:         -X) REALLYEXCLUDE="$REALLYEXCLUDE $(echo $2 | sed 's/,/ /g')" ; shift ;;
1.22      sno       367:         -L) LOGPATH="$2"; shift ;;
1.1       gdt       368:         --) shift; break ;;
                    369:     esac
                    370:     shift
                    371: done
                    372: 
                    373: if [ -n "$opt_h" ]; then
                    374:     usage
                    375: fi
                    376: 
1.13      tnn       377: if [ -n "$opt_s" ]; then
                    378:     UNSAFE_VAR=unsafe_depends_strict
                    379: else
                    380:     UNSAFE_VAR=unsafe_depends
                    381: fi
                    382: 
1.25      sno       383: MAKE="${MAKE}${MAKE_VAR_SEP}${MAKE_VAR}"
                    384: 
1.26      tnn       385: SUCCEEDED=""
1.22      sno       386: FAILED=""
                    387: 
1.1       gdt       388: MISMATCH_TODO=
1.41      rhialto   389: if [ -n "$opt_u" ]; then
1.1       gdt       390:     echo "${OPI} Checking for mismatched installed packages using pkg_chk"
                    391:     MISMATCH_TODO=$(check_packages_mismatched)
1.41      rhialto   392: else
                    393:     echo "${OPI} Checking for mismatched installed packages (mismatch=YES)"
                    394:     MISMATCH_TODO=$(check_packages_w_flag 'mismatch')
1.1       gdt       395: fi
                    396: 
1.41      rhialto   397: echo "${OPI} Excluding the following mismatched packages:"
                    398: echo "${OPC} EXCLUDE=[$EXCLUDE]"
                    399: MISMATCH_TODO=$(exclude $EXCLUDE --from $MISMATCH_TODO)
                    400: 
1.22      sno       401: if [ -z "$opt_F" ]; then
                    402:     echo "${OPI} Checking for rebuild-requested installed packages (rebuild=YES)"
                    403:     REBUILD_TODO=$(check_packages_w_flag 'rebuild')
1.1       gdt       404: 
1.22      sno       405:     echo "${OPI} Checking for unsafe installed packages (${UNSAFE_VAR}=YES)"
                    406:     UNSAFE_TODO=$(check_packages_w_flag ${UNSAFE_VAR})
                    407: fi
1.1       gdt       408: 
                    409: # DEPGRAPH_INSTALLED is rebuilt each round.  DEPGRAPH_SRC will collect
                    410: # edges that we discover using 'make show-depends', but that weren't
                    411: # listed as depends by the installed version of a package, and
                    412: # DEPENDS_CHECKED lists packages for which we've already done that
                    413: # check.
                    414: DEPGRAPH_INSTALLED=
                    415: DEPGRAPH_SRC=
                    416: DEPENDS_CHECKED=
                    417: 
1.22      sno       418: todo
1.1       gdt       419: 
                    420: depgraph_built=0
                    421: 
                    422: while [ -n "$REPLACE_TODO" ]; do
1.22      sno       423:     fail=
                    424: 
1.1       gdt       425:     # don't rebuild depgraph if we continued from new-depends step below
                    426:     if [ "$depgraph_built" -eq 0 ]; then
                    427:         echo "${OPI} Building dependency graph for installed packages"
                    428:         DEPGRAPH_INSTALLED=$(depgraph_installed)
                    429:         depgraph_built=1
                    430:     fi
                    431: 
                    432:     echo "${OPI} Tsorting dependency graph"
                    433:     TSORTED=$(echo $DEPGRAPH_INSTALLED $DEPGRAPH_SRC | tsort)
1.29      gdt       434:     pkgdir=
1.1       gdt       435:     for pkg in $TSORTED; do
                    436:         if is_member $pkg $REPLACE_TODO; then
1.29      gdt       437:            pkgdir=$(${PKG_INFO} -Q PKGPATH $pkg)
1.40      gdt       438:            if [ -n "$pkgdir" ]; then
                    439:                break;
                    440:            else
                    441:                error "Couldn't extract PKGPATH from installed package $pkg"
                    442:            fi
1.1       gdt       443:         fi
                    444:     done
1.29      gdt       445:     # loop should never exit without selecting a package
                    446:     [ -n "$pkgdir" ] || abort "pkg_chk reports the following packages need replacing, but they are not installed: $REPLACE_TODO"
1.26      tnn       447: 
1.1       gdt       448:     echo "${OPI} Selecting $pkg ($pkgdir) as next package to replace"
                    449:     sleep 1
                    450: 
                    451:     # Newer versions in pkgsrc sometimes have more depends than are
                    452:     # recorded for the installed version (this is entirely to be
                    453:     # expected as packages are split, renamed, and add new features).
                    454:     # When this happens, add the new edges to the graph and re-tsort.
                    455:     # Don't re-tsort if the new edges were already installed once
                    456:     # (otherwise we'll go into a loop).
                    457: 
                    458:     # XXX I'm not sure that DEPENDS_CHECKED is necessary, or whether
                    459:     # simply ignoring new deps that aren't in $REPLACE_TODO would have
                    460:     # been sufficient.  The DEPENDS_CHECKED approach causes one extra
                    461:     # tsort in some cases, which isn't overly expensive.
                    462: 
                    463:     # XXX After tsorting and choosing what to 'make replace', we
                    464:     # filter out packages that aren't already installed and marked for
                    465:     # replacement.  This is safe, since uninstalled depends will be
                    466:     # pulled in automatically by 'make replace'; but in rare cases it
                    467:     # might be non-optimal, leading to a duplicate rebuild that we
                    468:     # would have avoided had we selected the uninstalled package in
                    469:     # tsorted order and run 'make install' on it.  This seems like
                    470:     # such a rare case that the added complexity isn't worth it.
                    471: 
1.30      gdt       472:     # Set PKGNAME_REQD to give underlying make processes a chance to
                    473:     # set options derived from the package name.  For example,
                    474:     # the appropriate version of Python can be derived from the
1.35      wiz       475:     # package name (so, when building py34-foo, use python-3.4,
1.33      wiz       476:     # not python-2.7).
1.32      gdt       477:     MAKE_SET_VARS="PKGNAME_REQD=${pkg}-*"
1.30      gdt       478: 
1.1       gdt       479:     if ! is_member $pkg $DEPENDS_CHECKED; then
                    480:        echo "${OPI} Checking if $pkg has new depends..."
1.12      tnn       481:        OLD_DEPENDS=$(${PKG_INFO} -Nq $pkg | sed 's/-[0-9][^-]*$//')
1.1       gdt       482:        NEW_DEPENDS=
                    483:        cd "$PKGSRCDIR/$pkgdir"
1.31      obache    484:        bdeps=$(@SETENV@ ${MAKE_SET_VARS} ${MAKE} show-depends VARNAME=BUILD_DEPENDS)
1.37      gdt       485:        tdeps=$(@SETENV@ ${MAKE_SET_VARS} ${MAKE} show-depends VARNAME=TOOL_DEPENDS)
1.31      obache    486:        rdeps=$(@SETENV@ ${MAKE_SET_VARS} ${MAKE} show-depends)
1.37      gdt       487:        for depver in $bdeps $tdeps $rdeps; do
1.10      tnn       488:            dep=$(echo $depver | sed -e 's/[:[].*$/0/' -e 's/[<>]=/-/' \
                    489:                -e 's/-[0-9][^-]*$//')
1.1       gdt       490:            if ! is_member $dep $OLD_DEPENDS $NEW_DEPENDS; then
                    491:                NEW_DEPENDS="$NEW_DEPENDS $dep"
                    492:                DEPGRAPH_SRC="$DEPGRAPH_SRC $dep $pkg"
                    493:            fi
                    494:        done
                    495:        DEPENDS_CHECKED="$DEPENDS_CHECKED $pkg"
                    496:        if [ -n "$NEW_DEPENDS" ]; then
                    497:            echo "${OPI} $pkg has the following new depends (need to re-tsort):"
                    498:            echo "${OPC} [$(echo $NEW_DEPENDS)]"
                    499:            sleep 2
                    500:            continue
                    501:        fi
                    502:     fi
                    503: 
1.22      sno       504:     pkgname=$(${PKG_INFO} -e $pkg)
                    505:     if [ -n "$LOGPATH" ]; then
                    506:         logdir="$LOGPATH/`dirname $pkgdir`"
                    507:         logfile="$logdir/$pkgname"
                    508:         @MKDIR@ "$logdir" || abort "mkdir -p '$logdir' failed"
                    509:         exec 3>"$logfile"
                    510:         tail -f "$logfile" &
                    511:         TAILPID=$!
                    512:     fi
                    513: 
1.1       gdt       514:     # Do make replace, with clean before, and package and clean afterwards.
1.13      tnn       515:     fail=
1.23      sno       516:     if [ -d "$PKGSRCDIR/$pkgdir" ]; then
                    517:        cd "$PKGSRCDIR/$pkgdir";
1.22      sno       518:     else
1.36      gdt       519:        fail=1
1.26      tnn       520:         mark_as_failed $pkg
                    521:        error "No package directory '$pkgdir' for $pkg."
1.22      sno       522:     fi
1.23      sno       523: 
                    524:     if [ -z "$fail" ]; then
                    525:        if [ -z "$opt_F" ]; then
                    526:            echo "${OPI} Replacing $pkgname"
1.31      obache    527:            cmd="@SETENV@ ${MAKE_SET_VARS} ${MAKE} clean || fail=1"
1.23      sno       528:            if [ -n "$opt_n" ]; then
                    529:                echo "${OPI} Would run: $cmd"
                    530:            else
                    531:                if [ -n "$logfile" ]; then
                    532:                    eval "$cmd" >&3 2>&3
                    533:                else
                    534:                    eval "$cmd"
                    535:                fi
                    536:                if [ -n "$fail" ]; then
1.26      tnn       537:                     mark_as_failed $pkg
                    538:                    error "'make clean' failed for package $pkg."
1.23      sno       539:                fi
                    540:            fi
1.31      obache    541:            cmd="@SETENV@ ${MAKE_SET_VARS} ${MAKE} replace || fail=1" # XXX OLDNAME= support? xmlrpc-c -> xmlrpc-c-ss
1.23      sno       542:        else
                    543:            echo "${OPI} Fetching $pkgname"
1.31      obache    544:            cmd="@SETENV@ ${MAKE_SET_VARS} ${MAKE} fetch depends-fetch || fail=1"
1.23      sno       545:        fi
                    546:     fi
                    547: 
1.22      sno       548:     if [ -n "$opt_n" -a -z "$fail" ]; then
1.13      tnn       549:        echo "${OPI} Would run: $cmd"
1.22      sno       550:     elif [ -z "$fail" ]; then
                    551:         if [ -n "$logfile" ]; then
                    552:             eval "$cmd" >&3 2>&3
                    553:         else
                    554:             eval "$cmd"
                    555:         fi
                    556:        if [ -n "$fail" ]; then
1.26      tnn       557:             mark_as_failed $pkg
                    558:             error "'make replace' failed for package $pkg."
1.22      sno       559:         fi
1.13      tnn       560:     fi
1.22      sno       561:     if [ -z "$opt_n" -a -z "$opt_k" -a -z "$opt_F" ]; then
1.13      tnn       562:        [ -z "$(${PKG_INFO} -Q unsafe_depends_strict $pkg)" ] || \
                    563:            abort "package $pkg still has unsafe_depends_strict."
                    564:        [ -z "$(${PKG_INFO} -Q unsafe_depends $pkg)" ] || \
                    565:            abort "package $pkg still has unsafe_depends."
                    566:        [ -z "$(${PKG_INFO} -Q rebuild $pkg)" ] || \
                    567:            abort "package $pkg is still requested to be rebuilt."
1.41      rhialto   568:        [ -z "$(${PKG_INFO} -Q mismatch $pkg)" ] || \
                    569:            abort "package $pkg is still a mismatched version."
1.1       gdt       570:     fi
1.18      gdt       571:     # If -r not given, make a binary package.
1.22      sno       572:     if [ -z "$opt_r" -a -z "$fail" -a -z "$opt_F" ]; then
1.13      tnn       573:        echo "${OPI} Packaging $(${PKG_INFO} -e $pkg)"
1.31      obache    574:        cmd="@SETENV@ ${MAKE_SET_VARS} ${MAKE} package || fail=1"
1.22      sno       575:        if [ -n "$opt_n" -a -z "$fail" ]; then
1.13      tnn       576:            echo "${OPI} Would run: $cmd"
1.22      sno       577:        elif [ -z "$fail" ]; then
                    578:             if [ -n "$logfile" ]; then
                    579:                 eval "$cmd" >&3 2>&3
                    580:             else
                    581:                 eval "$cmd"
                    582:             fi
                    583:             if [ -n "$fail" ]; then
1.26      tnn       584:                 mark_as_failed $pkg
                    585:                 error "'make package' failed for package $pkg."
1.22      sno       586:             fi
1.13      tnn       587:        fi
1.1       gdt       588:     fi
1.18      gdt       589:     # Clean
1.22      sno       590:     if [ -z "$opt_n" -a -z "$fail" -a -z "$opt_F" ]; then
1.31      obache    591:         cmd="@SETENV@ ${MAKE_SET_VARS} ${MAKE} clean || fail=1"
1.22      sno       592:         if [ -n "$logfile" ]; then
                    593:             eval "$cmd" >&3 2>&3
                    594:         else
                    595:             eval "$cmd"
                    596:         fi
                    597:        if [ -n "$fail" ]; then
1.26      tnn       598:             mark_as_failed $pkg
                    599:             error "'make clean' failed for package $pkg."
1.22      sno       600:         fi
                    601:     fi
                    602: 
                    603:     if [ -z "$fail" ]; then
1.26      tnn       604:         mark_as_succeeded $pkg
1.18      gdt       605:     fi
                    606: 
1.1       gdt       607:     sleep 1
                    608: 
                    609:     # remove just-replaced package from all *_TODO lists
                    610:     MISMATCH_TODO=$(exclude $pkg --from $MISMATCH_TODO)
                    611:     REBUILD_TODO=$(exclude $pkg --from $REBUILD_TODO)
                    612:     UNSAFE_TODO=$(exclude $pkg --from $UNSAFE_TODO)
                    613: 
1.13      tnn       614:     echo "${OPI} Re-checking for unsafe installed packages (${UNSAFE_VAR}=YES)"
1.1       gdt       615:     if [ -n "$opt_n" ]; then
                    616:        # With -n, the replace didn't happen, and thus the packages that would
                    617:        # have been marked unsafe_depends=YES were not.  Add the set that
                    618:        # would have been marked so we can watch what pkg_rolling-replace
                    619:        # would have done (approximately).
                    620:         UNSAFE_TODO=$(uniqify $UNSAFE_TODO \
                    621:             $(who_requires $pkg --in-graph $DEPGRAPH_INSTALLED))
                    622:         sleep 1
                    623:     else
1.13      tnn       624:         UNSAFE_TODO=$(check_packages_w_flag ${UNSAFE_VAR})
1.1       gdt       625:     fi
                    626: 
1.22      sno       627:     depgraph_built=0
                    628: 
                    629:     todo
                    630:     vsleep 2
1.1       gdt       631: 
1.22      sno       632:     if [ -n "$logfile" ]; then
                    633:         exec 3>&-
                    634:         kill $TAILPID
                    635:     fi
1.1       gdt       636: done
                    637: 
                    638: echo "${OPI} No more packages to replace; done."
1.22      sno       639: 
                    640: report

CVSweb <webmaster@jp.NetBSD.org>