Packaging Script

#!/bin/bash
 
# Check whether Redis is started.
redis_pid=$(pgrep -f redis-server)
if [ -z "$redis_pid" ]; then
    echo "The Redis service is not running. The script exits."
    exit 1
else
    echo "The Redis service is running. PID: $redis_pid"
fi
 
# Check whether the Redis sentinel is started.
sentinel_pid=$(pgrep -f redis-sentinel)
if [ -z "$sentinel_pid" ]; then
    echo "The Redis sentinel is not running."
    is_sentinel_mode=false
else
    echo "The Redis sentinel is running. PID: $sentinel_pid"
    is_sentinel_mode=true
fi
 
# Obtain the IP address and port of the Redis service.
# Run the ps command to obtain information about redis-server and redis-sentinel.
redis_info=$(ps -ef | grep redis | grep -v grep)
 
# Get the IP address and port of redis-server.
redis_server_info=$(echo "$redis_info" | grep 'redis-server' | awk '{print $NF}')
redis_host=$(echo "$redis_server_info" | cut -d ':' -f1)
redis_port=$(echo "$redis_server_info" | cut -d ':' -f2)
 
# If the IP address and port of Redis are not obtained, use the default values.
if [ -z "$redis_host" ]; then
    redis_host="127.0.0.1"
    redis_port="6379"
    echo "Failed to obtain the IP address and port of redis-server. Use the default values: $redis_host:$redis_port"
else
    echo "Obtained the IP address and port of redis-server: $redis_host:$redis_port"
fi
 
# Obtain the IP address and port of redis-sentinel (if any).
redis_sentinel_host="127.0.0.1"
redis_sentinel_port="26379"
sentinel_info=$(echo "$redis_info" | grep 'redis-sentinel')
 
if [ -n "$sentinel_info" ]; then
    # Use a regular expression to match and extract the IP address and port.
    sentinel_info=$(echo "$sentinel_info" | grep -oP '\d+\.\d+\.\d+\.\d+:\d+|\*:\d+')  # Extract information similar to *:26379 or IP_address:port.
 
    # Extract the IP address and port.
    sentinel_host=$(echo "$sentinel_info" | cut -d ':' -f1)
    sentinel_port=$(echo "$sentinel_info" | cut -d ':' -f2)
 
    # If the IP address is * or not set, use the default value.
    if [ "$sentinel_host" == "*" ] || [ -z "$sentinel_host" ]; then
        sentinel_host="127.0.0.1"
        echo "The IP address of redis-sentinel is set to the default value: $sentinel_host"
    fi
 
    # If the port is * or not set, use the default value.
    if [ -z "$sentinel_port" ] || [ "$sentinel_port" == "*" ]; then
        sentinel_port="26379"
        echo "The port of redis-sentinel is set to the default value: $sentinel_port"
    fi
    redis_sentinel_host=$sentinel_host
    redis_sentinel_port=$sentinel_port
 
    echo "Obtained the IP address and port of redis-sentinel: $redis_sentinel_host:$redis_sentinel_port"
else
    echo "Failed to obtain redis-sentinel information. Use the default values: $redis_sentinel_host:$redis_sentinel_port"
fi
 
# Obtain the path to the redis-server executable file.
redis_exe_path=$(readlink -f /proc/$redis_pid/exe)
 
# Obtain the path to the parent directory.
redis_parent_dir=$(dirname "$redis_exe_path")
 
# Remove the slash (if any) at the end of the path.
redis_parent_dir=$(echo "$redis_parent_dir" | sed 's/\/$//')
 
# Check whether the parent directory of redis-server is the src or bin installation directory.
if [[ "$redis_parent_dir" == */src ]]; then
    installation_dir=$(dirname "$redis_parent_dir")
    echo "src installation directory identified: $installation_dir"
