Default setup

main.sh

#!/bin/bash

#######################################################################
##
## START HEADER SCRIPT
##
#######################################################################

type realpath &>/dev/null
if [ $? -eq 1 ]; then
    sudo apt-get -qq update && sudo apt-get -qq install realpath -y
fi

SCRIPT_PATH=$(dirname $(realpath -s $0))
BASENAME=$(basename $0)

#############################
## END HEADER SCRIPT ##
#######################

export DEBIAN_FRONTEND=noninteractive

. ${SCRIPT_PATH}/validate.sh
. ${SCRIPT_PATH}/test.sh
. ${SCRIPT_PATH}/setup_functions.sh

getCommand ()
{
    local DEFAULT=help
    local ARG=${@}
    local LENGTH=$(howmany ${ARG})

    IFS=' ' read -a array <<< ${ARG}
    if [ $(( LENGTH - 1 )) -lt 0 ]
    then
        echo ${DEFAULT}
    else
        local CMD=${array[$(($LENGTH - 1))]}
        echo ${CMD}
    fi
}

usage ()
{
    echo "Usage: ${BASENAME} [OPTIONS] COMMAND [ARG]"
    echo
    echo "My environment setup for linux host"
    echo
    echo "Options:"
    echo
    echo "  --user=root    Install profile for specific user, comma separate."
    echo "                 Example: --user=root,dev"
    echo
    echo "  --pkg=all      Sepecific setup function, default is install all available function."
    echo "                 Example: --pkg=locale,common"
    echo
    echo "Commands:"
    echo
    echo "  install        Install function."
    echo "  help           Show this message."
    echo
    echo "Available setup functions:"
    echo
    echo "  all,locale,common,php_and_apache2,composer"
    echo "  ssl,phalcon,mariadb,docker,fig_alias"
    echo "  bower,ssl_vhost"
    echo
}

setup ()
{
    local ARGS=${@}
    local SETUP_PROFILE_ARG="$(whoami)"
    local SETUP_PKG_ARG="all"

    IFS=' ' read -ra ARG <<< ${ARGS}
    for OPTIONS in ${ARG[@]}
    do
        IFS='=' read -ra OPTION <<< ${OPTIONS}

        local OPTION_ARG=${OPTION[0]}
        local ARGUMENT_ARG=${OPTION[1]}

        case ${OPTION_ARG} in
            "--user")
                SETUP_PROFILE_ARG=${ARGUMENT_ARG}
                ;;
            "--pkg")
                SETUP_PKG_ARG=${ARGUMENT_ARG}
                ;;
        esac
    done

    setupPkg     ${SETUP_PKG_ARG}
    setupProfile ${SETUP_PROFILE_ARG}
}

pkgname ()
{
    local PREFIX="setup_"
    local PKG=${1}
    echo "${PREFIX}${PKG}"
}

setupProfile ()
{
    local USERS=${1}
    IFS=',' read -ra USER <<< ${USERS}
    for user in ${USER[@]}; do
        callSetup $(pkgname dotfiles) ${user}
    done
}

setupPkg ()
{
    local PKGS=${1}
    local PREFIX="setup_"
    IFS=',' read -ra PKG <<< ${PKGS}
    for pkg in ${PKG[@]}
    do
        callSetup $(pkgname ${pkg})
    done
}

callSetup ()
{
    ${@}
}

main ()
{
    if [[ "test" = "${1}" ]]
    then
        runTest
    else
        if validateAllArgument ${@}
        then
            local COMMAND=$(getCommand ${@})
            case ${COMMAND} in
                install)
                    setup ${@}
                    ;;
                help)
                    usage
                    ;;
            esac
        else
            usage
        fi
    fi
}

main "$@"

setup_functions.sh

#!/bin/bash

#######################################################################
##
## START HEADER SCRIPT
##
#######################################################################

type realpath &>/dev/null
if [ $? -eq 1 ]; then
    sudo apt-get -qq update && sudo apt-get -qq install realpath -y
fi

SCRIPT_PATH=$(dirname $(realpath -s $0))
BASENAME=$(basename $0)

#############################
## END HEADER SCRIPT ##
#######################

