WebSVN – DevTools – /deployfiles/trunk/src/deployfiles/i.none

#set -x
# This class action script copies the files being replaced
# into a package being constructed in $BUILD_DIR. This class
# action script is only appropriate for regular files that
# are installed by simply copying them into place.
#
# For special package objects such as edittable files, the patch
# producer must supply appropriate class action scripts.
#
# directory format options.
#
#       @(#)i.script 1.13 99/11/17 SMI
#
# Copyright (c) 1995 by Sun Microsystems, Inc.
# All rights reserved
#


# -------------------------------------------------------------------------------------
_processLibFile ()
#
#    A project speccific function to process a library item detected in 
#    the delivere prototype file.
#
#    Input: src, dst
#
# -------------------------------------------------------------------------------------
{
    SRC=$1

    m_base=`basename $SRC`
    m_libNameNoVersion=`perl -e '$item=$ARGV[0]; $item =~ s/\.so.*$/\.so/; printf("$item")' -- $m_base`
    m_libNameNoVersionOrBuildType=`perl -e '$item=$ARGV[0]; $item =~ s/D\.so.*$|P\.so.*$/\.so/; printf("$item")' -- $m_base`

    # now we need to detemrine what we were previously linked to
    # in the app dir.
    #
    if [ -f  "$m_libNameNoVersionOrBuildType" ]
    then
        m_tmp=`ls -l $m_libNameNoVersionOrBuildType | tr -s " "`
        m_previousLibNameSrc=`echo $m_tmp | cut -f11 -d" "`
    else
        m_previousLibNameSrc=none
    fi

    # lets now record what we have done so we can back out
    #
    if [ ! -f "$M_BACKOUT_SCRIPT" ]
    then
        echo "#!/bin/sh" > $M_BACKOUT_SCRIPT
        echo "set -x"    >> $M_BACKOUT_SCRIPT
    fi

    if [ ! -f "$M_POSTPATCH_SCRIPT" ]
    then
        echo "#!/bin/sh" >  $M_POSTPATCH_SCRIPT
        echo "set -x"    >> $M_POSTPATCH_SCRIPT
    fi


    echo "# -------------------------------------------------------------------------------------------------" >> $M_BACKOUT_SCRIPT
    echo "# lets backout lib file, from=[$m_base] to=[$m_previousLibNameSrc]" >> $M_BACKOUT_SCRIPT

    echo "# -------------------------------------------------------------------------------------------------" >> $M_POSTPATCH_SCRIPT
    echo "# lets postpatch lib file, to=[$m_base] from=[$m_previousLibNameSrc]" >> $M_POSTPATCH_SCRIPT


    if [ "x$m_previousLibNameSrc" = "xnone" ]
    then

        echo "no history for item [$m_base]."

        # deal with items in the app dir
        #
        echo "installf -c none $PKGINST $M_APPLIB_DIR/$m_libNameNoVersion=$m_base s" >> $M_POSTPATCH_SCRIPT
        echo "installf -c none $PKGINST $M_APPLIB_DIR/$m_libNameNoVersionOrBuildType=$m_base s" >> $M_POSTPATCH_SCRIPT

        echo "removef $PKGINST $M_APPLIB_DIR/$m_libNameNoVersion"            >> $M_BACKOUT_SCRIPT
        echo "rm -f            $M_APPLIB_DIR/$m_libNameNoVersion"            >> $M_BACKOUT_SCRIPT

        echo "removef $PKGINST $M_APPLIB_DIR/$m_libNameNoVersionOrBuildType" >> $M_BACKOUT_SCRIPT
        echo "rm -f            $M_APPLIB_DIR/$m_libNameNoVersionOrBuildType" >> $M_BACKOUT_SCRIPT

        # create common items by default ...
        #
        echo "installf -c none $PKGINST $M_BASELIB_DIR/$m_base=$M_APPLIB_DIR/$m_base s" \
             >> $M_POSTPATCH_SCRIPT

        echo "installf -c none $PKGINST $M_BASELIB_DIR/$m_libNameNoVersion=$M_APPLIB_DIR/$m_base s" \
             >> $M_POSTPATCH_SCRIPT


# Not required. To be removed.
#        echo "installf -c none $PKGINST $M_BASELIB_DIR/$m_libNameNoVersionOrBuildType=$M_APPLIB_DIR/$m_base s" \
#             >> $M_POSTPATCH_SCRIPT


        echo "removef $PKGINST $M_BASELIB_DIR/$m_libNameNoVersion"            >> $M_BACKOUT_SCRIPT
        echo "rm -f            $M_BASELIB_DIR/$m_libNameNoVersion"            >> $M_BACKOUT_SCRIPT

        echo "removef $PKGINST $M_BASELIB_DIR/$m_libNameNoVersionOrBuildType" >> $M_BACKOUT_SCRIPT
        echo "rm -f            $M_BASELIB_DIR/$m_libNameNoVersionOrBuildType" >> $M_BACKOUT_SCRIPT


# Not required. To be removed.
#        echo "removef $PKGINST $M_BASELIB_DIR/$m_base"                        >> $M_BACKOUT_SCRIPT
#        echo "rm -f            $M_BASELIB_DIR/$m_base"                        >> $M_BACKOUT_SCRIPT


    else
       
        # we have history.

        # deal with items in the app dir
        #
        _removeItem $M_APPLIB_DIR/$m_libNameNoVersion

        _linkItem   $m_base \
                    $m_libNameNoVersion \
                    $m_previousLibNameSrc \
                    $M_APPLIB_DIR

        _removeItem $M_APPLIB_DIR/$m_libNameNoVersionOrBuildType

        _linkItem   $m_base \
                    $m_libNameNoVersionOrBuildType \
                    $m_previousLibNameSrc \
                    $M_APPLIB_DIR

        # deal with common items if they exist ...
        #
        if [ -f "$M_BASELIB_DIR/$m_libNameNoVersion" ]
        then
             _removeItem $M_BASELIB_DIR/$m_libNameNoVersion
    
             _linkItem   $M_APPLIB_DIR/$m_base \
                         $m_libNameNoVersion \
                         $M_APPLIB_DIR/$m_previousLibNameSrc \
                         $M_BASELIB_DIR
        fi

        if [ -f "$M_BASELIB_DIR/$m_libNameNoVersionOrBuildType" ]
        then
             _removeItem $M_BASELIB_DIR/$m_libNameNoVersionOrBuildType
    
             _linkItem   $M_APPLIB_DIR/$m_base \
                         $m_libNameNoVersionOrBuildType \
                         $M_APPLIB_DIR/$m_previousLibNameSrc \
                         $M_BASELIB_DIR
        fi


# Not required, as we do not have any of these links in the baseDir/lib
# To be removed.
#
#        if [ -f "$M_BASELIB_DIR/$m_previousLibNameSrc" ]
#        then
#
#            echo "removef $PKGINST $M_BASELIB_DIR/$m_previousLibNameSrc" >> $M_POSTPATCH_SCRIPT
#            echo "rm -f            $M_BASELIB_DIR/$m_previousLibNameSrc" >> $M_POSTPATCH_SCRIPT
#
#            echo "installf -c none $PKGINST $M_BASELIB_DIR/$m_base=$M_APPLIB_DIR/$m_base s" \
#                 >> $M_POSTPATCH_SCRIPT
#
#            echo "removef $PKGINST $M_BASELIB_DIR/$m_base"                        >> $M_BACKOUT_SCRIPT
#            echo "rm -f            $M_BASELIB_DIR/$m_base"                        >> $M_BACKOUT_SCRIPT
#
#            echo "installf -c none $PKGINST $M_BASELIB_DIR/$m_previousLibNameSrc=$M_APPLIB_DIR/$m_previousLibNameSrc s" \
#                 >> $M_BACKOUT_SCRIPT
#
#        fi

    fi
}

