linux uustat命令

命令简介

uustat 是UUCP（Unix to Unix Copy）工具集的状态查看工具，用于显示和控制UUCP作业队列的状态。它可以列出正在等待、正在执行或已完成的UUCP作业，允许管理员监控文件传输、远程命令执行等活动的状态，并可以删除或重新排队作业。

注意：uustat 是较老的UUCP系统管理工具，现代Linux系统中通常使用systemctl、journalctl等工具进行服务状态监控。但在某些遗留系统或特定应用中可能还会遇到。

基本语法

# 基本格式
uustat [选项] [作业ID] [系统名]

# 常用格式
uustat -a                      # 显示所有作业
uustat -s remotesys           # 显示特定系统的作业
uustat -k jobid               # 删除指定作业
uustat -r jobid               # 重新排队作业

UUCP作业系统简介

UUCP作业状态

UUCP作业可以处于以下状态：

  • 等待 (Waiting): 作业在队列中等待执行
  • 活动 (Active): 作业正在执行中
  • 完成 (Completed): 作业已成功完成
  • 失败 (Failed): 作业执行失败
  • 挂起 (Held): 作业被手动挂起
  • 已删除 (Deleted): 作业已被删除
UUCP作业类型

UUCP系统处理的主要作业类型：

  • 文件传输作业 (uucp)
  • 远程命令执行作业 (uux)
  • 邮件传输作业 (rmail)
  • 新闻组文章传输 (rnews)
  • 系统间同步作业
  • 批处理作业

常用选项

选项 描述
-a 显示所有作业（包括已完成和失败的）
-s 系统名 显示指定系统的作业
-u 用户名 显示指定用户的作业
-k 作业ID 删除（终止）指定作业
-r 作业ID 重新排队指定作业
-q 显示作业队列统计信息
-m 显示邮件作业
-o 小时数 显示指定小时内的旧作业
-y 小时数 显示指定小时内完成的作业
-p 显示进程ID
-l 长格式显示（详细信息）
-j 作业ID 显示指定作业的详细信息
-x 调试等级 显示调试信息（1-9）
-h 显示帮助信息
-V 显示版本信息

安装UUCP工具

现代Linux系统通常不预装UUCP工具，需要手动安装：

# Debian/Ubuntu
sudo apt-get update
sudo apt-get install uucp

# RHEL/CentOS
sudo yum install uucp
# 或
sudo dnf install uucp

# Arch Linux
sudo pacman -S uucp

# 验证安装
which uustat
uustat --help
# 输出示例：uustat (GNU UUCP) 1.07

# 创建测试作业
# 创建测试文件传输作业
echo "Test file" > /tmp/test.txt
uucp /tmp/test.txt remotehost!~/test.txt
# 创建测试命令作业
uux "remotehost!date"

# 查看作业状态
uustat -a
# 应该能看到刚创建的作业

实际示例

示例1：基本作业查看

查看UUCP作业的基本状态：

# 1. 显示所有作业
uustat -a
# 输出示例：
# remotehostN1234  username  remotehost  01/10 10:00 Executing uucp
# remotehostN5678  username  remotehost  01/10 10:05 Waiting    uux
# server1N9012    username  server1    01/10 09:30 Completed  rmail
# server1N3456    username  server1    01/10 09:25 Failed     uucp

# 字段说明：
# 作业ID: remotehostN1234
# 用户名: username
# 目标系统: remotehost
# 时间: 01/10 10:00
# 状态: Executing
# 类型: uucp

# 2. 显示队列统计
uustat -q
# 输出示例：
# 等待作业: 2
# 活动作业: 1
# 已完成: 15
# 失败: 3
# 总作业: 21

# 3. 显示特定系统的作业
uustat -s remotehost
# 只显示remotehost系统的作业

# 4. 显示特定用户的作业
uustat -u username
# 只显示username用户的作业

# 5. 显示邮件作业
uustat -m
# 只显示邮件相关作业

# 6. 显示旧作业（24小时内）
uustat -o 24
# 显示24小时内的旧作业

# 7. 显示完成作业（12小时内）
uustat -y 12
# 显示12小时内完成的作业

# 8. 长格式显示
uustat -l
# 或
uustat -a -l
# 显示详细信息，包括：
# - 作业创建时间
# - 最后修改时间
# - 文件大小
# - 命令参数
# - 错误信息

示例2：作业管理和控制

管理UUCP作业队列：

# 1. 删除单个作业
# 首先查看作业ID
uustat -a
# 输出：
# remotehostN1234  username  remotehost  10:00 Waiting uucp
# 删除作业
uustat -k remotehostN1234
# 输出：Job remotehostN1234 deleted

# 2. 删除用户的所有作业
uustat -u username | awk '{print $1}' | xargs -I {} uustat -k {}
# 或
for job in $(uustat -u username | awk '{print $1}'); do
    uustat -k $job
done

# 3. 删除系统的所有作业
uustat -s remotehost | awk '{print $1}' | xargs -I {} uustat -k {}