setup_mirror ()
{
    sudo sed -i 's/archive.ubuntu.com/mirror.psu.ac.th/' /etc/apt/sources.list
    sudo sed -i 's/security.ubuntu.com/mirror.psu.ac.th/' /etc/apt/sources.list
}

setup_locale ()
{
    sudo locale-gen en_US en_US.UTF-8 th_TH th_TH.UTF-8
}

setup_common ()
{
    sudo apt-get update && \
    sudo apt-get install -y curl git zsh tmux vim vim-nox gcc make openssh-server
}

setup_php_and_apache2 ()
{
    sudo apt-get update && \
    sudo apt-get install -y \
        php5 apache2 \
        php5-mysql php-apc php5-mcrypt \
        php5-curl php5-gd php5-json php5-cli \
        php5-dev php5-imagick \
        php5-intl php5-mongo php5-imap

    sudo php5enmod imap
    sudo php5enmod mcrypt

    sudo service apache2 restart
    sleep 3
}

setup_composer ()
{
    if type composer &>/dev/null
    then
        echo "Composer found"
    else
        echo "Error: Composer not found"
        curl -sS https://getcomposer.org/installer | php
        sudo mv composer.phar /usr/local/bin/composer
    fi
}

setup_ssl ()
{
    local SSL_DIR="/opt/ssl"
    local SSL_NAME="sran"

    local SUB_COUNTRY="TH"
    local SUB_STATE="Bangkok"
    local SUB_CITY="LAKSI"
    local SUB_ORG="SRAN Technology Co.,Ltc."
    local SUB_UNIT="IT Security"
    local SUB_COMMON="sran.dev"
    local SUB_EMAIL="sran-dev@gbtech.co.th"

    sudo mkdir -p ${SSL_DIR}
    sudo openssl req -new -x509 -days 3650 -sha1 -newkey rsa:2048 \
        -nodes -keyout ${SSL_DIR}/${SSL_NAME}.key \
        -out ${SSL_DIR}/${SSL_NAME}.crt \
        -subj "/C=${SUB_COUNTRY}/ST=${SUB_STATE}/L=${SUB_CITY}/O=${SUB_ORG}/OU=${SUB_UNIT}/CN=${SUB_COMMON}/emailAddress=${SUB_EMAIL}"

    sudo chmod 644 -R ${SSL_DIR}

    sudo sed -i 's/SSLCipherSuite ALL:!ADH:!EXPORT56:RC4+RSA:+HIGH:+MEDIUM:+LOW:+SSLv2:+EXP:+eNULL/SSLCipherSuite ALL:!aNULL:!ADH:!eNULL:!LOW:!EXP:RC4+RSA:+HIGH:+MEDIUM/' \
        /etc/apache2/mods-available/ssl.conf
    sudo sed -i 's/SSLProtocol all -SSLv2/SSLProtocol -ALL +SSLv3 +TLSv1/' \
        /etc/apache2/mods-available/ssl.conf

    a2enmod ssl
    a2enmod rewrite
}

setup_phalcon ()
{
    if [ ! -f /etc/php5/mods-available/phalcon.ini ]; then
        sudo apt-get update && \
        sudo apt-get install -y libpcre3-dev
        git clone --depth=1 git://github.com/phalcon/cphalcon.git ~/cphalcon
        cd ~/cphalcon/build && ./install;
        echo "extension=phalcon.so" | sudo tee /etc/php5/mods-available/phalcon.ini ;
        sudo php5enmod phalcon
    fi
}

setup_mariadb ()
{
    if type mysqld &>/dev/null
    then
        echo "MariaDB found"
    else
        echo "Error: MariaDB not found"
        sudo apt-key adv --recv-keys --keyserver hkp://keyserver.ubuntu.com:80 0xcbcb082a1bb943db && \
            echo 'deb http://mirrors.syringanetworks.net/mariadb/repo/10.1/ubuntu trusty main' | sudo tee --append /etc/apt/sources.list && \
            echo 'deb-src http://mirrors.syringanetworks.net/mariadb/repo/10.1/ubuntu trusty main' | sudo tee --append /etc/apt/sources.list && \
            sudo apt-get update && \
            sudo apt-get install -y mariadb-server pwgen
        sleep 10;
    fi

    sudo service mysql restart
}