_removeItem ()
{
    echo "rm -f $1"
    rm -f $1
    echo "rm -f $1" >> $M_BACKOUT_SCRIPT
}

_linkItem ()
{
    m_pwd=`pwd`

    cd $4
    echo "ln -s $1 $2"
    ln -s $1 $2 

    if [ "x$3" != "xnone" ]
    then
        echo "cd $4" >> $M_BACKOUT_SCRIPT
        echo "ln -s $3 $2" >> $M_BACKOUT_SCRIPT
    fi

    cd $m_pwd
}


PATH=/usr/sadm/bin:$PATH

ECHO="/usr/bin/echo"
SED="/usr/bin/sed"
PKGPROTO="/usr/bin/pkgproto"
EXPR="/usr/bin/expr"    # used by dirname
MKDIR="/usr/bin/mkdir"
CP="/usr/bin/cp"
RM="/usr/bin/rm"
MV="/usr/bin/mv"

recovery="no"
Pn=$$
procIdCtr=0

CMDS_USED="$ECHO $SED $PKGPROTO $EXPR $MKDIR $CP $RM $MV"
LIBS_USED=""

if [ "$PKG_INSTALL_ROOT" = "/" ]; then
        PKG_INSTALL_ROOT=""
fi

# Check to see if this is a patch installation retry.
if [ "$INTERRUPTION" = "yes" ]; then
        if [ -d "$PKG_INSTALL_ROOT/var/tmp/$SUNW_PATCHID.$PKGINST" ] || [ -d "$PATCH_BUILD_DIR/$SUNW_PATCHID.$PKGINST" ]; then
                recovery="yes"
        fi