# 4. 删除所有作业
uustat -a | awk '{print $1}' | xargs -I {} uustat -k {}
# 或（某些版本支持）
uustat -k ALL

# 5. 重新排队失败的作业
# 查看失败的作业
uustat -a | grep Failed
# 重新排队
uustat -r remotehostN1234
# 输出：Job remotehostN1234 requeued

# 6. 重新排队用户的所有失败作业
uustat -u username | grep Failed | awk '{print $1}' | xargs -I {} uustat -r {}

# 7. 挂起作业（通过更改状态）
# 没有直接挂起选项，但可以通过修改作业文件实现
# 作业文件位置：/var/spool/uucp/系统名/C./作业文件
# 将状态从等待改为挂起

# 8. 恢复挂起的作业
# 将状态从挂起改为等待

# 9. 查看作业详细信息
uustat -j remotehostN1234
# 显示作业的详细信息，包括：
# - 作业文件内容
# - 命令参数
# - 相关文件
# - 状态历史

# 10. 监控作业进度
# 持续监控作业状态
watch -n 5 'uustat -a'
# 或
while true; do
    clear
    uustat -a
    sleep 5
done

示例3：高级作业分析和报告

使用脚本分析UUCP作业：

#!/bin/bash
# 文件名: uucp-job-report.sh
# UUCP作业分析报告脚本

REPORT_DIR="/var/log/uucp/reports"
DATE=$(date +%Y%m%d)
REPORT_FILE="$REPORT_DIR/job-report-$DATE.txt"

# 创建报告目录
mkdir -p $REPORT_DIR

# 生成报告
{
    echo "=== UUCP作业分析报告 ==="
    echo "生成时间: $(date)"
    echo "主机名: $(hostname)"
    echo ""

    # 1. 总体统计
    echo "1. 作业总体统计:"
    echo "总作业数: $(uustat -a 2>/dev/null | wc -l)"
    echo "等待作业: $(uustat -a 2>/dev/null | grep -c Waiting)"
    echo "活动作业: $(uustat -a 2>/dev/null | grep -c Executing)"
    echo "完成作业: $(uustat -a 2>/dev/null | grep -c Completed)"
    echo "失败作业: $(uustat -a 2>/dev/null | grep -c Failed)"
    echo ""

    # 2. 用户统计
    echo "2. 用户作业统计:"
    echo "用户          作业数"
    echo "---------------------"
    uustat -a 2>/dev/null | awk '{print $2}' | sort | uniq -c | sort -rn | \
        awk '{printf "%-12s %-8s\n", $2, $1}'
    echo ""

    # 3. 系统统计
    echo "3. 系统作业统计:"
    echo "系统          作业数"
    echo "---------------------"
    uustat -a 2>/dev/null | awk '{print $3}' | sort | uniq -c | sort -rn | \
        awk '{printf "%-12s %-8s\n", $2, $1}'
    echo ""

    # 4. 类型统计
    echo "4. 作业类型统计:"
    echo "类型          作业数"
    echo "---------------------"
    uustat -a 2>/dev/null | awk '{print $6}' | sort | uniq -c | sort -rn | \
        awk '{printf "%-12s %-8s\n", $2, $1}'
    echo ""

    # 5. 时间分布
    echo "5. 作业时间分布 (最近24小时):"
    echo "小时          作业数"
    echo "---------------------"
    for hour in {0..23}; do
        count=$(uustat -a 2>/dev/null | grep "$(date -d "$hour hours ago" +%m/%d\ %H)" | wc -l)
        printf "%-4s小时前    %-8s\n" "$hour" "$count"
    done
    echo ""

    # 6. 最活跃作业
    echo "6. 最活跃的前10个作业:"
    echo "作业ID        状态      用户      系统      时间      类型"
    echo "-------------------------------------------------------------"
    uustat -a 2>/dev/null | head -10
    echo ""

    # 7. 失败作业分析
    echo "7. 失败作业分析:"
    echo "作业ID        用户      系统      时间      错误"
    echo "-------------------------------------------------------------"
    uustat -a 2>/dev/null | grep Failed | head -5
    echo ""

    if [ -f "/var/spool/uucp/.Log/remotehost" ]; then
        echo "8. 最近错误日志:"
        tail -10 /var/spool/uucp/.Log/remotehost
    fi

} > $REPORT_FILE

echo "报告已生成: $REPORT_FILE"

# 生成HTML报告
HTML_FILE="$REPORT_DIR/job-report-$DATE.html"
cat > $HTML_FILE << EOF



    UUCP作业分析报告
    


    
UUCP作业分析报告

    
生成时间: $(date)

    
主机名: $(hostname)


    

        
作业总体统计

        

            

                状态
                数量
            

            
总作业数$(uustat -a 2>/dev/null | wc -l)

            
等待作业$(uustat -a 2>/dev/null | grep -c Waiting)

            
活动作业$(uustat -a 2>/dev/null | grep -c Executing)

            
完成作业$(uustat -a 2>/dev/null | grep -c Completed)

            
失败作业$(uustat -a 2>/dev/null | grep -c Failed)

        

    