setup_docker ()
{
    if type docker &>/dev/null
    then
        echo 'Docker found'
    else
        echo 'Error: Docker not found'
        curl -sSL https://get.docker.com/ | sudo sh
        sudo usermod -a -G docker $(whoami)
    fi

    if type docker-compose &>/dev/null
    then
        echo 'Docker-compose found'
    else
        echo 'Error: Docker-compose not found'
        curl -L https://github.com/docker/compose/releases/download/1.3.3/docker-compose-`uname -s`-`uname -m` > /tmp/docker-compose
        sudo mv /tmp/docker-compose /usr/local/bin/docker-compose
        sudo chmod +x /usr/local/bin/docker-compose
    fi
}

setup_fig_alias ()
{
    if type docker-compose &>/dev/null
    then
        echo 'Docker-compose found'
        sudo ln -s $(which docker-compose) /usr/local/bin/fig
    else
        echo 'Error: Docker-compose not found'
    fi
}

setup_bower ()
{
    if type nodejs &>/dev/null
    then
        echo 'NodeJS found'
    else
        echo 'Error: NodeJS not found'
        curl -sL https://deb.nodesource.com/setup | sudo bash -
        sudo apt-get install -y nodejs build-essential
    fi
    
    sudo npm install npm@latest -g
    
    if type bower &>/dev/null
    then
        echo 'Bower found'
    else
        echo 'Error: Bower not found'
        sudo npm install -g bower
    fi
}

setup_dotfiles ()
{
    local SSH_USER=$1
    local HOME_PATH=$(eval echo ~${SSH_USER})

    if [ ! -f ${HOME_PATH}/.vimrc ]; then

        ##
        ## Check only ~/.vimrc file
        ##
        echo "${SSH_USER}: .vimrc not found";
        echo "CLEAN: ~/.vim, ~/dotfiles, ~/.vimrc, ~/.zshrc, ~/.oh-my-zsh";
        cd ${HOME_PATH}

        ##
        ## Clean
        ##
        rm -rf ${HOME_PATH}/.vim
        rm -rf ${HOME_PATH}/dotfiles
        rm -rf ${HOME_PATH}/.vimrc
        rm -rf ${HOME_PATH}/.zshrc
        rm -rf ${HOME_PATH}/.oh-my-zsh
        rm -rf ${HOME_PATH}/.tmux.conf

        ##
        ## Setup vim plugins
        ##
        echo "INSTALL: vim plugins and oh-my-zsh";
        su ${SSH_USER} -c "git clone https://github.com/gmarik/Vundle.vim.git ${HOME_PATH}/.vim/bundle/Vundle.vim"
        su ${SSH_USER} -c "git clone https://xemoe@bitbucket.org/xemoe/vimrc.git ${HOME_PATH}/dotfiles"
        su ${SSH_USER} -c "echo 'source ~/dotfiles/vimrc.vim' > ${HOME_PATH}/.vimrc"
        # su ${SSH_USER} -c "echo 'source ~/dotfiles/autocomplete.vim' >> ${HOME_PATH}/.vimrc"
        su ${SSH_USER} -c "vim +PluginInstall +qall"
        su ${SSH_USER} -c "echo export TERM=xterm >> ${HOME_PATH}/.zshrc"

        cd ${HOME_PATH}/.vim/bundle/vimproc.vim/
        su ${SSH_USER} -c "make"

        ##
        ## Copy zshrc configuration file
        ##
        su ${SSH_USER} -c "git clone git://github.com/robbyrussell/oh-my-zsh.git ${HOME_PATH}/.oh-my-zsh"
        su ${SSH_USER} -c "cp ${HOME_PATH}/.oh-my-zsh/templates/zshrc.zsh-template ${HOME_PATH}/.zshrc"

        ##
        ## Copy tmux.conf configuration file
        ##
        su ${SSH_USER} -c "cp ${HOME_PATH}/dotfiles/tmux.conf ${HOME_PATH}/.tmux.conf"
    fi

    git config --global alias.st status
    git config --global alias.lg "log --color --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr)%C(bold blue)<%an>%Creset' --abbrev-commit"
}

setup_ssl_vhost ()
{
    return 0
}

