SaltStack Boostrapper for SmartOS

zone-bootstrap.sh

#!/bin/bash
####
## Acheron SaltStack Bootstrap
## ---------------------------
####
### configuration
SALT_VERSION=2016.11
SALT_MASTER=salt-master.example.org
LOGFILE=/var/log/bootstrap.log

### variables
## global
E_ECHO="echo -ne"
[ -e /opt/local/bin/gecho ] && E_ECHO="/opt/local/bin/gecho -ne"
[ -e $(which printf) ] && E_ECHO=$(which printf)
B_FORCE=0
B_MASTER=0
which mdata-get 2> /dev/null > /dev/null
if [ $? -eq 0 ]; then
  B_MASTER_H=$(mdata-get sdc:hostname 2> /dev/null)
  B_MASTER_D=$(mdata-get sdc:dns_domain 2> /dev/null)
  [ "${B_MASTER_H}${B_MASTER_D:+.}${B_MASTER_D}" == "${SALT_MASTER}" ] && B_MASTER=1
  unset B_MASTER_H; unset B_MASTER_D
fi

## SmartOS
SMARTOS_TOOLS=2016Q4
SMARTOS_PIP_PKG="py27-pip"
SMARTOS_BASIC_PKG="
  python27 py27-crypto \
  openssl curl unzip \
"
SMARTOS_EXTRA_PKG="\
  py27-dateutil py27-gnupg py27-cparser \
  py27-cherrypy py27-cffi py27-OpenSSL \
  py27-sqlite3 sqlite3 gcc49 gmake libtool \
"
SMARTOS_BASIC_PIP="wheel libnacl raet cherrypy python-dateutil GitPython"
SMARTOS_EXTRA_PIP="python-gnupg gnupg smmap timelib cffi"

## Ubuntu
UBUNTU_PIP_PKG="python-pip"
UBUNTU_BASIC_PKG="\
  python-cffi python-cherrypy python-libnacl \
  python-msgpack python-pycparser python-gnupg \
  python-raet python-smmap python-timelib \
  python-dateutil python-m2crypto python-wheel \
  python-pysqlite2 python-sqlite python-git \
"

## CentOS
CENTOS_PIP_PKG="python-pip"
CENTOS_BASIC_PKG="\
  deltarpm python-cffi python-cherrypy python-libnacl \
  python2-msgpack python-pycparser python2-gnupg \
  python-raet python-smmap python-timelib \
  python-dateutil m2crypto python-wheel \
  python-sqlite3dbm GitPython pyOpenSSL \
"

### methodes
## logging
log_info() {
  ${E_ECHO} "[II] $1\r\n"
}
log_begin() {
  ${E_ECHO} "[>>] $1\r"
}
log_done() {
  ${E_ECHO} "[OK] $1\r\n"
}
log_fail() {
  ${E_ECHO} "[!!] $1\r\n"
}

## setup path
setup_path() {
  OPATH=$PATH
  [ -d /opt/local ] && export PATH=/opt/local/sbin:/opt/local/bin:$OPATH
  [ -d /opt/tools ] && export PATH=/opt/tools/sbin:/opt/tools/bin:$OPATH
}