fi

if [ -n "$PATCH_BUILD_DIR" -a -d "$PATCH_BUILD_DIR" ]; then
        BUILD_DIR="$PATCH_BUILD_DIR/$SUNW_PATCHID.$PKGINST"
else
        BUILD_DIR="$PKG_INSTALL_ROOT/var/tmp/$SUNW_PATCHID.$PKGINST"
fi

FILE_DIR=$BUILD_DIR/files
RELOC_DIR=$FILE_DIR/reloc
ROOT_DIR=$FILE_DIR/root
BO_Deletes=$FILE_DIR/deletes
PROGNAME=`basename $0`


# 31-July-2002 VC: added these variable, required to generate the postbackout script.
#
M_PATCHDB=/var/sadm/patch
M_PKGINST_LC=`echo $PKGINST | tr -s '[A-Z]' '[a-z]'`
M_APPLIB_DIR="$BASEDIR/$M_PKGINST_LC/lib"
M_BASELIB_DIR="$BASEDIR/lib"
M_BACKOUT_SCRIPT="$M_PATCHDB/$SUNW_PATCHID/postbackout"
M_POSTPATCH_SCRIPT="$M_PATCHDB/$SUNW_PATCHID/postpatch"

if [ "$PATCH_PROGRESSIVE" = "true" ]; then
        PATCH_NO_UNDO="true"
fi

# Since this is generic, figure out the class.
Class=`echo $PROGNAME | nawk ' { print substr($0, 3)  }'`

# Since this is an update, $BASEDIR is guaranteed to be correct
BD=${BASEDIR:-/}

cd $BD

#
# First, figure out the dynamic libraries that can trip us up.
#
if [ -z "$PKG_INSTALL_ROOT" ]; then
        if [ -x /usr/bin/ldd ]; then
                LIB_LIST=`/usr/bin/ldd $CMDS_USED | sort -u | nawk '
                        $1 ~ /\// { continue; }
                        { printf "%s ", $3 } '`
        else
                LIB_LIST="/usr/lib/libc.so.1 /usr/lib/libdl.so.1 /usr/lib/libw.so.1 /usr/lib/libintl.so.1 /usr/lib/libgen.so.1 /usr/lib/libadm.so.1 /usr/lib/libelf.so.1"
        fi
fi

#
# Now read the list of files in this class to be replaced. If the file
# is already in place, then this is a change and we need to copy it
# over to the build directory if undo is allowed. If it's a new entry
# (No $dst), then it goes in the deletes file for the backout package.
#

LD_LIB_DIR=$PKG_INSTALL_ROOT/var/tmp/LDLIB.$$