setup_all ()
{
    setup_mirror
    setup_locale
    setup_common
    setup_php_and_apache2
    setup_composer
    setup_ssl
    setup_phalcon
    setup_docker
    setup_fig_alias
    setup_bower
    setup_dotfiles
    return 0
}

stub.sh

#!/bin/bash

#######################################################################
##
## START HEADER SCRIPT
##
#######################################################################

type realpath &>/dev/null
if [ $? -eq 1 ]; then
    sudo apt-get -qq update && sudo apt-get -qq install realpath -y
fi

SCRIPT_PATH=$(dirname $(realpath -s $0))
BASENAME=$(basename $0)

#############################
## END HEADER SCRIPT ##
#######################

##
## Stub function
##

usage ()
{
    echo usage
}

setup_all ()
{
    printf "setup_all;"
}

setup_locale ()
{
    printf "setup_locale;"
}

setup_common ()
{
    printf "setup_common;"
}

setup_dotfiles ()
{
    printf "setup_dotfiles ${1};"
}

test.sh

#!/bin/bash

#######################################################################
##
## START HEADER SCRIPT
##
#######################################################################

type realpath &>/dev/null
if [ $? -eq 1 ]; then
    sudo apt-get -qq update && sudo apt-get -qq install realpath -y
fi

SCRIPT_PATH=$(dirname $(realpath -s $0))
BASENAME=$(basename $0)

#############################
## END HEADER SCRIPT ##
#######################

E_ASSERT_FAILED=99
E_PARAM_ERR=98

color_green="\033[01;32;5;160m"
color_yellow="\033[01;33;5;160m"
color_cyan="\033[01;36;5;160m"
color_white="\033[01;37;5;160m"
color_red="\033[01;38;5;160m"

log_info ()
{
    echo -e "${color_green}[$(date +"%F %R:%S")]: ${color_white}${1}"
}

log_error ()
{
    echo -e "${color_red}[$(date +"%F %R:%S")]: ${color_white}${1}"
}

assertTrue ()
{
    if [ "$#" -lt 2 ]
    then
        return $E_PARAM_ERR
    fi

    local EXPRESSION=${1}
    printf "Assertion: ${EXPRESSION}"

    ##
    ## Assert err on return 1
    ##
    if ! $( ${EXPRESSION} )
    then
        echo -e " ${color_red}failed${color_white} "
        echo
        echo "Assertion failed:  \"${EXPRESSION}\""
        echo "Expect tobe true"
        echo "File \"$0\", line ${LINEERR}"
        exit $E_ASSERT_FAILED
    else
        echo -e " ${color_green}pass${color_white} "
    fi
}

assertFalse ()
{
    if [ "$#" -lt 2 ]
    then
        return $E_PARAM_ERR
    fi

    local EXPRESSION=${1}
    printf "Assertion: ${EXPRESSION}"

    ##
    ## Assert err on return 0
    ##
    if $( ${EXPRESSION} )
    then
        echo -e " ${color_red}failed${color_white} "
        echo
        echo "Assertion failed:  \"${EXPRESSION}\""
        echo "Expect tobe false"
        echo "File \"$0\", line ${LINEERR}"
        exit $E_ASSERT_FAILED
    else
        echo -e " ${color_green}pass${color_white} "
    fi
}

assertEquals ()
{
    if [ "$#" -lt 3 ]
    then
        return $E_PARAM_ERR
    fi

    local EXPECT=${1}
    local EXPRESSION=${2}
    local LINEERR=${3}

    local CONDITION=$(${EXPRESSION})

    printf "Assertion: ${EXPRESSION}"

    ##
    ## Assert err on not equals
    ##
    if [[ ! "${EXPECT}" = "${CONDITION}" ]]
    then
        echo -e " ${color_red}failed${color_white} "
        echo
        echo "Assertion failed:  \"${EXPRESSION}\""
        echo "Expect \"${CONDITION}\" tobe \"${EXPECT}\""
        echo "File \"$0\", line ${LINEERR}"
        exit $E_ASSERT_FAILED
    else
        echo -e " ${color_green}pass${color_white} "
    fi
}