elif [[ "$redis_parent_dir" == */bin ]]; then
    installation_dir="$redis_parent_dir"
    echo "bin installation directory identified: $installation_dir"
 
    # Check whether the parent directory of bin contains src/redis-server.
    parent_dir=$(dirname "$redis_parent_dir")
    if [ -f "$parent_dir/src/redis-server" ]; then
        # Set installation_dir to $parent_dir (src directory).
        installation_dir="$parent_dir"
        redis_parent_dir="$parent_dir/src"  # Update redis_parent_dir to src.
        echo "Installation directory: $installation_dir"
    else
        echo "$parent_dir does not contain src/redis-server. Use bin as the installation directory."
        installation_dir="$redis_parent_dir"
    fi
else
    echo "The given directory is neither the src directory nor the bin directory. Check whether the path is correct."
    exit 1
fi
 
# Obtain the IP address inputted by the user. The default value is $redis_host.
read -p "The identified IP address of the Redis server is $redis_host. To change the IP address, input the correct one. To use the identified IP address, press Enter: " redis_host_input
redis_host=${redis_host_input:-$redis_host}
 
# Obtain the port inputted by the user. The default value is $redis_port.
read -p "The identified port of the Redis server is $redis_port. To change the port, input the correct one. To use the identified port, press Enter: " redis_port_input
redis_port=${redis_port_input:-$redis_port}
 
# Obtain the password inputted by the user. By default, the password is empty.
read -s -p "Input the password of the Redis server (If no password is configured, press Enter): " redis_password
echo
redis_password=${redis_password:-""}
 
if [ -n "$sentinel_info" ]; then
    # Ask the user to change the IP address and port of the Redis sentinel.
    read -p "The identified IP address of the Redis sentinel is $redis_sentinel_host. To change the IP address, input the correct one. To use the identified IP address, press Enter: " redis_sentinel_host_input
    redis_sentinel_host=${redis_sentinel_host_input:-$redis_sentinel_host}
 
    read -p "The identified port of the Redis sentinel is $redis_sentinel_port. To change the port, input the correct one. To use the identified port, press Enter: " redis_sentinel_port_input
    redis_sentinel_port=${redis_sentinel_port_input:-$redis_sentinel_port}
else
    echo "Your current server does not start the sentinel node."
fi
 