procIdCtr=0
while read src dst; do
        if [ -z "$PKG_INSTALL_ROOT" ]; then
                Chk_Path=$dst
                for library in $LIB_LIST; do
                        if [ "$Chk_Path" = "$library" ]; then
                                if [ ! -d "$LD_LIB_DIR" ]; then
                                        $MKDIR $LD_LIB_DIR
                                fi
                                $CP $dst $LD_LIB_DIR
                                LD_LIBRARY_PATH=$LD_LIB_DIR
                                export LD_LIBRARY_PATH
                        fi
                done
        fi

        if [ "$PATCH_PROGRESSIVE" = "true" ]; then
                # If this is being used in an old-style patch, insert
                # the old-style script commands here.

                #XXXOld_CommandsXXX#
                echo >/dev/null # dummy
        fi

        if [ "${PATCH_NO_UNDO}" != "true" ]; then
                #
                # Here we construct the path to the appropriate source
                # tree for the build. First we try to strip BASEDIR. If
                # there's no BASEDIR in the path, we presume that it is
                # absolute and construct the target as an absolute path
                # by stripping PKG_INSTALL_ROOT. FS_Path is the path to
                # the file on the file system (for deletion purposes).
                # Build_Path is the path to the object in the build
                # environment.
                #
                # The following rootPath variable accounts for a BASEDIR
                # that is used as a regular variable within the path and
                # not as a variable that a path needs to be relocated to.

                rootPath=`$ECHO $src | $SED s@"$INST_DATADIR/$PKGINST"@@ | \
                        nawk -F/ '{print $2}'`
                if [ "$rootPath" = "root" ]; then
                        FS_Path=$dst
                elif [ "$BD" = "/" ]; then
                        FS_Path=`$ECHO $dst | $SED s@"$BD"@@`
                else
                        FS_Path=`$ECHO $dst | $SED "s|$BD/||"`
                fi

                # If it's an absolute path the attempt to strip the
                # BASEDIR will have failed.
                if [ "$dst" = "$FS_Path" ]; then
                        if [ -z "$PKG_INSTALL_ROOT" ]; then
                                FS_Path=$dst
                                Build_Path="$ROOT_DIR$dst"
                        else
                                Build_Path="$ROOT_DIR"`echo $dst | \
                                    $SED "s|$PKG_INSTALL_ROOT||"`
                                FS_Path=`echo $dst | \
                                    $SED "s|$PKG_INSTALL_ROOT||"`
                        fi
                else
                        Build_Path="$RELOC_DIR/$FS_Path"
                fi

                if [ -f "$dst" ]; then  # If this is replacing something
                        cd $FILE_DIR
                        #
                        # Construct the prototype file entry. We replace
                        # the pointer to the filesystem object with the
                        # build directory object.
                        #
                        $PKGPROTO -c $Class $dst=$FS_Path | \
                            $SED -e "s|=$dst|=$Build_Path|" >> \
                            $BUILD_DIR/prototype

                        # Now copy over the file
                        if [ "$recovery" = "no" ]; then
                                DirName=`dirname $Build_Path`
                                $MKDIR -p $DirName
                                $CP -p $dst $Build_Path
                        else
                                # If this file is already in the build area skip it
                                if [ -f "$Build_Path" ]; then
                                        cd $BD
                                        continue
                                else
                                        DirName=`dirname $Build_Path`
                                        if [ ! -d "$DirName" ]; then
                                                $MKDIR -p $DirName
                                        fi
                                        $CP -p $dst $Build_Path
                                fi
                        fi

                        cd $BD
                else    # It's brand new
                        $ECHO $FS_Path >> $BO_Deletes
                fi
        fi

        # If special processing is required for each src/dst pair,
        # add that here.
        #
        #XXXSpecial_CommandsXXX#
        #
        
        # we need to determine if the item is a lib file
        `perl -e '$ARGV[0] =~ m/\.so/ or exit(1);' -- $src`
        isLib=$?
        if [ "$isLib" -eq "0" ]
        then
            OLD_DIR=`pwd`
            cd $M_APPLIB_DIR
            _processLibFile $src
            cd $OLD_DIR
        fi


        $CP -p $src $dst.$$$procIdCtr
        if [ $? -ne 0 ]; then
                $RM $dst.$$$procIdCtr 1>/dev/null 2>&1
        else
                $MV -f $dst.$$$procIdCtr $dst
                for library in $LIB_LIST; do
                        if [ "$library" = "$dst" ]; then
                                unset $LD_LIBRARY_PATH
                        fi
                done
        fi
        procIdCtr=`expr $procIdCtr + 1`
done
 
# If additional operations are required for this package, place
# those package-specific commands here.

#XXXSpecial_CommandsXXX#
echo "removef -f $PKGINST"  >> $M_POSTPATCH_SCRIPT
echo "installf -f $PKGINST" >> $M_POSTPATCH_SCRIPT
echo "exit 0;"              >> $M_POSTPATCH_SCRIPT
chmod 755 $M_POSTPATCH_SCRIPT

echo "removef -f $PKGINST"  >> $M_BACKOUT_SCRIPT
echo "installf -f $PKGINST" >> $M_BACKOUT_SCRIPT
echo "exit 0;"              >> $M_BACKOUT_SCRIPT
chmod 755 $M_BACKOUT_SCRIPT

#
# Release the dynamic libraries
#
if [ -d "$LD_LIB_DIR" ]; then
        $RM -fr $LD_LIB_DIR
fi

exit 0
Subversion Repositories DevTools

(root)/deployfiles/trunk/src/deployfiles/i.none – Rev 1530