setup_var() {
  if [ ${#} -gt 0 ]; then
    argv=($@); argi=0
    while [ ${argi} -lt ${#} ]; do
      param=${argv[$((argi++))]}
      case ${param} in
        --salt|-s)
          value=${argv[((argi++))]}
          if [ ${#value} -lt 6 ]; then
            log_begin "var::parse[${param}] unknown version: ${value}"; log_fail
            exit 1
          fi
          SALT_VERSION=$(echo ${value:-${SALT_VERSION}} | awk -F'.' '{ print $1"."$2 }')
        ;;
        --force|-f)
          B_FORCE=1
        ;;
        --tools|-t)
          value=${argv[((argi++))]}
          value_y=$(echo ${value} | awk -F'Q' '{print $1}' 2> /dev/null)
          value_q=$(echo ${value} | awk -F'Q' '{print $2}' 2> /dev/null)
          if [ ${#value} -lt 6 ] || [ "${value_y:-bad}" == "bad" ] || [ "${value_q:-bad}" == "bad" ]; then
            log_begin "var::parse[${param}] unknown version: ${value}"; log_fail
            exit 1
          fi
          if [ ${value_y:-0} -lt 2016 ]; then
            log_begin "var::parse[${param}] version to old ${value_y}<2016"; log_fail
            exit 1
          fi
          if [ ${value_q:-0} -lt 1 ] || [ ${value_q:-0} -gt 4 ]; then
            log_begin "var::parse[${param}] invalid quarter: ${value_q} not in range 1-4"; log_fail
            exit 1
          fi
          SMARTOS_TOOLS=${value}
        ;;
        --help|-h)
          echo "SmartOS Zone Bootstrap:"
          echo " --help            : print this message"
          echo " --salt {version}  : use salt {version}"
          echo " --tools {version} : use gz-tools {version} for bootstrapping a computenode"
          echo " --force           : do not quick if salt already installed"
          exit 0
        ;;
        *) echo "[>>] ignoring argument ${param} ..." ;;
      esac
    done
  fi

  log_info "var::version = ${SALT_VERSION}"
  log_info "var::tools = ${SMARTOS_TOOLS}"
}

## salt setup
check_salt() {
  log_begin "salt::check::installed"

  which salt-call 2> /dev/null > /dev/null
  if [ $? -eq 0 ]; then
    log_done
    if [ ${B_FORCE:-0} -eq 0 ]; then
      exit 0
    fi
  else
    log_fail
  fi
}

config_salt() {
  ## variables
  ETC_DIR=$1
  CONF_DIR=$2
  [ -z ${ETC_DIR} ] && ETC_DIR=/etc/salt
  [ -z ${CONF_DIR} ] && CONF_DIR=/salt/config

  ## create CONF_DIR
  log_begin "salt::config::mkdir"
  mkdir -p ${CONF_DIR} 2>> ${LOGFILE} >> ${LOGFILE}
  [ $? -eq 0 ] && log_done || log_fail

  ## setup symlink
  log_begin "salt::config::symlink"
  [ -d ${ETC_DIR} ] && rm -r ${ETC_DIR} 2>> ${LOGFILE} >> ${LOGFILE}
  [ -L ${ETC_DIR} ] && rm ${ETC_DIR} 2>> ${LOGFILE} >> ${LOGFILE}
  ln -sf ${CONF_DIR} ${ETC_DIR} 2>> ${LOGFILE} >> ${LOGFILE}
  [ $? -eq 0 ] && log_done || log_fail

  ## generate minion configuration
  log_begin "salt::config::minion"
  cat > ${ETC_DIR}/minion <<EOF
####
## SaltStack Minion Configuration
####
## version: 2.0-bootstrap
##########################################
## identification
id: $(hostname -s)

## network
master: ${SALT_MASTER}
ipv6: False

## directories and files
root_dir: /
pidfile:  /var/run/salt/salt-minion.pid
sock_dir: /var/run/salt/minion
cachedir: /var/cache/salt/minion
pki_dir:  ${CONF_DIR}/pki/minion
hash_type: sha256

## logging
log_level: error
log_level_logfile: warning
log_file: /var/log/salt/minion.log
EOF
  [ $? -eq 0 ] && log_done || log_fail

  ## restore minion keys if possible
  if [ $(mdata-list 2> /dev/null | egrep -c "(minion_key|minion_pub)") -eq 2 ]; then
    log_begin "salt::config::minion::pki_dir"
    mkdir -p ${CONF_DIR}/pki/minion 2>> ${LOGFILE} >> ${LOGFILE}
    [ $? -eq 0 ] && log_done || log_fail
    log_begin "salt::config::minion::private_key"
    mdata-get minion_key > ${CONF_DIR}/pki/minion/minion.pem
    [ $? -eq 0 ] && log_done || log_fail
    log_begin "salt::config::minion::private_pub"
    mdata-get minion_pub > ${CONF_DIR}/pki/minion/minion.pub
    [ $? -eq 0 ] && log_done || log_fail
  fi
}

## setup
# SmartOS
setup_smartos() {
  ## variables
  case $(zonename) in
    global) MODE=global ;;
    *)      MODE=zone   ;;
  esac
  if [ "${MODE}" != "zone" ]; then
    PKG_DIR=/opt/tools
    SMF_PATH=/opt/custom/smf
    CONF_DIR=/usbkey/salt
  else
    PKG_DIR=/opt/local
    SMF_PATH=/opt/local/lib/svc/manifest
    CONF_DIR=
  fi
  log_done "os::detect = smartos"
  log_info "smartos::mode = ${MODE}"

  ## install gz-tools
  if [ "${MODE}" != "zone" ]; then
    log_begin "smartos::${MODE}::tools"
    if [ ! -d /opt/tools ]; then
      TOOLS_URL=https://pkgsrc.joyent.com/packages/SmartOS/bootstrap/bootstrap-${SMARTOS_TOOLS}-tools.tar.gz
      curl -sk -o /tmp/tools.tar.gz ${TOOLS_URL} 2>> ${LOGFILE} >> ${LOGFILE}
      tar -zxpf /tmp/tools.tar.gz -C /
      [ $? -eq 0 ] && log_done || log_fail
      [ -e /tmp/tools.tar.gz ] && rm /tmp/tools.tar.gz 2>> ${LOGFILE} >> ${LOGFILE}
      [ -e /tmp/tools.tar.gz.asc ] && rm /tmp/tools.tar.gz.asc 2>> ${LOGFILE} >> ${LOGFILE}
      setup_path
    else
      log_done
    fi
  fi

  ## update mdata-execute timeout
  if [ "${MODE}" == "zone" ]; then
    if [ ! $(svcprop -p start/timeout_seconds mdata:execute) -eq 1800 ]; then
      log_begin "smartos::${MODE}::mdata-execute"
      svccfg -s mdata:execute setprop 'start/timeout_seconds =  count: (1800)' 2>> ${LOGFILE} >> ${LOGFILE}
      svcadm -v refresh mdata:execute 2>> ${LOGFILE} >> ${LOGFILE}
      svcadm -v restart mdata:execute 2>> ${LOGFILE} >> ${LOGFILE}
      [ $? -eq 0 ] && log_done || log_fail
      exit 0
    fi
  fi

  ## setup repository
  log_begin "smartos::packages::repository"
  if [ $(grep -c pkg.blackdot.be ${PKG_DIR}/etc/pkgin/repositories.conf) -eq 0 ]; then
    curl -sk -o /tmp/pbd-sign.key http://pkg.blackdot.be/pbd-signature.key 2>> ${LOGFILE} >> ${LOGFILE}
    gpg --no-default-keyring --keyring ${PKG_DIR}/etc/gnupg/pkgsrc.gpg --import /tmp/pbd-sign.key 2>> ${LOGFILE} >> ${LOGFILE}
    PKG_VER=$(awk -F/ '/SmartOS/ { print $6 }' ${PKG_DIR}/etc/pkgin/repositories.conf)
    PKG_ARCH=$(awk -F/ '/SmartOS/ { print $7 }' ${PKG_DIR}/etc/pkgin/repositories.conf)
    echo "http://pkg.blackdot.be/packages/${PKG_VER}/${PKG_ARCH}/All" >> ${PKG_DIR}/etc/pkgin/repositories.conf 2>> ${LOGFILE}
    [ $? -eq 0 ] && log_done || log_fail
    log_begin "smartos::packages::refresh"
    pkgin -fy update 2>> ${LOGFILE} >> ${LOGFILE}
    [ $? -eq 0 ] && log_done || log_fail
  else
    log_done
  fi

  ## check install methode
  pkgin -n in salt-${SALT_VERSION} 2> /dev/null > /dev/null
  [ $? -eq 0 ] && B_PKG=1 || B_PKG=0

  ## update pkgsrc
  log_begin "smartos::packages::upgrade"
  pkgin -y full-upgrade 2>> ${LOGFILE} >> ${LOGFILE}
  [ $? -eq 0 ] && log_done || log_fail

  ## install dependencies (use -F on failure)
  for dep in ${SMARTOS_BASIC_PKG}; do
    log_begin "smartos::packages::install[${dep}]"
    pkgin -y in ${dep} 2>> ${LOGFILE} >> ${LOGFILE}
    [ $? -eq 0 ] && log_done || log_fail
  done
  if [ "${MODE}" == "zone" ]; then
    for dep in ${SMARTOS_EXTRA_PKG}; do
      log_begin "smartos::packages::install[${dep}]"
      pkgin -y in ${dep} 2>> ${LOGFILE} >> ${LOGFILE}
      [ $? -eq 0 ] && log_done || log_fail
    done
  fi

  ## install pip
  if [ "${SMARTOS_BASIC_PIP:+yes}" == "yes" ] || [ "${MODE}" == "zone" -a  "${SMARTOS_EXTRA_PIP:+yes}" == "yes" ] || [ ${B_PKG} -eq 0 ]; then
    log_begin "smartos::packages::install[${SMARTOS_PIP_PKG}]"
    pkgin -y in ${SMARTOS_PIP_PKG} 2>> ${LOGFILE} >> ${LOGFILE}
    [ $? -eq 0 ] && log_done || log_fail
  fi

  ## install pip dependencies
  for dep in ${SMARTOS_BASIC_PIP}; do
    log_begin "smartos::pip::install[${dep}]"
    pip install ${dep} 2>> ${LOGFILE} >> ${LOGFILE}
    [ $? -eq 0 ] && log_done || log_fail
  done
  if [ "${MODE}" == "zone" ]; then
    for dep in ${SMARTOS_EXTRA_PIP}; do
      log_begin "smartos::pip::install[${dep}]"
      pip install ${dep} 2>> ${LOGFILE} >> ${LOGFILE}
      [ $? -eq 0 ] && log_done || log_fail
    done
  fi

  ## basic config
  if [ "${MODE}" == "zone" ]; then
    if [ ! -e /.bootstrap_config ]; then
      ## lookup basic config
      log_begin "smartos::${MODE}::config::lookup::hostname"
      HOSTNAME=$(mdata-get sdc:hostname)
      [ $? -eq 0 ] && log_done "smartos::${MODE}::config::lookup::hostname = ${HOSTNAME}" || log_fail
      log_begin "smartos::${MODE}::config::lookup::domain"
      DOMAIN=$(mdata-get sdc:dns_domain)
      [ $? -eq 0 ] && log_done "smartos::${MODE}::config::lookup::domain = ${DOMAIN}" || log_fail

      ## update nodename
      log_begin "smartos::${MODE}::config::nodename"
      echo ${HOSTNAME} > /etc/nodename
      svcadm restart system/identity:node
      [ $? -eq 0 ] && log_done || log_fail

      ## update domainname
      if [ -n ${DOMAIN} ]; then
        log_begin "smartos::${MODE}::config::defaultdomain"
        echo ${DOMAIN} > /etc/defaultdomain
        svcadm restart system/identity:domain
        [ $? -eq 0 ] && log_done || log_fail
      fi

      log_begin "smartos::${MODE}::update::nodename"
      /bin/uname -S ${HOSTNAME} 2>> ${LOGFILE} >> ${LOGFILE}
      [ $? -eq 0 ] && log_done || log_fail

      ## update hosts
      log_begin "smartos::${MODE}::config::hosts"
      echo "::1       localhost localhost.local loghost" > /etc/hosts
      echo "127.0.0.1 localhost localhost.local loghost" >> /etc/hosts
      if [ -n ${DOMAIN} ]; then
        echo "::1       ${HOSTNAME}.${DOMAIN} ${HOSTNAME}" >> /etc/hosts
        echo "127.0.0.1 ${HOSTNAME}.${DOMAIN} ${HOSTNAME}" >> /etc/hosts
      else
        echo "::1       ${HOSTNAME}" >> /etc/hosts
        echo "127.0.0.1 ${HOSTNAME}" >> /etc/hosts
      fi
      [ $? -eq 0 ] && log_done || log_fail

      ## mark configured
      touch /.bootstrap_config
    fi

    ## setup data on salt-master
    if [ ${B_MASTER} -eq 1 ]; then
      log_begin "smartos::${MODE}::config::persistance"
      mkdir -p /data/salt 2>> ${LOGFILE} >> ${LOGFILE}
      [ -d /salt ] && rm -r /salt 2>> ${LOGFILE} >> ${LOGFILE}
      [ -L /salt ] && rm /salt 2>> ${LOGFILE} >> ${LOGFILE}
      ln -sf /data/salt /salt  2>> ${LOGFILE} >> ${LOGFILE}
      [ $? -eq 0 ] && log_done || log_fail
    fi
  fi

  ## install salt
  if [ ${B_PKG} -gt 0 ]; then
    log_begin "smartos::packages::salt::install[${SALT_VERSION}]"
    pkgin -y install salt-${SALT_VERSION} 2>> ${LOGFILE} >> ${LOGFILE}
    [ $? -eq 0 ] && log_done || log_fail
  else
    for dep in $(pkgin show-deps salt | grep '^\s' | grep -v '\snot'); do
      log_begin "smartos::packages::install[${dep}]"
      pkgin -y in ${dep} 2>> ${LOGFILE} >> ${LOGFILE}
      [ $? -eq 0 ] && log_done || log_fail
    done
    log_begin "smartos::pip::salt::install[${SALT_VERSION}]"
    pip install --pre "salt==${SALT_VERSION}.*" 2>> ${LOGFILE} >> ${LOGFILE}
    [ $? -eq 0 ] && log_done || log_fail
    log_begin "smartos::pip::salt::smf::extract"
    pkg_add -f -I -R -P /tmp/pip_salt salt 2>> ${LOGFILE} >> ${LOGFILE}
    svccfg import /tmp/pip_salt/opt/local/lib/svc/manifest/salt.xml 2>> ${LOGFILE} >> ${LOGFILE}
    [ $? -eq 0 ] && log_done || log_fail
    log_begin "smartos::pip::salt::smf::cleanup"
    rm -rf /tmp/pip_salt 2>> ${LOGFILE} >> ${LOGFILE}
    [ $? -eq 0 ] && log_done || log_fail
  fi

  ## preferred salt version
  if [ "${MODE}" == "zone" ]; then
    mkdir -p /opt/local/etc/pkgin
    PKGIN_PREFERRED=/opt/local/etc/pkgin/preferred.conf
  else
    mkdir -p /opt/tools/etc/pkgin
    PKGIN_PREFERRED=/opt/tools/etc/pkgin/preferred.conf
  fi
  log_begin "smartos::packages::preference[salt=${SALT_VERSION}.*]"
  [ -e ${PKGIN_PREFERRED} ] && \
    grep -v '^salt' ${PKGIN_PREFERRED} > ${PKGIN_PREFERRED}-salt
  echo "salt=${SALT_VERSION}.*" >> ${PKGIN_PREFERRED}-salt
  mv ${PKGIN_PREFERRED}-salt ${PKGIN_PREFERRED} 2>> ${LOGFILE} >> ${LOGFILE}
  [ $? -eq 0 ] && log_done || log_fail

  ## configure salt
  config_salt ${PKG_DIR}/etc/salt ${CONF_DIR}

  ## update manifest
  if [ ${B_MASTER} -eq 0 ]; then
    log_begin "smartos::salt::svccfg::update"
    [ "$(svcs -H salt:api 2> /dev/null > /dev/null; echo $?)" -eq 0 ] && \
      svccfg delete salt:api 2>> ${LOGFILE} >> ${LOGFILE}
    [ "$(svcs -H salt:master 2> /dev/null > /dev/null; echo $?)" -eq 0 ] && \
      svccfg delete salt:master 2>> ${LOGFILE} >> ${LOGFILE}
    [ $? -eq 0 ] && log_done || log_fail
  fi

  ## bootstrap
  if [ ${B_MASTER} -eq 1 ]; then
    # salt-master
    if [ ! -e /salt/config/master ]; then
      log_begin "salt::config::master::bootstrap"
      echo "file_client: local"               >> /salt/config/minion
      echo "file_roots:"                      >> /salt/config/minion
      echo "  base:"                          >> /salt/config/minion
      echo "    - /data/salt/states/.extmods" >> /salt/config/minion
      echo "    - /data/salt/states"          >> /salt/config/minion
      echo "pillar_roots:"                    >> /salt/config/minion
      echo "  base:"                          >> /salt/config/minion
      echo "    - /data/salt/pillar"          >> /salt/config/minion
      salt-call --local state.apply role.salt.master 2>> ${LOGFILE} >> ${LOGFILE}
      [ $? -eq 0 ] && log_done || log_fail
    else
      log_begin "salt::config::master::enable"
      svcadm enable salt:master 2>> ${LOGFILE} >> ${LOGFILE}
      [ $? -eq 0 ] && log_done || log_fail
    fi
  fi
  log_begin "salt::config::minion::enable"
  svcadm enable salt:minion 2>> ${LOGFILE} >> ${LOGFILE}
  [ $? -eq 0 ] && log_done || log_fail
  if [ ${MODE} != 'zone' ]; then
    log_begin "salt::config::minion::persistent"
    [ -e /opt/custom/smf/salt.xml ] && rm /opt/custom/smf/salt.xml
    svccfg export salt > /opt/tools/lib/svc/manifest/salt.xml
    ln -sf /opt/tools/lib/svc/manifest/salt.xml /opt/custom/smf/salt.xml
    [ $? -eq 0 ] && log_done || log_fail
  fi
}

# Linux Generic (SystemD)
setup_lx_systemd() {
  ## basic config
  if [ ! -e /.bootstrap_config ]; then
    ## detect SmartOS
    which mdata-get 2> /dev/null > /dev/null
    if [ $? -eq 0 ]; then
      ## lookup hostname and domain on SmartOS
      log_begin "systemd::config::lookup::hostname"
      HOSTNAME=$(mdata-get sdc:hostname)
      [ $? -eq 0 ] && log_done "systemd::config::lookup::hostname = ${HOSTNAME}" || log_fail
      log_begin "systemd::config::lookup::domain"
      DOMAIN=$(mdata-get sdc:dns_domain)
      [ $? -eq 0 ] && log_done "systemd::config::lookup::domain = ${DOMAIN}" || log_fail

      ## hostname
      log_begin "systemd::config::hostname"
      hostnamectl set-hostname ${HOSTNAME}
      echo ${HOSTNAME} > /etc/hostname
      [ $? -eq 0 ] && log_done || log_fail

      ## update domainname
      if [ -n ${DOMAIN} ]; then
        log_begin "systemd::${MODE}::config::defaultdomain"
        echo ${DOMAIN} > /etc/defaultdomain
        [ $? -eq 0 ] && log_done || log_fail
      fi

      ## hosts and domainname
      log_begin "systemd::config::hosts"
      echo "::1         localhost localhost.localdomain localhost6 localhost6.localdomain6" > /etc/hosts
      echo "127.0.0.1   localhost localhost.localdomain localhost4 localhost4.localdomain4" >> /etc/hosts
      if [ -n ${DOMAIN} ]; then
        echo "::1       ${HOSTNAME}.${DOMAIN} ${HOSTNAME}" >> /etc/hosts
        echo "127.0.0.1 ${HOSTNAME}.${DOMAIN} ${HOSTNAME}" >> /etc/hosts
      else
        echo "::1       ${HOSTNAME}" >> /etc/hosts
        echo "127.0.0.1 ${HOSTNAME}" >> /etc/hosts
      fi
      [ $? -eq 0 ] && log_done || log_fail
    fi

    ## mark configured
    touch /.bootstrap_config
  fi
}

config_systemd() {
  case ${OSDIST} in
    Ubuntu) SYSDPATH=/lib/systemd/system ;;
    *) SYSDPATH=/usr/lib/systemd/system ;;
  esac
  if [ ! -e ${SYSDPATH}/salt-minion.service ]; then
    log_begin "systemd::config::service::salt-minion.service"
    cat > ${SYSDPATH}/salt-minion.service <<EOF
