Tools/dotnet-build.sh

   1 #!/bin/bash
   2
   3 usage() {
   4   echo "usage: "
   5   echo " $0 restore <project> [-s <source>] ..."
   6   echo " $0 build <project> [-c <configuration>] ..."
   7   echo " $0 pack <project> [-c <configuration>] [-v <version>] ..."
   8   echo " $0 install <project> [-t <type>]"
   9 }
  10
  11 exit_on_error() {
  12   if [ $1 -ne 0 ]; then
  13     echo "Error $1"
  14     exit $1
  15   fi
  16 }
  17
  18 retry() {
  19   local CMD=$1; shift
  20   local RETRY=$1; shift
  21   local RET=0
  22   local n=0
  23   until [ $n -ge $RETRY ]; do
  24     if [ $n -gt 0 ]; then
  25       sleep 2
  26       echo "Retry $n ....."
  27     fi
  28     echo "+ $CMD $@"
  29     $CMD $@
  30     RET=$?
  31     if [ $RET -eq 0 ]; then
  32       break
  33     fi
  34     n=$[$n+1]
  35   done
  36   exit_on_error $RET
  37 }
  38
  39 run_nuget() {
  40   retry nuget 3 $@
  41 }
  42
  43 run_xbuild() {
  44   echo "+ xbuild $@"
  45   xbuild $@
  46   exit_on_error $?
  47 }
  48
  49 run_dotnet() {
  50   echo "+ dotnet $@"
  51   dotnet $@
  52   exit_on_error $?
  53 }
  54
  55 build_project() {
  56   local CSPROJ=$1; shift
  57
  58   local PROJNAME=${CSPROJ%.*}
  59   local PROJECT_JSON=$PROJNAME.project.json
  60   if [ -f $PROJECT_JSON ]; then
  61     run_nuget restore $PROJECT_JSON
  62   fi
  63   run_xbuild $CSPROJ /p:Configuration=$CONFIGURATION $@
  64 }
  65
  66 cmd_restore() {
  67   if $USE_DOTNET_CLI; then
  68     local OPTS=""
  69     [ -n "$SOURCE" ] && OPTS="$OPTS -s $SOURCE"
  70     run_dotnet restore $PROJECT $OPTS $@
  71   else
  72     if [[ $PROJECT_TYPE == "dir" ]]; then
  73       local PROJFILES=$(find $PROJECT -name "*.project.json")
  74       for p in $PROJFILES; do
  75         run_nuget restore $p $@
  76       done
  77     else
  78       run_nuget restore $PROJECT $@
  79     fi
  80   fi
  81 }
  82
  83 cmd_build() {
  84   if $USE_DOTNET_CLI; then
  85     cmd_restore # restore first
  86     local OPTS=""
  87     [ -n "$CONFIGURATION" ] && OPTS="$OPTS -c $CONFIGURATION"
  88     [ -n "$VERSION" ] && OPTS="$OPTS /p:Version=$VERSION"
  89     run_dotnet build $PROJECT $OPTS $@
  90   else
  91     if [[ $PROJECT_TYPE == "dir" ]]; then
  92       local PROJFILES=$(find $PROJECT -name "*.csproj")
  93       for p in $PROJFILES; do
  94         build_project $p $@
  95       done
  96     elif [[ $PROJECT_TYPE == "sln" ]]; then
  97       run_xbuild $PROJECT /p:Configuration=$CONFIGURATION $@
  98     elif [[ $PROJECT_TYPE == "csproj" ]]; then
  99       build_project $PROJECT $@
 100     fi
 101   fi
 102 }
 103
 104 cmd_pack() {
 105   if $USE_DOTNET_CLI; then
 106     local OPTS=""
 107     [ -n "$CONFIGURATION" ] && OPTS="$OPTS -c $CONFIGURATION"
 108     [ -n "$VERSION" ] && OPTS="$OPTS /p:Version=$VERSION"
 109     run_dotnet pack $PROJECT $OPTS $@
 110   else
 111     local NUSPEC=($PROJECT)
 112     if [ -d $PROJECT ]; then
 113       NUSPEC=($(find $PROJECT -name "*.nuspec"))
 114     fi
 115     for x in ${NUSPEC[@]}; do
 116       run_nuget pack $x -Version $VERSION -Properties Configuration=$CONFIGURATION $@
 117     done
 118   fi
 119 }
 120
 121 cmd_install() {
 122   local DEST=$1; shift
 123
 124   mkdir -p $DEST
 125
 126   if [[ $TYPE == "assembly" ]]; then
 127     find $PROJECT/bin -name $PROJECT.dll -exec install -p -m 644 {} $DEST \;
 128   elif [[ $TYPE == "nupkg" ]]; then
 129     find . -name "$PROJECT.[0-9]*.nupkg" -exec install -p -m 644 {} $DEST \;
 130   fi
 131 }
 132
 133 #########################################################################
 134
 135 # Parse arguments
 136
 137 while getopts "s:c:v:t:" o; do
 138   case "$o" in
 139     s) SOURCE=${OPTARG} ;;
 140     c) CONFIGURATION=${OPTARG} ;;
 141     v) VERSION=${OPTARG} ;;
 142     t) TYPE=${OPTARG} ;;
 143     *) usage; exit 1 ;;
 144   esac
 145 done
 146 shift $((OPTIND-1))
 147
 148 if [ $# -lt 2 ]; then
 149   usage; exit 1
 150 fi
 151
 152 CMD=$1; shift
 153 PROJECT=$1; shift
 154
 155 # Check whether the project can be built using dotnet-cli
 156 PROJECT_TYPE=""
 157 USE_DOTNET_CLI=false
 158 if [ -f $PROJECT ]; then
 159   if [[ $PROJECT == *".sln" ]]; then
 160     PROJECT_TYPE="sln"
 161     VS_VERSION=$(grep -E "^VisualStudioVersion" $PROJECT | cut -f2 -d= | xargs)
 162     if [[ $VS_VERSION == "15."* ]]; then
 163       USE_DOTNET_CLI=true
 164     fi
 165   elif [[ $PROJECT == *".csproj" ]]; then
 166     PROJECT_TYPE="csproj"
 167     RET=$(grep "Microsoft.NET.Sdk" $PROJECT | wc -l)
 168     if [ $RET -gt 0 ]; then
 169       USE_DOTNET_CLI=true
 170     fi
 171   elif [[ $PROJECT == *".project.json" ]]; then
 172     PROJECT_TYPE="project.json"
 173   fi
 174 elif [ -d $PROJECT ]; then
 175   PROJECT_TYPE="dir"
 176   RET=$(find $PROJECT -name "*.project.json" | wc -l)
 177   if [ $RET -eq 0 ]; then
 178     CSPROJS=$(find $PROJECT -name "*.csproj")
 179     for p in $CSPROJS; do
 180       RET=$(grep "Microsoft.NET.Sdk" $p | wc -l)
 181       if [ $RET -gt 0 ]; then
 182         USE_DOTNET_CLI=true
 183         break;
 184       fi
 185     done
 186   fi
 187 fi
 188
 189 # Disable telemetry of dotnet
 190 export DOTNET_CLI_TELEMETRY_OPTOUT=1
 191
 192 # To build PCL projects ReferenceAssemblyRoot should be set.
 193 # dotnet-cli will find reference assemblies for PCL in this path.
 194 export ReferenceAssemblyRoot=/usr/lib/mono/xbuild-frameworks
 195
 196 # Dump
 197 echo "----------------------------------------------"
 198 echo "CMD=$CMD"
 199 echo "PROJECT=$PROJECT"
 200 echo "PROJECT_TYPE=$PROJECT_TYPE"
 201 echo "USE_DOTNET_CLI=$USE_DOTNET_CLI"
 202 echo "SOURCE=$SOURCE"
 203 echo "CONFIGURATION=$CONFIGURATION"
 204 echo "VERSION=$VERSION"
 205 echo "TYPE=$TYPE"
 206 echo "REST ARGS=$@"
 207 echo "----------------------------------------------"
 208
 209 case $CMD in
 210   restore) cmd_restore $@ ;;
 211   build) cmd_build $@ ;;
 212   pack) cmd_pack $@ ;;
 213   install) cmd_install $@ ;;
 214   *) usage; exit 1 ;;
 215 esac