runTest ()
{
    echo "Run test:"

    ##
    ## Test validateCommand
    ##

    assertTrue  "validateCommand install" $LINENO
    assertTrue  "validateCommand help"    $LINENO

    assertFalse "validateCommand"         $LINENO
    assertFalse "validateCommand foo"     $LINENO
    assertFalse "validateCommand foo,bar" $LINENO

    ##
    ## Test validateOption
    ##

    assertTrue  "validateOption --user"   $LINENO
    assertTrue  "validateOption --pkg"    $LINENO

    assertFalse "validateOption --foo"    $LINENO

    ##
    ## Test validateOptionArgument
    ##

    local ME=$(whoami)
    local ROOT_ID=0
    local ASSUME_NOT_EXIST_USER=-1

    assertTrue  "validateOptionArgument --user=${ME}"                               $LINENO
    assertTrue  "validateOptionArgument --user=root"                                $LINENO
    assertTrue  "validateOptionArgument --user=${ROOT_ID}"                          $LINENO
    assertFalse "validateOptionArgument --user=${ASSUME_NOT_EXIST_USER}"            $LINENO
    assertFalse "validateOptionArgument --user=${ME},${ASSUME_NOT_EXIST_USER}"      $LINENO

    assertTrue  "validateOptionArgument --pkg=all"                                  $LINENO
    assertTrue  "validateOptionArgument --pkg=locale,common"                        $LINENO
    assertFalse "validateOptionArgument --pkg=foo"                                  $LINENO
    assertFalse "validateOptionArgument --pkg=locale,foo"                           $LINENO
    assertFalse "validateOptionArgument --pkg=foo,locale"                           $LINENO

    ##
    ## Test validateAllArgument
    ##

    assertTrue  "validateAllArgument install"                                        $LINENO
    assertTrue  "validateAllArgument help"                                           $LINENO
    assertTrue  "validateAllArgument --user=root install"                            $LINENO
    assertTrue  "validateAllArgument --user=root --pkg=all install"                  $LINENO
    assertTrue  "validateAllArgument --pkg=locale,mariadb install"                   $LINENO

    assertFalse "validateAllArgument"                                               $LINENO
    assertFalse "validateAllArgument foo"                                           $LINENO
    assertFalse "validateAllArgument foo bar test"                                  $LINENO
    assertFalse "validateAllArgument --user=root --pkg=all install,foo"             $LINENO
    assertFalse "validateAllArgument --user=root --pkg=all install foo"             $LINENO
    assertFalse "validateAllArgument foo bar test yeah"                             $LINENO
    assertFalse "validateAllArgument --user=root --pkg=all install,foo"             $LINENO

    assertFalse "validateAllArgument --user=root --pkg=foo install"                 $LINENO
    assertFalse "validateAllArgument --user=-1 --pkg=all install"                   $LINENO
    assertFalse "validateAllArgument --user=-1 --pkg=foo install"                   $LINENO

    ##
    ## Test getCommand
    ##

    assertEquals "help"         "getCommand"                                        $LINENO
    assertEquals "--user=root"  "getCommand --user=root"                            $LINENO
    assertEquals "install"      "getCommand install"                                $LINENO
    assertEquals "install"      "getCommand --user=root install"                    $LINENO

    ##
    ## Validate function is available
    ##

    foo_bar ()
    {
        return 0
    }

    assertTrue  "validateAvailableFunction main"                                    $LINENO
    assertTrue  "validateAvailableFunction main,usage"                              $LINENO
    assertTrue  "validateAvailableFunction bar foo_"                                $LINENO
    assertFalse "validateAvailableFunction foo"                                     $LINENO
    assertFalse "validateAvailableFunction main,foo"                                $LINENO

    local PKGS="all,locale,common,php_and_apache2,composer,ssl,phalcon,mariadb,docker,fig_alias,bower,dotfiles,ssl_vhost";

    assertTrue  "validateAvailableFunction ${PKGS} setup_"                          $LINENO

    ##
    ## Stub function
    ##

    . ${SCRIPT_PATH}/stub.sh

    assertEquals "usage"                                "main help"                         $LINENO
    assertEquals "usage"                                "main foo"                          $LINENO

    assertEquals "setup_all;"                           "setupPkg all"                      $LINENO
    assertEquals "setup_locale;setup_common;"           "setupPkg locale,common"            $LINENO
    assertEquals "setup_dotfiles root;"                 "setupProfile root"                 $LINENO
    assertEquals "setup_all;setup_dotfiles $(whoami);"  "setup"                             $LINENO
    assertEquals "setup_common;setup_dotfiles root;"    "setup --pkg=common --user=root"    $LINENO
    assertEquals "setup_all;setup_dotfiles $(whoami);"  "main install"                      $LINENO
}

