Linux 实战技术指南：从入门到精通的完整实践路径

# 查看当前系统发行版信息
cat /etc/os-release

# 查看内核版本
uname -r

# 查看系统架构
uname -m

# 查看发行版特定信息
lsb_release -a  # Ubuntu/Debian
cat /etc/redhat-release  # CentOS/RHEL

# 检查系统是否支持虚拟化
egrep -c '(vmx|svm)' /proc/cpuinfo

# 安装 KVM 虚拟化环境（Ubuntu）
sudo apt update
sudo apt install qemu-kvm libvirt-daemon-system libvirt-clients bridge-utils

# 将用户添加到 libvirt 组
sudo usermod -aG libvirt $USER

# 验证 KVM 安装
sudo systemctl status libvirtd
virsh list --all

# 更新系统包
sudo apt update && sudo apt upgrade -y  # Ubuntu/Debian
sudo yum update -y  # CentOS 7
sudo dnf update -y  # CentOS 8+/Fedora

# 配置时区
sudo timedatectl set-timezone Asia/Shanghai
timedatectl status

# 配置主机名
sudo hostnamectl set-hostname myserver
hostnamectl status

# 配置静态 IP（示例）
sudo vim /etc/netplan/01-netcfg.yaml  # Ubuntu 18.04+

# 查看当前使用的 Shell
echo $SHELL

# 查看系统可用的 Shell
cat /etc/shells

# 切换到 zsh（如果已安装）
chsh -s /bin/zsh

# 配置 bash 环境变量
vim ~/.bashrc

# 添加常用别名
alias ll='ls -alF'
alias la='ls -A'
alias l='ls -CF'
alias grep='grep --color=auto'

# 重新加载配置
source ~/.bashrc