EOF

echo "HTML报告已生成: $HTML_FILE"

示例4：自动作业监控和清理

自动化UUCP作业监控和清理：

#!/bin/bash
# 文件名: uucp-job-monitor.sh
# 自动UUCP作业监控和清理脚本

LOG_FILE="/var/log/uucp/job-monitor.log"
MAX_WAITING_JOBS=50
MAX_FAILED_JOBS=20
MAX_AGE_HOURS=72
ALERT_EMAIL="admin@example.com"

# 记录日志
log_message() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" >> $LOG_FILE
    echo "$1"
}

# 检查作业状态
check_job_status() {
    log_message "检查UUCP作业状态..."

    # 检查等待作业数
    WAITING_COUNT=$(uustat -a 2>/dev/null | grep -c Waiting)
    if [ $WAITING_COUNT -gt $MAX_WAITING_JOBS ]; then
        log_message "警报: 等待作业过多 ($WAITING_COUNT/$MAX_WAITING_JOBS)"
        echo "UUCP等待作业过多: $WAITING_COUNT" | mail -s "UUCP作业警报" $ALERT_EMAIL
    fi

    # 检查失败作业数
    FAILED_COUNT=$(uustat -a 2>/dev/null | grep -c Failed)
    if [ $FAILED_COUNT -gt $MAX_FAILED_JOBS ]; then
        log_message "警报: 失败作业过多 ($FAILED_COUNT/$MAX_FAILED_JOBS)"
        echo "UUCP失败作业过多: $FAILED_COUNT" | mail -s "UUCP作业警报" $ALERT_EMAIL

        # 自动清理旧失败作业
        log_message "清理失败作业..."
        uustat -a 2>/dev/null | grep Failed | awk '{print $1}' | xargs -I {} uustat -k {} 2>/dev/null
    fi

    # 检查旧作业
    log_message "检查旧作业（超过${MAX_AGE_HOURS}小时）..."
    OLD_JOBS=$(uustat -o $MAX_AGE_HOURS 2>/dev/null | wc -l)
    if [ $OLD_JOBS -gt 0 ]; then
        log_message "发现 $OLD_JOBS 个旧作业，正在清理..."
        uustat -o $MAX_AGE_HOURS 2>/dev/null | awk '{print $1}' | xargs -I {} uustat -k {} 2>/dev/null
    fi
}

# 检查队列健康度
check_queue_health() {
    log_message "检查队列健康度..."

    # 计算队列健康度
    TOTAL_JOBS=$(uustat -a 2>/dev/null | wc -l)
    if [ $TOTAL_JOBS -eq 0 ]; then
        HEALTH=100
    else
        FAILED_JOBS=$(uustat -a 2>/dev/null | grep -c Failed)
        HEALTH=$((100 - (FAILED_JOBS * 100 / TOTAL_JOBS)))
    fi

    log_message "队列健康度: $HEALTH%"

    if [ $HEALTH -lt 80 ]; then
        log_message "警报: 队列健康度过低 ($HEALTH%)"
        echo "UUCP队列健康度过低: $HEALTH%" | mail -s "UUCP队列警报" $ALERT_EMAIL
    fi
}

# 生成统计报告
generate_statistics() {
    log_message "生成统计报告..."

    STATS_FILE="/var/log/uucp/daily-stats-$(date +%Y%m%d).txt"

    {
        echo "=== UUCP每日统计报告 ==="
        echo "日期: $(date)"
        echo ""

        # 作业统计
        echo "作业统计:"
        uustat -q 2>/dev/null || echo "无法获取队列统计"
        echo ""

        # 系统统计
        echo "各系统作业数:"
        uustat -a 2>/dev/null | awk '{print $3}' | sort | uniq -c | sort -rn
        echo ""

        # 用户统计
        echo "各用户作业数:"
        uustat -a 2>/dev/null | awk '{print $2}' | sort | uniq -c | sort -rn
        echo ""

        # 性能统计
        echo "性能统计:"
        echo "平均处理时间: 计算中..."
        echo "成功率: 计算中..."

    } > $STATS_FILE

    log_message "统计报告已生成: $STATS_FILE"
}

# 清理临时文件
cleanup_temp_files() {
    log_message "清理临时文件..."

    # 清理旧的临时文件
    find /var/spool/uucp -name "*.tmp" -mtime +1 -delete
    find /var/spool/uucp -name "*.temp" -mtime +1 -delete
    find /tmp -name "uucp-*" -mtime +1 -delete

    # 清理旧的日志文件
    find /var/log/uucp -name "*.log.*" -mtime +7 -delete
    find /var/log/uucp -name "daily-stats-*.txt" -mtime +30 -delete
}

