software

#!/bin/bash
# author:Muzhi

set -e

readonly YES="Y"
readonly NO="N"
readonly UNION="union"
readonly MEMBER="member"
readonly DOCKER_ROOT="/var/lib/docker"

DOCKER_FILE=
DOCKER_RPM_FILE=
DOCKER_DEB_FILE=
DOCKER_COMPOSE_FILE=
JDK_FILE=
DOS2UNIX_RPM_FILE=
DOS2UNIX_DEB_FILE=

readonly jdk_home='/opt/java/jdk1.8.0_351'
readonly jdk17_home='/opt/java/openjdk'
readonly jdk_env='$JAVA_HOME/bin'

jdk_version="8"

readonly Darwin="Darwin"
readonly CentOS="CentOS"
readonly Ubuntu="Ubuntu"
readonly Redhat="Redhat"

work_dir=$(cd -P $(dirname $0); pwd)

data_path="$HOME/data"
host=""
project=""
architecture=$([ "$(uname -m |grep aarch64)" ] && echo aarch64 || echo x86)
docker_root_dir=""
assume=""
params=""
install_rancher_assume="$NO"

suffix="cfg,sh,yml,yaml,env,conf,toml,xml,properties,json"
suffix_array=(${suffix//,/ })

rancher_db_host=""
rancher_db_port=3306
rancher_db_name=cattle
rancher_db_user=cattle
rancher_db_pass=cattle

LOG_ERROR()
{
    local content=${1}
    echo -e "\033[31m[ERROR] ${content}\033[0m"
}

LOG_INFO()
{
    local content=${1}
    echo -e "\033[32m [INFO] ${content}\033[0m"
}

LOG_WARN()
{
    local content=${1}
    echo -e "\033[33m [WARN] ${content}\033[0m"
}

LOG_DEBUG()
{
    local content=${1}
    echo -e "\033[34m[DEBUG] ${content}\033[0m"
}

usage() {
    echo '   ____     _____                     '
    echo '  / __/__  / _/ /__    _____ ________ '
    echo ' _\ \/ _ \/ _/ __/ |/|/ / _ `/ __/ -_)'
    echo '/___/\___/_/ \__/|__,__/\_,_/_/  \__/ '
    echo ""
    echo "Author muzhi"
    echo ""
    echo "usage: bash software.sh -p[project]"
    echo ""
    echo "Note:"
    echo "       project        (Required)      service project, must be one of value: $UNION, $MEMBER"
    echo ""
    echo "       member software: docker, docker-compose, dos2unix"
    echo "       union  software: docker, docker-compose, dos2unix, openjdk17"
    echo ""
}

parse() {
    if [[ $1 == -h* ]]; then
        host=${1:2}
    elif [[ $1 == -d* ]]; then
        data_path=${1:2}
    elif [[ $1 == -p* ]]; then
        project=${1:2}
    elif [[ "$1" = "-R" ]]; then
        install_rancher_assume=$YES
    elif [ "$1" = "-y" ]; then
        assume=$YES
    fi
}

function parse_args() {
    while (("$#")); do
        case "$1" in
        -h | --host)
            host=$2
            if [ $# -ge 2 ]; then
                shift 2
            else
                break
            fi
            ;;

        -d | --data_path)
            data_path=$2
            if [ $# -ge 2 ]; then
                shift 2
            else
                break
            fi
            ;;

        -p | --project)
            project=$2
            if [ $# -ge 2 ]; then
                shift 2
            else
                break
            fi
            ;;

        -R | --rancher)
            install_rancher_assume=$YES
            if [ $# -ge 1 ]; then
                shift 1
            else
                break
            fi
            ;;

        -y | --yes)
            assume=$YES
            if [ $# -ge 1 ]; then
                shift 1
            else
                break
            fi
            ;;

        *) # preserve positional arguments
            params="$params $1"
            if [ $# -ge 1 ]; then
                shift
            else
                break
            fi
            ;;
        esac
    done
}

entry() {
    cd $work_dir

    for opt; do
        parse $opt
    done

    parse_args $*



    echo ">> start install software: project $project, data_path: $data_path, architecture : $architecture, install_rancher: $install_rancher_assume"

    if [ "x$project" = "x" -o "$project" != "member" -a "$project" != "union"  -o "x$architecture" = "x" ]; then
        usage
        exit -1
    fi

    source $work_dir/apollo_${architecture}.cfg

    run_dos2unix

    # check union jdk
    if [ "$UNION" = "$project" ]; then
        if [ -f "$HOME/.bash_profile" ]; then
            source $HOME/.bash_profile
        fi
        if ! type java >/dev/null 2>&1; then
            read -p ">> install jdk [Y/N]" reply
            if [ "$(echo $reply | tr '[:lower:]' '[:upper:]')" = "$YES" ]; then
                gunzip_package
                read -p ">> jdk version, default [8]: [8/17]" jdk_version

                if [ "$jdk_version" = "17" ]; then
                    install_jdk17
                else
                    install_jdk
                fi
                source /etc/profile
                source ~/.bash_profile
            fi
        fi
    fi

    if ! type docker-compose >/dev/null 2>&1; then
        read -p ">> Install docker-compose [Y/N]" reply
        if [ "$(echo $reply | tr '[:lower:]' '[:upper:]')" = "$YES" ]; then
            gunzip_package
            install_docker_compose
        fi
    fi

    if ! type docker >/dev/null 2>&1; then
        read -p ">> install docker [Y/N]" reply
        if [ "$(echo $reply | tr '[:lower:]' '[:upper:]')" = "$YES" ]; then
            read -p ">> Docker Root Dir, default [${DOCKER_ROOT}]: " docker_root_dir
            if [ x"$docker_root_dir" = x ]; then
                docker_root_dir=$DOCKER_ROOT
            fi
            gunzip_package
            install_docker
        fi
    fi

    if [ "$install_rancher_assume" = "$YES" ]; then
        echo ">> install rancher"
        load_rancher_image
        install_rancher
    fi

    echo ">> install software success"
}

load_rancher_image(){
    echo ">> load_rancher_image"
    rancher_image=(
        rancher/server:v1.6.30
        rancher/scheduler:v0.8.6
        rancher/agent:v1.2.11
        rancher/net:v0.13.17
        rancher/dns:v0.17.4
        rancher/healthcheck:v0.3.8
        rancher/metadata:v0.10.4
        rancher/network-manager:v0.7.22
        rancher/net:holder
    )
    for img in ${rancher_image[*]}
    do
        if [ ! "$(docker images -q ${img})" ]; then
            image_file=${img/:/_}
            image_file=${image_file//\//-}
            echo "load ${img} start"
            gunzip -c apollo/rancher-image-${architecture}/${image_file}\.tar.gz | docker load
            echo "load ${img} success"
        else
            echo "${img} loaded"
        fi
    done
}

install_rancher(){
    echo ">> install_rancher"

#    rancher_db_host=${rancher_db_host:-$host}
#    if [ "x$rancher_db_host" = "x" ]; then
#        echo "rancher_db_host not be null"
#        exit -1
#    fi
#    echo "rancher_db_host: $rancher_db_host , rancher_db_port: $rancher_db_port , rancher_db_user: $rancher_db_user"
#    docker run -d --name nvx-rancher --restart=always -p 28080:8080 server:v1.6.30  \
#        --db-host "$rancher_db_host" --db-port $rancher_db_port \
#        --db-user $rancher_db_user --db-pass $rancher_db_pass --db-name $rancher_db_name

    docker run -d --name nvx-rancher-server --restart=always -v $data_path/rancher/mysql:/var/lib/mysql -p 28080:8080 rancher/server:v1.6.30
}

gunzip_package() {
    # gunzip apollo
    if [ ! -d "$work_dir/apollo" ]; then
        echo ">> start gunzip apollo"
        package_file=$(ls |grep apollo_v.*\\.tar$)
        if [ ! "${package_file}" ]; then
            echo "apollo_v*.tar not exist!"
            exit -1
        fi
        array=(${package_file//,/ })
        if [ ${#array[*]} != 1 ]; then
            echo "there are $package_file in work directory, please reserved only one"
            exit -1
        fi
        tar -xf apollo_v*.tar -C $work_dir
    fi

    # gunzip software
    if [ ! -d "$work_dir/apollo/software" ]; then
        echo ">> start gunzip software"
        if [ ! -f "$work_dir/apollo/software.tar.gz" ]; then
            echo "software.tar.gz not exist!"
            exit -1
        fi
        tar -zxf $work_dir/apollo/software.tar.gz -C $work_dir/apollo
    fi
}

run_dos2unix() {
    cd $work_dir
    if  ! type dos2unix >/dev/null 2>&1; then

        gunzip_package

        echo ">> install dos2unix [$(get_system)]"

        if [[ "$(get_system)" == "$CentOS" || "$(get_system)" == "$Redhat"  ]]; then
            echo ">> install dos2unix on centos/redhat"
            sudo rpm -ivh apollo/software/dos2unix/${DOS2UNIX_RPM_FILE}
        elif [ "$(get_system)" == "$Ubuntu" ]; then
            echo ">> install dos2unix on ubuntu"
            # sudo dpkg -i --auto-deconfigure --install libc6_2.35-0ubuntu3.1_amd64.deb
            sudo dpkg -i apollo/software/dos2unix/${DOS2UNIX_DEB_FILE}
        else
            echo "not support system: [$(get_system)]"
            exit -1
        fi
    fi

    #    dos2unix -q $(ls *.sh)

    dos2unix_convert_dir apollo
}

dos2unix_convert_dir(){
    for file in `ls $1`
    do
        if [ -d $1"/"$file ]; then
            dos2unix_convert_dir $1"/"$file
        else
            for x in ${suffix_array[*]}
            do
                # hello.tmp.txt -> tmp.txt    txt
                if [ "${file#*.}" = "$x" -o "${file##*.}" = "$x" ]; then
                    dos2unix -q $1"/"$file
                    break
                fi
            done
        fi
    done
}

get_system() {
    unix_name=`uname  -a`

    #CentOS os check
    FILE_EXE=/etc/redhat-release

    if [[ -f "$FILE_EXE" ]]; then
        redhat_release=`cat /etc/redhat-release`
        if [[ $redhat_release =~ $CentOS ]]; then
            echo $CentOS
        elif [[ $redhat_release =~ "Red" ]];then
            echo $Redhat
        else
            echo $unix_name
        fi
    elif [[ $unix_name =~ $Darwin ]];then
        echo $Darwin
    elif [[ $unix_name =~ $CentOS ]];then
        echo $CentOS
    elif [[ $unix_name =~ $Ubuntu ]];then
        echo $Ubuntu
    else
        echo $unix_name
    fi
}

install_docker() {
    cd $work_dir
    if [ ! -d apollo/tmp ]; then
        echo "mkdir apollo/tmp"
        mkdir -p apollo/tmp
    fi

    if [ "$docker_root_dir" != "$DOCKER_ROOT" ]; then
        echo ">> set docker root dir: ${docker_root_dir}"
        if [ ! -d "${docker_root_dir}" ]; then
            echo "mkdir ${docker_root_dir}"
            mkdir -p ${docker_root_dir}
        fi

        if [ ! -f "/etc/docker/daemon.json" ]; then
            echo ">> create file /etc/docker/daemon.json"

            if [ ! -d "/etc/docker" ]; then
                echo "mkdir /etc/docker"
                sudo mkdir -p /etc/docker
            fi

            sudo cp -n apollo/software/docker/daemon.json /etc/docker/
        fi

        if [ "$(grep \"data-root\" /etc/docker/daemon.json)" ]; then
            sudo sed -i "/data-root/s@:.*\"@: \"${docker_root_dir}\"@g" /etc/docker/daemon.json
        else
            #            sudo sed -i "/}/i ," /etc/docker/daemon.json
            sudo sed -i "$ i ,\"data-root\":\"${docker_root_dir}\"" /etc/docker/daemon.json
        fi
    fi

    group_name=""
    if [[ "$(get_system)" == "$CentOS" || "$(get_system)" == "$Redhat"  ]]; then
        echo ">> install docker on centos/redhat"
        # https://docs.docker.com/engine/install/centos/
        tar -zxf apollo/software/docker/redhat/${DOCKER_RPM_FILE} -C apollo/tmp
        cd apollo/tmp/docker
        sudo rpm -ivh *.rpm --force --nodeps
        sudo systemctl start docker

        group_name="docker"
        sudo usermod -aG docker $USER

        sudo systemctl enable docker --now
    elif [ "$(get_system)" == "$Ubuntu" ]; then
        echo ">> install docker on ubuntu"
        # https://docs.docker.com/engine/install/ubuntu/
        tar -zxf apollo/software/docker/debian/${DOCKER_DEB_FILE} -C apollo/tmp
        cd apollo/tmp/docker
        # containerd.io_1.6.14-1_amd64.deb docker-ce_20.10.22~3-0~ubuntu-focal_amd64.deb docker-ce-cli_20.10.22~3-0~ubuntu-focal_amd64.deb docker-compose-plugin_2.14.1~ubuntu-focal_amd64.deb
        # The Docker daemon starts automatically
        sudo dpkg -i ./containerd.io_*.deb \
          ./docker-ce_*.deb \
          ./docker-ce-cli_*.deb \
          ./docker-compose-plugin_*.deb

        group_name="docker"
        sudo usermod -aG docker $USER

        sudo systemctl enable docker --now
    else
        echo ">> install docker on linux"
        # https://docs.docker.com/engine/install/binaries/
        tar -zxf apollo/software/docker/binaries/${DOCKER_FILE} -C apollo/tmp
        sudo cp apollo/tmp/docker/* /usr/bin/
        sudo cp apollo/software/docker/docker.service /etc/systemd/system/docker.service
        sudo dockerd &
        sudo systemctl enable docker.service
    fi

    echo "remove install temp file"
    rm -rf apollo/tmp

#    if [ ! "$(sudo cat /etc/group | grep docker)" ]; then
#       sudo groupadd docker
#    fi
#    sudo usermod -a -G docker $USER

    if [ -f /var/run/docker.sock ]; then
        sudo chmod 666 /var/run/docker.sock
    fi

    sudo systemctl daemon-reload
    sudo systemctl restart docker
#    sudo systemctl reset-failed docker.service

    cd $work_dir

    if [[ -n "${group_name}" ]]; then
        echo ">> newgrp $group_name"
        LOG_WARN "如果打印这条提示之后，没有继续安装部署，请重复执行您的部署脚本"
        newgrp docker
    fi
}

install_docker_compose() {
    cd $work_dir
    sudo cp apollo/software/docker/${DOCKER_COMPOSE_FILE} /usr/local/bin/docker-compose
    sudo chmod +x /usr/local/bin/docker-compose
    cd $work_dir
}

install_jdk() {
    echo ">> install_jdk"
    cd $work_dir

    if [ ! -d "$jdk_home" ]; then
        echo ">> gunzip jdk zip file"
        sudo mkdir -p /opt/java
        if [ "${JDK_FILE#*.}" = "tar.gz" -o  "${JDK_FILE#*.}" = "tgz" ]; then
            sudo tar -zxf apollo/software/${JDK_FILE} -C /opt/java
        else
            sudo tar -xf apollo/software/${JDK_FILE} -C /opt/java
        fi
    fi

    if [ ! -f "$HOME/.bash_profile" ]; then
        echo ">> create file ~/.bash_profile"
        cp apollo/software/.bash_profile $HOME/
    else
        if [ ! "$(cat $HOME/.bash_profile)" ]; then
            echo ">> add new line"
            echo "# .bash_profile" >$HOME/.bash_profile
        fi

        if [ ! "$(grep $jdk_home ~/.bash_profile)" ]; then
            sed -i '1a export JAVA_HOME=/opt/java/jdk1.8.0_351' ~/.bash_profile
        fi

        if [ ! "$(grep 'export PATH' ~/.bash_profile)" ]; then
             sed -i '$a export PATH' ~/.bash_profile
        fi

        if [ ! "$(grep $jdk_env ~/.bash_profile)" ]; then
            if [ "$(grep PATH= ~/.bash_profile)" ]; then
                sed -i '/^PATH=/a PATH=$JAVA_HOME/bin:$PATH' ~/.bash_profile
            else
                sed -i '/^export PATH/i PATH=$JAVA_HOME/bin:$PATH' ~/.bash_profile
            fi
        fi
    fi
}

install_jdk17() {
    echo ">> install_jdk17"
    cd $work_dir

    if [ ! -d "$jdk17_home" ]; then
        echo ">> gunzip jdk zip file"
        sudo mkdir -p /opt/java
        if [ "${JDK17_FILE#*.}" = "tar.gz" -o  "${JDK17_FILE#*.}" = "tgz" ]; then
            sudo tar -zxf apollo/software/${JDK17_FILE} -C /opt/java
        else
            sudo tar -xf apollo/software/${JDK17_FILE} -C /opt/java
        fi
        sudo mv /opt/java/* /opt/java/openjdk
    fi

    if [ ! -f "$HOME/.bash_profile" ]; then
        echo ">> create file ~/.bash_profile"
        cp apollo/software/.bash_profile $HOME/
        sed -i "/jdk1.8.0_351/s@=.*@=$jdk17_home@g" $HOME/.bash_profile
    else
        if [ ! "$(cat $HOME/.bash_profile)" ]; then
            echo ">> add new line"
            echo "# .bash_profile" >$HOME/.bash_profile
        fi

        if [ ! "$(grep $jdk17_home ~/.bash_profile)" ]; then
            sed -i '1a export JAVA_HOME=/opt/java/openjdk' ~/.bash_profile
        fi

        if [ ! "$(grep $jdk_env ~/.bash_profile)" ]; then
             sed -i '/^PATH=/a PATH=$JAVA_HOME/bin:$PATH' ~/.bash_profile
        fi

        if [ ! "$(grep 'export PATH' ~/.bash_profile)" ]; then
             sed -i '$a export PATH' ~/.bash_profile
        fi
    fi
}

if [ $# -lt 1 ]; then
    usage
    exit -1
else
    entry $*
fi