# 文件和目录操作
ls -la /home/  # 详细列出目录内容
find /var/log -name "*.log" -mtime -7  # 查找7天内修改的日志文件
du -sh /var/*  # 查看目录大小
df -h  # 查看磁盘使用情况

# 文本处理
grep -r "error" /var/log/  # 递归搜索错误信息
sed 's/old/new/g' file.txt  # 替换文本
awk '{print $1}' access.log | sort | uniq -c  # 统计访问IP

# 进程管理
ps aux | grep nginx  # 查看nginx进程
top -p $(pgrep nginx)  # 监控特定进程
kill -9 $(pgrep -f "python script.py")  # 强制终止进程

# 查看根目录结构
ls -la /

# 查看各目录的作用
man hier

# 查看文件系统挂载信息
mount | column -t
df -T  # 显示文件系统类型

# 查看目录大小（按层级）
du -h --max-depth=1 /

# 查看文件的 inode 信息
ls -i filename
stat filename

# 查看文件系统 inode 使用情况
df -i

# 查找相同 inode 的文件（硬链接）
find /path -inum 12345

# 创建硬链接和软链接
ln original_file hard_link
ln -s original_file soft_link

# 查看链接信息
ls -li original_file hard_link soft_link

# 查看文件权限
ls -l filename

# 修改文件权限（数字方式）
chmod 755 script.sh  # rwxr-xr-x
chmod 644 config.txt  # rw-r--r--

# 修改文件权限（符号方式）
chmod u+x script.sh  # 给所有者添加执行权限
chmod g-w file.txt   # 移除组的写权限
chmod o=r file.txt   # 设置其他用户只读权限

# 修改文件所有者和组
chown user:group filename
chgrp group filename

# 递归修改目录权限
chmod -R 755 /path/to/directory
chown -R user:group /path/to/directory

# 检查文件系统是否支持 ACL
mount | grep acl

# 查看文件的 ACL
getfacl filename

# 设置 ACL 权限
setfacl -m u:username:rw filename  # 给特定用户读写权限
setfacl -m g:groupname:r filename  # 给特定组读权限
setfacl -m o::--- filename         # 移除其他用户的所有权限

# 设置默认 ACL（对目录）
setfacl -d -m u:username:rwx /path/to/directory

# 移除 ACL
setfacl -x u:username filename
setfacl -b filename  # 移除所有 ACL

# 批量重命名文件
for file in *.txt; do
    mv "$file" "${file%.txt}.bak"
done

# 使用 rename 命令（更强大）
rename 's/\.txt$/.bak/' *.txt

# 批量修改文件权限
find /path -type f -name "*.sh" -exec chmod +x {} \;

# 批量查找和替换文件内容
find /path -name "*.conf" -exec sed -i 's/old_value/new_value/g' {} \;

# 批量压缩文件
find /var/log -name "*.log" -mtime +30 -exec gzip {} \;

# 检查文件系统错误
sudo fsck /dev/sdb1

# 查看文件系统详细信息
tune2fs -l /dev/sdb1

# 优化文件系统参数
tune2fs -o journal_data_writeback /dev/sdb1

# 查看磁盘 I/O 统计
iostat -x 1

# 监控文件系统使用情况
watch -n 1 'df -h'

# 清理系统临时文件
sudo find /tmp -type f -atime +7 -delete
sudo journalctl --vacuum-time=7d  # 清理系统日志

# 查看进程树
pstree -p

# 查看进程详细信息
ps aux
ps -ef

# 查看特定进程的详细状态
cat /proc/PID/status
cat /proc/PID/cmdline

# 监控进程资源使用
top -p PID
htop  # 更友好的界面

# 查看进程打开的文件
lsof -p PID

# 查看进程的内存映射
cat /proc/PID/maps

# 查看系统 IPC 资源
ipcs -a

# 查看共享内存
ipcs -m

# 查看消息队列
ipcs -q

# 查看信号量
ipcs -s

# 清理 IPC 资源
ipcrm -m shmid  # 删除共享内存
ipcrm -q msgid  # 删除消息队列

# 监控进程信号
kill -l  # 列出所有信号
kill -USR1 PID  # 发送用户定义信号

# CPU 使用率监控
top
htop
vmstat 1  # 每秒更新一次

# 查看 CPU 详细信息
lscpu
cat /proc/cpuinfo

# 内存使用监控
free -h
cat /proc/meminfo

# 查看内存使用详情
ps aux --sort=-%mem | head -10  # 按内存使用排序
pmap PID  # 查看进程内存映射

# 系统负载监控
uptime
w
cat /proc/loadavg

# 磁盘 I/O 监控
iostat -x 1
iotop  # 按进程显示 I/O 使用情况

# 查看磁盘使用情况
df -h
du -sh /path/*

# 监控磁盘 I/O 等待
vmstat 1  # 关注 wa 列（I/O 等待时间）

# 查看磁盘读写速度
hdparm -t /dev/sda  # 测试磁盘读取速度
dd if=/dev/zero of=testfile bs=1M count=1024  # 测试写入速度

# 查看文件系统 I/O 统计
cat /proc/diskstats

# 查看系统服务状态
systemctl status
systemctl list-units --type=service

# 管理服务
systemctl start nginx
systemctl stop nginx
systemctl restart nginx
systemctl reload nginx

# 设置服务开机启动
systemctl enable nginx
systemctl disable nginx

# 查看服务日志
journalctl -u nginx
journalctl -u nginx -f  # 实时查看日志

# 创建自定义服务
sudo vim /etc/systemd/system/myapp.service

[Unit]
Description=My Application
After=network.target

[Service]
Type=simple
User=myuser
WorkingDirectory=/opt/myapp
ExecStart=/opt/myapp/start.sh
Restart=always

[Install]
WantedBy=multi-user.target

# 管理 cron 任务
crontab -l  # 列出当前用户的定时任务
crontab -e  # 编辑定时任务

# cron 时间格式：分 时 日 月 周
# 示例：每天凌晨2点执行备份
0 2 * * * /path/to/backup.sh

# 查看系统级定时任务
ls -la /etc/cron.*

# 使用 systemd timer
systemctl list-timers
systemctl status backup.timer

# 创建 systemd timer
sudo vim /etc/systemd/system/backup.timer

[Unit]
Description=Daily Backup Timer

[Timer]
OnCalendar=daily
Persistent=true

[Install]
WantedBy=timers.target

# 查看网络接口信息
ip addr show
ip link show
ifconfig  # 传统命令

# 查看路由表
ip route show
route -n

# 查看网络连接状态
ss -tuln
netstat -tuln

# 测试网络连通性
ping -c 4 google.com
traceroute google.com
mtr google.com  # 结合 ping 和 traceroute

# 查看 DNS 配置
cat /etc/resolv.conf
nslookup google.com
dig google.com

# 添加静态路由
sudo ip route add 192.168.2.0/24 via 192.168.1.1
sudo route add -net 192.168.2.0/24 gw 192.168.1.1

# 永久路由配置（Ubuntu）
sudo vim /etc/netplan/01-netcfg.yaml

# 防火墙管理（UFW - Ubuntu）
sudo ufw status
sudo ufw enable
sudo ufw allow 22/tcp
sudo ufw allow from 192.168.1.0/24
sudo ufw deny 80/tcp

# 防火墙管理（firewalld - CentOS/RHEL）
sudo firewall-cmd --state
sudo firewall-cmd --list-all
sudo firewall-cmd --add-service=http --permanent
sudo firewall-cmd --add-port=8080/tcp --permanent
sudo firewall-cmd --reload

# iptables 直接操作
sudo iptables -L -n
sudo iptables -A INPUT -p tcp --dport 22 -j ACCEPT
sudo iptables -A INPUT -s 192.168.1.0/24 -j ACCEPT

# 安装 Nginx
sudo apt install nginx  # Ubuntu
sudo yum install nginx  # CentOS

# 启动和管理 Nginx
sudo systemctl start nginx
sudo systemctl enable nginx
sudo systemctl status nginx

# 测试配置文件语法
sudo nginx -t

# 重新加载配置
sudo systemctl reload nginx

# 查看 Nginx 进程和端口
ps aux | grep nginx
ss -tuln | grep :80

server {
    listen 80;
    server_name example.com www.example.com;
    root /var/www/example.com;
    index index.html index.php;

    location / {
        try_files $uri $uri/ =404;
    }

    location ~ \.php$ {
        fastcgi_pass unix:/var/run/php/php7.4-fpm.sock;
        fastcgi_index index.php;
        include fastcgi_params;
    }
}

# 安装 MySQL
sudo apt install mysql-server  # Ubuntu
sudo yum install mysql-server  # CentOS

# 启动 MySQL 服务
sudo systemctl start mysql
sudo systemctl enable mysql

# 安全配置
sudo mysql_secure_installation

# 连接数据库
mysql -u root -p

# 查看数据库状态
sudo systemctl status mysql
mysqladmin -u root -p status
mysqladmin -u root -p processlist

# 备份和恢复
mysqldump -u root -p database_name > backup.sql
mysql -u root -p database_name < backup.sql

# 查看 MySQL 进程
mysqladmin -u root -p processlist

# 查看数据库状态
mysql -u root -p -e "SHOW STATUS LIKE 'Threads%'"
mysql -u root -p -e "SHOW STATUS LIKE 'Questions'"

# 查看慢查询日志
sudo tail -f /var/log/mysql/mysql-slow.log

# SSH 服务管理
sudo systemctl status ssh
sudo systemctl restart ssh

# SSH 配置文件
sudo vim /etc/ssh/sshd_config

# 生成 SSH 密钥对
ssh-keygen -t rsa -b 4096 -C "your_email@example.com"

# 复制公钥到远程服务器
ssh-copy-id user@remote_host

# 使用密钥登录
ssh -i ~/.ssh/id_rsa user@remote_host

# 查看 SSH 连接日志
sudo journalctl -u ssh
sudo tail -f /var/log/auth.log

# 禁用 root 直接登录
PermitRootLogin no

# 修改默认端口
Port 2222

# 禁用密码认证（仅使用密钥）
PasswordAuthentication no

# 限制登录用户
AllowUsers user1 user2

# 设置登录超时
ClientAliveInterval 300
ClientAliveCountMax 2

# 实时网络流量监控
iftop  # 按连接显示流量
nethogs  # 按进程显示流量
nload  # 简单的带宽监控

# 网络统计信息
cat /proc/net/dev
ss -i  # 显示详细的套接字信息

# 抓包分析
sudo tcpdump -i eth0 -n
sudo tcpdump -i eth0 port 80
wireshark  # 图形界面抓包工具

# 网络连接监控
watch -n 1 'ss -tuln'
netstat -i  # 接口统计信息

#!/bin/bash
# 网络流量监控脚本
INTERFACE="eth0"
LOG_FILE="/var/log/network_traffic.log"

while true; do
    RX_BYTES=$(cat /sys/class/net/$INTERFACE/statistics/rx_bytes)
    TX_BYTES=$(cat /sys/class/net/$INTERFACE/statistics/tx_bytes)
    TIMESTAMP=$(date '+%Y-%m-%d %H:%M:%S')
    
    echo "$TIMESTAMP RX: $RX_BYTES TX: $TX_BYTES" >> $LOG_FILE
    sleep 60
done

#!/bin/bash

# 变量定义和使用
name="Linux"
version=20.04
readonly PI=3.14159

echo "System: $name $version"
echo "PI value: $PI"

# 数组操作
fruits=("apple" "banana" "orange")
echo "First fruit: ${fruits[0]}"
echo "All fruits: ${fruits[@]}"
echo "Array length: ${#fruits[@]}"

# 字符串操作
text="Hello World"
echo "Length: ${#text}"
echo "Substring: ${text:0:5}"
echo "Replace: ${text/World/Linux}"

# 数值运算
num1=10
num2=20
result=$((num1 + num2))
echo "Sum: $result"

# 使用 bc 进行浮点运算
result=$(echo "scale=2; $num1 / 3" | bc)
echo "Division: $result"

#!/bin/bash

# 条件判断
check_file() {
    local file=$1
    
    if [[ -f "$file" ]]; then
        echo "File $file exists"
    elif [[ -d "$file" ]]; then
        echo "$file is a directory"
    else
        echo "$file does not exist"
    fi
}

# 循环结构
process_files() {
    local directory=$1
    
    # for 循环
    for file in "$directory"/*; do
        if [[ -f "$file" ]]; then
            echo "Processing: $(basename "$file")"
        fi
    done
    
    # while 循环
    local count=0
    while [[ $count -lt 5 ]]; do
        echo "Count: $count"
        ((count++))
    done
}

# 函数定义和调用
backup_file() {
    local source=$1
    local backup_dir=${2:-/backup}
    
    if [[ ! -d "$backup_dir" ]]; then
        mkdir -p "$backup_dir"
    fi
    
    cp "$source" "$backup_dir/$(basename "$source").$(date +%Y%m%d)"
    echo "Backup completed: $source"
}

# 错误处理
safe_execute() {
    local command=$1
    
    if ! $command; then
        echo "Error: Command failed - $command" >&2
        return 1
    fi
}

# 主程序
main() {
    check_file "/etc/passwd"
    process_files "/tmp"
    backup_file "/etc/hosts"
}

main "$@"

#!/bin/bash

# 系统监控脚本
SCRIPT_NAME="system_monitor"
LOG_FILE="/var/log/${SCRIPT_NAME}.log"
ALERT_EMAIL="admin@example.com"
CPU_THRESHOLD=80
MEMORY_THRESHOLD=85
DISK_THRESHOLD=90

# 日志函数
log_message() {
    local level=$1
    local message=$2
    local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
    echo "[$timestamp] [$level] $message" | tee -a "$LOG_FILE"
}

# CPU 监控
check_cpu() {
    local cpu_usage=$(top -bn1 | grep "Cpu(s)" | awk '{print $2}' | cut -d'%' -f1)
    cpu_usage=${cpu_usage%.*}  # 去除小数部分
    
    if [[ $cpu_usage -gt $CPU_THRESHOLD ]]; then
        log_message "WARNING" "High CPU usage: ${cpu_usage}%"
        send_alert "CPU usage is ${cpu_usage}%"
    else
        log_message "INFO" "CPU usage normal: ${cpu_usage}%"
    fi
}

# 内存监控
check_memory() {
    local memory_info=$(free | grep Mem)
    local total=$(echo $memory_info | awk '{print $2}')
    local used=$(echo $memory_info | awk '{print $3}')
    local usage=$((used * 100 / total))
    
    if [[ $usage -gt $MEMORY_THRESHOLD ]]; then
        log_message "WARNING" "High memory usage: ${usage}%"
        send_alert "Memory usage is ${usage}%"
    else
        log_message "INFO" "Memory usage normal: ${usage}%"
    fi
}

# 磁盘监控
check_disk() {
    while IFS= read -r line; do
        local usage=$(echo "$line" | awk '{print $5}' | cut -d'%' -f1)
        local mount=$(echo "$line" | awk '{print $6}')
        
        if [[ $usage -gt $DISK_THRESHOLD ]]; then
            log_message "WARNING" "High disk usage on $mount: ${usage}%"
            send_alert "Disk usage on $mount is ${usage}%"
        fi
    done < <(df -h | grep -E '^/dev/')
}

# 发送警报
send_alert() {
    local message=$1
    echo "$message" | mail -s "System Alert - $(hostname)" "$ALERT_EMAIL"
}

# 主监控函数
main() {
    log_message "INFO" "Starting system monitoring"
    
    check_cpu
    check_memory
    check_disk
    
    log_message "INFO" "System monitoring completed"
}

# 执行监控
main "$@"

#!/bin/bash

# 自动化部署脚本
APP_NAME="myapp"
APP_DIR="/opt/$APP_NAME"
BACKUP_DIR="/backup/$APP_NAME"
GIT_REPO="https://github.com/user/myapp.git"
SERVICE_NAME="$APP_NAME"

# 颜色输出
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m' # No Color

print_status() {
    local status=$1
    local message=$2
    
    case $status in
        "INFO")
            echo -e "${GREEN}[INFO]${NC} $message"
            ;;
        "WARNING")
            echo -e "${YELLOW}[WARNING]${NC} $message"
            ;;
        "ERROR")
            echo -e "${RED}[ERROR]${NC} $message"
            ;;
    esac
}

# 检查依赖
check_dependencies() {
    print_status "INFO" "Checking dependencies..."
    
    local deps=("git" "systemctl" "nginx")
    for dep in "${deps[@]}"; do
        if ! command -v "$dep" &> /dev/null; then
            print_status "ERROR" "Dependency not found: $dep"
            exit 1
        fi
    done
    
    print_status "INFO" "All dependencies satisfied"
}

# 备份当前版本
backup_current() {
    if [[ -d "$APP_DIR" ]]; then
        print_status "INFO" "Backing up current version..."
        local backup_name="$BACKUP_DIR/$(date +%Y%m%d_%H%M%S)"
        mkdir -p "$backup_name"
        cp -r "$APP_DIR"/* "$backup_name/"
        print_status "INFO" "Backup completed: $backup_name"
    fi
}

# 部署新版本
deploy_app() {
    print_status "INFO" "Deploying application..."
    
    # 停止服务
    if systemctl is-active --quiet "$SERVICE_NAME"; then
        print_status "INFO" "Stopping service: $SERVICE_NAME"
        sudo systemctl stop "$SERVICE_NAME"
    fi
    
    # 克隆或更新代码
    if [[ -d "$APP_DIR/.git" ]]; then
        print_status "INFO" "Updating existing repository..."
        cd "$APP_DIR" && git pull origin main
    else
        print_status "INFO" "Cloning repository..."
        sudo rm -rf "$APP_DIR"
        sudo git clone "$GIT_REPO" "$APP_DIR"
    fi
    
    # 安装依赖
    if [[ -f "$APP_DIR/requirements.txt" ]]; then
        print_status "INFO" "Installing Python dependencies..."
        pip install -r "$APP_DIR/requirements.txt"
    fi
    
    if [[ -f "$APP_DIR/package.json" ]]; then
        print_status "INFO" "Installing Node.js dependencies..."
        cd "$APP_DIR" && npm install
    fi
    
    # 设置权限
    sudo chown -R www-data:www-data "$APP_DIR"
    sudo chmod -R 755 "$APP_DIR"
}

# 启动服务
start_services() {
    print_status "INFO" "Starting services..."
    
    sudo systemctl start "$SERVICE_NAME"
    sudo systemctl enable "$SERVICE_NAME"
    
    # 检查服务状态
    if systemctl is-active --quiet "$SERVICE_NAME"; then
        print_status "INFO" "Service started successfully: $SERVICE_NAME"
    else
        print_status "ERROR" "Failed to start service: $SERVICE_NAME"
        exit 1
    fi
}

# 健康检查
health_check() {
    print_status "INFO" "Performing health check..."
    
    local max_attempts=30
    local attempt=0
    
    while [[ $attempt -lt $max_attempts ]]; do
        if curl -f http://localhost:8080/health &> /dev/null; then
            print_status "INFO" "Health check passed"
            return 0
        fi
        
        ((attempt++))
        sleep 2
    done
    
    print_status "ERROR" "Health check failed"
    return 1
}

# 回滚函数
rollback() {
    print_status "WARNING" "Rolling back to previous version..."
    
    local latest_backup=$(ls -t "$BACKUP_DIR" | head -n1)
    if [[ -n "$latest_backup" ]]; then
        sudo systemctl stop "$SERVICE_NAME"
        sudo rm -rf "$APP_DIR"
        sudo cp -r "$BACKUP_DIR/$latest_backup" "$APP_DIR"
        sudo systemctl start "$SERVICE_NAME"
        print_status "INFO" "Rollback completed"
    else
        print_status "ERROR" "No backup found for rollback"
    fi
}

# 主部署流程
main() {
    print_status "INFO" "Starting deployment of $APP_NAME"
    
    check_dependencies
    backup_current
    deploy_app
    start_services
    
    if health_check; then
        print_status "INFO" "Deployment completed successfully"
    else
        print_status "ERROR" "Deployment failed, initiating rollback"
        rollback
        exit 1
    fi
}

# 处理命令行参数
case "${1:-deploy}" in
    "deploy")
        main
        ;;
    "rollback")
        rollback
        ;;
    *)
        echo "Usage: $0 {deploy|rollback}"
        exit 1
        ;;
esac

#!/bin/bash

# 性能优化示例

# 1. 避免不必要的子进程
# 慢速方法
slow_method() {
    for file in $(ls /path/*.txt); do
        echo "Processing: $file"
    done
}

# 快速方法
fast_method() {
    for file in /path/*.txt; do
        [[ -f "$file" ]] && echo "Processing: $file"
    done
}

# 2. 使用内置命令替代外部命令
# 慢速方法
count_lines_slow() {
    local file=$1
    wc -l < "$file"
}

# 快速方法
count_lines_fast() {
    local file=$1
    local count=0
    while IFS= read -r line; do
        ((count++))
    done < "$file"
    echo $count
}

# 3. 批量处理而非逐个处理
# 慢速方法
process_files_slow() {
    for file in *.log; do
        grep "ERROR" "$file" > "${file}.errors"
    done
}

# 快速方法
process_files_fast() {
    grep -l "ERROR" *.log | xargs -I {} sh -c 'grep "ERROR" "$1" > "$1.errors"' _ {}
}

# 4. 使用关联数组进行查找
declare -A user_groups
user_groups["alice"]="admin"
user_groups["bob"]="user"
user_groups["charlie"]="admin"

# 快速查找用户组
get_user_group() {
    local user=$1
    echo "${user_groups[$user]:-unknown}"
}

#!/bin/bash

# 错误处理和调试示例

# 设置严格模式
set -euo pipefail  # 遇到错误立即退出，未定义变量报错，管道错误传播

# 调试模式
DEBUG=${DEBUG:-0}
debug_log() {
    [[ $DEBUG -eq 1 ]] && echo "[DEBUG] $*" >&2
}

# 错误处理函数
error_exit() {
    local message=$1
    local code=${2:-1}
    echo "ERROR: $message" >&2
    exit $code
}

# 清理函数
cleanup() {
    local exit_code=$?
    debug_log "Cleaning up temporary files"
    rm -f /tmp/script_temp_*
    exit $exit_code
}

# 注册清理函数
trap cleanup EXIT
trap 'error_exit "Script interrupted" 130' INT

# 参数验证
validate_parameters() {
    [[ $# -lt 1 ]] && error_exit "Usage: $0 <input_file>"
    [[ ! -f "$1" ]] && error_exit "Input file does not exist: $1"
    [[ ! -r "$1" ]] && error_exit "Input file is not readable: $1"
}

# 安全的文件操作
safe_file_operation() {
    local source=$1
    local destination=$2
    
    # 创建临时文件
    local temp_file=$(mktemp /tmp/script_temp_XXXXXX)
    
    # 执行操作
    if cp "$source" "$temp_file"; then
        debug_log "File copied to temporary location"
        
        # 验证文件完整性
        if cmp -s "$source" "$temp_file"; then
            mv "$temp_file" "$destination"
            debug_log "File operation completed successfully"
        else
            error_exit "File integrity check failed"
        fi
    else
        error_exit "Failed to copy file: $source"
    fi
}

# 重试机制
retry_command() {
    local max_attempts=$1
    local delay=$2
    shift 2
    local command=("$@")
    
    local attempt=1
    while [[ $attempt -le $max_attempts ]]; do
        debug_log "Attempt $attempt of $max_attempts: ${command[*]}"
        
        if "${command[@]}"; then
            debug_log "Command succeeded on attempt $attempt"
            return 0
        fi
        
        if [[ $attempt -lt $max_attempts ]]; then
            debug_log "Command failed, retrying in ${delay}s"
            sleep $delay
        fi
        
        ((attempt++))
    done
    
    error_exit "Command failed after $max_attempts attempts: ${command[*]}"
}

# 主函数
main() {
    validate_parameters "$@"
    
    local input_file=$1
    local output_file="${input_file}.processed"
    
    debug_log "Processing file: $input_file"
    
    # 使用重试机制执行网络操作
    retry_command 3 5 curl -f "http://api.example.com/process" -d "@$input_file"
    
    # 安全的文件操作
    safe_file_operation "$input_file" "$output_file"
    
    echo "Processing completed: $output_file"
}

# 执行主函数
main "$@"