add: exmtn, 增加exmtn扩展库

script/libs/exmtn.lua

@@ -0,0 +1,789 @@
+--[[
+@module  exmtn
+@summary 运维日志扩展库，负责日志的持久化存储
+@version 1.0
+@date    2025.12.9
+@author  zengeshuai
+@usage
+exmtn.init(1, 0)  -- 初始化，1个块，缓存写入
+exmtn.log("info", "tag", "message", 123)  -- 输出运维日志
+]]
+
+local exmtn = {}
+
+-- 常量定义
+local LOG_MTN_CACHE_SIZE = 4096
+local LOG_MTN_FILE_COUNT = 4
+local LOG_MTN_CONFIG_FILE = "/exmtn.trc"
+local LOG_MTN_DEFAULT_BLOCKS_DIVISOR = 40
+local LOG_MTN_ADD_WRITE_THRESHOLD = 256
+local LOG_MTN_CONFIG_VERSION = 1
+
+-- 写入方式常量
+exmtn.CACHE_WRITE = 0
+exmtn.ADD_WRITE = 1
+
+-- 内部状态
+local ctx = {
+    inited = false,
+    enabled = false,
+    cur_index = 1,           -- 1-4
+    block_size = 4096,       -- 默认块大小
+    blocks_per_file = 1,     -- 每文件块数
+    file_limit = 4096,       -- 每文件大小限制
+    write_way = 0,           -- 0=缓存写入, 1=直接追加
+    cache = "",              -- 缓存缓冲区
+    cache_used = 0,          -- 缓存已使用字节数
+}
+
+-- 重置缓存
+local function reset_cache()
+    ctx.cache = ""
+    ctx.cache_used = 0
+end
+
+-- 获取当前文件路径
+local function get_file_path(index)
+    return string.format("/hzmtn%d.trc", index or ctx.cur_index)
+end
+
+-- 获取当前文件大小
+local function get_current_file_size()
+    local path = get_file_path()
+    local file = io.open(path, "rb")
+    if not file then
+        return 0
+    end
+    local size = file:seek("end")
+    file:close()
+    -- file:seek("end") 返回文件大小，如果失败返回 nil
+    if size and size > 0 then
+        return size
+    end
+    return 0
+end
+
+-- 检查文件是否存在
+local function file_exists(path)
+    local file = io.open(path, "rb")
+    if file then
+        file:close()
+        return true
+    end
+    return false
+end
+
+-- 检查所有日志文件是否存在
+local function files_exist()
+    for i = 1, LOG_MTN_FILE_COUNT do
+        local path = get_file_path(i)
+        if file_exists(path) then
+            return true
+        end
+    end
+    return false
+end
+
+-- 删除所有日志文件
+local function remove_files()
+    for i = 1, LOG_MTN_FILE_COUNT do
+        local path = get_file_path(i)
+        os.remove(path)
+    end
+end
+
+-- 创建空文件
+local function create_files()
+    for i = 1, LOG_MTN_FILE_COUNT do
+        local path = get_file_path(i)
+        local file = io.open(path, "wb")
+        if file then
+            file:close()
+        end
+    end
+end
+
+-- 读取配置文件
+local function load_config()
+    local file = io.open(LOG_MTN_CONFIG_FILE, "rb")
+    if not file then
+        return nil  -- 文件不存在，返回 nil
+    end
+    
+    local content = file:read("*a")
+    file:close()
+    
+    if not content or #content == 0 then
+        return nil  -- 文件为空
+    end
+    
+    -- 解析配置：格式为 "VERSION=1\nINDEX=2\nBLOCKS=10\nWRITE_WAY=0\n"
+    local config = {}
+    for line in content:gmatch("[^\r\n]+") do
+        -- 移除首尾空白字符
+        line = line:match("^%s*(.-)%s*$") or line
+        local key, value = line:match("([^=]+)=(.+)")
+        if key and value then
+            -- 移除 key 和 value 的首尾空白字符
+            key = key:match("^%s*(.-)%s*$") or key
+            value = value:match("^%s*(.-)%s*$") or value
+            local num_value = tonumber(value)
+            if num_value then
+                config[key] = num_value
+            else
+                config[key] = value
+            end
+        end
+    end
+    
+    -- 验证版本号
+    if config.VERSION ~= LOG_MTN_CONFIG_VERSION then
+        return nil  -- 版本不匹配
+    end
+    
+    return config
+end
+
+-- 保存配置文件
+local function save_config(index, blocks, write_way)
+    local content = string.format("VERSION=%d\nINDEX=%d\nBLOCKS=%d\nWRITE_WAY=%d\n", 
+        LOG_MTN_CONFIG_VERSION, index, blocks, write_way)
+    
+    local file = io.open(LOG_MTN_CONFIG_FILE, "wb")
+    if not file then
+        log.warn("exmtn", "无法打开配置文件: " .. LOG_MTN_CONFIG_FILE)
+        return false
+    end
+    
+    local ok = file:write(content)
+    file:close()
+    
+    if not ok then
+        log.warn("exmtn", "写入配置文件失败: " .. LOG_MTN_CONFIG_FILE)
+        return false
+    end
+    
+    return true
+end
+
+-- 更新索引（同时保存完整配置）
+local function update_index(index)
+    return save_config(index, ctx.blocks_per_file, ctx.write_way)
+end
+
+-- 格式化时间戳
+-- 返回格式: [2025-11-05 15:06:49.947][00000027.994]
+local function format_timestamp()
+    -- 获取系统运行时间（毫秒）
+    local ticks_ms = 0
+    if mcu and mcu.ticks then
+        local ticks = mcu.ticks()
+        if ticks then
+            ticks_ms = ticks
+        end
+    end
+    
+    -- 获取当前日期时间
+    local date_time_str = ""
+    local ms = 0
+    
+    if os and os.date then
+        -- 获取当前日期时间字符串: 2025-11-05 15:06:49
+        local dt = os.date("%Y-%m-%d %H:%M:%S")
+        if dt then
+            -- 计算毫秒：使用系统运行时间的毫秒部分
+            -- 如果 RTC 已设置，时间会更准确
+            ms = ticks_ms % 1000
+            date_time_str = string.format("%s.%03d", dt, ms)
+        end
+    end
+    
+    -- 如果无法获取日期时间，使用默认格式
+    if date_time_str == "" then
+        date_time_str = "1970-01-01 00:00:00.000"
+    end
+    
+    -- 计算系统运行时间（秒.毫秒）
+    local uptime_sec = math.floor(ticks_ms / 1000)
+    local uptime_ms = ticks_ms % 1000
+    
+    -- 格式化运行时间部分: 00000027.994（固定宽度，9位整数+3位小数）
+    local uptime_str = string.format("%09d.%03d", uptime_sec, uptime_ms)
+    
+    -- 返回完整时间戳
+    return string.format("[%s][%s]", date_time_str, uptime_str)
+end
+
+-- 格式化调试信息
+local function format_debug_info(level, include_level)
+    local info = debug.getinfo(2, "Sl")
+    if not info or not info.source then
+        return nil
+    end
+    
+    local src = info.source
+    -- 跳过第一个字符（@ 或 =）
+    if src:sub(1, 1) == "@" or src:sub(1, 1) == "=" then
+        src = src:sub(2)
+    end
+    
+    local line = info.currentline or 0
+    if line > 64 * 1024 then
+        line = 0
+    end
+    
+    if include_level and level then
+        return string.format("%s/%s:%d", level, src, line)
+    else
+        return string.format("%s:%d", src, line)
+    end
+end
+
+-- 格式化消息（与 log.info/warn/error 格式一致，但添加时间戳前缀）
+local function format_message(level, tag, ...)
+    local argc = select("#", ...)
+    
+    -- 获取 log.style 配置
+    local log_style = 0
+    if log and log.style then
+        log_style = log.style() or 0
+    end
+    
+    -- 根据级别确定日志标识
+    local level_char = "I"  -- 默认 info
+    if level == "warn" then
+        level_char = "W"
+    elseif level == "error" then
+        level_char = "E"
+    end
+    
+    local msg = ""
+    local dbg_info_with_level = format_debug_info(level_char, true)
+    local dbg_info_only = format_debug_info(nil, false)
+    
+    if log_style == 0 then
+        -- LOG_STYLE_NORMAL: "I/user.tag arg1 arg2 ...\n"
+        msg = string.format("%s/user.%s", level_char, tag)
+        for i = 1, argc do
+            local arg = select(i, ...)
+            msg = msg .. " " .. tostring(arg)
+        end
+    elseif log_style == 1 then
+        -- LOG_STYLE_DEBUG_INFO: "I/file.lua:123 tag arg1 arg2 ...\n"
+        if dbg_info_with_level then
+            msg = dbg_info_with_level
+        else
+            msg = level_char
+        end
+        msg = msg .. " " .. tag
+        for i = 1, argc do
+            local arg = select(i, ...)
+            msg = msg .. " " .. tostring(arg)
+        end
+    else
+        -- LOG_STYLE_FULL: "I/user.tag file.lua:123 arg1 arg2 ...\n"
+        msg = string.format("%s/user.%s", level_char, tag)
+        if dbg_info_only then
+            msg = msg .. " " .. dbg_info_only
+        end
+        for i = 1, argc do
+            local arg = select(i, ...)
+            msg = msg .. " " .. tostring(arg)
+        end
+    end
+    
+    msg = msg .. "\n"
+    
+    -- 添加时间戳前缀
+    local timestamp = format_timestamp()
+    return timestamp .. " " .. msg
+end
+
+-- 刷新缓存到文件
+local function flush_cache()
+    if ctx.cache_used == 0 then
+        return true
+    end
+    
+    local path = get_file_path()
+    local file = io.open(path, "ab")
+    if not file then
+        log.warn("exmtn", "无法打开文件: " .. path)
+        return false
+    end
+    
+    -- file:write 返回 true/false 或 nil，不返回字节数
+    local ok = file:write(ctx.cache)
+    file:close()
+    
+    if not ok then
+        log.warn("exmtn", "写入文件失败: " .. path)
+        return false
+    end
+    
+    reset_cache()
+    return true
+end
+
+-- 直接写入文件（ADD_WRITE 模式）
+local function direct_write(data)
+    local path = get_file_path()
+    local file = io.open(path, "ab")
+    if not file then
+        log.warn("exmtn", "无法打开文件: " .. path)
+        return false
+    end
+    
+    -- file:write 返回 true/false 或 nil，不返回字节数
+    local ok = file:write(data)
+    file:close()
+    
+    if not ok then
+        log.warn("exmtn", "写入文件失败: " .. path)
+        return false
+    end
+    
+    return true
+end
+
+-- 将数据追加到缓存或直接写入
+local function buffer_append(data)
+    if not data or #data == 0 then
+        return true
+    end
+    
+    local len = #data
+    
+    -- ADD_WRITE 模式：直接写入文件
+    if ctx.write_way == exmtn.ADD_WRITE then
+        -- 小数据先缓存，累积到阈值再写入
+        if len < LOG_MTN_ADD_WRITE_THRESHOLD then
+            if ctx.cache_used + len > LOG_MTN_CACHE_SIZE then
+                if not flush_cache() then
+                    return false
+                end
+            end
+            ctx.cache = ctx.cache .. data
+            ctx.cache_used = ctx.cache_used + len
+            -- 如果累积到阈值，立即写入
+            if ctx.cache_used >= LOG_MTN_ADD_WRITE_THRESHOLD then
+                return flush_cache()
+            end
+            return true
+        end
+        -- 大数据直接写入
+        return direct_write(data)
+    end
+    
+    -- CACHE_WRITE 模式：原有逻辑
+    if len > LOG_MTN_CACHE_SIZE then
+        -- 先刷新缓存
+        if not flush_cache() then
+            return false
+        end
+        -- 大数据直接写入
+        return direct_write(data)
+    end
+    
+    -- 检查缓存是否足够
+    if ctx.cache_used + len > LOG_MTN_CACHE_SIZE then
+        if not flush_cache() then
+            return false
+        end
+    end
+    
+    ctx.cache = ctx.cache .. data
+    ctx.cache_used = ctx.cache_used + len
+    return true
+end
+
+-- 写入日志到文件
+local function write_to_file(msg)
+    if not ctx.enabled then
+        return true  -- 未启用时返回成功，不写入
+    end
+    
+    local len = #msg
+    
+    -- CACHE_WRITE 模式
+    if ctx.write_way == exmtn.CACHE_WRITE then
+        -- 检查文件大小 + 缓存大小 + 当前数据是否会超过限制
+        -- 如果会超过，先刷新缓存
+        if ctx.cache_used > 0 then
+            local file_sz = get_current_file_size()
+            if file_sz + ctx.cache_used + len > ctx.file_limit then
+                -- 先刷新缓存
+                if not flush_cache() then
+                    return false
+                end
+                -- 重新获取文件大小
+                file_sz = get_current_file_size()
+                -- 检查文件是否已满
+                if file_sz >= ctx.file_limit then
+                    -- 文件已满，切换到下一个文件
+                    ctx.cur_index = (ctx.cur_index % LOG_MTN_FILE_COUNT) + 1
+                    local path = get_file_path()
+                    local file = io.open(path, "wb")
+                    if file then
+                        file:close()
+                    end
+                    if not update_index(ctx.cur_index) then
+                        log.warn("exmtn", "更新索引失败")
+                        return false
+                    end
+                    reset_cache()
+                end
+            end
+        else
+            -- 缓存为空，检查文件大小
+            local file_sz = get_current_file_size()
+            if file_sz + len > ctx.file_limit then
+                -- 文件已满，切换到下一个文件
+                ctx.cur_index = (ctx.cur_index % LOG_MTN_FILE_COUNT) + 1
+                local path = get_file_path()
+                local file = io.open(path, "wb")
+                if file then
+                    file:close()
+                end
+                if not update_index(ctx.cur_index) then
+                    log.warn("exmtn", "更新索引失败")
+                    return false
+                end
+                reset_cache()
+            end
+        end
+        
+        -- 如果加入这条数据后缓存会满，先刷新缓存
+        if ctx.cache_used + len > LOG_MTN_CACHE_SIZE then
+            if not flush_cache() then
+                return false
+            end
+            
+            -- 刷新后再次检查文件大小
+            local file_sz = get_current_file_size()
+            if file_sz >= ctx.file_limit then
+                -- 文件已满，切换到下一个文件
+                ctx.cur_index = (ctx.cur_index % LOG_MTN_FILE_COUNT) + 1
+                local path = get_file_path()
+                local file = io.open(path, "wb")
+                if file then
+                    file:close()
+                end
+                if not update_index(ctx.cur_index) then
+                    log.warn("exmtn", "更新索引失败")
+                    return false
+                end
+                reset_cache()
+            end
+        end
+        
+        -- 加入缓存
+        return buffer_append(msg)
+    else
+        -- ADD_WRITE 模式：先刷新缓存，确保文件大小准确
+        if ctx.cache_used > 0 then
+            if not flush_cache() then
+                return false
+            end
+        end
+        
+        -- 获取当前文件大小
+        local file_sz = get_current_file_size()
+        
+        -- 检查当前文件是否已写满
+        if file_sz >= ctx.file_limit then
+            -- 文件已满，切换到下一个文件
+            ctx.cur_index = (ctx.cur_index % LOG_MTN_FILE_COUNT) + 1
+            local path = get_file_path()
+            local file = io.open(path, "wb")
+            if file then
+                file:close()
+            end
+            if not update_index(ctx.cur_index) then
+                log.warn("exmtn", "更新索引失败")
+                return false
+            end
+            reset_cache()
+        end
+        
+        -- 检查当前数据是否能放入当前文件
+        if file_sz + len > ctx.file_limit then
+            -- 当前数据放不下，切换到下一个文件
+            ctx.cur_index = (ctx.cur_index % LOG_MTN_FILE_COUNT) + 1
+            local path = get_file_path()
+            local file = io.open(path, "wb")
+            if file then
+                file:close()
+            end
+            if not update_index(ctx.cur_index) then
+                log.warn("exmtn", "更新索引失败")
+                return false
+            end
+            reset_cache()
+        end
+        
+        -- 加入缓存或直接写入（buffer_append 会根据大小决定）
+        return buffer_append(msg)
+    end
+end
+
+--[[
+初始化运维日志
+@api exmtn.init(blocks, write_way)
+@int blocks 每个文件的块数，0表示禁用，正整数表示块数量
+@int write_way 写入方式，可选参数。exmtn.CACHE_WRITE(0)表示缓存写入，exmtn.ADD_WRITE(1)表示直接追加写入，默认为exmtn.CACHE_WRITE
+@return boolean 成功返回true，失败返回false
+@usage
+exmtn.init(1, exmtn.CACHE_WRITE)  -- 初始化，1个块，缓存写入
+]]
+function exmtn.init(blocks, write_way)
+    -- 参数校验
+    if blocks == nil then
+        blocks = 0
+    end
+    blocks = math.floor(blocks)
+    if blocks < 0 then
+        log.warn("exmtn", "无效的块数")
+        return false
+    end
+    
+    write_way = write_way or exmtn.CACHE_WRITE
+    if write_way ~= exmtn.CACHE_WRITE and write_way ~= exmtn.ADD_WRITE then
+        write_way = exmtn.CACHE_WRITE
+    end
+    
+    -- 如果禁用
+    if blocks == 0 then
+        reset_cache()
+        remove_files()
+        ctx.enabled = false
+        ctx.cur_index = 1
+        -- 删除配置文件
+        os.remove(LOG_MTN_CONFIG_FILE)
+        ctx.inited = true
+        return true
+    end
+    
+    -- 读取文件系统信息
+    if not ctx.inited then
+        ctx.block_size = 4096
+        ctx.blocks_per_file = 1
+        
+        -- 尝试获取文件系统信息（需要 fs 模块支持）
+        -- fs.fsstat 返回: success, total_blocks, used_blocks, block_size, fs_type
+        if fs and fs.fsstat then
+            local success, total_blocks, used_blocks, block_size, fs_type = fs.fsstat("/")
+            if success and block_size and block_size > 0 then
+                ctx.block_size = block_size
+                if total_blocks and total_blocks > 0 then
+                    local def_blocks = math.floor(total_blocks / LOG_MTN_DEFAULT_BLOCKS_DIVISOR)
+                    if def_blocks > 0 then
+                        ctx.blocks_per_file = def_blocks
+                    end
+                end
+            end
+        end
+    end
+    
+    -- 读取配置文件（仅在首次初始化时读取）
+    if not ctx.inited then
+        local config = load_config()
+        if config then
+            -- 读取索引
+            if config.INDEX and config.INDEX >= 1 and config.INDEX <= LOG_MTN_FILE_COUNT then
+                ctx.cur_index = config.INDEX
+            end
+            
+            -- 读取块数配置
+            if config.BLOCKS and config.BLOCKS > 0 then
+                ctx.blocks_per_file = config.BLOCKS
+            end
+            
+            -- 读取写入方式配置
+            if config.WRITE_WAY == 0 or config.WRITE_WAY == 1 then
+                ctx.write_way = config.WRITE_WAY
+            end
+
+            log.info("exmtn", "读取索引", ctx.cur_index)
+            log.info("exmtn", "读取块数配置", ctx.blocks_per_file)
+            log.info("exmtn", "读取写入方式配置", ctx.write_way)
+        end
+    end
+    
+    -- 检查配置是否变化
+    -- 如果已初始化，比较当前配置和新配置；如果未初始化，不需要判断（首次初始化总是"变化"的）
+    local config_changed = false
+    if ctx.inited then
+        -- 已初始化：比较当前配置和新传入的配置
+        config_changed = (ctx.blocks_per_file ~= blocks) or (ctx.write_way ~= write_way)
+    end
+    -- 未初始化：config_changed 保持为 false，因为首次初始化不算"变化"
+
+    log.info("exmtn", "配置变化", config_changed)
+    -- 更新配置
+    ctx.blocks_per_file = blocks
+    ctx.write_way = write_way
+    ctx.file_limit = ctx.block_size * ctx.blocks_per_file
+    if ctx.file_limit == 0 then
+        ctx.file_limit = LOG_MTN_CACHE_SIZE
+    end
+    
+    -- 处理文件的三种情况
+    if config_changed then
+        -- 情况1：配置变化，清空文件
+        log.info("exmtn", "配置变化，清空文件")
+        reset_cache()
+        remove_files()
+        create_files()
+        ctx.cur_index = 1
+    elseif files_exist() then
+        -- 情况2：配置没有变化，文件存在，根据配置文件中保存的文件指针继续写
+        log.info("exmtn", "配置未变化，文件存在，继续写入")
+        -- ctx.cur_index 已经从配置文件读取（如果是首次初始化）或保持当前值（如果已初始化），不需要重置
+    else
+        -- 情况3：配置没有变化，文件不存在，创建文件
+        log.info("exmtn", "配置未变化，文件不存在，创建文件")
+        create_files()
+        -- ctx.cur_index 已经从配置文件读取（如果是首次初始化）或保持当前值（如果已初始化），不需要重置
+    end
+    
+    -- 保存配置到文件
+    if not save_config(ctx.cur_index, blocks, write_way) then
+        log.warn("exmtn", "保存配置失败")
+        return false
+    end
+    
+    ctx.enabled = true
+    ctx.inited = true
+    
+    -- 打印初始化信息
+    if blocks > 0 then
+        local total_size = ctx.file_limit * LOG_MTN_FILE_COUNT
+        local file_size_mb = ctx.file_limit / (1024 * 1024)
+        local total_size_mb = total_size / (1024 * 1024)
+        local file_size_kb = ctx.file_limit / 1024
+        local total_size_kb = total_size / 1024
+        
+        if ctx.file_limit >= 1024 * 1024 then
+            log.info("exmtn", string.format("初始化成功: 每个文件 %.2f MB (%d 块 × %d 字节), 总空间 %.2f MB (%d 个文件)", 
+                file_size_mb, ctx.blocks_per_file, ctx.block_size, total_size_mb, LOG_MTN_FILE_COUNT))
+        elseif ctx.file_limit >= 1024 then
+            log.info("exmtn", string.format("初始化成功: 每个文件 %.2f KB (%d 块 × %d 字节), 总空间 %.2f KB (%d 个文件)", 
+                file_size_kb, ctx.blocks_per_file, ctx.block_size, total_size_kb, LOG_MTN_FILE_COUNT))
+        else
+            log.info("exmtn", string.format("初始化成功: 每个文件 %d 字节 (%d 块 × %d 字节), 总空间 %d 字节 (%d 个文件)", 
+                ctx.file_limit, ctx.blocks_per_file, ctx.block_size, total_size, LOG_MTN_FILE_COUNT))
+        end
+    end
+    
+    return true
+end
+
+--[[
+输出运维日志并写入文件
+@api exmtn.log(level, tag, ...)
+@string level 日志级别，必须是 "info", "warn", 或 "error"
+@string tag 日志标识，必须是字符串
+@... 需打印的参数
+@return boolean 成功返回true，失败返回false
+@usage
+exmtn.log("info", "message", 123)
+exmtn.log("warn", "message", 456)
+exmtn.log("error", "message", 789)
+]]
+function exmtn.log(level, tag, ...)
+    if not level or type(level) ~= "string" then
+        log.warn("exmtn", "level 必须是字符串")
+        return false
+    end
+    
+    if not tag or type(tag) ~= "string" then
+        log.warn("exmtn", "tag 必须是字符串")
+        return false
+    end
+    
+    -- 根据级别调用对应的底层函数（会被日志级别过滤）
+    if level == "info" then
+        log.info(tag, ...)
+    elseif level == "warn" then
+        log.warn(tag, ...)
+    elseif level == "error" then
+        log.error(tag, ...)
+    else
+        log.warn("exmtn", "level 必须是 'info', 'warn' 或 'error'")
+        return false
+    end
+    
+    -- 格式化消息（用于文件写入）
+    local msg = format_message(level, tag, ...)
+    if not msg then
+        log.warn("exmtn", "格式化消息失败")
+        return false
+    end
+    
+    -- 写入文件（不受日志级别影响）
+    return write_to_file(msg)
+end
+
+--[[
+获取当前配置
+@api exmtn.get_config()
+@return table|nil 配置信息，失败返回nil
+@usage
+local config = exmtn.get_config()
+if config then
+    log.info("exmtn", "blocks:", config.blocks, "write_way:", config.write_way)
+end
+]]
+function exmtn.get_config()
+    if not ctx.inited then
+        return nil
+    end
+    return {
+        enabled = ctx.enabled,
+        cur_index = ctx.cur_index,
+        block_size = ctx.block_size,
+        blocks_per_file = ctx.blocks_per_file,
+        file_limit = ctx.file_limit,
+        write_way = ctx.write_way,
+    }
+end
+
+--[[
+清除所有运维日志文件
+@api exmtn.clear()
+@return boolean 成功返回true，失败返回false
+@usage
+local ok = exmtn.clear()
+if ok then
+    log.info("exmtn", "日志文件已清除")
+end
+]]
+function exmtn.clear()
+    -- 如果已初始化，先刷新缓存（确保数据不丢失）
+    if ctx.inited and ctx.cache_used > 0 then
+        if not flush_cache() then
+            return false
+        end
+    end
+    
+    -- 删除所有日志文件
+    remove_files()
+    
+    -- 重新创建空文件
+    create_files()
+    
+    -- 重置索引为1
+    ctx.cur_index = 1
+    
+    -- 更新配置文件
+    if not save_config(1, ctx.blocks_per_file, ctx.write_way) then
+        return false
+    end
+    
+    log.info("exmtn", "运维日志文件已清除")
+    return true
+end
+
+return exmtn
+