[Unit]
Description=The Salt Minion
After=syslog.target network.target

[Service]
Type=simple
ExecStart=$(which salt-minion)

[Install]
WantedBy=multi-user.target
EOF
    [ $? -eq 0 ] && log_done || log_fail
  fi

  log_begin "systemd::salt-minion"
  systemctl enable salt-minion 2>> ${LOGFILE} >> ${LOGFILE}
  systemctl restart salt-minion 2>> ${LOGFILE} >> ${LOGFILE}
  [ $? -eq 0 ] && log_done || log_fail
}

# CentOS
setup_centos() {
  CENTOS_RELEASE=$(cat /etc/redhat-release | awk '{ print $4 }')
  log_done "os::detect = centos ${CENTOS_RELEASE}"

  ## check version
  log_begin "centos::version"
  case ${CENTOS_RELEASE} in
    7.2*) log_done ;;
    *) log_fail "centos::version = unsupported" && exit 1 ;;
  esac

  ## add aditional repo
  log_begin "centos::packages::repo::epel"
  if [ $(yum -q repoinfo epel | grep -c 'Repo-id') -lt 1 ]; then
    yum -q -y install epel-release 2>> ${LOGFILE} >> ${LOGFILE}
  fi
  [ $? -eq 0 ] && log_done || log_fail

  log_begin "centos::packages::repository::saltstack"
  if [ $(yum -q repoinfo salt-${SALT_VERSION} | grep -c 'Repo-id') -lt 1 ]; then
    yum -q -y install http://repo.saltstack.com/yum/redhat/salt-repo-${SALT_VERSION}-1.el7.noarch.rpm 2>> ${LOGFILE} >> ${LOGFILE}
  fi
  [ $? -eq 0 ] && log_done || log_fail

  ## cleanup packages
  log_begin "centos::packages::clean"
  yum -q -y clean all -y 2>> ${LOGFILE} >> ${LOGFILE}
  [ $? -eq 0 ] && log_done || log_fail

  ## update packages
  log_begin "centos::packages::upgrade"
  yum -y upgrade 2>> ${LOGFILE} >> ${LOGFILE}
  [ $? -eq 0 ] && log_done || log_fail

  ## check install methode
  yum -q info salt-${SALT_VERSION}.* 2> /dev/null > /dev/null
  [ $? -eq 0 ] && B_PKG=1 || B_PKG=0

  ## install dependencies
  for dep in ${CENTOS_BASIC_PKG}; do
    log_begin "centos::packages::install[${dep}]"
    yum -q -y install ${dep} 2>> ${LOGFILE} >> ${LOGFILE}
    [ $? -eq 0 ] && log_done || log_fail
  done

  ## install pip
  if [ "${CENTOS_BASIC_PIP:+yes}" == "yes" ] || [ "${CENTOS_EXTRA_PIP:+yes}" == "yes" ] || [ ${B_PKG} -eq 0 ]; then
    log_begin "centos::packages::install[${CENTOS_PIP_PKG}]"
    yum -q -y install ${CENTOS_PIP_PKG} 2>> ${LOGFILE} >> ${LOGFILE}
    [ $? -eq 0 ] && log_done || log_fail
  fi

  ## basic linux configuration
  setup_lx_systemd

  ## setup salt
  if [ ${B_PKG} -gt 0 ]; then
    log_begin "centos:packages:::salt::install"
    yum -q -y install salt-${SALT_VERSION}.* salt-minion-${SALT_VERSION}.* salt-ssh-${SALT_VERSION}.* 2>> ${LOGFILE} >> ${LOGFILE}
    [ $? -eq 0 ] && log_done || log_fail
  else
    for dep in $(yum -q deplist salt salt-minion salt-ssh | grep provider | awk '{ print $2 }' | awk -F'.' '{ print $1 }' | grep -v 'salt' | uniq); do
      log_begin "centos::packages::install[${dep}]"
      yum -q -y install ${dep} 2>> ${LOGFILE} >> ${LOGFILE}
      [ $? -eq 0 ] && log_done || log_fail
    done
    log_begin "centos::pip::salt::install[${SALT_VERSION}]"
    pip install --pre "salt==${SALT_VERSION}.*" 2>> ${LOGFILE} >> ${LOGFILE}
    [ $? -eq 0 ] && log_done || log_fail
  fi

  ## configure salt
  config_salt /etc/salt

  ## setup services
  config_systemd
}