# 主函数
main() {
    log_message "=== 开始UUCP作业监控 ==="

    # 检查uustat是否可用
    if ! command -v uustat &> /dev/null; then
        log_message "错误: uustat命令未找到"
        exit 1
    fi

    # 执行监控任务
    check_job_status
    check_queue_health
    generate_statistics
    cleanup_temp_files

    log_message "=== 监控完成 ==="
}

# 运行主函数
main

# 计划任务配置
# 添加以下行到crontab (crontab -e)
# 每5分钟运行一次监控
# */5 * * * * /path/to/uucp-job-monitor.sh
# 每天凌晨1点生成详细报告
# 0 1 * * * /path/to/uucp-job-monitor.sh --full-report

示例5：故障排查和调试

UUCP作业故障排查：

# 1. 检查UUCP服务状态
# 查看uucico进程
ps aux | grep uucico
# 查看uuxqt进程
ps aux | grep uuxqt
# 查看uucp服务状态
systemctl status uucp

# 2. 查看作业详细信息
# 使用调试模式查看作业
uustat -x 5 -a
# 显示调试信息

# 3. 查看作业文件
# 作业文件位置
ls -la /var/spool/uucp/
# 查看具体作业文件
ls -la /var/spool/uucp/remotehost/C./
# 查看作业文件内容
cat /var/spool/uucp/remotehost/C./remotehostN1234

# 4. 检查作业日志
# 查看作业相关日志
tail -f /var/spool/uucp/.Log/uucico/remotehost
tail -f /var/spool/uucp/.Admin/remotehost

# 5. 手动测试作业
# 创建测试作业
echo "Test" > /tmp/test.txt
uucp /tmp/test.txt remotehost!~/test.txt
# 查看作业状态
uustat -a
# 查看作业ID
JOB_ID=$(uustat -a | grep "test.txt" | awk '{print $1}')
echo "作业ID: $JOB_ID"
# 查看作业详情
uustat -j $JOB_ID

# 6. 模拟作业失败
# 停止远程服务
# 在远程主机上：systemctl stop uucp
# 创建作业
uucp /tmp/test.txt remotehost!~/test.txt
# 查看失败状态
uustat -a | grep Failed
# 查看错误信息
tail -f /var/spool/uucp/.Log/uucico/remotehost

# 7. 恢复作业
# 启动远程服务
# 在远程主机上：systemctl start uucp
# 重新排队作业
uustat -r $JOB_ID
# 查看状态
uustat -a | grep $JOB_ID

# 8. 检查权限问题
# 查看spool目录权限
ls -la /var/spool/uucp/
# 应该为 uucp:uucp
# 修复权限
chown -R uucp:uucp /var/spool/uucp
chmod 755 /var/spool/uucp

# 9. 检查配置文件
# 检查系统配置
cat /etc/uucp/sys
# 检查权限配置
cat /etc/uucp/permissions
# 检查调试配置
cat /etc/uucp/config | grep -i debug

# 10. 网络诊断
# 检查网络连接
ping -c 3 remotehost
# 检查端口
telnet remotehost 540
# 检查路由
traceroute remotehost

# 11. 性能调优
# 查看系统资源
top -b -n 1 | grep -E "uucico|uuxqt"
# 调整队列大小
# 编辑/etc/uucp/config
max-aux-items = 100
max-uuxqt-procs = 5

# 12. 安全监控
# 检查可疑作业
uustat -a | grep -i "root\|admin\|password\|secret"
# 监控异常时间作业
uustat -a | grep -E "(0[0-5]|2[2-3]):[0-5][0-9]"
# 检查来自未知系统的作业
uustat -a | awk '{print $3}' | sort | uniq | \
    while read sys; do
        grep -q "^system $sys" /etc/uucp/sys || echo "未知系统: $sys"
    done

示例6：批量作业管理

批量管理UUCP作业：

#!/bin/bash
# 文件名: uucp-batch-manager.sh
# UUCP批量作业管理工具

# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color

# 函数：显示菜单
show_menu() {
    clear
    echo -e "${BLUE}=== UUCP批量作业管理器 ===${NC}"
    echo ""
    echo "1. 查看所有作业"
    echo "2. 查看等待作业"
    echo "3. 查看活动作业"
    echo "4. 查看完成作业"
    echo "5. 查看失败作业"
    echo "6. 删除作业"
    echo "7. 重新排队作业"
    echo "8. 批量操作"
    echo "9. 生成报告"
    echo "0. 退出"
    echo ""
}

# 函数：查看所有作业
view_all_jobs() {
    echo -e "${YELLOW}所有作业:${NC}"
    uustat -a 2>/dev/null
    echo ""
    read -p "按回车键继续..."
}

# 函数：查看等待作业
view_waiting_jobs() {
    echo -e "${YELLOW}等待作业:${NC}"
    uustat -a 2>/dev/null | grep Waiting
    echo ""
    read -p "按回车键继续..."
}

# 函数：查看活动作业
view_active_jobs() {
    echo -e "${YELLOW}活动作业:${NC}"
    uustat -a 2>/dev/null | grep Executing
    echo ""
    read -p "按回车键继续..."
}