# You can check the formats of the inputted IP address and port, for example, using a regular expression.
# Check the IP address format.
if [[ ! "$redis_host" =~ ^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
    echo "Error: Invalid Redis server IP address format!"
    exit 1
fi
 
# Check whether the port is valid.
if [[ ! "$redis_port" =~ ^[0-9]+$ ]]; then
    echo "Error: Invalid Redis server port!"
    exit 1
fi
 
# Check the format of the Redis sentinel IP address.
if [[ ! "$redis_sentinel_host" =~ ^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
    echo "Error: Invalid Redis sentinel IP address format!"
    exit 1
fi
 
# Check whether the port of the Redis sentinel is valid.
if [[ ! "$redis_sentinel_port" =~ ^[0-9]+$ ]]; then
    echo "Error: Invalid Redis sentinel port!"
    exit 1
fi
 
# Switch to the Redis installation directory and ensure that redis-cli can run properly.
cd "$redis_parent_dir"
echo "Go to the installation directory: $redis_parent_dir"
 
# Obtain the Redis configuration file path.
echo "Obtaining the Redis configuration file path..."
if [ -z "$redis_password" ]; then
    config_file_path=$(./redis-cli -h "$redis_host" -p "$redis_port" INFO | grep config_file | cut -d ':' -f2 | tr -d '[:space:]')
else
    config_file_path=$(./redis-cli -h "$redis_host" -p "$redis_port" -a "$redis_password" INFO | grep config_file | cut -d ':' -f2 | tr -d '[:space:]')
fi
 
if [ -z "$config_file_path" ]; then
    echo "Failed to obtain the Redis configuration file path. Check that the Redis service is started and the password is correct."
    exit 1
fi
config_file_path=$(realpath "$config_file_path")
 
echo "Configuration file path: '$config_file_path'"
 
# Obtain the path to the configuration file in the installation directory.
if [[ "$config_file_path" == "$installation_dir"* ]]; then
    redis_conf_in_package=true
    echo "The configuration file is in the installation directory. Skip the step of copying the configuration file."
else
    redis_conf_in_package=false
    echo "The configuration file is not in the installation directory. Copying the configuration file..."
    
    # Obtain the absolute path to the parent directory of the configuration file.
    config_file_parent_dir=$(dirname "$config_file_path")
    
    # Construct the target directory, which is source_related+parent directory of the configuration file under redis_parent_dir.
    target_dir="$redis_parent_dir/source_related$config_file_parent_dir"
    
    # Create a target directory (if not found).
    mkdir -p "$target_dir"
    cp "$config_file_path" "$target_dir"
    
    echo "The configuration file has been copied to $target_dir."
fi
 
# Obtain the Redis data directory.
echo "Obtaining the Redis data directory..."
if [ -z "$redis_password" ]; then
    redis_data_dir=$(./redis-cli -h "$redis_host" -p "$redis_port" CONFIG GET dir | awk 'NR==2 {print substr($0, index($0,$2))}' | tr -d '"')
else
    redis_data_dir=$(./redis-cli -h "$redis_host" -p "$redis_port" -a "$redis_password" CONFIG GET dir | awk 'NR==2 {print substr($0, index($0,$2))}' | tr -d '"')
fi
 
# Return the original Redis data directory.
 
# Check whether the data directory is set.
if [ -z "$redis_data_dir" ]; then
    echo "The Redis data directory is not set. Check the dir setting in the configuration file."
else
    echo "Redis data directory: $redis_data_dir"
fi
 
# Obtain the values of dbfilename and appendfilename.
echo "Obtaining dbfilename and appendfilename..."
if [ -z "$redis_password" ]; then
    dbfilename=$(./redis-cli -h "$redis_host" -p "$redis_port" CONFIG GET dbfilename | awk 'NR==2 {print substr($0, index($0,$2))}' | tr -d '"')
    appendfilename=$(./redis-cli -h "$redis_host" -p "$redis_port" CONFIG GET appendfilename | awk 'NR==2 {print substr($0, index($0,$2))}' | tr -d '"')
else
    dbfilename=$(./redis-cli -h "$redis_host" -p "$redis_port" -a "$redis_password" CONFIG GET dbfilename | awk 'NR==2 {print substr($0, index($0,$2))}' | tr -d '"')
    appendfilename=$(./redis-cli -h "$redis_host" -p "$redis_port" -a "$redis_password" CONFIG GET appendfilename | awk 'NR==2 {print substr($0, index($0,$2))}' | tr -d '"')
fi
 
echo "dbfilename: $dbfilename"
echo "appendfilename: $appendfilename"
 
# Check Redis data files.
if [ -n "$redis_data_dir" ]; then
 
    # Check whether the Redis data directory is under the installation directory.
    if [[ "$redis_data_dir" != "$installation_dir"* ]]; then
        redis_dir_in_package=false
        echo "The Redis data directory is not under the installation directory. Creating a directory and copying data files..."
 
        # Create a target directory and ensure that its path is complete.
        mkdir -p "$redis_parent_dir/source_related$redis_data_dir"
 
        # Check whether dbfilename is set.
        if [ -n "$dbfilename" ]; then
            if [ -f "$redis_data_dir/$dbfilename" ]; then
                echo "Copying the dbfilename file..."
                cp "$redis_data_dir/$dbfilename" "$redis_parent_dir/source_related$redis_data_dir"
            else
                echo "dbfilename not found: $redis_data_dir/$dbfilename"
            fi
        else
            echo "dbfilename not set. Skip the step of copying the dbfilename file."
        fi
 
        # Check whether appendfilename is set. If not set, use the default value appendonly.aof.
        if [ -z "$appendfilename" ]; then
            appendfilename="appendonly.aof"
            echo "appendfilename not set. The default value $appendfilename is used"
        fi
 
        # Find appendfilename and copy the file.
        if [ -f "$redis_data_dir/$appendfilename" ]; then
            echo "Copying the appendfilename file..."
            cp "$redis_data_dir/$appendfilename" "$redis_parent_dir/source_related$redis_data_dir"
        else
            echo "appendfilename not found: $redis_data_dir/$appendfilename. Skip the copy operation."
        fi
 
        echo "The Redis data files have been copied to $redis_parent_dir/source_related$redis_data_dir."
    else
        redis_dir_in_package=true
        echo "The Redis data directory is under the installation directory. Skip the step of copying data files."
    fi
else
    echo "The Redis data directory is not set. Skip the step of copying data files."
fi
 
# Obtain the logfile configuration.
if [ -z "$redis_password" ]; then
    logfile=$(./redis-cli -h "$redis_host" -p "$redis_port" CONFIG GET logfile | sed -n '2p')
else
    logfile=$(./redis-cli -h "$redis_host" -p "$redis_port" -a "$redis_password" CONFIG GET logfile | sed -n '2p')
fi
 
# Check whether logfile is configured.
if [ -n "$logfile" ]; then
    echo "Log file path: $logfile"
    
    # If the log file is not in the package, copy it.
    if [[ "$logfile" != "$installation_dir"* ]]; then
        redis_logfile_in_package=false
        echo "The log file is not in the installation directory. Copying the log file..."
        mkdir -p "$redis_parent_dir/source_related$(dirname "$logfile")"
        cp "$logfile" "$redis_parent_dir/source_related$logfile"
        echo "The log file has been copied to the target directory: $redis_parent_dir/source_related$logfile"
    else
        redis_logfile_in_package=true
        echo "The log file is in the installation directory. Skip the step of copying the log file."
    fi
else
    echo "The log file path is not set. Skip the step of copying the log file."
fi
 
# Obtain the pidfile configuration.
if [ -z "$redis_password" ]; then
    pidfile=$(./redis-cli -h "$redis_host" -p "$redis_port" CONFIG GET pidfile | sed -n '2p')
else
    pidfile=$(./redis-cli -h "$redis_host" -p "$redis_port" -a "$redis_password" CONFIG GET pidfile | sed -n '2p')
fi
 
# Check whether pidfile is configured.
if [ -n "$pidfile" ]; then
    echo "PID file path: $pidfile"
    # Save only the PID file path.
else
    echo "The PID file path is not set. Skip PID file processing."
fi
 
if [ -n "$sentinel_pid" ]; then
 
    # Obtain the sentinel configuration file path.
    echo "Obtaining the sentinel configuration file path..."
    if [ -z "$redis_password" ]; then
        sentinel_config_file_path=$(./redis-cli -h "$redis_sentinel_host" -p "$redis_sentinel_port" INFO | grep config_file | cut -d ':' -f2 | tr -d '[:space:]')
    else
        sentinel_config_file_path=$(./redis-cli -h "$redis_sentinel_host" -p "$redis_sentinel_port" -a "$redis_password" INFO | grep config_file | cut -d ':' -f2 | tr -d '[:space:]')
    fi
    sentinel_config_file_path=$(realpath "$sentinel_config_file_path")
 
    # Check sentinel_config_file_path.
    if [ -e "$sentinel_config_file_path" ]; then
        echo "Redis sentinel configuration file path: '$sentinel_config_file_path'"
 
        # Obtain the path to the sentinel.conf file in the installation directory.
        if [[ "$sentinel_config_file_path" == "$installation_dir"* ]]; then
            sentinel_conf_in_package=true
            echo "The sentinel configuration file is in the installation directory. Skip the step of copying the configuration file."
            
        else
            sentinel_conf_in_package=false
            echo "The sentinel configuration file is not in the installation directory. Copying the configuration file..."
 
            # Obtain the absolute path to the parent directory of the configuration file.
            config_file_parent_dir=$(dirname "$sentinel_config_file_path")
            
            # Construct the target directory, which is source_related+parent directory of the configuration file under redis_parent_dir.
            target_dir="$redis_parent_dir/source_related$config_file_parent_dir"
            
    # Create a target directory (if not found).
            mkdir -p "$target_dir"
            cp "$sentinel_config_file_path" "$target_dir"
            
            echo "The sentinel configuration file has been copied to $target_dir."
        fi
 
        # Obtain the Redis sentinel data directory (from sentinel.conf).
        sentinel_data_dir=$(grep -i "^dir" "$sentinel_config_file_path" | cut -d ' ' -f2)
        
        # If sentinel_data_dir is ./, leave it empty.
        if [ "$sentinel_data_dir" == "./" ]; then
            sentinel_data_dir=""
            echo "Redis sentinel data directory: $sentinel_data_dir"
        else
            echo "Redis sentinel data directory: $sentinel_data_dir"
        fi
 
    else
        echo "Redis sentinel configuration file path not found. Skip the subsequent operations. Check that the file exists."
    fi
 
else
    echo "Redis sentinel node not detected. Skip configuration file copying and data directory processing."
fi
 
# Create an output file path (with the .json suffix).
output_file="$redis_parent_dir/devkit_redis_conf_data.json"
 
# Obtain Redis and sentinel configurations.
redis_conf="${config_file_path:-}"
redis_dir="${redis_data_dir:-}"
redis_dir_in_package=${redis_dir_in_package:-false}
redis_logfile_in_package=${redis_logfile_in_package:-false}
redis_dbfile="${redis_data_dir}/${dbfilename:-}"
redis_aof="${redis_data_dir}/${appendfilename:-}"
redis_logfile="${logfile:-}"
redis_pidfile="${pidfile:-}"
sentinel_conf="${sentinel_config_file_path:-}"
sentinel_dir="${sentinel_data_dir:-}"
redis_conf_in_package=${redis_conf_in_package:-false}
sentinel_conf_in_package=${sentinel_conf_in_package:-false}
is_sentinel_mode=${is_sentinel_mode:-false}
sentinel_dir=$(echo "$sentinel_dir" | sed 's/^"\(.*\)"$/\1/')
 
# Construct JSON data.
json_data=$(cat <<EOF
{
"redis": {
    "redis_conf": "$redis_conf",
    "redis_conf_in_package": $redis_conf_in_package,
    "redis_dir": "$redis_dir",
    "redis_dir_in_package": $redis_dir_in_package,
    "redis_dbfile": "$redis_dbfile",
    "redis_aof": "$redis_aof",
    "redis_logfile": "$redis_logfile",
    "redis_logfile_in_package": $redis_logfile_in_package,
    "redis_pidfile": "$redis_pidfile"
},
"sentinel": {
    "sentinel_conf": "$sentinel_conf",
    "is_sentinel_mode": $is_sentinel_mode,
    "sentinel_conf_in_package": $sentinel_conf_in_package,
    "sentinel_dir": "$sentinel_dir"
}
}
EOF
)
 
# Write JSON data to a file.
echo "$json_data" > "$output_file"
 
# Output the completion message.
echo "The configuration data has been written into $output_file."
 
# Package the installation directory.
echo "Packaging the installation directory..."
# Switch to the parent directory of installation_dir.
cd "$installation_dir/.." || exit
 
# Generate a TAR package. The package contains the subdirectories of installation_dir, that is, $(basename "$installation_dir").
tar -zcf "redis.tar.gz" "$(basename "$installation_dir")"
 
# Obtain the absolute path to the current working directory (parent directory of installation_dir).
final_tar_path="$(pwd)/redis.tar.gz"
 
# Output the absolute path to the final TAR package after the packaging is complete.
echo "Packaging completed. The installation directory has been packaged to $final_tar_path."