# Ubuntu
setup_ubuntu() {
  UBUNTU_RELEASE=$(lsb_release -r | awk '{ print $2 }')
  UBUNTU_CODENAME=$(lsb_release -c | awk '{ print $2 }')
  log_done "os::detect = ubuntu ${UBUNTU_RELEASE}"

  ## check version
  log_begin "ubuntu::version"
  case ${UBUNTU_RELEASE} in
    16.04) log_done ;;
    *) log_fail "ubuntu::version = unsupported" && exit 1 ;;
  esac

  ## update ENV
  log_begin "ubuntu::package::configure"
  export DEBIAN_FRONTEND=noninteractive
  [ $? -eq 0 ] && log_done || log_fail

  ## add aditional repos
  if [ "$(curl -s -o /dev/null -w "%{http_code}" https://repo.saltstack.com/apt/ubuntu/${UBUNTU_RELEASE}/amd64/${SALT_VERSION}/SALTSTACK-GPG-KEY.pub)" -eq 200 ]; then
    log_begin "ubuntu::packages::repository::saltstack"
    wget -q -O - https://repo.saltstack.com/apt/ubuntu/${UBUNTU_RELEASE}/amd64/${SALT_VERSION}/SALTSTACK-GPG-KEY.pub | apt-key add - 2>> ${LOGFILE} >> ${LOGFILE}
    echo "deb http://repo.saltstack.com/apt/ubuntu/${UBUNTU_RELEASE}/amd64/${SALT_VERSION} ${UBUNTU_CODENAME} main" > /etc/apt/sources.list.d/saltstack.list 2>> ${LOGFILE}
    [ $? -eq 0 ] && log_done || log_fail
  fi

  ## update package list
  log_begin "ubuntu::packages::update"
  apt-get update 2>> ${LOGFILE} >> ${LOGFILE}
  [ $? -eq 0 ] && log_done || log_fail

  ## check install methode
  apt-cache show salt-common=${SALT_VERSION}.* 2> /dev/null > /dev/null
  [ $? -eq 0 ] && B_PKG=1 || B_PKG=0

  ## cleanup packages
  log_begin "ubuntu::packages::clean"
  apt-get clean -y 2>> ${LOGFILE} >> ${LOGFILE}
  [ $? -eq 0 ] && log_done || log_fail

  ## upgrade packages
  log_begin "ubuntu::packages::upgrade"
  apt-get upgrade -y 2>> ${LOGFILE} >> ${LOGFILE}
  [ $? -eq 0 ] && log_done || log_fail

  ## install dependencies
  for dep in ${UBUNTU_BASIC_PKG}; do
    log_begin "ubuntu::packages::install[${dep}]"
    apt-get install -y ${dep} 2>> ${LOGFILE} >> ${LOGFILE}
    [ $? -eq 0 ] && log_done || log_fail
  done

  ## install pip
  if [ "${UBUNTU_BASIC_PIP:+yes}" == "yes" ] || [ "${UBUNTU_EXTRA_PIP:+yes}" == "yes" ] || [ ${B_PKG} -eq 0 ]; then
    log_begin "ubuntu::packages::install[${UBUNTU_PIP_PKG}]"
    apt-get install -y ${UBUNTU_PIP_PKG} 2>> ${LOGFILE} >> ${LOGFILE}
    [ $? -eq 0 ] && log_done || log_fail
  fi

  ## basic linux configuration
  setup_lx_systemd

  ## setup salt
  if [ ${B_PKG} -gt 0 ]; then
    log_begin "ubuntu::packages::salt::install"
    apt-get install \
      -o Dpkg::Options::="--force-confnew" -o Dpkg::Options::="--force-overwrite" --allow-downgrades -y \
      salt-common=${SALT_VERSION}.* salt-minion=${SALT_VERSION}.* salt-ssh=${SALT_VERSION}.* 2>> ${LOGFILE} >> ${LOGFILE}
    [ $? -eq 0 ] && log_done || log_fail
  else
    for dep in $(apt-cache depends salt-common salt-minion salt-ssh | grep 'Depends' | awk -F': ' '{ print $2 }' | grep '^python'); do
      log_begin "ubuntu::packages::install[${dep}]"
      apt-get install -y ${dep} 2>> ${LOGFILE} >> ${LOGFILE}
      [ $? -eq 0 ] && log_done || log_fail
    done
    log_begin "ubuntu::pip::salt::install[${SALT_VERSION}]"
    pip install --pre "salt==${SALT_VERSION}.*" 2>> ${LOGFILE} >> ${LOGFILE}
    [ $? -eq 0 ] && log_done || log_fail
  fi

  ## configure salt
  config_salt /etc/salt

  ## setup services
  config_systemd
}

### main
setup_path
setup_var $@
check_salt
log_begin "os::detect"

OSTYPE=$(uname)
case ${OSTYPE} in
  SunOS)
    OSDIST=$(uname -v)
    case ${OSDIST} in
      joyent_*) setup_smartos ;;
      *) log_fail "${OSTYPE} distribution ${OSDIST} not supported!" && exit 1 ;;
    esac
  ;;
  Linux)
    if [ -e /etc/redhat-release ]; then
      OSDIST=$(cat /etc/redhat-release | awk '{ print $1 }')
    else
      OSDIST=$(lsb_release -i -s)
    fi
    case ${OSDIST} in
      Ubuntu) setup_ubuntu ;;
      CentOS*) setup_centos ;;
      *) log_fail "${OSTYPE} distribution ${OSDIST} not supported!" && exit 1 ;;
    esac
  ;;
  *) log_fail "${OSTYPE} not supported!" && exit 1 ;;
esac
exit 0

# vim: tabstop=2 expandtab shiftwidth=2 softtabstop=2