# 函数：查看完成作业
view_completed_jobs() {
    echo -e "${YELLOW}完成作业:${NC}"
    uustat -a 2>/dev/null | grep Completed
    echo ""
    read -p "按回车键继续..."
}

# 函数：查看失败作业
view_failed_jobs() {
    echo -e "${YELLOW}失败作业:${NC}"
    uustat -a 2>/dev/null | grep Failed
    echo ""
    read -p "按回车键继续..."
}

# 函数：删除作业
delete_job() {
    echo -e "${YELLOW}删除作业${NC}"
    read -p "请输入作业ID: " job_id

    if [ -n "$job_id" ]; then
        uustat -k $job_id 2>/dev/null
        if [ $? -eq 0 ]; then
            echo -e "${GREEN}作业 $job_id 已删除${NC}"
        else
            echo -e "${RED}删除作业失败${NC}"
        fi
    fi
    read -p "按回车键继续..."
}

# 函数：重新排队作业
requeue_job() {
    echo -e "${YELLOW}重新排队作业${NC}"
    read -p "请输入作业ID: " job_id

    if [ -n "$job_id" ]; then
        uustat -r $job_id 2>/dev/null
        if [ $? -eq 0 ]; then
            echo -e "${GREEN}作业 $job_id 已重新排队${NC}"
        else
            echo -e "${RED}重新排队失败${NC}"
        fi
    fi
    read -p "按回车键继续..."
}

# 函数：批量操作
batch_operations() {
    while true; do
        clear
        echo -e "${BLUE}=== 批量操作菜单 ===${NC}"
        echo ""
        echo "1. 删除所有失败作业"
        echo "2. 删除用户的所有作业"
        echo "3. 删除系统的所有作业"
        echo "4. 重新排队所有失败作业"
        echo "5. 删除旧作业（超过7天）"
        echo "6. 返回主菜单"
        echo ""

        read -p "请选择操作: " batch_choice

        case $batch_choice in
            1)
                echo -e "${YELLOW}删除所有失败作业...${NC}"
                failed_jobs=$(uustat -a 2>/dev/null | grep Failed | awk '{print $1}')
                if [ -n "$failed_jobs" ]; then
                    echo "$failed_jobs" | xargs -I {} uustat -k {} 2>/dev/null
                    echo -e "${GREEN}已删除所有失败作业${NC}"
                else
                    echo -e "${YELLOW}没有失败作业${NC}"
                fi
                ;;
            2)
                read -p "请输入用户名: " username
                if [ -n "$username" ]; then
                    user_jobs=$(uustat -u $username 2>/dev/null | awk '{print $1}')
                    if [ -n "$user_jobs" ]; then
                        echo "$user_jobs" | xargs -I {} uustat -k {} 2>/dev/null
                        echo -e "${GREEN}已删除用户 $username 的所有作业${NC}"
                    else
                        echo -e "${YELLOW}用户 $username 没有作业${NC}"
                    fi
                fi
                ;;
            3)
                read -p "请输入系统名: " system
                if [ -n "$system" ]; then
                    system_jobs=$(uustat -s $system 2>/dev/null | awk '{print $1}')
                    if [ -n "$system_jobs" ]; then
                        echo "$system_jobs" | xargs -I {} uustat -k {} 2>/dev/null
                        echo -e "${GREEN}已删除系统 $system 的所有作业${NC}"
                    else
                        echo -e "${YELLOW}系统 $system 没有作业${NC}"
                    fi
                fi
                ;;
            4)
                echo -e "${YELLOW}重新排队所有失败作业...${NC}"
                failed_jobs=$(uustat -a 2>/dev/null | grep Failed | awk '{print $1}')
                if [ -n "$failed_jobs" ]; then
                    echo "$failed_jobs" | xargs -I {} uustat -r {} 2>/dev/null
                    echo -e "${GREEN}已重新排队所有失败作业${NC}"
                else
                    echo -e "${YELLOW}没有失败作业${NC}"
                fi
                ;;
            5)
                echo -e "${YELLOW}删除旧作业（超过7天）...${NC}"
                old_jobs=$(uustat -o 168 2>/dev/null | awk '{print $1}')
                if [ -n "$old_jobs" ]; then
                    echo "$old_jobs" | xargs -I {} uustat -k {} 2>/dev/null
                    echo -e "${GREEN}已删除旧作业${NC}"
                else
                    echo -e "${YELLOW}没有旧作业${NC}"
                fi
                ;;
            6)
                return
                ;;
            *)
                echo -e "${RED}无效选择${NC}"
                ;;
        esac

        read -p "按回车键继续..."
    done
}

