netdata-installer.sh

   1 #!/usr/bin/env bash
   2
   3 # reload the user profile
   4 [ -f /etc/profile ] && . /etc/profile
   5
   6 export PATH="${PATH}:/sbin:/usr/sbin:/usr/local/bin:/usr/local/sbin"
   7
   8 # fix PKG_CHECK_MODULES error
   9 if [ -d /usr/share/aclocal ]
  10 then
  11         ACLOCAL_PATH=${ACLOCAL_PATH-/usr/share/aclocal}
  12         export ACLOCAL_PATH
  13 fi
  14
  15 LC_ALL=C
  16 umask 002
  17
  18 # Be nice on production environments
  19 renice 19 $$ >/dev/null 2>/dev/null
  20
  21 processors=$(cat /proc/cpuinfo  | grep ^processor | wc -l)
  22 [ $(( processors )) -lt 1 ] && processors=1
  23
  24 # you can set CFLAGS before running installer
  25 CFLAGS="${CFLAGS--O3}"
  26
  27 # keep a log of this command
  28 printf "\n# " >>netdata-installer.log
  29 date >>netdata-installer.log
  30 printf "CFLAGS=\"%s\" " "${CFLAGS}" >>netdata-installer.log
  31 printf "%q " "$0" "${@}" >>netdata-installer.log
  32 printf "\n" >>netdata-installer.log
  33
  34 REINSTALL_PWD="${PWD}"
  35 REINSTALL_COMMAND="$(printf "%q " "$0" "${@}"; printf "\n")"
  36
  37 banner() {
  38     local   l1="  ^"                                                                      \
  39             l2="  |.-.   .-.   .-.   .-.   .-.   .-.   .-.   .-.   .-.   .-.   .-.   .-.   .-"  \
  40             l3="  |   '-'   '-'   '-'   '-'   '-'   '-'   '-'   '-'   '-'   '-'   '-'   '-'  "  \
  41             l4="  +----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+--->" \
  42             sp="                                                                        " \
  43             netdata="netdata" start end msg="${*}"
  44
  45     [ ${#msg} -lt ${#netdata} ] && msg="${msg}${sp:0:$(( ${#netdata} - ${#msg}))}"
  46     [ ${#msg} -gt $(( ${#l2} - 20 )) ] && msg="${msg:0:$(( ${#l2} - 23 ))}..."
  47
  48     start="$(( ${#l2} / 2 - 4 ))"
  49     [ $(( start + ${#msg} + 4 )) -gt ${#l2} ] && start=$((${#l2} - ${#msg} - 4))
  50     end=$(( ${start} + ${#msg} + 4 ))
  51
  52     echo >&2
  53     echo >&2 "${l1}"
  54     echo >&2 "${l2:0:start}${sp:0:2}${netdata}${sp:0:$((end - start - 2 - ${#netdata}))}${l2:end:$((${#l2} - end))}"
  55     echo >&2 "${l3:0:start}${sp:0:2}${msg}${sp:0:2}${l3:end:$((${#l2} - end))}"
  56     echo >&2 "${l4}"
  57     echo >&2
  58 }
  59
  60 service="$(which service 2>/dev/null || command -v service 2>/dev/null)"
  61 systemctl="$(which systemctl 2>/dev/null || command -v systemctl 2>/dev/null)"
  62 service() {
  63     local cmd="${1}" action="${2}"
  64
  65     if [ ! -z "${service}" ]
  66     then
  67         run "${service}" "${cmd}" "${action}"
  68         return $?
  69     elif [ ! -z "${systemctl}" ]
  70     then
  71         run "${systemctl}" "${action}" "${cmd}"
  72         return $?
  73     fi
  74     return 1
  75 }
  76
  77 ME="$0"
  78 DONOTSTART=0
  79 DONOTWAIT=0
  80 NETDATA_PREFIX=
  81 LIBS_ARE_HERE=0
  82
  83 usage() {
  84     banner "installer command line options"
  85     cat <<USAGE
  86
  87 ${ME} <installer options>
  88
  89 Valid <installer options> are:
  90
  91    --install /PATH/TO/INSTALL
  92
  93         If your give: --install /opt
  94         netdata will be installed in /opt/netdata
  95
  96    --dont-start-it
  97
  98         Do not (re)start netdata.
  99         Just install it.
 100
 101    --dont-wait
 102
 103         Do not wait for the user to press ENTER.
 104         Start immediately building it.
 105
 106    --zlib-is-really-here
 107    --libs-are-really-here
 108
 109         If you get errors about missing zlib,
 110         or libuuid but you know it is available,
 111         you have a broken pkg-config.
 112         Use this option to allow it continue
 113         without checking pkg-config.
 114
 115 Netdata will by default be compiled with gcc optimization -O3
 116 If you need to pass different CFLAGS, use something like this:
 117
 118   CFLAGS="<gcc options>" ${ME} <installer options>
 119
 120 For the installer to complete successfully, you will need
 121 these packages installed:
 122
 123    gcc make autoconf automake pkg-config zlib1g-dev (or zlib-devel)
 124    uuid-dev (or libuuid-devel)
 125
 126 For the plugins, you will at least need:
 127
 128    curl nodejs
 129
 130 USAGE
 131 }
 132
 133 md5sum="$(which md5sum 2>/dev/null || command -v md5sum 2>/dev/null)"
 134 get_git_config_signatures() {
 135     local x s file md5
 136
 137     [ ! -d "conf.d" ] && echo >&2 "Wrong directory." && return 1
 138     [ -z "${md5sum}" -o ! -x "${md5sum}" ] && echo >&2 "No md5sum command." && return 1
 139
 140     echo >configs.signatures.tmp
 141
 142     for x in $(find conf.d -name \*.conf)
 143     do
 144             x="${x/conf.d\//}"
 145             echo "${x}"
 146             for c in $(git log --follow "conf.d/${x}" | grep ^commit | cut -d ' ' -f 2)
 147             do
 148                     git checkout ${c} "conf.d/${x}" || continue
 149                     s="$(cat "conf.d/${x}" | md5sum | cut -d ' ' -f 1)"
 150                     echo >>configs.signatures.tmp "${s}:${x}"
 151                     echo "    ${s}"
 152             done
 153             git checkout HEAD "conf.d/${x}" || break
 154     done
 155
 156     cat configs.signatures.tmp |\
 157         grep -v "^$" |\
 158         sort -u |\
 159         {
 160             echo "declare -A configs_signatures=("
 161             IFS=":"
 162             while read md5 file
 163             do
 164                 echo "  ['${md5}']='${file}'"
 165             done
 166             echo ")"
 167         } >configs.signatures
 168
 169     rm configs.signatures.tmp
 170
 171     return 0
 172 }
 173
 174
 175 while [ ! -z "${1}" ]
 176 do
 177     if [ "$1" = "--install" ]
 178         then
 179         NETDATA_PREFIX="${2}/netdata"
 180         shift 2
 181     elif [ "$1" = "--zlib-is-really-here" -o "$1" = "--libs-are-really-here" ]
 182         then
 183         LIBS_ARE_HERE=1
 184         shift 1
 185     elif [ "$1" = "--dont-start-it" ]
 186         then
 187         DONOTSTART=1
 188         shift 1
 189     elif [ "$1" = "--dont-wait" ]
 190         then
 191         DONOTWAIT=1
 192         shift 1
 193     elif [ "$1" = "--help" -o "$1" = "-h" ]
 194         then
 195         usage
 196         exit 1
 197     elif [ "$1" = "get_git_config_signatures" ]
 198         then
 199         get_git_config_signatures && exit 0
 200         exit 1
 201     else
 202         echo >&2
 203         echo >&2 "ERROR:"
 204         echo >&2 "I cannot understand option '$1'."
 205         usage
 206         exit 1
 207     fi
 208 done
 209
 210 banner "real-time performance monitoring, done right!"
 211 cat <<BANNER
 212
 213   You are about to build and install netdata to your system.
 214
 215   It will be installed at these locations:
 216
 217    - the daemon    at ${NETDATA_PREFIX}/usr/sbin/netdata
 218    - config files  at ${NETDATA_PREFIX}/etc/netdata
 219    - web files     at ${NETDATA_PREFIX}/usr/share/netdata
 220    - plugins       at ${NETDATA_PREFIX}/usr/libexec/netdata
 221    - cache files   at ${NETDATA_PREFIX}/var/cache/netdata
 222    - db files      at ${NETDATA_PREFIX}/var/lib/netdata
 223    - log files     at ${NETDATA_PREFIX}/var/log/netdata
 224    - pid file      at ${NETDATA_PREFIX}/var/run
 225
 226   This installer allows you to change the installation path.
 227   Press Control-C and run the same command with --help for help.
 228
 229 BANNER
 230
 231 if [ "${UID}" -ne 0 ]
 232     then
 233     if [ -z "${NETDATA_PREFIX}" ]
 234         then
 235         banner "wrong command line options!"
 236         cat <<NONROOTNOPREFIX
 237
 238 Sorry! This will fail!
 239
 240 You are attempting to install netdata as non-root, but you plan to install it
 241 in system paths.
 242
 243 Please set an installation prefix, like this:
 244
 245     $0 ${@} --install /tmp
 246
 247 or, run the installer as root:
 248
 249     sudo $0 ${@}
 250
 251 We suggest to install it as root, or certain data collectors will not be able
 252 to work. Netdata drops root privileges when running. So, if you plan to keep
 253 it, install it as root to get the full functionality.
 254
 255 NONROOTNOPREFIX
 256         exit 1
 257
 258     else
 259         cat <<NONROOT
 260
 261 IMPORTANT:
 262 You are about to install netdata as a non-root user.
 263 Netdata will work, but a few data collection modules that
 264 require root access will fail.
 265
 266 If you installing permanently on your system, run the
 267 installer like this:
 268
 269     sudo $0 ${@}
 270
 271 NONROOT
 272     fi
 273 fi
 274
 275 have_autotools=
 276 if [ "$(type autoreconf 2> /dev/null)" ]
 277 then
 278     autoconf_maj_min() {
 279         local maj min IFS=.-
 280
 281         maj=$1
 282         min=$2
 283
 284         set -- $(autoreconf -V | sed -ne '1s/.* \([^ ]*\)$/\1/p')
 285         eval $maj=\$1 $min=\$2
 286     }
 287     autoconf_maj_min AMAJ AMIN
 288
 289     if [ "$AMAJ" -gt 2 ]
 290     then
 291         have_autotools=Y
 292     elif [ "$AMAJ" -eq 2 -a "$AMIN" -ge 60 ]
 293     then
 294         have_autotools=Y
 295     else
 296         echo "Found autotools $AMAJ.$AMIN"
 297     fi
 298 else
 299     echo "No autotools found"
 300 fi
 301
 302 if [ ! "$have_autotools" ]
 303 then
 304     if [ -f configure ]
 305     then
 306         echo "Will skip autoreconf step"
 307     else
 308         banner "autotools v2.60 required"
 309         cat <<"EOF"
 310
 311 -------------------------------------------------------------------------------
 312 autotools 2.60 or later is required
 313
 314 Sorry, you do not seem to have autotools 2.60 or later, which is
 315 required to build from the git sources of netdata.
 316
 317 You can either install a suitable version of autotools and automake
 318 or download a netdata package which does not have these dependencies.
 319
 320 Source packages where autotools have already been run are available
 321 here:
 322        https://firehol.org/download/netdata/
 323
 324 The unsigned/master folder tracks the head of the git tree and released
 325 packages are also available.
 326 EOF
 327         exit 1
 328     fi
 329 fi
 330
 331 if [ ${DONOTWAIT} -eq 0 ]
 332     then
 333     if [ ! -z "${NETDATA_PREFIX}" ]
 334         then
 335         read -p "Press ENTER to build and install netdata to '${NETDATA_PREFIX}' > "
 336     else
 337         read -p "Press ENTER to build and install netdata to your system > "
 338     fi
 339 fi
 340
 341 build_error() {
 342     banner "sorry, it failed to build..."
 343     cat <<EOF
 344
 345 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 346
 347 Sorry! netdata failed to build...
 348
 349 You many need to check these:
 350
 351 1. The package uuid-dev (or libuuid-devel) has to be installed.
 352
 353    If your system cannot find libuuid, although it is installed
 354    run me with the option:  --libs-are-really-here
 355
 356 2. The package zlib1g-dev (or zlib-devel) has to be installed.
 357
 358    If your system cannot find zlib, although it is installed
 359    run me with the option:  --libs-are-really-here
 360
 361 3. You need basic build tools installed, like:
 362
 363    gcc make autoconf automake pkg-config
 364
 365    Autoconf version 2.60 or higher is required.
 366
 367 If you still cannot get it to build, ask for help at github:
 368
 369    https://github.com/firehol/netdata/issues
 370
 371
 372 EOF
 373     trap - EXIT
 374     exit 1
 375 }
 376
 377 run() {
 378     printf >>netdata-installer.log "# "
 379     printf >>netdata-installer.log "%q " "${@}"
 380     printf >>netdata-installer.log " ... "
 381
 382     printf >&2 "\n"
 383     printf >&2 ":-----------------------------------------------------------------------------\n"
 384     printf >&2 "Running command:\n"
 385     printf >&2 "\n"
 386     printf >&2 "%q " "${@}"
 387     printf >&2 "\n"
 388
 389     "${@}"
 390
 391     local ret=$?
 392     if [ ${ret} -ne 0 ]
 393         then
 394         printf >>netdata-installer.log "FAILED!\n"
 395     else
 396         printf >>netdata-installer.log "OK\n"
 397     fi
 398
 399     return ${ret}
 400 }
 401
 402 if [ ${LIBS_ARE_HERE} -eq 1 ]
 403     then
 404     shift
 405     echo >&2 "ok, assuming libs are really installed."
 406     export ZLIB_CFLAGS=" "
 407     export ZLIB_LIBS="-lz"
 408     export UUID_CFLAGS=" "
 409     export UUID_LIBS="-luuid"
 410 fi
 411
 412 trap build_error EXIT
 413
 414 if [ "$have_autotools" ]
 415 then
 416     run ./autogen.sh || exit 1
 417 fi
 418
 419 run ./configure \
 420     --prefix="${NETDATA_PREFIX}/usr" \
 421     --sysconfdir="${NETDATA_PREFIX}/etc" \
 422     --localstatedir="${NETDATA_PREFIX}/var" \
 423     --with-zlib --with-math --with-user=netdata \
 424     CFLAGS="${CFLAGS}" || exit 1
 425
 426 # remove the build_error hook
 427 trap - EXIT
 428
 429 if [ -f src/netdata ]
 430     then
 431     echo >&2 "Cleaning a possibly old compilation ..."
 432     run make clean
 433 fi
 434
 435 echo >&2 "Compiling netdata ..."
 436 run make -j${processors} || exit 1
 437
 438 if [ "${BASH_VERSINFO[0]}" -ge "4" ]
 439 then
 440     declare -A configs_signatures=()
 441     if [ -f "configs.signatures" ]
 442         then
 443         source "configs.signatures" || echo >&2 "ERROR: Failed to load configs.signatures !"
 444     fi
 445 fi
 446
 447 # migrate existing configuration files
 448 # for node.d and charts.d
 449 if [ -d "${NETDATA_PREFIX}/etc/netdata" ]
 450     then
 451     # the configuration directory exists
 452
 453     if [ ! -d "${NETDATA_PREFIX}/etc/netdata/charts.d" ]
 454         then
 455         run mkdir "${NETDATA_PREFIX}/etc/netdata/charts.d"
 456     fi
 457
 458     # move the charts.d config files
 459     for x in apache ap cpu_apps cpufreq example exim hddtemp load_average mem_apps mysql nginx nut opensips phpfpm postfix sensors squid tomcat
 460     do
 461         for y in "" ".old" ".orig"
 462         do
 463             if [ -f "${NETDATA_PREFIX}/etc/netdata/${x}.conf${y}" -a ! -f "${NETDATA_PREFIX}/etc/netdata/charts.d/${x}.conf${y}" ]
 464                 then
 465                 run mv -f "${NETDATA_PREFIX}/etc/netdata/${x}.conf${y}" "${NETDATA_PREFIX}/etc/netdata/charts.d/${x}.conf${y}"
 466             fi
 467         done
 468     done
 469
 470     if [ ! -d "${NETDATA_PREFIX}/etc/netdata/node.d" ]
 471         then
 472         run mkdir "${NETDATA_PREFIX}/etc/netdata/node.d"
 473     fi
 474
 475     # move the node.d config files
 476     for x in named sma_webbox snmp
 477     do
 478         for y in "" ".old" ".orig"
 479         do
 480             if [ -f "${NETDATA_PREFIX}/etc/netdata/${x}.conf${y}" -a ! -f "${NETDATA_PREFIX}/etc/netdata/node.d/${x}.conf${y}" ]
 481                 then
 482                 run mv -f "${NETDATA_PREFIX}/etc/netdata/${x}.conf${y}" "${NETDATA_PREFIX}/etc/netdata/node.d/${x}.conf${y}"
 483             fi
 484         done
 485     done
 486 fi
 487
 488 # backup user configurations
 489 installer_backup_suffix="${PID}.${RANDOM}"
 490 for x in $(find "${NETDATA_PREFIX}/etc/netdata/" -name '*.conf' -type f)
 491 do
 492     if [ -f "${x}" ]
 493         then
 494         # make a backup of the configuration file
 495         cp -p "${x}" "${x}.old"
 496
 497         if [ -z "${md5sum}" -o ! -x "${md5sum}" ]
 498             then
 499             # we don't have md5sum - keep it
 500             cp -p "${x}" "${x}.installer_backup.${installer_backup_suffix}"
 501         else
 502             # find it relative filename
 503             f="${x/*\/etc\/netdata\//}"
 504
 505             # find its checksum
 506             md5="$(cat "${x}" | ${md5sum} | cut -d ' ' -f 1)"
 507
 508             # copy the original
 509             if [ -f "conf.d/${f}" ]
 510                 then
 511                 cp "conf.d/${f}" "${x}.orig"
 512             fi
 513
 514             if [ "${BASH_VERSINFO[0]}" -ge "4" ]
 515             then
 516                 if [ "${configs_signatures[${md5}]}" = "${f}" ]
 517                 then
 518                     # it is a stock version - don't keep it
 519                     echo >&2 "File '${x}' is stock version."
 520                 else
 521                     # edited by user - keep it
 522                     echo >&2 "File '${x}' has been edited by user."
 523                     cp -p "${x}" "${x}.installer_backup.${installer_backup_suffix}"
 524                 fi
 525             else
 526                 echo >&2 "File '${x}' cannot be check for custom edits."
 527                 cp -p "${x}" "${x}.installer_backup.${installer_backup_suffix}"
 528             fi
 529         fi
 530
 531     elif [ -f "${x}.installer_backup.${installer_backup_suffix}" ]
 532         then
 533         rm -f "${x}.installer_backup.${installer_backup_suffix}"
 534     fi
 535 done
 536
 537 echo >&2 "Installing netdata ..."
 538 run make install || exit 1
 539
 540 # restore user configurations
 541 for x in $(find "${NETDATA_PREFIX}/etc/netdata/" -name '*.conf' -type f)
 542 do
 543     if [ -f "${x}.installer_backup.${installer_backup_suffix}" ]
 544         then
 545         cp -p "${x}.installer_backup.${installer_backup_suffix}" "${x}"
 546         rm -f "${x}.installer_backup.${installer_backup_suffix}"
 547     fi
 548 done
 549
 550 echo >&2 "Fixing permissions ..."
 551
 552 check_cmd() {
 553     which "${1}" >/dev/null 2>&1 && return 0
 554     command -v "${1}" >/dev/null 2>&1 && return 0
 555     return 1
 556 }
 557
 558 portable_add_user() {
 559     local username="${1}"
 560
 561     getent passwd "${username}" > /dev/null 2>&1
 562     [ $? -eq 0 ] && return 0
 563
 564     echo >&2 "Adding ${username} user account ..."
 565
 566     local nologin="$(which nologin 2>/dev/null || command -v nologin 2>/dev/null || echo '/bin/false')"
 567
 568     # Linux
 569     if check_cmd useradd
 570     then
 571         run useradd -r -g "${username}" -c "${username}" -s "${nologin}" -d / "${username}" && return 0
 572     fi
 573
 574     # FreeBSD
 575     if check_cmd pw
 576     then
 577         run pw useradd "${username}" -d / -g "${username}" -s "${nologin}" && return 0
 578     fi
 579
 580     # BusyBox
 581     if check_cmd adduser
 582     then
 583         run adduser -D -G "${username}" "${username}" && return 0
 584     fi
 585
 586     echo >&2 "Failed to add ${username} user account !"
 587
 588     return 1
 589 }
 590
 591 portable_add_group() {
 592     local groupname="${1}"
 593
 594     getent group "${groupname}" > /dev/null 2>&1
 595     [ $? -eq 0 ] && return 0
 596
 597     echo >&2 "Adding ${groupname} user group ..."
 598
 599     # Linux
 600     if check_cmd groupadd
 601     then
 602         run groupadd -r "${groupname}" && return 0
 603     fi
 604
 605     # FreeBSD
 606     if check_cmd pw
 607     then
 608         run pw groupadd "${groupname}" && return 0
 609     fi
 610
 611     # BusyBox
 612     if check_cmd addgroup
 613     then
 614         run addgroup "${groupname}" && return 0
 615     fi
 616
 617     echo >&2 "Failed to add ${groupname} user group !"
 618     return 1
 619 }
 620
 621 portable_add_user_to_group() {
 622     local groupname="${1}" username="${2}"
 623
 624     getent group "${groupname}" > /dev/null 2>&1
 625     [ $? -ne 0 ] && return 1
 626
 627     # find the users in the docker group
 628     local users=$(getent group "${groupname}" | cut -d ':' -f 4)
 629     if [[ ",${users}," =~ ,${username}, ]]
 630         then
 631         # username is already there
 632         :
 633     else
 634         # username is not in group
 635         echo >&2 "Adding ${username} user to the ${groupname} group ..."
 636
 637         # Linux
 638         if check_cmd usermod
 639         then
 640             run usermod -a -G "${groupname}" "${username}" && return 0
 641         fi
 642
 643         # FreeBSD
 644         if check_cmd pw
 645         then
 646             run pw groupmod "${groupname}" -m "${username}" && return 0
 647         fi
 648
 649         # BusyBox
 650         if check_cmd addgroup
 651         then
 652             run addgroup "${username}" "${groupname}" && return 0
 653         fi
 654
 655         echo >&2 "Failed to add user ${username} to group ${groupname} !"
 656         return 1
 657     fi
 658 }
 659
 660 run find ./system/ -type f -a \! -name \*.in -a \! -name Makefile\* -a \! -name \*.conf  -a \! -name \*.service -exec chmod 755 {} \;
 661
 662 NETDATA_ADDED_TO_DOCKER=0
 663 if [ ${UID} -eq 0 ]
 664     then
 665     portable_add_group netdata
 666     portable_add_user netdata
 667     portable_add_user_to_group docker netdata && NETDATA_ADDED_TO_DOCKER=1
 668
 669     if [ -d /etc/logrotate.d -a ! -f /etc/logrotate.d/netdata ]
 670         then
 671         echo >&2 "Adding netdata logrotate configuration ..."
 672         run cp system/netdata.logrotate /etc/logrotate.d/netdata
 673     fi
 674 fi
 675
 676
 677 # -----------------------------------------------------------------------------
 678 # load options from the configuration file
 679
 680 # create an empty config if it does not exist
 681 [ ! -f "${NETDATA_PREFIX}/etc/netdata/netdata.conf" ] && touch "${NETDATA_PREFIX}/etc/netdata/netdata.conf"
 682
 683 # function to extract values from the config file
 684 config_option() {
 685     local key="${1}" value="${2}" line=
 686
 687     if [ -s "${NETDATA_PREFIX}/etc/netdata/netdata.conf" ]
 688         then
 689         line="$( grep "^[[:space:]]*${key}[[:space:]]*=[[:space:]]*" "${NETDATA_PREFIX}/etc/netdata/netdata.conf" | head -n 1 )"
 690         [ ! -z "${line}" ] && value="$( echo "${line}" | cut -d '=' -f 2 | sed -e "s/^[[:space:]]\+//g" -e "s/[[:space:]]\+$//g" )"
 691     fi
 692
 693     echo "${value}"
 694 }
 695
 696 # the user netdata will run as
 697 if [ "${UID}" = "0" ]
 698     then
 699     NETDATA_USER="$( config_option "run as user" "netdata" )"
 700 else
 701     NETDATA_USER="${USER}"
 702 fi
 703
 704 # the owners of the web files
 705 NETDATA_WEB_USER="$(  config_option "web files owner" "${NETDATA_USER}" )"
 706 NETDATA_WEB_GROUP="$( config_option "web files group" "${NETDATA_WEB_USER}" )"
 707
 708 # debug flags
 709 NETDATA_DEBUG="$( config_option "debug flags" 0 )"
 710
 711 # port
 712 defport=19999
 713 NETDATA_PORT="$( config_option "default port" ${defport} )"
 714 NETDATA_PORT2="$( config_option "port" ${defport} )"
 715
 716 if [ "${NETDATA_PORT}" != "${NETDATA_PORT2}" ]
 717 then
 718     if [ "${NETDATA_PORT2}" != "${defport}" ]
 719     then
 720         NETDATA_PORT="${NETDATA_PORT2}"
 721     fi
 722 fi
 723
 724 # directories
 725 NETDATA_LIB_DIR="$( config_option "lib directory" "${NETDATA_PREFIX}/var/lib/netdata" )"
 726 NETDATA_CACHE_DIR="$( config_option "cache directory" "${NETDATA_PREFIX}/var/cache/netdata" )"
 727 NETDATA_WEB_DIR="$( config_option "web files directory" "${NETDATA_PREFIX}/usr/share/netdata/web" )"
 728 NETDATA_LOG_DIR="$( config_option "log directory" "${NETDATA_PREFIX}/var/log/netdata" )"
 729 NETDATA_CONF_DIR="$( config_option "config directory" "${NETDATA_PREFIX}/etc/netdata" )"
 730 NETDATA_RUN_DIR="${NETDATA_PREFIX}/var/run"
 731
 732
 733 # -----------------------------------------------------------------------------
 734 # prepare the directories
 735
 736 # this is needed if NETDATA_PREFIX is not empty
 737 if [ ! -d "${NETDATA_RUN_DIR}" ]
 738     then
 739     mkdir -p "${NETDATA_RUN_DIR}" || exit 1
 740 fi
 741
 742 echo >&2
 743 echo >&2 "Fixing directories (user: ${NETDATA_USER})..."
 744
 745 # --- conf dir ----
 746
 747 for x in "python.d" "charts.d" "node.d"
 748 do
 749     if [ ! -d "${NETDATA_CONF_DIR}/${x}" ]
 750         then
 751         echo >&2 "Creating directory '${NETDATA_CONF_DIR}/${x}'"
 752         run mkdir -p "${NETDATA_CONF_DIR}/${x}" || exit 1
 753     fi
 754 done
 755 run chown -R "${NETDATA_USER}:${NETDATA_USER}" "${NETDATA_CONF_DIR}"
 756 run find "${NETDATA_CONF_DIR}" -type f -exec chmod 0660 {} \;
 757 run find "${NETDATA_CONF_DIR}" -type d -exec chmod 0775 {} \;
 758
 759 # --- web dir ----
 760
 761 if [ ! -d "${NETDATA_WEB_DIR}" ]
 762     then
 763     echo >&2 "Creating directory '${NETDATA_WEB_DIR}'"
 764     run mkdir -p "${NETDATA_WEB_DIR}" || exit 1
 765 fi
 766 run chown -R "${NETDATA_WEB_USER}:${NETDATA_WEB_GROUP}" "${NETDATA_WEB_DIR}"
 767 run find "${NETDATA_WEB_DIR}" -type f -exec chmod 0664 {} \;
 768 run find "${NETDATA_WEB_DIR}" -type d -exec chmod 0775 {} \;
 769
 770 # --- data dirs ----
 771
 772 for x in "${NETDATA_LIB_DIR}" "${NETDATA_CACHE_DIR}" "${NETDATA_LOG_DIR}"
 773 do
 774     if [ ! -d "${x}" ]
 775         then
 776         echo >&2 "Creating directory '${x}'"
 777         run mkdir -p "${x}" || exit 1
 778     fi
 779
 780     run chown -R "${NETDATA_USER}:${NETDATA_USER}" "${x}"
 781     #run find "${x}" -type f -exec chmod 0660 {} \;
 782     #run find "${x}" -type d -exec chmod 0770 {} \;
 783 done
 784
 785 # --- plugins ----
 786
 787 if [ ${UID} -eq 0 ]
 788     then
 789     run chown -R root "${NETDATA_PREFIX}/usr/libexec/netdata"
 790     run find "${NETDATA_PREFIX}/usr/libexec/netdata" -type d -exec chmod 0755 {} \;
 791     run find "${NETDATA_PREFIX}/usr/libexec/netdata" -type f -exec chmod 0644 {} \;
 792     run find "${NETDATA_PREFIX}/usr/libexec/netdata" -type f -a -name \*.plugin -exec chmod 0755 {} \;
 793     run find "${NETDATA_PREFIX}/usr/libexec/netdata" -type f -a -name \*.sh -exec chmod 0755 {} \;
 794
 795     run setcap cap_dac_read_search,cap_sys_ptrace+ep "${NETDATA_PREFIX}/usr/libexec/netdata/plugins.d/apps.plugin"
 796     if [ $? -ne 0 ]
 797         then
 798         # fix apps.plugin to be setuid to root
 799         run chown root "${NETDATA_PREFIX}/usr/libexec/netdata/plugins.d/apps.plugin"
 800         run chmod 4755 "${NETDATA_PREFIX}/usr/libexec/netdata/plugins.d/apps.plugin"
 801     fi
 802 else
 803     run chown -R "${NETDATA_USER}:${NETDATA_USER}" "${NETDATA_PREFIX}/usr/libexec/netdata"
 804     run find "${NETDATA_PREFIX}/usr/libexec/netdata" -type f -exec chmod 0755 {} \;
 805     run find "${NETDATA_PREFIX}/usr/libexec/netdata" -type d -exec chmod 0755 {} \;
 806 fi
 807
 808 # --- fix #1292 bug ---
 809
 810 [ -d "${NETDATA_PREFIX}/usr/libexec" ] && run chmod a+rX "${NETDATA_PREFIX}/usr/libexec"
 811 [ -d "${NETDATA_PREFIX}/usr/share/netdata" ] && run chmod a+rX "${NETDATA_PREFIX}/usr/share/netdata"
 812
 813
 814 # -----------------------------------------------------------------------------
 815 # check if we can re-start netdata
 816
 817 if [ ${DONOTSTART} -eq 1 ]
 818     then
 819     if [ ! -s "${NETDATA_PREFIX}/etc/netdata/netdata.conf" ]
 820         then
 821         echo >&2 "Generating empty config file in: ${NETDATA_PREFIX}/etc/netdata/netdata.conf"
 822         echo "# Get config from http://127.0.0.1:${NETDATA_PORT}/netdata.conf" >"${NETDATA_PREFIX}/etc/netdata/netdata.conf"
 823
 824         if [ "${UID}" -eq 0 ]
 825             then
 826             chown "${NETDATA_USER}" "${NETDATA_PREFIX}/etc/netdata/netdata.conf"
 827         fi
 828         chmod 0644 "${NETDATA_PREFIX}/etc/netdata/netdata.conf"
 829     fi
 830     banner "is installed now!"
 831     echo >&2 "  enjoy real-time performance and health monitoring..."
 832     exit 0
 833 fi
 834
 835 # -----------------------------------------------------------------------------
 836 # stop a running netdata
 837
 838 isnetdata() {
 839     if [ -d /proc ]
 840     then
 841         [ -z "$1" -o ! -f "/proc/$1/stat" ] && return 1
 842         [ "$(cat "/proc/$1/stat" | cut -d '(' -f 2 | cut -d ')' -f 1)" = "netdata" ] && return 0
 843         return 1
 844     fi
 845     return 0
 846 }
 847
 848 stop_netdata_on_pid() {
 849     local pid="${1}" ret=0 count=0
 850
 851     isnetdata ${pid} || return 0
 852
 853     printf >&2 "Stopping netdata on pid ${pid} ..."
 854     while [ ! -z "$pid" -a ${ret} -eq 0 ]
 855     do
 856         if [ ${count} -gt 45 ]
 857             then
 858             echo >&2 "Cannot stop the running netdata on pid ${pid}."
 859             return 1
 860         fi
 861
 862         count=$(( count + 1 ))
 863
 864         run kill ${pid} 2>/dev/null
 865         ret=$?
 866
 867         test ${ret} -eq 0 && printf >&2 "." && sleep 2
 868     done
 869
 870     echo >&2
 871     if [ ${ret} -eq 0 ]
 872     then
 873         echo >&2 "SORRY! CANNOT STOP netdata ON PID ${pid} !"
 874         return 1
 875     fi
 876
 877     echo >&2 "netdata on pid ${pid} stopped."
 878     return 0
 879 }
 880
 881 stop_all_netdata() {
 882     local p myns ns
 883
 884     myns="$(readlink /proc/self/ns/pid 2>/dev/null)"
 885
 886     echo >&2 "Stopping a (possibly) running netdata..."
 887
 888     for p in $(cat "${NETDATA_RUN_DIR}/netdata.pid" 2>/dev/null) \
 889         $(cat /var/run/netdata.pid 2>/dev/null) \
 890         $(cat /var/run/netdata/netdata.pid 2>/dev/null) \
 891         $(pidof netdata 2>/dev/null)
 892     do
 893         ns="$(readlink /proc/${p}/ns/pid 2>/dev/null)"
 894
 895         if [ -z "${myns}" -o -z "${ns}" -o "${myns}" = "${ns}" ]
 896             then
 897             stop_netdata_on_pid ${p}
 898         fi
 899     done
 900 }
 901
 902 # -----------------------------------------------------------------------------
 903 # check for systemd
 904
 905 issystemd() {
 906     local pids p myns ns systemctl
 907
 908     # if the directory /etc/systemd/system does not exit, it is not systemd
 909     [ ! -d /etc/systemd/system ] && return 1
 910
 911     # if there is no systemctl command, it is not systemd
 912     systemctl=$(which systemctl 2>/dev/null || command -v systemctl 2>/dev/null)
 913     [ -z "${systemctl}" -o ! -x "${systemctl}" ] && return 1
 914
 915     # if pid 1 is systemd, it is systemd
 916     [ "$(basename $(readlink /proc/1/exe) 2>/dev/null)" = "systemd" ] && return 0
 917
 918     # if systemd is not running, it is not systemd
 919     pids=$(pidof systemd 2>/dev/null)
 920     [ -z "${pids}" ] && return 1
 921
 922     # check if the running systemd processes are not in our namespace
 923     myns="$(readlink /proc/self/ns/pid 2>/dev/null)"
 924     for p in ${pids}
 925     do
 926         ns="$(readlink /proc/${p}/ns/pid 2>/dev/null)"
 927
 928         # if pid of systemd is in our namespace, it is systemd
 929         [ ! -z "${myns}" && "${myns}" = "${ns}" ] && return 0
 930     done
 931
 932     # else, it is not systemd
 933     return 1
 934 }
 935
 936 installed_init_d=0
 937 install_non_systemd_init() {
 938     [ "${UID}" != 0 ] && return 1
 939
 940     local key="unknown"
 941     if [ -f /etc/os-release ]
 942         then
 943         source /etc/os-release || return 1
 944         key="${ID}-${VERSION_ID}"
 945
 946     elif [ -f /etc/centos-release ]
 947         then
 948         key=$(</etc/centos-release)
 949     fi
 950
 951     if [ -d /etc/init.d -a ! -f /etc/init.d/netdata ]
 952         then
 953         if [ "${key}" = "gentoo" ]
 954             then
 955             run cp system/netdata-openrc /etc/init.d/netdata && \
 956             run chmod 755 /etc/init.d/netdata && \
 957             run rc-update add netdata default && \
 958             installed_init_d=1
 959
 960         elif [ "${key}" = "ubuntu-12.04" -o "${key}" = "ubuntu-14.04" -o "${key}" = "debian-7" ]
 961             then
 962             run cp system/netdata-lsb /etc/init.d/netdata && \
 963             run chmod 755 /etc/init.d/netdata && \
 964             run update-rc.d netdata defaults && \
 965             run update-rc.d netdata enable && \
 966             installed_init_d=1
 967
 968         elif [ "${key}" = "CentOS release 6.8 (Final)" ]
 969             then
 970             run cp system/netdata-init-d /etc/init.d/netdata && \
 971             run chmod 755 /etc/init.d/netdata && \
 972             run chkconfig netdata on && \
 973             installed_init_d=1
 974         fi
 975     fi
 976
 977     return 0
 978 }
 979
 980 started=0
 981 if [ "${UID}" -eq 0 ]
 982     then
 983
 984     if issystemd
 985     then
 986         # systemd is running on this system
 987
 988         if [ ! -f /etc/systemd/system/netdata.service ]
 989         then
 990             echo >&2 "Installing systemd service..."
 991             run cp system/netdata.service /etc/systemd/system/netdata.service && \
 992                 run systemctl daemon-reload && \
 993                 run systemctl enable netdata
 994         else
 995             service netdata stop
 996         fi
 997
 998         stop_all_netdata
 999         service netdata restart && started=1
1000     else
1001         install_non_systemd_init
1002     fi
1003
1004     if [ ${started} -eq 0 ]
1005     then
1006         # check if we can use the system service
1007         service netdata stop
1008         stop_all_netdata
1009         service netdata restart && started=1
1010         if [ ${started} -eq 0 ]
1011         then
1012             service netdata start && started=1
1013         fi
1014     fi
1015 fi
1016
1017 if [ ${started} -eq 0 ]
1018 then
1019     # still not started...
1020
1021     stop_all_netdata
1022
1023     echo >&2 "Starting netdata..."
1024     run ${NETDATA_PREFIX}/usr/sbin/netdata -P ${NETDATA_RUN_DIR}/netdata.pid "${@}"
1025     if [ $? -ne 0 ]
1026         then
1027         echo >&2
1028         echo >&2 "SORRY! FAILED TO START NETDATA!"
1029         exit 1
1030     else
1031         echo >&2 "OK. NetData Started!"
1032     fi
1033
1034     echo >&2
1035 fi
1036
1037 # -----------------------------------------------------------------------------
1038 # save a config file, if it is not already there
1039
1040 if [ ! -s "${NETDATA_PREFIX}/etc/netdata/netdata.conf" ]
1041     then
1042     echo >&2
1043     echo >&2 "-------------------------------------------------------------------------------"
1044     echo >&2
1045     echo >&2 "Downloading default configuration from netdata..."
1046     sleep 5
1047
1048     # remove a possibly obsolete download
1049     [ -f "${NETDATA_PREFIX}/etc/netdata/netdata.conf.new" ] && rm "${NETDATA_PREFIX}/etc/netdata/netdata.conf.new"
1050
1051     # disable a proxy to get data from the local netdata
1052     export http_proxy=
1053     export https_proxy=
1054
1055     # try wget
1056     wget 2>/dev/null -O "${NETDATA_PREFIX}/etc/netdata/netdata.conf.new" "http://localhost:${NETDATA_PORT}/netdata.conf"
1057     ret=$?
1058
1059     # try curl
1060     if [ ${ret} -ne 0 -o ! -s "${NETDATA_PREFIX}/etc/netdata/netdata.conf.new" ]
1061         then
1062         curl -s -o "${NETDATA_PREFIX}/etc/netdata/netdata.conf.new" "http://localhost:${NETDATA_PORT}/netdata.conf"
1063         ret=$?
1064     fi
1065
1066     if [ ${ret} -eq 0 -a -s "${NETDATA_PREFIX}/etc/netdata/netdata.conf.new" ]
1067         then
1068         mv "${NETDATA_PREFIX}/etc/netdata/netdata.conf.new" "${NETDATA_PREFIX}/etc/netdata/netdata.conf"
1069         echo >&2 "New configuration saved for you to edit at ${NETDATA_PREFIX}/etc/netdata/netdata.conf"
1070
1071         if [ "${UID}" -eq 0 ]
1072             then
1073             chown "${NETDATA_USER}" "${NETDATA_PREFIX}/etc/netdata/netdata.conf"
1074         fi
1075         chmod 0664 "${NETDATA_PREFIX}/etc/netdata/netdata.conf"
1076     else
1077         echo >&2 "Cannnot download configuration from netdata daemon using url 'http://localhost:${NETDATA_PORT}/netdata.conf'"
1078         [ -f "${NETDATA_PREFIX}/etc/netdata/netdata.conf.new" ] && rm "${NETDATA_PREFIX}/etc/netdata/netdata.conf.new"
1079     fi
1080 fi
1081
1082 # -----------------------------------------------------------------------------
1083 # Check for KSM
1084
1085 ksm_is_available_but_disabled() {
1086     cat <<KSM1
1087
1088 -------------------------------------------------------------------------------
1089 Memory de-duplication instructions
1090
1091 You have kernel memory de-duper (called Kernel Same-page Merging,
1092 or KSM) available, but it is not currently enabled.
1093
1094 To enable it run:
1095
1096 echo 1 >/sys/kernel/mm/ksm/run
1097 echo 1000 >/sys/kernel/mm/ksm/sleep_millisecs
1098
1099 If you enable it, you will save 40-60% of netdata memory.
1100
1101 KSM1
1102 }
1103
1104 ksm_is_not_available() {
1105     cat <<KSM2
1106
1107 -------------------------------------------------------------------------------
1108 Memory de-duplication not present in your kernel
1109
1110 It seems you do not have kernel memory de-duper (called Kernel Same-page
1111 Merging, or KSM) available.
1112
1113 To enable it, you need a kernel built with CONFIG_KSM=y
1114
1115 If you can have it, you will save 40-60% of netdata memory.
1116
1117 KSM2
1118 }
1119
1120 if [ -f "/sys/kernel/mm/ksm/run" ]
1121     then
1122     if [ $(cat "/sys/kernel/mm/ksm/run") != "1" ]
1123         then
1124         ksm_is_available_but_disabled
1125     fi
1126 else
1127     ksm_is_not_available
1128 fi
1129
1130 # -----------------------------------------------------------------------------
1131 # Check for version.txt
1132
1133 if [ ! -s web/version.txt ]
1134     then
1135     cat <<VERMSG
1136
1137 -------------------------------------------------------------------------------
1138 Version update check warning
1139
1140 The way you downloaded netdata, we cannot find its version. This means the
1141 Update check on the dashboard, will not work.
1142
1143 If you want to have version update check, please re-install it
1144 following the procedure in:
1145
1146 https://github.com/firehol/netdata/wiki/Installation
1147
1148 VERMSG
1149 fi
1150
1151 # -----------------------------------------------------------------------------
1152 # apps.plugin warning
1153
1154 if [ "${UID}" -ne 0 ]
1155     then
1156     cat <<SETUID_WARNING
1157
1158 -------------------------------------------------------------------------------
1159 apps.plugin needs privileges
1160
1161 Since you have installed netdata as a normal user, to have apps.plugin collect
1162 all the needed data, you have to give it the access rights it needs, by running
1163 either of the following sets of commands:
1164
1165 To run apps.plugin with escalated capabilities:
1166
1167     sudo chown root:${NETDATA_USER} "${NETDATA_PREFIX}/usr/libexec/netdata/plugins.d/apps.plugin"
1168     sudo chmod 0750 "${NETDATA_PREFIX}/usr/libexec/netdata/plugins.d/apps.plugin"
1169     sudo setcap cap_dac_read_search,cap_sys_ptrace+ep "${NETDATA_PREFIX}/usr/libexec/netdata/plugins.d/apps.plugin"
1170
1171 or, to run apps.plugin as root:
1172
1173     sudo chown root "${NETDATA_PREFIX}/usr/libexec/netdata/plugins.d/apps.plugin"
1174     sudo chmod 4755 "${NETDATA_PREFIX}/usr/libexec/netdata/plugins.d/apps.plugin"
1175
1176 apps.plugin is performing a hard-coded function of data collection for all
1177 running processes. It cannot be instructed from the netdata daemon to perform
1178 any task, so it is pretty safe to do this.
1179
1180 SETUID_WARNING
1181 fi
1182
1183 # -----------------------------------------------------------------------------
1184 # Keep un-install info
1185
1186 cat >netdata-uninstaller.sh <<UNINSTALL
1187 #!/usr/bin/env bash
1188
1189 # this script will uninstall netdata
1190
1191 if [ "\$1" != "--force" ]
1192     then
1193     echo >&2 "This script will REMOVE netdata from your system."
1194     echo >&2 "Run it again with --force to do it."
1195     exit 1
1196 fi
1197
1198 echo >&2 "Stopping a possibly running netdata..."
1199 for p in \$(pidof netdata); do kill \$p; done
1200 sleep 2
1201
1202 deletedir() {
1203     if [ ! -z "\$1" -a -d "\$1" ]
1204         then
1205         echo
1206         echo "Deleting directory '\$1' ..."
1207         rm -I -R "\$1"
1208     fi
1209 }
1210
1211 if [ ! -z "${NETDATA_PREFIX}" -a -d "${NETDATA_PREFIX}" ]
1212     then
1213     # installation prefix was given
1214
1215     deletedir "${NETDATA_PREFIX}"
1216
1217 else
1218     # installation prefix was NOT given
1219
1220     if [ -f "${NETDATA_PREFIX}/usr/sbin/netdata" ]
1221         then
1222         echo "Deleting ${NETDATA_PREFIX}/usr/sbin/netdata ..."
1223         rm -i "${NETDATA_PREFIX}/usr/sbin/netdata"
1224     fi
1225
1226     deletedir "${NETDATA_PREFIX}/etc/netdata"
1227     deletedir "${NETDATA_PREFIX}/usr/share/netdata"
1228     deletedir "${NETDATA_PREFIX}/usr/libexec/netdata"
1229     deletedir "${NETDATA_PREFIX}/var/lib/netdata"
1230     deletedir "${NETDATA_PREFIX}/var/cache/netdata"
1231     deletedir "${NETDATA_PREFIX}/var/log/netdata"
1232 fi
1233
1234 if [ -f /etc/logrotate.d/netdata ]
1235     then
1236     echo "Deleting /etc/logrotate.d/netdata ..."
1237     rm -i /etc/logrotate.d/netdata
1238 fi
1239
1240 if [ -f /etc/systemd/system/netdata.service ]
1241     then
1242     echo "Deleting /etc/systemd/system/netdata.service ..."
1243     rm -i /etc/systemd/system/netdata.service
1244 fi
1245
1246 if [ -f /etc/init.d/netdata ]
1247     then
1248     echo "Deleting /etc/init.d/netdata ..."
1249     rm -i /etc/init.d/netdata
1250 fi
1251
1252 getent passwd netdata > /dev/null
1253 if [ $? -eq 0 ]
1254     then
1255     echo
1256     echo "You may also want to remove the user netdata"
1257     echo "by running:"
1258     echo "   userdel netdata"
1259 fi
1260
1261 getent group netdata > /dev/null
1262 if [ $? -eq 0 ]
1263     then
1264     echo
1265     echo "You may also want to remove the group netdata"
1266     echo "by running:"
1267     echo "   groupdel netdata"
1268 fi
1269
1270 getent group docker > /dev/null
1271 if [ $? -eq 0 -a "${NETDATA_ADDED_TO_DOCKER}" = "1" ]
1272     then
1273     echo
1274     echo "You may also want to remove the netdata user from the docker group"
1275     echo "by running:"
1276     echo "   gpasswd -d netdata docker"
1277 fi
1278
1279 UNINSTALL
1280 chmod 750 netdata-uninstaller.sh
1281
1282 # -----------------------------------------------------------------------------
1283
1284 cat <<END
1285
1286
1287 -------------------------------------------------------------------------------
1288
1289 OK. NetData is installed and it is running.
1290
1291 -------------------------------------------------------------------------------
1292
1293 By default netdata listens on all IPs on port ${NETDATA_PORT},
1294 so you can access it with:
1295
1296 http://this.machine.ip:${NETDATA_PORT}/
1297
1298 To stop netdata, just kill it, with:
1299
1300   killall netdata
1301
1302 To start it, just run it:
1303
1304   ${NETDATA_PREFIX}/usr/sbin/netdata
1305
1306
1307 END
1308 echo >&2 "Uninstall script generated: ./netdata-uninstaller.sh"
1309
1310 if [ -d .git ]
1311     then
1312     cat >netdata-updater.sh.new <<REINSTALL
1313 #!/usr/bin/env bash
1314
1315 force=0
1316 [ "\${1}" = "-f" ] && force=1
1317
1318 export PATH="\${PATH}:${PATH}"
1319 export CFLAGS="${CFLAGS}"
1320
1321 INSTALL_UID="${UID}"
1322 if [ "\${INSTALL_UID}" != "\${UID}" ]
1323     then
1324     echo >&2 "This script should be run as user with uid \${INSTALL_UID} but it now runs with uid \${UID}"
1325     exit 1
1326 fi
1327
1328 # make sure we cd to the working directory
1329 cd "${REINSTALL_PWD}" || exit 1
1330
1331 # make sure there is .git here
1332 [ \${force} -eq 0 -a ! -d .git ] && echo >&2 "No git structures found at: ${REINSTALL_PWD} (use -f for force re-install)" && exit 1
1333
1334 # signal netdata to start saving its database
1335 # this is handy if your database is big
1336 pids=\$(pidof netdata)
1337 [ ! -z "\${pids}" ] && kill -USR1 \${pids}
1338
1339 tmp=
1340 if [ -t 2 ]
1341     then
1342     # we are running on a terminal
1343     # open fd 3 and send it to stderr
1344     exec 3>&2
1345 else
1346     # we are headless
1347     # create a temporary file for the log
1348     tmp=\$(mktemp /tmp/netdata-updater-log-XXXXXX.log)
1349     # open fd 3 and send it to tmp
1350     exec 3>\${tmp}
1351 fi
1352
1353 info() {
1354     echo >&3 "\$(date) : INFO: " "\${@}"
1355 }
1356
1357 emptyline() {
1358     echo >&3
1359 }
1360
1361 error() {
1362     echo >&3 "\$(date) : ERROR: " "\${@}"
1363 }
1364
1365 # this is what we will do if it fails (head-less only)
1366 failed() {
1367     error "FAILED TO UPDATE NETDATA : \${1}"
1368
1369     if [ ! -z "\${tmp}" ]
1370     then
1371         cat >&2 "\${tmp}"
1372         rm "\${tmp}"
1373     fi
1374     exit 1
1375 }
1376
1377 get_latest_commit_id() {
1378     git log -1           2>&3 |\\
1379         grep ^commit     2>&3 |\\
1380         head -n 1        2>&3 |\\
1381         cut -d ' ' -f 2  2>&3
1382 }
1383
1384 update() {
1385     [ -z "\${tmp}" ] && info "Running on a terminal - (this script also supports running headless from crontab)"
1386
1387     emptyline
1388
1389     if [ -d .git ]
1390         then
1391         info "Updating netdata source from github..."
1392
1393         last_commit="\$(get_latest_commit_id)"
1394         [ \${force} -eq 0 -a -z "\${last_commit}" ] && failed "CANNOT GET LAST COMMIT ID (use -f for force re-install)"
1395
1396         git pull >&3 2>&3 || failed "CANNOT FETCH LATEST SOURCE (use -f for force re-install)"
1397
1398         new_commit="\$(get_latest_commit_id)"
1399         if [ \${force} -eq 0 ]
1400             then
1401             [ -z "\${new_commit}" ] && failed "CANNOT GET NEW LAST COMMIT ID (use -f for force re-install)"
1402             [ "\${new_commit}" = "\${last_commit}" ] && info "Nothing to be done! (use -f to force re-install)" && exit 0
1403         fi
1404     elif [ \${force} -eq 0 ]
1405         then
1406         failed "CANNOT FIND GIT STRUCTURES IN \$(pwd) (use -f for force re-install)"
1407     fi
1408
1409     emptyline
1410     info "Re-installing netdata..."
1411     ${REINSTALL_COMMAND// --dont-wait/} --dont-wait >&3 2>&3 || failed "FAILED TO COMPILE/INSTALL NETDATA"
1412
1413     [ ! -z "\${tmp}" ] && rm "\${tmp}" && tmp=
1414     return 0
1415 }
1416
1417 # the installer updates this script - so we run and exit in a single line
1418 update && exit 0
1419 ###############################################################################
1420 ###############################################################################
1421 REINSTALL
1422     chmod 755 netdata-updater.sh.new
1423     mv -f netdata-updater.sh.new netdata-updater.sh
1424     echo >&2 "Update script generated   : ./netdata-updater.sh"
1425 elif [ -f "netdata-updater.sh" ]
1426     then
1427     rm "netdata-updater.sh"
1428 fi
1429
1430 banner "is installed and running now!"
1431 echo >&2 "  enjoy real-time performance and health monitoring..."
1432 echo >&2
1433 exit 0