Merge branch '2.8.3-ocf' of gitlab.ocf.co.uk:aali/xcat-core into 2.8.3-ocf

because on linux, if the named is already stopped, when we tried
to stop named, the return code is 0 with a warning message;
while on AIX, if the named is already stopped, when we tried to
stop named, the return code is 1, it's different with Linux.

README

@@ -1,9 +0,0 @@
-xCAT - eXtreme Cloud Administration Toolkit
-
-xCAT is a toolkit for the deployment and administration of clusters.
-
-xCAT documentation is available at: http://xcat.sourceforge.net/
-
-xCAT is made available as open source software under the EPL license:
-http://www.opensource.org/licenses/eclipse-1.0.php
-

Version

@@ -1 +1 @@
-2.7.6
+2.8.3ocf

build-debianrepo

@@ -0,0 +1,241 @@
+#!/bin/sh
+# Update GSA Ubuntu Repositories or create a local repository
+#
+# Author: Leonardo Tonetto (tonetto@linux.vnet.ibm.com)
+# Revisor: Arif Ali (aali@ocf.co.uk)
+#
+# After running this script, add the following line to
+# /etc/apt/sources.list for local repository
+# deb file://<core_repo_path>/xcat-core/ maverick main
+# deb file://<dep_repo_path>/xcat-dep/ maverick main
+# 
+
+# For the purpose of getting the distribution name
+
+# Supported distributions
+dists="squeeze"
+
+a_flag=            # automatic flag - only update if repo was updated
+c_flag=            # xcat-core (trunk-delvel) path
+d_flag=            # xcat-dep (trunk) path
+local_flag=        # build the repository localy
+
+while getopts 'c:d:u:p:l:a' OPTION
+do
+    case $OPTION in
+	c)    c_flag=1
+	        xcat_core_path="$OPTARG"
+	        ;;
+	d)    d_flag=1
+	        xcat_dep_path="$OPTARG"
+	        ;;
+	l)    local_flag=1
+	        local_repo_path="$OPTARG"
+	        ;;
+	a)    a_flag=1
+	        ;;
+
+	?) printf "Usage: %s -c <core_trunk_path> [-d <dep_trunk_path>] -l <local-repo_path> [-a]\n" $(basename $0) >&2
+	    echo "-a        Automatic: update only if there's any update on repo"
+	    exit 2
+	    ;;
+    esac
+done
+shift $(($OPTIND - 1))
+
+if [ -z "$c_flag" -a -z "$d_flag" ]
+then
+    printf "Usage: %s -c <core_trunk_path> [-d <dep_trunk_path>] { -l <local-repo_path> | [-u <gsa_id> -p <gsa_passwd>] } [-a]\n" $(basename $0) >&2
+    echo "-a        Automatic: update only if there's any update on repo"
+    exit 2
+fi
+if [ ! -d $xcat_core_path ]
+then
+    printf "%s: No such directory\n" "$xcat_core_path" >&2
+    exit 2
+fi
+
+if [ "$d_flag" ]
+then
+    if [ ! -d $xcat_dep_path ]
+    then
+	printf "%s: No such directory\n" "$xcat_dep_path" >&2
+	exit 2
+    fi
+fi
+
+if [ "$local_flag" ]
+then
+    repo_xcat_core_path=$local_repo_path"/xcat-core"
+    repo_xcat_dep_path=$local_repo_path"/xcat-dep"
+else
+    printf "Usage: %s -c <core_trunk_path> [-d <dep_trunk_path>] -l <local-repo_path> [-a]\n" $(basename $0) >&2
+    echo "-a        Automatic: update only if there's any update on repo"
+    exit 2
+fi
+
+if [ "$a_flag" ]
+then
+    touch svcupdate.trace
+    SVCUP='svcupdate.trace'
+    svn update $xcat_core_path 1> $SVCUP 2>&1
+    if ! grep 'Tree is up to date' $SVCUP
+    then
+	update_core=1
+    else
+	update_core=
+    fi
+    rm -f $SVCUP
+else
+    update_core=1
+fi
+if [ "$c_flag" -a "$update_core" ]
+then
+    echo "###############################"
+    echo "# Building xcat-core packages #"
+    echo "###############################"
+
+    CMD_PATH=`pwd`
+    cd $xcat_core_path
+    ./build-debs-all "snap" "Nightly_Builds"
+
+    echo "#################################"
+    echo "# Creating xcat-core repository #"
+    echo "#################################"
+
+    if [ -d $repo_xcat_core_path ]; then
+    	rm -rf $repo_xcat_core_path
+    fi
+    mkdir -p $repo_xcat_core_path/conf
+
+    find . -iname '*.deb' -exec mv {} $repo_xcat_core_path \;
+
+    rm -rf debs/
+    cd $CMD_PATH
+
+    rm -rf $repo_xcat_core_path/conf/distributions
+
+    for dist in $dists; do
+       cat << __EOF__ >> $repo_xcat_core_path/conf/distributions
+Origin: xCAT internal repository
+Label: xcat-core bazaar repository
+Codename: $dist
+Architectures: amd64 
+Components: main
+Description: Repository automatically genereted conf 
+
+__EOF__
+     done
+
+    cat << __EOF__ > $repo_xcat_core_path/conf/options
+verbose
+basedir .
+__EOF__
+
+    for dist in $dists; do
+      for file in `ls $repo_xcat_core_path/*.deb`; do
+	reprepro -b $repo_xcat_core_path includedeb $dist $file;
+      done
+    done
+
+    mv $xcat_core_path/latest_version $repo_xcat_core_path/xcat-core_latest-build
+
+    cat << '__EOF__' > $repo_xcat_core_path/mklocalrepo.sh
+codename=`lsb_release -a 2>null | grep Codename | awk '{print $2}'`
+cd `dirname $0`
+echo deb file://"`pwd`" $codename main > /etc/apt/sources.list.d/xcat-core.list
+__EOF__
+
+    chmod 775 $repo_xcat_core_path/mklocalrepo.sh
+    rm -rf $repo_xcat_core_path/*.deb
+
+    if [ -z "$local_flag" ]
+    then
+	echo "###############################"
+	echo "# Updating GSA xcat-core repo #"
+	echo "###############################"
+	lftp -e "mirror -R --delete-first $repo_xcat_core_path /projects/i/ipl-xcat/ubuntu/; exit;" -u $gsa_id,$gsa_passwd -p 22 sftp://ausgsa.ibm.com
+    fi   ### if [ -z "$local_flag" ]
+fi    ### if [ "$a_flag" ]
+
+if [ "$a_flag" -a "$d_flag" ]
+then
+    touch svcupdate.trace
+    SVCUP='svcupdate.trace'
+    svn update $xcat_dep_path 1> $SVCUP 2>&1
+    if ! grep 'Tree is up to date' $SVCUP
+    then
+	update_dep=1
+    else
+	update_dep=
+    fi
+    rm -f $SVCUP
+else
+    update_dep=1
+fi
+if [ "$d_flag" -a "$update_dep" ]
+then
+    echo "##############################"
+    echo "# Building xcat-dep packages #"
+    echo "##############################"
+
+    CMD_PATH=`pwd`
+    cd $xcat_dep_path
+    ./build-debs-all "snap" "Nightly_Builds"
+
+    echo "################################"
+    echo "# Creating xcat-dep repository #"
+    echo "################################"
+    rm -rf $repo_xcat_dep_path
+    mkdir -p $repo_xcat_dep_path/conf
+    find $xcat_dep_path -iname '*.deb' -exec cp {} $repo_xcat_dep_path \;
+
+    rm -rf $repo_xcat_core_path/conf/distributions
+
+    for dist in $dists; do
+    cat << __EOF__ >> $repo_xcat_dep_path/conf/distributions
+Origin: xCAT internal repository
+Label: xcat-dep bazaar repository
+Codename: $dist
+Architectures: amd64 
+Components: main
+Description: Repository automatically genereted conf 
+
+__EOF__
+done
+
+    cat << __EOF__ > $repo_xcat_dep_path/conf/options
+verbose
+basedir .
+__EOF__
+
+    for dist in $dists; do
+      for file in `ls $repo_xcat_dep_path/*.deb`; do
+	reprepro -b $repo_xcat_dep_path includedeb $dist $file;
+      done
+    done
+
+    cat << '__EOF__' > $repo_xcat_dep_path/mklocalrepo.sh
+codename=`lsb_release -a 2>null | grep Codename | awk '{print $2}'`
+cd `dirname $0`
+echo deb file://"`pwd`" $codename main > /etc/apt/sources.list.d/xcat-dep.list
+__EOF__
+
+    chmod 775 $repo_xcat_dep_path/mklocalrepo.sh
+    rm -rf $repo_xcat_dep_path/*.deb
+
+    if [ -z "$local_flag" ]
+    then
+	echo "##############################"
+	echo "# Updating GSA xcat-dep repo #"
+	echo "##############################"
+	lftp -e "mirror -R --delete-first $repo_xcat_dep_path /projects/i/ipl-xcat/ubuntu/; exit;" -u $gsa_id,$gsa_passwd -p 22 sftp://ausgsa.ibm.com
+    fi   ### if [ -z "$local_flag" ]
+fi   ### if [ "$d_flag" -a "$a_flag"]
+
+if [ -z "$local_flag" ]                 # delete the temp repo after upload is done
+then
+    rm -rf ./gsa-repo_temp
+fi
+
+exit 0

build-debs-all

@@ -6,6 +6,7 @@
 #
 # Author: Leonardo Tonetto <tonetto@linux.vnet.ibm.com>
 # Revisor: Adalberto Medeiros <adalbas@linux.vnet.ibm.com>
+# Revisor2: Arif Ali <aali@ocf.co.uk>
 #
 # Input:
 #
@@ -29,7 +30,7 @@ fi
 XCAT_VERSION=`cat Version`
 TRUNK_REVISION=`svnversion | cut -d ":" -f1`
 CUR_DATE=`date +%Y%m%d`
-VERSION="$XCAT_VERSION$PKG_LOCATION-rev$TRUNK_REVISION-$CUR_DATE"
+VERSION="${XCAT_VERSION}-${PKG_LOCATION}${CUR_DATE}"
 
 function makedeb {
 	SRC_ROOT=$1
@@ -47,7 +48,7 @@ function makedeb {
 	do
         	DIR=`echo ${DEBIAN_DIR} | sed -e 's/[/]debian$//'`
         	cd ${DIR}
-		dch -v $VERSION -c debian/changelog "$BUILD_STRING"
+		dch -v $VERSION -b -c debian/changelog "$BUILD_STRING"
         	dpkg-buildpackage
 		cd -
         	RC=$?
@@ -60,21 +61,19 @@ function makedeb {
 	#	
 	# Clean up
 	#
-	# Eliminate unnecessary directories and debian/files made by dpgk-buildpakcage
+	# Eliminate unnecessary directories and debian/files made by dpkg-buildpackage
 
 	find $SRC_ROOT -maxdepth 3 -type d -name "xcat-*" | grep debian | xargs rm -rf	
 	find $SRC_ROOT -maxdepth 3 -type f -name "files" | grep debian | xargs rm -f
 }
 
 # build all debian packages
-makedeb xCAT-client $PKG_LOCATION "$BUILD_STRING" $VERSION
-makedeb xCAT-nbroot $PKG_LOCATION "$BUILD_STRING" $VERSION
-makedeb perl-xCAT $PKG_LOCATION "$BUILD_STRING" $VERSION
-makedeb xCAT-server $PKG_LOCATION "$BUILD_STRING" $VERSION
-makedeb xCAT-UI $PKG_LOCATION "$BUILD_STRING" $VERSION
-makedeb xCAT $PKG_LOCATION "$BUILD_STRING" $VERSION
-makedeb xCATsn $PKG_LOCATION "$BUILD_STRING" $VERSION
-makedeb xCAT-test $PKG_LOCATION "$BUILD_STRING" $VERSION
+packages="xCAT-client xCAT-nbroot xCAT-nbroot2 perl-xCAT xCAT-server xCAT-UI xCAT xCATsn xCAT-test xCAT-IBMhpc xCAT-rmc"
+
+for file in `echo $packages`
+do
+    makedeb $file $PKG_LOCATION "$BUILD_STRING" $VERSION
+done
 
 if [ -d debs ]; then
 	rm -rf debs

build-ubunturepo

@@ -1,215 +1,418 @@
-#!/bin/sh
+#!/bin/bash
 # Update GSA Ubuntu Repositories or create a local repository
 #
 # Author: Leonardo Tonetto (tonetto@linux.vnet.ibm.com)
+# Revisor: Arif Ali (aali@ocf.co.uk)
 #
-# After running this script, add the following line to
-# /etc/apt/sources.list for local repository
-# deb file://<core_repo_path>/xcat-core/ maverick main
 # 
+# Getting Started:
+#  - Check out the xcat-core svn repository (either the trunk or a branch) into
+#    a dir called <rel>/src/xcat-core, where <rel> is the same as the release dir it will be
+#    uploaded to in sourceforge (e.g. devel, or 2.3).
+#  - You probably also want to put root's pub key from the build machine onto sourceforge for
+#    the upload user listed below, so you don't have to keep entering pw's.  You can do this
+#    at https://sourceforge.net/account/ssh
+#  - make sure reprepro is installed on the build machine
+#  - Run this script from the local svn repository you just created.  It will create the other directories that are needed.
+
+# Usage:  attr=value attr=value ... ./build-ubunturepo { -c | -d }
+#               PROMOTE=1 - if the attribute "PROMOTE" is specified, means an official dot release.  This does not
+#                                       actually build xcat, just uploads the most recent snap build to https://sourceforge.net/projects/xcat/files/xcat/ .
+#                                       If not specified, a snap build is assumed, which uploads to https://sourceforge.net/projects/xcat/files/yum/
+#                                       or https://sourceforge.net/projects/xcat/files/aix/.
+#               PREGA=1 - use this option with PROMOTE=1 on a branch that already has a released dot release, but this build is
+#                                       a GA candidate build, not to be released yet.  This will result in the tarball being uploaded to
+#                                       https://sourceforge.net/projects/xcat/files/yum/ or https://sourceforge.net/projects/xcat/files/aix/
+#                                       (but the tarball file name will be like a released tarball, not a snap build).  When you are ready to
+#                                       release this build, use PROMOTE=1 without PREGA
+#               BUILDALL=1 - build all rpms, whether they changed or not.  Should be used for snap builds that are in prep for a release.
+#               UP=0 or UP=1 - override the default upload behavior
+#
+# For the dependency packages 1. please run the build-debs-all in xcat-dep svn first( there is usage detail in that script)
+#                             2. run ./build-ubunturepo -d
+#
+############################
+printusage()
+{
+    printf "Usage: %s {-c | -d} \n" $(basename $0) >&2
+    echo "    -c : Build the xcat core packages and create the repo"
+    echo "    -d : Create the xcat dep repo. Building the xcat dep packages can refer \"build-debs-all\" from svn"
+}
+# For the purpose of getting the distribution name
+. /etc/lsb-release
+
+# Process cmd line variable assignments, assigning each attr=val pair to a variable of same name
+for i in $*; do
+        echo $i | grep '='
+        if [ $? != 0 ];then
+            continue
+        fi
+        # upper case the variable name
+        varstring=`echo "$i"|cut -d '=' -f 1|tr '[a-z]' '[A-Z]'`=`echo "$i"|cut -d '=' -f 2`
+        export $varstring
+done
+
+# Supported distributions
+dists="maverick natty oneiric precise"
 
-a_flag=            # automatic flag - only update if repo was updated
 c_flag=            # xcat-core (trunk-delvel) path
 d_flag=            # xcat-dep (trunk) path
-u_flag=            # gsa user-id
-p_flag=            # gsa passwd
-local_flag=        # build the repository localy
+r_flag=            #genesis base rpm package path
 
-while getopts 'c:d:u:p:l:a' OPTION
+while getopts 'cdr:' OPTION
 do
     case $OPTION in
 	c)    c_flag=1
-	        xcat_core_path="$OPTARG"
 	        ;;
 	d)    d_flag=1
-	        xcat_dep_path="$OPTARG"
 	        ;;
-	u)    u_flag=1
-	        gsa_id="$OPTARG"
-	        ;;
-	p)    p_flag=1
-	        gsa_passwd="$OPTARG"
-	        ;;
-	l)    local_flag=1
-	        local_repo_path="$OPTARG"
-	        ;;
-	a)    a_flag=1
-	        ;;
-
-	?) printf "Usage: %s -c <core_trunk_path> [-d <dep_trunk_path>] { -l <local-repo_path> | [-u <gsa_id> -p <gsa_passwd>] } [-a]\n" $(basename $0) >&2
-	    echo "-a        Automatic: update only if there's any update on repo"
+        r)    r_flag=1
+                genesis_rpm_path="$OPTARG"
+                ;;
+	?)  printusage 
 	    exit 2
 	    ;;
     esac
 done
 shift $(($OPTIND - 1))
 
-if [ -z "$c_flag" ]
-then
-    printf "Usage: %s -c <core_trunk_path> [-d <dep_trunk_path>] { -l <local-repo_path> | [-u <gsa_id> -p <gsa_passwd>] } [-a]\n" $(basename $0) >&2
-    echo "-a        Automatic: update only if there's any update on repo"
-    exit 2
-fi
-if [ ! -d $xcat_core_path ]
-then
-    printf "%s: No such directory\n" "$xcat_core_path" >&2
+if [ -z "$c_flag" -a -z "$d_flag" ];then
+    printusage
     exit 2
 fi
 
-if [ "$d_flag" ]
-then
-    if [ ! -d $xcat_dep_path ]
-    then
-	printf "%s: No such directory\n" "$xcat_dep_path" >&2
-	exit 2
-    fi
+if [ "$c_flag" -a "$d_flag" ];then
+    printusage
+    exit 2
 fi
 
-if [ "$local_flag" ]
-then
-    repo_xcat_core_path=$local_repo_path"/xcat-core"
-    repo_xcat_dep_path=$local_repo_path"/xcat-dep"
-else
-    if [ -z "$u_flag" ]
-    then
-	if [ "$p_flag" ]
-	then
-	    printf "Usage: %s -c <core_trunk_path> [-d <dep_trunk_path>] { -l <local-repo_path> | [-u <gsa_id> -p <gsa_passwd>] } [-a]\n" $(basename $0) >&2
-	    echo "-a        Automatic: update only if there's any update on repo"
-	    exit 2
-	fi
-	echo -n "GSA id: "
-	read gsa_id
-	echo -n "GSA password: "
-	stty -echo; read gsa_passwd; stty echo;
-	echo ""; echo "";
-    fi
+uploader="bp-sawyers"
+# Find where this script is located to set some build variables
+old_pwd=`pwd`
+cd `dirname $0`
+curdir=`pwd`
 
-    repo_xcat_core_path="`pwd`/gsa-repo_temp/xcat-core"
-    repo_xcat_dep_path="`pwd`/gsa-repo_temp/xcat-dep"
+#define the dep source code path, core build target path and dep build target path
+local_core_repo_path="$curdir/../../xcat-core"
+xcat_dep_path="$curdir/../../../xcat-dep/src/xcat-dep"
+local_dep_repo_path="$curdir/../../../xcat-dep/xcat-dep"
+
+#define the url used for creating the source list file
+#define the upload dir used for uploading packages
+sf_repo_url="https://sourceforge.net/projects/xcat/files/ubuntu"
+sf_dir="/home/frs/project/x/xc/xcat"
+
+#use flock to only one person build at the same time
+# Get a lock, so can not do 2 builds at once
+exec 8>/var/lock/xcatbld.lock
+if ! flock -n 8; then
+    echo "Can't get lock /var/lock/xcatbld.lock.  Someone else must be doing a build right now.  Exiting...."
+    exit 1
 fi
 
-if [ "$a_flag" ]
+export HOME=/root
+
+#sync the gpg key to the build machine local
+gsa_url=http://pokgsa.ibm.com/projects/x/xcat/build/linux
+mkdir -p $HOME/.gnupg
+for key_name in pubring.gpg secring.gpg trustdb.gpg; do
+    if [ ! -f $HOME/.gnupg/$key_name ] || [ `wc -c $HOME/.gnupg/$key_name|cut -f 1 -d' '` == 0 ]; then
+        rm -f $HOME/.gnupg/$key_name
+        wget -P $HOME/.gnupg $gsa_url/keys/$key_name
+        chmod 600 $HOME/.gnupg/$key_name
+    fi
+done
+
+if [ "$c_flag" ]
 then
-    touch svcupdate.trace
-    SVCUP='svcupdate.trace'
-    svn update $xcat_core_path 1> $SVCUP 2>&1
-    if ! grep 'Tree is up to date' $SVCUP
-    then
-	update_core=1
+    # strip the /src/xcat-core from the end of the dir to get the next dir up and use as the release
+    if [ -z "$REL" ]; then
+        t=${curdir%/src/xcat-core}
+        REL=`basename $t`
+    fi
+
+    ver=`cat Version`
+    if [ "$PROMOTE" != 1 ]; then
+        code_change=0
+        update_log=''
+        #get the version
+        if [ "$REL" = "xcat-core" ];then
+            git_flag=1
+            REL=`git rev-parse --abbrev-ref HEAD`
+            if [ "$REL" = "master" ]; then
+                REL="devel"
+            fi
+            if [ -z "$GITUP" ];then
+                update_log=../coregitup
+                echo "git pull > $update_log"
+                git pull > $update_log
+            else
+                update_log=$GITUP
+            fi
+
+            if ! grep -q  'Already up-to-date' $update_log; then
+                code_change=1
+            fi
+        else
+            git_flag=0
+            if [ -z "$SVNUP" ];	then
+                update_log=../coresvnup
+                echo "svn up > $update_log"
+                svn up > $update_log
+            else
+                update_log=$SVNUP
+            fi
+
+            if ! grep -q 'At revision' $update_log;then
+                code_change=1
+            fi
+        fi
+        ver=`cat Version`
+        short_ver=`cat Version|cut -d. -f 1,2`
+        short_short_ver=`cat Version|cut -d. -f 1`
+
+        package_dir_name=debs$REL
+        #TODO: define the core path and tarball name
+        tarball_name="core-debs-snap.tar.bz2"
+
+        if [ $code_change == 0 -a "$UP" != 1 -a "$BUILDALL" != 1 ]; then
+            echo "Nothing new detected"
+            exit 0
+        fi
+
+        echo "###############################"
+        echo "# Building xcat-core packages #"
+        echo "###############################"
+
+        #the package type:  local | snap | alpha
+        #the build introduce stirng
+        pkg_type="snap"
+        build_string="Snap_Build"
+        cur_date=`date +%Y%m%d`
+        pkg_version="${short_ver}-${pkg_type}${cur_date}"
+    
+        if [ ! -d ../../$package_dir_name ];then
+            mkdir -p "../../$package_dir_name"
+        fi
+        packages="xCAT-client xCAT-genesis-scripts perl-xCAT xCAT-server xCAT-UI xCAT xCATsn xCAT-test xCAT-OpenStack"
+
+        for file in `echo $packages`
+        do
+            file_low=`echo $file | tr '[A-Z]' '[a-z]'`
+            if grep -q $file $update_log || [ "$BUILDALL" == 1 -o "$file" = "perl-xCAT" ]; then
+                rm -f ../../$package_dir_name/${file_low}_*.deb
+                #only for genesis package
+                rm -f ../../$package_dir_name/${file_low}-amd64_*.deb
+                cd $file
+                dch -v $pkg_version -b -c debian/changelog $build_string
+                dpkg-buildpackage -uc -us
+                rc=$?
+                if [ $rc -gt 0 ]; then
+                    echo "Error: $file build package failed exit code $rc"
+                fi
+                cd -
+                find $file -maxdepth 3 -type d -name "${file_low}*" | grep debian | xargs rm -rf
+                find $file -maxdepth 3 -type f -name "files" | grep debian | xargs rm -rf
+                mv ${file_low}* ../../$package_dir_name/
+            fi
+        done
+
+        find ../../$package_dir_name/* ! -name *.deb | xargs rm -f
     else
-	update_core=
+        if [ "$REL" = "xcat-core" ];then
+            git_flag=1
+            REL=`git rev-parse --abbrev-ref HEAD`
+            if [ "$REL" = "master" ]; then
+                REL="devel"
+            fi
+        fi
+        package_dir_name=debs$REL
     fi
-    rm -f $SVCUP
-else
-    update_core=1
-fi
-if [ "$update_core" ]
-then
-    echo "###############################"
-    echo "# Building xcat-core packages #"
-    echo "###############################"
 
-    CMD_PATH=`pwd`
-    cd $xcat_core_path
-    ./build-debs-all "snap" "Nightly_Builds"
+    if [ "$PROMOTE" = 1 ]; then
+        upload_dir="xcat-core"
+        tar_name="xcat-core-$ver.tar.bz2"
+    else
+        upload_dir="core-snap"
+        tar_name="core-debs-snap.tar.bz2"
+    fi
 
     echo "#################################"
     echo "# Creating xcat-core repository #"
     echo "#################################"
 
-    if [ -d $repo_xcat_core_path ]; then
-    	rm -rdf $repo_xcat_core_path
+    #clean the repo directory
+    if [ -e $local_core_repo_path ]; then
+    	rm -rf $local_core_repo_path
     fi
-    mkdir -p $repo_xcat_core_path/conf
+    mkdir -p $local_core_repo_path
+    cd $local_core_repo_path
+    mkdir conf
 
-    find . -iname '*.deb' -exec mv {} $repo_xcat_core_path \;
-
-    rm -rdf debs/
-    cd $CMD_PATH
-
-    cat << __EOF__ > $repo_xcat_core_path/conf/distributions
+    for dist in $dists; do
+       cat << __EOF__ >> conf/distributions
 Origin: xCAT internal repository
 Label: xcat-core bazaar repository
-Codename: maverick
-Architectures: i386 amd64 
+Codename: $dist
+Architectures: amd64 
 Components: main
 Description: Repository automatically genereted conf 
-__EOF__
+SignWith: yes
 
-    cat << __EOF__ > $repo_xcat_core_path/conf/options
+__EOF__
+     done
+
+    cat << __EOF__ > conf/options
 verbose
+ask-passphrase
 basedir .
 __EOF__
 
-    for file in `ls $repo_xcat_core_path/*.deb`; do
-	reprepro -b $repo_xcat_core_path includedeb maverick $file;
+    #import the deb packages into the repo
+    for dist in $dists; do
+      for file in `ls ../$package_dir_name/*.deb`; do
+	reprepro -b ./ includedeb $dist $file;
+      done
     done
 
-    mv $xcat_core_path/latest_version $repo_xcat_core_path/xcat-core_latest-build
+    #create the mklocalrepo script
+    cat << __EOF__ > mklocalrepo.sh
+. /etc/lsb-release
+cd `dirname $0`
+echo deb file://"`pwd`" $DISTRIB_CODENAME main > /etc/apt/sources.list.d/xcat-core.list
+__EOF__
 
-    if [ -z "$local_flag" ]
-    then
-	echo "###############################"
-	echo "# Updating GSA xcat-core repo #"
-	echo "###############################"
-	lftp -e "mirror -R --delete-first $repo_xcat_core_path /projects/i/ipl-xcat/ubuntu/; exit;" -u $gsa_id,$gsa_passwd -p 22 sftp://ausgsa.ibm.com
-    fi   ### if [ -z "$local_flag" ]
-fi    ### if [ "$a_flag" ]
+    chmod 775 mklocalrepo.sh
 
-if [ "$a_flag" -a "$d_flag" ]
-then
-    touch svcupdate.trace
-    SVCUP='svcupdate.trace'
-    svn update $xcat_dep_path 1> $SVCUP 2>&1
-    if ! grep 'Tree is up to date' $SVCUP
-    then
-	update_dep=1
-    else
-	update_dep=
+    #create the xcat-core.list file 
+    #echo "deb ${sf_repo_url}/${REL}/${upload_dir}/ precise main" > xcat-core.list
+
+    cd ../
+    if ! grep xcat /etc/group ; then
+        groupadd xcat
+    fi     
+
+    chgrp -R root xcat-core
+    chmod -R g+w xcat-core
+
+    #build the tar ball
+    tar -hjcf $tar_name xcat-core
+    chgrp root $tar_name
+    chmod g+w $tar_name
+
+    if [ ! -e core-snap ]; then
+        ln -s xcat-core core-snap
     fi
-    rm -f $SVCUP
-else
-    update_dep=1
+
+    # Decide whether to upload or not
+    if [ -n "$UP" ] && [ "$UP" == 0 ]; then
+        echo "No need to upload"
+        cd $old_pwd
+        exit 0
+    fi
+
+    #upload the deb packages
+    if [ "$REL" = "devel" -o "$PREGA" != 1 ]; then
+        i=0
+        echo "Uploading RPMs from $upload_dir to ${sf_dir}/ubuntu/${REL}/ ..."
+        while [ $((i+=1)) -le 5 ] && ! rsync -urLv --delete $upload_dir ${uploader},xcat@web.sourceforge.net:${sf_dir}/ubuntu/${REL}/
+        do : ; done
+    fi
+
+    #upload the tar ball
+    #for the GA build, upload to https://sourceforge.net/projects/xcat/files/xcat/<version>.x_Ubuntu/
+    #for other scenario, upload to https://sourceforge.net/projects/xcat/files/ubuntu/<version>
+    if [ "$PROMOTE" = 1 -a "$REL" != "devel" -a "$PREGA" != 1 ]; then
+        i=0
+        echo "Uploading $tar_name to ${sf_dir}/xcat/${REL}.x_Ubuntu/ ..."
+        while [ $((i+=1)) -le 5 ] && ! rsync -v $tar_name ${uploader},xcat@web.sourceforge.net:${sf_dir}/xcat/${REL}.x_Ubuntu/
+        do : ; done
+    else
+        i=0
+        echo "Uploading $tar_name to ${sf_dir}/ubuntu/${REL}/ ..."
+        while [ $((i+=1)) -le 5 ] && ! rsync -v $tar_name ${uploader},xcat@web.sourceforge.net:${sf_dir}/ubuntu/${REL}/
+        do : ; done
+    fi
+    
+    cd $old_pwd   
 fi
-if [ "$d_flag" -a "$update_dep" ]
+
+if [ "$d_flag" ]
 then
     echo "################################"
     echo "# Creating xcat-dep repository #"
     echo "################################"
-    rm -rdf $repo_xcat_dep_path
-    mkdir -p $repo_xcat_dep_path/conf
-    find $xcat_dep_path -iname '*.deb' -exec cp {} $repo_xcat_dep_path \;
-    cat << __EOF__ > $repo_xcat_dep_path/conf/distributions
+
+    #clean all old files
+    if [ -e $local_dep_repo_path ];then
+        rm -rf $local_dep_repo_path
+    fi
+    mkdir -p $local_dep_repo_path
+    cd $local_dep_repo_path
+    mkdir conf
+
+    #create the conf/distributions file
+    for dist in $dists; do
+        cat << __EOF__ >> conf/distributions
 Origin: xCAT internal repository
 Label: xcat-dep bazaar repository
-Codename: maverick
-Architectures: i386 amd64 
+Codename: $dist
+Architectures: amd64 
 Components: main
 Description: Repository automatically genereted conf 
-__EOF__
+SignWith: yes
 
-    cat << __EOF__ > $repo_xcat_dep_path/conf/options
+__EOF__
+    done
+
+    cat << __EOF__ > conf/options
 verbose
+ask-passphrase
 basedir .
 __EOF__
 
-    for file in `ls $repo_xcat_dep_path/*.deb`; do
-	reprepro -b $repo_xcat_dep_path includedeb maverick $file;
+    for dist in $dists; do
+      for file in `ls ../debs/*.deb`; do
+	reprepro -b ./ includedeb $dist $file;
+      done
     done
 
-    if [ -z "$local_flag" ]
-    then
-	echo "##############################"
-	echo "# Updating GSA xcat-dep repo #"
-	echo "##############################"
-	lftp -e "mirror -R --delete-first $repo_xcat_dep_path /projects/i/ipl-xcat/ubuntu/; exit;" -u $gsa_id,$gsa_passwd -p 22 sftp://ausgsa.ibm.com
-    fi   ### if [ -z "$local_flag" ]
-fi   ### if [ "$d_flag" -a "$a_flag"]
+    cat << '__EOF__' > mklocalrepo.sh
+. /etc/lsb-release
+cd `dirname $0`
+echo deb file://"`pwd`" $DISTRIB_CODENAME main > /etc/apt/sources.list.d/xcat-dep.list
+__EOF__
 
-if [ -z "$local_flag" ]                 # delete the temp repo after upload is done
-then
-    rm -rdf ./gsa-repo_temp
+    chmod 775 mklocalrepo.sh
+
+    #echo ""deb ${sf_repo_url}/xcat-dep/ precise main"" > xcat-dep.list
+
+    cd ..
+    if ! grep xcat /etc/group ; then
+        groupadd xcat
+    fi
+
+    chgrp -R root xcat-dep
+    chmod -R g+w xcat-dep
+
+    #create the tar ball
+    dep_tar_name=xcat-dep-ubuntu.tar.bz
+    tar -hjcf $dep_tar_name xcat-dep
+    chgrp root $dep_tar_name
+    chmod g+w $dep_tar_name
+
+    if [ -n "$UP" ] && [ "$UP" == 0 ];then
+        echo "No need to upload the dep packages"
+        cd $old_pwd
+        exit 0
+    fi
+
+    #upload the dep packages
+    i=0
+    echo "Uploading debs from xcat-dep to ${sf_dir}/ubuntu/xcat-dep/ ..."
+    while [ $((i+=1)) -le 5 ] && ! rsync -urLv --delete xcat-dep ${uploader},xcat@web.sourceforge.net:${sf_dir}/ubuntu/
+         do : ; done
+    #upload the tarball
+    cd $old_pwd
 fi
-
 exit 0

buildcore.sh

@@ -19,14 +19,20 @@
 #    directories that are needed.
 
 # Usage:  buildcore.sh [attr=value attr=value ...]
-#		PROMOTE=1 - if the attribute "PROMOTE" is specified, means an official dot release.
-#					Otherwise, and snap build is assumed.
-#		PREGA=1 - means this is a branch that has not been released yet, so during the promote, copy the
-#					xcat-core tarball to the SF web site instead of the FRS area.
+#       Before running buildcore.sh, you must change the local git repo to the branch you want built, using: git checkout <branch>
+#		PROMOTE=1 - if the attribute "PROMOTE" is specified, means an official dot release.  This does not
+#					actually build xcat, just uploads the most recent snap build to https://sourceforge.net/projects/xcat/files/xcat/ .
+#					If not specified, a snap build is assumed, which uploads to https://sourceforge.net/projects/xcat/files/yum/
+#					or https://sourceforge.net/projects/xcat/files/aix/.
+#		PREGA=1 - use this option with PROMOTE=1 on a branch that already has a released dot release, but this build is
+#					a GA candidate build, not to be released yet.  This will result in the tarball being uploaded to
+#					https://sourceforge.net/projects/xcat/files/yum/ or https://sourceforge.net/projects/xcat/files/aix/
+#					(but the tarball file name will be like a released tarball, not a snap build).  When you are ready to
+#					release this build, use PROMOTE=1 without PREGA
 #		BUILDALL=1 - build all rpms, whether they changed or not.  Should be used for snap builds that are in prep for a release.
 # 		UP=0 or UP=1 - override the default upload behavior 
 # 		SVNUP=<filename> - control which rpms get built by specifying a coresvnup file
-#       FRSYUM=0 - put the yum repo and snap builds in the old project web area instead of the FRS area.
+# 		GITUP=<filename> - control which rpms get built by specifying a coregitup file
 #		EMBED=<embedded-environment> - the environment for which a minimal version of xcat should be built, e.g. zvm or flex
 #		VERBOSE=1 - to see lots of verbose output
 
@@ -34,6 +40,17 @@
 UPLOADUSER=bp-sawyers
 FRS=/home/frs/project/x/xc/xcat
 
+# These are the rpms that should be built for each kind of xcat build
+ALLBUILD="perl-xCAT xCAT-client xCAT-server xCAT-IBMhpc xCAT-rmc xCAT-UI xCAT-test xCAT-buildkit xCAT xCATsn xCAT-genesis-scripts xCAT-OpenStack"
+ZVMBUILD="perl-xCAT xCAT-server xCAT-UI"
+ZVMLINK="xCAT-client xCAT xCATsn"
+PCMBUILD="xCAT"
+PCMLINK="perl-xCAT xCAT-client xCAT-server xCAT-buildkit xCAT-genesis-scripts-x86_64"
+# Note: for FSM, the FlexCAT rpm is built separately from gsa/git
+FSMBUILD="perl-xCAT xCAT-client xCAT-server"
+FSMLINK=""
+# If you add more embed cases, also change the if [ -n "$EMBED" ]... below
+
 # Process cmd line variable assignments, assigning each attr=val pair to a variable of same name
 for i in $*; do
 	# upper case the variable name
@@ -68,51 +85,79 @@ if [ "$OSNAME" != "AIX" ]; then
 	export HOME=/root		# This is so rpm and gpg will know home, even in sudo
 fi
 
-# this is needed only when we are transitioning the yum over to frs
-if [ "$FRSYUM" != 0 ]; then
-	YUMDIR=$FRS
-	YUMREPOURL="https://sourceforge.net/projects/xcat/files/yum"
-else
-	YUMDIR=htdocs
-	YUMREPOURL="http://xcat.sourceforge.net/yum"
+# for the git case, query the current branch and set REL (changing master to devel if necessary)
+function setbranch {
+	#git checkout $BRANCH
+	#REL=`git rev-parse --abbrev-ref HEAD`
+	REL=`git name-rev --name-only HEAD`
+	if [ "$REL" = "master" ]; then
+		REL="devel"
+	fi
+}
+
+if [ "$REL" = "xcat-core" ]; then			# using git
+	GIT=1
+	setbranch			# this changes the REL variable
 fi
 
+YUMDIR=$FRS
+YUMREPOURL="https://sourceforge.net/projects/xcat/files/yum"
+
 # Set variables based on which type of build we are doing
-if [ -n "$EMBED" ]; then EMBEDDIR="/$EMBED"
-else EMBEDDIR=""; fi
-XCATCORE="xcat-core"		# core-snap is a sym link to xcat-core
-echo "svn --quiet up Version"
-svn --quiet up Version
-VER=`cat Version`
-SHORTVER=`cat Version|cut -d. -f 1,2`
-SHORTSHORTVER=`cat Version|cut -d. -f 1`
-if [ "$PROMOTE" = 1 ]; then
-	CORE="xcat-core"
-	if [ "$OSNAME" = "AIX" ]; then
-		TARNAME=core-aix-$VER.tar.gz
+if [ -n "$EMBED" ]; then
+	EMBEDDIR="/$EMBED"
+	if [ "$EMBED" = "zvm" ]; then
+		EMBEDBUILD=$ZVMBUILD
+		EMBEDLINK=$ZVMLINK
+	elif [ "$EMBED" = "pcm" ]; then
+		EMBEDBUILD=$PCMBUILD
+		EMBEDLINK=$PCMLINK
+	elif [ "$EMBED" = "fsm" ]; then
+		EMBEDBUILD=$FSMBUILD
+		EMBEDLINK=$FSMLINK
 	else
-		TARNAME=xcat-core-$VER.tar.bz2
+		echo "Error: EMBED setting $EMBED not recognized."
+		exit 2
 	fi
 else
-	CORE="core-snap"
-	if [ "$OSNAME" = "AIX" ]; then
-		TARNAME=core-aix-snap.tar.gz
-	else
-		TARNAME=core-rpms-snap.tar.bz2
-	fi
+	EMBEDDIR=""
+	EMBEDBUILD=$ALLBUILD
+	EMBEDLINK=""
+fi
+
+XCATCORE="xcat-core"		# core-snap is a sym link to xcat-core
+
+if [ "$GIT" = "1" ]; then			# using git - need to include REL in the path where we put the built rpms
+	DESTDIR=../../$REL$EMBEDDIR/$XCATCORE
+else
+	DESTDIR=../..$EMBEDDIR/$XCATCORE
 fi
-DESTDIR=../..$EMBEDDIR/$XCATCORE
 SRCD=core-snap-srpms
 
 # currently aix builds ppc rpms, but someday it should build noarch
 if [ "$OSNAME" = "AIX" ]; then
 	NOARCH=ppc
+	SYSGRP=system
 else
 	NOARCH=noarch
+	SYSGRP=root
 fi
 
+function setversionvars {
+	VER=`cat Version`
+	SHORTVER=`cat Version|cut -d. -f 1,2`
+	SHORTSHORTVER=`cat Version|cut -d. -f 1`
+}
+
 
 if [ "$PROMOTE" != 1 ]; then      # very long if statement to not do builds if we are promoting
+# we are doing a snap build
+CORE="core-snap"
+if [ "$OSNAME" = "AIX" ]; then
+	TARNAME=core-aix-snap.tar.gz
+else
+	TARNAME=core-rpms-snap.tar.bz2
+fi
 mkdir -p $DESTDIR
 SRCDIR=$DESTDIR/../$SRCD
 mkdir -p $SRCDIR
@@ -133,18 +178,39 @@ else
 	#echo "source=$source"
 fi
 
-# If they have not given us a premade update file, do an svn update and capture the results
-if [ -z "$SVNUP" ]; then
-	SVNUP=../coresvnup
-	echo "svn up > $SVNUP"
-	svn up > $SVNUP
-fi
+# If they have not given us a premade update file, do an svn update or git pull and capture the results
 SOMETHINGCHANGED=0
-if ! $GREP 'At revision' $SVNUP; then
-	SOMETHINGCHANGED=1
+if [ "$GIT" = "1" ]; then			# using git
+	if [ -z "$GITUP" ]; then
+		GITUP=../coregitup
+		echo "git pull > $GITUP"
+		git pull > $GITUP
+		if [[ $? != 0 ]]; then
+			# do not continue so we do not build with old files
+			echo "The 'git pull' command failed.  Exiting the build."
+			exit 3
+		fi
+	fi
+	if ! $GREP 'Already up-to-date' $GITUP; then
+		SOMETHINGCHANGED=1
+	fi
+else		# using svn
+	GIT=0
+	if [ -z "$SVNUP" ]; then
+		SVNUP=../coresvnup
+		echo "svn up > $SVNUP"
+		svn up > $SVNUP
+	fi
+	if ! $GREP 'At revision' $SVNUP; then
+		SOMETHINGCHANGED=1
+	fi
+	# copy the SVNUP variable to GITUP so the rest of the script doesnt have to worry whether we did svn or git
+	GITUP=$SVNUP
 fi
 
-# Process for making most of the rpms
+setversionvars
+
+# Function for making the noarch rpms
 function maker {
 	rpmname="$1"
 	./makerpm $rpmname "$EMBED"
@@ -159,9 +225,11 @@ function maker {
 }
 
 # If anything has changed, we should always rebuild perl-xCAT
-if [ $SOMETHINGCHANGED == 1 -o "$BUILDALL" == 1 ]; then		# Use to be:  $GREP perl-xCAT $SVNUP; then
-	UPLOAD=1
-	maker perl-xCAT
+if [ $SOMETHINGCHANGED == 1 -o "$BUILDALL" == 1 ]; then		# Use to be:  $GREP perl-xCAT $GITUP; then
+	if [[ " $EMBEDBUILD " = *\ perl-xCAT\ * ]]; then
+		UPLOAD=1
+		maker perl-xCAT
+	fi
 fi
 if [ "$OSNAME" = "AIX" ]; then
 	# For the 1st one we overwrite, not append
@@ -169,10 +237,12 @@ if [ "$OSNAME" = "AIX" ]; then
 fi
 
 # Build the rest of the noarch rpms
-for rpmname in xCAT-client xCAT-server xCAT-IBMhpc xCAT-rmc xCAT-UI xCAT-test; do
-	if $GREP $rpmname $SVNUP || [ "$BUILDALL" == 1 ]; then
+for rpmname in xCAT-client xCAT-server xCAT-IBMhpc xCAT-rmc xCAT-UI xCAT-test xCAT-buildkit; do
+	#if [ "$EMBED" = "zvm" -a "$rpmname" != "xCAT-server" -a "$rpmname" != "xCAT-UI" ]; then continue; fi		# for zvm embedded env only need to build server and UI
+	if [[ " $EMBEDBUILD " != *\ $rpmname\ * ]]; then continue; fi
+	if [ "$OSNAME" = "AIX" -a "$rpmname" = "xCAT-buildkit" ]; then continue; fi		# do not build xCAT-buildkit on aix
+	if $GREP $rpmname $GITUP || [ "$BUILDALL" == 1 ]; then
 		UPLOAD=1
-		if [ "$EMBED" = "zvm" -a "$rpmname" != "xCAT-server" -a "$rpmname" != "xCAT-UI" ]; then continue; fi		# for embedded envs only need to build server special
 		maker $rpmname
 	fi
 	if [ "$OSNAME" = "AIX" ]; then
@@ -182,35 +252,40 @@ for rpmname in xCAT-client xCAT-server xCAT-IBMhpc xCAT-rmc xCAT-UI xCAT-test; d
 	fi
 done
 
-if [ "$OSNAME" != "AIX" -a "$EMBED" != "zvm" ]; then
-	if grep -v nbroot2 $SVNUP|$GREP xCAT-nbroot || [ "$BUILDALL" == 1 ]; then
-		UPLOAD=1
-		ORIGFAILEDRPMS="$FAILEDRPMS"
-		for arch in x86_64 x86 ppc64; do
-			./makerpm xCAT-nbroot-core $arch
-			if [ $? -ne 0 ]; then FAILEDRPMS="$FAILEDRPMS xCAT-nbroot-core-$arch"; fi
-		done
-		if [ "$FAILEDRPMS" = "$ORIGFAILEDRPMS" ]; then	# all succeeded
-			rm -f $DESTDIR/xCAT-nbroot-core*rpm
-			rm -f $SRCDIR/xCAT-nbroot-core*rpm
-			mv $source/RPMS/noarch/xCAT-nbroot-core-*rpm $DESTDIR
-			mv $source/SRPMS/xCAT-nbroot-core-*rpm $SRCDIR
+# Build xCAT-genesis-scripts for xcat-core.  xCAT-genesis-base gets built by hand and put in xcat-dep.
+# The mknb cmd combines them at install time.
+if [ "$OSNAME" != "AIX" ]; then
+	if [[ " $EMBEDBUILD " = *\ xCAT-genesis-scripts\ * ]]; then
+		if $GREP xCAT-genesis-scripts $GITUP || [ "$BUILDALL" == 1 ]; then
+			UPLOAD=1
+			ORIGFAILEDRPMS="$FAILEDRPMS"
+			./makerpm xCAT-genesis-scripts x86_64 "$EMBED"
+			if [ $? -ne 0 ]; then FAILEDRPMS="$FAILEDRPMS xCAT-genesis-scripts-x86_64"; fi
+			if [ "$FAILEDRPMS" = "$ORIGFAILEDRPMS" ]; then	# all succeeded
+				rm -f $DESTDIR/xCAT-genesis-scripts*rpm
+				rm -f $SRCDIR/xCAT-genesis-scripts*rpm
+				mv $source/RPMS/noarch/xCAT-genesis-scripts-*rpm $DESTDIR
+				mv $source/SRPMS/xCAT-genesis-scripts-*rpm $SRCDIR
+			fi
 		fi
 	fi
 fi
 
 # Build the xCAT and xCATsn rpms for all platforms
-for rpmname in xCAT xCATsn; do
-	if [ "$EMBED" = "zvm" ]; then break; fi
-	if [ $SOMETHINGCHANGED == 1 -o "$BUILDALL" == 1 ]; then		# used to be:  if $GREP -E "^[UAD] +$rpmname/" $SVNUP; then
+for rpmname in xCAT xCATsn xCAT-OpenStack; do
+	#if [ "$EMBED" = "zvm" ]; then break; fi
+	if [[ " $EMBEDBUILD " != *\ $rpmname\ * ]]; then continue; fi
+	if [ $SOMETHINGCHANGED == 1 -o "$BUILDALL" == 1 ]; then		# used to be:  if $GREP -E "^[UAD] +$rpmname/" $GITUP; then
 		UPLOAD=1
 		ORIGFAILEDRPMS="$FAILEDRPMS"
 		if [ "$OSNAME" = "AIX" ]; then
-			./makerpm $rpmname
+			if [ "$rpmname" = "xCAT-OpenStack" ]; then continue; fi 		# do not bld openstack on aix
+			./makerpm $rpmname "$EMBED"
 			if [ $? -ne 0 ]; then FAILEDRPMS="$FAILEDRPMS $rpmname"; fi
 		else
-			for arch in x86_64 i386 ppc64 s390x; do
-				./makerpm $rpmname $arch
+			for arch in x86_64 ppc64 s390x; do
+				if [ "$rpmname" = "xCAT-OpenStack" -a "$arch" != "x86_64" ]; then continue; fi 		# only bld openstack for x86_64 for now
+				./makerpm $rpmname $arch "$EMBED"
 				if [ $? -ne 0 ]; then FAILEDRPMS="$FAILEDRPMS $rpmname-$arch"; fi
 			done
 		fi
@@ -222,24 +297,30 @@ for rpmname in xCAT xCATsn; do
 		fi
 	fi
 done
-
+# no longer put in xCAT-rmc
 if [ "$OSNAME" = "AIX" ]; then
 	echo "rpm -Uvh xCAT-$SHORTSHORTVER*rpm" >> $DESTDIR/instxcat
-	echo "rpm -Uvh xCAT-rmc-$SHORTSHORTVER*rpm" >> $DESTDIR/instxcat
 fi
 
 # Make sym links in the embed subdirs for the rpms we do not have to build special
-cd $DESTDIR
-if [ "$EMBED" = "zvm" ]; then
+if [ -n "$EMBED" -a -n "$EMBEDLINK" ]; then
+	cd $DESTDIR
 	maindir="../../$XCATCORE"
-	rm -f xCAT-client-$SHORTSHORTVER*rpm
-	ln -s $maindir/xCAT-client-$SHORTSHORTVER*rpm .
-	rm -f xCAT-$SHORTSHORTVER*rpm
-	ln -s $maindir/xCAT-$SHORTSHORTVER*.s390x.rpm .
-	rm -f xCATsn-$SHORTSHORTVER*rpm
-	ln -s $maindir/xCATsn-$SHORTSHORTVER*.s390x.rpm .
+	for rpmname in $EMBEDLINK; do
+		if [ "$rpmname" = "xCAT" -o "$rpmname" = "xCATsn" ]; then
+			if [ "$EMBED" = "zvm" ]; then
+				echo "Creating link for $rpmname-$SHORTSHORTVER"'*.s390x.rpm'
+				rm -f $rpmname-$SHORTSHORTVER*rpm
+				ln -s $maindir/$rpmname-$SHORTSHORTVER*.s390x.rpm .
+			fi
+		else
+			echo "Creating link for $rpmname-$SHORTSHORTVER"'*rpm'
+			rm -f $rpmname-$SHORTSHORTVER*rpm
+			ln -s $maindir/$rpmname-$SHORTSHORTVER*rpm .
+		fi
+	done
+	cd - >/dev/null
 fi
-cd - >/dev/null
 
 
 # Decide if anything was built or not
@@ -274,10 +355,10 @@ if [ "$OSNAME" != "AIX" ]; then
 		echo '%_gpg_name Jarrod Johnson' >> $MACROS
 	fi
 	echo "Signing RPMs..."
-	build-utils/rpmsign.exp `find $DESTDIR -type f -name '*.rpm'` | grep -v -E '(was already signed|rpm --quiet --resign|WARNING: standard input reopened)'
-	build-utils/rpmsign.exp $SRCDIR/*rpm | grep -v -E '(was already signed|rpm --quiet --resign|WARNING: standard input reopened)'
-	createrepo $DESTDIR
-	createrepo $SRCDIR
+	build-utils/rpmsign.exp `find $DESTDIR -type f -name '*.rpm'` | grep -v -E '(already contains identical signature|was already signed|rpm --quiet --resign|WARNING: standard input reopened)'
+	build-utils/rpmsign.exp $SRCDIR/*rpm | grep -v -E '(already contains identical signature|was already signed|rpm --quiet --resign|WARNING: standard input reopened)'
+	createrepo --checksum sha $DESTDIR			# specifying checksum so the repo will work on rhel5
+	createrepo --checksum sha $SRCDIR
 	rm -f $SRCDIR/repodata/repomd.xml.asc
 	rm -f $DESTDIR/repodata/repomd.xml.asc
 	gpg -a --detach-sign $DESTDIR/repodata/repomd.xml
@@ -290,23 +371,26 @@ if [ "$OSNAME" != "AIX" ]; then
 	fi
 fi
 
-# make everything have a group of xcat, so anyone can manage them once they get on SF
+# set group and permissions correctly on the built rpms
 if [ "$OSNAME" = "AIX" ]; then
-	if ! lsgroup xcat >/dev/null 2>&1; then
-		mkgroup xcat
-	fi
 	chmod +x $DESTDIR/instxcat
-else	# linux
-	if ! $GREP xcat /etc/group; then
-		groupadd xcat
-	fi
 fi
-chgrp -R xcat $DESTDIR
+chgrp -R $SYSGRP $DESTDIR
 chmod -R g+w $DESTDIR
-chgrp -R xcat $SRCDIR
+chgrp -R $SYSGRP $SRCDIR
 chmod -R g+w $SRCDIR
 
-fi		# end of very long if-not-promote
+else		# end of very long if-not-promote
+	# we are only promoting (not building)
+	setversionvars
+	setbranch
+	CORE="xcat-core"
+	if [ "$OSNAME" = "AIX" ]; then
+		TARNAME=core-aix-$VER.tar.gz
+	else
+		TARNAME=xcat-core-$VER.tar.bz2
+	fi
+fi
 
 cd $DESTDIR
 
@@ -346,14 +430,17 @@ else
 	verboseflag=""
 fi
 echo "Creating $TARNAME ..."
+if [[ -e $TARNAME ]]; then
+	mkdir -p previous
+	mv -f $TARNAME previous
+fi
 if [ "$OSNAME" = "AIX" ]; then
 	tar $verboseflag -hcf ${TARNAME%.gz} $XCATCORE
-	rm -f $TARNAME
 	gzip ${TARNAME%.gz}
 else
 	tar $verboseflag -hjcf $TARNAME $XCATCORE
 fi
-chgrp xcat $TARNAME
+chgrp $SYSGRP $TARNAME
 chmod g+w $TARNAME
 
 # Decide whether to upload or not
@@ -407,8 +494,16 @@ if [ "$OSNAME" != "AIX" -a "$REL" = "devel" -a "$PROMOTE" != 1 -a -z "$EMBED" ];
 	rpm2cpio ../$XCATCORE/xCAT-client-*.$NOARCH.rpm | cpio -id '*.html'
 	rpm2cpio ../$XCATCORE/perl-xCAT-*.$NOARCH.rpm | cpio -id '*.html'
 	rpm2cpio ../$XCATCORE/xCAT-test-*.$NOARCH.rpm | cpio -id '*.html'
+	rpm2cpio ../$XCATCORE/xCAT-buildkit-*.$NOARCH.rpm | cpio -id '*.html'
+	rpm2cpio ../$XCATCORE/xCAT-OpenStack-*.x86_64.rpm | cpio -id '*.html'
 	i=0
 	while [ $((i+=1)) -le 5 ] && ! rsync $verboseflag -r opt/xcat/share/doc/man1 opt/xcat/share/doc/man3 opt/xcat/share/doc/man5 opt/xcat/share/doc/man7 opt/xcat/share/doc/man8 $UPLOADUSER,xcat@web.sourceforge.net:htdocs/
 	do : ; done
+
+	# extract and upload the tools readme
+	rpm2cpio ../$XCATCORE/xCAT-server-*.$NOARCH.rpm | cpio -id ./opt/xcat/share/xcat/tools/README.html
+	i=0
+	while [ $((i+=1)) -le 5 ] && ! rsync $verboseflag opt/xcat/share/xcat/tools/README.html $UPLOADUSER,xcat@web.sourceforge.net:htdocs/tools/
+	do : ; done
 	cd ..
 fi

builddep.sh

@@ -97,15 +97,15 @@ if [ "$OSNAME" != "AIX" ]; then
 
 	# Sign the rpms that are not already signed.  The "standard input reopened" warnings are normal.
 	echo "Signing RPMs..."
-	$XCATCOREDIR/build-utils/rpmsign.exp `find . -type f -name '*.rpm'` | grep -v -E '(was already signed|rpm --quiet --resign|WARNING: standard input reopened)'
+	$XCATCOREDIR/build-utils/rpmsign.exp `find . -type f -name '*.rpm'` | grep -v -E '(already contains identical signature|was already signed|rpm --quiet --resign|WARNING: standard input reopened)'
 
 	# Create the repodata dirs
 	echo "Creating repodata directories..."
 	for i in `find -mindepth 2 -maxdepth 2 -type d `; do
 		if [ -n "$VERBOSEMODE" ]; then
-			createrepo $i
+			createrepo --checksum sha $i            # specifying checksum so the repo will work on rhel5
 		else
-			createrepo $i >/dev/null
+			createrepo --checksum sha $i >/dev/null
 		fi
 		rm -f $i/repodata/repomd.xml.asc
 		gpg -a --detach-sign $i/repodata/repomd.xml
@@ -126,7 +126,7 @@ if [ "$OSNAME" != "AIX" ]; then
 fi
 
 if [ "$OSNAME" == "AIX" ]; then
-	# Build the instoss file
+	# Build the instoss file ------------------------------------------
 
 	cat >instoss << 'EOF'
 #!/bin/ksh
@@ -146,22 +146,32 @@ else
 fi
 cd $OSVER
 # Have to install rpms 1 at a time, since some may be already installed.
-# The only interdependency between the dep rpms so far is that net-snmp requires bash
-#  pyodbc is dependent on unixODBC
+# The only interdependency between the dep rpms so far is that net-snmp requires bash, and
+# pyodbc requires unixODBC.  (The bash dependency is taken care of automatically because it
+# comes earlier in the alphabet.)
+
+# first run /usr/sbin/updtvpkg to make sure any installp software is
+# registered with RPM.
+echo "Running updtvpkg. This could take a few minutes."
+/usr/sbin/updtvpkg
+echo "updtvpkg has completed."
+
 rpm -Uvh unixODBC*
-for i in `ls *.rpm|grep -v -E '^tcl-|^tk-|^expect-|^unixODBC-|^xCAT-UI-deps'`; do
+for i in `ls *.rpm|grep -v -E '^tcl-|^tk-|^expect-|^unixODBC-|^xCAT-UI-deps|^perl-DBD-DB2Lite'`; do
 	if [ "$i" == "perl-Net-DNS-0.66-1.aix5.3.ppc.rpm" ]; then
 		opts="--nodeps"
 	else
 		opts=""
 	fi
-	# this next if stmt means: if i does not start with perl-DBD-DB2
+	
+	# just in case we need it sometime, this next if stmt would mean: if it does not start with perl-DBD-DB2
 	#if [ "${i#perl-DBD-DB2}" == "$i" ]; then
-		echo rpm -Uvh $opts $i
-		rpm -Uvh $opts $i
-	#fi
+	
+	echo rpm -Uvh $opts $i
+	rpm -Uvh $opts $i
 done
 # don't try to install tcl, tk, or expect if they are already installed!
+# this section about expect/tcl/tk can be removed once 2.8 releases, because 2.8 no longer requires expect
 lslpp -l | grep expect.base > /dev/null 2>&1
 if [ $? -gt 0 ]; then
 	if [ "$OSVER" == "5.3" ]; then
@@ -174,24 +184,19 @@ if [ $? -gt 0 ]; then
 	fi
 fi
 EOF
-# end of instoss file content
+# end of instoss file content ---------------------------------------------
 
 
 	chmod +x instoss
 fi
 
-# Get the permissions correct.  Have to have all dirs/files with a group of xcat
-# and have them writeable by group, so any member of the xcat can build.
+# Get the permissions and group correct
 if [ "$OSNAME" == "AIX" ]; then
-	if ! lsgroup xcat >/dev/null 2>&1; then
-		mkgroup xcat
-	fi
+	SYSGRP=system
 else
-	if ! $GREP xcat /etc/group; then
-		groupadd xcat
-	fi
+	SYSGRP=root
 fi
-chgrp -R xcat *
+chgrp -R $SYSGRP *
 chmod -R g+w *
 
 # Build the tarball
@@ -213,7 +218,8 @@ else
 	echo "Creating $DFNAME ..."
 	tar $verbosetar -jcf $DFNAME xcat-dep
 fi
-cd xcat-dep
+
+#cd xcat-dep  <-- now we want to stay above xcat-dep, so we can rsync the whole dir
 
 if [ "$UP" == 0 ]; then
  exit 0;
@@ -235,12 +241,12 @@ if [ "$FRSYUM" != 0 ]; then
 else
 	links="-l"
 fi
-echo "Uploading RPMs to $YUMDIR/$YUM/xcat-dep/ ..."
-while [ $((i+=1)) -le 5 ] && ! rsync $links -ruv --delete * $UPLOADUSER,xcat@web.sourceforge.net:$YUMDIR/$YUM/xcat-dep/
+echo "Uploading RPMs from xcat-dep to $YUMDIR/$YUM/ ..."
+while [ $((i+=1)) -le 5 ] && ! rsync $links -ruv --delete xcat-dep $UPLOADUSER,xcat@web.sourceforge.net:$YUMDIR/$YUM/
 do : ; done
 
 # Upload the tarball to the SF FRS Area
 i=0
 echo "Uploading $DFNAME to $FRS/xcat-dep/$FRSDIR/ ..."
-while [ $((i+=1)) -le 5 ] && ! rsync -v ../$DFNAME $UPLOADUSER,xcat@web.sourceforge.net:$FRS/xcat-dep/$FRSDIR/
+while [ $((i+=1)) -le 5 ] && ! rsync -v $DFNAME $UPLOADUSER,xcat@web.sourceforge.net:$FRS/xcat-dep/$FRSDIR/
 do : ; done

makegenesisbuilderrpm

@@ -13,11 +13,11 @@ then
 	exit 1
 fi
 echo "The location for rpm building is ${RPMROOT}"
-cd `dirname $0`/xCAT-nbroot2
+cd `dirname $0`/xCAT-genesis-builder
 tar --exclude .svn -cjvf $RPMROOT/SOURCES/xCAT-genesis-builder.tar.bz2 .
 #mv -f *.gz $RPMROOT/SOURCES
 cp LICENSE.html $RPMROOT/BUILD
 cp xCAT-genesis-builder.spec $RPMROOT/SOURCES
 cd -
 rm -f $RPMROOT/SRPMS/xCAT-genesis-builder-$VER*rpm $RPMROOT/RPMS/*/xCAT-genesis-builder-$VER*rpm
-rpmbuild -ba xCAT-nbroot2/xCAT-genesis-builder.spec
+rpmbuild -ba xCAT-genesis-builder/xCAT-genesis-builder.spec

makerpm

@@ -24,7 +24,7 @@ function makenoarch {
 	else	# linux
 		echo "Building $RPMROOT/RPMS/noarch/$RPMNAME-$VER-snap*.noarch.rpm $EMBEDTXT..."
 		tar --exclude .svn -czf $RPMROOT/SOURCES/$RPMNAME-$VER.tar.gz $RPMNAME
-		rm -f $RPMROOT/SRPMS/xCAT-server-$VER*rpm $RPMROOT/RPMS/noarch/$RPMNAME-$VER*rpm
+		rm -f $RPMROOT/SRPMS/$RPMNAME-$VER*rpm $RPMROOT/RPMS/noarch/$RPMNAME-$VER*rpm
 		rpmbuild $QUIET -ta $RPMROOT/SOURCES/$RPMNAME-$VER.tar.gz
 		RC=$?
 	fi
@@ -32,9 +32,9 @@ function makenoarch {
 
 
 
-# Make one of the following rpms: xCAT, xCATsn
+# Make one of the following rpms: xCAT, xCATsn, xCAT-buildkit, xCAT-OpenStack
 function makexcat {
-	if [ "$OSNAME" != "AIX" -a -z "$2" ]; then
+	if [ "$OSNAME" != "AIX" -a "$1" != "xCAT-buildkit" -a -z "$2" ]; then
 		echo 'Usage: makerpm <RPMname> <arch> [<embedded-system>]'
 		exit 1
 	fi
@@ -68,24 +68,36 @@ function makexcat {
 		RC=$?
 	else	# linux
 		ARCH="$2"
-		cd `dirname $0`/$RPMNAME
+		TARGET="--target $ARCH"
 
 		if [ "$RPMNAME" = "xCAT" ]; then
-			tar --exclude .svn -czf $RPMROOT/SOURCES/postscripts.tar.gz  postscripts LICENSE.html
+			cd `dirname $0`/$RPMNAME
+			tar --exclude .svn --exclude upflag -czf $RPMROOT/SOURCES/postscripts.tar.gz  postscripts LICENSE.html
 			tar --exclude .svn -czf $RPMROOT/SOURCES/prescripts.tar.gz  prescripts
 			tar --exclude .svn -czf $RPMROOT/SOURCES/templates.tar.gz templates
 			cp xcat.conf $RPMROOT/SOURCES
 			cp xCATMN $RPMROOT/SOURCES
-		else	# xCATsn
+			cd - >/dev/null
+		elif [ "$RPMNAME" = "xCATsn" ]; then
+			cd `dirname $0`/$RPMNAME
 			tar --exclude .svn -czf $RPMROOT/SOURCES/license.tar.gz LICENSE.html
 			cp xcat.conf $RPMROOT/SOURCES
 			cp xCATSN $RPMROOT/SOURCES
+			cd - >/dev/null
+		elif [ "$RPMNAME" = "xCAT-buildkit" ]; then
+			ARCH="noarch"
+			TARGET=""
+			tar --exclude .svn --exclude xCAT-buildkit.spec -czf $RPMROOT/SOURCES/$RPMNAME-$VER.tar.gz $RPMNAME
+		elif [ "$RPMNAME" = "xCAT-OpenStack" ]; then
+			tar --exclude .svn --exclude xCAT-OpenStack.spec -czf $RPMROOT/SOURCES/$RPMNAME-$VER.tar.gz $RPMNAME
+		else	# do not recognize rpm
+			echo "Unrecognized rpm: $RPMNAME"
+			exit 2
 		fi
 
-		cd - >/dev/null
 		rm -f $RPMROOT/SRPMS/$RPMNAME-$VER*rpm $RPMROOT/RPMS/$ARCH/$RPMNAME-$VER*rpm
 		echo "Building $RPMROOT/RPMS/$ARCH/$RPMNAME-$VER-snap*.$ARCH.rpm $EMBEDTXT..."
-		rpmbuild $QUIET -ba $RPMNAME/$RPMNAME.spec --target $ARCH
+		rpmbuild $QUIET -ba $RPMNAME/$RPMNAME.spec $TARGET
 		RC=$?
 	fi
 }
@@ -115,9 +127,9 @@ function makenbroot {
 
 
 
-# Make the xCAT-nbroot-core rpm
+# Make the xCAT-genesis rpm
 function makegenesis {
-	DIR="xCAT-nbroot2"
+	DIR="xCAT-genesis-builder"
 	RPMNAME="$1"
 	cd `dirname $0`/$DIR
 	tar --exclude .svn -cjf $RPMROOT/SOURCES/$RPMNAME.tar.bz2 .
@@ -128,6 +140,25 @@ function makegenesis {
 	echo "Building $RPMROOT/RPMS/noarch/$RPMNAME-$VER-snap*.noarch.rpm $EMBEDTXT..."
 	rpmbuild $QUIET -ba $DIR/$RPMNAME.spec
 }
+function makegenesisscripts {
+	DIR="xCAT-genesis-scripts"
+	if [ -z "$2" ]; then
+		echo 'Usage: makerpm xCAT-genesis-scripts <arch> [<embedded-system>]'
+		exit 1
+	fi
+
+	RPMNAME="$1"
+	ARCH="$2"
+	TARGET="--target $ARCH"
+	cd `dirname $0`/
+	tar --exclude .svn -cjf $RPMROOT/SOURCES/$RPMNAME.tar.bz2 $DIR
+	cp $DIR/LICENSE.html $RPMROOT/BUILD
+	cp $DIR/$RPMNAME.spec $RPMROOT/SOURCES
+	cd - >/dev/null
+	rm -f $RPMROOT/SRPMS/$RPMNAME-$ARCH-$VER*rpm $RPMROOT/RPMS/noarch/$RPMNAME-$ARCH-$VER*rpm
+	echo "Building $RPMROOT/RPMS/noarch/$RPMNAME-$ARCH-$VER-snap*.noarch.rpm $EMBEDTXT..."
+	rpmbuild $QUIET -ba $DIR/$RPMNAME.spec $TARGET
+}
 
 
 # Export the name of the embedded system we are building for
@@ -172,15 +203,18 @@ else	# linux
 fi
 
 
-if [ "$1" = "xCAT" -o "$1" = "xCATsn" ]; then
+if [ "$1" = "xCAT" -o "$1" = "xCATsn" -o "$1" = "xCAT-buildkit" -o "$1" = "xCAT-OpenStack" ]; then
 	exportEmbed $3
 	makexcat $1 $2
 elif [ "$1" = "xCAT-nbroot" -o "$1" = "xCAT-nbroot-core" ]; then
 	exportEmbed $3
 	makenbroot xCAT-nbroot-core $2
 elif [ "$1" = "xCAT-genesis-builder" ]; then
+	exportEmbed $2
+	makegenesis $1
+elif [ "$1" = "xCAT-genesis-scripts" ]; then
 	exportEmbed $3
-	makegenesis $1 $2
+	makegenesisscripts $1 $2
 else	# must be one of the noarch rpms
 	exportEmbed $2
 	makenoarch $1

perl-xCAT/db2man

@@ -157,61 +157,69 @@ B<tabedit> or B<chtab> commands.  They can be viewed using B<nodels> or B<tabdum
 
 Alternatively, the xCAT database can be viewed and edited as logical objects, instead of flat tables.
 In this mode, xCAT takes care of which table each attribute should go in.  To treat the database
-as logical object definitions, use the commands:  lsdef, mkdef, chdef, rmdef.  See Object Definitions
+as logical object definitions, use the commands:  B<lsdef>, B<mkdef>, B<chdef>, B<rmdef>.  See Object Definitions
 below.
 
 xCAT allows the use of different database applications, depending on the needs of your cluster.
 The default database is SQLite, which is a daemonless, zero-config database.  But you could instead
 choose to use something like postgresql for greater scalability and remote access in the
 hierarchical/service node case.  To use a different database or a different location, create
-the file /etc/xcat/cfgloc. 
- See the appropriate xCAT docuementation for the format of the file for the database you choose. 
-The following example is for PostgreSQL:
+the file /etc/xcat/cfgloc.  See the appropriate xCAT docuementation for the format of the file for the database you choose. 
+The following example /etc/xcat/cfgloc file is for PostgreSQL:
 
-
-=over 4
-
-=item Pg:dbname=xcat;host=<mgmtnode>|<pgadminuserid>|<pgadminpasswd>
+ Pg:dbname=xcat;host=<mgmtnode>|<pgadminuserid>|<pgadminpasswd>
 
 where mgmtnode is the hostname of the management node adapter on the cluster side, and the pgadminuserid and pgadminpasswd are the database admin and password.
 
-=back
+=head2 GROUPS AND REGULAR EXPRESSIONS IN TABLES
 
-The xCAT database spans a number of tables, some with records associated with particular nodes
-(such as nodelist and nodehm) and others that do not have a direct relationship with any given node.
-The tables not associated with a given node are straightforward, the data is stored and retrieved
-as-is from the database without interpretation, and without any generic inheritance
-(though some calling code may implement inheritance for specific fields, for example
-nodehm.power inheriting from nodehm.mgt).
-
-The tables with records typically retrieved by node name have some extra features to enable a more
+The xCAT database has a number of tables, some with rows that are keyed by node name
+(such as noderes and nodehm) and others that are not keyed by node name (for example, the policy table).
+The tables that are keyed by node name have some extra features that enable a more
 template-based style to be used:
 
-Any group name can be used in lieu of a node name in the node field, and that record will then
-be taken to be applicable to any node in that group.  If a field is requested for a specific node,
-and either a record doesn't exist specifically for that nodename or a record exists, but has no
-definition for the requested field, that node's groups are then used to search for
-records.  If multiple records could apply from two different groups, the precedence is
-the order the groups are specified in the nodelist table for that node.  This is nearly identical to
-most xCAT 1.x tab file conventions.  This is useful in tables such as noderes, where typical
-configurations have exactly the same field values for large sets of nodes.
+Any group name can be used in lieu of a node name in the node field, and that row will then
+provide "default" attribute values for any node in that group.  A row with a specific node name
+can then override one or more attribute values for that specific node.  For example, if the nodehm table contains:
 
-xCAT 2 extends the above to be made useful where a field will vary for every node with a given tag,
-but in ways that would be trivial to describe.  If a field is of the format /I<pattern>/I<replacement>/,
-it is taken to be a perl regular expression, to be performed on the nodename.  For example, the bmc field
-of the ipmi table might be B</\z/-bmc/> for a record with node=ipmi to specify that the BMC hostname is derived
-by appending B<-bmc> to the end of the nodename of every node in the ipmi group.
+ #node,power,mgt,cons,termserver,termport,conserver,serialport,serialspeed,serialflow,getmac,cmdmapping,comments,disable
+ "mygroup",,"ipmi",,,,,,"19200",,,,,
+ "node1",,,,,,,,"115200",,,,,
 
-As an extension to the above, a regular expression extended with arithmetic operators is available,
-by using the format |I<pattern>|I<replacement>|.  This behaves similarly to the above, but () enclosed parts
-in I<replacement> are taken to signify arithmetic operations and substituted in.  All operations are integer
-arithmetic, so 5/4 would come out as 1.  The typical perl positional variables are available in such expressions.
+In the above example, the node group called mygroup sets mgt=ipmi and serialspeed=19200.  Any nodes that are in this group
+will have those attribute values, unless overridden.  For example, if node2 is a member of mygroup, it will automatically
+inherit these attribute values (even though it is not explicitly listed in this table).  In the case of node1 above, it
+inherits mgt=ipmi, but overrides the serialspeed to be 115200, instead of 19200.  A useful, typical way to use this
+capability is to create a node group for your nodes and for all the attribute values that are the same for every node,
+set them at the group level.  Then you only have to set attributes for each node that vary from node to node.
 
-For example, if you have many blades in your cluster and their hostnames have a regular
-pattern of blade1, blade2, etc., and your BladeCenter management modules also have a hostname
-pattern of amm1, amm2, etc., then your B<mp> table could be expressed by the following single row:
+xCAT extends the group capability so that it can also be used for attribute values that vary from node to node
+in a very regular pattern.  For example, if in the ipmi table you want the bmc attribute to be set to whatever the nodename is with
+"-bmc" appended to the end of it, then use this in the ipmi table:
 
-  "blade","|\D+(\d+)|amm(($1-1)/14+1)|","|\D+(\d+)|(($1-1)%14+1)|",,
+ #node,bmc,bmcport,taggedvlan,bmcid,username,password,comments,disable
+ "compute","/\z/-bmc/",,,,,,,
+
+In this example, "compute" is a node group that contains all of the compute nodes.  The 2nd attribute (bmc) is a regular
+expression that is similar to a substitution pattern.  The 1st part "\z" matches the end of the node name and substitutes "-bmc", effectively appending it to the node name.
+
+Another example is if node1 is to have IP address 10.0.0.1, node2 is to have IP address 10.0.0.2, etc.,
+then this could be represented in the hosts table with the single row:
+
+ #node,ip,hostnames,otherinterfaces,comments,disable
+ "compute","|node(\d+)|10.0.0.($1+0)|",,,,
+
+In this example, the regular expression in the ip attribute uses "|" to separate the 1st and 2nd part.  This means that
+xCAT will allow arithmetic operations in the 2nd part.  In the 1st part, "(\d+)", will match the number part of the node
+name and put that in a variable called $1.  The 2nd part
+is what value to give the ip attribute.  In this case it will set it to the string "10.0.0." and the number that is
+in $1.  (Zero is added to $1 just to remove any leading zeroes.)
+
+A more involved example is with the mp table.  If your blades have node names node01, node02, etc., and your chassis
+node names are cmm01, cmm02, etc., then you might have an mp table like:
+
+ #node,mpa,id,nodetype,comments,disable
+ "blade","|\D+(\d+)|cmm(sprintf('%02d',($1-1)/14+1))|","|\D+(\d+)|(($1-1)%14+1)|",,
 
 Before you panic, let me explain each column:
 
@@ -221,32 +229,34 @@ Before you panic, let me explain each column:
 
 This is a group name.  In this example, we are assuming that all of your blades belong to this
 group.  Each time the xCAT software accesses the B<mp> table to get the management module and slot number
-of a specific blade (e.g. B<blade20>), this row will match (because B<blade20> is in the B<blade> group).
-Once this row is matched for B<blade20>, then the processing described in the following items will take
+of a specific blade (e.g. B<node20>), this row will match (because B<node20> is in the B<blade> group).
+Once this row is matched for B<node20>, then the processing described in the following items will take
 place.
 
-=item B<|\D+(\d+)|amm(($1-1)/14+1)|>
+=item B<|\D+(\d+)|cmm(sprintf('%02d',($1-1)/14+1))|>
 
 This is a perl substitution pattern that will produce the value for the second column of the table (the
-management module hostname).
-The text B<\D+(\d+)> between the 1st two vertical bars is
+management module hostname).  The text B<\D+(\d+)> between the 1st two vertical bars is
 a regular expression that matches the node
-name that was searched for in this table (in this example B<blade20>).  The text that matches
+name that was searched for in this table (in this example B<node20>).  The text that matches
 within the 1st set of parentheses is set to $1.  (If there was a 2nd set of parentheses, it would
 be set to $2, and so on.)  In our case, the \D+ matches the non-numeric part of the name
-(B<blade>) and the \d+ matches the numeric part (B<20>).  So $1 is set to B<20>.  The text B<amm(($1-1)/14+1)> between the
-2nd and 3rd vertical bars produces the string that should be used as the value
-for this column in a hypothetical row for blade20.  Since $1 is set to 20, the expression B<($1-1)/14+1> equals
-19/14 + 1, which equals 2.  Therefore the whole string is B<amm2>, which will be used as the hostname
+(B<node>) and the B<\d+> matches the numeric part (B<20>).  So $1 is set to B<20>.  The text B<cmm(sprintf('%02d',($1-1)/14+1))> between the
+2nd and 3rd vertical bars produces the string that should be used as the value for the mpa attribute for node20.
+Since $1 is set to 20, the expression B<($1-1)/14+1> equals
+19/14 + 1, which equals 2.  (The division is integer division,
+so 19/14 equals 1.  Fourteen is used as the divisor, because there are 14 blades in each chassis.)  The value of 2 is then passed into sprintf() with a format string to add a leading
+zero, if necessary, to always make the number two digits.  Lastly the string B<cmm> is added to the beginning,
+making the resulting string B<cmm02>, which will be used as the hostname
 of the management module.
 
 =item B<|\D+(\d+)|(($1-1)%14+1)|>
 
 This item is similar to the one above.  This substituion pattern will produce the value for
-the 3rd column (the BladeCenter chassis slot number for this blade).  Because this row was
-the match for B<blade20>, the parentheses
+the 3rd column (the chassis slot number for this blade).  Because this row was
+the match for B<node20>, the parentheses
 within the 1st set of vertical bars will set $1 to 20.  Since % means modulo division, the
-expression B<($1-1)%14+1> will evaluate to 6.
+expression B<($1-1)%14+1> will evaluate to B<6>.
 
 =back
 

perl-xCAT/debian/control

@@ -1,8 +1,8 @@
 Source: perl-xcat
 Section: libs
 Priority: extra
-Maintainer: Arif Ali <aali@ocf.co.uk>
-Build-Depends: debhelper (>= 5), libsoap-lite-perl
+Maintainer: xCAT <xcat-user@lists.sourceforge.net>
+Build-Depends: debhelper (>= 5), libsoap-lite-perl, libdbi-perl
 Standards-Version: 3.7.2
 
 Package: perl-xcat

perl-xCAT/debian/perl-xcat.install

@@ -1,7 +1,7 @@
-xCAT/*    usr/lib/perl5/xCAT
+xCAT/*    /opt/xcat/lib/perl/xCAT/
 share/man/man5/*	opt/xcat/share/man/man5
 share/doc/man5/*	opt/xcat/share/doc/man5
 share/man/man7/*	opt/xcat/share/man/man7
 share/doc/man7/*	opt/xcat/share/doc/man7
 LICENSE.html		opt/xcat/share/doc/packages/perl-xCAT
-README			opt/xcat/
+README			opt/xcat/

perl-xCAT/debian/rules

@@ -14,7 +14,6 @@ export DH_COMPAT=5
 
 build:
 	dh_testdir
-	./modifyUtils `cat ../Version`
 	./db2man
 
 clean:
@@ -26,7 +25,7 @@ install:
 	dh_testdir
 	dh_testroot
 	dh_installdirs
-	dh_install
+	dh_install -X".svn"
 
 
 # Build architecture-independent files here.
@@ -40,7 +39,7 @@ binary-arch: build install
 	dh_installchangelogs 
 	dh_installdocs
 #	dh_installexamples
-	dh_install
+	dh_install -X".svn"
 	chmod 644 `pwd`/debian/perl-xcat/opt/xcat/lib/perl/xCAT/*
 	chmod 755 `pwd`/debian/perl-xcat/opt/xcat/lib/perl/xCAT/data
 	chmod 644 `pwd`/debian/perl-xcat/opt/xcat/share/doc/packages/perl-xCAT/*
@@ -49,6 +48,7 @@ binary-arch: build install
 	chmod 644 `pwd`/debian/perl-xcat/opt/xcat/share/doc/man5/*
 	chmod 644 `pwd`/debian/perl-xcat/opt/xcat/share/man/man7/*
 	chmod 644 `pwd`/debian/perl-xcat/opt/xcat/share/doc/man7/*
+	./modifyUtils `cat ../Version` `svn info | grep Revision | cut -d" " -f 2`
 #	dh_installmenu
 #	dh_installdebconf	
 #	dh_installlogrotate

perl-xCAT/modifyUtils

@@ -1,34 +1,26 @@
 #!/bin/sh
 # Put the version, svn revision #, and build date into the Version function in Version.pm
 
-if [ -z "$2" ]
+if [ -z "$1" ]
 	then
-	echo "modifyUtils:  Error:  must specify the xCAT version and svn revision number as arguments" >&2
+	echo "modifyUtils:  Error:  must specify the xCAT version as an argument" >&2
 	exit
 fi
 
 VER=$1
-SVNREF="svn r$2, "
-
-#SVNINFO=`svn info 2>/dev/null|grep Revision`
-#/bin/echo -e $SVNINFO
-#if [ $? -ne 0 -a -f .svninfo ]; then
-#    SVNINFO=`cat .svninfo 2>/dev/null|grep Revision`
-#fi
-#if [ $? -eq 0 ]
-#	then
-#		SVNREF="svn r"`echo $SVNINFO|awk '{print $2}'`", "
-#	else
-#		SVNREF=""
-#	fi
 
 BUILDDATE=`date`
-#echo ". '(${SVNREF}built $BUILDDATE)'"
+#echo ". '(built $BUILDDATE)'"
 
 if [ "$(uname)" = "AIX" ]
 then
-	sed -e s/"#XCATVERSIONSUBHERE"/". '$VER'"/ -e s/"#XCATSVNBUILDSUBHERE"/". ' (${SVNREF}built $BUILDDATE)'"/ xCAT/Version.pm >xCAT/Version.pm.new
+	sed -e s/"#XCATVERSIONSUBHERE"/". '$VER'"/ -e s/"#XCATSVNBUILDSUBHERE"/". ' (built $BUILDDATE)'"/ xCAT/Version.pm >xCAT/Version.pm.new
 	mv xCAT/Version.pm.new xCAT/Version.pm
 else
-	sed -i -e s/"#XCATVERSIONSUBHERE"/". '$VER'"/ -e s/"#XCATSVNBUILDSUBHERE"/". ' (${SVNREF}built $BUILDDATE)'"/ xCAT/Version.pm
+        if [ -f "/etc/debian_version" ];then
+            FILENAME="debian/perl-xcat/opt/xcat/lib/perl/xCAT/Version.pm"
+        else
+            FILENAME="xCAT/Version.pm"
+        fi
+	sed -i -e s/"#XCATVERSIONSUBHERE"/". '$VER'"/ -e s/"#XCATSVNBUILDSUBHERE"/". ' (built $BUILDDATE)'"/ $FILENAME
 fi

perl-xCAT/perl-xCAT.spec

@@ -24,7 +24,7 @@ Provides perl xCAT libraries for core functionality.  Required for all xCAT inst
 Includes xCAT::Table, xCAT::NodeRange, among others.
 
 %define zvm %(if [ "$zvm" = "1" ];then echo 1; else echo 0; fi)
-%define svninfo %(svn info | grep Revision | awk '{print $2}')
+%define fsm %(if [ "$fsm" = "1" ];then echo 1; else echo 0; fi)
 
 %prep
 %setup -q -n perl-xCAT
@@ -33,12 +33,15 @@ Includes xCAT::Table, xCAT::NodeRange, among others.
 # All of the tarball source has been unpacked there and is in the same file structure
 # as it is in svn.
 
+%if %fsm
+%else
 # Modify the Version() function in xCAT/Utils.pm to automatically have the correct version
-./modifyUtils %{version} %{svninfo}
+./modifyUtils %{version}
 
 # Build the pod version of the man pages for each DB table.  It puts them in the man5 and man7 subdirs.
 # Then convert the pods to man pages and html pages.
 ./db2man
+%endif
 
 %install
 # The install phase puts all of the files in the paths they should be in when the rpm is
@@ -75,6 +78,18 @@ rm $RPM_BUILD_ROOT/%{prefix}/lib/perl/xCAT/PPC*.pm
 cp xCAT/PPCdb.pm $RPM_BUILD_ROOT/%{prefix}/lib/perl/xCAT/
 chmod 644 $RPM_BUILD_ROOT/%{prefix}/lib/perl/xCAT/PPCdb.pm
 %endif
+# Don't ship these on FSM, to reduce dependencies
+%if %fsm
+rm $RPM_BUILD_ROOT/%{prefix}/lib/perl/xCAT/hpoa.pm
+rm $RPM_BUILD_ROOT/%{prefix}/lib/perl/xCAT/vboxService.pm
+rm $RPM_BUILD_ROOT/%{prefix}/lib/perl/xCAT/FSP*.pm
+rm $RPM_BUILD_ROOT/%{prefix}/lib/perl/xCAT/RemoteShellExp.pm
+rm $RPM_BUILD_ROOT/%{prefix}/lib/perl/xCAT/LparNetbootExp.pm
+rm $RPM_BUILD_ROOT/%{prefix}/lib/perl/xCAT/PPC*.pm
+# have to put PPCdb.pm back because it is needed by Postage.pm
+cp xCAT/PPCdb.pm $RPM_BUILD_ROOT/%{prefix}/lib/perl/xCAT/
+chmod 644 $RPM_BUILD_ROOT/%{prefix}/lib/perl/xCAT/PPCdb.pm
+%endif
 
 cp LICENSE.html $RPM_BUILD_ROOT/%{prefix}/share/doc/packages/perl-xCAT
 chmod 644 $RPM_BUILD_ROOT/%{prefix}/share/doc/packages/perl-xCAT/*
@@ -82,6 +97,8 @@ chmod 644 $RPM_BUILD_ROOT/%{prefix}/share/doc/packages/perl-xCAT/*
 cp README $RPM_BUILD_ROOT/%{prefix}
 chmod 644 $RPM_BUILD_ROOT/%{prefix}/README
 
+%if %fsm
+%else
 # These were built dynamically in the build phase
 cp share/man/man5/* $RPM_BUILD_ROOT/%{prefix}/share/man/man5
 chmod 644 $RPM_BUILD_ROOT/%{prefix}/share/man/man5/*
@@ -91,6 +108,7 @@ cp share/man/man7/* $RPM_BUILD_ROOT/%{prefix}/share/man/man7
 chmod 644 $RPM_BUILD_ROOT/%{prefix}/share/man/man7/*
 cp share/doc/man7/* $RPM_BUILD_ROOT/%{prefix}/share/doc/man7
 chmod 644 $RPM_BUILD_ROOT/%{prefix}/share/doc/man7/*
+%endif
 
 %clean
 # This step does not happen until *after* the %files packaging below
@@ -122,18 +140,8 @@ fi
 if [ "$1" -gt 1 ]; then #Ugrade only, restart daemon and migrate settings
    if [ -x /etc/init.d/xcatd ] && [ -f "/proc/cmdline" ]; then
       . /etc/profile.d/xcat.sh
-      /etc/init.d/xcatd reload
    fi
 fi
-%else 
-if [ "$1" -gt 1 ]; then #Ugrade only, restart daemon and migrate settings
-  if [ -n "$INUCLIENTS" ] && [ $INUCLIENTS -eq 1 ]; then
-    #Do nothing in not running system
-    echo "Do not restartxcatd in not running system"
-  else
-    XCATROOT=$RPM_INSTALL_PREFIX0 $RPM_INSTALL_PREFIX0/sbin/restartxcatd -r
-  fi 
-fi
 %endif
 exit 0
 

perl-xCAT/xCAT/CFMUtils.pm

@@ -0,0 +1,821 @@
+# IBM(c) 2012 EPL license http://www.eclipse.org/legal/epl-v10.html
+
+package xCAT::CFMUtils;
+
+BEGIN
+{
+  $::XCATROOT = $ENV{'XCATROOT'} ? $ENV{'XCATROOT'} : '/opt/xcat';
+}
+use lib "$::XCATROOT/lib/perl";
+
+use strict;
+use warnings;
+use File::Path;
+use File::Copy;
+use File::Find;
+use Getopt::Long;
+use Data::Dumper;
+use File::Basename;
+use xCAT::Table;
+use xCAT::Utils;
+use xCAT::MsgUtils;
+1;
+
+#-----------------------------------------------------------------------------
+
+=head3 initCFMdir
+    Initialize CFM directories and files. The default layout under cfmdir is:
+    . 
+    |-- etc
+    | |-- group.merge -> /etc/group.merge
+    | |-- hosts -> /etc/hosts
+    | |-- passwd.merge -> /etc/passwd.merge
+    | |-- shadow.merge -> /etc/shadow.merge
+    |-- group.OS -> /etc/group.OS
+    |-- passwd.OS -> /etc/passwd.OS
+    |-- shadow.OS -> /etc/shadow.OS
+    Note: the *.OS files are the backups for the original /etc/passwd, shadow, group files
+
+    Arguments:
+      $cfmdir
+    Returns:
+      0 - initialize successfully
+      1 - initialize failed
+    Globals:
+      none 
+    Error:
+      none
+    Example:
+      xCAT::CFMUtils->initCFMdir($cfmdir);
+
+=cut
+
+#-----------------------------------------------------------------------------
+sub initCFMdir
+{
+    my ($class, $cfmdir) = @_;
+
+    # below system files will be synced to all compute nodes
+    my @sysfiles = ("/etc/hosts");
+
+    # the /etc/passwd, shadow, group files will be merged 
+    my @userfiles = ("/etc/passwd", "/etc/shadow", "/etc/group");
+
+    # create the cfmdir
+    if (! -d $cfmdir)
+    {
+        mkpath $cfmdir;
+    }
+
+    # backup the OS files and create links under cfmdir
+    foreach my $file (@userfiles)
+    {
+        my $backup = $file.".OS";
+        if (! -e $backup)
+        {
+            copy($file, $backup);
+        }
+
+        if (! -e "$cfmdir/".basename($backup))
+        {
+            symlink($backup, "$cfmdir/".basename($backup));
+        }
+    }
+
+    # Initialize CFM directory and related files
+    if (! -d "$cfmdir/etc")
+    {
+        mkpath "$cfmdir/etc";
+    }
+
+    # link the system files
+    foreach my $file (@sysfiles)
+    {
+        symlink($file, "$cfmdir/$file");
+    }
+    # touch and link the merge files for /etc/passwd, shadow, group
+    foreach my $file (@userfiles)
+    {
+        my $merge = $file.".merge";
+        if (! -e "$merge")
+        {
+            xCAT::Utils->runcmd("touch $merge", -1);
+        }
+
+        if (! -e "$cfmdir/$merge")
+        {
+            symlink($merge, "$cfmdir/$merge");
+        }
+    }
+}
+
+#-----------------------------------------------------------------------------
+
+=head3 updateUserInfo
+    Update the /etc/passwd, shadow, group merge files under specified CFM directory
+
+    Arguments:
+      $cfmdir - CFM directory for osimage      
+    Returns:
+      0 - update successfully
+      1 - update failed
+    Globals:
+      $::CALLBACK
+    Error:
+      none
+    Example:
+      my $ret = xCAT::CFMUtils->updateUserInfo($cfmdir);
+
+=cut
+
+#-----------------------------------------------------------------------------
+sub updateUserInfo {
+    my ($class, $cfmdir) = @_;
+
+    my @userfiles = ("/etc/passwd", "/etc/shadow", "/etc/group");
+
+    my @osfiles = glob("$cfmdir/*.OS");
+    if (!@osfiles)
+    {
+        if ($::VERBOSE)
+        {
+            my $rsp = {};
+            $rsp->{data}->[0] = "Skiping the update of the /etc/passwd, shadow, group merge files under the CFM directory.";
+            xCAT::MsgUtils->message("I", $rsp, $::CALLBACK);
+        }
+	return 0;
+    }
+
+    foreach my $file (@userfiles)
+    {
+        my @oldrecords = ();
+        my @newrecords = ();
+        my $backup = basename($file).".OS";
+
+        # get the records from /etc/passwd, shadow, group file and backup files(.OS files)
+        # and all the files from /install/osimages/$imgname/cfmdir directory  
+        foreach my $userinfo ($file, "$cfmdir/$backup") 
+        {
+            my $fp;
+            open($fp, $userinfo);
+            my @records = ();
+            while (<$fp>)
+            {
+                my $line = xCAT::CFMUtils->trim($_);
+                if (($line =~ /^#/) || ($line =~ /^\s*$/ ))
+                { #comment line or blank line
+                    next;
+                } else
+                {    
+                    push @records, $line;
+                }   
+            }
+            close($fp);
+
+            # check the records from /etc/passwd, shadow, group file or backup
+            if ($userinfo =~ /^\/etc/ )
+            {
+                @newrecords = @records;
+            } else {
+                @oldrecords = @records;
+            }
+        }
+
+        # update the merge file
+        my $mergefile = $cfmdir."/".$file.".merge";
+        my @diff = xCAT::CFMUtils->arrayops("D", \@newrecords, \@oldrecords);
+        # output the diff to merge files
+        my $fp;
+        open($fp, '>', $mergefile);
+        if (@diff)
+        {
+            for my $record (@diff)
+            {
+                # skip to add ROOT relative records into MERGE file
+                if ($record =~ /^root/)
+                {
+                    next;
+                }
+                print $fp "$record\n";
+            }
+        }
+        close ($fp);
+        
+    }
+
+    return 0;
+}
+
+
+#-----------------------------------------------------------------------------
+=head3 setCFMSynclistFile
+    Set osimage synclists attribute for CFM function, the CMF synclist file is:
+    /install/osimages/<imagename>/synclist.cfm
+
+    Arguments:
+      $imagename - the specified osimage name
+    Returns:
+      It returns the cfmdir path if it is defined for an osimage object
+    Globals:
+      $::CALLBACK
+    Error:
+      none
+    Example:
+      my $cfmdir = xCAT::CFMUtils->setCFMSynclistFile($imagename);
+      if ($cfmdir) { # update the CFM synclist file }
+=cut
+#-----------------------------------------------------------------------------
+sub setCFMSynclistFile {
+    my ($class, $img) = @_;
+
+    my $cfmdir;
+    my $synclists;
+    my $cfmsynclist = "/install/osimages/$img/synclist.cfm";
+
+    # get the cfmdir and synclists attributes
+    my $osimage_t = xCAT::Table->new('osimage');
+    my $records = $osimage_t->getAttribs({imagename=>$img}, 'cfmdir', 'synclists');
+    if (defined ($records->{'cfmdir'}))
+    {
+        $cfmdir = $records->{'cfmdir'};
+        if (defined ($records->{'synclists'})) {$synclists = $records->{'synclists'}}
+    } else {
+        # no cfmdir defined, return directly
+        return 0;
+    }
+
+    my $found = 0;
+    my $index = 0; 
+    if ($synclists)
+    {
+        # the synclists is a comma separated list
+        my @lists = split(/,/, $synclists);
+        foreach my $synclist (@lists)
+        {
+            # find the synclist configuration for CFM
+            if ($synclist eq $cfmsynclist) 
+            {
+                $found = 1;
+                last;
+            }
+            $index += 1;
+        }
+        if ($found == 0)
+        {
+            # the CFM synclist is not defined, append it to $synclists
+            $synclists = "$synclists,$cfmsynclist"; 
+            # set the synclists attribute 
+            $osimage_t->setAttribs({imagename=>$img}, {'synclists' => $synclists});
+        }
+    } else {
+        # no synclists defined, set it to CFM synclist file
+        if ($cfmdir) { $synclists = $cfmsynclist; }
+        $osimage_t->setAttribs({imagename=>$img}, {'synclists' => $synclists});
+    }
+
+    return $cfmdir;   
+}
+
+
+#-----------------------------------------------------------------------------
+
+=head3 updateCFMSynclistFile
+    Update the synclist file(/install/osimages/<imagename>/synclist.cfm) for CFM function. 
+    It will recursively scan the files under cfmdir directory and then add them to CFM synclist file.
+    Note:
+    The files with suffix ".append" will be appended to the dest file(records in "APPEND:" section).
+    The files with suffix ".merge" will be merged to the dest file(records in "MERGE:" section).
+
+    In addition, it will reserve the user specified records in the synclist file. The example synclist file:
+	<cfmdir>/etc/hosts -> /etc/hosts
+	/root/install.log -> /tmp/install.log
+	...
+
+	APPEND:
+	<cfmdir>/etc/hosts.append -> /etc/hosts
+	/root/install.log.syslog -> /tmp/install.log
+	...
+	EXECUTE:
+	...
+	EXECUTEALWAYS:
+	...
+	MERGE:
+	<cfmdir>/etc/group.merge -> /etc/group
+	<cfmdir>/etc/shadow.merge -> /etc/shadow
+	<cfmdir>/etc/passwd.merge -> /etc/passwd
+
+    Arguments:
+      \@imagenames - reference to the osimage names array
+    Returns:
+      0 - update successfully
+      1 - update failed
+    Globals:
+      $::CALLBACK
+    Error:
+      none
+    Example:
+      my $ret = CAT::CFMUtils->updateCFMSynclistFile(\@imagenames);
+
+=cut
+
+#-----------------------------------------------------------------------------
+sub updateCFMSynclistFile {
+    my ($class, $imgs) = @_;
+
+    my @osimgs = @$imgs;
+    if (!@osimgs)
+    {
+        my $rsp = {};
+        $rsp->{error}->[0] = "No osimage names specified to process.";
+        xCAT::MsgUtils->message("E", $rsp, $::CALLBACK);
+        return 1;
+    }
+
+    foreach my $osimg (@osimgs)
+    {
+        my $cfmdir;
+        $cfmdir = xCAT::CFMUtils->setCFMSynclistFile($osimg);
+        if ($cfmdir)   # check for /install/osiamges/$osimg/cfmdir
+        {
+            my $cfmsynclist = "/install/osimages/$osimg/synclist.cfm";
+            if (! -d $cfmdir)
+            {
+                # skip this one go on to the next image, nothing to do for 
+                # CFMUtils in this image
+                next;
+            }
+            # create the parent directory of CFM synclist file
+            if (! -d dirname($cfmsynclist))
+            {
+                mkpath dirname($cfmsynclist);
+            }
+
+            # update /etc/passwd, shadow, group merge files
+            my $ret = xCAT::CFMUtils->updateUserInfo($cfmdir);
+            if ($ret !=0 )
+            {
+                my $rsp = {};
+                $rsp->{error}->[0] = 
+                "Update /etc/passwd, shadow, group merge files failed.";
+                xCAT::MsgUtils->message("E", $rsp, $::CALLBACK);
+                return 1;
+            }
+
+            # recursively list the files under cfm directory 
+            my @files = ();
+
+            find ( { wanted => sub { push @files, $File::Find::name if -f }, follow => 1 }, $cfmdir);
+            if (!@files) # not files under cfm directory, skip to next loop 
+            {
+                next;
+            }
+
+            my $fp;
+            open($fp, '>', $cfmsynclist);
+            my @mergefiles = ();
+            my @appendfiles = ();
+            foreach my $file (@files)
+            {
+                my $name = basename($file);
+                #TODO: find a better way to get the suffix 
+                my $suffix = ($name =~ m/([^.]+)$/)[0];
+                my $dest = substr($file, length($cfmdir));
+                if ($suffix eq "OS") # skip the backup files
+                {
+                    next;
+                } elsif ($suffix eq "merge") # merge file
+                {
+                    push(@mergefiles, $file);
+                } elsif ($suffix eq "append") { # append file
+                    push(@appendfiles, $file); 
+                } else { # output the syncing files maintained by CFM
+                    print $fp "$file -> $dest\n";
+                }
+            }
+
+            # output the APPEND records maintained by CFM
+            if (@appendfiles) {
+                print $fp "APPEND:\n";
+            }
+            foreach my $file (@appendfiles)
+            { 
+                my $dest = substr($file, length($cfmdir), length($file) - length(".append") - length($cfmdir));
+                print $fp "$file -> $dest\n";
+            }
+
+            # output the MERGE records maintained by CFM
+            if (@mergefiles) {
+                print $fp "MERGE:\n";
+            }
+            foreach my $file (@mergefiles)
+            {
+                my @userfiles = ("/etc/passwd", "/etc/shadow", "/etc/group");
+                my $dest = substr($file, length($cfmdir), length($file) - length(".merge") - length($cfmdir));
+                # only /etc/passwd, /etc/shadow, /etc/groups merging is supported
+                if (grep(/$dest/, @userfiles)) {		
+                    print $fp "$file -> $dest\n";
+                }
+            }
+            
+            # close the file 
+            close($fp);   
+        }
+    }
+ 
+    return 0;
+}
+
+#-----------------------------------------------------------------------------
+=head3 setCFMPkglistFile
+    Set the pkglist attribute of linuximage object for CFM function
+
+    Arguments:
+      $imagename - the specified linuximage name
+    Returns:
+      0 - update successfully
+      1 - update failed
+    Globals:
+      $::CALLBACK
+    Error:
+      none
+    Example:
+      my $ret = xCAT::CFMUtils->setCFMPkglistFile($imagename);
+=cut
+#-----------------------------------------------------------------------------
+sub setCFMPkglistFile {
+    my ($class, $img) = @_;
+
+    my $pkglists = "";
+    my $cfmpkglist = "/install/osimages/$img/pkglist.cfm";
+
+    # get the pkglist files
+    my $linuximage_t = xCAT::Table->new('linuximage');
+    my $records = $linuximage_t->getAttribs({imagename => $img}, 'pkglist');
+    if ($records)
+    {
+        if ($records->{'pkglist'}) { $pkglists = $records->{'pkglist'}; }
+    } else 
+    {
+        if ($::VERBOSE)
+        {
+            my $rsp = {};
+            $rsp->{data}->[0] = "There are no records for pkglist attribute in the linuximage:$img. There is nothing to process.";
+            xCAT::MsgUtils->message("I", $rsp, $::CALLBACK);
+        }
+    }
+
+    my $found = 0;
+    if ($pkglists)
+    {
+        foreach my $pkglist (split(/,/, $pkglists))
+        {
+            if ($pkglist eq $cfmpkglist) # the pkglist file for CFM is found, exit the loop 
+            {
+                $found = 1;
+                last;
+            }
+        }
+        # the pkglist file for CFM is not found, append it to $pkglits 
+        if (!$found) 
+        {
+            $pkglists = "$pkglists,$cfmpkglist"; 
+            # set the pkglist attribute for linuximage
+            $linuximage_t->setAttribs({imagename => $img}, {'pkglist' => $pkglists});
+        } 
+    } else 
+    {
+        # the pkglist file for linuximage is not defined, set it to $cfmpkglist
+        $pkglists = $cfmpkglist;
+        $linuximage_t->setAttribs({imagename => $img}, {'pkglist' => $pkglists});
+    }
+
+    return 0;   
+}
+
+#-----------------------------------------------------------------------------
+
+=head3 updateCFMPkglistFile
+    Update the ospkglist file
+
+    Arguments:
+      $imagename - the specified linuximage name
+      @curospkgs - the currently selected OS packages list
+    Returns:
+      0 - update successfully
+      1 - update failed
+    Globals:
+      none
+    Error:
+      none
+    Example:
+      my $ret = CAT::CFMUtils->updateCFMPkglistFile($imagename, @cur_selected_pkgs);
+
+=cut
+
+#-----------------------------------------------------------------------------
+sub updateCFMPkglistFile {
+    my ($class, $img, $ospkgs) = @_;
+     
+    my @cur_selected = @$ospkgs;
+    my $cfmpkglist = "/install/osimages/$img/pkglist.cfm";
+
+    my $ret = xCAT::CFMUtils->setCFMPkglistFile($img);
+    if ($ret)
+    {
+        my $rsp = {};
+        $rsp->{error}->[0] = "Set pkglist attribute for CFM failed.";
+        xCAT::MsgUtils->message("E", $rsp, $::CALLBACK);
+        return 1;
+    }
+
+    # check the parent directory of cfmpkglist file
+    if (! -d dirname($cfmpkglist))
+    {
+        mkpath dirname($cfmpkglist);
+    }
+
+    # get previous selected and removed OS packages list from pkglist file
+    my ($pre_selected_ref, $pre_removed_ref) = xCAT::CFMUtils->getPreOSpkgsList($cfmpkglist);
+    my @pre_selected = @$pre_selected_ref;
+    my @pre_removed = @$pre_removed_ref;
+
+    # get the #INCLUDE file from cfmpkglist file
+    my @incfiles = xCAT::CFMUtils->getIncludefiles($cfmpkglist);
+    # get the packages list in the #INCLUDE files
+    my @basepkgs = ();
+    foreach my $inc (@incfiles)
+    {
+        my ($selected_ref, $removed_ref) = xCAT::CFMUtils->getPreOSpkgsList($inc);
+        my @selected = @$selected_ref;
+        @basepkgs = xCAT::CFMUtils->arrayops("U", \@basepkgs, \@selected);
+    }
+
+    # get diff between previous and current selected OS packages lists    
+    my @diff = xCAT::CFMUtils->getPkgsDiff(\@pre_selected, \@cur_selected);
+ 
+    # merge the diff to previous removed OS packages list
+    my @all_removed = xCAT::CFMUtils->arrayops("U", \@pre_removed, \@diff);
+
+    # get the rollbacked OS packages list, the packages are existing in both removed and selected lists
+    # if so, we should remove the rollbacked OS packages from removed list
+    my @rollback = xCAT::CFMUtils->arrayops("I", \@all_removed, \@cur_selected);
+    my @cur_removed = xCAT::CFMUtils->arrayops("D", \@all_removed, \@rollback);
+
+    # remove the BASE packages from selected pakages
+    @basepkgs = xCAT::CFMUtils->arrayops("I", \@basepkgs, \@cur_selected);
+    @cur_selected = xCAT::CFMUtils->arrayops("D", \@cur_selected, \@basepkgs);
+
+    # update the pkglist file
+    my $fp;
+    open($fp, '>', $cfmpkglist);
+    foreach my $inc (@incfiles)
+    {
+        print $fp "#INCLUDE:$inc#\n";
+    }
+    # the pacakges be installed
+    if (@cur_selected)
+    {
+        foreach my $pkg (@cur_selected)
+        {
+            print $fp "$pkg\n";
+        }
+    }
+    # the packages be removed
+    if (@cur_removed)
+    {
+        foreach my $pkg (@cur_removed)
+        {
+            print $fp "-$pkg\n";
+        }
+    }
+    # close the file
+    close($fp);
+
+    return 0;
+}
+
+#-----------------------------------------------------------------------------
+
+=head3 getPreOSpkgsList
+    Get previously selected and removed OS packages lists from pkglist file
+
+    Arguments:
+      $ospkglist - the path for ospkglist file
+    Returns:
+      refs for selected and removed OS packages arrays
+    Globals:
+      none
+    Error:
+      none
+    Example:
+      my ($pre_selected_ref, $pre_removed_ref) = xCAT::CFMUtils->getPreOSpkgsList($ospkglist);
+      my @pre_selected = @$pre_selected_ref;
+      my @pre_removed = @$pre_removed_ref;
+
+=cut
+
+#-----------------------------------------------------------------------------
+sub getPreOSpkgsList {
+    my ($class, $pkglist) = @_;
+    my @selected = ();
+    my @removed = ();
+    my @pkglistfiles = ();
+
+    # get the #INCLUDE file from cfmpkglist file
+    my @incfiles = xCAT::CFMUtils->getIncludefiles($pkglist);
+    foreach my $inc (@incfiles)
+    {
+        push @pkglistfiles, $inc;
+    }
+    # assume the #INCLUDE file includes the BASE packages
+    push @pkglistfiles, $pkglist;
+
+    foreach my $file (@pkglistfiles)
+    {
+        my $pkglistfp;
+        open($pkglistfp, xCAT::CFMUtils->trim($file));
+        while (<$pkglistfp>)
+        {
+            my $line = xCAT::CFMUtils->trim($_);
+            if (($line =~ /^#/) || ($line =~ /^\s*$/ ) || ($line =~ /^@/))
+            { #comment line or blank line
+                next;
+            } else
+            {
+                if ($line =~ /^-/)
+                { # the package be removed
+                    push @removed, substr($line, 1);
+                } else
+                { # the package be installed
+                    push @selected, $line;
+                } 
+            }
+        }    
+        close($pkglistfp);
+    }
+
+    # delete the removed packages from selected list
+    my @intersection = xCAT::CFMUtils->arrayops("I", \@removed, \@selected);
+    @selected = xCAT::CFMUtils->arrayops("D", \@selected, \@intersection);
+
+    return (\@selected, \@removed);
+}
+
+#-----------------------------------------------------------------------------
+
+=head3 getPkgsDiff
+    Get the differences between previous and current packages list
+
+    Arguments:
+      @pre - previous selected packages list
+      @cur - current selected packages list
+    Returns:
+      @diff - the differencen list
+    Globals:
+      none
+    Error:
+      none
+    Example:
+      my @diff = xCAT::CFMUtils->getPkgsDiff(\@pre_selected, \@cur_selected);
+
+=cut
+
+#-----------------------------------------------------------------------------
+sub getPkgsDiff {
+    my ($class, $pre, $cur) = @_;
+
+    # get the intersection firstly
+    my @tmp = xCAT::CFMUtils->arrayops("I", \@$pre, \@$cur);
+
+    # get the difference
+    my @diff = xCAT::CFMUtils->arrayops("D", \@$pre, \@tmp);
+    #print Dumper(@diff);
+
+    return @diff;
+}
+
+#-----------------------------------------------------------------------------
+
+=head3 getIncludefiles 
+    Get the #INCLUDE files from the given file 
+
+    Arguments:
+      $file - the given file
+    Returns:
+      @files - the #INCLUDE files list
+    Globals:
+      none
+    Error:
+      none
+    Example:
+      my @diff = xCAT::CFMUtils->getIncludefiles($file);
+
+=cut
+
+#-----------------------------------------------------------------------------
+sub getIncludefiles {
+    my ($class, $file) = @_;
+    my @files = ();
+
+    my $fp;
+    open($fp, $file);
+    while (<$fp>)
+    {
+        my $line = xCAT::CFMUtils->trim($_);
+        if ($line =~ /^\s*$/)
+        { # blank line
+            next;
+        }
+        # find the #INCLUDE line
+        if ($line =~ /^\s*#INCLUDE:[^#^\n]+#/)
+        {
+            #print "The line is: [$line]\n";
+            my $incfile = substr($line, length("#INCLUDE:"), length($line)-length("#INCLUDE:")-1);
+            push @files, $incfile;
+        }
+    }
+    close($fp);
+
+    return @files;
+}
+
+#-----------------------------------------------------------------------------
+
+=head3 trim
+    Strip left and right whitspaces for a string 
+
+    Arguments:
+      $string
+    Returns:
+      @string
+    Globals:
+      none
+    Error:
+      none
+    Example:
+      my @new_string = xCAT::CFMUtils->trim($string);
+
+=cut
+
+#-----------------------------------------------------------------------------
+sub trim {
+    my ($class, $string) = @_;
+
+    # trim the left whitespaces
+    $string =~ s/^\s*//;
+
+    # trim the right whitespaces
+    $string =~ s/\s*$//;
+
+    return $string;
+}
+
+# Function: compute Union, Intersection or Difference of unique lists
+# Usage: arrayops ("U"/"I"/"D", @a, @b)
+# Return: @union/@intersection/@difference
+#-----------------------------------------------------------------------------
+
+=head3 arrayops
+    Compute Union/Intersection/Difference for 2 unique lists
+
+    Arguments:
+      $flag - "U"/"I"/"D"
+      \@array1 - reference to an arrary
+      \@array2 - reference to an arrary
+    Returns:
+      @union/@intersection/@difference
+    Globals:
+      none
+    Error:
+      none
+    Example:
+      my @array = xCAT::CFMUtils->arrayops(\@array1, \@array2);
+
+=cut
+
+#-----------------------------------------------------------------------------
+sub arrayops {
+    my ($class, $ops, $array1, $array2) = @_;
+
+    my @union = ();
+    my @intersection = ();
+    my @difference = ();
+    my %count = ();
+    foreach my $element (@$array1, @$array2) 
+    { 
+        $count{$element}++ 
+    }
+
+    foreach my $element (keys %count) {
+        push @union, $element;
+        push @{ $count{$element} > 1 ? \@intersection : \@difference }, $element;
+    }
+
+    if ($ops eq "U") { return @union; }
+   
+    if ($ops eq "I") { return @intersection; }
+
+    if ($ops eq "D") { return @difference; }
+
+    #return (\@union, \@intersection, \@difference);
+}

perl-xCAT/xCAT/Client.pm

@@ -9,10 +9,7 @@ BEGIN
 # if AIX - make sure we include perl 5.8.2 in INC path.
 #       Needed to find perl dependencies shipped in deps tarball.
 if ($^O =~ /^aix/i) {
-        use lib "/usr/opt/perl5/lib/5.8.2/aix-thread-multi";
-        use lib "/usr/opt/perl5/lib/5.8.2";
-        use lib "/usr/opt/perl5/lib/site_perl/5.8.2/aix-thread-multi";
-        use lib "/usr/opt/perl5/lib/site_perl/5.8.2";
+	unshift(@INC, qw(/usr/opt/perl5/lib/5.8.2/aix-thread-multi /usr/opt/perl5/lib/5.8.2 /usr/opt/perl5/lib/site_perl/5.8.2/aix-thread-multi /usr/opt/perl5/lib/site_perl/5.8.2));
 }
 
 my $inet6support;
@@ -27,6 +24,15 @@ if ($inet6support) {
 if ($inet6support) {
    $inet6support = eval { require IO::Socket::SSL; IO::Socket::SSL->import('inet6'); 1;};
 }
+
+if ($^O =~ /^linux/i) {
+    # Is IPv6 enabled on the MN or xcat client node at all?
+    my $ipv6enabled = `ip addr | grep inet6`;
+    if (!$ipv6enabled) {
+        $inet6support = 0;
+    }
+}
+
 unless ($inet6support) {
   eval { require Socket };
   eval { require IO::Socket::INET };
@@ -119,7 +125,7 @@ sub submit_request {
   unless ($cafile) { $cafile  = $homedir."/.xcat/ca.pem"; }
   $xCAT::Client::EXITCODE = 0;    # clear out exit code before invoking the plugin
 if (ref($request) eq 'HASH') { # the request is an array, not pure XML
-   $request->{clienttype}->[0] = "cli";   # setup clienttype for auditlog
+ $request->{clienttype}->[0] = "cli";   # setup clienttype for auditlog
 }
 # If XCATBYPASS is set, invoke the plugin process_request method directly
 # without going through the socket connection to the xcatd daemon
@@ -129,6 +135,7 @@ if (ref($request) eq 'HASH') { # the request is an array, not pure XML
        if (!(defined($request->{username}))) {
          $request->{username}->[0] = getpwuid($>);
        }
+
        # only allow root to run
        unless ($request->{username}->[0] =~ /root/) {
          print ("WARNING: Only allow root to run XCATBYPASS mode, your current user ID is $request->{username}->[0].\n");
@@ -146,14 +153,16 @@ if (ref($request) eq 'HASH') { # the request is an array, not pure XML
        }
     } else {
        # figure out default plugins dir
-       my $sitetab=xCAT::Table->new('site');
-       unless ($sitetab) {
-         print ("ERROR: Unable to open basic site table for configuration\n");
-       }
+       #my $sitetab=xCAT::Table->new('site');
+       #unless ($sitetab) {
+       #  print ("ERROR: Unable to open basic site table for configuration\n");
+       #}
        $plugins_dir=$::XCATROOT.'/lib/perl/xCAT_plugin';
        scan_plugins();
     }
 
+    populate_site_hash();
+
   #  don't do XML transformation -- assume request is well-formed
   #  my $xmlreq=XMLout($request,RootName=>xcatrequest,NoAttr=>1,KeyAttr=>[]);
   #  $request = XMLin($xmlreq,SuppressEmpty=>undef,ForceArray=>1) ;
@@ -170,11 +179,28 @@ if (ref($request) eq 'HASH') { # the request is an array, not pure XML
   if ($ENV{XCATHOST}) {
     $xcathost=$ENV{XCATHOST};
   }
+  my %connargs=();
+  if ($xcathost =~ s/%([^\]|:]*)//) {
+      $connargs{PeerScope} = $1;
+  }
+  $connargs{PeerAddr} = $xcathost;
+  $connargs{Timeout} = 15;
+  if ($connargs{PeerScope} and $connargs{PeerScope} =~ /[a-zA-Z]/) { #non-numeric, need to translate...
+	my @ipdata = `ip link`;
+	@ipdata = grep(/[^@]$connargs{PeerScope}(:|@)/,@ipdata);
+	if (scalar(@ipdata) != 1) {
+		print STDERR "Unable to identify scope ".$connargs{PeerScope}."\n";
+		exit(1);
+	}
+	$connargs{PeerScope} = $ipdata[0];
+	$connargs{PeerScope} =~ s/:.*//;
+   }
+		
+	
   my $pclient;
   if ($inet6support) {
-  	$pclient = IO::Socket::INET6->new(
-    PeerAddr => $xcathost,
-    Timeout => 15,
+     $pclient = IO::Socket::INET6->new(
+	%connargs,
     );
   } else {
      $pclient = IO::Socket::INET->new(
@@ -198,12 +224,12 @@ if (ref($request) eq 'HASH') { # the request is an array, not pure XML
     SSL_cert_file => $certfile,
     SSL_ca_file => $cafile,
     SSL_use_cert => 1,
-     Timeout => 0,
-     );
+    Timeout => 0,
+   );
   } else {
-  	 $client =  IO::Socket::SSL->start_SSL($pclient,
-	                 Timeout => 0,
-	                );
+    $client =  IO::Socket::SSL->start_SSL($pclient,
+		 Timeout => 0,
+		);
   }
   unless ($client) {
      print "Unable to open socket connection to xcatd daemon on $xcathost.\n";
@@ -286,6 +312,7 @@ if (ref($request) eq 'HASH') { # the request is an array, not pure XML
   $massresponse="";
   unless ($cleanexit) {
      print STDERR "ERROR/WARNING: communication with the xCAT server seems to have been ended prematurely\n";
+     $xCAT::Client::EXITCODE = 1;
   }
 
 sub validateXML {
@@ -373,7 +400,6 @@ sub plugin_command {
   my $callback = shift;
   my %handler_hash;
   my $usesiteglobal = 0;
-
   # We require these only in bypass mode to reduce start up time for the normal case
   #use lib "$::XCATROOT/lib/perl";
   #use xCAT::NodeRange;
@@ -407,11 +433,6 @@ sub plugin_command {
     unless (@nodes) {
        $req->{emptynoderange} = [1];
     }
-
-    if(@nodes == 0 ) {
-        print "No nodes or noderanges specified\n";
-        return 1;
-     }
   }
   if (@nodes) { $req->{node} = \@nodes; }
   my %unhandled_nodes;
@@ -429,17 +450,18 @@ sub plugin_command {
       if ($hdlspec =~ /^site:/) { #A site entry specifies a plugin
           my $sitekey = $hdlspec;
           $sitekey =~ s/^site://;
-          $sitetab = xCAT::Table->new('site');
-          my $sent = $sitetab->getAttribs({key=>$sitekey},['value']);
-          if ($sent and $sent->{value}) { #A site style plugin specification is just like
+          #$sitetab = xCAT::Table->new('site');
+          #my $sent = $sitetab->getAttribs({key=>$sitekey},['value']);
+          #if ($sent and $sent->{value}) { #A site style plugin specification is just like
+          if ($::XCATSITEVALS{$sitekey}) { #A site style plugin specification is just like
                                           #a static global, it grabs all nodes rather than some
             $useglobals = -1; #If they tried to specify anything, don't use the default global handlers at all
             unless (@nodes) {
-              $handler_hash{$sent->{value}} = 1;
+              $handler_hash{$::XCATSITEVALS{$sitekey}} = 1;
               $usesiteglobal = 1;
             }
             foreach (@nodes) { #Specified a specific plugin, not a table lookup
-              $handler_hash{$sent->{value}}->{$_} = 1;
+              $handler_hash{$::XCATSITEVALS{$sitekey}}->{$_} = 1;
             }
           }
       } elsif ($hdlspec =~ /:/) { #Specificed a table lookup path for plugin name
@@ -538,7 +560,8 @@ sub plugin_command {
           }
       } #Otherwise, global handler is implicitly disabled
   } else {
-    return 1;  #TODO: error back that request has no known plugin for it
+     print "Error request: $req->{command}->[0]  has no known plugin for it.\n"; 
+    return 1;  
   }
   if ($useunhandled) {
    my $queuelist;
@@ -602,7 +625,10 @@ sub plugin_command {
         no strict  "refs";
 #       eval { #REMOVEEVALFORDEBUG
 #       if ($dispatch_requests) {
-                dispatch_request($req,$callback,$modname);
+        # backup the original req and recover it after the a run
+        my $org_req = {%$req};
+        dispatch_request($req,$callback,$modname);
+        $req = {%$org_req};
 #       } else {
 #          $SIG{CHLD}='DEFAULT';
 #          ${"xCAT_plugin::".$modname."::"}{process_request}->($req,$callback,\&do_request);
@@ -723,7 +749,7 @@ sub dispatch_request {
     if (ref $_->{'_xcatdest'} and (ref $_->{'_xcatdest'}) eq 'ARRAY') {
         _->{'_xcatdest'} =  $_->{'_xcatdest'}->[0];
     }
-    if ($onlyone and not ($_->{'_xcatdest'} and xCAT::Utils->thishostisnot($_->{'_xcatdest'}))) {
+    if ($onlyone and not ($_->{'_xcatdest'} and xCAT::NetworkUtils->thishostisnot($_->{'_xcatdest'}))) {
        $SIG{CHLD}='DEFAULT';
        ${"xCAT_plugin::".$modname."::"}{process_request}->($_,$dispatch_cb,\&do_request);
         return;
@@ -764,7 +790,7 @@ sub dispatch_request {
      my $request_satisfied=0;
      foreach $xcatdest (@xcatdests) {
         my $dlock;
-        if ($xcatdest and xCAT::Utils->thishostisnot($xcatdest)) {
+        if ($xcatdest and xCAT::NetworkUtils->thishostisnot($xcatdest)) {
 #----- added to Client.pm -----#
        $dispatch_cb->({warning=>['XCATBYPASS is set, skipping hierarchy call to '.$_->{'_xcatdest'}.'']});
 #----- end added to Client.pm -----#
@@ -895,11 +921,28 @@ sub build_response {
 
 }    # end of submit_request()
 
+####################################
+# populates all the site attributes into %::XCATSITEVALS
+# This is used with XCATBYPASS=1
+###################################
+sub populate_site_hash {
+    %::XCATSITEVALS=();
+    my $sitetab = xCAT::Table->new('site',-create=>0);
+    unless ($sitetab) { 
+       print ("ERROR: Unable to open basic site table for configuration\n");
+       return; 
+    }
+    my @records = $sitetab->getAllAttribs(qw/key value/);
+    foreach (@records) {
+        $::XCATSITEVALS{$_->{key}}=$_->{value};
+    }
+}
+
 
 
 ##########################################
-# handle_response is a default callback that can be passed into submit_response()
-# It is invoked repeatedly by submit_response() to print out the data returned by
+# handle_response is a default callback that can be passed into submit_request()
+# It is invoked repeatedly by submit_request() to print out the data returned by
 # the plugin.
 #
 # The normal flow is:
@@ -979,14 +1022,14 @@ sub build_response {
 ##########################################
 sub handle_response {
   my $rsp = shift;
-   if ($ENV{'XCATSHOWXML'}) {
+  if ($ENV{'XCATSHOWXML'}) {
     my  $xmlrec=XMLout($rsp,RootName=>'xcatresponse',NoAttr=>1,KeyAttr=>[]);
     print "$xmlrec\n";
    return;
   }
 #print "in handle_response\n";
   # Handle errors
-  if ($rsp->{errorcode}) {
+  if (defined($rsp->{errorcode})) {
     if (ref($rsp->{errorcode}) eq 'ARRAY') {
       foreach my $ecode (@{$rsp->{errorcode}}) { 
         $xCAT::Client::EXITCODE |= $ecode;
@@ -1000,22 +1043,38 @@ sub handle_response {
 #print "printing error\n";
     if (ref($rsp->{error}) eq 'ARRAY') {
       foreach my $text (@{$rsp->{error}}) {
-        print STDERR "Error: $text\n";
+        if ($rsp->{NoErrorPrefix}) {
+          print STDERR "$text\n";
+        } else {
+          print STDERR "Error: $text\n";
+        }
       }
     }
     else {
-      print ("Error: ".$rsp->{error}."\n");
+      if ($rsp->{NoErrorPrefix}) {
+           print STDERR ($rsp->{error}."\n");
+      } else {
+          print STDERR ("Error: ".$rsp->{error}."\n");
+      }
     }
   }
   if ($rsp->{warning}) {
 #print "printing warning\n";
     if (ref($rsp->{warning}) eq 'ARRAY') {
       foreach my $text (@{$rsp->{warning}}) {
-        print STDERR "Warning: $text\n";
+        if ($rsp->{NoWarnPrefix}) {
+          print STDERR "$text\n";
+        } else {
+          print STDERR "Warning: $text\n";
+        }
       }
     }
     else {
-      print ("Warning: ".$rsp->{warning}."\n");
+        if ($rsp->{NoWarnPrefix}) {
+           print STDERR ($rsp->{warning}."\n");
+        } else {
+           print STDERR ("Warning: ".$rsp->{warning}."\n");
+        }
     }
   }
   if ($rsp->{info}) {

perl-xCAT/xCAT/Common.pm

@@ -8,6 +8,7 @@ use File::stat;
 use File::Copy;
 use xCAT::Usage;
 use Thread qw/yield/;
+use Storable qw/store_fd fd_retrieve/;
 
 BEGIN
 {
@@ -29,19 +30,18 @@ sub forward_data {
   my $rfh;
   my $rc = @ready_fds;
   foreach $rfh (@ready_fds) {
-    my $data;
-    if ($data = <$rfh>) {
-      while ($data !~ /ENDOFFREEZE6sK4ci/) {
-        $data .= <$rfh>;
-      }
+    my $responses;
+    eval {
+    	$responses = fd_retrieve($rfh);
+    };
+    if ($@ and $@ =~ /^Magic number checking on storable file/) { #this most likely means we ran over the end of available input
+      $fds->remove($rfh);
+      close($rfh);
+    } else {
       eval { print $rfh "ACK\n"; }; #Ignore ack loss due to child giving up and exiting, we don't actually explicitly care about the acks
-      my $responses=thaw($data);
       foreach (@$responses) {
         $callback->($_);
       }
-    } else {
-      $fds->remove($rfh);
-      close($rfh);
     }
   }
   yield(); #Try to avoid useless iterations as much as possible
@@ -62,8 +62,7 @@ sub send_data {
     foreach(@_) {
       my %output;
       if (ref($_) eq HASH) {
-          print $out freeze([$_]);
-          print $out "\nENDOFFREEZE6sK4ci\n";
+	  store_fd([$_],$out);
           yield();
           waitforack($out);
           next;
@@ -97,8 +96,7 @@ sub send_data {
       } else {
           $output{node}->[0]->{data}->[0]->{contents}->[0]=$text;
       }
-      print $out freeze([\%output]);
-      print $out "\nENDOFFREEZE6sK4ci\n";
+      store_fd([\%output],$out);
       yield();
       waitforack($out);
     }

perl-xCAT/xCAT/DBobjUtils.pm

@@ -16,6 +16,7 @@ require xCAT::Table;
 require xCAT::Utils;
 require xCAT::MsgUtils;
 require xCAT::NetworkUtils;
+require xCAT::ServiceNodeUtils;
 use strict;
 
 #  IPv6 not yet implemented - need Socket6
@@ -56,7 +57,7 @@ sub getObjectsOfType
 
     # The database may be changed between getObjectsOfType calls
     # do not use cache %::saveObjList  if --nocache is specified
-    if ($::saveObjList{$type} && !$::opt_c)
+    if ($::saveObjList{$type} && !$::opt_nc)
     {
         @objlist = @{$::saveObjList{$type}};
     }
@@ -199,7 +200,8 @@ sub getobjattrs
             # list of object names
             foreach my $table (keys %tableattrs) {
                 # open the table
-                my $thistable = xCAT::Table->new($table, -create => 1, -autocommit => 0);
+                # with autocommit => 0, it does not work on Ubuntu running mysql
+                my $thistable = xCAT::Table->new($table, -create => 1, -autocommit => 1);
                 if (!$thistable) {
                     my $rsp;
                     $rsp->{data}->[0] = "Could not open the \'$table\' table.";
@@ -395,6 +397,44 @@ sub getobjdefs
                     xCAT::MsgUtils->message("E", $rsp, $::callback);	
                 }
             }
+        } elsif (($objtype eq 'auditlog') || ($objtype eq 'eventlog')) {
+            # Special case for auditlog/eventlog
+            # All the auditlog/eventlog attributes are in auditlog/eventlog table,
+            # Do not need to read the table multiple times for each attribute.
+            # The auditlog/eventlog is likely be very big over time,
+            # performance is a big concern with the general logic
+            my @TableRowArray = xCAT::DBobjUtils->getDBtable($objtype);
+            foreach my $objname (sort @{$type_obj{$objtype}}) {
+                if (@TableRowArray)
+                {
+                    my $foundinfo = 0;
+                    foreach my $entry (@TableRowArray)
+                    {
+                        if ($entry->{recid} eq $objname)
+                        {
+                            foreach my $k (keys %{$entry})
+                            {
+                                # recid is the object name, do not need to be in the attributes list
+                                if ($k eq 'recid') { next; }
+                                if (defined($entry->{$k}) ) {
+                                    $foundinfo++;
+                                    if ($verbose == 1) {
+                                        $objhash{$objname}{$k} = "$entry->{$k}\t(Table:$objtype - Key:$k)";
+                                    } else {
+                                        $objhash{$objname}{$k} = $entry->{$k};
+                                    }
+                                }
+                            }
+                            if ($foundinfo)
+                            {
+                                $objhash{$objname}{'objtype'} = $objtype;
+                            }
+                            # There should not be multiple entries with the same recid
+                            last;
+                        } # end if($entry->
+                    } # end foreach my $entry
+               } # end if(@TableTowArray
+           } # end foreach my $objname
         } else {
             # get the object type decription from Schema.pm
             my $datatype = $xCAT::Schema::defspec{$objtype};
@@ -567,7 +607,7 @@ sub getDBtable
 
 	# save this table info - in case this subr gets called multiple times
     # --nocache flag specifies not to use cahe
-    if (grep(/^$table$/, @::foundTableList) && !$::opt_c)
+    if (grep(/^$table$/, @::foundTableList) && !$::opt_nc)
     {
 
         # already have this
@@ -1123,7 +1163,7 @@ sub setobjdefs
 			        xCAT::MsgUtils->message("W", $rsp, $::callback);
                              } else {
                                 my $rsp;
-			        $rsp->{data}->[0] = "$em is not in the atrribute of \'$attr_name\' for the \'$objname\' definition.";
+			        $rsp->{data}->[0] = "$em is not in the attribute of \'$attr_name\' for the \'$objname\' definition.";
 			        xCAT::MsgUtils->message("W", $rsp, $::callback);
                              }
                         }
@@ -1640,7 +1680,14 @@ sub readFileInput
 
             $look_for_colon = 0;    # ok - we have a colon
 
-            ($objectname, $junk2) = split(/:/, $l);
+            # Remove any trailing whitespace
+            $l =~ s/\s*$//;
+
+            # IPv6 network names could be something like fd59::/64
+            # Use all the characters before the last ":" as the object name
+            # .* means greedy regular expression
+            $l =~ /^(.*):(.*?)$/;
+            ($objectname, $junk2) = ($1, $2);
 
             # if $junk2 is defined or there's an = 
             if ($junk2 || grep(/=/, $objectname))
@@ -1956,15 +2003,18 @@ sub getNetwkInfo
                                     if (xCAT::Utils->isMN() && !$nethash{$node}{'gateway'})
                                     {
                                         # does not have ip address in this subnet,
-                                        # use the node attribute 'xcatmaster'
-                                        my $noderestab = xCAT::Table->new('noderes');
-                                        my $et = $noderestab->getNodeAttribs($node, ['xcatmaster']);
-                                        if ($et and defined($et->{'xcatmaster'}))
-                                        {
-                                            my $value = $et->{'xcatmaster'};
-                                            $nethash{$node}{'gateway'} = xCAT::NetworkUtils->getipaddr($value);
-                                        }
-                                        $noderestab->close();
+                                        # use the node attribute 'xcatmaster' or site.master
+                                        my @nodes = ("$node");
+                                        my $sn = xCAT::ServiceNodeUtils->get_ServiceNode(\@nodes,"xcat","Node");
+                                        my $snkey = (keys %{$sn})[0];
+                                        my $gw = xCAT::NetworkUtils->getipaddr($snkey);
+                                        # two possible cases when this code is run:
+                                        # 1. flat cluster: ip forwarding is not enabled on MN
+                                        # 2. hw ctrl in hierarchy cluster, in which HCP SN is not set
+                                        # in either case, MN itself should not be the gateway
+                                         if (xCAT::NetworkUtils->thishostisnot($gw)) {
+                                             $nethash{$node}{'gateway'} = $gw;
+                                         }
                                     }
                                 
                                 }
@@ -2115,7 +2165,7 @@ sub getchildren
           $::RUNCMD_RC = 1; 
           return undef; 
         }
-        my @ps = $ppctab->getAllNodeAttribs(['node','parent','nodetype']);
+        my @ps = $ppctab->getAllNodeAttribs(['node','parent','nodetype','hcp']);
         foreach my $entry ( @ps ) {
             my $p = $entry->{parent};
             my $c = $entry->{node};
@@ -2126,13 +2176,19 @@ sub getchildren
                     # build hash of ppc.parent -> ppc.node 
                     push @{$PPCHASH{$p}}, $c;
                 }   
+                elsif ($t eq 'blade') {
+                    push @{$PPCHASH{$c}}, $entry->{hcp};
+                }
               } else { # go look in the nodetype table to find nodetype 
-                 my $type = getnodetype($c);
+                 my $type = getnodetype($c, "ppc");
                  if ( $type eq 'fsp' or $type eq 'bpa')
                  {
                      # build hash of ppc.parent -> ppc.node 
                       push @{$PPCHASH{$p}}, $c;
                  }
+                 elsif ($type eq "blade") {
+                     push @{$PPCHASH{$c}}, $entry->{hcp};
+                 }
               }
             }  # not $p and $c
         }
@@ -2557,4 +2613,170 @@ sub judge_node
       
     return $flag;            
 }
+
+
+#-------------------------------------------------------------------------------
+
+=head3   expandnicsattr
+    Expand the nics related attributes into the readable format,
+    for example, the nicsips=eth0!1.1.1.1|2.1.1.1,eth1!3.1.1.1|4.1.1.1
+    expanded format:
+    nicsips.eth0=1.1.1.1|2.1.1.1
+    nicsips.eth1=3.1.1.1|4.1.1.1
+
+    Arguments:
+        nicsattr value, like niccsips=eth0!1.1.1.1|2.1.1.1,eth1!3.1.1.1|4.1.1.1 
+        nicnames: only return the value for specific nics, like "eth0,eth1"
+    Returns:
+        expanded format, like:
+        nicsips.eth0=1.1.1.1|2.1.1.1
+        nicsips.eth1=3.1.1.1|4.1.1.1
+    Error:
+        none
+
+    Example:
+        my $nicsstr = xCAT::DBobjUtils->expandnicsattr($attrval);
+
+    Comments:
+        none
+=cut
+
+#-------------------------------------------------------------------------------
+sub expandnicsattr()
+{
+    my $nicstr = shift;
+    if (($nicstr) && ($nicstr =~ /xCAT::/))
+    {
+        $nicstr = shift;
+    }
+    my $nicnames = shift;
+
+    my $ret; 
+
+    $nicstr =~ /^(.*?)=(.*?)$/;
+
+    #Attribute: nicips, nichostnamesuffix, etc.
+    my $nicattr = $1;
+
+    # Value: eth0!1.1.1.1|2.1.1.1,eth1!3.1.1.1|4.1.1.1
+    my $nicval=$2;
+
+    # $nicarr[0]: eth0!1.1.1.1|2.1.1.1
+    # $nicarr[1]: eth1!3.1.1.1|4.1.1.1 
+    my @nicarr = split(/,/, $nicval);
+    
+    foreach my $nicentry (@nicarr)
+    {
+        #nicentry: eth0!1.1.1.1|2.1.1.1
+        # $nicv[0]: eth0
+        # $nicv[1]: 1.1.1.1|2.1.1.1
+        my @nicv = split(/!/, $nicentry);
+
+        # only return nic* attr for these specific nics
+        if ($nicnames)
+        {
+            my @nics = split(/,/, $nicnames);
+            if ($nicv[0])
+            {
+                # Do not need to return the nic attr for this nic
+                if (!grep(/^$nicv[0]$/, @nics))
+                {
+                    next;
+                }
+            }
+        }
+
+        # ignore the line that does not have nicname or value
+        if ($nicv[0] && $nicv[1])
+        {
+            $ret .= "    $nicattr.$nicv[0]=$nicv[1]\n";
+        }
+    }
+
+    chomp($ret);
+    return $ret;
+
+}
+
+
+#-------------------------------------------------------------------------------
+
+=head3   collapsenicsattr
+    Collapse the nics related attributes into the database format,
+    for example, 
+    nicsips.eth0=1.1.1.1|2.1.1.1
+    nicsips.eth1=3.1.1.1|4.1.1.1
+    
+    the collapsed format:
+    nicsips=eth0!1.1.1.1|2.1.1.1,eth1!3.1.1.1|4.1.1.1
+    
+    The collapse will be done against the hash %::FILEATTRS or %::CLIATTRS,
+    remove the nicips.thx attributes from %::FILEATTRS or %::CLIATTRS,
+    add the collapsed info nicips into %::FILEATTRS or %::CLIATTRS.
+
+    Arguments:
+        $::FILEATTRS{$objname} or $::CLIATTRS{$objname}
+        $objname
+
+    Returns:
+        None, update %::FILEATTRS or %::CLIATTRS directly
+
+    Error:
+        none
+
+    Example:
+        xCAT::DBobjUtils->collapsenicsattr($nodeattrhash);
+
+    Comments:
+        none
+=cut
+
+#-------------------------------------------------------------------------------
+sub collapsenicsattr()
+{
+    my $nodeattrhash = shift;
+    if (($nodeattrhash) && ($nodeattrhash =~ /xCAT::/))
+    {
+        $nodeattrhash = shift;
+    }
+    my $objname = shift;
+
+    my %nicattrs = ();
+    foreach my $nodeattr (keys %{$nodeattrhash})
+    {       
+        # e.g nicips.eth0
+        # do not need to handle nic attributes without the postfix .ethx,
+        # it will be overwritten by the attributes with the postfix .ethx,
+        if ($nodeattr =~ /^(nic\w+)\.(\w+)$/)
+        {       
+           if ($1 && $2)
+           {       
+               # chdef <noderange> nicips.eth2= to remove the definition for eth2
+               # in this case, the $nodeattrhash->{'nicips.eth0'} is blank
+               if ($nodeattrhash->{$nodeattr})
+               {
+                   # $nicattrs{nicips}{eth0} = "1.1.1.1|1.2.1.1"
+                   $nicattrs{$1}{$2} = $nodeattrhash->{$nodeattr}; 
+               }
+
+               # remove nicips.eth0 from the %::FILEATTRS
+               delete $nodeattrhash->{$nodeattr};
+           }       
+        }       
+    }       
+    # $nicattrs{'nicips'}{'eth0'} = "1.1.1.1|1.2.1.1"
+    # $nicattrs{'nicips'}{'eth1'} = "2.1.1.1|2.2.1.1"
+    foreach my $nicattr (keys %nicattrs)
+    {       
+       my @tmparray = ();
+       foreach my $nicname (keys %{$nicattrs{$nicattr}})
+       {       
+           # eth0!1.1.1.1|1.2.1.1
+           push @tmparray, "$nicname!$nicattrs{$nicattr}{$nicname}";
+       }       
+       # eth0!1.1.1.1|1.2.1.1,eth1!2.1.1.1|2.2.1.1
+       $nodeattrhash->{$nicattr} = join(',', @tmparray);
+    }       
+}
+
 1;

perl-xCAT/xCAT/DSHCore.pm

@@ -159,6 +159,100 @@ no strict;
 use strict;
 }
 
+
+#---------------------------------------------------------------------------
+
+=head3
+        fork_output_for_commands
+
+        Forks a process for the given command array and returns the process
+        ID for the forked process and references to all I/O pipes for STDOUT
+        and STDERR. In the child process, it will invoke the xCAT::DSHCore->fork_no_output()
+        for the first command which is a no-output command and waitpid(). And then execute 
+        the left commands in the child process.
+
+        Arguments:
+        	$fork_id - unique identifer to use for tracking the forked process
+        	@command - command and parameter array to execute in the forkec process
+
+        Returns:
+        	$pid - process identifer for the forked process
+                
+        Globals:
+        	None
+    
+        Error:
+        	None
+    
+        Example:
+        	$pid = xCAT::DSHCore->fork_output_for_commands('hostname1PID', @command_array);
+
+        Comments:
+
+=cut
+
+#---------------------------------------------------------------------------
+
+
+sub fork_output_for_commands
+{
+    my ($class, $fork_id, @commands) = @_;
+no strict;
+    my $pid;
+    my %pipes = ();
+
+    my $rout_fh = "rout_$fork_id";
+    my $rerr_fh = "rerr_$fork_id";
+    my $wout_fh = "wout_$fork_id";
+    my $werr_fh = "werr_$fork_id";
+
+    (pipe($rout_fh, $wout_fh) == -1) && return (-1, undef);
+    (pipe($rerr_fh, $werr_fh) == -1) && return (-2, undef);
+
+    if ($pid = fork)
+    {
+        close($wout_fh);
+        close($werr_fh);
+    }
+
+    elsif (defined $pid)
+    {
+        close($rout_fh);
+        close($rerr_fh);
+
+        !(open(STDOUT, ">&$wout_fh")) && return (-5, undef);
+        !(open(STDERR, ">&$werr_fh")) && return (-6, undef);
+
+        select(STDOUT);
+        $| = 1;
+        select(STDERR);
+        $| = 1;
+        if ( @commands > 1 )  {
+            my $command0 = shift(@commands);       
+            my @exe_command0_process = xCAT::DSHCore->fork_no_output($fork_id, @$command0); 
+            waitpid($exe_command0_process[0], undef);
+        }
+       
+        my $t_command = shift(@commands);
+        my @command = @$t_command; 
+        if (!(exec {$command[0]} @command))
+        {
+            return (-4, undef);
+        }
+
+    }
+    else
+    {
+        return (-3, undef);
+    }
+
+    return ($pid, *$rout_fh, *$rerr_fh, *$wout_fh, *$werr_fh);
+use strict;
+}
+
+
+
+
 #---------------------------------------------------------------------------
 
 =head3
@@ -396,7 +490,7 @@ sub pipe_handler
                       || print STDOUT
                       "dsh>  Error_file_closed $$target_properties{hostname} $output_file\n";
                     my $rsp={};
-                    $rsp->{data}->[0] =
+                    $rsp->{error}->[0] =
                       "Error_file_closed $$target_properties{hostname $output_file}.\n";
                     xCAT::MsgUtils->message("E", $rsp, $::CALLBACK);
                     ($output_file == $$target_properties{'output-fh'})
@@ -575,55 +669,6 @@ sub pipe_handler_buffer
     return $eof_reached;
 }
 
-#---------------------------------------------------------------------------
-
-=head3
-        fping_hostnames
-
-        Executes fping on a given list of hostnames and returns a list of those
-        hostnames that did not respond
-
-        Arguments:
-        	@hostnames - list of hostnames to execute for fping
-
-        Returns:
-        	@no_response - list of hostnames that did not respond
-        	undef if fping is not installed
-                
-        Globals:
-        	None
-    
-        Error:
-        	None
-    
-        Example:
-        	@bad_hosts = xCAT::DSHCore->fping_hostnames(@host_list);
-
-        Comments:
-
-=cut
-
-#---------------------------------------------------------------------------
-
-sub fping_hostnames
-{
-    my ($class, @hostnames) = @_;
-
-    my $fping = (-x '/usr/sbin/fping') || undef;
-    !$fping && return undef;
-
-    my @output = `/usr/sbin/fping -B 1.0 -r 1 -t 50 -i 10 -p 50 @hostnames`;
-
-    my @no_response = ();
-    foreach my $line (@output)
-    {
-        my ($hostname, $token, $status) = split ' ', $line;
-        !(($token eq 'is') && ($status eq 'alive'))
-          && (push @no_response, $hostname);
-    }
-
-    return @no_response;
-}
 
 #---------------------------------------------------------------------------
 
@@ -709,12 +754,24 @@ sub pping_hostnames
     my ($class, @hostnames) = @_;
 
     my $hostname_list = join ",", @hostnames;
+    # read site table, usefping attribute
+    # if set then run pping -f to use fping
+    # this fixes a broken nmap in Redhat 6.2 with ip alias (3512)
+    my $cmd="$::XCATROOT/bin/pping $hostname_list";  # default
+    my @usefping=xCAT::TableUtils->get_site_attribute("usefping");
+    if ((defined($usefping[0])) && ($usefping[0] eq "1")) {
+       $cmd = "$::XCATROOT/bin/pping -f  $hostname_list";
+    }
+    #my $rsp={};
+    #$rsp->{data}->[0] = "running command $cmd";
+    #xCAT::MsgUtils->message("I", $rsp, $::CALLBACK);
+
     my @output =
-      xCAT::Utils->runcmd("$::XCATROOT/bin/pping $hostname_list", -1);
+      xCAT::Utils->runcmd($cmd, -1);
       if ($::RUNCMD_RC !=0) {
         my $rsp={};
-        $rsp->{data}->[0] = "Error from pping";
-        xCAT::MsgUtils->message("I", $rsp, $::CALLBACK);
+        $rsp->{error}->[0] = "Error from pping";
+        xCAT::MsgUtils->message("E", $rsp, $::CALLBACK);
       }
      $::RUNCMD_RC =0; # reset
     my @no_response = ();

perl-xCAT/xCAT/DiscoveryUtils.pm

@@ -0,0 +1,96 @@
+#!/usr/bin/env perl
+# IBM(c) 2013 EPL license http://www.eclipse.org/legal/epl-v10.html
+
+package xCAT::DiscoveryUtils;
+
+use strict;
+use XML::Simple;
+$XML::Simple::PREFERRED_PARSER='XML::Parser';
+
+use xCAT::MsgUtils;
+
+=head3 update_discovery_data 
+ Update the discovery data from the xcat request to discoverydata table to indicate the discovery events
+ arg1 - the request
+ 
+=cut
+
+sub update_discovery_data {
+    my $class = shift;
+    my $request = shift;
+    
+    my %disdata;
+    my %otherdata;
+
+    unless ($request->{'uuid'}->[0]) {
+        xCAT::MsgUtils->message("S", "Discovery Error: Found a node without uuid");
+    }
+
+    if ($request->{'discoverymethod'}->[0]) {
+        $disdata{'method'} = $request->{'discoverymethod'}->[0];
+    } else {
+        $disdata{'method'} = "undef";
+    }
+
+    #discoverytime
+    my ($sec,  $min,  $hour, $mday, $mon, $year, $wday, $yday, $isdst) = localtime(time);
+    my $currtime = sprintf("%02d-%02d-%04d %02d:%02d:%02d",
+    	      $mon + 1, $mday, $year + 1900, $hour, $min, $sec);
+    $disdata{'discoverytime'} = $currtime;
+
+    foreach my $attr (keys %$request) {
+        if ($attr =~ /^(command|discoverymethod|_xcat|cacheonly|noderange|environment|method|discoverytime|updateswitch)/) {
+            next;
+        } elsif ($attr =~ /^(node|uuid|arch|cpucount|cputype|memory|mtm|serial)$/) {
+            $disdata{$attr} = $request->{$attr}->[0];
+        } elsif ($attr eq 'nic') {
+            # Set the nics attributes
+            foreach my $nic (@{$request->{nic}}) {
+                my  $nicname = $nic->{'devname'}->[0];
+                foreach my $nicattr (keys %$nic) {
+                    my $tbattr;
+                    if ($nicattr eq 'driver') {
+                        $tbattr = "nicdriver";
+                    } elsif ($nicattr eq 'ip4address') {
+                        $tbattr = "nicipv4";
+                    } elsif ($nicattr eq 'hwaddr') {
+                        $tbattr = "nichwaddr";
+                    } elsif ($nicattr eq 'pcidev') {
+                        $tbattr = "nicpci";
+                    } elsif ($nicattr eq 'location') {
+                        $tbattr = "nicloc";
+                    } elsif ($nicattr eq 'onboardeth') {
+                        $tbattr = "niconboard";
+                    } elsif ($nicattr eq 'firmdesc') {
+                        $tbattr = "nicfirm";
+                    } elsif ($nicattr =~ /^(switchname|switchaddr|switchdesc|switchport)$/) {
+                        $tbattr = $nicattr;
+                    }
+
+                    if ($tbattr) {
+                        if ($disdata{$tbattr}) {
+                            $disdata{$tbattr} .= ','.$nicname.'!'.$nic->{$nicattr}->[0];
+                        } else {
+                            $disdata{$tbattr} = $nicname.'!'.$nic->{$nicattr}->[0];
+                        }
+                    }
+                }
+            }
+        } else {
+            # store to otherdata for the not parsed attributes
+            $otherdata{$attr} = $request->{$attr};
+        }
+    }
+
+    if (keys %otherdata) {
+        $disdata{'otherdata'} = XMLout(\%otherdata,RootName=>'discoveryotherdata' ,NoAttr=>1);
+    }
+
+    my $distab = xCAT::Table->new('discoverydata');
+    if ($distab) {
+      $distab->setAttribs({uuid=>$request->{'uuid'}->[0]},\%disdata);
+      $distab->close();
+    }
+}
+
+1;

perl-xCAT/xCAT/ExtTab.pm

@@ -35,7 +35,7 @@ foreach (@extSchema) {
     if ($@) { 
 	$warning ="Warning: The user defined database table schema file $file cannot be located or has compiling errors.\n";
         print $warning;
-        `logger -t xCAT $warning`; 
+        `logger -p local4.warning -t xCAT $warning`; 
 	next;
     }   
     if (${"xCAT_schema::" . "$modname" . "::"}{tabspec}) {
@@ -44,7 +44,7 @@ foreach (@extSchema) {
             if (exists($ext_tabspec{$tabname})) {
 		$warning = "Warning: File $file: the table name $tabname is used by other applications. Please rename the table.\n";
                 print $warning;
-               `logger -t xCAT $warning`; 
+               `logger -p local4.warning -t xCAT $warning`; 
 	    } else {
 		$ext_tabspec{$tabname}=$tabspec{$tabname};
 	    }
@@ -52,7 +52,7 @@ foreach (@extSchema) {
     } else {
 	$warning ="\n  Warning: Cannot find \%tabspec variable in the user defined database table schema file $file\n";
          print $warning;
-         `logger -t xCAT $warning`; 
+         `logger -p local4.warning -t xCAT $warning`; 
     }
    
     #get the defspec from each file and merge them into %ext_defspec
@@ -74,7 +74,7 @@ foreach (@extSchema) {
 			if (exists($tmp_hash{$attrname})) {
 			    $warning= "  Warning: Conflict when adding user defined defspec from file $file. Attribute name $attrname is already defined in object $objname.  \n";
                             print $warning;
-                           `logger -t xCAT $warning`; 
+                           `logger  -p local4.warning  -t xCAT $warning`; 
 			} else {
 			    #print "\ngot here objname=$objname, attrname=" . $h->{attr_name} . "\n";
 			    push(@{$ext_defspec{$objname}->{'attrs'}}, $h); 

perl-xCAT/xCAT/FSPUtils.pm

@@ -10,10 +10,7 @@ BEGIN
 # if AIX - make sure we include perl 5.8.2 in INC path.
 #       Needed to find perl dependencies shipped in deps tarball.
 if ($^O =~ /^aix/i) {
-        use lib "/usr/opt/perl5/lib/5.8.2/aix-thread-multi";
-        use lib "/usr/opt/perl5/lib/5.8.2";
-        use lib "/usr/opt/perl5/lib/site_perl/5.8.2/aix-thread-multi";
-        use lib "/usr/opt/perl5/lib/site_perl/5.8.2";
+	unshift(@INC, qw(/usr/opt/perl5/lib/5.8.2/aix-thread-multi /usr/opt/perl5/lib/5.8.2 /usr/opt/perl5/lib/site_perl/5.8.2/aix-thread-multi /usr/opt/perl5/lib/site_perl/5.8.2));
 }
 
 use lib "$::XCATROOT/lib/perl";
@@ -26,9 +23,10 @@ require xCAT::InstUtils;
 require xCAT::NetworkUtils;
 require xCAT::Schema;
 require xCAT::Utils;
+require xCAT::TableUtils;
 #use  Data::Dumper;
 require xCAT::NodeRange;
-
+use xCAT::MsgUtils qw(verbose_message);
 
         
  #-------------------------------------------------------------------------------
@@ -69,7 +67,7 @@ sub getHcpAttribs
 	}
     }
     
-    my @ps = $tabs->{ppc}->getAllNodeAttribs(['node','parent','nodetype']); 
+    my @ps = $tabs->{ppc}->getAllNodeAttribs(['node','parent','nodetype','hcp']); 
     for my $entry ( @ps ) {
         my $tmp_parent = $entry->{parent};
         my $tmp_node = $entry->{node};
@@ -78,6 +76,9 @@ sub getHcpAttribs
             push @{$ppchash{$tmp_parent}{children}}, $tmp_node;
 	    #push @{$ppchash{$tmp_parent}}, $tmp_node;
         }
+        if (defined($tmp_node) && defined($tmp_type) && ($tmp_type eq "blade") && defined($entry->{hcp})) {
+            push @{$ppchash{$tmp_node}{children}}, $entry->{hcp};
+        }
 
 	#if(exists($ppchash{$tmp_node})) {
 	#     if( defined($tmp_type) ) {
@@ -133,7 +134,7 @@ sub getIPaddress
     my $type       = shift;
     my $nodetocheck = shift;
     my $port        = shift;
-    if (xCAT::Utils::isIpaddr($nodetocheck)) {
+    if (xCAT::NetworkUtils::isIpaddr($nodetocheck)) {
         return $nodetocheck;
     }
     my $side = "[A|B]";
@@ -175,6 +176,8 @@ sub getIPaddress
 	    #the $nodetocheck is its' hcp. So set $nodetocheck to $parent variable. 
 	    #And then get the FSPs IPs for the CEC. 
             $parent = $nodetocheck;
+        } elsif ($type eq "blade") {
+            return $ppc->{$nodetocheck}->{children}->[0];
         } else {
             return undef;
         }
@@ -191,7 +194,7 @@ sub getIPaddress
             if ($tmp_s and $tmp_s =~ /^$side-$port$/i) {
                 $tmp_s =~ s/a/A/;
                 $tmp_s =~ s/b/B/;
-                if (xCAT::Utils::isIpaddr($tmp_n)) {
+                if (xCAT::NetworkUtils::isIpaddr($tmp_n)) {
                     $node_side_pairs{$tmp_s} = $tmp_n;           
                     $children_num++;
                 } else {
@@ -285,6 +288,7 @@ sub fsp_api_action {
     }
     $id = $$attrs[0];
     $fsp_name = $$attrs[3]; 
+    xCAT::MsgUtils->verbose_message($request, "fsp_api_action START node:$node_name,type:$$attrs[4].");
     if($$attrs[4] =~ /^fsp$/ || $$attrs[4] =~ /^lpar$/ || $$attrs[4] =~ /^cec$/) {
         $type = 0;
 	    $fsp_bpa_type="fsp";
@@ -307,7 +311,7 @@ sub fsp_api_action {
     } else {
         $fsp_ip = getIPaddress($request, $$attrs[4], $fsp_name );
     }
-
+    xCAT::MsgUtils->verbose_message($request, "fsp_api_action getIPaddress:$fsp_ip.");
     if(!defined($fsp_ip)) {
         $res = "Failed to get IP address for $fsp_name or the related FSPs/BPAs.";
         return ([$node_name, $res, -1]);	
@@ -348,7 +352,7 @@ sub fsp_api_action {
     }
 
     my $cmd;
-    my $install_dir = xCAT::Utils->getInstallDir();
+    my $install_dir = xCAT::TableUtils->getInstallDir();
     if( $action =~ /^(code_update|get_compatible_version_from_rpm)$/) { 
         $cmd = "$fsp_api -a $action -T $tooltype -t $type:$fsp_ip:$id:$node_name:$parameter -d $install_dir/packages_fw/";
     } elsif($action =~ /^code_updateD$/) {
@@ -364,14 +368,22 @@ sub fsp_api_action {
             } elsif( $parameter !=0 && $action =~ /^(on|reset)$/ ) {
                 #powerinterval for lpars power on
                 $cmd = "$fsp_api -a $action -i $parameter -T $tooltype -t $type:$fsp_ip:$id:$node_name:";
+            } elsif ($action =~ /^part_set_lpar_def_state$/) {
+                $cmd = "$fsp_api -a $action -T $tooltype -s $parameter -t $type:$fsp_ip:$id:$node_name:";
+            } elsif (exists($request->{opt}->{vios})) {
+                $cmd = "$fsp_api -a $action -T $tooltype -s 1 -t $type:$fsp_ip:$id:$node_name:$parameter";
             } else {
                 $cmd = "$fsp_api -a $action -T $tooltype -t $type:$fsp_ip:$id:$node_name:$parameter";
             }
         } else {
-            $cmd = "$fsp_api -a $action -T $tooltype -t $type:$fsp_ip:$id:$node_name:";
+            if (exists($request->{opt}->{vios})) {
+                $cmd = "$fsp_api -a $action -T $tooltype -s 1 -t $type:$fsp_ip:$id:$node_name:";
+            } else {
+                $cmd = "$fsp_api -a $action -T $tooltype -t $type:$fsp_ip:$id:$node_name:";
+            }
         }
     }
-
+    xCAT::MsgUtils->verbose_message($request, "fsp_api_action cmd:$cmd.");
     #print "cmd: $cmd\n"; 
     $SIG{CHLD} = 'DEFAULT'; 
     # secure passwords in verbose mode
@@ -393,6 +405,7 @@ sub fsp_api_action {
     if(defined($res)) {
         $res =~ s/$node_name: //g;
     }
+    xCAT::MsgUtils->verbose_message($request, "fsp_api_action return:$Rc.");
     return( [$node_name,$res, $Rc] ); 
 }
 
@@ -444,6 +457,7 @@ sub fsp_state_action {
     $fsp_name = $node_name; 
 
      
+    xCAT::MsgUtils->verbose_message($request, "fsp_state_action START node:$node_name,type:$$attrs[4].");
     if( $$attrs[4] =~ /^(fsp|lpar|cec|blade)$/) {
         $type = 0;
     } else { 
@@ -459,11 +473,13 @@ sub fsp_state_action {
         return ([-1, $res[0]]);	
     }
 	
+    xCAT::MsgUtils->verbose_message($request, "fsp_state_action getIPaddress:$fsp_ip.");
     #print "fsp name: $fsp_name\n";
     #print "fsp ip: $fsp_ip\n";
     my $cmd;
     #$cmd = "$fsp_api -a $action -u $user -p $password -T $tooltype -t $type:$fsp_ip:$id:$node_name:";
     $cmd = "$fsp_api -a $action -T $tooltype -t $type:$fsp_ip:$id:$node_name:";
+    xCAT::MsgUtils->verbose_message($request, "fsp_state_action cmd:$cmd.");
     #print "cmd: $cmd\n"; 
     $SIG{CHLD} = 'DEFAULT'; 
     @res = xCAT::Utils->runcmd($cmd, -1);
@@ -477,6 +493,7 @@ sub fsp_state_action {
     if( @res ) {
         $res[0] =~ s/$node_name: //g;
     }
+    xCAT::MsgUtils->verbose_message($request, "fsp_state_action return:$Rc.");
     return( [$Rc,@res] ); 
 }
 

perl-xCAT/xCAT/FSPboot.pm

@@ -215,7 +215,7 @@ sub rnetboot {
     my $options = $request->{opt};
     my $hwtype  = @$exp[2];
     my $result;
-    my $name;
+    my $name    = $request->{node};
     my $callback = $request->{callback};
     #####################################
     # Get node data 
@@ -238,6 +238,13 @@ sub rnetboot {
         C => $o->{client},
         m => $o->{mac}
     );
+    #####################################
+    # Parse node range
+    #####################################
+    if ($name =~ /ARRAY/) {
+        $name = join(',', @$name);
+    }
+
     #####################################
     # Strip colons from mac address 
     #####################################

perl-xCAT/xCAT/FSPbootseq.pm

@@ -7,6 +7,7 @@ use Getopt::Long;
 use xCAT::PPCcli qw(SUCCESS EXPECT_ERROR RC_ERROR NR_ERROR);
 use xCAT::NetworkUtils;
 use xCAT::FSPUtils;
+use xCAT::MsgUtils qw(verbose_message);
 #use Data::Dumper;
 
 ##########################################################################
@@ -46,7 +47,7 @@ sub parse_args {
     $Getopt::Long::ignorecase = 0;
     Getopt::Long::Configure( "bundling" );
 
-    if ( !GetOptions( \%opt,qw(h|help V|Verbose v|version ))) { 
+    if ( !GetOptions( \%opt,qw(h|help V|verbose v|version ))) { 
         return( usage() );
     }
     ####################################
@@ -135,12 +136,13 @@ sub rbootseq {
     #print "d"; 
     #print Dumper($d);
   
-         
+    xCAT::MsgUtils->verbose_message($request, "rbootseq START for node:$node_name, type=$$d[4].");        
     if (!($$d[4] =~ /^(lpar|blade)$/)) { 
         push @output, [$node_name, "\'boot\' command not supported for CEC or BPA", -1 ];
         return (\@output);
     }
     # add checking the power state of the cec 
+    xCAT::MsgUtils->verbose_message($request, "rbootseq check machine state for node:$node_name.");        
     my $power_state = xCAT::FSPUtils::fsp_api_action ($request, $node_name, $d, "cec_state", $tooltype);
     if ( @$power_state[2] != 0  ) {
         push @output, [$node_name, @$power_state[1], -1 ];
@@ -205,14 +207,17 @@ sub rbootseq {
 	        push @output, [$node_name, "The mac address in mac table could NOT be used for rbootseq with -net. HFI mac , or other wrong format?", -1 ];	
                 return( \@output );
          }	    
+         xCAT::MsgUtils->verbose_message($request, "rbootseq <$node_name> net=$parameter");        
        }
 
        if( $opt->{hfi}) {
        
            $parameter = "/hfi-iohub/hfi-ethernet:$o->{server},,$o->{client},$o->{gateway},$bootp_retries,$tftp_retries,$o->{netmask},$blksize";	      
        
+           xCAT::MsgUtils->verbose_message($request, "rbootseq <$node_name> hfi=$parameter");        
        }
 
+       xCAT::MsgUtils->verbose_message($request, "rbootseq set_lpar_bootstring for node:$node_name.");        
        my $res = xCAT::FSPUtils::fsp_api_action ($request, $node_name, $d, "set_lpar_bootstring", $tooltype, $parameter);
        #print "In boot, state\n";
        #print Dumper($res);
@@ -222,6 +227,7 @@ sub rbootseq {
        ##################################
        # Output error
        ##################################
+       xCAT::MsgUtils->verbose_message($request, "rbootseq return:$Rc.");        
        if ( $Rc != SUCCESS ) {
 	       push @output, [$node_name,$data,$Rc];
 	} else { 

perl-xCAT/xCAT/FSPcfg.pm

@@ -6,10 +6,11 @@ use Getopt::Long;
 use xCAT::Usage;
 use xCAT::Utils;
 use xCAT::FSPUtils;
+use xCAT::TableUtils;
 use xCAT::PPCcfg;
 #use Data::Dumper;
 #use xCAT::PPCcli;
-
+use xCAT::MsgUtils qw(verbose_message);
 
 ##########################################
 # Globals
@@ -173,7 +174,7 @@ sub parse_args {
     Getopt::Long::Configure( "bundling" );
     $request->{method} = undef;
 
-    if ( !GetOptions( \%opt, qw(V|Verbose resetnet))) {
+    if ( !GetOptions( \%opt, qw(V|verbose resetnet))) {
         return( usage() );
     }
     ####################################
@@ -224,7 +225,7 @@ sub parse_args {
         my $ppc_cmds_string = &array_to_string(\@ppc_cmds);
         return (usage("Invalid command array: $fsp_cmds_string can not execute with $ppc_cmds_string."));
     } elsif(scalar(@ppc_cmds)) {
-        my @enableASMI = xCAT::Utils->get_site_attribute("enableASMI");
+        my @enableASMI = xCAT::TableUtils->get_site_attribute("enableASMI");
         if (defined($enableASMI[0])) {
             $enableASMI[0] =~ tr/a-z/A-Z/;    # convert to upper
             if (($enableASMI[0] eq "1") || ($enableASMI[0] eq "YES")) {
@@ -466,6 +467,7 @@ sub do_query {
     while (my ($mtms, $h) = each(%$hash)) {
         while (my($name, $d) = each(%$h)) {
             my $action = $fspapi_action{$cmd}{query}{@$d[4]};
+            xCAT::MsgUtils->verbose_message($request, "rspconfig :$action for node:$name."); 
             my $values = xCAT::FSPUtils::fsp_api_action($request, $name, $d, $action);
             &do_process_query_res($name, $cmd, \@result, $values);
             #my $res = &do_process_query_res($name, $cmd, \@result, $values);
@@ -512,6 +514,7 @@ sub do_set {
     while (my ($mtms, $h) = each(%$hash)) {
         while (my($name, $d) = each(%$h)) {
             my $action = $fspapi_action{$cmd}{set}{@$d[4]};
+            xCAT::MsgUtils->verbose_message($request, "rspconfig :$action for node:$name, param:$value."); 
             my $para = &do_set_get_para($name, $cmd, $value);
             my $values = xCAT::FSPUtils::fsp_api_action($request, $name, $d, $action, 0, $para);
 #           print Dumper($values);
@@ -595,6 +598,7 @@ sub passwd {
            			while ( my ($node,$d) = each(%$h) ) {
                			my $type = @$d[4];
 				my $fsp_api    = ($::XCATROOT) ? "$::XCATROOT/sbin/fsp-api" : "/opt/xcat/sbin/fsp-api";
+                                xCAT::MsgUtils->verbose_message($request, "rspconfig :modify password of $usr for node:$node.");
 				my $cmd = xCAT::FSPcfg::fsp_api_passwd ($request, $node, $d, $usr, $passwd, $newpasswd);
                 		my $Rc = @$cmd[2];
 				my $data = @$cmd[1];
@@ -607,6 +611,7 @@ sub passwd {
                 		# Write the new password to table
                 		##################################
                 		if ( $Rc == 0 ) {
+                                    xCAT::MsgUtils->verbose_message($request, "rspconfig :update xCATdb for node:$node,ID:$usr.");
                 		    xCAT::PPCdb::update_credentials( $node, $type, $usr, $newpasswd );
                 		}
             			}
@@ -677,6 +682,7 @@ sub frame {
                     # Get frame number
                     #################################
 		    #$data = xCAT::PPCcli::lssyscfg( $exp, @$d[4], @$d[2], 'frame_num' );
+                    xCAT::MsgUtils->verbose_message($request, "rspconfig :get_frame_number for node:$node.");
 		    $data = xCAT::FSPUtils::fsp_api_action( $request, $node, $d, "get_frame_number");
                     $Rc = pop(@$data);
 
@@ -708,6 +714,7 @@ sub frame {
                         return( [[$node,"Cannot find frame num in database", -1]] );
                     }
 		    #$data = xCAT::PPCcli::chsyscfg( $exp, "bpa", $d, "frame_num=".$ent->{id} );
+                    xCAT::MsgUtils->verbose_message($request, "rspconfig :set_frame_number for node:$node,id:$ent->{id}.");
 		    $data = xCAT::FSPUtils::fsp_api_action( $request, $node, $d, "set_frame_number", 0, $ent->{id});
                     $Rc = pop(@$data);
 
@@ -727,6 +734,7 @@ sub frame {
                     # Read the frame number from opt
                     #################################
 		    #$data = xCAT::PPCcli::chsyscfg( $exp, "bpa", $d, "frame_num=$value" );
+                    xCAT::MsgUtils->verbose_message($request, "rspconfig :set_frame_number for node:$node,id:$value.");
                     $data = xCAT::FSPUtils::fsp_api_action( $request, $node, $d, "set_frame_number", 0, $value);
 		    $Rc = pop(@$data);
 
@@ -775,6 +783,7 @@ sub cec_off_policy {
                     #################################
                     # Get platform IPL parameters 
                     #################################
+                    xCAT::MsgUtils->verbose_message($request, "rspconfig :get_phyp_cfg_power_off_policy for node:$node.");
 		    $data = xCAT::FSPUtils::fsp_api_action( $request, $node, $d, "get_phyp_cfg_power_off_policy");
                     $Rc = pop(@$data);
 
@@ -794,6 +803,7 @@ sub cec_off_policy {
                     #################################
                     # Set cec off policy 
                     #################################
+                    xCAT::MsgUtils->verbose_message($request, "rspconfig :set power_off_policy for node:$node,policy:$value.");
 		    if( $value eq "poweroff") {
 		        $value = "cec_off_policy_poweroff";
 		    } else {
@@ -862,8 +872,8 @@ sub fsp_api_passwd {
     ############################
     # Get IP address
     ############################
-    #$fsp_ip = xCAT::Utils::get_hdwr_ip($fsp_name);
-    #$fsp_ip = xCAT::Utils::getNodeIPaddress($fsp_name);
+    #$fsp_ip = xCAT::NetworkUtils::get_hdwr_ip($fsp_name);
+    #$fsp_ip = xCAT::NetworkUtils::getNodeIPaddress($fsp_name);
     #$fsp_ip = xCAT::Utils::getIPaddress($fsp_name);
     $fsp_ip = xCAT::FSPUtils::getIPaddress($request, $$attrs[4], $fsp_name );
     if(!defined($fsp_ip) or ($fsp_ip == -3)) {

perl-xCAT/xCAT/FSPconn.pm

@@ -8,6 +8,7 @@ use xCAT::Usage;
 #use Data::Dumper;
 use xCAT::FSPUtils;
 use xCAT::PPCconn;
+use xCAT::MsgUtils qw(verbose_message);
 
 ##############################################
 # Globals
@@ -571,7 +572,7 @@ sub mkhwconn
     my $Rc      = undef;
     my $tooltype= $opt->{T};
     
-    
+    xCAT::MsgUtils->verbose_message($request, "mkhwconn START."); 
     for my $cec_bpa ( keys %$hash)
     {
         my $node_hash = $hash->{$cec_bpa};
@@ -596,6 +597,7 @@ sub mkhwconn
 
             #}
 
+            xCAT::MsgUtils->verbose_message($request, "mkhwconn :add_connection for node:$node_name."); 
             my $res = xCAT::FSPUtils::fsp_api_action($request, $node_name, $d, "add_connection", $tooltype, $opt->{port} );
             $Rc = @$res[2];
 	    if( @$res[1] ne "") {
@@ -604,6 +606,7 @@ sub mkhwconn
 
         }
     }
+    xCAT::MsgUtils->verbose_message($request, "mkhwconn END."); 
     return \@value;
 }
 ##########################################################################

perl-xCAT/xCAT/FSPflash.pm

@@ -44,11 +44,11 @@ sub dpush {
 # Parse the command line for options and operands 
 ##########################################################################
 sub parse_args {
-    my $req = shift;
-	$req->{mgt} = __PACKAGE__;
+    my $req = shift; 
+    $req->{mgt} = __PACKAGE__;
     my $opt = xCAT::PPCrflash::parse_args($req);
-	delete($req->{mgt});
-	return $opt;
+    delete($req->{mgt});
+    return $opt;
 }
 
 ##########################################################################
@@ -340,8 +340,8 @@ sub rflash {
                #if($activate =~ /^concurrent$/) {
                my $res = "\'$activate\' option not supported in FSPflash. Please use disruptive or deferred mode";
                push @value, [$name, $res, -1];
-	           next;
-           }
+	       next;
+          }
 	   
 	   my $msg;	
 	   if(!defined($housekeeping)) {	   

perl-xCAT/xCAT/FSPinv.pm

@@ -66,7 +66,7 @@ sub parse_args {
     $Getopt::Long::ignorecase = 0;
     Getopt::Long::Configure( "bundling" );
 
-    if ( !GetOptions( \%opt, qw(V|Verbose x) )) { 
+    if ( !GetOptions( \%opt, qw(V|verbose x) )) { 
         return( usage() );
     }
     ####################################

perl-xCAT/xCAT/FSPmac.pm

@@ -6,7 +6,7 @@ use strict;
 use Getopt::Long;
 use xCAT::PPCmac;
 use xCAT::PPCcli qw(SUCCESS EXPECT_ERROR RC_ERROR NR_ERROR);
-
+use xCAT::MsgUtils qw(verbose_message);
 use xCAT::LparNetbootExp;
 ##########################################################################
 # Parse the command line for options and operands 
@@ -184,6 +184,7 @@ sub do_getmacs {
     #        last;
     #    }
     #}
+    xCAT::MsgUtils->verbose_message($request, "getmacs :lparnetbootexp for node:$node.");
     my $Rc = xCAT::LparNetbootExp->lparnetbootexp(\%optarg, $request);
     ######################################
     # Split results into array
@@ -442,6 +443,7 @@ sub getmacs {
         #########################################
         # Connect to fsp to achieve MAC address
         #########################################
+        xCAT::MsgUtils->verbose_message($request, "getmacs START.");
         my $d = $par;
 
         #########################################
@@ -501,6 +503,7 @@ sub getmacs {
             #########################################
             # Manually collect MAC addresses.
             #########################################
+            xCAT::MsgUtils->verbose_message($request, "getmacs :do_getmacs for node:$node.");
             $result = do_getmacs( $request, $d, $exp, $name, $node );
         #}
         #$sitetab->close;
@@ -575,6 +578,7 @@ sub getmacs {
             writemac( $node, $value );
         }
 	#return( [[$node,$data,$Rc]] );
+        xCAT::MsgUtils->verbose_message($request, "getmacs END.");
 	return $res;
     }
 }

perl-xCAT/xCAT/FSPpower.pm

@@ -236,7 +236,7 @@ sub powercmd {
 	    if($action =~ /^lowpower$/) { $action = "cec_on_low_power"; }
         #if($action =~ /^cycle$/) {$action = "cec_reboot";}
         if($action =~ /^cycle$/) {$action = "reset";}
-	    if($action !~ /^cec_on_autostart$/ && $action !~ /^cec_off$/ &&  $action !~ /^cec_on_low_power$/ && $action !~ /^onstandby$/ && $action !~ /^reboot_service_processor$/ && $action !~ /^reset$/) {
+	    if($action !~ /^cec_on_autostart$/ && $action !~ /^cec_off$/ &&  $action !~ /^cec_on_low_power$/ && $action !~ /^onstandby$/ && $action !~ /^reboot_service_processor$/ && $action !~ /^reset$/ && $action !~ /^sms$/) {
 	        push @output, [$node_name, "\'$action\' command not supported for $$d[4]", -1 ];
 		    return (\@output);
 	    }	

perl-xCAT/xCAT/FSPscan.pm

@@ -13,6 +13,7 @@ use xCAT::GlobalDef;
 use xCAT::Usage;
 use xCAT::NetworkUtils;
 use xCAT::FSPUtils;
+require xCAT::data::ibmhwtypes;
 #use Data::Dumper;
 
 ##############################################
@@ -259,7 +260,8 @@ sub format_output {
         # Strip errors for results
         #######################################
         my @val = grep( !/^#.*: ERROR /, @$values );
-        xCAT::PPCdb::add_ppc( $hwtype, \@val );
+        #xCAT::PPCdb::add_ppc( $hwtype, \@val );
+        $values = xCAT::PPCdb::update_lpar( $hwtype, \@val, "write");
     }
 
     ###########################################
@@ -270,7 +272,8 @@ sub format_output {
         # Strip errors for results
         #######################################
         my @val = grep( !/^#.*: ERROR /, @$values );
-        $values = xCAT::PPCdb::update_ppc( $hwtype, \@val );
+        #$values = xCAT::PPCdb::update_ppc( $hwtype, \@val );
+        $values = xCAT::PPCdb::update_lpar( $hwtype, \@val );
         if ( exists( $opt->{x} ) or exists( $opt->{z} ))
         {
             unshift @$values, "hmc";
@@ -391,6 +394,7 @@ sub format_stanza {
         #################################
         # Add each attribute
         #################################
+        my $mtm = undef;
         foreach ( @attribs ) {
             my $d = $data[$i++];
 
@@ -401,7 +405,8 @@ sub format_stanza {
             } elsif ( /^hwtype$/ ) {        
                 $d = $globalhwtype{$type};
             } elsif ( /^groups$/ ) {
-                $d = "$type,all";
+                next;
+                #$d = "$type,all";
             } elsif ( /^mgt$/ ) {
                 $d = $hwtype;
             } elsif ( /^cons$/ ) {
@@ -414,7 +419,9 @@ sub format_stanza {
             } elsif ( /^(mtm|serial)$/ ) {
                 if ( $type eq "lpar" ) {
                     $d = undef;                    
-                }     
+                } elsif (/^mtm$/) {
+                    $mtm = $d;
+                }  
             } elsif (/^side$/) {
                 unless ( $type =~ /^fsp|bpa$/ ) {
                     next;
@@ -422,6 +429,15 @@ sub format_stanza {
             }
             $result .= "\t$_=$d\n";
         }
+        my $tmp_groups = "$type,all";
+        if (defined($mtm)) {
+            my $tmp_pre = xCAT::data::ibmhwtypes::parse_group($mtm);
+            if (defined($tmp_pre)) {
+                $tmp_groups .= ",$tmp_pre";
+            }     
+        }
+        $result .= "\tgroups=$tmp_groups\n";
+
     }
     return( $result );
 }
@@ -464,6 +480,7 @@ sub format_xml {
         #################################
         # Add each attribute 
         #################################
+        my $mtm = undef;
         foreach ( @attribs ) {
             my $d = $data[$i++];
 
@@ -472,7 +489,8 @@ sub format_xml {
             } elsif ( /^hwtype$/ ) {        
                 $d = $globalhwtype{$type};
             } elsif ( /^groups$/ ) {
-                $d = "$type,all";
+                next;
+                #$d = "$type,all";
             } elsif ( /^mgt$/ ) {
                 $d = $hwtype;
             } elsif ( /^cons$/ ) {
@@ -484,6 +502,8 @@ sub format_xml {
             } elsif ( /^(mtm|serial)$/ ) {
                 if ( $type eq "lpar" ) {
                     $d = undef;
+                } elsif (/^mtm$/) {
+                    $mtm = $d;
                 }
             } elsif (/^side$/) {
                 unless ( $type =~ /^fsp|bpa$/ ) {
@@ -492,6 +512,15 @@ sub format_xml {
             }
             $href->{Node}->{$_} = $d;
         }
+        my $tmp_groups = "$type,all";
+        if (defined($mtm)) {
+            my $tmp_pre = xCAT::data::ibmhwtypes::parse_group($mtm);
+            if (defined($tmp_pre)) {
+                $tmp_groups .= ",$tmp_pre";
+            }     
+        }
+        $href->{Node}->{groups}=$tmp_groups;
+
         #print Dumper($href);
         #################################
         # XML encoding

perl-xCAT/xCAT/FSPvitals.pm

@@ -116,6 +116,9 @@ sub enumerate_lcds {
     } else {
        my @array =  split(/\n/, $data);
        foreach my $a (@array) {
+            if ($a !~ /:\s?[^\s]*\s?[0|1]/) {
+                next;
+            }
             my @t = split(/:/, $a);
             my $name = $t[0];
             $data = $t[1];
@@ -429,8 +432,10 @@ sub lcds {
          }
     }
             
-    if( $type =~ /lpar/ ) {
+    if( $type eq "lpar" ) {
         $action = "query_lcds";
+    } elsif ($type eq "blade") {
+        $action = "pblade_query_lcds";
     } else {
         $action = "cec_query_lcds";
     } 

perl-xCAT/xCAT/FSPvm.pm

@@ -16,7 +16,7 @@ use xCAT::Usage;
 use xCAT::NodeRange;
 use xCAT::FSPUtils;
 #use Data::Dumper;
-
+use xCAT::MsgUtils qw(verbose_message);
 ##############################################
 # Globals
 ##############################################
@@ -51,6 +51,8 @@ sub parse_args {
 sub chvm_parse_extra_options {
 	my $args = shift;
 	my $opt = shift;
+    # Partition used attributes #
+    my @support_ops = qw(vmcpus vmmemory vmphyslots vmothersetting);
 	if (ref($args) ne 'ARRAY') {
 		return "$args";
 	}	
@@ -71,7 +73,20 @@ sub chvm_parse_extra_options {
 #			if ($value !~ /^\d+\/\d+\/\d+$/) {
 #				return "'$value' invalid";
 #			}
-		} else {
+        } elsif (grep(/^$cmd$/, @support_ops)) {
+            if (exists($opt->{p775})) {
+                return "'$cmd' doesn't work for Power 775 machines.";
+            } elsif ($cmd eq "vmothersetting") {
+                if ($value =~ /hugepage:\s*(\d+)/i) {
+                    $opt->{huge_page} = $1;
+                }
+                if ($value =~ /bsr:\s*(\d+)/i) {
+                    $opt->{bsr} = $1;
+                }
+                next;
+            }
+
+        } else {
 			return "'$cmd' not support";
 		}
 		$opt->{$cmd} = $value;
@@ -109,7 +124,7 @@ sub chvm_parse_args {
     $Getopt::Long::ignorecase = 0;
     Getopt::Long::Configure( "bundling" );
 
-    if ( !GetOptions( \%opt, qw(V|verbose p=s i=s m=s r=s ) )) {
+    if ( !GetOptions( \%opt, qw(V|verbose p=s i=s m=s r=s p775) )) {
         return( usage() );
     }
     ####################################
@@ -126,8 +141,11 @@ sub chvm_parse_args {
     #        return(usage( "Configuration file or attributes not specified" ));
     #    }
     #}
-    
+    if (exists($opt{p775})) { 
     my @cfgdata ;
+    if ((exists ($opt{p}) || defined($request->{stdin})) && !exists($opt{p775}) ) {
+        return(usage("Profile just work for Power 775"));
+    }
     if ( exists( $opt{p})) {
         
 	if ( exists( $opt{i} ) ||  exists( $opt{r}) || exists( $opt{m} ) ) {
@@ -302,6 +320,7 @@ sub chvm_parse_args {
         $request->{node} = [$other_p]; 
         $request->{noderange} = $other_p;  
     }
+    }
     ####################################
     # Check for an extra argument
     ####################################
@@ -347,21 +366,23 @@ sub mkvm_parse_args {
 #############################################
 # Process command-line arguments
 #############################################
-    if ( !defined( $args )) {
-        return(usage( "No command specified" ));
-    }
+    #if ( !defined( $args )) {
+    #    return(usage( "No command specified" ));
+    #}
 #############################################
 # Checks case in GetOptions, allows opts
 # to be grouped (e.g. -vx), and terminates
 # at the first unrecognized option.
 #############################################
-    @ARGV = @$args;
+    if (defined($args)) {
+        @ARGV = @$args;
+    }
     $Getopt::Long::ignorecase = 0;
     Getopt::Long::Configure( "bundling" );
-#    if ( !GetOptions( \%opt, qw(V|verbose ibautocfg ibacap=s i=s l=s c=s p=s full) )) {
+#    if ( !GetOptions( \%opt, qw(V|verbose ibautocfg ibacap=s i=s l=s c=s p=s m=s r=s full) )) {
 #        return( usage() );
 #    }
-    if ( !GetOptions( \%opt, qw(V|verbose i=s m=s r=s ) )) {
+    if ( !GetOptions( \%opt, qw(V|verbose full vios) )) {
         return( usage() );
     }
 ####################################
@@ -370,7 +391,37 @@ sub mkvm_parse_args {
     if ( grep(/^-$/, @ARGV )) {
         return(usage( "Missing option: -" ));
     }
+    if (!exists($opt{p775})) {
+        my @unsupport_ops = ();
+        foreach my $tmpop (keys %opt) {
+            if ($tmpop !~ /full|vios|V/) {
+                push @unsupport_ops, $tmpop;
+            }
+        }
+        my @support_ops = qw(vmcpus vmmemory vmphyslots vmothersetting);
+        if (defined(@ARGV[0]) and defined($opt{full})) {
+            return(usage("Option 'full' shall be used alone."));
+        } elsif (defined(@ARGV[0])) {
+            foreach my $arg (@ARGV) {
+                my ($cmd,$val) = split (/=/,$arg);
+                if (!grep(/^$cmd$/, @support_ops))  {
+                    push @unsupport_ops, $cmd;
+                } elsif (!defined($val)) {
+                    return(usage("The option $cmd need specific parameters."));
+                } else {
+                    $opt{$cmd} = $val;
+                }
+            }
+        }
 
+        if (@unsupport_ops) {
+            my $tmpops = join(",",@unsupport_ops);
+            return(usage( "The options $tmpops can only work(s) with Power 775 machines."));
+        }
+    } else {
+        if (exists($opt{full}) or exists($opt{vios})) {
+            return(usage( "Option 'p775' only works for Power 775 machines."));
+        }
 ####################################
 # Check for non-zero integer 
 ####################################
@@ -408,13 +459,14 @@ sub mkvm_parse_args {
 	} else {
             return(usage( "Invalid entry: $opt{m}.\n For Power 775, the pending memory interleaving mode only could be interleaved(or 1), or non-interleaved(or 2)." ));
 	}
-    } else {
+    } elsif (exists($opt{p775})){
         $opt{m} = 2 ;# non-interleaved, which is the default    
     }
    
-    my @ratio = (1, 2, 3, 4, 5);
-    my %octant_cfg = ();
     if ( exists( $opt{r} ) ) {
+        my @ratio = (1, 2, 3, 4, 5);
+        my %octant_cfg = ();
+
         my @elems = split(/\,/,$opt{r});
         my $range="";
         while (my $elem = shift @elems) {
@@ -461,15 +513,15 @@ sub mkvm_parse_args {
 		}
 	    } # end of "if .. else.."
         } # end of while
+        $opt{octant_cfg}{octant_cfg_value} = (\%octant_cfg);
+        $opt{octant_cfg}{memory_interleave} = $opt{m};
     } #end of if
     
-    $opt{octant_cfg}{octant_cfg_value} = (\%octant_cfg);
-    $opt{octant_cfg}{memory_interleave} = $opt{m};
-    
-    if ( !exists( $opt{i} ) ||  !exists( $opt{r} ) ) {
+        
+    if ( (!exists( $opt{i} ) ||  !exists( $opt{r} )) ) {
         return(usage());
     }
-    
+    } 
     $opt{target} = \@{$request->{node}};
     my $ppctab = xCAT::Table->new( 'ppc');
     unless($ppctab) {
@@ -483,6 +535,10 @@ sub mkvm_parse_args {
         if ( !$p) {
            return(usage("Not found the parent of $node"));
         }
+        if (exists($opt{full}) and defined($other_p) and $other_p eq $p){
+            return(usage("Only one full partition can be created in one CEC"));
+        }
+
         if(! defined( $other_p)) {
             $other_p = $p;
         } 
@@ -490,9 +546,10 @@ sub mkvm_parse_args {
             return(usage("For Power 775, please make sure the noderange are in one CEC "));
         }
     } 
-    $request->{node} = [$other_p]; 
-    $request->{noderange} = $other_p;  
- 
+    if (exists($opt{p775})) {
+        $request->{node} = [$other_p]; 
+        $request->{noderange} = $other_p;  
+    }
     ####################################
     # No operands - add command name 
     ####################################
@@ -535,10 +592,14 @@ sub rmvm_parse_args {
     $Getopt::Long::ignorecase = 0;
     Getopt::Long::Configure( "bundling" );
 
-    if ( !GetOptions( \%opt, qw(V|verbose service r) )) {
+    if ( !GetOptions( \%opt, qw(V|verbose service r p775) )) {
         return( usage() );
     }
-    return(usage( "rmvm doesn't support for Power 775." ));
+
+    if (exists($opt{p775})) {
+        return(usage( "rmvm doesn't support for Power 775." ));
+    }
+
     ####################################
     # Check for "-" with no option
     ####################################
@@ -592,9 +653,12 @@ sub lsvm_parse_args {
     $Getopt::Long::ignorecase = 0;
     Getopt::Long::Configure( "bundling" );
 
-    if ( !GetOptions( \%opt, qw(V|verbose l|long) )) {
+    if ( !GetOptions( \%opt, qw(V|verbose l|long p775) )) {
         return( usage() );
     }
+    if (exists($opt{l}) && !exists($opt{p775})) {
+        return(usage( "option 'l' only works for Power 775"));
+    }
     ####################################
     # Check for "-" with no option
     ####################################
@@ -622,8 +686,9 @@ sub modify {
     my $request = shift;
     my $hash    = shift;
     my $usage_string = xCAT::Usage->getUsage($request->{command});
-    return modify_by_prof( $request, $hash) if ( $request->{opt}->{p} || $request->{stdin}); 
-    return create( $request, $hash) if ( $request->{opt}->{i}); 
+    return modify_by_prof( $request, $hash) if ( exists($request->{opt}->{p775}) and ($request->{opt}->{p} || $request->{stdin})); 
+    return create( $request, $hash) if ( exists($request->{opt}->{p775}) and $request->{opt}->{i}); 
+    return op_extra_cmds ($request, $hash) if (!exists($request->{opt}->{p775}));
     return op_extra_cmds ($request, $hash) if ($request->{opt}->{lparname} || $request->{opt}->{huge_page});
     return ([["Error", "Miss argument\n".$usage_string, 1]]);
 }
@@ -631,25 +696,72 @@ sub do_op_extra_cmds {
     my $request = shift;
     my $hash = shift;
     my @values = ();
-	my $action;
-	my $param;
-	if (exists($request->{opt}->{lparname})) {
-		$action = "set_lpar_name";
-		$param = $request->{opt}->{lparname};
-	} elsif (exists($request->{opt}->{huge_page})) {
-		$action = "set_huge_page";
-		$param = $request->{opt}->{huge_page};
-	}
-    my $lparname_para = $request->{opt}->{lparname};
+
     while (my ($mtms, $h) = each(%$hash)) {
+        my $memhash;
         while (my($name, $d) = each(%$h)) {
-            my $tmp_value = ($param eq '*') ? $name : $param;
-            my $value = xCAT::FSPUtils::fsp_api_action($request, $name, $d, $action, 0, $tmp_value);
-            if (@$value[1] && ((@$value[1] =~ /Error/i) && (@$value[2] ne '0'))) {
-                return ([[$name, @$value[1], '1']]) ;
-            } else {
-                push @values, [$name, "Success", '0'];
-            } 
+            foreach my $op (keys %{$request->{opt}}) {
+	        my $action;
+	        my $param = $request->{opt}->{$op};
+	        if ($op eq "lparname") {
+		    $action = "set_lpar_name";
+	        } elsif ($op eq "huge_page") {
+		    $action = "set_huge_page";
+	        } elsif ($op eq "vmcpus") {
+                    $action = "part_set_lpar_pending_proc";
+                } elsif ($op eq "vmphyslots") {
+                    $action = "set_io_slot_owner_uber";
+                } elsif ($op eq "vmmemory") {
+                    my @td = @$d;
+                    @td[0] = 0;
+                    $memhash = &query_cec_info_actions($request, $name, \@td, 1, ["part_get_hyp_process_and_mem"]);
+                    if (!exists($memhash->{run})) {
+                        if ($param =~ /(\d+)([G|M]?)\/(\d+)([G|M]?)\/(\d+)([G|M]?)/i) {
+                            my $memsize = $memhash->{mem_region_size};
+                            my $min = $1;
+                            if ($2 == "G" or $2 == '') {
+                                $min = $min * 1024;
+                            } 
+                            $min = $min/$memsize;
+                            my $cur = $3;
+                            if ($4 == "G" or $4 == '') {
+                                $cur = $cur * 1024;
+                            }
+                            $cur = $cur/$memsize;
+                            my $max = $5;
+                            if ($6 == "G" or $6 == '') {
+                                $max = $max * 1024;
+                            }
+                            $max = $max/$memsize;
+                            $request->{opt}->{$op} ="$min/$cur/$max";
+                            $param = $request->{opt}->{$op};
+                        } else {
+                            return([[$name, "The format of param:$param is incorrect.", 1]]);
+                        }
+                        $memhash->{run} = 1;
+                    }
+                    $memhash->{memory} = $param;
+                    $memhash->{lpar_used_regions} = 0;
+                    my $ret = &deal_with_avail_mem($request, $name, $d, $memhash);
+                    if (ref($ret) eq "ARRAY") {
+                        return ([[@$ret]]);
+                    }
+                    $param = $memhash->{memory};
+                    $action = "part_set_lpar_pending_mem";
+                } elsif ($op eq "bsr") {
+                    $action = "set_lpar_bsr";
+                } else {
+                    last;
+                }
+                my $tmp_value = ($param eq '*') ? $name : $param;
+                xCAT::MsgUtils->verbose_message($request, "$request->{command} $action for node:$name, parm:$tmp_value."); 
+                my $value = xCAT::FSPUtils::fsp_api_action($request, $name, $d, $action, 0, $tmp_value);
+                if (@$value[1] && ((@$value[1] =~ /Error/i) && (@$value[2] ne '0'))) {
+                    return ([[$name, @$value[1], '1']]) ;
+                } else {
+                    push @values, [$name, "Success", '0'];
+                } 
+            }
         }
     } 
     return \@values;
@@ -698,7 +810,7 @@ sub modify_by_prof {
     my %io = ();   
     my %lpar_state = ();
     my @result;   
-
+    xCAT::MsgUtils->verbose_message($request, "$request->{command} START."); 
     if (defined( $request->{stdin} )) {
          my $p =  $request->{stdin};
          my @io = split(/\n/, $p) ;
@@ -721,6 +833,7 @@ sub modify_by_prof {
         }
         $td->[4] = "cec";
         #get the current I/O slot information
+        xCAT::MsgUtils->verbose_message($request, "$request->{command} :get_io_slot_info for node:$cec_name."); 
         my $action = "get_io_slot_info";
         my $values =  xCAT::FSPUtils::fsp_api_action ($request, $cec_name, $td, $action);
         my $Rc = $$values[2];
@@ -737,6 +850,7 @@ sub modify_by_prof {
         } 
         
         #get all the nodes state in the same cec
+        xCAT::MsgUtils->verbose_message($request, "$request->{command} :get all the nodes state for CEC:$cec_name."); 
         $action = "all_lpars_state";
         undef($values);
         my $values =  xCAT::FSPUtils::fsp_state_action ($request, $cec_name, $td, $action); 
@@ -771,6 +885,7 @@ sub modify_by_prof {
                     return ( \@result ); 
                 }                   
      
+                xCAT::MsgUtils->verbose_message($request, "$request->{command} :set_io_slot_owner io_slot_info:$f,owner:$lpar."); 
                 my $values =  xCAT::FSPUtils::fsp_api_action ($request, $lpar, $d, $action, $tooltype, $drc_index);
                 #my $Rc = shift(@$values);
                 my $Rc = pop(@$values);
@@ -782,6 +897,7 @@ sub modify_by_prof {
                   
         }
     }
+    xCAT::MsgUtils->verbose_message($request, "$request->{command} END."); 
     return( \@result );
 }
 
@@ -796,6 +912,7 @@ sub enumerate {
     my $type;
     my @td;
 
+    xCAT::MsgUtils->verbose_message($request, "lsvm :enumerate START for mtms:$mtms.");
     while (my ($name,$d) = each(%$h) ) {
         $cec = @$d[3];
         $type = @$d[4];
@@ -803,6 +920,7 @@ sub enumerate {
     }
    
     $td[4]="cec"; 
+    xCAT::MsgUtils->verbose_message($request, "lsvm :enumerate get_io_slot_info for node:$cec.");
     my $action = "get_io_slot_info";
     my $values =  xCAT::FSPUtils::fsp_api_action ($request, $cec, \@td, $action);
     #my $Rc = shift(@$values);
@@ -819,6 +937,7 @@ sub enumerate {
     #}
  
     if( $type =~ /^(fsp|cec)$/ )  {
+        xCAT::MsgUtils->verbose_message($request, "lsvm :enumerate query_octant_cfg for node:$cec.");
 	$action = "query_octant_cfg";
 	my $values =  xCAT::FSPUtils::fsp_api_action ($request, $cec, \@td, $action);
 	my $Rc = pop(@$values);
@@ -839,6 +958,7 @@ sub enumerate {
         $outhash{ $cec } = $res;	
     } 
     
+    xCAT::MsgUtils->verbose_message($request, "lsvm :enumerate END for mtms:$mtms.");
     return( [0,\%outhash] );
 }
 
@@ -987,6 +1107,7 @@ sub list {
     my %lpar_huges = ();
     my $l_string = "\n";
     #print Dumper($hash);    
+    xCAT::MsgUtils->verbose_message($request, "lsvm START");
     while (my ($mtms,$h) = each(%$hash) ) {
 	    my $info = enumerate($request, $h, $mtms );
     	my $Rc = shift(@$info);
@@ -1009,7 +1130,7 @@ sub list {
            #     push @result, [$node_name, "Node not found",1];
            # 	next;
            # }
-           
+            xCAT::MsgUtils->verbose_message($request, "lsvm :parse io info for node:$node_name.");           
             if( defined($msg)) { 
                  push @result,[$node_name, $msg, 0];
             } else {
@@ -1084,6 +1205,7 @@ sub list {
             
             # get the octant configuration value    
             if ($type=~/^(fsp|cec)$/) {
+                xCAT::MsgUtils->verbose_message($request, "lsvm :parse octant info for $type:$node_name.");           
                 my $value = $data->{$cec};
 		        if ($request->{opt}->{l}) {
 		            my $cec_bsr = get_cec_cec_bsr($node_name, $bsr_infos);
@@ -1101,6 +1223,7 @@ sub list {
 		    $l_string = "\n";
 	    } # end of while
     }# end of while
+    xCAT::MsgUtils->verbose_message($request, "lsvm END.");
     return( \@result );
 }
 
@@ -1194,6 +1317,7 @@ sub create {
     my %node_id = (); 
     my @nodes = @{$opt->{target}};	
    
+    xCAT::MsgUtils->verbose_message($request, "$request->{command} START."); 
     #print Dumper($request); 
     #####################################
     # Get source node information
@@ -1213,6 +1337,7 @@ sub create {
             }
         }
         
+        xCAT::MsgUtils->verbose_message($request, "$request->{command} :query_octant_cfg for CEC:$cec_name."); 
         my $values =  xCAT::FSPUtils::fsp_api_action ($request, $cec_name, $d, "query_octant_cfg");   
         my $Rc = shift(@$values);
         if ( $Rc != 0 ) {
@@ -1289,6 +1414,7 @@ sub create {
 
 
 	
+        xCAT::MsgUtils->verbose_message($request, "$request->{command} :set_octant_cfg for CEC:$cec_name,param:$parameters."); 
 	#$values = xCAT::FSPUtils::fsp_api_create_parttion( $starting_lpar_id, $octant_cfg, $node_number, $d, "set_octant_cfg");
         $values =  xCAT::FSPUtils::fsp_api_action ($request,$cec_name, $d, "set_octant_cfg", 0, $parameters);   
         my $Rc = $$values[2];
@@ -1306,6 +1432,7 @@ sub create {
         	
     }
     
+    xCAT::MsgUtils->verbose_message($request, "$request->{command} END."); 
     return( \@result );
 }
 
@@ -1407,7 +1534,468 @@ sub xCATdB {
     }
     return undef;
 }
+########################
+#***** partition related
+########################
 
+#my @partition_query_actions = qw(part_get_partition_cap part_get_num_of_lpar_slots part_get_hyp_config_process_and_mem part_get_hyp_avail_process_and_mem part_get_service_authority_lpar_id part_get_shared_processing_resource part_get_all_vio_info lpar_lhea_mac part_get_all_io_bus_info part_get_lpar_processing part_get_lpar_memory get_huge_page get_cec_bsr);
+my @partition_query_actions = qw(part_get_partition_cap part_get_hyp_process_and_mem part_get_all_io_bus_info get_huge_page get_cec_bsr);
+
+sub parse_part_get_info {
+    my $hash = shift;
+    my $data = shift;
+    my @array = split /\n/, $data;
+    foreach my $line (@array) {
+        chomp($line);
+        if ($line =~ /Num of lpar slots: (\d+)/i) {
+            $hash->{num_of_lpars} = $1;
+        } elsif ($line =~ /HYP Configurable Memory[^\(]*\((\d+)\s*regions\)/i) {
+            $hash->{hyp_config_mem} = $1;
+        } elsif ($line =~ /HYP Available Memory[^\(]*\((\d+)\s*regions\)/i) {
+            $hash->{hyp_avail_mem} = $1;
+        } elsif ($line =~ /HYP Memory Region Size[^\(]*\((\d+)\s*MB\)/i) {
+            $hash->{mem_region_size} = $1;
+        } elsif ($line =~ /HYP Configurable Processors: (\d+),\s*Avail Processors: (\d+)/i) {
+            $hash->{process_units_config} = $1;
+            $hash->{process_units_avail} = $2;
+        } elsif ($line =~ /Authority Lpar id:(\w+)/i) {
+            $hash->{service_lparid} = $1;
+        } elsif ($line =~ /(\d+),(\d+),[^,]*,(\w+),\w*\(([\w| |-|_]*)\)/) {
+            $hash->{bus}->{$3}->{cur_lparid} = $1;
+            $hash->{bus}->{$3}->{bus_slot} = $2;
+            $hash->{bus}->{$3}->{des} = $4;
+        } elsif ($line =~ /Phy drc_index:(\w+), Port group: (\w+), Phy port id: (\w+)/) {
+            $hash->{phy_drc_group_port}->{$1}->{$2}->{$3} = '1';
+        } elsif ($line =~ /adapter_id=(\w+),lpar_id=([\d|-]+).*port_group=(\d+),phys_port_id=(\d+).*drc_index=(\w+),.*/) {
+            if (($2 == -1) && ($4 == 255)) {
+                $hash->{logic_drc_phydrc}->{$3}->{$5} = $1;
+                #$hash->{logic_drc_phydrc}->{$5}->{$1} = [$2,$3,$4];
+            }
+        #} elsif ($line =~ /lpar 0:: Curr  Memory::min: 1,cur: (\d+),max:/i) {
+        } elsif ($line =~ /HYP Reserved Memory Regions:([-]?)(\d+), Min Required Regions:(\d+)/i) {
+            if ($1 eq '-') {
+                $hash->{lpar0_used_dec} = 1;
+            }
+            $hash->{lpar0_used_mem} = $2;
+            $hash->{phy_min_mem_req} = $3;
+            #print "===>lpar0_used_mem:$hash->{lpar0_used_mem}.\n";
+        } elsif ($line =~ /Curr Memory Req:[^\(]*\((\d+)\s*regions\)/) {
+            $hash->{lpar_used_regions} = $1;
+        } elsif ($line =~ /Available huge page memory\(in pages\):\s*(\d+)/) {
+            $hash->{huge_page_avail} = $1;
+        } elsif ($line =~ /Available BSR array:\s*(\d+)/) {
+            $hash->{cec_bsr_avail} = $1;
+        }
+    }
+}
+
+sub query_cec_info_actions {
+    my $request = shift;
+    my $name = shift;
+    my $td = shift;
+    my $usage = shift;
+    my $action_array = shift;
+    my $lparid = @$td[0];
+    my $data;
+    my @array = ();
+    my %hash = ();
+    if (!defined($action_array) or ref($action_array) ne "ARRAY") {
+        $action_array = \@partition_query_actions;
+    }
+
+    foreach my $action (@$action_array) {
+	#$data .= "======> ret info for $action:\n";
+        my $values = xCAT::FSPUtils::fsp_api_action($request, $name, $td, $action);
+        chomp(@$values[1]);
+        #if ($action eq "part_get_partition_cap" and (@$values[1] =~ /Error:/i or @$values[2] ne 0)) {
+        if (@$values[1] =~ /Error:/i or @$values[2] ne 0) {
+            return ([[@$values]]);
+        }
+        if (@$values[1] =~ /^$/) {
+            next;
+        }
+        if ($usage eq 0) {
+            if ($lparid) {
+                if ($action eq "lpar_lhea_mac") {
+                    my @output = split /\n/,@$values[1];
+                    foreach my $line (@output) {
+                        if ($line =~ /adapter_id=\w+,lpar_id=$lparid,type=hea/) {
+                            #$data .= "$line\n";
+                            push @array, [$name, $line, 0];
+                        }
+                    }
+                    #$data .= "\n";
+                    next;
+                }
+                if ($action eq "part_get_all_io_bus_info") {
+                    my @output = split /\n/, @$values[1];
+                    foreach my $line (@output) {
+                        if ($line =~ /^$lparid,/) {
+                            #$data .= "$line\n";
+                            push @array, [$name, $line, 0];
+                        }
+                    }
+                    #$data .= "\n";
+                    next;
+                } 
+            }
+	    #$data .= "@$values[1]\n\n";
+            push @array, [$name, @$values[1], @$values[2]];
+        } else {
+            &parse_part_get_info(\%hash, @$values[1]);
+        }
+    }
+    if ($usage eq 0) {
+        #return $data;
+        return \@array;
+    } else {
+        return \%hash; 
+    }
+}
+
+#my @partition_query_actions = qw(part_get_partition_cap part_get_num_of_lpar_slots part_get_hyp_config_process_and_mem part_get_hyp_avail_process_and_mem part_get_service_authority_lpar_id part_get_shared_processing_resource part_get_all_vio_info lpar_lhea_mac part_get_all_io_bus_info part_get_lpar_processing part_get_lpar_memory get_huge_page get_cec_bsr);
+sub query_cec_info {
+    my $request = shift;
+    my $hash    = shift;
+    my $args    = $request->{opt};
+    my @td = ();
+    my @result = ();
+    while (my ($mtms,$h) = each(%$hash) ) {
+        while (my ($name, $d) = each (%$h)) {
+            @td = @$d;
+            if (@$d[0] == 0 && @$d[4] ne "lpar") {
+                last;
+            }
+            #my $rethash = query_cec_info_actions($request, $name, $d, 0, ["part_get_lpar_processing","part_get_lpar_memory","part_get_all_vio_info","lpar_lhea_mac","part_get_all_io_bus_info","get_huge_page","get_cec_bsr"]);
+            my $rethash = query_cec_info_actions($request, $name, $d, 0, ["part_get_lpar_processing","part_get_lpar_memory","part_get_all_io_bus_info","get_huge_page","get_cec_bsr"]);
+	        #push @result, [$name, $rethash, 0];
+	        push @result, @$rethash;
+        }
+        if (@td[0] == 0) {
+            my $rethash = query_cec_info_actions($request, @td[3],\@td, 0);
+            #push @result, [@td[3], $rethash, 0];
+            push @result, @$rethash;
+        }  
+    }
+    return \@result;
+}
+
+########################
+#***** partition related
+########################
+
+my @partition_config_actions = qw/part_set_lpar_def_state part_set_lpar_pending_proc part_set_lpar_pending_mem part_set_pending_max_vslots part_set_lpar_shared_pool_util_auth part_set_lpar_group_id part_set_lpar_avail_priority part_set_partition_placement part_set_lhea_assign_info part_set_phea_port_info part_set_lhea_port_info part_set_veth_slot_config part_set_vscsi_slot_config part_set_vfchan_slot_config part_clear_vslot_config set_huge_page set_lpar_name/;
+
+sub set_lpar_undefined {
+    my $request = shift;
+    my $name = shift;
+    my $attr = shift;
+    my $values = xCAT::FSPUtils::fsp_api_action($request, $name, $attr, "part_set_lpar_def_state", 0, 0x0); 
+    if (!@$values[2]) {
+        return ([$name,"Done",0]);
+    }
+    return $values;
+}
+
+sub clear_service_authority_lpar {
+    my $request = shift;
+    my $name = shift;
+    my $attr = shift;
+    my $values = xCAT::FSPUtils::fsp_api_action($request, $name, $attr, "part_get_service_authority_lpar_id");
+    my @array = split /\n/, @$values[1]; 
+    my $service_lparid = undef;
+    foreach my $line (@array) {
+        if ($line =~ /Authority Lpar id:([-|\d]+)./i) {
+            $service_lparid = $1;
+        }
+    }
+    if (defined($service_lparid) and $service_lparid == @$attr[0]) {
+        xCAT::FSPUtils::fsp_api_action($request, $name, $attr, "part_set_service_authority_lpar_id");
+    }
+}
+
+sub remove {
+    my $request = shift;
+    my $hash = shift;
+    my @result = ();
+    while (my ($mtms, $h) = each (%$hash)) {
+        while (my ($name, $d) = each (%$h)) {
+             if (@$d[4] ne "lpar") {
+                 push @result, [$name, "Node must be LPAR", 1];
+                 last;
+             } 
+             &clear_service_authority_lpar($request, $name, $d);
+             my $values = &set_lpar_undefined($request, $name, $d);
+             push @result, $values;
+        }
+    }
+    return \@result;
+}
+
+sub deal_with_avail_mem {
+    my $request = shift;
+    my $name = shift;
+    my $d = shift;
+    my $lparhash = shift;
+    my $max_required_regions;
+    if ($lparhash->{memory} =~ /(\d+)\/(\d+)\/(\d+)/) {
+        my ($min,$cur,$max);
+        my $used_regions = 0;
+        my $cur_avail = 0;
+        $min = $1;
+        $cur = $2;
+        $max = $3;
+        my %tmphash;
+        my $values;
+        if (exists($lparhash->{lpar_used_regions})) {
+            $values = xCAT::FSPUtils::fsp_api_action($request, $name, $d, "part_get_lpar_memory");
+            &parse_part_get_info(\%tmphash, @$values[1]);
+            if (exists($tmphash{lpar_used_regions})) {
+                $used_regions = $tmphash{lpar_used_regions};
+            }
+        }
+        $values = xCAT::FSPUtils::fsp_api_action($request, $name, $d, "part_get_hyp_res_mem_regions", 0, $3);
+        &parse_part_get_info(\%tmphash, @$values[1]);
+        if (exists($tmphash{lpar0_used_mem}) && exists($tmphash{phy_min_mem_req})) {
+            if ($min < $tmphash{phy_min_mem_req}) {
+                $min = $tmphash{phy_min_mem_req};
+            }
+ 
+            if (exists($lparhash->{lpar0_used_dec})) {
+                $cur_avail = $lparhash->{hyp_avail_mem} + $used_regions + $tmphash{lpar0_used_mem}; 
+            } else {
+                $cur_avail = $lparhash->{hyp_avail_mem} + $used_regions - $tmphash{lpar0_used_mem};
+            }
+            xCAT::MsgUtils->verbose_message($request, "====****====used:$used_regions,avail:$cur_avail,($min:$cur:$max)."); 
+            if ($cur_avail < $min) {
+                return([$name, "Parse reserverd regions failed, no enough memory, available:$lparhash->{hyp_avail_mem}.", 1]);
+            }           
+            if ($cur > $cur_avail) {
+                my $new_cur = $cur_avail;
+                $lparhash->{memory} = "$min/$new_cur/$max";
+            }
+        } else {
+            return ([$name, "Failed to get hypervisor reserved memory regions.", 1]);
+        }
+    }
+    return 0;
+}
+
+sub create_lpar {
+    my $request = shift;
+    my $name = shift;
+    my $d = shift;
+    my $lparhash = shift;
+    my $values;
+    if (exists($request->{opt}->{vios})) {
+        $values = xCAT::FSPUtils::fsp_api_action($request, $name, $d, "part_set_lpar_def_state", 0, 0x03);
+    } else {
+        $values = xCAT::FSPUtils::fsp_api_action($request, $name, $d, "part_set_lpar_def_state", 0, 0x01);
+    }
+    if (@$values[2] ne 0) {
+        return ([[$name, @$values[1], @$values[0]]]);
+    }
+    $values = xCAT::FSPUtils::fsp_api_action($request, $name, $d, "set_lpar_name", 0, $name);
+    if (@$values[2] ne 0) {
+        &set_lpar_undefined($request, $name, $d);
+        return ([$name, @$values[1], @$values[0]]);
+    }
+    xCAT::FSPUtils::fsp_api_action($request, $name, $d, "part_set_lpar_shared_pool_util_auth");
+    xCAT::FSPUtils::fsp_api_action($request, $name, $d, "part_set_lpar_group_id");
+    xCAT::FSPUtils::fsp_api_action($request, $name, $d, "part_set_lpar_avail_priority");
+    #print "======>physlots:$lparhash->{physlots}.\n";
+    $values = xCAT::FSPUtils::fsp_api_action($request, $name, $d, "set_io_slot_owner_uber", 0, $lparhash->{physlots}); 
+    #$values = xCAT::FSPUtils::fsp_api_action($request, $name, $d, "set_io_slot_owner", 0, join(",",@phy_io_array)); 
+    if (@$values[2] ne 0) {
+        &set_lpar_undefined($request, $name, $d);
+        return ([$name, @$values[1], @$values[2]]);
+    }
+    if (exists($lparhash->{phy_hea})) {
+        my $phy_hash = $lparhash->{phy_hea};
+        foreach my $phy_drc (keys %$phy_hash) {
+            #print "======> set_lhea_assign_info: drc_index:$phy_drc.\n";
+            xCAT::FSPUtils::fsp_api_action($request, $name, $d, "part_set_lhea_assign_info", 0, $phy_drc);
+            my $group_hash = $phy_hash->{$phy_drc};
+            foreach my $group_id (keys %$group_hash) {
+                my @lhea_drc = (keys %{$lparhash->{logic_drc_phydrc}->{$group_id}}); 
+                foreach my $phy_port_id (keys %{$group_hash->{$group_id}}) {
+                    my $tmp_param = "$phy_drc,$group_id,$phy_port_id";
+                    #print "======> set_phea_port_info: $tmp_param.\n";
+                    xCAT::FSPUtils::fsp_api_action($request, $name, $d, "part_set_phea_port_info", 0, $tmp_param);
+                    my $tmp_lhea_param = $lhea_drc[$phy_port_id].",$phy_port_id";
+                    #print "======> set_lhea_port_info: $tmp_lhea_param.\n";
+                    xCAT::FSPUtils::fsp_api_action($request, $name, $d, "part_set_lhea_port_info", 0, $tmp_lhea_param);
+                }
+                delete ($lparhash->{logic_drc_phydrc}->{$group_id}->{$lhea_drc[0]});
+                delete ($lparhash->{logic_drc_phydrc}->{$group_id}->{$lhea_drc[1]});
+            } 
+        }
+    }
+
+    #print "======>cpus:$lparhash->{cpus}.\n";
+    $values = xCAT::FSPUtils::fsp_api_action($request, $name, $d, "part_set_lpar_pending_proc", 0, $lparhash->{cpus});
+    if (@$values[2] ne 0) {
+        &set_lpar_undefined($request, $name, $d);
+        return ([$name, @$values[1], @$values[2]]);
+    }
+    $values = &deal_with_avail_mem($request, $name, $d,$lparhash);
+    if (ref($values) eq "ARRAY") {
+        &set_lpar_undefined($request, $name, $d);
+        return ([@$values]);
+    }
+
+    #print "======>memory:$lparhash->{memory}.\n";
+    $values = xCAT::FSPUtils::fsp_api_action($request, $name, $d, "part_set_lpar_pending_mem", 0, $lparhash->{memory});
+    if (@$values[2] ne 0) {
+        &set_lpar_undefined($request, $name, $d);
+        return ([$name, @$values[1], @$values[2]]);
+    }
+    xCAT::FSPUtils::fsp_api_action($request, $name, $d, "part_set_lpar_comp_modes"); 
+    #print "======>memory:$lparhash->{huge_page}.\n";
+    xCAT::FSPUtils::fsp_api_action($request, $name, $d, "set_huge_page", 0, $lparhash->{huge_page});
+    #print "======>bsr:$lparhash->{bsr_num}.\n";
+    xCAT::FSPUtils::fsp_api_action($request, $name, $d, "set_lpar_bsr", 0, $lparhash->{bsr_num});
+    xCAT::FSPUtils::fsp_api_action($request, $name, $d, "part_set_partition_placement");
+    if (exists($request->{opt}->{vios})) { 
+        $values = xCAT::FSPUtils::fsp_api_action($request, $name, $d, "part_set_lpar_def_state", 0, 0x04);
+    } else {
+        $values = xCAT::FSPUtils::fsp_api_action($request, $name, $d, "part_set_lpar_def_state", 0, 0x02);
+    }
+    if (@$values[2] ne 0) {
+        return ([$name, @$values[1], @$values[2]]);
+    }
+    return ([$name, "Done", 0]);
+}
+
+sub mkspeclpar {
+    my $request = shift;
+    my $hash = shift;
+    my $opt = $request->{opt};
+    my $values;
+    my @result = ();
+    my $vmtab = xCAT::Table->new( 'vm');
+    unless($vmtab) {
+        return([["Error","Cannot open vm table", 1]]);
+    }
+    while (my ($mtms, $h) = each (%$hash)) {
+        my $memhash;
+        my @nodes = keys(%$h);
+        my $ent = $vmtab->getNodesAttribs(\@nodes, ['cpus', 'memory','physlots', 'othersettings']); 
+        while (my ($name, $d) = each (%$h)) {
+            if (@$d[4] ne 'lpar') {
+                push @result, [$name, "Node must be LPAR", 1];
+                last;
+            }
+            if (!exists($memhash->{run})) {
+                my @td = @$d;
+                @td[0] = 0;
+                $memhash = &query_cec_info_actions($request, $name, \@td, 1, ["part_get_hyp_process_and_mem","lpar_lhea_mac"]);
+                $memhash->{run} = 1; 
+            }
+            my $tmp_ent = $ent->{$name}->[0];
+            if (exists($opt->{vmcpus})) {
+                $tmp_ent->{cpus} = $opt->{vmcpus};
+            } 
+            if (exists($opt->{vmmemory})) {
+                $tmp_ent->{memory} = $opt->{vmmemory};
+            }
+            if (exists($opt->{vmphyslots})) {
+                $tmp_ent->{physlots} = $opt->{vmphyslots};
+            }
+            if (exists($opt->{vmothersetting})) {
+                $tmp_ent->{othersettings} = $opt->{vmothersetting};
+            }
+            if (!defined($tmp_ent) ) {
+                return ([[$name, "Not find params", 1]]);
+            } elsif (!exists($tmp_ent->{cpus}) || !exists($tmp_ent->{memory}) || !exists($tmp_ent->{physlots})) {
+                return ([[$name, "The attribute 'vmcpus', 'vmmemory' and 'vmphyslots' are all needed to be specified.", 1]]);
+            }
+            if ($tmp_ent->{memory} =~ /(\d+)([G|M]?)\/(\d+)([G|M]?)\/(\d+)([G|M]?)/i) {
+                my $memsize = $memhash->{mem_region_size};
+                my $min = $1;
+                if ($2 == "G" or $2 == '') {
+                    $min = $min * 1024;
+                }
+                $min = $min/$memsize;
+                my $cur = $3;
+                if ($4 == "G" or $4 == '') {
+                    $cur = $cur * 1024;
+                }
+                $cur = $cur/$memsize;
+                my $max = $5;
+                if ($6 == "G" or $6 == '') {
+                    $max = $max * 1024;
+                }
+                $max = $max/$memsize;
+                $tmp_ent->{memory} = "$min/$cur/$max";
+            }
+            $tmp_ent->{hyp_config_mem} = $memhash->{hyp_config_mem};
+            $tmp_ent->{hyp_avail_mem} = $memhash->{hyp_avail_mem};
+            $tmp_ent->{huge_page} = "0/0/0"; 
+            $tmp_ent->{bsr_num} = "0";
+            if (exists($tmp_ent->{othersettings}))  {
+                my $setting = $tmp_ent->{othersettings};
+                if ($setting =~ /hugepage:(\d+)/) {
+                    my $tmp = $1;
+                    $tmp_ent->{huge_page} = "1/".$tmp."/".$tmp;
+                }
+                if ($setting =~ /bsr:(\d+)/) {
+                    $tmp_ent->{bsr_num} = $1;
+                }
+            }
+            $tmp_ent->{phy_hea} = $memhash->{phy_drc_group_port};
+            $tmp_ent->{logic_drc_phydrc} = $memhash->{logic_drc_phydrc};
+            $values = &create_lpar($request, $name, $d, $tmp_ent); 
+            push @result, $values;
+            $name = undef;
+            $d = undef;
+        }
+    }
+    return \@result;    
+}
+
+sub mkfulllpar {
+    my $request = shift;
+    my $hash = shift;
+    my $values;
+    my @result = ();
+    while (my ($mtms, $h) = each (%$hash)) {
+        my $rethash;
+        while (my ($name, $d) = each (%$h)) {
+            if (@$d[4] ne 'lpar') {
+                push @result, [$name, "Node must be LPAR", 1];
+                last;
+            }
+            if (!exists($rethash->{run})) {
+                my @td = @$d;
+                @td[0] = 0;
+                $rethash = query_cec_info_actions($request, $name, \@td, 1); 
+                if (ref($rethash) ne 'HASH') {
+                    return ([[$mtms, "Cann't get hypervisor info hash", 1]]);
+                }
+                $rethash->{run} = 1; 
+                #print Dumper($rethash);
+            }
+            my %lpar_param = ();
+            $lpar_param{cpus} = "1/".$rethash->{process_units_avail}."/".$rethash->{process_units_config}; 
+            $lpar_param{memory} = "1/".$rethash->{hyp_avail_mem}."/".$rethash->{hyp_config_mem};
+            $lpar_param{hyp_config_mem} = $rethash->{hyp_config_mem};
+            $lpar_param{hyp_avail_mem} = $rethash->{hyp_avail_mem};
+            my @phy_io_array = keys(%{$rethash->{bus}});
+            $lpar_param{physlots} = join(",", @phy_io_array);
+            $lpar_param{huge_page} = "1/".$rethash->{huge_page_avail}."/".$rethash->{huge_page_avail};
+            $lpar_param{bsr_num} = $rethash->{cec_bsr_avail};
+            $lpar_param{phy_hea} = $rethash->{phy_drc_group_port};
+            $lpar_param{logic_drc_phydrc} = $rethash->{logic_drc_phydrc}; 
+            $values = &create_lpar($request, $name, $d, \%lpar_param);
+            $rethash->{logic_drc_phydrc} = $lpar_param{logic_drc_phydrc};
+            push @result, $values;
+            $name = undef;
+            $d = undef;
+        }    
+    }
+    return \@result;
+}
 
 ##########################################################################
 # Creates logical partitions 
@@ -1419,13 +2007,14 @@ sub mkvm {
     # decide if issuing mkvm with the option '-f'.
     # if yes, mklpar will be invoked to
     # create a full system partition for each CECs managed by the HMC.
-        if ( exists($opt->{full})) {
-                return( mkfulllpar(@_) );
-        }
-        else {
-        # if no, it will execute the original function.
-    return( create(@_) );
-	}
+    if (exists($opt->{p775})) {
+        return (create(@_));
+    }
+    if (exists($opt->{full})) {
+        return (mkfulllpar(@_));
+    } else {
+        return (mkspeclpar(@_));
+    }
 }
 
 ##########################################################################
@@ -1439,15 +2028,29 @@ sub chvm {
 ##########################################################################
 # No rmvm for Power 775 
 ##########################################################################
-#sub rmvm  {
+sub rmvm  {
+    my $request = $_[0];
+    my $opt = $request->{opt};
+    if (exists($opt->{p775})) {
+        return ([["lpar","rmvm only support Power Partitioning.", 1]]); 
+    } else {
+        return( remove(@_) );
+    }
 #    return( remove(@_) );
-#}
+}
 
 ##########################################################################
 # Lists logical partition profile
 ##########################################################################
 sub lsvm {
-    return( list(@_) );
+    my $request = shift;
+    my $hash    = shift;
+    my $args    = $request->{opt};
+    if (exists($args->{p775})) {    
+        return( list($request, $hash) );
+    } else {
+	return (query_cec_info($request, $hash));
+    }
 }
 
 1;

perl-xCAT/xCAT/GlobalDef.pm

@@ -33,6 +33,13 @@ $::NODETYPE_PPC="ppc";
 $::NODETYPE_ZVM="zvm";
 $::NODETYPE_MP="mp";
 
+#valid values for nodelist.updatestatus
+$::STATUS_SYNCING="syncing";
+$::STATUS_OUT_OF_SYNC="out-of-sync";
+$::STATUS_SYNCED="synced";
+$::STATUS_FAILED="failed";
+
+
 # valid values for nodelist.status columns or other status 
 $::STATUS_ACTIVE="alive";
 $::STATUS_INACTIVE="unreachable";
@@ -48,6 +55,28 @@ $::STATUS_STANDING_BY="standingby";
 $::STATUS_SHELL="shell";
 $::STATUS_DEFINED="defined";
 $::STATUS_UNKNOWN="unknown";
+$::STATUS_FAILED="failed";
+%::VALID_STATUS_VALUES = (
+	$::STATUS_ACTIVE=>1,
+	$::STATUS_INACTIVE=>1,
+	$::STATUS_INSTALLING=>1,
+	$::STATUS_INSTALLED=>1,
+	$::STATUS_BOOTING=>1,
+	$::STATUS_NETBOOTING=>1,
+	$::STATUS_BOOTED=>1,
+	$::STATUS_POWERING_OFF=>1,
+	$::STATUS_DISCOVERING=>1,
+	$::STATUS_CONFIGURING=>1,
+	$::STATUS_STANDING_BY=>1,
+	$::STATUS_SHELL=>1,
+	$::STATUS_DEFINED=>1,
+	$::STATUS_UNKNOWN=>1,
+        $::STATUS_FAILED=>1,
+
+	$::STATUS_SYNCING=>1,
+	$::STATUS_OUT_OF_SYNC=>1,
+	$::STATUS_SYNCED=>1,
+);
 
 #defined->[discovering]->[configuring]->[standingby]->installing->[installed]->booting->alive,  defined->[discovering]->[configuring]-[standingby]->netbooting->booted->alive,  alive/unreachable->booting->alive,  powering-off->unreachable, alive->unreachable
 %::NEXT_NODESTAT_VAL=(

perl-xCAT/xCAT/InstUtils.pm

@@ -9,12 +9,8 @@ BEGIN
 
 # if AIX - make sure we include perl 5.8.2 in INC path.
 #       Needed to find perl dependencies shipped in deps tarball.
-if ($^O =~ /^aix/i)
-{
-    use lib "/usr/opt/perl5/lib/5.8.2/aix-thread-multi";
-    use lib "/usr/opt/perl5/lib/5.8.2";
-    use lib "/usr/opt/perl5/lib/site_perl/5.8.2/aix-thread-multi";
-    use lib "/usr/opt/perl5/lib/site_perl/5.8.2";
+if ($^O =~ /^aix/i) {
+	unshift(@INC, qw(/usr/opt/perl5/lib/5.8.2/aix-thread-multi /usr/opt/perl5/lib/5.8.2 /usr/opt/perl5/lib/site_perl/5.8.2/aix-thread-multi /usr/opt/perl5/lib/site_perl/5.8.2));
 }
 
 use lib "$::XCATROOT/lib/perl";
@@ -27,7 +23,7 @@ use File::Path;
 use strict;
 require xCAT::Schema;
 use xCAT::NetworkUtils;
-
+use xCAT::TableUtils;
 #require Data::Dumper;
 #use Data::Dumper;
 require xCAT::NodeRange;
@@ -71,12 +67,14 @@ sub getnimprime
     # the primary NIM master is either specified in the site table
     # or it is the xCAT management node.
 
-    my $nimprime = xCAT::Utils->get_site_Master();
-    my $sitetab  = xCAT::Table->new('site');
-    (my $et) = $sitetab->getAttribs({key => "nimprime"}, 'value');
-    if ($et and $et->{value})
+    my $nimprime = xCAT::TableUtils->get_site_Master();
+    #my $sitetab  = xCAT::Table->new('site');
+    #(my $et) = $sitetab->getAttribs({key => "nimprime"}, 'value');
+    my @nimprimes = xCAT::TableUtils->get_site_attribute("nimprime");
+    my $tmp = $nimprimes[0];
+    if (defined($tmp))
     {
-        $nimprime = $et->{value};
+        $nimprime = $tmp;
     }
 
     my $hostname;
@@ -128,7 +126,7 @@ sub myxCATname
 		if (xCAT::Utils->isMN())
 		{
         	# read the site table, master attrib
-        	my $hostname = xCAT::Utils->get_site_Master();
+        	my $hostname = xCAT::TableUtils->get_site_Master();
         	if (($hostname =~ /\d+\.\d+\.\d+\.\d+/) || ($hostname =~ /:/))
         	{
             	$name = xCAT::NetworkUtils->gethostname($hostname);
@@ -752,11 +750,11 @@ sub get_server_nodes
         else
         {
             #  get ip facing node
-			$serv = xCAT::Utils->my_ip_facing($node);
+			$serv = xCAT::NetworkUtils->my_ip_facing($node);
         }
 		chomp $serv;
 
-		if (xCAT::Utils->validate_ip($serv)) {
+		if (xCAT::NetworkUtils->validate_ip($serv)) {
 			push (@{$servernodes{$serv}}, $node);
 		}
     }
@@ -895,12 +893,12 @@ sub dolitesetup
     	}
 	}
 
-	if (-e $litetreetab) {
-		my $rc = xCAT::Utils->runcmd("rm $litetreetab", -1);
+	if (-e $litetreetable) {
+		my $rc = xCAT::Utils->runcmd("rm $litetreetable", -1);
 		if ($::RUNCMD_RC != 0)
     	{
         	my $rsp;
-        	push @{$rsp->{data}}, "Could not remove existing $litetreetab file.";
+        	push @{$rsp->{data}}, "Could not remove existing $litetreetable file.";
         	xCAT::MsgUtils->message("E", $rsp, $callback);
         	return 1;
     	}
@@ -1134,7 +1132,11 @@ sub dolitesetup
         # $file could be full path file name or dir name
         # ex. /foo/bar/  or /etc/lppcfg
         my ($node, $option, $file) = split (/\|/, $line);
-        
+
+		if (!$file) {
+			next;
+       	}
+
         # ex. .../inst_root/foo/bar/  or .../inst_root/etc/lppcfg
         my $instrootfile = $instrootloc . $file;
 
@@ -1284,7 +1286,7 @@ sub dolitesetup
 
 	# add aixlitesetup to ..inst_root/aixlitesetup
 	# this will wind up in the root dir on the node ("/")
-	my $install_dir = xCAT::Utils->getInstallDir();
+	my $install_dir = xCAT::TableUtils->getInstallDir();
 	my $cpcmd = "/bin/cp $install_dir/postscripts/aixlitesetup $instrootloc/aixlitesetup; chmod +x $instrootloc/aixlitesetup";
 
 	my $out = xCAT::Utils->runcmd("$cpcmd", -1);

perl-xCAT/xCAT/KitPluginUtils.pm

@@ -0,0 +1,199 @@
+#!/usr/bin/env perl
+## IBM(c) 2007 EPL license http://www.eclipse.org/legal/epl-v10.html
+
+package xCAT::KitPluginUtils;
+
+BEGIN
+{
+    $::XCATROOT = $ENV{'XCATROOT'} ? $ENV{'XCATROOT'} : '/opt/xcat';
+}
+
+use lib "$::XCATROOT/lib/perl";
+
+use strict;
+use warnings;
+
+require xCAT::Table;
+
+
+#-------------------------------------------------------
+
+=head3  get_kits_used_by_nodes
+
+    Get the kits used by a list of nodes. A node uses a kit
+    if one or more of the kit's components are installed
+    on the node.
+
+    Arguments: list of node names (ref)
+
+    Returns: Return hash table which indexes the node names
+    by kitname (ref)
+    e.g., 
+         { "kitname1" => ["node11","node12",...],
+           "kitname2" => ["node21","node22",...]
+           ...
+         }
+
+    Examples: 
+        my @nodes = ("node11", "node12",...);
+        my $result = xCAT::KitPluginUtils->get_kits_used_by_nodes(\@nodes);
+
+=cut
+
+#-------------------------------------------------------
+
+sub get_kits_used_by_nodes {
+
+    my $class = shift;
+    my $nodes = shift;
+
+    # Group the nodes by what osimage they use
+    my $tablename = "nodetype";
+    my $table = xCAT::Table->new($tablename);
+    my $ent = $table->getNodesAttribs($nodes, ["provmethod"]);
+    
+    my $osimage_to_nodes = {};
+    foreach my $node (keys(%$ent)) {
+        my $provmethod = $ent->{$node}->[0]->{"provmethod"};
+        if (defined($provmethod)) {
+            push(@{ $osimage_to_nodes->{$provmethod} }, $node);
+       }
+    }
+
+    # Group the osimages by what kits they use
+    my @osimages = keys(%$osimage_to_nodes);
+    my $kits_to_osimages = xCAT::KitPluginUtils->get_kits_used_by_osimages(\@osimages);
+
+
+    # Group nodes by kit
+    my $kits_to_nodes = {};
+    foreach my $kit (keys(%$kits_to_osimages)) {
+        my $tmphash = {};
+        my $osimages = $kits_to_osimages->{$kit};
+        foreach my $osimage (@$osimages) {
+            # Store nodes as hash keys to eliminate duplicates
+            my @nodes = @{ $osimage_to_nodes->{$osimage} };
+            @$tmphash{@nodes} = ();
+        }
+        my @nodes = keys(%$tmphash);
+        $kits_to_nodes->{$kit} = \@nodes;
+    }
+
+    return $kits_to_nodes;
+}
+
+
+#-------------------------------------------------------
+
+=head3  get_kits_used_by_osimages
+
+    Get the kits used by a list of osimages. An osimage
+    uses a kit if one or more of the kit's components 
+    are associated with the osimage.
+
+    Arguments: list of osimage names (ref)
+
+    Returns: Return hash table which indexes the osimage
+    names by kitname (ref)
+    e.g., 
+         { "kitname1" => ["osimage11","osimage12",...],
+           "kitname2" => ["osimage21","osimage22",...]
+           ...
+         }
+
+    Examples: 
+      my @osimages = ("osimage11","osimage12", ...);
+      my $result = xCAT::KitPluginUtils->get_kits_used_by_osimages(\@osimages);
+
+=cut
+
+#-------------------------------------------------------
+
+sub get_kits_used_by_osimages {
+
+    my $class = shift;
+    my $osimages = shift;
+
+    # Get the kit components used by each osimage
+    my $tablename = "osimage";
+    my $table = xCAT::Table->new($tablename);
+
+    my $osimages_str = join ",", map {'\''.$_.'\''} @$osimages;
+    my $filter_stmt = sprintf("imagename in (%s)", $osimages_str);
+    my @table_rows = $table->getAllAttribsWhere($filter_stmt, ("imagename", "kitcomponents"));
+
+    my $kitcomps_to_osimages = {};
+    foreach my $row (@table_rows) {
+        if (defined($row->{kitcomponents})) {
+            my @kitcomps = split(/,/, $row->{kitcomponents});
+            foreach my $kitcomp (@kitcomps) {
+                push(@{ $kitcomps_to_osimages->{$kitcomp} }, $row->{imagename});
+            }
+        }
+    }
+
+    # Get the kit for each kit component
+    $tablename = "kitcomponent";
+    $table = xCAT::Table->new($tablename);
+
+    my $kitcomps_str = join ",", map {'\''.$_.'\''} keys(%$kitcomps_to_osimages);
+    $filter_stmt = sprintf("kitcompname in (%s)", $kitcomps_str);
+    @table_rows = $table->getAllAttribsWhere($filter_stmt, ("kitcompname", "kitname"));
+
+    my $kits_to_kitcomps = {};
+    foreach my $row (@table_rows) {
+        my $kitname = $row->{kitname};
+        my $kitcompname = $row->{kitcompname};
+        push(@{ $kits_to_kitcomps->{$kitname} }, $kitcompname);
+    }
+
+    # Match up kits to osimages
+
+    my $kits_to_osimages = {};
+    foreach my $kit (keys(%$kits_to_kitcomps)) {
+        my $tmphash = {};
+        my $kitcomps = $kits_to_kitcomps->{$kit};
+        foreach my $kitcomp (@$kitcomps) {
+            # Store osimages as hash keys to eliminate duplicates
+            my @osimages = @{ $kitcomps_to_osimages->{$kitcomp} };
+            @$tmphash{@osimages} = ();
+        }
+        my @osimages = keys(%$tmphash);
+        $kits_to_osimages->{$kit} = \@osimages;
+    }
+
+    return $kits_to_osimages;
+}
+
+
+#-------------------------------------------------------
+
+=head3  get_kits_used_by_image_profiles
+
+    Get the kits used by a list of image profiles.
+
+    Arguments: list of image profile names (ref)
+
+    Returns: Return hash table which indexes the image 
+    profile names by kitname (ref)
+    e.g., 
+         { "kitname1" => ["imgprofile11","imgprofile12",...],
+           "kitname2" => ["imgprofile21","imgprofile22",...]
+           ...
+         }
+
+    Examples: 
+      my @imgprofiles = ("imgprofile11","imgprofile12",...);
+      my $result = xCAT::KitPluginUtils->get_kits_used_by_image_profiles(\@imgprofiles);
+
+=cut
+
+#-------------------------------------------------------
+
+sub get_kits_used_by_image_profiles {
+
+    my $class = shift;
+    return xCAT::KitPluginUtils->get_kits_used_by_osimages(@_);
+}
+
+

perl-xCAT/xCAT/LparNetbootExp.pm

@@ -1849,6 +1849,14 @@ sub boot_network {
                 $state = $newstate[$state];
                 }
             ],
+            # For some old firmware, does not output "----"
+            [qr/BOOTP/=>
+                sub {
+                nc_msg ($verbose, $msg[$state]);
+                $rconsole->clear_accum();
+                $state = $newstate[$state];
+                }
+            ],
             [qr/]/=>
                 sub {
                 nc_msg($verbose, "Unexpected prompt\n");
@@ -1917,7 +1925,28 @@ sub Boot {
         #],
         [qr/BOOTP/=>      #-ex
             sub {
-                nc_msg($verbose, "# Network boot proceeding, exiting.\n");
+                nc_msg($verbose, "# Network boot proceeding - matched BOOTP, exiting.\n");
+                $rconsole->clear_accum();
+            }
+        ],
+        # Welcome to AIX - some old firmware does not output BOOTP or ----
+        [qr/Welcome/=>      #-ex
+            sub {
+                nc_msg($verbose, "# Network boot proceeding - matched Welcome, exiting.\n");
+                $rconsole->clear_accum();
+            }
+        ],
+        # tftp file download - some old firmware does not output BOOTP or ----
+        [qr/FILE/=>      #-ex
+            sub {
+                nc_msg($verbose, "# Network boot proceeding - matched FILE.\n");
+                $rconsole->clear_accum();
+            }
+        ],
+        # some old firmware does not output BOOTP or ----
+        [qr/Elapsed/=>      #-ex
+            sub {
+                nc_msg($verbose, "# Network boot proceeding - matched Elapsed, exiting.\n");
                 $rconsole->clear_accum();
             }
         ],
@@ -3148,12 +3177,12 @@ sub lparnetbootexp
                     }
                 ],
             );
-        return [1] if ($rc eq 1);
-        }
-        nc_msg($verbose, "# bootp sent over network.\n");
-        $rc = Boot($rconsole, $node, $verbose);#, @expect_out);
-        unless ($rc eq 0) {
-            nc_msg($verbose, "Can't boot here. \n");
+            return [1] if ($rc eq 1);
+            nc_msg($verbose, "# bootp sent over network.\n");
+            $rc = Boot($rconsole, $node, $verbose);#, @expect_out);
+            unless ($rc eq 0) {
+                nc_msg($verbose, "Can't boot here. \n");
+            }
         }
     }
 

perl-xCAT/xCAT/MacMap.pm

@@ -15,6 +15,7 @@ use strict;
 use xCAT::Table;
 use xCAT::Utils;
 use xCAT::MsgUtils;
+use xCAT::TableUtils;
 use IO::Select;
 use IO::Handle;
 use Sys::Syslog;
@@ -172,9 +173,11 @@ sub rvlan {
     #  operation => "pvid=<vid> or vlan=<vid>" for now, addvlan= and delvlan= for tagged vlans, 'pvid', vlan, or stat without = checks current value
     my $self=shift;
     my $community = "public";
-    $self->{sitetab} = xCAT::Table->new('site');
-    my $tmp = $self->{sitetab}->getAttribs({key=>'snmpc'},'value');
-    if ($tmp and $tmp->{value}) { $community = $tmp->{value} }
+    #$self->{sitetab} = xCAT::Table->new('site');
+    #my $tmp = $self->{sitetab}->getAttribs({key=>'snmpc'},'value');
+    my @snmpcs =  xCAT::TableUtils->get_site_attribute("snmpc");
+    my $tmp = $snmpcs[0];
+    if ( defined($tmp) ) { $community = $tmp }
     my %args = @_;
     my $op=$args{operation};
     my $nodes=$args{nodes};
@@ -302,9 +305,12 @@ sub refresh_table {
   $self->{switchestab} = xCAT::Table->new('switches', -create => 1);
   my @switchentries=$self->{switchestab}->getAllNodeAttribs([qw(switch snmpversion username password privacy auth)]);
   my $community = "public";
-  $self->{sitetab} = xCAT::Table->new('site');
-  my $tmp = $self->{sitetab}->getAttribs({key=>'snmpc'},'value');
-  if ($tmp and $tmp->{value}) { $community = $tmp->{value} }
+  #$self->{sitetab} = xCAT::Table->new('site');
+  #my $tmp = $self->{sitetab}->getAttribs({key=>'snmpc'},'value');
+  #if ($tmp and $tmp->{value}) { $community = $tmp->{value} }
+  my @snmpcs =  xCAT::TableUtils->get_site_attribute("snmpc");
+  my $tmp = $snmpcs[0];
+  if ( defined($tmp) ) { $community = $tmp }
   else { #Would warn here.. 
   }
   $self->{switchparmhash}={};

perl-xCAT/xCAT/MsgUtils.pm

@@ -5,16 +5,12 @@ package xCAT::MsgUtils;
 
 # if AIX - make sure we include perl 5.8.2 in INC path.
 #       Needed to find perl dependencies shipped in deps tarball.
-if ($^O =~ /^aix/i)
-{
-    use lib "/usr/opt/perl5/lib/5.8.2/aix-thread-multi";
-    use lib "/usr/opt/perl5/lib/5.8.2";
-    use lib "/usr/opt/perl5/lib/site_perl/5.8.2/aix-thread-multi";
-    use lib "/usr/opt/perl5/lib/site_perl/5.8.2";
+if ($^O =~ /^aix/i) {
+	unshift(@INC, qw(/usr/opt/perl5/lib/5.8.2/aix-thread-multi /usr/opt/perl5/lib/5.8.2 /usr/opt/perl5/lib/site_perl/5.8.2/aix-thread-multi /usr/opt/perl5/lib/site_perl/5.8.2));
 }
 
 use strict;
-use Sys::Syslog qw (:DEFAULT setlogsock);
+use Sys::Syslog;
 use xCAT::Utils;
 #use locale;
 use Socket;
@@ -137,7 +133,8 @@ This program module file, supports the xcat messaging and logging
 
                 D - DATA  goes to STDOUT
                 E - error.  This type of message will be sent to STDERR.
-                I - informational  goes to STDOUT
+                si - informational status info (sinfo)
+                I - informational  goes to STDOUT 
                 N - Node informational  goes to STDOUT
                 S - Message will be logged to syslog ( severe error)
                      Note S can be combined with other flags for example
@@ -213,12 +210,14 @@ This program module file, supports the xcat messaging and logging
      $rsp->{node}->[0]->{data}->[0] ="mydata";
      xCAT::MsgUtils->message("N", $rsp, $callback);
 
-
-
       my $rsp = {};
 		$rsp->{info}->[0] = "No hosts in node list\n";
 	    xCAT::MsgUtils->message("I", $rsp, $::CALLBACK);
 
+      my $rsp = {};
+		$rsp->{sinfo}->[0] = "No hosts in node list\n";
+	    xCAT::MsgUtils->message("IS", $rsp, $::CALLBACK);
+
 
       my $rsp = {};
 		$rsp->{warning}->[0] = "No hosts in node list\n";
@@ -275,7 +274,7 @@ sub message
     my $call_back = shift;    # optional
     my $exitcode  = shift;    # optional
 
-    # should be I, D, E, S, SA ,LS, W , L,N
+    # should be I,IS, D, E, S, SA ,LS, W , L,N
     #  or S(I, D, E, S, W, L,N)
     #
     # if new SA option need to split syslog messages from auditlog entry
@@ -357,6 +356,7 @@ sub message
         my $sevkey;
         if    ($sev =~ /D/) { $sevkey = 'data'; }
         elsif ($sev =~ /N/) { $sevkey = 'node'; }
+        elsif ($sev =~ /IS/) { $sevkey = 'sinfo'; }
         elsif ($sev =~ /I/) { $sevkey = 'info'; }
         elsif ($sev =~ /W/) { $sevkey = 'warning'; }
         elsif ($sev =~ /E/)
@@ -408,7 +408,7 @@ sub message
                 return;
             }
 
-            if ($exitcode)
+            if (defined($exitcode))
             {
                 push @{$rsp->{errorcode}}, $exitcode;
             }
@@ -456,8 +456,7 @@ sub message
 
         # If they want this msg to also go to syslog, do that now
         eval {
-            openlog("xCAT", '', 'local4');
-            setlogsock(["tcp", "unix", "stream"]);
+            openlog("xCAT", "nofatal,pid", "local4");
             if ($sev eq 'SE') {
               syslog("err", $rsp);
             } else {
@@ -503,8 +502,7 @@ sub message
             {
                 print $stdouterrf "Unable to open auditlog\n";
                 eval {
-                    openlog("xCAT", '', 'local4');
-                    setlogsock(["tcp", "unix", "stream"]);
+                    openlog("xCAT", "nofatal,pid", "local4");
                     syslog("err", "Unable to write to auditlog");
                     closelog();
                 };
@@ -521,8 +519,7 @@ sub message
         {    # error
             print $stdouterrf "Unable to open auditlog\n";
             eval {
-                openlog("xCAT", '', 'local4');
-                setlogsock(["tcp", "unix", "stream"]);
+                openlog("xCAT", "nofatal,pid", "local4");
                 syslog("err", "Unable to open auditlog");
                 closelog();
             };
@@ -720,7 +717,7 @@ sub verbose_message
     }
     my ($sec,$min,$hour,$mday,$mon,$yr,$wday,$yday,$dst) = localtime(time);
     my $time = sprintf "%04d%02d%02d.%02d:%02d:%02d", $yr+1900,$mon+1,$mday,$hour,$min,$sec;
-    $data = "$time ($$) ".$data;
+    $data = "$time ($$) ".$data; 
     if (defined($req->{callback})) {
         my %rsp;
         $rsp{data} = [$data];

perl-xCAT/xCAT/NameRange.pm

@@ -1,271 +0,0 @@
-# IBM(c) 2007 EPL license http://www.eclipse.org/legal/epl-v10.html
-package xCAT::NameRange;
-require xCAT::Table;
-require Exporter;
-use strict;
-
-#Perl implementation of namerange
-#  NOTE:  This is identical to xCAT::NodeRange except that no
-#		  database access occurs, no nodes are verified, and 
-#         no nodegroups are expanded.
-#		  Made a new utility since NodeRange is used EVERYWHERE in
-#		  xCAT code and did not want to risk de-stabilizing existing code.
-our @ISA = qw(Exporter);
-our @EXPORT = qw(namerange);
-
-my $recurselevel=0;
-
-
-sub subnodes (\@@) {
-    #Subtract set of nodes from the first list
-    my $nodes = shift;
-    my $node;
-    foreach $node (@_) {
-        @$nodes = (grep(!/^$node$/,@$nodes));
-    }
-}
-
-sub expandatom {
-	my $atom = shift;
-    my @nodes= ();
-    if ($atom =~ /^\(.*\)$/) {     # handle parentheses by recursively calling namerange()
-      $atom =~ s/^\((.*)\)$/$1/;
-      $recurselevel++;
-      return namerange($atom);
-    }
-    if ($atom =~ /@/) {
-          $recurselevel++;
-          return namerange($atom);
-     }
-
-	if ($atom =~ m/^\//) { # A regular expression - not supported in namerange
-          return ($atom);
-	}
-
-	if ($atom =~ m/(.*)\[(.*)\](.*)/) { # square bracket range
-	#for the time being, we are only going to consider one [] per atom
-	#xcat 1.2 does no better
-		my @subelems = split(/([\,\-\:])/,$2);
-		my $subrange="";
-		while (my $subelem = shift @subelems) {
-			my $subop=shift @subelems;
-			$subrange=$subrange."$1$subelem$3$subop";
-		}
-		foreach (split /,/,$subrange) {
-			my @newnodes=expandatom($_);
-			@nodes=(@nodes,@newnodes);
-		}
-		return @nodes;
-	}
-
-	if ($atom =~ m/\+/) {  # process the + operator
-		$atom =~ m/^([^0-9]*)([0-9]+)([^\+]*)\+([0-9]+)/;
-		my $pref=$1;
-		my $startnum=$2;
-		my $suf=$3;
-		my $end=$4+$startnum;
-        my $endnum = sprintf("%d",$end);
-        if (length ($startnum) > length ($endnum)) {
-          $endnum = sprintf("%0".length($startnum)."d",$end);
-        }
-		foreach ("$startnum".."$endnum") {
-			my @addnodes=expandatom($pref.$_.$suf);
-			@nodes=(@nodes,@addnodes);
-		}
-		return (@nodes);
-	}
-
-    if ($atom =~ m/[-:]/) { # process the minus range operator
-      my $left;
-      my $right;
-      if ($atom =~ m/:/) {
-        ($left,$right)=split /:/,$atom;
-      } else {
-        my $count= ($atom =~ tr/-//);
-        if (($count % 2)==0) { #can't understand even numbers of - in range context
-         # we might not really be in range context
-           return  ($atom);
-        }
-        my $expr="([^-]+?".("-[^-]*"x($count/2)).")-(.*)";
-        $atom =~ m/$expr/;
-        $left=$1;
-        $right=$2;
-      }
-      if ($left eq $right) { #if they said node1-node1 for some strange reason
-		return expandatom($left);
-      }
-      my @leftarr=split(/(\d+)/,$left);
-      my @rightarr=split(/(\d+)/,$right);
-      if (scalar(@leftarr) != scalar(@rightarr)) { #Mismatch formatting..
-        # guess it's meant to be a nodename
-        return  ($atom);
-      }
-      my $prefix = "";
-      my $suffix = "";
-      foreach (0..$#leftarr) {
-        my $idx = $_;
-        if ($leftarr[$idx] =~ /^\d+$/ and $rightarr[$idx] =~ /^\d+$/) { #pure numeric component
-          if ($leftarr[$idx] ne $rightarr[$idx]) { #We have found the iterator (only supporting one for now)
-            my $prefix = join('',@leftarr[0..($idx-1)]); #Make a prefix of the pre-validated parts
-            my $luffix; #However, the remainder must still be validated to be the same
-            my $ruffix;
-            if ($idx eq $#leftarr) {
-              $luffix="";
-              $ruffix="";
-            } else {
-              $ruffix = join('',@rightarr[($idx+1)..$#rightarr]);
-              $luffix = join('',@leftarr[($idx+1)..$#leftarr]);
-            }
-            if ($luffix ne $ruffix) { #the suffixes mismatched..
-              return ($atom);
-            }
-            foreach ($leftarr[$idx]..$rightarr[$idx]) {
-              my @addnodes=expandatom($prefix.$_.$luffix);
-              @nodes=(@nodes,@addnodes);
-            }
-            return (@nodes); #the return has been built, return, exiting loop and all
-          }
-        } elsif ($leftarr[$idx] ne $rightarr[$idx]) {
-          return ($atom);
-        }
-        $prefix .= $leftarr[$idx]; #If here, it means that the pieces were the same, but more to come
-      }
-      #I cannot conceive how the code could possibly be here, but whatever it is, it must be questionable
-      return  ($atom);
-	}
-
-	return ($atom);
-}
-
-sub namerange {
-  #We for now just do left to right operations
-  my $range=shift;
-  my %nodes = ();
-  my %delnodes = ();
-  my $op = ",";
-  my @elems = split(/(,(?![^[]*?])(?![^\(]*?\)))/,$range); # commas outside of [] or ()
-  if (scalar(@elems)==1) {
-      @elems = split(/(@(?![^\(]*?\)))/,$range);  # only split on @ when no , are present (inner recursion)
-  }
-
-  while (my $atom = shift @elems) {
-    if ($atom =~ /^-/) {           # if this is an exclusion, strip off the minus, but remember it
-      $atom = substr($atom,1);
-      $op = $op."-";
-    }
-
-    if ($atom =~ /^\^(.*)$/) {    # get a list of nodes from a file
-      open(NRF,$1);
-      while (<NRF>) {
-        my $line=$_;
-        unless ($line =~ m/^[\^#]/) {
-          $line =~ m/^([^:	 ]*)/;
-          my $newrange = $1;
-          chomp($newrange);
-          $recurselevel++;
-          my @filenodes = namerange($newrange);
-          foreach (@filenodes) {
-            $nodes{$_}=1;
-          }
-        }
-      }
-      close(NRF);
-      next;
-    }
-
-    my %newset = map { $_ =>1 } expandatom($atom);    # expand the atom and make each entry in the resulting array a key in newset
-
-    if ($op =~ /@/) {       # compute the intersection of the current atom and the node list we have received before this
-      foreach (keys %nodes) {
-        unless ($newset{$_}) {
-          delete $nodes{$_};
-        }
-      }
-    } elsif ($op =~ /,-/) {        # add the nodes from this atom to the exclude list
-		foreach (keys %newset) {
-			$delnodes{$_}=1; #delay removal to end
-		}
-	} else {          # add the nodes from this atom to the total node list
-		foreach (keys %newset) {
-			$nodes{$_}=1;
-		}
-	}
-	$op = shift @elems;
-
-    }    # end of main while loop
-
-    # Now remove all the exclusion nodes
-    foreach (keys %nodes) {
-		if ($delnodes{$_}) {
-			delete $nodes{$_};
-		}
-    }
-    if ($recurselevel) {
-        $recurselevel--;
-    }
-    return sort (keys %nodes);
-
-}
-
-
-1;
-
-=head1 NAME
-
-xCAT::NameRange - Perl module for xCAT namerange expansion
-
-=head1 SYNOPSIS
-
-	use xCAT::NameRange;
-	my @nodes=namerange("storage@rack1,node[1-200],^/tmp/nodelist,node300-node400,node401+10,500-550");
-
-=head1 DESCRIPTION
-
-namerange interprets xCAT noderange formatted strings and returns a list of 
-names. The following two operations are supported on elements, and interpreted 
-left to right:
-
-  , union next element with everything to the left.
-
-  @ take intersection of element to the right with everything on the left 
-   (i.e. mask out anything to the left not belonging to what is described to 
-   the right)
-
-Each element can be a number of things:
-
-  A node name, i.e.:
-
-=item * node1
-
-A hyphenated node range (only one group of numbers may differ between the left and right hand side, and those numbers will increment in a base 10 fashion):
-
-node1-node200 node1-compute-node200-compute
-node1:node200 node1-compute:node200-compute
-
-A namerange denoted by brackets:
-
-node[1-200] node[001-200]
-
-A regular expression describing the namerange:
-
-/d(1.?.?|200)
-
-A node plus offset (this increments the first number found in nodename):
-
-node1+199
-
-And most of the above substituting groupnames.
-3C
-3C
-
-NameRange tries to be intelligent about detecting padding, so you can:
-node001-node200
-And it will increment according to the pattern.
-
-
-=head1 COPYRIGHT
-
-Copyright 2007 IBM Corp.  All rights reserved.
-
-
-=cut

perl-xCAT/xCAT/NodeRange.pm

@@ -1,5 +1,6 @@
 # IBM(c) 2007 EPL license http://www.eclipse.org/legal/epl-v10.html
 package xCAT::NodeRange;
+use Text::Balanced qw/extract_bracketed/;
 require xCAT::Table;
 require Exporter;
 use strict;
@@ -180,7 +181,14 @@ sub nodesbycriteria {
    return \%critnodes;
 }
 
-sub expandatom { #TODO: implement table selection as an atom (nodetype.os==rhels5.3)
+# Expand one part of the noderange from the noderange() function.  Initially, one part means the
+# substring between commas in the noderange.  But expandatom also calls itself recursively to
+# further expand some parts.
+# Input args:
+#  - atom to expand
+#  - verify: whether or not to require that the resulting nodenames exist in the nodelist table
+#  - options: genericrange - a purely syntactical expansion of the range, not using the db at all, e.g not expanding group names
+sub expandatom {
 	my $atom = shift;
     if ($recurselevel > 4096) { die "NodeRange seems to be hung on evaluating $atom, recursion limit hit"; } 
     unless (scalar(@allnodeset) and (($allnodesetstamp+5) > time())) { #Build a cache of all nodes, some corner cases will perform worse, but by and large it will do better.  We could do tests to see where the breaking points are, and predict how many atoms we have to evaluate to mitigate, for now, implement the strategy that keeps performance from going completely off the rails
@@ -189,25 +197,28 @@ sub expandatom { #TODO: implement table selection as an atom (nodetype.os==rhels
         @allnodeset = $nodelist->getAllAttribs('node','groups');
         %allnodehash = map { $_->{node} => 1 } @allnodeset;
     }
-	my $verify = (scalar(@_) == 1 ? shift : 1);
+	my $verify = (scalar(@_) >= 1 ? shift : 1);
+  my %options = @_;      # additional options
         my @nodes= ();
     #TODO: these env vars need to get passed by the client to xcatd
 	my $nprefix=(defined ($ENV{'XCAT_NODE_PREFIX'}) ? $ENV{'XCAT_NODE_PREFIX'} : 'node');
 	my $nsuffix=(defined ($ENV{'XCAT_NODE_SUFFIX'}) ? $ENV{'XCAT_NODE_SUFFIX'} : '');
-	if ($allnodehash{$atom}) {		#The atom is a plain old nodename
+
+	if (not $options{genericrange} and  $allnodehash{$atom}) {		#The atom is a plain old nodename
 		return ($atom);
 	}
     if ($atom =~ /^\(.*\)$/) {     # handle parentheses by recursively calling noderange()
       $atom =~ s/^\((.*)\)$/$1/;
       $recurselevel++;
-      return noderange($atom);
+      return noderange($atom,$verify,1,%options);
     }
     if ($atom =~ /@/) {
           $recurselevel++;
-          return noderange($atom);
+          return noderange($atom,$verify,1,%options);
      }
 
     # Try to match groups?
+    unless ($options{genericrange}) {
         unless ($grptab) {
            $grptab = xCAT::Table->new('nodegroup');
         }
@@ -269,7 +280,9 @@ sub expandatom { #TODO: implement table selection as an atom (nodetype.os==rhels
         }
      }
   }
+}
 
+    # node selection based on db attribute values (nodetype.os==rhels5.3)
     if ($atom =~ m/[=~]/) { #TODO: this is the clunky, slow code path to acheive the goal.  It also is the easiest to write, strange coincidence.  Aggregating multiples would be nice
         my @nodes;
         foreach (@allnodeset) {
@@ -287,7 +300,7 @@ sub expandatom { #TODO: implement table selection as an atom (nodetype.os==rhels
     }
 	if ($atom =~ m/^[0-9]+\z/) {    # if only numbers, then add the prefix
 		my $nodename=$nprefix.$atom.$nsuffix;
-		return expandatom($nodename,$verify);
+		return expandatom($nodename,$verify,%options);
 	}
 	my $nodelen=@nodes;
 	if ($nodelen > 0) {
@@ -295,7 +308,7 @@ sub expandatom { #TODO: implement table selection as an atom (nodetype.os==rhels
 	}
 
 	if ($atom =~ m/^\//) { # A regular expression
-        unless ($verify) { # If not in verify mode, regex makes zero possible sense
+        if ($verify==0 or $options{genericrange}) { # If not in verify mode, regex makes zero possible sense
           return ($atom);
         }
 		#TODO: check against all groups
@@ -309,25 +322,29 @@ sub expandatom { #TODO: implement table selection as an atom (nodetype.os==rhels
 	}
 
 	if ($atom =~ m/(.+?)\[(.+?)\](.*)/) { # square bracket range
-		# if there are more than 1 [], we picked off just the 1st.  if there is another, we will process it later
-		my @subelems = split(/([\,\-\:])/,$2);
+		# if there is more than 1 set of [], we picked off just the 1st.  If there more sets of [], we will expand
+    # the 1st set and create a new set of atom by concatenating each result in the 1st expandsion with the rest
+    # of the brackets.  Then call expandatom() recursively on each new atom.
+		my @subelems = split(/([\,\-\:])/,$2);    # $2 is the range inside the 1st set of brackets
 		my $subrange="";
-        my $subelem;
-        my $start = $1;
-        my $ending = $3;
-        my $morebrackets = $ending =~ /\[.+?\]/;	# if there are more brackets, we have to expand just the 1st part, then add the 2nd part later
-		while (scalar @subelems) {
-            my $subelem = shift @subelems;
+    my $subelem;
+    my $start = $1;   # the text before the 1st set of brackets
+    my $ending = $3;    # the text after the 1st set of brackets (could contain more brackets)
+    my $morebrackets = $ending =~ /\[.+?\]/;	# if there are more brackets, we have to expand just the 1st part, then add the 2nd part later
+		while (scalar @subelems) {    # this while loop turns something like a[1-3] into a1-a3 because another section of expand atom knows how to expand that
+      my $subelem = shift @subelems;
 			my $subop=shift @subelems;
 			$subrange=$subrange."$start$subelem" . ($morebrackets?'':$ending) . "$subop";
 		}
-		foreach (split /,/,$subrange) {
-			my @newnodes=expandatom($_, ($morebrackets?0:$verify));
+		foreach (split /,/,$subrange) {   # this foreach is in case there were commas inside the brackets originally, e.g.: a[1,3,5]b[1-2]
+      # this expandatom just expands the part of the noderange that contains the 1st set of brackets
+      # e.g. if noderange is a[1-2]b[1-2] it will create newnodes of a1 and a2
+			my @newnodes=expandatom($_, ($morebrackets?0:$verify), genericrange=>($morebrackets||$options{genericrange}));
 			if (!$morebrackets) { push @nodes,@newnodes; }
 			else {
-				# for each of the new nodes, add the 2nd brackets and then expand
+				# for each of the new nodes (prefixes), add the rest of the brackets and then expand recursively
 				foreach my $n (@newnodes) {
-					push @nodes, expandatom("$n$ending", $verify);
+					push @nodes, expandatom("$n$ending", $verify, %options);
 				}
 			}
 		}
@@ -349,7 +366,7 @@ sub expandatom { #TODO: implement table selection as an atom (nodetype.os==rhels
 			$suf=$nsuffix;
 		}
 		foreach ("$startnum".."$endnum") {
-			my @addnodes=expandatom($pref.$_.$suf,$verify);
+			my @addnodes=expandatom($pref.$_.$suf,$verify,%options);
 			@nodes=(@nodes,@addnodes);
 		}
 		return (@nodes);
@@ -376,7 +393,7 @@ sub expandatom { #TODO: implement table selection as an atom (nodetype.os==rhels
         $right=$2;
       }
       if ($left eq $right) { #if they said node1-node1 for some strange reason
-		return expandatom($left,$verify);
+		return expandatom($left,$verify,%options);
       }
       my @leftarr=split(/(\d+)/,$left);
       my @rightarr=split(/(\d+)/,$right);
@@ -413,7 +430,7 @@ sub expandatom { #TODO: implement table selection as an atom (nodetype.os==rhels
               }
             }
             foreach ($leftarr[$idx]..$rightarr[$idx]) {
-              my @addnodes=expandatom($prefix.$_.$luffix,$verify);
+              my @addnodes=expandatom($prefix.$_.$luffix,$verify,%options);
               push @nodes,@addnodes;
             }
             return (@nodes); #the return has been built, return, exiting loop and all
@@ -461,7 +478,7 @@ sub retain_cache { #A semi private operation to be used *ONLY* in the interestin
         %allgrphash=();
     }
 }
-sub extnoderange { #An extended noderange function.  Needed as the more straightforward function return format too simple for this.
+sub extnoderange { #An extended noderange function.  Needed by the GUI as the more straightforward function return format too simple for this.
     my $range = shift;
     my $namedopts = shift;
     my $verify=1;
@@ -487,7 +504,7 @@ sub extnoderange { #An extended noderange function.  Needed as the more straight
     return $return;
 }
 sub abbreviate_noderange { 
-    #takes a list of nodes or a string and abbreviates
+    #takes a list of nodes or a string and reduces it by replacing a list of nodes that make up a group with the group name itself
     my $nodes=shift;
     my %grouphash;
     my %sizedgroups;
@@ -533,16 +550,40 @@ sub abbreviate_noderange {
     return (join ',',keys %targetelems,keys %nodesleft);
 }
 
+sub set_arith {
+    my $operand = shift;
+    my $op = shift;
+    my $newset = shift;
+    if ($op =~ /@/) {       # compute the intersection of the current atom and the node list we have received before this
+      foreach (keys %$operand) {
+        unless ($newset->{$_}) {
+          delete $operand->{$_};
+        }
+      }
+    } elsif ($op =~ /,-/) {        # add the nodes from this atom to the exclude list
+		foreach (keys %$newset) {
+            delete $operand->{$_}
+		}
+	} else {          # add the nodes from this atom to the total node list
+		foreach (keys %$newset) {
+			$operand->{$_}=1;
+		}
+	}
+}
+# Expand the given noderange
+# Input args:
+#  - noderange to expand
+#  - verify: whether or not to require that the resulting nodenames exist in the nodelist table
+#  - exsitenode: whether or not to honor site.excludenodes to automatically exclude those nodes from all noderanges
+#  - options: genericrange - a purely syntactical expansion of the range, not using the db at all, e.g not expanding group names
 sub noderange {
   $missingnodes=[];
   #We for now just do left to right operations
   my $range=shift;
   $range =~ s/['"]//g;
   my $verify = (scalar(@_) >= 1 ? shift : 1);
-
-  #excludenodes attribute in site table,
-  #these nodes should be excluded for any xCAT commands
-  my $exsitenode = (scalar(@_) >= 1 ? shift : 1);
+  my $exsitenode = (scalar(@_) >= 1 ? shift : 1);   # if 1, honor site.excludenodes
+  my %options = @_;      # additional options
 
   unless ($nodelist) { 
     $nodelist =xCAT::Table->new('nodelist',-create =>1); 
@@ -553,20 +594,45 @@ sub noderange {
   }
   my %nodes = ();
   my %delnodes = ();
+  if ($range =~ /\(/) {
+    my ($middle, $end, $start) =
+        extract_bracketed($range, '()', qr/[^()]*/);
+    unless ($middle) { die "Unbalanced parentheses in noderange" }
+    $middle = substr($middle,1,-1);
+    my $op = ",";
+    if ($start =~ m/-$/) { #subtract the parenthetical
+       $op .= "-"
+    } elsif ($start =~ m/\@$/) {
+        $op = "@"
+    }
+    $start =~ s/,-$//;
+    $start =~ s/,$//;
+    $start =~ s/\@$//;
+    %nodes = map { $_ => 1 } noderange($start,$verify,$exsitenode,%options);
+    my %innernodes = map { $_ => 1 } noderange($middle,$verify,$exsitenode,%options);
+    set_arith(\%nodes,$op,\%innernodes);
+    $range = $end;
+  }
+
   my $op = ",";
   my @elems = split(/(,(?![^[]*?])(?![^\(]*?\)))/,$range); # commas outside of [] or ()
   if (scalar(@elems)==1) {
       @elems = split(/(@(?![^\(]*?\)))/,$range);  # only split on @ when no , are present (inner recursion)
   }
 
-  while (my $atom = shift @elems) {
+  while (defined(my $atom = shift @elems)) {
+    if ($atom eq '') { next; }
     if ($atom eq ',') {
         next;
     }
     if ($atom =~ /^-/) {           # if this is an exclusion, strip off the minus, but remember it
       $atom = substr($atom,1);
       $op = $op."-";
+    } elsif ($atom =~ /^\@/) {           # if this is an exclusion, strip off the minus, but remember it
+      $atom = substr($atom,1);
+      $op = "@";
     }
+    if ($atom eq '') { next; }
 
     if ($atom =~ /^\^(.*)$/) {    # get a list of nodes from a file
       open(NRF,$1);
@@ -577,7 +643,7 @@ sub noderange {
           my $newrange = $1;
           chomp($newrange);
           $recurselevel++;
-          my @filenodes = noderange($newrange);
+          my @filenodes = noderange($newrange,$verify,$exsitenode,%options);
           foreach (@filenodes) {
             $nodes{$_}=1;
           }
@@ -587,7 +653,7 @@ sub noderange {
       next;
     }
 
-    my %newset = map { $_ =>1 } expandatom($atom,$verify);    # expand the atom and make each entry in the resulting array a key in newset
+    my %newset = map { $_ =>1 } expandatom($atom,$verify,%options);    # expand the atom and make each entry in the resulting array a key in newset
 
     if ($op =~ /@/) {       # compute the intersection of the current atom and the node list we have received before this
       foreach (keys %nodes) {
@@ -614,7 +680,7 @@ sub noderange {
         my $badnoderange = 0;
         my @badnodes = ();
 	if ($::XCATSITEVALS{excludenodes}) {
-                @badnodes = noderange($::XCATSITEVALS{excludenodes}, 1, 0);
+                @badnodes = noderange($::XCATSITEVALS{excludenodes}, 1, 0, %options);
                 foreach my $bnode (@badnodes) {
                     if (!$delnodes{$bnode}) {
                         $delnodes{$bnode} = 1;

perl-xCAT/xCAT/PPCboot.pm

@@ -8,6 +8,7 @@ use Getopt::Long;
 use xCAT::PPCcli qw(SUCCESS EXPECT_ERROR RC_ERROR NR_ERROR);
 use xCAT::Usage;
 use xCAT::Utils;
+use xCAT::TableUtils;
 use xCAT::MsgUtils;
 use xCAT::LparNetbootExp;
 
@@ -467,9 +468,12 @@ sub rnetboot {
         }
     }
 
-    my $sitetab  = xCAT::Table->new('site');
-    my $vcon = $sitetab->getAttribs({key => "conserverondemand"}, 'value');
-    if ($vcon and $vcon->{"value"} and $vcon->{"value"} eq "yes" ) {
+    #my $sitetab  = xCAT::Table->new('site');
+    #my $vcon = $sitetab->getAttribs({key => "conserverondemand"}, 'value');
+    my @vcons = xCAT::TableUtils->get_site_attribute("conserverondemand");
+    my $vcon = $vcons[0]; 
+    #if ($vcon and $vcon->{"value"} and $vcon->{"value"} eq "yes" ) {
+    if ( defined($vcon) and $vcon eq "yes" ) {
         $result = xCAT::PPCcli::lpar_netboot(
                             $exp,
                             $request->{verbose},
@@ -482,7 +486,7 @@ sub rnetboot {
         #########################################
         $result = do_rnetboot( $request, $d, $exp, $name, $node, \%opt );
     }
-    $sitetab->close;
+    #$sitetab->close;
 
     if (defined($request->{opt}->{m})) {
     

perl-xCAT/xCAT/PPCcfg.pm

@@ -8,6 +8,7 @@ use xCAT::PPCfsp;
 use xCAT::Usage;
 use Storable qw(freeze thaw);
 use POSIX "WNOHANG";
+use xCAT::NetworkUtils;
 use xCAT::MsgUtils qw(verbose_message);
 
 use LWP;
@@ -737,7 +738,7 @@ sub doresetnet {
             $nodetype = ( $nodetype =~ /^frame$/i ) ? "bpa" : "fsp";
             if ($cnodep) {
                 foreach my $cnode (@$cnodep) {
-                    my $ip = xCAT::Utils::getNodeIPaddress( $cnode );
+                    my $ip = xCAT::NetworkUtils::getNodeIPaddress( $cnode );
                     my $oi = $oihash{$cnode};
                     if(!defined $ip) {
                         send_msg($req, "doresetnet: can't get $cnode ip");
@@ -786,7 +787,7 @@ sub doresetnet {
     # this brunch is just for the xcat 2.5(or 2.5-) databse
     } elsif ( $nodetype =~ /^(fsp|bpa)$/ )  {
         foreach my $nn ( @{ $req->{node}} ) {
-            my $ip = xCAT::Utils::getNodeIPaddress( $nn );
+            my $ip = xCAT::NetworkUtils::getNodeIPaddress( $nn );
             if(!defined $ip) {
                 send_msg($req, "doresetnet: can't get $nn ip");
                 next;
@@ -1047,6 +1048,7 @@ sub child_process {
         }
     my $msg = "login result is :".join(',', @exp);
     xCAT::MsgUtils->verbose_message( $req, $msg);
+
     ####################################
     # do resetnet
     ####################################
@@ -1430,4 +1432,3 @@ sub connect {
 
 1;
 
-

perl-xCAT/xCAT/PPCcli.pm

@@ -6,7 +6,7 @@ require Exporter;
     our @ISA = qw(Exporter);
     our @EXPORT_OK = qw(SUCCESS RC_ERROR EXPECT_ERROR NR_ERROR);  
 use Expect;
-
+use xCAT::NetworkUtils;
 
 #############################################
 # Removes Ctrl characters from term output
@@ -139,7 +139,7 @@ sub connect {
     my $timeout    = $req->{ppctimeout};
     my $verbose    = $req->{verbose};
     my $ssh;
-    my $expect_log;
+    my $expect_log = "/dev/null";
     my $errmsg;
 	
     if ($req->{command} eq 'rflash') {
@@ -170,7 +170,7 @@ sub connect {
     ##################################################
     if ( $verbose ) {
         close STDERR;
-        if ( !open( STDERR, '>', \$expect_log )) {
+        if ( !open( STDERR, '>', $expect_log )) {
              return( "Unable to redirect STDERR: $!" );
         }
     }
@@ -179,7 +179,7 @@ sub connect {
     ##################################################
     if ( $verbose ) {
         close STDOUT;
-        if ( !open( STDOUT, '>', \$expect_log )) {
+        if ( !open( STDOUT, '>', $expect_log )) {
              return( "Unable to redirect STDOUT: $!" );
         }
     }
@@ -1335,7 +1335,7 @@ sub getHMCcontrolIP
         #my @newnodes = split(/,/, $nodes_found->[0]);
         #$Rc = shift(@newnodes);
         #for my $entry (@newnodes) {
-        #    if(xCAT::Utils->isIpaddr($entry)) {
+        #    if(xCAT::NetworkUtils->isIpaddr($entry)) {
         #        push @ips,$entry;
         #    }    
         #    $ip_result = join( ",", @ips );

perl-xCAT/xCAT/PPCconn.pm

@@ -5,9 +5,10 @@ use strict;
 use Getopt::Long;
 use xCAT::PPCcli qw(SUCCESS EXPECT_ERROR RC_ERROR NR_ERROR);
 use xCAT::Usage;
+use xCAT::NetworkUtils;
 use xCAT::DBobjUtils;
 use xCAT::FSPUtils;
-
+use xCAT::MsgUtils qw(verbose_message);
 ##############################################
 # Globals
 ##############################################
@@ -98,7 +99,7 @@ sub mkhwconn_parse_args
             #my $nodetype_hash    = $nodetypetab->getNodeAttribs( $node,[qw(nodetype)]);
             my $node_parent_hash = $ppctab->getNodeAttribs( $node,[qw(parent)]);
             #$nodetype    = $nodetype_hash->{nodetype};
-            $nodetype = xCAT::DBobjUtils->getnodetype($node);
+            $nodetype = xCAT::DBobjUtils->getnodetype($node,"ppc");
             $node_parent = $node_parent_hash->{parent};
             if ( !$nodetype )
             {
@@ -106,7 +107,7 @@ sub mkhwconn_parse_args
                 next;
             } else
             {
-                unless ( $nodetype =~ /^(fsp|bpa|frame|cec|hmc)$/)
+                unless ( $nodetype =~ /^(blade|fsp|bpa|frame|cec|hmc)$/)
                 {
                      return ( usage("Node type is incorrect. \n"));
                 }
@@ -473,6 +474,7 @@ sub mkhwconn
     my @value   = ();
     my $Rc      = undef;
 
+    xCAT::MsgUtils->verbose_message($request, "mkhwconn START."); 
     for my $cec_bpa ( keys %$hash)
     {
         my $node_hash = $hash->{$cec_bpa};
@@ -484,9 +486,13 @@ sub mkhwconn
             # Get IP address
             ############################
             my $cnode;
-            my $ntype = xCAT::DBobjUtils::getnodetype($node_name);
-            if ($ntype =~ /^(cec|frame)$/)
+            #my $ntype = xCAT::DBobjUtils::getnodetype($node_name);
+            my $ntype = $$d[4];
+            if ($ntype =~ /^(cec|frame|blade)$/)
             {
+                if ($ntype eq "blade") {
+                    delete $opt->{port};
+                }
                 $cnode = xCAT::DBobjUtils::getchildren($node_name, $opt->{port});
             } else {
                 $cnode = $node_name;
@@ -501,11 +507,12 @@ sub mkhwconn
             } else {
                 push @newnodes,$cnode;
             }
+            xCAT::MsgUtils->verbose_message($request, "mkhwconn :mksysconn for node:$node_name."); 
             for my $nn ( @newnodes )
             {
                 my $node_ip;
-                unless ( xCAT::Utils->isIpaddr($nn) ) {
-                    $node_ip = xCAT::Utils::getNodeIPaddress( $nn );
+                unless ( xCAT::NetworkUtils->isIpaddr($nn) ) {
+                    $node_ip = xCAT::NetworkUtils::getNodeIPaddress( $nn );
                 } else {
                     $node_ip = $nn;
                 }
@@ -515,12 +522,17 @@ sub mkhwconn
                     next;
                 }
 
-                my ( undef,undef,$mtms,undef,$type) = @$d;
+                my ( undef,undef,$mtms,undef,$type,$bpa) = @$d;
                 my ($user, $passwd);
                 if ( exists $opt->{P})
                 {
                     ($user, $passwd) = ('HMC', $opt->{P});
                 }
+                elsif ($type eq "blade") {
+                    $user = "USERID";
+                    ($user, $passwd) = xCAT::PPCdb::credentials( $bpa, $type, $user);
+                    $type = "cec";
+                }
                 else
                 {
                     ($user, $passwd) = xCAT::PPCdb::credentials( $node_name, $type,'HMC');
@@ -549,6 +561,7 @@ sub mkhwconn
 #            }
         }
     }
+    xCAT::MsgUtils->verbose_message($request, "mkhwconn END."); 
     return \@value;
 }
 ##########################################################################
@@ -639,7 +652,7 @@ sub lshwconn
                 {
                     #my $node_ip_hash = $hosttab->getNodeAttribs( $node_name,[qw(ip)]);
                     #$node_ip = $node_ip_hash->{ip};
-                    #$node_ip = xCAT::Utils::getNodeIPaddress( $node_name );
+                    #$node_ip = xCAT::NetworkUtils::getNodeIPaddress( $node_name );
 		    my $d = $node_hash->{$node_name};
                     $node_ip = xCAT::FSPUtils::getIPaddress($request, $$d[4], $node_name );
                 }
@@ -703,7 +716,7 @@ sub rmhwconn
             my $d = $node_hash->{$node_name};
 
             my ( undef,undef,undef,undef,$type) = @$d;
-
+            if ($type eq "blade") {$type = "cec";}
             ############################
             # Get IP address
             ############################
@@ -720,10 +733,19 @@ sub rmhwconn
 
             my @ips;
             foreach my $entry ( @$nodes_found ) {
-                if ( $entry =~ /$mtm\*$serial/)   {
-                    $entry =~ /ipaddr=(\d+\.\d+\.\d+\.\d+),/;
-                    push @ips, $1;
+                if ($entry =~ /type_model_serial_num=([^,]*),/) {
+                    my $match_mtm1 = $1;
+                    my $match_mtm2 = $match_mtm1;
+                    $match_mtm2 =~ s/\-//;
+                    if ($match_mtm1 =~ /$mtm\*$serial/ || $match_mtm2 =~ /$mtm\*$serial/) {
+                        $entry =~ /ipaddr=(\d+\.\d+\.\d+\.\d+),/;
+                        push @ips, $1;
+                    }
                 }
+            #if ( $entry =~ /$mtm\*$serial/)   {
+            #    $entry =~ /ipaddr=(\d+\.\d+\.\d+\.\d+),/;
+            #    push @ips, $1;
+            #}
             } 
             if (!@ips)
             {

perl-xCAT/xCAT/PPCdb.pm

@@ -4,7 +4,10 @@ package xCAT::PPCdb;
 use strict;
 use xCAT::Table;
 use xCAT::GlobalDef;
-
+use xCAT::Utils;
+use xCAT::TableUtils;
+use xCAT::NetworkUtils;
+require xCAT::data::ibmhwtypes;
 
 ###########################################
 # Factory defaults
@@ -98,7 +101,6 @@ sub add_ppc {
             $parent,
             $ips,
             $mac ) = split /,/;
-         
         ###############################
         # Update nodetype table
         ###############################
@@ -166,6 +168,10 @@ sub add_ppc {
             # Update nodelist table
             ###########################
             updategroups( $name, $db{nodelist}, $type );
+            my $tmp_group = xCAT::data::ibmhwtypes::parse_group($model);
+            if (defined($tmp_group)) {
+                updategroups($name, $db{nodelist}, $tmp_group);
+            }
             if ( $type =~ /^(fsp|bpa)$/ )  {
                 $db{nodelist}->setNodeAttribs( $name, {hidden => '1'});
             } else {
@@ -234,6 +240,97 @@ sub add_ppc {
     }
     return undef;
 }
+##########################################################################
+# Update lpar information in the xCAT databases
+##########################################################################
+sub update_lpar {
+    my $hwtype = shift;
+    my $values = shift;
+    my $write = shift;
+    my @tabs     = qw(ppc vpd nodehm nodelist nodetype ppcdirect hosts mac); 
+    my %db       = ();
+    my @update_list = ();
+    my @write_list = ();
+    ###################################
+    # Open database needed
+    ###################################
+    foreach ( @tabs ) {
+        $db{$_} = xCAT::Table->new( $_, -create=>1, -autocommit=>0 );
+        if ( !$db{$_} ) {
+            return( "Error opening '$_'" );
+        }
+    }
+    my @vpdlist = $db{vpd}->getAllNodeAttribs(['node','serial','mtm','side']);
+    my @ppclist = $db{ppc}->getAllNodeAttribs(['node','hcp','id',
+                                               'pprofile','parent','nodetype',
+                                               'comments', 'disable']);
+    #      'cec,cec1,,8246-L1D,100A9DA,,cec1,,cec1',
+    #      'lpar,10-0A9DA,1,8246-L1D,100A9DA,,cec1,,cec1'
+    my %ppchash = ();
+    my %vpdhash = ();
+    foreach my $ppcent (@ppclist) {
+        if ($ppcent->{id} and $ppcent->{nodetype} and $ppcent->{nodetype} eq "lpar") {
+            my $key = $ppcent->{node};
+            $ppchash{$key}{id} = $ppcent->{id};
+            $ppchash{$key}{parent} = $ppcent->{parent};
+        }
+    }
+    foreach my $vpdent (@vpdlist)
+    {
+        my $key = $vpdent->{node};
+        $vpdhash{$key}{mtm} = $vpdent->{mtm};
+        $vpdhash{$key}{serial} = $vpdent->{serial};
+    }
+    my @ppc_lpars = keys %ppchash; 
+    foreach my $value ( @$values ) {
+        my ($ttype,
+            $tname,
+            $tid,
+            $tmtm,
+            $tsn,
+            $tside,
+            $server,
+            $pprofile,
+            $parent) = split /,/, $value;
+            if ($ttype ne "lpar") {
+                push @update_list, $value;
+                next;
+            }
+            my $find_node = undef;
+            foreach my $tmp_node (@ppc_lpars) {
+                if ($ppchash{$tmp_node}{id} eq $tid) {
+                    if (exists($ppchash{$tmp_node}{parent}) and $ppchash{$tmp_node}{parent} eq $parent) {
+                        $find_node = $tmp_node;
+                        last;
+                    } elsif ($vpdhash{$tmp_node}{mtm} eq $tmtm and $vpdhash{$tmp_node}{serial} eq $tsn) {
+                        $find_node = $tmp_node;
+                        last;
+                    }
+                }
+            }
+            if (defined($find_node)) {
+                if ( update_node_attribs($hwtype, $ttype, $find_node, $tid, $tmtm, $tsn, $tside,
+                                    $server, $pprofile, $parent, "", \%db, $tname, \@ppclist))
+                {
+                    $value =~ s/^$ttype,$tname,/$ttype,$find_node,/; 
+                    push @update_list, $value;  
+                }
+            } elsif (defined($write)) {
+                push @write_list, $value;
+            }
+    }
+    if (defined($write)) {
+        &add_ppc($hwtype, \@write_list);
+        return ([@update_list,@write_list]);
+    } else {
+        foreach ( @tabs ) {
+            if ( exists( $db{$_}{commit} )) {
+               $db{$_}->commit;
+            }
+        }
+        return \@update_list;
+    }
+}
 
 ##########################################################################
 # Update nodes in the xCAT databases
@@ -276,7 +373,6 @@ sub update_ppc {
             $pprofile,
             $parent,
             $ips ) = split /,/, $value;
- 
         if ( $ttype eq 'cec' )
         {
             my $hostname =  get_host($tname, "FSP", $tmtm, $tsn, "", "", $tid, "","");
@@ -327,9 +423,7 @@ sub update_ppc {
             $pprofile,
             $parent,
             $ips ) = split /,/, $value;
-         
         next if ( $type ne 'cec' );
-
         my $predefined_node = undef;
         foreach my $vpdent (@vpdlist)
         {
@@ -523,6 +617,10 @@ sub update_node_attribs
     if ( $namediff)
     {
         updategroups( $name, $db->{nodelist}, $type );
+        my $tmp_group = xCAT::data::ibmhwtypes::parse_group($model);
+        if (defined($tmp_group)) {
+            updategroups($name, $db->{nodelist}, $tmp_group);
+        }
         $db->{nodelist}->setNodeAttribs( $name, {status=>$nodelisthash->{status},
                                                  appstatus=>$nodelisthash->{appstatus},
                                                  primarysn=>$nodelisthash->{primarysn},
@@ -886,6 +984,18 @@ sub get_usr_passwd {
     } else {
         ($ent) = $passwdtab->getNodeAttribs($key, qw(username password));
     }
+    if (!$ent) {
+        if ($key eq "cec") {
+            $key = "fsp";
+        } elsif ($key eq "frame") {
+            $key = "bpa";
+        }
+        if ($user) {
+            ($ent) = $passwdtab->getAttribs({key => $key, username => $user}, qw(password cryptmethod));
+        } else {
+            ($ent) = $passwdtab->getNodeAttribs($key, qw(username password));
+        }
+    }
     if (!$ent or !$ent->{password}) {
         my $hash = $default_passwd_accounts{$key};
         if (!$hash or ($user and !defined($hash->{$user}))) {
@@ -947,7 +1057,7 @@ sub get_host {
     #######################################
     if ($ip)
     {
-        my $nets = xCAT::Utils::my_nets();
+        my $nets = xCAT::NetworkUtils::my_nets();
         my $avip = getip_from_iplist( $ip, $nets);
         #if ( !defined( $ip )) {
         #    return undef;
@@ -956,7 +1066,6 @@ sub get_host {
     # get the information of existed nodes to do the migration
 
     read_from_table() unless (%::OLD_DATA_CACHE);
-
     foreach my $oldnode ( keys %::OLD_DATA_CACHE )
     {
         my $tmpmtm    = @{$::OLD_DATA_CACHE{$oldnode}}[0];
@@ -984,7 +1093,7 @@ sub get_host {
             }
 
             if ( $tmpmtm eq $mtm  and  $tmpsn eq $sn) {
-                my $ifip = xCAT::Utils->isIpaddr($oldnode);
+                my $ifip = xCAT::NetworkUtils->isIpaddr($oldnode);
                 if ( $ifip )  {# which means that the node is defined by the new lsslp
                     if ( $tmpside eq $side ) {# match! which means that node is the same as the new one
                         if ( $ip eq $tmpip ) { #which means that the ip is not changed
@@ -1104,7 +1213,7 @@ sub get_host {
     }
 
     # not matched, use the new name
-    my $ifip = xCAT::Utils->isIpaddr($nodename);
+    my $ifip = xCAT::NetworkUtils->isIpaddr($nodename);
     unless ($ifip) {
         return $nodename;
     }else {
@@ -1150,8 +1259,8 @@ sub getip_from_iplist
         for my $net ( keys %$nets)
         {
             my ($n,$m) = split /\//,$net;
-            if ( xCAT::Utils::isInSameSubnet( $n, $ip, $m, 1) and
-                 xCAT::Utils::isPingable( $ip))
+            if ( xCAT::NetworkUtils::isInSameSubnet( $n, $ip, $m, 1) and
+                 xCAT::NetworkUtils::isPingable( $ip))
             {
                 return $ip;
             }
@@ -1165,7 +1274,7 @@ sub read_from_table {
     my %typehash;
     my %iphash;
     my %vpdhash;
-    if ( !defined(%::OLD_DATA_CACHE))
+    if ( !(%::OLD_DATA_CACHE))
     {
         # find out all the existed nodes' ipaddresses
         my $hoststab  = xCAT::Table->new('hosts');
@@ -1211,7 +1320,7 @@ sub read_from_table {
                 @{$::OLD_DATA_CACHE{$entry->{node}}}[1] = @{$vpdhash{$entry->{node}}}[1];#sn
                 @{$::OLD_DATA_CACHE{$entry->{node}}}[2] = @{$vpdhash{$entry->{node}}}[2];#side
                 # find node ip address, check node name first, then check hosts table
-                my $ifip = xCAT::Utils->isIpaddr($entry->{node});
+                my $ifip = xCAT::NetworkUtils->isIpaddr($entry->{node});
                 if ( $ifip )
                 {
                     @{$::OLD_DATA_CACHE{$entry->{node}}}[3] = $entry->{node};#ip

perl-xCAT/xCAT/PPCenergy.pm

@@ -2,13 +2,19 @@
 
 package xCAT::PPCenergy;
 
+BEGIN
+{
+    $::XCATROOT = $ENV{'XCATROOT'} ? $ENV{'XCATROOT'} : '/opt/xcat';
+}
+use lib "$::XCATROOT/lib/perl";
+
 use strict;
 use Getopt::Long;
 use xCAT::Usage;
 use xCAT::NodeRange;
 use xCAT::DBobjUtils;
 use xCAT::FSPUtils;
-
+use xCAT::TableUtils qw(get_site_Master);
 %::QUERY_ATTRS = (
 'savingstatus' => 1,
 'dsavingstatus' => 1,
@@ -251,7 +257,7 @@ sub renergy {
         if( !defined($fsps) ) {
             return ([[$node, "Failed to get the FSPs for the cec $hcphost.", -1]]);
         }
-        #my $hcp_ip = xCAT::Utils::getNodeIPaddress($hcphost);
+        #my $hcp_ip = xCAT::NetworkUtils::getNodeIPaddress($hcphost);
         my $hcp_ip = xCAT::FSPUtils::getIPaddress($request, $hw_type, $hcphost);
         if (!defined($hcp_ip) or ($hcp_ip == -3)) {
             return ([[$node, "Failed to get IP address for $hcphost.", -1]]);
@@ -264,7 +270,7 @@ sub renergy {
         }
     } else {
         # for the case that hcp is hmc or fsp
-        push @hcps_ip, xCAT::Utils::getNodeIPaddress($hcphost);
+        push @hcps_ip, xCAT::NetworkUtils::getNodeIPaddress($hcphost);
     }
 
     if (!$user || !$password) {
@@ -279,28 +285,80 @@ sub renergy {
     }
     $verbose = $tmpv;
 
-    my $master = xCAT::Utils->get_site_Master();
-    my $masterip = xCAT::NetworkUtils->getipaddr($master);
-    if ($masterip =~ /:/) { #IPv6, needs fping6 support 
-        if (!-x '/usr/bin/fping6')
-        {
-            push @return_msg, [$node, "fping6 is not availabe for IPv6 ping.", -1];
-            return \@return_msg;
-        }
-        open (FPING, "fping6 ".join(' ',@hcps_ip). " 2>&1 |") or die("Cannot open fping pipe: $!");
-    } else {
-        open (FPING, "fping ".join(' ',@hcps_ip). " 2>&1 |") or die("Cannot open fping pipe: $!");
-    }
-
     my @pingable_hcp;
-    while (<FPING>) {
-        if ($verbose) {
-            push @return_msg, [$node, $_, 0];
-        }
-        if ($_ =~ /is alive/) {
-            s/ is alive//;
-            push @pingable_hcp, $_;
-        }
+    if (-x '/usr/bin/nmap' or -x '/usr/local/bin/nmap') { #use nmap
+	#print "use nmap\n";
+	if ($verbose) {
+	    push @return_msg, [$node, "Checking ping status using nmap for @hcps_ip", 0];
+	}
+	my %deadnodes;
+	foreach (@hcps_ip) {
+	    $deadnodes{$_}=1;
+	}	 
+	open (NMAP, "nmap -PE --system-dns --send-ip -sP ". join(' ',@hcps_ip) . " 2> /dev/null|") or die("Cannot open nmap pipe: $!");
+	my $node1;
+	my $msg1;
+	while (<NMAP>) {
+	    #print "$_\n";
+	    if (/Host (.*) \((.*)\) appears to be up/) {
+		$node1=$2;
+		unless ($deadnodes{$node1}) {
+		    foreach (keys %deadnodes) {
+			if ($node1 =~ /^$_\./) {
+			    $node1 = $_;
+			    last;
+			}
+		    }
+		}
+		delete $deadnodes{$node1};
+		if ($verbose) {
+		    push @return_msg, [$node, $_, 0];
+		}
+		push(@pingable_hcp, $node1);
+	    } elsif (/Nmap scan report for ([^ ]*) \((.*)\)/) {
+		$node1=$2;
+		$msg1=$_;
+	    } elsif (/Host is up./) {
+		unless ($deadnodes{$node1}) {
+		    foreach (keys %deadnodes) {
+			if ($node1 =~ /^$_\./) {
+			    $node1 = $_;
+			    last;
+			}
+		    }
+		}
+		delete $deadnodes{$node1};
+		if ($verbose) {
+		    push @return_msg, [$node, "$msg1$_", 0];
+		}
+		push(@pingable_hcp, $node1);
+	    }
+	}	
+    } else {
+	#use fping
+	#print "use fping\n";
+	my $master = xCAT::TableUtils->get_site_Master();
+	my $masterip = xCAT::NetworkUtils->getipaddr($master);
+	if ($masterip =~ /:/) { #IPv6, needs fping6 support 
+	    if (!-x '/usr/bin/fping6')
+	    {
+		push @return_msg, [$node, "fping6 is not availabe for IPv6 ping.", -1];
+		return \@return_msg;
+	    }
+	    open (FPING, "fping6 ".join(' ',@hcps_ip). " 2>&1 |") or die("Cannot open fping pipe: $!");
+	} else {
+	    open (FPING, "fping ".join(' ',@hcps_ip). " 2>&1 |") or die("Cannot open fping pipe: $!");
+	}
+	
+	while (<FPING>) {
+	    if ($verbose) {
+		push @return_msg, [$node, $_, 0];
+	    }
+	    if ($_ =~ /is alive/) {
+		s/ is alive//;
+		push @pingable_hcp, $_;
+	    }
+	}
     }
 
     if (!@pingable_hcp) {
@@ -319,17 +377,23 @@ sub renergy {
         # Generate the url path for CIM communication
         chomp($hcp);
         my $url_path = "https://"."$user".":"."$password"."\@"."$hcp".":5989";
+
+        # Not display password in command outupt.
+        my $display_url_path = "https://"."$user".":"."xxxxxx"."\@"."$hcp".":5989";
             
         # Execute the request
         my $cmd = "";
+        my $display_cmd = "";
         if ($opt->{'set'}) {
             $cmd = "$::CIM_CLIENT_PATH $verb_arg -u $url_path -n $cec_name -o $opt->{'set'}";
+            $display_cmd = "$::CIM_CLIENT_PATH $verb_arg -u $display_url_path -n $cec_name -o $opt->{'set'}";
         } elsif ($opt->{'query'}) {
             $cmd = "$::CIM_CLIENT_PATH $verb_arg -u $url_path -n $cec_name -o $opt->{'query'}";
+            $display_cmd = "$::CIM_CLIENT_PATH $verb_arg -u $display_url_path -n $cec_name -o $opt->{'query'}";
         }
         
         if ($verbose) {
-            push @noerr_msg, [$node, "Run following command: $cmd", 0];
+            push @noerr_msg, [$node, "Run following command: $display_cmd", 0];
         }
     
         # Disable the CHID signal before run the command. Otherwise the 

perl-xCAT/xCAT/PPCfsp.pm

@@ -12,6 +12,7 @@ use Socket;
 use xCAT::PPCdb; 
 use xCAT::MsgUtils qw(verbose_message);
 use xCAT::Utils;
+use xCAT::TableUtils;
 use xCAT::NetworkUtils;
 ##########################################
 # Globals
@@ -77,7 +78,7 @@ sub handler {
     # Disconnect from FSP 
     #####################################
     unless ($flag) {
-        xCAT::PPCfsp::disconnect( $exp );
+    xCAT::PPCfsp::disconnect( $exp );
     }    
     return( \@outhash );
 
@@ -1913,7 +1914,7 @@ sub set_netcfg
     elsif ( $inc_ip eq '*')
     {
         $inc_type = 'Static';
-        ($inc_ip, $inc_host, $inc_gateway, $inc_netmask) = xCAT::Utils::getNodeNetworkCfg(@$exp[1]);
+        ($inc_ip, $inc_host, $inc_gateway, $inc_netmask) = xCAT::NetworkUtils::getNodeNetworkCfg(@$exp[1]);
     }
     else
     {

perl-xCAT/xCAT/PPCinv.pm

@@ -5,6 +5,8 @@ use strict;
 use Getopt::Long;
 use xCAT::PPCcli qw(SUCCESS EXPECT_ERROR RC_ERROR NR_ERROR);
 use xCAT::Usage;
+use xCAT::TableUtils;
+require xCAT::data::ibmhwtypes;
 
 
 ##########################################
@@ -59,7 +61,7 @@ sub parse_args {
     $Getopt::Long::ignorecase = 0;
     Getopt::Long::Configure( "bundling" );
 
-    if ( !GetOptions( \%opt, qw(V|Verbose) )) { 
+    if ( !GetOptions( \%opt, qw(V|verbose t) )) { 
         return( usage() );
     }
     ####################################
@@ -75,6 +77,9 @@ sub parse_args {
     if ( !defined( $cmd )) {
         return(usage( "Invalid command: $ARGV[0]" ));
     }
+    if (exists($opt{t}) and $cmd ne "model") {
+        return(["Option 't' can only work with 'model'."]);
+    }
     ####################################
     # Check for an extra argument
     ####################################
@@ -411,6 +416,12 @@ sub vpd {
                 #############################
                 # Output value 
                 #############################
+                if ($_ eq 'model' and exists($request->{opt}->{t})) {
+		            my $tmp_pre = xCAT::data::ibmhwtypes::parse_args($data->{$_});
+		            if (defined($tmp_pre))  {
+			            xCAT::TableUtils->updatenodegroups($name, $tmp_pre);
+		            }
+		        }
                 my $value = "@{$prefix{$_}}[0]: $data->{$_}"; 
                 push @result, [$name,$value,$Rc];   
             }

perl-xCAT/xCAT/PPCmac.pm

@@ -6,8 +6,11 @@ use strict;
 use Getopt::Long;
 use Data::Dumper;
 use xCAT::PPCcli qw(SUCCESS EXPECT_ERROR RC_ERROR NR_ERROR);
+use xCAT::Utils;
+use xCAT::TableUtils;
+use xCAT::ServiceNodeUtils;
 use xCAT::NetworkUtils;
-
+use xCAT::MsgUtils qw(verbose_message);
 use xCAT::LparNetbootExp;
 
 ##########################################################################
@@ -46,7 +49,7 @@ sub parse_args {
     $Getopt::Long::ignorecase = 0;
     Getopt::Long::Configure( "bundling" );
 
-    if ( !GetOptions( \%opt,qw(h|help V|Verbose v|version C=s G=s S=s D d f M o F=s arp))) { 
+    if ( !GetOptions( \%opt,qw(h|help V|verbose v|version C=s G=s S=s D d f M o F=s arp))) { 
         return( usage() );
     }
     ####################################
@@ -74,6 +77,15 @@ sub parse_args {
         return(usage( "Invalid Argument: $ARGV[0]" ));
     }
     ####################################
+    # Check -o argument 
+    ####################################
+    if ( exists($opt{o}) ) {
+        unless (exists($opt{D})){
+            return(usage( "The -o flag must be used with -D flag" ));
+        }
+    
+    }
+    ####################################
     # Check argument for ping test
     ####################################
     if ( exists($opt{D}) ) {
@@ -90,9 +102,9 @@ sub parse_args {
         if ( exists($opt{S}) ) {
             push @network, $_;
         } else {
-			$server = xCAT::Utils->getSNformattedhash( $node, "xcat", "node", "primary" );
+	    $server = xCAT::ServiceNodeUtils->getSNformattedhash( $node, "xcat", "node", "primary" );
             foreach my $key ( keys %$server ) {
-                my $valid_ip = xCAT::Utils->validate_ip( $key );
+                my $valid_ip = xCAT::NetworkUtils->validate_ip( $key );
                 if ( $valid_ip ) {
                     ###################################################
                     # Service node is returned as hostname, Convert 
@@ -197,7 +209,7 @@ sub parse_args {
             if ( scalar(@network) != 3 ) {
                 return( usage() );
             }
-            my $result = xCAT::Utils->validate_ip( $opt{C}, $opt{G}, $opt{S} );
+            my $result = xCAT::NetworkUtils->validate_ip( $opt{C}, $opt{G}, $opt{S} );
             if ( @$result[0] ) {
                 return(usage( @$result[1] ));
             }
@@ -394,6 +406,7 @@ sub do_getmacs {
             #        last;
             #    }
             #}
+            xCAT::MsgUtils->verbose_message($request, "getmacs :lparnetbootexp for node:$node.");
             my $Rc = xCAT::LparNetbootExp->lparnetbootexp(\%optarg, $request);
     ######################################
     # Split results into array
@@ -631,6 +644,7 @@ sub getmacs {
         #########################################
         # Connect to fsp to achieve MAC address
         #########################################
+        xCAT::MsgUtils->verbose_message($request, "getmacs START.");
         my $d = $par;
 
         #########################################
@@ -651,6 +665,7 @@ sub getmacs {
         # Get name known by HCP
         #########################################
         my $filter = "name,lpar_id";
+        xCAT::MsgUtils->verbose_message($request, "getmacs :lssyscfg filter '$filter'.");
         my $values = xCAT::PPCcli::lssyscfg( $exp, $type, $mtms, $filter );
         my $Rc = shift(@$values);
 
@@ -676,9 +691,14 @@ sub getmacs {
             return( [[$node,"Node not found, lparid=$lparid",RC_ERROR]] );
         }
 
-        my $sitetab  = xCAT::Table->new('site');
-        my $vcon = $sitetab->getAttribs({key => "conserverondemand"}, 'value');
-        if ($vcon and $vcon->{"value"} and $vcon->{"value"} eq "yes" ) {
+        #my $sitetab  = xCAT::Table->new('site');
+        #my $vcon = $sitetab->getAttribs({key => "conserverondemand"}, 'value');
+        #there may be something wrong with the conserverondemand attribute. 
+        # Currently, the code is not used. So not fix this time. Just keep it here.
+        my @vcons = xCAT::TableUtils->get_site_attribute("conserverondemand");
+        my $vcon = $vcons[0];
+        #if ($vcon and $vcon->{"value"} and $vcon->{"value"} eq "yes" ) {
+        if ( defined($vcon) and $vcon eq "yes" ) {
             $result = xCAT::PPCcli::lpar_netboot(
                             $exp,
                             $request->{verbose},
@@ -689,10 +709,11 @@ sub getmacs {
             #########################################
             # Manually collect MAC addresses.
             #########################################
+            xCAT::MsgUtils->verbose_message($request, "getmacs :do_getmacs for node:$node.");
             $result = do_getmacs( $request, $d, $exp, $name, $node );
             $Rc = shift(@$result);
         }
-        $sitetab->close;
+        #$sitetab->close;
         
    
         ##################################
@@ -744,6 +765,7 @@ sub getmacs {
         if ( !exists( $opt->{d} )) {
             writemac( $node, $result );
         }
+        xCAT::MsgUtils->verbose_message($request, "getmacs END.");
         return( [[$node,$data,$Rc]] );
     }
 }

perl-xCAT/xCAT/PPCpower.pm

@@ -40,7 +40,7 @@ sub parse_args {
     $Getopt::Long::ignorecase = 0;
     Getopt::Long::Configure( "bundling" );
 
-    if ( !GetOptions( \%opt, qw(V|Verbose m:s@ t=s T=s r=s nodeps) )) {
+    if ( !GetOptions( \%opt, qw(V|verbose m:s@ t=s T=s r=s nodeps) )) {
         return( usage() );
     }
     ####################################

perl-xCAT/xCAT/PPCrflash.pm

@@ -8,6 +8,8 @@ use xCAT::Usage;
 use xCAT::PPCinv;
 use xCAT::DSHCLI;
 use xCAT::Table;
+use xCAT::Utils;
+use xCAT::TableUtils;
 use Getopt::Long;
 use File::Spec;
 use POSIX qw(tmpnam);
@@ -49,7 +51,6 @@ sub parse_args {
     my %opt     = ();
     my $cmd     = $request->{command};
     my $args    = $request->{arg};
-
     #############################################
     # Change CEC/Frame node into FSPs/BPAs
     #############################################     
@@ -157,15 +158,15 @@ sub parse_args {
     #--activate's value only can be concurrent and disruptive
     ################################
     if(exists($opt{activate})) {
-        if (defined($request->{mgt}) && ($request->{mgt} =~ /xCAT::FSP/i)) {
-            if (($opt{activate} ne "deferred") && ($opt{activate} ne "disruptive")) {
-                return (usage("--activate's value can only be deferred or disruptive"));
+        if (defined($request->{mgt}) && $request->{mgt} =~ /xCAT::FSP/i) {
+            if ($opt{activate} !~ /deferred|disruptive/) {
+                return (usage("--activate's value can only be deferred or disruptive."));
             }
         } else {
-            if( ($opt{activate} ne "concurrent") && ($opt{activate} ne "disruptive")) {
-                return (usage("--activate's value can only be disruptive or concurrent"));
+            if(($opt{activate} ne "disruptive") && ($opt{activate} ne "concurrent")) {
+                return (usage("--activate's value can only be disruptive or concurrent."));
             }
-        }  
+        }
         if(!exists( $opt{d} )) {
             $opt{d} = "/tmp";
         }
@@ -325,7 +326,7 @@ sub preprocess_for_rflash {
     my $request      = shift;
     my $opt = shift;    
     my $callback = $request->{callback}; 
-    my $install_dir = xCAT::Utils->getInstallDir();
+    my $install_dir = xCAT::TableUtils->getInstallDir();
     my $packages_fw = "$install_dir/packages_fw";
     my $c = 0;
     my $packages_d;
@@ -533,18 +534,22 @@ sub get_lic_filenames {
     #############
     if($fff ne $2) {
         $upgrade_required = 1;
+        if($activate ne "disruptive") {
+            $msg = "Option --activate's value should be disruptive";
+            return ("", "","", $msg, -1);
+        }
     } else {
 
-        if(($pns eq $1) && ($4 <= $active_level)) {
-        $msg = $msg. "Upgrade $mtms $activate!";
-    #    if($activate ne "concurrent") {
-    #        $msg = "Option --actviate's value should be disruptive";
-    #        return ("", "","", $msg, -1);
-    #    }
+        if(($pns eq $1) && ($3 > $active_level) &&($4 <= $active_level)) {
+            $msg = $msg. "Upgrade $mtms $activate!";
+            if($activate ne "concurrent") {
+                $msg = "Option --actviate's value should be concurrent";
+                return ("", "","", $msg, -1);
+            }
         } else {
-        $msg = $msg . "Upgrade $mtms!";
-            if($activate !~ /^(disruptive|concurrent)$/) {
-                $msg = "Option --activate's value shouldn't be $activate, and it must be disruptive or concurrent";
+            $msg = $msg . "Upgrade $mtms!";
+            if($activate ne "disruptive") {
+                $msg = "Option --activate's value should be disruptive";
                 return ("", "","", $msg, -1);
             }
         } 

perl-xCAT/xCAT/PPCscan.pm

@@ -11,7 +11,7 @@ use xCAT::PPCdb;
 use xCAT::GlobalDef;
 use xCAT::Usage;
 use xCAT::NetworkUtils;
-
+require xCAT::data::ibmhwtypes;
 
 ##############################################
 # Globals
@@ -74,7 +74,7 @@ sub parse_args {
     $Getopt::Long::ignorecase = 0;
     Getopt::Long::Configure( "bundling" );
 
-    if ( !GetOptions( \%opt, qw(V|Verbose u w x z) )){
+    if ( !GetOptions( \%opt, qw(V|verbose u w x z) )){
         return( usage() );
     }
     ####################################
@@ -545,6 +545,7 @@ sub format_stanza {
         #################################
         # Add each attribute
         #################################
+        my $mtm = undef;
         foreach ( @attribs ) {
             my $d = $data[$i++];
 
@@ -555,7 +556,8 @@ sub format_stanza {
             } elsif ( /^hwtype$/ ) {        
                 $d = $globalhwtype{$type};
             } elsif ( /^groups$/ ) {
-                $d = "$type,all";
+                next;
+                #$d = "$type,all";
             } elsif ( /^mgt$/ ) {
                 $d = $hwtype;
             } elsif ( /^cons$/ ) {
@@ -568,7 +570,9 @@ sub format_stanza {
             } elsif ( /^(mtm|serial)$/ ) {
                 if ( $type eq "lpar" ) {
                     $d = undef;                    
-                }     
+                } elsif (/^mtm$/) {
+                    $mtm = $d;
+                }
             } elsif (/^side$/) {
                 unless ( $type =~ /^fsp|bpa$/ ) {
                     next;
@@ -576,6 +580,14 @@ sub format_stanza {
             }
             $result .= "\t$_=$d\n";
         }
+        my $tmp_groups = "$type,all";
+        if (defined($mtm)) {
+            my $tmp_pre = xCAT::data::ibmhwtypes::parse_group($mtm);
+            if (defined($tmp_pre)) {
+                $tmp_groups .= ",$tmp_pre";
+            }     
+        }
+        $result .= "\tgroups=$tmp_groups\n";
     }
     return( $result );
 }
@@ -623,6 +635,7 @@ sub format_xml {
         #################################
         # Add each attribute 
         #################################
+        my $mtm = undef; 
         foreach ( @attribs ) {
             my $d = $data[$i++];
 
@@ -631,7 +644,8 @@ sub format_xml {
             } elsif ( /^hwtype$/ ) {        
                 $d = $globalhwtype{$type};
             } elsif ( /^groups$/ ) {
-                $d = "$type,all";
+                next;
+                #$d = "$type,all";
             } elsif ( /^mgt$/ ) {
                 $d = $hwtype;
             } elsif ( /^cons$/ ) {
@@ -643,6 +657,8 @@ sub format_xml {
             } elsif ( /^(mtm|serial)$/ ) {
                 if ( $type eq "lpar" ) {
                     $d = undef;
+                } elsif (/^mtm$/){
+                    $mtm = $d;
                 }
             } elsif (/^side$/) {
                 unless ( $type =~ /^fsp|bpa$/ ) {
@@ -651,6 +667,14 @@ sub format_xml {
             }
             $href->{Node}->{$_} = $d;
         }
+        my $tmp_groups = "$type,all";
+        if (defined($mtm)) {
+            my $tmp_pre = xCAT::data::ibmhwtypes::parse_group($mtm);
+            if (defined($tmp_pre)) {
+                $tmp_groups .= ",$tmp_pre";
+            }     
+        }
+        $href->{Node}->{groups}=$tmp_groups;
         #################################
         # XML encoding
         #################################

perl-xCAT/xCAT/PPCvitals.pm

@@ -40,7 +40,7 @@ sub parse_args {
     $Getopt::Long::ignorecase = 0;
     Getopt::Long::Configure( "bundling" );
 
-    if ( !GetOptions( \%opt, qw(V|Verbose) )) {
+    if ( !GetOptions( \%opt, qw(V|verbose) )) {
         return( usage() );
     }
     ####################################

perl-xCAT/xCAT/PPCvm.pm

@@ -8,7 +8,7 @@ use xCAT::PPCdb;
 use xCAT::Usage;
 use xCAT::NodeRange;
 use Data::Dumper;
-
+use xCAT::MsgUtils qw(verbose_message);
 
 ##############################################
 # Globals
@@ -504,6 +504,7 @@ sub clone {
     # Enumerate CECs
     #####################################
     my $filter = "type_model,serial_num";
+    xCAT::MsgUtils->verbose_message($request, "$request->{command} :lssyscfg fsps.filter:'$filter'.");
     my $cecs = xCAT::PPCcli::lssyscfg( $exp, "fsps", $filter );
     my $Rc = shift(@$cecs);
 
@@ -579,6 +580,7 @@ sub clone {
         $temp[2] = $destcec;
         $temp[4] = 'lpar';
 
+        xCAT::MsgUtils->verbose_message($request, "$request->{command} :mksyscfg lpar.cfg:'$cfg'.");
         my $result = xCAT::PPCcli::mksyscfg( $exp, "lpar", \@temp, $cfg ); 
         $Rc = shift(@$result);
 
@@ -618,6 +620,7 @@ sub remove {
     my @lpars   = ();
     my @values  = ();
     
+    xCAT::MsgUtils->verbose_message($request, "$request->{command} START.");
     while (my ($mtms,$h) = each(%$hash) ) {
         while (my ($lpar,$d) = each(%$h) ) {
             my $lparid = @$d[0];
@@ -641,6 +644,7 @@ sub remove {
             ####################################
             else {
                 my $filter = "name,lpar_id";
+                xCAT::MsgUtils->verbose_message($request, "$request->{command} :lssyscfg lpar.filter:'$filter'.");
                 my $result = xCAT::PPCcli::lssyscfg( 
                                              $exp,
                                              "lpar",
@@ -673,6 +677,7 @@ sub remove {
                     ###############################################
                     # begin to retrieve the CEC's service lpar id
                     ############################################### 
+                    xCAT::MsgUtils->verbose_message($request, "$request->{command} :lssyscfg fsp.filter:'service_lpar_id'.");
                     my $service_lparid = xCAT::PPCcli::lssyscfg(
                                                   $exp,
                                                   "fsp",
@@ -687,6 +692,7 @@ sub remove {
                         my $cfgdata = @$service_lparid[0];
                             if ( ($id == $cfgdata) && ($cfgdata !~ /none/) ) {
                                 $cfgdata = "service_lpar_id=none";
+                                xCAT::MsgUtils->verbose_message($request, "$request->{command} :lssyscfg fsp.filter:'$cfgdata'.");
                                 my $result = xCAT::PPCcli::chsyscfg( $exp, "fsp", $d, $cfgdata );
                                 $Rc = shift(@$result);
                                 if ( $Rc != SUCCESS ) {
@@ -703,6 +709,7 @@ sub remove {
                 ################################
                 # Send remove command 
                 ################################
+                xCAT::MsgUtils->verbose_message($request, "$request->{command} :rmsyscfg lpar.id:$id.");
                 my $result = xCAT::PPCcli::rmsyscfg( $exp, \@d );
                 my $Rc = shift(@$result);
 
@@ -710,6 +717,7 @@ sub remove {
                 # Remove LPAR from database 
                 ################################
                 if ( $Rc == SUCCESS and !exists( $opt->{r} ) ) {
+                    xCAT::MsgUtils->verbose_message($request, "$request->{command} :remove lpar:$name from xCATdb.");
                     my $err = xCATdB( "rmvm", $name,"", $id,"", $type,"" , $lpar );
                     if ( defined( $err )) {
                         push @values, [$lpar,$err,RC_ERROR];
@@ -720,6 +728,7 @@ sub remove {
             }
         }
     }
+    xCAT::MsgUtils->verbose_message($request, "$request->{command} END.");
     return( \@values ); 
 }
 
@@ -791,6 +800,7 @@ sub modify_by_attr {
     my $attrstr= $opt->{a};
     my @values;
 
+    xCAT::MsgUtils->verbose_message($request, "$request->{command} START.");
     # attrstr will be in stdin for "cat vmdef | chvm nodename"
     if (!defined($attrstr) && defined($request->{stdin})) {
         my $tempattr = $request->{stdin};
@@ -836,6 +846,7 @@ sub modify_by_attr {
                 ###########################
                 # Get current profile
                 ###########################
+                xCAT::MsgUtils->verbose_message($request, "$request->{command} :lssyscfg node.id:'@$d[0]'.");
                 my $cfg_res = xCAT::PPCcli::lssyscfg(
                              $exp,
                              "node",
@@ -868,6 +879,7 @@ sub modify_by_attr {
                 }
 
 
+               xCAT::MsgUtils->verbose_message($request, "$request->{command} :lssyscfg prof.filter:'lpar_ids=@$d[0],profile_names=@$cfg_res[0]'.");
                 my $prof = xCAT::PPCcli::lssyscfg(
                              $exp,
                              "prof",
@@ -893,12 +905,14 @@ sub modify_by_attr {
                     push @values, [$lpar, $err_msg, $Rc];
                     next;
                 }
+                xCAT::MsgUtils->verbose_message($request, "$request->{command} :chsyscfg prof.cfg:'$cfgdata'.");
                 my $result = xCAT::PPCcli::chsyscfg( $exp, "prof", $d, $cfgdata );
                 $Rc = shift(@$result);
                 push @values, [$lpar,@$result[0],$Rc];
             }
         }
     }
+    xCAT::MsgUtils->verbose_message($request, "$request->{command} END.");
     return (\@values);
 }
 
@@ -1004,6 +1018,7 @@ sub modify_by_prof {
     my $profile = $opt->{p};
     my @values;
 
+    xCAT::MsgUtils->verbose_message($request, "$request->{command} START.");
     #######################################
     # -p flag, find profile specified
     #######################################
@@ -1029,6 +1044,7 @@ sub modify_by_prof {
                 ###########################
                 # Get LPAR profiles 
                 ###########################
+                xCAT::MsgUtils->verbose_message($request, "$request->{command} :lssyscfg prof.filter:'lpar_ids=@$d[0],profile_names=$profile'.");
                 my $prof = xCAT::PPCcli::lssyscfg(
                              $exp,
                              "prof",
@@ -1100,6 +1116,7 @@ sub modify_by_prof {
             # Send command 
             ###############################
             if ( defined( $profile )) {
+               xCAT::MsgUtils->verbose_message($request, "$request->{command} :mksyscfg prof.cfg:'$cfg'.");
                my $result = xCAT::PPCcli::mksyscfg( $exp, "prof", $d, $cfg );
                my $Rc = shift(@$result);
 
@@ -1112,12 +1129,14 @@ sub modify_by_prof {
                push @values, [$lpar,@$result[0],$Rc];
             }
             else {
+               xCAT::MsgUtils->verbose_message($request, "$request->{command} :chsyscfg prof.cfg:'$cfg'.");
                my $result = xCAT::PPCcli::chsyscfg( $exp, "prof", $d, $cfg );
                my $Rc = shift(@$result);
                push @values, [$lpar,@$result[0],$Rc];
             }
         }
     }
+    xCAT::MsgUtils->verbose_message($request, "$request->{command} END.");
     return( \@values );
 }
 
@@ -1136,6 +1155,7 @@ sub list {
     my @lpars   = ();
     my $result;
 
+    xCAT::MsgUtils->verbose_message($request, "$request->{command} START.");
     while (my ($mtms,$h) = each(%$hash) ) {
         while (my ($lpar,$d) = each(%$h) ) {
             my $lparid = @$d[0];
@@ -1161,6 +1181,7 @@ sub list {
             ####################################
             else {
                 my $filter = "name,lpar_id";
+                xCAT::MsgUtils->verbose_message($request, "$request->{command} :lssyscfg lpar.filter:'$filter'.");
                 my $result = xCAT::PPCcli::lssyscfg(
                                              $exp,
                                              "lpar",
@@ -1191,6 +1212,7 @@ sub list {
                 #################################
                 # Get source LPAR profile
                 #################################
+                xCAT::MsgUtils->verbose_message($request, "$request->{command} :lssyscfg prof.filter:'lpar_ids=$id'.");
                 my $prof = xCAT::PPCcli::lssyscfg(
                                       $exp,
                                       "prof",
@@ -1244,7 +1266,7 @@ sub list {
     foreach ( sort keys %$values ) {
         push @value,$values->{$_};
     }
-
+    xCAT::MsgUtils->verbose_message($request, "$request->{command} END.");
     return( \@value );
 }
 ##########################################################################
@@ -1604,7 +1626,7 @@ sub create {
     my $mtms;
     my $type;
     my $profile;
-
+    xCAT::MsgUtils->verbose_message($request, "$request->{command} START.");
     #####################################
     # Get source node information
     #####################################
@@ -1643,6 +1665,7 @@ sub create {
     #####################################
     # Get source LPAR profile  
     #####################################
+    xCAT::MsgUtils->verbose_message($request, "$request->{command} :lssyscfg prof.filter:'lpar_ids=$lparid'.");
     my $prof = xCAT::PPCcli::lssyscfg(
                               $exp,
                               "prof",
@@ -1721,6 +1744,7 @@ sub create {
         #################################
         # Create new LPAR  
         #################################
+        xCAT::MsgUtils->verbose_message($request, "$request->{command} :mksyscfg lpar.cfg:'$cfgdata'.");
         $result = xCAT::PPCcli::mksyscfg( $exp, "lpar", $d, $cfgdata ); 
         $Rc = shift(@$result);
 
@@ -1728,6 +1752,7 @@ sub create {
         # Add new LPAR to database 
         #################################
         if ( $Rc == SUCCESS ) {
+            xCAT::MsgUtils->verbose_message($request, "$request->{command} :add lpar:$name from xCATdb.");
             my $err = xCATdB( "mkvm", $name, $profile, $id, $d, $hwtype, $lpar);
             if ( defined( $err )) {
                 push @values, [$name,$err,RC_ERROR];
@@ -1738,6 +1763,7 @@ sub create {
         push @values, [$name,@$result[0],$Rc];
         $id++;
     }
+    xCAT::MsgUtils->verbose_message($request, "$request->{command} END.");
     return( \@values );
 }
 

perl-xCAT/xCAT/RSYNC.pm

@@ -5,7 +5,7 @@ package xCAT::RSYNC;
 
 # cannot use strict
 use base xCAT::DSHRemoteShell;
-
+use xCAT::TableUtils qw(get_site_attribute);
 # Determine if OS is AIX or Linux
 # Configure standard locations of commands based on OS
 
@@ -35,6 +35,7 @@ if ($^O eq 'linux')
         	$class - Calling module name (discarded)
         	$config - Reference to copy command configuration hash table
         	$exec_path - Path to rsync executable
+        	$localhost - 1 indicates we are running on the Management Node 
 
         Returns:
         	A command array for the rsync command with the appropriate
@@ -68,7 +69,7 @@ if ($^O eq 'linux')
 
 sub remote_copy_command
 {
-    my ($class, $config, $exec_path) = @_;
+    my ($class, $config, $exec_path,$localhost) = @_;
 
     $exec_path || ($exec_path = $RSYNC_CMD);
 
@@ -76,7 +77,7 @@ sub remote_copy_command
     my $usersh=0;
     if ($^O eq 'aix')
     {
-      my @useSSH = xCAT::Utils->get_site_attribute("useSSHonAIX");
+      my @useSSH = xCAT::TableUtils->get_site_attribute("useSSHonAIX");
       if (defined($useSSH[0])) { 
         $useSSH[0] =~ tr/a-z/A-Z/;    # convert to upper
         if (($useSSH[0] eq "0") || ($useSSH[0] eq "NO"))
@@ -96,14 +97,22 @@ sub remote_copy_command
         if ($^O eq 'aix')
         {
             if (-e ("/usr/bin/rsync")) {
-             if ($usersh == 0) { # using ssh
+             if (($usersh == 0) || ($localhost == 1)) { # using ssh, or local 
+               if ($$config{'sudo'}){
+                $sync_opt = '--rsync-path=sudo /usr/bin/rsync ';
+               } else {
                 $sync_opt = '--rsync-path /usr/bin/rsync ';
+               }
              } else {
                 $sync_opt = '--rsh /bin/rsh --rsync-path /usr/bin/rsync ';
              }
             } else {
-             if ($usersh == 0) { # using ssh
-                $sync_opt = '--rsync-path /usr/local/bin/rsync ';
+             if (($usersh == 0) || ($localhost == 1)) { # using ssh, or local
+               if ($$config{'sudo'}){
+                $sync_opt = '--rsync-path=sudo /usr/local/bin/rsync  ';
+               } else {
+                $sync_opt = '--rsync-path=/usr/local/bin/rsync ';
+               }
              } else {
                 $sync_opt = '--rsh /bin/rsh --rsync-path /usr/local/bin/rsync ';
              }
@@ -111,11 +120,16 @@ sub remote_copy_command
         }
         else #linux
         {
+          if ($$config{'sudo'}) {
+            $sync_opt = '--rsync-path=\'sudo /usr/bin/rsync\' ';
+          } else {
             $sync_opt = '--rsync-path /usr/bin/rsync ';
+          }
         }
-        # if only syncing the service node or no postscripts then do not
+        # if only syncing the service node or
+        # (no postscripts and no append lines)  then do not
         # get update file notification
-        if (($::SYNCSN  == 1) || (!(defined @::postscripts))) { 
+        if (($::SYNCSN  == 1) || ((!(defined @::postscripts)) && (!(defined @::appendlines)) && (!(defined @::mergelines)))) { 
           $sync_opt .= '-Lprogtz ';
         } else {
            $sync_opt .= '-Liprogtz --out-format=%f%L '; # add notify of update
@@ -140,12 +154,17 @@ sub remote_copy_command
               "$$config{'dest-user'}@" . "$$config{'dest-host'}";
         }
         print RSCYCCMDFILE "#!/bin/sh\n";
-        if ($usersh == 0) { # using ssh
-          print RSCYCCMDFILE
-            "/usr/bin/ssh  $dest_user_host '/bin/mkdir -p $dest_dir_list'\n";
-        } else {
-          print RSCYCCMDFILE
-            "/usr/bin/rsh  $dest_user_host '/bin/mkdir -p $dest_dir_list'\n";
+        if ($localhost == 1) { # running to the MN from the MN
+            print RSCYCCMDFILE
+              "/bin/mkdir -p $dest_dir_list\n";
+        } else {  #  running to another node 
+          if ($usersh == 0) { # using ssh
+            print RSCYCCMDFILE
+              "/usr/bin/ssh  $dest_user_host '/bin/mkdir -p $dest_dir_list'\n";
+          } else {
+            print RSCYCCMDFILE
+              "/usr/bin/rsh  $dest_user_host '/bin/mkdir -p $dest_dir_list'\n";
+          }
         }
         foreach my $dest_dir (keys %{$$config{'destDir_srcFile'}})
         {
@@ -155,16 +174,28 @@ sub remote_copy_command
             my $src_file_list = join ' ', @src_file;
             if ($src_file_list)
             {
+               if ($localhost == 1) {  # running local ( on MN)
                 print RSCYCCMDFILE
-                  "$exec_path $sync_opt $src_file_list $dest_user_host:$dest_dir\n";
+                 "$exec_path $sync_opt $src_file_list $dest_dir\n";
+               } else {  # running to another node
+                print RSCYCCMDFILE
+                 "$exec_path $sync_opt $src_file_list $dest_user_host:$dest_dir\n";
+               }
             }
             my %diff_dest_hash =
               %{$$config{'destDir_srcFile'}{$dest_dir}{'diff_dest_name'}};
             foreach my $src_file_diff_dest (keys %diff_dest_hash)
             {
+
                 my $diff_basename = $diff_dest_hash{$src_file_diff_dest};
-                print RSCYCCMDFILE
+                # if  localhost do not put in hostname:
+                if ($localhost == 1) { # running to the MN from the MN (local)
+                  print RSCYCCMDFILE
+                  "$exec_path $sync_opt $src_file_diff_dest $dest_dir/$diff_basename\n";
+                } else { # running remote
+                  print RSCYCCMDFILE
                   "$exec_path $sync_opt $src_file_diff_dest $dest_user_host:$dest_dir/$diff_basename\n";
+                }
             }
 
         }

perl-xCAT/xCAT/RemoteShellExp.pm

@@ -41,15 +41,16 @@ package xCAT::RemoteShellExp;
    [-t node list]  test ssh connection to the node 
    [-k] Generates the ssh keys needed , for the user on the MN. 
    [-s node list]  copies the ssh keys to the nodes 
-
+   optional $timeout = timeout value for the expect.  Usually from the xdsh -t flag
+   default timeout is 10 seconds
     exit 0 - good
     exit 1 - abort
     exit 2 - usage error
 
 Examples:
-$rc=xCAT::RemoteShellExp->remoteshellexp("k",$callback,$remoteshellcmd); 
-$rc=xCAT::RemoteShellExp->remoteshellexp("s",$callback,$remoteshellcmd,$nodes); 
-$rc=xCAT::RemoteShellExp->remoteshellexp("t",$callback,$remoteshellcmd,$nodes); 
+$rc=xCAT::RemoteShellExp->remoteshellexp("k",$callback,$remoteshellcmd,$nodes,$timeout); 
+$rc=xCAT::RemoteShellExp->remoteshellexp("s",$callback,$remoteshellcmd,$nodes,$timeout); 
+$rc=xCAT::RemoteShellExp->remoteshellexp("t",$callback,$remoteshellcmd,$nodes,$timeout); 
 
 =cut
 
@@ -70,13 +71,13 @@ use strict;
 #-----------------------------------------------------------------------------
 sub remoteshellexp 
 {
-  my ($class, $flag, $callback, $remoteshell, $nodes) = @_;
+  my ($class, $flag, $callback, $remoteshell, $nodes, $timeout) = @_;
   my $rc=0;
   $::CALLBACK = $callback;
   if (!($flag))
   {
        my $rsp = {};
-       $rsp->{data}->[0] = 
+       $rsp->{error}->[0] = 
        "No flag provide to remoteshellexp.";
         xCAT::MsgUtils->message("E", $rsp, $::CALLBACK, 2);
         return 2;
@@ -84,12 +85,16 @@ sub remoteshellexp
 
   if (($flag ne "k") && ($flag ne "t") && ($flag ne "s")) {
        my $rsp = {};
-       $rsp->{data}->[0] = 
+       $rsp->{error}->[0] = 
         "Invalid  flag  $flag provided.";
         xCAT::MsgUtils->message("E", $rsp, $::CALLBACK, 1);
        return 2;
        
   }
+  my  $expecttimeout=10; # default
+  if (defined($timeout)) {  # value supplied
+     $expecttimeout=$timeout;
+  }
 
   # for -s flag must have nodes and a $to_userid password
   my $to_user_password;
@@ -99,14 +104,14 @@ sub remoteshellexp
   if ($flag eq "s"){
 	if (!$to_user_password) {
        my $rsp = {};
-       $rsp->{data}->[0] = 
+       $rsp->{error}->[0] = 
         "The DSH_REMOTE_PASSWORD environment variable has not been set to the user id password on the node which will have their ssh keys updated (ususally root).";
         xCAT::MsgUtils->message("E", $rsp, $::CALLBACK, 1);
        return 2;
 	}
 	if (!$nodes) {
        my $rsp = {};
-       $rsp->{data}->[0] = 
+       $rsp->{error}->[0] = 
         "No nodes were input to update the user's ssh keys.";
         xCAT::MsgUtils->message("E", $rsp, $::CALLBACK, 1);
        return 2;
@@ -162,7 +167,7 @@ sub remoteshellexp
   # Check to see if empty
   if (-z $key) {
          my $rsp = {};
-         $rsp->{data}->[0] = 
+         $rsp->{error}->[0] = 
          "The $key file is empty. Remove it and rerun the command.";
          xCAT::MsgUtils->message("E", $rsp, $::CALLBACK, 1);
          return 1;
@@ -170,7 +175,7 @@ sub remoteshellexp
   } 
   if (-z $key2) {
          my $rsp = {};
-         $rsp->{data}->[0] = 
+         $rsp->{error}->[0] = 
          "The $key2 file is empty. Remove it and rerun the command.";
          xCAT::MsgUtils->message("E", $rsp, $::CALLBACK, 1);
          return 1;
@@ -180,28 +185,28 @@ sub remoteshellexp
   {
      # if the file size of the id_rsa key is 0, tell them to remove it
      # and run the command again
-     $rc=xCAT::RemoteShellExp->gensshkeys;
+     $rc=xCAT::RemoteShellExp->gensshkeys($expecttimeout);
   }
   # send ssh keys to the nodes/devices, to setup passwordless ssh 
   if ($flag eq "s")
   {
     if (!($nodes)) {
          my $rsp = {};
-         $rsp->{data}->[0] = 
+         $rsp->{error}->[0] = 
          "There are no nodes defined to update the ssh keys.";
          xCAT::MsgUtils->message("E", $rsp, $::CALLBACK, 1);
          return 1;
     }
     if ($ssh_setup_cmd) { # setup ssh on devices
-     $rc=xCAT::RemoteShellExp->senddeviceskeys($remoteshell,$remotecopy,$to_userid,$to_user_password,$home,$ssh_setup_cmd,$nodes);
+     $rc=xCAT::RemoteShellExp->senddeviceskeys($remoteshell,$remotecopy,$to_userid,$to_user_password,$home,$ssh_setup_cmd,$nodes, $expecttimeout);
     } else {  #setup ssh on nodes
-     $rc=xCAT::RemoteShellExp->sendnodeskeys($remoteshell,$remotecopy,$to_userid,$to_user_password,$home,$nodes);
+     $rc=xCAT::RemoteShellExp->sendnodeskeys($remoteshell,$remotecopy,$to_userid,$to_user_password,$home,$nodes, $expecttimeout);
     } 
   }
   # test ssh setup on the node
   if ($flag eq "t")
   {
-     $rc=xCAT::RemoteShellExp->testkeys($remoteshell,$to_userid,$nodes);
+     $rc=xCAT::RemoteShellExp->testkeys($remoteshell,$to_userid,$nodes,$expecttimeout);
   }
   return $rc;
 }
@@ -220,9 +225,9 @@ sub remoteshellexp
 sub gensshkeys 
 
 {
-    my ($class) = @_;
+    my ($class, $expecttimeout) = @_;
     my $keygen;
-    my $timeout  = 10;    # sets Expect default timeout, 0 accepts immediately
+    my $timeout  = $expecttimeout;    # sets Expect default timeout, 0 accepts immediately
     my $keygen_sent = 0;
     my $prompt1   = 'Generating public/private rsa';
     my $prompt2   = 'Enter file.*:';
@@ -267,7 +272,7 @@ sub gensshkeys
     unless ($keygen->spawn($spawncmd))
     {
        my $rsp = {};
-       $rsp->{data}->[0] = 
+       $rsp->{error}->[0] = 
         "Unable to run $spawncmd.";
        xCAT::MsgUtils->message("E", $rsp, $::CALLBACK, 1);
        return 1;
@@ -324,8 +329,8 @@ sub gensshkeys
           return 0;
         } else {
           my $rsp = {};
-          $rsp->{data}->[0] =  $msg;
-          xCAT::MsgUtils->message("I", $rsp, $::CALLBACK);
+          $rsp->{error}->[0] =  $msg;
+          xCAT::MsgUtils->message("E", $rsp, $::CALLBACK);
           return 1;
         }
 
@@ -347,9 +352,9 @@ sub gensshkeys
 sub testkeys 
 
 {
-    my ($class,$remoteshell,$to_userid,$nodes) = @_;
+    my ($class,$remoteshell,$to_userid,$nodes, $expecttimeout) = @_;
     my $testkeys;
-    my $timeout  = 10;    # sets Expect default timeout, 0 accepts immediately
+    my $timeout  = $expecttimeout;    # sets Expect default timeout
     my $testkeys_sent = 0;
     my $prompt1   = 'Are you sure you want to continue connecting (yes/no)?';
     my $prompt2   = 'ssword:';
@@ -394,7 +399,7 @@ sub testkeys
     unless ($testkeys->spawn($spawncmd))
     {
        my $rsp = {};
-       $rsp->{data}->[0] = 
+       $rsp->{error}->[0] = 
         "Unable to run $spawncmd.";
        xCAT::MsgUtils->message("E", $rsp, $::CALLBACK, 1);
        return 1;
@@ -446,8 +451,8 @@ sub testkeys
           return 0;
         } else {
           my $rsp = {};
-          $rsp->{data}->[0] =  $msg;
-          xCAT::MsgUtils->message("I", $rsp, $::CALLBACK);
+          $rsp->{error}->[0] =  $msg;
+          xCAT::MsgUtils->message("E", $rsp, $::CALLBACK);
           return 1;
         }
 
@@ -469,9 +474,9 @@ sub testkeys
 sub sendnodeskeys 
 
 {
-   my ($class,$remoteshell,$remotecopy,$to_userid,$to_userpassword,$home,$nodes) = @_;
+   my ($class,$remoteshell,$remotecopy,$to_userid,$to_userpassword,$home,$nodes, $expecttimeout) = @_;
     my $sendkeys;
-    my $timeout  = 10;    # sets Expect default timeout, 0 accepts immediately
+    my $timeout  = $expecttimeout;    # sets Expect default timeout, 0 accepts immediately
     my $sendkeys_sent = 0;
     my $prompt1   = 'Are you sure you want to continue connecting (yes/no)?';
     my $prompt2   = 'ssword:';
@@ -522,7 +527,7 @@ sub sendnodeskeys
       unless ($sendkeys->spawn($spawnmkdir))
       {
         my $rsp = {};
-        $rsp->{data}->[0] = 
+        $rsp->{error}->[0] = 
          "Unable to run $spawnmkdir on $node";
         xCAT::MsgUtils->message("E", $rsp, $::CALLBACK, 1);
         next;
@@ -571,8 +576,8 @@ sub sendnodeskeys
                   $rc=0;
                } else {
                  my $rsp = {};
-                 $rsp->{data}->[0] =  "mkdir:$node has error,$msg";
-                 xCAT::MsgUtils->message("I", $rsp, $::CALLBACK);
+                 $rsp->{error}->[0] =  "mkdir:$node has error,$msg";
+                 xCAT::MsgUtils->message("E", $rsp, $::CALLBACK);
                  $rc=1;
                }
             }
@@ -612,7 +617,7 @@ sub sendnodeskeys
       unless ($sendkeys->spawn($spawncopyfiles))
       {
         my $rsp = {};
-        $rsp->{data}->[0] = 
+        $rsp->{error}->[0] = 
          "Unable to run $spawncopyfiles on $node.";
         xCAT::MsgUtils->message("E", $rsp, $::CALLBACK, 1);
         next; 
@@ -658,8 +663,8 @@ sub sendnodeskeys
                   $rc=0;
                } else {
                 my $rsp = {};
-                $rsp->{data}->[0] =  "copykeys:$node has error,$msg";
-                xCAT::MsgUtils->message("I", $rsp, $::CALLBACK);
+                $rsp->{error}->[0] =  "copykeys:$node has error,$msg";
+                xCAT::MsgUtils->message("E", $rsp, $::CALLBACK);
                 $rc=1;
               }
             }
@@ -693,7 +698,7 @@ sub sendnodeskeys
       unless ($sendkeys->spawn($spawnruncopy))
       {
         my $rsp = {};
-        $rsp->{data}->[0] = 
+        $rsp->{error}->[0] = 
          "Unable to run $spawnruncopy.";
         xCAT::MsgUtils->message("E", $rsp, $::CALLBACK, 1);
         next; # go to next node
@@ -743,8 +748,8 @@ sub sendnodeskeys
                   $rc=0;
                } else {
                  my $rsp = {};
-                 $rsp->{data}->[0] =  "copy.sh:$node has error,$msg";
-                 xCAT::MsgUtils->message("I", $rsp, $::CALLBACK);
+                 $rsp->{error}->[0] =  "copy.sh:$node has error,$msg";
+                 xCAT::MsgUtils->message("E", $rsp, $::CALLBACK);
                  $rc=1;
               }
             }
@@ -759,7 +764,7 @@ sub sendnodeskeys
 
 =head3    senddeviceskeys 
 	
-      Setup the ssh keys on the nodes 
+      Setup the ssh keys on the switches 
 
 =cut
 
@@ -768,9 +773,9 @@ sub sendnodeskeys
 sub senddeviceskeys 
 
 {
-   my ($class,$remoteshell,$remotecopy,$to_userid,$to_userpassword,$home,$ssh_setup_cmd,$nodes) = @_;
+   my ($class,$remoteshell,$remotecopy,$to_userid,$to_userpassword,$home,$ssh_setup_cmd,$nodes, $expecttimeout) = @_;
     my $sendkeys;
-    my $timeout  = 10;    # sets Expect default timeout, 0 accepts immediately
+    my $timeout  = $expecttimeout;    # sets Expect default timeout, 0 accepts immediately
     my $sendkeys_sent = 0;
     my $prompt1   = 'Are you sure you want to continue connecting (yes/no)?';
     my $prompt2   = 'ssword:';
@@ -829,7 +834,7 @@ sub senddeviceskeys
       unless ($sendkeys->spawn($spawnaddkey))
       {
         my $rsp = {};
-        $rsp->{data}->[0] = 
+        $rsp->{error}->[0] = 
          "Unable to run $spawnaddkey.";
         xCAT::MsgUtils->message("E", $rsp, $::CALLBACK, 1);
         next; # go to next node
@@ -877,8 +882,8 @@ sub senddeviceskeys
               $rc=0;
             } else {
               my $rsp = {};
-              $rsp->{data}->[0] =  "$node has error,$msg";
-              xCAT::MsgUtils->message("I", $rsp, $::CALLBACK);
+              $rsp->{error}->[0] =  "$node has error,$msg";
+              xCAT::MsgUtils->message("E", $rsp, $::CALLBACK);
               $rc=1;
               next; # go to next node
             }

perl-xCAT/xCAT/SINV.pm

@@ -60,9 +60,10 @@ sub usage
       " -p <template path> [-o output file ] [-t <template count>]\n";
     my $usagemsg4 = "      [-r remove templates] [-s <seednode>]\n";
     my $usagemsg5 = "      [-e exactmatch] [-i ignore] [-V verbose]\n";
+    my $usagemsg5A = "      [-l userid] [--devicetype type_of_device]\n";
     my $usagemsg6 = "      {-c <command>  | -f <command file>}";
     my $usagemsg .= $usagemsg1 .= $usagemsg1a .= $usagemsg3 .= $usagemsg4 .=
-      $usagemsg5 .= $usagemsg6;
+      $usagemsg5 .= $usagemsg5A .= $usagemsg6;
 ###  end usage mesage
 
     my $rsp = {};
@@ -110,6 +111,8 @@ sub parse_and_run_sinv
                     's|seed=s'      => \$options{'seed_node'},
                     'e|exactmatch'  => \$options{'exactmatch'},
                     'i|ignorefirst' => \$options{'ignorefirst'},
+                    'l|user=s'      => \$options{'user'},
+                    'devicetype|devicetype=s'    => \$options{'devicetype'}, 
                     'c|cmd=s'       => \$options{'sinv_cmd'},
                     'f|file=s'      => \$options{'sinv_cmd_file'},
                     'v|version'     => \$options{'version'},
@@ -198,14 +201,38 @@ sub parse_and_run_sinv
     # strip off the program and the noderange
     #
     my @nodelist  = ();
-    my @cmdparts  = split(' ', $cmd);
+    my @cmdparts  = ();
+    my $devicecommand =0;
+    if ($options{'devicetype'}) {  
+      # must split different because devices have commands with spaces
+      @cmdparts  = split(' ', $cmd,3);
+      $devicecommand =1;
+    } else {
+      @cmdparts  = split(' ', $cmd);
+    }
     my $cmdtype   = shift @cmdparts;
     my $noderange = shift @cmdparts;
     my @cmd       = ();
-    if ($noderange =~ /^-/)
+    if ($noderange =~ /^-/)  # if imageupdate not node
     {    # no noderange
         push @cmd, $noderange;    #  put flag back on command
     }
+    # root is sending the command
+    my @envs;
+    # if -l user id supplied
+    if ($options{'user'}) {
+       push @cmd,"-l";
+       push @cmd,$options{'user'};
+       push @envs,"DSH_TO_USERID=$options{'user'}";
+    }
+    # if device type supplied
+    if ($options{'devicetype'}) {
+       push @cmd,"--devicetype";
+       my $switchtype = $options{'devicetype'};
+       $switchtype =~ s/::/\//g;
+       push @cmd,$switchtype;
+    }
+ 
     foreach my $part (@cmdparts)
     {
 
@@ -471,13 +498,14 @@ sub parse_and_run_sinv
                    {
                     command => [$cmdtype],
                     node    => \@seed,
+                    env     => [@envs],
                     arg     => [@cmd]
                    },
                    \&$cmdoutput
                    );
 
         #  write the results to the tempfile after running through xdshcoll
-        $rc = &storeresults($callback);
+        $rc = &storeresults($callback,$devicecommand);
 
     }
     $processflg = "node";
@@ -500,6 +528,7 @@ sub parse_and_run_sinv
                {
                 command => [$cmdtype],
                 node    => \@nodelist,
+                env     => [@envs],
                 arg     => [@cmd]
                },
                \&$cmdoutput
@@ -507,7 +536,7 @@ sub parse_and_run_sinv
 
 
     #  write the results to the tempfile after running through xdshcoll
-    $rc = &storeresults($callback);
+    $rc = &storeresults($callback,$devicecommand);
 
     #  Build report and write to output file
     #  if file exist and has something in it
@@ -1424,12 +1453,11 @@ sub rinvoutput
 sub storeresults
 {
     my $callback = shift;
-
+    my $devicecommand= shift;
     # open file to write results of xdsh or rinv command
     my $newtempfile = $tempfile;
     $newtempfile .= "temp";
-    open(FILE, ">$newtempfile");
-    if ($? > 0)
+    unless (open(NEWTMPFILE, ">$newtempfile"))
     {
         my $rsp = {};
         $rsp->{data}->[0] = "Could not open $newtempfile\n";
@@ -1438,9 +1466,9 @@ sub storeresults
     }
     foreach my $line (@cmdresult)
     {
-        print FILE $line;
+        print NEWTMPFILE $line;
     }
-    close FILE;
+    close NEWTMPFILE;
     my $outputfile;
     if ($processflg eq "seednode")
     {    # cmd to seednode
@@ -1452,8 +1480,7 @@ sub storeresults
     }
 
     # open  file to put results of xdshcoll
-    open(FILE, ">$outputfile");
-    if ($? > 0)
+    unless (open(NEWOUTFILE, ">$outputfile"))
     {
         my $rsp = {};
         $rsp->{data}->[0] = "Could not open $outputfile\n";
@@ -1462,8 +1489,7 @@ sub storeresults
     }
     my $cmd = " $::XCATROOT/sbin/xdshcoll <$newtempfile |";
 
-    open(XCOLL, "$cmd");
-    if ($? > 0)
+    unless (open(XCOLL, "$cmd"))
     {
         my $rsp = {};
         $rsp->{data}->[0] = "Could not call xdshcoll \n";
@@ -1476,18 +1502,37 @@ sub storeresults
     while (<XCOLL>)
     {
         $line = $_;
-        print FILE $line
+        print NEWOUTFILE $line
 
     }
 
     close(XCOLL);
-    close FILE;
+    close NEWOUTFILE;
 
     system("/bin/rm  $newtempfile");
+    # is device command, we get false errors from the Switch, check for  
+    # blank error output lines and remove them.  If there is nothing left
+    # then there really were no errors
+    my @newerrresult=();
+    my $processerrors =1;
+    if ($devicecommand==1) {
+        foreach my $line (@errresult)
+        {
+          my @newline =  (split(/:/, $line));
+          if ($newline[1] !~ /^\s*$/) { # Not blank, then save it 
+            push @newerrresult,$line;  
+          } 
+          
+        } 
+        my $arraysize=@newerrresult;
+        if ($arraysize < 1) {
+            $processerrors =0;
+        }
+    }
 
     # capture errors
     #
-    if (@errresult)
+    if ((@errresult) && ($processerrors ==1))
     {    # if errors
         my $rsp = {};
         my $i   = 0;

perl-xCAT/xCAT/SLP.pm

@@ -81,7 +81,6 @@ sub dodiscover {
             }
         }
     }
-    # for print information
     my @printip;
     foreach my $iface (keys %{$interfaces}) {
         foreach my $sip (@{$interfaces->{$iface}->{ipv4addrs}}) {
@@ -91,7 +90,7 @@ sub dodiscover {
         }
     }
     my $printinfo = join(",", @printip);  
-    send_message($args{reqcallback}, 0, "Sending SLP request on interfaces: $printinfo ...") if ($args{reqcallback});
+    send_message($args{reqcallback}, 0, "Sending SLP request on interfaces: $printinfo ...") if ($args{reqcallback} and !$args{nomsg} );
 	foreach my $srvtype (@srvtypes) {
 		send_service_request_single(%args,ifacemap=>$interfaces,SrvType=>$srvtype);
 	}
@@ -99,12 +98,12 @@ sub dodiscover {
 	unless ($args{NoWait}) { #in nowait, caller owns the responsibility..
 		#by default, report all respondants within 3 seconds:
 		my $waitforsocket = IO::Select->new();
-        $waitforsocket->add($args{'socket'});
+		$waitforsocket->add($args{'socket'});
         my $retrytime = ($args{Retry}>0)?$args{Retry}+1:3;
         my $retryinterval = ($args{Retry}>0)?$args{Retry}:REQ_INTERVAL;  
         my $waittime = ($args{Time}>0)?$args{Time}:20; 
         my @peerarray;
-		my @pkgarray;
+        my @pkgarray;
 
         my $startinterval = time();
         my $interval;
@@ -117,87 +116,87 @@ sub dodiscover {
             # receive untill there is none
             ########################################
             while ($waitforsocket->can_read(0)) {
-                my $peer = $args{'socket'}->recv($slppacket,1400,0);
+                my $peer = $args{'socket'}->recv($slppacket,3000,0);
                 push @peerarray, $peer;
                 push @pkgarray, $slppacket;
             }
             #######################################
             # process the packets
             #######################################
-                for(my $j = 0; $j< scalar(@peerarray); $j++) {
-				    my $pkg = $peerarray[$j];
-					my $slpkg = $pkgarray[$j];
-		    		if ($ip6support) {
-                        ( $port,$flow,$ip6n,$scope) = Socket6::unpack_sockaddr_in6_all($pkg);
-		    			$peername = Socket6::inet_ntop(Socket6::AF_INET6(),$ip6n);
-		    		} else {
-                        ($port,$ip4n) = sockaddr_in($pkg);
-		    			$peername = inet_ntoa($ip4n);
-		    		}
-		    		if ($rethash{$peername}) {
-		    			next; #got a dupe, discard
-		    		}
-                    my $result = process_slp_packet(packet=>$slpkg,sockaddr=>$pkg,'socket'=>$args{'socket'});
-		    		if ($result) {
-		    			if ($peername =~ /\./) { #ipv4
-		    				$peername =~ s/::ffff://;
-		    			}
-		    			$result->{peername} = $peername;
-                        if ($gprlist) {
-                            $gprlist .= ','.$peername if(length($gprlist) < 1250);
-                        } else {
-                            $gprlist = $peername;
-                        }
-		    			$result->{scopeid} = $scope;
-                        $result->{sockaddr} = $pkg;
-		    			my $hashkey;
-		    			if ($peername =~ /fe80/) {
-		    				$peername .= '%'.$scope;
-		    			}
-                        $rspcount++;
-                        $rspcount1++;
-		    			$rethash{$peername} = $result;
-		    			if ($args{Callback}) {
-		    				$args{Callback}->($result);
-		    			}
-		    		}
-		    	}
+            for(my $j = 0; $j< scalar(@peerarray); $j++) {
+                my $pkg = $peerarray[$j];
+                my $slpkg = $pkgarray[$j];
+                if ($ip6support) {
+                    ( $port,$flow,$ip6n,$scope) = Socket6::unpack_sockaddr_in6_all($pkg);
+                    $peername = Socket6::inet_ntop(Socket6::AF_INET6(),$ip6n);
+                } else {
+                    ($port,$ip4n) = sockaddr_in($pkg);
+                    $peername = inet_ntoa($ip4n);
+                }
+                if ($rethash{$peername}) {
+                    next; #got a dupe, discard
+                }
+                my $result = process_slp_packet(packet=>$slpkg,sockaddr=>$pkg,'socket'=>$args{'socket'});
+                if ($result) {
+                    if ($peername =~ /\./) { #ipv4
+                        $peername =~ s/::ffff://;
+                    }
+                    $result->{peername} = $peername;
+                    if ($gprlist) {
+                        $gprlist .= ','.$peername if(length($gprlist) < 1250);
+                    } else {
+                        $gprlist = $peername;
+                    }
+                    $result->{scopeid} = $scope;
+                    $result->{sockaddr} = $pkg;
+                    my $hashkey;
+                    if ($peername =~ /fe80/) {
+                        $peername .= '%'.$scope;
+                    }
+                    $rspcount++;
+                    $rspcount1++;
+                    $rethash{$peername} = $result;
+
+                    if ($args{Callback}) {
+                        $args{Callback}->($result);
+                    }
+                }
+            }
             #############################
             # check if need to return
             #############################
-                @peerarray = ();
-				@pkgarray = ();
-                $interval = time() -  $startinterval;
-                if ($args{Time} and $args{Count}) {
-                    if ($rspcount >= $args{Count} or $interval >= $args{Time}) {
-                        send_message($args{reqcallback}, 0, "Received $rspcount1 responses.") if ($args{reqcallback});
-                        last;
-                    }
+            @peerarray = ();
+            @pkgarray = ();
+            $interval = time() -  $startinterval;
+            if ($args{Time} and $args{Count}) {
+                if ($rspcount >= $args{Count} or $interval >= $args{Time}) {
+                    send_message($args{reqcallback}, 0, "Received $rspcount1 responses.") if ($args{reqcallback}  and !$args{nomsg});
+                    last;
                 }
+            }
             if ($sendcount > $retrytime and $rspcount1 == 0) {
-                send_message($args{reqcallback}, 0, "Received $rspcount1 responses.") if ($args{reqcallback});
+                send_message($args{reqcallback}, 0, "Received $rspcount1 responses.") if ($args{reqcallback} and !$args{nomsg});
                 last;
             }
             #########################
             # send request again
             #########################
-                if ( $interval >  $retryinterval){#* (2**$sendcount))) { #double time
-                    $sendcount++;
-                    $startinterval = time();
-                send_message($args{reqcallback}, 0, "Received $rspcount1 responses.") if ($args{reqcallback});  
-                send_message($args{reqcallback}, 0, "Sending SLP request on interfaces: $printinfo ...") if ($args{reqcallback});
-		    	    foreach my $srvtype (@srvtypes) {
-		    	    	send_service_request_single(%args,ifacemap=>$interfaces,SrvType=>$srvtype);
-		    	    }
+            if ( $interval > $retryinterval){#* (2**$sendcount))) { #double time
+                $sendcount++;
+                $startinterval = time();
+                send_message($args{reqcallback}, 0, "Received $rspcount1 responses.") if ($args{reqcallback} and !$args{nomsg});  
+                send_message($args{reqcallback}, 0, "Sending SLP request on interfaces: $printinfo ...") if ($args{reqcallback} and !$args{nomsg});
+                foreach my $srvtype (@srvtypes) {
+                    send_service_request_single(%args,ifacemap=>$interfaces,SrvType=>$srvtype);
+                }
                 $rspcount1 = 0;
-				}	
-		    }
+            }    
+        }
   
-        } #end nowait
-
+    } #end nowait
     foreach my $entry (keys %rethash) {
         handle_new_slp_entity($rethash{$entry})
-        }
+    }
     if (xCAT::Utils->isAIX()) {
         foreach my $iface (keys %{$interfaces}) {
             foreach my $sip (@{$interfaces->{$iface}->{ipv4addrs}}) {
@@ -646,16 +645,11 @@ sub get_ipv6_neighbors {
         }
 }
 
-##########################################################################
-# Invokes the callback with the specified message
-##########################################################################
 sub send_message {
-
     my $callback = shift;
     my $ecode   = shift;
     my $msg     = shift;
     my %output;
-
     $output{errorcode} = $ecode;
     $output{data} = $msg;
     $callback->( \%output );

perl-xCAT/xCAT/SPD.pm

@@ -667,6 +667,9 @@ sub decode_spd {
         1066 => 8500,
         1333 => 10600,
         1600 => 12800,
+        1867 => 14900,
+        2133 => 17000,
+        2134 => 17000,
     );
 
     my %ddr3modcap = (
@@ -707,9 +710,20 @@ sub decode_spd {
     }
     $rethash->{product}->{name}=$memtypes{$spd[2]};
     if  ($spd[2] == 11) { #DDR3 spec applies
+        my $ftbdividend = $spd[9] >> 4;
+        my $ftbdivisor = $spd[9] & 0xf;
+        my $ftb = $ftbdividend/$ftbdivisor;
+        my $fineoffset = $spd[34];
+        if ($fineoffset & 0b10000000) {
+            #negative value, twos complement
+            $fineoffset = 0-(($fineoffset ^ 0xff) + 1);
+        }
+        $fineoffset = ($ftb * $fineoffset) * 10**-3;
         my $mtb = $spd[10]/$spd[11];
-        my $speed = $speedfromclock{int(2/($mtb*$spd[12]*10**-3))};
-        $rethash->{product}->{name}="PC3-".$speed;
+        my $clock = int(2/(($mtb*$spd[12]+$fineoffset)*10**-3));
+        my $speed = $speedfromclock{$clock};
+        unless ($speed) { $speed = "UNKNOWN"; }
+        $rethash->{product}->{name}="PC3-".$speed." ($clock MT/s)";
         if ($spd[8]&0b11000) {
             $rethash->{product}->{name} .= " ECC";
         }

perl-xCAT/xCAT/Scope.pm

@@ -1,6 +1,7 @@
 package xCAT::Scope;
 use xCAT::Utils;
 use xCAT::Table;
+use xCAT::ServiceNodeUtils qw(getSNList);
 sub get_broadcast_scope {
    my $req = shift;
    if ($req =~ /xCAT::Scope/) {
@@ -10,8 +11,8 @@ sub get_broadcast_scope {
    if ($req->{_xcatpreprocessed}->[0] == 1) { return [$req]; }
     #Exit if the packet has been preprocessed in its history
    my @requests = ({%$req}); #Start with a straight copy to reflect local instance
-   foreach (xCAT::Utils->getSNList()) {
-         if (xCAT::Utils->thishostisnot($_)) {
+   foreach (xCAT::ServiceNodeUtils->getSNList()) {
+         if (xCAT::NetworkUtils->thishostisnot($_)) {
             my $reqcopy = {%$req};
             $reqcopy->{'_xcatdest'} = $_;
             $reqcopy->{_xcatpreprocessed}->[0] = 1; 
@@ -24,7 +25,7 @@ sub get_broadcast_scope {
    #$sitetab->close;
    #if ($ent and $ent->{value}) {
    #   foreach (split /,/,$ent->{value}) {
-   #      if (xCAT::Utils->thishostisnot($_)) {
+   #      if (xCAT::NetworkUtils->thishostisnot($_)) {
    #         my $reqcopy = {%$req};
    #         $reqcopy->{'_xcatdest'} = $_;
    #         push @requests,$reqcopy;

perl-xCAT/xCAT/ServiceNodeUtils.pm

@@ -0,0 +1,854 @@
+#!/usr/bin/env perl
+# IBM(c) 2007 EPL license http://www.eclipse.org/legal/epl-v10.html
+package xCAT::ServiceNodeUtils;
+
+BEGIN
+{
+    $::XCATROOT = $ENV{'XCATROOT'} ? $ENV{'XCATROOT'} : '/opt/xcat';
+}
+
+# if AIX - make sure we include perl 5.8.2 in INC path.
+#       Needed to find perl dependencies shipped in deps tarball.
+if ($^O =~ /^aix/i) {
+        use lib "/usr/opt/perl5/lib/5.8.2/aix-thread-multi";
+        use lib "/usr/opt/perl5/lib/5.8.2";
+        use lib "/usr/opt/perl5/lib/site_perl/5.8.2/aix-thread-multi";
+        use lib "/usr/opt/perl5/lib/site_perl/5.8.2";
+}
+
+use lib "$::XCATROOT/lib/perl";
+use strict;
+#-----------------------------------------------------------------------------
+
+=head3 readSNInfo
+
+  Read resource, NFS server, Master node, OS an ARCH from the database
+  for the service node
+
+  Input: service nodename
+  Output: Masternode, OS and ARCH
+  Example:
+    my $retdata = xCAT::ServiceNodeUtils->readSNInfo;
+=cut
+#-----------------------------------------------------------------------------
+sub readSNInfo
+{
+    my ($class, $nodename) = @_;
+    my $rc = 0;
+    my $et;
+    my $masternode;
+    my $os;
+    my $arch;
+    $rc = xCAT::Utils->exportDBConfig();
+    if ($rc == 0)
+    {
+
+        if ($nodename)
+        {
+            $masternode = xCAT::TableUtils->GetMasterNodeName($nodename);
+            if (!($masternode))
+            {
+                xCAT::MsgUtils->message('S',
+                                   "Could not get Master for node $nodename\n");
+                return 1;
+            }
+
+            $et = xCAT::TableUtils->GetNodeOSARCH($nodename);
+            if ($et == 1)
+            {
+                xCAT::MsgUtils->message('S',
+                                  "Could not get OS/ARCH for node $nodename\n");
+                return 1;
+            }
+            if (!($et->{'os'} || $et->{'arch'}))
+            {
+                xCAT::MsgUtils->message('S',
+                                  "Could not get OS/ARCH for node $nodename\n");
+                return 1;
+            }
+        }
+        $et->{'master'} = $masternode;
+        return $et;
+    }
+    return $rc;
+}
+
+#-----------------------------------------------------------------------------
+
+=head3 isServiceReq
+
+
+  Checks the service node table in the database to see 
+  if input Service should be setup on the
+  input service node or Management Node (used by AAsn.pm)
+
+  Input:servicenodename,ipaddres(s) and hostnames of service node
+  Output:
+        hash of services to setup  for this service node
+    Globals:
+        $::RUNCMD_RC = 0; good
+        $::RUNCMD_RC = 1; error 
+    Error:
+        none
+    Example:
+      $servicestosetup=xCAT::ServiceNodeUtils->isServiceReq($servicenodename, @serviceip) { blah; }
+
+=cut
+
+#-----------------------------------------------------------------------------
+sub isServiceReq
+{
+    require xCAT::Table;
+    my ($class, $servicenodename, $serviceip) = @_;
+
+    # get list of all services from service node table ( actually all defined attributes)
+    # read the  schema
+    my $schema = xCAT::Table->getTableSchema("servicenode");
+    my @services; #  list of only the actual service attributes from the servicenode table
+    my @servicesattrs;  # building second copy for call to getAllNodeAttribs, which modifies the array
+    foreach my $c (@{$schema->{cols}}) {
+      if (($c ne "node") && ($c ne "comments") && ($c ne "disable")) {
+       push @servicesattrs,$c;
+       push @services,$c;
+      }
+    }
+
+    my @ips = @$serviceip;    # list of service node ip addresses and names
+    my $rc  = 0;
+
+    $rc = xCAT::Utils->exportDBConfig();    # export DB env
+    if ($rc != 0)
+    {
+        xCAT::MsgUtils->message('S', "Unable export DB environment.\n");
+        $::RUNCMD_RC = 1;
+        return;
+
+    }
+
+    # get handle to servicenode table
+    my $servicenodetab = xCAT::Table->new('servicenode');
+    unless ($servicenodetab)
+    {
+        xCAT::MsgUtils->message('S', "Unable to open servicenode table.\n");
+        $::RUNCMD_RC = 1;
+        return;    # do not setup anything
+    }
+
+    # Are we on the MN 
+    my $mname;
+    if (xCAT::Utils->isMN()) {
+      my @nodeinfo = xCAT::NetworkUtils->determinehostname;
+       $mname   = pop @nodeinfo;                    # get hostname
+    }
+
+    my $servicehash;
+    
+    # read all the nodes from the table, all the service attributes
+    my @snodelist= $servicenodetab->getAllNodeAttribs(\@servicesattrs); 
+    foreach my $service (@services) # check list of services
+    {
+
+        foreach $serviceip (@ips)    # check the table for this servicenode
+        {
+            foreach my $node (@snodelist)
+
+            {
+                if ($serviceip eq $node->{'node'})
+                {                    # match table entry
+                    if ($node->{$service})
+                    {                # returns service, only if set
+                        my $value = $node->{$service};
+                        $value =~ tr/a-z/A-Z/;    # convert to upper
+                             # value 1 or yes  then we setup the service
+                        if (($value eq "1") || ($value eq "YES"))
+                        {
+                            $servicehash->{$service} = "1";
+                        } else {
+                            $servicehash->{$service} = "0";
+                        }
+                    }
+                    last; 
+                }
+            }  
+        }
+
+    }
+    # if the ftpserver attribute is not defined in the service node table 
+    # and we are on
+    # the Linux management node, we need to look at site.vsftp
+    # if the tftpserver attribute is not defined, then we default it 1
+    if (($mname) && (xCAT::Utils->isLinux())) {
+      if (!exists($servicehash->{'ftpserver'})) { 
+        my @tmp = xCAT::TableUtils->get_site_attribute("vsftp");
+        if ($tmp[0] && ($tmp[0] !~ /0|NO|No|no|N|n/ )) {
+           $servicehash->{'ftpserver'} = 1;
+        }
+      }
+      if (!exists($servicehash->{'tftpserver'})) { 
+           $servicehash->{'tftpserver'} = 1;
+      }
+    }
+    $servicenodetab->close;
+
+    $::RUNCMD_RC = 0;
+    return $servicehash;
+
+}
+
+#-----------------------------------------------------------------------------
+
+=head3 getAllSN 
+ 
+    Returns an array of all service nodes from service node table 
+
+    Arguments:
+       ALL"  - will also return the management node in the array, if
+        if has been defined in the servicenode table 
+    Returns:
+		array of Service Nodes or empty array, if none
+    Globals:
+        none
+    Error:
+        1 - error
+    Example:
+         @SN=xCAT::ServiceNodeUtils->getAllSN
+         @allSN=xCAT::ServiceNodeUtils->getAllSN("ALL")
+    Comments:
+        none
+
+=cut
+
+#-----------------------------------------------------------------------------
+sub getAllSN
+{
+   
+    my ($class, $options) = @_;
+    require xCAT::Table;
+    # reads all nodes from the service node table
+    my @servicenodes;
+    my $servicenodetab = xCAT::Table->new('servicenode');
+    unless ($servicenodetab)    # no  servicenode table
+    {
+        xCAT::MsgUtils->message('I', "Unable to open servicenode table.\n");
+        $servicenodetab->close;
+        return @servicenodes;
+
+    }
+    my @nodes = $servicenodetab->getAllNodeAttribs(['tftpserver']);
+    foreach my $nodes (@nodes)
+    {
+          push @servicenodes, $nodes->{node};
+    }
+    # if did not input "ALL" and there is a MN, remove it
+    my @newservicenodes;
+    if ((!defined($options)) || ($options ne "ALL")) {   
+       my @mname = xCAT::Utils->noderangecontainsMn(@servicenodes);
+       if (@mname) { # if there is a MN
+        foreach my $node (@servicenodes) {
+          # check to see if node in MN list
+          if (!(grep(/^$node$/, @mname))) { # if node not in the MN array
+              push @newservicenodes, $node;
+          }
+        }
+        $servicenodetab->close;
+        return @newservicenodes;  # return without the MN in the array
+       }
+    }
+    $servicenodetab->close;
+    return @servicenodes;
+}
+
+#-----------------------------------------------------------------------------
+
+=head3 getSNandNodes 
+ 
+    Returns an hash-array of all service nodes and the nodes they service
+
+    Arguments:
+       none 
+#-----------------------------------------------------------------------------
+
+=head3 getSNandNodes 
+ 
+    Returns an hash-array of all service nodes and the nodes they service
+
+    Arguments:
+       none 
+    Returns:
+	 Service Nodes and the nodes they service or empty , if none
+    Globals:
+        none
+    Error:
+        1 - error
+    Example:
+        $sn=xCAT::ServiceNodeUtils->getSNandNodes()
+    Comments:
+        none
+
+=cut
+
+#-----------------------------------------------------------------------------
+sub getSNandNodes
+{
+
+    require xCAT::Table;
+    # read all the nodes from the nodelist table
+    #  call get_ServiceNode to find which Service Node
+    # the node belongs to.
+    my %sn;
+    my @nodes;
+    my $nodelisttab = xCAT::Table->new('nodelist');
+    my $recs        = $nodelisttab->getAllEntries();
+    foreach (@$recs)
+    {
+        push @nodes, $_->{node};
+    }
+    $nodelisttab->close;
+    my $sn = xCAT::ServiceNodeUtils->get_ServiceNode(\@nodes, "xcat", "MN");
+    return $sn;
+}
+
+#-----------------------------------------------------------------------------
+
+=head3 getSNList 
+ 
+	Reads the servicenode table. Will return all the enabled Service Nodes
+	that will setup the input Service ( e.g tftpserver,nameserver,etc)
+	If service is blank, then will return the list of all enabled Service
+	Nodes. 
+
+    Arguments:
+       Servicename ( xcat,tftpserver,dhcpserver,conserver,etc) 
+       If no servicename, returns all Servicenodes
+       "ALL" argument means you also want the MN returned. It can be in the 
+       servicenode list.  If no "ALL", take out the MN if it is there. 
+    Returns:
+	  Array of service node names 
+    Globals:
+        none
+    Error:
+        1 - error  
+    Example:
+         $sn= xCAT::ServiceNodeUtils->getSNList($servicename) { blah; }
+         $sn= xCAT::ServiceNodeUtils->getSNList($servicename,"ALL") { blah; }
+         $sn= xCAT::ServiceNodeUtils->getSNList() { blah; }
+         $sn= xCAT::ServiceNodeUtils->getSNList("","ALL") { blah; }
+    Comments:
+        none
+
+=cut
+
+#-----------------------------------------------------------------------------
+sub getSNList
+{
+    require xCAT::Table;
+    my ($class, $service,$options) = @_;
+
+    # reads all nodes from the service node table
+    my @servicenodes;
+    my $servicenodetab = xCAT::Table->new('servicenode', -create => 1);
+    unless ($servicenodetab)    # no  servicenode table
+    {
+        xCAT::MsgUtils->message('I', "Unable to open servicenode table.\n");
+        return ();
+    }
+    my @nodes = $servicenodetab->getAllNodeAttribs([$service]);
+    $servicenodetab->close;
+    foreach my $node (@nodes)
+    {
+        if  (! defined ($service) || ($service eq ""))     # want all the service nodes
+        {
+            push @servicenodes, $node->{node};
+        }
+        else
+        {                       # looking for a particular service
+            if ($node->{$service})
+            {                   # if null then do not add node
+                my $value = $node->{$service};
+                $value =~ tr/a-z/A-Z/;    # convert to upper
+                     # value 1 or yes or blank then we setup the service
+                if (($value == 1) || ($value eq "YES"))
+                {
+                    push @servicenodes, $node->{node};
+
+                }
+            }
+        }
+    }
+    # if did not input "ALL" and there is a MN, remove it
+    my @newservicenodes;
+    if ((!defined($options)) || ($options ne "ALL")) {   
+       my $mname = xCAT::Utils->noderangecontainsMn(@servicenodes);
+       if ($mname) { # if there is a MN
+        foreach my $nodes (@servicenodes) {
+           if ($mname ne ($nodes)){
+              push @newservicenodes, $nodes;
+           }
+        }
+        return @newservicenodes;  # return without the MN in the array
+       }
+    }
+
+    return @servicenodes;
+}
+
+
+#-----------------------------------------------------------------------------
+
+=head3 get_ServiceNode
+
+     Will get the Service node ( name or ipaddress) as known by the Management
+	 Node  or Node for the input nodename or ipadress of the node 
+         which can be a Service Node.
+         If the input node is a Service Node then it's Service node
+         is always the Management Node.
+
+     input: list of nodenames and/or node ipaddresses (array ref)
+			service name
+			"MN" or "Node"  determines if you want the Service node as known
+			 by the Management Node  or by the node.
+
+		recognized service names: xcat,tftpserver,
+		nfsserver,conserver,monserver
+
+        service "xcat" is used by command like xdsh that need to know the
+		service node that will process the command but are not tied to a
+		specific service like tftp
+
+		Todo:  Handle  dhcpserver and nameserver from the networks table
+
+	 output: A hash ref  of arrays, the key is the service node pointing to
+			 an array of nodes that are serviced by that service node
+
+     Globals:
+        $::ERROR_RC
+     Error:
+         $::ERROR_RC=0 no error $::ERROR_RC=1 error
+
+	 example: $sn =xCAT::ServiceNodeUtils->get_ServiceNode(\@nodes,$service,"MN");
+	  $sn =xCAT::ServiceNodeUtils->get_ServiceNode(\@nodes,$service,"Node");
+        Note: this rountine is important to hierarchical support in xCAT
+              and used in many places.  Any changes to the logic should be
+              reviewed by xCAT architecture
+=cut
+
+#-----------------------------------------------------------------------------
+sub get_ServiceNode
+{
+    require xCAT::Table;
+    my ($class, $node, $service, $request) = @_;
+    my @node_list = @$node;
+    my $cmd;
+    my %snhash;
+    my $nodehash;
+    my $sn;
+    my $nodehmtab;
+    my $noderestab;
+    my $snattribute;
+    my $oshash;
+    my $nodetab;
+    $::ERROR_RC = 0;
+
+    # determine if the request is for the service node as known by the MN
+    # or the node
+
+    if ($request eq "MN")
+    {
+        $snattribute = "servicenode";
+
+    }
+    else    # Node
+    {
+        $snattribute = "xcatmaster";
+    }
+    # get site.master this will be the default
+    my $master = xCAT::TableUtils->get_site_Master();  
+    $noderestab = xCAT::Table->new('noderes');
+
+    unless ($noderestab)    # no noderes table, use default site.master
+    {
+        xCAT::MsgUtils->message('I',
+                         "Unable to open noderes table. Using site->Master.\n");
+
+        if ($master)        # use site Master value
+        {
+				
+            foreach my $node (@node_list)
+            {               
+					push @{$snhash{$master}}, $node;
+            }
+        }
+        else
+        {
+            xCAT::MsgUtils->message('E', "Unable to read site Master value.\n");
+            $::ERROR_RC = 1;
+        }
+
+        return \%snhash;
+    }
+
+    if ($service eq "xcat")
+    {    # find all service nodes for the nodes in the list
+
+        $nodehash = $noderestab->getNodesAttribs(\@node_list, [$snattribute]);
+
+
+        foreach my $node (@node_list)
+        {
+            foreach my $rec (@{$nodehash->{$node}})
+            {
+                if ($rec and $rec->{$snattribute}) # use noderes.servicenode
+                {
+                    my $key = $rec->{$snattribute};
+                    push @{$snhash{$key}}, $node;
+                }
+                else  # use site.master
+                {    
+  		  push @{$snhash{$master}}, $node;
+                }
+            }
+        }
+
+        $noderestab->close;
+        return \%snhash;
+
+    }
+    else
+    {
+        if (
+            ($service eq "tftpserver")    # all from noderes table
+            || ($service eq "nfsserver") || ($service eq "monserver")
+          )
+        {
+            $nodehash =
+              $noderestab->getNodesAttribs(\@node_list,
+                                           [$service, $snattribute]);
+            foreach my $node (@node_list)
+            {
+                foreach my $rec (@{$nodehash->{$node}})
+                {
+                    if ($rec and $rec->{$service})
+                    {
+
+                        # see if both  MN and Node address in attribute
+                        my ($msattr, $nodeattr) = split ':', $rec->{$service};
+                        my $key = $msattr;
+                        if ($request eq "Node")
+                        {
+                            if ($nodeattr)    # override with Node, if it exists
+                            {
+                                $key = $nodeattr;
+                            }
+                        }
+                        push @{$snhash{$key}}, $node;
+                    }
+                    else
+                    {
+                        if ($rec and $rec->{$snattribute})    # if it exists
+                        {
+                            my $key = $rec->{$snattribute};
+                            push @{$snhash{$key}}, $node;
+                        }
+                        else
+                        {                                     # use site.master
+                            push @{$snhash{$master}}, $node;
+                        }
+                    }
+                }
+            }
+
+            $noderestab->close;
+            return \%snhash;
+
+        }
+        else
+        {
+            if ($service eq "conserver")
+            {
+
+                # read the nodehm table
+                $nodehmtab = xCAT::Table->new('nodehm');
+                unless ($nodehmtab)    # no nodehm table
+                {
+                    xCAT::MsgUtils->message('I',
+                                            "Unable to open nodehm table.\n");
+
+                    # use servicenode
+                    $nodehash =
+                      $noderestab->getNodesAttribs(\@node_list, [$snattribute]);
+                    foreach my $node (@node_list)
+                    {
+                        foreach my $rec (@{$nodehash->{$node}})
+                        {
+                            if ($rec and $rec->{$snattribute})
+                            {
+                                my $key = $rec->{$snattribute};
+                                push @{$snhash{$key}}, $node;
+                            }
+                            else
+                            {    # use site.master
+                                push @{$snhash{$master}}, $node;
+                            }
+                        }
+                    }
+                    $noderestab->close;
+                    return \%snhash;
+                }
+
+                # can read the nodehm table
+                $nodehash =
+                  $nodehmtab->getNodesAttribs(\@node_list, ['conserver']);
+                foreach my $node (@node_list)
+                {
+                    foreach my $rec (@{$nodehash->{$node}})
+                    {
+                        if ($rec and $rec->{'conserver'})
+                        {
+
+                            # see if both  MN and Node address in attribute
+                            my ($msattr, $nodeattr) = split ':',
+                              $rec->{'conserver'};
+                            my $key = $msattr;
+                            if ($request eq "Node")
+                            {
+                                if ($nodeattr
+                                  )    # override with Node, if it exists
+                                {
+                                    $key = $nodeattr;
+                                }
+                            }
+                            push @{$snhash{$key}}, $node;
+                        }
+                        else
+                        {              # use service node for this node
+                            $sn =
+                              $noderestab->getNodeAttribs($node,
+                                                          [$snattribute]);
+                            if ($sn and $sn->{$snattribute})
+                            {
+                                my $key = $sn->{$snattribute};
+                                push @{$snhash{$key}}, $node;
+                            }
+                            else
+                            {          # no service node use master
+                                push @{$snhash{$master}}, $node;
+                            }
+                        }
+                    }
+                }
+                $noderestab->close;
+                $nodehmtab->close;
+                return \%snhash;
+
+            }
+            else
+            {
+                xCAT::MsgUtils->message('E',
+                                        "Invalid service=$service input.\n");
+                $::ERROR_RC = 1;
+            }
+        }
+    }
+    return \%snhash;
+
+}
+
+
+#-----------------------------------------------------------------------------
+
+=head3 getSNformattedhash
+
+     Will call get_ServiceNode to  get the Service node ( name or ipaddress)
+	 as known by the Management
+	 Server or Node for the input nodename or ipadress of the node
+	 It will then format the output into a single servicenode key with values
+	 the list of nodes service by that service node.  This routine will 
+	 break up pools of service nodes into individual node in the hash unlike
+	 get_ServiceNode which leaves the pool as the key.
+
+	 input:  Same as get_ServiceNode to call get_ServiceNode
+			list of nodenames and/or node ipaddresses (array ref)
+			service name
+			"MN" or "Node"  determines if you want the Service node as known
+			 by the Management Node  or by the node.
+
+		recognized service names: xcat,tftpserver,
+		nfsserver,conserver,monserver
+
+        service "xcat" is used by command like xdsh that need to know the
+		service node that will process the command but are not tied to a
+		specific service like tftp
+
+
+	 output: A hash ref  of arrays, the key is a single service node 
+	          pointing to
+			 a list of nodes that are serviced by that service node
+	        'rra000-m'=>['blade01', 'testnode']
+	        'sn1'=>['blade01', 'testnode']
+	        'sn2'=>['blade01']
+	        'sn3'=>['testnode']
+
+     Globals:
+        $::ERROR_RC
+     Error:
+         $::ERROR_RC=0 no error $::ERROR_RC=1 error
+
+	 example: $sn =xCAT::ServiceNodeUtils->getSNformattedhash(\@nodes,$service,"MN", $type);
+	  $sn =xCAT::ServiceNodeUtils->getSNformattedhash(\@nodes,$service,"Node", "primary");
+
+=cut
+
+#-----------------------------------------------------------------------------
+sub getSNformattedhash
+{
+    my ($class, $node, $service, $request, $btype) = @_;
+    my @node_list = @$node;
+    my $cmd;
+    my %newsnhash;
+
+	my $type="";
+	if ($btype) {
+		$type=$btype;
+	}
+
+	# get the values of either the servicenode or xcatmaster attributes
+    my $sn = xCAT::ServiceNodeUtils->get_ServiceNode(\@node_list, $service, $request);
+
+    # get the keys which are the service nodes and break apart any pool lists
+    # format into individual service node keys pointing to node lists
+	if ($sn)
+	{
+        foreach my $snkey (keys %$sn)
+        {
+			# split the key if pool of service nodes
+			push my @tmpnodes, $sn->{$snkey};
+			my @nodes;
+			for my $i (0 .. $#tmpnodes) {
+				for my $j ( 0 .. $#{$tmpnodes[$i]}) {
+					my $check=$tmpnodes[$i][$j];
+					push @nodes,$check; 
+				}
+			}
+
+			# for SN backup we might only want the primary or backup
+			my @servicenodes;
+			my ($primary, $backup) = split /,/, $snkey;
+			if (($primary) && ($type eq "primary")) {
+				push @servicenodes, $primary;
+			} elsif (($backup) && ($type eq "backup")) {
+				push @servicenodes, $backup;
+			} else {
+				@servicenodes = split /,/, $snkey;
+			}
+
+			# now build new hash of individual service nodes
+			foreach my $newsnkey (@servicenodes) {
+				push @{$newsnhash{$newsnkey}}, @nodes;
+			}
+		}
+	}
+    return \%newsnhash;
+}
+
+#----------------------------------------------------------------------------
+
+=head3  getAIXSNinterfaces
+
+	Get a list of ip addresses for each service node in a list
+
+	Arguments:
+		list of service nodes
+	Returns:
+		hash of ips for each service node
+	Globals:
+		none
+	Error:
+		none
+	Example:
+		my $sni = xCAT::ServiceNodeUtils->getAIXSNinterfaces(\@servlist, $callback, $subreq);
+
+	Comments:
+
+=cut
+
+#-----------------------------------------------------------------------------
+sub getAIXSNinterfaces
+{
+    my ($class, $list, $callback, $sub_req) = @_;
+
+    my @snlist = @$list;
+    my %SNinterfaces;
+
+    # get all the possible IPs for the node I'm running on
+    my $ifcmd = "/usr/sbin/ifconfig -a | grep 'inet ' ";
+    foreach my $sn (@snlist)
+    {
+        my $SNIP;
+        my $out = xCAT::InstUtils->xcmd($callback, $sub_req, "xdsh", $sn, $ifcmd, 0);
+        if ($::RUNCMD_RC != 0)
+        {
+			my $rsp;
+			push @{$rsp->{data}}, "Could not get IP addresses from service node $sn.\n";
+			xCAT::MsgUtils->message("E", $rsp, $callback);
+            next;
+        }
+
+		my @result;
+		foreach my $line ( split(/\n/, $out)) {
+			$line =~ s/$sn:\s+//;
+			push(@result, $line);
+		}
+
+		foreach my $int (@result) {
+			my ($inet, $SNIP, $str) = split(" ", $int);
+			chomp $SNIP;
+			$SNIP =~ s/\/.*//; # ipv6 address 4000::99/64
+			$SNIP =~ s/\%.*//; # ipv6 address ::1%1/128
+            push(@{$SNinterfaces{$sn}}, $SNIP);
+        }
+    } # end foreach SN
+   	return \%SNinterfaces;
+}
+
+#-----------------------------------------------------------------------------
+
+=head3  
+ 
+    getSNandCPnodes - Take an array of nodes and returns 
+    an array of the service 
+    nodes and an array of the computenode . 
+
+    Arguments:
+       none 
+    Returns:
+		array of Service Nodes and/or array of compute nodesarray of compute nodes       empty array, if none
+    Globals:
+        none
+    Error:
+        1 - error
+    Example:
+         xCAT::ServiceNodeUtils->getSNandCPnodes(\@nodes,\@SN,\@CN);
+    Comments:
+        none
+
+=cut
+
+#-----------------------------------------------------------------------------
+sub getSNandCPnodes 
+{
+   
+    my ($class, $nodes,$sn,$cn) = @_; 
+    my @nodelist = @$nodes;
+    # get the list of all Service nodes
+    my @allSN=xCAT::ServiceNodeUtils->getAllSN;
+    foreach my $node (@nodelist) {
+      if (grep(/^$node$/, @allSN)) { # it is a SN
+         push (@$sn,$node);
+      } else {  # a CN
+         push (@$cn,$node);
+      }
+    }
+
+    return ; 
+}
+1;

perl-xCAT/xCAT/Table.pm

@@ -12,7 +12,9 @@
 #   -cache to persist so long as '_build_cache' calls concurrently stack (for NodeRange interpretation mainly) (done)
 #   -Allow plugins to define a staleness threshold for getNodesAttribs freshness (complicated enough to postpone...)
 #    so that actions requested by disparate managed nodes may aggregate in SQL calls
-# reference count managed cache lifetime, if clear_cache is called, and build_chache has been called twice, decrement the counter
+# cache lifetime is no longer determined strictly by function duration
+# now it can live up to 5 seconds.  However, most calls will ignore the cache unless using a special option.
+# Hmm, potential issue, getNodesAttribs might return up to 5 second old data even if caller expects brand new data
 # if called again, decrement again and clear cache
 # for getNodesAttribs, we can put a parameter to request allowable staleneess
 # if the cachestamp is too old, build_cache is called
@@ -34,7 +36,7 @@
 package xCAT::Table;
 use xCAT::MsgUtils;
 use Sys::Syslog;
-use Storable qw/freeze thaw/;
+use Storable qw/freeze thaw store_fd fd_retrieve/;
 use IO::Socket;
 #use Data::Dumper;
 use POSIX qw/WNOHANG/;
@@ -49,10 +51,7 @@ BEGIN
 # if AIX - make sure we include perl 5.8.2 in INC path.
 #       Needed to find perl dependencies shipped in deps tarball.
 if ($^O =~ /^aix/i) {
-        use lib "/usr/opt/perl5/lib/5.8.2/aix-thread-multi";
-        use lib "/usr/opt/perl5/lib/5.8.2";
-        use lib "/usr/opt/perl5/lib/site_perl/5.8.2/aix-thread-multi";
-        use lib "/usr/opt/perl5/lib/site_perl/5.8.2";
+	unshift(@INC, qw(/usr/opt/perl5/lib/5.8.2/aix-thread-multi /usr/opt/perl5/lib/5.8.2 /usr/opt/perl5/lib/site_perl/5.8.2/aix-thread-multi /usr/opt/perl5/lib/site_perl/5.8.2));
 }
 
 use lib "$::XCATROOT/lib/perl";
@@ -71,7 +70,7 @@ require xCAT::NotifHandler;
 
 my $dbworkerpid; #The process id of the database worker
 my $dbworkersocket;
-my $dbsockpath = "/tmp/xcat/dbworker.sock.".$$;
+my $dbsockpath = "/var/run/xcat/dbworker.sock.".$$;
 my $exitdbthread;
 my $dbobjsforhandle;
 my $intendedpid;
@@ -93,8 +92,6 @@ sub dbc_call {
 sub dbc_submit {
     my $request = shift;
     $request->{'wantarray'} = wantarray();
-    my $data = freeze($request);
-    $data.= "\nENDOFFREEZEQFVyo4Cj6Q0v\n";
     my $clisock;
     my $tries=300;
     while($tries and !($clisock = IO::Socket::UNIX->new(Peer => $dbsockpath, Type => SOCK_STREAM, Timeout => 120) ) ) {
@@ -106,22 +103,20 @@ sub dbc_submit {
         use Carp qw/cluck/;
         cluck();
     }
-    print $clisock $data;
-    $data="";
+    store_fd($request,$clisock);
+    #print $clisock $data;
+    my $data="";
     my $lastline="";
-    while (read($clisock,$lastline,32768)) { #$lastline ne "ENDOFFREEZEQFVyo4Cj6Q0j\n" and $lastline ne "*XCATBUGDETECTED*76e9b54341\n") { #index($lastline,"ENDOFFREEZEQFVyo4Cj6Q0j") < 0) {
-#        $lastline = <$clisock>;
-	    $data .= $lastline;
-    }
+    my $retdata = fd_retrieve($clisock);
     close($clisock);
-    if ($lastline =~  m/\*XCATBUGDETECTED\*76e9b54341\n\z/) { #if it was an error
+    if (ref $retdata eq "SCALAR") { #bug detected
         #in the midst of the operation, die like it used to die
         my $err;
-        $data =~ /\*XCATBUGDETECTED\*:(.*):\*XCATBUGDETECTED\*/s;
+        $$retdata =~ /\*XCATBUGDETECTED\*:(.*):\*XCATBUGDETECTED\*/s;
         $err = $1;
         die $err;
     }
-    my @returndata = @{thaw($data)};
+    my @returndata = @{$retdata};
     if (wantarray) {
         return @returndata;
     } else {
@@ -164,7 +159,7 @@ sub init_dbworker {
         #This process is the database worker, it's job is to manage database queries to reduce required handles and to permit cross-process caching
         $0 = "xcatd: DB Access";
         use File::Path;
-        mkpath('/tmp/xcat/');
+        mkpath('/var/run/xcat/');
         use IO::Socket;
         $SIG{TERM} = $SIG{INT} = sub {
             $exitdbthread=1;
@@ -202,8 +197,7 @@ sub init_dbworker {
                             xCAT::MsgUtils->message("S","xcatd: possible BUG encountered by xCAT DB worker ".$err);
                             if ($currcon) {
                                 eval { #avoid hang by allowin client to die too
-                                    print $currcon "*XCATBUGDETECTED*:$err:*XCATBUGDETECTED*\n";
-                                    print $currcon "*XCATBUGDETECTED*76e9b54341\n";
+                                    store_fd("*XCATBUGDETECTED*:$err:*XCATBUGDETECTED*\n",$currcon);
         			    $clientset->remove($currcon);
 			            close($currcon);
                                 };
@@ -214,9 +208,10 @@ sub init_dbworker {
             };
             if ($@) { #this should never be reached, but leave it intact just in case
                 my $err=$@;
-                xCAT::MsgUtils->message("S","xcatd: possible BUG encountered by xCAT DB worker ".$err);
+                eval { xCAT::MsgUtils->message("S","xcatd: possible BUG encountered by xCAT DB worker ".$err); };
             }
             if ($intendedpid != $$) { #avoid redundant fork
+                eval { xCAT::MsgUtils->message("S","Pid $$ shutting itself down because only pid $intendedpid is permitted to be in this area"); };
                 exit(0);
             }
         }
@@ -230,13 +225,14 @@ sub handle_dbc_conn {
     my $client = shift;
     my $clientset = shift;
     my $data;
-    if ($data = <$client>) {
-	my $lastline;
-        while ($lastline ne "ENDOFFREEZEQFVyo4Cj6Q0v\n") { #$data !~ /ENDOFFREEZEQFVyo4Cj6Q0v/) {
-	    $lastline = <$client>;
-            $data .= $lastline;
-        }
-        my $request = thaw($data);
+    my $request;
+    eval { 
+	$request = fd_retrieve($client);
+    };
+    if ($@ and $@ =~ /^Magic number checking on storable file/) { #this most likely means we ran over the end of available input
+        $clientset->remove($client);
+        close($client);
+    } elsif ($request) {
         my $response;
         my @returndata;
         if ($request->{'wantarray'}) {
@@ -244,12 +240,7 @@ sub handle_dbc_conn {
         } else {
             @returndata = (scalar(handle_dbc_request($request)));
         }
-        $response = freeze(\@returndata);
-    #    $response .= "\nENDOFFREEZEQFVyo4Cj6Q0j\n";
-        print $client $response;
-        $clientset->remove($client);
-        close($client);
-    } else { #Connection terminated, clean up
+	store_fd(\@returndata,$client);
         $clientset->remove($client);
         close($client);
     }
@@ -332,6 +323,8 @@ sub handle_dbc_request {
          return $opentables{$tablename}->{$autocommit}->getAllNodeAttribs(@args);
     } elsif ($functionname eq 'getAllEntries') {
          return $opentables{$tablename}->{$autocommit}->getAllEntries(@args);
+    } elsif ($functionname eq 'getMAXMINEntries') {
+         return $opentables{$tablename}->{$autocommit}->getMAXMINEntries(@args);
     } elsif ($functionname eq 'writeAllEntries') {
          return $opentables{$tablename}->{$autocommit}->writeAllEntries(@args);
     } elsif ($functionname eq 'getAllAttribsWhere') {
@@ -360,8 +353,6 @@ sub handle_dbc_request {
          return $opentables{$tablename}->{$autocommit}->_set_use_cache(@args);
     } elsif ($functionname eq '_build_cache') {
          return $opentables{$tablename}->{$autocommit}->_build_cache(@args);
-    } elsif ($functionname eq '_clear_cache') {
-         return $opentables{$tablename}->{$autocommit}->_clear_cache(@args);
     } else {
         die "undefined function $functionname";
     }
@@ -1614,7 +1605,7 @@ sub setAttribs
            # delimit the columns of the table
 	   my $delimitedcol = &delimitcol($col);	
            $cols = $cols . $delimitedcol . " = ?,";
-           push @bind, (($$elems{$col} =~ /NULL/) ? undef: $$elems{$col});
+           push @bind, (($$elems{$col} eq "NULL") ? undef: $$elems{$col});
         }
         chop($cols);
         my $cmd ;
@@ -1797,7 +1788,7 @@ sub setAttribsWhere
       # delimit the columns of the table
       my $delimitedcol = &delimitcol($col);	
       $cols = $cols . $delimitedcol . " = ?,";
-      push @bind, (($$elems{$col} =~ /NULL/) ? undef: $$elems{$col});
+      push @bind, (($$elems{$col} eq "NULL") ? undef: $$elems{$col});
     }
     chop($cols);
     my $cmd = "UPDATE " . $self->{tabname} . " set $cols where " . $where_clause;
@@ -2093,10 +2084,8 @@ sub getNodesAttribs {
         my @nodeentries=$self->getNodeAttribs($_,\@realattribs,%options);
         $rethash->{$_} = \@nodeentries; #$self->getNodeAttribs($_,\@attribs);
     }
-    $self->_clear_cache;
     $self->{_use_cache} = 0;
-    if ($self->{tabname} ne 'nodelist') { #avoid calling clear_cache on nodelist twice
-	    $self->{nodelist}->_clear_cache;
+    if ($self->{tabname} ne 'nodelist') { 
 	    $self->{nodelist}->{_use_cache} = 0;
     }
     return $rethash;
@@ -2123,27 +2112,6 @@ sub _refresh_cache { #if cache exists, force a rebuild, leaving reference counts
     return;
 }
 
-sub _clear_cache { #PRIVATE FUNCTION TO EXPIRE CACHED DATA EXPLICITLY
-    #This is no longer sufficient to do at destructor time, as Table objects actually live an indeterminite amount of time now
-    #TODO: only clear cache if ref count mentioned in build_cache is 1, otherwise decrement ref count
-    my $self = shift;
-    if ($dbworkerpid) {
-        return dbc_call($self,'_clear_cache',@_);
-    }
-    if ($self->{_cache_ref} > 1) { #don't clear the cache if there are still live references
-        $self->{_cache_ref} -= 1;
-        return;
-    } elsif ($self->{_cache_ref} == 1) { #If it is 1, decrement to zero and carry on
-        return;
-        #$self->{_cache_ref} = 0;
-    }
-    #it shouldn't have been zero, but whether it was 0 or 1, ensure that the cache is gone
-    $self->{_use_cache}=0; # Signal slow operation to any in-flight operations that may fail with empty cache
-    $self->{_cached_attriblist} = undef;
-    undef $self->{_tablecache};
-    undef $self->{_nodecache};
-}
-
 sub _build_cache { #PRIVATE FUNCTION, PLEASE DON'T CALL DIRECTLY
 #TODO: increment a reference counter type thing to preserve current cache
 #Also, if ref count is 1 or greater, and the current cache is less than 3 seconds old, reuse the cache?
@@ -2159,10 +2127,6 @@ sub _build_cache { #PRIVATE FUNCTION, PLEASE DON'T CALL DIRECTLY
     }
     
     if (not $refresh and $self->{_cache_ref}) { #we have active cache reference, increment counter and return
-        #TODO: ensure that the cache isn't somehow still ludirously old
-	unless ($copts{noincrementref}) {
-           $self->{_cache_ref} += 1;
-        }
 	my $currattr;
 	my $cachesufficient=1;
 	foreach $currattr (@$attriblist) { #if any of the requested attributes are not cached, we must rebuild
@@ -2174,6 +2138,7 @@ sub _build_cache { #PRIVATE FUNCTION, PLEASE DON'T CALL DIRECTLY
         if ($self->{_cachestamp} < (time()-5)) { #NEVER use a cache older than 5 seconds
 		$cachesufficient=0;
 	}
+        
 	if ($cachesufficient) { return; }
 	#cache is insufficient, now we must do the converse of above
 	#must add any currently cached columns to new list if not requested
@@ -2308,16 +2273,16 @@ sub getNodeAttribs
             #skip undefined values, save time
             next;
         }
-
         if ($datum->{$attrib} =~ /^\/[^\/]*\/[^\/]*\/$/)
         {
             my $exp = substr($datum->{$attrib}, 1);
             chop $exp;
             my @parts = split('/', $exp, 2);
-            $node =~ s/$parts[0]/$parts[1]/;
-            $datum->{$attrib} = $node;
+	         my $retval = $node;
+            $retval =~ s/$parts[0]/$parts[1]/;
+            $datum->{$attrib} = $retval;
         }
-        elsif ($datum->{$attrib} =~ /^\|.*\|.*\|$/)
+        elsif ($datum->{$attrib} =~ /^\|.*\|$/)
         {
 
             #Perform arithmetic and only arithmetic operations in bracketed issues on the right.
@@ -2327,6 +2292,14 @@ sub getNodeAttribs
             my $exp = substr($datum->{$attrib}, 1);
             chop $exp;
             my @parts = split('\|', $exp, 2);
+            my $arraySize = @parts;
+            if ($arraySize < 2) { # easy regx, generate lhs from node
+              my $lhs;
+              my @numbers = $node =~ m/[\D0]*(\d+)/g;
+              $lhs = '[\D0]*(\d+)' x scalar(@numbers);
+              $lhs .= '.*$';
+              unshift(@parts,$lhs);
+            }
             my $curr;
             my $next;
             my $prev;
@@ -2378,71 +2351,6 @@ sub getNodeAttribs
 
 #--------------------------------------------------------------------------
 
-=head3 getNodeSpecAttribs
-    Description: Retrieves the requested attributes which matching the specified options for a node
-    Arguments:
-        Noderange
-        The specified options
-        List of attributes 
-    Return:
-        Attribute hash 
-    Example:
-        my $tab = xCAT::Table->new('ppcdirect');
-        my $ent = $tab->getNodeSpecAttribs($node, {username=>'HMC'}, qw/password/); 
-    Comments:
-        The keys of the specified options can be given in the list of attributes or not, 
-        this routine will deal with them.
-=cut
-
-#--------------------------------------------------------------------------
-
-#sub getNodeSpecAttribs {
-#    my $self = shift;
-#    my $node = shift;
-#    my %options = ();
-#    my @attribs = ();
-#    my @keys = ();
-#    if (ref $_[0] eq 'HASH') {
-#        %options = %{shift()};
-#        @attribs = @_;
-#        foreach my $key (keys %options) {
-#            if (!grep(/^$key$/, @attribs)) {
-#                push @attribs, $key;
-#            }
-#        }
-#    } else {
-#        @attribs = @_;
-#    }
-#    if ((keys (%options)) == 0) {
-#        my $ent = $self->getNodeAttribs($node, \@attribs);
-#        return $ent; 
-#    } else {
-#        my $nodekey = "node";
-#        if (defined $xCAT::Schema::tabspec{$self->{tabname}}->{nodecol}) {
-#            $nodekey = $xCAT::Schema::tabspec{$self->{tabname}}->{nodecol};
-#        }
-#        $options{$nodekey} = $node;
-#        my $ent = $self->getAttribs(\%options, \@attribs);
-#        if ($ent) {
-#            return $ent;
-#        }
-#        my ($nodeghash) = $self->{nodelist}->getAttribs({node=>$node}, "groups");
-#        unless(defined($nodeghash) && defined($nodeghash->{groups})) {
-#            return undef;
-#        }
-#        my @nodegroups = split(/,/, $nodeghash->{groups});
-#        foreach my $group (@nodegroups) {
-#            $options{$nodekey} = $group;
-#            my $g_ret = $self->getAttribs(\%options, \@attribs);
-#            if ($g_ret) {
-#                return $g_ret;
-#            }
-#        }
-#    }
-#    return undef;
-#}
-#--------------------------------------------------------------------------
-
 =head3 getNodeAttribs_nosub
 
     Description:
@@ -2928,7 +2836,9 @@ sub getAllAttribsWhere
 
     Arguments:
                  Table handle
-				 Attribute list
+	         Attribute list
+                 optional hash return style
+                 ( changes the return hash structure format) 
     Returns:
                  Array of attribute values
     Globals:
@@ -2936,7 +2846,8 @@ sub getAllAttribsWhere
     Error:
 
     Example:
-         my @entries = $self->{switchtab}->getAllNodeAttribs(['port','switch']);
+       my @entries = $self->{switchtab}->getAllNodeAttribs(['port','switch']);
+       my @entries = $self->{switchtab}->getAllNodeAttribs(['port','switch'],1);
     Comments:
         none
 
@@ -2975,8 +2886,6 @@ sub getAllNodeAttribs
     unless ($options{prefetchcache}) {
     $self->{_use_cache} = 0;
     $self->{nodelist}->{_use_cache}=0;
-    $self->_clear_cache();
-    $self->{nodelist}->_clear_cache();
     }
     $self->_build_cache($attribq);
     $self->{nodelist}->_build_cache(['node','groups']);
@@ -2995,10 +2904,14 @@ sub getAllNodeAttribs
 		$self->{nrcache}->{$data->{$nodekey}}->{tstamp} = time();
 	    }
             @nodes = @{$self->{nrcache}->{$data->{$nodekey}}->{value}};    #expand node entry, to make groups expand
-            unless (@nodes) { #in the event of an entry not in nodelist, use entry value verbatim
-                @nodes = ($data->{$nodekey});
-            }
+
+            #If node not in nodelist do not add to the hash (SF 3580)
+            #unless (@nodes) { #in the event of an entry not in nodelist, use entry value verbatim
+            #    @nodes = ($data->{$nodekey});
+            #}  end SF 3580
+
             #my $localhash = $self->getNodesAttribs(\@nodes,$attribq); #NOTE:  This is stupid, rebuilds the cache for every entry, FIXME
+
             foreach (@nodes)
             {
                 if ($donenodes{$_}) { next; }
@@ -3030,11 +2943,8 @@ sub getAllNodeAttribs
             }
         }
     }
-    $self->_clear_cache();
-    $self->{nodelist}->_clear_cache();
     $self->{_use_cache} = 0;
     $self->{nodelist}->{_use_cache} = 0;
-    xCAT::NodeRange::retain_cache(0);
     $query->finish();
     if ($hashretstyle) {
         return $rethash;
@@ -3150,11 +3060,18 @@ sub getAllAttribs
     Error:
 
     Example:
-	my $table=xCAT::Table->new("notification", -create => 1,-autocommit => 0);
-	my %key_col = (filename=>$fname);
-	$table->delEntries(\%key_col);
-	$table->commit;
+	my $table=xCAT::Table->new("nodelist");
+        my %keyhash;
+        $keyhash{node} = "node1";
+        $keyhash{groups} = "compute1";
+	$table->delEntries(\%keyhash);
+         $table->commit;
+        Build delete statement and'ing the elements of the hash
+        DELETE FROM nodelist WHERE ("groups" = "compute1" AND "node" = "node1")
 
+        If called with no attributes, it will delete all entries in the table. 
+          $table->delEntries();
+          $table->commit;
     Comments:
         none
 
@@ -3291,7 +3208,7 @@ sub getAttribs
 {
 
     #Takes two arguments:
-    #-Node name (will be compared against the 'Node' column)
+    #-Key(s) name (will be compared against the table key(s) value)
     #-List reference of attributes for which calling code wants at least one of defined
     # (recurse argument intended only for internal use.)
     # Returns a hash reference with requested attributes defined.
@@ -3921,7 +3838,7 @@ sub writeAllEntries
     # open the file for write
     unless (open($fh," > $filename")) {
      my $msg="Unable to open $filename for write \n.";
-       `logger -t xcat $msg`;
+       `logger -p local4.err  -t xcat $msg`;
         return 1;  
     }
     my $query;
@@ -4006,7 +3923,7 @@ sub writeAllAttribsWhere
     # open the file for write
     unless (open($fh," > $filename")) {
      my $msg="Unable to open $filename for write \n.";
-       `logger -t xcat $msg`;
+       `logger -p local4.err -t xcat $msg`;
         return 1;  
     }
     my $header;
@@ -4073,5 +3990,97 @@ sub output_table {
    print $fh "\n";
    return 0;
 }
+#--------------------------------------------------------------------------
+
+=head3 getMAXMINEntries
+
+    Description: Select the rows in  the Table which has the MAX and the row with the 
+                 Min value for the input attribute.
+                 Currently only the auditlog and evenlog are setup to have such an attribute (recid). 
+
+    Arguments:
+           Table handle
+           attribute name ( e.g. recid)
+
+    Returns:
+        HASH 
+            max=>  max value
+            min=>  min value 
+    Globals:
+
+    Error:
+
+    Example:
+
+	 my $tabh = xCAT::Table->new($table);
+         my $recs=$tabh->getMAXMINEntries("recid"); 
+
+    Comments:
+        none
+
+=cut
+
+#--------------------------------------------------------------------------------
+sub getMAXMINEntries
+{
+    my $self = shift;
+    if ($dbworkerpid) {
+        return dbc_call($self,'getMAXMINEntries',@_);
+    }
+    my $attr = shift;
+    my $rets;
+    my $query;
+    my $xcatcfg=get_xcatcfg();
+    # delimit the disable column based on the DB 
+    my $disable= &delimitcol("disable");	
+    my $qstring;
+    if ($xcatcfg =~ /^DB2:/) {  # for DB2 
+       $qstring = "SELECT MAX (\"$attr\") FROM " . $self->{tabname} . " WHERE " . $disable . " is NULL or " .  $disable . " in ('0','no','NO','No','nO')";
+    } else {
+       $qstring = "SELECT MAX($attr) FROM " . $self->{tabname} . " WHERE " . $disable . " is NULL or " .  $disable . " in ('0','no','NO','No','nO')";
+    }
+    $query = $self->{dbh}->prepare($qstring);
+
+    $query->execute();
+    while (my $data = $query->fetchrow_hashref())
+    {
+        foreach (keys %$data)
+        {
+            if ($data->{$_} =~ /^$/)
+            {
+                $rets->{"max"} = undef;
+            } else {
+                $rets->{"max"} = $data->{$_};
+
+            }
+            last;   # better only be one value for max
+            
+        }
+    }
+    $query->finish();
+    if ($xcatcfg =~ /^DB2:/) {  # for DB2 
+       $qstring = "SELECT MIN (\"$attr\") FROM " . $self->{tabname} . " WHERE " . $disable . " is NULL or " .  $disable . " in ('0','no','NO','No','nO')";
+    } else {
+    $qstring = "SELECT MIN($attr) FROM " . $self->{tabname} . " WHERE " . $disable . " is NULL or " .  $disable . " in ('0','no','NO','No','nO')";
+    }
+    $query = $self->{dbh}->prepare($qstring);
+
+    $query->execute();
+    while (my $data = $query->fetchrow_hashref())
+    {
+        foreach (keys %$data)
+        {
+            if ($data->{$_} =~ /^$/)
+            {
+                $rets->{"min"} = undef;
+            } else {
+                $rets->{"min"} = $data->{$_};
+            }
+            last;   # better be only one value  for min
+        }
+    }
+    return $rets;
+}
+
 1;
 

perl-xCAT/xCAT/Usage.pm

@@ -36,11 +36,13 @@ my %usage = (
      LPAR(using Direct FSP Management) specific:
        rpower <noderange> [on|off|reset|stat|state|boot|of|sms]
      Blade(using Direct FSP Management) specific:
-       rpower <noderange> [on|off|cycle|state]
+       rpower <noderange> [on|onstandby|off|cycle|state|sms]
      Blade(using AMM) specific:
        rpower <noderange> [cycle|softoff] [-V|--verbose]
      zVM specific:
        rpower noderange [on|off|reset|stat|softoff]
+     MIC specific:
+       rpower noderange [stat|state|on|off|reset|boot]
 ",
     "rbeacon" => 
 "Usage: rbeacon <noderange> [on|off|stat] [-V|--verbose]
@@ -58,9 +60,11 @@ my %usage = (
   Blade specific:
       rvitals noderange {temp|wattage|fanspeed|leds|summary|all}
   BMC specific:
-      rvitals noderange {temp|voltage|wattage|fanspeed|power|leds|lcds|summary|all}",
+      rvitals noderange {temp|voltage|wattage|fanspeed|power|leds|lcds|summary|all}
+  MIC specific:
+      rvitals noderange {thermal|all}",
     "reventlog" => 
-"Usage: reventlog <noderange> [all|clear|<number of entries to retrieve>] [-V|--verbose]
+"Usage: reventlog <noderange> [all [-s]|clear|<number of entries to retrieve> [-s]] [-V|--verbose]
        reventlog [-h|--help|-v|--version]",
     "rinv" => 
 "Usage: 
@@ -68,29 +72,31 @@ my %usage = (
        rinv <noderange> [all|model|serial] [-V|--verbose]
        rinv [-h|--help|-v|--version]
     BMC specific:
-       rinv <noderange> [vpd|mprom|deviceid|uuid|guid]
+       rinv <noderange> [mprom|deviceid|uuid|guid|vpd [-t]|all [-t]]
     MPA specific:
-       rinv <noderange> [firm|bios|diag|mprom|sprom|mparom|mac|mtm]
+       rinv <noderange> [firm|bios|diag|mprom|sprom|mparom|mac|mtm [-t]] 
     PPC specific(with HMC):
-       rinv <noderange> [bus|config|serial|model|firm|all]
+       rinv <noderange> [all|bus|config|serial|model|firm [-t]]
     PPC specific(using Direct FSP Management):
        rinv <noderange> [firm]
        rinv <noderange> [deconfig [-x]]
     Blade specific:
-       rinv <noderange> [mtm|serial|mac|bios|diag|mprom|mparom|firm|all]
+       rinv <noderange> [all|serial|mac|bios|diag|mprom|mparom|firm|mtm [-t]]
     IBM Flex System Compute Node specific:
        rinv <noderange> [firm]
     VMware specific:
        rinv <noderange>
     zVM specific:
-       rinv noderange [all|config]",
+       rinv noderange [all|config]
+    MIC specific:
+       rinv noderange [system|ver|board|core|gddr|all]",
     "rsetboot" => 
 "Usage: rsetboot <noderange> [net|hd|cd|floppy|def|stat] [-V|--verbose]
        rsetboot [-h|--help|-v|--version]",
     "rbootseq" => 
 "Usage: 
        Common:
-           rbootseq [-h|--help|-v|--version]
+           rbootseq [-h|--help|-v|--version|-V|--verbose]
        Blade specific:
            rbootseq <noderange> [hd0|hd1|hd2|hd3|net|iscsi|usbflash|floppy|none],...
        PPC (using Direct FSP Management) specific:
@@ -101,7 +107,7 @@ my %usage = (
     "rspconfig" => 
 "Usage: 
    Common:
-       rspconfig [-h|--help|-v|--version]
+       rspconfig [-h|--help|-v|--version|-V|--verbose]
    BMC/MPA Common:
        rspconfig <noderange> [snmpdest|alert|community] [-V|--verbose]
        rspconfig <noderange> [snmpdest=<dest ip address>|alert=<on|off|en|dis|enable|disable>|community=<string>]
@@ -115,7 +121,7 @@ my %usage = (
        rspconfig <noderange>  [sshcfg|snmpcfg|pd1|pd2|network|swnet|ntp|textid|frame]
        rspconfig <singlenode> [textid=name]
        rspconfig <singlenode> [frame=number]
-       rspconfig <singlenode> [USERID=passwd]
+       rspconfig <singlenode> [USERID=passwd] [updateBMC=<y|n>]
        rspconfig <noderange>  [sshcfg=<enable|disable>|
            snmpcfg=<enable|disable>|                             
            pd1=<nonred|redwoperf|redwperf>|
@@ -185,7 +191,7 @@ my %usage = (
    PPC specific:
        getmacs <noderange> [-F filter] 
        getmacs <noderange> [-M]
-       getmacs <noderange> [-V| --verbose] [-f] [-d] [--arp] | [-D [-S server] [-G gateway] [-C client]]
+       getmacs <noderange> [-V| --verbose] [-f] [-d] [--arp] | [-D [-o] [-S server] [-G gateway] [-C client]]
    blade specific:
        getmacs <noderange> [-V| --verbose] [-d] [--arp] [-i ethN|enN]
 ",
@@ -193,10 +199,14 @@ my %usage = (
 "Usage:
     Common:
        mkvm [-h|--help|-v|--version]
-    For PPC(with HMC):
+    For PPC(with HMC) specific:
        mkvm noderange -i id -l singlenode [-V|--verbose]
        mkvm noderange -c destcec -p profile [-V|--verbose]
        mkvm noderange --full [-V|--verbose]
+    PPC (using Direct FSP Management) specific:
+       mkvm noderange [--full]
+       mkvm noderange [vmcpus=min/req/max] [vmmemory=min/req/max]
+                      [vmphyslots=drc_index1,drc_index2...] [vmothersetting=hugepage:N,bsr:N]
     For KVM
        mkvm noderange -m|--master mastername -s|--size disksize -f|--force
     For zVM
@@ -210,7 +220,8 @@ my %usage = (
    PPC (with HMC) specific:
        lsvm <noderange> [-a|--all]
    PPC (using Direct FSP Management) specific:
-       lsvm <noderange> [-l|--long]
+       lsvm <noderange> [-l|--long] --p775
+       lsvm <noderange>
    zVM specific:
        lsvm noderange
        lsvm noderange --getnetworknames
@@ -225,9 +236,11 @@ my %usage = (
        chvm <noderange> [-p profile][-V|--verbose] 
        chvm <noderange> <attr>=<val> [<attr>=<val>...]
    PPC (using Direct FSP Management) specific:
-       chvm <noderange> [-p <profile>]
+       chvm <noderange> --p775 [-p <profile>]
+       chvm <noderange> --p775 -i <id> [-m <memory_interleaving>] -r <partition_rule>
        chvm <noderange> [lparname=<*|name>]
-       chvm <noderange> -i <id> [-m <memory_interleaving>] -r <partition_rule>
+       chvm <noderange> [vmcpus=min/req/max] [vmmemory=min/req/max]
+                        [vmphyslots=drc_index1,drc_index2...] [vmothersetting=hugepage:N,bsr:N]
    VMware specific:
        chvm <noderange> [-a size][-d disk][-p disk][--resize disk=size][--cpus count][--mem memory]
    zVM specific:
@@ -258,10 +271,12 @@ my %usage = (
     "rmvm" => 
 "Usage: rmvm <noderange> [--service][-V|--verbose] 
        rmvm [-h|--help|-v|--version],
-       rmvm [-p] [-f]",
+       rmvm [-p] [-f]
+       PPC (using Direct FSP Management) specific:
+       rmvm <noderange>",
     "lsslp" =>
 "Usage: lsslp [-h|--help|-v|--version]
-       lsslp [<noderange>][-V|--verbose][-i ip[,ip..]][-w][-r|-x|-z][-n][-I][-s FRAME|CEC|MM|IVM|RSA|HMC|CMM]
+       lsslp [<noderange>][-V|--verbose][-i ip[,ip..]][-w][-r|-x|-z][-n][-I][-s FRAME|CEC|MM|IVM|RSA|HMC|CMM|IMM2|FSP]
              [-t tries][--vpdtable][-C counts][-T timeout]",
   "rflash" =>
 "Usage: 
@@ -272,7 +287,7 @@ my %usage = (
     PPC (using Direct FSP Management) specific:
 	rflash <noderange> -p <rpm_directory> --activate <disruptive|deferred> [-d <data_directory>]
 	rflash <noderange> [--commit | --recover] [-V|--verbose]
-       rflash <noderange> [--bpa_acdl]",
+        rflash <noderange> [--bpa_acdl]",
     "mkhwconn" =>
 "Usage:
     mkhwconn [-h|--help]
@@ -317,20 +332,31 @@ my %usage = (
     renergy noderange [-V] { all | { [savingstatus] [dsavingstatus] [cappingstatus] [cappingmaxmin] [cappingvalue] [cappingsoftmin] [averageAC] [averageDC] [ambienttemp] [exhausttemp] [CPUspeed] [syssbpower] [sysIPLtime] [fsavingstatus] [ffoMin] [ffoVmin] [ffoTurbo] [ffoNorm] [ffovalue] } }
     renergy noderange [-V] { {savingstatus}={on | off} | {dsavingstatus}={on-norm | on-maxp | off} | {fsavingstatus}={on | off} | {ffovalue}=MHZ | {cappingstatus}={on | off} | {cappingwatt}=watt | {cappingperc}=percentage }
 
-    Blade specific :
-    renergy noderange [-V] { all | pd1all | pd2all | { [pd1status] [pd2status] [pd1policy] [pd2policy] [pd1powermodule1] [pd1powermodule2] [pd2powermodule1] [pd2powermodule2] [pd1avaiablepower] [pd2avaiablepower] [pd1reservedpower] [pd2reservedpower] [pd1remainpower] [pd2remainpower] [pd1inusedpower] [pd2inusedpower] [availableDC] [averageAC] [thermaloutput] [ambienttemp] [mmtemp] } }
-    renergy noderange [-V] { all | { [averageDC] [capability] [cappingvalue] [CPUspeed] [maxCPUspeed] [savingstatus] [dsavingstatus] } }
-    renergy noderange [-V] { {savingstatus}={on | off} | {dsavingstatus}={on-norm | on-maxp | off} }",
+    BladeCenter specific :
+      For Management Modules:
+        renergy noderange [-V] { all | pd1all | pd2all | [pd1status] [pd2status] [pd1policy] [pd2policy] [pd1powermodule1] [pd1powermodule2] [pd2powermodule1] [pd2powermodule2] [pd1avaiablepower] [pd2avaiablepower] [pd1reservedpower] [pd2reservedpower] [pd1remainpower] [pd2remainpower] [pd1inusedpower] [pd2inusedpower] [availableDC] [averageAC] [thermaloutput] [ambienttemp] [mmtemp] }
+      For a blade server nodes:
+        renergy noderange [-V] { all | [averageDC] [capability] [cappingvalue] [CPUspeed] [maxCPUspeed] [savingstatus] [dsavingstatus] }
+        renergy noderange [-V] { savingstatus={on | off} | dsavingstatus={on-norm | on-maxp | off} }
+ 
+    Flex specific :
+      For Flex Management Modules:
+        renergy noderange [-V] { all | [powerstatus] [powerpolicy] [powermodule] [avaiablepower] [reservedpower] [remainpower] [inusedpower] [availableDC] [averageAC] [thermaloutput] [ambienttemp] [mmtemp] }
+ 
+      For Flex node (power and x86):
+        renergy noderange [-V] { all | [averageDC] [capability] [cappingvalue] [cappingmaxmin] [cappingmax] [cappingmin] [cappingGmin] [CPUspeed] [maxCPUspeed] [savingstatus] [dsavingstatus] }
+        renergy noderange [-V] { cappingstatus={on | off} | cappingwatt=watt | cappingperc=percentage | savingstatus={on | off} | dsavingstatus={on-norm | on-maxp | off} }
+ 
+    iDataPlex specific :
+      renergy noderange [-V] [ { cappingmaxmin | cappingmax | cappingmin } ] [cappingstatus] [cappingvalue] [relhistogram]
+      renergy noderange [-V] { cappingstatus={on | enable | off | disable} | {cappingwatt|cappingvalue}=watt }",
   "updatenode" =>
 "Usage:
-    updatenode [-h|--help|-v|--version]
+    updatenode [-h|--help|-v|--version | -g|--genmypost]
     or
-    updatenode <noderange> [-V|--verbose] [-k|--security] [-s|--sn]
+    updatenode <noderange> [-V|--verbose] [-k|--security] [-s|--sn] [-t <timeout>]
     or
-    updatenode <noderange> [-V|--verbose] [-k|--security] [--user] 
-        [--devicetype]
-    or
-    updatenode <noderange> [-V|--verbose] [-F|--sync | -f|--snsync] [-S|--sw] 
+    updatenode <noderange> [-V|--verbose] [-F|--sync | -f|--snsync] [-l|--user[username]] [--fanout=[fanout value]] [-S|--sw] [-t <timeout>]
         [-P|--scripts [script1,script2,...]] [-s|--sn] 
         [-A|--updateallsw] [-c|--cmdlineonly] [-d alt_source_dir]
         [attr=val [attr=val...]]
@@ -343,14 +369,20 @@ Options:
     [-k|--security] Update the security keys and certificates for the 
         target nodes.
 
-    [-k|--security] [--user] [--devicetype] Update the ssh keys for 
-        specific device.
-
     [-F|--sync] Perform File Syncing.
 
+    [--fanout]  Allows you to assign the fanout value for the command. 
+        See xdsh/xdcp fanout parameter in the man page.
+
     [-f|--snsync] Performs File Syncing to the service nodes that service 
         the nodes in the noderange.
 
+    [-g|--genmypost] Will generate a new mypostscript file for the  
+        the nodes in the noderange, if site precreatemypostscripts is 1 or YES.
+
+    [-l|--user] User name to run the updatenode command.  It overrides the
+        current user which is the default.
+
     [-S|--sw] Perform Software Maintenance.
 
     [-P|--scripts] Execute postscripts listed in the postscripts table or 
@@ -361,6 +393,9 @@ Options:
 
     [-s|--sn] Set the server information stored on the nodes.
 
+    [-t|--timeout] Time out in seconds to allow the command to run. Default is no timeout,
+        except for updatenode -k which has a 10 second default timeout.
+
     [-A|--updateallsw] Install or update all software contained in the source 
         directory. (AIX only)
 
@@ -385,7 +420,7 @@ Options:
 "Usage:
    Common:
       nodeset [-h|--help|-v|--version]
-      nodeset <noderange> [install|shell|boot|runcmd=bmcsetup|netboot|iscsiboot|osimage=<imagename>|statelite|offline]",
+      nodeset <noderange> [install|shell|boot|runcmd=bmcsetup|netboot|iscsiboot|osimage[=<imagename>]|statelite|offline]",
   "rmflexnode" =>
 "Usage:
     rmflexnode [-h|--help|-v|--version]

perl-xCAT/xCAT/VMCommon.pm

@@ -26,7 +26,7 @@ sub grab_table_data{ #grab table data relevent to VM guest nodes
   if ($vpdtab) {
       $cfghash->{vpd} = $vpdtab->getNodesAttribs($noderange,['uuid']);
   }
-  $cfghash->{vm} = $vmtab->getNodesAttribs($noderange,['node','host','migrationdest','cfgstore','storage','vidmodel','vidproto','vidpassword','storagemodel','memory','cpus','nics','nicmodel','bootorder','virtflags','datacenter','guestostype','othersettings','master']);
+  $cfghash->{vm} = $vmtab->getNodesAttribs($noderange,['node','host','migrationdest','cfgstore','storage','storagecache','storageformat','vidmodel','vidproto','vidpassword','storagemodel','memory','cpus','nics','nicmodel','bootorder','virtflags','datacenter','guestostype','othersettings','master']);
   my $mactab = xCAT::Table->new("mac",-create=>1);
   my $nrtab= xCAT::Table->new("noderes",-create=>1);
   $cfghash->{mac} = $mactab->getAllNodeAttribs(['mac'],1);

perl-xCAT/xCAT/Version.pm

@@ -10,10 +10,7 @@ BEGIN
 # if AIX - make sure we include perl 5.8.2 in INC path.
 #       Needed to find perl dependencies shipped in deps tarball.
 if ($^O =~ /^aix/i) {
-        use lib "/usr/opt/perl5/lib/5.8.2/aix-thread-multi";
-        use lib "/usr/opt/perl5/lib/5.8.2";
-        use lib "/usr/opt/perl5/lib/site_perl/5.8.2/aix-thread-multi";
-        use lib "/usr/opt/perl5/lib/site_perl/5.8.2";
+	unshift(@INC, qw(/usr/opt/perl5/lib/5.8.2/aix-thread-multi /usr/opt/perl5/lib/5.8.2 /usr/opt/perl5/lib/site_perl/5.8.2/aix-thread-multi /usr/opt/perl5/lib/site_perl/5.8.2));
 }
 
 use lib "$::XCATROOT/lib/perl";
@@ -41,7 +38,7 @@ use strict;
 sub Version
 {
 
-    #The following tag tells the build script where to append build info
+    #The following tags tells the build script where to append build info
     my $version = shift;
     if ($version eq 'short')
     {

perl-xCAT/xCAT/Yum.pm

@@ -18,9 +18,24 @@ sub localize_yumrepo {
     $installpfx = "$installroot/$distname/$arch";
     mkpath("$installroot/postscripts/repos/$distname/$arch/");
     open($yumrepofile,">","$installroot/postscripts/repos/$distname/$arch/local-repository.tmpl");
-    find(\&check_tofix,$installpfx);
-    close($yumrepofile);
+    my %options=(
+      wanted => \&check_tofix,
+      follow_fast => 1
+      );
+    find(\%options,$installpfx);    
+     close($yumrepofile);
 }
+
+
+sub remove_yumrepo {
+    my $self = shift;
+    my $installroot = shift;
+    $distname = shift;
+    $arch = shift;
+
+    rmtree("$installroot/postscripts/repos/$distname/$arch/");
+}
+
 sub check_tofix {
    if (-d $File::Find::name and $File::Find::name =~ /\/repodata$/) {
 		if($distname =~ /rhels5/)
@@ -29,7 +44,12 @@ sub check_tofix {
 		}
 		generate_repo($File::Find::name);
    }
+   elsif($File::Find::name =~ /\/RPM-GPG-KEY/){
+   		qx(rpm --import $File::Find::name);
+   }
 }
+
+
 sub generate_repo
 {
     #write local-repository.tmpl

perl-xCAT/xCAT/data/discinfo.pm

@@ -1,9 +1,10 @@
 # IBM(c) 2007 EPL license http://www.eclipse.org/legal/epl-v10.html
+
+# You can get copycds to recognize new distro DVDs/ISOs (so that you do not have to specify -n and -a)
+# by adding the disc ids to the %distnames hash below.  Follow the syntax carefully.
+# Reload xcatd to have it take affect (service xcatd reload).
+
 package xCAT::data::discinfo;
-#BEGIN
-#{
-#  $::XCATROOT = $ENV{'XCATROOT'} ? $ENV{'XCATROOT'} : '/opt/xcat';
-#}
 
 require Exporter;
 @ISA=qw(Exporter);
@@ -11,11 +12,11 @@ require Exporter;
 @EXPORT_OK=qw(distnames numdiscs);
 
 
-
-
 %distnames = (
                  "1310229985.226287" => "centos6",
 		 "1323560292.885204" => "centos6.2",
+		 "1341569670.539525" => "centos6.3",#x86
+		 "1362445555.957609" => "centos6.4",#x86_64
                  "1176234647.982657" => "centos5",
                  "1156364963.862322" => "centos4.4",
                  "1178480581.024704" => "centos4.5",
@@ -25,6 +26,8 @@ require Exporter;
                  "1214240246.285059" => "centos5.2",
                  "1237641529.260981" => "centos5.3",
                  "1272326751.405938" => "centos5.5",
+                 "1330913492.861127" => "centos5.8",#x86_64
+                 "1357930415.252042" => "centos5.9",#x86_64
                  "1195488871.805863" => "centos4.6",
                  "1195487524.127458" => "centos4.6",
                  "1301444731.448392" => "centos5.6",
@@ -43,6 +46,9 @@ require Exporter;
                  "1269262918.904535" => "rhels5.5", #ppc
                  "1269260915.992102" => "rhels5.5", #i386
                  "1269263646.691048" => "rhels5.5", #x86_64
+                 "1328205744.315196" => "rhels5.8", #x86_64
+                 "1354216429.587870" => "rhels5.9", #x86_64
+                 "1354214009.518521" => "rhels5.9", #ppc64
                  "1285193176.460470" => "rhels6", #x86_64
                  "1285192093.430930" => "rhels6", #ppc64
                  "1305068199.328169" => "rhels6.1", #x86_64
@@ -50,9 +56,15 @@ require Exporter;
                  "1321546114.510099" => "rhels6.2", #x86_64
                  "1321546739.676170" => "rhels6.2", #ppc64
 		 "1339641244.734735" => "rhels6.3", #ppc64
-		 "1339640147.274118" => "rhels6.3", #x86_64
-		 "1339638991.532890" => "rhels6.3", #i386
-                 "1285193176.593806" => "rhelhpc6",
+                 "1339640147.274118" => "rhels6.3", #x86_64
+                 "1339638991.532890" => "rhels6.3", #i386
+                 "1359576752.435900" => "rhels6.4", #x86_64
+                 "1359576196.686790" => "rhels6.4", #ppc64
+		 "1285193176.593806" => "rhelhpc6", #x86_64
+		 "1305067719.718814" => "rhelhpc6.1",#x86_64				
+		 "1321545261.599847" => "rhelhpc6.2",#x86_64				
+		 "1339640148.070971" => "rhelhpc6.3",#x86_64				
+		 "1359576195.413831" => "rhelhpc6.4",#x86_64, RHEL ComputeNode
                  "1194015916.783841" => "fedora8",
                  "1194015385.299901" => "fedora8",
                  "1210112435.291709" => "fedora9",
@@ -64,6 +76,8 @@ require Exporter;
                  "1273712675.937554" => "fedora13", #x86_64 DVD ISO
                  "1287685820.403779" => "fedora14", #x86_64 DVD ISO
                  "1305315870.828212" => "fedora15", #x86_64 DVD ISO
+                 "1372355769.065812" => "fedora19", #x86_64 DVD ISO
+                 "1372402928.663653" => "fedora19", #ppc64 DVD ISO
 
                  "1194512200.047708" => "rhas4.6",
                  "1194512327.501046" => "rhas4.6",
@@ -78,9 +92,4 @@ my %numdiscs = (
                 );
 
 
-#sub handled_commands
-#{
-#	return;
-#};
-
 	1;

perl-xCAT/xCAT/data/ibmhwtypes.pm

@@ -0,0 +1,43 @@
+#!/usr/bin/env perl
+# IBM(c) 2007 EPL license http://www.eclipse.org/legal/epl-v10.html
+
+package xCAT::data::ibmhwtypes;
+require Exporter;
+@EXPORT_OK=qw(parse_group mt2group);
+use Data::Dumper;
+my %groups2mtm = (
+    "x3250" => ["2583","4251","4252"],
+    "x3550" => ["7914","7944","7946"],
+    "x3650" => ["7915","7945"],
+    "dx360" => [],
+    "x220"  => ["7906"],
+    "x240"  => ["8737","7863"],
+    "x440"  => ["7917"],
+    "p260"  => ["7895"], #789522X, 789523X
+    "p460"  => [],       #789542X
+    "p470"  => ["7954"],
+);
+
+%mt2group = ();
+foreach my $group (keys %groups2mtm) {
+    foreach my $mtm (@{$groups2mtm{$group}}) {
+        $mt2group{$mtm} = $group;
+    }
+}
+
+sub parse_group {
+    my $mtm = shift;
+    if ($mtm =~ /xCAT::data/) {
+        $mtm = shift;
+    }
+    if ($mtm =~ /^(\w{4})/) {
+        $mt = $1;
+        if ($mt eq "7895" and $mtm =~ /789542X/i) {
+            return "p460";
+        }
+        return $mt2group{$mt};
+    }
+    return undef;
+}
+
+1;

perl-xCAT/xCAT/hpoa.pm

@@ -14,7 +14,7 @@ package xCAT::hpoa;
 
 use strict;
 
-use SOAP::Lite;
+#use SOAP::Lite;	# hpblade.pm requires SOAP::Lite before requiring hpoa.pm, so we can check for SOAP::Lite dynamically
 use vars qw(@ISA);
 @ISA = qw(SOAP::Lite);
 

perl-xCAT/xCAT/zvmCPUtils.pm

@@ -1,4 +1,4 @@
-# IBM(c) 2012 EPL license http://www.eclipse.org/legal/epl-v10.html
+# IBM(c) 2013 EPL license http://www.eclipse.org/legal/epl-v10.html
 #-------------------------------------------------------
 
 =head1
@@ -19,7 +19,8 @@ use warnings;
 =head3   getUserId
 
     Description : Get the user ID of a given node
-    Arguments   : Node
+    Arguments   :   User (root or non-root)
+                    Node
     Returns     : UserID
     Example     : my $userID = xCAT::zvmCPUtils->getUserId($node);
     
@@ -29,10 +30,15 @@ use warnings;
 sub getUserId {
 
     # Get inputs
-    my ( $class, $node ) = @_;
+    my ( $class, $user, $node ) = @_;
+    
+    my $sudo = "sudo";
+    if ($user eq "root") {
+        $sudo = "";
+    }
 
     # Get user ID using VMCP
-    my $out     = `ssh -o ConnectTimeout=5 $node "vmcp q userid"`;
+    my $out     = `ssh -o ConnectTimeout=5 $user\@$node "$sudo /sbin/vmcp q userid"`;
     my @results = split( ' ', $out );
 
     return ( $results[0] );
@@ -43,7 +49,8 @@ sub getUserId {
 =head3   getHost
 
     Description : Get the z/VM host of a given node
-    Arguments   : Node
+    Arguments   :   User (root or non-root)
+                    Node
     Returns     : z/VM host
     Example     : my $host = xCAT::zvmCPUtils->getHost($node);
     
@@ -53,10 +60,15 @@ sub getUserId {
 sub getHost {
 
     # Get inputs
-    my ( $class, $node ) = @_;
+    my ( $class, $user, $node ) = @_;
+    
+    my $sudo = "sudo";
+    if ($user eq "root") {
+        $sudo = "";
+    }
 
     # Get host using VMCP
-    my $out     = `ssh -o ConnectTimeout=5 $node "vmcp q userid"`;
+    my $out     = `ssh -o ConnectTimeout=5 $user\@$node "$sudo /sbin/vmcp q userid"`;
     my @results = split( ' ', $out );
     my $host    = $results[2];
 
@@ -68,7 +80,8 @@ sub getHost {
 =head3   getPrivileges
 
     Description : Get the privilege class of a given node
-    Arguments   : Node
+    Arguments   :   User (root or non-root)
+                    Node
     Returns     : Privilege class
     Example     : my $class = xCAT::zvmCPUtils->getPrivileges($node);
     
@@ -78,10 +91,15 @@ sub getHost {
 sub getPrivileges {
 
     # Get inputs
-    my ( $class, $node ) = @_;
+    my ( $class, $user, $node ) = @_;
+    
+    my $sudo = "sudo";
+    if ($user eq "root") {
+        $sudo = "";
+    }
 
     # Get privilege class
-    my $out = `ssh -o ConnectTimeout=5 $node "vmcp q priv"`;
+    my $out = `ssh -o ConnectTimeout=5 $user\@$node "$sudo /sbin/vmcp q priv"`;
     my @out = split( '\n', $out );
     $out[1] = xCAT::zvmUtils->trimStr( $out[1] );
     $out[2] = xCAT::zvmUtils->trimStr( $out[2] );
@@ -95,7 +113,8 @@ sub getPrivileges {
 =head3   getMemory
 
     Description : Get the memory of a given node
-    Arguments   : Node
+    Arguments   :   User (root or non-root)
+                    Node
     Returns     : Memory
     Example     : my $memory = xCAT::zvmCPUtils->getMemory($node);
     
@@ -105,21 +124,29 @@ sub getPrivileges {
 sub getMemory {
 
     # Get inputs
-    my ( $class, $node ) = @_;
+    my ( $class, $user, $node ) = @_;
+    
+    my $sudo = "sudo";
+    if ($user eq "root") {
+        $sudo = "";
+    }
 
     # Get memory
-    my $out = `ssh -o ConnectTimeout=5 $node "vmcp q virtual storage"`;
-    my @out = split( '=', $out );
+    my $out = `ssh -o ConnectTimeout=5 $user\@$node "$sudo /sbin/vmcp q virtual storage"`;
+    my @out = split( ' ', $out );
 
-    return ( xCAT::zvmUtils->trimStr( $out[1] ) );
+    return ( xCAT::zvmUtils->trimStr( $out[2] ) );
 }
 
+
+
 #-------------------------------------------------------
 
 =head3   getCpu
 
     Description : Get the processor(s) of a given node
-    Arguments   : Node
+    Arguments   :   User (root or non-root)
+                    Node
     Returns     : Processor(s)
     Example     : my $proc = xCAT::zvmCPUtils->getCpu($node);
     
@@ -129,10 +156,15 @@ sub getMemory {
 sub getCpu {
 
     # Get inputs
-    my ( $class, $node ) = @_;
+    my ( $class, $user, $node ) = @_;
+    
+    my $sudo = "sudo";
+    if ($user eq "root") {
+        $sudo = "";
+    }
 
     # Get processors
-    my $out = `ssh -o ConnectTimeout=5 $node "vmcp q virtual cpus"`;
+    my $out = `ssh -o ConnectTimeout=5 $user\@$node "$sudo /sbin/vmcp q virtual cpus"`;
     my $str = xCAT::zvmUtils->tabStr($out);
 
     return ($str);
@@ -143,7 +175,8 @@ sub getCpu {
 =head3   getNic
 
     Description : Get the network interface card (NIC) of a given node
-    Arguments   : Node
+    Arguments   :   User (root or non-root)
+                    Node
     Returns     : NIC(s)
     Example     : my $nic = xCAT::zvmCPUtils->getNic($node);
     
@@ -153,10 +186,15 @@ sub getCpu {
 sub getNic {
 
     # Get inputs
-    my ( $class, $node ) = @_;
+    my ( $class, $user, $node ) = @_;
+    
+    my $sudo = "sudo";
+    if ($user eq "root") {
+        $sudo = "";
+    }
 
     # Get NIC
-    my $out = `ssh -o ConnectTimeout=5 $node "vmcp q virtual nic"`;
+    my $out = `ssh -o ConnectTimeout=5 $user\@$node "$sudo /sbin/vmcp q virtual nic"`;
     my $str = xCAT::zvmUtils->tabStr($out);
 
     return ($str);
@@ -167,9 +205,10 @@ sub getNic {
 =head3   getNetworkNames
 
     Description : Get a list of network names available to a given node
-    Arguments   : Node
+    Arguments   :   User (root or non-root)
+                    Node
     Returns     : Network names
-    Example     : my $lans = xCAT::zvmCPUtils->getNetworkNames($node);
+    Example     : my $lans = xCAT::zvmCPUtils->getNetworkNames($user, $node);
     
 =cut
 
@@ -177,10 +216,15 @@ sub getNic {
 sub getNetworkNames {
 
     # Get inputs
-    my ( $class, $node ) = @_;
+    my ( $class, $user, $node ) = @_;
+    
+    my $sudo = "sudo";
+    if ($user eq "root") {
+        $sudo = "";
+    }
 
     # Get network names
-    my $out = `ssh -o ConnectTimeout=5 $node "vmcp q lan | egrep 'LAN|VSWITCH'"`;
+    my $out = `ssh -o ConnectTimeout=5 $user\@$node "$sudo /sbin/vmcp q lan | egrep 'LAN|VSWITCH'"`;
     my @lines = split( '\n', $out );
     my @parms;
     my $names;
@@ -213,9 +257,10 @@ sub getNetworkNames {
 =head3   getNetworkNamesArray
 
     Description : Get an array of network names available to a given node
-    Arguments   : Node
+    Arguments   :   User (root or non-root)
+                    Node
     Returns     : Array of networks names
-    Example     : my @networks = xCAT::zvmCPUtils->getNetworkNamesArray($node);
+    Example     : my @networks = xCAT::zvmCPUtils->getNetworkNamesArray($user, $node);
     
 =cut
 
@@ -223,12 +268,17 @@ sub getNetworkNames {
 sub getNetworkNamesArray {
 
     # Get inputs
-    my ( $class, $node ) = @_;
+    my ( $class, $user, $node ) = @_;
     my @networks;
     my %netHash;
     
+    my $sudo = "sudo";
+    if ($user eq "root") {
+        $sudo = "";
+    }
+    
     # Get the networks used by the node
-    my $out   = `ssh $node "vmcp q v nic" | egrep -i "VSWITCH|LAN"`;
+    my $out   = `ssh $user\@$node "$sudo /sbin/vmcp q v nic" | egrep -i "VSWITCH|LAN"`;
     my @lines = split( '\n', $out );
     
     # Loop through each line
@@ -264,7 +314,8 @@ sub getNetworkNamesArray {
 =head3   getNetwork
 
     Description : Get the network info for a given node
-    Arguments   :   Node
+    Arguments   :   User (root or non-root)
+                    Node
                     Network name
     Returns     : Network configuration
     Example     : my $config = xCAT::zvmCPUtils->getNetwork($node, $netName);
@@ -275,14 +326,19 @@ sub getNetworkNamesArray {
 sub getNetwork {
 
     # Get inputs
-    my ( $class, $node, $netName ) = @_;
+    my ( $class, $user, $node, $netName ) = @_;
 
+    my $sudo = "sudo";
+    if ($user eq "root") {
+        $sudo = "";
+    }
+    
     # Get network info
     my $out;
     if ( $netName eq "all" ) {
-        $out = `ssh -o ConnectTimeout=5 $node "vmcp q lan"`;
+        $out = `ssh -o ConnectTimeout=5 $user\@$node "$sudo /sbin/vmcp q lan"`;
     } else {
-        $out = `ssh -o ConnectTimeout=5 $node "vmcp q lan $netName"`;
+        $out = `ssh -o ConnectTimeout=5 $user\@$node "$sudo /sbin/vmcp q lan $netName"`;
     }
 
     return ($out);
@@ -293,7 +349,8 @@ sub getNetwork {
 =head3   getDisks
 
     Description : Get the disk(s) of given node
-    Arguments   : Node
+    Arguments   :   User (root or non-root)
+                    Node
     Returns     : Disk(s)
     Example     : my $storage = xCAT::zvmCPUtils->getDisks($node);
     
@@ -303,10 +360,15 @@ sub getNetwork {
 sub getDisks {
 
     # Get inputs
-    my ( $class, $node ) = @_;
+    my ( $class, $user, $node ) = @_;
+    
+    my $sudo = "sudo";
+    if ($user eq "root") {
+        $sudo = "";
+    }
 
     # Get disks
-    my $out = `ssh -o ConnectTimeout=5 $node "vmcp q virtual dasd"`;
+    my $out = `ssh -o ConnectTimeout=5 $user\@$node "$sudo /sbin/vmcp q virtual dasd"`;
     my $str = xCAT::zvmUtils->tabStr($out);
 
     return ($str);
@@ -317,7 +379,8 @@ sub getDisks {
 =head3   loadVmcp
 
     Description : Load Linux VMCP module on a given node
-    Arguments   : Node
+    Arguments   :   User (root or non-root)
+                    Node
     Returns     : Nothing
     Example     : xCAT::zvmCPUtils->loadVmcp($node);
     
@@ -327,10 +390,15 @@ sub getDisks {
 sub loadVmcp {
 
     # Get inputs
-    my ( $class, $node ) = @_;
+    my ( $class, $user, $node ) = @_;
+    
+    my $sudo = "sudo";
+    if ($user eq "root") {
+        $sudo = "";
+    }
 
     # Load Linux VMCP module
-    my $out = `ssh -o ConnectTimeout=5 $node "modprobe vmcp"`;
+    my $out = `ssh -o ConnectTimeout=5 $user\@$node "$sudo /sbin/modprobe vmcp"`;
     return;
 }
 
@@ -339,7 +407,8 @@ sub loadVmcp {
 =head3   getVswitchId
 
     Description : Get the VSwitch ID(s) of given node
-    Arguments   : Node
+    Arguments   :   User (root or non-root)
+                    Node
     Returns     : VSwitch ID(s)
     Example     : my @vswitch = xCAT::zvmCPUtils->getVswitchId($node);
     
@@ -349,10 +418,15 @@ sub loadVmcp {
 sub getVswitchId {
 
     # Get inputs
-    my ( $class, $node ) = @_;
+    my ( $class, $user, $node ) = @_;
+    
+    my $sudo = "sudo";
+    if ($user eq "root") {
+        $sudo = "";
+    }
 
     # Get VSwitch
-    my $out = `ssh -o ConnectTimeout=5 $node "vmcp q v nic" | grep "VSWITCH"`;
+    my $out = `ssh -o ConnectTimeout=5 $user\@$node "$sudo /sbin/vmcp q v nic" | grep "VSWITCH"`;
     my @lines = split( '\n', $out );
     my @parms;
     my @vswitch;
@@ -369,7 +443,8 @@ sub getVswitchId {
 =head3   grantVSwitch
 
     Description : Grant VSwitch access for a given userID 
-    Arguments   :   HCP node
+    Arguments   :   User (root or non-root)
+                    zHCP
                     User ID
                     VSWITCH ID
     Returns     : Operation results (Done/Failed)
@@ -381,15 +456,24 @@ sub getVswitchId {
 sub grantVSwitch {
 
     # Get inputs
-    my ( $class, $callback, $hcp, $userId, $vswitchId ) = @_;
+    my ( $class, $callback, $user, $hcp, $userId, $vswitchId ) = @_;
+    
+    # Directory where executables are
+    my $dir = '/opt/zhcp/bin';
+    
+    my $sudo = "sudo";
+    if ($user eq "root") {
+        $sudo = "";
+    }
 
-    # Grant VSwitch for specified userID
-    my $out = `ssh $hcp "vmcp set vswitch $vswitchId grant $userId"`;
+    # Use SMAPI EXEC
+    my $out = `ssh $user\@$hcp "$sudo $dir/smcli Virtual_Network_Vswitch_Set -T SYSTEM -n $vswitchId -I $userId"`;
+    xCAT::zvmUtils->printSyslog("grantVSwitch- ssh $user\@$hcp $sudo $dir/smcli Virtual_Network_Vswitch_Set -T SYSTEM -n $vswitchId -I $userId");
     $out = xCAT::zvmUtils->trimStr($out);
 
-    # If return string contains 'Command complete' - Operation was successful
+    # If return string contains 'Done' - Operation was successful
     my $retStr;
-    if ( $out =~ m/Command complete/i ) {
+    if ( $out =~ m/Done/i ) {
         $retStr = "Done\n";
     } else {
         $retStr = "Failed\n";
@@ -403,12 +487,15 @@ sub grantVSwitch {
 
 =head3   flashCopy
 
-    Description : Flash copy (Class B users only)
-    Arguments   :   Node
+    Description : Flash copy
+    Arguments   :   User (root or non-root)
+                    zHCP
+                    Source userId
                     Source address
+                    Target userId
                     Target address
     Returns     : Operation results (Done/Failed)
-    Example     : my $results = xCAT::zvmCPUtils->flashCopy($node, $srcAddr, $targetAddr);
+    Example     : my $results = xCAT::zvmCPUtils->flashCopy($user, $hcp, $srcAddr, $targetAddr);
     
 =cut
 
@@ -416,19 +503,79 @@ sub grantVSwitch {
 sub flashCopy {
 
     # Get inputs
-    my ( $class, $node, $srcAddr, $tgtAddr ) = @_;
+    my ( $class, $user, $hcp, $srcAddr, $tgtAddr ) = @_;
+    
+    # Directory where executables are
+    my $dir = '/opt/zhcp/bin';
+    
+    my $sudo = "sudo";
+    if ($user eq "root") {
+        $sudo = "";
+    }
 
-    # Flash copy
-    my $out = `ssh $node "vmcp flashcopy $srcAddr 0 end to $tgtAddr 0 end synchronous"`;
+    # Flash copy using CP
+    my $out = `ssh $user\@$hcp "$sudo /sbin/vmcp flashcopy $srcAddr 0 end to $tgtAddr 0 end synchronous"`;
+    
     $out = xCAT::zvmUtils->trimStr($out);
 
     # If return string contains 'Command complete' - Operation was successful
     my $retStr = "";
     if ( $out =~ m/Command complete/i ) {
-        $retStr = "Done\n";
+        $retStr = "Copying data via CP FLASHCOPY... Done\n";
     } else {
         $out    = xCAT::zvmUtils->tabStr($out);
-        $retStr = "Failed\n$out";
+        $retStr = "Copying data via CP FLASHCOPY... Failed\n$out";
+    }
+
+    return $retStr;
+}
+
+#-------------------------------------------------------
+
+=head3   smapiFlashCopy
+
+    Description : Flash copy using SMAPI
+    Arguments   :   User (root or non-root)
+                    zHCP
+                    Source userId
+                    Source address
+                    Target userId
+                    Target address
+    Returns     : Operation results (Done/Failed)
+    Example     : my $results = xCAT::zvmCPUtils->smapiFlashCopy($user, $node, $srcId, $srcAddr, $tgtId, $targetAddr);
+    
+=cut
+
+#-------------------------------------------------------
+sub smapiFlashCopy {
+
+    # Get inputs
+    my ( $class, $user, $hcp, $srcId, $srcAddr, $tgtId, $tgtAddr ) = @_;
+    
+    # Directory where executables are
+    my $dir = '/opt/zhcp/bin';
+    
+    my $sudo = "sudo";
+    if ($user eq "root") {
+        $sudo = "";
+    }
+
+    my $hcpUserId = xCAT::zvmCPUtils->getUserId($user, $hcp);
+        
+    # Use SMAPI EXEC to flash copy
+    my $cmd = '\"' . "CMD=FLASHCOPY $srcId $srcAddr 0 END $tgtId $tgtAddr 0 END" . '\"';
+    my $out = `ssh $user\@$hcp "$sudo $dir/smcli xCAT_Commands_IUO -T $hcpUserId -c $cmd"`;
+    xCAT::zvmUtils->printSyslog("smapiFlashCopy- ssh $user\@$hcp $sudo $dir/smcli xCAT_Commands_IUO -T $hcpUserId -c $cmd");
+        
+    $out = xCAT::zvmUtils->trimStr($out);
+
+    # If return string contains 'Done' - Operation was successful
+    my $retStr = "";
+    if ( $out =~ m/Done/i ) {
+        $retStr = "Copying data via SMAPI FLASHCOPY... Done\n";
+    } else {
+        $out    = xCAT::zvmUtils->tabStr($out);
+        $retStr = "Copying data via SMAPI FLASHCOPY... $out";
     }
 
     return $retStr;
@@ -439,7 +586,8 @@ sub flashCopy {
 =head3   punch2Reader
 
     Description : Write file to z/VM punch and transfer it to reader
-    Arguments   :   HCP node
+    Arguments   :   User (root or non-root)
+                    zHCP
                     UserID to receive file
                     Source file
                     Target file to be created by punch (e.g. sles.parm)
@@ -451,19 +599,51 @@ sub flashCopy {
 
 #-------------------------------------------------------
 sub punch2Reader {
-    my ( $class, $hcp, $userId, $srcFile, $tgtFile, $options ) = @_;
-
-    # Punch to reader
-    my $out = `ssh -o ConnectTimeout=5 $hcp "vmur punch $options -u $userId -r $srcFile -N $tgtFile"`;
-
-    # If punch is successful -- Look for this string
-    my $searchStr = "created and transferred";
-    if ( !( $out =~ m/$searchStr/i ) ) {
-        $out = "Failed\n";
-    } else {
-        $out = "Done\n";
+    my ( $class, $user, $hcp, $userId, $srcFile, $tgtFile, $options ) = @_;
+    
+    my $sudo = "sudo";
+    if ($user eq "root") {
+        $sudo = "";
     }
-
+    
+    # Get source node OS
+    my $os = xCAT::zvmUtils->getOsVersion($user, $hcp);
+            
+    # Punch to reader
+    # VMUR located in different directories on RHEL and SLES
+    my $vmur;
+    if ( $os =~ m/sles10/i ) {
+        $vmur = "/sbin/vmur";
+    } else {
+        $vmur = "/usr/sbin/vmur";
+    }
+    my $out;
+    my $done = 0;
+    
+    until ( $done ) {
+        $out = `ssh -o ConnectTimeout=5 $user\@$hcp "$sudo $vmur punch $options -u $userId -r $srcFile -N $tgtFile" 2>&1`;
+        my $rc = $? >> 8;
+        if ( $rc == 255 ) {
+            $out = "(Error) Unable to communicate with the zHCP system: $hcp";
+            $done = 1;
+        } elsif ( $out =~ m/A concurrent instance of vmur is already active/i ) {
+            # Recoverable error: retry the command after a delay
+            xCAT::zvmUtils->printSyslog( "punch2Reader() Punch in use on $hcp, retrying in 15 seconds" );
+            sleep( 15 );
+        } else {
+            # Punch appears successful -- Look for the completion string
+            my $searchStr = "created and transferred";
+            if ( !( $out =~ m/$searchStr/i ) ) {
+                chomp( $out );
+                $out = "Failed, punch info: '$out'\n";
+                xCAT::zvmUtils->printSyslog( "punch2Reader() Failed punching $srcFile to $userId from $hcp, info: '$out'" );
+            } else {
+                $out = "Done\n";
+            }
+            $done = 1;
+        }
+    }
+    
     return $out;
 }
 
@@ -471,8 +651,9 @@ sub punch2Reader {
 
 =head3   purgeReader
 
-    Description : Purge reader (Class D users only)
-    Arguments   :   HCP node
+    Description : Purge reader
+    Arguments   :   User (root or non-root)
+                    zHCP
                     UserID to purge reader
     Returns     : Nothing
     Example     : my $rc = xCAT::zvmCPUtils->purgeReader($hcp, $userId);
@@ -481,12 +662,32 @@ sub punch2Reader {
 
 #-------------------------------------------------------
 sub purgeReader {
-    my ( $class, $hcp, $userId ) = @_;
+    my ( $class, $user, $hcp, $userId ) = @_;
+    
+    # Directory where executables are
+    my $dir = '/opt/zhcp/bin';
+    
+    my $sudo = "sudo";
+    if ($user eq "root") {
+        $sudo = "";
+    }
+    
+    xCAT::zvmUtils->printSyslog("sudoer:$user zHCP:$hcp sudo:$sudo");
+    
+    my $out;
+    if (xCAT::zvmUtils->smapi4xcat($user, $hcp)) {
+        # Use SMAPI EXEC to purge reader
+        my $cmd = '\"' . "CMD=PURGE $userId RDR ALL" . '\"';
+        $out = `ssh $user\@$hcp "$sudo $dir/smcli xCAT_Commands_IUO -T $userId -c $cmd"`;
+        xCAT::zvmUtils->printSyslog("smcli xCAT_Commands_IUO -T $userId -c $cmd");
+    } else {
+        # Purge reader using CP
+        $out = `ssh -o ConnectTimeout=5 $user\@$hcp "$sudo /sbin/vmcp purge $userId rdr all"`;
+        xCAT::zvmUtils->printSyslog("/sbin/vmcp purge $userId rdr all");
+    }
 
-    # Purge reader
-    my $out = `ssh -o ConnectTimeout=5 $hcp "vmcp purge $userId rdr all"`;
-
-    return;
+    $out = xCAT::zvmUtils->trimStr($out);
+    return $out;
 }
 
 #-------------------------------------------------------
@@ -494,7 +695,8 @@ sub purgeReader {
 =head3   sendCPCmd
 
     Description : Send CP command to a given userID (Class C users only)
-    Arguments   :   HCP node
+    Arguments   :   User (root or non-root)
+                    zHCP
                     UserID to send CP command
     Returns     : Nothing
     Example     : xCAT::zvmCPUtils->sendCPCmd($hcp, $userId, $cmd);
@@ -503,11 +705,31 @@ sub purgeReader {
 
 #-------------------------------------------------------
 sub sendCPCmd {
-    my ( $class, $hcp, $userId, $cmd ) = @_;
+    my ( $class, $user, $hcp, $userId, $cmd ) = @_;
 
-    # Send CP command to given userID
-    my $out = `ssh $hcp "vmcp send cp $userId $cmd"`;
+    # Directory where executables are
+    my $dir = '/opt/zhcp/bin';
+    
+    my $sudo = "sudo";
+    if ($user eq "root") {
+        $sudo = "";
+    }
+    
+    xCAT::zvmUtils->printSyslog("sudoer:$user zHCP:$hcp sudo:$sudo");
+    
+    my $out;
+    if (xCAT::zvmUtils->smapi4xcat($user, $hcp)) {
+        # Use SMAPI EXEC to send command
+        $cmd = '\"' . "CMD=SEND CP $userId " . uc($cmd) . '\"';
+        $out = `ssh $user\@$hcp "$sudo $dir/smcli xCAT_Commands_IUO -T $userId -c $cmd"`;
+        xCAT::zvmUtils->printSyslog("smcli xCAT_Commands_IUO -T $userId -c $cmd");
+    } else {
+        # Send CP command to given user
+        $out = `ssh $user\@$hcp "$sudo /sbin/vmcp send cp $userId $cmd"`;
+        xCAT::zvmUtils->printSyslog("/sbin/vmcp send cp $userId $cmd");
+    }
 
+    $out = xCAT::zvmUtils->trimStr($out);
     return;
 }
 
@@ -516,7 +738,8 @@ sub sendCPCmd {
 =head3   getNetworkLayer
 
     Description : Get the network layer for a given node
-    Arguments   :   Node
+    Arguments   :   User (root or non-root)
+                    Node
                     Network name
     Returns     :  2     - Layer 2
                    3     - Layer 3
@@ -527,15 +750,20 @@ sub sendCPCmd {
 
 #-------------------------------------------------------
 sub getNetworkLayer {
-    my ( $class, $node, $netName ) = @_;
+    my ( $class, $user, $node, $netName ) = @_;
 
+    my $sudo = "sudo";
+    if ($user eq "root") {
+        $sudo = "";
+    }
+    
     # Exit if the network name is not given
     if ( !$netName ) {
         return -1;
     }
 
     # Get network type (Layer 2 or 3)
-    my $out = `ssh -o ConnectTimeout=5 $node "vmcp q lan $netName"`;
+    my $out = `ssh -o ConnectTimeout=5 $user\@$node "$sudo /sbin/vmcp q lan $netName"`;
     if ( !$out ) {
         return -1;
     }
@@ -559,7 +787,8 @@ sub getNetworkLayer {
 =head3   getNetworkType
 
     Description : Get the network type of a given network
-    Arguments   :   HCP node
+    Arguments   :   User (root or non-root)
+                    zHCP
                     Name of network
     Returns     : Network type (VSWITCH/HIPERS/QDIO)
     Example     : my $netType = xCAT::zvmCPUtils->getNetworkType($hcp, $netName);
@@ -568,10 +797,15 @@ sub getNetworkLayer {
 
 #-------------------------------------------------------
 sub getNetworkType {
-    my ( $class, $hcp, $netName ) = @_;
-
+    my ( $class, $user, $hcp, $netName ) = @_;
+    
+    my $sudo = "sudo";
+    if ($user eq "root") {
+        $sudo = "";
+    }
+    
     # Get network details
-    my $out = `ssh -o ConnectTimeout=5 $hcp "vmcp q lan $netName" | grep "Type"`;
+    my $out = `ssh -o ConnectTimeout=5 $user\@$hcp "$sudo /sbin/vmcp q lan $netName" | grep "Type"`;
 
     # Go through each line and determine network type
     my @lines = split( '\n', $out );
@@ -602,7 +836,8 @@ sub getNetworkType {
 =head3   defineCpu
 
     Description : Add processor(s) to given node
-    Arguments   : Node
+    Arguments   :   User (root or non-root)
+                    Node
     Returns     : Nothing
     Example     : my $out = xCAT::zvmCPUtils->defineCpu($node, $addr, $type);
     
@@ -612,10 +847,15 @@ sub getNetworkType {
 sub defineCpu {
 
     # Get inputs
-    my ( $class, $node, $addr, $type ) = @_;
+    my ( $class, $user, $node, $addr, $type ) = @_;
+    
+    my $sudo = "sudo";
+    if ($user eq "root") {
+        $sudo = "";
+    }
 
     # Define processor(s)
-    my $out = `ssh -o ConnectTimeout=5 $node "vmcp define cpu $addr type $type"`;
+    my $out = `ssh -o ConnectTimeout=5 $user\@$node "$sudo /sbin/vmcp define cpu $addr type $type"`;
 
     return ($out);
 }

xCAT-IBMhpc/debian/changelog

@@ -0,0 +1,5 @@
+xcat-ibmhpc (2.8.0-1) stable; urgency=low
+
+  * Initial Release
+
+ -- OCF xCAT <xcat@ocf.co.uk>  Tue, 03 Apr 2012 09:00:00 -0000

xCAT-IBMhpc/debian/compat

@@ -0,0 +1 @@
+5

xCAT-IBMhpc/debian/control

@@ -0,0 +1,15 @@
+Source: xcat-ibmhpc
+Section: admin
+Priority: extra
+Maintainer: Arif Ali <aali@ocf.co.uk>
+Build-Depends: debhelper (>= 5)
+Standards-Version: 3.7.2
+
+Package: xcat-ibmhpc
+Architecture: all
+Depends: ${perl:Depends}, perl-xcat (>= 2.8.0), xcat-client (>= 2.8.0)
+Description: Install and configuration utilities for IBM HPC products in an xCAT cluster
+ xCAT-IBMhpc provides sample installation and configuration scripts for running 
+ the IBM HPC software stack in an xCAT cluser.  Support for the following IBM 
+ products is provided:  GPFS, LoadLeveler, Parallel Environment, ESSL and Parallel 
+ ESSL libraries, some compilers (vac, xlC, xlf).

xCAT-IBMhpc/debian/copyright

@@ -0,0 +1,88 @@
+Eclipse Public License - v 1.0
+
+THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.
+
+1. DEFINITIONS
+
+"Contribution" means:
+
+a) in the case of the initial Contributor, the initial code and documentation distributed under this Agreement, and
+b) in the case of each subsequent Contributor:
+
+i) changes to the Program, and
+
+ii) additions to the Program;
+
+where such changes and/or additions to the Program originate from and are distributed by that particular Contributor. A Contribution 'originates' from a Contributor if it was added to the Program by such Contributor itself or anyone acting on such Contributor's behalf. Contributions do not include additions to the Program which: (i) are separate modules of software distributed in conjunction with the Program under their own license agreement, and (ii) are not derivative works of the Program.
+
+"Contributor" means any person or entity that distributes the Program.
+
+"Licensed Patents " mean patent claims licensable by a Contributor which are necessarily infringed by the use or sale of its Contribution alone or when combined with the Program.
+
+"Program" means the Contributions distributed in accordance with this Agreement.
+
+"Recipient" means anyone who receives the Program under this Agreement, including all Contributors.
+
+2. GRANT OF RIGHTS
+
+a) Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide, royalty-free copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, distribute and sublicense the Contribution of such Contributor, if any, and such derivative works, in source code and object code form.
+
+b) Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide, royalty-free patent license under Licensed Patents to make, use, sell, offer to sell, import and otherwise transfer the Contribution of such Contributor, if any, in source code and object code form. This patent license shall apply to the combination of the Contribution and the Program if, at the time the Contribution is added by the Contributor, such addition of the Contribution causes such combination to be covered by the Licensed Patents. The patent license shall not apply to any other combinations which include the Contribution. No hardware per se is licensed hereunder.
+
+c) Recipient understands that although each Contributor grants the licenses to its Contributions set forth herein, no assurances are provided by any Contributor that the Program does not infringe the patent or other intellectual property rights of any other entity. Each Contributor disclaims any liability to Recipient for claims brought by any other entity based on infringement of intellectual property rights or otherwise. As a condition to exercising the rights and licenses granted hereunder, each Recipient hereby assumes sole responsibility to secure any other intellectual property rights needed, if any. For example, if a third party patent license is required to allow Recipient to distribute the Program, it is Recipient's responsibility to acquire that license before distributing the Program.
+
+d) Each Contributor represents that to its knowledge it has sufficient copyright rights in its Contribution, if any, to grant the copyright license set forth in this Agreement.
+
+3. REQUIREMENTS
+
+A Contributor may choose to distribute the Program in object code form under its own license agreement, provided that:
+
+a) it complies with the terms and conditions of this Agreement; and
+
+b) its license agreement:
+
+i) effectively disclaims on behalf of all Contributors all warranties and conditions, express and implied, including warranties or conditions of title and non-infringement, and implied warranties or conditions of merchantability and fitness for a particular purpose;
+
+ii) effectively excludes on behalf of all Contributors all liability for damages, including direct, indirect, special, incidental and consequential damages, such as lost profits;
+
+iii) states that any provisions which differ from this Agreement are offered by that Contributor alone and not by any other party; and
+
+iv) states that source code for the Program is available from such Contributor, and informs licensees how to obtain it in a reasonable manner on or through a medium customarily used for software exchange.
+
+When the Program is made available in source code form:
+
+a) it must be made available under this Agreement; and
+
+b) a copy of this Agreement must be included with each copy of the Program.
+
+Contributors may not remove or alter any copyright notices contained within the Program.
+
+Each Contributor must identify itself as the originator of its Contribution, if any, in a manner that reasonably allows subsequent Recipients to identify the originator of the Contribution.
+
+4. COMMERCIAL DISTRIBUTION
+
+Commercial distributors of software may accept certain responsibilities with respect to end users, business partners and the like. While this license is intended to facilitate the commercial use of the Program, the Contributor who includes the Program in a commercial product offering should do so in a manner which does not create potential liability for other Contributors. Therefore, if a Contributor includes the Program in a commercial product offering, such Contributor ("Commercial Contributor") hereby agrees to defend and indemnify every other Contributor ("Indemnified Contributor") against any losses, damages and costs (collectively "Losses") arising from claims, lawsuits and other legal actions brought by a third party against the Indemnified Contributor to the extent caused by the acts or omissions of such Commercial Contributor in connection with its distribution of the Program in a commercial product offering. The obligations in this section do not apply to any claims or Losses relating to any actual or alleged intellectual property infringement. In order to qualify, an Indemnified Contributor must: a) promptly notify the Commercial Contributor in writing of such claim, and b) allow the Commercial Contributor to control, and cooperate with the Commercial Contributor in, the defense and any related settlement negotiations. The Indemnified Contributor may participate in any such claim at its own expense.
+
+For example, a Contributor might include the Program in a commercial product offering, Product X. That Contributor is then a Commercial Contributor. If that Commercial Contributor then makes performance claims, or offers warranties related to Product X, those performance claims and warranties are such Commercial Contributor's responsibility alone. Under this section, the Commercial Contributor would have to defend claims against the other Contributors related to those performance claims and warranties, and if a court requires any other Contributor to pay any damages as a result, the Commercial Contributor must pay those damages.
+
+5. NO WARRANTY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely responsible for determining the appropriateness of using and distributing the Program and assumes all risks associated with its exercise of rights under this Agreement , including but not limited to the risks and costs of program errors, compliance with applicable laws, damage to or loss of data, programs or equipment, and unavailability or interruption of operations.
+
+6. DISCLAIMER OF LIABILITY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+7. GENERAL
+
+If any provision of this Agreement is invalid or unenforceable under applicable law, it shall not affect the validity or enforceability of the remainder of the terms of this Agreement, and without further action by the parties hereto, such provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable.
+
+If Recipient institutes patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Program itself (excluding combinations of the Program with other software or hardware) infringes such Recipient's patent(s), then such Recipient's rights granted under Section 2(b) shall terminate as of the date such litigation is filed.
+
+All Recipient's rights under this Agreement shall terminate if it fails to comply with any of the material terms or conditions of this Agreement and does not cure such failure in a reasonable period of time after becoming aware of such noncompliance. If all Recipient's rights under this Agreement terminate, Recipient agrees to cease use and distribution of the Program as soon as reasonably practicable. However, Recipient's obligations under this Agreement and any licenses granted by Recipient relating to the Program shall continue and survive.
+
+Everyone is permitted to copy and distribute copies of this Agreement, but in order to avoid inconsistency the Agreement is copyrighted and may only be modified in the following manner. The Agreement Steward reserves the right to publish new versions (including revisions) of this Agreement from time to time. No one other than the Agreement Steward has the right to modify this Agreement. The Eclipse Foundation is the initial Agreement Steward. The Eclipse Foundation may assign the responsibility to serve as the Agreement Steward to a suitable separate entity. Each new version of the Agreement will be given a distinguishing version number. The Program (including Contributions) may always be distributed subject to the version of the Agreement under which it was received. In addition, after a new version of the Agreement is published, Contributor may elect to distribute the Program (including its Contributions) under the new version. Except as expressly stated in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to the intellectual property of any Contributor under this Agreement, whether expressly, by implication, estoppel or otherwise. All rights in the Program not expressly granted under this Agreement are reserved.
+
+This Agreement is governed by the laws of the State of New York and the intellectual property laws of the United States of America. No party to this Agreement will bring a legal action under this Agreement more than one year after the cause of action arose. Each party waives its rights to a jury trial in any resulting litigation.
+
+ 

xCAT-IBMhpc/debian/dirs

@@ -0,0 +1,8 @@
+opt/xcat/share/xcat/IBMhpc/compilers
+opt/xcat/share/xcat/IBMhpc/essl
+opt/xcat/share/xcat/IBMhpc/gpfs
+opt/xcat/share/xcat/IBMhpc/loadl
+opt/xcat/share/xcat/IBMhpc/pe
+opt/xcat/share/xcat/IBMhpc/rsct
+opt/xcat/share/xcat/IBMhpc/compilers
+opt/xcat/share/doc/packages/xCAT-IBMhpc

xCAT-IBMhpc/debian/docs

@@ -0,0 +1 @@
+LICENSE.html

xCAT-IBMhpc/debian/install

@@ -0,0 +1,2 @@
+share/xcat/IBMhpc/* opt/xcat/share/xcat/IBMhpc/
+LICENSE.html share/doc/packages/xCAT-IBMhpc/

xCAT-IBMhpc/debian/rules

@@ -0,0 +1,70 @@
+#!/usr/bin/make -f
+# -*- makefile -*-
+# Sample debian/rules that uses debhelper.
+# This file was originally written by Joey Hess and Craig Small.
+# As a special exception, when this file is copied by dh-make into a
+# dh-make output file, you may use that output file without restriction.
+# This special exception was added by Craig Small in version 0.37 of dh-make.
+
+# Uncomment this to turn on verbose mode.
+#export DH_VERBOSE=1
+
+export DH_COMPAT=5
+
+
+build:
+	pwd
+	dh_quilt_patch
+
+clean:
+	dh_testdir
+	dh_testroot
+	dh_clean -d
+
+install:
+	pwd
+	dh_testdir
+	dh_testroot
+	dh_installdirs
+	dh_install -X".svn"
+	dh_link
+
+
+# Build architecture-independent files here.
+binary-indep: build install
+# We have nothing to do by default.
+
+# Build architecture-dependent files here.
+binary-arch:
+	pwd
+	dh_testdir
+	dh_testroot
+	dh_installchangelogs 
+	dh_installdocs
+#	dh_installexamples
+	dh_install -X".svn"
+#	dh_installmenu
+#	dh_installdebconf	
+#	dh_installlogrotate
+#	dh_installemacsen
+#	dh_installpam
+#	dh_installmime
+#	dh_python
+#	dh_installinit
+#	dh_installcron
+#	dh_installinfo
+	dh_installman
+#	dh_link
+#	dh_strip
+	dh_compress
+#	dh_fixperms
+	dh_perl
+	dh_makeshlibs
+	dh_installdeb
+	dh_shlibdeps
+	dh_gencontrol
+	dh_md5sums
+	dh_builddeb
+
+binary: binary-indep binary-arch
+.PHONY: build clean binary-indep binary-arch binary install configure

xCAT-IBMhpc/debian/source/format

@@ -0,0 +1 @@
+1.0

xCAT-IBMhpc/share/xcat/IBMhpc/dev-compute.rhels6.ppc64.exlist

@@ -0,0 +1,7 @@
+#INCLUDE:/opt/xcat/share/xcat/IBMhpc/IBMhpc.rhels6.ppc64.exlist#
+#INCLUDE:/opt/xcat/share/xcat/IBMhpc/gpfs/gpfs.exlist#
+#INCLUDE:/opt/xcat/share/xcat/IBMhpc/compilers/compilers.exlist#
+#INCLUDE:/opt/xcat/share/xcat/IBMhpc/pe/pe.exlist#
+#INCLUDE:/opt/xcat/share/xcat/IBMhpc/essl/essl.exlist#
+#INCLUDE:/opt/xcat/share/xcat/IBMhpc/rsct/rsct.exlist#
+#INCLUDE:/opt/xcat/share/xcat/IBMhpc/loadl/loadl.exlist#

xCAT-IBMhpc/share/xcat/IBMhpc/dev-compute.rhels6.ppc64.otherpkgs.pkglist

@@ -0,0 +1,5 @@
+#INCLUDE:/opt/xcat/share/xcat/IBMhpc/gpfs/gpfs.otherpkgs.pkglist#
+#INCLUDE:/opt/xcat/share/xcat/IBMhpc/compilers/compilers.otherpkgs.pkglist#
+#INCLUDE:/opt/xcat/share/xcat/IBMhpc/pe/pe-1200.rhels6.ppc64.otherpkgs.pkglist#
+#INCLUDE:/opt/xcat/share/xcat/IBMhpc/essl/essl.otherpkgs.pkglist#
+#INCLUDE:/opt/xcat/share/xcat/IBMhpc/loadl/loadl-5103.otherpkgs.pkglist#

xCAT-IBMhpc/share/xcat/IBMhpc/dev-compute.rhels6.ppc64.pkglist

@@ -0,0 +1,4 @@
+#INCLUDE:/opt/xcat/share/xcat/IBMhpc/IBMhpc.rhels6.ppc64.pkglist#
+#INCLUDE:/opt/xcat/share/xcat/IBMhpc/pe/pe-1200.rhels6.ppc64.pkglist#
+#INCLUDE:/opt/xcat/share/xcat/IBMhpc/compilers/compilers.rhels6.pkglist#
+#INCLUDE:/opt/xcat/share/xcat/IBMhpc/essl/essl.pkglist#

xCAT-IBMhpc/share/xcat/IBMhpc/dev-compute.rhels6.ppc64.postinstall

@@ -0,0 +1,62 @@
+#!/bin/sh
+# Sample postinstall script for building a diskless SLES11 PPC64 image
+#  with all IBM HPC products
+#
+#-- this script is run after all packages from $profile.pkglist are installed
+#--
+#-- it gets these arguments:
+#--
+#-- $1 = install root (chroot directory for profile)
+#-- $2 = OS version
+#-- $3 = architecture
+#-- $4 = profile name
+#-- $5 = work dir (where genimage is located)
+#--
+#--
+installroot=$1
+osver=$2
+arch=$3
+profile=$4
+workdir=$5
+
+otherpkgs=/install/post/otherpkgs/$osver/$arch
+
+################
+# This script runs other postinstall scripts from the $hpc directory
+# If you have created a custom copy of ANY of these scripts,
+#   make sure to change the execution path from $hpc/<product> to the location
+#   you have placed your script in
+###############
+hpc=/opt/xcat/share/xcat/IBMhpc
+custom=/install/custom/netboot/rh
+installps=/install/postscripts
+
+# Run default postinstall shipped with xcat
+/opt/xcat/share/xcat/netboot/rh/compute.rhels6.ppc64.postinstall $1 $2 $3 $4 $5
+
+
+# Run general IBMhpc postinstall script
+$hpc/IBMhpc.rhel.postinstall $1 $2 $3 $4 $5
+
+
+# Run script to install gpfs updates
+installroot=$installroot NODESETSTATE=genimage   $hpc/gpfs/gpfs_updates
+# Run script to update GPFS mmsdrfs file in the image
+installroot=$installroot   $hpc/gpfs/gpfs_mmsdrfs
+
+
+# Run script to accept compiler license
+installroot=$installroot NODESETSTATE=genimage   $hpc/compilers/compilers_license
+
+
+# Run script to install PE and accept license
+installroot=$installroot pedir=$otherpkgs/pe NODESETSTATE=genimage   $hpc/pe/pe_install-1200
+
+# Run script to accept LoadLeveler license, install product rpms, 
+# and do some config
+installroot=$installroot loadldir=$otherpkgs/loadl NODESETSTATE=genimage   $hpc/loadl/loadl_install-5103
+
+# Run script to install RSCT rpms
+installroot=$installroot rsctdir=$otherpkgs/rsct NODESETSTATE=genimage   $hpc/rsct/rsct_install
+
+

xCAT-IBMhpc/share/xcat/IBMhpc/dev-compute.rhels6.x86_64.exlist

@@ -0,0 +1,7 @@
+#INCLUDE:/opt/xcat/share/xcat/IBMhpc/IBMhpc.rhels6.x86_64.exlist#
+#INCLUDE:/opt/xcat/share/xcat/IBMhpc/gpfs/gpfs.exlist#
+#INCLUDE:/opt/xcat/share/xcat/IBMhpc/pe/pe.exlist#
+#INCLUDE:/opt/xcat/share/xcat/IBMhpc/compilers/compilers.exlist#
+#INCLUDE:/opt/xcat/share/xcat/IBMhpc/essl/essl.exlist#
+#INCLUDE:/opt/xcat/share/xcat/IBMhpc/rsct/rsct.exlist#
+#INCLUDE:/opt/xcat/share/xcat/IBMhpc/loadl/loadl.exlist#

xCAT-IBMhpc/share/xcat/IBMhpc/dev-compute.rhels6.x86_64.otherpkgs.pkglist

@@ -0,0 +1,3 @@
+#INCLUDE:/opt/xcat/share/xcat/IBMhpc/gpfs/gpfs.x86_64.otherpkgs.pkglist#
+#INCLUDE:/opt/xcat/share/xcat/IBMhpc/pe/pe-1200.rhels6.x86_64.otherpkgs.pkglist#   
+#INCLUDE:/opt/xcat/share/xcat/IBMhpc/loadl/loadl-5103.otherpkgs.pkglist#

xCAT-IBMhpc/share/xcat/IBMhpc/dev-compute.rhels6.x86_64.pkglist

@@ -0,0 +1,4 @@
+#INCLUDE:/opt/xcat/share/xcat/IBMhpc/IBMhpc.rhels6.x86_64.pkglist#
+#INCLUDE:/opt/xcat/share/xcat/IBMhpc/pe/pe-1200.rhels6.x86_64.pkglist#    
+#INCLUDE:/opt/xcat/share/xcat/IBMhpc/compilers/compilers.rhels6.pkglist#
+#INCLUDE:/opt/xcat/share/xcat/IBMhpc/essl/essl.pkglist#

xCAT-IBMhpc/share/xcat/IBMhpc/dev-compute.rhels6.x86_64.postinstall

@@ -0,0 +1,60 @@
+#!/bin/sh
+# Sample postinstall script for building a diskless SLES11 PPC64 image
+#  with all IBM HPC products
+#
+#-- this script is run after all packages from $profile.pkglist are installed
+#--
+#-- it gets these arguments:
+#--
+#-- $1 = install root (chroot directory for profile)
+#-- $2 = OS version
+#-- $3 = architecture
+#-- $4 = profile name
+#-- $5 = work dir (where genimage is located)
+#--
+#--
+installroot=$1
+osver=$2
+arch=$3
+profile=$4
+workdir=$5
+
+otherpkgs=/install/post/otherpkgs/$osver/$arch
+
+################
+# This script runs other postinstall scripts from the $hpc directory
+# If you have created a custom copy of ANY of these scripts,
+#   make sure to change the execution path from $hpc/<product> to the location
+#   you have placed your script in
+###############
+hpc=/opt/xcat/share/xcat/IBMhpc
+custom=/install/custom/netboot/rh
+installps=/install/postscripts
+
+# Run default postinstall shipped with xcat
+/opt/xcat/share/xcat/netboot/rh/compute.rhels6.x86_64.postinstall $1 $2 $3 $4 $5
+
+
+# Run general IBMhpc postinstall script
+$hpc/IBMhpc.rhel.postinstall $1 $2 $3 $4 $5
+
+
+# Run script to install gpfs updates
+installroot=$installroot NODESETSTATE=genimage   $hpc/gpfs/gpfs_updates
+# Run script to update GPFS mmsdrfs file in the image
+installroot=$installroot   $hpc/gpfs/gpfs_mmsdrfs
+
+
+# Run script to accept compiler license.  x86_64 is using gcc, comment this line.
+#installroot=$installroot NODESETSTATE=genimage   $hpc/compilers/compilers_license
+
+
+# Run script to install PE and accept license
+installroot=$installroot pedir=$otherpkgs/pe NODESETSTATE=genimage   $hpc/pe/pe_install-1200
+
+# Run script to accept LoadLeveler license, install product rpms, 
+# and do some config
+installroot=$installroot loadldir=$otherpkgs/loadl NODESETSTATE=genimage   $hpc/loadl/loadl_install-5103
+
+# Run script to install RSCT rpms.  Not available on x86_64
+#installroot=$installroot rsctdir=$otherpkgs/rsct NODESETSTATE=genimage   $hpc/rsct/rsct_install

xCAT-IBMhpc/share/xcat/IBMhpc/dev-compute.sles11.ppc64.exlist

@@ -0,0 +1,10 @@
+# Sample exlude list for building a diskless SLES 11 PPC64 image
+
+#INCLUDE:/opt/xcat/share/xcat/netboot/sles/compute.exlist#
+#INCLUDE:/opt/xcat/share/xcat/IBMhpc/IBMhpc.sles11.ppc64.exlist#
+#INCLUDE:/opt/xcat/share/xcat/IBMhpc/compilers/compilers.exlist#
+#INCLUDE:/opt/xcat/share/xcat/IBMhpc/essl/essl.exlist#
+#INCLUDE:/opt/xcat/share/xcat/IBMhpc/gpfs/gpfs.exlist#
+#INCLUDE:/opt/xcat/share/xcat/IBMhpc/loadl/loadl.exlist#
+#INCLUDE:/opt/xcat/share/xcat/IBMhpc/pe/pe.exlist#
+#INCLUDE:/opt/xcat/share/xcat/IBMhpc/rsct/rsct.exlist#

xCAT-IBMhpc/share/xcat/IBMhpc/dev-compute.sles11.ppc64.otherpkgs.pkglist

@@ -0,0 +1,13 @@
+# Sample otherpkgs pkglist for installing all IBM HPC products in a 
+# SLES11 PPC64 diskless image
+
+#INCLUDE:/opt/xcat/share/xcat/IBMhpc/compilers/compilers.otherpkgs.pkglist#
+#NEW_INSTALL_LIST#
+#INCLUDE:/opt/xcat/share/xcat/IBMhpc/gpfs/gpfs.otherpkgs.pkglist#
+#INCLUDE:/opt/xcat/share/xcat/IBMhpc/pe/pe.otherpkgs.pkglist#
+#INCLUDE:/opt/xcat/share/xcat/IBMhpc/essl/essl.otherpkgs.pkglist#
+#INCLUDE:/opt/xcat/share/xcat/IBMhpc/loadl/loadl-5103.otherpkgs.pkglist#
+
+#  For full-disk (stateful) images, EDIT below to use rsct.otherpkgs
+#  For diskless, rpms are installed with postinstall script
+#do not INCLUDE:/opt/xcat/share/xcat/IBMhpc/rsct/rsct.otherpkgs.pkglist#

xCAT-IBMhpc/share/xcat/IBMhpc/dev-compute.sles11.ppc64.pkglist

@@ -0,0 +1,10 @@
+#  Sample package list for installing all IBM HPC products in a
+#  SLES11 ppc64 diskless image
+
+#INCLUDE:/opt/xcat/share/xcat/IBMhpc/IBMhpc.sles11.ppc64.pkglist#
+#INCLUDE:/opt/xcat/share/xcat/IBMhpc/compilers/compilers.pkglist#
+#INCLUDE:/opt/xcat/share/xcat/IBMhpc/essl/essl.pkglist#
+#INCLUDE:/opt/xcat/share/xcat/IBMhpc/pe/pe-1200.sles11.ppc64.pkglist#
+#INCLUDE:/opt/xcat/share/xcat/IBMhpc/rsct/rsct.pkglist#
+
+

xCAT-IBMhpc/share/xcat/IBMhpc/dev-compute.sles11.ppc64.postinstall

@@ -0,0 +1,68 @@
+#!/bin/sh
+# Sample postinstall script for building a diskless SLES11 PPC64 image
+#  with all IBM HPC products
+#
+#-- this script is run after all packages from $profile.pkglist are installed
+#--
+#-- it gets these arguments:
+#--
+#-- $1 = install root (chroot directory for profile)
+#-- $2 = OS version
+#-- $3 = architecture
+#-- $4 = profile name
+#-- $5 = work dir (where genimage is located)
+#--
+#--
+installroot=$1
+osver=$2
+arch=$3
+profile=$4
+workdir=$5
+
+otherpkgs=/install/post/otherpkgs/$osver/$arch
+
+################
+# This script runs other postinstall scripts from the $hpc directory
+# If you have created a custom copy of ANY of these scripts,
+#   make sure to change the execution path from $hpc/<product> to the location
+#   you have placed your script in
+###############
+hpc=/opt/xcat/share/xcat/IBMhpc
+custom=/install/custom/netboot/sles
+installps=/install/postscripts
+
+
+# Run default postinstall shipped with xcat
+/opt/xcat/share/xcat/netboot/sles/compute.sles11.postinstall $1 $2 $3 $4 $5
+
+
+# Run general IBMhpc postinstall script
+$hpc/IBMhpc.sles.postinstall $1 $2 $3 $4 $5
+
+
+# Run script to install gpfs updates
+installroot=$installroot NODESETSTATE=genimage   $hpc/gpfs/gpfs_updates
+# Run script to update GPFS mmsdrfs file in the image
+installroot=$installroot   $hpc/gpfs/gpfs_mmsdrfs
+
+
+# Run script to accept compiler license
+installroot=$installroot NODESETSTATE=genimage   $hpc/compilers/compilers_license
+
+
+# Run script to install PE and accept license
+installroot=$installroot pedir=$otherpkgs/pe NODESETSTATE=genimage   $hpc/pe/pe_install
+
+
+# Run script to install ESSL and PESSL rpms
+#installroot=$installroot essldir=$otherpkgs/essl NODESETSTATE=genimage   $hpc/essl/essl_install
+
+
+# Run script to accept LoadLeveler license, install product rpms, 
+# and do some config
+installroot=$installroot loadldir=$otherpkgs/loadl NODESETSTATE=genimage   $hpc/loadl/loadl_install-5103
+
+# Run script to install RSCT rpms
+installroot=$installroot rsctdir=$otherpkgs/rsct NODESETSTATE=genimage   $hpc/rsct/rsct_install
+
+