# 函数：生成报告
generate_report() {
    echo -e "${YELLOW}生成报告...${NC}"

    REPORT_FILE="/tmp/uucp-report-$(date +%Y%m%d-%H%M%S).txt"

    {
        echo "=== UUCP作业报告 ==="
        echo "生成时间: $(date)"
        echo ""

        # 总体统计
        echo "总体统计:"
        uustat -q 2>/dev/null || echo "无法获取统计"
        echo ""

        # 等待作业详情
        echo "等待作业:"
        uustat -a 2>/dev/null | grep Waiting
        echo ""

        # 活动作业详情
        echo "活动作业:"
        uustat -a 2>/dev/null | grep Executing
        echo ""

        # 失败作业详情
        echo "失败作业:"
        uustat -a 2>/dev/null | grep Failed
        echo ""

    } > $REPORT_FILE

    echo -e "${GREEN}报告已生成: $REPORT_FILE${NC}"
    read -p "按回车键继续..."
}

# 主函数
main() {
    while true; do
        show_menu
        read -p "请选择操作: " choice

        case $choice in
            1) view_all_jobs ;;
            2) view_waiting_jobs ;;
            3) view_active_jobs ;;
            4) view_completed_jobs ;;
            5) view_failed_jobs ;;
            6) delete_job ;;
            7) requeue_job ;;
            8) batch_operations ;;
            9) generate_report ;;
            0)
                echo -e "${GREEN}退出${NC}"
                exit 0
                ;;
            *)
                echo -e "${RED}无效选择${NC}"
                read -p "按回车键继续..."
                ;;
        esac
    done
}

# 运行主函数
main

现代替代工具

systemctl

systemd服务管理工具，替代uustat监控服务状态。

# 查看服务状态
systemctl status uucp
# 查看服务日志
journalctl -u uucp
# 重启服务
systemctl restart uucp
# 查看依赖关系
systemctl list-dependencies uucp
at 和 cron

作业调度工具，替代UUCP的作业队列。

# 单次作业调度
at now + 1 hour
# 输入命令
# Ctrl+D结束
# 周期作业调度
crontab -e
# 添加：0 2 * * * /path/to/backup.sh
# 查看作业队列
atq
crontab -l
rsync

文件同步工具，替代UUCP文件传输。

# 同步文件
rsync -avz /local/path/ user@remote:/remote/path/
# 通过SSH
rsync -avz -e ssh /local/ remote:/
# 监控传输状态
rsync --progress source dest
# 断点续传
rsync --partial source dest
supervisor

进程监控工具，替代作业状态监控。

# 安装
pip install supervisor
# 配置
echo_supervisord_conf > /etc/supervisord.conf
# 启动
supervisord -c /etc/supervisord.conf
# 查看状态
supervisorctl status
# 控制进程
supervisorctl start|stop|restart process

常见问题

可能原因和解决方案：

  1. 权限问题：当前用户无法读取作业文件 
    # 检查spool目录权限
ls -la /var/spool/uucp/
# 应为uucp:uucp 755
# 修复权限
sudo chown -R uucp:uucp /var/spool/uucp
sudo chmod 755 /var/spool/uucp
  2. UUCP服务未运行：uucico或uuxqt未运行 
    # 检查服务状态