validate.sh

#!/bin/bash

#######################################################################
##
## START HEADER SCRIPT
##
#######################################################################

type realpath &>/dev/null
if [ $? -eq 1 ]; then
    sudo apt-get -qq update && sudo apt-get -qq install realpath -y
fi

SCRIPT_PATH=$(dirname $(realpath -s $0))
BASENAME=$(basename $0)

#############################
## END HEADER SCRIPT ##
#######################

validate ()
{
    local ARG=${1}
    local REGEX=${2}
    local ON_TRUE=0
    local ON_FALSE=1

    if echo ${ARG} | grep -q -E ${REGEX} &>/dev/null
    then
        return ${ON_TRUE}
    else
        return ${ON_FALSE}
    fi
}

validateCommand () 
{
    local ARG=${1}
    local REGEX="^(install|help)$"
    validate ${ARG} ${REGEX}
}

validateOption ()
{
    local ARG=${1}
    local REGEX="^(--user|--pkg)$"
    validate ${ARG} ${REGEX}
}

validateOptionArgument ()
{
    local ARG=${1}
    IFS='=' read -ra ARGS <<< ${ARG}

    local OPTION_ARG=${ARGS[0]}
    local ARGUMENT_ARG=${ARGS[1]}
    local PKG_REGEX="^(all|locale|common|php_and_apache2|composer|ssl|phalcon|mariadb|docker|fig_alias|bower|ssl_vhost)$"
    local RET=0

    case ${OPTION_ARG} in
        "--user")

            IFS=',' read -ra ADDR <<< ${ARGUMENT_ARG}
            for each in ${ADDR[@]}; do
                if getent passwd ${each} &>/dev/null
                then
                    RET=$((${RET} || 0))
                else
                    RET=$((${RET} || 1))
                fi
            done

            ;;
        "--pkg")

            IFS=',' read -ra ADDR <<< ${ARGUMENT_ARG}
            for each in ${ADDR[@]}
            do
                if echo ${each} | grep -q -E ${PKG_REGEX} &>/dev/null
                then
                    RET=$((${RET} || 0))
                else
                    RET=$((${RET} || 1))
                fi
            done

            ;;
    esac

    return ${RET}
}

howmany()
{ 
    echo ${#}
}

validateAllArgument ()
{
    local ARG="${@}"
    local RET=0

    ##
    ## Validate argument length
    ## Should between ${MIN_ARG} and ${MAX_ARG}
    ##

    local ARG_COUNT=$(howmany ${ARG})
    local MIN_ARG=1
    local MAX_ARG=3

    if [ ${ARG_COUNT} -ge ${MIN_ARG} ] && [ ${ARG_COUNT} -le ${MAX_ARG} ]
    then
        RET=$((${RET} || 0))
    else
        RET=$((${RET} || 1))
    fi

    ##
    ## Validate command
    ##

    local COMMAND=$(getCommand ${ARG})

    if validateCommand ${COMMAND}
    then
        RET=$((${RET} || 0))
    else
        RET=$((${RET} || 1))
    fi
    
    ##
    ## Validate options
    ##

    IFS=' ' read -ra ARGS <<< ${ARG}
    for each in ${ARGS[@]}
    do
        if validateOptionArgument ${each}
        then
            RET=$((${RET} || 0))
        else
            RET=$((${RET} || 1))
        fi
    done

    return ${RET}
}

validateAvailableFunction ()
{
    local ARGS=${1}
    local PREFIX=${2}
    local RET=0

    IFS=',' read -ra ADDR <<< ${ARGS}
    for each in ${ADDR[@]}; do
        if declare -F ${PREFIX}${each} &>/dev/null
        then
            RET=$((${RET} || 0))
        else
            RET=$((${RET} || 1))
        fi
    done

    return ${RET}
}