Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1 | # functions-common - Common functions used by DevStack components |
| 2 | # |
| 3 | # The canonical copy of this file is maintained in the DevStack repo. |
| 4 | # All modifications should be made there and then sync'ed to other repos |
| 5 | # as required. |
| 6 | # |
| 7 | # This file is sorted alphabetically within the function groups. |
| 8 | # |
| 9 | # - Config Functions |
| 10 | # - Control Functions |
| 11 | # - Distro Functions |
| 12 | # - Git Functions |
| 13 | # - OpenStack Functions |
| 14 | # - Package Functions |
| 15 | # - Process Functions |
| 16 | # - Python Functions |
| 17 | # - Service Functions |
Masayuki Igawa | f6368d3 | 2014-02-20 13:31:26 +0900 | [diff] [blame] | 18 | # - System Functions |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 19 | # |
| 20 | # The following variables are assumed to be defined by certain functions: |
| 21 | # |
| 22 | # - ``ENABLED_SERVICES`` |
| 23 | # - ``ERROR_ON_CLONE`` |
| 24 | # - ``FILES`` |
| 25 | # - ``OFFLINE`` |
| 26 | # - ``PIP_DOWNLOAD_CACHE`` |
| 27 | # - ``PIP_USE_MIRRORS`` |
| 28 | # - ``RECLONE`` |
Masayuki Igawa | d20f632 | 2014-02-28 09:22:37 +0900 | [diff] [blame] | 29 | # - ``REQUIREMENTS_DIR`` |
| 30 | # - ``STACK_USER`` |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 31 | # - ``TRACK_DEPENDS`` |
Masayuki Igawa | d20f632 | 2014-02-28 09:22:37 +0900 | [diff] [blame] | 32 | # - ``UNDO_REQUIREMENTS`` |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 33 | # - ``http_proxy``, ``https_proxy``, ``no_proxy`` |
| 34 | |
| 35 | # Save trace setting |
| 36 | XTRACE=$(set +o | grep xtrace) |
| 37 | set +o xtrace |
| 38 | |
| 39 | |
| 40 | # Config Functions |
| 41 | # ================ |
| 42 | |
| 43 | # Append a new option in an ini file without replacing the old value |
| 44 | # iniadd config-file section option value1 value2 value3 ... |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 45 | function iniadd { |
Sean Dague | 45917cc | 2014-02-24 16:09:14 -0500 | [diff] [blame] | 46 | local xtrace=$(set +o | grep xtrace) |
| 47 | set +o xtrace |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 48 | local file=$1 |
| 49 | local section=$2 |
| 50 | local option=$3 |
| 51 | shift 3 |
| 52 | local values="$(iniget_multiline $file $section $option) $@" |
| 53 | iniset_multiline $file $section $option $values |
Sean Dague | 45917cc | 2014-02-24 16:09:14 -0500 | [diff] [blame] | 54 | $xtrace |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 55 | } |
| 56 | |
| 57 | # Comment an option in an INI file |
| 58 | # inicomment config-file section option |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 59 | function inicomment { |
Sean Dague | 45917cc | 2014-02-24 16:09:14 -0500 | [diff] [blame] | 60 | local xtrace=$(set +o | grep xtrace) |
| 61 | set +o xtrace |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 62 | local file=$1 |
| 63 | local section=$2 |
| 64 | local option=$3 |
| 65 | sed -i -e "/^\[$section\]/,/^\[.*\]/ s|^\($option[ \t]*=.*$\)|#\1|" "$file" |
Sean Dague | 45917cc | 2014-02-24 16:09:14 -0500 | [diff] [blame] | 66 | $xtrace |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 67 | } |
| 68 | |
| 69 | # Get an option from an INI file |
| 70 | # iniget config-file section option |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 71 | function iniget { |
Sean Dague | 45917cc | 2014-02-24 16:09:14 -0500 | [diff] [blame] | 72 | local xtrace=$(set +o | grep xtrace) |
| 73 | set +o xtrace |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 74 | local file=$1 |
| 75 | local section=$2 |
| 76 | local option=$3 |
| 77 | local line |
| 78 | line=$(sed -ne "/^\[$section\]/,/^\[.*\]/ { /^$option[ \t]*=/ p; }" "$file") |
| 79 | echo ${line#*=} |
Sean Dague | 45917cc | 2014-02-24 16:09:14 -0500 | [diff] [blame] | 80 | $xtrace |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 81 | } |
| 82 | |
| 83 | # Get a multiple line option from an INI file |
| 84 | # iniget_multiline config-file section option |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 85 | function iniget_multiline { |
Sean Dague | 45917cc | 2014-02-24 16:09:14 -0500 | [diff] [blame] | 86 | local xtrace=$(set +o | grep xtrace) |
| 87 | set +o xtrace |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 88 | local file=$1 |
| 89 | local section=$2 |
| 90 | local option=$3 |
| 91 | local values |
| 92 | values=$(sed -ne "/^\[$section\]/,/^\[.*\]/ { s/^$option[ \t]*=[ \t]*//gp; }" "$file") |
| 93 | echo ${values} |
Sean Dague | 45917cc | 2014-02-24 16:09:14 -0500 | [diff] [blame] | 94 | $xtrace |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 95 | } |
| 96 | |
| 97 | # Determinate is the given option present in the INI file |
| 98 | # ini_has_option config-file section option |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 99 | function ini_has_option { |
Sean Dague | 45917cc | 2014-02-24 16:09:14 -0500 | [diff] [blame] | 100 | local xtrace=$(set +o | grep xtrace) |
| 101 | set +o xtrace |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 102 | local file=$1 |
| 103 | local section=$2 |
| 104 | local option=$3 |
| 105 | local line |
| 106 | line=$(sed -ne "/^\[$section\]/,/^\[.*\]/ { /^$option[ \t]*=/ p; }" "$file") |
Sean Dague | 45917cc | 2014-02-24 16:09:14 -0500 | [diff] [blame] | 107 | $xtrace |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 108 | [ -n "$line" ] |
| 109 | } |
| 110 | |
| 111 | # Set an option in an INI file |
| 112 | # iniset config-file section option value |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 113 | function iniset { |
Sean Dague | 45917cc | 2014-02-24 16:09:14 -0500 | [diff] [blame] | 114 | local xtrace=$(set +o | grep xtrace) |
| 115 | set +o xtrace |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 116 | local file=$1 |
| 117 | local section=$2 |
| 118 | local option=$3 |
| 119 | local value=$4 |
| 120 | |
| 121 | [[ -z $section || -z $option ]] && return |
| 122 | |
| 123 | if ! grep -q "^\[$section\]" "$file" 2>/dev/null; then |
| 124 | # Add section at the end |
| 125 | echo -e "\n[$section]" >>"$file" |
| 126 | fi |
| 127 | if ! ini_has_option "$file" "$section" "$option"; then |
| 128 | # Add it |
| 129 | sed -i -e "/^\[$section\]/ a\\ |
| 130 | $option = $value |
| 131 | " "$file" |
| 132 | else |
| 133 | local sep=$(echo -ne "\x01") |
| 134 | # Replace it |
| 135 | sed -i -e '/^\['${section}'\]/,/^\[.*\]/ s'${sep}'^\('${option}'[ \t]*=[ \t]*\).*$'${sep}'\1'"${value}"${sep} "$file" |
| 136 | fi |
Sean Dague | 45917cc | 2014-02-24 16:09:14 -0500 | [diff] [blame] | 137 | $xtrace |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 138 | } |
| 139 | |
| 140 | # Set a multiple line option in an INI file |
| 141 | # iniset_multiline config-file section option value1 value2 valu3 ... |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 142 | function iniset_multiline { |
Sean Dague | 45917cc | 2014-02-24 16:09:14 -0500 | [diff] [blame] | 143 | local xtrace=$(set +o | grep xtrace) |
| 144 | set +o xtrace |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 145 | local file=$1 |
| 146 | local section=$2 |
| 147 | local option=$3 |
| 148 | shift 3 |
| 149 | local values |
| 150 | for v in $@; do |
| 151 | # The later sed command inserts each new value in the line next to |
| 152 | # the section identifier, which causes the values to be inserted in |
| 153 | # the reverse order. Do a reverse here to keep the original order. |
| 154 | values="$v ${values}" |
| 155 | done |
| 156 | if ! grep -q "^\[$section\]" "$file"; then |
| 157 | # Add section at the end |
| 158 | echo -e "\n[$section]" >>"$file" |
| 159 | else |
| 160 | # Remove old values |
| 161 | sed -i -e "/^\[$section\]/,/^\[.*\]/ { /^$option[ \t]*=/ d; }" "$file" |
| 162 | fi |
| 163 | # Add new ones |
| 164 | for v in $values; do |
| 165 | sed -i -e "/^\[$section\]/ a\\ |
| 166 | $option = $v |
| 167 | " "$file" |
| 168 | done |
Sean Dague | 45917cc | 2014-02-24 16:09:14 -0500 | [diff] [blame] | 169 | $xtrace |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 170 | } |
| 171 | |
| 172 | # Uncomment an option in an INI file |
| 173 | # iniuncomment config-file section option |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 174 | function iniuncomment { |
Sean Dague | 45917cc | 2014-02-24 16:09:14 -0500 | [diff] [blame] | 175 | local xtrace=$(set +o | grep xtrace) |
| 176 | set +o xtrace |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 177 | local file=$1 |
| 178 | local section=$2 |
| 179 | local option=$3 |
| 180 | sed -i -e "/^\[$section\]/,/^\[.*\]/ s|[^ \t]*#[ \t]*\($option[ \t]*=.*$\)|\1|" "$file" |
Sean Dague | 45917cc | 2014-02-24 16:09:14 -0500 | [diff] [blame] | 181 | $xtrace |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 182 | } |
| 183 | |
| 184 | # Normalize config values to True or False |
| 185 | # Accepts as False: 0 no No NO false False FALSE |
| 186 | # Accepts as True: 1 yes Yes YES true True TRUE |
| 187 | # VAR=$(trueorfalse default-value test-value) |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 188 | function trueorfalse { |
Sean Dague | 45917cc | 2014-02-24 16:09:14 -0500 | [diff] [blame] | 189 | local xtrace=$(set +o | grep xtrace) |
| 190 | set +o xtrace |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 191 | local default=$1 |
| 192 | local testval=$2 |
| 193 | |
| 194 | [[ -z "$testval" ]] && { echo "$default"; return; } |
| 195 | [[ "0 no No NO false False FALSE" =~ "$testval" ]] && { echo "False"; return; } |
| 196 | [[ "1 yes Yes YES true True TRUE" =~ "$testval" ]] && { echo "True"; return; } |
| 197 | echo "$default" |
Sean Dague | 45917cc | 2014-02-24 16:09:14 -0500 | [diff] [blame] | 198 | $xtrace |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 199 | } |
| 200 | |
| 201 | |
| 202 | # Control Functions |
| 203 | # ================= |
| 204 | |
| 205 | # Prints backtrace info |
| 206 | # filename:lineno:function |
| 207 | # backtrace level |
| 208 | function backtrace { |
| 209 | local level=$1 |
| 210 | local deep=$((${#BASH_SOURCE[@]} - 1)) |
| 211 | echo "[Call Trace]" |
| 212 | while [ $level -le $deep ]; do |
| 213 | echo "${BASH_SOURCE[$deep]}:${BASH_LINENO[$deep-1]}:${FUNCNAME[$deep-1]}" |
| 214 | deep=$((deep - 1)) |
| 215 | done |
| 216 | } |
| 217 | |
| 218 | # Prints line number and "message" then exits |
| 219 | # die $LINENO "message" |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 220 | function die { |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 221 | local exitcode=$? |
| 222 | set +o xtrace |
| 223 | local line=$1; shift |
| 224 | if [ $exitcode == 0 ]; then |
| 225 | exitcode=1 |
| 226 | fi |
| 227 | backtrace 2 |
| 228 | err $line "$*" |
Dean Troyer | a25a6f6 | 2014-02-24 16:03:41 -0600 | [diff] [blame] | 229 | # Give buffers a second to flush |
| 230 | sleep 1 |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 231 | exit $exitcode |
| 232 | } |
| 233 | |
| 234 | # Checks an environment variable is not set or has length 0 OR if the |
| 235 | # exit code is non-zero and prints "message" and exits |
| 236 | # NOTE: env-var is the variable name without a '$' |
| 237 | # die_if_not_set $LINENO env-var "message" |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 238 | function die_if_not_set { |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 239 | local exitcode=$? |
| 240 | FXTRACE=$(set +o | grep xtrace) |
| 241 | set +o xtrace |
| 242 | local line=$1; shift |
| 243 | local evar=$1; shift |
| 244 | if ! is_set $evar || [ $exitcode != 0 ]; then |
| 245 | die $line "$*" |
| 246 | fi |
| 247 | $FXTRACE |
| 248 | } |
| 249 | |
| 250 | # Prints line number and "message" in error format |
| 251 | # err $LINENO "message" |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 252 | function err { |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 253 | local exitcode=$? |
| 254 | errXTRACE=$(set +o | grep xtrace) |
| 255 | set +o xtrace |
| 256 | local msg="[ERROR] ${BASH_SOURCE[2]}:$1 $2" |
| 257 | echo $msg 1>&2; |
| 258 | if [[ -n ${SCREEN_LOGDIR} ]]; then |
| 259 | echo $msg >> "${SCREEN_LOGDIR}/error.log" |
| 260 | fi |
| 261 | $errXTRACE |
| 262 | return $exitcode |
| 263 | } |
| 264 | |
| 265 | # Checks an environment variable is not set or has length 0 OR if the |
| 266 | # exit code is non-zero and prints "message" |
| 267 | # NOTE: env-var is the variable name without a '$' |
| 268 | # err_if_not_set $LINENO env-var "message" |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 269 | function err_if_not_set { |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 270 | local exitcode=$? |
| 271 | errinsXTRACE=$(set +o | grep xtrace) |
| 272 | set +o xtrace |
| 273 | local line=$1; shift |
| 274 | local evar=$1; shift |
| 275 | if ! is_set $evar || [ $exitcode != 0 ]; then |
| 276 | err $line "$*" |
| 277 | fi |
| 278 | $errinsXTRACE |
| 279 | return $exitcode |
| 280 | } |
| 281 | |
| 282 | # Exit after outputting a message about the distribution not being supported. |
| 283 | # exit_distro_not_supported [optional-string-telling-what-is-missing] |
| 284 | function exit_distro_not_supported { |
| 285 | if [[ -z "$DISTRO" ]]; then |
| 286 | GetDistro |
| 287 | fi |
| 288 | |
| 289 | if [ $# -gt 0 ]; then |
| 290 | die $LINENO "Support for $DISTRO is incomplete: no support for $@" |
| 291 | else |
| 292 | die $LINENO "Support for $DISTRO is incomplete." |
| 293 | fi |
| 294 | } |
| 295 | |
| 296 | # Test if the named environment variable is set and not zero length |
| 297 | # is_set env-var |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 298 | function is_set { |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 299 | local var=\$"$1" |
| 300 | eval "[ -n \"$var\" ]" # For ex.: sh -c "[ -n \"$var\" ]" would be better, but several exercises depends on this |
| 301 | } |
| 302 | |
| 303 | # Prints line number and "message" in warning format |
| 304 | # warn $LINENO "message" |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 305 | function warn { |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 306 | local exitcode=$? |
| 307 | errXTRACE=$(set +o | grep xtrace) |
| 308 | set +o xtrace |
| 309 | local msg="[WARNING] ${BASH_SOURCE[2]}:$1 $2" |
| 310 | echo $msg 1>&2; |
| 311 | if [[ -n ${SCREEN_LOGDIR} ]]; then |
| 312 | echo $msg >> "${SCREEN_LOGDIR}/error.log" |
| 313 | fi |
| 314 | $errXTRACE |
| 315 | return $exitcode |
| 316 | } |
| 317 | |
| 318 | |
| 319 | # Distro Functions |
| 320 | # ================ |
| 321 | |
| 322 | # Determine OS Vendor, Release and Update |
| 323 | # Tested with OS/X, Ubuntu, RedHat, CentOS, Fedora |
| 324 | # Returns results in global variables: |
| 325 | # os_VENDOR - vendor name |
| 326 | # os_RELEASE - release |
| 327 | # os_UPDATE - update |
| 328 | # os_PACKAGE - package type |
| 329 | # os_CODENAME - vendor's codename for release |
| 330 | # GetOSVersion |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 331 | function GetOSVersion { |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 332 | # Figure out which vendor we are |
| 333 | if [[ -x "`which sw_vers 2>/dev/null`" ]]; then |
| 334 | # OS/X |
| 335 | os_VENDOR=`sw_vers -productName` |
| 336 | os_RELEASE=`sw_vers -productVersion` |
| 337 | os_UPDATE=${os_RELEASE##*.} |
| 338 | os_RELEASE=${os_RELEASE%.*} |
| 339 | os_PACKAGE="" |
| 340 | if [[ "$os_RELEASE" =~ "10.7" ]]; then |
| 341 | os_CODENAME="lion" |
| 342 | elif [[ "$os_RELEASE" =~ "10.6" ]]; then |
| 343 | os_CODENAME="snow leopard" |
| 344 | elif [[ "$os_RELEASE" =~ "10.5" ]]; then |
| 345 | os_CODENAME="leopard" |
| 346 | elif [[ "$os_RELEASE" =~ "10.4" ]]; then |
| 347 | os_CODENAME="tiger" |
| 348 | elif [[ "$os_RELEASE" =~ "10.3" ]]; then |
| 349 | os_CODENAME="panther" |
| 350 | else |
| 351 | os_CODENAME="" |
| 352 | fi |
| 353 | elif [[ -x $(which lsb_release 2>/dev/null) ]]; then |
| 354 | os_VENDOR=$(lsb_release -i -s) |
| 355 | os_RELEASE=$(lsb_release -r -s) |
| 356 | os_UPDATE="" |
| 357 | os_PACKAGE="rpm" |
| 358 | if [[ "Debian,Ubuntu,LinuxMint" =~ $os_VENDOR ]]; then |
| 359 | os_PACKAGE="deb" |
| 360 | elif [[ "SUSE LINUX" =~ $os_VENDOR ]]; then |
| 361 | lsb_release -d -s | grep -q openSUSE |
| 362 | if [[ $? -eq 0 ]]; then |
| 363 | os_VENDOR="openSUSE" |
| 364 | fi |
| 365 | elif [[ $os_VENDOR == "openSUSE project" ]]; then |
| 366 | os_VENDOR="openSUSE" |
| 367 | elif [[ $os_VENDOR =~ Red.*Hat ]]; then |
| 368 | os_VENDOR="Red Hat" |
| 369 | fi |
| 370 | os_CODENAME=$(lsb_release -c -s) |
| 371 | elif [[ -r /etc/redhat-release ]]; then |
| 372 | # Red Hat Enterprise Linux Server release 5.5 (Tikanga) |
| 373 | # Red Hat Enterprise Linux Server release 7.0 Beta (Maipo) |
| 374 | # CentOS release 5.5 (Final) |
| 375 | # CentOS Linux release 6.0 (Final) |
| 376 | # Fedora release 16 (Verne) |
| 377 | # XenServer release 6.2.0-70446c (xenenterprise) |
| 378 | os_CODENAME="" |
| 379 | for r in "Red Hat" CentOS Fedora XenServer; do |
| 380 | os_VENDOR=$r |
| 381 | if [[ -n "`grep \"$r\" /etc/redhat-release`" ]]; then |
| 382 | ver=`sed -e 's/^.* \([0-9].*\) (\(.*\)).*$/\1\|\2/' /etc/redhat-release` |
| 383 | os_CODENAME=${ver#*|} |
| 384 | os_RELEASE=${ver%|*} |
| 385 | os_UPDATE=${os_RELEASE##*.} |
| 386 | os_RELEASE=${os_RELEASE%.*} |
| 387 | break |
| 388 | fi |
| 389 | os_VENDOR="" |
| 390 | done |
| 391 | os_PACKAGE="rpm" |
| 392 | elif [[ -r /etc/SuSE-release ]]; then |
| 393 | for r in openSUSE "SUSE Linux"; do |
| 394 | if [[ "$r" = "SUSE Linux" ]]; then |
| 395 | os_VENDOR="SUSE LINUX" |
| 396 | else |
| 397 | os_VENDOR=$r |
| 398 | fi |
| 399 | |
| 400 | if [[ -n "`grep \"$r\" /etc/SuSE-release`" ]]; then |
| 401 | os_CODENAME=`grep "CODENAME = " /etc/SuSE-release | sed 's:.* = ::g'` |
| 402 | os_RELEASE=`grep "VERSION = " /etc/SuSE-release | sed 's:.* = ::g'` |
| 403 | os_UPDATE=`grep "PATCHLEVEL = " /etc/SuSE-release | sed 's:.* = ::g'` |
| 404 | break |
| 405 | fi |
| 406 | os_VENDOR="" |
| 407 | done |
| 408 | os_PACKAGE="rpm" |
| 409 | # If lsb_release is not installed, we should be able to detect Debian OS |
| 410 | elif [[ -f /etc/debian_version ]] && [[ $(cat /proc/version) =~ "Debian" ]]; then |
| 411 | os_VENDOR="Debian" |
| 412 | os_PACKAGE="deb" |
| 413 | os_CODENAME=$(awk '/VERSION=/' /etc/os-release | sed 's/VERSION=//' | sed -r 's/\"|\(|\)//g' | awk '{print $2}') |
| 414 | os_RELEASE=$(awk '/VERSION_ID=/' /etc/os-release | sed 's/VERSION_ID=//' | sed 's/\"//g') |
| 415 | fi |
| 416 | export os_VENDOR os_RELEASE os_UPDATE os_PACKAGE os_CODENAME |
| 417 | } |
| 418 | |
| 419 | # Translate the OS version values into common nomenclature |
| 420 | # Sets global ``DISTRO`` from the ``os_*`` values |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 421 | function GetDistro { |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 422 | GetOSVersion |
| 423 | if [[ "$os_VENDOR" =~ (Ubuntu) || "$os_VENDOR" =~ (Debian) ]]; then |
| 424 | # 'Everyone' refers to Ubuntu / Debian releases by the code name adjective |
| 425 | DISTRO=$os_CODENAME |
| 426 | elif [[ "$os_VENDOR" =~ (Fedora) ]]; then |
| 427 | # For Fedora, just use 'f' and the release |
| 428 | DISTRO="f$os_RELEASE" |
| 429 | elif [[ "$os_VENDOR" =~ (openSUSE) ]]; then |
| 430 | DISTRO="opensuse-$os_RELEASE" |
| 431 | elif [[ "$os_VENDOR" =~ (SUSE LINUX) ]]; then |
| 432 | # For SLE, also use the service pack |
| 433 | if [[ -z "$os_UPDATE" ]]; then |
| 434 | DISTRO="sle${os_RELEASE}" |
| 435 | else |
| 436 | DISTRO="sle${os_RELEASE}sp${os_UPDATE}" |
| 437 | fi |
| 438 | elif [[ "$os_VENDOR" =~ (Red Hat) || "$os_VENDOR" =~ (CentOS) ]]; then |
| 439 | # Drop the . release as we assume it's compatible |
| 440 | DISTRO="rhel${os_RELEASE::1}" |
| 441 | elif [[ "$os_VENDOR" =~ (XenServer) ]]; then |
| 442 | DISTRO="xs$os_RELEASE" |
| 443 | else |
| 444 | # Catch-all for now is Vendor + Release + Update |
| 445 | DISTRO="$os_VENDOR-$os_RELEASE.$os_UPDATE" |
| 446 | fi |
| 447 | export DISTRO |
| 448 | } |
| 449 | |
| 450 | # Utility function for checking machine architecture |
| 451 | # is_arch arch-type |
| 452 | function is_arch { |
| 453 | ARCH_TYPE=$1 |
| 454 | |
| 455 | [[ "$(uname -m)" == "$ARCH_TYPE" ]] |
| 456 | } |
| 457 | |
| 458 | # Determine if current distribution is a Fedora-based distribution |
| 459 | # (Fedora, RHEL, CentOS, etc). |
| 460 | # is_fedora |
| 461 | function is_fedora { |
| 462 | if [[ -z "$os_VENDOR" ]]; then |
| 463 | GetOSVersion |
| 464 | fi |
| 465 | |
| 466 | [ "$os_VENDOR" = "Fedora" ] || [ "$os_VENDOR" = "Red Hat" ] || [ "$os_VENDOR" = "CentOS" ] |
| 467 | } |
| 468 | |
| 469 | |
| 470 | # Determine if current distribution is a SUSE-based distribution |
| 471 | # (openSUSE, SLE). |
| 472 | # is_suse |
| 473 | function is_suse { |
| 474 | if [[ -z "$os_VENDOR" ]]; then |
| 475 | GetOSVersion |
| 476 | fi |
| 477 | |
| 478 | [ "$os_VENDOR" = "openSUSE" ] || [ "$os_VENDOR" = "SUSE LINUX" ] |
| 479 | } |
| 480 | |
| 481 | |
| 482 | # Determine if current distribution is an Ubuntu-based distribution |
| 483 | # It will also detect non-Ubuntu but Debian-based distros |
| 484 | # is_ubuntu |
| 485 | function is_ubuntu { |
| 486 | if [[ -z "$os_PACKAGE" ]]; then |
| 487 | GetOSVersion |
| 488 | fi |
| 489 | [ "$os_PACKAGE" = "deb" ] |
| 490 | } |
| 491 | |
| 492 | |
| 493 | # Git Functions |
| 494 | # ============= |
| 495 | |
Dean Troyer | abc7b1d | 2014-02-12 12:09:22 -0600 | [diff] [blame] | 496 | # Returns openstack release name for a given branch name |
| 497 | # ``get_release_name_from_branch branch-name`` |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 498 | function get_release_name_from_branch { |
Dean Troyer | abc7b1d | 2014-02-12 12:09:22 -0600 | [diff] [blame] | 499 | local branch=$1 |
| 500 | if [[ $branch =~ "stable/" ]]; then |
| 501 | echo ${branch#*/} |
| 502 | else |
| 503 | echo "master" |
| 504 | fi |
| 505 | } |
| 506 | |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 507 | # git clone only if directory doesn't exist already. Since ``DEST`` might not |
| 508 | # be owned by the installation user, we create the directory and change the |
| 509 | # ownership to the proper user. |
| 510 | # Set global RECLONE=yes to simulate a clone when dest-dir exists |
| 511 | # Set global ERROR_ON_CLONE=True to abort execution with an error if the git repo |
| 512 | # does not exist (default is False, meaning the repo will be cloned). |
| 513 | # Uses global ``OFFLINE`` |
| 514 | # git_clone remote dest-dir branch |
| 515 | function git_clone { |
| 516 | GIT_REMOTE=$1 |
| 517 | GIT_DEST=$2 |
| 518 | GIT_REF=$3 |
| 519 | RECLONE=$(trueorfalse False $RECLONE) |
Sean Dague | 64bd016 | 2014-03-12 13:04:22 -0400 | [diff] [blame] | 520 | local orig_dir=`pwd` |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 521 | |
| 522 | if [[ "$OFFLINE" = "True" ]]; then |
| 523 | echo "Running in offline mode, clones already exist" |
| 524 | # print out the results so we know what change was used in the logs |
| 525 | cd $GIT_DEST |
| 526 | git show --oneline | head -1 |
Sean Dague | 64bd016 | 2014-03-12 13:04:22 -0400 | [diff] [blame] | 527 | cd $orig_dir |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 528 | return |
| 529 | fi |
| 530 | |
| 531 | if echo $GIT_REF | egrep -q "^refs"; then |
| 532 | # If our branch name is a gerrit style refs/changes/... |
| 533 | if [[ ! -d $GIT_DEST ]]; then |
| 534 | [[ "$ERROR_ON_CLONE" = "True" ]] && \ |
| 535 | die $LINENO "Cloning not allowed in this configuration" |
Ian Wienand | d53ad0b | 2014-02-20 13:55:13 +1100 | [diff] [blame] | 536 | git_timed clone $GIT_REMOTE $GIT_DEST |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 537 | fi |
| 538 | cd $GIT_DEST |
Ian Wienand | d53ad0b | 2014-02-20 13:55:13 +1100 | [diff] [blame] | 539 | git_timed fetch $GIT_REMOTE $GIT_REF && git checkout FETCH_HEAD |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 540 | else |
| 541 | # do a full clone only if the directory doesn't exist |
| 542 | if [[ ! -d $GIT_DEST ]]; then |
| 543 | [[ "$ERROR_ON_CLONE" = "True" ]] && \ |
| 544 | die $LINENO "Cloning not allowed in this configuration" |
Ian Wienand | d53ad0b | 2014-02-20 13:55:13 +1100 | [diff] [blame] | 545 | git_timed clone $GIT_REMOTE $GIT_DEST |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 546 | cd $GIT_DEST |
| 547 | # This checkout syntax works for both branches and tags |
| 548 | git checkout $GIT_REF |
| 549 | elif [[ "$RECLONE" = "True" ]]; then |
| 550 | # if it does exist then simulate what clone does if asked to RECLONE |
| 551 | cd $GIT_DEST |
| 552 | # set the url to pull from and fetch |
| 553 | git remote set-url origin $GIT_REMOTE |
Ian Wienand | d53ad0b | 2014-02-20 13:55:13 +1100 | [diff] [blame] | 554 | git_timed fetch origin |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 555 | # remove the existing ignored files (like pyc) as they cause breakage |
| 556 | # (due to the py files having older timestamps than our pyc, so python |
| 557 | # thinks the pyc files are correct using them) |
| 558 | find $GIT_DEST -name '*.pyc' -delete |
| 559 | |
| 560 | # handle GIT_REF accordingly to type (tag, branch) |
| 561 | if [[ -n "`git show-ref refs/tags/$GIT_REF`" ]]; then |
| 562 | git_update_tag $GIT_REF |
| 563 | elif [[ -n "`git show-ref refs/heads/$GIT_REF`" ]]; then |
| 564 | git_update_branch $GIT_REF |
| 565 | elif [[ -n "`git show-ref refs/remotes/origin/$GIT_REF`" ]]; then |
| 566 | git_update_remote_branch $GIT_REF |
| 567 | else |
| 568 | die $LINENO "$GIT_REF is neither branch nor tag" |
| 569 | fi |
| 570 | |
| 571 | fi |
| 572 | fi |
| 573 | |
| 574 | # print out the results so we know what change was used in the logs |
| 575 | cd $GIT_DEST |
| 576 | git show --oneline | head -1 |
Sean Dague | 64bd016 | 2014-03-12 13:04:22 -0400 | [diff] [blame] | 577 | cd $orig_dir |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 578 | } |
| 579 | |
Ian Wienand | d53ad0b | 2014-02-20 13:55:13 +1100 | [diff] [blame] | 580 | # git can sometimes get itself infinitely stuck with transient network |
| 581 | # errors or other issues with the remote end. This wraps git in a |
| 582 | # timeout/retry loop and is intended to watch over non-local git |
| 583 | # processes that might hang. GIT_TIMEOUT, if set, is passed directly |
| 584 | # to timeout(1); otherwise the default value of 0 maintains the status |
| 585 | # quo of waiting forever. |
| 586 | # usage: git_timed <git-command> |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 587 | function git_timed { |
Ian Wienand | d53ad0b | 2014-02-20 13:55:13 +1100 | [diff] [blame] | 588 | local count=0 |
| 589 | local timeout=0 |
| 590 | |
| 591 | if [[ -n "${GIT_TIMEOUT}" ]]; then |
| 592 | timeout=${GIT_TIMEOUT} |
| 593 | fi |
| 594 | |
| 595 | until timeout -s SIGINT ${timeout} git "$@"; do |
| 596 | # 124 is timeout(1)'s special return code when it reached the |
| 597 | # timeout; otherwise assume fatal failure |
| 598 | if [[ $? -ne 124 ]]; then |
| 599 | die $LINENO "git call failed: [git $@]" |
| 600 | fi |
| 601 | |
| 602 | count=$(($count + 1)) |
| 603 | warn "timeout ${count} for git call: [git $@]" |
| 604 | if [ $count -eq 3 ]; then |
| 605 | die $LINENO "Maximum of 3 git retries reached" |
| 606 | fi |
| 607 | sleep 5 |
| 608 | done |
| 609 | } |
| 610 | |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 611 | # git update using reference as a branch. |
| 612 | # git_update_branch ref |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 613 | function git_update_branch { |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 614 | |
| 615 | GIT_BRANCH=$1 |
| 616 | |
| 617 | git checkout -f origin/$GIT_BRANCH |
| 618 | # a local branch might not exist |
| 619 | git branch -D $GIT_BRANCH || true |
| 620 | git checkout -b $GIT_BRANCH |
| 621 | } |
| 622 | |
| 623 | # git update using reference as a branch. |
| 624 | # git_update_remote_branch ref |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 625 | function git_update_remote_branch { |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 626 | |
| 627 | GIT_BRANCH=$1 |
| 628 | |
| 629 | git checkout -b $GIT_BRANCH -t origin/$GIT_BRANCH |
| 630 | } |
| 631 | |
| 632 | # git update using reference as a tag. Be careful editing source at that repo |
| 633 | # as working copy will be in a detached mode |
| 634 | # git_update_tag ref |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 635 | function git_update_tag { |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 636 | |
| 637 | GIT_TAG=$1 |
| 638 | |
| 639 | git tag -d $GIT_TAG |
| 640 | # fetching given tag only |
Ian Wienand | d53ad0b | 2014-02-20 13:55:13 +1100 | [diff] [blame] | 641 | git_timed fetch origin tag $GIT_TAG |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 642 | git checkout -f $GIT_TAG |
| 643 | } |
| 644 | |
| 645 | |
| 646 | # OpenStack Functions |
| 647 | # =================== |
| 648 | |
| 649 | # Get the default value for HOST_IP |
| 650 | # get_default_host_ip fixed_range floating_range host_ip_iface host_ip |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 651 | function get_default_host_ip { |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 652 | local fixed_range=$1 |
| 653 | local floating_range=$2 |
| 654 | local host_ip_iface=$3 |
| 655 | local host_ip=$4 |
| 656 | |
| 657 | # Find the interface used for the default route |
| 658 | host_ip_iface=${host_ip_iface:-$(ip route | sed -n '/^default/{ s/.*dev \(\w\+\)\s\+.*/\1/; p; }' | head -1)} |
| 659 | # Search for an IP unless an explicit is set by ``HOST_IP`` environment variable |
| 660 | if [ -z "$host_ip" -o "$host_ip" == "dhcp" ]; then |
| 661 | host_ip="" |
| 662 | host_ips=`LC_ALL=C ip -f inet addr show ${host_ip_iface} | awk '/inet/ {split($2,parts,"/"); print parts[1]}'` |
| 663 | for IP in $host_ips; do |
| 664 | # Attempt to filter out IP addresses that are part of the fixed and |
| 665 | # floating range. Note that this method only works if the ``netaddr`` |
| 666 | # python library is installed. If it is not installed, an error |
| 667 | # will be printed and the first IP from the interface will be used. |
| 668 | # If that is not correct set ``HOST_IP`` in ``localrc`` to the correct |
| 669 | # address. |
| 670 | if ! (address_in_net $IP $fixed_range || address_in_net $IP $floating_range); then |
| 671 | host_ip=$IP |
| 672 | break; |
| 673 | fi |
| 674 | done |
| 675 | fi |
| 676 | echo $host_ip |
| 677 | } |
| 678 | |
| 679 | # Grab a numbered field from python prettytable output |
| 680 | # Fields are numbered starting with 1 |
| 681 | # Reverse syntax is supported: -1 is the last field, -2 is second to last, etc. |
| 682 | # get_field field-number |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 683 | function get_field { |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 684 | while read data; do |
| 685 | if [ "$1" -lt 0 ]; then |
| 686 | field="(\$(NF$1))" |
| 687 | else |
| 688 | field="\$$(($1 + 1))" |
| 689 | fi |
| 690 | echo "$data" | awk -F'[ \t]*\\|[ \t]*' "{print $field}" |
| 691 | done |
| 692 | } |
| 693 | |
| 694 | # Add a policy to a policy.json file |
| 695 | # Do nothing if the policy already exists |
| 696 | # ``policy_add policy_file policy_name policy_permissions`` |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 697 | function policy_add { |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 698 | local policy_file=$1 |
| 699 | local policy_name=$2 |
| 700 | local policy_perm=$3 |
| 701 | |
| 702 | if grep -q ${policy_name} ${policy_file}; then |
| 703 | echo "Policy ${policy_name} already exists in ${policy_file}" |
| 704 | return |
| 705 | fi |
| 706 | |
| 707 | # Add a terminating comma to policy lines without one |
| 708 | # Remove the closing '}' and all lines following to the end-of-file |
| 709 | local tmpfile=$(mktemp) |
| 710 | uniq ${policy_file} | sed -e ' |
| 711 | s/]$/],/ |
| 712 | /^[}]/,$d |
| 713 | ' > ${tmpfile} |
| 714 | |
| 715 | # Append policy and closing brace |
| 716 | echo " \"${policy_name}\": ${policy_perm}" >>${tmpfile} |
| 717 | echo "}" >>${tmpfile} |
| 718 | |
| 719 | mv ${tmpfile} ${policy_file} |
| 720 | } |
| 721 | |
Bartosz Górski | 0abde39 | 2014-02-28 14:15:19 +0100 | [diff] [blame^] | 722 | # Gets or creates user |
| 723 | # Usage: get_or_create_user <username> <password> <project> <email> |
| 724 | function get_or_create_user { |
| 725 | # Gets user id |
| 726 | USER_ID=$( |
| 727 | # Gets user id |
| 728 | openstack user show $1 -f value -c id 2>/dev/null || |
| 729 | # Creates new user |
| 730 | openstack user create \ |
| 731 | $1 \ |
| 732 | --password "$2" \ |
| 733 | --project $3 \ |
| 734 | --email $4 \ |
| 735 | -f value -c id |
| 736 | ) |
| 737 | echo $USER_ID |
| 738 | } |
| 739 | |
| 740 | # Gets or creates project |
| 741 | # Usage: get_or_create_project <name> |
| 742 | function get_or_create_project { |
| 743 | # Gets project id |
| 744 | PROJECT_ID=$( |
| 745 | # Gets project id |
| 746 | openstack project show $1 -f value -c id 2>/dev/null || |
| 747 | # Creates new project if not exists |
| 748 | openstack project create $1 -f value -c id |
| 749 | ) |
| 750 | echo $PROJECT_ID |
| 751 | } |
| 752 | |
| 753 | # Gets or creates role |
| 754 | # Usage: get_or_create_role <name> |
| 755 | function get_or_create_role { |
| 756 | ROLE_ID=$( |
| 757 | # Gets role id |
| 758 | openstack role show $1 -f value -c id 2>/dev/null || |
| 759 | # Creates role if not exists |
| 760 | openstack role create $1 -f value -c id |
| 761 | ) |
| 762 | echo $ROLE_ID |
| 763 | } |
| 764 | |
| 765 | # Gets or adds user role |
| 766 | # Usage: get_or_add_user_role <role> <user> <project> |
| 767 | function get_or_add_user_role { |
| 768 | # Gets user role id |
| 769 | USER_ROLE_ID=$(openstack user role list \ |
| 770 | $2 \ |
| 771 | --project $3 \ |
| 772 | --column "ID" \ |
| 773 | --column "Name" \ |
| 774 | | grep " $1 " | get_field 1) |
| 775 | if [[ -z "$USER_ROLE_ID" ]]; then |
| 776 | # Adds role to user |
| 777 | USER_ROLE_ID=$(openstack role add \ |
| 778 | $1 \ |
| 779 | --user $2 \ |
| 780 | --project $3 \ |
| 781 | | grep " id " | get_field 2) |
| 782 | fi |
| 783 | echo $USER_ROLE_ID |
| 784 | } |
| 785 | |
| 786 | # Gets or creates service |
| 787 | # Usage: get_or_create_service <name> <type> <description> |
| 788 | function get_or_create_service { |
| 789 | # Gets service id |
| 790 | SERVICE_ID=$( |
| 791 | # Gets service id |
| 792 | openstack service show $1 -f value -c id 2>/dev/null || |
| 793 | # Creates new service if not exists |
| 794 | openstack service create \ |
| 795 | $1 \ |
| 796 | --type=$2 \ |
| 797 | --description="$3" \ |
| 798 | -f value -c id |
| 799 | ) |
| 800 | echo $SERVICE_ID |
| 801 | } |
| 802 | |
| 803 | # Gets or creates endpoint |
| 804 | # Usage: get_or_create_endpoint <service> <region> <publicurl> <adminurl> <internalurl> |
| 805 | function get_or_create_endpoint { |
| 806 | # Gets endpoint id |
| 807 | ENDPOINT_ID=$(openstack endpoint list \ |
| 808 | --column "ID" \ |
| 809 | --column "Region" \ |
| 810 | --column "Service Name" \ |
| 811 | | grep " $2 " \ |
| 812 | | grep " $1 " | get_field 1) |
| 813 | if [[ -z "$ENDPOINT_ID" ]]; then |
| 814 | # Creates new endpoint |
| 815 | ENDPOINT_ID=$(openstack endpoint create \ |
| 816 | $1 \ |
| 817 | --region $2 \ |
| 818 | --publicurl $3 \ |
| 819 | --adminurl $4 \ |
| 820 | --internalurl $5 \ |
| 821 | | grep " id " | get_field 2) |
| 822 | fi |
| 823 | echo $ENDPOINT_ID |
| 824 | } |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 825 | |
| 826 | # Package Functions |
| 827 | # ================= |
| 828 | |
| 829 | # _get_package_dir |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 830 | function _get_package_dir { |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 831 | local pkg_dir |
| 832 | if is_ubuntu; then |
| 833 | pkg_dir=$FILES/apts |
| 834 | elif is_fedora; then |
| 835 | pkg_dir=$FILES/rpms |
| 836 | elif is_suse; then |
| 837 | pkg_dir=$FILES/rpms-suse |
| 838 | else |
| 839 | exit_distro_not_supported "list of packages" |
| 840 | fi |
| 841 | echo "$pkg_dir" |
| 842 | } |
| 843 | |
| 844 | # Wrapper for ``apt-get`` to set cache and proxy environment variables |
| 845 | # Uses globals ``OFFLINE``, ``*_proxy`` |
| 846 | # apt_get operation package [package ...] |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 847 | function apt_get { |
Sean Dague | 45917cc | 2014-02-24 16:09:14 -0500 | [diff] [blame] | 848 | local xtrace=$(set +o | grep xtrace) |
| 849 | set +o xtrace |
| 850 | |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 851 | [[ "$OFFLINE" = "True" || -z "$@" ]] && return |
| 852 | local sudo="sudo" |
| 853 | [[ "$(id -u)" = "0" ]] && sudo="env" |
Sean Dague | 45917cc | 2014-02-24 16:09:14 -0500 | [diff] [blame] | 854 | |
| 855 | $xtrace |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 856 | $sudo DEBIAN_FRONTEND=noninteractive \ |
| 857 | http_proxy=$http_proxy https_proxy=$https_proxy \ |
| 858 | no_proxy=$no_proxy \ |
| 859 | apt-get --option "Dpkg::Options::=--force-confold" --assume-yes "$@" |
| 860 | } |
| 861 | |
| 862 | # get_packages() collects a list of package names of any type from the |
| 863 | # prerequisite files in ``files/{apts|rpms}``. The list is intended |
| 864 | # to be passed to a package installer such as apt or yum. |
| 865 | # |
| 866 | # Only packages required for the services in 1st argument will be |
| 867 | # included. Two bits of metadata are recognized in the prerequisite files: |
| 868 | # |
| 869 | # - ``# NOPRIME`` defers installation to be performed later in `stack.sh` |
| 870 | # - ``# dist:DISTRO`` or ``dist:DISTRO1,DISTRO2`` limits the selection |
| 871 | # of the package to the distros listed. The distro names are case insensitive. |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 872 | function get_packages { |
Sean Dague | 45917cc | 2014-02-24 16:09:14 -0500 | [diff] [blame] | 873 | local xtrace=$(set +o | grep xtrace) |
| 874 | set +o xtrace |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 875 | local services=$@ |
| 876 | local package_dir=$(_get_package_dir) |
| 877 | local file_to_parse |
| 878 | local service |
| 879 | |
| 880 | if [[ -z "$package_dir" ]]; then |
| 881 | echo "No package directory supplied" |
| 882 | return 1 |
| 883 | fi |
| 884 | if [[ -z "$DISTRO" ]]; then |
| 885 | GetDistro |
Sean Dague | 45917cc | 2014-02-24 16:09:14 -0500 | [diff] [blame] | 886 | echo "Found Distro $DISTRO" |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 887 | fi |
| 888 | for service in ${services//,/ }; do |
| 889 | # Allow individual services to specify dependencies |
| 890 | if [[ -e ${package_dir}/${service} ]]; then |
| 891 | file_to_parse="${file_to_parse} $service" |
| 892 | fi |
| 893 | # NOTE(sdague) n-api needs glance for now because that's where |
| 894 | # glance client is |
| 895 | if [[ $service == n-api ]]; then |
| 896 | if [[ ! $file_to_parse =~ nova ]]; then |
| 897 | file_to_parse="${file_to_parse} nova" |
| 898 | fi |
| 899 | if [[ ! $file_to_parse =~ glance ]]; then |
| 900 | file_to_parse="${file_to_parse} glance" |
| 901 | fi |
| 902 | elif [[ $service == c-* ]]; then |
| 903 | if [[ ! $file_to_parse =~ cinder ]]; then |
| 904 | file_to_parse="${file_to_parse} cinder" |
| 905 | fi |
| 906 | elif [[ $service == ceilometer-* ]]; then |
| 907 | if [[ ! $file_to_parse =~ ceilometer ]]; then |
| 908 | file_to_parse="${file_to_parse} ceilometer" |
| 909 | fi |
| 910 | elif [[ $service == s-* ]]; then |
| 911 | if [[ ! $file_to_parse =~ swift ]]; then |
| 912 | file_to_parse="${file_to_parse} swift" |
| 913 | fi |
| 914 | elif [[ $service == n-* ]]; then |
| 915 | if [[ ! $file_to_parse =~ nova ]]; then |
| 916 | file_to_parse="${file_to_parse} nova" |
| 917 | fi |
| 918 | elif [[ $service == g-* ]]; then |
| 919 | if [[ ! $file_to_parse =~ glance ]]; then |
| 920 | file_to_parse="${file_to_parse} glance" |
| 921 | fi |
| 922 | elif [[ $service == key* ]]; then |
| 923 | if [[ ! $file_to_parse =~ keystone ]]; then |
| 924 | file_to_parse="${file_to_parse} keystone" |
| 925 | fi |
| 926 | elif [[ $service == q-* ]]; then |
| 927 | if [[ ! $file_to_parse =~ neutron ]]; then |
| 928 | file_to_parse="${file_to_parse} neutron" |
| 929 | fi |
Adam Gandelman | 539ec43 | 2014-03-18 18:57:43 -0700 | [diff] [blame] | 930 | elif [[ $service == ir-* ]]; then |
| 931 | if [[ ! $file_to_parse =~ ironic ]]; then |
| 932 | file_to_parse="${file_to_parse} ironic" |
| 933 | fi |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 934 | fi |
| 935 | done |
| 936 | |
| 937 | for file in ${file_to_parse}; do |
| 938 | local fname=${package_dir}/${file} |
| 939 | local OIFS line package distros distro |
| 940 | [[ -e $fname ]] || continue |
| 941 | |
| 942 | OIFS=$IFS |
| 943 | IFS=$'\n' |
| 944 | for line in $(<${fname}); do |
| 945 | if [[ $line =~ "NOPRIME" ]]; then |
| 946 | continue |
| 947 | fi |
| 948 | |
| 949 | # Assume we want this package |
| 950 | package=${line%#*} |
| 951 | inst_pkg=1 |
| 952 | |
| 953 | # Look for # dist:xxx in comment |
| 954 | if [[ $line =~ (.*)#.*dist:([^ ]*) ]]; then |
| 955 | # We are using BASH regexp matching feature. |
| 956 | package=${BASH_REMATCH[1]} |
| 957 | distros=${BASH_REMATCH[2]} |
| 958 | # In bash ${VAR,,} will lowecase VAR |
| 959 | # Look for a match in the distro list |
| 960 | if [[ ! ${distros,,} =~ ${DISTRO,,} ]]; then |
| 961 | # If no match then skip this package |
| 962 | inst_pkg=0 |
| 963 | fi |
| 964 | fi |
| 965 | |
| 966 | # Look for # testonly in comment |
| 967 | if [[ $line =~ (.*)#.*testonly.* ]]; then |
| 968 | package=${BASH_REMATCH[1]} |
| 969 | # Are we installing test packages? (test for the default value) |
| 970 | if [[ $INSTALL_TESTONLY_PACKAGES = "False" ]]; then |
| 971 | # If not installing test packages the skip this package |
| 972 | inst_pkg=0 |
| 973 | fi |
| 974 | fi |
| 975 | |
| 976 | if [[ $inst_pkg = 1 ]]; then |
| 977 | echo $package |
| 978 | fi |
| 979 | done |
| 980 | IFS=$OIFS |
| 981 | done |
Sean Dague | 45917cc | 2014-02-24 16:09:14 -0500 | [diff] [blame] | 982 | $xtrace |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 983 | } |
| 984 | |
| 985 | # Distro-agnostic package installer |
| 986 | # install_package package [package ...] |
Monty Taylor | 5cc6d2c | 2014-06-06 08:45:16 -0400 | [diff] [blame] | 987 | function update_package_repo { |
| 988 | if [[ "NO_UPDATE_REPOS" = "True" ]]; then |
| 989 | return 0 |
| 990 | fi |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 991 | |
Monty Taylor | 5cc6d2c | 2014-06-06 08:45:16 -0400 | [diff] [blame] | 992 | if is_ubuntu; then |
| 993 | local xtrace=$(set +o | grep xtrace) |
| 994 | set +o xtrace |
| 995 | if [[ "$REPOS_UPDATED" != "True" || "$RETRY_UPDATE" = "True" ]]; then |
| 996 | # if there are transient errors pulling the updates, that's fine. |
| 997 | # It may be secondary repositories that we don't really care about. |
| 998 | apt_get update || /bin/true |
| 999 | REPOS_UPDATED=True |
| 1000 | fi |
Sean Dague | 45917cc | 2014-02-24 16:09:14 -0500 | [diff] [blame] | 1001 | $xtrace |
Monty Taylor | 5cc6d2c | 2014-06-06 08:45:16 -0400 | [diff] [blame] | 1002 | fi |
| 1003 | } |
| 1004 | |
| 1005 | function real_install_package { |
| 1006 | if is_ubuntu; then |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1007 | apt_get install "$@" |
| 1008 | elif is_fedora; then |
| 1009 | yum_install "$@" |
| 1010 | elif is_suse; then |
| 1011 | zypper_install "$@" |
| 1012 | else |
| 1013 | exit_distro_not_supported "installing packages" |
| 1014 | fi |
| 1015 | } |
| 1016 | |
Monty Taylor | 5cc6d2c | 2014-06-06 08:45:16 -0400 | [diff] [blame] | 1017 | # Distro-agnostic package installer |
| 1018 | # install_package package [package ...] |
| 1019 | function install_package { |
| 1020 | update_package_repo |
| 1021 | real_install_package $@ || RETRY_UPDATE=True update_package_repo && real_install_package $@ |
| 1022 | } |
| 1023 | |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1024 | # Distro-agnostic function to tell if a package is installed |
| 1025 | # is_package_installed package [package ...] |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 1026 | function is_package_installed { |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1027 | if [[ -z "$@" ]]; then |
| 1028 | return 1 |
| 1029 | fi |
| 1030 | |
| 1031 | if [[ -z "$os_PACKAGE" ]]; then |
| 1032 | GetOSVersion |
| 1033 | fi |
| 1034 | |
| 1035 | if [[ "$os_PACKAGE" = "deb" ]]; then |
| 1036 | dpkg -s "$@" > /dev/null 2> /dev/null |
| 1037 | elif [[ "$os_PACKAGE" = "rpm" ]]; then |
| 1038 | rpm --quiet -q "$@" |
| 1039 | else |
| 1040 | exit_distro_not_supported "finding if a package is installed" |
| 1041 | fi |
| 1042 | } |
| 1043 | |
| 1044 | # Distro-agnostic package uninstaller |
| 1045 | # uninstall_package package [package ...] |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 1046 | function uninstall_package { |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1047 | if is_ubuntu; then |
| 1048 | apt_get purge "$@" |
| 1049 | elif is_fedora; then |
| 1050 | sudo yum remove -y "$@" |
| 1051 | elif is_suse; then |
| 1052 | sudo zypper rm "$@" |
| 1053 | else |
| 1054 | exit_distro_not_supported "uninstalling packages" |
| 1055 | fi |
| 1056 | } |
| 1057 | |
| 1058 | # Wrapper for ``yum`` to set proxy environment variables |
| 1059 | # Uses globals ``OFFLINE``, ``*_proxy`` |
| 1060 | # yum_install package [package ...] |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 1061 | function yum_install { |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1062 | [[ "$OFFLINE" = "True" ]] && return |
| 1063 | local sudo="sudo" |
| 1064 | [[ "$(id -u)" = "0" ]] && sudo="env" |
Ian Wienand | b27f16d | 2014-02-28 14:29:02 +1100 | [diff] [blame] | 1065 | |
| 1066 | # The manual check for missing packages is because yum -y assumes |
| 1067 | # missing packages are OK. See |
| 1068 | # https://bugzilla.redhat.com/show_bug.cgi?id=965567 |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1069 | $sudo http_proxy=$http_proxy https_proxy=$https_proxy \ |
| 1070 | no_proxy=$no_proxy \ |
Ian Wienand | b27f16d | 2014-02-28 14:29:02 +1100 | [diff] [blame] | 1071 | yum install -y "$@" 2>&1 | \ |
| 1072 | awk ' |
| 1073 | BEGIN { fail=0 } |
| 1074 | /No package/ { fail=1 } |
| 1075 | { print } |
| 1076 | END { exit fail }' || \ |
| 1077 | die $LINENO "Missing packages detected" |
| 1078 | |
| 1079 | # also ensure we catch a yum failure |
| 1080 | if [[ ${PIPESTATUS[0]} != 0 ]]; then |
| 1081 | die $LINENO "Yum install failure" |
| 1082 | fi |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1083 | } |
| 1084 | |
| 1085 | # zypper wrapper to set arguments correctly |
| 1086 | # zypper_install package [package ...] |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 1087 | function zypper_install { |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1088 | [[ "$OFFLINE" = "True" ]] && return |
| 1089 | local sudo="sudo" |
| 1090 | [[ "$(id -u)" = "0" ]] && sudo="env" |
| 1091 | $sudo http_proxy=$http_proxy https_proxy=$https_proxy \ |
| 1092 | zypper --non-interactive install --auto-agree-with-licenses "$@" |
| 1093 | } |
| 1094 | |
| 1095 | |
| 1096 | # Process Functions |
| 1097 | # ================= |
| 1098 | |
| 1099 | # _run_process() is designed to be backgrounded by run_process() to simulate a |
| 1100 | # fork. It includes the dirty work of closing extra filehandles and preparing log |
| 1101 | # files to produce the same logs as screen_it(). The log filename is derived |
| 1102 | # from the service name and global-and-now-misnamed SCREEN_LOGDIR |
| 1103 | # _run_process service "command-line" |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 1104 | function _run_process { |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1105 | local service=$1 |
| 1106 | local command="$2" |
| 1107 | |
| 1108 | # Undo logging redirections and close the extra descriptors |
| 1109 | exec 1>&3 |
| 1110 | exec 2>&3 |
| 1111 | exec 3>&- |
| 1112 | exec 6>&- |
| 1113 | |
| 1114 | if [[ -n ${SCREEN_LOGDIR} ]]; then |
| 1115 | exec 1>&${SCREEN_LOGDIR}/screen-${1}.${CURRENT_LOG_TIME}.log 2>&1 |
| 1116 | ln -sf ${SCREEN_LOGDIR}/screen-${1}.${CURRENT_LOG_TIME}.log ${SCREEN_LOGDIR}/screen-${1}.log |
| 1117 | |
| 1118 | # TODO(dtroyer): Hack to get stdout from the Python interpreter for the logs. |
| 1119 | export PYTHONUNBUFFERED=1 |
| 1120 | fi |
| 1121 | |
| 1122 | exec /bin/bash -c "$command" |
| 1123 | die "$service exec failure: $command" |
| 1124 | } |
| 1125 | |
| 1126 | # Helper to remove the ``*.failure`` files under ``$SERVICE_DIR/$SCREEN_NAME``. |
| 1127 | # This is used for ``service_check`` when all the ``screen_it`` are called finished |
| 1128 | # init_service_check |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 1129 | function init_service_check { |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1130 | SCREEN_NAME=${SCREEN_NAME:-stack} |
| 1131 | SERVICE_DIR=${SERVICE_DIR:-${DEST}/status} |
| 1132 | |
| 1133 | if [[ ! -d "$SERVICE_DIR/$SCREEN_NAME" ]]; then |
| 1134 | mkdir -p "$SERVICE_DIR/$SCREEN_NAME" |
| 1135 | fi |
| 1136 | |
| 1137 | rm -f "$SERVICE_DIR/$SCREEN_NAME"/*.failure |
| 1138 | } |
| 1139 | |
| 1140 | # Find out if a process exists by partial name. |
| 1141 | # is_running name |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 1142 | function is_running { |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1143 | local name=$1 |
| 1144 | ps auxw | grep -v grep | grep ${name} > /dev/null |
| 1145 | RC=$? |
| 1146 | # some times I really hate bash reverse binary logic |
| 1147 | return $RC |
| 1148 | } |
| 1149 | |
| 1150 | # run_process() launches a child process that closes all file descriptors and |
| 1151 | # then exec's the passed in command. This is meant to duplicate the semantics |
| 1152 | # of screen_it() without screen. PIDs are written to |
| 1153 | # $SERVICE_DIR/$SCREEN_NAME/$service.pid |
| 1154 | # run_process service "command-line" |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 1155 | function run_process { |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1156 | local service=$1 |
| 1157 | local command="$2" |
| 1158 | |
| 1159 | # Spawn the child process |
| 1160 | _run_process "$service" "$command" & |
| 1161 | echo $! |
| 1162 | } |
| 1163 | |
| 1164 | # Helper to launch a service in a named screen |
| 1165 | # screen_it service "command-line" |
| 1166 | function screen_it { |
Sean Dague | ea22a4f | 2014-06-27 15:21:41 -0400 | [diff] [blame] | 1167 | SCREEN_NAME=${SCREEN_NAME:-stack} |
| 1168 | SERVICE_DIR=${SERVICE_DIR:-${DEST}/status} |
| 1169 | USE_SCREEN=$(trueorfalse True $USE_SCREEN) |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1170 | |
| 1171 | if is_service_enabled $1; then |
| 1172 | # Append the service to the screen rc file |
Sean Dague | ea22a4f | 2014-06-27 15:21:41 -0400 | [diff] [blame] | 1173 | screen_rc "$1" "$2" |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1174 | |
Sean Dague | ea22a4f | 2014-06-27 15:21:41 -0400 | [diff] [blame] | 1175 | if [[ "$USE_SCREEN" = "True" ]]; then |
| 1176 | screen -S $SCREEN_NAME -X screen -t $1 |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1177 | |
Sean Dague | ea22a4f | 2014-06-27 15:21:41 -0400 | [diff] [blame] | 1178 | if [[ -n ${SCREEN_LOGDIR} ]]; then |
| 1179 | screen -S $SCREEN_NAME -p $1 -X logfile ${SCREEN_LOGDIR}/screen-${1}.${CURRENT_LOG_TIME}.log |
| 1180 | screen -S $SCREEN_NAME -p $1 -X log on |
| 1181 | ln -sf ${SCREEN_LOGDIR}/screen-${1}.${CURRENT_LOG_TIME}.log ${SCREEN_LOGDIR}/screen-${1}.log |
| 1182 | fi |
| 1183 | |
| 1184 | # sleep to allow bash to be ready to be send the command - we are |
| 1185 | # creating a new window in screen and then sends characters, so if |
| 1186 | # bash isn't running by the time we send the command, nothing happens |
| 1187 | sleep 3 |
| 1188 | |
| 1189 | NL=`echo -ne '\015'` |
| 1190 | # This fun command does the following: |
| 1191 | # - the passed server command is backgrounded |
| 1192 | # - the pid of the background process is saved in the usual place |
| 1193 | # - the server process is brought back to the foreground |
| 1194 | # - if the server process exits prematurely the fg command errors |
| 1195 | # and a message is written to stdout and the service failure file |
| 1196 | # The pid saved can be used in screen_stop() as a process group |
| 1197 | # id to kill off all child processes |
| 1198 | screen -S $SCREEN_NAME -p $1 -X stuff "$2 & echo \$! >$SERVICE_DIR/$SCREEN_NAME/$1.pid; fg || echo \"$1 failed to start\" | tee \"$SERVICE_DIR/$SCREEN_NAME/$1.failure\"$NL" |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1199 | else |
| 1200 | # Spawn directly without screen |
Sean Dague | ea22a4f | 2014-06-27 15:21:41 -0400 | [diff] [blame] | 1201 | run_process "$1" "$2" >$SERVICE_DIR/$SCREEN_NAME/$1.pid |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1202 | fi |
| 1203 | fi |
| 1204 | } |
| 1205 | |
| 1206 | # Screen rc file builder |
| 1207 | # screen_rc service "command-line" |
| 1208 | function screen_rc { |
| 1209 | SCREEN_NAME=${SCREEN_NAME:-stack} |
| 1210 | SCREENRC=$TOP_DIR/$SCREEN_NAME-screenrc |
| 1211 | if [[ ! -e $SCREENRC ]]; then |
| 1212 | # Name the screen session |
| 1213 | echo "sessionname $SCREEN_NAME" > $SCREENRC |
| 1214 | # Set a reasonable statusbar |
| 1215 | echo "hardstatus alwayslastline '$SCREEN_HARDSTATUS'" >> $SCREENRC |
| 1216 | # Some distributions override PROMPT_COMMAND for the screen terminal type - turn that off |
| 1217 | echo "setenv PROMPT_COMMAND /bin/true" >> $SCREENRC |
| 1218 | echo "screen -t shell bash" >> $SCREENRC |
| 1219 | fi |
| 1220 | # If this service doesn't already exist in the screenrc file |
| 1221 | if ! grep $1 $SCREENRC 2>&1 > /dev/null; then |
| 1222 | NL=`echo -ne '\015'` |
| 1223 | echo "screen -t $1 bash" >> $SCREENRC |
| 1224 | echo "stuff \"$2$NL\"" >> $SCREENRC |
| 1225 | |
| 1226 | if [[ -n ${SCREEN_LOGDIR} ]]; then |
| 1227 | echo "logfile ${SCREEN_LOGDIR}/screen-${1}.${CURRENT_LOG_TIME}.log" >>$SCREENRC |
| 1228 | echo "log on" >>$SCREENRC |
| 1229 | fi |
| 1230 | fi |
| 1231 | } |
| 1232 | |
| 1233 | # Stop a service in screen |
| 1234 | # If a PID is available use it, kill the whole process group via TERM |
| 1235 | # If screen is being used kill the screen window; this will catch processes |
| 1236 | # that did not leave a PID behind |
| 1237 | # screen_stop service |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 1238 | function screen_stop { |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1239 | SCREEN_NAME=${SCREEN_NAME:-stack} |
| 1240 | SERVICE_DIR=${SERVICE_DIR:-${DEST}/status} |
| 1241 | USE_SCREEN=$(trueorfalse True $USE_SCREEN) |
| 1242 | |
| 1243 | if is_service_enabled $1; then |
| 1244 | # Kill via pid if we have one available |
| 1245 | if [[ -r $SERVICE_DIR/$SCREEN_NAME/$1.pid ]]; then |
| 1246 | pkill -TERM -P -$(cat $SERVICE_DIR/$SCREEN_NAME/$1.pid) |
| 1247 | rm $SERVICE_DIR/$SCREEN_NAME/$1.pid |
| 1248 | fi |
| 1249 | if [[ "$USE_SCREEN" = "True" ]]; then |
| 1250 | # Clean up the screen window |
| 1251 | screen -S $SCREEN_NAME -p $1 -X kill |
| 1252 | fi |
| 1253 | fi |
| 1254 | } |
| 1255 | |
| 1256 | # Helper to get the status of each running service |
| 1257 | # service_check |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 1258 | function service_check { |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1259 | local service |
| 1260 | local failures |
| 1261 | SCREEN_NAME=${SCREEN_NAME:-stack} |
| 1262 | SERVICE_DIR=${SERVICE_DIR:-${DEST}/status} |
| 1263 | |
| 1264 | |
| 1265 | if [[ ! -d "$SERVICE_DIR/$SCREEN_NAME" ]]; then |
| 1266 | echo "No service status directory found" |
| 1267 | return |
| 1268 | fi |
| 1269 | |
| 1270 | # Check if there is any falure flag file under $SERVICE_DIR/$SCREEN_NAME |
Sean Dague | 09bd7c8 | 2014-02-03 08:35:26 +0900 | [diff] [blame] | 1271 | # make this -o errexit safe |
| 1272 | failures=`ls "$SERVICE_DIR/$SCREEN_NAME"/*.failure 2>/dev/null || /bin/true` |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1273 | |
| 1274 | for service in $failures; do |
| 1275 | service=`basename $service` |
| 1276 | service=${service%.failure} |
| 1277 | echo "Error: Service $service is not running" |
| 1278 | done |
| 1279 | |
| 1280 | if [ -n "$failures" ]; then |
Sean Dague | 1237922 | 2014-02-27 17:16:46 -0500 | [diff] [blame] | 1281 | die $LINENO "More details about the above errors can be found with screen, with ./rejoin-stack.sh" |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1282 | fi |
| 1283 | } |
| 1284 | |
| 1285 | |
| 1286 | # Python Functions |
| 1287 | # ================ |
| 1288 | |
| 1289 | # Get the path to the pip command. |
| 1290 | # get_pip_command |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 1291 | function get_pip_command { |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1292 | which pip || which pip-python |
| 1293 | |
| 1294 | if [ $? -ne 0 ]; then |
| 1295 | die $LINENO "Unable to find pip; cannot continue" |
| 1296 | fi |
| 1297 | } |
| 1298 | |
| 1299 | # Get the path to the direcotry where python executables are installed. |
| 1300 | # get_python_exec_prefix |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 1301 | function get_python_exec_prefix { |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1302 | if is_fedora || is_suse; then |
| 1303 | echo "/usr/bin" |
| 1304 | else |
| 1305 | echo "/usr/local/bin" |
| 1306 | fi |
| 1307 | } |
| 1308 | |
| 1309 | # Wrapper for ``pip install`` to set cache and proxy environment variables |
| 1310 | # Uses globals ``OFFLINE``, ``PIP_DOWNLOAD_CACHE``, ``PIP_USE_MIRRORS``, |
| 1311 | # ``TRACK_DEPENDS``, ``*_proxy`` |
| 1312 | # pip_install package [package ...] |
| 1313 | function pip_install { |
Sean Dague | 45917cc | 2014-02-24 16:09:14 -0500 | [diff] [blame] | 1314 | local xtrace=$(set +o | grep xtrace) |
| 1315 | set +o xtrace |
| 1316 | if [[ "$OFFLINE" = "True" || -z "$@" ]]; then |
| 1317 | $xtrace |
| 1318 | return |
| 1319 | fi |
| 1320 | |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1321 | if [[ -z "$os_PACKAGE" ]]; then |
| 1322 | GetOSVersion |
| 1323 | fi |
| 1324 | if [[ $TRACK_DEPENDS = True ]]; then |
| 1325 | source $DEST/.venv/bin/activate |
| 1326 | CMD_PIP=$DEST/.venv/bin/pip |
| 1327 | SUDO_PIP="env" |
| 1328 | else |
| 1329 | SUDO_PIP="sudo" |
| 1330 | CMD_PIP=$(get_pip_command) |
| 1331 | fi |
| 1332 | |
| 1333 | # Mirror option not needed anymore because pypi has CDN available, |
| 1334 | # but it's useful in certain circumstances |
| 1335 | PIP_USE_MIRRORS=${PIP_USE_MIRRORS:-False} |
| 1336 | if [[ "$PIP_USE_MIRRORS" != "False" ]]; then |
| 1337 | PIP_MIRROR_OPT="--use-mirrors" |
| 1338 | fi |
| 1339 | |
| 1340 | # pip < 1.4 has a bug where it will use an already existing build |
| 1341 | # directory unconditionally. Say an earlier component installs |
| 1342 | # foo v1.1; pip will have built foo's source in |
| 1343 | # /tmp/$USER-pip-build. Even if a later component specifies foo < |
| 1344 | # 1.1, the existing extracted build will be used and cause |
| 1345 | # confusing errors. By creating unique build directories we avoid |
| 1346 | # this problem. See https://github.com/pypa/pip/issues/709 |
| 1347 | local pip_build_tmp=$(mktemp --tmpdir -d pip-build.XXXXX) |
| 1348 | |
Sean Dague | 45917cc | 2014-02-24 16:09:14 -0500 | [diff] [blame] | 1349 | $xtrace |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1350 | $SUDO_PIP PIP_DOWNLOAD_CACHE=${PIP_DOWNLOAD_CACHE:-/var/cache/pip} \ |
Yves-Gwenael Bourhis | d79a8ac | 2014-04-14 14:49:07 +0200 | [diff] [blame] | 1351 | http_proxy=$http_proxy \ |
| 1352 | https_proxy=$https_proxy \ |
| 1353 | no_proxy=$no_proxy \ |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1354 | $CMD_PIP install --build=${pip_build_tmp} \ |
| 1355 | $PIP_MIRROR_OPT $@ \ |
| 1356 | && $SUDO_PIP rm -rf ${pip_build_tmp} |
| 1357 | } |
| 1358 | |
Sean Dague | 099e5e3 | 2014-03-31 10:35:43 -0400 | [diff] [blame] | 1359 | # this should be used if you want to install globally, all libraries should |
| 1360 | # use this, especially *oslo* ones |
| 1361 | function setup_install { |
| 1362 | local project_dir=$1 |
| 1363 | setup_package_with_req_sync $project_dir |
| 1364 | } |
| 1365 | |
| 1366 | # this should be used for projects which run services, like all services |
| 1367 | function setup_develop { |
| 1368 | local project_dir=$1 |
| 1369 | setup_package_with_req_sync $project_dir -e |
| 1370 | } |
| 1371 | |
Dean Troyer | af616d9 | 2014-02-17 12:57:55 -0600 | [diff] [blame] | 1372 | # ``pip install -e`` the package, which processes the dependencies |
| 1373 | # using pip before running `setup.py develop` |
| 1374 | # |
| 1375 | # Updates the dependencies in project_dir from the |
| 1376 | # openstack/requirements global list before installing anything. |
| 1377 | # |
| 1378 | # Uses globals ``TRACK_DEPENDS``, ``REQUIREMENTS_DIR``, ``UNDO_REQUIREMENTS`` |
| 1379 | # setup_develop directory |
Sean Dague | 099e5e3 | 2014-03-31 10:35:43 -0400 | [diff] [blame] | 1380 | function setup_package_with_req_sync { |
Dean Troyer | af616d9 | 2014-02-17 12:57:55 -0600 | [diff] [blame] | 1381 | local project_dir=$1 |
Sean Dague | 099e5e3 | 2014-03-31 10:35:43 -0400 | [diff] [blame] | 1382 | local flags=$2 |
Dean Troyer | af616d9 | 2014-02-17 12:57:55 -0600 | [diff] [blame] | 1383 | |
Dean Troyer | af616d9 | 2014-02-17 12:57:55 -0600 | [diff] [blame] | 1384 | # Don't update repo if local changes exist |
| 1385 | # Don't use buggy "git diff --quiet" |
Dean Troyer | 83b6c99 | 2014-02-27 12:41:28 -0600 | [diff] [blame] | 1386 | # ``errexit`` requires us to trap the exit code when the repo is changed |
| 1387 | local update_requirements=$(cd $project_dir && git diff --exit-code >/dev/null || echo "changed") |
Dean Troyer | af616d9 | 2014-02-17 12:57:55 -0600 | [diff] [blame] | 1388 | |
YAMAMOTO Takashi | 3b1f2e4 | 2014-02-24 20:30:07 +0900 | [diff] [blame] | 1389 | if [[ $update_requirements != "changed" ]]; then |
Dean Troyer | af616d9 | 2014-02-17 12:57:55 -0600 | [diff] [blame] | 1390 | (cd $REQUIREMENTS_DIR; \ |
| 1391 | $SUDO_CMD python update.py $project_dir) |
| 1392 | fi |
| 1393 | |
Sean Dague | 099e5e3 | 2014-03-31 10:35:43 -0400 | [diff] [blame] | 1394 | setup_package $project_dir $flags |
Dean Troyer | af616d9 | 2014-02-17 12:57:55 -0600 | [diff] [blame] | 1395 | |
| 1396 | # We've just gone and possibly modified the user's source tree in an |
| 1397 | # automated way, which is considered bad form if it's a development |
| 1398 | # tree because we've screwed up their next git checkin. So undo it. |
| 1399 | # |
| 1400 | # However... there are some circumstances, like running in the gate |
| 1401 | # where we really really want the overridden version to stick. So provide |
| 1402 | # a variable that tells us whether or not we should UNDO the requirements |
| 1403 | # changes (this will be set to False in the OpenStack ci gate) |
| 1404 | if [ $UNDO_REQUIREMENTS = "True" ]; then |
YAMAMOTO Takashi | 3b1f2e4 | 2014-02-24 20:30:07 +0900 | [diff] [blame] | 1405 | if [[ $update_requirements != "changed" ]]; then |
Dean Troyer | af616d9 | 2014-02-17 12:57:55 -0600 | [diff] [blame] | 1406 | (cd $project_dir && git reset --hard) |
| 1407 | fi |
| 1408 | fi |
| 1409 | } |
| 1410 | |
| 1411 | # ``pip install -e`` the package, which processes the dependencies |
| 1412 | # using pip before running `setup.py develop` |
| 1413 | # Uses globals ``STACK_USER`` |
| 1414 | # setup_develop_no_requirements_update directory |
Sean Dague | 099e5e3 | 2014-03-31 10:35:43 -0400 | [diff] [blame] | 1415 | function setup_package { |
Dean Troyer | af616d9 | 2014-02-17 12:57:55 -0600 | [diff] [blame] | 1416 | local project_dir=$1 |
Sean Dague | 099e5e3 | 2014-03-31 10:35:43 -0400 | [diff] [blame] | 1417 | local flags=$2 |
Dean Troyer | af616d9 | 2014-02-17 12:57:55 -0600 | [diff] [blame] | 1418 | |
Sean Dague | 099e5e3 | 2014-03-31 10:35:43 -0400 | [diff] [blame] | 1419 | pip_install $flags $project_dir |
Dean Troyer | af616d9 | 2014-02-17 12:57:55 -0600 | [diff] [blame] | 1420 | # ensure that further actions can do things like setup.py sdist |
Sean Dague | 099e5e3 | 2014-03-31 10:35:43 -0400 | [diff] [blame] | 1421 | if [[ "$flags" == "-e" ]]; then |
| 1422 | safe_chown -R $STACK_USER $1/*.egg-info |
| 1423 | fi |
Dean Troyer | af616d9 | 2014-02-17 12:57:55 -0600 | [diff] [blame] | 1424 | } |
| 1425 | |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1426 | |
| 1427 | # Service Functions |
| 1428 | # ================= |
| 1429 | |
| 1430 | # remove extra commas from the input string (i.e. ``ENABLED_SERVICES``) |
| 1431 | # _cleanup_service_list service-list |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 1432 | function _cleanup_service_list { |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1433 | echo "$1" | sed -e ' |
| 1434 | s/,,/,/g; |
| 1435 | s/^,//; |
| 1436 | s/,$// |
| 1437 | ' |
| 1438 | } |
| 1439 | |
| 1440 | # disable_all_services() removes all current services |
| 1441 | # from ``ENABLED_SERVICES`` to reset the configuration |
| 1442 | # before a minimal installation |
| 1443 | # Uses global ``ENABLED_SERVICES`` |
| 1444 | # disable_all_services |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 1445 | function disable_all_services { |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1446 | ENABLED_SERVICES="" |
| 1447 | } |
| 1448 | |
| 1449 | # Remove all services starting with '-'. For example, to install all default |
| 1450 | # services except rabbit (rabbit) set in ``localrc``: |
| 1451 | # ENABLED_SERVICES+=",-rabbit" |
| 1452 | # Uses global ``ENABLED_SERVICES`` |
| 1453 | # disable_negated_services |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 1454 | function disable_negated_services { |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1455 | local tmpsvcs="${ENABLED_SERVICES}" |
| 1456 | local service |
| 1457 | for service in ${tmpsvcs//,/ }; do |
| 1458 | if [[ ${service} == -* ]]; then |
| 1459 | tmpsvcs=$(echo ${tmpsvcs}|sed -r "s/(,)?(-)?${service#-}(,)?/,/g") |
| 1460 | fi |
| 1461 | done |
| 1462 | ENABLED_SERVICES=$(_cleanup_service_list "$tmpsvcs") |
| 1463 | } |
| 1464 | |
| 1465 | # disable_service() removes the services passed as argument to the |
| 1466 | # ``ENABLED_SERVICES`` list, if they are present. |
| 1467 | # |
| 1468 | # For example: |
| 1469 | # disable_service rabbit |
| 1470 | # |
| 1471 | # This function does not know about the special cases |
| 1472 | # for nova, glance, and neutron built into is_service_enabled(). |
| 1473 | # Uses global ``ENABLED_SERVICES`` |
| 1474 | # disable_service service [service ...] |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 1475 | function disable_service { |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1476 | local tmpsvcs=",${ENABLED_SERVICES}," |
| 1477 | local service |
| 1478 | for service in $@; do |
| 1479 | if is_service_enabled $service; then |
| 1480 | tmpsvcs=${tmpsvcs//,$service,/,} |
| 1481 | fi |
| 1482 | done |
| 1483 | ENABLED_SERVICES=$(_cleanup_service_list "$tmpsvcs") |
| 1484 | } |
| 1485 | |
| 1486 | # enable_service() adds the services passed as argument to the |
| 1487 | # ``ENABLED_SERVICES`` list, if they are not already present. |
| 1488 | # |
| 1489 | # For example: |
| 1490 | # enable_service qpid |
| 1491 | # |
| 1492 | # This function does not know about the special cases |
| 1493 | # for nova, glance, and neutron built into is_service_enabled(). |
| 1494 | # Uses global ``ENABLED_SERVICES`` |
| 1495 | # enable_service service [service ...] |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 1496 | function enable_service { |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1497 | local tmpsvcs="${ENABLED_SERVICES}" |
| 1498 | for service in $@; do |
| 1499 | if ! is_service_enabled $service; then |
| 1500 | tmpsvcs+=",$service" |
| 1501 | fi |
| 1502 | done |
| 1503 | ENABLED_SERVICES=$(_cleanup_service_list "$tmpsvcs") |
| 1504 | disable_negated_services |
| 1505 | } |
| 1506 | |
| 1507 | # is_service_enabled() checks if the service(s) specified as arguments are |
| 1508 | # enabled by the user in ``ENABLED_SERVICES``. |
| 1509 | # |
| 1510 | # Multiple services specified as arguments are ``OR``'ed together; the test |
| 1511 | # is a short-circuit boolean, i.e it returns on the first match. |
| 1512 | # |
| 1513 | # There are special cases for some 'catch-all' services:: |
| 1514 | # **nova** returns true if any service enabled start with **n-** |
| 1515 | # **cinder** returns true if any service enabled start with **c-** |
| 1516 | # **ceilometer** returns true if any service enabled start with **ceilometer** |
| 1517 | # **glance** returns true if any service enabled start with **g-** |
| 1518 | # **neutron** returns true if any service enabled start with **q-** |
| 1519 | # **swift** returns true if any service enabled start with **s-** |
| 1520 | # **trove** returns true if any service enabled start with **tr-** |
| 1521 | # For backward compatibility if we have **swift** in ENABLED_SERVICES all the |
| 1522 | # **s-** services will be enabled. This will be deprecated in the future. |
| 1523 | # |
| 1524 | # Cells within nova is enabled if **n-cell** is in ``ENABLED_SERVICES``. |
| 1525 | # We also need to make sure to treat **n-cell-region** and **n-cell-child** |
| 1526 | # as enabled in this case. |
| 1527 | # |
| 1528 | # Uses global ``ENABLED_SERVICES`` |
| 1529 | # is_service_enabled service [service ...] |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 1530 | function is_service_enabled { |
Sean Dague | 45917cc | 2014-02-24 16:09:14 -0500 | [diff] [blame] | 1531 | local xtrace=$(set +o | grep xtrace) |
| 1532 | set +o xtrace |
| 1533 | local enabled=1 |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1534 | services=$@ |
| 1535 | for service in ${services}; do |
Sean Dague | 45917cc | 2014-02-24 16:09:14 -0500 | [diff] [blame] | 1536 | [[ ,${ENABLED_SERVICES}, =~ ,${service}, ]] && enabled=0 |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1537 | |
| 1538 | # Look for top-level 'enabled' function for this service |
| 1539 | if type is_${service}_enabled >/dev/null 2>&1; then |
| 1540 | # A function exists for this service, use it |
| 1541 | is_${service}_enabled |
Sean Dague | 45917cc | 2014-02-24 16:09:14 -0500 | [diff] [blame] | 1542 | enabled=$? |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1543 | fi |
| 1544 | |
| 1545 | # TODO(dtroyer): Remove these legacy special-cases after the is_XXX_enabled() |
| 1546 | # are implemented |
| 1547 | |
Sean Dague | 45917cc | 2014-02-24 16:09:14 -0500 | [diff] [blame] | 1548 | [[ ${service} == n-cell-* && ${ENABLED_SERVICES} =~ "n-cell" ]] && enabled=0 |
| 1549 | [[ ${service} == "nova" && ${ENABLED_SERVICES} =~ "n-" ]] && enabled=0 |
| 1550 | [[ ${service} == "cinder" && ${ENABLED_SERVICES} =~ "c-" ]] && enabled=0 |
| 1551 | [[ ${service} == "ceilometer" && ${ENABLED_SERVICES} =~ "ceilometer-" ]] && enabled=0 |
| 1552 | [[ ${service} == "glance" && ${ENABLED_SERVICES} =~ "g-" ]] && enabled=0 |
| 1553 | [[ ${service} == "ironic" && ${ENABLED_SERVICES} =~ "ir-" ]] && enabled=0 |
| 1554 | [[ ${service} == "neutron" && ${ENABLED_SERVICES} =~ "q-" ]] && enabled=0 |
| 1555 | [[ ${service} == "trove" && ${ENABLED_SERVICES} =~ "tr-" ]] && enabled=0 |
| 1556 | [[ ${service} == "swift" && ${ENABLED_SERVICES} =~ "s-" ]] && enabled=0 |
| 1557 | [[ ${service} == s-* && ${ENABLED_SERVICES} =~ "swift" ]] && enabled=0 |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1558 | done |
Sean Dague | 45917cc | 2014-02-24 16:09:14 -0500 | [diff] [blame] | 1559 | $xtrace |
| 1560 | return $enabled |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1561 | } |
| 1562 | |
| 1563 | # Toggle enable/disable_service for services that must run exclusive of each other |
| 1564 | # $1 The name of a variable containing a space-separated list of services |
| 1565 | # $2 The name of a variable in which to store the enabled service's name |
| 1566 | # $3 The name of the service to enable |
| 1567 | function use_exclusive_service { |
| 1568 | local options=${!1} |
| 1569 | local selection=$3 |
| 1570 | out=$2 |
| 1571 | [ -z $selection ] || [[ ! "$options" =~ "$selection" ]] && return 1 |
| 1572 | for opt in $options;do |
| 1573 | [[ "$opt" = "$selection" ]] && enable_service $opt || disable_service $opt |
| 1574 | done |
| 1575 | eval "$out=$selection" |
| 1576 | return 0 |
| 1577 | } |
| 1578 | |
| 1579 | |
Masayuki Igawa | f6368d3 | 2014-02-20 13:31:26 +0900 | [diff] [blame] | 1580 | # System Functions |
| 1581 | # ================ |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1582 | |
| 1583 | # Only run the command if the target file (the last arg) is not on an |
| 1584 | # NFS filesystem. |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 1585 | function _safe_permission_operation { |
Sean Dague | 45917cc | 2014-02-24 16:09:14 -0500 | [diff] [blame] | 1586 | local xtrace=$(set +o | grep xtrace) |
| 1587 | set +o xtrace |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1588 | local args=( $@ ) |
| 1589 | local last |
| 1590 | local sudo_cmd |
| 1591 | local dir_to_check |
| 1592 | |
| 1593 | let last="${#args[*]} - 1" |
| 1594 | |
| 1595 | dir_to_check=${args[$last]} |
| 1596 | if [ ! -d "$dir_to_check" ]; then |
| 1597 | dir_to_check=`dirname "$dir_to_check"` |
| 1598 | fi |
| 1599 | |
| 1600 | if is_nfs_directory "$dir_to_check" ; then |
Sean Dague | 45917cc | 2014-02-24 16:09:14 -0500 | [diff] [blame] | 1601 | $xtrace |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1602 | return 0 |
| 1603 | fi |
| 1604 | |
| 1605 | if [[ $TRACK_DEPENDS = True ]]; then |
| 1606 | sudo_cmd="env" |
| 1607 | else |
| 1608 | sudo_cmd="sudo" |
| 1609 | fi |
| 1610 | |
Sean Dague | 45917cc | 2014-02-24 16:09:14 -0500 | [diff] [blame] | 1611 | $xtrace |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1612 | $sudo_cmd $@ |
| 1613 | } |
| 1614 | |
| 1615 | # Exit 0 if address is in network or 1 if address is not in network |
| 1616 | # ip-range is in CIDR notation: 1.2.3.4/20 |
| 1617 | # address_in_net ip-address ip-range |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 1618 | function address_in_net { |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1619 | local ip=$1 |
| 1620 | local range=$2 |
| 1621 | local masklen=${range#*/} |
| 1622 | local network=$(maskip ${range%/*} $(cidr2netmask $masklen)) |
| 1623 | local subnet=$(maskip $ip $(cidr2netmask $masklen)) |
| 1624 | [[ $network == $subnet ]] |
| 1625 | } |
| 1626 | |
| 1627 | # Add a user to a group. |
| 1628 | # add_user_to_group user group |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 1629 | function add_user_to_group { |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1630 | local user=$1 |
| 1631 | local group=$2 |
| 1632 | |
| 1633 | if [[ -z "$os_VENDOR" ]]; then |
| 1634 | GetOSVersion |
| 1635 | fi |
| 1636 | |
| 1637 | # SLE11 and openSUSE 12.2 don't have the usual usermod |
| 1638 | if ! is_suse || [[ "$os_VENDOR" = "openSUSE" && "$os_RELEASE" != "12.2" ]]; then |
| 1639 | sudo usermod -a -G "$group" "$user" |
| 1640 | else |
| 1641 | sudo usermod -A "$group" "$user" |
| 1642 | fi |
| 1643 | } |
| 1644 | |
| 1645 | # Convert CIDR notation to a IPv4 netmask |
| 1646 | # cidr2netmask cidr-bits |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 1647 | function cidr2netmask { |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1648 | local maskpat="255 255 255 255" |
| 1649 | local maskdgt="254 252 248 240 224 192 128" |
| 1650 | set -- ${maskpat:0:$(( ($1 / 8) * 4 ))}${maskdgt:$(( (7 - ($1 % 8)) * 4 )):3} |
| 1651 | echo ${1-0}.${2-0}.${3-0}.${4-0} |
| 1652 | } |
| 1653 | |
| 1654 | # Gracefully cp only if source file/dir exists |
| 1655 | # cp_it source destination |
| 1656 | function cp_it { |
| 1657 | if [ -e $1 ] || [ -d $1 ]; then |
| 1658 | cp -pRL $1 $2 |
| 1659 | fi |
| 1660 | } |
| 1661 | |
| 1662 | # HTTP and HTTPS proxy servers are supported via the usual environment variables [1] |
| 1663 | # ``http_proxy``, ``https_proxy`` and ``no_proxy``. They can be set in |
| 1664 | # ``localrc`` or on the command line if necessary:: |
| 1665 | # |
| 1666 | # [1] http://www.w3.org/Daemon/User/Proxies/ProxyClients.html |
| 1667 | # |
| 1668 | # http_proxy=http://proxy.example.com:3128/ no_proxy=repo.example.net ./stack.sh |
| 1669 | |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 1670 | function export_proxy_variables { |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1671 | if [[ -n "$http_proxy" ]]; then |
| 1672 | export http_proxy=$http_proxy |
| 1673 | fi |
| 1674 | if [[ -n "$https_proxy" ]]; then |
| 1675 | export https_proxy=$https_proxy |
| 1676 | fi |
| 1677 | if [[ -n "$no_proxy" ]]; then |
| 1678 | export no_proxy=$no_proxy |
| 1679 | fi |
| 1680 | } |
| 1681 | |
| 1682 | # Returns true if the directory is on a filesystem mounted via NFS. |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 1683 | function is_nfs_directory { |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1684 | local mount_type=`stat -f -L -c %T $1` |
| 1685 | test "$mount_type" == "nfs" |
| 1686 | } |
| 1687 | |
| 1688 | # Return the network portion of the given IP address using netmask |
| 1689 | # netmask is in the traditional dotted-quad format |
| 1690 | # maskip ip-address netmask |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 1691 | function maskip { |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1692 | local ip=$1 |
| 1693 | local mask=$2 |
| 1694 | local l="${ip%.*}"; local r="${ip#*.}"; local n="${mask%.*}"; local m="${mask#*.}" |
| 1695 | local subnet=$((${ip%%.*}&${mask%%.*})).$((${r%%.*}&${m%%.*})).$((${l##*.}&${n##*.})).$((${ip##*.}&${mask##*.})) |
| 1696 | echo $subnet |
| 1697 | } |
| 1698 | |
| 1699 | # Service wrapper to restart services |
| 1700 | # restart_service service-name |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 1701 | function restart_service { |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1702 | if is_ubuntu; then |
| 1703 | sudo /usr/sbin/service $1 restart |
| 1704 | else |
| 1705 | sudo /sbin/service $1 restart |
| 1706 | fi |
| 1707 | } |
| 1708 | |
| 1709 | # Only change permissions of a file or directory if it is not on an |
| 1710 | # NFS filesystem. |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 1711 | function safe_chmod { |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1712 | _safe_permission_operation chmod $@ |
| 1713 | } |
| 1714 | |
| 1715 | # Only change ownership of a file or directory if it is not on an NFS |
| 1716 | # filesystem. |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 1717 | function safe_chown { |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1718 | _safe_permission_operation chown $@ |
| 1719 | } |
| 1720 | |
| 1721 | # Service wrapper to start services |
| 1722 | # start_service service-name |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 1723 | function start_service { |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1724 | if is_ubuntu; then |
| 1725 | sudo /usr/sbin/service $1 start |
| 1726 | else |
| 1727 | sudo /sbin/service $1 start |
| 1728 | fi |
| 1729 | } |
| 1730 | |
| 1731 | # Service wrapper to stop services |
| 1732 | # stop_service service-name |
Ian Wienand | aee18c7 | 2014-02-21 15:35:08 +1100 | [diff] [blame] | 1733 | function stop_service { |
Dean Troyer | dff49a2 | 2014-01-30 15:37:40 -0600 | [diff] [blame] | 1734 | if is_ubuntu; then |
| 1735 | sudo /usr/sbin/service $1 stop |
| 1736 | else |
| 1737 | sudo /sbin/service $1 stop |
| 1738 | fi |
| 1739 | } |
| 1740 | |
| 1741 | |
| 1742 | # Restore xtrace |
| 1743 | $XTRACE |
| 1744 | |
| 1745 | # Local variables: |
| 1746 | # mode: shell-script |
| 1747 | # End: |