ps aux | grep uucico
ps aux | grep uuxqt
# 启动服务
sudo systemctl start uucp
# 检查作业文件是否存在
ls -la /var/spool/uucp/*/C./
  3. 作业文件损坏：作业文件格式错误 
    # 检查作业文件
find /var/spool/uucp -name "C.*" -type f | head -5
# 查看文件内容
cat /var/spool/uucp/remotehost/C./remotehostN1234
# 如果损坏，删除
rm /var/spool/uucp/remotehost/C./remotehostN1234
  4. 使用正确选项：可能需要使用-a选项 
    # 默认只显示活动作业
uustat
# 显示所有作业
uustat -a
# 显示特定用户
uustat -u username
# 显示特定系统
uustat -s remotehost
  5. 作业已被处理：作业可能已被处理并删除 
    # 检查日志
tail -f /var/log/uucp/Log
# 查看作业处理记录
grep -i "processed\|completed\|failed" /var/log/uucp/Log

迁移步骤：

  1. 分析现有作业：导出当前作业状态 
    # 导出所有作业
uustat -a > /tmp/uucp-jobs-backup.txt
# 分析作业类型
awk '{print $6}' /tmp/uucp-jobs-backup.txt | sort | uniq -c
# 最常见的类型：
# uucp - 文件传输
# uux - 远程命令
# rmail - 邮件
# rnews - 新闻
  2. 文件传输迁移：uucp → rsync/scp 
    # 提取文件传输作业
grep "uucp" /tmp/uucp-jobs-backup.txt
# 转换为rsync命令
# 原：uucp file.txt remotehost!~/file.txt
# 新：rsync -avz file.txt user@remotehost:~/file.txt
# 或：scp file.txt user@remotehost:~/file.txt
  3. 远程命令迁移：uux → ssh 
    # 提取远程命令作业
grep "uux" /tmp/uucp-jobs-backup.txt
# 转换为ssh命令
# 原：uux "remotehost!date"
# 新：ssh user@remotehost "date"
# 批量执行：使用ssh密钥认证
  4. 邮件传输迁移：rmail → SMTP 
    # 配置现代邮件系统
# 安装Postfix或Sendmail
sudo apt-get install postfix
# 配置邮件转发
# 使用mail命令替代
echo "内容" | mail -s "主题" user@example.com
  5. 作业调度迁移：UUCP队列 → cron/at 
    # 分析作业时间模式
awk '{print $4, $5}' /tmp/uucp-jobs-backup.txt | sort | uniq -c
# 转换为cron作业
# 原：定时UUCP作业
# 新：crontab -e
# 添加：0 2 * * * /path/to/script.sh
  6. 状态监控迁移：uustat → systemctl 
    # 原：uustat -a
# 新：systemctl status service-name
# 原：uustat -q
# 新：systemctl list-units --type=service
# 使用监控工具：Nagios, Zabbix, Prometheus

性能监控配置：

  1. 实时性能监控： 
    #!/bin/bash
# 实时UUCP性能监控
while true; do
    clear
    echo "=== UUCP性能监控 ==="
    echo "时间: $(date)"
    echo ""

    # 队列统计
    echo "队列统计:"
    uustat -q 2>/dev/null
    echo ""

    # 处理速度
    echo "处理速度 (最近5分钟):"
    START_JOBS=$(uustat -a 2>/dev/null | grep -c "10:0[0-4]")
    END_JOBS=$(uustat -a 2>/dev/null | grep -c "10:0[5-9]")
    PROCESSED=$((START_JOBS - END_JOBS))
    echo "处理作业数: $PROCESSED"
    echo "平均速度: $((PROCESSED / 5)) 作业/分钟"
    echo ""

    # 资源使用
    echo "资源使用:"
    ps aux | grep -E "uucico|uuxqt" | grep -v grep | awk '{print $3, $4, $6}'
    echo ""

    # 预测完成时间
    WAITING_JOBS=$(uustat -a 2>/dev/null | grep -c Waiting)
    if [ $WAITING_JOBS -gt 0 ] && [ $PROCESSED -gt 0 ]; then
        ETA=$((WAITING_JOBS * 5 / PROCESSED))
        echo "预测完成时间: $ETA 分钟"
    fi

    sleep 60
done
  2. 性能指标收集： 
    # 收集性能指标
collect_performance_metrics() {
    METRICS_FILE="/var/log/uucp/performance-$(date +%Y%m%d).csv"

    if [ ! -f "$METRICS_FILE" ]; then
        echo "时间戳,等待作业,活动作业,CPU使用,内存使用,队列深度,处理速度" > $METRICS_FILE
    fi

    TIMESTAMP=$(date '+%Y-%m-%d %H:%M:%S')
    WAITING=$(uustat -a 2>/dev/null | grep -c Waiting)
    ACTIVE=$(uustat -a 2>/dev/null | grep -c Executing)
    CPU=$(ps aux | grep uucico | grep -v grep | awk '{sum += $3} END {print sum}')
    MEM=$(ps aux | grep uucico | grep -v grep | awk '{sum += $4} END {print sum}')
    QUEUE_DEPTH=$((WAITING + ACTIVE))

    echo "$TIMESTAMP,$WAITING,$ACTIVE,$CPU,$MEM,$QUEUE_DEPTH" >> $METRICS_FILE
}

# 每5分钟收集一次
while true; do
    collect_performance_metrics
    sleep 300
done
  3. 性能警报： 
    # 性能阈值
MAX_QUEUE_DEPTH=100
MAX_CPU=80
MAX_MEM=70

check_performance() {
    QUEUE_DEPTH=$(uustat -a 2>/dev/null | wc -l)
    CPU=$(ps aux | grep uucico | grep -v grep | awk '{sum += $3} END {print sum+0}')
    MEM=$(ps aux | grep uucico | grep -v grep | awk '{sum += $4} END {print sum+0}')

    if [ $QUEUE_DEPTH -gt $MAX_QUEUE_DEPTH ]; then
        echo "警报: 队列深度 $QUEUE_DEPTH > $MAX_QUEUE_DEPTH" | mail -s "UUCP性能警报" admin@example.com
    fi

    if [ $(echo "$CPU > $MAX_CPU" | bc) -eq 1 ]; then
        echo "警报: CPU使用 $CPU% > $MAX_CPU%" | mail -s "UUCP性能警报" admin@example.com
    fi

    if [ $(echo "$MEM > $MAX_MEM" | bc) -eq 1 ]; then
        echo "警报: 内存使用 $MEM% > $MAX_MEM%" | mail -s "UUCP性能警报" admin@example.com
    fi
}
  4. 性能优化： 
    # 调整UUCP配置优化性能
sudo nano /etc/uucp/config
# 优化参数：
max-aux-items = 200     # 增加队列大小
max-uuxqt-procs = 10    # 增加并发进程
protocol-parameter g n   # 使用更高效的协议
# 网络优化
compression yes         # 启用压缩
packet-size 1024        # 优化包大小
# 重启服务
sudo systemctl restart uucp

作业队列备份策略：

  1. 完整备份： 
    #!/bin/bash
# UUCP作业队列完整备份
BACKUP_DIR="/backup/uucp-queue"
DATE=$(date +%Y%m%d-%H%M%S)
BACKUP_FILE="$BACKUP_DIR/uucp-queue-$DATE.tar.gz"

# 创建备份目录
mkdir -p $BACKUP_DIR

# 停止UUCP服务（可选）
# systemctl stop uucp

# 备份作业队列
tar -czf $BACKUP_FILE \
    /var/spool/uucp \
    /etc/uucp \
    /var/log/uucp 2>/dev/null

# 备份作业状态
uustat -a > $BACKUP_DIR/uucp-status-$DATE.txt
uustat -q > $BACKUP_DIR/uucp-queue-stats-$DATE.txt

# 生成备份清单
{
    echo "=== UUCP作业队列备份报告 ==="
    echo "备份时间: $(date)"
    echo "备份文件: $BACKUP_FILE"
    echo "文件大小: $(du -h $BACKUP_FILE | cut -f1)"
    echo "作业数量: $(uustat -a 2>/dev/null | wc -l)"
    echo "包含:"
    find /var/spool/uucp -type f | wc -l
    echo "个作业文件"
} > $BACKUP_DIR/backup-report-$DATE.txt

# 启动UUCP服务（如果停止了）
# systemctl start uucp

echo "备份完成: $BACKUP_FILE"
  2. 增量备份： 
    # 增量备份脚本
incremental_backup() {
    BACKUP_DIR="/backup/uucp-queue/incremental"
    DATE=$(date +%Y%m%d-%H%M%S)
    SNAPSHOT_FILE="$BACKUP_DIR/snapshot-$DATE.tar.gz"

    # 查找自上次备份后修改的文件
    LAST_BACKUP=$(ls -t $BACKUP_DIR/snapshot-*.tar.gz 2>/dev/null | head -1)

    if [ -n "$LAST_BACKUP" ]; then
        # 增量备份
        find /var/spool/uucp -type f -newer $LAST_BACKUP -print0 | \
            tar -czf $SNAPSHOT_FILE --null -T -
    else
        # 首次完整备份
        tar -czf $SNAPSHOT_FILE /var/spool/uucp
    fi

    echo "增量备份完成: $SNAPSHOT_FILE"
}
  3. 恢复作业队列： 
    # 恢复UUCP作业队列
restore_uucp_queue() {
    BACKUP_FILE="$1"
    RESTORE_DIR="/var/spool/uucp-restore-$(date +%Y%m%d-%H%M%S)"

    if [ ! -f "$BACKUP_FILE" ]; then
        echo "错误: 备份文件不存在"
        return 1
    fi

    # 停止UUCP服务
    systemctl stop uucp

    # 创建恢复目录
    mkdir -p $RESTORE_DIR

    # 解压备份
    tar -xzf $BACKUP_FILE -C $RESTORE_DIR

    # 备份当前队列
    mv /var/spool/uucp /var/spool/uucp-backup-$(date +%Y%m%d-%H%M%S)

    # 恢复队列
    cp -r $RESTORE_DIR/var/spool/uucp /var/spool/

    # 修复权限
    chown -R uucp:uucp /var/spool/uucp
    chmod 755 /var/spool/uucp

    # 启动UUCP服务
    systemctl start uucp

    echo "恢复完成"
    echo "原队列备份在: /var/spool/uucp-backup-*"
    echo "恢复文件来自: $BACKUP_FILE"
}
  4. 验证备份完整性： 
    # 验证备份完整性
verify_backup() {
    BACKUP_FILE="$1"
    TEMP_DIR="/tmp/backup-verify-$(date +%s)"

    # 解压到临时目录
    mkdir -p $TEMP_DIR
    tar -xzf $BACKUP_FILE -C $TEMP_DIR 2>/dev/null

    # 检查关键文件
    if [ -d "$TEMP_DIR/var/spool/uucp" ]; then
        echo "✓ 作业队列目录存在"
        JOB_COUNT=$(find $TEMP_DIR/var/spool/uucp -name "C.*" -type f | wc -l)
        echo "  包含 $JOB_COUNT 个作业文件"
    else
        echo "✗ 作业队列目录不存在"
    fi

    if [ -d "$TEMP_DIR/etc/uucp" ]; then
        echo "✓ 配置文件目录存在"
    else
        echo "✗ 配置文件目录不存在"
    fi

    # 清理临时目录
    rm -rf $TEMP_DIR

    # 检查备份文件完整性
    if tar -tzf $BACKUP_FILE >/dev/null 2>&1; then
        echo "✓ 备份文件完整性验证通过"
    else
        echo "✗ 备份文件可能损坏"
    fi
}

相关命令

uucp

UUCP文件复制工具
uux

UUCP远程命令执行
uulog

UUCP日志查看工具
systemctl

系统服务管理工具
at

作业调度工具
cron

定时任务工具
上一章: uulog 命令 下一章: ppp-off 命令